Reconcile Encryption and Casefolding in Ext4
Subsystems (3)
v2 cover Reconcile Encryption and Casefolding in Ext4
These patches add support for ext4 encryption and casefolding at the same time. Since the hash for encrypted casefolded directory names cannot be computed without the key, we need to store the hash on disk. We only do so for encrypted and casefolded directories to avoid on disk format changes.
e2fsprogs has already been updated with support for casefolding and encryption.
v2 changes:
When checking for 'fake' entries (which do not include the extra hash bytes) -Check for . and .. using names instead of position
-Check for csum entries via file_type instead of position
-Assume last entry in directory will be csum for __ext4_check_entry if csum enabled
This means we don't need to pass along lblk all over the place
-Don't use siphash value for find_group_orlov, just use regular hash
Daniel Rosenberg (2):
ext4: Handle casefolding with encryption
ext4: Optimize match for casefolded encrypted dirs
Documentation/filesystems/ext4/directory.rst | 27 +++ fs/ext4/dir.c | 37 +++- fs/ext4/ext4.h | 73 +++++-- fs/ext4/hash.c | 25 ++- fs/ext4/inline.c | 25 ++- fs/ext4/namei.c | 213 ++++++++++++++----- fs/ext4/super.c | 6 - 7 files changed, 303 insertions(+), 103 deletions(-)
base-commit: f296bfd5cd04cbb49b8fc9585adc280ab2b58624
Signature · 1 line
2.31.0.rc2.261.g7f71774620-goog
PATCH v2 1/2 ext4: Handle casefolding with encryption
This adds support for encryption with casefolding.
Since the name on disk is case preserving, and also encrypted, we can no longer just recompute the hash on the fly. Additionally, to avoid leaking extra information from the hash of the unencrypted name, we use siphash via an fscrypt v2 policy.
The hash is stored at the end of the directory entry for all entries inside of an encrypted and casefolded directory apart from those that deal with '.' and '..'. This way, the change is backwards compatible with existing ext4 filesystems.
--- Documentation/filesystems/ext4/directory.rst | 27 +++ fs/ext4/dir.c | 37 +++- fs/ext4/ext4.h | 56 +++++- fs/ext4/hash.c | 25 ++- fs/ext4/inline.c | 25 ++- fs/ext4/namei.c | 198 ++++++++++++++----- fs/ext4/super.c | 6 - 7 files changed, 285 insertions(+), 89 deletions(-)
Documentation/filesystems/ext4/directory.rst +27 -0
@@ -121,6 +121,31 @@ The directory file type is one of the following values: * - 0x7 - Symbolic link. +To support directories that are both encrypted and casefolded directories, we +must also include hash information in the directory entry. We append +``ext4_extended_dir_entry_2`` to ``ext4_dir_entry_2`` except for the entries +for dot and dotdot, which are kept the same. The structure follows immediately +after ``name`` and is included in the size listed by ``rec_len`` If a directory +entry uses this extension, it may be up to 271 bytes. + +.. list-table:: + :widths: 8 8 24 40 + :header-rows: 1 + + * - Offset + - Size + - Name + - Description + * - 0x0 + - \_\_le32 + - hash + - The hash of the directory name + * - 0x4 + - \_\_le32 + - minor\_hash + - The minor hash of the directory name + + In order to add checksums to these classic directory blocks, a phony ``struct ext4_dir_entry`` is placed at the end of each leaf block to hold the checksum. The directory entry is 12 bytes long. The inode
@@ -322,6 +347,8 @@ The directory hash is one of the following values: - Half MD4, unsigned. * - 0x5 - Tea, unsigned. + * - 0x6 + - Siphash. Interior nodes of an htree are recorded as ``struct dx_node``, which is also the full length of a data block:
fs/ext4/dir.c +28 -9
@@ -55,6 +55,18 @@ static int is_dx_dir(struct inode *inode)return 0 ; } +static bool is_fake_dir_entry (struct ext4_dir_entry_2 *de) +{ +/* Check if . or .. , or skip if namelen is 0 */ +if ((de->name_len >0 ) && (de->name_len <=2 ) && (de->name[0 ] =='.' ) && + (de->name[1 ] =='.' || de->name[1 ] =='\0' )) +return true; +/* Check if this is a csum entry */ +if (de->file_type ==EXT4_FT_DIR_CSUM ) +return true; +return false; +} +/* * Return 0 if the directory entry is OK, and 1 if there is a problem *
@@ -73,16 +85,20 @@ int __ext4_check_dir_entry(const char *function, unsigned int line,const int rlen =ext4_rec_len_from_disk (de->rec_len, dir->i_sb->s_blocksize);const int next_offset = ((char *) de - buf) + rlen; +bool fake =is_fake_dir_entry (de); +bool has_csum =ext4_has_metadata_csum (dir->i_sb); -if (unlikely (rlen <EXT4_DIR_REC_LEN (1 ))) +if (unlikely (rlen <ext4_dir_rec_len (1 , fake ?NULL : dir))) error_msg ="rec_len is smaller than minimal" ;else if (unlikely (rlen %4 !=0 )) error_msg ="rec_len % 4 != 0" ; -else if (unlikely (rlen <EXT4_DIR_REC_LEN (de->name_len))) +else if (unlikely (rlen <ext4_dir_rec_len (de->name_len, + fake ?NULL : dir))) error_msg ="rec_len is too small for name_len" ;else if (unlikely (next_offset > size)) error_msg ="directory entry overrun" ; -else if (unlikely (next_offset > size -EXT4_DIR_REC_LEN (1 ) && +else if (unlikely (next_offset > size -ext4_dir_rec_len (1 , + has_csum ?NULL : dir) && next_offset != size)) error_msg ="directory entry too close to block end" ; else if (unlikely(le32_to_cpu(de->inode) >
@@ -94,15 +110,15 @@ int __ext4_check_dir_entry(const char *function, unsigned int line,if (filp)ext4_error_file (filp, function, line, bh->b_blocknr,"bad entry in directory: %s - offset=%u, " -"inode=%u, rec_len=%d, name_len=%d, size=%d" , +"inode=%u, rec_len=%d, size=%d fake=%d" , error_msg, offset,le32_to_cpu (de->inode), - rlen, de->name_len, size); + rlen, size, fake);else ext4_error_inode (dir, function, line, bh->b_blocknr,"bad entry in directory: %s - offset=%u, " -"inode=%u, rec_len=%d, name_len=%d, size=%d" , +"inode=%u, rec_len=%d, size=%d fake=%d" , error_msg, offset,le32_to_cpu (de->inode), - rlen, de->name_len, size); + rlen, size, fake);return 1 ; }
@@ -224,7 +240,8 @@ static int ext4_readdir(struct file *file, struct dir_context *ctx)* failure will be detected in the * dirent test below. */ if (ext4_rec_len_from_disk (de->rec_len, - sb->s_blocksize) <EXT4_DIR_REC_LEN (1 )) + sb->s_blocksize) <ext4_dir_rec_len (1 , + inode))break ; i +=ext4_rec_len_from_disk (de->rec_len, sb->s_blocksize);
@@ -265,7 +282,9 @@ static int ext4_readdir(struct file *file, struct dir_context *ctx)/* Directory is encrypted */ err =fscrypt_fname_disk_to_usr (inode, -0 ,0 , &de_name, &fstr); +EXT4_DIRENT_HASH (de), +EXT4_DIRENT_MINOR_HASH (de), + &de_name, &fstr); de_name = fstr; fstr.len = save_len;if (err)
fs/ext4/ext4.h +48 -8
107 lines not on this page · raw message
fs/ext4/hash.c +21 -4
@@ -197,7 +197,7 @@ static void str2hashbuf_unsigned(const char *msg, int len, __u32 *buf, int num)* represented, and whether or not the returned hash is 32 bits or 64 * bits. 32 bit hashes will return 0 for the minor hash. */ -static int __ext4fs_dirhash (const char *name,int len, +static int __ext4fs_dirhash (const struct inode *dir,const char *name,int len,struct dx_hash_info *hinfo) {__u32 hash;
@@ -259,6 +259,22 @@ static int __ext4fs_dirhash(const char *name, int len, hash = buf[0 ]; minor_hash = buf[1 ];break ; +case DX_HASH_SIPHASH : + { +struct qstr qname =QSTR_INIT (name, len); +__u64 combined_hash; + +if (fscrypt_has_encryption_key (dir)) { + combined_hash =fscrypt_fname_siphash (dir, &qname); + }else { +ext4_warning_inode (dir,"Siphash requires key" ); +return -1 ; + } + + hash = (__u32)(combined_hash >>32 ); + minor_hash = (__u32 )combined_hash; +break ; + }default : hinfo->hash =0 ;return -1 ;
@@ -280,7 +296,8 @@ int ext4fs_dirhash(const struct inode *dir, const char *name, int len,unsigned char *buff;struct qstr qstr = {.name = name, .len = len }; -if (len &&IS_CASEFOLDED (dir) && um) { +if (len &&IS_CASEFOLDED (dir) && um && + (!IS_ENCRYPTED (dir) ||fscrypt_has_encryption_key (dir))) { buff =kzalloc (sizeof (char ) *PATH_MAX ,GFP_KERNEL );if (!buff)return -ENOMEM ;
@@ -291,12 +308,12 @@ int ext4fs_dirhash(const struct inode *dir, const char *name, int len, goto opaque_seq; } - r =__ext4fs_dirhash (buff, dlen, hinfo); + r =__ext4fs_dirhash (dir, buff, dlen, hinfo);kfree (buff);return r; } opaque_seq: #endif -return __ext4fs_dirhash (name, len, hinfo); +return __ext4fs_dirhash (dir, name, len, hinfo); }
fs/ext4/inline.c +15 -10
@@ -1031,7 +1031,7 @@ static int ext4_add_dirent_to_inline(handle_t *handle, err =ext4_journal_get_write_access (handle, iloc->bh);if (err)return err; -ext4_insert_dentry (inode, de, inline_size, fname); +ext4_insert_dentry (dir, inode, de, inline_size, fname);ext4_show_inline_dir (dir, iloc->bh, inline_start, inline_size);
@@ -1100,7 +1100,7 @@ static int ext4_update_inline_dir(handle_t *handle, struct inode *dir,int old_size =EXT4_I (dir)->i_inline_size -EXT4_MIN_INLINE_DATA_SIZE ;int new_size =get_max_inline_xattr_value_size (dir, iloc); -if (new_size - old_size <=EXT4_DIR_REC_LEN (1 )) +if (new_size - old_size <=ext4_dir_rec_len (1 ,NULL ))return -ENOSPC ; ret = ext4_update_inline_data(handle, dir,
@@ -1380,8 +1380,8 @@ int ext4_inlinedir_to_tree(struct file *dir_file, fake.name_len =1 ;strcpy (fake.name,"." ); fake.rec_len =ext4_rec_len_to_disk ( -EXT4_DIR_REC_LEN (fake.name_len), - inline_size); +ext4_dir_rec_len (fake.name_len,NULL ), + inline_size);ext4_set_de_type (inode->i_sb, &fake,S_IFDIR ); de = &fake; pos =EXT4_INLINE_DOTDOT_OFFSET ;
@@ -1390,8 +1390,8 @@ int ext4_inlinedir_to_tree(struct file *dir_file, fake.name_len =2 ;strcpy (fake.name,".." ); fake.rec_len =ext4_rec_len_to_disk ( -EXT4_DIR_REC_LEN (fake.name_len), - inline_size); +ext4_dir_rec_len (fake.name_len,NULL ), + inline_size);ext4_set_de_type (inode->i_sb, &fake,S_IFDIR ); de = &fake; pos =EXT4_INLINE_DOTDOT_SIZE ;
@@ -1406,7 +1406,12 @@ int ext4_inlinedir_to_tree(struct file *dir_file, } } -ext4fs_dirhash (dir, de->name, de->name_len, hinfo); +if (ext4_hash_in_dirent (dir)) { + hinfo->hash =EXT4_DIRENT_HASH (de); + hinfo->minor_hash =EXT4_DIRENT_MINOR_HASH (de); + }else { +ext4fs_dirhash (dir, de->name, de->name_len, hinfo); + }if ((hinfo->hash < start_hash) || ((hinfo->hash == start_hash) && (hinfo->minor_hash < start_minor_hash)))
@@ -1488,8 +1493,8 @@ int ext4_read_inline_dir(struct file *file,* So we will use extra_offset and extra_size to indicate them * during the inline dir iteration. */ - dotdot_offset =EXT4_DIR_REC_LEN (1 ); - dotdot_size = dotdot_offset +EXT4_DIR_REC_LEN (2 ); + dotdot_offset =ext4_dir_rec_len (1 ,NULL ); + dotdot_size = dotdot_offset +ext4_dir_rec_len (2 ,NULL ); extra_offset = dotdot_size -EXT4_INLINE_DOTDOT_SIZE ; extra_size = extra_offset + inline_size;
@@ -1524,7 +1529,7 @@ int ext4_read_inline_dir(struct file *file,* failure will be detected in the * dirent test below. */ if (ext4_rec_len_from_disk (de->rec_len, extra_size) - <EXT4_DIR_REC_LEN (1 )) + <ext4_dir_rec_len (1 ,NULL ))break ; i +=ext4_rec_len_from_disk (de->rec_len, extra_size);
fs/ext4/namei.c +146 -52
407 lines not on this page · raw message
fs/ext4/super.c +0 -6
@@ -4291,12 +4291,6 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)struct unicode_map *encoding;__u16 encoding_flags; -if (ext4_has_feature_encrypt (sb)) { -ext4_msg (sb,KERN_ERR , -"Can't mount with encoding and encryption" ); - goto failed_mount; - } -if (ext4_sb_read_encoding (es, &encoding_info, &encoding_flags)) { ext4_msg(sb, KERN_ERR,
Signature · 1 line
2.31.0.rc2.261.g7f71774620-goog
Re: [PATCH v2 1/2] ext4: Handle casefolding with encryption
Quoted 8 lines · Daniel Rosenberg
This adds support for encryption with casefolding.
Since the name on disk is case preserving, and also encrypted, we can no longer just recompute the hash on the fly. Additionally, to avoid leaking extra information from the hash of the unencrypted name, we use siphash via an fscrypt v2 policy.
Quoted 6 lines
The hash is stored at the end of the directory entry for all entries inside of an encrypted and casefolded directory apart from those that deal with '.' and '..'. This way, the change is backwards compatible with existing ext4 filesystems.
Signed-off-by Daniel Rosenberg <[email protected]>
Cheers, Andreas
Theodore Ts'o
maintainerRe: [PATCH v2 1/2] ext4: Handle casefolding with encryption
In reply to Daniel RosenbergQuoted 7 lines · Daniel Rosenberg
This adds support for encryption with casefolding.
Since the name on disk is case preserving, and also encrypted, we can no longer just recompute the hash on the fly. Additionally, to avoid leaking extra information from the hash of the unencrypted name, we use siphash via an fscrypt v2 policy.
Quoted 6 lines
The hash is stored at the end of the directory entry for all entries inside of an encrypted and casefolded directory apart from those that deal with '.' and '..'. This way, the change is backwards compatible with existing ext4 filesystems.
Signed-off-by Daniel Rosenberg <[email protected]>
Applied, thanks with the following addition so that tests, e2fsprogs, etc., can determine whether or not the currently running kernel has this feature enabled:
fs/ext4/sysfs.c +2 -0
@@ -313,6 +313,7 @@ EXT4_ATTR_FEATURE(verity);#endif EXT4_ATTR_FEATURE (metadata_csum_seed);EXT4_ATTR_FEATURE (fast_commit); +EXT4_ATTR_FEATURE (encrypted_casefold);static struct attribute *ext4_feat_attrs[] = {ATTR_LIST (lazy_itable_init),
@@ -330,6 +331,7 @@ static struct attribute *ext4_feat_attrs[] = {#endif ATTR_LIST (metadata_csum_seed),ATTR_LIST (fast_commit), +ATTR_LIST (encrypted_casefold),NULL , };ATTRIBUTE_GROUPS (ext4_feat);
Future versions of e2fsprogs may issue a warning if tune2fs or mke2fs tries to modify or create a file system such that both the encryption and casefold feature is enabled if it appears that the kernel won't support this combination. Daniel, if you could try to get this change into the Android kernels that are using encrypted casefold, that would be a good thing.
- Ted
PATCH v2 2/2 ext4: Optimize match for casefolded encrypted dirs
In reply to Daniel RosenbergMatching names with casefolded encrypting directories requires decrypting entries to confirm case since we are case preserving. We can avoid needing to decrypt if our hash values don't match.
--- fs/ext4/ext4.h | 17 ++++++++------- fs/ext4/namei.c | 55 ++++++++++++++++++++++++++----------------------- 2 files changed, 38 insertions(+), 34 deletions(-)
fs/ext4/ext4.h +9 -8
@@ -2637,9 +2637,9 @@ extern unsigned ext4_free_clusters_after_init(struct super_block *sb,ext4_fsblk_t ext4_inode_to_goal_block (struct inode *);#ifdef CONFIG_UNICODE -extern void ext4_fname_setup_ci_filename (struct inode *dir, +extern int ext4_fname_setup_ci_filename (struct inode *dir,const struct qstr *iname, -struct fscrypt_str *fname); +struct ext4_filename *fname);#endif #ifdef CONFIG_FS_ENCRYPTION
@@ -2670,9 +2670,9 @@ static inline int ext4_fname_setup_filename(struct inode *dir,ext4_fname_from_fscrypt_name (fname, &name);#ifdef CONFIG_UNICODE -ext4_fname_setup_ci_filename (dir, iname, &fname->cf_name); + err =ext4_fname_setup_ci_filename (dir, iname, fname);#endif -return 0 ; +return err; } static inline int ext4_fname_prepare_lookup(struct inode *dir,
@@ -2689,9 +2689,9 @@ static inline int ext4_fname_prepare_lookup(struct inode *dir,ext4_fname_from_fscrypt_name (fname, &name);#ifdef CONFIG_UNICODE -ext4_fname_setup_ci_filename (dir, &dentry->d_name, &fname->cf_name); + err =ext4_fname_setup_ci_filename (dir, &dentry->d_name, fname);#endif -return 0 ; +return err; }static inline void ext4_fname_free_filename (struct ext4_filename *fname)
@@ -2716,15 +2716,16 @@ static inline int ext4_fname_setup_filename(struct inode *dir,int lookup, struct ext4_filename *fname) { + int err = 0; fname->usr_fname = iname; fname->disk_name.name = (unsigned char *) iname->name; fname->disk_name.len = iname->len;#ifdef CONFIG_UNICODE -ext4_fname_setup_ci_filename (dir, iname, &fname->cf_name); + err =ext4_fname_setup_ci_filename (dir, iname, fname);#endif -return 0 ; +return err; } static inline int ext4_fname_prepare_lookup(struct inode *dir,
fs/ext4/namei.c +29 -26
106 lines not on this page · raw message
Signature · 1 line
2.31.0.rc2.261.g7f71774620-goog
Re: [PATCH v2 2/2] ext4: Optimize match for casefolded encrypted dirs
Quoted 5 lines · Daniel Rosenberg
Matching names with casefolded encrypting directories requires decrypting entries to confirm case since we are case preserving. We can avoid needing to decrypt if our hash values don't match.
Signed-off-by Daniel Rosenberg <[email protected]>
Thanks, applied.
- Ted