Skip to contentSkip to conversation

allow unprivileged overlay mounts

PATCH In review Miklos Szeredi 7 participants 40 messages Dec 7, 2020 – Jan 12, 2021

Subsystems (5)
lore
Share & tools
lore
#0 lore raw

v2 cover allow unprivileged overlay mounts

I've done some more work to verify that unprivileged mount of overlayfs is safe.

One thing I did is to basically audit all function calls made by overlayfs to see if it's normally called with any checks and whether overlayfs calls it with the same (permission and other) checks.

Some of this work has already made it into 5.8 and this series contains more fixes.

A general observation is that overlayfs does not call security_path_*() hooks on the underlying fs. I don't see this as a problem, because a simple bind mount done inside a private mount namespace also defeats the path based security checks. Maybe I'm missing something here, so I'm interested in comments from AppArmor and Tomoyo developers.

Eric, do you have thought about what to look for with respect to unprivileged mount safety and whether you think this is ready for upstream?

Git tree:
git://git.kernel.org/pub/scm/linux/kernel/git/mszeredi/vfs.git#ovl-unpriv-v2

Thanks,
Miklos

Miklos Szeredi (10):
vfs: move cap_convert_nscap() call into vfs_setxattr()
vfs: verify source area in vfs_dedupe_file_range_one()
ovl: check privs before decoding file handle
ovl: make ioctl() safe
ovl: simplify file splice
ovl: user xattr
ovl: do not fail when setting origin xattr
ovl: do not fail because of O_NOATIME
ovl: do not get metacopy for userxattr
ovl: unprivieged mounts

 fs/overlayfs/copy_up.c     |   3 +-
 fs/overlayfs/file.c        | 126 +++----------------------------------
 fs/overlayfs/inode.c       |  10 ++-
 fs/overlayfs/namei.c       |   3 +
 fs/overlayfs/overlayfs.h   |   8 ++-
 fs/overlayfs/ovl_entry.h   |   1 +
 fs/overlayfs/super.c       |  56 +++++++++++++++--
 fs/overlayfs/util.c        |  12 +++-
 fs/remap_range.c           |  10 ++-
 fs/xattr.c                 |  17 +++--
 include/linux/capability.h |   2 +-
 security/commoncap.c       |   3 +-
 12 files changed, 110 insertions(+), 141 deletions(-)
Signature · 1 line
2.26.2
#1 lore raw

PATCH v2 1/10 vfs: move cap_convert_nscap() call into vfs_setxattr()

cap_convert_nscap() does permission checking as well as conversion of the xattr value conditionally based on fs's user-ns.

This is needed by overlayfs and probably other layered fs (ecryptfs) and is what vfs_foo() is supposed to do anyway.

---
 fs/xattr.c                 | 17 +++++++++++------
 include/linux/capability.h |  2 +-
 security/commoncap.c       |  3 +--
 3 files changed, 13 insertions(+), 9 deletions(-)
