RFC 2876

Use of the KEA and SKIPJACK Algorithms in CMS

📅 published July 2000, from ietf

Use of the KEA and SKIPJACK Algorithms in CMS 🦋

Okay bestie, the header first 📜 This is RFC 2876, written by J. Pawling from WGSI, A Getronics Company, and it's dated July 2000. It's Informational, so it's sharing info with the Internet community and it is not an Internet standard. The title block doesn't list anything it obsoletes or updates.

Status of This Memo 📌

This memo provides information for the Internet community. It does not specify an Internet standard of any kind. Distribution of this memo is unlimited.

Copyright Notice ©️

Abstract 💭

This document describes how to use the Key Exchange Algorithm (KEA) and the SKIPJACK encryption algorithm together with the Cryptographic Message Syntax [CMS] enveloped-data and encrypted-data content types. It's basically the recipe for mixing these two 🍓

1. Introduction 🎀

Throughout this document, the terms MUST, MUST NOT, SHOULD and MAY are written in capital letters. This follows the definitions in [MUSTSHOULD]. [MUSTSHOULD] explains how these key words make the intent of standards track documents super clear, and the same key words are used here so implementers can get interoperability 🫶 Software that claims compliance with this document MUST provide the capabilities indicated by the MUST, MUST NOT, SHOULD and MAY terms. The KEA and SKIPJACK algorithms are described in [SJ-KEA] ✨

2. Content Encryption Process 🔐

This section applies to building both the enveloped-data and encrypted-data content types. Compliant software MUST meet the requirements stated in [CMS] Section 6.3, "Content-encryption Process". The input to the encryption process MUST be padded to a multiple of eight octets, using the padding rules described in [CMS] Section 6.3. The content MUST be encrypted as one single string using SKIPJACK in 64-bit Cipher Block Chaining (CBC) mode, with a randomly-generated 8-byte Initialization Vector (IV) and an 80-bit SKIPJACK content-encryption key (CEK) 💅

3. Content Decryption Process 🔓

This section applies to processing both the enveloped-data and encrypted-data content types. The encryptedContent MUST be decrypted as one single string using SKIPJACK in 64-bit CBC mode. The 80-bit SKIPJACK CEK and the 8-byte IV MUST be used as inputs to the SKIPJACK decryption process. After decryption, the padding MUST be removed from the decrypted data. The padding rules are described in [CMS] Section 6.3, "Content-encryption Process" 🧚

4. Enveloped-data Conventions 💌

The CMS enveloped-data content type is made of encrypted content plus wrapped CEKs for one or more recipients. Compliant software MUST meet the requirements for constructing an enveloped-data content type stated in [CMS] Section 6, "Enveloped-data Content Type". Go read [CMS] Section 6 first, because this section doesn't repeat that text 📖

An 8-byte IV and an 80-bit CEK MUST be randomly generated for each instance of an enveloped-data content type, and they're used as inputs to SKIPJACK to encrypt the content. The SKIPJACK CEK MUST only be used for encrypting the content of a single instance of an enveloped-data content type. One key, one message, periodt 🔥

KEA and SKIPJACK can be used with the enveloped-data content type using either of these key management techniques, defined in [CMS] Section 6:

Key Agreement: The SKIPJACK CEK is uniquely wrapped for each recipient using a pairwise symmetric key-encryption key (KEK). That KEK is generated with KEA, using the originator's private KEA key, the recipient's public KEA key and other values. Section 4.2 has the extra details 🤝
"Previously Distributed" Symmetric KEK: The SKIPJACK CEK is wrapped using a "previously distributed" symmetric KEK, such as a Mail List Key. How that symmetric KEK gets generated and distributed is beyond the scope of this document. Section 4.3 has more details 💜

[CMS] Section 6 also describes the key transport key management technique. The key transport technique MUST NOT be used with KEA. 🚫

4.1. EnvelopedData Fields 📋

The enveloped-data content type is Abstract Syntax Notation.1 (ASN.1) encoded using the EnvelopedData syntax. The fields of the EnvelopedData syntax need to be filled in as follows:

The EnvelopedData version MUST be 2.

If key agreement is being used, the EnvelopedData originatorInfo field SHOULD be present, and it SHOULD include the originator's KEA X.509 v3 certificate. That certificate has the KEA public key associated with the KEA private key that was used to form each pairwise symmetric KEK used to wrap each copy of the SKIPJACK CEK. The issuers' X.509 v3 certificates needed to form the complete certification path for the originator's KEA X.509 v3 certificate MAY be included in the EnvelopedData originatorInfo field. Self-signed certificates SHOULD NOT be included in the EnvelopedData originatorInfo field 🙈

The EnvelopedData RecipientInfo CHOICE depends on the key management technique being used. Sections 4.2 and 4.3 have more info on that.

The EnvelopedData encryptedContentInfo contentEncryptionAlgorithm algorithm field MUST be the id-fortezzaConfidentialityAlgorithm object identifier (OID). The EnvelopedData encryptedContentInfo contentEncryptionAlgorithm parameters field MUST include the random 8-byte IV that was used as the input to the content encryption process.

The EnvelopedData unprotectedAttrs MAY be present 🌸

4.2. Key Agreement 🤝

This section describes how to use KEA and SKIPJACK with the CMS enveloped-data content type to support key agreement. When key agreement is used, the RecipientInfo keyAgreeRecipientInfo CHOICE MUST be used.

If the EnvelopedData originatorInfo field does not include the originator's KEA X.509 v3 certificate, then each recipientInfos KeyAgreementRecipientInfo originator field MUST include the issuerAndSerialNumber CHOICE, which identifies the originator's KEA X.509 v3 certificate. If the EnvelopedData originatorInfo field does include the originator's KEA X.509 v3 certificate, then each recipientInfos KeyAgreementRecipientInfo originator field MUST include either the subjectKeyIdentifier CHOICE (containing the value from the subjectKeyIdentifier extension of the originator's KEA X.509 v3 certificate) or the issuerAndSerialNumber CHOICE that identifies the originator's KEA X.509 v3 certificate. To keep the EnvelopedData small, it's recommended that the subjectKeyIdentifier CHOICE be used 💖

In some environments, the KeyAgreementRecipientInfo originator field MAY include the originatorKey CHOICE. The originatorKey CHOICE SHOULD NOT be used with KEA for e-mail transactions. Inside a controlled security architecture, a module may produce KEA key pairs for use with internal/local storage of encrypted data. In that case there may not be an X.509 certificate associated with a (possibly) short-term or one-time-use public KEA key. When originatorKey is used, the KEA public key MUST be conveyed in the publicKey BIT STRING, as specified in [KEA] Section 3.1.2. The originatorKey algorithm identifier MUST be the id-keyExchangeAlgorithm OID. The originatorKey algorithm parameters field MUST contain the KEA "domain identifier" (ASN.1 encoded as an OCTET STRING), which identifies the KEA algorithm parameters (i.e., p/q/g values) associated with the KEA public key. [KEA] Section 3.1.1 describes how to compute the KEA domain identifier value 🧮

4.2.1. SKIPJACK CEK Wrap Process 🎁

The SKIPJACK CEK is uniquely wrapped for each recipient of the EnvelopedData, using a pairwise KEK. That KEK is generated from the KEA material of the originator and the recipient, along with the originator's User Keying Material (UKM), which is Ra. CMS EnvelopedData gives two options for wrapping the SKIPJACK CEK for each recipient with a KEA-generated KEK. The "shared Originator UKM" option SHOULD be used when constructing EnvelopedData objects. The "unique originator UKM" option MAY be used when constructing EnvelopedData objects. Compliant software MUST be able to process EnvelopedData objects built with either option 🦋

Shared Originator UKM Option: CMS lets a single, shared originator's UKM generate each pairwise KEK used to wrap the SKIPJACK CEK for each recipient. With the shared originator UKM option, a single RecipientInfo KeyAgreeRecipientInfo structure MUST be constructed to contain the wrapped SKIPJACK CEKs for all of the KEA recipients that share the same KEA parameters. The KeyAgreeRecipientInfo structure includes multiple RecipientEncryptedKey fields, and each one holds the SKIPJACK CEK wrapped for a specific recipient.
Unique Originator UKM Option: CMS also lets a unique originator UKM generate each pairwise KEK used to wrap the SKIPJACK CEK for each recipient. With the unique originator UKM option, a separate RecipientInfo KeyAgreeRecipientInfo structure MUST be constructed for each recipient. Each KeyAgreeRecipientInfo structure includes a single RecipientEncryptedKey field, which contains the SKIPJACK CEK wrapped for that recipient. This option has more overhead than the shared UKM option, because the KeyAgreeRecipientInfo fields (i.e. version, originator, ukm, keyEncryptionAlgorithm) have to be repeated for each recipient 🌈

The next two paragraphs apply to both options.

The KeyAgreeRecipientInfo keyEncryptionAlgorithm algorithm field MUST include the id-kEAKeyEncryptionAlgorithm OID. The KeyAgreeRecipientInfo keyEncryptionAlgorithm parameters field MUST contain a KeyWrapAlgorithm, as specified in [CMS] Appendix A, "ASN.1 Module". The algorithm field of the KeyWrapAlgorithm MUST be the id-fortezzaWrap80 OID, which indicates that the FORTEZZA 80-bit wrap function is used to wrap the 80-bit SKIPJACK CEK. Since the FORTEZZA 80-bit wrap function includes an integrity check value, the wrapped SKIPJACK key is 96 bits long. The parameters field of the KeyWrapAlgorithm MUST be absent 🔒

If the originator is not already an explicit recipient, a copy of the SKIPJACK CEK SHOULD be wrapped for the originator and included in the EnvelopedData. That way the originator can decrypt the contents of the EnvelopedData 💜

4.2.1.1. SKIPJACK CEK Wrap Process Using A Shared Originator UKM Value 🎀

okay so this part is about using ONE shared originator UKM value as an input to KEA, which then generates a separate pairwise KEK for each recipient to wrap the SKIPJACK CEK 🔐✨

when you're using the shared originator UKM option, you MUST build a single KeyAgreeRecipientInfo structure that holds the wrapped SKIPJACK CEKs for all the KEA recipients who use the same set of KEA parameters 💅 if every recipient's KEA public keys were generated with the same set of KEA parameters, there MUST only be ONE KeyAgreeRecipientInfo structure for all of them 🦋 but if the recipients' KEA public keys came from different sets of KEA parameters, you MUST build multiple KeyAgreeRecipientInfo fields, because the originatorIdentifierOrKey will be different for each distinct set 🌸

for each distinct set of recipients' KEA parameters, a unique 128-byte originator's UKM MUST be generated 🍓 and the originator's UKM MUST be placed in each KeyAgreeRecipientInfo ukm OCTET STRING 💜

the originator's and recipient's KEA parameters MUST be identical for KEA to successfully generate a pairwise KEK 🫶 [KEA] explains how a KEA public key is conveyed in an X.509 v3 certificate, and it says the KEA parameters are NOT included in KEA certificates. Instead, a "domain identifier" goes in the subjectPublicKeyInfo algorithm parameters field of every KEA certificate 🧚 so you can compare the KEA domain identifiers in the originator's and recipient's KEA X.509 v3 certificates to figure out whether their KEA parameters are identical ✨

the following steps MUST be repeated for each recipient 👑

KEA MUST be used to generate the pairwise KEK from four things: the originator's UKM, the originator's private KEA key, the recipient's 128-byte public KEA key (taken from the recipient's KEA X.509 v3 certificate), and that same recipient's 128-byte public KEA key, which is used as the Rb value 🔥
The SKIPJACK CEK MUST be wrapped using the KEA-generated pairwise KEK as input to the FORTEZZA 80-bit wrap function. This function takes the 80-bit SKIPJACK CEK along with a 16-bit integrity check value and produces a 96-bit result using the KEA-generated pairwise KEK 🌈
A new RecipientEncryptedKey SEQUENCE MUST be constructed for the recipient 🦋
The value of the subjectKeyIdentifier extension from the recipient's KEA X.509 v3 certificate MUST be placed in the recipient's RecipientEncryptedKey rid rKeyId subjectKeyIdentifier field. The KeyAgreeRecipientIdentifier CHOICE MUST be rKeyId. The date and other fields MUST be absent from the recipientEncryptedKey rid rKeyId SEQUENCE 🙈
The wrapped SKIPJACK CEK MUST be placed in the recipient's RecipientEncryptedKey encryptedKey OCTET STRING 💖
The recipient's RecipientEncryptedKey MUST be included in the KeyAgreeRecipientInfo recipientEncryptedKeys SEQUENCE OF RecipientEncryptedKey 🍓

4.2.1.2. SKIPJACK CEK Wrap Process Using Unique Originator UKM Values 🌸

this section is the opposite vibe: every recipient gets their OWN unique originator UKM value, which gets fed into KEA to make that recipient's pairwise KEK 💅✨

the following steps MUST be repeated for each recipient 🫶

A new KeyAgreeRecipientInfo structure MUST be constructed 💜
A unique 128-byte originator's UKM MUST be generated. The originator's UKM MUST be placed in the KeyAgreeRecipientInfo ukm OCTET STRING 🍓
KEA MUST be used to generate the pairwise KEK from the originator's UKM, the originator's private KEA key, the recipient's 128-byte public KEA key, and the recipient's 128-byte public KEA key used as the Rb value 🔥
The SKIPJACK CEK MUST be wrapped using the KEA-generated pairwise KEK as input to the FORTEZZA 80-bit wrap function. The FORTEZZA 80-bit wrap function takes the 80-bit SKIPJACK CEK along with a 16-bit integrity check value and produces a 96-bit result using the KEA-generated pairwise KEK 🦋
A new RecipientEncryptedKey SEQUENCE MUST be constructed 🧚
The value of the subjectKeyIdentifier extension from the recipient's KEA X.509 v3 certificate MUST be placed in the RecipientEncryptedKey rid rKeyId subjectKeyIdentifier field. The KeyAgreeRecipientIdentifier CHOICE MUST be rKeyId. The date and other fields MUST be absent from the RecipientEncryptedKey rid rKeyId SEQUENCE 🌈
The wrapped SKIPJACK CEK MUST be placed in the RecipientEncryptedKey encryptedKey OCTET STRING ⭐
The recipient's RecipientEncryptedKey MUST be the ONLY RecipientEncryptedKey present in the KeyAgreeRecipientInfo recipientEncryptedKeys SEQUENCE OF RecipientEncryptedKey 👑
The RecipientInfo containing the recipient's KeyAgreeRecipientInfo MUST be included in the EnvelopedData RecipientInfos SET OF RecipientInfo 💖

4.2.2. SKIPJACK CEK Unwrap Process 🔓

this is the receiving side, and it's where the recipient works backwards to get the SKIPJACK CEK back out and decrypt the content 🕵️‍♀️💅

