Post-Quantum Cryptography in OpenPGP
Internet-Draft draft-ietf-openpgp-pqc-04
Stavros Kousidis
BSI
Germany
stavros.kousidis@bsi.bund.de
Johannes Roth
MTG AG
Germany
johannes.roth@mtg.de
Falko Strenzke
MTG AG
Germany
falko.strenzke@mtg.de
Aron Wussler
Proton AG
Switzerland
aron@wussler.it
08 July 2024
sec
Network Working Group
Internet-Draft
This document defines a post-quantum public-key algorithm extension for the OpenPGP protocol. Given the generally assumed threat of a cryptographically relevant quantum computer, this extension provides a basis for long-term secure OpenPGP signatures and ciphertexts. Specifically, it defines composite public-key encryption based on ML-KEM (formerly CRYSTALS-Kyber), composite public-key signatures based on ML-DSA (formerly CRYSTALS-Dilithium), both in combination with elliptic curve cryptography, and SLH-DSA-SHAKE (formerly SPHINCS+) as a standalone public key signature scheme.
About This Document
Status information for this document may be found at https://datatracker.ietf.org/doc/draft-ietf-openpgp-pqc/.
Discussion of this document takes place on the WG Working Group mailing list (mailto:openpgp@ietf.org), which is archived at https://mailarchive.ietf.org/arch/browse/openpgp/. Subscribe at https://www.ietf.org/mailman/listinfo/openpgp/.
Source for this draft and an issue tracker can be found at https://github.com/openpgp-pqc/draft-openpgp-pqc.
Introduction
The OpenPGP protocol supports various traditional public-key algorithms based on the factoring or discrete logarithm problem. As the security of algorithms based on these mathematical problems is endangered by the advent of quantum computers, there is a need to extend OpenPGP by algorithms that remain secure in the presence of quantum computers.
Such cryptographic algorithms are referred to as post-quantum cryptography. The algorithms defined in this extension were chosen for standardization by the National Institute of Standards and Technology (NIST) in mid 2022 [NISTIR-8413] as the result of the NIST Post-Quantum Cryptography Standardization process initiated in 2016 [NIST-PQC]. Namely, these are ML-KEM [FIPS-203] as a Key Encapsulation Mechanism (KEM), a KEM being a modern building block for public-key encryption, and ML-DSA [FIPS-204] as well as SLH-DSA-SHAKE [FIPS-205] as signature schemes.
For the two ML-* schemes, this document follows the conservative strategy to deploy post-quantum in combination with traditional schemes such that the security is retained even if all schemes but one in the combination are broken. In contrast, the stateless hash-based signature scheme SLH-DSA-SHAKE is considered to be sufficiently well understood with respect to its security assumptions in order to be used standalone. To this end, this document specifies the following new set: SLH-DSA-SHAKE standalone and the two ML-* as composite with ECC-based KEM and digital signature schemes. Here, the term "composite" indicates that any data structure or algorithm pertaining to the combination of the two components appears as single data structure or algorithm from the protocol perspective.
The document specifies the conventions for interoperability between compliant OpenPGP implementations that make use of this extension and the newly defined algorithms or algorithm combinations.
Conventions used in this Document
Terminology for Multi-Algorithm Schemes
The terminology in this document is oriented towards the definitions in [I-D.ietf-pquip-pqt-hybrid-terminology]. Specifically, the terms "multi-algorithm", "composite" and "non-composite" are used in correspondence with the definitions therein. The abbreviation "PQ" is used for post-quantum schemes. To denote the combination of post-quantum and traditional schemes, the abbreviation "PQ/T" is used. The short form "PQ(/T)" stands for PQ or PQ/T.
Post-Quantum Cryptography
This section describes the individual post-quantum cryptographic schemes. All schemes listed here are believed to provide security in the presence of a cryptographically relevant quantum computer. However, the mathematical problems on which the two ML-* schemes and SLH-DSA-SHAKE are based, are fundamentally different, and accordingly the level of trust commonly placed in them as well as their performance characteristics vary.
[Note to the reader: This specification refers to the NIST PQC draft standards FIPS 203, FIPS 204, and FIPS 205 as if they were a final specification. This is a temporary solution until the final versions of these documents are available. The goal is to provide a sufficiently precise specification of the algorithms already at the draft stage of this specification, so that it is possible for implementers to create interoperable implementations. Furthermore, we want to point out that, depending on possible future changes to the draft standards by NIST, this specification may be updated as soon as corresponding information becomes available.]
ML-KEM
ML-KEM [FIPS-203] is based on the hardness of solving the Learning with Errors problem in module lattices (MLWE). The scheme is believed to provide security against cryptanalytic attacks by classical as well as quantum computers. This specification defines ML-KEM only in composite combination with ECDH encryption schemes in order to provide a pre-quantum security fallback.
ML-DSA
ML-DSA [FIPS-204] is a signature scheme that, like ML-KEM, is based on the hardness of solving the Learning With Errors problem and a variant of the Short Integer Solution problem in module lattices (MLWE and SelfTargetMSIS). Accordingly, this specification only defines ML-DSA in composite combination with EdDSA signature schemes.
SLH-DSA-SHAKE
SLH-DSA-SHAKE [FIPS-205] is a stateless hash-based signature scheme. Its security relies on the hardness of finding preimages for cryptographic hash functions. This feature is generally considered to be a high security guarantee. Therefore, this specification defines SLH-DSA-SHAKE as a standalone signature scheme.
In deployments the performance characteristics of SLH-DSA-SHAKE should be taken into account. We refer to Section 10.1 for a discussion of the performance characteristics of this scheme.
Elliptic Curve Cryptography
The ECDH encryption is defined here as a KEM. Curve25519 and Curve448 are defined in [RFC7748] for use in a Diffie-Hellman key agreement scheme and defined in [RFC8032] for use in a digital signature scheme.
Standalone and Multi-Algorithm Schemes
This section provides a categorization of the new algorithms and their combinations.
Standalone and Composite Multi-Algorithm Schemes
This specification introduces new cryptographic schemes, which can be categorized as follows:
- PQ/T multi-algorithm public-key encryption, namely a composite combination of ML-KEM with an ECDH KEM,
- PQ/T multi-algorithm digital signature, namely composite combinations of ML-DSA with EdDSA signature schemes,
- PQ digital signature, namely SLH-DSA-SHAKE as a standalone cryptographic algorithm.
For each of the composite schemes, this specification mandates that the consuming party has to successfully perform the cryptographic algorithms for each of the component schemes used in a cryptographic message, in order for the message to be deciphered and considered as valid. This means that all component signatures must be verified successfully in order to achieve a successful verification of the composite signature. In the case of the composite public-key decryption, each of the component KEM decapsulation operations must succeed.
Non-Composite Algorithm Combinations
As the OpenPGP protocol [I-D.ietf-openpgp-crypto-refresh] allows for multiple signatures to be applied to a single message, it is also possible to realize non-composite combinations of signatures. Furthermore, multiple OpenPGP signatures may be combined on the application layer. These latter two cases realize non-composite combinations of signatures. Section 3.3 specifies how implementations should handle the verification of such combinations of signatures.
Furthermore, the OpenPGP protocol also allows parallel encryption to different keys by using multiple PKESK packets, thus realizing non-composite multi-algorithm public-key encryption.
Supported Public Key Algorithms
This section specifies the composite ML-KEM + ECDH and ML-DSA + EdDSA schemes as well as the standalone SLH-DSA-SHAKE signature scheme. All of these schemes are fully specified via their algorithm ID, i.e., they are not parametrized.
Algorithm Specifications
For encryption, the following composite KEM schemes are specified:
KEM algorithm specifications
ID | Algorithm | Requirement | Definition
TBD (105 for testing) | ML-KEM-768+X25519 | MUST | Section 4.2
TBD (106 for testing) | ML-KEM-1024+X448 | SHOULD | Section 4.2
For signatures, the following (composite) signature schemes are specified:
Signature algorithm specifications
ID | Algorithm | Requirement | Definition
TBD (107 for testing) | ML-DSA-65+Ed25519 | MUST | Section 5.2
TBD (108 for testing) | ML-DSA-87+Ed448 | SHOULD | Section 5.2
TBD | SLH-DSA-SHAKE-128s | MAY | Section 6.1
TBD | SLH-DSA-SHAKE-128f | MAY | Section 6.1
TBD | SLH-DSA-SHAKE-256s | MAY | Section 6.1
Experimental Codepoints for Interop Testing
[ Note: this section to be removed before publication ]
Algorithms indicated as MAY are not assigned a codepoint in the current state of the draft in order to leave enough private/experimental code points available for other drafts.
The use of private/experimental codepoints during development are intended to be used in non-released software only, for experimentation and interop testing purposes only. An OpenPGP implementation MUST NOT produce a formal release using these experimental codepoints. This draft will not be sent to IANA without every listed algorithm having a non-experimental codepoint.
Algorithm Combinations
Composite KEMs
The ML-KEM + ECDH public-key encryption involves both the ML-KEM and an ECDH KEM in an a priori non-separable manner. This is achieved via KEM combination, i.e. both key encapsulations/decapsulations are performed in parallel, and the resulting key shares are fed into a key combiner to produce a single shared secret for message encryption.
As explained in Section 1.4.2, the OpenPGP protocol inherently supports parallel encryption to different keys. Note that the confidentiality of a message is not post-quantum secure when encrypting to different keys if at least one key does not support PQ/T encryption schemes. In section 8.1 it is explained how to deal with multiple key scenarios.
Composite Signatures
The ML-DSA + EdDSA signature consists of independent ML-DSA and EdDSA signatures, and an implementation MUST successfully validate both signatures to state that the ML-DSA + EdDSA signature is valid.
Multiple Signatures
The OpenPGP message format allows multiple signatures of a message, i.e. the attachment of multiple signature packets.
An implementation MAY sign a message with a traditional key and a PQ(/T) key from the same sender. This ensures backwards compatibility due to [I-D.ietf-openpgp-crypto-refresh], Section 5.2.5, since a legacy implementation without PQ(/T) support can fall back on the traditional signature.
Newer implementations with PQ(/T) support MAY ignore the traditional signature(s) during validation.
Implementations SHOULD consider the message correctly signed if at least one of the non-ignored signatures validates successfully.
[Note to the reader: The last requirement, that one valid signature is sufficient to identify a message as correctly signed, is an interpretation of [I-D.ietf-openpgp-crypto-refresh], Section 5.2.5.]
ECC requirements
Even though the zero point, also called the point at infinity, may occur as a result of arithmetic operations on points of an elliptic curve, it MUST NOT appear in any ECC data structure defined in this document.
Furthermore, when performing the explicitly listed operations in Section 4.1.1.1 or Section 4.1.1.2 it is REQUIRED to follow the specification and security advisory mandated from the respective elliptic curve specification.
Composite KEM schemes
Building Blocks
ECDH KEMs
In this section we define the encryption, decryption, and data formats for the ECDH component of the composite algorithms.
Table 3 describes the ECDH-KEM parameters and artifact lengths. The artifacts in Table 3 follow the encodings described in [RFC7748].
Montgomery curves parameters and artifact lengths
| X25519 | X448
Algorithm ID reference | TBD (105 for testing) | TBD (106 for testing)
Field size | 32 octets | 56 octets
ECDH-KEM | x25519Kem (Section 4.1.1.1) | x448Kem (Section 4.1.1.2)
ECDH public key | 32 octets [RFC7748] | 56 octets [RFC7748]
ECDH secret key | 32 octets [RFC7748] | 56 octets [RFC7748]
ECDH ephemeral | 32 octets [RFC7748] | 56 octets [RFC7748]
ECDH share | 32 octets [RFC7748] | 56 octets [RFC7748]
Key share | 32 octets | 64 octets
Hash | SHA3-256 | SHA3-512
The various procedures to perform the operations of an ECDH KEM are defined in the following subsections. Specifically, each of these subsections defines the instances of the following operations:

