API Reference

OZeroSecurityManager OZeroSDK.Security

The central singleton that manages all active security modules. Survives scene transitions via DontDestroyOnLoad. Access it through the static Instance property. Created automatically by OZeroBootstrapper at one of three [RuntimeInitializeOnLoadMethod] hooks before the first scene loads — do not instantiate it manually.

Properties

Methods

Registers a callback so your project can react to security events. OZero's built-in response still runs separately, so registering or removing this callback does not turn protection off. The callback receives an OZeroSecurityEvent with the detected area, public abort code, message key, diagnostic message, and whether the app is scheduled to close.

Removes a previously registered user callback. Always call this in OnDisable or OnDestroy to prevent memory leaks.

Registers a callback for server-issued policy actions delivered by the Pro device policy heartbeat. Use this for portal policies such as Callback responses. It is separate from local security detection callbacks.

Removes a previously registered policy action callback. Register in OnEnable and unregister in OnDisable when using a scene object.

Registers a callback for user-facing activation or DRM state changes. With OZero-managed Steam DRM and the default Managed Verification UI, the SDK already shows the online-required, retry, timeout, and blocked states; register this only for custom UI, telemetry, or a game-specific session gate.

Removes a previously registered activation state callback. Register in OnEnable and unregister in OnDisable when using a scene object.

Registers a callback for the shared OZero Managed Verification state used by Pro Build Integrity and Steam DRM. The default SDK UI handles these states automatically when enabled; use this callback only for custom UI, custom telemetry, or game-specific session gates.

Removes a previously registered managed verification state callback. Register in OnEnable and unregister in OnDisable when using a scene object.

Replaces individual built-in verification UI strings at runtime. Use JSON files under Assets/OZeroSDK/Resources/OZeroLocalization for normal localization, and use this provider only when text must be supplied dynamically.

Removes a previously registered managed verification text provider.

Retries SDK-managed Build Integrity attestation after an online-required or retry-timeout state. The default Managed Verification UI calls this automatically. If your own game server validates OZA tokens, retry your own login or session-refresh request instead.

Retries OZero-server-managed Steam Activation / DRM verification. The default Managed Verification UI calls the matching retry flow for you. Call this from game code only when you intentionally replace the default UI; if your own game server performs Steam verification, retry your own login or session request instead.

Delegate

The callback signature used by RegisterUserCallback. Use evt.Type, evt.AbortCodeHex, evt.MessageKey, evt.Message, and evt.WillAbort when you need a warning UI, your own server log, or a short save step. If evt.WillAbort is true, keep the work brief because the app is already scheduled to close.

Example

using OZeroSDK.Security;
using UnityEngine;

public class MySecurityListener : MonoBehaviour
{
    void OnEnable()
        => OZeroSecurityManager.Instance.RegisterUserCallback(OnThreat);

    void OnDisable()
        => OZeroSecurityManager.Instance.UnregisterUserCallback(OnThreat);

    void OnThreat(OZeroSecurityEvent evt)
        => Debug.Log(
            $"Threat={evt.Type}, Code={evt.AbortCodeHex}, Message={evt.Message}");
}

OZeroSecurityEvent class

Customer-facing violation payload passed to RegisterUserCallback. It intentionally exposes stable, safe diagnostics rather than internal detection details.

OZeroPolicyActionEvent class

Server policy callback payload passed to RegisterUserPolicyActionCallback. These events are issued by the customer portal policy system and delivered on the Unity main thread through the Pro device policy heartbeat.

Policy callback example

Use this when a Customer Portal security policy is configured as Callback. The SDK delivers the policy action to the game, and your game decides how to notify, restrict, or move the user.

using OZeroSDK.Security;
using UnityEngine;

public sealed class OZeroPolicyListener : MonoBehaviour
{
    private void OnEnable()
        => OZeroSecurityManager.Instance.RegisterUserPolicyActionCallback(OnPolicyAction);

    private void OnDisable()
        => OZeroSecurityManager.Instance.UnregisterUserPolicyActionCallback(OnPolicyAction);

    private void OnPolicyAction(OZeroPolicyActionEvent evt)
    {
        Debug.LogWarning($"Policy={evt.PolicyId}, Module={evt.Module}, Score={evt.Score}, Reason={evt.Reason}");

        if (evt.Score >= 80)
        {
            ShowSecurityNotice(evt.Reason);
            DisableRankedMatchmaking();
        }
    }
}

