API Reference

OZeroSecurityManager OZeroSDK.Security

The global manager that handles all active security modules and security events. Survives scene transitions and can be accessed via the Instance property. The SDK creates it automatically at app startup, so you do not need to 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 the project callback used by CustomCallbackOnly. It runs only after native code has armed an irreversible fatal-exit deadline. The callback may show a notice or perform brief cleanup, but cannot cancel or extend that deadline.

Removes a previously registered security termination notice callback.

Immediately completes an already-pending fatal security exit, typically from a notice dialog's OK button. It does nothing when no fatal exit is pending.

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}");
}

OZeroSecurityTerminationNoticeEvent class

User-facing payload emitted only after the native fatal-exit deadline is armed. It wraps the original safe security event and a stable support code suitable for a dialog or customer-support report.

OZeroSecurityEvent class

Customer-facing violation event passed to RegisterUserCallback. It intentionally exposes only stable, safe diagnostic info 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.

OZeroSecurityTerminationNoticePolicy enum

Controls the optional user-facing notice shown immediately before an already-armed fatal security exit. This common policy is available to Standard / Pro licenses.

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. Passed via OZeroSecurityEvent.Type.

OZeroBootstrapper OZeroSDK.Security

The automatic startup entry point responsible for initializing the SDK. You do not need to call this directly in your project code. It loads security settings in alignment with the Unity startup flow and prepares active detectors before the game starts.

OZeroSecurityConfigRuntime OZeroSDK.Security

A configuration loader that reads and validates protected build settings when the player runs. It validates the packaged configuration, prepares an in-memory OZeroSecurityConfig snapshot, and applies the configured threat-response policy if validation fails.

Properties

Methods

A loader that is safe to call repeatedly. First call validates and loads the packaged configuration; later calls reuse the same configuration snapshot. Failure handling follows the configured response policy.

OZero Secure Variables OZeroSDK.Security

Encrypted types that can be used instead of regular numeric, string, and vector types. Values are stored in a protected memory area and support most arithmetic operators and implicit conversions. You can apply them to existing code simply by changing the type name.

Available types

Supported operators

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

OZeroSafePlayerPrefs OZeroSDK.Security

An encrypted storage that can be used similarly to Unity's PlayerPrefs. Key names and values are protected, making it difficult to read the original values even if you open the Windows registry or iOS settings file directly.

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

Protects file reads and writes with internal encryption logic. Because it does not use a device binding key, it can be used when the same save file needs to be read across multiple devices, like Steam Cloud Save. If a file is intentionally tampered with, the integrity check fails at read time and throws an InvalidDataException.

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 integrity, and returns the decrypted string. If the file was tampered with, InvalidDataException is thrown.

Encrypts data and stores it safely at path.

Reads the file specified at path. Verifies file integrity during read and detects any tampering.

Decrypts an encrypted byte buffer that is already loaded in memory instead of a file path. Use this when you cannot pass data received from a remote download or custom storage 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, optional Pro server attestation, and OZero Managed Verification. The component is created automatically by the SDK 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.

CustomerGameServer only. After local checks pass, starts attestation with a server-issued audience, 64-character challenge hex, and session ID. Send the callback's OZA token and exact binding values to the game server for /v1/validate. Returns false for invalid configuration or binding, or while validation is busy.

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

OZeroBuildAttestationToken

Pro attestation result. Send AttestToken to your game server and call IsValid(nowMillis) to check validity 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

Checks if suspicious modules are attached to the running game, or if there are traces of hooking or debuggers. Periodic checks use slight timing variations when possible to make simple bypass attempts more difficult.

What it detects

Detection fires via OZeroSecurityManager callbacks with ModulationType.Injection.

OZeroSteamAntiPiracy OZeroSDK.Security

Runtime API to change the post-detection action of Steam Anti-Piracy. Setting this up in the Config Dashboard is sufficient for most projects. Only use this if you provide an admin menu or QA switch directly inside the game.

OZeroSteamDetectionAction

Methods

Overrides the local Steam Anti-Piracy detection action at runtime. Used when temporarily lowering to Observe in QA builds, or letting operators select specific actions from an admin menu.

Clears the runtime override and reverts to the default action set in OZeroSecurityConfig or the Pro portal.

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. Includes reported AppID, BuildID, SteamID, server verification state, soft signal, and native score fields. Can be used for debug UI or QA reports, but do not use it as the sole criterion for gameplay authorization.

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, diagnostic logs, or store-specific branching.

Methods and event

Invoked when the install source is resolved.

Returns the cached result from the most recent check.

Performs initialization if necessary, 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 Unity ScriptableObject asset that stores the default settings for OZero security modules. Changes made in the Config Dashboard or Inspector are included as protection settings for players during build. Use OZeroSecurityConfig.Instance when you need to check the current settings in code.

Fields

Fields are grouped into nested settings classes such as Response and Integrity. This table lists the fields most often checked from code or changed during integration; see the manual for the full Inspector table. Defaults mean the serialized values defined in code. Rows marked with * are forced to a different runtime value in release builds.

WebTimeUnavailablePolicy

Policy used after configured web-time addresses 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

A ScriptableObject loaded from Resources/OZeroLicenseConfig. It manages Standard/Pro settings, the project license key, and Pro server settings. A missing asset or empty key 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 local Build Integrity handles signed Pro portal block policies when the device cannot reach the server. The values intentionally separate fail-open operation, fail-closed policy enforcement, and test bypass behavior.

Properties

Loads the runtime config from Resources. If null, treat it the same as Standard.

Indicates a configuration that runs without server activation. True for Standard or an empty license key; false when Pro server activation is required. Existing compatibility configurations remain supported by the SDK.

Indicates a configuration eligible for dedicated native binary validation, including Pro. The imported signed manifest identifies whether a private package is present. Existing compatibility configurations remain supported by the SDK.

True only when the explicit native variant compatibility override is enabled for the current project.

OZeroLicenseRuntime OZeroSDK.Security.License

Runtime API for reading the current license state. It is initialized automatically at app startup, so most projects only need to read the state or call HasCapability.

Properties

Methods

Safe to call multiple times. Usually called automatically by the SDK; custom bootstraps can await it before reading license state.

Returns whether the current activation info includes capability permissions like telemetry, signed_time, or attestation. False in Standard.

License Server Runtime Calls

Pro features use HTTPS JSON APIs under /v1. OZA v2 is a one-time token bound to an audience, a 256-bit challenge, a session ID, and build evidence. Calls to /v1/validate require a License Server API Key and the same binding values; every successful token is consumed atomically. Teams without a backend use OZero Managed with a root-signed keyset and OZMS receipt.

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

Use OZeroAbortCode and MessageKey as the base values for logs and localized UI. Message is written in safe, developer-friendly language so it can be shown directly on developer screens or QA logs.

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.

Data Structure — 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. Use it only for modules distributed with the game whose normal behavior has been confirmed by the developer. This local list is available in all tiers; Pro customers can update the same kind of policy during live operations through the customer portal server-managed whitelist.