Internet-Draft OHMP and OHMP-TL November 2026
King Expires 20 May 2027 [Page]
Workgroup:
Network Working Group
Internet-Draft:
draft-openhttpa-ohmp-00
Published:
Intended Status:
Experimental
Expires:
Author:
G. King
OpenHTTPA Foundation

OpenHTTPA Hierarchical Measurement Protocol (OHMP) and Transparency Log

Abstract

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.

Status of This Memo

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.

▲

Table of Contents

1. Introduction

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.

1.1. Requirements Language

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.

2. OHMP Trust Architecture

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.

2.1. Endpoints

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.

Table 1
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.

3. Encodings

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.

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.

4. FIPS 204 Context Strings

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.

Table 2
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"

5. OHMP-TL: The Merkle Transparency Log

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.

5.1. Domain Separation

  • Empty Tree Hash: SHA256("")
  • Leaf Node Hash: 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.
  • Interior Node Hash: 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.

5.2. Signed Tree Head (STH)

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).

5.3. Log Entries and Certificate Rules

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:

  1. Log before use. An endorsement is valid in the log only if a certificate for its delegate_id, for this log_id, carrying a valid Root-MA quorum under "openhttpa-ohmp/v1/delegate-cert", appears at a lower leaf index.
  2. Certificate selection. The certificate in force for an endorsement is the latest certificate for its 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.
  3. Anti-replay. Logged entries are public and remain validly signed. A given Delegate Authority Certificate MUST appear in a log at most once, a given endorsement 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.
  4. Revocation. An endorsement MUST NOT be logged after a revocation that covers it (Section 8), and a certificate MUST NOT be logged for a revoked delegate key.