OZeroUserActivationStateEvent class

User-facing activation or DRM state payload passed to RegisterUserActivationStateCallback. Steam Activation / DRM uses it to tell the game whether cached offline play is still allowed or online revalidation is required.

Activation state callback usage

For OZero-managed Steam DRM with the default Managed Verification UI, no activation callback code is required; the SDK shows online-required, retry, timeout, and blocked states for the player. Register this callback only when you intentionally replace the default UI, add your own session gate, or operate a customer game-server verification flow. Do not put Steam Web API keys or OZero server API keys in the client.

OZeroUserManagedVerificationStateEvent class

User-facing managed verification payload passed to RegisterUserManagedVerificationStateCallback. Build Integrity and Steam DRM both use this event, but the default Managed Verification UI consumes it automatically. Handle it in game code only for custom UI, custom telemetry, or a game-specific session gate.

Managed verification callback usage

When managedVerificationUiPolicy uses an OZero built-in dialog, the SDK already handles Build Integrity and Steam DRM managed-verification UI, retry, and timeout states. Register RegisterUserManagedVerificationStateCallback only for Custom UI / Callback Only, additional telemetry, or a game-specific session gate. In custom UI mode, call the retry method that matches Provider; in customer game-server mode, retry your own login or session request instead.

OZeroManagedVerificationUiPolicy enum

Controls how the SDK presents managed verification states from Build Integrity and Steam DRM to the player. Both built-in policies require TextMeshPro, TMP Essential Resources, and the optional OZero Built-In TMP Dialog package. Build preflight stops the player build when a built-in policy is selected without those prerequisites; use Window > OZero Security > Check Setup and its Import Package action to fix the project.

OZeroManagedVerificationTimeoutAction enum

Controls what the built-in managed verification UI does when online-required or retry states are not resolved within the configured timeout.

ModulationType enum

Identifies which security module raised an alert. Available as OZeroSecurityEvent.Type.

OZeroBootstrapper OZeroSDK.Security

Zero-wiring auto-bootstrap entry point. You do not call anything on this class directly. It connects the SDK to Unity startup, loads the verified security configuration, and prepares enabled detectors automatically before gameplay starts. Native runtime protection is also initialized here when available.

OZeroSecurityConfigRuntime OZeroSDK.Security

Runtime loader for the protected build-time security configuration. It validates the packaged configuration, prepares an in-memory OZeroSecurityConfig snapshot, and applies the configured threat-response policy if validation fails.

Properties

Methods

Idempotent loader — safe to call repeatedly. First access validates and loads the packaged configuration; later calls reuse the same snapshot. Failure handling follows the configured global threat-response policy.

OZero Secure Variables OZeroSDK.Security

Encrypted drop-in replacements for primitive types. Values are stored exclusively in the Native C++ heap and encrypted with OZero proprietary cipher. A per-frame per-frame masking layer is applied on top, so memory scanners see only noise. All arithmetic operators and implicit conversions are supported — existing code requires only a type name change.

Available types

Supported operators

Numeric types (Int, Int64, UInt, UInt64, Short, UShort, Byte, Float, Double, Decimal) support all arithmetic (+ - * / %), comparison (== != < > <= >=), compound assignment (+= -= *= /=), and increment/decrement (++ --) operators, plus implicit conversions to/from their primitive equivalent. Vector2 and Vector3 support arithmetic and equality operators. Bool supports equality operators only. String supports ==, !=, and +. Buffer provides raw byte-array access with index operators.

OZeroSafePlayerPrefs OZeroSDK.Security

An encrypted drop-in replacement for Unity's PlayerPrefs. Key names are hashed with message authentication and values are encrypted with OZero proprietary cipher using a device-bound encryption key. The stored data cannot be read by browsing the device's registry (Windows) or preference plist (iOS).

Methods

The common PlayerPrefs-style methods are available, plus Int64, Double, Bool, and IncrementInt helpers. Existing plain PlayerPrefs values are not migrated automatically; start using OZeroSafePlayerPrefs for keys you want protected going forward.

OZeroSV_File OZeroSDK.Security

