RFC 10003

Certificate Management over CMS (CMC): Transport Protocols

📅 published July 2026, from ietf

RFC 10003: Certificate Management over CMS (CMC): Transport Protocols 💖

Okay bestie, this is RFC 10003, and it's giving Standards Track 🎀 It's titled "Certificate Management over CMS (CMC): Transport Protocols" and dates from July 2026 (ISSN 2070-1721). J. Mandel, Ed. from AKAYLA, Inc. and S. Turner, Ed. from sn3rd wrote it. It obsoletes RFCs 5273 and 6402, so those older docs are officially retired 💅

Abstract 🦋

This doc defines a bunch of transport mechanisms for moving Certificate Management over CMS (CMC) messages. The ones it covers are HTTP, file, mail, and TCP. It also obsoletes RFCs 5273 and 6402.

Status of This Memo 📜

This is an Internet Standards Track document from the IETF, and it reflects the consensus of the IETF community. It got public review and was approved by the Internet Engineering Steering Group (IESG). If you want more on Internet Standards, check Section 2 of RFC 7841. For the current status, errata, and how to send feedback, go to https://www.rfc-editor.org/info/rfc10003 ✨

Copyright (c) 2026 IETF Trust and the persons identified as the document authors. All rights reserved.

This doc is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) as they stand on the publication date. Please read them carefully, because they lay out your rights and restrictions for this document. Code Components pulled out of this doc must include Revised BSD License text, as described in Section 4.e of the Trust Legal Provisions, and they come without warranty as described in the Revised BSD License 🌈

This doc may contain material from IETF Documents or IETF Contributions published or made publicly available before November 10, 2008. The people controlling the copyright in some of that material may not have given the IETF Trust permission to allow modifications outside the IETF Standards Process. Without an adequate license from them, this document may not be modified outside the IETF Standards Process, and derivative works of it may not be created outside the IETF Standards Process. The exceptions are formatting it for publication as an RFC and translating it into languages other than English.

Table of Contents 📚

   1.  Introduction
   2.  Requirements Terminology
   3.  Changes Since RFCs 5273 and 6402
   4.  File-Based Protocol
   5.  Mail-Based Protocol
   6.  HTTP-Based Protocol
     6.1.  PKI Request
     6.2.  PKI Response
   7.  TCP-Based Protocol
   8.  IANA Considerations
   9.  Security Considerations
   10. References
     10.1.  Normative References
     10.2.  Informative References
   Acknowledgements
   Contributors
   Authors' Addresses

1. Introduction 🌸

So this doc defines a few transport methods that move CMC messages (defined in [CMC-STRUCT]). The transport mechanisms here are HTTP, file, mail, and TCP.

It obsoletes RFCs 5273 [CMC-TRANSv1] and 6402 [CMC-Updates]. It also incorporates [Err3593] 🫶

2. Requirements Terminology 🔥

Here's the deal with the capital letters 👑 The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" are read as described in BCP 14 [RFC2119] [RFC8174], but only when they show up in all capitals, just like they're shown here.

3. Changes Since RFCs 5273 and 6402 💅

Here's what's new since those older docs, bestie:

  • Merged [CMC-Updates] text.
  • IANA assigned TCP port 5318 for the use of CMC.
  • Clarified the file extensions for Full Public Key Infrastructure (PKI) Requests and Responses.
  • Added examples of encoding types for mail-based Requests and Responses.
  • Replaced TLS 1.0 with TLS 1.2 or later, and added that implementations are required to follow the recommendations in [BCP195].
  • Addressed [Err3593].
  • Added a reference to [HTTP-IMP] for HTTP guidance.
  • Restricted early data (0-RTT) if using TLS 1.3 or QUIC.
  • Restricted the use of TCP-Pipelining.
  • Clarified the limitations of SMTP-over-TLS and the use of authenticated TLS for message delivery.

4. File-Based Protocol 📁

