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/OZeroSecurity/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 Security Config > Pro - License & Online Services > Online Verification UI > Ui Policy 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 and 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.

In the online add-on this event is OZeroOnlineAttestation.OnAttestationPassed: invoked after server attestation succeeds and OZeroOnlineAttestation.Token holds a valid token.

Moved to OZeroOnlineAttestation.RequestGameServerAttestation in the online add-on. CustomerGameServer only: after local checks pass, starts attestation with a server-issued audience, 64-character challenge hex and session ID; the token arrives through OZeroOnlineAttestation.TokenReady. See Game Server Integration with the Server API Key.

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.

OZeroPCStoreAntiPiracy 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. It also provides an ownership query for optional DLC (QueryDlcOwnership).

OZeroPCStoreDetectionAction

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.
OZeroPCStoreAntiPiracy.SetDetectionActionOverride(
    OZeroPCStoreDetectionAction.Observe);

// Restore the dashboard/server policy.
OZeroPCStoreAntiPiracy.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.

QueryDlcOwnership

Queries whether the current Steam user owns an optional DLC. This is a query-only API that never terminates the game; use it for decisions such as unlocking DLC content. Required DLC listed in requiredDlcAppIds is checked automatically at startup and does not need this call. Use this API instead of calling Steamworks.NET directly.

using OZeroSDK.Security;

// Optional DLC: unlock the content only when the account owns it.
OZeroDlcOwnership dlc = OZeroPCStoreAntiPiracy.QueryDlcOwnership(1234560);
if (dlc.Owned)
{
    UnlockExpansion();
}

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 and binds the current device again. In player builds, when a Pro license and server settings are configured, a non-empty token is verified as a server-issued Reset Token in the background, so the reset happens after this call returns; use ClearStoredFingerprintAsync to await the result. Otherwise the reset authorizer decides and receives the token in AuthorizationToken. Prefer RequestReset when you do not use server Reset Tokens.

Awaitable form of ClearStoredFingerprint. Call it from the main thread and await it; it returns true when the fingerprint was cleared. The server check never blocks the main thread, which matters where HTTP runs on the main thread (Windows and macOS IL2CPP, WebGL).

Asks to clear the stored fingerprint. In player builds the reset authorizer decides; reason is passed to it for your own logging. When approved, the SDK clears the fingerprint, binds the current device again in the same session and returns true. In the Editor the reset always proceeds.

Registers your game's callback that approves (true) or denies a reset in player builds. Pass null to remove it. The callback runs synchronously on the thread that requested the reset. Without an authorizer, player builds refuse resets unless a valid server Reset Token is supplied.

OZeroDeviceBindingResetRequest

Read-only struct passed to the reset authorizer.

Reason passed to RequestReset; empty when none.

Token passed to ClearStoredFingerprint; empty when none.

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

// Reset flow: register an authorizer that performs your own check.
OZeroDeviceBindingDetector.SetResetAuthorizer(request =>
    MyAccountService.HasVerifiedResetFor(request.Reason));
bool cleared = detector.RequestReset("ticket-1234");

OZeroSecurityConfig ScriptableObject

The security settings of the OZero modules. In the Editor they are edited in Edit > Project Settings > OZero Security and saved in ProjectSettings/OZeroSecuritySettings.asset (shared) and UserSettings/OZeroSecuritySecrets.json (per-user secrets); the build bakes them into the player. Use OZeroSecurityConfig.Instance to read the current settings in code. To change them from an editor script, use OZeroSecurityProjectSettings (Load, LoadOrCreate, Save).

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

The online license settings. In the Editor they are saved in ProjectSettings/OZeroLicenseSettings.asset and edited in Window > OZero Security > Online Services or the Pro card of Edit > Project Settings > OZero Security; the build packs them into the player as an encrypted resource. They select the license tier and store the Pro license key and Pro runtime server settings. If the settings file is missing or the key is empty, the SDK operates the same way as Standard. To change them from an editor script, use OZeroSDK.Security.License.OZeroLicenseProjectSettings (Load, LoadOrCreate, Save, Reload).