Compliant software MUST be capable of processing EnvelopedData objects constructed using both the shared and the unique originator UKM options. To support the shared UKM option, the receiving software MUST be capable of searching for the recipient's RecipientEncryptedKey in a KeyAgreeRecipientInfo recipientEncryptedKeys SEQUENCE OF RecipientEncryptedKey. To support the unique UKM option, the receiving software MUST be capable of searching for the recipient's RecipientEncryptedKey in the EnvelopedData recipientInfos SET OF RecipientInfo, with each RecipientInfo containing exactly one RecipientEncryptedKey. For each RecipientEncryptedKey, if the rid rkeyId CHOICE is present, then the receiving software MUST attempt to match the value of the subjectKeyIdentifier extension from the recipient's KEA X.509 v3 certificate with the RecipientEncryptedKey rid rKeyId subjectKeyIdentifier field. If the rid issuerAndSerialNumber CHOICE is present, then the receiving software MUST attempt to match the values of the issuer name and serial number from the recipient's KEA X.509 v3 certificate with the RecipientEncryptedKey rid issuerAndSerialNumber field 🔍✨
The receiving software MUST extract the originator's UKM from the ukm OCTET STRING contained in the same KeyAgreeRecipientInfo that includes the recipient's RecipientEncryptedKey 🎀
The receiving software MUST locate the originator's KEA X.509 v3 certificate identified by the originator field contained in the same KeyAgreeRecipientInfo that includes the recipient's RecipientEncryptedKey 🦋
KEA MUST be used to generate the pairwise KEK from the originator's UKM, the originator's 128-byte public KEA key (extracted from the originator's KEA X.509 v3 certificate), the recipient's private KEA key (associated with the recipient's KEA X.509 v3 certificate identified by the RecipientEncryptedKey rid field), and the originator's 128-byte public KEA key used as the Rb value 🔥
The SKIPJACK CEK MUST be unwrapped using the KEA-generated pairwise KEK as input to the FORTEZZA 80-bit unwrap function 🌸
The unwrapped 80-bit SKIPJACK CEK from the SKIPJACK CEK unwrap process, plus the 8-byte IV taken from the EnvelopedData encryptedContentInfo contentEncryptionAlgorithm parameters field, are used as inputs to the SKIPJACK content decryption process to decrypt the EnvelopedData encryptedContent 💖

4.3. "Previously Distributed" Symmetric KEK 🗝️

this section is about using SKIPJACK with the CMS enveloped-data content type when you're working with a "previously distributed" symmetric KEK 🧁 when a "previously distributed" symmetric KEK is used to wrap the SKIPJACK CEK, the RecipientInfo KEKRecipientInfo CHOICE MUST be used. How that symmetric KEK gets generated and distributed is beyond the scope of this document, so we're not going there 🙈

the KEKRecipientInfo fields MUST be populated as specified in [CMS] Section 6.2.3, "KEKRecipientInfo Type" 🫶 The KEKRecipientInfo keyEncryptionAlgorithm algorithm field MUST be the id-fortezzaWrap80 OID, which says the FORTEZZA 80-bit wrap function is used to wrap the 80-bit SKIPJACK CEK 🔥 The KEKRecipientInfo keyEncryptionAlgorithm parameters field MUST be absent 💅 And the KEKRecipientInfo encryptedKey field MUST include the SKIPJACK CEK wrapped using the "previously distributed" symmetric KEK as input to the FORTEZZA 80-bit wrap function 👑

5. Encrypted-data Conventions 🔐

okay so the CMS encrypted-data content type is just encrypted content with NO recipient information attached 🫠 how the SKIPJACK CEK needed to decrypt that content gets conveyed is beyond the scope of this document. Compliant software MUST meet the requirements for constructing an encrypted-data content type stated in [CMS] Section 8, "Encrypted-data Content Type" 💖 and [CMS] Section 8 should be studied before you read this section, because this section does NOT repeat the [CMS] text 📚

the encrypted-data content type is ASN.1 encoded using the EncryptedData syntax. The fields of the EncryptedData syntax must be populated as follows: 🎀

The EncryptedData version MUST be set according to [CMS] Section 8 🧚
The EncryptedData encryptedContentInfo contentEncryptionAlgorithm algorithm field MUST be the id-fortezzaConfidentialityAlgorithm OID 🦋
The EncryptedData encryptedContentInfo contentEncryptionAlgorithm parameters field MUST include the random 8-byte IV used as the input to the content encryption process 🌸
The EncryptedData unprotectedAttrs MAY be present ✨

6. FORTEZZA 80-bit Wrap Function 🙅‍♀️

the United States Government has not published the description of the FORTEZZA 80-bit wrap function, so that one's a no-go for us 🙈💀

7. SMIMECapabilities Attribute Conventions 📇

RFC 2633 [MSG], Section 2.5.2 defines the SMIMECapabilities signed attribute (defined as a SEQUENCE of SMIMECapability SEQUENCEs) to be used to specify a partial list of algorithms that the software announcing the SMIMECapabilities can support 💜 When constructing a signedData object, compliant software MAY include the SMIMECapabilities signed attribute announcing that it supports the KEA and SKIPJACK algorithms 🫶

the SMIMECapability SEQUENCE representing KEA MUST include the id-kEAKeyEncryptionAlgorithm OID in the capabilityID field and MUST include a KeyWrapAlgorithm SEQUENCE in the parameters field. The algorithm field of KeyWrapAlgorithm MUST be the id-fortezzaWrap80 OID. The parameters field of KeyWrapAlgorithm MUST be absent. The SMIMECapability SEQUENCE for KEA SHOULD be included in the key management algorithms portion of the SMIMECapabilities list. The SMIMECapability SEQUENCE representing KEA MUST be DER-encoded as the following hexadecimal string: 🔥

3018 0609 6086 4801 6502 0101 1830 0b06 0960 8648 0165 0201 0117

the SMIMECapability SEQUENCE representing SKIPJACK MUST include the id-fortezzaConfidentialityAlgorithm OID in the capabilityID field, and the parameters field MUST be absent 🌈 The SMIMECapability SEQUENCE for SKIPJACK SHOULD be included in the symmetric encryption algorithms portion of the SMIMECapabilities list. The SMIMECapability SEQUENCE representing SKIPJACK MUST be DER-encoded as the following hexadecimal string: ✨

300b 0609 6086 4801 6502 0101 0400

8. Object Identifier Definitions ✨

okay so these OIDs are officially defined over in [INFO], but I copied them here so you don't have to go hunting 🧚 they're the ID numbers that label the algorithms, so every system agrees on what's what 💜

   id-keyExchangeAlgorithm OBJECT IDENTIFIER ::= {joint-iso-ccitt(2)
   country(16) us(840) organization(1) gov(101) dod(2) infosec(1)
   algorithms(1) keyExchangeAlgorithm (22)}
   id-fortezzaWrap80 OBJECT IDENTIFIER ::= {joint-iso-ccitt(2)
   country(16) us(840) organization(1) gov(101) dod(2) infosec(1)
   algorithms(1) fortezzaWrap80Algorithm (23)}

   id-kEAKeyEncryptionAlgorithm OBJECT IDENTIFIER ::= {joint-iso-
   ccitt(2) country(16) us(840) organization(1) gov(101) dod(2)
   infosec(1) algorithms(1) kEAKeyEncryptionAlgorithm (24)}

   id-fortezzaConfidentialityAlgorithm OBJECT IDENTIFIER ::= {joint-
   iso-ccitt(2) country(16) us(840) organization(1) gov(101) dod(2)
   infosec(1) algorithms(1) fortezzaConfidentialityAlgorithm (4)}

as [USSUP1] lays out, whenever the id-fortezzaConfidentialityAlgorithm OID shows up in the AlgorithmIdentifier algorithm field, the AlgorithmIdentifier parameters field MUST be present, and it MUST include the SKIPJACK IV, ASN.1 encoded with this syntax 🔥

   Skipjack-Parm ::= SEQUENCE { initialization-vector   OCTET STRING }

note: [CMS] Section 2, "General Overview" explains the ASN.1 encoding conventions for the CMS content types, including enveloped-data and encrypted-data, which are the places where the id-fortezzaConfidentialityAlgorithm OID and its parameters will show up 💅

References ✨

[CMS] Housley, R., "Cryptographic Message Syntax", RFC 2630, June 1999.
[KEA] Housley, R. and W. Polk, "Representation of Key Exchange Algorithm (KEA) Keys in Internet X.509 Public Key Infrastructure Certificates", RFC 2528, March 1999.
[INFO] Registry of INFOSEC Technical Objects, 22 July 1999.
[MSG] Ramsdell, B., "S/MIME Version 3 Message Specification", RFC 2633, June 1999.
[MUSTSHOULD] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, March 1997.
[SJ-KEA] SKIPJACK and KEA Algorithm Specifications, Version 2.0, http://csrc.nist.gov/encryption/skipjack-kea.htm.
[USSUP1] Allied Communication Publication 120 (ACP120) Common Security Protocol (CSP) United States (US) Supplement No. 1, June 1998; http://www.armadillo.huntsville.al.us/Fortezza_docs/missi2.html#specs.

Acknowledgments 🫶

huge thank yous to the people who made significant contributions to this memo: David Dalkowski, Phillip Griffin, Russ Housley, Pierce Leonberger, Rich Nicholas, Bob Relyea and Jim Schaad. you all are iconic 🌈

Author's Address 🎀

   John Pawling
   Wang Government Services, Inc. (WGSI),
   A Getronics Company
   141 National Business Pkwy, Suite 210
   Annapolis Junction, MD  20701

   Phone: (301) 939-2739
          (410) 880-6095
   EMail: john.pawling@wang.com

Full Copyright Statement ⚖️

the legal bits have to stay word-for-word, so here they are exactly as written 🙈

This document and translations of it may be copied and furnished to others, and derivative works that comment on or otherwise explain it or assist in its implementation may be prepared, copied, published and distributed, in whole or in part, without restriction of any kind, provided that the above copyright notice and this paragraph are included on all such copies and derivative works. However, this document itself may not be modified in any way, such as by removing the copyright notice or references to the Internet Society or other Internet organizations, except as needed for the purpose of developing Internet standards in which case the procedures for copyrights defined in the Internet Standards process must be followed, or as required to translate it into languages other than English.

The limited permissions granted above are perpetual and will not be revoked by the Internet Society or its successors or assigns.

This document and the information contained herein is provided on an "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.

Acknowledgement 💖

funding for the RFC Editor function is currently provided by the Internet Society. and that's a wrap, bestie 🦋✨

📦 where this page comes from

ietf: rfc2876 2000-07
💖 girlified by claude-haiku-5-5 on 2026-10-16: a language model's rewrite of the original, under its terms