fs/xattr.c +11 -6
index cd7a563e8bcd..fd57153b1f61 100644
@@ -276,8 +276,16 @@ vfs_setxattr(struct dentry *dentry, const char *name, const void *value,
 {
 	struct inode *inode = dentry->d_inode;
 	struct inode *delegated_inode = NULL;
+	const void  *orig_value = value;
 	int error;
 
+	if (size && strcmp(name, XATTR_NAME_CAPS) == 0) {
+		error = cap_convert_nscap(dentry, &value, size);
+		if (error < 0)
+			return error;
+		size = error;
+	}
+
 retry_deleg:
 	inode_lock(inode);
 	error = __vfs_setxattr_locked(dentry, name, value, size, flags,
@@ -289,6 +297,9 @@ vfs_setxattr(struct dentry *dentry, const char *name, const void *value,
 		if (!error)
 			goto retry_deleg;
 	}
+	if (value != orig_value)
+		kfree(value);
+
 	return error;
 }
 EXPORT_SYMBOL_GPL(vfs_setxattr);
@@ -537,12 +548,6 @@ setxattr(struct dentry *d, const char __user *name, const void __user *value,
 		if ((strcmp(kname, XATTR_NAME_POSIX_ACL_ACCESS) == 0) ||
 		    (strcmp(kname, XATTR_NAME_POSIX_ACL_DEFAULT) == 0))
 			posix_acl_fix_xattr_from_user(kvalue, size);
-		else if (strcmp(kname, XATTR_NAME_CAPS) == 0) {
-			error = cap_convert_nscap(d, &kvalue, size);
-			if (error < 0)
-				goto out;
-			size = error;
-		}
 	}
 
 	error = vfs_setxattr(d, kname, kvalue, size, flags);
include/linux/capability.h +1 -1
index 1e7fe311cabe..b2f698915c0f 100644
@@ -270,6 +270,6 @@ static inline bool checkpoint_restore_ns_capable(struct user_namespace *ns)
 /* audit system wants to get cap info from files as well */
 extern int get_vfs_caps_from_disk(const struct dentry *dentry, struct cpu_vfs_cap_data *cpu_caps);
 
-extern int cap_convert_nscap(struct dentry *dentry, void **ivalue, size_t size);
+extern int cap_convert_nscap(struct dentry *dentry, const void **ivalue, size_t size);
 
 #endif /* !_LINUX_CAPABILITY_H */
security/commoncap.c +1 -2
index 59bf3c1674c8..bacc1111d871 100644
@@ -473,7 +473,7 @@ static bool validheader(size_t size, const struct vfs_cap_data *cap)
  *
  * If all is ok, we return the new size, on error return < 0.
  */
-int cap_convert_nscap(struct dentry *dentry, void **ivalue, size_t size)
+int cap_convert_nscap(struct dentry *dentry, const void **ivalue, size_t size)
 {
 	struct vfs_ns_cap_data *nscap;
 	uid_t nsrootid;
@@ -516,7 +516,6 @@ int cap_convert_nscap(struct dentry *dentry, void **ivalue, size_t size)
 	nscap->magic_etc = cpu_to_le32(nsmagic);
 	memcpy(&nscap->data, &cap->data, sizeof(__le32) * 2 * VFS_CAP_U32);
 
-	kvfree(*ivalue);
 	*ivalue = nscap;
 	return newsize;
 }
Signature · 1 line
2.26.2
maintainer Acked-by on v2 1/10
#2 lore raw

Re: [PATCH v2 01/10] vfs: move cap_convert_nscap() call into vfs_setxattr()

Quoted 7 lines · Miklos Szeredi

cap_convert_nscap() does permission checking as well as conversion of the xattr value conditionally based on fs's user-ns.

This is needed by overlayfs and probably other layered fs (ecryptfs) and is what vfs_foo() is supposed to do anyway.

Signature · 2 lines
James Morris
<[email protected]>
#3 lore raw

Re: [PATCH v2 01/10] vfs: move cap_convert_nscap() call into vfs_setxattr()

In reply to Miklos Szeredi
Quoted 5 lines · Miklos Szeredi

cap_convert_nscap() does permission checking as well as conversion of the xattr value conditionally based on fs's user-ns.

This is needed by overlayfs and probably other layered fs (ecryptfs) and is what vfs_foo() is supposed to do anyway.

Well crap.

I just noticed this and it turns out this change is wrong.

The problem is that it reads the rootid from the v3 fscap, using current_user_ns() and then writes it using the sb->s_user_ns.

So any time the stacked filesystems sb->s_user_ns do not match or current_user_ns does not match sb->s_user_ns this could be a problem.

In a stacked filesystem a second pass through vfs_setxattr will result in the rootid being translated a second time (with potentially the wrong namespaces). I think because of the security checks a we won't write something we shouldn't be able to write to the filesystem. Still we will be writing the wrong v3 fscap which can go quite badly.

This doesn't look terribly difficult to fix.

Probably convert this into a fs independent form using uids in init_user_ns at input and have cap_convert_nscap convert the v3 fscap into the filesystem dependent form. With some way for stackable filesystems to just skip converting it from the filesystem independent format.

Uids in xattrs that are expected to go directly to disk, but aren't always suitable for going directly to disk are tricky.

Eric

Quoted 84 lines
---
 fs/xattr.c                 | 17 +++++++++++------
 include/linux/capability.h |  2 +-
 security/commoncap.c       |  3 +--
 3 files changed, 13 insertions(+), 9 deletions(-)
fs/xattr.c +11 -6
index cd7a563e8bcd..fd57153b1f61 100644
@@ -276,8 +276,16 @@ vfs_setxattr(struct dentry *dentry, const char *name, const void *value,
 {
 	struct inode *inode = dentry->d_inode;
 	struct inode *delegated_inode = NULL;
+	const void  *orig_value = value;
 	int error;
 
+	if (size && strcmp(name, XATTR_NAME_CAPS) == 0) {
+		error = cap_convert_nscap(dentry, &value, size);
+		if (error < 0)
+			return error;
+		size = error;
+	}
+
 retry_deleg:
 	inode_lock(inode);
 	error = __vfs_setxattr_locked(dentry, name, value, size, flags,
@@ -289,6 +297,9 @@ vfs_setxattr(struct dentry *dentry, const char *name, const void *value,
 		if (!error)
 			goto retry_deleg;
 	}
+	if (value != orig_value)
+		kfree(value);
+
 	return error;
 }
 EXPORT_SYMBOL_GPL(vfs_setxattr);
@@ -537,12 +548,6 @@ setxattr(struct dentry *d, const char __user *name, const void __user *value,
 		if ((strcmp(kname, XATTR_NAME_POSIX_ACL_ACCESS) == 0) ||
 		    (strcmp(kname, XATTR_NAME_POSIX_ACL_DEFAULT) == 0))
 			posix_acl_fix_xattr_from_user(kvalue, size);
-		else if (strcmp(kname, XATTR_NAME_CAPS) == 0) {
-			error = cap_convert_nscap(d, &kvalue, size);
-			if (error < 0)
-				goto out;
-			size = error;
-		}
 	}
 
 	error = vfs_setxattr(d, kname, kvalue, size, flags);
include/linux/capability.h +1 -1
index 1e7fe311cabe..b2f698915c0f 100644
@@ -270,6 +270,6 @@ static inline bool checkpoint_restore_ns_capable(struct user_namespace *ns)
 /* audit system wants to get cap info from files as well */
 extern int get_vfs_caps_from_disk(const struct dentry *dentry, struct cpu_vfs_cap_data *cpu_caps);
 
-extern int cap_convert_nscap(struct dentry *dentry, void **ivalue, size_t size);
+extern int cap_convert_nscap(struct dentry *dentry, const void **ivalue, size_t size);
 
 #endif /* !_LINUX_CAPABILITY_H */
security/commoncap.c +1 -2
index 59bf3c1674c8..bacc1111d871 100644
@@ -473,7 +473,7 @@ static bool validheader(size_t size, const struct vfs_cap_data *cap)
  *
  * If all is ok, we return the new size, on error return < 0.
  */
-int cap_convert_nscap(struct dentry *dentry, void **ivalue, size_t size)
+int cap_convert_nscap(struct dentry *dentry, const void **ivalue, size_t size)
 {
 	struct vfs_ns_cap_data *nscap;
 	uid_t nsrootid;
@@ -516,7 +516,6 @@ int cap_convert_nscap(struct dentry *dentry, void **ivalue, size_t size)
 	nscap->magic_etc = cpu_to_le32(nsmagic);
 	memcpy(&nscap->data, &cap->data, sizeof(__le32) * 2 * VFS_CAP_U32);
 
-	kvfree(*ivalue);
 	*ivalue = nscap;
 	return newsize;
 }
maintainer
#4 lore raw

Re: [PATCH v2 01/10] vfs: move cap_convert_nscap() call into vfs_setxattr()

Quoted 26 lines · Eric W. Biederman
Quoted 5 lines · Miklos Szeredi

cap_convert_nscap() does permission checking as well as conversion of the xattr value conditionally based on fs's user-ns.

This is needed by overlayfs and probably other layered fs (ecryptfs) and is what vfs_foo() is supposed to do anyway.

Well crap.

I just noticed this and it turns out this change is wrong.

The problem is that it reads the rootid from the v3 fscap, using current_user_ns() and then writes it using the sb->s_user_ns.

So any time the stacked filesystems sb->s_user_ns do not match or current_user_ns does not match sb->s_user_ns this could be a problem.

In a stacked filesystem a second pass through vfs_setxattr will result in the rootid being translated a second time (with potentially the wrong namespaces). I think because of the security checks a we won't write something we shouldn't be able to write to the filesystem. Still we will be writing the wrong v3 fscap which can go quite badly.

This doesn't look terribly difficult to fix.

Quoted 8 lines

Probably convert this into a fs independent form using uids in init_user_ns at input and have cap_convert_nscap convert the v3 fscap into the filesystem dependent form. With some way for stackable filesystems to just skip converting it from the filesystem independent format.

Uids in xattrs that are expected to go directly to disk, but aren't always suitable for going directly to disk are tricky.

I've been looking at this for a couple of days and can't say I clearly understand everything yet.

For one: a v2 fscap is supposed to be equivalent to a v3 fscap with a rootid of zero, right?

If so, why does cap_inode_getsecurity() treat them differently (v2 fscap succeeding unconditionally while v3 one being either converted to v2, rejected or left as v3 depending on current_user_ns())?

Anyway, here's a patch that I think fixes getxattr() layering for security.capability. Does basically what you suggested. Slight change of semantics vs. v1 caps, not sure if that is still needed, getxattr()/setxattr() hasn't worked for these since the introduction of v3 in 4.14. Untested.

I still need to wrap my head around the permission requirements for the setxattr() case...

Thanks,
Miklos

---
 fs/overlayfs/super.c       |   15 +++
 include/linux/capability.h |    2 
 include/linux/fs.h         |    1 
 security/commoncap.c       |  210 ++++++++++++++++++++++++---------------------
 4 files changed, 132 insertions(+), 96 deletions(-)
fs/overlayfs/super.c +15 -0
@@ -395,6 +395,20 @@ static int ovl_remount(struct super_bloc
 	return ret;
 }
 
+static int ovl_cap_get(struct dentry *dentry,
+		       struct vfs_ns_cap_data *nscap)
+{
+	int res;
+	const struct cred *old_cred;
+	struct dentry *realdentry = ovl_dentry_real(dentry);
+
+	old_cred = ovl_override_creds(dentry->d_sb);
+	res = vfs_cap_get(realdentry, nscap);
+	revert_creds(old_cred);
+
+	return res;
+}
+
 static const struct super_operations ovl_super_operations = {
 	.alloc_inode	= ovl_alloc_inode,
 	.free_inode	= ovl_free_inode,
@@ -405,6 +419,7 @@ static const struct super_operations ovl
 	.statfs		= ovl_statfs,
 	.show_options	= ovl_show_options,
 	.remount_fs	= ovl_remount,
+	.cap_get	= ovl_cap_get,
 };
 
 enum {
include/linux/capability.h +2 -0
@@ -272,4 +272,6 @@ extern int get_vfs_caps_from_disk(const
 
 extern int cap_convert_nscap(struct dentry *dentry, const void **ivalue, size_t size);
 
+int vfs_cap_get(struct dentry *dentry, struct vfs_ns_cap_data *nscap);
+
 #endif /* !_LINUX_CAPABILITY_H */
include/linux/fs.h +1 -0
@@ -1963,6 +1963,7 @@ struct super_operations {
 				  struct shrink_control *);
 	long (*free_cached_objects)(struct super_block *,
 				    struct shrink_control *);
+	int (*cap_get)(struct dentry *dentry, struct vfs_ns_cap_data *nscap);
 };
 
 /*
security/commoncap.c +114 -96

292 lines not on this page · raw message

#5 lore raw

Re: [PATCH v2 01/10] vfs: move cap_convert_nscap() call into vfs_setxattr()

Quoted 33 lines · Miklos Szeredi
Quoted 32 lines · Eric W. Biederman
Quoted 5 lines · Miklos Szeredi

cap_convert_nscap() does permission checking as well as conversion of the xattr value conditionally based on fs's user-ns.

This is needed by overlayfs and probably other layered fs (ecryptfs) and is what vfs_foo() is supposed to do anyway.

Well crap.

I just noticed this and it turns out this change is wrong.

The problem is that it reads the rootid from the v3 fscap, using current_user_ns() and then writes it using the sb->s_user_ns.

So any time the stacked filesystems sb->s_user_ns do not match or current_user_ns does not match sb->s_user_ns this could be a problem.

In a stacked filesystem a second pass through vfs_setxattr will result in the rootid being translated a second time (with potentially the wrong namespaces). I think because of the security checks a we won't write something we shouldn't be able to write to the filesystem. Still we will be writing the wrong v3 fscap which can go quite badly.

This doesn't look terribly difficult to fix.

Probably convert this into a fs independent form using uids in init_user_ns at input and have cap_convert_nscap convert the v3 fscap into the filesystem dependent form. With some way for stackable filesystems to just skip converting it from the filesystem independent format.

Quoted 8 lines
Quoted 2 lines

Uids in xattrs that are expected to go directly to disk, but aren't always suitable for going directly to disk are tricky.

I've been looking at this for a couple of days and can't say I clearly understand everything yet.

For one: a v2 fscap is supposed to be equivalent to a v3 fscap with a rootid of zero, right?

Yes. This assumes that everything is translated into the uids of the target filesystem.

Quoted 3 lines

If so, why does cap_inode_getsecurity() treat them differently (v2 fscap succeeding unconditionally while v3 one being either converted to v2, rejected or left as v3 depending on current_user_ns())?

As I understand it v2 fscaps have always succeeded unconditionally. The only case I can see for a v2 fscap might not succeed when read is if the filesystem is outside of the initial user namespace.

Quoted 5 lines

Anyway, here's a patch that I think fixes getxattr() layering for security.capability. Does basically what you suggested. Slight change of semantics vs. v1 caps, not sure if that is still needed, getxattr()/setxattr() hasn't worked for these since the introduction of v3 in 4.14. Untested.

Taking a look. The goal of change how these operate is to make it so that layered filesystems can just pass through the data if they don't want to change anything (even with the user namespaces of the filesystems in question are different).

Feedback on the code below:
- cap_get should be in inode_operations like get_acl and set_acl.

- cap_get should return a cpu_vfs_cap_data.

Which means that only make_kuid is needed when reading the cap from disk.

Which means that except for the rootid_owns_currentns check (which needs to happen elsewhere) default_cap_get should be today's get_vfs_cap_from_disk.

- With the introduction of cap_get I believe commoncap should stop implementing the security_inode_getsecurity hook, and rather have getxattr observe is the file capability xatter and call the new vfs_cap_get then translate to a v2 or v3 cap as appropriate when returning the cap to userspace.

I think that would put the code on a solid comprehensible foundation.

Eric

Quoted 363 lines

I still need to wrap my head around the permission requirements for the setxattr() case...

Thanks,
Miklos

---
 fs/overlayfs/super.c       |   15 +++
 include/linux/capability.h |    2 
 include/linux/fs.h         |    1 
 security/commoncap.c       |  210 ++++++++++++++++++++++++---------------------
 4 files changed, 132 insertions(+), 96 deletions(-)
fs/overlayfs/super.c +15 -0
@@ -395,6 +395,20 @@ static int ovl_remount(struct super_bloc
 	return ret;
 }
 
+static int ovl_cap_get(struct dentry *dentry,
+		       struct vfs_ns_cap_data *nscap)
+{
+	int res;
+	const struct cred *old_cred;
+	struct dentry *realdentry = ovl_dentry_real(dentry);
+
+	old_cred = ovl_override_creds(dentry->d_sb);
+	res = vfs_cap_get(realdentry, nscap);
+	revert_creds(old_cred);
+
+	return res;
+}
+
 static const struct super_operations ovl_super_operations = {
 	.alloc_inode	= ovl_alloc_inode,
 	.free_inode	= ovl_free_inode,
@@ -405,6 +419,7 @@ static const struct super_operations ovl
 	.statfs		= ovl_statfs,
 	.show_options	= ovl_show_options,
 	.remount_fs	= ovl_remount,
+	.cap_get	= ovl_cap_get,
 };
 
 enum {
include/linux/capability.h +2 -0
@@ -272,4 +272,6 @@ extern int get_vfs_caps_from_disk(const
 
 extern int cap_convert_nscap(struct dentry *dentry, const void **ivalue, size_t size);
 
+int vfs_cap_get(struct dentry *dentry, struct vfs_ns_cap_data *nscap);
+
 #endif /* !_LINUX_CAPABILITY_H */
include/linux/fs.h +1 -0
@@ -1963,6 +1963,7 @@ struct super_operations {
 				  struct shrink_control *);
 	long (*free_cached_objects)(struct super_block *,
 				    struct shrink_control *);
+	int (*cap_get)(struct dentry *dentry, struct vfs_ns_cap_data *nscap);
 };
 
 /*
security/commoncap.c +114 -96
@@ -341,6 +341,13 @@ static __u32 sansflags(__u32 m)
 	return m & ~VFS_CAP_FLAGS_EFFECTIVE;
 }
 
+static bool is_v1header(size_t size, const struct vfs_cap_data *cap)
+{
+	if (size != XATTR_CAPS_SZ_1)
+		return false;
+	return sansflags(le32_to_cpu(cap->magic_etc)) == VFS_CAP_REVISION_1;
+}
+
 static bool is_v2header(size_t size, const struct vfs_cap_data *cap)
 {
 	if (size != XATTR_CAPS_SZ_2)
@@ -355,6 +362,72 @@ static bool is_v3header(size_t size, con
 	return sansflags(le32_to_cpu(cap->magic_etc)) == VFS_CAP_REVISION_3;
 }
 
+static bool validheader(size_t size, const struct vfs_cap_data *cap)
+{
+	return is_v1header(size, cap) || is_v2header(size, cap) || is_v3header(size, cap);
+}
+
+static void cap_to_v3(const struct vfs_cap_data *cap,
+			 struct vfs_ns_cap_data *nscap)
+{
+	u32 magic, nsmagic;
+
+	nsmagic = VFS_CAP_REVISION_3;
+	magic = le32_to_cpu(cap->magic_etc);
+	if (magic & VFS_CAP_FLAGS_EFFECTIVE)
+		nsmagic |= VFS_CAP_FLAGS_EFFECTIVE;
+	nscap->magic_etc = cpu_to_le32(nsmagic);
+	nscap->rootid = cpu_to_le32(0);
+}
+
+static int default_cap_get(struct dentry *dentry, struct vfs_ns_cap_data *nscap)
+{
+	int err;
+	ssize_t size;
+	kuid_t kroot;
+	uid_t root, mappedroot;
+	char *tmpbuf = NULL;
+	struct vfs_cap_data *cap;
+	struct user_namespace *fs_ns = dentry->d_sb->s_user_ns;
+
+	size = vfs_getxattr_alloc(dentry, XATTR_NAME_CAPS, &tmpbuf,
+				  sizeof(struct vfs_ns_cap_data), GFP_NOFS);
+	if (size < 0)
+		return size;
+
+	cap = (struct vfs_cap_data *) tmpbuf;
+	err = -EINVAL;
+	if (!validheader(size, cap))
+		goto out;
+
+	memset(nscap, 0, sizeof(*nscap));
+	memcpy(nscap, tmpbuf, size);
+	if (!is_v3header(size, cap))
+		cap_to_v3(cap, nscap);
+
+	/* Convert rootid from fs user namespace to init user namespace */
+	root = le32_to_cpu(nscap->rootid);
+	kroot = make_kuid(fs_ns, root);
+	mappedroot = from_kuid(&init_user_ns, kroot);
+	nscap->rootid = cpu_to_le32(mappedroot);
+
+	err = 0;
+out:
+	kfree(tmpbuf);
+	return err;
+}
+
+int vfs_cap_get(struct dentry *dentry, struct vfs_ns_cap_data *nscap)
+{
+	struct super_block *sb = dentry->d_sb;
+
+	if (sb->s_op->cap_get)
+		return sb->s_op->cap_get(dentry, nscap);
+	else
+		return default_cap_get(dentry, nscap);
+}
+EXPORT_SYMBOL(vfs_cap_get);
+
 /*
  * getsecurity: We are called for security.* before any attempt to read the
  * xattr from the inode itself.
@@ -369,14 +442,15 @@ static bool is_v3header(size_t size, con
 int cap_inode_getsecurity(struct inode *inode, const char *name, void **buffer,
 			  bool alloc)
 {
-	int size, ret;
+	int ret;
+	ssize_t size;
 	kuid_t kroot;
+	__le32 nsmagic, magic;
 	uid_t root, mappedroot;
-	char *tmpbuf = NULL;
+	void *tmpbuf = NULL;
 	struct vfs_cap_data *cap;
-	struct vfs_ns_cap_data *nscap;
+	struct vfs_ns_cap_data nscap;
 	struct dentry *dentry;
-	struct user_namespace *fs_ns;
 
 	if (strcmp(name, "capability") != 0)
 		return -EOPNOTSUPP;
@@ -385,67 +459,50 @@ int cap_inode_getsecurity(struct inode *
 	if (!dentry)
 		return -EINVAL;
 
-	size = sizeof(struct vfs_ns_cap_data);
-	ret = (int) vfs_getxattr_alloc(dentry, XATTR_NAME_CAPS,
-				 &tmpbuf, size, GFP_NOFS);
+	ret = vfs_cap_get(dentry, &nscap);
 	dput(dentry);
 
 	if (ret < 0)
 		return ret;
 
-	fs_ns = inode->i_sb->s_user_ns;
-	cap = (struct vfs_cap_data *) tmpbuf;
-	if (is_v2header((size_t) ret, cap)) {
-		/* If this is sizeof(vfs_cap_data) then we're ok with the
-		 * on-disk value, so return that.  */
-		if (alloc)
-			*buffer = tmpbuf;
-		else
-			kfree(tmpbuf);
-		return ret;
-	} else if (!is_v3header((size_t) ret, cap)) {
-		kfree(tmpbuf);
-		return -EINVAL;
-	}
+	tmpbuf = kmalloc(sizeof(struct vfs_ns_cap_data), GFP_NOFS);
+	if (!tmpbuf)
+		return -ENOMEM;
 
-	nscap = (struct vfs_ns_cap_data *) tmpbuf;
-	root = le32_to_cpu(nscap->rootid);
-	kroot = make_kuid(fs_ns, root);
+	root = le32_to_cpu(nscap.rootid);
+	kroot = make_kuid(&init_user_ns, root);
 
 	/* If the root kuid maps to a valid uid in current ns, then return
 	 * this as a nscap. */
 	mappedroot = from_kuid(current_user_ns(), kroot);
 	if (mappedroot != (uid_t)-1 && mappedroot != (uid_t)0) {
+		size = sizeof(struct vfs_cap_data);
 		if (alloc) {
 			*buffer = tmpbuf;
-			nscap->rootid = cpu_to_le32(mappedroot);
-		} else
-			kfree(tmpbuf);
-		return size;
+			tmpbuf = NULL;
+			nscap.rootid = cpu_to_le32(mappedroot);
+			memcpy(*buffer, &nscap, size);
+		}
+		goto out;
 	}
 
-	if (!rootid_owns_currentns(kroot)) {
-		kfree(tmpbuf);
-		return -EOPNOTSUPP;
-	}
+	size = -EOPNOTSUPP;
+	if (!rootid_owns_currentns(kroot))
+		goto out;
 
 	/* This comes from a parent namespace.  Return as a v2 capability */
 	size = sizeof(struct vfs_cap_data);
 	if (alloc) {
-		*buffer = kmalloc(size, GFP_ATOMIC);
-		if (*buffer) {
-			struct vfs_cap_data *cap = *buffer;
-			__le32 nsmagic, magic;
-			magic = VFS_CAP_REVISION_2;
-			nsmagic = le32_to_cpu(nscap->magic_etc);
-			if (nsmagic & VFS_CAP_FLAGS_EFFECTIVE)
-				magic |= VFS_CAP_FLAGS_EFFECTIVE;
-			memcpy(&cap->data, &nscap->data, sizeof(__le32) * 2 * VFS_CAP_U32);
-			cap->magic_etc = cpu_to_le32(magic);
-		} else {
-			size = -ENOMEM;
-		}
+		cap = *buffer = tmpbuf;
+		tmpbuf = NULL;
+		magic = VFS_CAP_REVISION_2;
+		nsmagic = le32_to_cpu(nscap.magic_etc);
+		if (nsmagic & VFS_CAP_FLAGS_EFFECTIVE)
+			magic |= VFS_CAP_FLAGS_EFFECTIVE;
+		memcpy(&cap->data, &nscap.data, sizeof(__le32) * 2 * VFS_CAP_U32);
+		cap->magic_etc = cpu_to_le32(magic);
 	}
+out:
 	kfree(tmpbuf);
 	return size;
 }
@@ -462,11 +519,6 @@ static kuid_t rootid_from_xattr(const vo
 	return make_kuid(task_ns, rootid);
 }
 
-static bool validheader(size_t size, const struct vfs_cap_data *cap)
-{
-	return is_v2header(size, cap) || is_v3header(size, cap);
-}
-
 /*
  * User requested a write of security.capability.  If needed, update the
  * xattr to change from v2 to v3, or to fixup the v3 rootid.
@@ -570,74 +622,40 @@ static inline int bprm_caps_from_vfs_cap
 int get_vfs_caps_from_disk(const struct dentry *dentry, struct cpu_vfs_cap_data *cpu_caps)
 {
 	struct inode *inode = d_backing_inode(dentry);
-	__u32 magic_etc;
-	unsigned tocopy, i;
-	int size;
-	struct vfs_ns_cap_data data, *nscaps = &data;
-	struct vfs_cap_data *caps = (struct vfs_cap_data *) &data;
-	kuid_t rootkuid;
-	struct user_namespace *fs_ns;
+	unsigned int i;
+	int ret;
+	struct vfs_ns_cap_data nscaps;
 
 	memset(cpu_caps, 0, sizeof(struct cpu_vfs_cap_data));
 
 	if (!inode)
 		return -ENODATA;
 
-	fs_ns = inode->i_sb->s_user_ns;
-	size = __vfs_getxattr((struct dentry *)dentry, inode,
-			      XATTR_NAME_CAPS, &data, XATTR_CAPS_SZ);
-	if (size == -ENODATA || size == -EOPNOTSUPP)
+	ret = vfs_cap_get((struct dentry *) dentry, &nscaps);
+	if (ret == -ENODATA || ret == -EOPNOTSUPP)
 		/* no data, that's ok */
 		return -ENODATA;
 
-	if (size < 0)
-		return size;
-
-	if (size < sizeof(magic_etc))
-		return -EINVAL;
-
-	cpu_caps->magic_etc = magic_etc = le32_to_cpu(caps->magic_etc);
+	if (ret < 0)
+		return ret;
 
-	rootkuid = make_kuid(fs_ns, 0);
-	switch (magic_etc & VFS_CAP_REVISION_MASK) {
-	case VFS_CAP_REVISION_1:
-		if (size != XATTR_CAPS_SZ_1)
-			return -EINVAL;
-		tocopy = VFS_CAP_U32_1;
-		break;
-	case VFS_CAP_REVISION_2:
-		if (size != XATTR_CAPS_SZ_2)
-			return -EINVAL;
-		tocopy = VFS_CAP_U32_2;
-		break;
-	case VFS_CAP_REVISION_3:
-		if (size != XATTR_CAPS_SZ_3)
-			return -EINVAL;
-		tocopy = VFS_CAP_U32_3;
-		rootkuid = make_kuid(fs_ns, le32_to_cpu(nscaps->rootid));
-		break;
+	cpu_caps->magic_etc = le32_to_cpu(nscaps.magic_etc);
+	cpu_caps->rootid = make_kuid(&init_user_ns, le32_to_cpu(nscaps.rootid));
 
-	default:
-		return -EINVAL;
-	}
 	/* Limit the caps to the mounter of the filesystem
 	 * or the more limited uid specified in the xattr.
 	 */
-	if (!rootid_owns_currentns(rootkuid))
+	if (!rootid_owns_currentns(cpu_caps->rootid))
 		return -ENODATA;
 
 	CAP_FOR_EACH_U32(i) {
-		if (i >= tocopy)
-			break;
-		cpu_caps->permitted.cap[i] = le32_to_cpu(caps->data[i].permitted);
-		cpu_caps->inheritable.cap[i] = le32_to_cpu(caps->data[i].inheritable);
+		cpu_caps->permitted.cap[i] = le32_to_cpu(nscaps.data[i].permitted);
+		cpu_caps->inheritable.cap[i] = le32_to_cpu(nscaps.data[i].inheritable);
 	}
 
 	cpu_caps->permitted.cap[CAP_LAST_U32] &= CAP_LAST_U32_VALID_MASK;
 	cpu_caps->inheritable.cap[CAP_LAST_U32] &= CAP_LAST_U32_VALID_MASK;
 
-	cpu_caps->rootid = rootkuid;
-
 	return 0;
 }
 
maintainer
#6 lore raw

Re: [PATCH v2 01/10] vfs: move cap_convert_nscap() call into vfs_setxattr()

Quoted 11 lines · Eric W. Biederman
Quoted 4 lines · Miklos Szeredi

On Fri, Jan 01, 2021 at 11:35:16AM -0600, Eric W. Biederman wrote:

For one: a v2 fscap is supposed to be equivalent to a v3 fscap with a rootid of zero, right?

Yes. This assumes that everything is translated into the uids of the target filesystem.

Quoted 7 lines
Quoted 3 lines

If so, why does cap_inode_getsecurity() treat them differently (v2 fscap succeeding unconditionally while v3 one being either converted to v2, rejected or left as v3 depending on current_user_ns())?

As I understand it v2 fscaps have always succeeded unconditionally. The only case I can see for a v2 fscap might not succeed when read is if the filesystem is outside of the initial user namespace.

Looking again, it's rather confusing. cap_inode_getsecurity() currently handles the following cases:

v1: -> fails with -EINVAL

v2: -> returns unconverted xattr

v3:
a) rootid is mapped in the current namespace to non-zero:

     -> convert rootid

b) rootid owns the current or ancerstor namespace:

     -> convert to v2

c) rootid is not mapped and is not owner:

     -> return -EOPNOTSUPP -> falls back to unconverted v3

So lets take the example, where a tmpfs is created in a private user namespace and one file has a v2 cap and the other an equivalent v3 cap with a zero rootid. This is the result when looking at it from

1) the namespace of the fs:
---------------------------------------
t = cap_dac_override+eip
tt = cap_dac_override+eip

2) the initial namespace:
---------------------------------------
t = cap_dac_override+eip
tt = cap_dac_override+eip [rootid=1000]

3) an unrelated namespace:
---------------------------------------
t = cap_dac_override+eip
tt = cap_dac_override+eip

Note: in this last case getxattr will actually return a v3 cap with zero rootid for "tt" which getcap does not display due to being zero. I could do a setup with a nested namespaces that better demonstrate the confusing nature of this, but I think this also proves the point.

At this point userspace simply cannot determine whether the returned cap is in any way valid or not.

The following semantics would make a ton more sense, since getting a v2 would indicate that rootid is unknown:

- if cap is v2 convert to v3 with zero rootid
- after this, check if rootid needs to be translated, if not return v3
- if yes, try to translate to current ns, if succeeds return translated v3
- if not mappable, return v2

Hmm?

Quoted 6 lines
Quoted 5 lines

Anyway, here's a patch that I think fixes getxattr() layering for security.capability. Does basically what you suggested. Slight change of semantics vs. v1 caps, not sure if that is still needed, getxattr()/setxattr() hasn't worked for these since the introduction of v3 in 4.14. Untested.

Quoted 7 lines

Taking a look. The goal of change how these operate is to make it so that layered filesystems can just pass through the data if they don't want to change anything (even with the user namespaces of the filesystems in question are different).

Feedback on the code below:
- cap_get should be in inode_operations like get_acl and set_acl.

So it's not clear to me why xattr ops are per-sb and acl ops are per-inode.

Quoted 4 lines

- cap_get should return a cpu_vfs_cap_data.

Which means that only make_kuid is needed when reading the cap from disk.

It also means translating the cap bits back and forth between disk and cpu endian. Not a big deal, but...

Quoted 3 lines

Which means that except for the rootid_owns_currentns check (which needs to happen elsewhere) default_cap_get should be today's get_vfs_cap_from_disk.

