RFC 9763
Related Certificates for Use in Multiple Authentications within a Protocol
Related Certificates for Use in Multiple Authentications within a Protocol 💖
- Series: Internet Engineering Task Force (IETF) 🌸
- RFC number: 9763
- Authors: A. Becker, R. Guthrie, M. Jenkins (all from NSA) 👑
- Category: Standards Track ✨
- ISSN: 2070-1721
- Date: June 2025 🦋
- Obsoletes / Updates: the header doesn't list anything it obsoletes or updates 🙈
Abstract ✨
okay so this doc introduces two new things: a Certificate Signing Request (CSR) attribute called relatedCertRequest and a new X.509 certificate extension called RelatedCertificate 🎀. When you use the relatedCertRequest attribute in a CSR, and the RelatedCertificate extension shows up in the resulting certificate, you get extra assurance that two certificates both belong to the same end entity 💅. This is especially useful for non-composite hybrid authentication, which lets users run the same certificates for hybrid authentication as they would for authentication done with only traditional or post-quantum algorithms. it's giving flexibility 🧚
Status of This Memo 🌈
This is an Internet Standards Track document.
This document is a product of the Internet Engineering Task Force (IETF). It represents the consensus of the IETF community. It has received public review and has been approved for publication by the Internet Engineering Steering Group (IESG). Further information on Internet Standards is available in Section 2 of RFC 7841. ✨
Information about the current status of this document, any errata, and how to provide feedback on it may be obtained at https://www.rfc-editor.org/info/rfc9763. 🍓
Copyright Notice 💜
Copyright (c) 2025 IETF Trust and the persons identified as the document authors. All rights reserved.
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. 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
1.1. Overview
2. Requirements Language
3. CSR and Related Certificates
3.1. The relatedCertRequest Attribute
3.2. CSR Processing
4. Related Certificate
4.1. The RelatedCertificate Extension
4.2. Endpoint Protocol Multiple Authentication Processing
5. Use Case
6. CA Organization Considerations
7. Security Considerations
8. IANA Considerations
9. References
9.1. Normative References
9.2. Informative References
Appendix A. ASN.1 Module
Authors' Addresses1. Introduction 🎀
okay bestie, the goal here is to give a method for proving that two X.509 (aka PKIX) end-entity certificates are owned by the same entity 🔥. The whole point is to let someone do multiple authentications where each certificate lines up with its own digital signature. This method is built to make it easier to use two certificates for authentication in a secure protocol, while changing the certificate format [RFC5280] and current PKI best practices as little as possible 💖.
when you're using non-composite hybrid public key mechanisms, the party relying on a certificate (an authentication verifier or a key-establishment initiator) is gonna want assurance that the private keys tied to each certificate are controlled by the same entity 👀. This doc defines a certificate extension, RelatedCertificate, that signals the certificate holding the extension can be used together with the other specified certificate ✨.
a certification authority (CA) organization (defined here as the entity or organization that runs a CA and decides the policies and tools the CA will use) might get a request for a certificate with that extension. they may want assurance from a registration authority (RA) that the private keys (matching, for example, two public keys: one in an extant certificate and one in a current request) belong to the same entity 🦋. so to make that possible, there's a CSR attribute called relatedCertRequest that lets an RA make that assertion 💅.
1.1. Overview 🌸
the general roadmap is easiest to see with an entity (like a device, service, or user token) that already has a certificate (Cert A) and asks for a new one (Cert B), maybe as part of an organization's plan to move its PKI from traditional cryptography to post-quantum cryptography (PQC) 🧚.
- For protocols where authentication isn't negotiated but is instead limited by what the signer offers, like Cryptographic Message Syntax (CMS) and S/MIME, either Cert A's signing key, Cert B's signing key, or both signing keys may be invoked, depending on which verifiers the signer expects 🙈.
- For protocols where authentication is negotiated in-protocol, like TLS and Internet Key Exchange Protocol Version 2 (IKEv2), either Cert A or Cert B's signing key may be invoked, depending on the verifier's preference. If the protocol supports it, peers may request that both Cert A and Cert B are used for authentication 🔥.
a verifier that prefers multiple authentication types may get help from relevant information included in one of the signer's certificates. that information shows a related certificate exists, plus some assurance that those certificates were issued to the same entity 👑. this doc describes a certificate request attribute and certificate extension that provide that assurance 💜.
so to back this up, the doc defines a new CSR attribute, relatedCertRequest. it holds info on how to find a previously issued certificate (Cert A) and proof that the requesting entity owns that certificate 🎀. when the RA sends the request to the CA, the CA uses that info to find Cert A and checks ownership before generating the new certificate, Cert B ✨.
2. 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. 📜
3. CSR and Related Certificates 🌈
3.1. The relatedCertRequest Attribute 💖
this section defines a new CSR attribute made so the RA can attest that the owner of the public key in the CSR also owns the public key tied to the end-entity certificate named in this attribute 🦋. the relatedCertRequest attribute points to the location of a previously issued certificate that the end entity owns and wants identified in the new certificate requested through the CSR 🍓.
the relatedCertRequest attribute has the following syntax 🧚:
id-aa-relatedCertRequest OBJECT IDENTIFIER ::= { id-aa 60 }
aa-relatedCertRequest ATTRIBUTE ::= {
TYPE RequesterCertificate
IDENTIFIED BY id-aa-relatedCertRequest}
RequesterCertificate ::= SEQUENCE {
certID IssuerAndSerialNumber,
requestTime BinaryTime,
locationInfo UniformResourceIdentifier,
signature BIT STRING }the RequesterCertificate type has four fields 💅:
- The certID field uses the IssuerAndSerialNumber type [RFC5652] to identify a previously issued end-entity certificate that the requesting entity also owns. IssuerAndSerialNumber is repeated here for convenience 🌸:
IssuerAndSerialNumber ::= SEQUENCE {
issuer Name,
serialNumber CertificateSerialNumber }
CertificateSerialNumber ::= INTEGER- The requestTime field uses the BinaryTime type [RFC6019] to ensure freshness, so the signed data can only be used at the time of the initial CSR ⏰. The means by which the CA and RA synchronize time is outside the scope of this document. BinaryTime is repeated here for convenience 🕒:
BinaryTime ::= INTEGER (0..MAX)- The locationInfo field uses UniformResourceIdentifier to give info on where the other certificate the requesting entity owns can be found 🗺️. UniformResourceIdentifier is defined as 🍬:
UniformResourceIdentifier ::= IA5Stringthe UniformResourceIdentifier is a pointer to a location over HTTP(S) or a data URL 🌐. this field can hold one of two acceptable values:
- If the request for (new) Cert B goes to the CA organization that also issued (existing) Cert A, then the UniformResourceIdentifier value SHOULD be a URL pointing to a file with a certificate or certificate chain that the requesting entity owns, as detailed in [RFC5280]. the URL is made available via HTTP or HTTPS. the file must permit access to a CMS 'certs-only' message containing the end-entity certificate or the entire certificate chain. this option uses less data than a data URL. all certificates contained must be DER encoded 🥰.
- If the request for (new) Cert B goes to a CA organization different from the one that issued the certificate (existing) Cert A referenced in the CSR, then the UniformResourceIdentifier value SHOULD be a data URL [RFC2397] containing inline degenerate PKCS#7 (see Sections 3.2.1 and 3.8 of [RFC8551]) made up of all the certificates and CRLs required to validate Cert A. this lets the CA do validation (as described in Section 3.2) without having to fetch certificates or CRLs from another CA 🤯. more on what this scenario needs is in Section 5 🔍.
- The signature field provides evidence that the requesting entity owns the certificate indicated by the certID field. specifically, the signature field holds a digital signature over the concatenation of the DER-encoded IssuerAndSerialNumber and BinaryTime 🔐. the concatenated value is signed using the signature algorithm and private key associated with the certificate identified by the certID field ✍️.
- If the related certificate is a key establishment certificate (e.g., using RSA key transport or Elliptic Curve Cryptography (ECC) key agreement), the private key is used to sign one time for proof of possession (POP) (as detailed in Section 8.1.5.1.1.2 of [NIST-SP-800-57]) 💎.
the verification of this signature by the CA makes sure the owner of the CSR also owns the certificate indicated in the relatedCertRequest attribute 🫧. ngl that's the core of the whole trick ✨👑
3.2. CSR Processing 🦋
So the relatedCertRequest attribute is basically the CA's detective kit 🕵️♀️ It lets the CA find a cert the requester already owns and then confirm that ownership. How? It uses the public key in that old cert to check the signature in the attribute. Iconic, honestly.
If a CA gets a CSR with the relatedCertRequest attribute and that CA supports the attribute, the CA:
- MUST retrieve the certificate identified in the
relatedCertRequestattribute using the information provided inUniformResourceIdentifier, and validate it using certificate path validation rules defined in [RFC5280]. The CA then extracts theIssuerAndSerialNumberfrom the indicated certificate and compares this value against theIssuerAndSerialNumberprovided in thecertIDfield ofrelatedCertRequest. 🔍 - MUST check that the
BinaryTimeindicated in therequestTimefield is sufficiently fresh. Note that sufficient freshness is defined by local policy and is out of the scope of this document. ⏰ - MUST verify the
signaturefield of therelatedCertRequestattribute. The CA verifies the signature using the public key associated with the certificate identified by therelatedCertRequestattribute. The details of the verification process are outside the scope of this document. 🔐 - SHOULD issue the new certificate containing the
RelatedCertificateextension as specified in Section 4, which references the certificate indicated in the attribute'sIssuerAndSerialNumberfield. The CA may also apply local policy regarding the suitability of the related certificate, such as validity period remaining. 💅
The RA MUST only allow a previously issued certificate to be indicated in the relatedCertRequest attribute, and only so the CA can perform the required signature verification. No freelancing here, bestie 🙅♀️
The RA MAY send the CA a CSR containing a relatedCertRequest attribute that includes the IssuerAndSerialNumber of a certificate that was issued by a different CA. 🌈
4. Related Certificate 🎀
4.1. The RelatedCertificate Extension 💖
Okay, this section is where we officially define a new X.509 certificate extension called RelatedCertificate ✨ It creates an association between the certificate containing the RelatedCertificate extension (Cert B) and the certificate referenced inside the extension (Cert A). So when two end-entity certificates are used in a protocol, and one of them has a RelatedCertificate extension pointing at the other, the authenticating entity gets extra assurance that both certificates belong to the same entity. Main character energy for certs 🦋
The RelatedCertificate extension contains the hash of a single end-entity certificate.
The RelatedCertificate extension has the following syntax:
-- Object Identifier for certificate extension
id-relatedCert OBJECT IDENTIFIER ::= { 36 }
-- X.509 Certificate extension
RelatedCertificate ::= SEQUENCE {
hashAlgorithm DigestAlgorithmIdentifier,
hashValue OCTET STRING }The extension is a SEQUENCE of two fields. The hashAlgorithm field identifies the hash algorithm used to compute hashValue, which is the digest value obtained from hashing the entire related certificate identified in the relatedCertRequest CSR attribute defined above. If there is a hash algorithm explicitly indicated by the related certificate's signature OID (e.g., ecdsa-with-SHA512), that hash algorithm SHOULD also be used for this extension. 🧁
This extension SHOULD NOT be marked critical. Marking this extension critical would severely impact interoperability. 😭 Please don't do this to yourself, babe.
For certificate chains, this extension MUST only be included in the end-entity certificate. 🫶
For the RelatedCertificate extension to be meaningful, a CA that issues a certificate with this extension:
- MUST only include a certificate in the extension that is listed in the
relatedCertRequestattribute of the CSR submitted by the requesting entity. 🎯 - MUST ensure that the related certificate contains the key usage (KU) bits and extended key usage (EKU) OIDs [RFC5280] being asserted in the certificate being issued. 🔑
- SHOULD determine that the related certificate is valid at the time of issuance. The usable overlap with the validity period of the newly issued certificate is a Subscriber concern. 📅
4.2. Endpoint Protocol Multiple Authentication Processing 🧚
When an endpoint expresses, through the protocol itself (e.g., during negotiation), that it prefers a non-composite hybrid authentication mode, the use of the RelatedCertificate extension and its enforcement are left to the protocol's existing authorization mechanism. That mechanism also handles the other decisions endpoints make about whether to complete or drop a connection. ✨
If an endpoint has indicated that it supports non-composite hybrid authentication and receives the appropriate authentication data, it should check end-entity certificates (Cert A and Cert B) for the RelatedCertificate extension. If it's present in one certificate (e.g., Cert B), it should:
- Compute the appropriate hash of Cert A, the other end-entity certificate received. 🧮
- Confirm that the hash value matches the hash entry in the
RelatedCertificateextension of Cert B. ✅
How to proceed with authentication based on the outcome of this process is outside the scope of this document. Different determinations may be made depending on each peer's policy regarding whether both or at least one authentication needs to succeed. 🤷♀️
5. Use Case 🌸
The general design of this method is best illustrated through a specific use within a migration strategy to PQC via a non-composite hybrid authentication mechanism. 🔮 The intent is for a CA issuing a new, post-quantum (PQ) certificate to add an X.509 extension that provides information about a previously issued, traditional certificate. The private key of that traditional certificate is controlled by the same end entity as the PQ certificate. It's giving "same person, two certs" energy 💜
Here's the scenario: an entity currently has a traditional certificate, and it requests that a new PQ certificate be issued containing a RelatedCertificate extension that references the entity's traditional certificate.
The RA receives a CSR for a PQ certificate, and the CSR includes the relatedCertRequest attribute detailed in this document. The relatedCertRequest attribute includes a certID field that identifies the entity's previously issued traditional certificate. It also includes a signature field, in which the requesting entity produces a digital signature over the concatenation of the IssuerAndSerialNumber and BinaryTime, using the private key of the certificate identified by the IssuerAndSerialNumber. 🖋️
The purpose of the relatedCertRequest attribute is to serve as a tool for the RA to give assurance to the CA organization that the entity controlling the private key of the PQ certificate being requested also controls the private key of the referenced, previously issued traditional certificate. Two keys, one owner, no cap 🫶
Once the CSR is received and validated, the CA issues a PQ certificate to the requesting entity. That certificate includes the RelatedCertificate extension detailed in this document, and the extension includes a hash of the entire traditional certificate identified in the CSR. The X.509 extension creates an association between the PQ certificate and the traditional certificate, via an assertion of end-entity ownership. 🦋
The attribute and the subsequent extension together provide assurance from the CA organization that the same end entity controls the private keys of both certificates. It is neither a requirement nor a mandate that either certificate be used with the other. It's simply an assurance that they can be used together, since they're under the control of the same entity. Not a rule, just a vibe ✨
6. CA Organization Considerations 👑
The relatedCertRequest CSR attribute asserts end-entity control of the private key associated with a related certificate (Cert A) to the CA organization issuing a new certificate (Cert B). 💅 A public-facing CA organization may not be configured to validate certificates that have been issued by different CA organizations. In that case, recognizing the contents of the relatedCertRequest attribute may need pre-arrangement. For example, that could mean a contract with pre-configured trust anchors from another CA organization, plus agreements about policies for certificate application, issuance, and acceptance. 🤝
Continuing with this scenario: for the CA organization to make sure Cert B is issued under security parameters comparable to Cert A, the issuing CA organization should match the issued certification policies to the related ones. As part of validating Cert A, the issuing CA organization figures out which policies are asserted in Cert A's certification path. Then it decides which of its own certification policies will best ensure that the protection of the private key associated with Cert B is comparable to that of Cert A. 🔍 The relatedCertRequest attribute and the subsequent RelatedCertificate certificate extension are solely intended to provide assurance that both private keys are controlled by the same end entity. That's the whole tea ☕🌈
7. Security Considerations 🔐
Okay bestie, this part is serious, so grab a snack 🍓 and let's go. This document inherits the security considerations from [RFC5280] 💅, so those apply here too, periodt.
The mechanisms in this document only give a way to say that multiple certificates are related 🫶. They're meant for whoever receives the data they're embedded in (a CSR or a certificate) to interpret. By themselves, they don't do any security function at all 🙈.
Authentication is one-way, unlike key establishment. The claimant makes an assertion to a verifier, and the verifier needs to be happy with the means and strength of that authentication mechanism. A system security designer needs to know what authentication assurances each part of the system needs and how to get them. In a closed system (like Company X shipping firmware to its own devices), that can be kind of implicit. In an online protocol like IPsec, where the peers are usually known, picking any mechanism from a pre-established set might be enough. For more open online protocols like TLS, it's a big deal that the verifier can express what's possible and what's preferred, and then check that its requirements were met 💖.
A certificate asserts a binding between an identity and a public key 🎀. But that assertion rests on other assurances too, especially that the identity belongs to a particular physical entity, and that this entity controls the private key that matches the public key. For any hybrid approach, it's super important that there's evidence the same entity controls all the private keys at time of use (to the verifier) and at time of registration (to the CA) 🔥.
All hybrid implementations are vulnerable to a downgrade attack 💀. A malicious peer just doesn't express support for the stronger algorithm, so the exchange ends up relying only on a weaker algorithm for its security.
Implementors should be aware of the risks that come with retrieving a related certificate through the UniformResourceIdentifier in the relatedCertRequest CSR attribute 👀. A URL can point to malicious code! Implementors should make sure the data is properly formed and fully validate the retrieved data ✨.
CAs should know that retrieving existing certificates may be subject to observation 🌈. If that's a concern, it's advisable to use the data URL option described in Section 3.1 🦋.
8. IANA Considerations 📋
This document defines an extension for use with X.509 certificates. IANA has registered the following OID in the "SMI Security for PKIX Certificate Extension" registry (1.3.6.1.5.5.7.1):
+=========+===================+============+
| Decimal | Description | References |
+=========+===================+============+
| 36 | id-pe-relatedCert | RFC 9763 |
+---------+-------------------+------------+
Table 1The registration procedure is Specification Required [RFC8126] 📝.
This document defines a CSR attribute. IANA has registered the following OID in the "SMI Security for S/MIME Attributes (1.2.840.113549.1.9.16.2)" registry:
+=========+==========================+============+
| Decimal | Description | References |
+=========+==========================+============+
| 60 | id-aa-relatedCertRequest | RFC 9763 |
+---------+--------------------------+------------+
Table 2This document defines an ASN.1 module in Appendix A. IANA has registered the following OID for the module identifier in the "SMI Security for PKIX Module Identifier" registry (1.3.6.1.5.5.7.0):
+=========+==========================+============+
| Decimal | Description | References |
+=========+==========================+============+
| 115 | id-mod-related-cert-2023 | RFC 9763 |
+---------+--------------------------+------------+
Table 39. References 📚
9.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,
<https://www.rfc-editor.org/info/rfc2119>.
[RFC2397] Masinter, L., "The "data" URL scheme", RFC 2397,
DOI 10.17487/RFC2397, August 1998,
<https://www.rfc-editor.org/info/rfc2397>.
[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,
<https://www.rfc-editor.org/info/rfc5280>.
[RFC5652] Housley, R., "Cryptographic Message Syntax (CMS)", STD 70,
RFC 5652, DOI 10.17487/RFC5652, September 2009,
<https://www.rfc-editor.org/info/rfc5652>.
[RFC6019] Housley, R., "BinaryTime: An Alternate Format for
Representing Date and Time in ASN.1", RFC 6019,
DOI 10.17487/RFC6019, September 2010,
<https://www.rfc-editor.org/info/rfc6019>.
[RFC8174] Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC
2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174,
May 2017, <https://www.rfc-editor.org/info/rfc8174>.9.2. Informative References 🧚
[NIST-SP-800-57]
Barker, E., "Recommendation for Key Management: Part 1 -
General", National Institute of Standards and Technology,
NIST SP 800-57pt1r5, DOI 10.6028/NIST.SP.800-57pt1r5, May
2020,
<https://nvlpubs.nist.gov/nistpubs/SpecialPublications/
NIST.SP.800-57pt1r5.pdf>.
[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,
<https://www.rfc-editor.org/info/rfc5912>.
[RFC6268] Schaad, J. and S. Turner, "Additional New ASN.1 Modules
for the Cryptographic Message Syntax (CMS) and the Public
Key Infrastructure Using X.509 (PKIX)", RFC 6268,
DOI 10.17487/RFC6268, July 2011,
<https://www.rfc-editor.org/info/rfc6268>.
[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,
<https://www.rfc-editor.org/info/rfc8126>.
[RFC8551] Schaad, J., Ramsdell, B., and S. Turner, "Secure/
Multipurpose Internet Mail Extensions (S/MIME) Version 4.0
Message Specification", RFC 8551, DOI 10.17487/RFC8551,
April 2019, <https://www.rfc-editor.org/info/rfc8551>.Appendix A. ASN.1 Module 🧾
Here's the RelatedCertificate ASN.1 module, which describes the RequesterCertificate type found in the relatedCertAttribute 🤓. It pulls definitions from the modules in [RFC5912] and [RFC6268] for the IssuerAndSerialNumber type, and from [RFC6019] for the BinaryTime type.
RelatedCertificate { iso(1) identified-organization(3) dod(6)
internet(1) security(5) mechanisms(5) pkix(7) id-mod(0)
id-mod-related-cert-2023(115)}
DEFINITIONS IMPLICIT TAGS ::=
BEGIN
IMPORTS
ATTRIBUTE, EXTENSION
FROM PKIX-CommonTypes-2009 -- in RFC 5912
{ iso(1) identified-organization(3) dod(6) internet(1)
security(5) mechanisms(5) pkix(7) id-mod(0)
id-mod-pkixCommon-02(57) }
IssuerAndSerialNumber, DigestAlgorithmIdentifier
FROM CryptographicMessageSyntax-2010 -- in RFC 6268
{ iso(1) member-body(2) us(840) rsadsi(113549)
pkcs(1) pkcs-9(9) smime(16) modules(0)
id-mod-cms-2009(58) }
BinaryTime
FROM BinarySigningTimeModule -- in RFC 6019
{ iso(1) member-body(2) us(840) rsadsi(113549)
pkcs(1) pkcs-9(9) smime(16) modules(0)
id-mod-binarySigningTime(27) } ;
-- Object identifier arcs
id-pe OBJECT IDENTIFIER ::= { iso(1) identified-organization(3)
dod(6) internet(1) security(5) mechanisms(5) pkix(7) 1 }
id-aa OBJECT IDENTIFIER ::= { iso(1) member-body(2) usa(840)
rsadsi(113549) pkcs(1) pkcs-9(9) smime(16) 2 }
-- relatedCertificate Extension
id-pe-relatedCert OBJECT IDENTIFIER ::= { id-pe 36 }
RelatedCertificate ::= SEQUENCE {
hashAlgorithm DigestAlgorithmIdentifier,
hashValue OCTET STRING }
ext-relatedCertificate EXTENSION ::= {
SYNTAX RelatedCertificate
IDENTIFIED BY id-pe-relatedCert }
-- relatedCertRequest Attribute
id-aa-relatedCertRequest OBJECT IDENTIFIER ::= { id-aa 60 }
RequesterCertificate ::= SEQUENCE {
certID IssuerAndSerialNumber,
requestTime BinaryTime,
locationInfo UniformResourceIdentifiers,
signature BIT STRING }
UniformResourceIdentifiers ::= SEQUENCE SIZE (1..MAX) OF URI
URI ::= IA5String
aa-relatedCertRequest ATTRIBUTE ::= {
TYPE RequesterCertificate
IDENTIFIED BY id-aa-relatedCertRequest }
ENDAuthors' Addresses 🦋
Alison Becker
National Security Agency
Email: aebecke@uwe.nsa.gov
Rebecca Guthrie
National Security Agency
Email: rmguthr@uwe.nsa.gov
Michael Jenkins
National Security Agency
Email: mjjenki@cyber.nsa.gov📦 where this page comes from
- ietf: rfc9763 2025-06
- 💖 girlified by claude-haiku-5-5 on : a language model's rewrite of the original, under its terms