EVE Proof

Signed decision evidence you can verify independently, offline, without trusting the EVE server.

Who this is for

Risk, audit, and platform teams who need to hand a regulator, auditor, or counterparty a record of a governed decision — and have that party confirm the record is authentic and unaltered on their own machine, in their own language runtime, with no dependency on EVE being online or trusted.

The problem

A log line is only as trustworthy as the system that wrote it. If evidence can be edited after the fact, or can only be checked by the vendor that produced it, it is not independent evidence. You need records that are cryptographically bound to the decision they describe, serialized deterministically, and verifiable by a third party.

Supported capabilities

• Signed decision evidence. Every governed decision can produce a signed evidence record bound to the decision (Ed25519 in production configuration, HMAC-SHA256 fallback). Implemented in core/governance/cert_signing.py, core/artifact_scan/evidence.py, and core/mcp/execution_binding.py.
• Independent offline verification. Signed EVE evidence can be verified independently and offline, in Python, Node, or the browser, without trusting the EVE server.
• Versioned canonicalization (jcs-1). EVE signs artifacts over a versioned canonicalization (jcs-1), a constrained RFC 8785 profile with proven byte-for-byte parity across Python, TypeScript, and the browser for the supported value domain (16/16 supported vectors byte-identical Python↔TypeScript).

Readiness: signed evidence, offline verification, and jcs-1 canonicalization are SUPPORTED.

How it works

1. A governed decision (CoreGuard verdict, MCP execution binding, artifact scan, red-team result) produces a payload.
2. EVE canonicalizes the payload with jcs-1 and computes a content hash.
3. EVE signs the canonical bytes — Ed25519 in production configuration.
4. The resulting envelope carries the content hash, canonicalization tag, and signature.
5. Any party with the Ed25519 public key verifies integrity, signature, and schema — offline, in Python, Node, or the browser.

Technical example (evidence envelope)

{
  "content_hash": "…",
  "canon": "jcs-1",
  "signature": "ed25519-…",
  "payload": { "decision_id": "…", "action": "BLOCK", "reason_codes": ["…"] }
}

Signed evidence example (Python, produce)

Signing happens inside the EVE service. A governed decision returns evidence you keep:

from eve_coreguard import EVE

eve = EVE(policy="lending_v1", mode="hosted",
          endpoint="https://your-endpoint", api_key="eve_sk_...")
result = eve.govern_tool_call(
    tool="export_records",
    arguments={"count": 10000},
    context={"tenant_id": "org_abc", "principal_id": "u_9", "session_id": "s_1"},
)
# govern_tool_call returns a plain dict; the certificate is the signed
# evidence bound to result["decision_id"]
certificate = result["certificate"]

Verifier example (offline, no server trust)

Python:

from core.eve_sdk import verify_evidence

# first argument selects the evidence kind (decision | mcp | shadow | scan | redteam | monitoring)
report = verify_evidence("decision", envelope)
assert report["valid"] is True

TypeScript / browser:

import { verifyEvidence } from "@eve/coreguard";

const report = verifyEvidence(envelope, { publicKeyPem });
// { valid: true, signature: "ed25519-valid" }

A tampered envelope is rejected. The TypeScript SDK never signs and holds no secrets — it only verifies.

Deployment options

Evidence and verification work across all EVE deployment modes: embedded (in-service), hosted, sidecar, and sovereign/offline. Verifiers run wherever Python ≥3.9, Node ≥18, or a browser is available.

Readiness

Signed decision evidence, independent offline verification, and jcs-1 canonicalization are SUPPORTED. The verifying clients ship as release-candidate core clients (eve-coreguard 0.2.2 for Python; @eve/coreguard 0.1.0-rc1 for TypeScript/browser). The EVE SDK core overall is a RELEASE CANDIDATE WITH EXCLUSIONS.

Limitations

• Independent (asymmetric) verification requires the Ed25519 public key. The HMAC-SHA256 fallback is symmetric and not independently verifiable.
• Verification proves authenticity, integrity, and schema conformance — it does not attest that the underlying decision was correct, only that the evidence is authentic and unaltered.
• jcs-1 is a constrained RFC 8785 profile: it does not serialize non-integer floats, NaN, or Infinity (it fails closed). It is not full RFC 8785 float compliance. Signed governance artifacts stay in the supported domain (for example, rates carried as integer permille).
• The release-candidate clients are distributed privately for pilots — install the pilot artifact, not a public pip/npm install (see readiness for public-registry status).

Next step

Request a pilot and receive signed sample evidence plus the public key, so your auditors can verify it on their own machines before you commit.