[oss-security] CVE-2014-4014: Linux kernel user namespace bug

The internal function inode_capable was used inappropriately.
Depending on configuration, this may be usable to escalate privileges.
A cursory inspection of my Fedora box suggests that it is not
vulnerable to the obvious way to exploit this bug.

The fix should appear in Linus' -master shortly, and it's tagged for
stable. In the mean time, I've attached it here.

I'll follow up in a day or two with a description of the actual bug,
or one of you can try to beat me to it.

–Andy

0001-fs-userns-Change-inode_capable-to-capable_wrt_inode_.patch

From fc8ad6759de122ee180a02c16518c2e252cc9d48 Mon Sep 17 00:00:00 2001
Message-Id: <fc8ad6759de122ee180a02c16518c2e252cc9d48.1402429263.git.luto@amacapital.net>
From: Andy Lutomirski <[email protected]>
Date: Tue, 10 Jun 2014 12:35:26 -0700
Subject: [PATCH v3] 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 <[email protected]>
Cc: Serge Hallyn <[email protected]>
Cc: "Eric W. Biederman" <[email protected]>
Cc: Dave Chinner <[email protected]>
Cc: [email protected]
Signed-off-by: Andy Lutomirski <[email protected]>

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 f96d2a6…d2fb2f2 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 a8d63df…24663b3 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