backport some more fscrypt fixes to 4.19
Subsystems (7)
Eric Biggers
maintainercover backport some more fscrypt fixes to 4.19
Backport some fscrypt fixes from upstream 5.2 to 4.19-stable.
This is needed to get 'kvm-xfstests -c ext4,f2fs,ubifs -g encrypt' to fully pass on 4.19-stable. Before, generic/397 and generic/429 failed on UBIFS due to missing "fscrypt: fix race where ->lookup() marks plaintext dentry as ciphertext".
This also fixes some bugs that aren't yet covered by the xfstests. E.g., "fs, fscrypt: clear DCACHE_ENCRYPTED_NAME when unaliasing directory" fixes a bug that caused real-world problems on Chrome OS.
Some relatively straightforward adjustments were needed to the patches, mainly due to the refactoring of fscrypt.h that was done in 5.1.
Eric Biggers (5):
fscrypt: clean up and improve dentry revalidation
fscrypt: fix race allowing rename() and link() of ciphertext dentries fs, fscrypt: clear DCACHE_ENCRYPTED_NAME when unaliasing directory
fscrypt: only set dentry_operations on ciphertext dentries
fscrypt: fix race where ->lookup() marks plaintext dentry as
ciphertext
fs/crypto/crypto.c | 58 +++++++++++++------------ fs/crypto/fname.c | 1 + fs/crypto/hooks.c | 28 ++++++++---- fs/dcache.c | 15 +++++++ fs/ext4/ext4.h | 62 ++++++++++++++++++++------- fs/ext4/namei.c | 76 ++++++++++++++++++++++----------- fs/f2fs/namei.c | 17 +++++--- fs/ubifs/dir.c | 8 ++-- include/linux/dcache.h | 2 +- include/linux/fscrypt.h | 30 +++++++------ include/linux/fscrypt_notsupp.h | 9 ++-- include/linux/fscrypt_supp.h | 6 ++- 12 files changed, 205 insertions(+), 107 deletions(-)
Signature · 1 line
2.29.1
Eric Biggers
maintainerPATCH 1/5 fscrypt: clean up and improve dentry revalidation
From: Eric Biggers <[email protected]>
commit 6cc248684d3d23bbd073ae2fa73d3416c0558909 upstream.
Make various improvements to fscrypt dentry revalidation:
- Don't try to handle the case where the per-directory key is removed, as this can't happen without the inode (and dentries) being evicted.
- Flag ciphertext dentries rather than plaintext dentries, since it's ciphertext dentries that need the special handling.
- Avoid doing unnecessary work for non-ciphertext dentries.
- When revalidating ciphertext dentries, try to set up the directory's i_crypt_info to make sure the key is really still absent, rather than invalidating all negative dentries as the previous code did. An old comment suggested we can't do this for locking reasons, but AFAICT this comment was outdated and it actually works fine.
--- fs/crypto/crypto.c | 58 +++++++++++++++++++++-------------------- fs/crypto/hooks.c | 4 +-- include/linux/dcache.h | 2 +- include/linux/fscrypt.h | 6 ++--- 4 files changed, 35 insertions(+), 35 deletions(-)
fs/crypto/crypto.c +30 -28
@@ -314,45 +314,47 @@ int fscrypt_decrypt_page(const struct inode *inode, struct page *page,EXPORT_SYMBOL (fscrypt_decrypt_page);/* -* Validate dentries for encrypted directories to make sure we aren't -* potentially caching stale data after a key has been added or -* removed. +* Validate dentries in encrypted directories to make sure we aren't potentially +* caching stale dentries after a key has been added. */ static int fscrypt_d_revalidate (struct dentry *dentry,unsigned int flags) {struct dentry *dir; -int dir_has_key, cached_with_key; +int err; +int valid; + +/* +* Plaintext names are always valid, since fscrypt doesn't support +* reverting to ciphertext names without evicting the directory's inode +* -- which implies eviction of the dentries in the directory. +*/ +if (!(dentry->d_flags &DCACHE_ENCRYPTED_NAME )) +return 1 ; + +/* +* Ciphertext name; valid if the directory's key is still unavailable. +* +* Although fscrypt forbids rename() on ciphertext names, we still must +* use dget_parent() here rather than use ->d_parent directly. That's +* because a corrupted fs image may contain directory hard links, which +* the VFS handles by moving the directory's dentry tree in the dcache +* each time ->lookup() finds the directory and it already has a dentry +* elsewhere. Thus ->d_parent can be changing, and we must safely grab +* a reference to some ->d_parent to prevent it from being freed. +*/ if (flags &LOOKUP_RCU )return -ECHILD ; dir =dget_parent (dentry); -if (!IS_ENCRYPTED (d_inode (dir))) { -dput (dir); -return 0 ; - } - -spin_lock (&dentry->d_lock); - cached_with_key = dentry->d_flags &DCACHE_ENCRYPTED_WITH_KEY ; -spin_unlock (&dentry->d_lock); - dir_has_key = (d_inode (dir)->i_crypt_info !=NULL ); + err =fscrypt_get_encryption_info (d_inode (dir)); + valid = !fscrypt_has_encryption_key (d_inode (dir));dput (dir); -/* -* If the dentry was cached without the key, and it is a -* negative dentry, it might be a valid name. We can't check -* if the key has since been made available due to locking -* reasons, so we fail the validation so ext4_lookup() can do -* this check. -* -* We also fail the validation if the dentry was created with -* the key present, but we no longer have the key, or vice versa. -*/ -if ((!cached_with_key &&d_is_negative (dentry)) || - (!cached_with_key && dir_has_key) || - (cached_with_key && !dir_has_key)) -return 0 ; -return 1 ; +if (err <0 ) +return err; + +return valid; }const struct dentry_operations fscrypt_d_ops = {
fs/crypto/hooks.c +2 -2
@@ -101,9 +101,9 @@ int __fscrypt_prepare_lookup(struct inode *dir, struct dentry *dentry)if (err)return err; -if (fscrypt_has_encryption_key (dir)) { +if (!fscrypt_has_encryption_key (dir)) {spin_lock (&dentry->d_lock); - dentry->d_flags |=DCACHE_ENCRYPTED_WITH_KEY ; + dentry->d_flags |=DCACHE_ENCRYPTED_NAME ;spin_unlock (&dentry->d_lock); }
include/linux/dcache.h +1 -1
@@ -210,7 +210,7 @@ struct dentry_operations {#define DCACHE_MAY_FREE 0x00800000#define DCACHE_FALLTHRU 0x01000000/* Fall through to lower layer */ -#define DCACHE_ENCRYPTED_WITH_KEY 0x02000000/* dir is encrypted with a valid key */ +#define DCACHE_ENCRYPTED_NAME 0x02000000/* Encrypted name (dir key was unavailable) */ #define DCACHE_OP_REAL 0x04000000#define DCACHE_PAR_LOOKUP 0x10000000/* being looked up (with parent locked shared) */
include/linux/fscrypt.h +2 -4
@@ -145,10 +145,8 @@ static inline int fscrypt_prepare_rename(struct inode *old_dir,* filenames are presented in encrypted form. Therefore, we'll try to set up * the directory's encryption key, but even without it the lookup can continue. * -* To allow invalidating stale dentries if the directory's encryption key is -* added later, we also install a custom ->d_revalidate() method and use the -* DCACHE_ENCRYPTED_WITH_KEY flag to indicate whether a given dentry is a -* plaintext name (flag set) or a ciphertext name (flag cleared). +* This also installs a custom ->d_revalidate() method which will invalidate the +* dentry if it was created without the key and the key is later added. * * Return: 0 on success, -errno if a problem occurred while setting up the * encryption key
Signature · 1 line
2.29.1
Eric Biggers
maintainerPATCH 4/5 fscrypt: only set dentry_operations on ciphertext dentries
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
commit d456a33f041af4b54f3ce495a86d00c246165032 upstream.
Plaintext dentries are always valid, so only set fscrypt_d_ops on ciphertext dentries.
Besides marginally improved performance, this allows overlayfs to use an fscrypt-encrypted upperdir, provided that all the following are true:
(1) The fscrypt encryption key is placed in the keyring before mounting overlayfs, and remains while the overlayfs is mounted.
(2) The overlayfs workdir uses the same encryption policy.
(3) No dentries for the ciphertext names of subdirectories have been created in the upperdir or workdir yet. (Since otherwise d_splice_alias() will reuse the old dentry with ->d_op set.)
One potential use case is using an ephemeral encryption key to encrypt all files created or changed by a container, so that they can be securely erased ("crypto-shredded") after the container stops.
--- fs/crypto/hooks.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
fs/crypto/hooks.c +1 -2
@@ -115,9 +115,8 @@ int __fscrypt_prepare_lookup(struct inode *dir, struct dentry *dentry)spin_lock (&dentry->d_lock); dentry->d_flags |=DCACHE_ENCRYPTED_NAME ;spin_unlock (&dentry->d_lock); +d_set_d_op (dentry, &fscrypt_d_ops); } - -d_set_d_op (dentry, &fscrypt_d_ops);return 0 ; }EXPORT_SYMBOL_GPL (__fscrypt_prepare_lookup);
Signature · 1 line
2.29.1
Eric Biggers
maintainerPATCH 5/5 fscrypt: fix race where ->lookup() marks plaintext dentry as ciphertext
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
commit b01531db6cec2aa330dbc91bfbfaaef4a0d387a4 upstream.
->lookup() in an encrypted directory begins as follows:
1. fscrypt_prepare_lookup():
a. Try to load the directory's encryption key.
b. If the key is unavailable, mark the dentry as a ciphertext name
via d_flags.
2. fscrypt_setup_filename():
a. Try to load the directory's encryption key.
b. If the key is available, encrypt the name (treated as a plaintext
name) to get the on-disk name. Otherwise decode the name (treated as a ciphertext name) to get the on-disk name.
But if the key is concurrently added, it may be found at (2a) but not at (1a). In this case, the dentry will be wrongly marked as a ciphertext name even though it was actually treated as plaintext.
This will cause the dentry to be wrongly invalidated on the next lookup, potentially causing problems. For example, if the racy ->lookup() was part of sys_mount(), then the new mount will be detached when anything tries to access it. This is despite the mountpoint having a plaintext path, which should remain valid now that the key was added.
Of course, this is only possible if there's a userspace race. Still, the additional kernel-side race is confusing and unexpected.
Close the kernel-side race by changing fscrypt_prepare_lookup() to also set the on-disk filename (step 2b), consistent with the d_flags update.
--- fs/crypto/fname.c | 1 + fs/crypto/hooks.c | 11 ++--- fs/ext4/ext4.h | 62 ++++++++++++++++++++------- fs/ext4/namei.c | 76 ++++++++++++++++++++++----------- fs/f2fs/namei.c | 17 +++++--- fs/ubifs/dir.c | 8 ++-- include/linux/fscrypt.h | 22 +++++++--- include/linux/fscrypt_notsupp.h | 5 ++- include/linux/fscrypt_supp.h | 3 +- 9 files changed, 139 insertions(+), 66 deletions(-)
fs/crypto/fname.c +1 -0
@@ -354,6 +354,7 @@ int fscrypt_setup_filename(struct inode *dir, const struct qstr *iname, }if (!lookup)return -ENOKEY ; + fname->is_ciphertext_name = true;/* * We don't have the key and we are doing a lookup; decode the
fs/crypto/hooks.c +6 -5
@@ -104,20 +104,21 @@ int __fscrypt_prepare_rename(struct inode *old_dir, struct dentry *old_dentry, }EXPORT_SYMBOL_GPL (__fscrypt_prepare_rename); -int __fscrypt_prepare_lookup (struct inode *dir,struct dentry *dentry) +int __fscrypt_prepare_lookup (struct inode *dir,struct dentry *dentry, +struct fscrypt_name *fname) { -int err =fscrypt_get_encryption_info (dir); +int err =fscrypt_setup_filename (dir, &dentry->d_name,1 , fname); -if (err) +if (err && err != -ENOENT )return err; -if (!fscrypt_has_encryption_key (dir)) { +if (fname->is_ciphertext_name) {spin_lock (&dentry->d_lock); dentry->d_flags |=DCACHE_ENCRYPTED_NAME ;spin_unlock (&dentry->d_lock);d_set_d_op (dentry, &fscrypt_d_ops); } -return 0 ; +return err; }EXPORT_SYMBOL_GPL (__fscrypt_prepare_lookup);
fs/ext4/ext4.h +47 -15
89 lines not on this page · raw message
fs/ext4/namei.c +52 -24
138 lines not on this page · raw message
fs/f2fs/namei.c +10 -7
@@ -432,19 +432,23 @@ static struct dentry *f2fs_lookup(struct inode *dir, struct dentry *dentry,nid_t ino =-1 ;int err =0 ;unsigned int root_ino =F2FS_ROOT_INO (F2FS_I_SB (dir)); +struct fscrypt_name fname;trace_f2fs_lookup_start (dir, dentry, flags); - err =fscrypt_prepare_lookup (dir, dentry, flags); -if (err) - goto out; -if (dentry->d_name.len >F2FS_NAME_LEN ) { err = -ENAMETOOLONG ; goto out; } - de =f2fs_find_entry (dir, &dentry->d_name, &page); + err =fscrypt_prepare_lookup (dir, dentry, &fname); +if (err == -ENOENT ) + goto out_splice; +if (err) + goto out; + de =__f2fs_find_entry (dir, &fname, &page); +fscrypt_free_filename (&fname); +if (!de) {if (IS_ERR (page)) { err =PTR_ERR (page);
@@ -484,8 +488,7 @@ static struct dentry *f2fs_lookup(struct inode *dir, struct dentry *dentry, } out_splice: new =d_splice_alias (inode, dentry); -if (IS_ERR (new)) - err =PTR_ERR (new); + err =PTR_ERR_OR_ZERO (new);trace_f2fs_lookup_end (dir, dentry, ino, err);return new; out_iput:
fs/ubifs/dir.c +3 -5
@@ -220,11 +220,9 @@ static struct dentry *ubifs_lookup(struct inode *dir, struct dentry *dentry,dbg_gen ("'%pd' in dir ino %lu" , dentry, dir->i_ino); - err =fscrypt_prepare_lookup (dir, dentry, flags); -if (err) -return ERR_PTR (err); - - err =fscrypt_setup_filename (dir, &dentry->d_name,1 , &nm); + err =fscrypt_prepare_lookup (dir, dentry, &nm); +if (err == -ENOENT ) +return d_splice_alias (NULL , dentry);if (err)return ERR_PTR (err);
include/linux/fscrypt.h +15 -7
@@ -32,6 +32,7 @@ struct fscrypt_name {u32 hash;u32 minor_hash;struct fscrypt_str crypto_buf; +bool is_ciphertext_name; };#define FSTR_INIT (n, l) { .name = n, .len = l }
@@ -138,25 +139,32 @@ static inline int fscrypt_prepare_rename(struct inode *old_dir,* fscrypt_prepare_lookup - prepare to lookup a name in a possibly-encrypted directory * @dir: directory being searched * @dentry: filename being looked up -* @flags: lookup flags +* @fname: (output) the name to use to search the on-disk directory * -* Prepare for ->lookup() in a directory which may be encrypted. Lookups can be -* done with or without the directory's encryption key; without the key, +* Prepare for ->lookup() in a directory which may be encrypted by determining +* the name that will actually be used to search the directory on-disk. Lookups +* can be done with or without the directory's encryption key; without the key, * filenames are presented in encrypted form. Therefore, we'll try to set up * the directory's encryption key, but even without it the lookup can continue. * * This also installs a custom ->d_revalidate() method which will invalidate the * dentry if it was created without the key and the key is later added. * -* Return: 0 on success, -errno if a problem occurred while setting up the -* encryption key +* Return: 0 on success; -ENOENT if key is unavailable but the filename isn't a +* correctly formed encoded ciphertext name, so a negative dentry should be +* created; or another -errno code. */ static inline int fscrypt_prepare_lookup (struct inode *dir,struct dentry *dentry, -unsigned int flags) +struct fscrypt_name *fname) {if (IS_ENCRYPTED (dir)) -return __fscrypt_prepare_lookup (dir, dentry); +return __fscrypt_prepare_lookup (dir, dentry, fname); + +memset (fname,0 ,sizeof (*fname)); + fname->usr_fname = &dentry->d_name; + fname->disk_name.name = (unsigned char *)dentry->d_name.name; + fname->disk_name.len = dentry->d_name.len;return 0 ; }
include/linux/fscrypt_notsupp.h +3 -2
@@ -112,7 +112,7 @@ static inline int fscrypt_setup_filename(struct inode *dir,if (IS_ENCRYPTED (dir))return -EOPNOTSUPP ; -memset (fname,0 ,sizeof (struct fscrypt_name )); +memset (fname,0 ,sizeof (*fname)); fname->usr_fname = iname; fname->disk_name.name = (unsigned char *)iname->name; fname->disk_name.len = iname->len;
@@ -199,7 +199,8 @@ static inline int __fscrypt_prepare_rename(struct inode *old_dir, }static inline int __fscrypt_prepare_lookup (struct inode *dir, -struct dentry *dentry) +struct dentry *dentry, +struct fscrypt_name *fname) {return -EOPNOTSUPP ; }
include/linux/fscrypt_supp.h +2 -1
@@ -191,7 +191,8 @@ extern int __fscrypt_prepare_rename(struct inode *old_dir,struct inode *new_dir, struct dentry *new_dentry, unsigned int flags); -extern int __fscrypt_prepare_lookup (struct inode *dir,struct dentry *dentry); +extern int __fscrypt_prepare_lookup (struct inode *dir,struct dentry *dentry, +struct fscrypt_name *fname);extern int __fscrypt_prepare_symlink (struct inode *dir,unsigned int len,unsigned int max_len,struct fscrypt_str *disk_link);
Signature · 1 line
2.29.1
Eric Biggers
maintainerPATCH 3/5 fs, fscrypt: clear DCACHE_ENCRYPTED_NAME when unaliasing directory
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
commit 0bf3d5c1604ecbbd4e49e9f5b3c79152b87adb0d upstream.
Make __d_move() clear DCACHE_ENCRYPTED_NAME on the source dentry. This is needed for when d_splice_alias() moves a directory's encrypted alias to its decrypted alias as a result of the encryption key being added.
Otherwise, the decrypted alias will incorrectly be invalidated on the next lookup, causing problems such as unmounting a mount the user just mount()ed there.
Note that we don't have to support arbitrary moves of this flag because fscrypt doesn't allow dentries with DCACHE_ENCRYPTED_NAME to be the source or target of a rename().
--- fs/dcache.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+)
fs/dcache.c +15 -0
@@ -2712,6 +2712,20 @@ static void copy_name(struct dentry *dentry, struct dentry *target)call_rcu (&old_name->u.head, __d_free_external_name); } +/* +* When d_splice_alias() moves a directory's encrypted alias to its decrypted +* alias as a result of the encryption key being added, DCACHE_ENCRYPTED_NAME +* must be cleared. Note that we don't have to support arbitrary moves of this +* flag because fscrypt doesn't allow encrypted aliases to be the source or +* target of a rename(). +*/ +static inline void fscrypt_handle_d_move (struct dentry *dentry) +{ +#if IS_ENABLED (CONFIG_FS_ENCRYPTION ) + dentry->d_flags &= ~DCACHE_ENCRYPTED_NAME ; +#endif +} +/* * __d_move - move a dentry * @dentry: entry to move
@@ -2787,6 +2801,7 @@ static void __d_move(struct dentry *dentry, struct dentry *target,list_move (&dentry->d_child, &dentry->d_parent->d_subdirs);__d_rehash (dentry);fsnotify_update_flags (dentry); +fscrypt_handle_d_move (dentry);write_seqcount_end (&target->d_seq);write_seqcount_end (&dentry->d_seq);
Signature · 1 line
2.29.1
Eric Biggers
maintainerPATCH 2/5 fscrypt: fix race allowing rename() and link() of ciphertext dentries
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
commit 968dd6d0c6d6b6a989c6ddb9e2584a031b83e7b5 upstream.
Close some race conditions where fscrypt allowed rename() and link() on ciphertext dentries that had been looked up just prior to the key being concurrently added. It's better to return -ENOKEY in this case.
This avoids doing the nonsensical thing of encrypting the names a second time when searching for the actual on-disk dir entries. It also guarantees that DCACHE_ENCRYPTED_NAME dentries are never rename()d, so the dcache won't have support all possible combinations of moving DCACHE_ENCRYPTED_NAME around during __d_move().
--- fs/crypto/hooks.c | 12 +++++++++++- include/linux/fscrypt.h | 2 +- include/linux/fscrypt_notsupp.h | 4 ++-- include/linux/fscrypt_supp.h | 3 ++- 4 files changed, 16 insertions(+), 5 deletions(-)
fs/crypto/hooks.c +11 -1
@@ -49,7 +49,8 @@ int fscrypt_file_open(struct inode *inode, struct file *filp) }EXPORT_SYMBOL_GPL (fscrypt_file_open); -int __fscrypt_prepare_link (struct inode *inode,struct inode *dir) +int __fscrypt_prepare_link (struct inode *inode,struct inode *dir, +struct dentry *dentry) {int err;
@@ -57,6 +58,10 @@ int __fscrypt_prepare_link(struct inode *inode, struct inode *dir)if (err)return err; +/* ... in case we looked up ciphertext name before key was added */ +if (dentry->d_flags &DCACHE_ENCRYPTED_NAME ) +return -ENOKEY ; +if (!fscrypt_has_permitted_context (dir, inode))return -EXDEV ;
@@ -78,6 +83,11 @@ int __fscrypt_prepare_rename(struct inode *old_dir, struct dentry *old_dentry,if (err)return err; +/* ... in case we looked up ciphertext name(s) before key was added */ +if ((old_dentry->d_flags | new_dentry->d_flags) & +DCACHE_ENCRYPTED_NAME ) +return -ENOKEY ; + if (old_dir != new_dir) { if (IS_ENCRYPTED(new_dir) && !fscrypt_has_permitted_context(new_dir,
include/linux/fscrypt.h +1 -1
@@ -97,7 +97,7 @@ static inline int fscrypt_prepare_link(struct dentry *old_dentry, struct dentry *dentry) {if (IS_ENCRYPTED (dir)) -return __fscrypt_prepare_link (d_inode (old_dentry), dir); +return __fscrypt_prepare_link (d_inode (old_dentry), dir, dentry);return 0 ; }
include/linux/fscrypt_notsupp.h +2 -2
@@ -183,8 +183,8 @@ static inline int fscrypt_file_open(struct inode *inode, struct file *filp)return 0 ; } -static inline int __fscrypt_prepare_link (struct inode *inode, -struct inode *dir) +static inline int __fscrypt_prepare_link (struct inode *inode,struct inode *dir, +struct dentry *dentry) {return -EOPNOTSUPP ; }
include/linux/fscrypt_supp.h +2 -1
@@ -184,7 +184,8 @@ extern int fscrypt_zeroout_range(const struct inode *, pgoff_t, sector_t,/* hooks.c */ extern int fscrypt_file_open (struct inode *inode,struct file *filp); -extern int __fscrypt_prepare_link (struct inode *inode,struct inode *dir); +extern int __fscrypt_prepare_link (struct inode *inode,struct inode *dir, +struct dentry *dentry); extern int __fscrypt_prepare_rename(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir,
Signature · 1 line
2.29.1
Greg KH
maintainerQuoted 7 lines · Eric Biggers
Backport some fscrypt fixes from upstream 5.2 to 4.19-stable.
This is needed to get 'kvm-xfstests -c ext4,f2fs,ubifs -g encrypt' to fully pass on 4.19-stable. Before, generic/397 and generic/429 failed on UBIFS due to missing "fscrypt: fix race where ->lookup() marks plaintext dentry as ciphertext".
Quoted 6 lines
This also fixes some bugs that aren't yet covered by the xfstests. E.g., "fs, fscrypt: clear
DCACHE_ENCRYPTED_NAMEwhen unaliasing directory" fixes a bug that caused real-world problems on Chrome OS.Some relatively straightforward adjustments were needed to the patches, mainly due to the refactoring of
fscrypt.hthat was done in 5.1.
All now queued up, thanks!
greg k-h
[f2fs-dev] Patch "fs, fscrypt: clear DCACHE_ENCRYPTED_NAME when unaliasing directory" has been added to the 4.19-stable tree
In reply to Eric BiggersThis is a note to let you know that I've just added the patch titled
fs, fscrypt: clear DCACHE_ENCRYPTED_NAME when unaliasing directory
to the 4.19-stable tree which can be found at:
http://www.kernel.org/git/?p=linux/kernel/git/stable/stable-queue.git;a=summary
The filename of the patch is:
fs-fscrypt-clear-dcache_encrypted_name-when-unaliasing-directory.patch
and it can be found in the queue-4.19 subdirectory.
If you, or anyone else, feels it should not be added to the stable tree, please let <[email protected]> know about it.
From foo@baz Sun Nov 1 11:35:18 AM CET 2020
From: Eric Biggers <[email protected]>
Date: Sat, 31 Oct 2020 15:05:51 -0700
Subject: fs, fscrypt: clear DCACHE_ENCRYPTED_NAME when unaliasing directory
To: [email protected]
Cc: [email protected], [email protected], [email protected], [email protected], Sarthak Kukreti <[email protected]>, Theodore Ts'o <[email protected]>
Message-ID: <[email protected]>
From: Eric Biggers <[email protected]>
commit 0bf3d5c1604ecbbd4e49e9f5b3c79152b87adb0d upstream.
Make __d_move() clear DCACHE_ENCRYPTED_NAME on the source dentry. This is needed for when d_splice_alias() moves a directory's encrypted alias to its decrypted alias as a result of the encryption key being added.
Otherwise, the decrypted alias will incorrectly be invalidated on the next lookup, causing problems such as unmounting a mount the user just mount()ed there.
Note that we don't have to support arbitrary moves of this flag because fscrypt doesn't allow dentries with DCACHE_ENCRYPTED_NAME to be the source or target of a rename().
--- fs/dcache.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+)
fs/dcache.c +15 -0
@@ -2713,6 +2713,20 @@ static void copy_name(struct dentry *den }/* +* When d_splice_alias() moves a directory's encrypted alias to its decrypted +* alias as a result of the encryption key being added, DCACHE_ENCRYPTED_NAME +* must be cleared. Note that we don't have to support arbitrary moves of this +* flag because fscrypt doesn't allow encrypted aliases to be the source or +* target of a rename(). +*/ +static inline void fscrypt_handle_d_move (struct dentry *dentry) +{ +#if IS_ENABLED (CONFIG_FS_ENCRYPTION ) + dentry->d_flags &= ~DCACHE_ENCRYPTED_NAME ; +#endif +} + +/* * __d_move - move a dentry * @dentry: entry to move * @target: new dentry
@@ -2787,6 +2801,7 @@ static void __d_move(struct dentry *dentlist_move (&dentry->d_child, &dentry->d_parent->d_subdirs);__d_rehash (dentry);fsnotify_update_flags (dentry); +fscrypt_handle_d_move (dentry);write_seqcount_end (&target->d_seq);write_seqcount_end (&dentry->d_seq);
Patches currently in stable-queue which might be from [email protected] are
queue-4.19/fscrypt-only-set-dentry_operations-on-ciphertext-dentries.patch queue-4.19/fscrypt-clean-up-and-improve-dentry-revalidation.patch queue-4.19/fscrypt-fix-race-allowing-rename-and-link-of-ciphertext-dentries.patch queue-4.19/fs-fscrypt-clear-dcache_encrypted_name-when-unaliasing-directory.patch queue-4.19/fscrypt-fix-race-where-lookup-marks-plaintext-dentry-as-ciphertext.patch
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
[f2fs-dev] Patch "fscrypt: fix race where ->lookup() marks plaintext dentry as ciphertext" has been added to the 4.19-stable tree
In reply to Eric BiggersThis is a note to let you know that I've just added the patch titled
fscrypt: fix race where ->lookup() marks plaintext dentry as ciphertext
to the 4.19-stable tree which can be found at:
http://www.kernel.org/git/?p=linux/kernel/git/stable/stable-queue.git;a=summary
The filename of the patch is:
fscrypt-fix-race-where-lookup-marks-plaintext-dentry-as-ciphertext.patch
and it can be found in the queue-4.19 subdirectory.
If you, or anyone else, feels it should not be added to the stable tree, please let <[email protected]> know about it.
From foo@baz Sun Nov 1 11:35:18 AM CET 2020
From: Eric Biggers <[email protected]>
Date: Sat, 31 Oct 2020 15:05:53 -0700
Subject: fscrypt: fix race where ->lookup() marks plaintext dentry as ciphertext
To: [email protected]
Cc: [email protected], [email protected], [email protected], [email protected], Theodore Ts'o <[email protected]>
Message-ID: <[email protected]>
From: Eric Biggers <[email protected]>
commit b01531db6cec2aa330dbc91bfbfaaef4a0d387a4 upstream.
->lookup() in an encrypted directory begins as follows:
1. fscrypt_prepare_lookup():
a. Try to load the directory's encryption key.
b. If the key is unavailable, mark the dentry as a ciphertext name
via d_flags.
2. fscrypt_setup_filename():
a. Try to load the directory's encryption key.
b. If the key is available, encrypt the name (treated as a plaintext
name) to get the on-disk name. Otherwise decode the name (treated as a ciphertext name) to get the on-disk name.
But if the key is concurrently added, it may be found at (2a) but not at (1a). In this case, the dentry will be wrongly marked as a ciphertext name even though it was actually treated as plaintext.
This will cause the dentry to be wrongly invalidated on the next lookup, potentially causing problems. For example, if the racy ->lookup() was part of sys_mount(), then the new mount will be detached when anything tries to access it. This is despite the mountpoint having a plaintext path, which should remain valid now that the key was added.
Of course, this is only possible if there's a userspace race. Still, the additional kernel-side race is confusing and unexpected.
Close the kernel-side race by changing fscrypt_prepare_lookup() to also set the on-disk filename (step 2b), consistent with the d_flags update.
--- fs/crypto/fname.c | 1 fs/crypto/hooks.c | 11 +++-- fs/ext4/ext4.h | 62 ++++++++++++++++++++++++-------- fs/ext4/namei.c | 76 +++++++++++++++++++++++++++------------- fs/f2fs/namei.c | 17 +++++--- fs/ubifs/dir.c | 8 +--- include/linux/fscrypt.h | 22 +++++++---- include/linux/fscrypt_notsupp.h | 5 +- include/linux/fscrypt_supp.h | 3 + 9 files changed, 139 insertions(+), 66 deletions(-)
fs/crypto/fname.c +1 -0
@@ -354,6 +354,7 @@ int fscrypt_setup_filename(struct inode }if (!lookup)return -ENOKEY ; + fname->is_ciphertext_name = true;/* * We don't have the key and we are doing a lookup; decode the
fs/crypto/hooks.c +6 -5
@@ -104,20 +104,21 @@ int __fscrypt_prepare_rename(struct inod }EXPORT_SYMBOL_GPL (__fscrypt_prepare_rename); -int __fscrypt_prepare_lookup (struct inode *dir,struct dentry *dentry) +int __fscrypt_prepare_lookup (struct inode *dir,struct dentry *dentry, +struct fscrypt_name *fname) { -int err =fscrypt_get_encryption_info (dir); +int err =fscrypt_setup_filename (dir, &dentry->d_name,1 , fname); -if (err) +if (err && err != -ENOENT )return err; -if (!fscrypt_has_encryption_key (dir)) { +if (fname->is_ciphertext_name) {spin_lock (&dentry->d_lock); dentry->d_flags |=DCACHE_ENCRYPTED_NAME ;spin_unlock (&dentry->d_lock);d_set_d_op (dentry, &fscrypt_d_ops); } -return 0 ; +return err; }EXPORT_SYMBOL_GPL (__fscrypt_prepare_lookup);
fs/ext4/ext4.h +47 -15
89 lines not on this page · raw message
fs/ext4/namei.c +52 -24
138 lines not on this page · raw message
fs/f2fs/namei.c +10 -7
@@ -432,19 +432,23 @@ static struct dentry *f2fs_lookup(structnid_t ino =-1 ;int err =0 ;unsigned int root_ino =F2FS_ROOT_INO (F2FS_I_SB (dir)); +struct fscrypt_name fname;trace_f2fs_lookup_start (dir, dentry, flags); - err =fscrypt_prepare_lookup (dir, dentry, flags); -if (err) - goto out; -if (dentry->d_name.len >F2FS_NAME_LEN ) { err = -ENAMETOOLONG ; goto out; } - de =f2fs_find_entry (dir, &dentry->d_name, &page); + err =fscrypt_prepare_lookup (dir, dentry, &fname); +if (err == -ENOENT ) + goto out_splice; +if (err) + goto out; + de =__f2fs_find_entry (dir, &fname, &page); +fscrypt_free_filename (&fname); +if (!de) {if (IS_ERR (page)) { err =PTR_ERR (page);
@@ -484,8 +488,7 @@ static struct dentry *f2fs_lookup(struct } out_splice: new =d_splice_alias (inode, dentry); -if (IS_ERR (new)) - err =PTR_ERR (new); + err =PTR_ERR_OR_ZERO (new);trace_f2fs_lookup_end (dir, dentry, ino, err);return new; out_iput:
fs/ubifs/dir.c +3 -5
@@ -220,11 +220,9 @@ static struct dentry *ubifs_lookup(strucdbg_gen ("'%pd' in dir ino %lu" , dentry, dir->i_ino); - err =fscrypt_prepare_lookup (dir, dentry, flags); -if (err) -return ERR_PTR (err); - - err =fscrypt_setup_filename (dir, &dentry->d_name,1 , &nm); + err =fscrypt_prepare_lookup (dir, dentry, &nm); +if (err == -ENOENT ) +return d_splice_alias (NULL , dentry);if (err)return ERR_PTR (err);
include/linux/fscrypt.h +15 -7
@@ -32,6 +32,7 @@ struct fscrypt_name {u32 hash;u32 minor_hash;struct fscrypt_str crypto_buf; +bool is_ciphertext_name; };#define FSTR_INIT (n, l) { .name = n, .len = l }
@@ -138,25 +139,32 @@ static inline int fscrypt_prepare_rename* fscrypt_prepare_lookup - prepare to lookup a name in a possibly-encrypted directory * @dir: directory being searched * @dentry: filename being looked up -* @flags: lookup flags +* @fname: (output) the name to use to search the on-disk directory * -* Prepare for ->lookup() in a directory which may be encrypted. Lookups can be -* done with or without the directory's encryption key; without the key, +* Prepare for ->lookup() in a directory which may be encrypted by determining +* the name that will actually be used to search the directory on-disk. Lookups +* can be done with or without the directory's encryption key; without the key, * filenames are presented in encrypted form. Therefore, we'll try to set up * the directory's encryption key, but even without it the lookup can continue. * * This also installs a custom ->d_revalidate() method which will invalidate the * dentry if it was created without the key and the key is later added. * -* Return: 0 on success, -errno if a problem occurred while setting up the -* encryption key +* Return: 0 on success; -ENOENT if key is unavailable but the filename isn't a +* correctly formed encoded ciphertext name, so a negative dentry should be +* created; or another -errno code. */ static inline int fscrypt_prepare_lookup (struct inode *dir,struct dentry *dentry, -unsigned int flags) +struct fscrypt_name *fname) {if (IS_ENCRYPTED (dir)) -return __fscrypt_prepare_lookup (dir, dentry); +return __fscrypt_prepare_lookup (dir, dentry, fname); + +memset (fname,0 ,sizeof (*fname)); + fname->usr_fname = &dentry->d_name; + fname->disk_name.name = (unsigned char *)dentry->d_name.name; + fname->disk_name.len = dentry->d_name.len;return 0 ; }
include/linux/fscrypt_notsupp.h +3 -2
@@ -112,7 +112,7 @@ static inline int fscrypt_setup_filenameif (IS_ENCRYPTED (dir))return -EOPNOTSUPP ; -memset (fname,0 ,sizeof (struct fscrypt_name )); +memset (fname,0 ,sizeof (*fname)); fname->usr_fname = iname; fname->disk_name.name = (unsigned char *)iname->name; fname->disk_name.len = iname->len;
@@ -199,7 +199,8 @@ static inline int __fscrypt_prepare_rena }static inline int __fscrypt_prepare_lookup (struct inode *dir, -struct dentry *dentry) +struct dentry *dentry, +struct fscrypt_name *fname) {return -EOPNOTSUPP ; }
include/linux/fscrypt_supp.h +2 -1
@@ -191,7 +191,8 @@ extern int __fscrypt_prepare_rename(strustruct inode *new_dir, struct dentry *new_dentry, unsigned int flags); -extern int __fscrypt_prepare_lookup (struct inode *dir,struct dentry *dentry); +extern int __fscrypt_prepare_lookup (struct inode *dir,struct dentry *dentry, +struct fscrypt_name *fname);extern int __fscrypt_prepare_symlink (struct inode *dir,unsigned int len,unsigned int max_len,struct fscrypt_str *disk_link);
Patches currently in stable-queue which might be from [email protected] are
queue-4.19/fscrypt-only-set-dentry_operations-on-ciphertext-dentries.patch queue-4.19/fscrypt-clean-up-and-improve-dentry-revalidation.patch queue-4.19/fscrypt-fix-race-allowing-rename-and-link-of-ciphertext-dentries.patch queue-4.19/fs-fscrypt-clear-dcache_encrypted_name-when-unaliasing-directory.patch queue-4.19/fscrypt-fix-race-where-lookup-marks-plaintext-dentry-as-ciphertext.patch
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
[f2fs-dev] Patch "fscrypt: fix race allowing rename() and link() of ciphertext dentries" has been added to the 4.19-stable tree
In reply to Eric BiggersThis is a note to let you know that I've just added the patch titled
fscrypt: fix race allowing rename() and link() of ciphertext dentries
to the 4.19-stable tree which can be found at:
http://www.kernel.org/git/?p=linux/kernel/git/stable/stable-queue.git;a=summary
The filename of the patch is:
fscrypt-fix-race-allowing-rename-and-link-of-ciphertext-dentries.patch
and it can be found in the queue-4.19 subdirectory.
If you, or anyone else, feels it should not be added to the stable tree, please let <[email protected]> know about it.
From foo@baz Sun Nov 1 11:35:18 AM CET 2020
From: Eric Biggers <[email protected]>
Date: Sat, 31 Oct 2020 15:05:50 -0700
Subject: fscrypt: fix race allowing rename() and link() of ciphertext dentries
To: [email protected]
Cc: [email protected], [email protected], [email protected], [email protected], Theodore Ts'o <[email protected]>
Message-ID: <[email protected]>
From: Eric Biggers <[email protected]>
commit 968dd6d0c6d6b6a989c6ddb9e2584a031b83e7b5 upstream.
Close some race conditions where fscrypt allowed rename() and link() on ciphertext dentries that had been looked up just prior to the key being concurrently added. It's better to return -ENOKEY in this case.
This avoids doing the nonsensical thing of encrypting the names a second time when searching for the actual on-disk dir entries. It also guarantees that DCACHE_ENCRYPTED_NAME dentries are never rename()d, so the dcache won't have support all possible combinations of moving DCACHE_ENCRYPTED_NAME around during __d_move().
--- fs/crypto/hooks.c | 12 +++++++++++- include/linux/fscrypt.h | 2 +- include/linux/fscrypt_notsupp.h | 4 ++-- include/linux/fscrypt_supp.h | 3 ++- 4 files changed, 16 insertions(+), 5 deletions(-)
fs/crypto/hooks.c +11 -1
@@ -49,7 +49,8 @@ int fscrypt_file_open(struct inode *inod }EXPORT_SYMBOL_GPL (fscrypt_file_open); -int __fscrypt_prepare_link (struct inode *inode,struct inode *dir) +int __fscrypt_prepare_link (struct inode *inode,struct inode *dir, +struct dentry *dentry) {int err;
@@ -57,6 +58,10 @@ int __fscrypt_prepare_link(struct inodeif (err)return err; +/* ... in case we looked up ciphertext name before key was added */ +if (dentry->d_flags &DCACHE_ENCRYPTED_NAME ) +return -ENOKEY ; +if (!fscrypt_has_permitted_context (dir, inode))return -EXDEV ;
@@ -78,6 +83,11 @@ int __fscrypt_prepare_rename(struct inodif (err)return err; +/* ... in case we looked up ciphertext name(s) before key was added */ +if ((old_dentry->d_flags | new_dentry->d_flags) & +DCACHE_ENCRYPTED_NAME ) +return -ENOKEY ; + if (old_dir != new_dir) { if (IS_ENCRYPTED(new_dir) && !fscrypt_has_permitted_context(new_dir,
include/linux/fscrypt.h +1 -1
@@ -97,7 +97,7 @@ static inline int fscrypt_prepare_link(s struct dentry *dentry) {if (IS_ENCRYPTED (dir)) -return __fscrypt_prepare_link (d_inode (old_dentry), dir); +return __fscrypt_prepare_link (d_inode (old_dentry), dir, dentry);return 0 ; }
include/linux/fscrypt_notsupp.h +2 -2
@@ -183,8 +183,8 @@ static inline int fscrypt_file_open(strureturn 0 ; } -static inline int __fscrypt_prepare_link (struct inode *inode, -struct inode *dir) +static inline int __fscrypt_prepare_link (struct inode *inode,struct inode *dir, +struct dentry *dentry) {return -EOPNOTSUPP ; }
include/linux/fscrypt_supp.h +2 -1
@@ -184,7 +184,8 @@ extern int fscrypt_zeroout_range(const s/* hooks.c */ extern int fscrypt_file_open (struct inode *inode,struct file *filp); -extern int __fscrypt_prepare_link (struct inode *inode,struct inode *dir); +extern int __fscrypt_prepare_link (struct inode *inode,struct inode *dir, +struct dentry *dentry); extern int __fscrypt_prepare_rename(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir,
Patches currently in stable-queue which might be from [email protected] are
queue-4.19/fscrypt-only-set-dentry_operations-on-ciphertext-dentries.patch queue-4.19/fscrypt-clean-up-and-improve-dentry-revalidation.patch queue-4.19/fscrypt-fix-race-allowing-rename-and-link-of-ciphertext-dentries.patch queue-4.19/fs-fscrypt-clear-dcache_encrypted_name-when-unaliasing-directory.patch queue-4.19/fscrypt-fix-race-where-lookup-marks-plaintext-dentry-as-ciphertext.patch
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
[f2fs-dev] Patch "fscrypt: only set dentry_operations on ciphertext dentries" has been added to the 4.19-stable tree
In reply to Eric BiggersThis is a note to let you know that I've just added the patch titled
fscrypt: only set dentry_operations on ciphertext dentries
to the 4.19-stable tree which can be found at:
http://www.kernel.org/git/?p=linux/kernel/git/stable/stable-queue.git;a=summary
The filename of the patch is:
fscrypt-only-set-dentry_operations-on-ciphertext-dentries.patch
and it can be found in the queue-4.19 subdirectory.
If you, or anyone else, feels it should not be added to the stable tree, please let <[email protected]> know about it.
From foo@baz Sun Nov 1 11:35:18 AM CET 2020
From: Eric Biggers <[email protected]>
Date: Sat, 31 Oct 2020 15:05:52 -0700
Subject: fscrypt: only set dentry_operations on ciphertext dentries
To: [email protected]
Cc: [email protected], [email protected], [email protected], [email protected], Theodore Ts'o <[email protected]>
Message-ID: <[email protected]>
From: Eric Biggers <[email protected]>
commit d456a33f041af4b54f3ce495a86d00c246165032 upstream.
Plaintext dentries are always valid, so only set fscrypt_d_ops on ciphertext dentries.
Besides marginally improved performance, this allows overlayfs to use an fscrypt-encrypted upperdir, provided that all the following are true:
(1) The fscrypt encryption key is placed in the keyring before mounting overlayfs, and remains while the overlayfs is mounted.
(2) The overlayfs workdir uses the same encryption policy.
(3) No dentries for the ciphertext names of subdirectories have been created in the upperdir or workdir yet. (Since otherwise d_splice_alias() will reuse the old dentry with ->d_op set.)
One potential use case is using an ephemeral encryption key to encrypt all files created or changed by a container, so that they can be securely erased ("crypto-shredded") after the container stops.
--- fs/crypto/hooks.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
fs/crypto/hooks.c +1 -2
@@ -115,9 +115,8 @@ int __fscrypt_prepare_lookup(struct inodspin_lock (&dentry->d_lock); dentry->d_flags |=DCACHE_ENCRYPTED_NAME ;spin_unlock (&dentry->d_lock); +d_set_d_op (dentry, &fscrypt_d_ops); } - -d_set_d_op (dentry, &fscrypt_d_ops);return 0 ; }EXPORT_SYMBOL_GPL (__fscrypt_prepare_lookup);
Patches currently in stable-queue which might be from [email protected] are
queue-4.19/fscrypt-only-set-dentry_operations-on-ciphertext-dentries.patch queue-4.19/fscrypt-clean-up-and-improve-dentry-revalidation.patch queue-4.19/fscrypt-fix-race-allowing-rename-and-link-of-ciphertext-dentries.patch queue-4.19/fs-fscrypt-clear-dcache_encrypted_name-when-unaliasing-directory.patch queue-4.19/fscrypt-fix-race-where-lookup-marks-plaintext-dentry-as-ciphertext.patch
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
[f2fs-dev] Patch "fscrypt: clean up and improve dentry revalidation" has been added to the 4.19-stable tree
In reply to Eric BiggersThis is a note to let you know that I've just added the patch titled
fscrypt: clean up and improve dentry revalidation
to the 4.19-stable tree which can be found at:
http://www.kernel.org/git/?p=linux/kernel/git/stable/stable-queue.git;a=summary
The filename of the patch is:
fscrypt-clean-up-and-improve-dentry-revalidation.patch
and it can be found in the queue-4.19 subdirectory.
If you, or anyone else, feels it should not be added to the stable tree, please let <[email protected]> know about it.
From foo@baz Sun Nov 1 11:35:18 AM CET 2020
From: Eric Biggers <[email protected]>
Date: Sat, 31 Oct 2020 15:05:49 -0700
Subject: fscrypt: clean up and improve dentry revalidation
To: [email protected]
Cc: [email protected], [email protected], [email protected], [email protected], Theodore Ts'o <[email protected]>
Message-ID: <[email protected]>
From: Eric Biggers <[email protected]>
commit 6cc248684d3d23bbd073ae2fa73d3416c0558909 upstream.
Make various improvements to fscrypt dentry revalidation:
- Don't try to handle the case where the per-directory key is removed, as this can't happen without the inode (and dentries) being evicted.
- Flag ciphertext dentries rather than plaintext dentries, since it's ciphertext dentries that need the special handling.
- Avoid doing unnecessary work for non-ciphertext dentries.
- When revalidating ciphertext dentries, try to set up the directory's i_crypt_info to make sure the key is really still absent, rather than invalidating all negative dentries as the previous code did. An old comment suggested we can't do this for locking reasons, but AFAICT this comment was outdated and it actually works fine.
--- fs/crypto/crypto.c | 58 ++++++++++++++++++++++++------------------------ fs/crypto/hooks.c | 4 +-- include/linux/dcache.h | 2 - include/linux/fscrypt.h | 6 +--- 4 files changed, 35 insertions(+), 35 deletions(-)
fs/crypto/crypto.c +30 -28
@@ -314,45 +314,47 @@ int fscrypt_decrypt_page(const struct inEXPORT_SYMBOL (fscrypt_decrypt_page);/* -* Validate dentries for encrypted directories to make sure we aren't -* potentially caching stale data after a key has been added or -* removed. +* Validate dentries in encrypted directories to make sure we aren't potentially +* caching stale dentries after a key has been added. */ static int fscrypt_d_revalidate (struct dentry *dentry,unsigned int flags) {struct dentry *dir; -int dir_has_key, cached_with_key; +int err; +int valid; + +/* +* Plaintext names are always valid, since fscrypt doesn't support +* reverting to ciphertext names without evicting the directory's inode +* -- which implies eviction of the dentries in the directory. +*/ +if (!(dentry->d_flags &DCACHE_ENCRYPTED_NAME )) +return 1 ; + +/* +* Ciphertext name; valid if the directory's key is still unavailable. +* +* Although fscrypt forbids rename() on ciphertext names, we still must +* use dget_parent() here rather than use ->d_parent directly. That's +* because a corrupted fs image may contain directory hard links, which +* the VFS handles by moving the directory's dentry tree in the dcache +* each time ->lookup() finds the directory and it already has a dentry +* elsewhere. Thus ->d_parent can be changing, and we must safely grab +* a reference to some ->d_parent to prevent it from being freed. +*/ if (flags &LOOKUP_RCU )return -ECHILD ; dir =dget_parent (dentry); -if (!IS_ENCRYPTED (d_inode (dir))) { -dput (dir); -return 0 ; - } - -spin_lock (&dentry->d_lock); - cached_with_key = dentry->d_flags &DCACHE_ENCRYPTED_WITH_KEY ; -spin_unlock (&dentry->d_lock); - dir_has_key = (d_inode (dir)->i_crypt_info !=NULL ); + err =fscrypt_get_encryption_info (d_inode (dir)); + valid = !fscrypt_has_encryption_key (d_inode (dir));dput (dir); -/* -* If the dentry was cached without the key, and it is a -* negative dentry, it might be a valid name. We can't check -* if the key has since been made available due to locking -* reasons, so we fail the validation so ext4_lookup() can do -* this check. -* -* We also fail the validation if the dentry was created with -* the key present, but we no longer have the key, or vice versa. -*/ -if ((!cached_with_key &&d_is_negative (dentry)) || - (!cached_with_key && dir_has_key) || - (cached_with_key && !dir_has_key)) -return 0 ; -return 1 ; +if (err <0 ) +return err; + +return valid; }const struct dentry_operations fscrypt_d_ops = {
fs/crypto/hooks.c +2 -2
@@ -101,9 +101,9 @@ int __fscrypt_prepare_lookup(struct inodif (err)return err; -if (fscrypt_has_encryption_key (dir)) { +if (!fscrypt_has_encryption_key (dir)) {spin_lock (&dentry->d_lock); - dentry->d_flags |=DCACHE_ENCRYPTED_WITH_KEY ; + dentry->d_flags |=DCACHE_ENCRYPTED_NAME ;spin_unlock (&dentry->d_lock); }
include/linux/dcache.h +1 -1
@@ -210,7 +210,7 @@ struct dentry_operations {#define DCACHE_MAY_FREE 0x00800000#define DCACHE_FALLTHRU 0x01000000/* Fall through to lower layer */ -#define DCACHE_ENCRYPTED_WITH_KEY 0x02000000/* dir is encrypted with a valid key */ +#define DCACHE_ENCRYPTED_NAME 0x02000000/* Encrypted name (dir key was unavailable) */ #define DCACHE_OP_REAL 0x04000000#define DCACHE_PAR_LOOKUP 0x10000000/* being looked up (with parent locked shared) */
include/linux/fscrypt.h +2 -4
@@ -145,10 +145,8 @@ static inline int fscrypt_prepare_rename* filenames are presented in encrypted form. Therefore, we'll try to set up * the directory's encryption key, but even without it the lookup can continue. * -* To allow invalidating stale dentries if the directory's encryption key is -* added later, we also install a custom ->d_revalidate() method and use the -* DCACHE_ENCRYPTED_WITH_KEY flag to indicate whether a given dentry is a -* plaintext name (flag set) or a ciphertext name (flag cleared). +* This also installs a custom ->d_revalidate() method which will invalidate the +* dentry if it was created without the key and the key is later added. * * Return: 0 on success, -errno if a problem occurred while setting up the * encryption key
Patches currently in stable-queue which might be from [email protected] are
queue-4.19/fscrypt-only-set-dentry_operations-on-ciphertext-dentries.patch queue-4.19/fscrypt-clean-up-and-improve-dentry-revalidation.patch queue-4.19/fscrypt-fix-race-allowing-rename-and-link-of-ciphertext-dentries.patch queue-4.19/fs-fscrypt-clear-dcache_encrypted_name-when-unaliasing-directory.patch queue-4.19/fscrypt-fix-race-where-lookup-marks-plaintext-dentry-as-ciphertext.patch
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel