From 7c02a3a60c04e7332b43570873544a0f7c8da94e Mon Sep 17 00:00:00 2001 From: Josh Boyer Date: Mon, 16 Jun 2014 09:12:50 -0400 Subject: [PATCH] CVE-2014-4014 possible priv escalation in userns (rhbz 1107966 1109836) --- ...-inode_capable-to-capable_wrt_inode_.patch | 209 ++++++++++++++++++ kernel.spec | 9 + 2 files changed, 218 insertions(+) create mode 100644 fs-userns-Change-inode_capable-to-capable_wrt_inode_.patch diff --git a/fs-userns-Change-inode_capable-to-capable_wrt_inode_.patch b/fs-userns-Change-inode_capable-to-capable_wrt_inode_.patch new file mode 100644 index 000000000..b56e7171a --- /dev/null +++ b/fs-userns-Change-inode_capable-to-capable_wrt_inode_.patch @@ -0,0 +1,209 @@ +Bugzilla: 1109836 +Upstream-status: 3.16-rc1 and CC'd to stable + +From 23adbe12ef7d3d4195e80800ab36b37bee28cd03 Mon Sep 17 00:00:00 2001 +From: Andy Lutomirski +Date: Tue, 10 Jun 2014 12:45:42 -0700 +Subject: [PATCH] fs,userns: Change inode_capable to capable_wrt_inode_uidgid + +The kernel has no concept of capabilities with respect to inodes; inodes +exist independently of namespaces. For example, inode_capable(inode, +CAP_LINUX_IMMUTABLE) would be nonsense. + +This patch changes inode_capable to check for uid and gid mappings and +renames it to capable_wrt_inode_uidgid, which should make it more +obvious what it does. + +Fixes CVE-2014-4014. + +Cc: Theodore Ts'o +Cc: Serge Hallyn +Cc: "Eric W. Biederman" +Cc: Dave Chinner +Cc: stable@vger.kernel.org +Signed-off-by: Andy Lutomirski +Signed-off-by: Linus Torvalds +--- + fs/attr.c | 8 ++++---- + fs/inode.c | 10 +++++++--- + fs/namei.c | 11 ++++++----- + fs/xfs/xfs_ioctl.c | 2 +- + include/linux/capability.h | 2 +- + kernel/capability.c | 20 ++++++++------------ + 6 files changed, 27 insertions(+), 26 deletions(-) + +diff --git a/fs/attr.c b/fs/attr.c +index 5d4e59d..6530ced 100644 +--- a/fs/attr.c ++++ b/fs/attr.c +@@ -50,14 +50,14 @@ int inode_change_ok(const struct inode *inode, struct iattr *attr) + if ((ia_valid & ATTR_UID) && + (!uid_eq(current_fsuid(), inode->i_uid) || + !uid_eq(attr->ia_uid, inode->i_uid)) && +- !inode_capable(inode, CAP_CHOWN)) ++ !capable_wrt_inode_uidgid(inode, CAP_CHOWN)) + return -EPERM; + + /* Make sure caller can chgrp. */ + if ((ia_valid & ATTR_GID) && + (!uid_eq(current_fsuid(), inode->i_uid) || + (!in_group_p(attr->ia_gid) && !gid_eq(attr->ia_gid, inode->i_gid))) && +- !inode_capable(inode, CAP_CHOWN)) ++ !capable_wrt_inode_uidgid(inode, CAP_CHOWN)) + return -EPERM; + + /* Make sure a caller can chmod. */ +@@ -67,7 +67,7 @@ int inode_change_ok(const struct inode *inode, struct iattr *attr) + /* Also check the setgid bit! */ + if (!in_group_p((ia_valid & ATTR_GID) ? attr->ia_gid : + inode->i_gid) && +- !inode_capable(inode, CAP_FSETID)) ++ !capable_wrt_inode_uidgid(inode, CAP_FSETID)) + attr->ia_mode &= ~S_ISGID; + } + +@@ -160,7 +160,7 @@ void setattr_copy(struct inode *inode, const struct iattr *attr) + umode_t mode = attr->ia_mode; + + if (!in_group_p(inode->i_gid) && +- !inode_capable(inode, CAP_FSETID)) ++ !capable_wrt_inode_uidgid(inode, CAP_FSETID)) + mode &= ~S_ISGID; + inode->i_mode = mode; + } +diff --git a/fs/inode.c b/fs/inode.c +index 2feb9b6..6eecb7f 100644 +--- a/fs/inode.c ++++ b/fs/inode.c +@@ -1839,14 +1839,18 @@ EXPORT_SYMBOL(inode_init_owner); + * inode_owner_or_capable - check current task permissions to inode + * @inode: inode being checked + * +- * Return true if current either has CAP_FOWNER to the inode, or +- * owns the file. ++ * Return true if current either has CAP_FOWNER in a namespace with the ++ * inode owner uid mapped, or owns the file. + */ + bool inode_owner_or_capable(const struct inode *inode) + { ++ struct user_namespace *ns; ++ + if (uid_eq(current_fsuid(), inode->i_uid)) + return true; +- if (inode_capable(inode, CAP_FOWNER)) ++ ++ ns = current_user_ns(); ++ if (ns_capable(ns, CAP_FOWNER) && kuid_has_mapping(ns, inode->i_uid)) + return true; + return false; + } +diff --git a/fs/namei.c b/fs/namei.c +index 8016827..985c6f3 100644 +--- a/fs/namei.c ++++ b/fs/namei.c +@@ -332,10 +332,11 @@ int generic_permission(struct inode *inode, int mask) + + if (S_ISDIR(inode->i_mode)) { + /* DACs are overridable for directories */ +- if (inode_capable(inode, CAP_DAC_OVERRIDE)) ++ if (capable_wrt_inode_uidgid(inode, CAP_DAC_OVERRIDE)) + return 0; + if (!(mask & MAY_WRITE)) +- if (inode_capable(inode, CAP_DAC_READ_SEARCH)) ++ if (capable_wrt_inode_uidgid(inode, ++ CAP_DAC_READ_SEARCH)) + return 0; + return -EACCES; + } +@@ -345,7 +346,7 @@ int generic_permission(struct inode *inode, int mask) + * at least one exec bit set. + */ + if (!(mask & MAY_EXEC) || (inode->i_mode & S_IXUGO)) +- if (inode_capable(inode, CAP_DAC_OVERRIDE)) ++ if (capable_wrt_inode_uidgid(inode, CAP_DAC_OVERRIDE)) + return 0; + + /* +@@ -353,7 +354,7 @@ int generic_permission(struct inode *inode, int mask) + */ + mask &= MAY_READ | MAY_WRITE | MAY_EXEC; + if (mask == MAY_READ) +- if (inode_capable(inode, CAP_DAC_READ_SEARCH)) ++ if (capable_wrt_inode_uidgid(inode, CAP_DAC_READ_SEARCH)) + return 0; + + return -EACCES; +@@ -2379,7 +2380,7 @@ static inline int check_sticky(struct inode *dir, struct inode *inode) + return 0; + if (uid_eq(dir->i_uid, fsuid)) + return 0; +- return !inode_capable(inode, CAP_FOWNER); ++ return !capable_wrt_inode_uidgid(inode, CAP_FOWNER); + } + + /* +diff --git a/fs/xfs/xfs_ioctl.c b/fs/xfs/xfs_ioctl.c +index 0b18776..6152cbe 100644 +--- a/fs/xfs/xfs_ioctl.c ++++ b/fs/xfs/xfs_ioctl.c +@@ -1215,7 +1215,7 @@ xfs_ioctl_setattr( + * cleared upon successful return from chown() + */ + if ((ip->i_d.di_mode & (S_ISUID|S_ISGID)) && +- !inode_capable(VFS_I(ip), CAP_FSETID)) ++ !capable_wrt_inode_uidgid(VFS_I(ip), CAP_FSETID)) + ip->i_d.di_mode &= ~(S_ISUID|S_ISGID); + + /* +diff --git a/include/linux/capability.h b/include/linux/capability.h +index a6ee1f9..84b13ad 100644 +--- a/include/linux/capability.h ++++ b/include/linux/capability.h +@@ -210,7 +210,7 @@ extern bool has_ns_capability_noaudit(struct task_struct *t, + struct user_namespace *ns, int cap); + extern bool capable(int cap); + extern bool ns_capable(struct user_namespace *ns, int cap); +-extern bool inode_capable(const struct inode *inode, int cap); ++extern bool capable_wrt_inode_uidgid(const struct inode *inode, int cap); + extern bool file_ns_capable(const struct file *file, struct user_namespace *ns, int cap); + + /* audit system wants to get cap info from files as well */ +diff --git a/kernel/capability.c b/kernel/capability.c +index 84b2bbf..a5cf13c 100644 +--- a/kernel/capability.c ++++ b/kernel/capability.c +@@ -424,23 +424,19 @@ bool capable(int cap) + EXPORT_SYMBOL(capable); + + /** +- * inode_capable - Check superior capability over inode ++ * capable_wrt_inode_uidgid - Check nsown_capable and uid and gid mapped + * @inode: The inode in question + * @cap: The capability in question + * +- * Return true if the current task has the given superior capability +- * targeted at it's own user namespace and that the given inode is owned +- * by the current user namespace or a child namespace. +- * +- * Currently we check to see if an inode is owned by the current +- * user namespace by seeing if the inode's owner maps into the +- * current user namespace. +- * ++ * Return true if the current task has the given capability targeted at ++ * its own user namespace and that the given inode's uid and gid are ++ * mapped into the current user namespace. + */ +-bool inode_capable(const struct inode *inode, int cap) ++bool capable_wrt_inode_uidgid(const struct inode *inode, int cap) + { + struct user_namespace *ns = current_user_ns(); + +- return ns_capable(ns, cap) && kuid_has_mapping(ns, inode->i_uid); ++ return ns_capable(ns, cap) && kuid_has_mapping(ns, inode->i_uid) && ++ kgid_has_mapping(ns, inode->i_gid); + } +-EXPORT_SYMBOL(inode_capable); ++EXPORT_SYMBOL(capable_wrt_inode_uidgid); +-- +1.9.3 + diff --git a/kernel.spec b/kernel.spec index 7f304fac0..6b007f133 100644 --- a/kernel.spec +++ b/kernel.spec @@ -737,6 +737,9 @@ Patch25100: dm-thin-update-discard_granularity-to-reflect-the-thin-pool-blocksiz #rhbz 1103528 Patch25101: elantech-Deal-with-clickpads-reporting-right-button-.patch +#CVE-2014-4014 rhbz 1107966 1109836 +Patch25102: fs-userns-Change-inode_capable-to-capable_wrt_inode_.patch + # END OF PATCH DEFINITIONS %endif @@ -1442,6 +1445,9 @@ ApplyPatch dm-thin-update-discard_granularity-to-reflect-the-thin-pool-blocksize #rhbz 1103528 ApplyPatch elantech-Deal-with-clickpads-reporting-right-button-.patch +#CVE-2014-4014 rhbz 1107966 1109836 +ApplyPatch fs-userns-Change-inode_capable-to-capable_wrt_inode_.patch + # END OF PATCH APPLICATIONS %endif @@ -2254,6 +2260,9 @@ fi # ||----w | # || || %changelog +* Mon Jun 16 2014 Josh Boyer +- CVE-2014-4014 possible priv escalation in userns (rhbz 1107966 1109836) + * Wed Jun 11 2014 Josh Boyer - Fix elantech right click on Dell vostro 5470 (rhbz 1103528) - Fix fstrim on dm-thin volume data (rhbz 1106856)