Fields

Local clock policy

This policy is managed under Customer Portal > License > Local clock; there is no Unity field to keep in sync. Online Pro activation uses server time. The selected allowance is used only when deciding whether saved Pro activation information may be reused at an offline start.

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.

True for Standard or an empty license key. False when Pro activation is required.

True for Pro. Identifies tiers eligible for Native Variant validation; private Variant presence is detected from the signed imported manifest.

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.

[Pro] Links your user UUID (account ID) to this session. Call it after sign-in. The value is hashed on the device and only the hash is sent. Returns false when the value is empty after trimming spaces, longer than 128 characters, or contains control characters. Calling it before activation is fine; the hash is sent after activation. A device policy check runs about 5 seconds later (at most once every 30 seconds).

[Pro] Unlinks the user UUID. Call it on sign-out.

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.

Game Server Integration with the Server API Key

[Pro] The server API key lets your game server talk to OZero for three jobs: check that a player's build is genuine at sign-in (validate), look up users and devices for support and operations (read), and block or unblock users (block). The key stays on your game server. The game client never holds it; the client only runs the OZero SDK and sends tokens to your server.

Overview

Game client (OZero SDK)          Your game server                         OZero API
-----------------------          ----------------                         ---------
sign-in request        ------->  issue audience, challenge, sessionId
RequestGameServerAttestation()
TokenReady: attestToken ------>  POST /v1/validate            [validate]  ----> valid / reason
                                 allow or refuse the sign-in
SetExternalUserId(uuid)          (the SDK sends only the hash h1 with policy checks)
                                 support tool: GET /customer-api/...  [read]  ---->
                                 sanctions: POST/DELETE user-blocks   [block] ---->
policy check: callback or end  <---------------------------------------------  rule applied

The server API key lives only on your game server. Never put it in the game client.

Server API key scopes

The API uses your existing server API key (Customer Portal > Server Keys > Server API Keys) with scopes. Choose the scopes when you issue a key; the key list shows each key's scopes. Keys issued earlier have validate only.

• validate: token verification with /v1/validate (the original use).
• read: look up users, devices, events and block rules (all GET requests).
• block: create, update and lift user block rules, including Terminate rules that end the game for a user.
• config: list, register and revoke security config hashes (/v1/customer-api/config-hashes, all methods). Meant for CI: give a CI key only config, never block.

When you tick block on the issue screen, read is ticked too (you can untick it). With block alone, the key can create and lift block rules but cannot look up users, devices or the rule list. To look up as well, use read + block.

Authentication and limits

All requests go to https://api.ozerosecurity.com/v1 with Authorization: Bearer <server API key>, and only active Pro licenses can use them. POST /v1/validate needs the validate scope and has a per-IP limit. /v1/customer-api/* needs read for GET and block for rule changes (the exception is /v1/customer-api/config-hashes: every method there, including GET, needs config); each key can make 120 requests per minute, and a per-IP limit also applies. Lists are paged with limit and before (nextBefore from the previous page).

1. Validate: is this a genuine build?

The SDK sends the build's integrity evidence to OZero and receives a one-time OZA attestation token bound to values your server chose. POST /v1/validate tells your server that the token was issued by OZero for a genuine build of this license, for this sign-in, and has not been used before. Use it before sign-in, ranked play or purchases. It requires Online Services > Build Integrity > Check Integrity With Server on and Attestation Verification Mode set to CustomerGameServer.