Enrollment messages and responses can move between clients and servers using file-system-based mechanisms 💾 That's useful when enrollment happens for an offline client, for example. When files carry Full PKI Request or Full PKI Response messages, there MUST be only one instance of a request or response message in a single file, and the file MUST be binary encoded. The abbreviations crq and crp stand for Full PKI Request/Response, respectively. For clarity, we define file extensions for them. The following file type extensions SHOULD be used:

                 +=====================+================+
                 | Message Type        | File Extension |
                 +=====================+================+
                 | Simple PKI Request  | .p10           |
                 +---------------------+----------------+
                 | Full PKI Request    | .crq           |
                 +---------------------+----------------+
                 | Simple PKI Response | .p7c           |
                 +---------------------+----------------+
                 | Full PKI Response   | .crp           |
                 +---------------------+----------------+

                    Table 1: File PKI Request/Response
                              Identification

5. Mail-Based Protocol 📬

MIME wrapping is defined for environments that support MIME 🌷 The basic MIME wrapping in this section comes from [SMIMEV4]. When you're using a mail-based protocol, MIME wrapping between the layers of Cryptographic Message Syntax (CMS) wrapping is optional. Heads up, this is different from a standard S/MIME (Secure MIME) message.

Below you'll find a set of Simple PKI Request and Response messages and a set of Full PKI Request and Response messages. The headers we talk about appear in the top-level content of the messages, and the message contents are the entire message bodies.

WARNING: The examples that follow are purposely truncated for brevity.

Simple enrollment requests are encoded using the "application/pkcs10" content type [RFC5967]. A file name MUST be included either in a Content-Type or a Content-Disposition header, in the name or filename parameter respectively. The extension for the file MUST be ".p10". Here's an example similar to the one from [RFC5967] 🍓

     From: cmc-client@example.com
     Message-Id: <E06C3FA6-FF15-4851-AC7F-DB9F3B1C2C7A@example.com>
     To: cmc-server@example.com
     Subject: Simple Enrollment Request
     Date: Tue, 3 Feb 2026 16:08:28 -0500
     MIME-Version: 1.0
     Content-Type: application/pkcs10; name=smime.p10
     Content-Transfer-Encoding: base64
     Content-Disposition: inline; filename=smime.p10

     < message contents >

                Figure 1: Simple PKI Request Message Example

Simple PKI Response messages MUST be encoded as content type "application/pkcs7-mime". A smime-type parameter MUST be on the Content-Type header with a value of "certs-only". A file name with the ".p7c" extension MUST be specified as part of the Content-Type or Content-Disposition header, in the name or filename parameter respectively. Here's an example similar to the one from [SMIMEV4] 🧚

     From: cmc-server@example.com
     Message-Id: <E06C3FA6-FF15-4851-AC7F-DB9F3B1C2C7B@example.com>
     To: cmc-client@example.com
     Subject: Re: Simple Enrollment Request
     Date: Tue, 3 Feb 2026 16:09:28 -0500
     MIME-Version: 1.0
     References: <E06C3FA6-FF15-4851-AC7F-DB9F3B1C2C7A@example.com>
     In-Reply-To: <E06C3FA6-FF15-4851-AC7F-DB9F3B1C2C7A@example.com>
     Content-Type: application/pkcs7-mime; smime-type=certs-only;
       name=smime.p7c
     Content-Transfer-Encoding: base64
     Content-Disposition: inline; filename=smime.p7c

     < message contents >

               Figure 2: Simple PKI Response Message Example

Full PKI Request messages MUST be encoded as content type "application/pkcs7-mime". The smime-type parameter MUST be included with a value of "CMC-Request". A file name with the ".p7m" extension MUST be specified as part of the Content-Type or Content-Disposition header, in the name or filename parameter respectively. Here's an example similar to the one from [SMIMEV4] 🌈

     From: cmc-client@example.com
     Message-Id: <E06C3FA6-FF15-4851-AC7F-DB9F3B1C2C7C@example.com>
     To: cmc-server@example.com
     Subject: Full Enrollment Request
     Date: Tue, 3 Feb 2026 16:10:28 -0500
     MIME-Version: 1.0
     Content-Type: application/pkcs7-mime; smime-type=CMC-Request;
       name=smime.p7c
     Content-Transfer-Encoding: base64
     Content-Disposition: inline; filename=smime.p7m

     < message contents >

                 Figure 3: Full PKI Request Message Example