(ecdhCipherText, ecdhKeyShare) <- ECDH-KEM.Encaps(ecdhPublicKey)

and

(ecdhKeyShare) <- ECDH-KEM.Decaps(ecdhSecretKey, ecdhCipherText, ecdhPublicKey)

To instantiate ECDH-KEM, one must select a parameter set from Table 3.
X25519-KEM
The encapsulation and decapsulation operations of x25519kem are described using the function X25519() and encodings defined in [RFC7748]. The ecdhSecretKey is denoted as r, the ecdhPublicKey as R, they are subject to the equation R = X25519(r, U(P)). Here, U(P) denotes the u-coordinate of the base point of Curve25519.
The operation x25519Kem.Encaps() is defined as follows:
1. Generate an ephemeral key pair {v, V} via V = X25519(v,U(P)) where v is a randomly generated octet string with a length of 32 octets
2. Compute the shared coordinate X = X25519(v, R) where R is the recipient's public key ecdhPublicKey
3. Set the output ecdhCipherText to V
4. Set the output ecdhKeyShare to SHA3-256(X || ecdhCipherText || ecdhPublicKey)
The operation x25519Kem.Decaps() is defined as follows:
1. Compute the shared coordinate X = X25519(r, V), where r is the ecdhSecretKey and V is the ecdhCipherText
2. Set the output ecdhKeyShare to SHA3-256(X || ecdhCipherText || ecdhPublicKey)
X448-KEM
The encapsulation and decapsulation operations of x448kem are described using the function X448() and encodings defined in [RFC7748]. The ecdhSecretKey is denoted as r, the ecdhPublicKey as R, they are subject to the equation R = X25519(r, U(P)). Here, U(P) denotes the u-coordinate of the base point of Curve448.
The operation x448.Encaps() is defined as follows:
1. Generate an ephemeral key pair {v, V} via V = X448(v,U(P)) where v is a randomly generated octet string with a length of 56 octets
2. Compute the shared coordinate X = X448(v, R) where R is the recipient's public key ecdhPublicKey
3. Set the output ecdhCipherText to V
4. Set the output ecdhKeyShare to SHA3-512(X || ecdhCipherText || ecdhPublicKey)
The operation x448Kem.Decaps() is defined as follows:
1. Compute the shared coordinate X = X448(r, V), where r is the ecdhSecretKey and V is the ecdhCipherText
2. Set the output ecdhKeyShare to SHA3-512(X || ecdhCipherText || ecdhPublicKey)
ML-KEM
ML-KEM features the following operations:

(mlkemCipherText, mlkemKeyShare) <- ML-KEM.Encaps(mlkemPublicKey)

and

(mlkemKeyShare) <- ML-KEM.Decaps(mlkemCipherText, mlkemSecretKey)

The above are the operations ML-KEM.Encaps and ML-KEM.Decaps defined in [FIPS-203]. Note that mlkemPublicKey is the encapsulation and mlkemSecretKey is the decapsulation key.
ML-KEM has the parametrization with the corresponding artifact lengths in octets as given in Table 4. All artifacts are encoded as defined in [FIPS-203].
ML-KEM parameters artifact lengths in octets
Algorithm ID reference | ML-KEM | Public key | Secret key | Ciphertext | Key share
TBD (105 for testing) | ML-KEM-768 | 1184 | 2400 | 1088 | 32
TBD (106 for testing) | ML-KEM-1024 | 1568 | 3168 | 1568 | 32
To instantiate ML-KEM, one must select a parameter set from the column "ML-KEM" of Table 4.
The procedure to perform ML-KEM.Encaps() is as follows:
1. Invoke (mlkemCipherText, mlkemKeyShare) <- ML-KEM.Encaps(mlkemPublicKey), where mlkemPublicKey is the recipient's public key
2. Set mlkemCipherText as the ML-KEM ciphertext
3. Set mlkemKeyShare as the ML-KEM symmetric key share
The procedure to perform ML-KEM.Decaps() is as follows:
1. Invoke mlkemKeyShare <- ML-KEM.Decaps(mlkemCipherText, mlkemSecretKey)
2. Set mlkemKeyShare as the ML-KEM symmetric key share
Composite Encryption Schemes with ML-KEM
Table 1 specifies the following ML-KEM + ECDH composite public-key encryption schemes:
ML-KEM + ECDH composite schemes
Algorithm ID reference | ML-KEM | ECDH-KEM
TBD (105 for testing) | ML-KEM-768 | x25519Kem
TBD (106 for testing) | ML-KEM-1024 | x448Kem
The ML-KEM + ECDH composite public-key encryption schemes are built according to the following principal design:
- The ML-KEM encapsulation algorithm is invoked to create an ML-KEM ciphertext together with an ML-KEM symmetric key share.
- The encapsulation algorithm of an ECDH KEM, namely X25519-KEM or X448-KEM, is invoked to create an ECDH ciphertext together with an ECDH symmetric key share.
- A Key-Encryption-Key (KEK) is computed as the output of a key combiner that receives as input both of the above created symmetric key shares and the protocol binding information.
- The session key for content encryption is then wrapped as described in [RFC3394] using AES-256 as algorithm and the KEK as key.
- The PKESK packet's algorithm-specific parts are made up of the ML-KEM ciphertext, the ECDH ciphertext, and the wrapped session key.
Fixed information
For the composite KEM schemes defined in Table 1 the following procedure, justified in Section 9.4, MUST be used to derive a string to use as binding between the KEK and the communication parties.

//   Input:
//   algID - the algorithm ID encoded as octet
//
//   Constants:
//   domSeparation - the UTF-8 encoding of the string
//                   "OpenPGPCompositeKDFv1"

fixedInfo = algID || domSeparation

The value of domSeparation is the UTF-8 encoding of the string "OpenPGPCompositeKDFv1" and MUST be the following octet sequence:

domSeparation := 4F 70 65 6E 50 47 50 43 6F 6D 70 6F 73 69 74 65 4B
                 44 46 76 31

