Internet-Draft | ietf-tls-hybrid-design | July 2021 |
Stebila, et al. | Expires 14 January 2022 | [Page] |
Hybrid key exchange refers to using multiple key exchange algorithms simultaneously and combining the result with the goal of providing security even if all but one of the component algorithms is broken. It is motivated by transition to post-quantum cryptography. This document provides a construction for hybrid key exchange in the Transport Layer Security (TLS) protocol version 1.3.¶
Discussion of this work is encouraged to happen on the TLS IETF mailing list tls@ietf.org or on the GitHub repository which contains the draft: https://github.com/dstebila/draft-ietf-tls-hybrid-design.¶
This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.¶
Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.¶
Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."¶
This Internet-Draft will expire on 14 January 2022.¶
Copyright (c) 2021 IETF Trust and the persons identified as the document authors. All rights reserved.¶
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Simplified BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Simplified BSD License.¶
This document gives a construction for hybrid key exchange in TLS 1.3. The overall design approach is a simple, "concatenation"-based approach: each hybrid key exchange combination should be viewed as a single new key exchange method, negotiated and transmitted using the existing TLS 1.3 mechanisms.¶
This document does not propose specific post-quantum mechanisms; see Section 1.4 for more on the scope of this document.¶
Earlier versions of this document categorized various design decisions one could make when implementing hybrid key exchange in TLS 1.3. These have been moved to the appendix of the current draft, and will be eventually be removed.¶
draft-ietf-tls-hybrid-design-03:¶
draft-ietf-tls-hybrid-design-02:¶
draft-ietf-tls-hybrid-design-01:¶
draft-ietf-tls-hybrid-design-00:¶
draft-stebila-tls-hybrid-design-03:¶
draft-stebila-tls-hybrid-design-02:¶
draft-stebila-tls-hybrid-design-01:¶
For the purposes of this document, it is helpful to be able to divide cryptographic algorithms into two classes:¶
"Hybrid" key exchange, in this context, means the use of two (or more) key exchange algorithms based on different cryptographic assumptions, e.g., one traditional algorithm and one next-gen algorithm, with the purpose of the final session key being secure as long as at least one of the component key exchange algorithms remains unbroken. We use the term "component" algorithms to refer to the algorithms combined in a hybrid key exchange.¶
We note that some authors prefer the phrase "composite" to refer to the use of multiple algorithms, to distinguish from "hybrid public key encryption" in which a key encapsulation mechanism and data encapsulation mechanism are combined to create public key encryption.¶
The primary motivation of this document is preparing for post-quantum algorithms. However, it is possible that public key cryptography based on alternative mathematical constructions will be required independent of the advent of a quantum computer, for example because of a cryptanalytic breakthrough. As such we opt for the more generic term "next-generation" algorithms rather than exclusively "post-quantum" algorithms.¶
Note that TLS 1.3 uses the phrase "groups" to refer to key exchange algorithms - for example, the supported_groups
extension - since all key exchange algorithms in TLS 1.3 are Diffie-Hellman-based. As a result, some parts of this document will refer to data structures or messages with the term "group" in them despite using a key exchange algorithm that is not Diffie-Hellman-based nor a group.¶
A hybrid key exchange algorithm allows early adopters eager for post-quantum security to have the potential of post-quantum security (possibly from a less-well-studied algorithm) while still retaining at least the security currently offered by traditional algorithms. They may even need to retain traditional algorithms due to regulatory constraints, for example FIPS compliance.¶
Ideally, one would not use hybrid key exchange: one would have confidence in a single algorithm and parameterization that will stand the test of time. However, this may not be the case in the face of quantum computers and cryptanalytic advances more generally.¶
Many (though not all) post-quantum algorithms currently under consideration are relatively new; they have not been subject to the same depth of study as RSA and finite-field or elliptic curve Diffie-Hellman, and thus the security community does not necessarily have as much confidence in their fundamental security, or the concrete security level of specific parameterizations.¶
Moreover, it is possible that after next-generation algorithms are defined, and for a period of time thereafter, conservative users may not have full confidence in some algorithms.¶
As such, there may be users for whom hybrid key exchange is an appropriate step prior to an eventual transition to next-generation algorithms.¶
This document focuses on hybrid ephemeral key exchange in TLS 1.3 [TLS13]. It intentionally does not address:¶
The primary goal of a hybrid key exchange mechanism is to facilitate the establishment of a shared secret which remains secure as long as as one of the component key exchange mechanisms remains unbroken.¶
In addition to the primary cryptographic goal, there may be several additional goals in the context of TLS 1.3:¶
Backwards compatibility: Clients and servers who are "hybrid-aware", i.e., compliant with whatever hybrid key exchange standard is developed for TLS, should remain compatible with endpoints and middle-boxes that are not hybrid-aware. The three scenarios to consider are:¶
Ideally backwards compatibility should be achieved without extra round trips and without sending duplicate information; see below.¶
Low latency: Use of hybrid key exchange should not substantially increase the latency experienced to establish a connection. Factors affecting this may include the following.¶
This document models key agreement as key encapsulation mechanisms (KEMs), which consist of three algorithms:¶
KeyGen() -> (pk, sk)
: A probabilistic key generation algorithm, which generates a public key pk
and a secret key sk
.¶
Encaps(pk) -> (ct, ss)
: A probabilistic encapsulation algorithm, which takes as input a public key pk
and outputs a ciphertext ct
and shared secret ss
.¶
Decaps(sk, ct) -> ss
: A decapsulation algorithm, which takes as input a secret key sk
and ciphertext ct
and outputs a shared secret ss
, or in some cases a distinguished error value.¶
The main security property for KEMs is indistinguishability under adaptive chosen ciphertext attack (IND-CCA2), which means that shared secret values should be indistinguishable from random strings even given the ability to have arbitrary ciphertexts decapsulated. IND-CCA2 corresponds to security against an active attacker, and the public key / secret key pair can be treated as a long-term key or reused. A common design pattern for obtaining security under key reuse is to apply the Fujisaki-Okamoto (FO) transform [FO] or a variant thereof [HHK].¶
A weaker security notion is indistinguishability under chosen plaintext attack (IND-CPA), which means that the shared secret values should be indistinguishable from random strings given a copy of the public key. IND-CPA roughly corresponds to security against a passive attacker, and sometimes corresponds to one-time key exchange.¶
Key exchange in TLS 1.3 is phrased in terms of Diffie-Hellman key exchange in a group. DH key exchange can be modeled as a KEM, with KeyGen
corresponding to selecting an exponent x
as the secret key and computing the public key g^x
; encapsulation corresponding to selecting an exponent y
, computing the ciphertext g^y
and the shared secret g^(xy)
, and decapsulation as computing the shared secret g^(xy)
. See [I-D.irtf-cfrg-hpke] for more details of such Diffie-Hellman-based key encapsulation mechanisms.¶
TLS 1.3 does not require that ephemeral public keys be used only in a single key exchange session; some implementations may reuse them, at the cost of limited forward secrecy. As a result, any KEM used in the manner described in this document MUST explicitly be designed to be secure in the event that the public key is re-used, such as achieving IND-CCA2 security or having a transform like the Fujisaki-Okamoto transform [FO] [HHK] applied. While it is recommended that implementations avoid reuse of KEM public keys, implementations that do reuse KEM public keys MUST ensure that the number of reuses of a KEM public key abides by any bounds in the specification of the KEM or subsequent security analyses. Implementations MUST NOT reuse randomness in the generation of KEM ciphertexts.¶
Each particular combination of algorithms in a hybrid key exchange will be represented as a NamedGroup
and sent in the supported_groups
extension. No internal structure or grammar is implied or required in the value of the identifier; they are simply opaque identifiers.¶
Each value representing a hybrid key exchange will correspond to an ordered pair of two algorithms. For example, a future document could specify that one codepoint corresponds to secp256r1+ntruhrss701, and another corresponds to x25519+ntruhrss701. (We note that this is independent from future documents standardizing solely post-quantum key exchange methods, which would have to be assigned their own identifier.)¶
Specific values shall be standardized by IANA in the TLS Supported Groups registry.¶
enum { /* Elliptic Curve Groups (ECDHE) */ secp256r1(0x0017), secp384r1(0x0018), secp521r1(0x0019), x25519(0x001D), x448(0x001E), /* Finite Field Groups (DHE) */ ffdhe2048(0x0100), ffdhe3072(0x0101), ffdhe4096(0x0102), ffdhe6144(0x0103), ffdhe8192(0x0104), /* Hybrid Key Exchange Methods */ TBD(0xTBD), ..., /* Reserved Code Points */ ffdhe_private_use(0x01FC..0x01FF), hybrid_private_use(0xTBD..0xTBD), ecdhe_private_use(0xFE00..0xFEFF), (0xFFFF) } NamedGroup;¶
We take the relatively simple "concatenation approach": the messages from the two algorithms being hybridized will be concatenated together and transmitted as a single value, to avoid having to change existing data structures. The values are directly concatenated, without any additional encoding or length fields; this assumes that the representation and length of elements is fixed once the algorithm is fixed. If concatenation were to be used with values that are not fixed-length, a length prefix or other unambiguous encoding must be used to ensure that the composition of the two values is injective. See Appendix B.4.1 for a discussion of the concatenation combiner.¶
Recall that in TLS 1.3 a KEM public key or KEM ciphertext is represented as a KeyShareEntry
:¶
struct { NamedGroup group; opaque key_exchange<1..2^16-1>; } KeyShareEntry;¶
These are transmitted in the extension_data
fields of KeyShareClientHello
and KeyShareServerHello
extensions:¶
struct { KeyShareEntry client_shares<0..2^16-1>; } KeyShareClientHello; struct { KeyShareEntry server_share; } KeyShareServerHello;¶
The client's shares are listed in descending order of client preference; the server selects one algorithm and sends its corresponding share.¶
For a hybrid key exchange, the key_exchange
field of a KeyShareEntry
is the concatenation of the key_exchange
field for each of the constituent algorithms. The order of shares in the concatenation is the same as the order of algorithms indicated in the definition of the NamedGroup
.¶
For the client's share, the key_exchange
are the pk
outputs of the corresponding KEMs' KeyGen
algorithms, if that algorithm corresponds to a KEM; or the (EC)DH ephemeral key share, if that algorithm corresponds to an (EC)DH group. For the server's share, the key_exchange
values are the ct
outputs of the corresponding KEMs' Encaps
algorithms, if that algorithm corresponds to a KEM; or the (EC)DH ephemeral key share, if that algorithm corresponds to an (EC)DH group.¶
[TLS13] requires that ``The key_exchange values for each KeyShareEntry MUST be generated independently.'' In the context of this document, since the same algorithm may appear in multiple named groups, we relax the above requirement to allow the same key_exchange value for the same algorithm to be reused in multiple KeyShareEntry records sent in within the same ClientHello
. However, key_exchange values for different algorithms MUST be generated independently.¶
Larger public keys and/or ciphertexts.
The HybridKeyExchange
struct in Section 3.2 limits public keys and ciphertexts to 2^16-1 bytes; this is bounded by the same (2^16-1)-byte limit on the key_exchange
field in the KeyShareEntry
struct. Some post-quantum KEMs have larger public keys and/or ciphertexts; for example, Classic McEliece's smallest parameter set has public key size 261,120 bytes. Hence this draft can not accommodate all current NIST Round 3 candidates.¶
Duplication of key shares.
Concatenation of public keys in the HybridKeyExchange
struct as described in Section 3.2 can result in sending duplicate key shares. For example, if a client wanted to offer support for two combinations, say "secp256r1+sikep503" and "x25519+sikep503", it would end up sending two sikep503 public keys, since the KeyShareEntry
for each combination contains its own copy of a sikep503 key. This duplication may be more problematic for post-quantum algorithms which have larger public keys.¶
Failures. Some post-quantum key exchange algorithms have non-zero probability of failure, meaning two honest parties may derive different shared secrets. This would cause a handshake failure. All current NIST Round 3 candidates have either 0 or cryptographically small failure rate; if other algorithms are used, implementers should be aware of the potential of handshake failure. Clients can retry if a failure is encountered.¶
Identifiers for specific key exchange algorithm combinations will be defined in later documents.¶
The shared secrets computed in the hybrid key exchange should be computed in a way that achieves the "hybrid" property: the resulting secret is secure as long as at least one of the component key exchange algorithms is unbroken. See [GIACON] and [BINDEL] for an investigation of these issues. Under the assumption that shared secrets are fixed length once the combination is fixed, the construction from Section 3.3 corresponds to the dual-PRF combiner of [BINDEL] which is shown to preserve security under the assumption that the hash function is a dual-PRF.¶
As noted in Section 2, KEMs used in the manner described in this document MUST explicitly be designed to be secure in the event that the public key is re-used, such as achieving IND-CCA2 security or having a transform like the Fujisaki-Okamoto transform applied. Some IND-CPA-secure post-quantum KEMs (i.e., without countermeasures such as the FO transform) are completely insecure under public key reuse; for example, some lattice-based IND-CPA-secure KEMs are vulnerable to attacks that recover the private key after just a few thousand samples [FLUHRER].¶
Public keys, ciphertexts, and secrets should be constant length. This document assumes that the length of each public key, ciphertext, and shared secret is fixed once the algorithm is fixed. This is the case for all Round 3 finalists and alternate candidates.¶
Note that variable-length secrets are, generally speaking, dangerous. In particular, when using key material of variable length and processing it using hash functions, a timing side channel may arise. In broad terms, when the secret is longer, the hash function may need to process more blocks internally. In some unfortunate circumstances, this has led to timing attacks, e.g. the Lucky Thirteen [LUCKY13] and Raccoon [RACCOON] attacks.¶
Therefore, this specification MUST only be used with algorithms which have fixed-length shared secrets (after the variant has been fixed by the algorithm identifier in the NamedGroup
negotiation in Section 3.1).¶
These ideas have grown from discussions with many colleagues, including Christopher Wood, Matt Campagna, Eric Crockett, authors of the various hybrid Internet-Drafts and implementations cited in this document, and members of the TLS working group. The immediate impetus for this document came from discussions with attendees at the Workshop on Post-Quantum Software in Mountain View, California, in January 2019. Martin Thomson suggested the (Comb-KDF-1) (Appendix B.4.2) approach. Daniel J. Bernstein and Tanja Lange commented on the risks of reuse of ephemeral public keys. Matt Campagna and the team at Amazon Web Services provided additional suggestions. Nimrod Aviram proposed restricting to fixed-length secrets.¶
This appendix discusses choices one could make along four distinct axes when integrating hybrid key exchange into TLS 1.3:¶
The construction in the main body illustrates one selection along each of these axes. The remainder of this appendix outlines various options we have identified for each of these choices. Immediately below we provide a summary list. Options are labelled with a short code in parentheses to provide easy cross-referencing.¶
(Neg) (Appendix B.1) How to negotiate the use of hybridization in general and component algorithms specifically?¶
(Neg-Ind) (Appendix B.1.2) Negotiating component algorithms individually¶
ClientHello
supported_groups
extension, next-gen algorithms in another extension¶
supported_groups
with external mapping to tradition/next-gen.¶
supported_groups
separated by a delimiter.¶
(Neg-Comb) (Appendix B.1.3) Negotiating component algorithms as a combination¶
NamedGroup
identifiers for each desired combination.¶
supported_groups
with an extension defining the combination corresponding to each placeholder.¶
supported_groups
list.¶
(Num) (Appendix B.2) How many component algorithms can be combined?¶
(Shares) (Appendix B.3) How should multiple key shares (public keys / ciphertexts) be conveyed?¶
(Comb) (Appendix B.4) How should multiple shared secrets be combined?¶
Recall that in TLS 1.3, the key exchange mechanism is negotiated via the supported_groups
extension. The NamedGroup
enum is a list of standardized groups for Diffie-Hellman key exchange, such as secp256r1
, x25519
, and ffdhe2048
.¶
The client, in its ClientHello
message, lists its supported mechanisms in the supported_groups
extension. The client also optionally includes the public key of one or more of these groups in the key_share
extension as a guess of which mechanisms the server might accept in hopes of reducing the number of round trips.¶
If the server is willing to use one of the client's requested mechanisms, it responds with a key_share
extension containing its public key for the desired mechanism.¶
If the server is not willing to use any of the client's requested mechanisms, the server responds with a HelloRetryRequest
message that includes an extension indicating its preferred mechanism.¶
In these three approaches, the parties negotiate which traditional algorithm and which next-gen algorithm to use independently. The NamedGroup
enum is extended to include algorithm identifiers for each next-gen algorithm.¶
The client advertises two lists to the server: one list containing its supported traditional mechanisms (e.g. via the existing ClientHello
supported_groups
extension), and a second list containing its supported next-generation mechanisms (e.g., via an additional ClientHello
extension). A server could then select one algorithm from the traditional list, and one algorithm from the next-generation list. (This is the approach in [SCHANCK].)¶
The client advertises a single list to the server which contains both its traditional and next-generation mechanisms (e.g., all in the existing ClientHello
supported_groups
extension), but with some external table provides a standardized mapping of those mechanisms as either "traditional" or "next-generation". A server could then select two algorithms from this list, one from each category.¶
The client advertises a single list to the server delimited into sublists: one for its traditional mechanisms and one for its next-generation mechanisms, all in the existing ClientHello
supported_groups
extension, with a special code point serving as a delimiter between the two lists. For example, supported_groups = secp256r1, x25519, delimiter, nextgen1, nextgen4
.¶
In these three approaches, combinations of key exchange mechanisms appear as a single monolithic block; the parties negotiate which of several combinations they wish to use.¶
The NamedGroup
enum is extended to include algorithm identifiers for each combination of algorithms desired by the working group. There is no "internal structure" to the algorithm identifiers for each combination, they are simply new code points assigned arbitrarily. The client includes any desired combinations in its ClientHello
supported_groups
list, and the server picks one of these. This is the approach in [KIEFER] and [OQS-111].¶
The NamedGroup
enum is extended to include algorithm identifiers for each next-gen algorithm. Some additional field/extension is used to convey which combinations the parties wish to use. For example, in [WHYTE13], there are distinguished NamedGroup
called hybrid_marker 0
, hybrid_marker 1
, hybrid_marker 2
, etc. This is complemented by a HybridExtension
which contains mappings for each numbered hybrid_marker
to the set of component key exchange algorithms (2 or more) for that proposed combination.¶
The client lists combinations in supported_groups
list, using a special delimiter to indicate combinations. For example,
supported_groups = combo_delimiter, secp256r1, nextgen1, combo_delimiter, secp256r1, nextgen4, standalone_delimiter, secp256r1, x25519
would indicate that the client's highest preference is the combination secp256r1+nextgen1, the next highest preference is the combination secp2561+nextgen4, then the single algorithm secp256r1, then the single algorithm x25519. A hybrid-aware server would be able to parse these; a hybrid-unaware server would see unknown, secp256r1, unknown, unknown, secp256r1, unknown, unknown, secp256r1, x25519
, which it would be able to process, although there is the potential that every "projection" of a hybrid list that is tolerable to a client does not result in list that is tolerable to the client.¶
Combinatorial explosion. (Neg-Comb-1) (Appendix B.1.3.1) requires new identifiers to be defined for each desired combination. The other 4 options in this section do not.¶
Extensions. (Neg-Ind-1) (Appendix B.1.2.1) and (Neg-Comb-2) (Appendix B.1.3.2) require new extensions to be defined. The other options in this section do not.¶
New logic. All options in this section except (Neg-Comb-1) (Appendix B.1.3.1) require new logic to process negotiation.¶
Matching security levels. (Neg-Ind-1) (Appendix B.1.2.1), (Neg-Ind-2) (Appendix B.1.2.2), (Neg-Ind-3) (Appendix B.1.2.3), and (Neg-Comb-2) (Appendix B.1.3.2) allow algorithms of different claimed security level from their corresponding lists to be combined. For example, this could result in combining ECDH secp256r1 (classical security level 128) with NewHope-1024 (classical security level 256). Implementations dissatisfied with a mismatched security levels must either accept this mismatch or attempt to renegotiate. (Neg-Ind-1) (Appendix B.1.2.1), (Neg-Ind-2) (Appendix B.1.2.2), and (Neg-Ind-3) (Appendix B.1.2.3) give control over the combination to the server; (Neg-Comb-2) (Appendix B.1.3.2) gives control over the combination to the client. (Neg-Comb-1) (Appendix B.1.3.1) only allows standardized combinations, which could be set by TLS working group to have matching security (provided security estimates do not evolve separately).¶
Backwards-compability. TLS 1.3-compliant hybrid-unaware servers should ignore unreocgnized elements in supported_groups
(Neg-Ind-2) (Appendix B.1.2.2), (Neg-Ind-3) (Appendix B.1.2.3), (Neg-Comb-1) (Appendix B.1.3.1), (Neg-Comb-2) (Appendix B.1.3.2) and unrecognized ClientHello
extensions (Neg-Ind-1) (Appendix B.1.2.1), (Neg-Comb-2) (Appendix B.1.3.2). In (Neg-Ind-3) (Appendix B.1.2.3) and (Neg-Comb-3) (Appendix B.1.3.3), a server that is hybrid-unaware will ignore the delimiters in supported_groups
, and thus might try to negotiate an algorithm individually that is only meant to be used in combination; depending on how such an implementation is coded, it may also encounter bugs when the same element appears multiple times in the list.¶
Exactly two algorithms can be combined together in hybrid key exchange. This is the approach taken in [KIEFER] and [SCHANCK].¶
Two or more algorithms can be combined together in hybrid key exchange. This is the approach taken in [WHYTE13].¶
Restricting the number of component algorithms that can be hybridized to two substantially reduces the generality required. On the other hand, some adopters may want to further reduce risk by employing multiple next-gen algorithms built on different cryptographic assumptions.¶
Each component key exchange algorithm establishes a shared secret. These shared secrets must be combined in some way that achieves the "hybrid" property: the resulting secret is secure as long as at least one of the component key exchange algorithms is unbroken.¶
Each party concatenates the shared secrets established by each component algorithm in an agreed-upon order, then feeds that through the TLS key schedule. In the context of TLS 1.3, this would mean using the concatenated shared secret in place of the (EC)DHE input to the second call to HKDF-Extract
in the TLS 1.3 key schedule:¶
0 | v PSK -> HKDF-Extract = Early Secret | +-----> Derive-Secret(...) +-----> Derive-Secret(...) +-----> Derive-Secret(...) | v Derive-Secret(., "derived", "") | v concatenated_shared_secret -> HKDF-Extract = Handshake Secret ^^^^^^^^^^^^^^^^^^^^^^^^^^ | +-----> Derive-Secret(...) +-----> Derive-Secret(...) | v Derive-Secret(., "derived", "") | v 0 -> HKDF-Extract = Master Secret | +-----> Derive-Secret(...) +-----> Derive-Secret(...) +-----> Derive-Secret(...) +-----> Derive-Secret(...)¶
This is the approach used in [KIEFER], [OQS-111], and [WHYTE13].¶
[GIACON] analyzes the security of applying a KDF to concatenated KEM shared secrets, but their analysis does not exactly apply here since the transcript of ciphertexts is included in the KDF application (though it should follow relatively straightforwardly).¶
[BINDEL] analyzes the security of the (Comb-Concat) approach as abstracted in their dualPRF
combiner. They show that, if the component KEMs are IND-CPA-secure (or IND-CCA-secure), then the values output by Derive-Secret
are IND-CPA-secure (respectively, IND-CCA-secure). An important aspect of their analysis is that each ciphertext is input to the final PRF calls; this holds for TLS 1.3 since the Derive-Secret
calls that derive output keys (application traffic secrets, and exporter and resumption master secrets) include the transcript hash as input.¶
Each party feeds the shared secrets established by each component algorithm in an agreed-upon order into a KDF, then feeds that through the TLS key schedule. In the context of TLS 1.3, this would mean first applying HKDF-Extract
to the shared secrets, then using the output in place of the (EC)DHE input to the second call to HKDF-Extract
in the TLS 1.3 key schedule:¶
0 | v PSK -> HKDF-Extract = Early Secret | +-----> Derive-Secret(...) +-----> Derive-Secret(...) +-----> Derive-Secret(...) Next-Gen | | v (EC)DHE -> HKDF-Extract Derive-Secret(., "derived", "") | | v v output -----> HKDF-Extract = Handshake Secret ^^^^^^ | +-----> Derive-Secret(...) +-----> Derive-Secret(...) | v Derive-Secret(., "derived", "") | v 0 -> HKDF-Extract = Master Secret | +-----> Derive-Secret(...) +-----> Derive-Secret(...) +-----> Derive-Secret(...) +-----> Derive-Secret(...)¶
Each party concatenates the shared secrets established by each component algorithm in an agreed-upon order then feeds that into a KDF, then feeds the result through the TLS key schedule.¶
Compared with (Comb-KDF-1) (Appendix B.4.2), this method concatenates the (2 or more) shared secrets prior to input to the KDF, whereas (Comb-KDF-1) puts the (exactly 2) shared secrets in the two different input slots to the KDF.¶
Compared with (Comb-Concat) (Appendix B.4.1), this method has an extract KDF application. While this adds computational overhead, this may provide a cleaner abstraction of the hybridization mechanism for the purposes of formal security analysis.¶
0 | v PSK -> HKDF-Extract = Early Secret | +-----> Derive-Secret(...) +-----> Derive-Secret(...) +-----> Derive-Secret(...) | v concatenated 0 shared | secret -> HKDF-Extract Derive-Secret(., "derived", "") ^^^^^^ | | v v output -----> HKDF-Extract = Handshake Secret ^^^^^^ | +-----> Derive-Secret(...) +-----> Derive-Secret(...) | v Derive-Secret(., "derived", "") | v 0 -> HKDF-Extract = Master Secret | +-----> Derive-Secret(...) +-----> Derive-Secret(...) +-----> Derive-Secret(...) +-----> Derive-Secret(...)¶
Each party XORs the shared secrets established by each component algorithm (possibly after padding secrets of different lengths), then feeds that through the TLS key schedule. In the context of TLS 1.3, this would mean using the XORed shared secret in place of the (EC)DHE input to the second call to HKDF-Extract
in the TLS 1.3 key schedule.¶
[GIACON] analyzes the security of applying a KDF to the XORed KEM shared secrets, but their analysis does not quite apply here since the transcript of ciphertexts is included in the KDF application (though it should follow relatively straightforwardly).¶
Each party applies a chain of key derivation functions to the shared secrets established by each component algorithm in an agreed-upon order; roughly speaking: F(k1 || F(k2))
. In the context of TLS 1.3, this would mean extending the key schedule to have one round of the key schedule applied for each component algorithm's shared secret:¶
0 | v PSK -> HKDF-Extract = Early Secret | +-----> Derive-Secret(...) +-----> Derive-Secret(...) +-----> Derive-Secret(...) | v Derive-Secret(., "derived", "") | v traditional_shared_secret -> HKDF-Extract ^^^^^^^^^^^^^^^^^^^^^^^^^ | Derive-Secret(., "derived", "") | v next_gen_shared_secret -> HKDF-Extract = Handshake Secret ^^^^^^^^^^^^^^^^^^^^^^ | +-----> Derive-Secret(...) +-----> Derive-Secret(...) | v Derive-Secret(., "derived", "") | v 0 -> HKDF-Extract = Master Secret | +-----> Derive-Secret(...) +-----> Derive-Secret(...) +-----> Derive-Secret(...) +-----> Derive-Secret(...)¶
This is the approach used in [SCHANCK].¶
[BINDEL] analyzes the security of this approach as abstracted in their nested dual-PRF N
combiner, showing a similar result as for the dualPRF combiner that it preserves IND-CPA (or IND-CCA) security. Again their analysis depends on each ciphertext being input to the final PRF (Derive-Secret
) calls, which holds for TLS 1.3.¶
In the context of TLS 1.3, the next-generation shared secret is used in place of a currently unused input in the TLS 1.3 key schedule, namely replacing the 0
"IKM" input to the final HKDF-Extract
:¶
0 | v PSK -> HKDF-Extract = Early Secret | +-----> Derive-Secret(...) +-----> Derive-Secret(...) +-----> Derive-Secret(...) | v Derive-Secret(., "derived", "") | v traditional_shared_secret -> HKDF-Extract = Handshake Secret ^^^^^^^^^^^^^^^^^^^^^^^^^ | +-----> Derive-Secret(...) +-----> Derive-Secret(...) | v Derive-Secret(., "derived", "") | v next_gen_shared_secret -> HKDF-Extract = Master Secret ^^^^^^^^^^^^^^^^^^^^^^ | +-----> Derive-Secret(...) +-----> Derive-Secret(...) +-----> Derive-Secret(...) +-----> Derive-Secret(...)¶
This approach is not taken in any of the known post-quantum/hybrid TLS drafts. However, it bears some similarities to the approach for using external PSKs in [EXTERN-PSK].¶
New logic. While (Comb-Concat) (Appendix B.4.1), (Comb-KDF-1) (Appendix B.4.2), and (Comb-KDF-2) (Appendix B.4.3) require new logic to compute the concatenated shared secret, this value can then be used by the TLS 1.3 key schedule without changes to the key schedule logic. In contrast, (Comb-Chain) (Appendix B.4.5) requires the TLS 1.3 key schedule to be extended for each extra component algorithm.¶
Philosophical. The TLS 1.3 key schedule already applies a new stage for different types of keying material (PSK versus (EC)DHE), so (Comb-Chain) (Appendix B.4.5) continues that approach.¶
Efficiency. (Comb-KDF-1) (Appendix B.4.2), (Comb-KDF-2) (Appendix B.4.3), and (Comb-Chain) (Appendix B.4.5) increase the number of KDF applications for each component algorithm, whereas (Comb-Concat) (Appendix B.4.1) and (Comb-AltInput) (Appendix B.4.6) keep the number of KDF applications the same (though with potentially longer inputs).¶
Extensibility. (Comb-AltInput) (Appendix B.4.6) changes the use of an existing input, which might conflict with other future changes to the use of the input.¶
More than 2 component algorithms. The techniques in (Comb-Concat) (Appendix B.4.1) and (Comb-Chain) (Appendix B.4.5) can naturally accommodate more than 2 component shared secrets since there is no distinction to how each shared secret is treated. (Comb-AltInput) (Appendix B.4.6) would have to make some distinct, since the 2 component shared secrets are used in different ways; for example, the first shared secret is used as the "IKM" input in the 2nd HKDF-Extract
call, and all subsequent shared secrets are concatenated to be used as the "IKM" input in the 3rd HKDF-Extract
call.¶