Full PKI Response messages MUST be encoded as content type "application/pkcs7-mime". The smime-type parameter MUST be included with a value of "CMC-Response". A file name with the ".p7m" extension MUST be specified as part of the Content-Type or Content-Disposition statement. Here's an example similar to the one from [SMIMEV4] 💜

     From: cmc-server@example.com
     Message-Id: <E06C3FA6-FF15-4851-AC7F-DB9F3B1C2C7D@example.com>
     To: cmc-client@example.com
     Subject: Re: Full Enrollment Request
     Date: Tue, 3 Feb 2026 16:11:28 -0500
     MIME-Version: 1.0
     References: <E06C3FA6-FF15-4851-AC7F-DB9F3B1C2C7C@example.com>
     In-Reply-To: <E06C3FA6-FF15-4851-AC7F-DB9F3B1C2C7C@example.com>
     Content-Type: application/pkcs7-mime; smime-type=CMC-Response;
       name=smime.p7m
     Content-Transfer-Encoding: base64
     Content-Disposition: inline; filename=smime.p7m

     < message contents >

                Figure 4: Full PKI Response Message Example

For file names in the name or filename parameters, non-ASCII text is prohibited 🙈

   +====================+==============+================+==============+
   | Item               | MIME Type    | File Extension | SMIME Type   |
   +====================+==============+================+==============+
   | Simple PKI         | application/ | .p10           | N/A          |
   | Request            | pkcs10       |                |              |
   +--------------------+--------------+----------------+--------------+
   | Full PKI           | application/ | .p7m           | CMC-Request  |
   | Request            | pkcs7-mime   |                |              |
   +--------------------+--------------+----------------+--------------+
   | Simple PKI         | application/ | .p7c           | certs-only   |
   | Response           | pkcs7-mime   |                |              |
   +--------------------+--------------+----------------+--------------+
   | Full PKI           | application/ | .p7m           | CMC-Response |
   | Response           | pkcs7-mime   |                |              |
   +--------------------+--------------+----------------+--------------+

             Table 2: MIME PKI Request/Response Identification

6. HTTP-Based Protocol 🌸

okay so this section is all about how CMC rides on HTTP 🚀 It's giving web-native energy. Go check [HTTP-IMP] if you want the extra deets 📖 And HTTPS [HTTP] handles any necessary content protection from eavesdroppers 🙈 Nobody peeking over your shoulder, periodt.

For CMC clients and servers using HTTP to actually interoperate (the whole point, bestie), these rules apply:

  • Clients are configured with enough info to build the server URI [RFC3986]. ✨
  • Client requests go out using the POST method 💌
  • Servers MUST use the 2XX response codes for successful responses. 🎀
  • Clients MAY attempt to send certification requests using HTTPS [HTTP]. Servers aren't required to support TLS/QUIC, but a secure channel might still be available depending on the HTTP version implemented [HTTP_1.0], [HTTP_1.1], [HTTP_2], [HTTP_3], or later. If TLS is used by the HTTP version, then the implementation MUST follow the recommendations in [BCP195]. CMC implementations that support TLS 1.3 or QUIC MUST NOT use early data (i.e., 0-RTT) because POST is not idempotent. 😭
  • Clients aren't required to support any type of HTTP authentication (see Section 11 of [HTTP]) or Cookies [COOKIES]. So servers can't rely on these features being available. 🙅‍♀️
  • Clients and servers are expected to follow the other rules and restrictions in [HTTP]. Some of those rules are for HTTP methods other than POST, so honestly only the rules that apply to POST matter for this spec. 💅

6.1. PKI Request

Here's how a PKI Request using POST gets put together 🧁

The Content-Type field MUST have the appropriate value from Table 2.

A Content-Type field for a request looks like this:

Content-Type: application/pkcs7-mime; smime-type=CMC-Request;
name=request.p7m

The body of the message is just the binary encoding of the PKI Request 🫶

6.2. PKI Response

The content of an HTTP-based PKI Response is the binary value of the BER (Basic Encoding Rules) encoding [X690] of either a Simple or Full PKI Response. 🎁

The Content-Type field MUST have the appropriate value from Table 2.

A Content-Type field for a response looks like this:

Content-Type: application/pkcs7-mime; smime-type=CMC-Response;
name=response.p7m

7. TCP-Based Protocol 🦋

When CMC messages go over a TCP-based connection, no wrapping is needed. They just get sent in their binary encoded form, slay 💅

The client closes a connection after getting a response, or it sends another request to the server over the same connection. Reusing one connection for multiple successive requests is RECOMMENDED over opening a bunch of connections that each only handle a single request, for performance and resource conservation reasons. ⭐ The client MUST wait for the full response before making another request on the same connection. A server MAY close a connection after it's been idle for some period of time, and that timeout would typically be several minutes long ⏳

CMC needs a registered port number to send and receive CMC messages over TCP. The Service Name is pkix-cmc, and the TCP port number is 5318 🎀

Before [CMC-Updates], CMC didn't have a registered port number and used an externally configured port from the Private Port range. Client implementations MAY continue to use a port chosen from the Private Port range. A TCP Server SHOULD use the port assigned to the CMC service, which is 5318. HTTP is expected to stay the main transport method for CMC installations 🌈

8. IANA Considerations 📋

IANA has assigned a TCP port number in the "Dynamic and/or Private Ports Range" of the "Service Name and Transport Protocol Port Number Registry" for CMC. 🧚

Service Name:  pkix-cmc
Port Number:  5318
Transport Protocol:  tcp
Description:  PKIX Certificate Management using CMS (CMC)
Assignee:  iesg@ietf.org
Contact:  chair@ietf.org
Reference:  RFC 10003

IANA has updated the references to [CMC-TRANSv1] in the "Parameter Values for the smime-type Parameter" registry, in the "Media Type Sub-Parameter Registries" registry group, for CMC-Request and CMC-Response. They now point to this document instead ✨

9. Security Considerations 🔐

Okay, this part is serious, bestie 😭 Mechanisms for thwarting replay attacks may be required in particular implementations of this protocol, depending on the operational environment. Where the Certification Authority (CA) keeps significant state information, replay attacks may be detectable without the (optional) CMC nonce mechanisms. Implementers and designers need to think carefully about environmental conditions before deciding whether or not to use the senderNonce and recipientNonce attributes described in Section 6.6 of [CMC-STRUCT]. Developers of state-constrained PKI clients are strongly encouraged to use these attributes. 🙈

A secure channel between an End-Entity (EE) and a CA or Registration Authority (RA), and similarly between an RA and another RA or CA, necessarily needs an out-of-band trust initiation mechanism. For example, a secure channel may be built between the EE and the CA via IPsec [IPsec] or TLS [TLS]. There are lots of these schemes, and picking one for trust initiation is outside the scope of this document. Implementers are strongly encouraged to follow generally accepted principles of secure key management when they bring this into an overall security architecture 🔑

Sometimes no out-of-band trust has been set up before this protocol is used. That can happen when the protocol itself is used to download the set of trust anchors onto the system. In those cases, the EnvelopedData content type (Section 3.2.1.3.3 of [CMC-STRUCT]) or AuthEnvelopedData content type Section 3.2.1.3.5 of [CMC-STRUCT] gives the same shrouding that TLS would have given 🧁

For the mail-based protocol, the EnvelopedData or AuthEnvelopedData content types can also apply confidentiality protection (content shrouding) to the messages being conveyed. Heads up though: even if the application uses SMTP-over-TLS [RFC3207] with its preferred Message Submission Agent (MSA) for the first submission of the message, SMTP in later relay hops may be neither authenticated nor encrypted. 😬 For some combinations of initial MSA and destination domains, it may be possible to ask for authenticated TLS at every relay "hop" of delivery via the mechanism in [RFC8689]. This MAY be used when it's supported and expected to work, but it risks non-delivery if some of the SMTP servers along the relay chain don't support the REQUIRETLS ESMTP extension 💀

