Re: [TLS] Consensus for AEAD IV

[Michael StJohns <[e-mail]>]

On 4/27/2015 3:51 AM, Yoav Nir wrote:
>>> The ChaCha20-Poly1305 for IPsec draft does the same thing, and in fact so does RFC 5288 (AES-GCM for TLS 1.2)
>> >
>> >Citing your own draft as proof of your own argument is a bit.... well…
> That WG draft is in WGLC now, so it it’s doing something that is wrong, now would be a good time to say why. It’s also doing the exact same thing that IPsec has been doing with AEADs since 4106 and TLS since 5288. All of these combined a 64-bit explicit IV with a 32-bit salt that is derived as part of the keying materials (KEYMAT for IPsec, key_block for TLS) and never ever transmitted.

See below:  Basically getting your nonce/IV material from the same key 
stream production of your keys is problematic.  You'd be better off 
specifying a different mechanism for producing such material, even if it 
differs from what is done throughout IPSEC.

But that's a side show and rat hole we need not go down for TLS.


>
>> >In any event, I note that your IPSEC draft doesn't actually describe the ESP payload format, so without that, I'd make the assumption that the IV is included before the payload as is described in the IPSEC ESP document.
>> >
>>> >>
>>> >>So no, that salt (and by extension, the proposed 96-bit value) need not be secret, but it’s never transmitted.
>> >In which of the above?  Maybe in the chacha20 draft... but not in the other two.
>> >
>> >And RFC5288 does it the wrong way - getting IV (session nonce) material from the same key stream as key material.  That hopefully will be fixed with TLS1.3.  It would have been much more preferable to use a zero session nonce than extract it from the key stream.
> You are saying that this is wrong. Why?

Because TLS1.2 had eliminated the IV production as part of the key 
expansion from the master secret phase.  The AEAD suites added it back 
in.  Without the IV production, it would have been somewhat easier to 
secure some of the TLS HSM functionality.   And given that zero session 
nonces are completely acceptable and secure, that would have been a fine 
fixed choice  instead of the one that was made.
>
>>> >>  This also shows that there is good precedent for generating such a doesn’t-really-need-to-be-secret value from the key_block or KEYMAT.
>> >
>> >I'm pretty sure it doesn't.  It just shows a continuous misunderstanding of the problems with doing it this way.
> And those problems are…?
>


Let me try this one last time.  I must just not be speaking the same 
language as the rest of you.

The generic definition of a KDF both in TLS and IPSEC looks something like:

Key_Stream = KDF (MasterSecret, Mixins, Length Of KeyStream)

The above is deterministic - if you call the same KDF repeatedly with 
the same master secret, mixins and length, you will get the exact same 
key stream.  The details of how you get that key stream differ between 
the two, but you still end up get a block of pseudo-random bytes of a 
certain length.

E.g. pretend I've derived a keystream of 20 octets for IPSEC: 
0x112233445566778899aabbccddeeff0011223344

In both TLS and IPSEC, the key stream is then broken down into parts 
that are assigned to secret keys, and unfortunately to values that are 
not secret (e.g. IV's nonces, etc).   For example, a new KEYMAT is 
generated for each GCM key and broken down into the key and salt (per 
RFC4106 section 8.1).

However, the split in the key stream is under user control.   For both 
TLS and the IPSEC, I can call the appropriate function and assign any 
part of the key stream to secret or public status. While the IPSEC spec 
says to generate 20 octets for a 128 bit GCM key, and to assign 4 octets 
of that to the salt, if I instead assign 0 octets to a key and 20 octets 
to a salt, I've managed to move what I thought was secret into a public 
part.

E.g. the first call gets me an AES key of 
0x112233445566778899aabbccddeeff00 with a salt of 0x11223344; the second 
call by the attacker gets him only a salt of 
0x112233445566778899aabbccddeeff0011223344 which coincidentally has the 
exact same value as the generated key stream.

This is important because calling sequences for HSM versions of these 
KDFs have no way of knowing - FOR A SPECIFIC CALL - the *real* purpose 
of a desired key.   The user may make a call to do the split along the 
16/4 lines, but an attacker can use the same exact call with different 
key targets to get the 0/20 split and extract the derived AES key.

Mixing the production of secret and not-secret data in the same call to 
a KDF without a way of cryptographically isolating the result means that 
you can never be sure of the secrecy of the derived keys in an HSM.

There are ways to mitigate this:  mandatory mixins of the length and 
types of material to be produced to the key stream production phase.  
That way, changes to the keystream to key assignments result in 
completely different keystream material and avoid this problem. An HSM 
can enforce the keystream to key assignments and even allow non-key 
material to be produced IF that is appropriately mixed in.

All of this is generally not a big issue for software only 
implementations because all memory is outside of any assurance boundary 
and the treatment of any stream of bytes as public or secret are matters 
of convention rather than enforced policy.

I'm going to stop talking on this set of threads now.  My head hurts.

Mike