Key combiner
For the composite KEM schemes defined in Table 1 the following procedure MUST be used to compute the KEK that wraps a session key. The construction is a one-step key derivation function compliant to [SP800-56C], Section 4, based on SHA3-256. It is given by the following algorithm, which computes the key encryption key KEK that is used to wrap, i.e., encrypt, the session key.
[Note to the reader: the key combiner defined in the current version of this draft is not actually compliant to [SP800-56C], since the NIST standard requires that the shared secret is fed to the KDF first whereas the combiner defined here feeds the key shares of the two component schemes, which together form the shared secret, in two parts with public information in between. The combiner will be reworked to fix this defect. The change is planned to be integrated prior to IETF 121.]

//   multiKeyCombine(ecdhKeyShare, ecdhCipherText, ecdhPublicKey, mlkemKeyShare,
//                   mlkemCipherText, mlkemPublicKey, fixedInfo)
//
//   Input:
//   ecdhKeyShare    - the ECDH key share encoded as an octet string
//   ecdhCipherText  - the ECDH ciphertext encoded as an octet string
//   ecdhPublicKey   - The ECDH public key of the recipient as an octet string
//   mlkemKeyShare   - the ML-KEM key share encoded as an octet string
//   mlkemCipherText - the ML-KEM ciphertext encoded as an octet string
//   mlkemPublicKey  - The ML-KEM public key of the recipient as an octet string
//   fixedInfo       - the fixed information octet string
//
//   Constants:
//   counter - the 4 byte value 00 00 00 01

ecdhData = ecdhKeyShare || ecdhCipherText || ecdhPublicKey
mlkemData = mlkemKeyShare || mlkemCipherText || mlkemPublicKey

KEK = SHA3-256(counter || ecdhData || mlkemData || fixedInfo)
return KEK

Note that the values ecdhKeyShare defined in Section 4.1.1 and mlkemKeyShare defined in Section 4.1.2 already use the relative ciphertext in the derivation. The ciphertext and public keys are by design included again in the key combiner to provide a robust security proof.
The value of counter MUST be set to the following octet sequence:

counter :=  00 00 00 01

The value of fixedInfo MUST be set according to Section 4.2.1.
Key generation procedure
The implementation MUST independently generate the ML-KEM and the ECDH component keys. ML-KEM key generation follows the specification [FIPS-203] and the artifacts are encoded as fixed-length octet strings as defined in Section 4.1.2. For ECDH this is done following the relative specification in [RFC7748], and encoding the outputs as fixed-length octet strings in the format specified in Table 3.
Encryption procedure
The procedure to perform public-key encryption with an ML-KEM + ECDH composite scheme is as follows:
1. Take the recipient's authenticated public-key packet pkComposite and sessionKey as input
2. Parse the algorithm ID from pkComposite
3. Extract the ecdhPublicKey and mlkemPublicKey component from the algorithm specific data encoded in pkComposite with the format specified in Section 4.3.2.
4. Instantiate the ECDH-KEM and the ML-KEM depending on the algorithm ID according to Table 5
5. Compute (ecdhCipherText, ecdhKeyShare) := ECDH-KEM.Encaps(ecdhPublicKey)
6. Compute (mlkemCipherText, mlkemKeyShare) := ML-KEM.Encaps(mlkemPublicKey)
7. Compute fixedInfo as specified in Section 4.2.1
8. Compute KEK := multiKeyCombine(ecdhKeyShare, ecdhCipherText, ecdhPublicKey, mlkemKeyShare, mlkemCipherText, mlkemPublicKey, fixedInfo) as defined in Section 4.2.2
9. Compute C := AESKeyWrap(KEK, sessionKey) with AES-256 as per [RFC3394] that includes a 64 bit integrity check
10. Output the algorithm specific part of the PKESK as ecdhCipherText || mlkemCipherText || len(C, symAlgId) (|| symAlgId) || C, where both symAlgId and len(C, symAlgId) are single octet fields, symAlgId denotes the symmetric algorithm ID used and is present only for a v3 PKESK, and len(C, symAlgId) denotes the combined octet length of the fields specified as the arguments.
Decryption procedure
The procedure to perform public-key decryption with an ML-KEM + ECDH composite scheme is as follows:
1. Take the matching PKESK and own secret key packet as input
2. From the PKESK extract the algorithm ID and the encryptedKey, i.e., the wrapped session key
3. Check that the own and the extracted algorithm ID match
4. Parse the ecdhSecretKey and mlkemSecretKey from the algorithm specific data of the own secret key encoded in the format specified in Section 4.3.2
5. Instantiate the ECDH-KEM and the ML-KEM depending on the algorithm ID according to Table 5
6. Parse ecdhCipherText, mlkemCipherText, and C from encryptedKey encoded as ecdhCipherText || mlkemCipherText || len(C,symAlgId) (|| symAlgId) || C as specified in Section 4.3.1, where symAlgId is present only in the case of a v3 PKESK.
7. Compute (ecdhKeyShare) := ECDH-KEM.Decaps(ecdhCipherText, ecdhSecretKey, ecdhPublicKey)
8. Compute (mlkemKeyShare) := ML-KEM.Decaps(mlkemCipherText, mlkemSecretKey)
9. Compute fixedInfo as specified in Section 4.2.1
10. Compute KEK := multiKeyCombine(ecdhKeyShare, ecdhCipherText, ecdhPublicKey, mlkemKeyShare, mlkemCipherText, mlkemPublicKey, fixedInfo) as defined in Section 4.2.2
11. Compute sessionKey := AESKeyUnwrap(KEK, C) with AES-256 as per [RFC3394], aborting if the 64 bit integrity check fails
12. Output sessionKey
Packet specifications
Public-Key Encrypted Session Key Packets (Tag 1)
The algorithm-specific fields consists of the output of the encryption procedure described in Section 4.2.4:
- A fixed-length octet string representing an ECDH ephemeral public key in the format associated with the curve as specified in Section 4.1.1.
- A fixed-length octet string of the ML-KEM ciphertext, whose length depends on the algorithm ID as specified in Table 4.
- A one-octet size of the following fields.
- Only in the case of a v3 PKESK packet: a one-octet symmetric algorithm identifier.
- The wrapped session key represented as an octet string.
Note that like in the case of the algorithms X25519 and X448 specified in [I-D.ietf-openpgp-crypto-refresh], for the ML-KEM composite schemes, in the case of a v3 PKESK packet, the symmetric algorithm identifier is not encrypted. Instead, it is placed in plaintext after the mlkemCipherText and before the length octet preceding the wrapped session key. In the case of v3 PKESK packets for ML-KEM composite schemes, the symmetric algorithm used MUST be AES-128, AES-192 or AES-256 (algorithm ID 7, 8 or 9).
In the case of a v3 PKESK, a receiving implementation MUST check if the length of the unwrapped symmetric key matches the symmetric algorithm identifier, and abort if this is not the case.
Implementations MUST NOT use the obsolete Symmetrically Encrypted Data packet (tag 9) to encrypt data protected with the algorithms described in this document.
Key Material Packets
The algorithm-specific public key is this series of values:
- A fixed-length octet string representing an EC point public key, in the point format associated with the curve specified in Section 4.1.1.
- A fixed-length octet string containing the ML-KEM public key, whose length depends on the algorithm ID as specified in Table 4.
The algorithm-specific secret key is these two values:
- A fixed-length octet string of the encoded secret scalar, whose encoding and length depend on the algorithm ID as specified in Section 4.1.1.
- A fixed-length octet string containing the ML-KEM secret key, whose length depends on the algorithm ID as specified in Table 4.
Composite Signature Schemes
Building blocks
EdDSA-Based signatures
To sign and verify with EdDSA the following operations are defined:

(eddsaSignature) <- EdDSA.Sign(eddsaSecretKey, dataDigest)

and

(verified) <- EdDSA.Verify(eddsaPublicKey, eddsaSignature, dataDigest)

The public and secret key, as well as the signature MUST be encoded according to [RFC8032] as fixed-length octet strings. The following table describes the EdDSA parameters and artifact lengths:
EdDSA parameters and artifact lengths in octets
Algorithm ID reference | Curve | Field size | Public key | Secret key | Signature
TBD (107 for testing) | Ed25519 | 32 | 32 | 32 | 64
TBD (108 for testing) | Ed448 | 57 | 57 | 57 | 114
ML-DSA signatures
For ML-DSA signature generation the default hedged version of ML-DSA.Sign given in [FIPS-204] is used. That is, to sign with ML-DSA the following operation is defined:

(mldsaSignature) <- ML-DSA.Sign(mldsaSecretKey, dataDigest)

For ML-DSA signature verification the algorithm ML-DSA.Verify given in [FIPS-204] is used. That is, to verify with ML-DSA the following operation is defined:

(verified) <- ML-DSA.Verify(mldsaPublicKey, dataDigest, mldsaSignature)

ML-DSA has the parametrization with the corresponding artifact lengths in octets as given in Table 7. All artifacts are encoded as defined in [FIPS-204].
ML-DSA parameters and artifact lengths in octets
Algorithm ID reference | ML-DSA | Public key | Secret key | Signature value
TBD (107 for testing) | ML-DSA-65 | 1952 | 4032 | 3309
TBD (108 for testing) | ML-DSA-87 | 2592 | 4896 | 4627
Composite Signature Schemes with ML-DSA
Signature data digest
Signature data (i.e. the data to be signed) is digested prior to signing operations, see [I-D.ietf-openpgp-crypto-refresh], Section 5.2.4. Composite ML-DSA + EdDSA signatures MUST use the associated hash algorithm as specified in Table 8 for the signature data digest. Signatures using other hash algorithms MUST be considered invalid.
An implementation supporting a specific ML-DSA + EdDSA algorithm MUST also support the matching hash algorithm.
Binding between ML-DSA + EdDSA and signature data digest
Algorithm ID reference | Hash function | Hash function ID reference
TBD (107 for testing) | SHA3-256 | 12
TBD (108 for testing) | SHA3-512 | 14
Key generation procedure
The implementation MUST independently generate the ML-DSA and the EdDSA component keys. ML-DSA key generation follows the specification [FIPS-204] and the artifacts are encoded as fixed-length octet strings as defined in Section 5.1.2. For EdDSA this is done following the relative specification in [RFC7748], and encoding the artifacts as specified in Section 5.1.1 as fixed-length octet strings.
Signature Generation
To sign a message M with ML-DSA + EdDSA the following sequence of operations has to be performed:
1. Generate dataDigest according to [I-D.ietf-openpgp-crypto-refresh], Section 5.2.4
2. Create the EdDSA signature over dataDigest with EdDSA.Sign() from Section 5.1.1
3. Create the ML-DSA signature over dataDigest with ML-DSA.Sign() from Section 5.1.2
4. Encode the EdDSA and ML-DSA signatures according to the packet structure given in Section 5.3.1.
Signature Verification
To verify an ML-DSA + EdDSA signature the following sequence of operations has to be performed:
1. Verify the EdDSA signature with EdDSA.Verify() from Section 5.1.1
2. Verify the ML-DSA signature with ML-DSA.Verify() from Section 5.1.2
As specified in Section 3.2 an implementation MUST validate both signatures, i.e. EdDSA and ML-DSA, successfully to state that a composite ML-DSA + EdDSA signature is valid.
Packet Specifications
Signature Packet (Tag 2)
The composite ML-DSA + EdDSA schemes MUST be used only with v6 signatures, as defined in [I-D.ietf-openpgp-crypto-refresh].
The algorithm-specific v6 signature parameters for ML-DSA + EdDSA signatures consist of:
- A fixed-length octet string representing the EdDSA signature, whose length depends on the algorithm ID as specified in Table 6.
- A fixed-length octet string of the ML-DSA signature value, whose length depends on the algorithm ID as specified in Table 7.
Key Material Packets
The composite ML-DSA + EdDSA schemes MUST be used only with v6 keys, as defined in [I-D.ietf-openpgp-crypto-refresh].
The algorithm-specific public key for ML-DSA + EdDSA keys is this series of values:
- A fixed-length octet string representing the EdDSA public key, whose length depends on the algorithm ID as specified in Table 6.
- A fixed-length octet string containing the ML-DSA public key, whose length depends on the algorithm ID as specified in Table 7.
The algorithm-specific secret key for ML-DSA + EdDSA keys is this series of values:
- A fixed-length octet string representing the EdDSA secret key, whose length depends on the algorithm ID as specified in Table 6.
- A fixed-length octet string containing the ML-DSA secret key, whose length depends on the algorithm ID as specified in Table 7.
SLH-DSA-SHAKE
The SLH-DSA-SHAKE Algorithms
The following table lists the group of algorithm code points for the SLH-DSA-SHAKE signature scheme and the corresponding artifact lengths. This group of algorithms is henceforth referred to as "SLH-DSA-SHAKE code points".
SLH-DSA-SHAKE algorithm code points and the corresponding artifact lengths in octets.
Algorithm ID reference | SLH-DSA-SHAKE public key | SLH-DSA-SHAKE secret key | SLH-DSA-SHAKE signature
TBD (SLH-DSA-SHAKE-128s) | 32 | 64 | 7856
TBD (SLH-DSA-SHAKE-128f) | 32 | 64 | 17088
TBD (SLH-DSA-SHAKE-256s) | 64 | 128 | 29792
Signature Data Digest
Signature data (i.e. the data to be signed) is digested prior to signing operations, see [I-D.ietf-openpgp-crypto-refresh], Section 5.2.4. SLH-DSA-SHAKE signatures MUST use the associated hash algorithm as specified in Table 10 for the signature data digest. Signatures using other hash algorithms MUST be considered invalid.
An implementation supporting a specific SLH-DSA-SHAKE algorithm code point MUST also support the matching hash algorithm.
Binding between SLH-DSA-SHAKE algorithm code points and signature data hash algorithms
Algorithm ID reference | Hash function | Hash function ID reference
TBD (SLH-DSA-SHAKE-128s) | SHA3-256 | 12
TBD (SLH-DSA-SHAKE-128f) | SHA3-256 | 12
TBD (SLH-DSA-SHAKE-256s) | SHA3-512 | 14
Key generation
SLH-DSA-SHAKE key generation is performed via the algorithm SLH-DSA.KeyGen as specified in [FIPS-205], and the artifacts are encoded as fixed-length octet strings as defined in Section 6.1.
Signature Generation
SLH-DSA-SHAKE signature generation is performed via the algorithm SLH-DSA.Sign as specified in [FIPS-205]. The variable opt_rand is set to PK.seed. See also Section 9.5.
Signature Verification
SLH-DSA-SHAKE signature verification is performed via the algorithm SLH-DSA.Verify as specified in [FIPS-205].
Packet specifications
Signature Packet (Tag 2)
The SLH-DSA-SHAKE algorithms MUST be used only with v6 signatures, as defined in [I-D.ietf-openpgp-crypto-refresh], Section 5.2.3.
The algorithm-specific part of a signature packet for an SLH-DSA-SHAKE algorithm code point consists of:
- A fixed-length octet string of the SLH-DSA-SHAKE signature value, whose length depends on the algorithm ID in the format specified in Table 9.
Key Material Packets
The SLH-DSA-SHAKE algorithms code points MUST be used only with v6 keys, as defined in [I-D.ietf-openpgp-crypto-refresh].
The algorithm-specific part of the public key consists of:
- A fixed-length octet string containing the SLH-DSA-SHAKE public key, whose length depends on the algorithm ID as specified in Table 9.
The algorithm-specific part of the secret key consists of:
- A fixed-length octet string containing the SLH-DSA-SHAKE secret key, whose length depends on the algorithm ID as specified in Table 9.
Notes on Algorithms
Symmetric Algorithms for SEIPD Packets
Implementations MUST implement AES-256. An implementation SHOULD use AES-256 in the case of a v1 SEIPD packet, or AES-256 with any available AEAD mode in the case of a v2 SEIPD packet, if all recipient certificates indicate support for it (explicitly or implicitly).
A v4 or v6 certificate that contains a PQ(/T) key SHOULD include AES-256 in the "Preferred Symmetric Ciphers for v1 SEIPD" subpacket. A v6 certificate that contains a PQ(/T) key SHOULD include the pair AES-256 with OCB in the "Preferred AEAD Ciphersuites" subpacket.
If AES-256 is not explicitly in the list of the "Preferred Symmetric Ciphers for v1 SEIPD" subpacket, and if the certificate contains a PQ/T key, it is implicitly at the end of the list. This is justified since AES-256 is mandatory to implement. If AES-128 is also implicitly added to the list, it is added after AES-256.
If the pair AES-256 with OCB is not explicitly in the list of the "Preferred AEAD Ciphersuites" subpacket, and if the certificate contains a PQ/T key, it is implicitly at the end of the list. This is justified since AES-256 and OCB are mandatory to implement. If the pair AES-128 with OCB is also implicitly added to the list, it is added after the pair AES-256 with OCB.
Hash Algorithms for Key Binding Signatures
Subkey binding signatures over algorithms described in this document and primary key binding signatures made by algorithms described in this document MUST NOT be made with MD5, SHA-1, or RIPEMD-160. A receiving implementation MUST treat such a signature as invalid.
Migration Considerations
The post-quantum KEM algorithms defined in Table 1 and the signature algorithms defined in Table 2 are a set of new public key algorithms that extend the algorithm selection of [I-D.ietf-openpgp-crypto-refresh]. During the transition period, the post-quantum algorithms will not be supported by all clients. Therefore various migration considerations must be taken into account, in particular backwards compatibility to existing implementations that have not yet been updated to support the post-quantum algorithms.
Key preference
Implementations SHOULD prefer PQ(/T) keys when multiple options are available. When encrypting to a certificate that has both a valid PQ/T and a valid traditional encryption subkey, an implementation SHOULD use the PQ/T subkey only. Furthermore, if an application has any means to determine that encrypting to a PQ/T certificate and a traditional certificate is redundant, it should omit encrypting to the traditional certificate.
As specified in Section 3.1, the confidentiality of a message is not post-quantum secure when using multiple PKESKs if at least one does not use PQ/T encryption schemes. An implementation SHOULD NOT abort the encryption process when encrypting a message to both PQ/T and traditional keys to allow for a smooth transition to post-quantum cryptography.
An implementation MAY sign with both a PQ(/T) and an ECC key using multiple signatures over the same data as described in Section 3.3. Signing only with PQ(/T) key material is not backwards compatible.
Key generation strategies
It is RECOMMENDED to generate fresh secrets when generating PQ(/T) keys. Note that reusing key material from existing ECC keys in PQ(/T) keys does not provide backwards compatibility.
An OpenPGP certificate is composed of a certification-capable primary key and one or more subkeys for signature, encryption, and authentication. Two migration strategies are recommended:
1. Generate two independent certificates, one for PQ(/T)-capable implementations, and one for legacy implementations. Implementations not understanding PQ(/T) certificates can use the legacy certificate, while PQ(/T)-capable implementations will prefer the newer certificate. This allows having an older v4 or v6 certificate for compatibility and a v6 PQ(/T) certificate, at a greater complexity in key distribution.
2. Attach PQ(/T) encryption subkeys to an existing traditional OpenPGP certificate. In the case of a v6 certificate, also PQ(/T) signature keys may be attached. Implementations understanding PQ(/T) will be able to parse and use the subkeys, while PQ(/T)-incapable implementations can gracefully ignore them. This simplifies key distribution, as only one certificate needs to be communicated and verified, but leaves the primary key vulnerable to quantum computer attacks.
Security Considerations
Security Aspects of Composite Signatures
When multiple signatures are applied to a message, the question of the protocol's resistance against signature stripping attacks naturally arises. In a signature stripping attack, an adversary removes one or more of the signatures such that only a subset of the signatures remain in the message at the point when it is verified. This amounts to a downgrade attack that potentially reduces the value of the signature. It should be noted that the composite signature schemes specified in this draft are not subject to a signature stripping vulnerability. This is due to the fact that in any OpenPGP signature, the hashed meta data includes the signature algorithm ID, as specified in [I-D.ietf-openpgp-crypto-refresh], Section 5.2.4. As a consequence, a component signature taken out of the context of a specific composite algorithm is not a valid signature for any message.
Furthermore, it is also not possible to craft a new signature for a message that was signed twice with a composite algorithm by interchanging (i.e., remixing) the component signatures, which would classify as a weak existential forgery. This is due to the fact that each v6 signatures also includes a random salt at the start of the hashed meta data, as also specified in the aforementioned reference.
Hashing in ECDH-KEM
Our construction of the ECDH-KEMs, in particular the inclusion of ecdhCipherText in the final hashing step in encapsulation and decapsulation that produces the ecdhKeyShare, is standard and known as hashed ElGamal key encapsulation, a hashed variant of ElGamal encryption. It ensures IND-CCA2 security in the random oracle model under some Diffie-Hellman intractability assumptions [CS03]. The additional inclusion of ecdhPublicKey follows the security advice in Section 6.1 of [RFC7748].
Key combiner
For the key combination in Section 4.2.2 this specification limits itself to the use of SHA3-256. The sponge construction used by SHA3-256 was proven to be indifferentiable from a random oracle [BDPA08]. This means, that in contrast to SHA2, which uses a Merkle-Damgard construction, no HMAC-based construction is required for key combination. It is therefore sufficient to simply process the concatenation of any number of key shares with a domain separation when using a sponge-based construction like SHA3-256.
More precisely, for a given capacity c the indifferentiability proof shows that assuming there are no weaknesses found in the Keccak permutation, an attacker has to make an expected number of 2^(c/2) calls to the permutation to tell SHA3-256 from a random oracle. For a random oracle, a difference in only a single bit gives an unrelated, uniformly random output. Hence, to be able to distinguish a key K, derived from shared keys K1 and K2 (with ciphertexts C1 and C2 and public keys P1 and P2) as

K = SHA3-256(counter || K1 || C1 || P1 || K2 || C2 || P2 || fixedInfo)

from a random bit string, an adversary has to know (or correctly guess) both key shares K1 and K2, entirely.
The proposed construction in Section 4.2.2 preserves IND-CCA2 of any of its ingredient KEMs, i.e. the newly formed combined KEM is IND-CCA2 secure as long as at least one of the ingredient KEMs is. Indeed, the above stated indifferentiability from a random oracle qualifies Keccak as a split-key pseudorandom function as defined in [GHP18]. That is, Keccak behaves like a random function if at least one input shared secret is picked uniformly at random. Our construction can thus be seen as an instantiation of the IND-CCA2 preserving Example 3 in Figure 1 of [GHP18], up to some reordering of input shared secrets and ciphertexts. In the random oracle setting, the reordering does not influence the arguments in [GHP18].
Domain separation and binding
The domSeparation information defined in Section 4.2.1 provides the domain separation for the key combiner construction. This ensures that the input keying material is used to generate a KEK for a specific purpose or context.
The algID defined in Section 4.2.1 binds the derived KEK to the chosen algorithm and communication parties. The algorithm ID identifies unequivocally the algorithm, the parameters for its instantiation, and the length of all artifacts, including the derived key.
This is in line with the Recommendation for ECC in section 5.5 of [SP800-56A]. Other fields included in the recommendation are not relevant for the OpenPGP protocol, since the sender is not required to have a key of their own, there are no pre-shared secrets, and all the other parameters are unequivocally defined by the algorithm ID.
SLH-DSA-SHAKE Message Randomizer
The specification of SLH-DSA-SHAKE [FIPS-205] prescribes an optional non-deterministic message randomizer. This is not used in this specification, as OpenPGP v6 signatures already provide a salted signature data digest of the appropriate size.
Binding hashes in signatures with signature algorithms
In order not to extend the attack surface, we bind the hash algorithm used for signature data digestion to the hash algorithm used internally by the signature algorithm.
ML-DSA internally uses a SHAKE256 digest, therefore we require SHA3 in the ML-DSA + EdDSA signature packet, see Section 5.2.1. Note that we bind a NIST security category 2 hash function to a signature algorithm that falls into NIST security category 3. This does not constitute a security bottleneck: because of the unpredictable random salt that is prepended to the digested data in v6 signatures, the hardness assumption is not collision resistance but second-preimage resistance.
In the case of SLH-DSA-SHAKE the internal hash algorithm varies based on the algorithm ID, see Section 6.1.1.
Symmetric Algorithms for SEIPD Packets
This specification mandates support for AES-256 for two reasons. First, AES-KeyWrap with AES-256 is already part of the composite KEM construction. Second, some of the PQ(/T) algorithms target the security level of AES-256.
For the same reasons, this specification further recommends the use of AES-256 if it is supported by all recipient certificates, regardless of what the implementation would otherwise choose based on the recipients' preferences. This recommendation should be understood as a clear and simple rule for the selection of AES-256 for encryption. Implementations may also make more nuanced decisions.
Additional considerations
Performance Considerations for SLH-DSA-SHAKE
This specification introduces both ML-DSA + EdDSA as well as SLH-DSA-SHAKE as PQ(/T) signature schemes.
Generally, it can be said that ML-DSA + EdDSA provides a performance in terms of execution time requirements that is close to that of traditional ECC signature schemes. Regarding the size of signatures and public keys, though, ML-DSA has far greater requirements than traditional schemes like EC-based or even RSA signature schemes.
Implementers may want to offer SLH-DSA-SHAKE for applications where the weaker security assumptions of a hash-based signature scheme are required – namely only the 2nd preimage resistance of a hash function – and thus a potentially higher degree of trust in the long-term security of signatures is achieved. However, SLH-DSA-SHAKE has performance characteristics in terms of execution time of the signature generation as well as space requirements for the signature that are even greater than those of ML-DSA + EdDSA signature schemes.
Pertaining to the execution time, the particularly costly operation in SLH-DSA-SHAKE is the signature generation. Depending on the parameter set, it can range from approximately the one hundred fold to more than the two thousand fold of that of ML-DSA-87. These number are based on the performance measurements published in the NIST submissions for SLH-DSA-SHAKE and ML-DSA. In order to achieve fast signature generation times, the algorithm SLH-DSA-SHAKE-128f ("f" standing for "fast") should be chosen. This comes at the expense of a larger signature size. This choice can be relevant in applications where mass signing occurs or a small latency is required.
In order to minimize the space requirements of an SLH-DSA-SHAKE signature, an algorithm ID with the name ending in "s" for "small" should be chosen. This comes at the expense of a longer signature generation time. In particular, SLH-DSA-SHAKE-128s achieves the smallest possible signature size, which is about the double size of an ML-DSA-87 signature. Where a higher security level than 128 bit is needed, SLH-DSA-SHAKE-256s can be used.
Unlike the signature generation time, the signature verification time of SLH-DSA-SHAKE is not that much larger than that of other PQC schemes. Based on the performance measurements published in the NIST submissions for SLH-DSA-SHAKE and ML-DSA, the verification time of the SLH-DSA-SHAKE is, for the parameters covered by this specification, larger than that of ML-DSA-87 by a factor ranging from four (for -128s) over nine (for -256s) to twelve (for -128f).
IANA Considerations
IANA is requested to add the algorithm IDs defined in Table 11 to the existing registry OpenPGP Public Key Algorithms. The field specifications enclosed in brackets for the ML-KEM + ECDH composite algorithms denote fields that are only conditionally contained in the data structure.
IANA updates for registry 'OpenPGP Public Key Algorithms'
ID | Algorithm | Public Key Format | Secret Key Format | Signature Format | PKESK Format | Reference
TBD | ML-KEM-768+X25519 | 32 octets X25519 public key (Table 3), 1184 octets ML-KEM-768 public key (Table 4) | 32 octets X25519 secret key (Table 3), 2400 octets ML-KEM-768 secret-key (Table 4) | N/A | 32 octets X25519 ciphertext, 1088 octets ML-KEM-768 ciphertext [, 1 octet algorithm ID in case of v3 PKESK], 1 octet length field of value n, n octets wrapped session key (Section 4.3.1) | Section 4.2
TBD | ML-KEM-1024+X448 | 56 octets X448 public key (Table 3), 1568 octets ML-KEM-1024 public key (Table 4) | 56 octets X448 secret key (Table 3), 3168 octets ML-KEM-1024 secret-key (Table 4) | N/A | 56 octets X448 ciphertext, 1568 octets ML-KEM-1024 ciphertext [, 1 octet algorithm ID in case of v3 PKESK], 1 octet length field of value n, n octets wrapped session key (Section 4.3.1) | Section 4.2
TBD | ML-DSA-65+Ed25519 | 32 octets Ed25519 public key (Table 6), 1952 octets ML-DSA-65 public key (Table 7) | 32 octets Ed25519 secret key (Table 6), 4032 octets ML-DSA-65 secret (Table 7) | 64 octets Ed25519 signature (Table 6), 3293 octets ML-DSA-65 signature (Table 7) | N/A | Section 5.2
TBD | ML-DSA-87+Ed448 | 57 octets Ed448 public key (Table 6), 2592 octets ML-DSA-87 public key (Table 7) | 57 octets Ed448 secret key (Table 6), 4896 octets ML-DSA-87 secret (Table 7) | 114 octets Ed448 signature (Table 6), 4595 octets ML-DSA-87 signature (Table 7) | N/A | Section 5.2
TBD | SLH-DSA-SHAKE-128s | 32 octets public key (Table 9) | 64 octets secret key (Table 9) | 7856 octets signature (Table 9) | N/A | Section 6.1
TBD | SLH-DSA-SHAKE-128f | 32 octets public key (Table 9) | 64 octets secret key (Table 9) | 17088 octets signature (Table 9) | N/A | Section 6.1
TBD | SLH-DSA-SHAKE-256s | 64 octets public key (Table 9) | 128 octets secret key (Table 9) | 29792 octets signature (Table 9) | N/A | Section 6.1
Changelog
draft-wussler-openpgp-pqc-01
- Shifted the algorithm IDs by 4 to align with the crypto-refresh.
- Renamed v5 packets into v6 to align with the crypto-refresh.
- Defined IND-CCA2 security for KDF and key combination.
- Added explicit key generation procedures.
- Changed the key combination KMAC salt.
- Mandated Parameter ID check in SPHINCS+ signature verification.
- Fixed key share size for Kyber-768.
- Added "Preliminaries" section.
- Fixed IANA considerations.
draft-wussler-openpgp-pqc-02
- Added the ephemeral and public key in the ECC key derivation function.
- Removed public key hash from key combiner.
- Allowed v3 PKESKs and v4 keys with PQ algorithms, limiting them to AES symmetric ciphers. for encryption with SEIPDv1, in line with the crypto-refresh.
draft-wussler-openpgp-pqc-03
- Replaced round 3 submission with NIST PQC Draft Standards FIPS 203, 204, 205.
- Added consideration about security level for hashes.
draft-wussler-openpgp-pqc-04
- Added Johannes Roth as author
draft-ietf-openpgp-pqc-00
- Renamed draft
draft-ietf-openpgp-pqc-01
- Mandated AES-256 as mandatory to implement.
- Added AES-256 / AES-128 with OCB implicitly to v1/v2 SEIPD preferences of "PQ(/T) certificates".
- Added a recommendation to use AES-256 when possible.
- Swapped the optional v3 PKESK algorithm identifier with length octet in order to align with X25519 and X448.
- Fixed ML-DSA private key size.
- Added test vectors.
- Correction and completion of IANA instructions.
draft-ietf-openpgp-pqc-02
- Removed git rebase artifact.
draft-ietf-openpgp-pqc-03
- Updated SLH-DSA by removing parametrization and restricting to three SLH-DSA-SHAKE algorithm code points.
- Removed NIST and Brainpool curve hybrids, dropped ECDSA from the current specification.
- Updated KDF as proposed at IETF 119.
- Removed whitespaces from composite algorithm names.
- Explicitly disallowed SED (tag 9) and weak hashes when using PQ algorithms.
draft-ietf-openpgp-pqc-04
- Fixed ML-DSA signature size
- Fixed parameters order in PKESK description
- Fixed missing inputs into KEM combination description
- Improved parallel encryption guidance
- Improved SED deprecation decscription
- Added ML-DSA test vectors
Contributors
Stephan Ehlen (BSI)
Carl-Daniel Hailfinger (BSI)
Andreas Huelsing (TU Eindhoven)
References
Normative References
[RFC7748]

Elliptic Curves for Security
A. Langley
M. Hamburg
S. Turner
January 2016
RFC 7748
DOI 10.17487/RFC7748
[RFC8032]

Edwards-Curve Digital Signature Algorithm (EdDSA)
S. Josefsson
I. Liusvaara
January 2017
RFC 8032
DOI 10.17487/RFC8032
[RFC3394]

Advanced Encryption Standard (AES) Key Wrap Algorithm
J. Schaad
R. Housley
September 2002
RFC 3394
DOI 10.17487/RFC3394
[I-D.ietf-openpgp-crypto-refresh]

OpenPGP
Paul Wouters
Aiven
Daniel Huigens
Proton AG
Justus Winter
Sequoia-PGP
Niibe Yutaka
FSIJ
4 January 2024
Internet-Draft draft-ietf-openpgp-crypto-refresh-13
Informative References
[NIST-PQC]

Post-Quantum Cryptography Standardization
Lily Chen
Dustin Moody
Yi-Kai Liu
December 2016
[NISTIR-8413]

Status Report on the Third Round of the NIST Post-Quantum Cryptography Standardization Process
Gorjan Alagic
Daniel Apon
David Cooper
Quynh Dang
Thinh Dang
John Kelsay
Jacob Lichtinger
Carl Miller
Dustin Moody
Rene Peralta
Ray Perlner
Angela Robinson
Daniel Smith-Tone
Yi-Kai Liu
September 2022
NIST IR 8413
[SP800-56C]

Recommendation for Key-Derivation Methods in Key-Establishment Schemes
Elaine Barker
Lily Chen
Richard Davis
August 2020
NIST Special Publication 800-56C Rev. 2
[SP800-56A]

Recommendation for Pair-Wise Key-Establishment Schemes Using Discrete Logarithm Cryptography
Elaine Barker
Lily Chen
Allen Roginsky
Apostol Vassilev
Richard Davis
April 2018
NIST Special Publication 800-56A Rev. 3
[FIPS-203]

Module-Lattice-Based Key-Encapsulation Mechanism Standard
National Institute of Standards and Technology
August 2023
[FIPS-204]

Module-Lattice-Based Digital Signature Standard
National Institute of Standards and Technology
August 2023
[FIPS-205]

Stateless Hash-Based Digital Signature Standard
National Institute of Standards and Technology
August 2023
[GHP18]

KEM Combiners
Federico Giacon
Felix Heuer
Bertram Poettering
2018
[BDPA08]

On the Indifferentiability of the Sponge Construction
Guido Bertoni
Joan Daemen
Michael Peters
Gilles van Assche
2008
[CS03]

Design and Analysis of Practical Public-Key Encryption Schemes Secure against Adaptive Chosen Ciphertext Attack
Ronald Cramer
Victor Shoup
2003
[I-D.ietf-pquip-pqt-hybrid-terminology]

Terminology for Post-Quantum Traditional Hybrid Schemes
Florence D
UK National Cyber Security Centre
Michael P
UK National Cyber Security Centre
9 May 2024
Internet-Draft draft-ietf-pquip-pqt-hybrid-terminology-03
Test Vectors
To help implementing this specification a set of non-normative examples follow here. The test vectors are implemented using the Initial Public Draft (IPD) variant of the ML-DSA and ML-KEM schemes.
Sample v6 PQC Subkey Artifacts
Here is a Private Key consisting of:
- A v6 Ed25519 Private-Key packet
- A v6 direct key self-signature
- A User ID packet
- A v6 positive certification self-signature
- A v6 ML-KEM-ipd-768+X25519 Private-Subkey packet
- A v6 subkey binding signature
The primary key has the fingerprint 52343242345254050219ceff286e9c8e479ec88757f95354388984a02d7d0b59.
The subkey has the fingerprint 263e34b69938e753dc67ca8ee37652795135e0e16e48887103c11d7307df40ed.

-----BEGIN PGP PRIVATE KEY BLOCK-----

[encoded data, 5696 characters]
/d8lkIgM
-----END PGP PRIVATE KEY BLOCK-----

Here is the corresponding Public Key consisting of:
- A v6 Ed25519 Public-Key packet
- A v6 direct key self-signature
- A User ID packet
- A v6 positive certification self-signature
- A v6 ML-KEM-ipd-768+X25519 Public-Subkey packet
- A v6 subkey binding signature

-----BEGIN PGP PUBLIC KEY BLOCK-----
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-----END PGP PUBLIC KEY BLOCK-----

Here is an unsigned message "Testing\n" encrypted to this key:
- A v6 PKESK
- A v2 SEIPD
The hex-encoded SHA3-256 ecdhKeyShare input is c3bcf24924717f82614c331cc13eea1c333ab16c6d42a6f958cbeb48aa4260fb.
The hex-encoded SHA3-256 mlkemKeyShare input is 9e956c105e25da824d6f1fddbbd93b920dd33f2fd647cfcb859904966efff31a.
The hex-encoded SHA3-256 output is 99229561bcf5017d6b1dd34d8eb0441897968d5b140597756db705f1de67c078.
The hex-encoded session key is 0e7d04eb84f066d0943c7898db8d36959203bdecdfb3e17e5fd3a24a13641d7b.

-----BEGIN PGP MESSAGE-----

wcPtBiEGJj40tpk451PcZ8qO43ZSeVE14OFuSIhxA8EdcwffQO1pvDRTpyIxERdP
Zf0JNCpG7uBqOXUty4vHAu/wCUmXFiutlBnRlG9O2jx2gaNp/HpAQeYmHwdDroFo
MGisG0RVOigKCVqjEgSCwmk0KLyGl6jFowNA9cMfi/pf6uU9PaweMGWmlgVyXDr0
2qf/jsjEx87yeL3t6yi2YIFXCitLc+vaqWjd3/8qBOcoTf/TpPXMNPmzmffh8xZx
bU25jlzB25dHXRLmwnFUlz3PU7voCQNhBtJiMSXmCzbb26BWrB+YVNvxStokvDBG
pnP+lGcUIJUJpPgSoJeZLp5CWSl/UPTiuz6blsddWpfYm8wa/7V/EzmZNKkvDZt4
7vdaXBaZDnPsMTE1Tn/FIc6/13CUe2rHDqcdLKIQ1bKRTpWH2BGqaX9a71XmxgR2
kdTZ067m4xeRRGidL7/A5qklIEMumL+IyjC4zDvgtHBaGyCeDD12nK7paGhfuTxj
Qn4SQQvDvswUnUlmfPQbdMV1H02+lWHk7i4QpK2vrnKOd6O7pOnWFQSMGg/L4lCx
pfztFSf5bUrYSrf/VoQJdfqLwTZ0cw8uQC7eoEOn419DcKOQA1G/cKNY/lSeYZMD
IAAMZZ6iIzXcSvwd5NZkISVuZO1uh/9rhg4ZTOb+rcI6RYb5GHQbEvFAw1RUNk28
4Vr1F2aYPuYw2rltNlE/D2jns6+9inJYnDmExbWX7hIItJVwwhGPqW0s0bbntFZD
zqlivMUoiCla49ZNQ6m7t5HwEv7IUZcNz5PvHvy5SPlFuzAJf82bKPYhAaCC1fE9
IBQEVLG9Kw+duKgS2HtKndNd9sN3Edgf24JpM6OzhjIfuO8hUUUSl88mh3YlBKmp
xbBHd01s6rr2WK/L4KifiL+Bi99k0QJjVRx4mgv5uKv6sdFKmBkcSIr6olNG5GHR
hWCKuNvIg0zL9WSB8Qeav4s6sCn4gEWgyLXZ33tF39OwJFGZJtk+F01hNrISCylW
cQ39tM58hK2vuqAFjvvyHmjwrQDnGMfOh+86yMipIrWF7AfzB+BVdWOkBynRMgws
45Ne2D4XyD6z8rgKqrQEKWspHdeYOxhmtLZFpg5uO06I6T944whwXWYTeGjBPsi2
YJuWlgH1nuZ+sw1FTE93XCfRHiLNQ6wBYCI9Usw9abAmW7Jhxd0/Kx72BbwLDmWm
vD1iXsgyCA1uyAfj89Xs5EIhPXFsxE6dfJ13dZGJVZl6mRJwjJgZStSEycvtsbtU
84tj9A+XpPfyCmk7wIte1d71vPE3s8Wx1WFYSiwPyVJS/AALSvPdEs4vhON7EQOa
xmhX1xITEesRXKhfKynhfMPpOUPgP1ctkpAbC8RGsRtEyhnALgHYqBYCULP+Pbmk
x34Z3pYlVXaWqiU0VJobuMwQJvnvax0ipFOPFYr6HBYvAuUlCdD17phL7ZFmLQjY
qstC0VS7E3mpvzbpo2uR1RDvWf6x6YFPAQoI9ltJ1S/lQdeLVh1+FOXuXh57qMcp
rD9h0SH7PihV9SRdvR2vvWyn7ygFNPajy/8PTH15eEv/5g6ZWxs5CKvpz0hTqf8C
0lQCCQIMslhjNg7KUOTtedOwUxvAoHK/lZf4fpMbG2GW7r6OHwShQ/zNruQmR8qV
qJsN7xv8+utysXtt6SUgMPnF3oUp9HzBnCwHb/m/di69xNsYQAE=
-----END PGP MESSAGE-----

Here is a Private Key consisting of:
- A v6 ML-DSA-ipd-65+EdDSA Private-Key packet
- A v6 direct key self-signature
- A User ID packet
- A v6 positive certification self-signature
- A v6 ML-KEM-ipd-768+X25519 Private-Subkey packet
- A v6 subkey binding signature
The primary key has the fingerprint eb8503e3b591f84d068fc2411c310a0b7ca116974d32f81f96f0407f3fbfbb21.
The subkey has the fingerprint 5f7e002bd964a5be4f3c50b95e03b19cb37bf02fa0e029af701f6677e08bd272.

-----BEGIN PGP PRIVATE KEY BLOCK-----

[encoded data, 26816 characters]
tMH1Sk5ufYEAAAAAAAAAAAAAAAAAAAAAAAAACA0SFx8k
-----END PGP PRIVATE KEY BLOCK-----

Here is the corresponding Public Key consisting of:
- A v6 ML-DSA-ipd-65+EdDSA Public-Key packet
- A v6 direct key self-signature
- A User ID packet
- A v6 positive certification self-signature
- A v6 ML-KEM-ipd-768+X25519 Public-Subkey packet
- A v6 subkey binding signature

-----BEGIN PGP PUBLIC KEY BLOCK-----

[encoded data, 18176 characters]
AAAAAAAAAAAACA0SFx8k
-----END PGP PUBLIC KEY BLOCK-----

V4 PQC Subkey Artifacts
Here is a Private Key consisting of:
- A v4 Ed25519 Private-Key packet
- A User ID packet
- A v4 positive certification self-signature
- A v4 ECDH (Curve25519) Private-Subkey packet
- A v4 subkey binding signature
- A v4 ML-KEM-ipd-768+X25519 Private-Subkey packet
- A v4 subkey binding signature
The primary key has the fingerprint b2e9b532d55bd6287ec79e17c62adc0ddd1edd73.
The ECDH subkey has the fingerprint 95bed3c63f295e7b980b6a2b93b3233faf28c9d2.
The ML-KEM-ipd-768+X25519 subkey has the fingerprint bd67d98388813e88bf3490f3e440cfbaffd6f357.

-----BEGIN PGP PRIVATE KEY BLOCK-----

[encoded data, 5696 characters]
0O22blDNAr/tDA==
=q5En
-----END PGP PRIVATE KEY BLOCK-----

Here is the corresponding Public Key consisting of:
- A v4 Ed25519 Public-Key packet
- A User ID packet
- A v4 positive certification self-signature
- A v4 ECDH (Curve25519) Public-Subkey packet
- A v4 subkey binding signature
- A v4 ML-KEM-ipd-768+X25519 Public-Subkey packet
- A v4 subkey binding signature

-----BEGIN PGP PUBLIC KEY BLOCK-----
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=dPFW
-----END PGP PUBLIC KEY BLOCK-----

Here is an SEIPDv1 unsigned message "Testing\n" encrypted to this key:
- A v3 PKESK
- A v1 SEIPD
The hex-encoded SHA3-256 ecdhKeyShare input is 98782f4d20476dc2787ce8e264731e0d0cfeac0a35732cd88cc5518b57e634a0.
The hex-encoded SHA3-256 mlkemKeyShare input is 3e8813445ee2a4a6f1a503d14149304f0ea4f626b45ed871e9381b967fb19008.
The hex-encoded SHA3-256 output is 86ea88190089aae9256f04fdd09cd62e19f2c1d02cfb844aa1f99f7b17c49743.
The hex-encoded session key is f3037ae17d83a40ed08d884e19dc66065eac82d96337e4b74b1d10e933535e4d.

