All notable changes to this project will be documented in this file.
The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.
- A sealed TRACE signing key on the TPM tier (#462), off by default. With
attestation.seal_signing_keyandprovider: tpm, the signing key survives restarts, sealed underTPM2_PolicyNVover a gate NV index (0x01500433) that holds the gateway digest, so a relying party can pin it withcmcp verify --trusted-key. A gateway whose measured inputs differ from the sealed digest does not get the key and does not start; each failure has its ownSEALED_KEY_*code, and nothing is minted to recover. A verified policy reload reseals the key to the new digest. ATTEST-004 applies only with sealing off. Seedocs/spec/attestation.md4.2 for what it does and does not guarantee. cmcp measureprints the gateway digest and its components.cmcp key public,cmcp key resealandcmcp key rotatemanage the sealed key.- A
tpmextra for tpm2-pytss. On Linux, CI's test job installs it and runs the TPM tier against swtpm.
-
Defer sealed signing-key provisioning/unseal until all
run_startupchecks succeed (#782). A rejected policy, identity or store configuration no longer leaves a newly sealed key bound to rejected inputs. Port binding happens later and is outside this boundary. Earlier validation errors now take precedence over final provisioning and unseal errors. Failed startup releases the sealed-key store lock. Clarify the empty-owner-password access boundary. -
The test suite could write to the developer's TPM. With tpm2-pytss installed, tests that expected the degraded path opened the default TCTI and defined and extended the measurement index on the machine's real TPM. The suite now refuses any ESAPI context that is not a simulator.
-
sink_policy.tool_max_sensitivitywas measured as its printed form, in YAML order, so reordering the tools changed the configuration digest. It is now measured as a mapping. The new measured sealing settings change the config digest for every deployment on upgrade; deployments settingsink_policyalso receive this mapping correction.
- The operator token was measured. Only the bearer token was excluded from
the measured configuration, so
CMCP_OPERATOR_TOKENfed the gateway digest (since #629): rotating it changed the digest, and a digest over it reached the measurement index and, onsev-snp,tdxandazure-cvm-sev-snp, the report nonce. A verifier recomputing an expected digest also needed the production token. The configuration digest changes once for every deployment, since the field leaves the measured payload. A deployment that used a low-entropy operator token should rotate it after upgrading. - Agent Manifest v0.2: the SDK appraised the COSE envelope, but the binding
fields were read from the decoded dict the caller passed, and nothing checked
that the two were the same document. A valid envelope paired with a dict
carrying another policy or catalog hash bound. The dict must now equal the
signed payload, and
issuer_key_idis the key that verified the envelope instead of an empty string.
build_server(ctx, trace_gate=...): an optional pre-transport hook for verifier-issued TRACE tokens (cmcp_runtime.trace_gate.TraceGate). With a gate,POST /trace/challengeandPOST /trace/admitare registered behind bearer auth, everytools/callneeds a holder proof bound to its exact action, and the gate is rechecked and a receipt committed before any byte goes upstream. A gate requires enforcing mode. With no gate, the routes do not exist and the call path is unchanged.cmcp_runtime.manifest_catalog.manifest_catalog_binding: the Agent Manifest tool Merkle root (spec 3.2.3) computed from the catalog being served, kept separate from cMCP's sealed catalog digest.- Experimental
evidence-requirements-experimental-v1manifest profile: the tool binding is checked against that Merkle projection, and the signed evidence requirements must also name the sealed catalog digest.
- The
opaqueattestation provider and its verifier.cmcp_runtime.tee.opaquewas a placeholder that only raised, andcmcp_verify.opaquemarkedhardware_attestationverified on an unsignedverified: truefrom a remote endpoint, which is not evidence. Gone with them:TEEProvider.OPAQUE, theATTESTATION_PROVIDER_NOT_IMPLEMENTEDerror, theopaqueandopaque-managedplatform branches inverify_trace_claim, and theCMCP_OPAQUE_ATTESTATION_ENDPOINTandOPAQUE_API_KEYvariables. A config namingattestation.provider: opaquenow fails with the sameConfigErroras any unknown provider. The spec no longer lists ahighestvalue forattestation_assurance, which only that provider used.
- Breaking: an Agent Manifest binding now requires issuer key
authorization (Agent Manifest spec §5.3.3). The trust anchor at
agent_manifest.trust_anchor_pathcarries anissuerslist of SPIFFE URIs per key, and the gateway passes it to the SDK astrusted_key_issuers. Before, cMCP passed no issuer policy and agent-manifest 0.15.0 skipped the check, so any trusted key could sign a manifest naming any issuer. Startup now stops withAGENT_MANIFEST_BINDING_FAILEDwhen no key in the trust anchor listsissuers, and when the signing key is not authorized for the manifest'sissuer.cmcp verifyandverify_trace_claimread the same policy (newtrusted_agent_manifest_key_issuersargument) and report the binding unverified without it. The trust anchor is parsed once for keys and policy, and loading it fails on a malformed SPIFFE ID inissuersor a repeatedkey_id. Found by @litzki-systems on agentrust-io/agent-manifest#493. - Test fixtures and docs use vendor-neutral example model names.
- LICENSE and NOTICE name the copyright holder as AgenTrust Contributors. The previous LICENSE line credited Agentic AI Foundation contributors, but the foundation has not accepted the project. CHARTER.md and GOVERNANCE.md now say the "cMCP" and "cMCP-compatible" marks are held by the founding maintainer until a host organization accepts the project.
- Enforce canonical unpadded base64url in
cmcp_runtime.agent_manifest._b64url_decode(rejectinglen % 4 == 1and non-zero trailing bits), reject private JWK key material in Agent Manifest trust anchors and catalogpublisher_jwkentries, reject duplicate JSON object keys acrossmcp/server.py,catalog/loader.py,agent_manifest.py, andinspection/pipeline.py, and reject non-finite floats and integers outside the RFC 8785 safe-integer range inmcp/proxy.py(#798). - An Agent Manifest that lists its tools in
tool_manifest.toolscould never bind: cMCP handed the SDK its sealed catalog digest, and from agent-manifest 0.13 the SDK comparescatalog_hashwith the Merkle root of that list. Such a manifest now binds when its list and root equal the projection of the catalog being served (cmcp_runtime.manifest_catalog). A manifest that omitstoolsis still compared with the sealed digest.verify_agent_manifest_bindingtakesruntime_catalogfor this; without it a manifest withtoolsdoes not bind, which includescmcp verify, since it has no catalog to project. - The Agent Manifest tool projection (
cmcp_runtime.manifest_catalog, added in #713 after the v0.7.0 tag) now follows the restricted profile ruled on agentrust-io/agent-manifest#340.schema_hashis SHA-256 over the JCS form of{"input_schema", "output_schema"}instead of the input schema alone,description_hashis over the description as a JCS string instead of its raw UTF-8, andendpoint_idis the server's SPIFFE ID with no fallback to its URL. This changes everyschema_hash,description_hashandcatalog_hashthe projection produces, so a manifest built from main before this fix must be reissued. No release carries the old values. Binding now joins the manifest's tools to the served catalog on exacttool_nameplusendpoint_id, one to one, rebuilds the root from the manifest'stool_idand the served component hashes, and compares only that root. A non-empty served catalog with any server lacking aspiffe_idraisesManifestCatalogOutOfProfile, an outcome distinct from a failed join or a root mismatch; the gateway still does not bind. Reported by @asymx-mechanics (#719).
- A Cedar Allow reached with evaluation errors was enforced as Allow
(GHSA-frxc-7f57-6f4r). Cedar skips a policy whose condition errors, so a
forbidreading a context attribute the current phase does not carry could not stop a matchingpermit.CedarBackendnow denies any Allow that comes with evaluation errors, and the error reaches thetool_calloregress_deniedaudit row. So that a policy written for one phase does not deny in the other, both phases now carry the same context keys: egress addssession_max_sensitivity(the label string),arguments,baa_covered,compliance_domain,server_identity,destination_classandattestation_platform, and ingress addsegress(false),sensitivity_level,injection_events,reset_countandresponse_size_bytes(0). Without this the shipped BFSi demo denied every response at egress. A policy that reads a key outside that set, orworkflow_idwhen the caller declared none, now denies. - The TPM AIA certificate fetch was unbounded (GHSA-mrcx-xvv4-m7f8). The chain walk followed redirects to any address and read responses without a limit. It now refuses destinations that do not resolve to global addresses, checks every redirect the same way, follows at most three and ignores responses over 64 KiB. Each hop's host is resolved once and the connection goes to the checked address (the request still names the host, and HTTPS still verifies the certificate against it), so a second DNS answer cannot point the fetch somewhere else. The fetch no longer uses environment proxies. An on-prem CA whose AIA host has a private address falls back to the vendored bundle.
- Upstream drift was classified against the wrong catalog entry (GHSA-2p85-666x-xm7x). The scanner received the server of whichever entry was last in the catalog. Detection and fail-closed denial were not affected; only the classification written to the audit row was.
- TPM 2.0:
verify_tpm_measurementlisted aqualifying_datamismatch as unverified but still returnedverified, so a genuine quote could be attached to a claim signed by any key. It also never compared the quote'spcrDigestwith the claim'smeasurement, thoughdocs/spec/tpm-security-model.mdsaid it did. Both now fail the check.
verify_trace_claimtakesexpected_launch_measurements, andcmcp verifytakes a repeatable--launch-measurement. A hardware claim whose measurement is outside the set fails. With no set, a hardware claim ispartially_verifiedwithlaunch_measurementunverified: genuine hardware says what ran, not that it was approved, and a report from any guest image used to come outverified.
0.6.0 - 2026-09-25
agent_manifest.revocation_list_path: a JSON Lines revocation list in the Agent Manifest CLI's CRL format. Startup rejects a bound manifest listed there, and a missing or malformed list aborts startup instead of reading as empty. Without it, startup now logs that revocation is not checked; before, the SDK was always handed an empty store.
-
verify_audit_bundlenow requires every change of entrysession_idto be a recordedsession_resetthat names the closing session and its successor, and requires the claim'sgateway.session_idto be the session the bundle ends in. A bundle mixing sessions with no recorded boundary used to verify. -
code_digesthashes each installed file RECORD vouches for and refuses the measurement when the bytes differ, so an edit to an installed file with RECORD left alone no longer leaves the digest unchanged. A listed file that was deleted is marked<missing>in the digest. Digests of intact installs are unchanged. -
GET /audit/exportserved the live chain under anysession_idthe caller named, labelling the bundle with that id. It now serves a closed session's chain under its own id and the live chain only under the current session id, and returns 404 otherwise. The quickstart read the internal id by exporting under the_cmcp.session_idlabel; it now reads it from the allowed call'sresult._cmcp.session_id. -
A bearer token containing non-ASCII characters returned 500 from the auth middleware; it now returns 401.
-
The container image and the ClusterFuzzLite build install dependencies from the new hash-pinned
requirements/runtime.txt, and the base image is pinned by digest. -
Exhaust upstream
tools/listpagination before drift and provenance comparisons (#631). HTTP and stdio share bounded acquisition: later-page failures, malformed or ambiguous listings, and cursor cycles are unchecked, never a comparison against a partial catalog. Existing drift policy and unchecked-call behavior are unchanged. Observed by solloek369-arch on #566 and confirmed in #631 by Imran Siddique. Drift and provenance now share one completed discovery acquisition per server/authority per session, including unchecked outcomes, avoiding a second full pagination walk on cold calls with provenance configured. Concurrent readers wait for completion; cancelled reads are not cached. Session rebinding resets acquisition and comparison caches together. The duplicate-fetch cost was identified by qubeena07 during review of #633. -
verify_audit_bundle()now reports malformedtool_namevalues during claim summary verification and malformed external-receiptevidence_typevalues as failed verification results instead of raisingTypeError. Hash-chain checks remain active, and receipt verification remains opt-in (#593, #597). -
verify_trace_claim()stops at a schema failure and returnsCLAIM_MALFORMEDwith the offendingmalformed_field, instead of continuing to signature and binding checks against a claim whose shape was never established (#592, #596). -
Embodied action evidence nested inside embodied action evidence is rejected rather than verified recursively (#688).
-
The TRACE claim schema declares
intent_hash,agent_key_thumbprintandenforcement_modeundergateway.agent_identity. The runtime already emitted them whenever an Agent Manifest binding was configured, so those claims failed the schema they were signed against (#622, #632). -
A non-string value for a path setting in config is reported as a configuration error instead of raising a
TypeError(#673, #674). -
docker-compose.ymlruns the gateway from/var/lib/cmcpon a namedgateway-datavolume, so audit data survivesdocker compose down(down --volumesstill deletes it). CI checks the compose storage layout (#686). -
Accept emitted
gateway.call_log_summaryand call-graphedges_representfields in the TRACE claim schema. Both remain optional for older claims; malformed values and undeclared properties remain rejected.
-
An unrecognised enforcement mode was signed as
advisory._build_policyfell back toadvisoryfor any value outsideenforcing,advisoryandsilent, so a claim built from such a value asserted that the policy had been evaluated. The gateway's own path passes a validatedEnforcementMode, so this was reachable only by callers building claims directly. Claim construction now refuses the value, as_build_runtimealready refuses an unknown provider. Reported by @saintmalik in #654. -
Add an opt-in exact-output disclosure contract and library adapter. Independently scoped owner signatures bind output bytes, source labels, workload, recipient, purpose, policy and validity. Durable pre-delivery consumption rejects replay and keeps failed delivery unknown. Existing gateway sink ceilings are unchanged; transport binding, classification, storage and clocks remain trusted inputs.
-
Distinct tool names could share one Cedar policy identity. The policy backend names a call's action by joining the underscore-separated parts of the tool name, so
read_file,read__file,_read_fileandread_file_all becameAction::"ReadFile", and a permit or forbid written for one applied to the others. The catalog loader checked only literal duplicates and uppercase names. It now refuses a catalog in which two entries derive the same action (CATALOG_TOOL_NAME_COLLISION), using the same derivation the backend uses, now shared incmcp_runtime.policy.action_name. The derivation itself is unchanged, so existing policies keep their action names. Reported by @saintmalik in #655. -
Nothing in a claim showed whether the kill switch was armed, and a refusal left no evidence. A claim with
kill_switch_triggered: falseread the same whether the switch was enabled and did not trip or was never enabled, and a call refused by a tripped gateway produced nothing a verifier could check. Claims from a gateway with the switch enabled now carry agateway.kill_switchblock with its settings and, when it tripped,trigger(deny_rateoroperator); claims from gateways without it are unchanged. Each refused call returns a receipt signed with the claim signing key and bound to the closed session's claim by digest, andcmcp_verify.verify_kill_switch_refusalchecks one against the other.kill_switch.enabledwith no Agent Manifest now stops startup (KILL_SWITCH_REQUIRES_IDENTITY): the switch blocks an identity, and without one it stopped nothing while appearing armed. The tutorial no longer claims evidence is verifiable by any regulator or that no other gateway can produce it, and says what the evidence does not cover. -
The kill switch only acted when a session closed. The deny rate was evaluated in
close_session, so an agent the switch should have stopped kept calling for as long as its client kept the session open. Each call is now counted as it completes, and the call that crosses the threshold closes the session at once, signs its claim withkill_switch_triggered: true, and recordstripping_call_id. Calls counted this way are not counted again at close. Operators can also trip the switch directly withPOST /kill-switch/trip, which requiresreasonandauthorized_by, blocks the bound identity, records the trip, and returns the closed session's claim. -
The kill switch did not survive a restart, and the close that tripped it failed. Blocked identities were held in an in-memory set, so any restart lifted every block. Over HTTP, a close that tripped the switch raised
KillSwitchTrippedwhile creating the successor session: the caller got a generic500 INTERNAL_ERRORinstead of the claim, and later tool calls waited on a rotation that could never finish instead of receiving the documented403 KILL_SWITCH_TRIPPED. Blocks now live in the audit database, the tripping close returns its signed claim, and every later call is refused at once. A gateway that starts with its identity blocked comes up halted rather than failing to start, and/readyzreports it. The tutorial described aDELETE /admin/kill-switch/...endpoint that did not exist; the operator route is nowPOST /kill-switch/unblock, which requiresagent_id,reasonandauthorized_byand records the unblock in the audit chain. -
A compromised policy signing key could not be revoked without a restart. Hot reload accepted any bundle signed by
CMCP_POLICY_SIGNING_KEYwith a higher version, and the only way to stop trusting that key was new config plus a restart, so until every gateway restarted the key's holder could keep installing policy on it.CMCP_POLICY_SUCCESSOR_SIGNING_KEYnow pins a second key at startup. A statement insigning-key-revocations.json, signed by the successor or the current key, revokes the current key on the next reload and promotes the successor. The policy in force is then untrusted and every tool call is refused withPOLICY_SIGNING_KEY_REVOKED, in every enforcement mode, until a successor-signed bundle with a higher version is installed. A bundle signed by the revoked key is refused with the same code. Revocation is one-way within the process: no statement un-revokes, a stolen current key cannot revoke the successor, and bad statements are logged (POLICY_KEY_REVOCATION_INVALID) and skipped without blocking the reload. TRACE claims gain an optionalgateway.policy_signingobject recording the key the policy in force verified under and the keys revoked. Startup also now reports a bundle signature failure as aPOLICY_SIGNATURE_INVALIDFATAL entry and exit 1, where the exception previously propagated out ofrun_startup. -
Signed policy reload never installed a changed bundle when a hash was also pinned.
PolicyStore.reload_if_stalepassed the startupCMCP_POLICY_HASHto every reload, so with a hash and a signing key both pinned (the documented production shape, and the only one outside dev mode, where a hash is required) a correctly signed newer bundle failed withPolicyHashMismatchand the old policy stayed in force. With a key pinned, the key now authorises reloads and the hash is checked on the startup load. -
Add optional operator-owned tool and caller-response sensitivity ceilings. They enforce accumulated/catalog/declared classification independently of Cedar mode, before discovery and dispatch and before response release. Strict sink policy suppresses captured stdio stderr content; upstream error logs no longer echo tool messages. This is conservative label enforcement, not semantic information-flow verification or automatic declassification.
-
Add verifier-owned SNP platform policy to native and Azure verification and the public TRACE verifier. Explicit requirements fail closed without signed SNP evidence. The optional policy covers PLATFORM_INFO, not guest DEBUG, firmware TCB currency, or runtime admission.
-
A response arriving during an operator reset raised the successor session. The per-session mutation lock serialised a reset and a response elevation but did not order them, so whichever coroutine acquired it second won. A response in flight when the reset landed was applied to the successor, which had just been initialised to
public, and recorded the pre-resetcall_idas the call that raised it. The successor exists to start at the minimum level, so this carried the closed session's sensitivity across the boundary the reset drew.update_from_inspection()now takes thereset_countobserved at call entry and drops a response whose generation no longer matches, loggingSESSION_RESET_RACE. The discriminator isreset_countrather thansession_idbecauseupgrade_attestation()rotates the identifier while deliberately continuing the same session, so a call in flight across an attestation upgrade must still apply. The previous concurrency test asserted only thatmax_sensitivityremained a member ofSENSITIVITY_ORDER, which every value satisfies. -
The reset route accepted the tool-invocation token.
POST /sessions/{id}/resetis not reachable as an MCP tool, but it sat behind the same singleCMCP_BEARER_TOKENasPOST /mcp, so an agent host holding its own tool-invocation credential could clear accumulated session sensitivity. The operator interface (session reset and catalog exception) now takesCMCP_OPERATOR_TOKEN, which must differ fromCMCP_BEARER_TOKENand is required outsideCMCP_DEV_MODE=1(OPERATOR_TOKEN_REQUIRED). Where it is unset those routes still fall back to the bearer token, so an existing single-token deployment keeps working until it sets the new variable. -
Session close retained stdio children and per-session upstream caches. (
#625)rebind_session()rotated the audit chain and call logs but never calledaclose(), so the stdio child, pooled HTTP clients, and the provenance/drift-checked caches all survived a close and were reused by the next session - the exact cross-session contaminationdocs/spec/stdio-transport.mdnames as the reason children are scoped to one session rather than pooled. Close now serializes session transitions, drains admitted calls before signing, cleans up resources before rebinding, and preserves claim and resource ownership across retryable failures. Partial claim failures keep admission sealed and are reported for operator investigation. A failed cancellation drain also keeps admission sealed until a close retry can drain the remaining work. Graceful shutdown rejects new work and resource acquisition, drains active calls, and coordinates spawning with cleanup; an incomplete drain is reported as failure. Concurrent first-use stdio spawning is serialized to avoid creating an untracked second child. Cancellation during session hydration is finalized before signing; a failed terminal audit write prevents signing or rotating an incomplete claim.POST /sessions/{id}/resetretires a session id and opens a successor, so it leaked the same resources for the same reason; it now drains admitted calls and releases them before recording the boundary, which also leaves a failed reset retryable with the session untouched. A reset naming an already-rotated session is rejected before draining, so it cannot cancel the successor's in-flight calls. A child that fails to close is retained for retry; a pooled HTTP client that fails to close is dropped and logged instead, because anAsyncClientmarks itself closed and HTTPcore empties its pool before the streams are released, leaving nothing a retry could reach. A call arriving during a transition still waits for the successor, but the wait is bounded: a close that cannot resolve, such as one whose successor creation keeps failing, now answers callers with the reason instead of blocking them indefinitely.
-
A reference for confining an agent that already holds plaintext on native Linux (
docs/confinement.md,examples/confinement/, #659). The agent runs in a Docker container with no network, a read-only root filesystem and no automatic restart, and reaches tools only through a host bridge to the gateway. A separate host watchdog stops the container on EOF or a missed two-second heartbeat.tests/confinement/carries the bypass harness and validates the claims the confined gateway emits (#663). -
ExecutionRegistry, a standalone SQLite state machine for execution correlation (#565, #606). It is a foundation only: the gateway does not construct or admit through it, and no replay or exactly-once guarantee is provided in this release. Seedocs/spec/execution-correlation.md. -
Wire the configured session-state store into startup.
session_state_pathis accepted at config load, checked for a non-blank string and traversal, and opened as aSqliteSessionStateStorebefore the gateway starts. An unopenable path aborts startup withSESSION_STATE_STORE_UNAVAILABLE. Writes for the same session identifier use SQLite's cross-process transaction lock. Restarting the gateway or sharing the database does not restore the same logical session. Authenticated session resumption remains separate work in #653; this change only connects the existing store. Unset preserves the in-process default.
-
A
tools/callthat supplies_cmcp.execution_idis now refused withexecution_correlation_unavailablebefore discovery or invocation, and a malformed value (including explicit null) withexecution_invalid_execution_id. Omitting the field keeps the previous call path (#606). -
The reset audit entry now identifies the session boundary rather than only the sensitivity transition:
detailcarries the closed session identifier, the successor identifier, the resulting reset counter, and which credential was verified.detailis inside the canonical body, so those fields are covered by the entry hash. -
The audit chain no longer attributes post-reset entries to the closed session.
AuditChain.rotate_session_id()moves attribution to the successor after the boundary entry is written, so the reset entry belongs to the session that reached the recorded value and later entries belong to the successor. Previously every entry after a reset carried the closed session's identifier and the successor's identifier appeared nowhere in the chain. -
A reset now preserves the closed session's final state as a distinct
ClosedSessionRecordinstead of overwriting it, andPOST /sessions/{id}/resetreturnsclosed_session_max_sensitivityandreset_count.
0.5.0 - 2026-09-05
-
Cross-boundary compliance recording was dead for HIPAA PHI, PCI data and MNPI.
call_log._HIGH_SENSITIVITY_DOMAINS, which decides whether a call leaving a domain is recorded as a boundary crossing in the TRACE claim, was the literal{"pii", "phi", "pci", "restricted"}, while the catalog schema permitted{hipaa_phi, pci_data, mnpi, pii, internal, external, public}. The two overlapped onpiialone:phi,pciandrestrictedcould never appear as acompliance_domain, and the three most regulated domains the field can express never matched. A session that read HIPAA PHI and then called an external tool recorded no crossing. The set is now derived from a singleCOMPLIANCE_DOMAINSvocabulary besideSENSITIVITY_ORDER; the legacy spellings stay in it so no deployment regresses. -
Policy bundle hash now uses RFC 8785 (GHSA-wh6r-6j4v-p4p6).
docs/spec/cedar-policy.md§1 definescanonical_jsonas RFC 8785 and the implementation usedjson.dumps(sort_keys=True, ensure_ascii=True). The two agree for ASCII-only, integer-only bundles and diverge on non-ASCII strings and float-typed numbers, so an independent implementation following the spec could not reproduce this gateway's startup gate. Breaking for bundles carrying non-ASCII text or float-typed numbers: those change hash and need re-pinning. ASCII-only bundles are byte-identical. -
_redact_auth_headersis deny-by-default. It redacted onlyAuthorization, while the same request is configured withOPAQUE_API_KEY, so a deployment carrying it inx-api-keyor a cookie logged it in clear on the debug path. -
Least-privilege CI. All 24 third-party action references pin a commit SHA rather than a mutable tag, including the release-path steps that hold registry credentials, signing keys and
id-token: write. Four workflows gained a top-levelpermissions:floor, and four${{ }}interpolations moved out ofrun:blocks intoenv:.
-
cert-pinnedrotation mode is reachable.server.rotation_modehas always been read by the loader and used by the proxy, anddocs/spec/tool-identity.mddocuments"rotation_mode": "cert-pinned"as the catalog field an operator sets. The catalog schema declared theserverblockadditionalProperties: falseand never listed it, so a catalog following the documentation was rejected at load and every deployment ran the weakerkey-pinneddefault with no way to opt out. -
compliance_domainis deployment extensible. It was a closed seven-value enum, so a deployment with its own classification could not express it and the catalog would not load. Validation moves to load time against the built-in vocabulary plussensitivity.compliance_domainsin config, mirroring whatsensitivity_levelalready does since #479. A deployment adding a domain declares whether it is regulated. Additive only: a config key colliding with a built-in is rejected. -
rfc8785is a declared dependency rather than a transitive one.
- TLS pinning test fixtures set
minimum_version = TLSv1_2; the server was built withPROTOCOL_TLS_SERVERand no floor, leaving TLSv1 and TLSv1.1 reachable in the test that asserts the gateway's transport rules.
- Bind SNP, Azure CVM and TDX evidence to the claim's existing
trace.runtime.nonce(#595). These branches previously read areport_datafield forbidden by the runtime schema, passingNoneto an optional binding check. A valid report for a different key or audit root could therefore receive hardware-verification credit on the SNP and Azure paths. The verifier now requires the canonical 64-byte nonce and checks it against the report (or the AK-signed quote on Azure). TDX TDREPORT-only claims remain partially verified; this does not add DCAP quote collection or transport.
0.4.1 - 2026-09-02
Anyone running 0.4.0 should upgrade. On 0.4.0 verify_gateway_measurement() could return
verified=True for a correctly signed TPM2_NV_Certify pair that does not refer to cMCP's configured
TPM_NT_EXTEND object or its complete 32-byte range (GHSA-943q-hvhp-mrx2). The verifier compared the
two signed TPM Names only with each other and never against trusted verifier policy, so an accepted AK
could certify attacker-arranged values from an ordinary NV object and receive an authorization-grade
verdict. No signature forgery was required. Reported and fixed by
Noah Ingwers.
The appraisal API is intentionally breaking: callers that omit the full GatewayNvAppraisalPolicy now
fail closed.
-
TPM NV-certify wire parsing now delegates to Agent Manifest 0.11.2 instead of maintaining a second
TPMS_ATTEST/TPMS_NV_CERTIFY_INFOparser in cMCP. The publicparse_nv_certifyreturn shape andValueErrorcontract remain intact. The shared parser also makes cMCP accept valid size-prefixedTPM2B_ATTESTtransport framing, reject undeclared bytes afternvContents, and verify AK signatures over the canonical innerTPMS_ATTESTrather than over the transport length prefix. A genuine swtpm-produced two-certify reference pair exercises Agent Manifest's configured-root chain helper plus the signature, transcript, explicitly authorized test Name/range, and extend-relation path. The synthetic fixture CA is test trust only and makes no full-PKIX, hardware-provenance, or vendor-enrollment claim. -
Removed AGT/
agent_osfrom the production dependency graph. cMCP now owns the runtime call and response enforcement path; AGT remains isolated to CI and release governance verification. Legacyagent_os_versionbundle metadata is still readable but is no longer enforced.
-
Gateway NV appraisal accepted an evidence-selected NV object and certified range as the configured gateway measurement.
verify_gateway_measurementauthenticated the AK chain, both signatures, phase bindings, andpost = SHA256(pre || digest), but only required the two signed Names to equal each other. It did not compare either Name or signed offset/extent with trusted verifier policy, and a collector-claimed digest could produceverified=Truewhen no expected digest was supplied. An accepted AK could therefore certify attacker-arranged values from an ordinary or otherwise unapproved NV object and receive an authorization-grade verdict without proving use of cMCP's configuredTPM_NT_EXTENDpublic template.Appraisal now requires a complete
GatewayNvAppraisalPolicysupplied by the verifier: the exact signed TPM Name, offset zero, 32-byte extent, and expected gateway digest. Both attestations and the envelope copy must match that policy; digest-only legacy calls fail closed. The producer also validates the complete public area and TPM-returned Name before any read, extend, or certify; a newly defined object is checked in its unwritten state and again afterWRITTENis set. Unexpected existing objects are never silently redefined, and only an actualTPM_RC_NV_UNINITIALIZEDread maps to the initial zero value.The API change is intentionally breaking for callers that omitted the full policy. A genuine swtpm corpus covers the canonical production object, a correctly signed same-handle ordinary object with an arranged byte relation, and a correctly signed partial range. This fixes the standalone primitive; the startup pair is still not carried by the TRACE schema or appraised by
verify_trace_claim, so it is not an end-to-end runtime-claim guarantee.
CMCPProxy._client_for_upstream pooled every unpinned upstream server in a session behind one shared httpx.AsyncClient (#281). The pinned branch already keys its cached client on the fingerprint (a matching pin is the same verified peer, so sharing there is correct), but both unpinned branches plain http:// and the PLACEHOLDER_FINGERPRINT dev-mode pin collapsed to the single literal key "unpinned", regardless of which server the entry actually pointed at. A gateway session whose catalog lists two or more unrelated unpinned upstreams (the supported, if discouraged, dev/demo path this same method's docstring describes) got one httpx.AsyncClient for all of them: one cookie jar, and one shared pool of max_connections/max_keepalive_connections, across servers whose only thing in common was that neither presented a real pin.
POST /mcptools/call500'd on a non-stringname, and silently accepted a non-objectarguments._handle_tool_callreadtool_name: str = params.get("name", "").lower()andarguments: dict[str, Any] = params.get("arguments", {}): the.get(field, default)default only covers a genuinely absent field, so a caller-suppliednamethat is present but not a string (an int, a list, a bool,null) reached.lower()and raised an unhandledAttributeError, caught only by the outermost_unhandled_error_handlerand logged asUNHANDLED_EXCEPTION/INTERNAL_ERRORfor what is ordinary client input validation, not an internal failure.argumentshad the matching gap on the other side:_arg_shape_violation(the #518/#562 depth/key-count/string-length gate) only recognizesdict,listandstr, so a scalararguments(an int, for instance) silently returned "no violation" and reachedcall_toolwith a shape its own type annotation says cannot occur.
Both fields are exactly as caller-controlled as _cmcp a few lines below, already guarded with "A malformed _cmcp (string, list, number) must not 500 the call path" name and arguments were the two places that same reasoning wasn't applied. Both now return the same -32602 Invalid params JSON-RPC error the adjacent depth/key/string-length and non-dict-params checks already return, before call_tool is ever reached.
-
On SEV-SNP, TDX and Azure CVM the policy actually in force was committed to nothing (#552, follow-up to #432).
gateway_measurement()folds the installed code, the policy bundle and the effective configuration into one digest, and #432 extended it into aTPM_NT_EXTENDNV index and had the TPM certify it. That path is validated on real Azure Trusted Launch vTPM hardware, and it ran for thetpmprovider only:_measure_gatewayreturned early for every other provider.The stated reason was that "SEV-SNP and TDX commit their own binding through the report's fields". That is true and it is not equivalent. Those fields carry the launch measurement, which is fixed at boot and does not move when the Cedar bundle reloads mid-session through
PolicyEvaluator._maybe_reload(). So on exactly the platforms whose whole premise is hardware-rooted policy enforcement, nothing signed said which policy was running.No new commitment scheme was invented.
make_measurement_bound_nonce(tee_public_key, measurement_digest)puts the already-validated digest into the second half of the attestation nonce, in the same 64-byte layoutmake_audit_bound_noncealready uses:jwk_thumbprint(pubkey) (32) || measurement_digest (32).gateway_measurement().digestis a raw 32-byte SHA-256, so it drops in unreshaped and a verifier compares it against a digest it recomputes rather than against a hash of one. Thetpmprovider is deliberately not in that report-data set: it has a separate NV-extend/certify path whose evidence remains startup-scoped, is not refreshed on policy reload, and is not carried by ordinary TRACE claims.This replaces the 32 random salt bytes on those providers, and freshness survives the change for a reason worth stating rather than assuming: the gateway generates a new signing key on every start, so
report_data[:32]still differs between two starts of byte-identical code, policy and config.report_datacarries one value and no history, so a report built before a bundle reload still looks well-formed on its own, and nothing in it says whether it is current. The gateway now re-attests on every policy-bundle reload, including one that finds the bundle unchanged, wired fromPolicyEvaluator._maybe_reloadthrough a newon_reloadhook torefresh_measurement_binding. Re-signing an unchanged digest is not redundant: the same digest signed now and that digest signed an hour ago are different assertions, and only the latest report reaches a verifier. The cost is bounded bypolicy_reload_interval_secondsrather than by request rate, becausePolicyStore.reload_if_stalestamps its clock before the attempt, and it is zero in the default configuration where reloading is off.A refresh that cannot re-attest logs and keeps the previous report rather than refusing traffic: the stale binding no longer matches the recomputed digest, so a verifier rejects the claim, and failing closed here would trade a detectable weakness for an outage. That is the same trade AUDIT-006 already makes for a failed per-session attestation.
Recompute-and-compare is what catches a gateway that did not refresh, so it is now a check rather than a note in the spec.
verify_trace_claimgains an optionalexpected_gateway_measurement(raw 32 bytes, hex, orsha256:-prefixed) and aMEASUREMENT_NOT_BOUNDfailure reason. It is opt-in because the expected digest must be an out-of-band trust input likeApprovedHashes: a check that read it out of the claim would be asking the claim to vouch for itself. The digest is compared directly rather than re-hashed, which is the one way it differs from the AUDIT-006 check beside it.Known limit, stated rather than implied. The binding is on the gateway's startup report. A TRACE Claim for a session carries the per-session report when one was produced, and AUDIT-006 already commits the audit-chain root in the same
report_data[32:64]. So on the normal session path a verifier sees the chain-root commitment, not the measurement, and step 7c applies to claims that fall back to the startup report. Carrying both in one 64-byte field is not possible as the layout stands, and #552 explicitly scopes the audit-chain-root binding out, so this is left for the issue that takes that on.Behaviour change: an unmeasurable gateway on
sev-snp,tdxorazure-cvm-sev-snpis now fatal at startup in production, as it has been ontpmsince #432, because extending the measurement to a platform extends the consequence of not having one.CMCP_DEV_MODE=1still downgrades it to a warning, which is what an editable install with noRECORDmetadata needs.Not addressed here, per the issue: binding the audit-chain root, which is session activity rather than gateway identity and which AUDIT-006 already owns in the per-session report's
report_data[32:64], and validation on real SEV-SNP and TDX silicon. The contract lands with software-only proof: the round trip throughSoftwareOnlyProvidercomposes the nonce, takes the report, and has an independent recompute match both halves, with a stale pre-reload measurement correctly rejected. -
The public chained TPM quote verifier discarded the signature scheme and digest after parsing them (agent-manifest#320). Passing only the bare signature made the shared verifier apply its legacy RSASSA/SHA-256 defaults: a valid RSAPSS/SHA-384 quote failed, while false scheme or digest metadata was not authoritative.
verify_tpm_quote_chainednow forwards the completeParsedSignature; the existing Azure RSASSA/SHA-256 vector remains unchanged. This helper currently has no runtime caller, so the fix corrects the public API and its future reuse rather than changing today's TRACE claim-verification path. -
An approval record stopped verifying once its approvals expired (#533, follow-up to #531).
verify_catalog_changejudgedapproved_atandexpires_atagainsttime.time(), so a record that was valid when the catalog was approved became permanently unverifiable, and the chain #517 exists to let an auditor replay could not be replayed. That made the record an authorization token with a lifetime rather than a provenance record.The interval is now what it says it is: an assertion about when the signature could have been produced. The caller passes
validity_instant, a pinned checkpoint or transparency-receipt timestamp where it has one, and where it passes nothing each approval is judged at its ownapproved_at. Requiring a pin instead would mean an auditor cannot verify a record without also holding the pin, which is a worse default than the one it replaces. Thenowparameter is gone with the wall clock, andtimeis no longer imported.Revocation is unchanged and stays at verification time, with the reason stated in the code as well as the doc: whether a key was valid when it signed and whether it is revoked now are different questions, and they will read as the same check to whoever touches this next.
-
The catalog-approval schema shipped in the repository and nowhere else, so nothing validated against it (#533, follow-up to #531).
schemas/catalog-approval.schema.jsonwas added by #519 and never loaded:verify_catalog_changereimplemented structural validation by hand, the two drifted, and the schema was absent from[tool.hatch.build.targets.wheel.force-include]so an installed wheel did not carry it at all. #531 could only document one divergence, a negativeapproved_atthat the schema rejects and the verifier accepted, as a strict xfail.The schema is now the structural authority.
verify_catalog_changeloads it and validates the record before any other check, and refuses to verify when it is missing from the installation, exactly asloader.pyrefuses to load a catalog withoutcatalog-entry.schema.json. The hand-written checks that duplicated it are deleted rather than left unreachable: field presence and unknown members, digest shapes, integer and boolean types, string emptiness, and the signature alphabet. What stays in code is what JSON Schema cannot express, the runtime hash binding, the policy pin, reviewer identity and key rules, the validity interval ordering, and the signatures. The xfail is gone because the case now fails closed.The schema is force-included in the wheel alongside the catalog entry schema, and
scripts/verify_python_distribution.pychecks both resolve to a file inside the installed distribution, so a wheel that drops one fails the release smoke test rather than a verifier at runtime. A unit test asserts the force-include mapping, since that line is the only thing putting these files next to the code.previous_record_hashon the first record in a chain is the all-zero digest,sha256:followed by 64 zeros, stated in both the schema and the spec doc. It validated against the digest pattern before and meant nothing, which is the worst combination: representable and unspecified. -
cmcp verifycould not authenticate a TPM attestation-key certificate chain. The verifier library already required a caller-suppliedtrusted_tpm_ca_pem, but the CLI had no way to provide it, so otherwise complete TPM 2.0 evidence remained partially verified.--trusted-tpm-canow accepts a verifier-owned PEM certificate bundle, validates it before verification, and passes it only to the TPM trust input. It does not configure AMD SEV-SNP or Intel TDX trust anchors. -
A single trusted reviewer key could approve any catalog change, under any policy (#517, follow-up to #519).
verify_catalog_changereadthreshold,distinct_principals, anddistinct_rolesout of the record it was verifying, and checkedpolicy_hashfor digest shape only: never recomputed over the policy body, never compared to anything. A record declaringthreshold: 1with arbitrary bytes inpolicy_hashverified on one signature, so the M-of-N property the module advertises was unenforced. This is the failure the spec doc already forbids for keys, "no record-embedded key can bootstrap trust", applied to the policy instead. M is only meaningful when it comes from verifier-side configuration.expected_policy_hashandexpected_catalog_idare now required arguments. A record'spolicy_hashmust cover its own policy body, whichcompute_policy_hashdefines so that producers and verifiers agree on it, and must equal the policy the verifier was configured with. Neither can be defaulted without falling back to the record's own claim, so the signature change is deliberate; nothing calls this module yet.catalog_id,sequence, andprevious_catalog_hashwere format checked and then unused, so a record for a different catalog verified against this one.catalog_idis now always bound, andexpected_sequenceandexpected_previous_catalog_hashjoinexpected_previous_record_hashas optional checkpoints, optional because they must come from an external pin or transparency receipt. Distinctness now rejects repeats as each approval is read rather than counting distinct values afterwards, which had admitted alice, bob, alice at a threshold of two. String and integer fields are validated before use, so a non-hashableroleraisesCatalogApprovalErrorinstead of escaping asTypeError, boolean timestamps are rejected as the shipped schema already rejects them, and the signature is checked against the base64url alphabet and for a 64 byte decode, with the decode moved out of thetryblock that was reporting its errors as "signature is invalid".The distinctness rules did not close the property on their own, because nothing bound approvals to distinct keys. A threshold of three under a policy that does not require distinct principals was satisfied by one key signing the identical approval three times, and a threshold of two under a policy that does require distinct roles was satisfied by one key signing twice as two different roles, since a
TrustedReviewercarrying no role lets the record assert whichever role it likes. A reviewer key now counts once per record whatever the policy says: a repeated signature is one approval presented N times, not N approvals. The check runs after the principal and role rules so those keep reporting the more specific cause.The four tests that shipped with #519 passed whether or not any of these checks existed. The suite is now 31 tests, each guard verified by deleting it and confirming a test fails. One is xfailed on purpose: the schema sets a minimum of zero on the approval timestamps and the verifier does not, which is left failing until the schema-wiring decision lands.
-
The catalog-approval signing input was not the JCS it claims to be (#517).
canonical_jsonis documented as RFC 8785 compatible and serialized withensure_ascii=True, which is the one thing JCS does not do: it emits an ASCII escape where the standard emits UTF-8. Any record carrying a non-ASCIIprincipal_id,issuer,role,catalog_id, orpolicy_idwas signed over different bytes than a conforming producer signs, so a record produced anywhere but here failed with an invalid-signature error that points nowhere near the encoding.sort_keyswas the second divergence, ordering members by code point where JCS orders by UTF-16 code unit. The two disagree for any key outside the BMP, since a surrogate pair leads with0xD800and sorts below a BMP character above0xE000.Members are now ordered on their UTF-16BE bytes and the output is UTF-8. Values JCS cannot pin down are refused rather than serialized into a signing input that two implementations would read differently: floating point numbers, integers beyond
2**53 - 1, non-string keys, and unpaired surrogates, each asCatalogApprovalErrorrather than as an escapingUnicodeEncodeErrororTypeError. Approval records carry none of those, so refusing them only closes a door.ASCII-only records serialize to the same bytes as before, pinned by test, so nothing that verifies today stops verifying. #517 asks for JCS reuse precisely so a record can cross implementations, and nothing consumes these records at runtime yet, so the encoding is still free to correct.
-
catalog.drift_policywas unreachable from configuration (#523). The parser defined the setting, but strict top-level validation rejected everycatalog:block before it could be read. The block and its only supported key are now explicitly allowlisted;fail_closedremains the default, and misspelled nested keys fail closed. -
cMCP could not verify a v0.2 Agent Manifest at all (agent-manifest#315, phase 4 of agent-manifest#243). The pin moved to
agent-manifest>=0.11, which carries the COSE verifier, and nothing here ever presented a v0.2 manifest to it. It could not have worked:load_agent_manifestread JSON and_verify_with_sdkpassed a dict, and from v0.2 the COSE_Sign1 structure is the signature (ADR-0011), so a v0.2 document handed over as a dict has nothing to appraise. The SDK correctly reported a missing signature, and an operator would have read that as a malformed manifest rather than a manifest supplied in the wrong form.load_agent_manifest_document()now returns the decoded document alongside the envelope bytes it arrived in, and the envelope is what reachesverify_manifestwhen there is one. The file is sniffed rather than switched on its extension: a COSE envelope is CBOR and never parses as JSON, so trying JSON first is unambiguous and an operator does not have to name the file correctly for the gateway to read it. A v0.2 payload supplied as bare JSON is now named as such.load_agent_manifest()keeps its dict-returning signature for callers that only read identity fields. -
TDX read both of the fields it attests from the wrong offsets, and enforced neither (#371).
REPORTDATAwas read at0x08, inside REPORTMACSTRUCT's leading RESERVED block, and a mismatch was advisory: the binding between the report and the confirmation key was neither checked in the right place nor enforced where it was checked.MRTDwas read at0x90, which is insideREPORTMACSTRUCT.report_data, the 64 bytes the guest itself supplies. The producer wrote the nonce there and then hashed 48 bytes of it back out as the "TD measurement", so two attestations of the same TD with different nonces produced different measurements. A measurement that moves with the nonce is not a measurement.Both offsets now come from
cmcp_runtime.tee.tdreport, one ctypes definition of TDREPORT_STRUCT imported by the producer and the verifier, with the ABI offsets asserted at import:REPORTDATAat0x80,MRTDat0x210. Producer and verifier having their own copies is how two wrong offsets agreed with each other for this long. Areport_datamismatch is now fatal on TDX, matching the SEV-SNP rule from #390. -
A TDX claim could be reported as fully
verifiedwith the quote signature unverified (#370).LIMITATIONS.mdalready said a claim whose report signature or chain is unverified stayspartially_verifiedand is never presented as hardware-backed. That was true of SEV-SNP, which #390 gated on the VCEK chain, and not of TDX, where a TDREPORT alone was enough. A TDREPORT is an unsigned buffer the host could have written. TDX is now gated ondcap_quote_signatureexactly as SNP is gated onvcek_cert_chain, so the documentation and the code agree. -
initializeanswered every handshake with a revision that has noinitialize(#509). Third on the to-do list in #496 was "stop hardcoding the downstream protocol version", and #509 did it by replacing the hardcoded2024-11-05in theinitializeresult withPROTOCOL_VERSION. That constant is2026-07-28: the revision that removed the handshake. So the gateway answered everyinitializeby naming a protocol in which the request just made does not exist, and in which each later request must carry_metaplus the mirroredMCP-Protocol-Version/Mcp-Methodheaders a handshake-era client has no way to know it should send. Confirmed against every revision a real client offers: asked2025-06-18,2025-03-26or2024-11-05, the gateway answered2026-07-28in all three cases.The direction of the swap is the whole defect.
PROTOCOL_VERSIONis correct on the outbound leg, where the gateway is the client and #509 got it right; it is wrong on the inbound one, where reachinginitializeat all is proof the caller is handshake-era.initializenow negotiates over_LEGACY_PROTOCOL_VERSIONSonly, echoing the client's request when the gateway speaks it and otherwise answering with the newest handshake-era revision. A client that asks for2026-07-28at a handshake is deliberately not humoured: it cannot be speaking a revision with no handshake, so confirming it would agree on a protocol neither side is using.server.pyno longer importsPROTOCOL_VERSION; #509 introduced that import solely for this misuse.That set now leads with
2025-11-25, the newest revision that still definesinitialize. It had been omitted, so a client offering the latest handshake revision was answered2025-06-18instead. The lifecycle spec requires a server to echo a version it supports and says a client that does not support the server's answer SHOULD disconnect, which makes a needless downgrade the same class of defect as the one above, one revision over.Non-object
initializeparams are now rejected with-32600rather than treated as an empty object.InitializeRequestParamsis an object with required members, so answering a malformed handshake with a successful negotiation blessed a validation gap. This matches how #500 already rejects non-objecttools/callparams. Absentparamsremains legal and negotiates the newest revision.tests/unit/test_initialize_protocol_version.pypins the negotiation and asserts the outbound constant is untouched. Verified by mutation: reverting only theinitializeline while keeping the new constant fails 9 of its 10 tests.
- The MCP ingress now rejects non-object JSON-RPC messages, non-string methods, and non-object
tools/callparameters with a boundedMCP_INVALID_REQUESTresponse. Structurally invalid attacker input no longer reaches attribute errors, HTTP 500 responses, or exception trace logging. - The unauthenticated health/readiness rate limiter now expires inactive source-address entries and caps tracked clients at 10,000. Source-address churn can no longer grow the in-memory limiter map for the lifetime of the gateway.
- Upstream stdio children and provenance verdicts are now cached by complete execution and trust identity rather than the non-unique human-readable
display_name. Distinct catalog servers sharing a label can no longer reuse another server's process or provenance result. - Built wheels now include the catalog-entry JSON Schema, and catalog loading fails closed if that schema is absent or unreadable. Previously source-tree tests validated catalog structure, but installed wheels omitted the schema and silently skipped that validation.
- PyPI publication now installs and smoke-tests the exact wheel and source distribution before upload, including release-tag/version agreement, import provenance, runtime configuration, and the packaged CLI.
- The runtime container now uses a patch-pinned Python slim base, builds a non-editable production wheelhouse in a separate stage, excludes development dependencies and build tooling from the final image, and runs as an unprivileged numeric UID/GID.
-
STATUS.mdunderstated the attestation default in two ways. It gave the probe order astpm -> sev-snp -> tdx, missingazure-cvm, which is probed first and exists precisely so an Azure confidential VM is not mistaken for a plain TPM host. And it said nothing about what happens when no hardware is found, which is the question an evaluator is actually asking.The answer is better than the omission implied and is now stated: auto never degrades to software. With no hardware detected the gateway refuses to start unless
CMCP_DEV_MODE=1, andprovider: software-onlyrequires that flag as well, so a software-mode gateway is always a deployment that asked for one rather than a silent downgrade.tests/unit/test_tee.pypins both, including that settingCMCP_DEV_MODEin the environment after config load does not bypass it.Documentation only. No behaviour changed; the behaviour was already correct and the defaults table was selling it short.
-
Configurable sensitivity vocabulary (#479). The six built in sensitivity labels (
public,pii,confidential,hipaa_phi,mnpi,trade_secret) were the only ones a catalog entry could ever declare, so a regulated deployment whose own scheme names a tier abovetrade_secret, an Open/Confidential/Secret/Top Secret ladder for example, had no way to catalogue it truthfully.sensitivity.vocabularyin config now lets a deployment add new labels at any rank. It is additive only and enforced at two layers: config parsing rejects a vocabulary key that names a built in label outright, andsession/state.py'seffective_sensitivity_order()merges the built in table in last regardless, so a built in name can never be shadowed even by a bug elsewhere in the chain. That guarantee is not cosmetic: response inspection's content pattern detectors emit the built in tagspiiandhipaa_phidirectly when they spot an SSN, an email, a diagnosis code and so on, and if either name had silently dropped out of the effective vocabulary those detections would have ranked at 0, the same fail open hole #478 closed for the catalog schema.SessionManagerandPolicyEvaluatoreach derive the effective vocabulary once from the sameConfig, so a session'smax_sensitivitystring and thesensitivity_levelinteger Cedar evaluates can never disagree about what a custom label ranks as. The catalog schema'ssensitivity_levelenum moved from the static JSON schema into a Python level check at load time against this same effective set, so the vocabulary stays closed, just not hardcoded.Per call classification, letting a single call declare a class narrower than its tool's catalogued default, is the second half of #479 and is left for a follow up change.
-
Per call sensitivity classification (#479). One catalogued tool can serve many classes of data, a model call tool catalogued at
piimight, on a specific call, actually carryconfidentialdata (agentrust-io/demos#36 is the motivating example). The signed transcript could only ever show the tool's single catalogued value, and the session's own sensitivity tracking never rose past what the catalog alone said either, an enforcement gap for later calls in the session, not only a record keeping one.A call may now declare a class for itself via
_cmcp.data_classon the request. It composes with the vocabulary work above: a deployment adds a label in config, a call declares it per call. The declared value needs no separate validation,_max_sensitivityalready is the validator: it returns whichever of two labels ranks higher and ties favour the catalog value, so an unrecognised or lower declared value is harmless by construction, and a legitimately higher one raises both the session'smax_sensitivityand, independently, that specific call's own row in the signed transcript, without inheriting whatever the session had already accumulated from earlier calls.AuditEntrygained one new field,effective_data_class,Noneon every call that never declares one, so nothing changes for a caller that does not use_cmcp.data_class. -
Server provenance checking (step 3). The gateway consumes
server-provenance-v1records viaagentrust-trace>=0.8: it verifies the record against a configured publisher key, then compares the record's tool-catalog hash against the tools the server advertises to this gateway.It never falls back to the catalog's own approved definitions for that comparison. Comparing a record against our approval instead of against the server is the substitution that turns the whole check into theatre.
Five outcomes reach the audit chain and none is silent.
verified;catalog-mismatch, which means the document is fine and the server is not;invalid;unchecked, which means the record verified but the tool list was unavailable so the comparison that catches a substituted server never ran; andabsent.uncheckedexists because reporting a signature check alone asverifiedis a document checking itself.Absence is recorded and non-fatal by default. Almost no MCP server has a record, and a gateway that refuses to route without one is a gateway that gets turned off on first contact and never turned back on.
attestation.required_provenance_kindsets a floor per deployment; acatalog-mismatchsatisfies no floor, including the weakest.A record with no configured publisher key is
invalid, notverified: the key embedded in a record cannot be used to check that record, because a forgery supplies its own.
-
stdio transport: the gateway spawns the MCP server as its own child, inside the enclave (#484).
docs/spec/transport.mdruled stdio out and rejected two bridging options, correctly, because both put a translating component outside the TEE where it can inject or suppress calls before the gateway sees them. Both options assumed the agent spawns the server. It does not: that same document states the agent reaches only the gateway and that the runtime catalog is authoritative. So the child is a child of a process already inside the enclave, and nothing crosses the boundary that does not cross it today.This buys a binding no network upstream can have. The gateway chooses when to
exec, so it digests the entrypoint first and refuses to spawn on a mismatch. A pinned TLS fingerprint identifies an endpoint; a verified digest identifies code.And it costs something, which is in the spec rather than the footnotes. The server then runs in the same isolation domain as the policy evaluator and the audit chain, and the gateway's launch measurement does not cover a process spawned later. The child's digest is therefore reported as its own evidence class,
spawn-measuredorspawn-unmeasured, never folded intohardware_attestation.Defaults:
attestation.allow_unmeasured_spawnisfalse, so a server the catalog does not pin is not spawned at all. Turning it on does not make the spawn silent; every such call is recorded asspawn-unmeasured.Two design corrections came out of writing the tests. Pinning the executable is nearly useless for an interpreted server — the executable is the interpreter, so every Python MCP server on a host shares one digest and the pin would match a completely different server;
measure_targetpins the entrypoint instead. And executable and readable are different properties: a Windows Store Python is an App Execution Alias that runs fine and cannot be opened for reading, so an unmeasurable target is a refusal with an explanation rather than a crash.Framing errors are fatal by design. A child that logs to stdout has desynchronized the JSON-RPC stream, and skipping to the next parsable line means guessing which bytes answered which call; a response whose id does not match its request is fatal for the same reason. stderr never enters the audit chain, because diagnostics carry payloads and the chain is meant to be shareable: content goes to the logger, only the byte count is exposed.
The catalog schema conditions its requirements on transport rather than relaxing them, so a network transport still requires
urlandtls_fingerprintwhile stdio requiresspawn.
-
The AIA chain walk for a TPM attestation key had no margin above the one depth it was measured against (#514).
TPMProvider._chain_from_leafstops walking the certificate chain at_AIA_MAX_DEPTH, and that constant was4, exactly the length of the one real Azure hierarchy measured so far: leaf, Azure Cloud Virtual TPM CA - 11, Azure Cloud Virtual TPM CA 2025, root. Split out of #453, whose own investigation found a second real hierarchy,Global Virtual TPM CA - 03, that reaches the same root in only 3 certificates. Two different depths already exist on real fleet hardware, so a cap sized to match one of them exactly leaves zero room for a future or differently configured hierarchy that needs one more hop: the walk would stop one certificate short of the root, and the resulting chain would ship without it.Not a loop logic bug: the walk correctly builds any chain up to the cap, including one where the root arrives on the last allowed certificate. The cap is now
6, two hops above the deeper of the two known depths rather than matching either exactly, and the walk logs a warning when it stops without reaching a self signed root, so a future truncation is visible in the logs immediately rather than only surfacing later as a chain verification failure that looks identical to a chain that legitimately reaches an untrusted root.
0.4.0 - 2026-08-08
Anyone running 0.3.0 should upgrade. On 0.3.0 a forged TPM quote was reported as hardware-attested: the tpm2 branch of verify_trace_claim called only verify_tpm_measurement, which takes no signature parameter, so a TPMS_ATTEST with the correct magic and matching qualifying_data passed with no signature and no certificate chain (#370). The authenticated path existed and was tested; nothing in production called it. This release makes the quote signature and the AK certificate chain the gate on hardware_attestation, so evidence that does not chain to a pinned root can no longer report as verified.
-
BREAKING for verifiers: claims now carry
gateway.attestation_evidence(#469, #370). Signed platform evidence (raw_evidence,quote_signature,cert_chain,ek_cert_chain) travels inside the claim so the verifier has something to check the TPM quote against. It could not live undertrace.runtime, because agentrust-trace'sRuntimeInfoisextra="forbid"and rejected the claim asCLAIM_MALFORMEDbefore the platform branch ran, which is precisely what kept the chain verifiers unreachable.The break is one-directional, and only for verifiers:
result this verifier reading an older claim with no evidence fine, the fields are optional and trace.runtimeis still read as a fallbacka verifier older than 0.4.0 reading a claim from this gateway CLAIM_MALFORMEDongateway.attestation_evidenceGatewayAddendaandRuntimeClaimare bothextra="forbid", so any additive field anywhere in the claim is rejected by a verifier built before it, andverify_trace_claimnever readscmcp_version. There is no negotiation path, so "evidence travels with the claim" and "older verifiers keep working" cannot both hold. Evidence transport won, since without it the TPM quote is unauthenticated. Anyone verifying claims from a 0.4.0 gateway must upgradecmcp-runtimeto 0.4.0, which is what shipscmcp_verify. Claims with no evidence serialize byte-identically to 0.3.0, so software-only deployments are unaffected.Minor rather than patch under SemVer: the wire format gained a field that older readers reject.
Five changes below the headline TPM fix, each one a case where cMCP reported more assurance than it held. Collected here rather than scattered through Fixed, because an operator deciding whether to upgrade should be able to read them in one place.
-
Tokenless development mode may now only bind a loopback address.
CMCP_DEV_MODE=1skips the bearer-token requirement, and the defaultlisten_addris0.0.0.0:8443, so the documented quickstart stood up an unauthenticated gateway on every interface of the host. Configuration is now refused unless the bind is loopback orCMCP_BEARER_TOKENis set. The default bind is unchanged; what changed is that the unsafe combination no longer starts. -
A claim is no longer issued when the per-session TEE attestation call fails (#426).
close_sessionfell back to the shared startup report and signed a claim anyway. That report carries no chain-root commitment, so a strict verifier rejects it, but the runtime handed it out as if nothing were wrong. On a hardware platform this now raisesTeeFaultinstead of issuing an unbound claim. Software-only dev mode keeps the previous fallback, where the binding was already best-effort. -
Unsigned PCR reads were labelled hardware-attested (#441). A PCR read carries no signature and nothing binds it to a TPM, but the provider still reported
provider=tpmwhen the quote failed, and the subprocess path never produces a quote at all. Both cases now downgrade to software-only with the notetpm-pcr-read-unsigned. Related: a PCR hex-parsing defect that corrupted the measurement itself (#437). -
SNP
report_datamismatch is now fatal (#371, #390), since that field carries the confirmation-key binding and the freshness nonce, and the dispatcher no longer reportshardware_attestationas verified while the VCEK chain is unverified (#370, #372); such a claim staysPARTIALLY_VERIFIED. Same defect class as the TPM headline, on the AMD path, fixed first. -
TCG event logs are replayed against the reported PCR values (#443), so a log that does not reproduce the quoted digests is detected rather than trusted as narrative.
-
gateway.agent_identity.agent_key_thumbprintscaffold (#425). SAGE (via l33tdawg, agentrust-io/.github discussion #15) wanted an offline check that a downstream signature came from the agent a TRACE Claim describes. Investigating turned up that the issue's own premise did not hold:AgentManifestBindingcarries no agent public key anywhere, andsubject_sourceis a static config value today, not a live-authenticated credential (svidis a valid value but nothing produces it). So there was no key material anywhere in the runtime to hash.Landed as a nullable, additive field instead:
agent_key_thumbprint(RFC 7638 JWK thumbprint,sha256:<hex>) onAgentIdentityInfo/AgentIdentityOut, alwaysNonetoday since no code path supplies agent key bytes. The real, non-speculative piece is on the verifier side:cmcp_verify.verify_trace_claimnow fails closed (AGENT_KEY_THUMBPRINT_UNBOUND_SUBJECT) on any claim that carries the field whilesubject_sourceis not live-authenticated, so a future producer cannot launder a config-supplied identity into something that looks like a hardware-attested key binding.Populating the field for real needs either an
agent_manifest_sdkschema change carrying the agent's public key, or a live mTLS/challenge-response credential wired intoAgentManifestBinding- both explicitly out of scope here, tracked in the issue thread.
-
TPM2_NV_Certifycould never have worked as shipped in #459 (hardware, 2026-08-01). Two defects, both found by running it against a real Azure Trusted Launch vTPM and neither catchable by the unit tests as written:ESAPI.nv_certifytakesin_scheme(aTPMT_SIG_SCHEME) andsizeas required positional arguments. The shipped call omitted both, so it raisedTypeErrorbefore the TPM was ever reached. The fake in the unit tests accepted any signature, so the tests passed against code that could not run.- A freshly defined
TPM_NT_EXTENDindex is uninitialised, andTPM2_NV_Certifyon it fails withTPM_RC_NV_UNINITIALIZED. On a first gateway start there was therefore no pre-value to certify. Fixed by seeding the index once at provision time, which keeps the verifier'spost == H(pre || digest)check free of a first-boot special case.
The fake now enforces both constraints, so each defect has a regression test that fails without its fix (verified by mutation).
What the run then established: the platform AK at
0x81000003can sign an NV certify, which was an open question for a restricted signing key;parse_nv_certify's field offsets are correct against a real blob, which was the highest-risk item since they came from the TCG spec and had never met real bytes; the extend relation holds across two consecutive starts with run 2'spreequal to run 1'spost; andverify_gateway_measurementpasses all seven steps while rejecting a wrong digest and a replayed nonce on genuine evidence. The chain was anchored on the leaf because that host presented the no-AIA hierarchy, so key provenance remains unproven on Azure (#453).
-
The gateway measurement is now signed evidence (#432, second half). The NV index value previously travelled as an ordinary NV read that no signature covers, so it was a local integrity control: a compromised gateway could report any value.
certify_and_extend_gateway_measurementnow certifies the index, extends it, and certifies again, giving two TPM-signed values.cmcp_verify.nv_certify.verify_gateway_measurementappraises the pair, checkingpost == H(pre || expected_gateway_digest)with nothing collector-asserted and no verifier-side state.Two certifies rather than one because
TPM2_NV_Certifysigns only the index's current value and cannot attest to a previous one, while extends accumulate across reboots so there is no absolute value a verifier could expect. The two calls commit different qualifying data (pre/post) so each blob's role is signed rather than inferred from position. The shortcut that looks equivalent and is not: reading the index and committing the result into a quote's qualifying data means the collector asserts the value it read, and a compromised gateway is the adversary.Only the platform attestation key certifies. A transient key would produce a verifiable signature with no provenance, which is worse than an honest absence because it looks like evidence, so a platform without a certified key falls back to the unsigned extend and ships no evidence at all.
TPMProvider.platform_attestation_keyexposes that distinction explicitly instead of leaving callers to read a transient-key side channel.agent_manifest.verify_tpm_quotecannot appraise an NV certify: it rejects any attest type that is notTPM_ST_ATTEST_QUOTE, and its parser assumes aTPML_PCR_SELECTIONunion. The certificate chain is still delegated toagent_manifest.verify_cert_chain; only theTPM_ST_ATTEST_NVandTPMT_SIGNATUREwire formats are local, tracked upstream as agentrust-io/agent-manifest#255.
- Startup generates the signing key before measuring the gateway. The measurement's certify calls commit the attestation nonce, which is derived from that key, so the key now comes first. It has no dependencies of its own, so this is ordering only and not a behaviour change. The documented sequence in
run_startupis updated: detect provider, signing key and nonce, measure and certify, produce the report. mypy srcis clean for the first time. The five pre-existing errors incmcp_verify/tpm.pywere atype[HashAlgorithm]inference that madehash_cls()read as instantiating the abstract base; typing the lookup as a factory fixes it, andpadding.PSS.DIGEST_LENGTHreplaceshash_cls.digest_sizefor the same salt length with a correct type.
- The Azure vTPM certificate hierarchy is fleet variance, not a migration (hardware, 2026-08-01).
docs/testing/hardware-validation.mdrecorded on 2026-07-31 that "Azure has changed its vTPM PKI", after finding the AK certificate at NV0x01C101D0issued byAzure Cloud Virtual TPM CA - 11with a walkable AIA chain, superseding an earlier no-AIA observation. A VM provisioned 2026-08-01 (Standard_D2s_v7, eastus2) presented the older form again: 994 bytes, issued byGlobal Virtual TPM CA - 03, no AIA extension at all, andtpm2_getcap handles-nv-indexconfirmed no intermediates stored in NV as a fallback. Both hierarchies are live concurrently, so the planning assumption must be that a host may present either and AIA cannot be relied on. The practical consequence, now stated in the doc and incmcp_verify/tpm_roots.py: pinning the 2023 root does not make Azure verify everywhere, and chained verification is impossible on a host presenting the no-AIA hierarchy. This is worth re-reading against #431, which was closed on the basis that chains ship with the evidence.
-
Hardware validation for the gateway measurement NV extend index (#432, #451). The TPM calls in
cmcp_runtime.tee.measurementwere written against the documented tpm2-pytss API without ever executing against a TPM. All of them work on a real Azure Trusted Launch vTPM:nv_define_spacewithTPMA_NV.parse(...) | (TPM2_NT.EXTEND << 4)created a genuine extend index (TPM_NT = 4read back from the public area),nv_extendaccumulated asH(old || data)across calls, an existing index was reused rather than redefined, and a plainnv_writeto the index was refused by the TPM, which is the check the tamper-evidence argument actually rests on. Recorded indocs/testing/hardware-validation.md. -
The gateway is now measured into a TPM NV extend index at startup (#432). PCRs 0 through 7 cover firmware, option ROMs, boot configuration, and the bootloader, and there was no
PCR_Extendanywhere in the codebase, so replacing the policy bundle or the gateway itself produced an identical measurement and the TPM authenticated no commitment to the thing the TPM path exists to measure.cmcp_runtime.tee.measurementdigests the installed distributions' recorded per-file hashes (pip'sRECORD), the policy bundle bytes, and the resolved configuration with secrets excluded, then extends that digest into NV0x01500432before the gateway serves traffic.RuntimeContextcarries the result.An NV index with
TPM_NT_EXTENDrather than an application PCR, per the decision on #432: PCR 23 and PCR 16 are both resettable from locality 0, so an adversary with local code execution could reset and re-extend a chosen value, which is exactly the adversary this tier addresses. Extend writes are one-way (new = H(old || data)), so forgery needs a preimage, which is what carries the security argument rather than the write policy the original proposal called for.Scope is deliberately honest about two things. Measuring dependencies means an editable install, which has no
RECORD, cannot be measured: that is fatal in production and a warning underCMCP_DEV_MODE, rather than a confident digest over an unknown subset of code. And because extends accumulate across reboots, the index is a hash chain over every start rather than a predictable absolute value, so the collector reports the value both before and after the extend and continuity is what a relying party checks.
- RFC section 5 P2 (
docs/spec/tpm-security-model.md) rewritten to record the NV-extend decision instead of leading with the application PCR it rejected, along with the residual-risk analysis:TPM2_NV_UndefineSpacewith owner auth can erase the measurement, which guest root holds on Azure, so the property is tamper-evident rather than tamper-proof. Section 4.3 now separates what landed from what has not: the index value travels as an ordinary NV read, which the quote signature does not cover, so it is a local integrity control and not yet remote-verifiable evidence.TPM2_NV_Certifyis the primitive that closes it; committing an NV read into the quote's qualifying data is not sound, because the collector would be asserting the value it read.
- BREAKING: TRACE Claims now carry the v0.2 profile
tag:agentrust-io.com,2026:trace-v0.2, andagentrust-traceis pinned to>=0.5. The v0.1 URI namedagentrust.io, a domain this project never controlled, which RFC 4151 does not permit for a tag URI (agentrust-io/trace-spec#107). A verifier on the v0.2 suite rejects a v0.1 claim, so producers and verifiers move together. Nothing else about the claim format changed.
- Moved every
agentrust.ioidentifier toagentrust-io.com: the JSON Schema$idvalues fortrace-claim,audit-entry, andcatalog-entry, the@contextURL in test fixtures, and the maintainer email.agentrust.iois not ours and resolves to parked AWS addresses, so these identifiers pointed at a domain we do not control. They never resolved, so nothing that worked stops working. Thetag:agentrust-io.com,2026:trace-v0.2EAT profile identifier is deliberately unchanged; it is a cross-repo identifier inside signed payloads and needs a transition decision, not a rename.
- README no longer claims hardware attestation unconditionally. "Each session produces a signed, hardware-attested TRACE Claim" contradicted the TL;DR two paragraphs below it, which tells you to
pip install cmcp-runtimeand start in software mode with no hardware. It now reads "hardware-attested when the gateway runs in a TEE and signed-only in software mode", which is what the runtime actually does.
- Raised the
agent-manifestfloor to>=0.6.1and made an unappraisable manifest fail closed with a diagnostic message.verify_agent_manifest_bindingruns the SDK verifier over a peer-supplied manifest, and before 0.6.1 a manifest declaringML-DSA-65orhybrid-Ed25519-ML-DSA-65crashed the SDK with an uncaughtRuntimeErroron any install without the optional[pq]extra, so this path answered a crash instead of a rejection. The SDK now returnsUNVERIFIABLE, which cMCP already rejects; theUNVERIFIABLEmessage now distinguishes "could not be verified" (missing trusted key or unavailable algorithm) from "verification failed" (a bad signature) and surfaces the verifier's own reason, because those call for different operator responses. - The TDX verifier rejected every genuine DCAP v4 quote. Real quotes nest the Quoting Enclave material: the bytes after the attestation key are a certification-data header of type 6 (
QE_REPORT_CERTIFICATION_DATA) wrapping the QE report, its PCK signature, the auth data and the type-5 PCK chain.parse_td_quoteread the QE report directly after the attestation key, six bytes early, so a real GCP C3 quote failed withattestation_key_not_bound_to_qe. The synthetic test fixture emitted the same flat layout, so CI validated the defect. Failure was closed, so this was a false negative rather than an unsound accept, but the TDX path had never worked against real evidence. The parser now handles the nested layout, the fixture builds the real shape, and a new test rejects the flat layout outright.
- Real-hardware validation for SEV-SNP and TDX, recorded in
docs/testing/hardware-validation.md.cmcp_verifynow verifies a genuine Azure CVM SEV-SNP report (VCEK chain to the AMD ARK-Milan root, ECDSA-P384 report signature, paravisorREPORT_DATAbinding) and a genuine GCP C3 Intel TDX DCAP v4 quote (PCK chain to the pinned Intel SGX Root CA, QE binding, quote signature) end to end. Both are env-gated (CMCP_AZURE_FIXTURE_DIR,CMCP_TDX_FIXTURE_DIR) because the evidence embeds per-CPU identifiers and cannot be committed.test_real_tdx_quote_agrees_with_agent_manifestpins cMCP's verdict to the shared verifier so the two cannot drift apart silently. STATUS and ROADMAP now say which platforms have been validated against real evidence and which have not (TPM has not).
- Attestation crypto now delegates to agent-manifest's shared verification library (
agent-manifest>=0.5) instead of cMCP's own copies: the SEV-SNP report signature (verify_snp_signature) and the VCEK/PCK certificate-chain verification (the genericverify_cert_chain) are shared across the org rather than duplicated. cMCP keeps its own DCAP quote parser,*VerificationResultshapes, TR-field semantics, and report_data/qualifying-data bindings; behavior is unchanged (all tests pass unchanged). cMCP's TPM verifier stays local (Phase-1 parse-only: no AK signature/chain to share).
- Azure confidential-VM attestation (
cmcp_runtime.tee.azure_cvm.AzureCVMProvider+cmcp_verify.azure_cvm), hardware-validated on live Azure SEV-SNP silicon. Azure runs SNP behind a Hyper-V paravisor with no/dev/sev-guest; the SNP report is read from the vTPM NV index0x01400001and the guest cannot controlREPORT_DATA(the paravisor binds the vTPM AK there). cMCP's nonce (jwk_thumbprint || audit-root) is therefore committed into an AK-signed TPM quote's qualifying data, with the AK rooted in silicon via the SNP report (REPORT_DATA == sha256(runtime_data)) and the VCEK→ASK→ARK chain (reusingcmcp_verify.sev_snp). Auto-detected first (before TPM/SEV-SNP) since Azure exposes no/dev/sev-guest. Carries its ownruntime.platformvalueazure-cvm-sev-snp(requiresagentrust-trace>=0.4) so a consumer keying onruntime.platformknows the root of trust is vTPM-rooted, not a guest-controlled SNPreport_data. tool_transcript.entries: privacy-preserving per-call view in the TRACE Claim (one entry per tool call withtool_name,data_classfrom the catalog, and the policydecision), derived from the audit chain so no raw parameters or response bodies are exposed.tool_transcript.hashcontinues to bind the full transcript to the audit-chain tip. Addstranscript_entries_hash()for offline recomputation. (#126)
- Bare-metal
SEVSNPProvidernow obtains the SNP report via the kernel configfs-TSM interface (/sys/kernel/config/tsm/report) instead of a/dev/sev-guestioctl. The previous ioctl number and inline request ABI were incorrect and failed on real hardware withENOTTY("inappropriate ioctl for device"). Hardware-validated on a non-paravisor SEV-SNP guest (GCP N2D, AMD Milan): the guest-supplied nonce lands in the report'sREPORT_DATAand the report verifies against the AMD VCEK. - SNP report-version check in
cmcp_verify.sev_snpnow accepts version>= 2(was(2, 3)only). Real Milan hardware emits report version 5, which the old allowlist wrongly rejected asinvalid_snp_report_version; the field offsets read are layout-stable across v2..v5 and the VCEK signature is the real gate.
0.3.0 - 2026-06-30
- Software-only (non-hardware-backed) claims now return
partially_verifiedinstead ofverified(fail-closed); a real verification failure is never downgraded. - An external-execution receipt whose
linked_call_iddoes not match the entry is no longer reported signature-valid (short-circuits).
0.2.0 - 2026-06-12
- Bearer-token auth (
Authorization: Bearer) wired into the live gateway server - Upstream MCP forwarding: AGT pre-call interception, JSON-RPC forward to the attested catalog server, response size guard, injection/credential/PII response scanning
- Durable SQLite audit store (WAL mode, synchronous) with TEE-anchored hash chains and orphaned-session detection
POST /sessions/{id}/closeissues the signed TRACE Trust Record and rotates the session- Cedar
@annotationmetadata returned as structured advice on deny decisions (HITL payloads) cmcp-verify: one-command verification of claims and signed audit bundles, tamper-evident- Fail-closed hardware verifiers (TPM, SEV-SNP, TDX, OPAQUE): no attestation evidence means no verification
- Dev-mode records carry
platform: software-only, nevertpm2(requiresagentrust-trace>=0.1.1) - Silent mode contract: operational logs quiet, audit evidence always recorded
0.1.0 - 2026-06-09
- Initial TEE gateway with provider support for TPM, SEV-SNP, TDX, and OPAQUE
- Cedar policy enforcement for request authorization at the gateway layer
- TRACE Claim generation using the
GatewayClaimenvelope fromagentrust-trace cmcp-verifystandalone verifier for validating TRACE Claims offline- Audit chain with Ed25519 signing for tamper-evident log integrity