Skip to content

Open specifications

DIV — Deterministic Intent Verification

Open specificationDIV 1.2.0 · Edition 1.3.0 · October 2026

DIV is an open, transport-agnostic protocol for proving a human approved specific execution parameters immediately before an irreversible action — verifiable offline, with no call back to the issuer.

Abstract

Existing authorization systems establish who is permitted to perform an operation and what classes of operations are allowable. They generally do not provide cryptographic evidence that a human explicitly approved specific execution parameters immediately prior to execution.

In autonomous environments — AI agent tool invocation, CI/CD pipelines, automated background workers — that gap exposes infrastructure to parameter-mutation attacks, prompt injection, and unauthorized execution under valid standing credentials.

DIV defines a signed intent object, an explicit proof envelope, and a deterministic offline verification procedure that binds a human signature to the canonical byte representation of exact execution parameters. It is designed to embed within existing IAM and OAuth architectures rather than replace them.

The five invariants

A compliant implementation must satisfy all five. Invariant 2 does the distinctive work: the relying party rebuilds the payload from its own runtime parameters before checking the signature, so an approval for one set of parameters cannot authorize another. Replay is stopped separately, by the expiry and nonce checks in the verification procedure.

InvariantRequirement
Parameter-bound bindingThe signature must be computed over the complete intent payload containing the exact execution parameters — not a summary, a title, or a truncated description.
Local payload reconstructionThe relying party must NOT trust the payload supplied inside the envelope. It must rebuild the expected payload from its own runtime parameters before verifying.
Offline verificationThe signature must be verified locally against a trusted approver public key. Verification must not require outbound calls to a broker or a vendor service.
Fail-closed executionAny irreversible action encountering a missing, malformed, unverified, expired, or replayed proof must abort before invoking the underlying operation.
Target isolationThe payload must explicitly bind the intended target identifier, preventing an approval issued for one service from being replayed against another.

The canonical intent payload

Payloads are serialized with the JSON Canonicalization Scheme (RFC 8785), keys sorted recursively by UTF-16 code unit. Implementations must not rely on arbitrary JSON serialization behavior — and where language runtimes genuinely disagree (each switches to exponent notation for numbers at its own threshold), producers must refuse to sign a payload containing a non-portable number (§4.1.1) rather than serialize it differently.

{
  "v": 1,
  "type": "div-intent-verification",
  "target": "prod-db-cluster-01",
  "actionType": "db:dropTable",
  "display": "Delete production users table",
  "params": {
    "environment": "production",
    "table": "users"
  },
  "evidence": null,
  "requester": {
    "did": "did:example:service:deploy-pipeline",
    "attestation": null
  },
  "requirement": {
    "requiredApprovals": 2,
    "requireHardwareKey": true,
    "allowedAaguids": ["adce0002-35bc-c60a-2b7b-40b2ede212b7"],
    "requesterCannotApprove": true,
    "signerClass": "human"
  },
  "nonce": "c_8f91a2b4c6e8",
  "expiresAt": "2026-07-24T12:05:00Z"
}

The null attestation is signed and load-bearing: it distinguishes an attested workload from a bare credential holder. When present, an attestation carries exactly a method, an issuer, and a subject — consumed from OIDC or SPIFFE rather than reinvented here. The requirement object is equally load-bearing: without it in the signed bytes, a receipt from a 3-of-3 hardware-pinned challenge would be byte-for-byte identical to a 1-of-1 one.

The evidence field is reserved (§4.3.4). It is required in the bytes and must be null in this version, where null is the payload's explicit statement that the authorization was not conditioned on any external fact. Non-null values are reserved for a later version, and a verifier must refuse one rather than treat it as unconditioned — the same fail-closed-on-unknown rule the signer-class registry uses. Params is deliberately not the place for such a commitment: it is reconstructed by the relying party from the operation it is about to perform.

The proof envelope

The envelope carries the canonical payload, a signatures array — one witness entry per approver, so a quorum receipt is representable — a short verification code derived from the payload digest, and the human-readable action description. Each witness signature may be ES256 — a raw P-256 signature over the canonical payload bytes — or WEBAUTHN, a FIDO2 assertion, which additionally carries authenticatorData, clientDataJSON, and a COSE-encoded public key, without which a passkey approval could not be represented or verified.

A relying party verifying a WebAuthn envelope must pin the expected origin and RP ID, must enforce the user-present flag (and, by default, user-verified), and must reject cross-origin assertions unless explicitly opted in. The assertion signs authenticatorData plus the SHA-256 of clientDataJSON — not the payload bytes directly; the payload binds through the challenge inside clientDataJSON. Without an origin to pin, an assertion harvested at any other relying party would verify.

Verification procedure

  1. Receive the proof envelope.
  2. Validate its structure.
  3. Resolve trusted approver keys from local policy. Quorum and separation of duties require identity-associated keys. Reject a signed requirement weaker than the relying party’s local approval policy (§5 step 3d); the signed requirement alone is only what the signers stated.
  4. Construct the expected intent payload from local runtime parameters.
  5. Serialize that expected payload with RFC 8785 JCS.
  6. Verify each witness signature against those canonical bytes.
  7. Validate the approval requirement: count distinct approver identities with a valid signature, and reject unless the count is at least requirement.requiredApprovals. Two credentials belonging to one approver count once; one key mapped to two identities also counts once.
  8. Validate the target binding.
  9. Validate expiration.
  10. Validate nonce freshness.
  11. Record nonce redemption.
  12. Permit execution.

If any step fails, execution must be denied. Steps 1 through 9 are a stateless cryptographic check and can be implemented by a self-contained offline verifier holding no state. Steps 10 and 11 are inherently stateful — the relying party has to persist which nonces it has consumed — so a deployment may satisfy them in a stateful gatekeeper while running 1 through 9 as defense-in-depth at the point of execution. Step 7 is what makes quorum meaningful offline: a relying party that verifies one signature and stops has verified an approval, not the approval the policy required.

What DIV explicitly does not define

The trust surface stays small by refusing scope. DIV specifies only the intent object, its envelope, its serialization, and the local verification algorithm.

  • Authentication and identity management. DIV assumes identity attestation via OIDC, SPIFFE, or DIDs is established independently.
  • Key distribution and PKI. Public key discovery and rotation are deferred to external key management — though §4.4.6 constrains the anchor's shape: verifying a quorum requires an identity-associating trust anchor, not a bare key set.
  • Transport. Envelopes may be carried over HTTP, gRPC, WebSockets, or file-based IPC.
  • Approval workflow orchestration. Step-up prompting, notification routing, and quorum scheduling are operational concerns outside this specification.

Security considerations

DIV protects against modification of approved execution parameters, replay against unintended targets, unauthorized execution using valid standing credentials, and transport-layer alteration of intent artifacts.

It does not protect against compromise of the approver's private signing key, a malicious approval by a trusted approver, compromise of the relying party's execution environment, or incorrect interpretation of valid parameters by the executing application. An approver interface should display the exact execution parameters before signature generation to reduce blind-signing risk — a protocol cannot make someone read.