-----BEGIN PGP MESSAGE-----

wcPUA+RAz7r/1vNXaUNGH8CAkSiFgunnUDqAiD9JSd3Sb7lMNUsWk6lzWiJicgky
S/vu0sSnRtxweWkoMr1y2ZaS45nXbEQyShiqHhZUKfVwtxbU+rGVH5oCgSvtTCrs
verZaFpqzqPWyZ8ApzJvjbGUDBuwns09dGIKvKoePT5DCrqXlsW4EA8gFJbiXeb3
E7nsyg3l2uMzbt6FHtYoa6qq9Q0PsUiGte52nXXWEnmBOGUfmCkVsgmHDmz63BLT
1xXuZ5YopZkhhpjTNtvWtXc6MIaqnh6XtAcg8ZoaH0iferpbHEp9+M4bv5YDjzji
vv83rBQN4cBaS1/TSmBkNJHmxcyT1AOOXY2ZbmxQBORhGOTrFz3w8R78MYkEvB6x
JAjoYirpsyNLJzdewpXEYrPQq4Ey8EG2+qDY47vQkQaYcSFFoxYQ8MpHXmmgJ2bp
D13g/lQlSHcdWX2L59Wa1dhKRVnUyeEtO5c06FKJ7QOrywNjPdVciPVCx6bBfVd2
6qiWLynSGnzGaKd1YyaviioCm48Ydu5q8Z+QbEANbKW1azVAWCuxuiomE3RBvf1O
8d30UvBnImEf+9ANDxzmjIG2lW39U591Jbv0pL00at3tIMQN2wwiduP1KZ1dilWa
gEkdPjl6Q68ov0vRCYMAZizj4pMZbsUdge2Jj9GieObnp+w25pJu9nBeI6iqYmwd
Ny1U3OuvzbEUsNfKcHoQd9Cem8EZn+5ICk7eqsTkZq69oYfIVRyzEEc/X9562nzh
6B+X4CHZY/C8UCWougQriG4KVszM4myOgekKg0kNVIWgE2y7Z//S9c2twdxRWT/a
8QC4p7QX7JRgzDD9erkj/9J3hKwHxDHShKB5jsVaGO+BxtFSCiiTmgeo7+SAnJwU
Mi/N0UiI2BbKdo4KmdDPUVDyobBjCjeXil7Kg7pTU0vewPZQDLl9X16CcXCB60HL
fkDGpcYbjkZYbmB449sQfaLvxRMHomP4TY4PEfANIXdWmk1mS0/+zNzMQ9+Xderc
8P/EdKDKF5yr7IzSNoxuLiIWpyWJj+5QmAwup9mVv5gkh5RPnUQ0fgQ1vU8K9PMz
OmYqlX2W4gPn29UovjkbGH+lEzazEzA7VZWHXG86NVN8WMXqdQvMJcmMRZhDmC3F
kCII5zc6dxFXjNUgaAqV8eBqvRBbgCqK+6HSwCMY7jNFhFIy+Nj/9BYU/ereax0t
Zlsk7XDK9lMZUidh5+VeEqbyMsLQ0YiyO7VJ5VdiPESXHjPkzxo42XZJELuBVC9D
ArAX2Qip+oV1RXzhu/SeJdRQufGSENeZpGiG4tW24dpROh40I5TgXmpd4ALhuh1S
PrepCNhXuFtKDIStKZEmCknPAGWAkLYZz5rAaMtztdGvzlektn+8CDtSo3d6FUww
dp68ZtSMMb5HGscAoiDoOTiB5KVPSd80s3EPXlsgQSfHuSUHTvmD8G6q4hqGXMeV
IUdwjwTvDMfW7CU5zqiV01SO6dXKsFyjLJrT57kpCbQ/2fhoMC+kNcXpzI+Z65yI
jCP6Sjv+cVh7tv55kTKAPHO5VE3MDxvSOQHpUQ0zora+lfzpLUahfv8uZ4Q4J3L6
mkHfXuplyv3LcunejQDog2bhakqbrb5lg3fZGYNagykZxw==
=2Xhi
-----END PGP MESSAGE-----

Here is an SEIPDv2 unsigned message Testing\n encrypted to this key:
- A v6 PKESK
- A v2 SEIPD
The hex-encoded SHA3-256 ecdhKeyShare input is 4a0b21ff26997b812f6e0381b7b4ff907ecc7abdec01f16ecbf60bdc3f633341.
The hex-encoded SHA3-256 mlkemKeyShare input is 4c0c441f23711ed5d44983e2cbfc06799295029b92f627b161cd57f072e0ebd0.
The hex-encoded SHA3-256 output is 76ea8fcc9a31a9fa672940b9ad578f6b8ecbea1b1d1175d01f1777364a8e2704.
The hex-encoded session key is b5d810efc6b2b82e77f907813e114587aca2d0e33c9c74e90eb1638df030dcaf.

-----BEGIN PGP MESSAGE-----

wcPhBhUEvWfZg4iBPoi/NJDz5EDPuv/W81dpZ1Yz1yu1Dk/HK2JuEmE6RavqzhvT
i508AZhPxC08BxfNFar+uyZCNyMrUSrY0qY8H61GTtx1+O9VynXl8uXtS1nTDGJ9
vCR+EvH6rT/gOPQB8HUhX6Ps97Yqi/Iys1gfS8n961pScwIYpPJzUWfUUKjIT55W
htkh9aIB6unqzwUDi3p4oRZRm67j1ZP14SLyonAG2tXtCZyu1An62UHeOyNl1/6Z
CgC3egTf6lz26US15T8AP54AO77LOf9KwLpUYcwvSExqHGgmhS0Mil6WnFyuJUDB
7A2T2p/koW7TDaqoxhWsxY2isiH1SmAxNxzMnrGd7rNpPJ/k/r42bILfOuG0TRUN
zqC9ph6OdydSyhHkN5G4eOYQqqvk19/lfLuHWlNwfNcn/2PsgsxLxNj7ltVn90W0
qLubPWrujn/DhLl+hs2xXDOudpcztUqxcBnrsSaHlaebjQoDfttVAQj2jjdNXRjZ
uNRnRfcG9s3sO3b8d4ed6tk6U+nMrE2dZCBjTagqvD07Z1TpZDh7t86V3X16o/ps
jxW42s+YR589b88IZcieZRbKVtXt00pn2tn95kpvL3d8nAkaiPUhrowQUz0jpn8c
CDBNAn1j690qM3pD5XJlwverC2cmJH1Hjobnrhi6X1k2lQxweX28p+R9NQjSoX0h
ORuE0/Wpi15y0xmr2EzjcZ/6vPncy/IrYJCYmx9+aWQAjrKjizzNFTt73kf1xba5
t4tbZkj9xgdDJXq3bAqB0/JeeTb4aTCk+n4olVYzCnMtLgj+1fWPClMModACmFOG
1+bw5Q91/7euo363sw5UwgU1JhSQ/xcKNyJQsnklWkLMJNB1Yhj/C32lEmLntigv
UOO510+ehA7D5ftef8cMfEIm73HrBBiLfixvVTR8AQV4hiV/mzKP7weM7kxvAvbz
ir4jt3uSBOuhTjzq2is/S3D2K+O8FZqGIbkDhnKd98LbEA2cn9nTfsbV+TVXCmaS
lHNojVxPL2pUKxedV5skvfflRFciuP7UNsf8myHe7wdfPdSzMsbytDEwID3vcsme
fBqZdEZxqv/mNnn38TfHMSCF+yv5XbF9ham4DIcqNlkYud1ipEFFbcBZ0o9nUIWp
diSY7KGAtVF224dtcr3FTHGuBnayDq+Yk++VhF4Bb3uPVuwrkf7Bncp1aYEQfkhI
HwF3X6GnwC3y7kpbkU1rOq7yXv/0mRyGpVQlW/Yf3qT1buxcWt5BvXBmKzbBpVg/
0B9vpzrlFsT0Pb2GHuQ6U+9JoZ+ePnRMVdDz93RCGr1kQlyY15K1b+yILJiV6oOL
OxoxXHnr5soIumxCqv+6oAm4SdQVJLELQK72x1dVKJ90jUOgYCeOY61NsC9BFWHT
h0itUEnwWMjKg73z00bthndwfEXHBJLrHizkcv+pwD8M5wb/9H6HU4x8ELSr5Fyn
WjSoa2739wmJkoJY5ifaic3L8UXJeLuEZnVG9tUrl9ohHO8RNR3Vc/uHmyhImoYp
RL4rcc6YpuyextmYu9S9LkPR5Bzr+mFeJDeXbA7GJm9eofdw0lQCCQIMAGc2j84/
tfivyP5YrgQ8uBt9iwJN3IYRBy8qdr9JUyxkpkOEshV6XE4g3Orpbx0ZdrxbKmDS
7eJl5fSust3gb2KfaAoWkFQivVJP2KTl5gw=
-----END PGP MESSAGE-----

Acknowledgments
Thanks to Daniel Huigens and Evangelos Karatsiolis for the early review and feedback on this document.