1. Your game server issues a binding for this sign-in: audience (a fixed name for your game, 3-128 characters of letters, digits and ._:-), challenge (32 random bytes as 64 hex characters, new every time) and sessionId (16-128 characters, same character set).
2. The client calls OZeroOnlineAttestation.RequestGameServerAttestation(audience, challenge, sessionId). It returns false when the settings above are off, local checks have not passed yet, a run is in progress, or a value is invalid.
3. The token arrives through OZeroOnlineAttestation.TokenReady (or RegisterTokenCallback). The client sends context.AttestToken to your game server.
4. Your game server calls POST /v1/validate with a key that has the validate scope and the body { attestToken, licenseKey, audience, challenge, sessionId, enforceVersionWhitelist }, using exactly the values it issued.
5. valid: true: allow the sign-in; payload tells you the platform, SDK and app version, manifest hash and more. valid: false: refuse it and log reason. Each token can be validated only once; a second call returns TOKEN_REPLAYED.

Game client (Unity):

using OZeroSDK.Online;
using OZeroSDK.Security;
using UnityEngine;

public sealed class OZeroSignInAttestation : MonoBehaviour
{
    private void OnEnable() => OZeroOnlineAttestation.RegisterTokenCallback(OnToken);
    private void OnDisable() => OZeroOnlineAttestation.UnregisterTokenCallback(OnToken);

    // 1) Your game server answered the sign-in request with a binding.
    public void OnBindingReceived(string audience, string challenge, string sessionId)
    {
        if (!OZeroOnlineAttestation.RequestGameServerAttestation(audience, challenge, sessionId))
            Debug.LogWarning("OZero attestation did not start (check Security Config > Build Integrity > Pro - Online).");
    }

    // 2) The SDK issued a token bound to that binding: send it to your game server.
    private void OnToken(OZeroAttestationTokenContext context)
    {
        MyGameServer.SendAttestToken(context.AttestToken);   // your networking code
    }
}

Request and responses:

POST https://api.ozerosecurity.com/v1/validate
Authorization: Bearer <server API key with the validate scope>
Content-Type: application/json

{
  "attestToken": "<header>.<payload>.<signature>",
  "licenseKey": "<your license key>",
  "audience": "my-game-login",
  "challenge": "<64 hex characters, new for every sign-in>",
  "sessionId": "4b1d6c2e-8f3a-4c55-9a0e-2f1b7d9c3e11",
  "enforceVersionWhitelist": false
}

200 OK (genuine build)
{
  "valid": true,
  "reason": null,
  "payload": {
    "licenseSubject": "...", "platform": "...", "sdkVersion": "1.2.0", "appVersion": "...",
    "manifestHash": "...", "integrityFlags": "...", "deviceBindingHash": "...",
    "deviceBinding": null, "installSource": null, "countryCode": null,
    "issuedAt": "...", "expiresAt": "...", "tokenId": "..."
  }
}

403 Forbidden (rejected)
{ "valid": false, "reason": "TOKEN_REPLAYED", "payload": null }

Common results of /v1/validate:

4xx and 5xx responses also have a JSON body. Read it before raising an error: key and request errors return { "code", "message" }, and a rejected token returns { "valid": false, "reason" }.

2. Read: look up users and devices

Typical support questions: which devices did the reported user play on, what did OZero detect recently, and is this user linked to the device in the report? Compute h1 from the user's UUID with the license salt, then call the GET endpoints below. The server stores only keyed hashes, so it cannot list your users' h1; to check a user on a device, pass ?h1=.

Example response of GET /users/{h1}/devices:

{
  "userKeyPrefix": "a1b2c3d4",
  "devices": [
    { "deviceId": "...", "firstSeenAt": 1789900000000, "lastSeenAt": 1790000000000, "eventCount": 12 }
  ],
  "block": null
}

3. Block: sanction and lift

Typical uses: block a user automatically when your anti-cheat review confirms cheating, apply a time-limited sanction from your operations tool, and lift it when an appeal succeeds. callback leaves the response to your game code; terminate ends the game. Posting again for the same user updates the rule in effect.

What happens in the game: the rule is applied at the device policy check about 5 seconds after the game calls SetExternalUserId (at most once every 30 seconds). callback sends a policy action with Module = "user_policy" to the game; terminate sends the policy action first, then shows the OZ-SEC-0E notice and ends the session, and OZeroLicenseRuntime.LastServerBlockCode becomes "USER_BLOCKED". See Device ID and User UUID in the manual.

