1 // SPDX-License-Identifier: GPL-2.0
3 * Implementation of HKDF ("HMAC-based Extract-and-Expand Key Derivation
4 * Function"), aka RFC 5869. See also the original paper (Krawczyk 2010):
5 * "Cryptographic Extraction and Key Derivation: The HKDF Scheme".
7 * This is used to derive keys from the llcrypt master keys.
9 * Copyright 2019 Google LLC
12 * Linux commit 219d54332a09
16 #include <crypto/hash.h>
17 #include <crypto/sha.h>
19 #include "llcrypt_private.h"
22 * HKDF supports any unkeyed cryptographic hash algorithm, but llcrypt uses
23 * SHA-512 because it is reasonably secure and efficient; and since it produces
24 * a 64-byte digest, deriving an AES-256-XTS key preserves all 64 bytes of
25 * entropy from the master key and requires only one iteration of HKDF-Expand.
27 #define HKDF_HMAC_ALG "hmac(sha512)"
28 #define HKDF_HASHLEN SHA512_DIGEST_SIZE
31 * HKDF consists of two steps:
33 * 1. HKDF-Extract: extract a pseudorandom key of length HKDF_HASHLEN bytes from
34 * the input keying material and optional salt.
35 * 2. HKDF-Expand: expand the pseudorandom key into output keying material of
36 * any length, parameterized by an application-specific info string.
38 * HKDF-Extract can be skipped if the input is already a pseudorandom key of
39 * length HKDF_HASHLEN bytes. However, cipher modes other than AES-256-XTS take
40 * shorter keys, and we don't want to force users of those modes to provide
41 * unnecessarily long master keys. Thus llcrypt still does HKDF-Extract. No
42 * salt is used, since llcrypt master keys should already be pseudorandom and
43 * there's no way to persist a random salt per master key from kernel mode.
46 /* HKDF-Extract (RFC 5869 section 2.2), unsalted */
47 static int hkdf_extract(struct crypto_shash *hmac_tfm, const u8 *ikm,
48 unsigned int ikmlen, u8 prk[HKDF_HASHLEN])
50 static const u8 default_salt[HKDF_HASHLEN];
51 SHASH_DESC_ON_STACK(desc, hmac_tfm);
54 err = crypto_shash_setkey(hmac_tfm, default_salt, HKDF_HASHLEN);
59 err = crypto_shash_digest(desc, ikm, ikmlen, prk);
60 shash_desc_zero(desc);
65 * Compute HKDF-Extract using the given master key as the input keying material,
66 * and prepare an HMAC transform object keyed by the resulting pseudorandom key.
68 * Afterwards, the keyed HMAC transform object can be used for HKDF-Expand many
69 * times without having to recompute HKDF-Extract each time.
71 int llcrypt_init_hkdf(struct llcrypt_hkdf *hkdf, const u8 *master_key,
72 unsigned int master_key_size)
74 struct crypto_shash *hmac_tfm;
78 hmac_tfm = crypto_alloc_shash(HKDF_HMAC_ALG, 0, 0);
79 if (IS_ERR(hmac_tfm)) {
80 llcrypt_err(NULL, "Error allocating " HKDF_HMAC_ALG ": %ld",
82 return PTR_ERR(hmac_tfm);
85 if (WARN_ON(crypto_shash_digestsize(hmac_tfm) != sizeof(prk))) {
90 err = hkdf_extract(hmac_tfm, master_key, master_key_size, prk);
94 err = crypto_shash_setkey(hmac_tfm, prk, sizeof(prk));
98 hkdf->hmac_tfm = hmac_tfm;
102 crypto_free_shash(hmac_tfm);
104 memzero_explicit(prk, sizeof(prk));
109 * HKDF-Expand (RFC 5869 section 2.3). This expands the pseudorandom key, which
110 * was already keyed into 'hkdf->hmac_tfm' by llcrypt_init_hkdf(), into 'okmlen'
111 * bytes of output keying material parameterized by the application-specific
112 * 'info' of length 'infolen' bytes, prefixed by "llcrypt\0" and the 'context'
113 * byte. This is thread-safe and may be called by multiple threads in parallel.
115 * ('context' isn't part of the HKDF specification; it's just a prefix llcrypt
116 * adds to its application-specific info strings to guarantee that it doesn't
117 * accidentally repeat an info string when using HKDF for different purposes.)
119 int llcrypt_hkdf_expand(struct llcrypt_hkdf *hkdf, u8 context,
120 const u8 *info, unsigned int infolen,
121 u8 *okm, unsigned int okmlen)
123 SHASH_DESC_ON_STACK(desc, hkdf->hmac_tfm);
127 const u8 *prev = NULL;
129 u8 tmp[HKDF_HASHLEN];
131 if (WARN_ON(okmlen > 255 * HKDF_HASHLEN))
134 desc->tfm = hkdf->hmac_tfm;
136 memcpy(prefix, "fscrypt\0", 8);
139 for (i = 0; i < okmlen; i += HKDF_HASHLEN) {
141 err = crypto_shash_init(desc);
146 err = crypto_shash_update(desc, prev, HKDF_HASHLEN);
151 err = crypto_shash_update(desc, prefix, sizeof(prefix));
155 err = crypto_shash_update(desc, info, infolen);
159 BUILD_BUG_ON(sizeof(counter) != 1);
160 if (okmlen - i < HKDF_HASHLEN) {
161 err = crypto_shash_finup(desc, &counter, 1, tmp);
164 memcpy(&okm[i], tmp, okmlen - i);
165 memzero_explicit(tmp, sizeof(tmp));
167 err = crypto_shash_finup(desc, &counter, 1, &okm[i]);
177 memzero_explicit(okm, okmlen); /* so caller doesn't need to */
178 shash_desc_zero(desc);
182 void llcrypt_destroy_hkdf(struct llcrypt_hkdf *hkdf)
184 crypto_free_shash(hkdf->hmac_tfm);