ecryptfs: Use MD5 library instead of crypto_shash

eCryptfs uses MD5 for a couple unusual purposes: to "mix" the key into
the IVs for file contents encryption (similar to ESSIV), and to prepend
some key-dependent bytes to the plaintext when encrypting filenames
(which is useless since eCryptfs encrypts the filenames with ECB).

Currently, eCryptfs computes these MD5 hashes using the crypto_shash
API.  Update it to instead use the MD5 library API.  This is simpler and
faster: the library doesn't require memory allocations, can't fail, and
provides direct access to MD5 without overhead such as indirect calls.

To preserve the existing behavior of eCryptfs support being disabled
when the kernel is booted with "fips=1", make ecryptfs_get_tree() check
fips_enabled itself.  Previously it relied on crypto_alloc_shash("md5")
failing.  I don't know for sure that this is actually needed; e.g., it
could be argued that eCryptfs's use of MD5 isn't for a security purpose
as far as FIPS is concerned.  But this preserves the existing behavior.

Tested by verifying that an existing eCryptfs can still be mounted with
a kernel that has this commit, with all the files matching.  Also tested
creating a filesystem with this commit and mounting+reading it without.

Signed-off-by: Eric Biggers <ebiggers@kernel.org>
Link: https://patch.msgid.link/20251011200010.193140-1-ebiggers@kernel.org
Acked-by: Ard Biesheuvel <ardb@kernel.org>
Signed-off-by: Christian Brauner <brauner@kernel.org>

diff --git a/fs/ecryptfs/Kconfig b/fs/ecryptfs/Kconfig
index 1bdeaa6d57900cccab5aa099766f791033243c74..c2f4fb41b4e6aa586acd705abe5b77f30c782510 100644 (file)
--- a/fs/ecryptfs/Kconfig
+++ b/fs/ecryptfs/Kconfig
@@ -4,7 +4,7 @@ config ECRYPT_FS
        depends on KEYS && CRYPTO && (ENCRYPTED_KEYS || ENCRYPTED_KEYS=n)
        select CRYPTO_ECB
        select CRYPTO_CBC
-       select CRYPTO_MD5
+       select CRYPTO_LIB_MD5
        help
          Encrypted filesystem that operates on the VFS layer.  See
          <file:Documentation/filesystems/ecryptfs.rst> to learn more about

diff --git a/fs/ecryptfs/crypto.c b/fs/ecryptfs/crypto.c
index 69536cacdea8d1d0daff715480c7bbb98aa787f8..260f8a4938b01981b9b6cb773051d4bfe19d86bf 100644 (file)
--- a/fs/ecryptfs/crypto.c
+++ b/fs/ecryptfs/crypto.c
@@ -9,7 +9,6 @@
  *             Michael C. Thompson <mcthomps@us.ibm.com>
  */
 
-#include <crypto/hash.h>
 #include <crypto/skcipher.h>
 #include <linux/fs.h>
 #include <linux/mount.h>
@@ -48,32 +47,6 @@ void ecryptfs_from_hex(char *dst, char *src, int dst_size)
        }
 }
 
-/**
- * ecryptfs_calculate_md5 - calculates the md5 of @src
- * @dst: Pointer to 16 bytes of allocated memory
- * @crypt_stat: Pointer to crypt_stat struct for the current inode
- * @src: Data to be md5'd
- * @len: Length of @src
- *
- * Uses the allocated crypto context that crypt_stat references to
- * generate the MD5 sum of the contents of src.
- */
-static int ecryptfs_calculate_md5(char *dst,
-                                 struct ecryptfs_crypt_stat *crypt_stat,
-                                 char *src, int len)
-{
-       int rc = crypto_shash_tfm_digest(crypt_stat->hash_tfm, src, len, dst);
-
-       if (rc) {
-               printk(KERN_ERR
-                      "%s: Error computing crypto hash; rc = [%d]\n",
-                      __func__, rc);
-               goto out;
-       }
-out:
-       return rc;
-}
-
 static int ecryptfs_crypto_api_algify_cipher_name(char **algified_name,
                                                  char *cipher_name,
                                                  char *chaining_modifier)
