Network Working Group L. Li Internet-Draft 17 November 2026 Intended status: Standards Track Expires: 21 May 2027 Key Provenance Evidence for Certification Authority Keys draft-li-lamps-ca-key-provenance-01 Abstract Many cryptographic modules can sign a statement that they generated a given key, using an attestation key that the module vendor certifies. This document defines Key Provenance Evidence (KPE), which applies this to the keys of certification authorities (CAs). A KPE file carries the public key of a CA together with the statements that modules signed about it. Anyone can then verify a chain of signatures from the vendor's trust anchor to the public key in a CA certificate, and so confirm that the private key was generated inside a module. The signed statements stay in the formats that module vendors already use, which are listed in a new IANA registry. Modules that are already deployed need no changes. 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 21 May 2027. Copyright Notice 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. Li Expires 21 May 2027 [Page 1] Internet-Draft CA Key Provenance Evidence November 2026 Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Revised BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Revised BSD License. Table of Contents 1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . 3 1.1. Non-Goals . . . . . . . . . . . . . . . . . . . . . . . . 5 1.2. Relationship to Other Work . . . . . . . . . . . . . . . 5 2. Conventions and Definitions . . . . . . . . . . . . . . . . . 6 3. Provenance Facts . . . . . . . . . . . . . . . . . . . . . . 6 4. Cryptographic Binding . . . . . . . . . . . . . . . . . . . . 8 5. Key Provenance Evidence File . . . . . . . . . . . . . . . . 10 5.1. Structure . . . . . . . . . . . . . . . . . . . . . . . . 10 5.2. Textual Encoding . . . . . . . . . . . . . . . . . . . . 11 5.3. Media Type . . . . . . . . . . . . . . . . . . . . . . . 11 5.4. Assembling a KPE File . . . . . . . . . . . . . . . . . . 11 6. Evidence Format Specifications . . . . . . . . . . . . . . . 12 7. Verification Procedure . . . . . . . . . . . . . . . . . . . 14 8. Use in Certificate Issuance and Disclosure . . . . . . . . . 16 9. Security Considerations . . . . . . . . . . . . . . . . . . . 16 9.1. What Is and Is Not Shown . . . . . . . . . . . . . . . . 17 9.2. Trust in Module Vendors . . . . . . . . . . . . . . . . . 17 9.3. The Operator as Adversary . . . . . . . . . . . . . . . . 18 9.4. Attestation Keys and Other Keys Under the Same Trust Anchor . . . . . . . . . . . . . . . . . . . . . . . . . 18 9.5. Operator-Chosen Values in Signed Content . . . . . . . . 19 9.6. Key Generation Inputs . . . . . . . . . . . . . . . . . . 20 9.7. Unauthenticated Container . . . . . . . . . . . . . . . . 20 9.8. Key Comparison . . . . . . . . . . . . . . . . . . . . . 21 9.9. Backup and Cloning . . . . . . . . . . . . . . . . . . . 21 9.10. Replay . . . . . . . . . . . . . . . . . . . . . . . . . 22 9.11. Verification Over Time . . . . . . . . . . . . . . . . . 22 9.12. Disclosure of Module Information . . . . . . . . . . . . 23 10. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 23 10.1. ASN.1 Module Identifier . . . . . . . . . . . . . . . . 23 10.2. Key Provenance Evidence Formats Registry . . . . . . . . 23 10.3. Media Type Registration . . . . . . . . . . . . . . . . 24 11. References . . . . . . . . . . . . . . . . . . . . . . . . . 25 11.1. Normative References . . . . . . . . . . . . . . . . . . 25 11.2. Informative References . . . . . . . . . . . . . . . . . 26 Appendix A. ASN.1 Module . . . . . . . . . . . . . . . . . . . . 30 Appendix B. Carrying Provenance Statements in Other Structures . . . . . . . . . . . . . . . . . . . . . . . 31 B.1. Certification Requests . . . . . . . . . . . . . . . . . 31 B.2. Conceptual Message Wrapper . . . . . . . . . . . . . . . 32 Li Expires 21 May 2027 [Page 2] Internet-Draft CA Key Provenance Evidence November 2026 Appendix C. Example: Detecting a Substituted Key . . . . . . . . 33 Appendix D. Rationale for the Hash Strength Requirements . . . . 33 Appendix E. Existing Vendor Mechanisms . . . . . . . . . . . . . 35 E.1. Thales Luna . . . . . . . . . . . . . . . . . . . . . . . 36 E.2. Entrust nShield . . . . . . . . . . . . . . . . . . . . . 37 E.3. Marvell LiquidSecurity . . . . . . . . . . . . . . . . . 38 E.4. Securosys Primus . . . . . . . . . . . . . . . . . . . . 39 E.5. Yubico YubiHSM 2 . . . . . . . . . . . . . . . . . . . . 39 E.6. Crypto4A QASM . . . . . . . . . . . . . . . . . . . . . . 40 Appendix F. IETF RATS Evidence Format for Hardware Security Modules . . . . . . . . . . . . . . . . . . . . . . . . . 40 Acknowledgments . . . . . . . . . . . . . . . . . . . . . . . . . 41 Author's Address . . . . . . . . . . . . . . . . . . . . . . . . 41 1. Introduction A certification authority (CA) is expected to generate its key pairs inside a cryptographic module and to keep the private keys there. Today, the assurance that this happened for a particular CA key comes from procedural controls: a key generation script, witnessing of the key ceremony, logs, and an auditor's report (see, for example, Section 6.1.1.1 of [CABF-BR]). These controls describe the process. They do not let anyone check that the public key in a given certificate belongs to a private key that the module generated. In October 2026, the P-384 private keys of eight subordinate CAs were found to be integers smaller than 256 [EMUDHRA-REPORT]. According to the CA's incident report, the keys had been generated correctly in a module and were to be transferred to modules of another vendor. A host-side script wrapped and unwrapped each key, read the private value back into host memory, and created a new key object from it. For these keys, the script truncated the value to its leading byte. The certificates, including cross-certificates from another CA, were issued for the re-created keys: keys that were in the module but had not been generated by it. The report notes that the ceremony did not compare the certified public key with the key originally generated, and that such a check would have detected the problem. Eight RSA keys from the same ceremony went through the same steps. Their values were not changed, but the CA revoked their certificates because the key material had been in host memory and the CA could not show that this complied with its policy. For these keys, the certified public keys were the ones that the module had generated. What went wrong is that the private keys left the module. In both cases, the CAs that certified the keys had no way to check what had happened to them, whatever checks the operator made. The modules themselves can close this gap. Many cryptographic modules Li Expires 21 May 2027 [Page 3] Internet-Draft CA Key Provenance Evidence November 2026 can sign a statement about a key that they hold, which says that the key was generated inside a module and not brought in from outside. Some modules also state whether the key can ever leave the module. The module signs this statement with an attestation key, and the module vendor certifies the attestation key under a trust anchor that the vendor publishes. The result is a chain of signatures from the vendor's trust anchor to the public key of the CA, as shown in Figure 1. Vendor Trust Anchor | | certifies, directly or through intermediate keys v attestation key, held inside the module | | signs v +----------------------------------------------+ | public key K | | "the private key of K was generated inside | | a module" | +----------------------------------------------+ | | K is the public key in v CA certificate or certification request Figure 1: The Chain of Signatures That KPE Verifies This document is built around that chain. It defines Key Provenance Evidence (KPE), which consists of: * a file that carries the SubjectPublicKeyInfo [RFC5280] of a CA key together with the signed statements about it (Section 5); * the facts that a Verifier takes from a signed statement (Section 3); * the requirements that the chain has to meet (Section 4); * the procedure to verify the chain (Section 7). Li Expires 21 May 2027 [Page 4] Internet-Draft CA Key Provenance Evidence November 2026 KPE does not define what a module signs. Module vendors already offer key attestation mechanisms, each with its own encoding, and the signed statement stays in the vendor's format. Each format is identified by an entry in an IANA registry (Section 10.2), as the attestation statement formats of Web Authentication are [RFC8809]. Modules that are already deployed therefore need no changes. A CA adds one step to its key ceremony: it obtains the signed statement from the module. KPE works with any public key algorithm that has a SubjectPublicKeyInfo encoding, including RSA, ECDSA and ML-DSA. 1.1. Non-Goals This document does not: * attest the quality of the module's random bit generator, or the entropy of any key; * show how many copies of the private key exist or which modules hold them. Exportability (Section 3) can show only that the key cannot leave modules. The rest is covered by policy and audit (for example, [CABF-BR]); * specify when a KPE file is required. That is left to the policies of CAs and root programs. 1.2. Relationship to Other Work This document depends on no other attestation specification. Appendix B shows how the statements of a KPE file can be carried in a certification request as described in [I-D.ietf-lamps-csr-attestation], and how a KPE file can be carried in a Conceptual Message Wrapper [RFC9999]. The evidence format for hardware security modules that [I-D.ietf-rats-pkix-key-attestation] defines could be registered as an Evidence Format (Section 6) once it is published (Appendix F). The roles in this document map onto the RATS architecture [RFC9334]: the Module is the Attester, the Module Vendor is the Endorser, and the party that checks a KPE file is the Verifier. The PKI Consortium maintains a list of modules and services that support key attestation, together with instructions for verifying the evidence of some of them [PKIC-RKA]. It is concerned with keys of subscribers, such as code signing keys, and leaves the choice of the properties to be checked to the module vendor and the verifier. The properties that it names as typical, that the key was generated in the module and cannot be exported, correspond to Origin and Li Expires 21 May 2027 [Page 5] Internet-Draft CA Key Provenance Evidence November 2026 Exportability (Section 3). This document applies the same approach to CA keys and adds a file format, a registry of Evidence Formats, and the requirements that an Evidence Format has to meet. 2. Conventions and Definitions 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. Cryptographic Module (Module): A hardware security module or similar device that generates and stores private keys and performs operations with them inside a protected boundary, for example a module validated under [FIPS140-3]. Module Vendor: The entity that manufactures a Module and operates the public key infrastructure used to certify the Module's attestation keys. Vendor Trust Anchor: A trust anchor, published by a Module Vendor, to which the attestation keys of the vendor's Modules chain. Module Evidence: Data about a key held by a Module: content that the Module signed with an attestation key that chains to a Vendor Trust Anchor, together with any further data that the Evidence Format needs to verify it, such as certificates. Evidence Format: A specification of one kind of Module Evidence and of how to verify it, identified by an object identifier and listed in the registry defined in Section 10.2. Subject Key: The public key whose provenance a KPE file shows. Assembler: The party that creates a KPE file. Usually the CA operator. The Assembler is not trusted by the Verifier. Verifier: A party that checks a KPE file, for example a CA about to issue a certificate for the Subject Key, a root program, an auditor, or a relying party. 3. Provenance Facts Verifying a piece of Module Evidence under its Evidence Format yields the following Provenance Facts. An Evidence Format specification defines how each fact is derived (Section 6). If a fact cannot be derived, its value is "unknown". Li Expires 21 May 2027 [Page 6] Internet-Draft CA Key Provenance Evidence November 2026 Attested Key: The public key that the Module Evidence is about. Origin: One of "generated", "not-generated" or "unknown". "generated" means that a Module created the private key from the output of its own random bit generator, and that no party outside the Module supplied the private key, a seed, or any other value from which the private key can be computed (Section 9.6). That Module is either the Module that produced the evidence, or a Module from which the key was cloned or restored by a mechanism that the Evidence Format specification identifies as preserving this fact. A mechanism preserves this fact only if no party outside a Module can create or change the Origin that the receiving Module records, for example because the transfer is protected by keys that can be used only inside Modules. "not- generated" means that the Module that produced the evidence reports that the private key entered it from outside, for example by import, unwrapping or derivation, and not by a mechanism that preserves "generated". This does not show that no other Module generated the key. Origin describes how the key came into existence or into the Module. Exportability: One of "not-exportable", "exportable" or "unknown". "not-exportable" means that no function of a Module has made the private key, or any value from which it can be computed, available outside Modules since the key was created in or brought into a Module, and that nobody, including the operator of the Module, can cause this later, for example by changing an attribute of the key, the configuration of a Module or its firmware. Functions that transfer the key between Modules, for example for backup or cloning, are excluded if the Evidence Format specification identifies them as keeping the key inside Modules. A function keeps the key inside Modules only if no party outside a Module can obtain the key from what the function transfers, every Module that can receive the key is subject to the same restrictions, and no party outside a Module can create or change the Exportability that the receiving Module records. "exportable" means that the Module Evidence shows that a function of a Module could have made the key available outside Modules in another way, or still can, for example because the key is or was marked as extractable. Module Description: Information about two Modules, which can be the same Module. The Producing Module is the Module that produced the evidence, as it was when it produced the evidence. The Generating Module is the Module that generated the key, as it was when it generated the key. For each of them, the Module Description can give the Module Vendor, the Module model, the firmware version, the Module serial number, and identifiers of validation certificates for the Module, such as a [FIPS140-3] certificate Li Expires 21 May 2027 [Page 7] Internet-Draft CA Key Provenance Evidence November 2026 number. A value describes the Generating Module only if the Evidence Format specification says so. Otherwise it describes the Producing Module. Values that the Module Evidence does not give are "unknown". Trust Path: The certification path from the key that signed the Module Evidence to a Vendor Trust Anchor, including the identity of that anchor. 4. Cryptographic Binding A Verifier checks the chain in Figure 1 from the certificate upwards, in three steps. Every Evidence Format MUST support all three, and the Verification Procedure (Section 7) performs all three. Certificate to KPE file: The SubjectPublicKeyInfo in the certificate or certification request is byte-for-byte identical to subjectKey. This check needs no cryptography, because the Verifier holds both values. KPE file to Module Evidence: The Module Evidence contains a signature over some signed content, made with an attestation key that is held inside the Module. The signed content MUST include the Attested Key, either as the complete public key or as a hash of it. The included key, or the data that is hashed, MUST determine the public key algorithm, all of its parameters, and the key value. The hash function MUST provide at least 128 bits of security against second preimages, and SHOULD provide at least 384 bits, as SHA-384 and SHA-512 do [FIPS180-4]. Appendix D explains these values. The Verifier compares the Attested Key with subjectKey as described in Section 7. The signed content MUST also establish the Origin of the private key corresponding to the Attested Key, either through a value in the signed content or because the Module produces signed content of this kind only for keys with one Origin. Where the Evidence Format supports Exportability, the same applies to it. The origin or the attributes of a public key object are not sufficient, because a public key can be placed in a Module without its private key. Module Evidence to Vendor Trust Anchor: The attestation key is certified by a chain of signatures, the Trust Path, that ends at a Vendor Trust Anchor. The Evidence Format specification defines how the Trust Path is validated (Section 6). If the Trust Path consists of X.509 certificates, the Verifier validates it as described in Section 6 of [RFC5280], except where the Evidence Format specification states a different rule. Li Expires 21 May 2027 [Page 8] Internet-Draft CA Key Provenance Evidence November 2026 It is not enough that the Trust Path ends at a Vendor Trust Anchor. The Verifier MUST also check that the Trust Path identifies the attestation key as a key that the Module Vendor has designated for signing Module Evidence of this Evidence Format, for example through an extended key usage in its certificate (Section 9.4). The Module Vendor asserts that such a key can be used only inside a Module, and that a Module uses it only to sign content that the Module itself constructs. The Verifier cannot check this assertion and relies on the Module Vendor for it. The signed content MUST have only one interpretation under the Evidence Format specification, including when it contains values that the operator of the Module chose, such as a key label (Section 9.5). Every signature that the Verifier relies on, that is, the signature over the signed content and each signature in the Trust Path, MUST use an algorithm and a key size that provide a security strength of at least 112 bits, and SHOULD provide at least 128 bits (see, for example, [SP800-57]). The hash function of such a signature MUST be collision resistant. A Verifier MUST NOT accept a signature that uses MD5 or SHA-1. This is stricter than the requirement for the hash of the Attested Key, because signed content can contain values that the operator of the Module chose (Section 9.5). The self- signature of a trust anchor is not relied on and is outside this requirement. A Verifier MUST take every Provenance Fact from content covered by a signature that it has verified: either the signed content of the Module Evidence or a certificate in the Trust Path. Everything else in a KPE file can be written or changed by whoever assembles the file. This includes subjectKey, format, and any data in the Module Evidence that no verified signature covers. The Verifier MUST NOT use any of it as the source of a Provenance Fact. Assume that Modules and the Module Vendor behave as the Evidence Format specification states. Then a KPE file that passes verification for a given SubjectPublicKeyInfo can exist only if one of the following happened: 1. a Module generated the corresponding private key, and that Module, or a Module that received the key through a mechanism that preserves Origin (Section 3), signed evidence for that key; 2. someone forged a signature of the attestation key or of a key in the Trust Path, or found two different contents with the same hash under the hash function of such a signature; Li Expires 21 May 2027 [Page 9] Internet-Draft CA Key Provenance Evidence November 2026 3. the Attested Key is included as a hash, and someone found a different public key with the same hash. If the Verifier also requires Exportability "not-exportable", the first case further means that no function of a Module has made the private key available outside Modules, or can do so (Section 3). So, beyond the correct behavior of Modules and the Module Vendor, the security of KPE rests on the unforgeability of the signatures that the Verifier checks, on the collision resistance of their hash functions, and on the second-preimage resistance of the hash that identifies the Attested Key. The assumption of correct behavior carries real weight. It includes that an attestation key signs nothing except content that the Module constructed, that the operator of a Module cannot extract its attestation key, that a Module records a key as generated only if the key meets the definition in Section 3, and that a key leaves a Module only through the functions that the Evidence Format specification lists. Section 6 requires each Evidence Format specification to state how these properties are met. Section 9.3 and Section 9.4 describe what follows when they are not. 5. Key Provenance Evidence File 5.1. Structure A KPE file is the DER [X.690] encoding of the following ASN.1 [X.680] structure. The complete ASN.1 module is in Appendix A. KeyProvenanceEvidence ::= SEQUENCE { version KPEVersion, subjectKey SubjectPublicKeyInfo, statements SEQUENCE SIZE (1..MAX) OF ProvenanceStatement } KPEVersion ::= INTEGER { v1(0) } ProvenanceStatement ::= SEQUENCE { format OBJECT IDENTIFIER, evidence OCTET STRING } version: MUST be v1 for files that conform to this document. subjectKey: The SubjectPublicKeyInfo of the Subject Key, in the same DER encoding that appears in certificates and certification requests [RFC2986] for the key. statements: One or more pieces of Module Evidence about the Subject Li Expires 21 May 2027 [Page 10] Internet-Draft CA Key Provenance Evidence November 2026 Key. format: The object identifier of the Evidence Format of this statement, as registered in Section 10.2. evidence: The Module Evidence, encoded as its Evidence Format specifies. The encoding can be a container that host software assembles. The Assembler MUST carry signed content in the exact encoding over which the signature was computed. A KPE file has no signature of its own. The Verifier uses version and format only to decode the file and to select an Evidence Format, and uses subjectKey only to compare it with the certificate and with the Attested Key (Section 7). It takes the Provenance Facts from signed content only (Section 4). 5.2. Textual Encoding A KPE file MAY be represented in the textual encoding of [RFC7468] with the label "KEY PROVENANCE EVIDENCE": -----BEGIN KEY PROVENANCE EVIDENCE----- (base64 encoding of the DER-encoded KeyProvenanceEvidence) -----END KEY PROVENANCE EVIDENCE----- 5.3. Media Type The media type "application/key-provenance-evidence" (Section 10.3) identifies a KPE file in its DER encoding. It is not used for the textual encoding. The file extension for the DER encoding is ".kpe". 5.4. Assembling a KPE File To produce a KPE file for a CA key, the CA operator: 1. generates the key pair inside a Module; 2. obtains Module Evidence for the key, as described by the Evidence Format specification. The CA operator SHOULD do this during the key generation ceremony, before the public key is used in any certification request or certificate, and SHOULD record the evidence in the ceremony log; 3. sets subjectKey to the SubjectPublicKeyInfo of the key; 4. places the Module Evidence in statements. Li Expires 21 May 2027 [Page 11] Internet-Draft CA Key Provenance Evidence November 2026 Statements MAY be added to an existing KPE file later. For example, the operator might add evidence from a backup Module, or evidence in a newer Evidence Format. 6. Evidence Format Specifications An Evidence Format specification MUST be publicly available and MUST contain: 1. the object identifier of the Evidence Format; 2. the encoding of the Module Evidence carried in the evidence field, including any container that host software assembles; 3. which part of the Module Evidence is the signed content, how to verify the signature over it, and which signature algorithms are allowed (Section 4); 4. how to parse the signed content so that it has only one interpretation (Section 4). This includes how values that the operator of the Module chose, such as key labels, are delimited, and which signed value tells the Verifier which version or layout of the signed content it has; 5. how to build the Trust Path and how to validate it at the time of verification: which signatures are verified, which algorithms are allowed, and how validity periods and revocation status are checked, or a statement that the mechanism has none. This item also says where the Vendor Trust Anchors are published; 6. how the Verifier recognizes from the Trust Path that the Module Vendor has designated the attestation key for signing Module Evidence of this Evidence Format (Section 4), for example by an extended key usage, a policy identifier, or the position of its certificate under a specific vendor CA. The specification states what the Module Vendor asserts about keys with this designation: that they can be used only inside a Module, and that a Module uses them only to sign content that the Module itself constructs. It also states what else the attestation key and the other keys in the Trust Path sign, and why none of that can be accepted as Module Evidence of this Evidence Format; 7. which signatures and which Trust Path are required when the Module Evidence carries more than one, for example a chain from the Module Vendor and a chain from a service provider that hosts the Module; Li Expires 21 May 2027 [Page 12] Internet-Draft CA Key Provenance Evidence November 2026 8. how to derive each of the Provenance Facts in Section 3 from signed content. This includes whether the Attested Key is included as the complete public key or as a hash, which hash function is used, how the Attested Key is compared with a SubjectPublicKeyInfo, and how the signed content shows that the Origin, and the Exportability if supported, are those of the private key corresponding to the Attested Key; 9. how the Module determines Origin. For example, a Module might use a key attribute that it sets at generation and does not allow to change, such as CKA_LOCAL in [PKCS11]. The specification lists the ways of creating a key that result in "generated", and states whether any of them accepts a seed or another secret value from outside the Module; 10. whether the Evidence Format supports Exportability, and if so, how the Module determines it. The specification lists every function by which a Module can let a private key, or a value from which it can be computed, leave it, including wrapping, backup, cloning, splitting into shares, and vendor-specific functions. For each function it states whether the function keeps the key inside Modules (Section 3) and why, to which Modules it can transfer the key, and whether it can be enabled later for an existing key. For example, a Module that implements [PKCS11] might use the attribute CKA_NEVER_EXTRACTABLE, which the Module sets and which is true only if the key has never been extractable, together with a statement about the backup and cloning functions of the Module, which that attribute does not necessarily control; 11. under which conditions the Module produces the Module Evidence; whether it can be produced for a key some time after the key was generated; and whether Origin and Exportability are preserved when the key is backed up, cloned or otherwise transferred to another Module. If either is preserved, the specification states by which mechanism, why the mechanism meets the conditions in Section 3, and which Modules can be the source of such a transfer; 12. which Module models and firmware versions produce the Module Evidence, and how the Verifier establishes from signed data that the Producing Module is one of them and is a production unit, not a development unit, an emulator, or a unit in a test mode; Li Expires 21 May 2027 [Page 13] Internet-Draft CA Key Provenance Evidence November 2026 13. whether code that the operator can load into the Module can affect key generation, key attributes, the functions by which keys leave the Module, or the content of the Module Evidence, and if so, how the Module Evidence shows that the Module allows or contains such code. The derivation of Origin MUST be sound. It yields "generated" only if, for Modules that behave as the specification states, the signed content could not have been produced for a key that does not meet the definition of "generated" in Section 3. The same applies to "not- exportable" and the derivation of Exportability. Where this depends on something that the Module Evidence does not show, such as how a wrapping key was created or whether a backup function can be enabled, the derivation yields "unknown". An Evidence Format specification SHOULD state which values of the Module Description describe the Generating Module (Section 3). If the Module records the firmware version that was in use when the key was generated, the Module Evidence SHOULD include it. An Evidence Format specification SHOULD provide test vectors and SHOULD reference a verifier implementation that is publicly available. Editor's note: Existing vendor key attestation mechanisms are candidates for registration. Appendix E summarizes what their public documentation shows. Whether each of them supports deriving the Provenance Facts, including Exportability, and meets the requirements of Section 4, for each key algorithm of interest, has not been confirmed with the vendors yet. 7. Verification Procedure Inputs: * a KPE file; * the SubjectPublicKeyInfo S of the certificate or certification request being checked; * the Verifier's policy: the Evidence Formats that the Verifier accepts; for each of them, the Vendor Trust Anchors that it accepts; the rules that decide whether a Module Description is acceptable; and whether it requires Exportability "not- exportable". The Verifier performs the following steps: Li Expires 21 May 2027 [Page 14] Internet-Draft CA Key Provenance Evidence November 2026 1. Decode the KPE file. If it is not the DER encoding of one KeyProvenanceEvidence value with no data after it, or version is not v1, the verification fails. 2. If subjectKey is not byte-for-byte identical to S, the verification fails. 3. For each ProvenanceStatement: 1. If the Verifier does not implement the Evidence Format identified by format, or its policy does not accept that Evidence Format, skip the statement. 2. Parse the Module Evidence, verify the signature over the signed content, and validate the Trust Path as of the time of verification, all as the Evidence Format specification describes. This includes checking that the attestation key and the other keys in the Trust Path have the roles that the specification requires, and that every signature meets the requirements of Section 4. Derive the Provenance Facts from signed content only. If any of this fails, or if the Module Evidence deviates from the form that the specification defines, for example by a repeated element or by unexpected data, skip the statement. 3. The statement is satisfying if all of the following hold: * the Attested Key is the same public key as subjectKey. If the signed content includes the complete public key, the comparison MUST be made on the decoded public key, that is, the algorithm, its parameters, and the key value, and not on an encoding. If it includes a hash, the Verifier computes the hash from subjectKey as the Evidence Format specification describes and compares the two values. If either key cannot be decoded unambiguously, the statement is not satisfying; * Origin is "generated"; * if the Verifier's policy requires it, Exportability is "not-exportable"; * the Trust Path ends at a Vendor Trust Anchor that the Verifier accepts for this Evidence Format; * the Module Description is acceptable under the Verifier's policy. Li Expires 21 May 2027 [Page 15] Internet-Draft CA Key Provenance Evidence November 2026 4. If at least one statement is satisfying, the verification succeeds. Otherwise it fails. On success, the Verifier's result is the Provenance Facts of a satisfying statement. A Verifier MUST NOT treat "unknown" as satisfying any condition in step 3.3. 8. Use in Certificate Issuance and Disclosure Where a policy requires a KPE file, the following applies: * A CA that issues a certificate to another CA, including a cross- certificate, verifies a KPE file for the Subject Key before issuance, using the SubjectPublicKeyInfo of the certification request or the to-be-signed certificate as S. * A CA operator makes the KPE file for each of its CA keys, including those of root CAs, available to root programs and other parties that the policy names. For example, the operator might publish it alongside the key ceremony report. * A KPE file can be produced for a key that is already in service if the Evidence Format supports producing Module Evidence for existing keys. This allows existing CA keys to be checked retroactively. A key that a Module did not generate, for example a key generated outside any Module and then imported, cannot obtain a KPE file that passes verification. A policy that introduces KPE can therefore apply it to keys generated after a given date. A Verifier gets the same result no matter who delivers the file or how it is delivered. A KPE file can therefore be sent with a certification request, published in a repository, or exchanged by any other means. Appendix B describes how its content can be carried in structures that other specifications define. A KPE file is about a key, not about a certificate. It applies to every certificate for the Subject Key, including cross-certificates, for as long as any of them is in use. 9. Security Considerations Li Expires 21 May 2027 [Page 16] Internet-Draft CA Key Provenance Evidence November 2026 9.1. What Is and Is Not Shown A successful verification shows that the private key for the Subject Key was generated inside a Module. It shows what happened to the key afterwards only if the Verifier requires Exportability "not- exportable": then no function of a Module has made the key available outside Modules, or can do so. It does not show how many copies of the key exist inside Modules, or where they are. It also does not show that the Module's random bit generator worked correctly. A key generated by a Module with a failed random bit generator passes verification. Such a failure is likely to affect every key and every signature produced by that Module, and is out of scope for this document. KPE detects the substitution of a key that the Module did not generate, whether or not the substituted key is weak. With Exportability "not-exportable", it also detects a key that a Module generated but let leave, for example by wrapping it under a key that host software holds (Appendix C). A successful verification also does not show who operated the Module that generated the key. Anyone who has a Module of an accepted model can obtain valid Module Evidence for the keys that this Module generates. A policy that requires the key to come from a particular Module, for example one listed in the audited inventory of the CA, has to compare the serial number in the Module Description with that record. 9.2. Trust in Module Vendors The facts shown by KPE are only as reliable as the Module Vendor's attestation keys and the Module firmware. If an attestation key or a Vendor Trust Anchor is compromised, false Module Evidence can be produced. The same is true if a firmware version reports Origin or Exportability incorrectly, or if a later firmware version lets a key that earlier evidence reported as "not-exportable" leave the Module. Verifier policies SHOULD let the Verifier stop accepting a Vendor Trust Anchor, an Evidence Format, specific Module models or firmware versions, and individual Modules identified by their serial numbers (Section 9.3). This document does not defend against a Module or a Module Vendor that is malicious. The registration of an Evidence Format (Section 10.2) shows that a specification exists and covers the items in Section 6. It does not show that the mechanism is secure. A Verifier decides for itself which Evidence Formats it accepts. Li Expires 21 May 2027 [Page 17] Internet-Draft CA Key Provenance Evidence November 2026 9.3. The Operator as Adversary In the cases that KPE is meant to detect, the false statement about a key comes from the CA operator, by mistake or on purpose. The CA operator has physical possession of the Module, administers it, controls the host software, and chooses every value that the Module's interface lets a user choose. The verification procedure trusts none of this. It trusts only what the Module signs. KPE therefore depends on the Module protecting its attestation key and its record of each key's Origin and Exportability against its own operator. If the operator of a Module extracts its attestation key, the operator can produce Module Evidence for any public key, with any Origin or Exportability, and that evidence verifies under the Vendor Trust Anchor. The resistance of the Module to physical and logical attacks by the party that holds it, as assessed for example in a validation under [FIPS140-3], is therefore part of the security of KPE. A Verifier policy can require such a validation through the Module Description. Evidence forged in this way carries the identity of the Module whose attestation key was extracted. This is why a Verifier should be able to stop accepting an individual Module (Section 9.2), in particular where the vendor mechanism has no revocation (Section 9.11). 9.4. Attestation Keys and Other Keys Under the Same Trust Anchor A chain of signatures to a Vendor Trust Anchor shows that the vendor, or a device of the vendor, certified a key. It does not show what that key is for. A vendor can use one trust anchor for several product lines, for development units and emulators, and for keys with other purposes, such as keys of smart cards or keys that sign time stamps or logs. Some Modules also let the operator choose which key signs evidence. That key can be one that the operator imported, or one that can also sign arbitrary data, and the Module can certify it with a key that chains to the Vendor Trust Anchor. Li Expires 21 May 2027 [Page 18] Internet-Draft CA Key Provenance Evidence November 2026 If a Verifier accepted a signature from any key that chains to the trust anchor, the operator could obtain false Module Evidence without breaking any algorithm, for example by writing the content of the evidence and having a general-purpose signing key sign it. For this reason Section 4 requires the Verifier to establish that the Module Vendor designated the attestation key for this purpose, and Section 6 requires each Evidence Format specification to say how. This check does not remove the need to trust the Module Vendor. It limits that trust to the keys about which the vendor makes its assertion, and excludes every other key under the same trust anchor. The same care applies to every other key in the Trust Path: a certificate is accepted at a given position only if its key is allowed to sign what follows it. A service provider that hosts Modules can add its own signature or its own certificate chain to the Module Evidence. Such a chain shows that the provider vouches for the Module. It does not replace the Trust Path to the Vendor Trust Anchor. A Verifier that accepted the provider's chain alone would be trusting the provider, not the Module Vendor. For the same reason, a Verifier accepts a Vendor Trust Anchor only for the Evidence Formats for which it is meant (Section 7). Content that is harmless under the rules of one Evidence Format can have a different meaning under the rules of another. 9.5. Operator-Chosen Values in Signed Content Signed content often contains values that the operator of the Module chose: key labels, identifiers, usage policies, or a challenge supplied with the request. The Module signs them together with the facts that matter. This allows two attacks that need no access to any key. The first attack uses an ambiguous encoding. If a chosen value can be read as part of the surrounding structure, for example a label that contains markup in a text-based format, the operator can make the Module sign content that a tolerant parser reads as evidence about a different key or with different Provenance Facts. Section 4 therefore requires that signed content has only one interpretation, and Section 7 requires the Verifier to reject Module Evidence that deviates from the defined form. Searching the signed content for a field name is not a safe way to parse it. The second attack uses hash collisions. If the signature is computed with a hash function that is not collision resistant, the operator may be able to prepare two contents with the same hash that differ in the key or in a Provenance Fact, have the Module sign the harmless Li Expires 21 May 2027 [Page 19] Internet-Draft CA Key Provenance Evidence November 2026 one, and attach the signature to the other. Chosen-prefix collisions of this kind are practical for MD5 and SHA-1 [SHAMBLES]. Section 4 therefore requires collision-resistant hash functions in signatures. The hash that identifies the Attested Key is a different matter (Appendix D). 9.6. Key Generation Inputs A key that a Module computes from a seed or another secret value supplied from outside does not have Origin "generated" (Section 3), even if the Module's interface calls the operation key generation. Standard interfaces keep the two apart. For example, [PKCS11] does not allow the seed of an ML-DSA key to be supplied when the key is generated, and it marks keys that are created from supplied values, unwrapped or derived as not locally generated. Vendor-specific functions do not necessarily follow the same rule. This is why Section 6 requires an Evidence Format specification to list the ways of creating a key that result in "generated". The operator still chooses the public inputs of key generation: the algorithm, the key size, and parameters such as an RSA public exponent or an elliptic curve. Origin "generated" does not show that these were chosen well. A key that a Module generated over a weak group selected by the operator is a weak key. These choices are visible in the SubjectPublicKeyInfo. A Verifier therefore applies its own requirements for algorithms, key sizes and parameters to S, as it would without KPE. For elliptic curve keys, [RFC5480] already requires that the curve is identified by name. Some Modules can run code that the operator loads into the protected boundary. Depending on the product, such code might influence how keys are generated, which attributes they get, or what the Module signs. Section 6 requires an Evidence Format specification to cover this. If such code can affect the Origin or the Exportability that the Module reports, and the Module Evidence does not show whether it was present, the derivation of that fact yields "unknown". 9.7. Unauthenticated Container Anyone can create or modify a KPE file. This is safe because a Verifier accepts a file only if one statement contains Module Evidence that verifies under an accepted Vendor Trust Anchor and whose Attested Key equals subjectKey, and only if subjectKey equals the certificate's SubjectPublicKeyInfo (Section 7). Li Expires 21 May 2027 [Page 20] Internet-Draft CA Key Provenance Evidence November 2026 9.8. Key Comparison Vendor formats can encode public keys differently from a SubjectPublicKeyInfo. For example, an elliptic curve point can be compressed or uncompressed. For this reason, step 3.3 compares decoded public keys, or a hash computed as the Evidence Format specifies. Step 2 compares encodings byte for byte, because the CA operator supplies both the KPE file and the SubjectPublicKeyInfo to be certified, and a byte comparison leaves no room for ambiguity. 9.9. Backup and Cloning CA keys are routinely backed up or cloned to other Modules. Some Modules record Origin only in the Module that generated the key. In that case, the Module Evidence has to be obtained from the generating Module, or obtained before the key is cloned. The CA operator should plan for this in the key ceremony. Keys also move between Modules by wrapping and unwrapping. With standard interfaces, a key that enters a Module in this way is not marked as locally generated (Section 9.6). Keys that move between Modules of different vendors usually move in this way. Module Evidence with Origin "generated" for such a key can then come only from the Module that generated it, or from a Module that received the key from it by a mechanism that preserves Origin. If none of these Modules supports an Evidence Format that the Verifier accepts, the key cannot obtain such evidence, even if every step of the transfer was carried out correctly. Vendor-specific mechanisms for cloning, backup and restore are different. They carry the attributes of the key with it, and the receiving Module records the Origin that the transfer conveys. Such a mechanism preserves Origin only under the condition stated in Section 3. In particular, if the operator can choose or learn the key that protects the transfer, the operator can construct a transfer that conveys any Origin. Wrapping also affects Exportability. A key wrapped under a key that the operator can choose or learn has been available outside Modules, because the operator can unwrap it outside any Module. With standard interfaces, such a key cannot be reported as "not-exportable": in [PKCS11], a key can be wrapped only if its CKA_EXTRACTABLE attribute is true, and a key that has ever had this attribute set to true has CKA_NEVER_EXTRACTABLE false. Vendor-specific backup and cloning functions often do not depend on these attributes, which is why Section 6 requires an Evidence Format specification to list them. A CA operator whose keys have to meet a policy that requires "not- exportable" has to choose, before generating a key, a backup and cloning method that keeps the key inside Modules. Li Expires 21 May 2027 [Page 21] Internet-Draft CA Key Provenance Evidence November 2026 When Origin is preserved across transfers, "generated" in evidence from the receiving Module means that some Module among the possible sources generated the key. The assurance is that of the weakest Module that can be a source. That Module might be an older model, run an earlier firmware version, or be configured differently. Unless the Module Evidence describes the Generating Module, a Verifier that accepts such an Evidence Format accepts every source that the Evidence Format specification names (Section 6). Likewise, "not-exportable" is only as strong as the weakest Module to which the key can be transferred. 9.10. Replay Module Evidence records how a key came into existence and, through Exportability, whether the key can ever leave Modules. Neither changes over time. Presenting the same evidence again for the same key conveys facts that are still true. Evidence for one key cannot be presented for another key (Section 4). KPE therefore needs no nonce or other freshness mechanism. KPE does not show that a key is still held by a Module today. A Verifier that needs to know that has to use a different mechanism. 9.11. Verification Over Time A Verifier validates the Trust Path as of the time of verification. Module Evidence whose Trust Path has since expired or been revoked fails verification, even if the path was valid when the Module produced the evidence. In that case the CA operator can obtain new Module Evidence for the key, if the Evidence Format supports producing evidence for existing keys (Section 6) and the Module Vendor provides a Trust Path that is valid at that time, for example by issuing a new certificate for the attestation key. If the vendor does not, the key no longer passes verification. This approach avoids having to establish, years later, when a piece of evidence was produced. Not every vendor mechanism has validity periods or revocation, and an Evidence Format specification states which checks apply (Section 6). Where a mechanism has neither, a Trust Path stops being acceptable only when the Verifier's policy stops accepting it (Section 9.2). The Producing Module and the Generating Module (Section 3) can differ, for example after cloning, and a Module's firmware can be updated after the Module generated the key. A Verifier policy that distrusts a firmware version because of a fault in key generation needs the firmware version of the Generating Module. A policy that distrusts a firmware version because of a fault in producing evidence needs that of the Producing Module. When the Module Evidence does Li Expires 21 May 2027 [Page 22] Internet-Draft CA Key Provenance Evidence November 2026 not describe the Generating Module, a policy of the first kind fails. It does not fall back to the firmware version of the Producing Module. 9.12. Disclosure of Module Information A KPE file reveals the Module Vendor, the model, the firmware version and possibly the serial number of the Module that produced the evidence, and possibly of the Module that generated the key. This information helps an attacker choose an attack against a specific firmware version. CA operators and policy authors should weigh this when deciding where KPE files are published. 10. IANA Considerations 10.1. ASN.1 Module Identifier IANA is requested to assign an object identifier for the ASN.1 module in Appendix A in the "SMI Security for PKIX Module Identifier" registry (1.3.6.1.5.5.7.0), with the description "id-mod-key- provenance-2026" and a reference to this document. 10.2. Key Provenance Evidence Formats Registry IANA is requested to create a registry titled "Key Provenance Evidence Formats". Each entry has the following fields: Object Identifier: The identifier of the Evidence Format. It MAY be allocated from any object identifier arc that the registrant controls. It identifies Module Evidence that is carried in an OCTET STRING, as in the evidence field (Section 5). An object identifier that another specification uses with a different meaning, or for a value of a different ASN.1 type, MUST NOT be registered. Name: A short descriptive name. Specification: A reference to the publicly available Evidence Format specification. Change Controller: The entity that can change the specification, normally the Module Vendor. The registration policy is Specification Required [RFC8126]. The designated experts should check that: * the specification is publicly available and stable; Li Expires 21 May 2027 [Page 23] Internet-Draft CA Key Provenance Evidence November 2026 * the specification covers every item listed in Section 6, in particular which content is signed and how each Provenance Fact is derived from it; * the encoding, the meaning of the Object Identifier, and the verification rules are described in enough detail that independent implementations can interoperate; * the Object Identifier is not already registered and is not used elsewhere with a different meaning or type. The experts are not asked to evaluate the security of the mechanism or of any product (Section 9.2). A third party MAY register an Evidence Format that a Module Vendor has deployed and publicly documented, if the experts find that the vendor documentation covers the items in Section 6. In that case the Module Vendor is recorded as the Change Controller. The registry is initially empty. 10.3. Media Type Registration IANA is requested to register the following media type in the "Media Types" registry, in accordance with [RFC6838]. Type name: application Subtype name: key-provenance-evidence Required parameters: N/A Optional parameters: N/A Encoding considerations: binary Security considerations: See the Security Considerations section of this document. A KPE file contains no active content. It has no signature of its own, and a recipient relies on it only through the verification procedure in Section 7. Interoperability considerations: N/A Published specification: This document Applications that use this media type: Software of certification authorities, root programs and auditors that produces, publishes or verifies Key Provenance Evidence. Li Expires 21 May 2027 [Page 24] Internet-Draft CA Key Provenance Evidence November 2026 Fragment identifier considerations: N/A Additional information: Deprecated alias names for this type: N/A. Magic number(s): N/A. File extension(s): .kpe. Macintosh file type code(s): N/A. Person & email address to contact for further information: See the Authors' Addresses section of this document. Intended usage: COMMON Restrictions on usage: N/A Author: See the Authors' Addresses section of this document. Change controller: IETF Provisional registration? (standards tree only): No 11. References 11.1. Normative References [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, DOI 10.17487/RFC2119, March 1997, . [RFC5280] Cooper, D., Santesson, S., Farrell, S., Boeyen, S., Housley, R., and W. Polk, "Internet X.509 Public Key Infrastructure Certificate and Certificate Revocation List (CRL) Profile", RFC 5280, DOI 10.17487/RFC5280, May 2008, . [RFC5912] Hoffman, P. and J. Schaad, "New ASN.1 Modules for the Public Key Infrastructure Using X.509 (PKIX)", RFC 5912, DOI 10.17487/RFC5912, June 2010, . [RFC7468] Josefsson, S. and S. Leonard, "Textual Encodings of PKIX, PKCS, and CMS Structures", RFC 7468, DOI 10.17487/RFC7468, April 2015, . [RFC8126] Cotton, M., Leiba, B., and T. Narten, "Guidelines for Writing an IANA Considerations Section in RFCs", BCP 26, RFC 8126, DOI 10.17487/RFC8126, June 2017, . Li Expires 21 May 2027 [Page 25] Internet-Draft CA Key Provenance Evidence November 2026 [RFC8174] Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174, May 2017, . [X.680] ITU-T, "Information technology - Abstract Syntax Notation One (ASN.1): Specification of basic notation", ITU-T Recommendation X.680, February 2021. [X.690] ITU-T, "Information technology - ASN.1 encoding rules: Specification of Basic Encoding Rules (BER), Canonical Encoding Rules (CER) and Distinguished Encoding Rules (DER)", ITU-T Recommendation X.690, February 2021. 11.2. Informative References [AZURE-ATTEST] Microsoft, "Validate Azure Key Vault Managed HSM keys with key attestation", 30 January 2026, . [C4A-ATTEST] Crypto4A, "Attestation using the QASM", Document C4A- 302-0043, n.d., . [CABF-BR] CA/Browser Forum, "Baseline Requirements for the Issuance and Management of Publicly-Trusted TLS Server Certificates", Version 2.3.1, 4 October 2026, . [EMUDHRA-REPORT] eMudhra, "Full Incident Report", Mozilla Bugzilla, Bug 2083449, eMudhra: Private key compromise of Intermediate Certificates, Comment 82, 10 November 2026, . [FIPS140-3] National Institute of Standards and Technology, "Security Requirements for Cryptographic Modules", FIPS 140-3, DOI 10.6028/NIST.FIPS.140-3, 22 March 2019, . Li Expires 21 May 2027 [Page 26] Internet-Draft CA Key Provenance Evidence November 2026 [FIPS180-4] National Institute of Standards and Technology, "Secure Hash Standard (SHS)", FIPS 180-4, DOI 10.6028/NIST.FIPS.180-4, 4 August 2015, . [GCP-ATTEST] Google Cloud, "Verify attestations", Cloud Key Management Service documentation, n.d., . [GCP-EKCV] Google Cloud, "Verify an imported key version", Cloud Key Management Service documentation, n.d., . [I-D.ietf-lamps-csr-attestation] Ounsworth, M., Tschofenig, H., Birkholz, H., Wiseman, M., and N. Smith, "Use of Remote Attestation with Certification Signing Requests", Work in Progress, Internet-Draft, draft-ietf-lamps-csr-attestation-33, 2 November 2026, . [I-D.ietf-rats-pkix-key-attestation] Fiset, J., Ounsworth, M., Tschofenig, H., Birkholz, H., Wiseman, M., and N. Smith, "Evidence Encoding for Hardware Security Modules", Work in Progress, Internet-Draft, draft-ietf-rats-pkix-key-attestation-08, 30 October 2026, . [KELSEY-SCHNEIER] Kelsey, J. and B. Schneier, "Second Preimages on n-bit Hash Functions for Much Less than 2^n Work", Advances in Cryptology - EUROCRYPT 2005, Lecture Notes in Computer Science, vol. 3494, pp. 474-490, DOI 10.1007/11426639_28, 2005, . [LUNA-CONFIRM] Thales, "Verifying HSM Authenticity or Key Attestation", n.d., . Li Expires 21 May 2027 [Page 27] Internet-Draft CA Key Provenance Evidence November 2026 [LUNA-GETPKC] Thales, "cmu getpkc", n.d., . [LUNA-PKCV] Thales, "luna-pkc-validator", Reference validator source code, n.d., . [MARVELL-ATTEST] Marvell, "LiquidSecurity HSM - Software Key Attestation", n.d., . [NSHIELD-KAF] Entrust, "Key Attestation Format", nShield Application Note, 2 June 2026, . [NSHIELD-WARRANTS] Entrust, "nShield Warrants", nShield Application Note, 2 June 2026, . [PKCS11] OASIS, "PKCS #11 Specification Version 3.2", OASIS Standard pkcs11-spec-v3.2-os, 3 June 2026, . [PKIC-RKA] PKI Consortium, "Remote Key Attestation", Cryptographic Module Working Group, n.d., . [RFC2986] Nystrom, M. and B. Kaliski, "PKCS #10: Certification Request Syntax Specification Version 1.7", RFC 2986, DOI 10.17487/RFC2986, November 2000, . [RFC5480] Turner, S., Brown, D., Yiu, K., Housley, R., and T. Polk, "Elliptic Curve Cryptography Subject Public Key Information", RFC 5480, DOI 10.17487/RFC5480, March 2009, . Li Expires 21 May 2027 [Page 28] Internet-Draft CA Key Provenance Evidence November 2026 [RFC6838] Freed, N., Klensin, J., and T. Hansen, "Media Type Specifications and Registration Procedures", BCP 13, RFC 6838, DOI 10.17487/RFC6838, January 2013, . [RFC8554] McGrew, D., Curcio, M., and S. Fluhrer, "Leighton-Micali Hash-Based Signatures", RFC 8554, DOI 10.17487/RFC8554, April 2019, . [RFC8809] Hodges, J., Mandyam, G., and M. Jones, "Registries for Web Authentication (WebAuthn)", RFC 8809, DOI 10.17487/RFC8809, August 2020, . [RFC9334] Birkholz, H., Thaler, D., Richardson, M., Smith, N., and W. Pan, "Remote ATtestation procedureS (RATS) Architecture", RFC 9334, DOI 10.17487/RFC9334, January 2023, . [RFC9999] Birkholz, H., Smith, N., Fossati, T., and H. Tschofenig, "Remote ATtestation procedureS (RATS) Conceptual Message Wrapper (CMW)", RFC 9999, DOI 10.17487/RFC9999, July 2026, . [SECUROSYS-AN] Securosys, "Primus HSM Audit & Attestation: Usage with Qualified Trust Service Providers", Application Note AN- E01, Edition 1 (v1.0.2), May 2023, . [SECUROSYS-ATTEST] Securosys, "Primus HSM - Attestation and Audit (Device, User, Key)", n.d., . [SHAMBLES] Leurent, G. and T. Peyrin, "SHA-1 is a Shambles: First Chosen-Prefix Collision on SHA-1 and Application to the PGP Web of Trust", 29th USENIX Security Symposium, pp. 1839-1856, 2020, . [SHATTERED] Stevens, M., Bursztein, E., Karpman, P., Albertini, A., and Y. Markov, "The First Collision for Full SHA-1", Advances in Cryptology - CRYPTO 2017, Lecture Notes in Computer Science, vol. 10401, pp. 570-596, Li Expires 21 May 2027 [Page 29] Internet-Draft CA Key Provenance Evidence November 2026 DOI 10.1007/978-3-319-63688-7_19, 2017, . [SP800-57] National Institute of Standards and Technology, "Recommendation for Key Management: Part 1 - General", NIST SP 800-57 Part 1 Rev. 5, DOI 10.6028/NIST.SP.800-57pt1r5, May 2020, . [YUBICO-OID] Yubico, "YubiHSM OIDs", n.d., . [YUBIHSM-CONCEPTS] Yubico, "YubiHSM 2 Core Concepts", YubiHSM 2 User Guide, n.d., . [YUBIHSM-OVERVIEW] Yubico, "YubiHSM 2 Product Overview", YubiHSM 2 User Guide, n.d., . [YUBIHSM-PY] Yubico, "python-yubihsm API Documentation: yubihsm.objects", n.d., . Appendix A. ASN.1 Module This module imports SubjectPublicKeyInfo from the PKIX1Explicit-2009 module in [RFC5912]. Li Expires 21 May 2027 [Page 30] Internet-Draft CA Key Provenance Evidence November 2026 KeyProvenanceEvidence-2026 { iso(1) identified-organization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) id-mod(0) id-mod-key-provenance-2026(TBD1) } DEFINITIONS EXPLICIT TAGS ::= BEGIN EXPORTS ALL; IMPORTS SubjectPublicKeyInfo FROM PKIX1Explicit-2009 { iso(1) identified-organization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) id-mod(0) id-mod-pkix1-explicit-02(51) } ; KeyProvenanceEvidence ::= SEQUENCE { version KPEVersion, subjectKey SubjectPublicKeyInfo, statements SEQUENCE SIZE (1..MAX) OF ProvenanceStatement } KPEVersion ::= INTEGER { v1(0) } ProvenanceStatement ::= SEQUENCE { format OBJECT IDENTIFIER, evidence OCTET STRING } END Appendix B. Carrying Provenance Statements in Other Structures This appendix is informative. It describes two ways to carry the content of a KPE file in structures that other specifications define (Section 8). B.1. Certification Requests [I-D.ietf-lamps-csr-attestation] defines how a certification request carries an AttestationBundle. An AttestationBundle contains one or more AttestationStatement values. Each AttestationStatement consists of an object identifier, type, which identifies the format of the statement, and a value, stmt, whose ASN.1 type that format defines. That document registers no statement formats. It leaves the object identifier to the specification of each format, and it asks a format that is not defined in ASN.1 to define an ASN.1 wrapper for it, for example an OCTET STRING. This description follows version 33 of that Li Expires 21 May 2027 [Page 31] Internet-Draft CA Key Provenance Evidence November 2026 document, which had not been published as an RFC when this appendix was written. A ProvenanceStatement (Section 5) has the same two fields as an AttestationStatement: format corresponds to type, and evidence corresponds to stmt. The only possible difference is the ASN.1 type of stmt. For an Evidence Format, that type is OCTET STRING, because the object identifier of an Evidence Format identifies Module Evidence that is carried in an OCTET STRING (Section 10.2). A ProvenanceStatement and an AttestationStatement with such an object identifier therefore have the same DER encoding, and a statement can be copied between a KPE file and an AttestationBundle without change. When statements are carried in a certification request in this way: * the request contains no subjectKey. The Verifier uses the SubjectPublicKeyInfo of the request as S and performs steps 3 and 4 of Section 7, with S in place of subjectKey, on the statements whose type is an Evidence Format that it accepts; * the Module Evidence in each statement already contains everything that its Evidence Format needs for verification, except the Vendor Trust Anchor. The certs field of the AttestationBundle is not used for it; * no nonce or other freshness mechanism is needed (Section 9.10); * a CA that receives such a request can assemble a KPE file from the statements, with the SubjectPublicKeyInfo of the request as subjectKey, and keep or publish it (Section 8). B.2. Conceptual Message Wrapper A Conceptual Message Wrapper (CMW) [RFC9999] carries a message together with an identifier of its type. In a CMW record, that identifier is a media type or a CoAP Content-Format. A KPE file can be the value of a CMW record whose type is "application/key- provenance-evidence" (Section 5.3). A record can also contain an indicator of the kind of message that it carries. For a KPE file, the fitting value is "evidence", together with "endorsements" when the Module Evidence includes certificates of the Module Vendor. [RFC9999] defines how a CMW is carried in other structures, among them an X.509 extension that can appear in certification requests. For a certification request, the form in Appendix B.1 is more direct, because it needs no second wrapper. Li Expires 21 May 2027 [Page 32] Internet-Draft CA Key Provenance Evidence November 2026 Appendix C. Example: Detecting a Substituted Key This appendix is informative. During a key ceremony, a CA operator generates key pair K1 inside a Module. A later step in the ceremony goes wrong and produces a different key pair, K2, for example by re-creating K1 from key material that host software read back and altered. The certification request submitted to the issuing CA contains the public key of K2. The Module produces Module Evidence with Origin "generated" only for K1. In a KPE file whose subjectKey is the public key of K2, no statement can be satisfying (Section 7): * a statement that does not verify is skipped; * a statement that verifies and whose Attested Key is not K2, for example the evidence for K1, does not match subjectKey; * a statement that verifies and whose Attested Key is K2 has Origin "not-generated" or "unknown". Verification therefore fails, and the issuing CA detects the problem before issuing the certificate. The detection does not depend on K2 being weak, and does not depend on knowing why K2 was produced. A different failure re-creates K1 itself from key material that host software read, for example after wrapping K1 under a key that the host holds. The certification request then contains the public key of K1, and the evidence for K1 is satisfying under a policy that does not consider Exportability. A policy that requires Exportability "not-exportable" detects this case as well, because a Module that let K1 be wrapped under such a key does not report "not-exportable" for it (Section 3). Appendix D. Rationale for the Hash Strength Requirements This appendix is informative. Some deployed vendor mechanisms include the Attested Key in the signed content only as a hash, and at least one of them uses SHA-1 (Appendix E.2). Section 4 requires at least 128 bits of security against second preimages, which SHA-1 provides, and recommends at least 384 bits. This appendix explains both values. KPE relies on the second-preimage resistance of this hash, not on its collision resistance. The Module chooses the Attested Key, because the Module generates it. An attacker who wants a KPE file for a Li Expires 21 May 2027 [Page 33] Internet-Draft CA Key Provenance Evidence November 2026 public key of its own choosing therefore has to find a public key whose hash equals the hash of a key that a Module generated. That is a second-preimage problem. For an n-bit hash function, the generic cost is about 2^n hash computations. The collision attacks on SHA-1 [SHATTERED] [SHAMBLES] do not apply. They produce two inputs with the same hash, but the attacker has to choose both inputs, or at least their prefixes. Here one of the two inputs is a public key that the Module generated from its own random bits. Importing a key of the attacker's choice into a Module does not help either, because evidence for an imported key reports Origin "not-generated". Two generic effects reduce the cost of a second preimage. Neither changes this conclusion: * The attack in [KELSEY-SCHNEIER] finds second preimages faster than 2^n for long target messages. Its advantage grows with the length of the target. Public keys are short, so the attack gives no meaningful advantage here. * An attacker that can get evidence for many keys, for example by having a Module generate T keys, can aim at any one of them. This reduces the work by a factor of T. For SHA-1 and T = 2^40, about 2^120 hash computations remain. The recommended value of 384 bits leaves a margin for this reduction, for the long lifetime of CA keys, and for generic quantum attacks, which reduce second-preimage resistance to about half of its bit length. Evidence Formats that include the complete public key in the signed content do not depend on a hash function for this binding. The argument in this appendix applies only to the hash that identifies the Attested Key. The signatures of the Module Evidence and the Trust Path are computed over content that can contain values chosen by the operator of the Module, and a party that chooses part of the input can use a collision (Section 9.5). This is why Section 4 allows SHA-1 for identifying the Attested Key but not in signatures. Li Expires 21 May 2027 [Page 34] Internet-Draft CA Key Provenance Evidence November 2026 The argument also assumes that the operator cannot choose a long part of the public key that is hashed. When domain parameters are identified by name, the parts that the operator selects, such as a curve name or an RSA public exponent, are short, and the Verifier checks them against its own requirements (Section 9.6). Domain parameters that are specified explicitly are long values chosen by the operator. The argument does not cover keys with such parameters. Appendix E. Existing Vendor Mechanisms This appendix is informative. It summarizes Module Vendor documentation and reference implementations, supplemented by official cloud-provider documentation, as read in November 2026. It relates these mechanisms to the Provenance Facts in Section 3. It is not an evaluation of any product and registers none of these mechanisms. "Not confirmed" means that the sources cited do not settle the question; it does not mean that a product lacks the capability. +================+============================+=====================+ | Mechanism | Attested Key in signed | Origin | | | content | | +================+============================+=====================+ | Thales Luna | SubjectPublicKeyInfo in | PKC issuance | | PKC | the PKC certificate | restricted to keys | | | | created in a Module | +----------------+----------------------------+---------------------+ | Entrust | SHA-1 nCore key hash | key generation | | nShield key | | certificate | | attestation | | | +----------------+----------------------------+---------------------+ | Marvell | RSA public-key | OBJ_ATTR_LOCAL | | LiquidSecurity | attributes; Cloud HSM | attribute | | | also documents a SHA-256 | | | | public-key digest | | +----------------+----------------------------+---------------------+ | Securosys | SubjectPublicKeyInfo in | creation attribute | | Primus | signed XML | and key attributes | +----------------+----------------------------+---------------------+ | Yubico YubiHSM | SubjectPublicKeyInfo in | Origin extension | | 2 | the attestation | | | | certificate | | +----------------+----------------------------+---------------------+ | Crypto4A QASM | SubjectPublicKeyInfo or | claim that the key | | | its SHA-256 digest | is hardware | | | | generated | +----------------+----------------------------+---------------------+ Table 1: Vendor Mechanisms: Attested Key and Origin Li Expires 21 May 2027 [Page 35] Internet-Draft CA Key Provenance Evidence November 2026 +================+=======================+=======================+ | Mechanism | Module Description | Trust Path | +================+=======================+=======================+ | Thales Luna | serial number; | certificate chain to | | PKC | firmware version when | the Thales SafeNet | | | present | root | +----------------+-----------------------+-----------------------+ | Entrust | serial numbers; | KML, KLF2, and a | | nShield key | hardware approval | warrant to KWARN-1 | | attestation | fields | | +----------------+-----------------------+-----------------------+ | Marvell | model and firmware | Marvell chain; hosted | | LiquidSecurity | fields not confirmed | services also provide | | | | a provider chain | +----------------+-----------------------+-----------------------+ | Securosys | device identity in | attestation key, | | Primus | the chain; model and | device key, Securosys | | | firmware in separate | root | | | device-state evidence | | +----------------+-----------------------+-----------------------+ | Yubico YubiHSM | firmware version, | default attestation | | 2 | serial number, FIPS | key chains to a | | | extensions | Yubico root | +----------------+-----------------------+-----------------------+ | Crypto4A QASM | UUID, serial number, | one or more | | | firmware version, | signatures; default | | | FIPS-mode claim | keys chain to a | | | | Crypto4A root | +----------------+-----------------------+-----------------------+ Table 2: Vendor Mechanisms: Module Description and Trust Path The tables describe available fields, not fields guaranteed to occur in every attestation. An Evidence Format specification would still need to identify the supported versions, required signed fields, their interpretation, and the applicable Trust Path. E.1. Thales Luna A Luna HSM restricts Public Key Confirmation (PKC) issuance to private keys generated in a Luna Module and confined to Luna HSM protection [LUNA-CONFIRM]. The cmu getpkc documentation describes retrieval for existing non-extractable RSA and ECC keys [LUNA-GETPKC]. Applications can retrieve the PKC through CKA_PKC or CKA_PKC_ECC and the supporting certificates through CA_GetTokenCertificates. The cmu procedure is not supported with Functionality Modules enabled. Li Expires 21 May 2027 [Page 36] Internet-Draft CA Key Provenance Evidence November 2026 The PKCS #7 bundle contains the PKC and its certificate chain. The documented RSA path is PKC, DAC, HOC, MIC, then the Thales SafeNet root; the ECC path uses a separate ECC MIC [LUNA-CONFIRM]. Thales's reference validator [LUNA-PKCV] compares the encoded public key in the leaf PKC certificate with the public key in a certification request. The Attested Key is therefore available as the certificate's SubjectPublicKeyInfo, rather than only as a fingerprint. The validator also reads the serial-number extension 1.3.6.1.4.1.12383.2.1 and, when present, the firmware-version extension 1.3.6.1.4.1.12383.2.3. The validator verifies each signature in the chain. Where a certificate carries an extended key usage, the validator compares it with the value expected at that position in the chain; it does not reject a certificate that lacks the extension. In the test chains published with the validator, every certificate carries a critical extended key usage, and the value differs at each level. An Evidence Format specification that uses these values to recognize the attestation key would have to require them. The validator does not check validity periods or revocation. The certificates below the roots in those test chains are signed with SHA-384 [LUNA-PKCV]. The sources reviewed do not fully specify the model mapping or PKC behavior after cloning between Modules. E.2. Entrust nShield Entrust's key attestation format note, dated June 2, 2026, describes a JSON bundle assembled by host software from Module-signed artifacts [NSHIELD-KAF]. The key generation certificate contains the nCore public-key hash, generation parameters, and generation-time access control list (ACL), signed by KML. The documented nCore hash is SHA- 1. The complete public key, including domain parameters, is carried separately in pubkeydata; its binding is checked by computing the nCore hash and comparing it with the signed hash. A module state certificate binds KML to KLF2. A vendor warrant binds KLF2 to the vendor's trust root. The documented ModuleInformation warrant uses ECDSA P-521 with SHA-512 and root key KWARN-1, and carries electronic and physical serial numbers and optional hardware approval fields [NSHIELD-WARRANTS]. Those fields describe approval properties, not necessarily a FIPS validation certificate number. The warrant note separately documents a legacy FieldUpgradeModuleInformation form using DSA; the warrant type must therefore be identified rather than assuming that every historical warrant uses the same algorithm. The warrant note also defines a certificate type for smart cards under the same root, and the ModuleInformation payload that it documents has no validity period Li Expires 21 May 2027 [Page 37] Internet-Draft CA Key Provenance Evidence November 2026 [NSHIELD-WARRANTS]. The reference verification code in the format note accepts ECDSA with SHA-512 and DSA with SHA-256 as signature mechanisms of KML [NSHIELD-KAF]. The generation certificate is stored with the key. A module state certificate can be regenerated if the original Module is available and has not been reinitialized. The bundle mechanism supports asymmetric keys. The cited format note does not confirm a firmware version field [NSHIELD-KAF]. E.3. Marvell LiquidSecurity Marvell describes the attestation as an optional part of the response to a command, such as key generation, that is signed by the HSM [MARVELL-ATTEST]. The signed data consists of type-length-value key attributes and, unless the request excludes it, the response header. Its RSA example includes the modulus (0x0120) and public exponent (0x0122), as well as OBJ_ATTR_LOCAL (0x0163), which is true for keys created on the HSM and false for imported keys. In that example, the attributes of the private key also include the modulus, the public exponent and OBJ_ATTR_LOCAL, so the Attested Key and the Origin can be read from the same object. The format supports different attribute sets, so an Evidence Format specification must identify which signed attributes establish the Attested Key and Origin. The documented layout uses a 256-byte RSA signature. The page does not name the hash function of that signature; the output of its verification script reports raw padding for firmware 2.x and PKCS #1 padding for firmware 3.x. Marvell distinguishes format version 1 before firmware 3.2 from format version 2 starting with firmware 3.2; it also provides separate instructions for legacy 2.x firmware. The page does not say which signed field, if any, distinguishes these versions. A format version is not itself an attested firmware version. Signed model and firmware fields were not confirmed in the sources reviewed. The documentation does not say whether an attestation can be obtained later for an existing key. It also describes a park operation that returns the encrypted key together with its attributes, and does not say how Origin is handled when such an object is restored. Google's Cloud HSM documentation describes both Marvell and Google certificate chains and confirms the meaning of LOCAL [GCP-ATTEST]. For asymmetric keys, Google defines the extended key check value (EKCV) as the SHA-256 digest of the DER-encoded public key [GCP-EKCV]. Marvell describes the EKCV as derived with a SHA- 256-based HKDF extract [MARVELL-ATTEST]. An Evidence Format Li Expires 21 May 2027 [Page 38] Internet-Draft CA Key Provenance Evidence November 2026 specification therefore has to define the computation exactly. The ordinary key check value, three bytes of a SHA-1 digest of the modulus, is far too short for the binding specified in Section 4. Azure Managed HSM likewise supplies the attestation blob and certificates, and documents validation through both Marvell and Microsoft certificate chains [AZURE-ATTEST]. These hosted-service paths should be distinguished from the underlying vendor mechanism. E.4. Securosys Primus Securosys documents key attestation from firmware 2.8 and device attestation from firmware 2.10 [SECUROSYS-ATTEST]. Its Audit and Attestation application note [SECUROSYS-AN] describes signed XML with a detached signature and a separate certificate chain. The attestation key is certified by a device key, which chains to a Securosys root. The verification example in the note checks the signature of the attestation file with SHA-256. The signed public_key element (Sections 4.4 and 5.3 of the note) contains a base64 encoding of the DER SubjectPublicKeyInfo, which can be compared with the public key in a certification request. The example in Section 8.1.1 includes a private_key creation attribute set to generated, creation and attestation times, algorithm information, and attributes including sensitive, always_sensitive, extractable, and never_extractable. This supplies both a public-key binding and documented generation-related attributes; the note does not fully specify their interpretation for every import or cloning operation. Device-state attestation separately reports information including the model, software version, and operating mode. Section 6 describes linking key and device evidence through their common device key. These device-state fields should not be assumed to occur in the key attestation XML itself. E.5. Yubico YubiHSM 2 A YubiHSM 2 produces an X.509 attestation certificate whose SubjectPublicKeyInfo contains the attested public key [YUBIHSM-PY] [YUBICO-OID]. The default attestation key and its certificate are preloaded under object ID 0 and chain through a Yubico intermediate to a Yubico root [YUBIHSM-CONCEPTS]. Custom attestation keys are also supported; their certificates do not acquire a Yubico trust path merely by being used for attestation [YUBICO-OID]. Li Expires 21 May 2027 [Page 39] Internet-Draft CA Key Provenance Evidence November 2026 The signature uses RSA PKCS #1 v1.5 with SHA-256 or ECDSA with SHA- 256. The certificate validity dates are copied from the attesting key's certificate. Extensions report firmware version, serial number, Origin, domains, capabilities, object ID, and label [YUBICO-OID]. On FIPS devices with firmware 2.4.1 or later, an extension reports whether attestation occurred in FIPS-approved mode. A separate vendor-coded extension identifies a FIPS validation; these are distinct claims [YUBIHSM-OVERVIEW]. Origin is a read-only object property. Its bits distinguish generated (0x01), imported (0x02), and imported_wrapped (0x10). Wrapped imports combine the last bit with the original origin, yielding 0x11 or 0x12 [YUBIHSM-CONCEPTS]. An Evidence Format specification would need to state how these values map to Origin, including the conditions for preserving generated origin through wrapped transfer. The sources reviewed do not confirm attestation availability for every imported-key origin value. E.6. Crypto4A QASM Crypto4A's document "Attestation using the QASM" [C4A-ATTEST] specifies ASN.1 claims with one or more signatures and optional X.509 certificates. The Module checks claims before signing them. Attestation keys cannot also have the general signing capability. Key claims include key-spki (SubjectPublicKeyInfo), key-spki-sha256 (its SHA-256 digest), key-is-hardware-generated (the local bit), key- is-confined, and key-never-extracted. Object UUIDs identify claim subjects. Module claims cover UUID, serial number, firmware version, certified-production status, attestation time, and FIPS mode. The private-key-is-on-hsm verification template treats key-is- hardware-generated as optional. Successful template verification therefore does not establish Origin generated without that claim bound to the relevant key. The default key is QASM_AA_ECC; examples also select ECC and HSS signatures [RFC8554]. Dual signatures are not mandatory. Default certificates chain through C4A_SCA to C4A_RCA; custom chains are supported. Verification checks the attestation extended key usage 1.3.6.1.4.1.39901.4.1.1, signatures, and certificate paths to accepted roots. Appendix F. IETF RATS Evidence Format for Hardware Security Modules This appendix is informative. Li Expires 21 May 2027 [Page 40] Internet-Draft CA Key Provenance Evidence November 2026 [I-D.ietf-rats-pkix-key-attestation] is a working group draft that defines a vendor-neutral evidence format for hardware security modules. It is not a deployed vendor mechanism. This appendix follows version 08 of that draft, which can still change. The key claim spki carries the SubjectPublicKeyInfo of the key. The claims local, extractable, sensitive and never-extractable correspond to the [PKCS11] attributes of the same names, such as CKA_LOCAL. A further claim, device-bound, asserts when it is true that the key was generated on the device, has never been exported from it in any form, and cannot be exported in the future, including by backup, cloning or interfaces available only to the vendor. Platform claims give, among other values, the hardware model, the serial number, the firmware version, and whether the device is operating in FIPS mode. The certificate of the attestation key has to contain an extended key usage, id-kp-attestationKey, that the draft defines for signing evidence, and a Verifier has to check for it. This is a designation of the kind that Section 4 requires. The draft also allows the attestation key to chain to a trust anchor of the device operator instead of the vendor, and allows a signer to be identified without a certificate. Evidence of that kind has no Trust Path to a Vendor Trust Anchor and does not pass the verification procedure of this document. An Evidence Format specification for this format would still have to state which claims and which form of signer identification it requires, and how local, never-extractable and device-bound relate to the definitions of "generated" and "not-exportable" in Section 3, in particular after a key has been transferred between Modules. A device-bound key cannot be transferred to another Module at all, so that claim is stricter than "not-exportable". Acknowledgments TODO Author's Address Leonard Li Email: cuno3u@gmail.com Li Expires 21 May 2027 [Page 41]