How do I verify a certificate offline?

Remove the signature block, canonicalize the remaining fields (sorted keys, UTF-8, no insignificant whitespace), and verify the ECDSA P-384 signature against the public key. For this sample, the demo public key is on the page; for production certificates, the platform public key is published at /.well-known/eve-pubkey and any certificate can be checked at /verify. No EVE account is required.

Is the sample signed with the production key?

No. The sample is signed with a clearly-labeled demo key so it is safe to publish and independently verifiable. Production decision certificates are signed with the platform ECDSA P-384 key whose public half is published at /.well-known/eve-pubkey.

Examiner Evidence Pack — Signed Certificate

Q: What is in the examiner evidence pack?

A simplified sample EVE decision certificate that illustrates the shape EVE produces for every governed decision (the production schema is eve.decision.v3): the proposed action, the ALLOW/MODIFY/BLOCK verdict and reason code, the policy set and version in force, a risk score, a content hash and prior-record hash for the chain, and an ECDSA P-384 signature. It is an illustrative sample signed with a published demo key so you can verify it offline yourself.

What Is In The Pack

One decision, fully evidenced

The pack is a simplified demonstration certificate that illustrates the shape of the decision record EVE produces for every governed decision — not the full production eve.decision.v3 schema: the proposed action, the ALLOW / MODIFY / BLOCK verdict and reason code, the policy set and version that governed it, a risk score, a content hash plus prior-record hash for the audit chain, and an ECDSA P-384 signature. This sample is signed with a clearly-labeled demo key (published below) so it is safe to share and you can verify it yourself. Production certificates are signed with the platform key whose public half is published at /.well-known/eve-pubkey.

This is a simplified demonstration certificate, signed with a published demo key so you can verify it offline — not the full production eve.decision.v3 schema. See EVE Proof for the production evidence format.

Schema & canonicalization registry. Production artifacts are canonicalized with jcs-1 (a constrained RFC 8785 JSON Canonicalization Scheme profile). The legacy sample on this page uses the same sorted-key principle described informally.

Artifact	Schema	Canonicalization
CoreGuard decision record	`eve.decision.v3`	`jcs-1` (constrained RFC 8785 JCS)
EVE Proof Governed Decision Certificate	GDC v1.1	`jcs-1` (constrained RFC 8785 JCS)
Legacy examiner sample (this page)	`eve.decision.v1`	sorted-key JSON, UTF-8, no insignificant whitespace

{
  "certificate_version": "eve.decision.v1",
  "request_id": "req-2026-07-14-000042",
  "tenant_id": "org_sample",
  "timestamp": "2026-07-14T15:04:05Z",
  "proposed_action": {
    "type": "loan_approval",
    "amount": 50000,
    "applicant_ref": "app_9f3c"
  },
  "model_output": {
    "decision": "approve",
    "confidence": 0.91
  },
  "decision": {
    "status": "MODIFIED",
    "reason_code": "lending.dti_over_threshold",
    "modification": "route_to_manual_review"
  },
  "policy": {
    "policy_set": "lending_v1",
    "policy_version": "2026.07.1"
  },
  "risk": {
    "level": "MEDIUM",
    "score": 0.42
  },
  "evidence": {
    "canonicalization": "sorted-keys JSON, UTF-8, no insignificant whitespace",
    "hash_alg": "sha256",
    "prev_record_hash": "sha256:9b1f...c204"
  },
  "signature": {
    "alg": "ecdsa-p384",
    "public_key_id": "demo-examiner-sample-2026",
    "content_hash": "sha256:72d4fcebb0777799e3cbcf453cadfaf052e943f4f76e7ed0505cd7d9938b5d49",
    "value": "kms-ecdsa-p384:e78313dfbd4b6e702b6e7b52ea0b321d7da6ce2396182bc1458f76dcee159932ee44a354b5e2bd7edffd9ea470a8a8e8074b1fcb2f40301269180ba9616c1d0f"
  }
}

Download sample-decision-certificate.json Demo public key (hex): 77be917626243bd07e5d703372fea46d686c5e2ecb178c13e4bf809040b8639f

Verify It Offline

Three steps, no EVE account

01 Canonicalize

Remove the signature block and re-serialize the remaining fields with sorted keys, UTF-8, and no insignificant whitespace.

02 Check the hash

SHA-256 the canonical bytes and confirm it equals the certificate’s content_hash.

03 Verify the signature

Verify the ECDSA P-384 signature over the canonical bytes against the demo public key (or the published platform key for production certs).

A minimal Python check — the same procedure the eve-coreguard SDK performs, and what the live verifier at /verify does for production certificates:

import json, base64, hashlib
from cryptography.hazmat.primitives.serialization import load_pem_public_key
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import hashes

cert = json.load(open("sample-decision-certificate.json"))
sig = cert.pop("signature")                       # remove signature block
canonical = json.dumps(cert, sort_keys=True, separators=(",", ":")).encode()
assert sig["content_hash"] == "sha256:" + hashlib.sha256(canonical).hexdigest()
pub = load_pem_public_key(DEMO_PUBLIC_KEY_PEM.encode())   # ECDSA P-384 (AWS KMS)
pub.verify(bytes.fromhex(sig["value"].split(":", 1)[1]), canonical, ec.ECDSA(hashes.SHA384()))   # raises if invalid
print("signature OK — verdict:", cert["decision"]["status"])

Set DEMO_PUBLIC_KEY_PEM to the PEM value above. For production certificates, fetch the key from /.well-known/eve-pubkey instead.

Why It Holds Up

Reproducible by construction

Because the verdict is deterministic — the same normalized input under the same policy version yields the same result — the certificate is not just a log line. It can be re-derived and re-verified long after the decision was made, and it names the exact policy version that governed it. That is the difference between “we have logs” and “here is the decision, signed, and here is how to prove it.” See EVE Proof for the full evidence layer.

Common Questions

FAQ

No. It is signed with a clearly-labeled demo key so it is safe to publish and independently verifiable. Production decision certificates are signed with the platform ECDSA P-384 key whose public half is published at /.well-known/eve-pubkey.
No. Verification uses only the certificate, the documented canonicalization procedure, and a public key. The published eve-coreguard SDK performs it offline, and the live verifier at /verify checks production certificates with no login.
Yes. Every verdict — ALLOW, MODIFY, and BLOCK — is bound to the policy version and emitted as a signed, hash-chained record. A block still produces the evidence that explains why.

For technical and audit buyers

Book an architecture review, or run a pilot

Walk your model-risk, security, or engineering team through where the gate sits, how the evidence is produced, and how offline verification works — then run one of your real decisions through it. Founding design-partner pilot from $27,500 (standard $37,500).

Book an Architecture Review Book a Pilot

Related: EVE Proof · Live verifier · For model risk · For compliance.

The evidence an examiner can actually inspect