fscrypt: allow 256-bit master keys with AES-256-XTS

[ 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>

diff --git a/Documentation/filesystems/fscrypt.rst b/Documentation/filesystems/fscrypt.rst
index 0eb799d9d05a2cdffa8bae08abe8e16bf0dc643f..7940a45d395229d2ea3c9320b1bd1ca8f3fa462e 100644 (file)
--- 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 3fa965eb3336dab7209ad30609eb5187b8b20706..cb25ef0cdf1f3be4a7439bed4329557bece3d579 100644 (file)
--- 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 e0ec2105550534c8cc188712d8826168898fbff3..7607d18b35fc0749ae7ed74b8a1d6970a24b4075 100644 (file)
--- 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 bca9c6658a7c5e918d36bfddb1758b4b7892d844..89cd533a88bff54f0c2f5ac4b978fd0b795e4063 100644 (file)
--- 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;
        }