@@ -104,13 +77,10 @@ out:
  *
  * Generate the initialization vector from the given root IV and page
  * offset.
- *
- * Returns zero on success; non-zero on error.
  */
-int ecryptfs_derive_iv(char *iv, struct ecryptfs_crypt_stat *crypt_stat,
-                      loff_t offset)
+void ecryptfs_derive_iv(char *iv, struct ecryptfs_crypt_stat *crypt_stat,
+                       loff_t offset)
 {
-       int rc = 0;
        char dst[MD5_DIGEST_SIZE];
        char src[ECRYPTFS_MAX_IV_BYTES + 16];
 
@@ -129,20 +99,12 @@ int ecryptfs_derive_iv(char *iv, struct ecryptfs_crypt_stat *crypt_stat,
                ecryptfs_printk(KERN_DEBUG, "source:\n");
                ecryptfs_dump_hex(src, (crypt_stat->iv_bytes + 16));
        }
-       rc = ecryptfs_calculate_md5(dst, crypt_stat, src,
-                                   (crypt_stat->iv_bytes + 16));
-       if (rc) {
-               ecryptfs_printk(KERN_WARNING, "Error attempting to compute "
-                               "MD5 while generating IV for a page\n");
-               goto out;
-       }
+       md5(src, crypt_stat->iv_bytes + 16, dst);
        memcpy(iv, dst, crypt_stat->iv_bytes);
        if (unlikely(ecryptfs_verbosity > 0)) {
                ecryptfs_printk(KERN_DEBUG, "derived iv:\n");
                ecryptfs_dump_hex(iv, crypt_stat->iv_bytes);
        }
-out:
-       return rc;
 }
 
 /**
@@ -151,29 +113,14 @@ out:
  *
  * Initialize the crypt_stat structure.
  */
-int ecryptfs_init_crypt_stat(struct ecryptfs_crypt_stat *crypt_stat)
+void ecryptfs_init_crypt_stat(struct ecryptfs_crypt_stat *crypt_stat)
 {
-       struct crypto_shash *tfm;
-       int rc;
-
-       tfm = crypto_alloc_shash(ECRYPTFS_DEFAULT_HASH, 0, 0);
-       if (IS_ERR(tfm)) {
-               rc = PTR_ERR(tfm);
-               ecryptfs_printk(KERN_ERR, "Error attempting to "
-                               "allocate crypto context; rc = [%d]\n",
-                               rc);
-               return rc;
-       }
-
        memset((void *)crypt_stat, 0, sizeof(struct ecryptfs_crypt_stat));
        INIT_LIST_HEAD(&crypt_stat->keysig_list);
        mutex_init(&crypt_stat->keysig_list_mutex);
        mutex_init(&crypt_stat->cs_mutex);
        mutex_init(&crypt_stat->cs_tfm_mutex);
-       crypt_stat->hash_tfm = tfm;
        crypt_stat->flags |= ECRYPTFS_STRUCT_INITIALIZED;
-
-       return 0;
 }
 
 /**
@@ -187,7 +134,6 @@ void ecryptfs_destroy_crypt_stat(struct ecryptfs_crypt_stat *crypt_stat)
        struct ecryptfs_key_sig *key_sig, *key_sig_tmp;
 
        crypto_free_skcipher(crypt_stat->tfm);
-       crypto_free_shash(crypt_stat->hash_tfm);
        list_for_each_entry_safe(key_sig, key_sig_tmp,
                                 &crypt_stat->keysig_list, crypt_stat_list) {
                list_del(&key_sig->crypt_stat_list);
@@ -361,14 +307,7 @@ static int crypt_extent(struct ecryptfs_crypt_stat *crypt_stat,
        int rc;
 
        extent_base = (((loff_t)page_index) * (PAGE_SIZE / extent_size));
-       rc = ecryptfs_derive_iv(extent_iv, crypt_stat,
-                               (extent_base + extent_offset));
-       if (rc) {
-               ecryptfs_printk(KERN_ERR, "Error attempting to derive IV for "
-                       "extent [0x%.16llx]; rc = [%d]\n",
-                       (unsigned long long)(extent_base + extent_offset), rc);
-               goto out;
-       }
+       ecryptfs_derive_iv(extent_iv, crypt_stat, extent_base + extent_offset);
 
        sg_init_table(&src_sg, 1);
        sg_init_table(&dst_sg, 1);
@@ -609,31 +548,20 @@ void ecryptfs_set_default_sizes(struct ecryptfs_crypt_stat *crypt_stat)
  */
 int ecryptfs_compute_root_iv(struct ecryptfs_crypt_stat *crypt_stat)
 {
-       int rc = 0;
        char dst[MD5_DIGEST_SIZE];
 
        BUG_ON(crypt_stat->iv_bytes > MD5_DIGEST_SIZE);
        BUG_ON(crypt_stat->iv_bytes <= 0);
        if (!(crypt_stat->flags & ECRYPTFS_KEY_VALID)) {
-               rc = -EINVAL;
                ecryptfs_printk(KERN_WARNING, "Session key not valid; "
                                "cannot generate root IV\n");
-               goto out;
-       }
-       rc = ecryptfs_calculate_md5(dst, crypt_stat, crypt_stat->key,
-                                   crypt_stat->key_size);
-       if (rc) {
-               ecryptfs_printk(KERN_WARNING, "Error attempting to compute "
-                               "MD5 while generating root IV\n");
-               goto out;
-       }
-       memcpy(crypt_stat->root_iv, dst, crypt_stat->iv_bytes);
-out:
-       if (rc) {
                memset(crypt_stat->root_iv, 0, crypt_stat->iv_bytes);
                crypt_stat->flags |= ECRYPTFS_SECURITY_WARNING;
+               return -EINVAL;
        }
-       return rc;
+       md5(crypt_stat->key, crypt_stat->key_size, dst);
+       memcpy(crypt_stat->root_iv, dst, crypt_stat->iv_bytes);
+       return 0;
 }
 
 static void ecryptfs_generate_new_key(struct ecryptfs_crypt_stat *crypt_stat)