Encrypts and decrypts files with built-in integrity verification. Keys live at the app level (not device-bound), making the format compatible with Steam Cloud Save. On read, the integrity check runs before the data is returned; tampering causes an exception rather than silently returning corrupted data.

Methods

Encrypts contents and stores it at path. Parent folders are not created automatically, so call Directory.CreateDirectory first when needed.

Reads the file at path, verifies its integrity, and returns the decrypted string. Throws InvalidDataException if the file has been tampered with.

Encrypts a raw byte array and writes it to path.

Reads and decrypts a file written by WriteAllBytes. Verifies the integrity tag before returning.

Decrypts an encrypted byte buffer already loaded from another source, such as a remote download or custom storage backend. Use this when you cannot pass a filesystem path to ReadAllText.

Example

using OZeroSDK.Security;

string path = Application.persistentDataPath + "/save.json";
string json = JsonUtility.ToJson(saveData);

// Write (encrypts automatically)
OZeroSV_File.WriteAllText(path, json);

// Read (decrypts + integrity check)
try
{
    string loaded = OZeroSV_File.ReadAllText(path);
    saveData = JsonUtility.FromJson<SaveData>(loaded);
}
catch (System.IO.InvalidDataException)
{
    // File was tampered — handle accordingly
    Debug.LogError("Save file integrity check failed.");
}

OZeroBuildIntegrityValidator OZeroSDK.Security

Runtime validator for build tampering, debugger/timing anomalies, platform-native integrity checks, and optional Pro server attestation. The component is created automatically by OZeroBootstrapper when Build Integrity is enabled in OZeroSecurityConfig.

What it checks

Public properties

Events and methods

Invoked when all enabled local checks pass.

Invoked when an enabled local check or Pro attestation rejects the build.

Invoked after Pro server attestation succeeds and AttestationToken contains a valid token.

Starts a manual validation run. Normal projects usually rely on the dashboard's startup and periodic validation settings instead.

OZeroBuildAttestationToken

Pro attestation result returned through AttestationToken. Send AttestToken to your game server and call IsValid(nowMillis) before using it for login, PvP, ranking, or currency flows.

Returns true after the server-issued expiry time.

Returns true when the token was issued successfully and has not expired.

OZeroSpeedHackDetector OZeroSDK.Security

Detects speed hacks and time manipulation using five independent detection signals. A threat is reported only when signals confirm each other, reducing false positives.

Detection signals

Detection fires via OZeroSecurityManager callbacks with ModulationType.SpeedHack or ModulationType.TimeHack. Configured in OZeroSecurityConfig.

OZeroWatchdog OZeroSDK.Security

Public helper for trusted long-running loading work. It temporarily defers the native Watchdog heartbeat deadline around synchronous work that can legitimately block Unity's main thread longer than the release deadline.

Methods

Starts a bounded loading grace scope. Call End() or dispose the returned scope as soon as trusted loading work finishes. Nested scopes are supported; normal Watchdog timing resumes when the last scope ends.

Ends this loading grace scope manually. Dispose() calls the same logic, so using blocks and explicit End() are equivalent.

Convenience wrapper for synchronous loading work. It creates a loading grace scope, runs work, and ends the scope in a finally-safe using block.

Example

using OZeroSDK.Security;
using UnityEngine.SceneManagement;

public void LoadLargeScene()
{
    using (OZeroWatchdog.BeginLoadingGrace(60000))
    {
        SceneManager.LoadScene("Battle", LoadSceneMode.Single);
    }
}

OZeroInjectionDetector OZeroSDK.Security

Observes abnormal runtime module, hook, debugger, and trusted-module policy signals. Periodic checks use jittered scheduling where applicable to reduce predictable scan timing.

What it detects

Detection fires via OZeroSecurityManager callbacks with ModulationType.Injection.

OZeroSteamAntiPiracy OZeroSDK.Security

Runtime controls for Steam Anti-Piracy. Most projects configure Steam protection in the Config Dashboard, but games that expose their own policy UI can temporarily override the local detection action through this static API.

OZeroSteamDetectionAction

Methods

Overrides the local Steam Anti-Piracy detection action at runtime. This is useful when your game offers a QA/admin switch or when you need to temporarily move Steam protection to observe mode while investigating a customer environment.

Clears the runtime override and returns to the action configured in OZeroSecurityConfig or the current Pro server policy.

