From 40cfb8e68aa073f03c25bc33022a8dbb29fdc777 Mon Sep 17 00:00:00 2001

From: Eric Biggers <ebiggers@google.com>

Date: Mon, 20 Sep 2021 20:03:03 -0700

Subject: [PATCH] fscrypt: allow 256-bit master keys with AES-256-XTS

Git-commit: 7f595d6a6cdc336834552069a2e0a4f6d4756ddf

Patch-mainline: v5.16-rc1

References: stable-5.14.19

[ Upstream commit 7f595d6a6cdc336834552069a2e0a4f6d4756ddf ]

fscrypt currently requires a 512-bit master key when AES-256-XTS is

used, since AES-256-XTS keys are 512-bit and fscrypt requires that the

master key be at least as long any key that will be derived from it.

However, this is overly strict because AES-256-XTS doesn't actually have

a 512-bit security strength, but rather 256-bit.  The fact that XTS

takes twice the expected key size is a quirk of the XTS mode.  It is

sufficient to use 256 bits of entropy for AES-256-XTS, provided that it

is first properly expanded into a 512-bit key, which HKDF-SHA512 does.

Therefore, relax the check of the master key size to use the security

strength of the derived key rather than the size of the derived key

(except for v1 encryption policies, which don't use HKDF).

Besides making things more flexible for userspace, this is needed in

order for the use of a KDF which only takes a 256-bit key to be

introduced into the fscrypt key hierarchy.  This will happen with

hardware-wrapped keys support, as all known hardware which supports that

feature uses an SP800-108 KDF using AES-256-CMAC, so the wrapped keys

are wrapped 256-bit AES keys.  Moreover, there is interest in fscrypt

supporting the same type of AES-256-CMAC based KDF in software as an

alternative to HKDF-SHA512.  There is no security problem with such

features, so fix the key length check to work properly with them.

Reviewed-by: Paul Crowley <paulcrowley@google.com>

Link: https://lore.kernel.org/r/20210921030303.5598-1-ebiggers@kernel.org

Signed-off-by: Eric Biggers <ebiggers@google.com>

Signed-off-by: Sasha Levin <sashal@kernel.org>

Acked-by: Takashi Iwai <tiwai@suse.de>

---

 Documentation/filesystems/fscrypt.rst | 10 ++---

 fs/crypto/fscrypt_private.h           |  5 ++-

 fs/crypto/hkdf.c                      | 11 ++++--

 fs/crypto/keysetup.c                  | 57 +++++++++++++++++++++------

 4 files changed, 61 insertions(+), 22 deletions(-)

diff --git a/Documentation/filesystems/fscrypt.rst b/Documentation/filesystems/fscrypt.rst

index 44b67ebd6e40..936fae06db77 100644

--- a/Documentation/filesystems/fscrypt.rst

+++ b/Documentation/filesystems/fscrypt.rst

@@ -176,11 +176,11 @@ Master Keys

 Each encrypted directory tree is protected by a *master key*.  Master

 keys can be up to 64 bytes long, and must be at least as long as the

-greater of the key length needed by the contents and filenames

-encryption modes being used.  For example, if AES-256-XTS is used for

-contents encryption, the master key must be 64 bytes (512 bits).  Note

-that the XTS mode is defined to require a key twice as long as that

-required by the underlying block cipher.

+greater of the security strength of the contents and filenames

+encryption modes being used.  For example, if any AES-256 mode is

+used, the master key must be at least 256 bits, i.e. 32 bytes.  A

+stricter requirement applies if the key is used by a v1 encryption

+policy and AES-256-XTS is used; such keys must be 64 bytes.

 To "unlock" an encrypted directory tree, userspace must provide the

 appropriate master key.  There can be any number of master keys, each

diff --git a/fs/crypto/fscrypt_private.h b/fs/crypto/fscrypt_private.h

index 3fa965eb3336..cb25ef0cdf1f 100644

--- a/fs/crypto/fscrypt_private.h

+++ b/fs/crypto/fscrypt_private.h

@@ -549,8 +549,9 @@ int __init fscrypt_init_keyring(void);

 struct fscrypt_mode {

 	const char *friendly_name;

 	const char *cipher_str;

-	int keysize;

-	int ivsize;

+	int keysize;		/* key size in bytes */

+	int security_strength;	/* security strength in bytes */

+	int ivsize;		/* IV size in bytes */

 	int logged_impl_name;

 	enum blk_crypto_mode_num blk_crypto_mode;

 };

diff --git a/fs/crypto/hkdf.c b/fs/crypto/hkdf.c

index e0ec21055505..7607d18b35fc 100644

--- a/fs/crypto/hkdf.c

+++ b/fs/crypto/hkdf.c

@@ -16,9 +16,14 @@

 /*

  * HKDF supports any unkeyed cryptographic hash algorithm, but fscrypt uses

- * SHA-512 because it is reasonably secure and efficient; and since it produces

- * a 64-byte digest, deriving an AES-256-XTS key preserves all 64 bytes of

- * entropy from the master key and requires only one iteration of HKDF-Expand.

+ * SHA-512 because it is well-established, secure, and reasonably efficient.

+ *

+ * HKDF-SHA256 was also considered, as its 256-bit security strength would be

+ * sufficient here.  A 512-bit security strength is "nice to have", though.

+ * Also, on 64-bit CPUs, SHA-512 is usually just as fast as SHA-256.  In the

+ * common case of deriving an AES-256-XTS key (512 bits), that can result in

+ * HKDF-SHA512 being much faster than HKDF-SHA256, as the longer digest size of

+ * SHA-512 causes HKDF-Expand to only need to do one iteration rather than two.

  */

 #define HKDF_HMAC_ALG		"hmac(sha512)"

 #define HKDF_HASHLEN		SHA512_DIGEST_SIZE

diff --git a/fs/crypto/keysetup.c b/fs/crypto/keysetup.c

index bca9c6658a7c..89cd533a88bf 100644

--- a/fs/crypto/keysetup.c

+++ b/fs/crypto/keysetup.c

@@ -19,6 +19,7 @@ struct fscrypt_mode fscrypt_modes[] = {

 		.friendly_name = "AES-256-XTS",

 		.cipher_str = "xts(aes)",

 		.keysize = 64,

+		.security_strength = 32,

 		.ivsize = 16,

 		.blk_crypto_mode = BLK_ENCRYPTION_MODE_AES_256_XTS,

 	},

@@ -26,12 +27,14 @@ struct fscrypt_mode fscrypt_modes[] = {

 		.friendly_name = "AES-256-CTS-CBC",

 		.cipher_str = "cts(cbc(aes))",

 		.keysize = 32,

+		.security_strength = 32,

 		.ivsize = 16,

 	},

 	[FSCRYPT_MODE_AES_128_CBC] = {

 		.friendly_name = "AES-128-CBC-ESSIV",

 		.cipher_str = "essiv(cbc(aes),sha256)",

 		.keysize = 16,

+		.security_strength = 16,

 		.ivsize = 16,

 		.blk_crypto_mode = BLK_ENCRYPTION_MODE_AES_128_CBC_ESSIV,

 	},

@@ -39,12 +42,14 @@ struct fscrypt_mode fscrypt_modes[] = {

 		.friendly_name = "AES-128-CTS-CBC",

 		.cipher_str = "cts(cbc(aes))",

 		.keysize = 16,

+		.security_strength = 16,

 		.ivsize = 16,

 	},

 	[FSCRYPT_MODE_ADIANTUM] = {

 		.friendly_name = "Adiantum",

 		.cipher_str = "adiantum(xchacha12,aes)",

 		.keysize = 32,

+		.security_strength = 32,

 		.ivsize = 32,

 		.blk_crypto_mode = BLK_ENCRYPTION_MODE_ADIANTUM,

 	},

@@ -357,6 +362,45 @@ static int fscrypt_setup_v2_file_key(struct fscrypt_info *ci,

 	return 0;

 }

+/*

+ * Check whether the size of the given master key (@mk) is appropriate for the

+ * encryption settings which a particular file will use (@ci).

+ *

+ * If the file uses a v1 encryption policy, then the master key must be at least

+ * as long as the derived key, as this is a requirement of the v1 KDF.

+ *

+ * Otherwise, the KDF can accept any size key, so we enforce a slightly looser

+ * requirement: we require that the size of the master key be at least the

+ * maximum security strength of any algorithm whose key will be derived from it

+ * (but in practice we only need to consider @ci->ci_mode, since any other

+ * possible subkeys such as DIRHASH and INODE_HASH will never increase the

+ * required key size over @ci->ci_mode).  This allows AES-256-XTS keys to be

+ * derived from a 256-bit master key, which is cryptographically sufficient,

+ * rather than requiring a 512-bit master key which is unnecessarily long.  (We

+ * still allow 512-bit master keys if the user chooses to use them, though.)

+ */

+static bool fscrypt_valid_master_key_size(const struct fscrypt_master_key *mk,

+					  const struct fscrypt_info *ci)

+{

+	unsigned int min_keysize;

+

+	if (ci->ci_policy.version == FSCRYPT_POLICY_V1)

+		min_keysize = ci->ci_mode->keysize;

+	else

+		min_keysize = ci->ci_mode->security_strength;

+

+	if (mk->mk_secret.size < min_keysize) {

+		fscrypt_warn(NULL,

+			     "key with %s %*phN is too short (got %u bytes, need %u+ bytes)",

+			     master_key_spec_type(&mk->mk_spec),

+			     master_key_spec_len(&mk->mk_spec),

+			     (u8 *)&mk->mk_spec.u,

+			     mk->mk_secret.size, min_keysize);

+		return false;

+	}

+	return true;

+}

+

 /*

  * Find the master key, then set up the inode's actual encryption key.

  *

@@ -422,18 +466,7 @@ static int setup_file_encryption_key(struct fscrypt_info *ci,

 		goto out_release_key;

 	}

-	/*

-	 * Require that the master key be at least as long as the derived key.

-	 * Otherwise, the derived key cannot possibly contain as much entropy as

-	 * that required by the encryption mode it will be used for.  For v1

-	 * policies it's also required for the KDF to work at all.

-	 */

-	if (mk->mk_secret.size < ci->ci_mode->keysize) {

-		fscrypt_warn(NULL,

-			     "key with %s %*phN is too short (got %u bytes, need %u+ bytes)",

-			     master_key_spec_type(&mk_spec),

-			     master_key_spec_len(&mk_spec), (u8 *)&mk_spec.u,

-			     mk->mk_secret.size, ci->ci_mode->keysize);

+	if (!fscrypt_valid_master_key_size(mk, ci)) {

 		err = -ENOKEY;

 		goto out_release_key;

 	}

-- 

2.26.2