Key Wrapping and Encapsulation

cat /dev/random > /dev/null

Posted on:

One of the synonoms for the word 'wrap' is 'encapsulate.' However, in cryptography, and especially with respect to keying material, these two words mean very different things. In this post I'll explain these two terms and what they mean. (Mostly as a way to get it straight in my mind as well.)

Key Wrapping

Key wrapping is a cryptographic algorithm which aims to provide "privacy and integrity protection for specialized data such as cryptographic keys, ... without the use of nonces" [1,2]. Without knowing any more details, there are two terms that should resonate with cryptography folks: privacy and integrity. Or, said differently, confidentiality and integrity. Authenticated encryption with associated data (AEAD) is one class of algorithms that provide these properties. Popular examples of AEAD algorithms include AES-GCM, ChaCha20+Poly1305, and more. However, existing AEAD algorithms require the use of nonces to ensure randomness that's required for CCA-security. So, as Phil Rogaway framed it, the key wrapping problem is about creating deterministic authenticated encryption (DAE) algorithms [1].

DAE algorithms accept a symmetric key, a header (i.e., the associated data), and a message and returns a ciphertext. The inverse operation takes the same key, header, and ciphertext to produce the plaintext message. The security of the DAE scheme is defined similarly to AEAD schemes. Namely, the adversary is given access to either (a) an encryption and decryption oracle or (b) a fake encryption and decryption oracle that return random bits and failures, respectively. If the adversary cannot distinguish between which oracle it received, then the DAE scheme is secure. If the adversary could in fact distinguish between these two cases, then some information about the plaintext is leaked by the ciphertext from the encryption oracle or forgeries are possible. Thus, privacy and integrity are captured by this definition.

Rogaway's DAE construction is based on what he calls a synthetic initialization vector (SIV). I don't know the details of this construction yet myself, so I'll defer that to a future post. (Possibly when I'm on the plane to Germany this Saturday.)

Key Encapsulation

Encapsulation, unlike wrapping, is about creating provably secure hybrid encryption schemes. That is, public-key encryption when the message cannot be mapped to an element of the PK group, e.g., an ElGamal or RSA group element. The traditional way to do this is as follows: First, generate a random symmetric key K and encrypt the message M with the data to produce some ciphertext C. Then encrypt K under the recipient's public key to obtain the encrypted key K'. Finally, transfer (C, K') to the recipient. If they possess the right private key, they can decrypt K and then C to obtain M. Easy enough.

Sadly, to my knowledge, there have been no security proofs for these schemes. Moreover, most schemes, such as RSA-OEAP [3], require the input to be padded, though it is still secure. Padding schemes such as those defined in PKCS #1 v1.5 are not secure [4].

Key encapsulation was introduced as a way to solve this problem. Instead of encrypting the random (and padded) symmetric key, an element of the group, which is used to derive the symmetric key, is encrypted. To give an example, here's how the RSA key encapsulate mechanism works (paraphrased from [5] for simplicity).

  1. Generate a random integer $$z < N$$.
  2. Encrypt $$z$$ under the recipient's public key $$(N, e)$$ to obtain $$z'$$.
  3. Derive the encryption key (or KEK, in the case where a symmetric key is being encrypted for transport) using a KDF function with $$z$$ as input.
  4. Encrypt the data $$M$$ using the encryption key to obtain $$C$$.
  5. Output $$(z',C)$$.

To inverse this process and recover the data $$M$$, the recipient of this tuple decrypts $$z$$, computes the encryption key, and then inverses the symmetric-key encryption algorithm. Easy enough.

"Wrapping" Up

Key wrapping is DAE for any type of message, but particularly keys, to a party that has the keys necessary to decrypt the message ciphertexts, whereas key encapsulation is about securely transmitting symmetric keys to another party and using them to encrypt any data. Key wrapping requires only symmetric-key encryption, whereas key encapsulation requires public-key encryption.


More posts: