| Internet-Draft | OHMP and OHMP-TL | November 2026 |
| King | Expires 20 May 2027 | [Page] |
This document specifies the OpenHTTPA Hierarchical Measurement Protocol (OHMP), a distributed, zero-trust attestation protocol operating over the OpenHTTPA transport layer. OHMP replaces static, manually pinned measurement configurations with a hierarchy of hardware-backed Trusted Execution Environment (TEE) Measurement Authorities. To ensure split-view resistance and cryptographic accountability, OHMP integrates OHMP-TL, an append-only binary Merkle Transparency Log requiring M-of-N multi-cloud threshold signatures.¶
This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.¶
Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.¶
Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."¶
This Internet-Draft will expire on 20 May 2027.¶
Copyright (c) 2026 IETF Trust and the persons identified as the document authors. All rights reserved.¶
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document.¶
In confidential computing and zero-trust architectures, Relying Parties must verify the hardware cryptographic evidence (e.g., AMD SEV-SNP or Intel TDX quotes) presented by workloads. Pinning exact launch measurements locally does not scale with continuous integration, paravisor updates, or dynamic scaling. OHMP solves this by delegating policy appraisal to a hierarchy of TEE-hosted Measurement Authorities over OpenHTTPA.¶
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.¶
OHMP establishes a 3-tier hierarchy: 1. Root-MA Quorum: A threshold (M-of-N) group of TEE-hosted Root Measurement Authorities spanning distinct cloud vendors (e.g., Azure OpenHCL, Google Cloud direct devices). This is the only trust anchor pinned by the client. 2. Delegate-MA: Regional or namespace-specific TEEs authorized by the Root-MA Quorum to appraise specific workload types. 3. Workload TEE: The target server executing the Relying Party's request.¶
A Delegate-MA is itself a TEE. It MAY be certified by the Root-MA Quorum in an offline ceremony, or by self-attestation: each Root-MA appraises the hardware evidence of the Delegate-MA's own confidential VM (Section 7). A Workload TEE MAY serve its own proof of endorsement to Relying Parties (Section 6), so that verifying it needs no request to any Measurement Authority.¶
All OHMP endpoints of Measurement Authorities are OpenHTTPA trusted requests. A Workload TEE MAY serve its stapled bundle as a trusted request or over plain HTTP, since the bundle is self-authenticating. Because a trusted request carries its ciphertext in the request body, a read resource MUST also be accepted as POST with an empty encrypted body; the OpenHTTPA request binding covers method, path and query either way.¶
| Path | Served by | Purpose |
|---|---|---|
/.well-known/ohmp/sth
|
Delegate-MA | current Signed Tree Head |
/.well-known/ohmp/endorsements
|
Delegate-MA | current tokens of a workload (Section 5.7) |
/.well-known/ohmp/stapled
|
Delegate-MA | stapled bundle of one replica (Section 6) |
/.well-known/ohmp/stapled
|
Workload TEE | its own stapled bundle (Section 6) |
/.well-known/ohmp/tl/entries
|
Delegate-MA | log entries for auditors (Section 10) |
/v1/ohmp/appraise
|
Delegate-MA | appraisal (Section 5.6) |
/v1/ohmp/revoke
|
Delegate-MA | emergency revocation (Section 8) |
/v1/ohmp/tl/root-rotation
|
Delegate-MA | logs a quorum key rotation (Section 9) |
/v1/ohmp/tl/consistency
|
Delegate-MA | consistency proof |
/v1/ohmp/tl/entries
|
Delegate-MA | log entries (at most 1000) |
/v1/ohmp/tl/cosign-sth
|
Root-MA | STH co-signing |
/v1/ohmp/root/certify-delegate
|
Root-MA | delegate certification (Section 7) |
Query parameters, all REQUIRED:¶
/.well-known/ohmp/endorsements?workload_id=...¶
/.well-known/ohmp/stapled?workload_id=...&identity_pub_sha256=... (on a Delegate-MA; a Workload TEE takes none)¶
/v1/ohmp/tl/consistency?first=...&second=...¶
/v1/ohmp/tl/entries?start=...&end=... and /.well-known/ohmp/tl/entries?start=...&end=... (the range [start, end))¶
Errors are {"error": {"code": ..., "message": ...}}. Besides the codes of the verification rules (malformed, bad-signature, quorum-not-met, proof-invalid, expired, namespace-violation, scope-violation, profile-refused, appraisal-failed, endorsement-conflict, equivocation-detected, not-found), this document uses revoked (Section 8), validity-exceeded with the member max_ttl_seconds (Section 7), and need-entries with the member have_size (co-signing).¶
Every response carries the OpenHTTPA-OHMP-Authority field naming the authority (authority_id of a Root-MA, delegate_id of a Delegate-MA) that produced it; a Workload TEE serving a stapled bundle names the delegate_id that endorsed it.¶
Every OHMP object is a tree of objects, arrays, text strings, booleans, null and integers; binary values are lowercase hexadecimal text and no floating-point value exists.¶
application/ohmp+json is the canonical JSON form: the JSON Canonicalization Scheme [RFC8785] restricted to integer numbers, i.e. UTF-8, no insignificant whitespace, object members sorted by the UTF-16 code units of their names, strings escaped minimally, integers in shortest decimal form.¶
application/ohmp+cbor is a supported transport encoding of the same data model in deterministic CBOR ([RFC8949], Section 4.2.1): definite lengths, shortest-form heads, text-string map keys sorted bytewise. A receiver MUST reject CBOR that is not already in this form, and MUST reject unknown object members in either encoding.¶
Signatures and Merkle leaf hashes are always computed over the canonical JSON bytes of the object, whichever encoding transported it, so a signature verifies regardless of the transport encoding.¶
Every OHMP signature is a pure ML-DSA-65 signature [FIPS204] over the canonical JSON of the signed body, with a role-specific, non-empty context string. A signature MUST verify under its own context; there is no empty-context fallback.¶
| Signed object | Signer | Context string |
|---|---|---|
| Signed Tree Head body | each Root-MA |
"openhttpa-ohmp/v1/sth"
|
| Delegate Authority Certificate body | each Root-MA |
"openhttpa-ohmp/v1/delegate-cert"
|
| Workload Endorsement body | Delegate-MA |
"openhttpa-ohmp/v1/workload-endorsement"
|
cosign-sth request body |
Delegate-MA |
"openhttpa-ohmp/v1/cosign-req"
|
| Delegate certification request body | Delegate-MA (proof of possession) |
"openhttpa-ohmp/v1/delegate-csr"
|
| Revocation body | Root-MA quorum, Delegate-MA, or the revoked replica key |
"openhttpa-ohmp/v1/revocation"
|
| Root-MA quorum key rotation body | each Root-MA of the old quorum |
"openhttpa-ohmp/v1/root-rotation"
|
To prevent a compromised Delegate-MA or Root-MA from issuing targeted, split-view endorsements, OHMP defines a SHA-256 Binary Merkle Tree (OHMP-TL). Each log is sequenced by one Delegate-MA and witnessed by the Root-MAs.¶
SHA256("")¶
SHA256(0x00 || canonical_json_bytes), where canonical_json_bytes is the canonical JSON (see Encodings) of the log entry {"leaf_index": i, "kind": {...}}, so a leaf commits to its own position.¶
SHA256(0x01 || left_hash || right_hash)¶
The tree shape, inclusion audit paths and consistency proofs are those of [RFC9162], Section 2.1, with one addition: when the first size m of a consistency proof is a power of two, RFC 9162 omits MTH(D[0:m]) because the verifier holds it as the first root; an OHMP-TL proof MUST carry it as its first node. The proof then states which root the larger tree commits size m to, as it does for every other m (Section 5.5). A verifier MUST accept both forms and tells them apart by length (the OHMP-TL form is one node longer). The leaf hash is never computed over the CBOR encoding.¶
The STH is signed using FIPS 204 ML-DSA-65 with the context string "openhttpa-ohmp/v1/sth". A valid STH MUST contain at least quorum_m cryptographically valid signatures from distinct authorities defined in the Relying Party's trust anchor. The trust anchor MUST satisfy 2 * quorum_m > N, so any two quorums share an authority. Its epoch member (omitted when 0) counts the quorum key rotations applied to it (Section 9).¶
A log entry (member kind) is a Delegate Authority Certificate (delegate-cert), a signed Workload Endorsement (endorsement), a revocation (revocation, Section 8) or a quorum key rotation (root-rotation, Section 9). Every party that checks a log (Root-MAs before co-signing, auditors, Delegate-MAs at startup) applies these rules:¶
delegate_id, for this log_id, carrying a valid Root-MA quorum under "openhttpa-ohmp/v1/delegate-cert", appears at a lower leaf index.¶
delegate_id at a lower leaf index. The endorsement MUST verify under that certificate's key, lie within its namespace_constraints, profiles and endorsement_scope, and have issued_at within its validity window. A Workload Endorsement Token MUST carry that certificate.¶
token_id MUST appear at most once, a given revocation body at most once, and one rotation per old_epoch. A Root-MA MUST refuse to co-sign a head whose new entries repeat an earlier entry, and a Delegate-MA MUST NOT be restarted on a certificate that a later certificate has superseded.¶
POST /v1/ohmp/tl/cosign-sth)
A Delegate-MA obtains Root-MA signatures for a proposed tree head by sending a request whose body names the requester (signer_id), the proposed tree head, and the log entries from entries_from to the head's tree_size. The body is signed by the Delegate-MA under "openhttpa-ohmp/v1/cosign-req". A Root-MA MUST, before changing any state:¶
timestamp is not near its own clock (this bounds how long a captured request can be used);¶
need-entries with its mirror size if entries_from exceeds that size;¶
signer_id in its mirror or among the new entries of the request, and verify that it is for this log, carries a valid Root-MA quorum, and is valid now;¶
"openhttpa-ohmp/v1/cosign-req";¶
signer_id and every new entry to satisfy the Log Entries and Certificate Rules; require entries it already holds to be byte-identical to its mirror; and recompute the root of the proposed size.¶
Only then does the Root-MA durably append the new entries to its mirror and return its STH signature. Because the mirror is append-only and durable before a signature leaves, an honest Root-MA never signs two different roots for one tree size.¶
A Relying Party keeps, per log, the largest STH whose quorum it verified (its checkpoint). On seeing another quorum-verified STH it MUST check that both heads belong to one append-only log, and MUST record the log as equivocating, permanently, only on cryptographic proof:¶
MTH(D[0:m]) also when m is a power of two, this holds at every size: a quorum-signed head that conflicts with the log at a power-of-two size is latched as deterministically as at any other.¶
A consistency proof that cannot be fetched, answers another size pair, or does not reconstruct the larger quorum-verified root proves nothing: the Relying Party MUST refuse the new STH for that request and MUST NOT change its checkpoint.¶
POST /v1/ohmp/appraise)
A Delegate-MA appraises Class B evidence against its policy, which MUST be able to pin minimum TCB levels: for AMD SEV-SNP the PSP bootloader, PSP OS, SNP firmware and microcode SVNs and the firmware ABI version; for Intel TDX the TEE_TCB_SVN, compared component by component. The binding digest commits to the workload_id and to the workload's identity_key, so appraisals by distinct replicas of one workload never collide. Evidence over a given binding digest is appraised once. A repeated request with the same binding digest, the same profile and the same evidence, whose endorsement is logged and unexpired, MUST be answered with that endorsement, proven against the current STH, instead of an error; other evidence, or the same evidence under another profile, over the same binding digest MUST be refused as a replay.¶
A Delegate-MA policy MAY hold several rules for one namespace, at most one per profile (for example an azure-cvm-snp rule and an azure-cvm-tdx rule for *.prod.example). The first rule whose namespace matches the workload_id selects the namespace; the request MUST then be appraised against that namespace's rule for the requested profile, and refused if there is none.¶
A Delegate-MA MAY replace its rule table while running (for example to roll out new golden measurements from continuous integration). It MUST validate the new table as at startup (including refusing two rules for one (namespace, profile) and profiles its certificate does not cover), MUST keep the old table if validation fails, and MUST swap the table atomically, so that every appraisal uses either the old or the new table; the log, the current STH and the replay state of the binding digests are kept. A Delegate-MA MUST refuse to endorse a workload whose endorsement a logged revocation would cover.¶
A logical workload_id MAY have several concurrently active Workload Endorsement Token leaves in OHMP-TL, each bound to the distinct hardware-sealed identity_key of one CVM replica. This supports horizontal scaling and failover pools behind one service identifier, including pools that mix AMD SEV-SNP (azure-cvm-snp) and Intel TDX (azure-cvm-tdx) replicas. An endorsement is therefore identified by the composite key (workload_id, identity_key), where identity_key is carried as identity_pub_sha256.¶
GET /.well-known/ohmp/endorsements?workload_id=... MUST return, each with an inclusion proof against the current STH, every unexpired endorsement of the workload that is not a renewal: of endorsements identical in identity_pub_sha256, profile, infrastructure claims and payload claims, only the one with the highest leaf index is returned. Endorsements of one identity_key that differ in any of these MUST all be returned, so that Relying Parties can detect the conflict. Endorsements that a logged revocation covers MUST NOT be returned; when every endorsement of the workload is revoked, the response is the error revoked.¶
A Relying Party verifies every token, then resolves the workload's replica set:¶
(workload_id, identity_key). Distinct keys are distinct replicas, which MAY use different profiles.¶
(workload_id, identity_key) whose validity windows overlap MUST agree on profile, on the infrastructure claims (launch measurement or MRTD, PCRs 4, 7 and 11) where both carry them, and on every payload PCR both carry. An identity_key with conflicting bindings MUST be treated as compromised and refused; the other replicas of the workload are unaffected.¶
When it connects, the Relying Party MUST match the identity_key the peer presents in the OpenHTTPA handshake against this replica set, and MUST appraise the peer only against the endorsements of that one replica. A key that is absent from the set, refused for a conflict, or covered by a revocation the Relying Party knows of (Section 10), MUST NOT be accepted.¶
A Relying Party on the Internet that connects to a Workload TEE needs the workload's endorsement, the delegate certificate behind it, and proof that both are in OHMP-TL. Fetching them from the Delegate-MA on every connection adds a round trip and makes the Delegate-MA an availability and privacy dependency of every connection. With stapling the Workload TEE fetches this material in the background and serves it itself, and the Relying Party verifies it offline against its root_trust_anchor.json alone.¶
An OhmpStapledBundle is an object with exactly these members, encoded as application/ohmp+json or application/ohmp+cbor (media type parameter profile="stapled-bundle"):¶
| Member | Content |
|---|---|
sth
|
a Signed Tree Head |
delegate_cert
|
the Delegate Authority Certificate of the endorsing Delegate-MA |
delegate_inclusion
|
inclusion proof of the leaf {"leaf_index": i, "kind": {"delegate-cert": delegate_cert}}
|
endorsement
|
the delegate-signed Workload Endorsement (body and signature) |
endorsement_inclusion
|
inclusion proof of the leaf {"leaf_index": j, "kind": {"endorsement": endorsement}}
|
Each inclusion proof has the members leaf_index, audit_path and sth; the sth of both proofs MUST be byte-identical to the bundle's sth. A bundle is useful until the earlier of the endorsement's expires_at and the certificate's not_after.¶
GET /.well-known/ohmp/stapled?workload_id=W&identity_pub_sha256=K on a Delegate-MA returns the bundle of the replica of workload W whose identity key has SHA-256 K (lowercase hexadecimal): its most recent unexpired endorsement under the current STH, preferring one that carries infrastructure claims, the certificate in force for that endorsement (the Log Entries and Certificate Rules), and both inclusion proofs against the current STH. The Delegate-MA MUST answer not-found if there is none, and revoked if the replica's endorsements are revoked.¶
A Workload TEE that staples:¶
identity_key (Section 5.6), and calls POST /v1/ohmp/appraise;¶
/.well-known/ohmp/stapled on the Delegate-MA;¶
/.well-known/ohmp/stapled on its own origin, with OpenHTTPA-OHMP-Authority set to the bundle's delegate_id, and MUST NOT serve it after the earliest of the endorsement's expires_at, the certificate's not_after and sth.timestamp + max_sth_age_secs;¶
A Relying Party that pins root_trust_anchor.json verifies a bundle for an expected workload_id and the identity key identity_key that the peer proved possession of in the OpenHTTPA handshake, at its current time now. It MUST perform every check below, MUST NOT contact any Measurement Authority to do so, and MUST refuse the peer if any check fails:¶
sth carries at least quorum_m valid signatures from distinct pinned authorities under "openhttpa-ohmp/v1/sth", and is fresh: now - sth.timestamp <= max_sth_age_secs, a Relying Party setting (RECOMMENDED: at most one hour), and sth.timestamp is not in the future beyond clock skew.¶
delegate_cert carries a Root-MA quorum under "openhttpa-ohmp/v1/delegate-cert", not_before <= now < not_after, its log_id is that of sth, and one of its namespace_constraints admits workload_id. delegate_inclusion proves the certificate's leaf in sth.¶
endorsement verifies under the certificate's key and "openhttpa-ohmp/v1/workload-endorsement" and lies within the certificate's namespaces, profiles and scope; issued_at lies within the certificate's validity and not in the future beyond clock skew, and now < expires_at; its workload_id equals the expected one; and its identity_pub_sha256 equals SHA-256 of identity_key. endorsement_inclusion proves the endorsement's leaf in sth.¶
delegate_inclusion.leaf_index < endorsement_inclusion.leaf_index.¶
revoked).¶
The checks may run in any order; an implementation that verifies delegate_inclusion last runs every other check even when that proof is missing.¶
The verified endorsement is then the one-endorsement replica set of (workload_id, identity_key) (Section 5.7), and the peer is appraised against it.¶
The bundle need not show that delegate_cert is the latest certificate of the delegate before the endorsement: the endorsement is in a quorum-signed head, so honest Root-MAs checked it against the certificate then in force before co-signing, and it verifies under delegate_cert too, which lies before it in the same log.¶
A Relying Party that keeps checkpoints (Section 5.5) MUST also hold sth to the checkpoint of its log without fetching anything: it MUST refuse a log already recorded as equivocating; it MUST refuse an sth smaller than the checkpoint as stale; it MUST record the log as equivocating if sth has the checkpoint's size and another root (after re-verifying the checkpoint's quorum). It MAY accept a larger sth but MUST NOT advance the checkpoint without a verified consistency proof. A Relying Party without a checkpoint for the log MAY adopt sth as its checkpoint.¶
A Delegate-MA that runs in a confidential VM can obtain its Delegate Authority Certificate from the Root-MA Quorum on the strength of its own hardware evidence, without an offline ceremony.¶
The request body (media type parameter profile="delegate-csr") has the members:¶
| Member | Content |
|---|---|
version
|
1
|
delegate_id
|
the delegate to certify |
log_id
|
the log it will sequence |
public_key
|
its ML-DSA-65 public key, generated in the confidential VM and sealed to its vTPM |
namespace_constraints
|
requested namespace constraints |
endorsement_scope
|
requested scope (full, infrastructure-only or payload-only) |
profiles
|
attestation profiles it asks to appraise |
profile
|
attestation profile of evidence (for example azure-cvm-tdx or azure-cvm-snp) |
not_before
|
the certificate's exact not_before, Unix seconds |
not_after
|
the certificate's exact not_after (exclusive) |
evidence
|
hardware evidence of the Delegate-MA's own confidential VM over D
|
The request is {"body": ..., "signature": ...}, where signature is an ML-DSA-65 signature by public_key over the canonical JSON of body under "openhttpa-ohmp/v1/delegate-csr" (proof of possession). The binding digest is¶
B = SHA-512("openhttpa-ohmp/v1/delegate-csr-binding"
|| canonical_json(body without the member "evidence"))
D = SHA-512("openhttpa-az-cvm/v1/session-nonce" || B
|| SHA-256(public_key))
¶
For Class B evidence, D is the HCL runtime-data user-data and the hardware REPORT_DATA[0..32] is SHA-256 of that runtime data, so the hardware report commits to the delegate identifier, its key, its log, its namespaces, scope and profiles, and the validity window of the certificate.¶
POST /v1/ohmp/root/certify-delegate)
A Root-MA certifies Delegate-MAs under a delegate appraisal policy: rules keyed by (delegate_id, profile), each listing the namespace constraints and profiles the delegate may be granted, the widest endorsement scope, the longest validity window max_ttl_seconds, and the golden measurements and hardware TCB floors of the delegate's confidential VM (approved SEV-SNP launch measurements or TDX MRTDs, PCRs 4, 7 and 11, the SEV-SNP bootloader, TEE, SNP firmware and microcode SVNs and firmware ABI version, and the TDX TEE_TCB_SVN). A Root-MA MUST, in this order, and fail closed:¶
(delegate_id, profile), and refuse with not-found for an unknown delegate or profile-refused for a profile without a rule;¶
log_id to be the log it witnesses, every requested namespace constraint and profile to be listed by the rule, the requested scope to be the rule's scope or the rule's scope to be full, not_before to be within 300 seconds of its clock, and not_before < not_after; if not_after - not_before exceeds the rule's max_ttl_seconds, it MUST refuse with validity-exceeded, carrying its max_ttl_seconds, and MUST NOT shorten the window;¶
evidence over D against the rule's golden measurements and TCB floors exactly as a Delegate-MA appraises a workload (Section 5.6);¶
"openhttpa-ohmp/v1/delegate-cert", the certificate body built from the request with not_before and not_after exactly as requested, and return it as a Delegate Authority Certificate carrying its one signature.¶
The certificate body is a function of the request alone, so every Root-MA that accepts a request signs byte-identical canonical JSON, whatever its own max_ttl_seconds and however far its clock is from the others' within the skew window. Root-MAs need not agree on their ceilings: a request is certified by the Root-MAs whose ceiling admits its window, and a requester that gets validity-exceeded from too many of them retries with a window within the reported ceilings. The Delegate-MA merges the signatures of the Root-MAs that certified it into one certificate, MUST verify that it carries a quorum, and logs it as the next entry of its log before its first endorsement. The Root-MAs verify the certificate again when they co-sign the head that contains it, so the certificate enters OHMP-TL only through hardware attestation and the quorum.¶
A Root-MA without a delegate appraisal policy MUST refuse every certification request.¶
Endorsement TTLs bound how long a compromised replica key, a vulnerable image or a rogue Delegate-MA stays trusted. A revocation ends it at once, through the log.¶
A revocation entry is {"body": ..., "signatures": [...]}. Its body has the members version (1), log_id, target, revoked_at (Unix seconds) and reason (at most 256 octets), and target is one of:¶
{"delegate-key": {"delegate_id", "delegate_public_key_sha256"}} revokes every endorsement made under a certificate for that key, and every later use of the key. It is signed by a Root-MA quorum.¶
{"workload-replica": {"workload_id", "identity_pub_sha256"}} revokes every endorsement of that replica key of the workload. It is signed by a Delegate-MA certified for the workload.¶
{"launch-measurement": {"namespace", "profile", "launch_measurement"}} revokes every endorsement under profile that carries that launch measurement (SEV-SNP measurement or TDX MRTD) for a workload the namespace pattern admits. It is signed by a Delegate-MA certified for the namespace and the profile.¶
All signatures are ML-DSA-65 over the canonical JSON of the body under "openhttpa-ohmp/v1/revocation". A delegate-key revocation carries at least quorum_m signatures of distinct pinned authorities. Any other revocation carries exactly one signature, whose authority_id is the delegate_id of the signing Delegate-MA; it MUST verify under the latest certificate of that delegate logged before it, and the target MUST lie within that certificate: workload_id admitted by one of its namespace_constraints, or namespace equal to one of them or (without a leading *.) admitted by one, and profile among its profiles. A revocation is permanent and independent of time: it covers matching endorsements whenever they were issued.¶
POST /v1/ohmp/revoke)
The request is {"body": ..., "authorization": ...}, where authorization is either {"root-quorum": [...]} (a Root-MA quorum of signatures over the body under "openhttpa-ohmp/v1/revocation") or, only for a workload-replica target, {"replica-key": {"identity_pub": ..., "signature": ...}}: the revoked identity key itself, signing the body under the same context (whoever holds a compromised key can only take it out of service). For a workload-replica or launch-measurement target, authorization MAY instead be {"delegate": signature}: the signature of the log's Delegate-MA (authority_id = its delegate_id) under the same context, by the key of its latest logged certificate, which MUST be valid and unrevoked, with the target inside that certificate's namespace_constraints and profiles; it never authorizes a delegate-key target, and it becomes the entry's signature. A Delegate-MA MUST verify the authorization, refuse a revoked_at in the future, and refuse a target outside its certificate. It then builds the entry (the quorum signatures for delegate-key, its own signature otherwise), logs it, has the head that contains it co-signed, and returns the entry with its inclusion proof. The same body logged again returns the logged entry.¶
From the moment a revocation is logged, the Delegate-MA MUST NOT return covered endorsements from /.well-known/ohmp/endorsements or /.well-known/ohmp/stapled, and MUST refuse covered appraisals with revoked. Root-MAs MUST refuse to co-sign heads with new entries that a logged revocation covers, and MUST refuse co-signing requests made with a revoked delegate key; a revoked Delegate-MA's log is therefore frozen until it is re-certified with a new key.¶
A Relying Party learns revocations by auditing the log (Section 10) and MUST then refuse every covered endorsement, in endorsement sets and in stapled bundles alike, with revoked. A Relying Party that verifies stapled bundles offline without auditing relies on the STH freshness window: a bundle whose replica was revoked cannot be renewed, so it is refused once its STH is older than max_sth_age_secs.¶
A rotation replaces the pinned Root-MA quorum (new keys, new authorities or a new threshold) through the log, so Relying Parties move to the new anchor without re-provisioning root_trust_anchor.json.¶
A rotation entry is {"body": ..., "signatures": [...]}. Its body has the members version (1), log_id, old_epoch, new_epoch (old_epoch + 1), new_quorum_threshold, new_root_keys (authority entries as in the trust anchor) and effective_at (Unix seconds). It MUST carry at least quorum_m signatures of the anchor of epoch old_epoch under "openhttpa-ohmp/v1/root-rotation", and the anchor it establishes (epoch = new_epoch, quorum_m = new_quorum_threshold, authorities = new_root_keys) MUST be valid, including 2 * new_quorum_threshold > N.¶
POST /v1/ohmp/tl/root-rotation asks a Delegate-MA to log a rotation; the signatures are its authorization. The Delegate-MA and every Root-MA that co-signs the head containing it verify the rotation against their anchor.¶
A Relying Party applies a rotation given its entry, an inclusion proof and the STH it is proven against: it MUST verify the STH's quorum, the inclusion of the leaf {"leaf_index": i, "kind": {"root-rotation": ...}}, that old_epoch is the epoch of its latest anchor, the old quorum's signatures and the validity of the new anchor, and then MUST add the new anchor, in force from effective_at. It keeps the old anchors: a tree head is verified under the anchor in force at its timestamp, and a Delegate Authority Certificate under the anchor in force at the time of verification, so a rotation away from compromised keys also retires the certificates they signed, and delegates are re-certified by the new quorum. Root-MAs and Delegate-MAs of the new epoch are configured with the new anchor and start from a copy of the log.¶
GET /.well-known/ohmp/tl/entries?start=...&end=... returns the published log entries [start, end), at most 1000 per response, so that monitors and Relying Parties can audit the log. An auditor fetches entries 0 to tree_size of a quorum-verified STH (checked against its checkpoint, Section 5.5) and MUST verify that they are leaves 0, 1, ... in order, that their leaf hashes SHA-256(0x00 || canonical_json(entry)) rebuild the STH's root_hash, and that every revocation and rotation is validly signed. It then enforces every revocation it found and applies every rotation that follows its latest anchor. A full audit is stronger than an inclusion proof of each entry.¶
This section records the status of known implementations as of November 2026, following [RFC7942].¶
ohmp-rs (main, November 2026): the OHMP-TL Merkle engine ([RFC9162] tree shape and proofs, domain-separated hashing), the canonical JSON and deterministic CBOR codecs, the five context strings, M-of-N STH verification, authenticated cosign-sth with anti-replay, split-view latching on proof only, appraisal against full Class B TCB floors, multi-replica resolution per (workload_id, identity_key), OHMP stapling (the Delegate-MA endpoint, a background workload agent and an offline verifier), and self-attesting Delegate-MA certification. It also implements requester-proposed certificate windows, emergency revocation, quorum key rotation, log auditing, rule hot-reload, the power-of-two consistency-proof form, and crash-safe log storage: an append changes no in-memory state until its write and fdatasync succeed, and a torn last line is truncated at startup. Its tests exercise SEV-SNP and TDX replicas of one workload, certification and its refusals, Root-MAs with different ceilings and skewed clocks signing one certificate body, revocation of each target kind, rotation and auditing, and stapled verification and its refusals, against software Class B evidence that omits only the vendor signature over the hardware report. Stapled-bundle verification is also run against the captured artifacts of the live run (Appendix A): the quorum on the Intel TDX Root-MAs' STH of size 4 (root 3f3b1c57...358b), the TDX Delegate-MA's certificate, the AMD SEV-SNP endorsement and its inclusion at leaf 3, freshness and revocation all verify from the captured octets. The capture does not contain log leaves 1 and 2, so the inclusion proof of the certificate at leaf 0 cannot be formed from it, and the verifier refuses the bundle at that check, as it must.¶
openhttpa-proxy-rs (commit 2af53dc): Root-MA and Delegate-MA services in Azure confidential VMs, with ML-DSA-65 authority keys generated in the guest and sealed to the vTPM; Relying Party verification in the proxy client; and an offline verifier (verify-artifacts).¶
IANA is requested to register application/ohmp+json and application/ohmp+cbor in the Standards Tree per [RFC6838].
* Contact: Gordon King garyw@apache.org, VALSEE LLC
* Optional parameter: profile (e.g., "appraisal-request", "endorsement-token", "sth", "stapled-bundle", "delegate-csr", "revocation", "root-rotation")¶
IANA is requested to register the ohmp URI suffix per [RFC8615]. The one registration covers every path below /.well-known/ohmp/ that this document defines: /.well-known/ohmp/sth, /.well-known/ohmp/endorsements, /.well-known/ohmp/stapled and /.well-known/ohmp/tl/entries. This document creates no new registry.¶
IANA is requested to register OpenHTTPA-OHMP-Authority (Dictionary, provisional) per [RFC9110] Section 16.3. (Legacy implementations MAY emit X-OpenHTTPA-OHMP-Authority; new deployments SHOULD NOT, per [RFC6648].)¶
OHMP relies on FIPS 204 ML-DSA-65 for authentication. While OHMP-TL uses classical SHA-256, the Brassard-Hoyer-Tapp (BHT) quantum collision bound for an N-bit hash is $\mathcal{O}(2^{N/3})$. For SHA-256, this yields $\approx 2^{85.3}$ quantum operations, which remains infeasible for transparency log collision attacks given that leaf indices and FIPS 204 STH bindings strongly constrain the attacker's search space.¶
cosign-sth is reachable by any OpenHTTPA peer. Without the request signature and the anti-replay rule, a peer could propose an already public, validly signed entry at the next index; once in a Root-MA's durable mirror, the honest log would look like a fork to that Root-MA forever, halting the log without any key compromise. Signing requests under "openhttpa-ohmp/v1/cosign-req" with the key of a logged, currently valid certificate restricts co-signing to the log's Delegate-MA, and the anti-replay rule keeps even that Delegate-MA from repeating entries.¶
A stapled bundle is public and can be replayed by anyone, but it only vouches for the identity_key in its endorsement; a Relying Party accepts it only from a peer that proved possession of that key in the OpenHTTPA handshake. Freshness is bounded by the endorsement TTL, the certificate validity and max_sth_age_secs: a Relying Party that verifies offline cannot learn of a newer log state, so a replica revoked after its bundle was captured remains acceptable until the bundle's STH is older than max_sth_age_secs or its endorsement expires, whichever is first, unless the Relying Party audits the log. Deployments SHOULD therefore keep endorsement TTLs and max_sth_age_secs short (minutes); stapling makes this cheap because renewal is off the connection path. The checkpoint rules of Section 6 keep a Relying Party that also audits the log from accepting a head that contradicts what it has verified.¶
A Root-MA that certifies a Delegate-MA on hardware evidence delegates its trust in that Delegate-MA to the silicon vendor's roots and to the reviewed golden measurements of the Delegate-MA image; the TCB floors MUST be kept current. The binding digest commits the hardware report to the whole request except the evidence, so evidence captured from one request cannot certify another key, namespace or lifetime, and the proof of possession shows that the requester holds the key. The not_before skew window bounds the reuse of a captured request; reusing one within the window only reproduces the same certificate body. Because Root-MAs never change the requested window, an attacker cannot make honest Root-MAs sign different bodies, and a Root-MA with a lower ceiling only withholds its signature.¶
A revocation authorized by a replica key can only remove that key from service, and every other revocation needs either the Root-MA quorum or the Delegate-MA that could have endorsed the target in the first place; no party can revoke outside its authority, so revocation does not add a denial-of-service lever beyond the existing ones. A rotation needs the old quorum, so it cannot be forged by fewer than quorum_m old authorities; a Relying Party that keeps the old anchors for heads before effective_at can still check consistency across the rotation.¶
While the OHMP session layer achieves post-quantum forward secrecy, the underlying hardware roots (AMD ARK, Intel DCAP) remain classical (RSA/ECDSA). Relying Parties MUST evaluate this hybrid threat model.¶
This appendix documents a live run of the full OHMP ceremony across two silicon vendors and two cloud regions. The capture is published as crates/openhttpa-proxy/tests/fixtures/ohmp-real-silicon/ in openhttpa-proxy-rs at commit 2af53dc, and the regression test verify_artifacts_ohmp_real_silicon re-verifies it. The values below are copied from that capture.¶
| Role | Identifier | TEE (profile) | Azure VM size | Region |
|---|---|---|---|---|
| Root-MA |
root-r1
|
Intel TDX (azure-cvm-tdx) |
Standard_DC2es_v6
|
westus3
|
| Root-MA |
root-r2
|
Intel TDX (azure-cvm-tdx) |
Standard_DC2es_v6
|
westus3
|
| Root-MA |
root-r3
|
Intel TDX (azure-cvm-tdx) |
Standard_DC2es_v6
|
westus3
|
| Delegate-MA |
delegate-eu
|
Intel TDX (azure-cvm-tdx) |
Standard_DC2es_v6
|
westus3
|
| Workload |
api.prod.example
|
AMD SEV-SNP, Genoa (azure-cvm-snp) |
Standard_DC2as_v6
|
eastus2
|
Each Measurement Authority ran on its own CVM. Its ML-DSA-65 key was generated inside the guest and sealed to the vTPM (/dev/tpmrm0) under PCRs 4 and 11; only the public key left the VM. The identifier delegate-eu is a label and does not name the region.¶
The run exercised every step of this document:¶
azure-cvm-snp evidence to the Delegate-MA. The Delegate-MA appraised it against a policy that pins the full SEV-SNP TCB floor (Section 5.6).¶
cosign-sth, signing each request under "openhttpa-ohmp/v1/cosign-req". The Root-MAs co-sign only signed requests, so the STH quorum in the capture also attests that path.¶
Root trust anchor
version 1
quorum_m 2 (of 3)
authority_id root-r1, root-r2, root-r3
Delegate Authority Certificate
delegate_id delegate-eu
log_id log.ohmp.example
namespace *.prod.example
endorsement_scope full
profiles azure-cvm-snp
not_before 1794117050
not_after 1796709350
signatures root-r1, root-r2, root-r3
Workload Endorsement
token_id 76a71e7814e704d26e787b815018b311
workload_id api.prod.example
profile azure-cvm-snp
issued_at 1794117670
expires_at 1794117970 (TTL 300 s)
identity_pub_sha256 98339ea35decaeefb9295f982dbbe142
f4ffbbae0a8273f57b97a4827b9e83aa
launch_measurement 6587d41e46995d71808f7d92d859e0ed
093bea3c55a342c866a20cd1a213ae4e
20241bdbc44d5255222da65cce1c7f48
pcr4 b863cc12451d109d0339c3ece3cbf4ba
06d52eb04f5a0939f9a85455c13478a5
pcr7 f014e5cbfa297ee787a976abc51bc1d6
7e23e1b9e4a60128a1106dd0adef0c5b
pcr11 63016abdb71b86cacf01e814c3e7afaf
d1b1e334a5cbf98fd97770fe39b4ad3e
Inclusion proof
leaf_index 3
audit_path 2 nodes
Signed Tree Head
version 1
log_id log.ohmp.example
tree_size 4
root_hash (SHA-256) 3f3b1c5743309d7440eeb7f0d81c8f19
e6b04d194c1942cfcdff1a3c65e6358b
timestamp 1794117670
signatures root-r1, root-r2, root-r3 (quorum 2)
Workload SEV-SNP TCB floor (policy = host reported_tcb)
bootloader 10, tee 0, snp 23, microcode 84
abi 0.31 (GUEST_POLICY 0x3001f: ABI_MAJOR 0, ABI_MINOR 31)
reported_tcb equal to the VCEK's KDS TCB extensions
Measurement Authority golden image (TDX)
MRTD efef2fafedab1cecacab0acbb3ec70ab
6638b474a4469022745c1c8ba0470be4
cfa1170ad5c82f57bff4833acde55e4c
pcr4, pcr7, pcr11 as for the workload above
¶
Two verifiers reproduce the values above from the captured octets:¶
verify-artifacts (Rust) checks the anchor; the azure-cvm-tdx evidence of the four Measurement Authorities; the certificate quorum; the endorsement signature; the [RFC9162] inclusion proof and the STH quorum; the workload's azure-cvm-snp evidence against the endorsed policy; and the OpenHTTPA wire record.¶
Signatures under six context strings verify: the four of this document that the run used (it did not exercise "openhttpa-ohmp/v1/delegate-csr", "openhttpa-ohmp/v1/revocation" or "openhttpa-ohmp/v1/root-rotation") and the OpenHTTPA identity contexts "openhttpa/v1/hs-server-transcript" and "openhttpa/v1/epoch-session-binding".¶
The floor in this run is the workload host's own reported TCB. It is not a fleet minimum. An earlier capture of the same paravisor launch measurement (6587d41e...7f48) on another Azure Genoa host, with a different VCEK, reported bootloader 12, tee 0, snp 28, microcode 88. Hosts within one cloud update PSP firmware and microcode at different times, so the reported TCB varies from host to host and region to region. The VCEK is derived for one chip at one TCB, and its KDS TCB extension OIDs carry the levels it was issued for. Both captures show reported_tcb equal to those extensions. A Delegate-MA policy therefore sets each floor at the lowest level the operator accepts across the fleet: a floor taken from the newer host would have refused the eastus2 workload.¶
All three Root-MAs were Azure CVMs in one region. The run validates the protocol and cross-silicon appraisal; it does not exercise the cloud-provider independence that Section 2 requires of a production quorum. In the published fixture, endpoint addresses are replaced with role names; the raw frames, quotes, PCRs, proofs and signatures are unchanged.¶