diff --git a/fs/ecryptfs/ecryptfs_kernel.h b/fs/ecryptfs/ecryptfs_kernel.h
index 9e6ab0b41337647544baf060d5885733fe20d92a..62a2ea7f59eda366dd4f39096be01c213404822b 100644 (file)
--- a/fs/ecryptfs/ecryptfs_kernel.h
+++ b/fs/ecryptfs/ecryptfs_kernel.h
@@ -14,6 +14,7 @@
 #ifndef ECRYPTFS_KERNEL_H
 #define ECRYPTFS_KERNEL_H
 
+#include <crypto/md5.h>
 #include <crypto/skcipher.h>
 #include <keys/user-type.h>
 #include <keys/encrypted-type.h>
@@ -137,8 +138,6 @@ ecryptfs_get_key_payload_data(struct key *key)
                                        + MAGIC_ECRYPTFS_MARKER_SIZE_BYTES)
 #define ECRYPTFS_DEFAULT_CIPHER "aes"
 #define ECRYPTFS_DEFAULT_KEY_BYTES 16
-#define ECRYPTFS_DEFAULT_HASH "md5"
-#define ECRYPTFS_TAG_70_DIGEST ECRYPTFS_DEFAULT_HASH
 #define ECRYPTFS_TAG_1_PACKET_TYPE 0x01
 #define ECRYPTFS_TAG_3_PACKET_TYPE 0x8C
 #define ECRYPTFS_TAG_11_PACKET_TYPE 0xED
@@ -163,8 +162,6 @@ ecryptfs_get_key_payload_data(struct key *key)
  * ECRYPTFS_MAX_IV_BYTES */
 #define ECRYPTFS_FILENAME_MIN_RANDOM_PREPEND_BYTES 16
 #define ECRYPTFS_NON_NULL 0x42 /* A reasonable substitute for NULL */