4. Config: security config hashes (CI)

Register the hash of each release build so the security level check accepts only your builds (see Security Config Hash Allowlist in the manual). Every method needs the config scope. The hash is the 64 lowercase hex characters from the build log line [OZero] Security config digest for this <Target> build: ….

Request and responses:

POST https://api.ozerosecurity.com/v1/customer-api/config-hashes
Authorization: Bearer <server API key with the config scope>
Content-Type: application/json

{
  "configHash": "<64 hex characters from the build log>",
  "label": "1.2.0 release (Windows)",
  "expiresInDays": 365,
  "acknowledgeEnforcement": true
}

201 Created
{
  "hash": {
    "configHash": "...", "label": "1.2.0 release (Windows)", "status": "active",
    "createdAt": 1790000000000, "createdBy": "api-key:...", "expiresAt": 1821536000000,
    "revokedAt": null, "revokedBy": null
  },
  "created": true,
  "enforcementStarted": true
}

409 Conflict (first approval without acknowledgeEnforcement)
{ "code": "ENFORCEMENT_ACK_REQUIRED", "message": "the first approved hash turns on enforcement: ..." }

GET https://api.ozerosecurity.com/v1/customer-api/config-hashes
{
  "policy": { "activeCount": 1, "mode": "enforced" },
  "approved": [ { "configHash": "...", "label": "...", "status": "active", "expiresAt": null, "...": "..." } ],
  "observed": [ { "configHash": "...", "firstSeenAt": 1789900000000, "lastSeenAt": 1790000000000, "seenCount": 3,
                  "lastDeclaredLevel": 2, "lastSdkVersion": "1.2.0", "lastPlatform": "...", "approval": "active" } ],
  "schemaReady": true
}

DELETE https://api.ozerosecurity.com/v1/customer-api/config-hashes/<configHash>
{ "hash": { "configHash": "...", "status": "revoked", "...": "..." },
  "policy": { "activeCount": 0, "mode": "compatibility" } }

CI example (bash, after the Unity build): read the hash from the build log (the file passed to -logFile) and register it. Store the key as a CI secret.

#!/usr/bin/env bash
# CI step after the Unity build. BUILD_LOG is the file passed to Unity with -logFile.
# OZERO_CONFIG_API_KEY: a server API key with only the config scope, stored as a CI secret.
set -euo pipefail

BUILD_LOG="${BUILD_LOG:-build.log}"
LABEL="${BUILD_LABEL:-ci build}"   # letters, digits and spaces only (it goes into JSON as is)

HASH=$(grep -oE 'Security config digest for this [A-Za-z0-9]+ build: [0-9a-f]{64}' "$BUILD_LOG" \
  | tail -n 1 | awk '{print $NF}')
if [ -z "$HASH" ]; then
  echo "No security config digest in $BUILD_LOG" >&2
  exit 1
fi

STATUS=$(curl -sS -o ozero-response.json -w '%{http_code}' -X POST \
  "https://api.ozerosecurity.com/v1/customer-api/config-hashes" \
  -H "Authorization: Bearer ${OZERO_CONFIG_API_KEY}" \
  -H "Content-Type: application/json" \
  -d "{\"configHash\":\"${HASH}\",\"label\":\"${LABEL}\",\"expiresInDays\":365}")

case "$STATUS" in
  200|201) echo "Approved security config hash ${HASH}" ;;
  409) echo "First approval turns on enforcement: approve once in the Customer Portal," \
            "or send \"acknowledgeEnforcement\": true on purpose." >&2
       cat ozero-response.json >&2; exit 1 ;;
  *)   echo "OZero API returned HTTP ${STATUS}:" >&2   # the body has { "code", "message" }
       cat ozero-response.json >&2; exit 1 ;;
esac

Customer API errors