5.4. Co-signing (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:

  1. refuse a head for a log it does not witness, or whose timestamp is not near its own clock (this bounds how long a captured request can be used);
  2. answer need-entries with its mirror size if entries_from exceeds that size;
  3. find the latest certificate for 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;
  4. verify the request signature under that certificate's key and "openhttpa-ohmp/v1/cosign-req";
  5. refuse the request if the key of that certificate is revoked by an entry it already holds;
  6. require every new endorsement, and every new revocation signed by a Delegate-MA, to be by 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.

5.5. Split-View Detection by Relying Parties

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:

  • two quorum-verified STHs of the same size with different roots; or
  • a consistency proof that reconstructs the larger quorum-verified root but commits the smaller size to a root other than that of the smaller quorum-verified STH. Because OHMP-TL proofs carry 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.

5.6. Appraisal (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.

5.7. Endorsement Resolution and Client Verification

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:

  1. It groups the verified, unexpired endorsements by (workload_id, identity_key). Distinct keys are distinct replicas, which MAY use different profiles.
  2. Endorsements of one (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.
  3. Otherwise the renewals of a replica are deduplicated: for each claim kind, the endorsement with the highest leaf index is kept.

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.

6. OHMP Stapling

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.

6.1. The Stapled Bundle

An OhmpStapledBundle is an object with exactly these members, encoded as application/ohmp+json or application/ohmp+cbor (media type parameter profile="stapled-bundle"):

Table 3
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.

6.2. Obtaining and Serving a Bundle

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:

  1. obtains fresh hardware evidence over the appraisal binding digest, which commits to its identity_key (Section 5.6), and calls POST /v1/ohmp/appraise;
  2. fetches its bundle from /.well-known/ohmp/stapled on the Delegate-MA;
  3. verifies the bundle as a Relying Party would (below) and MUST NOT serve a bundle that fails;
  4. serves the latest verified bundle at /.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;
  5. renews before that time. Renewal SHOULD start once two thirds of the bundle's lifetime have passed, with random jitter of up to a tenth of the lifetime so that replicas do not renew in lockstep, and SHOULD back off exponentially after a failure.

6.3. Verifying a Bundle

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:

  1. Tree head. 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.
  2. Delegate certificate. 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.
  3. Endorsement. 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.
  4. Log before use. delegate_inclusion.leaf_index < endorsement_inclusion.leaf_index.
  5. Revocation. No revocation the Relying Party knows of covers the replica key, the endorsed launch measurement or the certificate's key (error 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.

7. Self-Attesting Delegate-MA Certification

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.

7.1. Certification Request

The request body (media type parameter profile="delegate-csr") has the members:

Table 4
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.

7.2. Root-MA Processing (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:

  1. verify the proof-of-possession signature;
  2. find the rule for (delegate_id, profile), and refuse with not-found for an unknown delegate or profile-refused for a profile without a rule;
  3. require 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;
  4. appraise evidence over D against the rule's golden measurements and TCB floors exactly as a Delegate-MA appraises a workload (Section 5.6);
  5. sign, under "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.

8. Emergency Revocation

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.

8.1. Revocation Entries

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.

8.2. Logging a Revocation (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.

8.3. Enforcement by Relying Parties

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.

9. Root-MA Quorum Key Rotation

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.

9.1. Rotation Entries

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.

9.2. Applying a Rotation

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.

10. Log Auditing

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.

11. Implementation Status

This section records the status of known implementations as of November 2026, following [RFC7942].

12. IANA Considerations

12.1. Media Types

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")

12.2. Well-Known URI

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.

12.3. HTTP Field Name

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].)

13. Security Considerations

13.1. Quantum Security Bounds

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.

13.2. Co-signing Authentication and Replay

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.

13.3. Stapled Bundles

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.

13.4. Self-Attesting Delegates

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.

13.5. Revocation and Rotation

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.

13.6. Classical Silicon Roots

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.

14. References

14.1. Normative References

[RFC2119]
Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, DOI 10.17487/RFC2119, , <https://www.rfc-editor.org/info/rfc2119>.
[RFC6648]
Saint-Andre, P., Crocker, D., and M. Nottingham, "Deprecating the "X-" Prefix and Similar Constructs in Application Protocols", BCP 178, RFC 6648, DOI 10.17487/RFC6648, , <https://www.rfc-editor.org/info/rfc6648>.
[RFC6838]
Freed, N., Klensin, J., and T. Hansen, "Media Type Specifications and Registration Procedures", BCP 13, RFC 6838, DOI 10.17487/RFC6838, , <https://www.rfc-editor.org/info/rfc6838>.
[RFC8174]
Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174, , <https://www.rfc-editor.org/info/rfc8174>.
[RFC8615]
Nottingham, M., "Well-Known Uniform Resource Identifiers (URIs)", RFC 8615, DOI 10.17487/RFC8615, , <https://www.rfc-editor.org/info/rfc8615>.
[RFC8785]
Rundgren, A., Jordan, B., and S. Erdtman, "JSON Canonicalization Scheme (JCS)", RFC 8785, DOI 10.17487/RFC8785, , <https://www.rfc-editor.org/info/rfc8785>.
[RFC8949]
Bormann, C. and P. Hoffman, "Concise Binary Object Representation (CBOR)", STD 94, RFC 8949, DOI 10.17487/RFC8949, , <https://www.rfc-editor.org/info/rfc8949>.
[RFC9110]
Fielding, R., Ed., Nottingham, M., Ed., and J. Reschke, Ed., "HTTP Semantics", STD 97, RFC 9110, DOI 10.17487/RFC9110, , <https://www.rfc-editor.org/info/rfc9110>.
[RFC9162]
Laurie, B., Messeri, E., and R. Stradling, "Certificate Transparency Version 2.0", RFC 9162, DOI 10.17487/RFC9162, , <https://www.rfc-editor.org/info/rfc9162>.
[FIPS204]
NIST, "Module-Lattice-Based Digital Signature Standard", .

14.2. Informative References

[RFC7942]
Sheffer, Y. and A. Farrel, "Improving Awareness of Running Code: The Implementation Status Section", BCP 205, RFC 7942, DOI 10.17487/RFC7942, , <https://www.rfc-editor.org/info/rfc7942>.

Appendix A. Cross-Silicon Live Verification

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.

A.1. Topology

Table 5
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:

  1. The Root-MAs formed a 2-of-3 trust anchor and signed the Delegate Authority Certificate.
  2. The workload presented its 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).
  3. The Delegate-MA signed the Workload Endorsement and submitted the log entry through 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.
  4. A Relying Party fetched through the workload over OpenHTTPA and verified the endorsement, the inclusion proof and the STH quorum against the pinned anchor.

A.2. Captured Values

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

A.3. Verification

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.
  • An independent Python verifier, written from the specifications on a separate FIPS 204 implementation, checks every ML-DSA-65 signature under its context string, the inclusion proof, and the SEV-SNP chain (ARK, ASK, VCEK, report signature, vTPM quote). It does not check the Measurement Authorities' TDX quotes; the Rust verifier does.

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".

A.4. Why TCB Floors Differ Between Hosts

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.

A.5. Limits of This Run

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.

Author's Address

Gordon King
OpenHTTPA Foundation
United States