-#define MD5_DIGEST_SIZE 16
-#define ECRYPTFS_TAG_70_DIGEST_SIZE MD5_DIGEST_SIZE
 #define ECRYPTFS_TAG_70_MIN_METADATA_SIZE (1 + ECRYPTFS_MIN_PKT_LEN_SIZE \
                                           + ECRYPTFS_SIG_SIZE + 1 + 1)
 #define ECRYPTFS_TAG_70_MAX_METADATA_SIZE (1 + ECRYPTFS_MAX_PKT_LEN_SIZE \
@@ -237,8 +234,6 @@ struct ecryptfs_crypt_stat {
        unsigned int extent_mask;
        struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
        struct crypto_skcipher *tfm;
-       struct crypto_shash *hash_tfm; /* Crypto context for generating
-                                       * the initialization vectors */
        unsigned char cipher[ECRYPTFS_MAX_CIPHER_NAME_SIZE + 1];
        unsigned char key[ECRYPTFS_MAX_KEY_BYTES];
        unsigned char root_iv[ECRYPTFS_MAX_IV_BYTES];
@@ -558,7 +553,7 @@ int virt_to_scatterlist(const void *addr, int size, struct scatterlist *sg,
                        int sg_size);
 int ecryptfs_compute_root_iv(struct ecryptfs_crypt_stat *crypt_stat);
 void ecryptfs_rotate_iv(unsigned char *iv);
-int ecryptfs_init_crypt_stat(struct ecryptfs_crypt_stat *crypt_stat);
+void ecryptfs_init_crypt_stat(struct ecryptfs_crypt_stat *crypt_stat);
 void ecryptfs_destroy_crypt_stat(struct ecryptfs_crypt_stat *crypt_stat);
 void ecryptfs_destroy_mount_crypt_stat(
        struct ecryptfs_mount_crypt_stat *mount_crypt_stat);
@@ -693,8 +688,8 @@ ecryptfs_parse_tag_70_packet(char **filename, size_t *filename_size,
                             char *data, size_t max_packet_size);
 int ecryptfs_set_f_namelen(long *namelen, long lower_namelen,
                           struct ecryptfs_mount_crypt_stat *mount_crypt_stat);
-int ecryptfs_derive_iv(char *iv, struct ecryptfs_crypt_stat *crypt_stat,
-                      loff_t offset);
+void ecryptfs_derive_iv(char *iv, struct ecryptfs_crypt_stat *crypt_stat,
+                       loff_t offset);
 
 extern const struct xattr_handler * const ecryptfs_xattr_handlers[];
 

diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
index ed1394da8d6bd7065f2a074378331f13fcda17f9..bae9011fa62ffb0c1b0c8a5b83f19ab45fd5f83d 100644 (file)
--- a/fs/ecryptfs/inode.c
+++ b/fs/ecryptfs/inode.c
@@ -903,11 +903,8 @@ static int ecryptfs_setattr(struct mnt_idmap *idmap,
        struct ecryptfs_crypt_stat *crypt_stat;
 
        crypt_stat = &ecryptfs_inode_to_private(d_inode(dentry))->crypt_stat;
-       if (!(crypt_stat->flags & ECRYPTFS_STRUCT_INITIALIZED)) {
-               rc = ecryptfs_init_crypt_stat(crypt_stat);
-               if (rc)
-                       return rc;
-       }
+       if (!(crypt_stat->flags & ECRYPTFS_STRUCT_INITIALIZED))
+               ecryptfs_init_crypt_stat(crypt_stat);
        inode = d_inode(dentry);
        lower_inode = ecryptfs_inode_to_lower(inode);
        lower_dentry = ecryptfs_dentry_to_lower(dentry);

diff --git a/fs/ecryptfs/keystore.c b/fs/ecryptfs/keystore.c
index 7f9f68c00ef63c76a3353ba354406cba6d4c0682..bbf8603242fa01a6d2b786bda70e6dc15e857142 100644 (file)
--- a/fs/ecryptfs/keystore.c
+++ b/fs/ecryptfs/keystore.c
@@ -11,7 +11,6 @@
  *              Trevor S. Highland <trevor.highland@gmail.com>
  */
 
-#include <crypto/hash.h>
 #include <crypto/skcipher.h>
 #include <linux/string.h>
 #include <linux/pagemap.h>
@@ -601,10 +600,7 @@ struct ecryptfs_write_tag_70_packet_silly_stack {
        struct crypto_skcipher *skcipher_tfm;
        struct skcipher_request *skcipher_req;
        char iv[ECRYPTFS_MAX_IV_BYTES];
-       char hash[ECRYPTFS_TAG_70_DIGEST_SIZE];
-       char tmp_hash[ECRYPTFS_TAG_70_DIGEST_SIZE];
-       struct crypto_shash *hash_tfm;
-       struct shash_desc *hash_desc;
+       char hash[MD5_DIGEST_SIZE];
 };
 
 /*
@@ -741,51 +737,15 @@ ecryptfs_write_tag_70_packet(char *dest, size_t *remaining_bytes,
                       "password tokens\n", __func__);
                goto out_free_unlock;
        }
-       s->hash_tfm = crypto_alloc_shash(ECRYPTFS_TAG_70_DIGEST, 0, 0);
-       if (IS_ERR(s->hash_tfm)) {
-                       rc = PTR_ERR(s->hash_tfm);
-                       printk(KERN_ERR "%s: Error attempting to "
-                              "allocate hash crypto context; rc = [%d]\n",
-                              __func__, rc);
-                       goto out_free_unlock;
-       }
-
-       s->hash_desc = kmalloc(sizeof(*s->hash_desc) +
-                              crypto_shash_descsize(s->hash_tfm), GFP_KERNEL);
-       if (!s->hash_desc) {
-               rc = -ENOMEM;
-               goto out_release_free_unlock;
-       }
 
-       s->hash_desc->tfm = s->hash_tfm;
-
-       rc = crypto_shash_digest(s->hash_desc,
-                                (u8 *)s->auth_tok->token.password.session_key_encryption_key,
-                                s->auth_tok->token.password.session_key_encryption_key_bytes,
-                                s->hash);
-       if (rc) {
-               printk(KERN_ERR
-                      "%s: Error computing crypto hash; rc = [%d]\n",
-                      __func__, rc);
-               goto out_release_free_unlock;
-       }
+       md5(s->auth_tok->token.password.session_key_encryption_key,
+           s->auth_tok->token.password.session_key_encryption_key_bytes,
+           s->hash);
        for (s->j = 0; s->j < (s->num_rand_bytes - 1); s->j++) {
                s->block_aligned_filename[s->j] =
-                       s->hash[(s->j % ECRYPTFS_TAG_70_DIGEST_SIZE)];
-               if ((s->j % ECRYPTFS_TAG_70_DIGEST_SIZE)
-                   == (ECRYPTFS_TAG_70_DIGEST_SIZE - 1)) {
-                       rc = crypto_shash_digest(s->hash_desc, (u8 *)s->hash,
-                                               ECRYPTFS_TAG_70_DIGEST_SIZE,
-                                               s->tmp_hash);
-                       if (rc) {
-                               printk(KERN_ERR
-                                      "%s: Error computing crypto hash; "
-                                      "rc = [%d]\n", __func__, rc);
-                               goto out_release_free_unlock;
-                       }
-                       memcpy(s->hash, s->tmp_hash,
-                              ECRYPTFS_TAG_70_DIGEST_SIZE);
-               }
+                       s->hash[s->j % MD5_DIGEST_SIZE];
+               if ((s->j % MD5_DIGEST_SIZE) == (MD5_DIGEST_SIZE - 1))
+                       md5(s->hash, MD5_DIGEST_SIZE, s->hash);
                if (s->block_aligned_filename[s->j] == '\0')
                        s->block_aligned_filename[s->j] = ECRYPTFS_NON_NULL;
        }
@@ -798,7 +758,7 @@ ecryptfs_write_tag_70_packet(char *dest, size_t *remaining_bytes,
                       "convert filename memory to scatterlist; rc = [%d]. "
                       "block_aligned_filename_size = [%zd]\n", __func__, rc,
                       s->block_aligned_filename_size);
-               goto out_release_free_unlock;
+               goto out_free_unlock;
        }
        rc = virt_to_scatterlist(&dest[s->i], s->block_aligned_filename_size,
                                 s->dst_sg, 2);
@@ -807,7 +767,7 @@ ecryptfs_write_tag_70_packet(char *dest, size_t *remaining_bytes,
                       "convert encrypted filename memory to scatterlist; "
                       "rc = [%d]. block_aligned_filename_size = [%zd]\n",
                       __func__, rc, s->block_aligned_filename_size);
-               goto out_release_free_unlock;
+               goto out_free_unlock;
        }
        /* The characters in the first block effectively do the job
         * of the IV here, so we just use 0's for the IV. Note the
@@ -825,7 +785,7 @@ ecryptfs_write_tag_70_packet(char *dest, size_t *remaining_bytes,
                       rc,
                       s->auth_tok->token.password.session_key_encryption_key,
                       mount_crypt_stat->global_default_fn_cipher_key_bytes);
-               goto out_release_free_unlock;
+               goto out_free_unlock;
        }
        skcipher_request_set_crypt(s->skcipher_req, s->src_sg, s->dst_sg,
                                   s->block_aligned_filename_size, s->iv);
@@ -833,13 +793,11 @@ ecryptfs_write_tag_70_packet(char *dest, size_t *remaining_bytes,
        if (rc) {
                printk(KERN_ERR "%s: Error attempting to encrypt filename; "
                       "rc = [%d]\n", __func__, rc);
-               goto out_release_free_unlock;
+               goto out_free_unlock;
        }
        s->i += s->block_aligned_filename_size;
        (*packet_size) = s->i;
        (*remaining_bytes) -= (*packet_size);
-out_release_free_unlock:
-       crypto_free_shash(s->hash_tfm);
 out_free_unlock:
        kfree_sensitive(s->block_aligned_filename);
 out_unlock:
@@ -850,7 +808,6 @@ out:
                key_put(auth_tok_key);
        }
        skcipher_request_free(s->skcipher_req);
-       kfree_sensitive(s->hash_desc);
        kfree(s);
        return rc;
 }

diff --git a/fs/ecryptfs/main.c b/fs/ecryptfs/main.c
index 16ea14dd2c62e73264ab3c82649dde98149d63ef..c12dc680f8fe21105c9adb86e4d805aab029ebad 100644 (file)
--- a/fs/ecryptfs/main.c
+++ b/fs/ecryptfs/main.c
@@ -12,6 +12,7 @@
 
 #include <linux/dcache.h>
 #include <linux/file.h>
+#include <linux/fips.h>
 #include <linux/module.h>
 #include <linux/namei.h>
 #include <linux/skbuff.h>
@@ -454,6 +455,12 @@ static int ecryptfs_get_tree(struct fs_context *fc)
                goto out;
        }
 
+       if (fips_enabled) {
+               rc = -EINVAL;
+               err = "eCryptfs support is disabled due to FIPS";
+               goto out;
+       }
+
        s = sget_fc(fc, NULL, set_anon_super_fc);
        if (IS_ERR(s)) {
                rc = PTR_ERR(s);

diff --git a/fs/ecryptfs/super.c b/fs/ecryptfs/super.c
index e7b7f426fecfbcd5c249e499f06bd1ec791aa4ef..3bc21d677564d1babf516a34daf7f91a20473194 100644 (file)
--- a/fs/ecryptfs/super.c
+++ b/fs/ecryptfs/super.c
@@ -41,10 +41,7 @@ static struct inode *ecryptfs_alloc_inode(struct super_block *sb)
        inode_info = alloc_inode_sb(sb, ecryptfs_inode_info_cache, GFP_KERNEL);
        if (unlikely(!inode_info))
                goto out;
-       if (ecryptfs_init_crypt_stat(&inode_info->crypt_stat)) {
-               kmem_cache_free(ecryptfs_inode_info_cache, inode_info);
-               goto out;
-       }
+       ecryptfs_init_crypt_stat(&inode_info->crypt_stat);
        mutex_init(&inode_info->lower_file_mutex);
        atomic_set(&inode_info->lower_file_count, 0);
        inode_info->lower_file = NULL;