1 // SPDX-License-Identifier: GPL-2.0
2 /*
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".
6 *
7 * This is used to derive keys from the fscrypt master keys.
8 *
9 * Copyright 2019 Google LLC
10 */
11
12 #include <crypto/hash.h>
13 #include <crypto/sha.h>
14
15 #include "fscrypt_private.h"
16
17 /*
18 * HKDF supports any unkeyed cryptographic hash algorithm, but fscrypt uses
19 * SHA-512 because it is reasonably secure and efficient; and since it produces
20 * a 64-byte digest, deriving an AES-256-XTS key preserves all 64 bytes of
21 * entropy from the master key and requires only one iteration of HKDF-Expand.
22 */
23 #define HKDF_HMAC_ALG "hmac(sha512)"
24 #define HKDF_HASHLEN SHA512_DIGEST_SIZE
25
26 /*
27 * HKDF consists of two steps:
28 *
29 * 1. HKDF-Extract: extract a pseudorandom key of length HKDF_HASHLEN bytes from
30 * the input keying material and optional salt.
31 * 2. HKDF-Expand: expand the pseudorandom key into output keying material of
32 * any length, parameterized by an application-specific info string.
33 *
34 * HKDF-Extract can be skipped if the input is already a pseudorandom key of
35 * length HKDF_HASHLEN bytes. However, cipher modes other than AES-256-XTS take
36 * shorter keys, and we don't want to force users of those modes to provide
37 * unnecessarily long master keys. Thus fscrypt still does HKDF-Extract. No
38 * salt is used, since fscrypt master keys should already be pseudorandom and
39 * there's no way to persist a random salt per master key from kernel mode.
40 */
41
42 /* HKDF-Extract (RFC 5869 section 2.2), unsalted */
43 static int hkdf_extract(struct crypto_shash *hmac_tfm, const u8 *ikm,
44 unsigned int ikmlen, u8 prk[HKDF_HASHLEN])
45 {
46 static const u8 default_salt[HKDF_HASHLEN];
47 SHASH_DESC_ON_STACK(desc, hmac_tfm);
48 int err;
49
50 err = crypto_shash_setkey(hmac_tfm, default_salt, HKDF_HASHLEN);
51 if (err)
52 return err;
53
54 desc->tfm = hmac_tfm;
55 err = crypto_shash_digest(desc, ikm, ikmlen, prk);
56 shash_desc_zero(desc);
57 return err;
58 }
59
60 /*
61 * Compute HKDF-Extract using the given master key as the input keying material,
62 * and prepare an HMAC transform object keyed by the resulting pseudorandom key.
63 *
64 * Afterwards, the keyed HMAC transform object can be used for HKDF-Expand many
65 * times without having to recompute HKDF-Extract each time.
66 */
67 int fscrypt_init_hkdf(struct fscrypt_hkdf *hkdf, const u8 *master_key,
68 unsigned int master_key_size)
69 {
70 struct crypto_shash *hmac_tfm;
71 u8 prk[HKDF_HASHLEN];
72 int err;
73
74 hmac_tfm = crypto_alloc_shash(HKDF_HMAC_ALG, 0, 0);
75 if (IS_ERR(hmac_tfm)) {
76 fscrypt_err(NULL, "Error allocating " HKDF_HMAC_ALG ": %ld",
77 PTR_ERR(hmac_tfm));
78 return PTR_ERR(hmac_tfm);
79 }
80
81 if (WARN_ON(crypto_shash_digestsize(hmac_tfm) != sizeof(prk))) {
82 err = -EINVAL;
83 goto err_free_tfm;
84 }
85
86 err = hkdf_extract(hmac_tfm, master_key, master_key_size, prk);
87 if (err)
88 goto err_free_tfm;
89
90 err = crypto_shash_setkey(hmac_tfm, prk, sizeof(prk));
91 if (err)
92 goto err_free_tfm;
93
94 hkdf->hmac_tfm = hmac_tfm;
95 goto out;
96
97 err_free_tfm:
98 crypto_free_shash(hmac_tfm);
99 out:
100 memzero_explicit(prk, sizeof(prk));
101 return err;
102 }
103
104 /*
105 * HKDF-Expand (RFC 5869 section 2.3). This expands the pseudorandom key, which
106 * was already keyed into 'hkdf->hmac_tfm' by fscrypt_init_hkdf(), into 'okmlen'
107 * bytes of output keying material parameterized by the application-specific
108 * 'info' of length 'infolen' bytes, prefixed by "fscrypt\0" and the 'context'
109 * byte. This is thread-safe and may be called by multiple threads in parallel.
110 *
111 * ('context' isn't part of the HKDF specification; it's just a prefix fscrypt
112 * adds to its application-specific info strings to guarantee that it doesn't
113 * accidentally repeat an info string when using HKDF for different purposes.)
114 */
115 int fscrypt_hkdf_expand(struct fscrypt_hkdf *hkdf, u8 context,
116 const u8 *info, unsigned int infolen,
117 u8 *okm, unsigned int okmlen)
118 {
119 SHASH_DESC_ON_STACK(desc, hkdf->hmac_tfm);
120 u8 prefix[9];
121 unsigned int i;
122 int err;
123 const u8 *prev = NULL;
124 u8 counter = 1;
125 u8 tmp[HKDF_HASHLEN];
126
127 if (WARN_ON(okmlen > 255 * HKDF_HASHLEN))
128 return -EINVAL;
129
130 desc->tfm = hkdf->hmac_tfm;
131
132 memcpy(prefix, "fscrypt\0", 8);
133 prefix[8] = context;
134
135 for (i = 0; i < okmlen; i += HKDF_HASHLEN) {
136
137 err = crypto_shash_init(desc);
138 if (err)
139 goto out;
140
141 if (prev) {
142 err = crypto_shash_update(desc, prev, HKDF_HASHLEN);
143 if (err)
144 goto out;
145 }
146
147 err = crypto_shash_update(desc, prefix, sizeof(prefix));
148 if (err)
149 goto out;
150
151 err = crypto_shash_update(desc, info, infolen);
152 if (err)
153 goto out;
154
155 BUILD_BUG_ON(sizeof(counter) != 1);
156 if (okmlen - i < HKDF_HASHLEN) {
157 err = crypto_shash_finup(desc, &counter, 1, tmp);
158 if (err)
159 goto out;
160 memcpy(&okm[i], tmp, okmlen - i);
161 memzero_explicit(tmp, sizeof(tmp));
162 } else {
163 err = crypto_shash_finup(desc, &counter, 1, &okm[i]);
164 if (err)
165 goto out;
166 }
167 counter++;
168 prev = &okm[i];
169 }
170 err = 0;
171 out:
172 if (unlikely(err))
173 memzero_explicit(okm, okmlen); /* so caller doesn't need to */
174 shash_desc_zero(desc);
175 return err;
176 }
177
178 void fscrypt_destroy_hkdf(struct fscrypt_hkdf *hkdf)
179 {
180 crypto_free_shash(hkdf->hmac_tfm);
181 }