4xx and 5xx responses also return { "code", "message" } in the body. Read the body and branch on code:

Rules made through the API show Server API in the Customer Portal rule list, and Operation history records them as server-api-key … with the key's last four characters.

5. Example: one game server file

A complete Node.js module (18+, no extra packages) covering validate, read and block, followed by the same flow in C# and Python. Keys, the license key and the salt come from environment variables. The hash function checks itself against the test vector before use. 429 and 503 are retried with exponential backoff.

// ozero-server.js - Node.js 18+ (built-in fetch and crypto, no extra packages)
const crypto = require("crypto");

const API = "https://api.ozerosecurity.com/v1";
const VALIDATE_KEY = process.env.OZERO_VALIDATE_API_KEY; // scope: validate (sign-in servers)
const OPS_KEY = process.env.OZERO_SERVER_API_KEY;        // scopes: read + block (operations tools)
const LICENSE_KEY = process.env.OZERO_LICENSE_KEY;
const SALT = process.env.OZERO_EXTUID_SALT;              // Customer Portal > User UUID > Settings
const AUDIENCE = "my-game-login";

// h1 = SHA-256("OZERO-EXTUID-V1|" + salt + "|" + uuid) as lowercase hex.
function extUserHash(salt, uuid) {
  const id = uuid.replace(/^[ \t\n\v\f\r]+|[ \t\n\v\f\r]+$/g, "");
  return crypto.createHash("sha256").update("OZERO-EXTUID-V1|" + salt + "|" + id, "utf8").digest("hex");
}

// Self-check with the published test vector.
const TEST_SALT = Array.from({ length: 32 }, (_, i) => i.toString(16).padStart(2, "0")).join("");
if (extUserHash(TEST_SALT, "player-123") !== "2d5a23607064e6dbc02dc32dc96af8cf54862d2f51d778596cfbe9d6ba8f8a3a") {
  throw new Error("extUserHash does not match the test vector");
}

// 4xx and 5xx responses carry a JSON body with "code" (for example SCOPE_REQUIRED).
class OZeroApiError extends Error {
  constructor(status, data) {
    super(`OZero API ${status}: ${data.code ?? "HTTP_" + status} ${data.message ?? ""}`.trim());
    this.status = status;
    this.code = data.code ?? `HTTP_${status}`;
  }
}

// One request helper: reads the JSON body for every status and retries 429 and 503
// with exponential backoff (0.5, 1, 2, 4 s).
async function call(key, method, path, body, attempt = 0) {
  const res = await fetch(API + path, {
    method,
    headers: { Authorization: `Bearer ${key}`, "Content-Type": "application/json" },
    body: body ? JSON.stringify(body) : undefined,
  });
  if ((res.status === 429 || res.status === 503) && attempt < 4) {
    await new Promise((resolve) => setTimeout(resolve, 500 * 2 ** attempt));
    return call(key, method, path, body, attempt + 1);
  }
  return { status: res.status, data: await res.json().catch(() => ({})) };
}

async function callOk(key, method, path, body) {
  const { status, data } = await call(key, method, path, body);
  if (status >= 400) throw new OZeroApiError(status, data);
  return { status, data };
}

// 1) validate --------------------------------------------------------------
function newSignInBinding() {
  return {
    audience: AUDIENCE,
    challenge: crypto.randomBytes(32).toString("hex"),
    sessionId: crypto.randomUUID(),
  };
}

async function validateSignIn(binding, attestToken) {
  const { status, data } = await call(VALIDATE_KEY, "POST", "/validate", {
    attestToken,
    licenseKey: LICENSE_KEY,
    ...binding,
    enforceVersionWhitelist: false,
  });
  if (data.valid === true) return { ok: true, payload: data.payload };
  if (data.valid === false) return { ok: false, reason: data.reason }; // e.g. TOKEN_REPLAYED: refuse
  throw new OZeroApiError(status, data); // e.g. SERVER_API_KEY_REQUIRED: fix the key or setup
}

// 2) read ------------------------------------------------------------------
async function lookUpUser(uuid) {
  const h1 = extUserHash(SALT, uuid);
  const devices = await callOk(OPS_KEY, "GET", `/customer-api/users/${h1}/devices`);
  const events = await callOk(OPS_KEY, "GET", `/customer-api/users/${h1}/events?limit=20`);
  return { devices: devices.data.devices, block: devices.data.block, events: events.data.events };
}

async function isUserOnDevice(uuid, deviceId) {
  const h1 = extUserHash(SALT, uuid);
  const { data } = await callOk(OPS_KEY, "GET",
    `/customer-api/devices/${encodeURIComponent(deviceId)}/users?h1=${h1}`);
  return data.linked === true;
}

// 3) block -----------------------------------------------------------------
async function blockUser(uuid, action, reason, days) {
  const body = { h1: extUserHash(SALT, uuid), action, reason }; // action: "callback" | "terminate"
  if (days) body.expiresInDays = days;                            // omit to keep it until lifted
  const { data } = await callOk(OPS_KEY, "POST", "/customer-api/user-blocks", body);
  return data.block.id; // 201 created, 200 updated the user's rule in effect
}

async function liftBlock(ruleId) {
  await callOk(OPS_KEY, "DELETE", `/customer-api/user-blocks/${ruleId}`);
}

// Branch on the error code, for example in your operations tool:
async function blockFromTool(uuid) {
  try {
    return await blockUser(uuid, "terminate", "Cheating", 30);
  } catch (e) {
    if (e.code === "SCOPE_REQUIRED") throw new Error("This key has no block scope: issue a read + block key.");
    if (e.code === "API_KEY_INVALID") throw new Error("The key was revoked: deploy the new key.");
    throw e;
  }
}

module.exports = {
  newSignInBinding, validateSignIn, lookUpUser, isUserOnDevice, blockUser, liftBlock, blockFromTool, OZeroApiError,
};

// C# (.NET 6+): the same flow
using System.Net;
using System.Net.Http.Headers;
using System.Net.Http.Json;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;

// 4xx and 5xx responses carry a JSON body with "code" (for example SCOPE_REQUIRED).
public sealed class OZeroApiException : Exception
{
    public OZeroApiException(int status, string code, string message)
        : base($"OZero API {status}: {code} {message}".Trim())
    {
        Status = status;
        Code = code;
    }

    public int Status { get; }
    public string Code { get; }
}

public sealed class OZeroServerClient
{
    // Leave out null fields such as expiresInDays when no expiry is given.
    private static readonly JsonSerializerOptions Json = new() { DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull };
    private static readonly Uri Api = new("https://api.ozerosecurity.com/v1/");
    private readonly HttpClient _validate = Create(Env("OZERO_VALIDATE_API_KEY"));
    private readonly HttpClient _ops = Create(Env("OZERO_SERVER_API_KEY"));
    private readonly string _licenseKey = Env("OZERO_LICENSE_KEY");
    private readonly string _salt = Env("OZERO_EXTUID_SALT");

    private static string Env(string name) =>
        Environment.GetEnvironmentVariable(name) ?? throw new InvalidOperationException(name + " is not set");

    private static HttpClient Create(string key)
    {
        var http = new HttpClient { BaseAddress = Api };
        http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", key);
        return http;
    }

    public static string ExtUserHash(string salt, string uuid)
    {
        var id = uuid.Trim(' ', '\t', '\n', '\v', '\f', '\r');
        var bytes = SHA256.HashData(Encoding.UTF8.GetBytes("OZERO-EXTUID-V1|" + salt + "|" + id));
        return Convert.ToHexString(bytes).ToLowerInvariant();
    }

    // Sends the request (retrying 429 and 503 with exponential backoff) and always reads the JSON body.
    private static async Task<(int Status, JsonElement Body)> Send(Func<Task<HttpResponseMessage>> request)
    {
        for (int attempt = 0; ; attempt++)
        {
            using var res = await request();
            bool retry = res.StatusCode is HttpStatusCode.TooManyRequests or HttpStatusCode.ServiceUnavailable;
            if (retry && attempt < 4)
            {
                await Task.Delay(500 * (1 << attempt));
                continue;
            }
            JsonElement body;
            try { body = await res.Content.ReadFromJsonAsync<JsonElement>(); }
            catch (JsonException) { body = default; } // not JSON (for example a proxy error page)
            return ((int)res.StatusCode, body);
        }
    }

    // Throws OZeroApiException with the server's code for 4xx and 5xx.
    private static JsonElement Ok((int Status, JsonElement Body) r)
    {
        if (r.Status < 400) return r.Body;
        string code = $"HTTP_{r.Status}", message = "";
        if (r.Body.ValueKind == JsonValueKind.Object)
        {
            if (r.Body.TryGetProperty("code", out var c)) code = c.GetString() ?? code;
            if (r.Body.TryGetProperty("message", out var m)) message = m.GetString() ?? "";
        }
        throw new OZeroApiException(r.Status, code, message);
    }

    // 1) validate: (true, payload) allows the sign-in, (false, reason) refuses it.
    public async Task<(bool Ok, JsonElement Result)> ValidateSignIn(
        string audience, string challenge, string sessionId, string attestToken)
    {
        var r = await Send(() => _validate.PostAsJsonAsync("validate", new
        {
            attestToken, licenseKey = _licenseKey, audience, challenge, sessionId, enforceVersionWhitelist = false,
        }));
        if (r.Body.ValueKind == JsonValueKind.Object && r.Body.TryGetProperty("valid", out var valid))
            return valid.GetBoolean() ? (true, r.Body.GetProperty("payload")) : (false, r.Body.GetProperty("reason"));
        Ok(r); // no "valid": a key or setup error such as SERVER_API_KEY_REQUIRED
        throw new OZeroApiException(r.Status, $"HTTP_{r.Status}", "unexpected response");
    }

    // 2) read
    public async Task<JsonElement> LookUpUser(string uuid) =>
        Ok(await Send(() => _ops.GetAsync($"customer-api/users/{ExtUserHash(_salt, uuid)}/devices")));

    // 3) block and lift
    public async Task<string> BlockUser(string uuid, string action, string reason, int? days = null)
    {
        var body = Ok(await Send(() => _ops.PostAsJsonAsync("customer-api/user-blocks", new
        {
            h1 = ExtUserHash(_salt, uuid), action, reason, expiresInDays = days,
        }, Json)));
        return body.GetProperty("block").GetProperty("id").GetString()!;
    }

    public async Task LiftBlock(string ruleId) =>
        Ok(await Send(() => _ops.DeleteAsync($"customer-api/user-blocks/{ruleId}")));

    // Branch on the error code, for example in your operations tool.
    public async Task<string?> BlockFromTool(string uuid)
    {
        try
        {
            return await BlockUser(uuid, "terminate", "Cheating", 30);
        }
        catch (OZeroApiException e) when (e.Code == "SCOPE_REQUIRED")
        {
            Console.Error.WriteLine("This key has no block scope: issue a read + block key.");
            return null;
        }
    }
}

# Python 3 + requests: the same flow
import hashlib
import os
import secrets
import time
import uuid as uuidlib

import requests

API = "https://api.ozerosecurity.com/v1"
VALIDATE_KEY = os.environ["OZERO_VALIDATE_API_KEY"]  # scope: validate
OPS_KEY = os.environ["OZERO_SERVER_API_KEY"]         # scopes: read + block
LICENSE_KEY = os.environ["OZERO_LICENSE_KEY"]
SALT = os.environ["OZERO_EXTUID_SALT"]


def ext_user_hash(salt: str, uuid: str) -> str:
    uid = uuid.strip(" \t\n\v\f\r")
    return hashlib.sha256(f"OZERO-EXTUID-V1|{salt}|{uid}".encode("utf-8")).hexdigest()


assert ext_user_hash(bytes(range(32)).hex(), "player-123") == \
    "2d5a23607064e6dbc02dc32dc96af8cf54862d2f51d778596cfbe9d6ba8f8a3a"


class OZeroApiError(Exception):
    """4xx and 5xx responses carry a JSON body with "code" (for example SCOPE_REQUIRED)."""

    def __init__(self, status, data):
        self.status = status
        self.code = data.get("code") or f"HTTP_{status}"
        super().__init__(f"OZero API {status}: {self.code} {data.get('message', '')}".strip())


def call(key, method, path, body=None):
    """Reads the JSON body for every status; retries 429 and 503 with exponential backoff."""
    for attempt in range(5):
        res = requests.request(method, API + path, json=body, timeout=10,
                               headers={"Authorization": f"Bearer {key}"})
        if res.status_code not in (429, 503) or attempt == 4:
            try:
                data = res.json()
            except ValueError:
                data = {}
            return res.status_code, data
        time.sleep(0.5 * 2 ** attempt)


def call_ok(key, method, path, body=None):
    status, data = call(key, method, path, body)
    if status >= 400:
        raise OZeroApiError(status, data)
    return data


# 1) validate
def new_sign_in_binding():
    return {"audience": "my-game-login", "challenge": secrets.token_hex(32), "sessionId": str(uuidlib.uuid4())}


def validate_sign_in(binding, attest_token):
    status, data = call(VALIDATE_KEY, "POST", "/validate", {
        "attestToken": attest_token, "licenseKey": LICENSE_KEY, **binding, "enforceVersionWhitelist": False})
    if "valid" not in data:
        raise OZeroApiError(status, data)  # e.g. SERVER_API_KEY_REQUIRED
    return data["valid"], data.get("payload") if data["valid"] else data.get("reason")


# 2) read
def look_up_user(uuid):
    return call_ok(OPS_KEY, "GET", f"/customer-api/users/{ext_user_hash(SALT, uuid)}/devices")


# 3) block and lift
def block_user(uuid, action, reason, days=None):
    body = {"h1": ext_user_hash(SALT, uuid), "action": action, "reason": reason}
    if days:
        body["expiresInDays"] = days
    return call_ok(OPS_KEY, "POST", "/customer-api/user-blocks", body)["block"]["id"]


def lift_block(rule_id):
    call_ok(OPS_KEY, "DELETE", f"/customer-api/user-blocks/{rule_id}")


# Branch on the error code, for example in your operations tool:
def block_from_tool(uuid):
    try:
        return block_user(uuid, "terminate", "Cheating", 30)
    except OZeroApiError as e:
        if e.code == "SCOPE_REQUIRED":
            raise RuntimeError("This key has no block scope: issue a read + block key.") from e
        raise

6. Operations tips

• Split keys by use: a validate key on your sign-in servers, and a read + block key only in your operations tools. A leaked sign-in key then cannot block users.
• Give CI its own key with only the config scope. A leaked CI key then cannot look up or block users.
• Rotate a key without downtime: issue a new key, deploy it to your servers, then revoke the old one in the Customer Portal.
• Mind the limits: 120 customer API requests per minute per key. Batch support lookups and back off on 429.
• Do not write server API keys, the salt, h1 or raw UUIDs to logs or analytics. Treat h1 as a pseudonymous personal identifier.

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; }
public bool EnableWindowsSystemModuleScan { 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.

Returns the current enableWindowsSystemModuleScan value. This property is read-only. To change it, use Unity's Injection settings or apply a Low, Standard, or Strict security preset.

An unfamiliar system module does not immediately close the game. It is recorded for review; repeated sightings or a missing embedded signature alone do not trigger a block. Existing allow rules still apply, as do explicit blocks matched by file hash. Configure this option in Unity's Injection settings; it cannot be changed remotely from the Pro portal. Other platforms are unaffected.