Subject: [TLS] Benjamin Kaduk's Yes on draft-ietf-tls-external-psk-importer-06: (with COMMENT)

From: Benjamin Kaduk via Datatracker <[email-masked]>
Date: Thu, 31 Dec 2020 11:12:36 -0800

Benjamin Kaduk has entered the following ballot position for
draft-ietf-tls-external-psk-importer-06: Yes

When responding, please keep the subject line intact and reply to all
email addresses included in the To and CC lines. (Feel free to cut this
introductory paragraph, however.)

Please refer to https://www.ietf.org/iesg/statement/discuss-criteria.html
for more information about IESG DISCUSS and COMMENT positions.

The document, along with other ballot positions, can be found here:
https://datatracker.ietf.org/doc/draft-ietf-tls-external-psk-importer/

----------------------------------------------------------------------
COMMENT:
----------------------------------------------------------------------

Sorry about the large volume of comments; this document is actually in
pretty good shape, there are just a bunch of details that can be subtle
to get exactly right.

I specifically call out the note in Section 4.1 about which
HKDF-Expand-Label is to be used, since that would affect the actual
derived keys for DTLS 1.3 (and any hypothetical future TLS versions).

Section 1

   While there is no known way in which the same external PSK might
   produce related output in TLS 1.3 and prior versions, only limited
   analysis has been done.  Applications SHOULD provision separate PSKs
   for TLS 1.3 and prior versions.

   To mitigate against any interference, this document specifies a PSK
   Importer interface by which external PSKs may be imported and
   subsequently bound to a specific key derivation function (KDF) and
   hash function for use in TLS 1.3 [RFC8446] and DTLS 1.3 [DTLS13].  [...]

