EVE Verify

Confirm that signed EVE evidence is authentic and unaltered — offline, in your own runtime, without trusting the EVE server.

Who this is for

Auditors, regulators, counterparties, and internal reviewers who receive an EVE evidence record and need to check it independently. You should not have to call EVE, hold an EVE credential, or trust EVE's servers to confirm a record is genuine.

The problem

Evidence that only the producing vendor can validate is not independent. If verification requires the vendor to be online and trusted, the record proves little to a third party. You need a verifier that runs on your machine, uses only a public key, and rejects any tampering.

Supported capabilities

Independent offline verification. Signed EVE evidence can be verified independently and offline, in Python, Node, or the browser, without trusting the EVE server (packages/eve-agent-governance/verifiers/*.mjs; eve-ai-governance verifyEvidence; core.eve_sdk.verify_evidence).
Cross-language canonicalization (jcs-1). Evidence is signed over jcs-1, a constrained RFC 8785 profile with proven byte-for-byte parity across Python, TypeScript, and the browser for the supported value domain — so a Python-signed envelope verifies in TypeScript and returns ed25519-valid.

Readiness: offline verification and jcs-1 are SUPPORTED.

How it works

You receive a signed evidence envelope and the Ed25519 public key.
Your verifier canonicalizes the payload with jcs-1 and recomputes the content hash.
It checks the Ed25519 signature against the public key and validates the schema.
If anything was altered, verification fails; otherwise it returns valid: true with ed25519-valid.

No EVE credential is needed, and EVE does not need to be online.

Technical example

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 (ESM, Node ≥18):

import { verifyEvidence } from "eve-ai-governance";

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

Signed evidence example

The verifier operates on any EVE evidence envelope — a CoreGuard decision, an MCP execution record, an artifact scan, a shadow report, or a red-team result:

{ "content_hash": "…", "canon": "jcs-1", "signature": "ed25519-…", "payload": { "decision_id": "…" } }

A tampered envelope (for example, a changed artifact_digest or altered payload) is rejected.

Verifier example (tamper rejected)

import { verifyEvidence } from "eve-ai-governance";

const tampered = { ...envelope, payload: { ...envelope.payload, action: "ALLOW" } };
const report = verifyEvidence(tampered, { publicKeyPem });
// { valid: false }

Deployment options

Verification runs wherever Python ≥3.9, Node ≥18, or a browser is available — including sovereign/offline environments. The TypeScript verifier is browser-safe, never signs, and holds no secrets.

Readiness

Independent offline verification and jcs-1 canonicalization are SUPPORTED. The verifying clients (eve-coreguard 0.2.7, eve-ai-governance 0.3.1) are release-candidate core clients. The EVE SDK core overall is a RELEASE CANDIDATE WITH EXCLUSIONS.

Limitations

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.
Independent (asymmetric) verification requires the Ed25519 public key. An HMAC-SHA256 fallback is symmetric and not independently verifiable.
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.
The clients are published on public registries: pip install eve-coreguard (PyPI) and npm install eve-ai-governance (npm).

Next step

Request sample signed evidence and the public key so your reviewers can run the verifier on their own machines before a pilot begins.