For the file-based protocol, filesystem permissions are usually an extra way to apply confidentiality protection (content shrouding) to the messages being conveyed 📁 The local system may limit read access to just a single user or group that matches the entity authorized to read the request or response. Diligent use of these filesystem permissions can be a really useful tool in multi-user environments 👑

10. References 📚

These are the normative references 💜

[BCP195]   Best Current Practice 195,
           <https://www.rfc-editor.org/info/bcp195>.
           At the time of writing, this BCP comprises the following:

           Moriarty, K. and S. Farrell, "Deprecating TLS 1.0 and TLS
           1.1", BCP 195, RFC 8996, DOI 10.17487/RFC8996, March 2021,
           <https://www.rfc-editor.org/info/rfc8996>.

           Sheffer, Y., Saint-Andre, P., and T. Fossati,
           "Recommendations for Secure Use of Transport Layer
           Security (TLS) and Datagram Transport Layer Security
           (DTLS)", BCP 195, RFC 9325, DOI 10.17487/RFC9325, November
           2022, <https://www.rfc-editor.org/info/rfc9325>.

[CMC-STRUCT]
           Mandel, J., Ed. and S. Turner, Ed., "Certificate
           Management over CMS (CMC)", RFC 10002,
           DOI 10.17487/RFC10002, July 2026,
           <https://www.rfc-editor.org/info/rfc10002>.

[HTTP]     Fielding, R., Ed., Nottingham, M., Ed., and J. Reschke,
           Ed., "HTTP Semantics", STD 97, RFC 9110,
           DOI 10.17487/RFC9110, June 2022,
           <https://www.rfc-editor.org/info/rfc9110>.

[HTTP-IMP] Nottingham, M., "Building Protocols with HTTP", BCP 56,
           RFC 9205, DOI 10.17487/RFC9205, June 2022,
           <https://www.rfc-editor.org/info/rfc9205>.

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

[RFC3986]  Berners-Lee, T., Fielding, R., and L. Masinter, "Uniform
           Resource Identifier (URI): Generic Syntax", STD 66,
           RFC 3986, DOI 10.17487/RFC3986, January 2005,
           <https://www.rfc-editor.org/info/rfc3986>.

[RFC5967]  Turner, S., "The application/pkcs10 Media Type", RFC 5967,
           DOI 10.17487/RFC5967, August 2010,
           <https://www.rfc-editor.org/info/rfc5967>.

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

[SMIMEV4]  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>.

[X690]     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, ISO/IEC 8825-1:2021,
           February 2021, <https://www.itu.int/rec/T-REC-X.690>.

10.2. Informative References 📚✨

Okay so these are the informative ones, aka the bonus reading list 🤓 You don't have to read them, but they're giving important background vibes, bestie 💅

Acknowledgements 🫶

Obviously, the authors wanna give a huge thank you to Jim Schaad and Michael Myers for all their work on RFC 5273 🙌

Thank you SO much to Julian Reschke, Benjamin Kaduk, Vidhi Goel, Thomas Fossati, Gorry Fairhurst, Éric Vyncke, Gunter Van de Velde, Mahesh Jethanandani, Mike Bishop, Mohamed Boucadair, Viktor Dukhovni, and Eliot Lear for reviewing the document and dropping comments 💖 You're all literal legends 👑

The Acknowledgements section from RFC 5273 of this document follows:

The authors and the PKIX Working Group are grateful for the participation of Xiaoyi Liu and Jeff Weinstein in helping to author the original versions of this document. The authors would like to thank Brian LaMacchia for his work in developing and writing up many of the concepts presented in this document. The authors would also like to thank Alex Deacon and Barb Fox for their contributions. ✨

Contributors 💜

Jim Schaad, August Cellars 🌸

Michael Myers, TraceRoute Security, Inc. 🎀

Authors' Addresses 🦋

Joseph Mandel (editor), AKAYLA, Inc. 💅 Email: joe@akayla.com

Sean Turner (editor), sn3rd 🧚 Email: sean@sn3rd.com

📦 where this page comes from