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 */
 43static 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 */
 67int 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
 97err_free_tfm:
 98	crypto_free_shash(hmac_tfm);
 99out:
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 */
115int 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;
171out:
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
178void fscrypt_destroy_hkdf(struct fscrypt_hkdf *hkdf)
179{
180	crypto_free_shash(hkdf->hmac_tfm);
181}