Linux 6.9-rc1
[linux-2.6-microblaze.git] / fs / crypto / hkdf.c
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/sha2.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         int err;
48
49         err = crypto_shash_setkey(hmac_tfm, default_salt, HKDF_HASHLEN);
50         if (err)
51                 return err;
52
53         return crypto_shash_tfm_digest(hmac_tfm, ikm, ikmlen, prk);
54 }
55
56 /*
57  * Compute HKDF-Extract using the given master key as the input keying material,
58  * and prepare an HMAC transform object keyed by the resulting pseudorandom key.
59  *
60  * Afterwards, the keyed HMAC transform object can be used for HKDF-Expand many
61  * times without having to recompute HKDF-Extract each time.
62  */
63 int fscrypt_init_hkdf(struct fscrypt_hkdf *hkdf, const u8 *master_key,
64                       unsigned int master_key_size)
65 {
66         struct crypto_shash *hmac_tfm;
67         u8 prk[HKDF_HASHLEN];
68         int err;
69
70         hmac_tfm = crypto_alloc_shash(HKDF_HMAC_ALG, 0, 0);
71         if (IS_ERR(hmac_tfm)) {
72                 fscrypt_err(NULL, "Error allocating " HKDF_HMAC_ALG ": %ld",
73                             PTR_ERR(hmac_tfm));
74                 return PTR_ERR(hmac_tfm);
75         }
76
77         if (WARN_ON(crypto_shash_digestsize(hmac_tfm) != sizeof(prk))) {
78                 err = -EINVAL;
79                 goto err_free_tfm;
80         }
81
82         err = hkdf_extract(hmac_tfm, master_key, master_key_size, prk);
83         if (err)
84                 goto err_free_tfm;
85
86         err = crypto_shash_setkey(hmac_tfm, prk, sizeof(prk));
87         if (err)
88                 goto err_free_tfm;
89
90         hkdf->hmac_tfm = hmac_tfm;
91         goto out;
92
93 err_free_tfm:
94         crypto_free_shash(hmac_tfm);
95 out:
96         memzero_explicit(prk, sizeof(prk));
97         return err;
98 }
99
100 /*
101  * HKDF-Expand (RFC 5869 section 2.3).  This expands the pseudorandom key, which
102  * was already keyed into 'hkdf->hmac_tfm' by fscrypt_init_hkdf(), into 'okmlen'
103  * bytes of output keying material parameterized by the application-specific
104  * 'info' of length 'infolen' bytes, prefixed by "fscrypt\0" and the 'context'
105  * byte.  This is thread-safe and may be called by multiple threads in parallel.
106  *
107  * ('context' isn't part of the HKDF specification; it's just a prefix fscrypt
108  * adds to its application-specific info strings to guarantee that it doesn't
109  * accidentally repeat an info string when using HKDF for different purposes.)
110  */
111 int fscrypt_hkdf_expand(const struct fscrypt_hkdf *hkdf, u8 context,
112                         const u8 *info, unsigned int infolen,
113                         u8 *okm, unsigned int okmlen)
114 {
115         SHASH_DESC_ON_STACK(desc, hkdf->hmac_tfm);
116         u8 prefix[9];
117         unsigned int i;
118         int err;
119         const u8 *prev = NULL;
120         u8 counter = 1;
121         u8 tmp[HKDF_HASHLEN];
122
123         if (WARN_ON(okmlen > 255 * HKDF_HASHLEN))
124                 return -EINVAL;
125
126         desc->tfm = hkdf->hmac_tfm;
127
128         memcpy(prefix, "fscrypt\0", 8);
129         prefix[8] = context;
130
131         for (i = 0; i < okmlen; i += HKDF_HASHLEN) {
132
133                 err = crypto_shash_init(desc);
134                 if (err)
135                         goto out;
136
137                 if (prev) {
138                         err = crypto_shash_update(desc, prev, HKDF_HASHLEN);
139                         if (err)
140                                 goto out;
141                 }
142
143                 err = crypto_shash_update(desc, prefix, sizeof(prefix));
144                 if (err)
145                         goto out;
146
147                 err = crypto_shash_update(desc, info, infolen);
148                 if (err)
149                         goto out;
150
151                 BUILD_BUG_ON(sizeof(counter) != 1);
152                 if (okmlen - i < HKDF_HASHLEN) {
153                         err = crypto_shash_finup(desc, &counter, 1, tmp);
154                         if (err)
155                                 goto out;
156                         memcpy(&okm[i], tmp, okmlen - i);
157                         memzero_explicit(tmp, sizeof(tmp));
158                 } else {
159                         err = crypto_shash_finup(desc, &counter, 1, &okm[i]);
160                         if (err)
161                                 goto out;
162                 }
163                 counter++;
164                 prev = &okm[i];
165         }
166         err = 0;
167 out:
168         if (unlikely(err))
169                 memzero_explicit(okm, okmlen); /* so caller doesn't need to */
170         shash_desc_zero(desc);
171         return err;
172 }
173
174 void fscrypt_destroy_hkdf(struct fscrypt_hkdf *hkdf)
175 {
176         crypto_free_shash(hkdf->hmac_tfm);
177 }