Pre-release Sign-up is not open yet. Platform verification and the signed client download are in development. See what is available
Design

Integration model

The components of an Obscurity integration, what each is responsible for, and where the trust boundaries are.

What exists. Sessions, join-token verification, build registration and usage metering work today and are described below as built. Platform attestation, telemetry, detections and the kernel driver are design and are marked as such.

Components

ComponentRuns onResponsibilityTrusted?
Client SDKPlayer's PC, inside the game processOpen a session, keep it alive, mint join tokens, report the game executable's hash. Later: carry platform evidence and integrity signals.No. Treated as potentially manipulated.
Session serviceObscurityDecide admission from the game's policy and entitlement, authenticate every later request, issue and redeem join tokens.Yes
Game server integrationYour infrastructureVerify a player's join token before admitting them; run server-authoritative gameplay checks.Yes, authenticated by server key
ConsoleObscurityConfiguration, policy, builds, team, usage. Later: evidence review and enforcement decisions.Yes, per-member roles

Session flow (built)

  1. Start. The SDK generates a key pair for this one session and sends the public half with the public game ID, its version, the Windows build number and the SHA-256 of the game executable.
  2. Decision. The service looks up the game, its active policy version and its entitlement, and answers admitted or refused with a code and a category. The client cannot name a tier, a policy or an enforcement mode: nothing it sends is an input to those.
  3. Proof of possession. Every later request is signed with the session key and carries an increasing sequence number. The first accepted one activates the session. A captured request cannot be replayed or moved to another session.
  4. Confirmation. The SDK mints a single-use join token, valid for a minute. The game sends it to your game server, which redeems it with its server key. The client cannot admit itself: the confirmation travels server to server, and the session is bound to the player ID your server supplies.
  5. Revalidation. At each heartbeat (every 30 seconds) the session is re-evaluated against the current policy and entitlement. Raising a game's tier therefore applies to running sessions within a heartbeat. A session that stops sending heartbeats is marked stale, then ended after five minutes.

Admission results

A refusal always carries a category that says what kind of result it is. None of them is a cheating finding and none creates a penalty.

CategoryCodesWhat it means
servicegame_unavailable, game_service_unavailable, development_limitThe game's registration or service state. Clients are told only that protection is unavailable for the game; your console shows the precise reason.
compatibilityclient_unsupported, platform_requirement_not_met, platform_verification_unavailable, attestation_requiredThe game version or PC cannot meet a requirement. The message says what to do. platform_requirement_not_met names the item and gives the player advice; platform_verification_unavailable means the client is too old to produce evidence or the game requires a component that does not exist yet; attestation_required is the waiting state before evidence arrives.
integritybuild_not_recognizedThe executable is not one of your registered builds.

What a session does not prove

A session shows that some process on the player's PC holds a key the service admitted for your game, and that your server verified it. It does not show that the process is an unmodified copy of your game: the SDK runs on a machine the player controls, and the executable hash is reported by that machine. Catching a determined cheat is the job of server-authoritative validation and, later, the detectors. Sessions are what those are attached to.

Platform verification (built, not released; Advanced)

When a game's policy requires a platform item, the session start answers attestation_required with a challenge instead of admitting. The SDK then sends a TPM quote of the boot measurements bound to that challenge and the measured-boot log in three signed requests, and the service admits or refuses once it has verified them. No join token is issued while a session waits. See platform verification for the mechanism, the results and its limits.

The service never admits a session under a weaker profile than the one configured. A client too old to produce evidence is refused with platform_verification_unavailable, and so is every Enforce-mode session of an Elite game while its boot-start component does not exist.

Rules the design follows

  • Authorization stays on servers. Entitlements, admission and enforcement are decided by Obscurity services or your game server, never by the client.
  • Replay resistance. Requests are signed per session and sequenced; join tokens work once.
  • Four separate stages. Collection, detection, evidence review and enforcement are distinct. A detector cannot ban anyone; it produces evidence for a decision that is recorded and reversible.
  • Outage is not failure. If the service cannot be reached, the SDK reports service_unavailable, never a failed requirement, and it is never held against a player.
  • Billing is not about players. A lapsed subscription suspends service for the game. It never lowers the tier and is never recorded against a player.
  • Minimal collection. See data collection and privacy for every field.

What you integrate

PieceFormStatus
Server API (HTTPS + game-scoped key)Verify join tokens, re-check and end sessions, and read the game's policy and usage. Works from any language.Available
C/C++ client SDK for Windows x64DLL or static library with a C ABI, for custom engines and as the base for engine plugins. Builds from source; signed downloads are not published yet.In development
Game server library (Python)Reference client for the server API plus the server-authoritative validation helpers. Builds as the obscurity-gameserver package; not yet published on PyPI.In development
Unreal Engine 5 pluginWraps the C SDK as an engine plugin.Planned
Unity (Windows, IL2CPP) packageWraps the C SDK as a native plugin.Planned

Privileged components

Every tier is designed to include a kernel driver, which is planned and neither built nor distributed. On Core and Advanced it is loaded when the game starts and unloaded when the game exits. On Elite it is a boot-start driver, loaded early in Windows startup; it starts with Windows, not before it.

Until the driver exists, everything on the player's PC runs in user mode: the client SDK, and platform verification, which relies on the TPM and Windows' own measured boot. Gameplay validation runs on your servers, and that is what today's detections rest on.

Before any release the driver needs Microsoft's driver certification, memory-integrity compatibility and testing on physical hardware. Its interface to user mode will be narrow and documented here first: it will not expose general memory access, it gates admission only to games protected by Obscurity, and Windows must keep working normally if it fails or is removed.