Example

using OZeroSDK.Security;

// QA session: observe Steam violations without blocking gameplay.
OZeroSteamAntiPiracy.SetDetectionActionOverride(
    OZeroSteamDetectionAction.Observe);

// Restore the dashboard/server policy.
OZeroSteamAntiPiracy.ClearDetectionActionOverride();

Last result

Returns the most recent Steam validation snapshot, including reported AppID, BuildID, SteamID, server verification state, soft-signal details, and native score fields. Read this for debug UI or QA reports; do not use it as the only gameplay authorization gate.

OZeroInstallSourceValidator OZeroSDK.Security

Android install-source validator. The component is created automatically when Install Source is enabled. Customer code usually reads the last result for support UI, diagnostics, or store-specific flows.

Methods and event

Raised after the install source is resolved.

Returns the cached result from the most recent check.

Forces initialization if needed, then returns the Android installation source result.

InstallSourceResult

AndroidInstallSource

Exact enum values returned by InstallSourceResult.DetectedSource. Store names in the manual are friendly labels; code should compare against these enum names.

OZeroDeviceBindingDetector OZeroSDK.Security

Helper API for device-bound save slots and support reset flows. The detector starts automatically when Device Binding is enabled. Call these token methods only when your game wants to bind a cloud save, account save slot, or similar data to the current device.

Methods

Prepares the local device fingerprint, then registers or validates it. In normal projects this is called automatically during SDK startup.

Creates a token that links a save-slot key to the current device. Store the token with your save metadata or server record, not inside a player-editable save body.

Checks whether the stored save-slot token matches the current device. If it does not match, the SDK raises the configured Device Binding violation response.

Debug/demo helper that returns the current device fingerprint hash. Do not show, upload, or store this value from production gameplay code.

Clears the fingerprint stored on this device. In non-Editor builds, pass a server-issued Reset Token and use it only for legitimate support reset flows.

Example

using OZeroSDK.Security;

var detector = OZeroDeviceBindingDetector.Instance;
string slotKey = "account:1234:slot:main";

string token = detector.BindToSaveSlot(slotKey);
// Store token next to your save metadata.

bool ok = detector.ValidateSaveSlot(slotKey, token);

OZeroSecurityConfig ScriptableObject

A ScriptableObject asset that stores global security settings. Author it in the Editor, then let the build pipeline package a protected runtime configuration for player builds. Access the effective settings through OZeroSecurityConfig.Instance.

Fields

Fields are grouped into nested settings classes such as Response and Integrity. This table lists the fields most often used from code or changed during integration; the full Inspector table is in the manual. Defaults below mean the serialized asset default. If release builds force a different runtime value, the row marks it with *.

WebTimeUnavailablePolicy

Policy used after configured web-time endpoints fail for maxConsecutiveFailures rounds in a row. Use this to decide whether a temporary network problem should only be logged or should become a security callback.

OZeroLicenseConfig OZeroSDK.Security.License

ScriptableObject loaded from Resources/OZeroLicenseConfig. It selects the license tier, stores the Plus/Pro license key, and configures Pro runtime server settings. Missing or empty config behaves as Standard/serverless mode.

Fields

OZeroDeclaredSecurityLevel

Enum sent to the Pro server when security-level validation is enabled. The server compares this value with the minimum level configured for the license.

OZeroOfflineProPolicyMode

Controls how the SDK handles signed Pro portal block policies when the device cannot reach the server.

Useful properties

Loads the runtime config from Resources. Treat null as Standard/serverless mode.

True for Standard, Plus, or an empty license key. False only when Pro activation should run.

True for Plus and Pro. Used by the build preflight and native Variant binding.

OZeroLicenseRuntime OZeroSDK.Security.License

Runtime facade for the current license state. It is initialized automatically at app startup, so most projects only read its state or call HasCapability.

Properties

Methods

Idempotent startup method. Usually called automatically by the SDK; custom bootstraps may await it before reading license state.

Returns whether the active entitlement includes a capability such as telemetry, signed_time, or attestation_v1. Returns false in Standard/serverless mode.

License Server Runtime Calls

Pro features use HTTPS JSON calls under /v1. These calls are issued by the SDK automatically; game code normally interacts through OZeroLicenseRuntime and module settings instead of calling the endpoints directly.