That's true. So what's the deal with v1 caps? Support was silently
dropped for getxattr/setxattr but remained in get_vfs_caps_from_disk() (I guess to not break legacy disk images), but maybe it's time to deprecate v1 caps completely?

Quoted 5 lines

- With the introduction of cap_get I believe commoncap should stop implementing the security_inode_getsecurity hook, and rather have getxattr observe is the file capability xatter and call the new vfs_cap_get then translate to a v2 or v3 cap as appropriate when returning the cap to userspace.

Confused. vfs_cap_get() is the one the layered filesystem will
recurse with, so it must not translate the cap. The one to do that
would be __vfs_getxattr(), right?

Thanks,
Miklos

maintainer
#7 lore raw

Re: [PATCH v2 01/10] vfs: move cap_convert_nscap() call into vfs_setxattr()

Quoted 9 lines · Miklos Szeredi

The following semantics would make a ton more sense, since getting a v2 would indicate that rootid is unknown:

- if cap is v2 convert to v3 with zero rootid
- after this, check if rootid needs to be translated, if not return v3
- if yes, try to translate to current ns, if succeeds return translated v3
- if not mappable, return v2

Hmm?

Actually, it would make even more sense to simply skip unconvertible caps and return -ENODATA. In fact that's what I thought would happen until I looked at the -EOPNOTSUPP fallback code in vfs_getxattr().

Serge, do you remember what was the reason for the unconverted fallback?

Thanks,
Miklos

#8 lore raw

Re: [PATCH v2 01/10] vfs: move cap_convert_nscap() call into vfs_setxattr()

In reply to Miklos Szeredi
Quoted 56 lines · Miklos Szeredi
Quoted 11 lines · Eric W. Biederman
Quoted 4 lines · Miklos Szeredi

On Fri, Jan 01, 2021 at 11:35:16AM -0600, Eric W. Biederman wrote:

For one: a v2 fscap is supposed to be equivalent to a v3 fscap with a rootid of zero, right?

Yes. This assumes that everything is translated into the uids of the target filesystem.

Quoted 7 lines
Quoted 3 lines

If so, why does cap_inode_getsecurity() treat them differently (v2 fscap succeeding unconditionally while v3 one being either converted to v2, rejected or left as v3 depending on current_user_ns())?

As I understand it v2 fscaps have always succeeded unconditionally. The only case I can see for a v2 fscap might not succeed when read is if the filesystem is outside of the initial user namespace.

Looking again, it's rather confusing. cap_inode_getsecurity() currently handles the following cases:

v1: -> fails with -EINVAL

v2: -> returns unconverted xattr

v3:
a) rootid is mapped in the current namespace to non-zero:

     -> convert rootid

b) rootid owns the current or ancerstor namespace:

     -> convert to v2

c) rootid is not mapped and is not owner:

     -> return -EOPNOTSUPP -> falls back to unconverted v3

So lets take the example, where a tmpfs is created in a private user namespace and one file has a v2 cap and the other an equivalent v3 cap with a zero rootid. This is the result when looking at it from

1) the namespace of the fs:
---------------------------------------
t = cap_dac_override+eip
tt = cap_dac_override+eip

2) the initial namespace:
---------------------------------------
t = cap_dac_override+eip
tt = cap_dac_override+eip [rootid=1000]

3) an unrelated namespace:
---------------------------------------
t = cap_dac_override+eip
tt = cap_dac_override+eip

Quoted 4 lines

Note: in this last case getxattr will actually return a v3 cap with zero rootid for "tt" which getcap does not display due to being zero. I could do a setup with a nested namespaces that better demonstrate the confusing nature of this, but I think this also proves the point.

Yes. There is real confusion on the reading case when the namespaces do not match.

Quoted 6 lines

At this point userspace simply cannot determine whether the returned cap is in any way valid or not.

The following semantics would make a ton more sense, since getting a v2 would indicate that rootid is unknown:

Quoted 6 lines

- if cap is v2 convert to v3 with zero rootid
- after this, check if rootid needs to be translated, if not return v3
- if yes, try to translate to current ns, if succeeds return translated v3
- if not mappable, return v2

Hmm?

So there is the basic question do we want to read the raw bytes on disk or do we want to return something meaningful to the reader. As the existing tools use the xattr interface to set/clear fscaps returning data to user space rather than raw bytes seems the perfered interface.

My ideal semantics would be:

- If current_user_ns() == sb->s_user_ns return the raw data.

I don't know how to implement this first scenario while permitting stacked filesystems.

- Calculate the cpu_vfs_cap_data as get_vfs_caps_from_disk does. That gives the meaning of the xattr.

- If "from_kuid(current_userns(), krootid) == 0" return a v2 cap.

- If "rootid_owns_currentns()" return a v2 cap.

- Else return an error. Probably a permission error.

The fscap simply can not make sense to the user if the rootid does not map. Return a v2 cap would imply that the caps are present on the executable (in the current context) which they are not.

Quoted 11 lines
Quoted 11 lines
Quoted 5 lines

Anyway, here's a patch that I think fixes getxattr() layering for security.capability. Does basically what you suggested. Slight change of semantics vs. v1 caps, not sure if that is still needed, getxattr()/setxattr() hasn't worked for these since the introduction of v3 in 4.14. Untested.

Taking a look. The goal of change how these operate is to make it so that layered filesystems can just pass through the data if they don't want to change anything (even with the user namespaces of the filesystems in question are different).

Quoted 4 lines
Quoted 2 lines

Feedback on the code below:
- cap_get should be in inode_operations like get_acl and set_acl.

So it's not clear to me why xattr ops are per-sb and acl ops are per-inode.

I don't know why either. What I do see is everything except inode->i_sb->s_xattr (the list of xattr handlers) is in inode_operations.

Especially permission. So just for consistency I would keep everything in the inode_operations.

Quoted 7 lines
Quoted 4 lines

- cap_get should return a cpu_vfs_cap_data.

Which means that only make_kuid is needed when reading the cap from disk.

It also means translating the cap bits back and forth between disk and cpu endian. Not a big deal, but...

For the very rare case of userspace reading and writing them.

For the common case of actually using them it should be optimal, and it allows for non-standard implementations. Anything where someone gets clever we want the bits to be in cpu format to make mistakes harder.

Quoted 8 lines
Quoted 3 lines

Which means that except for the rootid_owns_currentns check (which needs to happen elsewhere) default_cap_get should be today's get_vfs_cap_from_disk.

That's true. So what's the deal with v1 caps? Support was silently
dropped for getxattr/setxattr but remained in get_vfs_caps_from_disk() (I guess to not break legacy disk images), but maybe it's time to deprecate v1 caps completely?

I really don't remember. When I look I see they appear to be a subset of v2 caps. I would have to look to see if they bits might have a different meaning.

Quoted 9 lines
Quoted 5 lines

- With the introduction of cap_get I believe commoncap should stop implementing the security_inode_getsecurity hook, and rather have getxattr observe is the file capability xatter and call the new vfs_cap_get then translate to a v2 or v3 cap as appropriate when returning the cap to userspace.

Confused. vfs_cap_get() is the one the layered filesystem will
recurse with, so it must not translate the cap. The one to do that
would be __vfs_getxattr(), right?

So there are two layers that I am worrying about.

The layer dealing with fscaps knowing they are fscaps. That is vfs_cap_get and friends.

Then there is the layer dealing with xattrs which should also handle fscaps. So that the xattr layer stacks properly I believe we need to completely bypass vfs_getxattr and friends and at the edge of userspace before there is any possibility of interception call vfs_cap_get and translate the result to a form userspace can consume.

With xattrs and caps we are in part of the kernel that hasn't seen a lot of attention and so is not the best factored. So I am proposing we fix up the abstractions to make it easier to implement stacked fscap support.

Eric

#9 lore raw

Re: [PATCH v2 01/10] vfs: move cap_convert_nscap() call into vfs_setxattr()

Quoted 11 lines · [email protected] (Eric W. Biederman) writes:

So there is the basic question do we want to read the raw bytes on disk or do we want to return something meaningful to the reader. As the existing tools use the xattr interface to set/clear fscaps returning data to user space rather than raw bytes seems the perfered interface.

My ideal semantics would be:

- If current_user_ns() == sb->s_user_ns return the raw data.

I don't know how to implement this first scenario while permitting stacked filesystems.

After a little more thought I do.

In getxattr if the get_cap method is not implemented by the filesystem if current_user_ns() == sb->s_user_ns simply treat it as an ordinary xattr read/write.

Otherwise call vfs_get_cap and translate the result as described below.

The key point of this is it allows for seeing what is actually on disk (when it is not confusing).

Quoted 5 lines

- Calculate the cpu_vfs_cap_data as get_vfs_caps_from_disk does. That gives the meaning of the xattr.

- If "from_kuid(current_userns(), krootid) == 0" return a v2 cap.

Quoted 7 lines

- If "rootid_owns_currentns()" return a v2 cap.

- Else return an error. Probably a permission error.

The fscap simply can not make sense to the user if the rootid does not map. Return a v2 cap would imply that the caps are present on the executable (in the current context) which they are not.

Eric

#10 lore raw

PATCH v2 2/10 vfs: verify source area in vfs_dedupe_file_range_one()

In reply to Miklos Szeredi

Call remap_verify_area() on the source file as well as the destination.

When called from vfs_dedupe_file_range() the check as already been performed, but not so if called from layered fs (overlayfs, etc...)

Could ommit the redundant check in vfs_dedupe_file_range(), but leave for now to get error early (for fear of breaking backward compatibility).

This call shouldn't be performance sensitive.

---
 fs/remap_range.c | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)
fs/remap_range.c +9 -1
index e6099beefa97..77dba3a49e65 100644
@@ -456,8 +456,16 @@ loff_t vfs_dedupe_file_range_one(struct file *src_file, loff_t src_pos,
 	if (ret)
 		return ret;
 
+	/*
+	 * This is redundant if called from vfs_dedupe_file_range(), but other
+	 * callers need it and it's not performance sesitive...
+	 */
+	ret = remap_verify_area(src_file, src_pos, len, false);
+	if (ret)
+		goto out_drop_write;
+
 	ret = remap_verify_area(dst_file, dst_pos, len, true);
-	if (ret < 0)
+	if (ret)
 		goto out_drop_write;
 
 	ret = -EPERM;
Signature · 1 line
2.26.2
#11 lore raw

PATCH v2 3/10 ovl: check privs before decoding file handle

In reply to Miklos Szeredi

CAP_DAC_READ_SEARCH is required by open_by_handle_at(2) so check it in ovl_decode_real_fh() as well to prevent privilege escalation for unprivileged overlay mounts.

---
 fs/overlayfs/namei.c | 3 +++
 1 file changed, 3 insertions(+)
fs/overlayfs/namei.c +3 -0
index a6162c4076db..82a55fdb1e7a 100644
@@ -156,6 +156,9 @@ struct dentry *ovl_decode_real_fh(struct ovl_fh *fh, struct vfsmount *mnt,
 	struct dentry *real;
 	int bytes;
 
+	if (!capable(CAP_DAC_READ_SEARCH))
+		return NULL;
+
 	/*
 	 * Make sure that the stored uuid matches the uuid of the lower
 	 * layer where file handle will be decoded.
Signature · 1 line
2.26.2
maintainer
#12 lore raw

Re: [PATCH v2 03/10] ovl: check privs before decoding file handle

Quoted 15 lines · Miklos Szeredi

CAP_DAC_READ_SEARCH is required by open_by_handle_at(2) so check it in ovl_decode_real_fh() as well to prevent privilege escalation for unprivileged overlay mounts.

---
 fs/overlayfs/namei.c | 3 +++
 1 file changed, 3 insertions(+)
fs/overlayfs/namei.c +0 -0
index a6162c4076db..82a55fdb1e7a 100644

fs/overlayfs/namei.c struct dentry *ovl_decode_real_fh(struct ovl_fh *fh, struct vfsmount *mnt, · line 161

Quoted 6 lines
fs/overlayfs/namei.c +3 -0
@@ -156,6 +156,9 @@ struct dentry *ovl_decode_real_fh(struct ovl_fh *fh, struct vfsmount *mnt,
        struct dentry *real;
        int bytes;
 
+       if (!capable(CAP_DAC_READ_SEARCH))
+               return NULL;
+

If the mounter is not capable in init ns, ovl_check_origin() and ovl_verify_index()
will not function as expected and this will break index and nfs export features. So I think we need to also check capability in ovl_can_decode_fh(), to auto disable those features.

Thanks,
Amir.

maintainer
#13 lore raw

Re: [PATCH v2 03/10] ovl: check privs before decoding file handle

Quoted 20 lines · Amir Goldstein
Quoted 18 lines · Miklos Szeredi

CAP_DAC_READ_SEARCH is required by open_by_handle_at(2) so check it in ovl_decode_real_fh() as well to prevent privilege escalation for unprivileged overlay mounts.

---
 fs/overlayfs/namei.c | 3 +++
 1 file changed, 3 insertions(+)
fs/overlayfs/namei.c +0 -0
index a6162c4076db..82a55fdb1e7a 100644
@@ -156,6 +156,9 @@ struct dentry *ovl_decode_real_fh(struct ovl_fh *fh, struct vfsmount *mnt,
        struct dentry *real;
        int bytes;
 
Quoted 7 lines

fs/overlayfs/namei.c struct dentry *ovl_decode_real_fh(struct ovl_fh *fh, struct vfsmount *mnt, · line 161

Quoted 3 lines
fs/overlayfs/namei.c +3 -0
+       if (!capable(CAP_DAC_READ_SEARCH))
+               return NULL;
+

If the mounter is not capable in init ns, ovl_check_origin() and ovl_verify_index()
will not function as expected and this will break index and nfs export features.

NFS export is clear-cut.

Hard link indexing should work without fh decoding, since it is only encoding the file handle to search for the index entry, and encoding is not privileged.

Not sure how ovl_verify_index will choke on that, will have to try... but worse case we just need to disable verification.

And yeah, using .overlay.origin attribute for inode number consistency won't work either, but it should fail silently (which is probably a good thing). Haven't tested this yet, though.

Thanks,
Miklos

maintainer
#14 lore raw

Re: [PATCH v2 03/10] ovl: check privs before decoding file handle

Quoted 3 lines · Miklos Szeredi

Hard link indexing should work without fh decoding, since it is only encoding the file handle to search for the index entry, and encoding is not privileged.

Tested this a bit and while hard link indexing does work, inode lookup is broken since it uses the origin inode as a key (which is not available) instead of using the origin value directly. This is fixable, but needs a fair amount of restructuring, so let's just postpone this and disable index for now, as you suggested.

Thanks,
Miklos

maintainer
#15 lore raw

Re: [PATCH v2 03/10] ovl: check privs before decoding file handle

Quoted 9 lines · Miklos Szeredi
Quoted 3 lines · Miklos Szeredi

Hard link indexing should work without fh decoding, since it is only encoding the file handle to search for the index entry, and encoding is not privileged.

Tested this a bit and while hard link indexing does work, inode lookup is broken since it uses the origin inode as a key (which is not

Yes, that is what I meant by ovl_check_origin() is broken.

Quoted 2 lines

available) instead of using the origin value directly. This is fixable, but needs a fair amount of restructuring, so let's just

Maybe it also requires on-disk changes.
We should be able to use the origin fh as the key for lower inode, but we need the lower st_inode for initializing the ovl inode with correct ino. If we cannot decode lower inode from origin fh, I think we would need to store the ino in user.overlay.ino on copy up or maintain redirect, but redirect is not supported either with user ns mount...

Quoted 2 lines

postpone this and disable index for now, as you suggested.

Nobody seems to be enabling it anyway :-/

Thanks,
Amir.

#16 lore raw

PATCH v2 4/10 ovl: make ioctl() safe

In reply to Miklos Szeredi

ovl_ioctl_set_flags() does a capability check using flags, but then the real ioctl double-fetches flags and uses potentially different value.

The "Check the capability before cred override" comment misleading: user can skip this check by presenting benign flags first and then overwriting them to non-benign flags.

Just remove the cred override for now, hoping this doesn't cause a regression.

The proper solution is to create a new setxflags i_op (patches are in the works).

Xfstests don't show a regression.

---
 fs/overlayfs/file.c | 75 ++-------------------------------------------
 1 file changed, 3 insertions(+), 72 deletions(-)
fs/overlayfs/file.c +3 -72
index efccb7c1f9bc..3cd1590f2030 100644
@@ -541,46 +541,26 @@ static long ovl_real_ioctl(struct file *file, unsigned int cmd,
 			   unsigned long arg)
 {
 	struct fd real;
-	const struct cred *old_cred;
 	long ret;
 
 	ret = ovl_real_fdget(file, &real);
 	if (ret)
 		return ret;
 
-	old_cred = ovl_override_creds(file_inode(file)->i_sb);
 	ret = security_file_ioctl(real.file, cmd, arg);
 	if (!ret)
 		ret = vfs_ioctl(real.file, cmd, arg);
-	revert_creds(old_cred);
 
 	fdput(real);
 
 	return ret;
 }
 
-static unsigned int ovl_iflags_to_fsflags(unsigned int iflags)
-{
-	unsigned int flags = 0;
-
-	if (iflags & S_SYNC)
-		flags |= FS_SYNC_FL;
-	if (iflags & S_APPEND)
-		flags |= FS_APPEND_FL;
-	if (iflags & S_IMMUTABLE)
-		flags |= FS_IMMUTABLE_FL;
-	if (iflags & S_NOATIME)
-		flags |= FS_NOATIME_FL;
-
-	return flags;
-}
-
 static long ovl_ioctl_set_flags(struct file *file, unsigned int cmd,
-				unsigned long arg, unsigned int flags)
+				unsigned long arg)
 {
 	long ret;
 	struct inode *inode = file_inode(file);
-	unsigned int oldflags;
 
 	if (!inode_owner_or_capable(inode))
 		return -EACCES;
@@ -591,12 +571,6 @@ static long ovl_ioctl_set_flags(struct file *file, unsigned int cmd,
 
 	inode_lock(inode);
 
-	/* Check the capability before cred override */
-	oldflags = ovl_iflags_to_fsflags(READ_ONCE(inode->i_flags));
-	ret = vfs_ioc_setflags_prepare(inode, oldflags, flags);
-	if (ret)
-		goto unlock;
-
 	ret = ovl_maybe_copy_up(file_dentry(file), O_WRONLY);
 	if (ret)
 		goto unlock;
@@ -613,46 +587,6 @@ static long ovl_ioctl_set_flags(struct file *file, unsigned int cmd,
 
 }
 
-static long ovl_ioctl_set_fsflags(struct file *file, unsigned int cmd,
-				  unsigned long arg)
-{
-	unsigned int flags;
-
-	if (get_user(flags, (int __user *) arg))
-		return -EFAULT;
-
-	return ovl_ioctl_set_flags(file, cmd, arg, flags);
-}
-
-static unsigned int ovl_fsxflags_to_fsflags(unsigned int xflags)
-{
-	unsigned int flags = 0;
-
-	if (xflags & FS_XFLAG_SYNC)
-		flags |= FS_SYNC_FL;
-	if (xflags & FS_XFLAG_APPEND)
-		flags |= FS_APPEND_FL;
-	if (xflags & FS_XFLAG_IMMUTABLE)
-		flags |= FS_IMMUTABLE_FL;
-	if (xflags & FS_XFLAG_NOATIME)
-		flags |= FS_NOATIME_FL;
-
-	return flags;
-}
-
-static long ovl_ioctl_set_fsxflags(struct file *file, unsigned int cmd,
-				   unsigned long arg)
-{
-	struct fsxattr fa;
-
-	memset(&fa, 0, sizeof(fa));
-	if (copy_from_user(&fa, (void __user *) arg, sizeof(fa)))
-		return -EFAULT;
-
-	return ovl_ioctl_set_flags(file, cmd, arg,
-				   ovl_fsxflags_to_fsflags(fa.fsx_xflags));
-}
-
 long ovl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
 	long ret;
@@ -663,12 +597,9 @@ long ovl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 		ret = ovl_real_ioctl(file, cmd, arg);
 		break;
 
-	case FS_IOC_SETFLAGS:
-		ret = ovl_ioctl_set_fsflags(file, cmd, arg);
-		break;
-
 	case FS_IOC_FSSETXATTR:
-		ret = ovl_ioctl_set_fsxflags(file, cmd, arg);
+	case FS_IOC_SETFLAGS:
+		ret = ovl_ioctl_set_flags(file, cmd, arg);
 		break;
 
 	default:
Signature · 1 line
2.26.2
maintainer Reviewed-by on v2 4/10
#17 lore raw

Re: [PATCH v2 04/10] ovl: make ioctl() safe

Quoted 11 lines · Miklos Szeredi

ovl_ioctl_set_flags() does a capability check using flags, but then the real ioctl double-fetches flags and uses potentially different value.

The "Check the capability before cred override" comment misleading: user can skip this check by presenting benign flags first and then overwriting them to non-benign flags.

Just remove the cred override for now, hoping this doesn't cause a regression.

Quoted 7 lines

The proper solution is to create a new setxflags i_op (patches are in the works).

Xfstests don't show a regression.

Looks reasonable

Quoted 20 lines
---
 fs/overlayfs/file.c | 75 ++-------------------------------------------
 1 file changed, 3 insertions(+), 72 deletions(-)
fs/overlayfs/file.c +0 -2
index efccb7c1f9bc..3cd1590f2030 100644
@@ -541,46 +541,26 @@ static long ovl_real_ioctl(struct file *file, unsigned int cmd,
                           unsigned long arg)
 {
        struct fd real;
-       const struct cred *old_cred;
        long ret;
 
        ret = ovl_real_fdget(file, &real);
        if (ret)
                return ret;
 
-       old_cred = ovl_override_creds(file_inode(file)->i_sb);

fs/overlayfs/file.c static long ovl_real_ioctl(struct file *file, unsigned int cmd, · line 558

Quoted 10 lines
fs/overlayfs/file.c +0 -1
        ret = security_file_ioctl(real.file, cmd, arg);
        if (!ret)
                ret = vfs_ioctl(real.file, cmd, arg);
-       revert_creds(old_cred);
 
        fdput(real);
 
        return ret;
 }
 

I wonder if we shouldn't leave a comment behind to explain that no override is intentional.

I also wonder if "Permission model" sections shouldn't be saying something about ioctl() (current task checks only)? or we just treat this is a breakage of the permission model that needs to be fixed?

Thanks,
Amir.

maintainer
#18 lore raw

Re: [PATCH v2 04/10] ovl: make ioctl() safe

Quoted 52 lines · Amir Goldstein
Quoted 11 lines · Miklos Szeredi

ovl_ioctl_set_flags() does a capability check using flags, but then the real ioctl double-fetches flags and uses potentially different value.

The "Check the capability before cred override" comment misleading: user can skip this check by presenting benign flags first and then overwriting them to non-benign flags.

Just remove the cred override for now, hoping this doesn't cause a regression.

Quoted 7 lines

The proper solution is to create a new setxflags i_op (patches are in the works).

Xfstests don't show a regression.

Looks reasonable

Quoted 27 lines
---
 fs/overlayfs/file.c | 75 ++-------------------------------------------
 1 file changed, 3 insertions(+), 72 deletions(-)
fs/overlayfs/file.c +0 -3
index efccb7c1f9bc..3cd1590f2030 100644
@@ -541,46 +541,26 @@ static long ovl_real_ioctl(struct file *file, unsigned int cmd,
                           unsigned long arg)
 {
        struct fd real;
-       const struct cred *old_cred;
        long ret;
 
        ret = ovl_real_fdget(file, &real);
        if (ret)
                return ret;
 
-       old_cred = ovl_override_creds(file_inode(file)->i_sb);
        ret = security_file_ioctl(real.file, cmd, arg);
        if (!ret)
                ret = vfs_ioctl(real.file, cmd, arg);
-       revert_creds(old_cred);
 
        fdput(real);
 
Quoted 7 lines

fs/overlayfs/file.c static long ovl_real_ioctl(struct file *file, unsigned int cmd, · line 558

Quoted 3 lines
fs/overlayfs/file.c +0 -0
        return ret;
 }
 

I wonder if we shouldn't leave a comment behind to explain that no override is intentional.

Comment added.

Quoted 3 lines

I also wonder if "Permission model" sections shouldn't be saying something about ioctl() (current task checks only)? or we just treat this is a breakage of the permission model that needs to be fixed?

This is a breakage of the permission model. But I don't think this is a serious breakage, or one that actually matters.

Not sure which is better: adding exceptions to the model or applying the model in situations where it's unnecessary. I'd rather go with the latter, but clearly in this case that was the wrong decision.

Thanks,
Miklos

maintainer
#19 lore raw

Re: [PATCH v2 04/10] ovl: make ioctl() safe

Quoted 62 lines · Miklos Szeredi
Quoted 52 lines · Amir Goldstein
Quoted 11 lines · Miklos Szeredi

ovl_ioctl_set_flags() does a capability check using flags, but then the real ioctl double-fetches flags and uses potentially different value.

The "Check the capability before cred override" comment misleading: user can skip this check by presenting benign flags first and then overwriting them to non-benign flags.

Just remove the cred override for now, hoping this doesn't cause a regression.

Quoted 7 lines

The proper solution is to create a new setxflags i_op (patches are in the works).

Xfstests don't show a regression.

Looks reasonable

Quoted 27 lines
---
 fs/overlayfs/file.c | 75 ++-------------------------------------------
 1 file changed, 3 insertions(+), 72 deletions(-)
fs/overlayfs/file.c +0 -3
index efccb7c1f9bc..3cd1590f2030 100644
@@ -541,46 +541,26 @@ static long ovl_real_ioctl(struct file *file, unsigned int cmd,
                           unsigned long arg)
 {
        struct fd real;
-       const struct cred *old_cred;
        long ret;
 
        ret = ovl_real_fdget(file, &real);
        if (ret)
                return ret;
 
-       old_cred = ovl_override_creds(file_inode(file)->i_sb);
        ret = security_file_ioctl(real.file, cmd, arg);
        if (!ret)
                ret = vfs_ioctl(real.file, cmd, arg);
-       revert_creds(old_cred);
 
        fdput(real);
 
Quoted 7 lines

fs/overlayfs/file.c static long ovl_real_ioctl(struct file *file, unsigned int cmd, · line 558

Quoted 3 lines
fs/overlayfs/file.c +0 -0
        return ret;
 }
 

I wonder if we shouldn't leave a comment behind to explain that no override is intentional.

Quoted 9 lines

Comment added.

Quoted 3 lines

I also wonder if "Permission model" sections shouldn't be saying something about ioctl() (current task checks only)? or we just treat this is a breakage of the permission model that needs to be fixed?

This is a breakage of the permission model. But I don't think this is a serious breakage, or one that actually matters.

Perhaps, but there is a much bigger issue with this change IMO. Not because of dropping rule (b) of the permission model, but because of relaxing rule (a).

Should overlayfs respect the conservative interpretation as it partly did until this commit, a lower file must not lose IMMUTABLE/APPEND_ONLY after copy up, but that is exactly what is going to happen if we first copy up and then fail permission check on setting the flags.

It's true that before this change, file could still be copied up and system crash would leave it without the flags, but after the change it is much worse as the flags completely lose their meaning on lower files when any unprivileged process can remove them.

So I suggest that you undo all the changes except for the no override.

And this calls for a fork of generic/545 to overlay test with lower files.

Thanks,
Amir.

maintainer
#20 lore raw

Re: [PATCH v2 04/10] ovl: make ioctl() safe

Quoted 8 lines · Amir Goldstein

Perhaps, but there is a much bigger issue with this change IMO. Not because of dropping rule (b) of the permission model, but because of relaxing rule (a).

Should overlayfs respect the conservative interpretation as it partly did until this commit, a lower file must not lose IMMUTABLE/APPEND_ONLY after copy up, but that is exactly what is going to happen if we first copy up and then fail permission check on setting the flags.

Yeah, it's a mess. This will hopefully sort it out, as it will allow
easier copy up of flags:

https://lore.kernel.org/linux-fsdevel/[email protected]/

In actual fact losing S_APPEND is not currently prevented by copy-up triggered by anything other than FS_IOC_SETX*, and even that is prone to races as indicated by the bug report that resulted in this patch.

Let's just fix the IMMUTABLE case:

- if the file is already copied up with data (since the overlay
ioctl implementation currently uses the realdata), then we're fine to copy up

- if the file is not IMMUTABLE to start with, then also fine to copy
up; even if the op will fail after copy up we haven't done anything that wouldn't be possible without this particular codepath

- if task has CAP_LINUX_IMMUTABLE (can add/remove immutable) then
it's also fine to copy up since we can be fairly sure that the actual setflags will succeed as well. If not, that can be a problem, but as I've said copying up IMMUTABLE and other flags should really be done by the copy up code, otherwise it won't work properly.

Something like this incremental should be good, I think:

@@ -576,6 +576,15 @@ static long ovl_ioctl_set_flags(struct f

  inode_lock(inode);

+ /*
+ * Prevent copy up if immutable and has no CAP_LINUX_IMMUTABLE
+ * capability.
+ */
+ ret = -EPERM;
+ if (!ovl_has_upperdata(inode) && IS_IMMUTABLE(inode) &&
+ !capable(CAP_LINUX_IMMUTABLE))
+ goto unlock;
+
ret = ovl_maybe_copy_up(file_dentry(file), O_WRONLY); if (ret)
goto unlock;

Thanks,
Miklos

maintainer
#21 lore raw

Re: [PATCH v2 04/10] ovl: make ioctl() safe

Quoted 46 lines · Miklos Szeredi
Quoted 8 lines · Amir Goldstein

Perhaps, but there is a much bigger issue with this change IMO. Not because of dropping rule (b) of the permission model, but because of relaxing rule (a).

Should overlayfs respect the conservative interpretation as it partly did until this commit, a lower file must not lose IMMUTABLE/APPEND_ONLY after copy up, but that is exactly what is going to happen if we first copy up and then fail permission check on setting the flags.

Yeah, it's a mess. This will hopefully sort it out, as it will allow
easier copy up of flags:

https://lore.kernel.org/linux-fsdevel/[email protected]/

In actual fact losing S_APPEND is not currently prevented by copy-up triggered by anything other than FS_IOC_SETX*, and even that is prone to races as indicated by the bug report that resulted in this patch.

Let's just fix the IMMUTABLE case:

- if the file is already copied up with data (since the overlay
ioctl implementation currently uses the realdata), then we're fine to copy up

- if the file is not IMMUTABLE to start with, then also fine to copy
up; even if the op will fail after copy up we haven't done anything that wouldn't be possible without this particular codepath

- if task has CAP_LINUX_IMMUTABLE (can add/remove immutable) then
it's also fine to copy up since we can be fairly sure that the actual setflags will succeed as well. If not, that can be a problem, but as I've said copying up IMMUTABLE and other flags should really be done by the copy up code, otherwise it won't work properly.

Something like this incremental should be good, I think:

(quoted diff) +2 -0
@@ -576,6 +576,15 @@ static long ovl_ioctl_set_flags(struct f
 
  inode_lock(inode);
 
+ /*
+ * Prevent copy up if immutable and has no CAP_LINUX_IMMUTABLE

Review static long ovl_ioctl_set_flags(struct f · line 590

Quoted 10 lines
(quoted diff) +7 -0
+ * capability.
+ */
+ ret = -EPERM;
+ if (!ovl_has_upperdata(inode) && IS_IMMUTABLE(inode) &&
+     !capable(CAP_LINUX_IMMUTABLE))
+ goto unlock;
+
  ret = ovl_maybe_copy_up(file_dentry(file), O_WRONLY);
  if (ret)
  goto unlock;

I guess that looks ok for a band aid.

Thanks,
Amir.

maintainer
#22 lore raw

Re: [PATCH v2 04/10] ovl: make ioctl() safe

In reply to Miklos Szeredi
Quoted 6 lines · Miklos Szeredi

ovl_ioctl_set_flags() does a capability check using flags, but then the real ioctl double-fetches flags and uses potentially different value.

The "Check the capability before cred override" comment misleading: user can skip this check by presenting benign flags first and then overwriting them to non-benign flags.

Is this a security bug which should be fixed in stable?

Signature · 2 lines
James Morris
<[email protected]>
maintainer
#23 lore raw

Re: [PATCH v2 04/10] ovl: make ioctl() safe

Quoted 11 lines · James Morris
Quoted 6 lines · Miklos Szeredi

ovl_ioctl_set_flags() does a capability check using flags, but then the real ioctl double-fetches flags and uses potentially different value.

The "Check the capability before cred override" comment misleading: user can skip this check by presenting benign flags first and then overwriting them to non-benign flags.

Is this a security bug which should be fixed in stable?

Yes, good point. Added Cc: stable@...

Thanks,
Miklos

#24 lore raw

PATCH v2 5/10 ovl: simplify file splice

In reply to Miklos Szeredi

generic_file_splice_read() and iter_file_splice_write() will call back into f_op->iter_read() and f_op->iter_write() respectively. These already do the real file lookup and cred override. So the code in ovl_splice_read() and ovl_splice_write() is redundant.

In addition the ovl_file_accessed() call in ovl_splice_write() is incorrect, though probably harmless.

Fix by calling generic_file_splice_read() and iter_file_splice_write() directly.

---
 fs/overlayfs/file.c | 46 ++-------------------------------------------
 1 file changed, 2 insertions(+), 44 deletions(-)
fs/overlayfs/file.c +2 -44
index 3cd1590f2030..dc767034d37b 100644
@@ -397,48 +397,6 @@ static ssize_t ovl_write_iter(struct kiocb *iocb, struct iov_iter *iter)
 	return ret;
 }
 
-static ssize_t ovl_splice_read(struct file *in, loff_t *ppos,
-			 struct pipe_inode_info *pipe, size_t len,
-			 unsigned int flags)
-{
-	ssize_t ret;
-	struct fd real;
-	const struct cred *old_cred;
-
-	ret = ovl_real_fdget(in, &real);
-	if (ret)
-		return ret;
-
-	old_cred = ovl_override_creds(file_inode(in)->i_sb);
-	ret = generic_file_splice_read(real.file, ppos, pipe, len, flags);
-	revert_creds(old_cred);
-
-	ovl_file_accessed(in);
-	fdput(real);
-	return ret;
-}
-
-static ssize_t
-ovl_splice_write(struct pipe_inode_info *pipe, struct file *out,
-			  loff_t *ppos, size_t len, unsigned int flags)
-{
-	struct fd real;
-	const struct cred *old_cred;
-	ssize_t ret;
-
-	ret = ovl_real_fdget(out, &real);
-	if (ret)
-		return ret;
-
-	old_cred = ovl_override_creds(file_inode(out)->i_sb);
-	ret = iter_file_splice_write(pipe, real.file, ppos, len, flags);
-	revert_creds(old_cred);
-
-	ovl_file_accessed(out);
-	fdput(real);
-	return ret;
-}
-
 static int ovl_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 {
 	struct fd real;
@@ -732,8 +690,8 @@ const struct file_operations ovl_file_operations = {
 #ifdef CONFIG_COMPAT
 	.compat_ioctl	= ovl_compat_ioctl,
 #endif
-	.splice_read    = ovl_splice_read,
-	.splice_write   = ovl_splice_write,
+	.splice_read    = generic_file_splice_read,
+	.splice_write   = iter_file_splice_write,
 
 	.copy_file_range	= ovl_copy_file_range,
 	.remap_file_range	= ovl_remap_file_range,
Signature · 1 line
2.26.2
#25 lore raw

PATCH v2 6/10 ovl: user xattr

In reply to Miklos Szeredi

Optionally allow using "user.overlay." namespace instead of "trusted.overlay."

This is necessary for overlayfs to be able to be mounted in an unprivileged namepsace.

Make the option explicit, since it makes the filesystem format be incompatible.

Disable redirect_dir and metacopy options, because these would allow privilege escalation through direct manipulation of the "user.overlay.redirect" or "user.overlay.metacopy" xattrs.

---
 fs/overlayfs/inode.c     | 10 ++++++--
 fs/overlayfs/overlayfs.h |  8 +++---
 fs/overlayfs/ovl_entry.h |  1 +
 fs/overlayfs/super.c     | 55 ++++++++++++++++++++++++++++++++++++----
 fs/overlayfs/util.c      |  5 ++--
 5 files changed, 67 insertions(+), 12 deletions(-)
fs/overlayfs/inode.c +8 -2
index b584dca845ba..8ec3062999a9 100644
@@ -329,8 +329,14 @@ static const char *ovl_get_link(struct dentry *dentry,
 
 bool ovl_is_private_xattr(struct super_block *sb, const char *name)
 {
-	return strncmp(name, OVL_XATTR_PREFIX,
-		       sizeof(OVL_XATTR_PREFIX) - 1) == 0;
+	struct ovl_fs *ofs = sb->s_fs_info;
+
+	if (ofs->config.userxattr)
+		return strncmp(name, OVL_XATTR_USER_PREFIX,
+			       sizeof(OVL_XATTR_USER_PREFIX) - 1) == 0;
+	else
+		return strncmp(name, OVL_XATTR_TRUSTED_PREFIX,
+			       sizeof(OVL_XATTR_TRUSTED_PREFIX) - 1) == 0;
 }
 
 int ovl_xattr_set(struct dentry *dentry, struct inode *inode, const char *name,
fs/overlayfs/overlayfs.h +5 -3
index f8880aa2ba0e..46282111d6e6 100644
@@ -22,7 +22,9 @@ enum ovl_path_type {
 #define OVL_TYPE_MERGE(type)	((type) & __OVL_PATH_MERGE)
 #define OVL_TYPE_ORIGIN(type)	((type) & __OVL_PATH_ORIGIN)
 
-#define OVL_XATTR_PREFIX XATTR_TRUSTED_PREFIX "overlay."
+#define OVL_XATTR_NAMESPACE "overlay."
+#define OVL_XATTR_TRUSTED_PREFIX XATTR_TRUSTED_PREFIX OVL_XATTR_NAMESPACE
+#define OVL_XATTR_USER_PREFIX XATTR_USER_PREFIX OVL_XATTR_NAMESPACE
 
 enum ovl_xattr {
 	OVL_XATTR_OPAQUE,
@@ -113,10 +115,10 @@ struct ovl_fh {
 #define OVL_FH_FID_OFFSET	(OVL_FH_WIRE_OFFSET + \
 				 offsetof(struct ovl_fb, fid))
 
-extern const char *ovl_xattr_table[];
+extern const char *ovl_xattr_table[][2];
 static inline const char *ovl_xattr(struct ovl_fs *ofs, enum ovl_xattr ox)
 {
-	return ovl_xattr_table[ox];
+	return ovl_xattr_table[ox][ofs->config.userxattr];
 }
 
 static inline int ovl_do_rmdir(struct inode *dir, struct dentry *dentry)
fs/overlayfs/ovl_entry.h +1 -0
index 1b5a2094df8e..d634c7ba3b9c 100644
@@ -17,6 +17,7 @@ struct ovl_config {
 	bool nfs_export;
 	int xino;
 	bool metacopy;
+	bool userxattr;
 	bool ovl_volatile;
 };
 
fs/overlayfs/super.c +50 -5

101 lines not on this page · raw message

fs/overlayfs/util.c +3 -2
index 23f475627d07..66eaf4db027f 100644
@@ -582,9 +582,10 @@ bool ovl_check_dir_xattr(struct super_block *sb, struct dentry *dentry,
 #define OVL_XATTR_METACOPY_POSTFIX	"metacopy"
 
 #define OVL_XATTR_TAB_ENTRY(x) \
-	[x] = OVL_XATTR_PREFIX x ## _POSTFIX
+	[x] = { [false] = OVL_XATTR_TRUSTED_PREFIX x ## _POSTFIX, \
+		[true] = OVL_XATTR_USER_PREFIX x ## _POSTFIX }
 
-const char *ovl_xattr_table[] = {
+const char *ovl_xattr_table[][2] = {
 	OVL_XATTR_TAB_ENTRY(OVL_XATTR_OPAQUE),
 	OVL_XATTR_TAB_ENTRY(OVL_XATTR_REDIRECT),
 	OVL_XATTR_TAB_ENTRY(OVL_XATTR_ORIGIN),
Signature · 1 line
2.26.2
maintainer Reviewed-by on v2 6/10
#26 lore raw

Re: [PATCH v2 06/10] ovl: user xattr

Quoted 3 lines · Miklos Szeredi

Optionally allow using "user.overlay." namespace instead of "trusted.overlay."

There are several occurrences of "trusted.overlay" string in code and Documentation, which is fine. But maybe only adjust the comment for testing xattr support:

* Check if upper/work fs supports trusted.overlay.* xattr

Quoted 7 lines

This is necessary for overlayfs to be able to be mounted in an unprivileged namepsace.

Make the option explicit, since it makes the filesystem format be incompatible.

Quoted 6 lines

Disable redirect_dir and metacopy options, because these would allow privilege escalation through direct manipulation of the "user.overlay.redirect" or "user.overlay.metacopy" xattrs.

---

Quoted 6 lines
fs/overlayfs/util.c +0 -0
@@ -582,9 +582,10 @@ bool ovl_check_dir_xattr(struct super_block *sb, struct dentry *dentry,
 #define OVL_XATTR_METACOPY_POSTFIX     "metacopy"
 
 #define OVL_XATTR_TAB_ENTRY(x) \

fs/overlayfs/util.c bool ovl_check_dir_xattr(struct super_block *sb, struct dentry *dentry,

Quoted 10 lines
fs/overlayfs/util.c +3 -3
-       [x] = OVL_XATTR_PREFIX x ## _POSTFIX
+       [x] = { [false] = OVL_XATTR_TRUSTED_PREFIX x ## _POSTFIX, \
+               [true] = OVL_XATTR_USER_PREFIX x ## _POSTFIX }
 
-const char *ovl_xattr_table[] = {
+const char *ovl_xattr_table[][2] = {
        OVL_XATTR_TAB_ENTRY(OVL_XATTR_OPAQUE),
        OVL_XATTR_TAB_ENTRY(OVL_XATTR_REDIRECT),
        OVL_XATTR_TAB_ENTRY(OVL_XATTR_ORIGIN),
--

Can you constify this 2D array? I don't even know the syntax for that...

Thanks,
Amir.

maintainer
#27 lore raw

Re: [PATCH v2 06/10] ovl: user xattr

Quoted 11 lines · Amir Goldstein
Quoted 3 lines · Miklos Szeredi

Optionally allow using "user.overlay." namespace instead of "trusted.overlay."

There are several occurrences of "trusted.overlay" string in code and Documentation, which is fine. But maybe only adjust the comment for testing xattr support:

* Check if upper/work fs supports trusted.overlay.* xattr

Updated documentation and comments.

Pushed new series to:

git://git.kernel.org/pub/scm/linux/kernel/git/mszeredi/vfs.git#ovl-unpriv-v3

Based on the feedback, I feel it's ready for v5.11, so merged this into #overlayfs-next as well.

Thanks,
Miklos

maintainer
#28 lore raw

Re: [PATCH v2 06/10] ovl: user xattr

Quoted 8 lines · Miklos Szeredi
Quoted 6 lines · Amir Goldstein
Quoted 3 lines · Miklos Szeredi

Optionally allow using "user.overlay." namespace instead of "trusted.overlay."

Quoted 8 lines
Quoted 5 lines

There are several occurrences of "trusted.overlay" string in code and Documentation, which is fine. But maybe only adjust the comment for testing xattr support:

* Check if upper/work fs supports trusted.overlay.* xattr

Updated documentation and comments.

I think you just missed this one comment above that I pointed out.

Thanks,
Amir.

#29 lore raw

PATCH v2 7/10 ovl: do not fail when setting origin xattr

In reply to Miklos Szeredi

Comment above call already says this, but only EOPNOTSUPP is ignored, other failures are not.

For example setting "user.*" will fail with EPERM on symlink/special.

Ignore this error as well.

---
 fs/overlayfs/copy_up.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)
fs/overlayfs/copy_up.c +2 -1
index 955ecd4030f0..8a7ef40d98f8 100644
@@ -352,7 +352,8 @@ int ovl_set_origin(struct dentry *dentry, struct dentry *lower,
 				 fh ? fh->fb.len : 0, 0);
 	kfree(fh);
 
-	return err;
+	/* Ignore -EPERM from setting "user.*" on symlink/special */
+	return err == -EPERM ? 0 : err;
 }
 
 /* Store file handle of @upper dir in @index dir entry */
Signature · 1 line
2.26.2
#30 lore raw

PATCH v2 8/10 ovl: do not fail because of O_NOATIME

In reply to Miklos Szeredi

In case the file cannot be opened with O_NOATIME because of lack of capabilities, then clear O_NOATIME instead of failing.

---
 fs/overlayfs/file.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)
fs/overlayfs/file.c +3 -2
index dc767034d37b..d6ac7ac66410 100644
@@ -53,9 +53,10 @@ static struct file *ovl_open_realfile(const struct file *file,
 	err = inode_permission(realinode, MAY_OPEN | acc_mode);
 	if (err) {
 		realfile = ERR_PTR(err);
-	} else if (!inode_owner_or_capable(realinode)) {
-		realfile = ERR_PTR(-EPERM);
 	} else {
+		if (!inode_owner_or_capable(realinode))
+			flags &= ~O_NOATIME;
+
 		realfile = open_with_fake_path(&file->f_path, flags, realinode,
 					       current_cred());
 	}
Signature · 1 line
2.26.2
maintainer
#31 lore raw

Re: [PATCH v2 08/10] ovl: do not fail because of O_NOATIME

Quoted 14 lines · Miklos Szeredi

In case the file cannot be opened with O_NOATIME because of lack of capabilities, then clear O_NOATIME instead of failing.

---
 fs/overlayfs/file.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)
fs/overlayfs/file.c +0 -0
index dc767034d37b..d6ac7ac66410 100644

fs/overlayfs/file.c static struct file *ovl_open_realfile(const struct file *file, · line 59

Quoted 9 lines
fs/overlayfs/file.c +3 -2
@@ -53,9 +53,10 @@ static struct file *ovl_open_realfile(const struct file *file,
        err = inode_permission(realinode, MAY_OPEN | acc_mode);
        if (err) {
                realfile = ERR_PTR(err);
-       } else if (!inode_owner_or_capable(realinode)) {
-               realfile = ERR_PTR(-EPERM);
        } else {
+               if (!inode_owner_or_capable(realinode))
+                       flags &= ~O_NOATIME;
+

Isn't that going to break:

        flags |= OVL_OPEN_FLAGS;

        /* If some flag changed that cannot be changed then something's amiss */
        if (WARN_ON((file->f_flags ^ flags) & ~OVL_SETFL_MASK))

IOW setting a flag that is allowed to change will fail because of missing O_ATIME in file->f_flags.

I guess we need test coverage for SETFL.

Thanks,
Amir.

maintainer
#32 lore raw

Re: [PATCH v2 08/10] ovl: do not fail because of O_NOATIME

Quoted 28 lines · Amir Goldstein
Quoted 14 lines · Miklos Szeredi

In case the file cannot be opened with O_NOATIME because of lack of capabilities, then clear O_NOATIME instead of failing.

---
 fs/overlayfs/file.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)
fs/overlayfs/file.c +0 -0
index dc767034d37b..d6ac7ac66410 100644

fs/overlayfs/file.c static struct file *ovl_open_realfile(const struct file *file, · line 59

Quoted 9 lines
fs/overlayfs/file.c +3 -2
@@ -53,9 +53,10 @@ static struct file *ovl_open_realfile(const struct file *file,
        err = inode_permission(realinode, MAY_OPEN | acc_mode);
        if (err) {
                realfile = ERR_PTR(err);
-       } else if (!inode_owner_or_capable(realinode)) {
-               realfile = ERR_PTR(-EPERM);
        } else {
+               if (!inode_owner_or_capable(realinode))
+                       flags &= ~O_NOATIME;
+

Isn't that going to break:

Quoted 7 lines
        flags |= OVL_OPEN_FLAGS;

        /* If some flag changed that cannot be changed then something's amiss */
        if (WARN_ON((file->f_flags ^ flags) & ~OVL_SETFL_MASK))

IOW setting a flag that is allowed to change will fail because of missing O_ATIME in file->f_flags.

Well spotted. I just removed those lines as a fix. The check never
triggered since its introduction in 4.19, so I guess it isn't worth adding more complexity for.

Quoted 2 lines

I guess we need test coverage for SETFL.

There might be some in ltp, haven't checked. Would be nice if the fs related ltp tests could be integrated into xfstests.

Thanks,
Miklos

maintainer
#33 lore raw

Re: [PATCH v2 08/10] ovl: do not fail because of O_NOATIME

Quoted 43 lines · Miklos Szeredi
Quoted 28 lines · Amir Goldstein
Quoted 14 lines · Miklos Szeredi

In case the file cannot be opened with O_NOATIME because of lack of capabilities, then clear O_NOATIME instead of failing.

---
 fs/overlayfs/file.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)
fs/overlayfs/file.c +0 -0
index dc767034d37b..d6ac7ac66410 100644

fs/overlayfs/file.c static struct file *ovl_open_realfile(const struct file *file, · line 59

Quoted 9 lines
fs/overlayfs/file.c +3 -2
@@ -53,9 +53,10 @@ static struct file *ovl_open_realfile(const struct file *file,
        err = inode_permission(realinode, MAY_OPEN | acc_mode);
        if (err) {
                realfile = ERR_PTR(err);
-       } else if (!inode_owner_or_capable(realinode)) {
-               realfile = ERR_PTR(-EPERM);
        } else {
+               if (!inode_owner_or_capable(realinode))
+                       flags &= ~O_NOATIME;
+

Isn't that going to break:

Quoted 7 lines
        flags |= OVL_OPEN_FLAGS;

        /* If some flag changed that cannot be changed then something's amiss */
        if (WARN_ON((file->f_flags ^ flags) & ~OVL_SETFL_MASK))

IOW setting a flag that is allowed to change will fail because of missing O_ATIME in file->f_flags.

Well spotted. I just removed those lines as a fix. The check never
triggered since its introduction in 4.19, so I guess it isn't worth adding more complexity for.

Quoted 1 line
Quoted 5 lines
Quoted 1 line

I guess we need test coverage for SETFL.

There might be some in ltp, haven't checked. Would be nice if the fs related ltp tests could be integrated into xfstests.

There is some test coverage for SETFL in xfstests.

The t_immutable tests for one, but those would not run if the mounter has no CAP_LINUX_IMMUTABLE, so would not have been useful to detect the problem above.

fsstress also seems to have support for SETFL ops, but I am not sure in how many tests it is exercises and perhaps the relevant problem would have been covered by some stress test that is not in the 'quick' tests group.

Thanks,
Amir.

#34 lore raw

PATCH v2 9/10 ovl: do not get metacopy for userxattr

In reply to Miklos Szeredi

When looking up an inode on the lower layer for which the mounter lacks read permisison the metacopy check will fail. This causes the lookup to fail as well, even though the directory is readable.

So ignore EACCES for the "userxattr" case and assume no metacopy for the unreadable file.

---
 fs/overlayfs/util.c | 7 +++++++
 1 file changed, 7 insertions(+)
fs/overlayfs/util.c +7 -0
index 66eaf4db027f..703c6e529f39 100644
@@ -880,6 +880,13 @@ int ovl_check_metacopy_xattr(struct ovl_fs *ofs, struct dentry *dentry)
 	if (res < 0) {
 		if (res == -ENODATA || res == -EOPNOTSUPP)
 			return 0;
+		/*
+		 * getxattr on user.* may fail with EACCES in case there's no
+		 * read permission on the inode.  Not much we can do, other than
+		 * tell the caller that this is not a metacopy inode.
+		 */
+		if (ofs->config.userxattr && res == -EACCES)
+			return 0;
 		goto out;
 	}
 
Signature · 1 line
2.26.2
#35 lore raw

PATCH v2 10/10 ovl: unprivieged mounts

In reply to Miklos Szeredi

Enable unprivileged user namespace mounts of overlayfs. Overlayfs's permission model (*) ensures that the mounter itself cannot gain additional privileges by the act of creating an overlayfs mount.

This feature request is coming from the "rootless" container crowd.

(*) Documentation/filesystems/overlayfs.txt#Permission model

---
 fs/overlayfs/super.c | 1 +
 1 file changed, 1 insertion(+)
fs/overlayfs/super.c +1 -0
index 189380b946be..019e6f1834b0 100644
@@ -2073,6 +2073,7 @@ static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags,
 static struct file_system_type ovl_fs_type = {
 	.owner		= THIS_MODULE,
 	.name		= "overlay",
+	.fs_flags	= FS_USERNS_MOUNT,
 	.mount		= ovl_mount,
 	.kill_sb	= kill_anon_super,
 };
Signature · 1 line
2.26.2
#36 lore raw
In reply to Miklos Szeredi
Quoted 5 lines · Miklos Szeredi

A general observation is that overlayfs does not call security_path_*() hooks on the underlying fs. I don't see this as a problem, because a simple bind mount done inside a private mount namespace also defeats the path based security checks. Maybe I'm missing something here, so I'm interested in comments from AppArmor and Tomoyo developers.

Regarding TOMOYO, I don't want overlayfs to call security_path_*() hooks on the underlying fs, but the reason is different. It is not because a simple bind mount done inside a private mount namespace defeats the path based security checks. TOMOYO does want to check what device/filesystem is mounted on which location. But currently TOMOYO is failing to check it due to fsopen()/fsmount()/move_mount() API.

#37 lore raw
Quoted 7 lines · Tetsuo Handa
Quoted 5 lines · Miklos Szeredi

A general observation is that overlayfs does not call security_path_*() hooks on the underlying fs. I don't see this as a problem, because a simple bind mount done inside a private mount namespace also defeats the path based security checks. Maybe I'm missing something here, so I'm interested in comments from AppArmor and Tomoyo developers.

Quoted 6 lines

Regarding TOMOYO, I don't want overlayfs to call security_path_*() hooks on the underlying fs, but the reason is different. It is not because a simple bind mount done inside a private mount namespace defeats the path based security checks. TOMOYO does want to check what device/filesystem is mounted on which location. But currently TOMOYO is failing to check it due to fsopen()/fsmount()/move_mount() API.

Regardless of TOMOYO's approach I would say that overlays should call the security_path_*() hooks, making it possible for an LSM to do something based off of them when needed.

The current state of private mounts with regard to path based mediation is broken. I just haven't had time to try and come up with an acceptable fix for it. overlayfs is actually broken under apparmor mediation, and accesses to the lower layer end up getting denied but there is no way to properly allow them. So policy that hits this needs a flag set that allows for it in a very hacky way (its on the list of things to fix).

Path based mediation has to carefully control mounts otherwise policy can be circumvented as Miklos rightly points out. Ideally path based LSM wouldn't allow you to do the simple bind mount inside a private mount namespace (at least not unless policy allowed for it). AppArmor does mediate the mount hooks and bind mounts in a private mount namespace (if they go through the LSM mount hooks) will be denied. Again the problem is how to allow them, and this is broken.

maintainer
#38 lore raw
Quoted 27 lines · John Johansen
Quoted 7 lines · Tetsuo Handa
Quoted 5 lines · Miklos Szeredi

A general observation is that overlayfs does not call security_path_*() hooks on the underlying fs. I don't see this as a problem, because a simple bind mount done inside a private mount namespace also defeats the path based security checks. Maybe I'm missing something here, so I'm interested in comments from AppArmor and Tomoyo developers.

Quoted 6 lines

Regarding TOMOYO, I don't want overlayfs to call security_path_*() hooks on the underlying fs, but the reason is different. It is not because a simple bind mount done inside a private mount namespace defeats the path based security checks. TOMOYO does want to check what device/filesystem is mounted on which location. But currently TOMOYO is failing to check it due to fsopen()/fsmount()/move_mount() API.

Regardless of TOMOYO's approach I would say that overlays should call the security_path_*() hooks, making it possible for an LSM to do something based off of them when needed.

The current state of private mounts with regard to path based mediation is broken. I just haven't had time to try and come up with an acceptable fix for it. overlayfs is actually broken under apparmor mediation, and accesses to the lower layer end up getting denied but there is no way to properly allow them. So policy that hits this needs a flag set that allows for it in a very hacky way (its on the list of things to fix).

Quoted 6 lines

Path based mediation has to carefully control mounts otherwise policy can be circumvented as Miklos rightly points out. Ideally path based LSM wouldn't allow you to do the simple bind mount inside a private mount namespace (at least not unless policy allowed for it). AppArmor does mediate the mount hooks and bind mounts in a private mount namespace (if they go through the LSM mount hooks) will be denied. Again the problem is how to allow them, and this is broken.

Okay, so what does that mean for overlayfs?

AA can deny the overlay mount just as well as the bind mount, and it can allow it just as well as the bind mount. Policy could be the same.

Also all the security_path_ hooks will still get called for each access on overlayfs itself. They won't be called for the accesses which overlayfs does on underlying layers, but is that needed?

Overlay could call those hooks itself (since the vfs_ helpers don't) but the big question is whether that makes any sense. AFAICS it might make sense, but only if AA would correctly handle bind mounts, and especially detached bind mounts (which is what overlayfs technically uses).

Thanks,
Miklos

Tja

#39 lore raw
Quoted 36 lines · Miklos Szeredi
Quoted 27 lines · John Johansen
Quoted 7 lines · Tetsuo Handa
Quoted 5 lines · Miklos Szeredi

A general observation is that overlayfs does not call security_path_*() hooks on the underlying fs. I don't see this as a problem, because a simple bind mount done inside a private mount namespace also defeats the path based security checks. Maybe I'm missing something here, so I'm interested in comments from AppArmor and Tomoyo developers.

Quoted 6 lines

Regarding TOMOYO, I don't want overlayfs to call security_path_*() hooks on the underlying fs, but the reason is different. It is not because a simple bind mount done inside a private mount namespace defeats the path based security checks. TOMOYO does want to check what device/filesystem is mounted on which location. But currently TOMOYO is failing to check it due to fsopen()/fsmount()/move_mount() API.

Regardless of TOMOYO's approach I would say that overlays should call the security_path_*() hooks, making it possible for an LSM to do something based off of them when needed.

The current state of private mounts with regard to path based mediation is broken. I just haven't had time to try and come up with an acceptable fix for it. overlayfs is actually broken under apparmor mediation, and accesses to the lower layer end up getting denied but there is no way to properly allow them. So policy that hits this needs a flag set that allows for it in a very hacky way (its on the list of things to fix).

Quoted 6 lines

Path based mediation has to carefully control mounts otherwise policy can be circumvented as Miklos rightly points out. Ideally path based LSM wouldn't allow you to do the simple bind mount inside a private mount namespace (at least not unless policy allowed for it). AppArmor does mediate the mount hooks and bind mounts in a private mount namespace (if they go through the LSM mount hooks) will be denied. Again the problem is how to allow them, and this is broken.

Quoted 6 lines

Okay, so what does that mean for overlayfs?

AA can deny the overlay mount just as well as the bind mount, and it can allow it just as well as the bind mount. Policy could be the same.

not entirely the private mount is always detached from the namespace and we have no way to correlate the private mount to the overlay so the only safe thing is to deny operations on the private mount.

Ideally we would have a way to provide some kind of correlation so we could make an informed decision.

Quoted 4 lines

Also all the security_path_ hooks will still get called for each access on overlayfs itself. They won't be called for the accesses which overlayfs does on underlying layers, but is that needed?

maybe but maybe not. The thing is apparmor doesn't just used security_path_ hooks which means we get some operation on leaking through that are using the private mount. Its this inconsistent partial view that is problematic.

Quoted 6 lines

Overlay could call those hooks itself (since the vfs_ helpers don't) but the big question is whether that makes any sense. AFAICS it might make sense, but only if AA would correctly handle bind mounts, and especially detached bind mounts (which is what overlayfs technically uses).

I haven't investigated enough to say for sure whether AA needs the path hooks called, but I think it probably doesn't. What AA does need is a way to determine what to do with private mounts when it encounters them in the none path hooks.

That could be a simple as a hook when the private mount is setup so it can setup some state.

Quoted 5 lines

Thanks,
Miklos

Tja