IIRC the main target use cases for this mechanism are for *existing*
external PSKs (violating the "SHOULD" from the first quoted paragraph),
as well as deployments that are simplified by only needing to provision
a single PSK.  Does it make sense to include such clarifying description
here?  (Similarly, is it accurate to say that "[a]pplications SHOULD
provision separate PSKs [...], but the mechanism defined in this
document provides a partial mitigation for use when that is not possible"?

Also, we only use the word "interference" twice in this document
(this is the first instance), so it might be worth a couple more words
to clarify the nature of the potential interference.

Section 3

   non-imported keys for TLS versions prior to TLS 1.3.  Non-imported
   and imported PSKs are distinct since their identities are different
   on the wire.  See Section 6 for more details.

(side note?) I think the precise story here is a little subtle -- for
any given key, the imported and non-imported identities are distinct,
but in principle one could construct a non-imported identity that
overlaps with an imported identity for a different key (and we say as
much at the end of Section 7).  This is vanishingly rare to happen by
chance, but makes the statement as written not quite categorically true.
That said, the change to the binder key derivation (§ 4.2) seems to
obviate any potential consequences to such a collision (though the
connection attempt would presumably fail).

   Endpoints which import external keys MUST NOT use either the external
   keys or the derived keys for any other purpose.  Moreover, each

IIUC, this is "MUST NOT use the keys that are input to the import
process for any purpose other than the importer, and MUST NOT use the
derived keys for any purpose other than TLS PSKs".  Is it worth spelling
it out explicitly like that?

   external PSK MUST be associated with at most one hash function, as
   per the rules in Section 4.2.11 from [RFC8446].  See Section 7 for
   more discussion.

Does this requirement apply to the inputs to the importer process, the
outputs, or both?

Section 3.1

   *  Imported PSK (IPSK): A PSK derived from an EPSK, External
      Identity, optional context string, target protocol, and target
      KDF.

There is an "External Identity" that is contained within the EPSK
itself; is the "External Identity" listed here distinct from that?

Section 4.1

   The PSK Importer interface takes as input an EPSK with External
   Identity "external_identity" and base key "epsk", as defined in
   Section 3.1, along with an optional context, and transforms it into a
   set of PSKs and imported identities for use in a connection based on
   target protocols and KDFs.  In particular, for each supported target
   protocol "target_protocol" and KDF "target_kdf", the importer
   constructs an ImportedIdentity structure as follows:

If I understand correctly the "target_kdf" is supposed to be the KDF
associated with the cipher suite(s) the derived PSK will be usable for.
This is something of a divergence from RFC 8446, where we *assume* that
the KDF will be HKDF and associate only a *hash function* with the
cipher suite.  While discussing a more generic KDF concept seems
reasonable (and is directly in line with the cryptographic principles
that motivate this work), I'd recommend adding a few more words
somewhere in this section to clarify the relationship between the
target_kdf and the cipher suite(s), probably in the paragraph that
starts "[e]ndpoints SHOULD generate a compatible 'ipskx' for each target
ciphersuite they offer".

   struct {
      opaque external_identity<1...2^16-1>;
      opaque context<0..2^16-1>;
      uint16 target_protocol;
      uint16 target_kdf;
   } ImportedIdentity;

Should we say that this is using the TLS presentation language?

   ImportedIdentity.context MUST include the context used to derive the
   EPSK, if any exists.  For example, ImportedIdentity.context may

(nit?) "derive" suggests a cryptographic key derivation process, but the
rest of the prose suggests that this is more a process of
"identification" or "determination".  Is there a more appropriate word
to use?

   Given an ImportedIdentity and corresponding EPSK with base key
   "epsk", an Imported PSK IPSK with base key "ipskx" is computed as
   follows:

      epskx = HKDF-Extract(0, epsk)
      ipskx = HKDF-Expand-Label(epskx, "derived psk",
                                Hash(ImportedIdentity), L)

I think we need to say that the HKDF-Expand-Label used (i.e., the
HkdfLabel.label prefix) is the one corresponding to
ImportedIdentity.target_protocol.

   L corresponds to the KDF output length of ImportedIdentity.target_kdf
   as defined in Section 9.  For hash-based KDFs, such as
   HKDF_SHA256(0x0001), this is the length of the hash function output,
   i.e., 32 octets.  This is required for the IPSK to be of length

(32 octets for SHA256, not all hash-based KDFs)

   The identity of "ipskx" as sent on the wire is ImportedIdentity,
   i.e., the serialized content of ImportedIdentity is used as the
   content of PskIdentity.identity in the PSK extension.  The
   corresponding TLS 1.3 binder key is "ipskx".

In RFC 8446, the "binder_key" is the *output* of the key schedule, but
ipskx is an *input* to the key schedule.  So I think we want to say
something like "the corresponding PSK input for the TLS 1.3 key schedule
is 'ipskx'".

   The hash function used for HKDF [RFC5869] is that which is associated
   with the EPSK.  It is not the hash function associated with
   ImportedIdentity.target_kdf.  If no hash function is specified,

I predict that someone will mess up the hash function selection while
implementing this.  Perhaps we could provide test vectors for the full
matrix of (EPSK Hash, target_kdf hash) pairs using SHA256/SHA384?

   SHA-256 [SHA2] MUST be used.  Diversifying EPSK by

I think we might be able to tolerate the *protocol* having a strict
requirement that the associated hash function is specified, and provide
a recommended value that would be used by people deploying the protocol
in the absence of other information.  This might in some sense help
future-proof the document for the scenario where SHA256 weakens or is
broken and the default should change.

   KDFs, protocols, and context string(s) are known a priori.  EPSKs MAY
   also be imported for early data use if they are bound to protocol
   settings and configurations that would otherwise be required for
   early data with normal (ticket-based PSK) resumption.  Minimally,
   that means Application-Layer Protocol Negotiation [RFC7301], QUIC

RFC 8446 does not limit 0-RTT data to resumption, so I think we just
want "if they are bound to the protocol settings and configuration that
are required for sending early data".

Also, nit: I think we usually refer to the "ALPN value" instead of just
"ALPN" being configured.

Section 5

   If a client or server wish to deprecate a hash function and no longer
   use it for TLS 1.3, they remove the corresponding KDF from the set of
   target KDFs used for importing keys.  This does not affect the KDF
   operation used to derive Imported PSKs.

Should we also include a paragraph about how to deprecate the Hash used
in deriving Imported PSKs?  (It's fixed per EPSK, so, "configure a new
EPSK", basically.)

Section 6

   Recall that TLS 1.2 permits computing the TLS PRF with any hash
   algorithm and PSK.  Thus, an EPSK may be used with the same KDF (and
   underlying HMAC hash algorithm) as TLS 1.3 with importers.  However,
   critically, the derived PSK will not be the same since the importer
   differentiates the PSK via the identity and target KDF and protocol.
   Thus, PSKs imported for TLS 1.3 are distinct from those used in TLS
   1.2, and thereby avoid cross-protocol collisions.  [...]

As I read this I recalled that up in Section 1 we say that applications
"SHOULD provision separate PSKs for TLS 1.3 and prior versions".  The
scenario being described here sounds like it can only occur if that
SHOULD is ignored, which might be worth reiterating.

We also say in § 4.1 that "external PSKs MUST NOT be imported for (D)TLS
1.2 or prior versions".  In light of these two observations, my best
interpretation of the quoted text is that it should be equivalent to:

NEW:
   Recall that TLS 1.2 permits computing the TLS PRF with any hash
   algorithm and PSK.  Accordingly, a given EPSK might be both used
   directly as a TLS 1.2 PSK and used with TLS 1.3 via the importer
   mechanism (noting that this configuration is not recommended, per Section
   1), using the same KDF algorithm.  However, because the TLS 1.3
   importer mechanism includes an additional key-derivation step, the
   actual PSK used in the TLS 1.3 key schedule will be distinct from the
   one used in the TLS 1.2 key schedule, so there are no cross-protocol
   collisions possible.
--

                                                      Note that this
   does not preclude endpoints from using non-imported PSKs for TLS 1.2.

For some reason this line implies to me that endpoints might use
imported PSKs for TLS 1.2, but this is forbidden by Section 4.1 (as
quoted above).  Perhaps "does not preclude endpoints from continuing to
use TLS 1.2 and the non-imported PSKs it requires"?

Section 7

We should probably note that any information placed in
ImportedIdentity.context will be visible on the wire in cleartext, and
thus that confidential identifiers from other protocols should either
not be used or should be protected (e.g., by hashing) prior to use.

   1.  Externally provisioned PSKs imported into a TLS connection
       achieve compound authentication of the provisioning process and
       connection.

   2.  Context-free PSKs only achieve authentication within the context
       of a single connection.

Do we need to use psk_dh_ke to get the strong compound authentication
property, or is it attainable with psk_ke as well?

Section 10.1

I'm not sure why [QUIC] and RFC 5246 are listed as normative references.

Appendix B

   The Selfie attack [Selfie] relies on a misuse of the PSK interface.
   The PSK interface makes the implicit assumption that each PSK is
   known only to one client and one server.  If multiple clients or
   multiple servers with distinct roles share a PSK, TLS only
   authenticates the entire group.  A node successfully authenticates
   its peer as being in the group whether the peer is another node or
   itself.

I think it may be useful to call out that the "multiple clients" and
"multiple servers" case can occur even when there are only two endpoints
that know the key (that is, when they do not have predetermined
client/server roles).

     struct {
       opaque client_mac<0..2^16-1>;
       opaque server_mac<0..2^16-1>;
     } Context;

We may not need the whole 16k to hold a MAC address, especially since
this is just an example.

   If an attacker then redirects a ClientHello intended for one node to
   a different node, the receiver will compute a different context
   string and the handshake will not complete.

Similarly to the above, this could be "a different node (including the
node that generated the ClientHello)".