POST /v1/activate contract

This is the basic request contract sent by the Unity SDK when it activates a Pro license. The server schema can accept additional native verification fields, but the current SDK activation request sends the fields below.

OZeroAbortCode & Event Messages

When OZero confirms a security threat, it creates an OZeroSecurityEvent and passes it to the built-in response flow and any project callbacks. The event contains ModulationType, a stable public OZeroAbortCode, MessageKey, a safe English Message, and WillAbort.

Abort code and message table

Treat OZeroAbortCode and MessageKey as stable public values for logs and localization. The human-readable Message is intentionally safe and may be shown in developer UI.

Handling security events at runtime

By default, OZero either closes the app or leaves a log according to the Response settings in the Config Dashboard. Register a handler with OZeroSecurityManager.RegisterUserCallback when you need to show your own warning screen, send a server log, or save a small amount of data just before the app closes.

If evt.WillAbort is true, the current response policy will close the app after the callback flow. Use that time only for short work such as analytics flush or a final save. The callback is a reporting and cleanup hook; it is not a way to cancel OZero's security response.

using OZeroSDK.Security;

void OnEnable()
{
    OZeroSecurityManager.Instance.RegisterUserCallback(OnHack);
}

void OnHack(OZeroSecurityEvent evt)
{
    Debug.LogWarning(
        $"OZero: {evt.Type} {evt.AbortCodeHex} {evt.MessageKey} - {evt.Message}");

    if (evt.WillAbort)
    {
        // Last chance to flush your own analytics or save state.
    }

    Analytics.FlushSync();
}

Injection Detector API OZeroSDK.Security

API for registering modules that should be treated as trusted by the Injection scan. Use it for overlays, recorders, operations plugins, or partner modules that ship with your game and are known to be safe but may be detected. HashHex is the SHA-256 hash of the module file, and SignerHex is the SHA-256 hash of the module signing certificate. Do not guess these values; register only values confirmed from the actual distributed file or diagnostic output.

DTO — OZeroInjectionWhitelistEntry

[Serializable]
public class OZeroInjectionWhitelistEntry
{
    // SHA-256 of the matched module file. Lowercase 64-char hex. Required.
    public string HashHex { get; set; }

    // SHA-256 of the module's signing certificate. Lowercase 64-char hex.
    // Empty ("") means "match by hash only" (only mode for Android .so / Linux ELF).
    public string SignerHex { get; set; }

    // Module file format hint — "pe" | "macho" | "so". Defaults to "so".
    public string Type { get; set; }

    // Optional human-readable note (UI / audit only — never sent to native).
    public string Comment { get; set; }
}

Data structure for local trusted module entries in Unity. HashHex is the required 64-character SHA-256 file hash, and SignerHex is an optional 64-character signer fingerprint. Type is one of pe, macho, or so, and Comment is a human-readable note.

Runtime API — OZeroDispatch

// Returns true when trusted-module policy support is available.
public static bool HasInjectionV3 { get; }

// Replace trusted module entries atomically. Pass null/empty to clear.
// Returns false when the runtime support is unavailable.
public static bool RegisterInjectionWhitelistHash(OZeroInjectionWhitelistEntry[] entries);

// Trusted-module aware scan. Returns true when a relevant runtime signal is observed.
// Output fields are diagnostic context for your review and may be empty.
public static bool DetectAssemblyInjectionV3(
    out bool   silencedByWhitelist,
    out string hashHex,
    out string signerHex,
    out string matchedModulePath);

Used at runtime to pass the trusted module list to the native scanner, or to check whether this feature is available on the current platform. Most projects only need the Injection settings in the Config Dashboard. If you call this API directly, register only the required entries after distribution files are finalized and verify the result in QA logs.

Config — OZeroSecurityConfig.InjectionSettings

// Preferred local trusted-module surface in the Injection settings.
public OZeroInjectionWhitelistEntry[] InjectionWhitelistEntries { get; }

InjectionWhitelistEntries is the local trusted module list inside the Injection settings. It is not meant to broadly allow programs randomly installed on a customer's PC, but only to register modules distributed alongside the game whose normal behavior has been confirmed by the developer. Pro customers can update the same kind of policy during live operations through the customer portal server-managed whitelist.