userns: review of bug fixes for 3.19-rcX
Subsystems (5)
cover userns: review of bug fixes for 3.19-rcX
The entire tree for testing is available at:
git.kernel.org:/pub/scm/linux/kernel/git/ebiederm/user-namespace.git for-testing
This is my queue of important bug fixes for user namespaces. Most of these changes warrant being backported. A few are bug fixes for cases where only root can trigger the issue so have not been marked for being back ported to stable.
A few of these patches have not been posted for review preivously, so I a giving the light of mailling list before I send them to Linus. This patchset has seen some testing already.
Since there are small deliberate breakage of userspace in here the more reviewers/testers the better.
Baring complictions I intend to ask Linus to pull this patchset sometime early next week.
So far nothing broke on my libvirt-lxc test bed. :-) Tested with openSUSE 13.2 and libvirt 1.2.9.
Tested on Fedora20 with libvirt 1.2.11, works fine.
Eric W. Biederman (18):
mnt: Implicitly add MNT_NODEV on remount when it was implicitly added by mount
mnt: Update unprivileged remount test
umount: Disallow unprivileged mount force
umount: Do not allow unmounting rootfs.
mnt: Move the clear of MNT_LOCKED from copy_tree to it's callers.
mnt: Carefully set CL_UNPRIVILEGED in clone_mnt
mnt: Clear mnt_expire during pivot_root
groups: Consolidate the setgroups permission checks
userns: Document what the invariant required for safe unprivileged mappings.
userns: Don't allow setgroups until a gid mapping has been setablished
userns: Don't allow unprivileged creation of gid mappings
userns: Check euid no fsuid when establishing an unprivileged uid mapping
userns: Only allow the creator of the userns unprivileged mappings
userns: Rename id_map_mutex to userns_state_mutex
userns: Add a knob to disable setgroups on a per user namespace basis
userns: Allow setting gid_maps without privilege when setgroups is disabled userns; Correct the comment in map_write
userns: Unbreak the unprivileged remount tests
PATCH 1/18 mnt: Implicitly add MNT_NODEV on remount when it was implicitly added by mount
Now that remount is properly enforcing the rule that you can't remove nodev at least sandstorm.io is breaking when performing a remount.
It turns out that there is an easy intuitive solution implicitly add nodev on remount when nodev was implicitly added on mount.
--- fs/namespace.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-)
fs/namespace.c +7 -1
@@ -2098,7 +2098,13 @@ static int do_remount(struct path *path, int flags, int mnt_flags, }if ((mnt->mnt.mnt_flags &MNT_LOCK_NODEV ) && !(mnt_flags &MNT_NODEV )) { -return -EPERM ; +/* Was the nodev implicitly added in mount? */ +if ((mnt->mnt_ns->user_ns != &init_user_ns) && + !(sb->s_type->fs_flags &FS_USERNS_DEV_MOUNT )) { + mnt_flags |=MNT_NODEV ; + }else { +return -EPERM ; + } }if ((mnt->mnt.mnt_flags &MNT_LOCK_NOSUID ) && !(mnt_flags &MNT_NOSUID )) {
Signature · 1 line
1.9.1
A message that is not in the archive (sent off-list or not yet received): [email protected]
PATCH 1/18 mnt: Implicitly add MNT_NODEV on remount when it was implicitly added by mount
Now that remount is properly enforcing the rule that you can't remove nodev at least sandstorm.io is breaking when performing a remount.
It turns out that there is an easy intuitive solution implicitly add nodev on remount when nodev was implicitly added on mount.
--- fs/namespace.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-)
fs/namespace.c +7 -1
@@ -2098,7 +2098,13 @@ static int do_remount(struct path *path, int flags, int mnt_flags, }if ((mnt->mnt.mnt_flags &MNT_LOCK_NODEV ) && !(mnt_flags &MNT_NODEV )) { -return -EPERM ; +/* Was the nodev implicitly added in mount? */ +if ((mnt->mnt_ns->user_ns != &init_user_ns) && + !(sb->s_type->fs_flags &FS_USERNS_DEV_MOUNT )) { + mnt_flags |=MNT_NODEV ; + }else { +return -EPERM ; + } }if ((mnt->mnt.mnt_flags &MNT_LOCK_NOSUID ) && !(mnt_flags &MNT_NOSUID )) {
Signature · 1 line
1.9.1
PATCH 2/18 mnt: Update unprivileged remount test
In reply to a message not in the archive- MNT_NODEV should be irrelevant except when reading back mount flags, no longer specify MNT_NODEV on remount.
- Test MNT_NODEV on devpts where it is meaningful even for unprivileged mounts.
- Add a test to verify that remount of a prexisting mount with the same flags is allowed and does not change those flags.
- Cleanup up the definitions of MS_REC, MS_RELATIME, MS_STRICTATIME that are used when the code is built in an environment without them.
- Correct the test error messages when tests fail. There were not 5 tests that tested MS_RELATIME.
--- .../selftests/mount/unprivileged-remount-test.c | 172 +++++++++++++++++---- 1 file changed, 142 insertions(+), 30 deletions(-)
tools/testing/selftests/mount/unprivileged-remount-test.c +142 -30
@@ -6,6 +6,8 @@#include <sys/types.h> #include <sys/mount.h> #include <sys/wait.h> +#include <sys/vfs.h> +#include <sys/statvfs.h> #include <stdlib.h> #include <unistd.h> #include <fcntl.h>
@@ -32,11 +34,14 @@# define CLONE_NEWPID 0x20000000#endif +#ifndef MS_REC +# define MS_REC 16384 +#endif #ifndef MS_RELATIME -#define MS_RELATIME (1 << 21) +# define MS_RELATIME (1 << 21)#endif #ifndef MS_STRICTATIME -#define MS_STRICTATIME (1 << 24) +# define MS_STRICTATIME (1 << 24)#endif static void die (char *fmt, ...)
@@ -87,6 +92,45 @@ static void write_file(char *filename, char *fmt, ...) } } +static int read_mnt_flags (const char *path) +{ +int ret; +struct statvfs stat; +int mnt_flags; + + ret =statvfs (path, &stat); +if (ret !=0 ) { +die ("statvfs of %s failed: %s\n" , + path,strerror (errno)); + } +if (stat.f_flag & ~(ST_RDONLY |ST_NOSUID |ST_NODEV | \ +ST_NOEXEC |ST_NOATIME |ST_NODIRATIME |ST_RELATIME | \ +ST_SYNCHRONOUS |ST_MANDLOCK )) { +die ("Unrecognized mount flags\n" ); + } + mnt_flags =0 ; +if (stat.f_flag &ST_RDONLY ) + mnt_flags |=MS_RDONLY ; +if (stat.f_flag &ST_NOSUID ) + mnt_flags |=MS_NOSUID ; +if (stat.f_flag &ST_NODEV ) + mnt_flags |=MS_NODEV ; +if (stat.f_flag &ST_NOEXEC ) + mnt_flags |=MS_NOEXEC ; +if (stat.f_flag &ST_NOATIME ) + mnt_flags |=MS_NOATIME ; +if (stat.f_flag &ST_NODIRATIME ) + mnt_flags |=MS_NODIRATIME ; +if (stat.f_flag &ST_RELATIME ) + mnt_flags |=MS_RELATIME ; +if (stat.f_flag &ST_SYNCHRONOUS ) + mnt_flags |=MS_SYNCHRONOUS ; +if (stat.f_flag &ST_MANDLOCK ) + mnt_flags |=ST_MANDLOCK ; + +return mnt_flags; +} +static void create_and_enter_userns (void ) {uid_t uid;
@@ -118,7 +162,8 @@ static void create_and_enter_userns(void) }static -bool test_unpriv_remount (int mount_flags,int remount_flags,int invalid_flags) +bool test_unpriv_remount (const char *fstype,const char *mount_options, +int mount_flags,int remount_flags,int invalid_flags) {pid_t child;
@@ -151,9 +196,11 @@ bool test_unpriv_remount(int mount_flags, int remount_flags, int invalid_flags) strerror(errno)); } -if (mount ("testing" ,"/tmp" ,"ramfs" , mount_flags,NULL ) !=0 ) { -die ("mount of /tmp failed: %s\n" , -strerror (errno)); +if (mount ("testing" ,"/tmp" , fstype, mount_flags, mount_options) !=0 ) { +die ("mount of %s with options '%s' on /tmp failed: %s\n" , + fstype, + mount_options? mount_options :"" , +strerror (errno)); }create_and_enter_userns ();
@@ -181,62 +228,127 @@ bool test_unpriv_remount(int mount_flags, int remount_flags, int invalid_flags)static bool test_unpriv_remount_simple (int mount_flags) { -return test_unpriv_remount (mount_flags, mount_flags,0 ); +return test_unpriv_remount ("ramfs" ,NULL , mount_flags, mount_flags,0 ); }static bool test_unpriv_remount_atime (int mount_flags,int invalid_flags) { -return test_unpriv_remount (mount_flags, mount_flags, invalid_flags); +return test_unpriv_remount ("ramfs" ,NULL , mount_flags, mount_flags, + invalid_flags); +} + +static bool test_priv_mount_unpriv_remount (void ) +{ +pid_t child; +int ret; +const char *orig_path ="/dev" ; +const char *dest_path ="/tmp" ; +int orig_mnt_flags, remount_mnt_flags; + + child =fork (); +if (child ==-1 ) { +die ("fork failed: %s\n" , +strerror (errno)); + } +if (child !=0 ) {/* parent */ +pid_t pid; +int status; + pid =waitpid (child, &status,0 ); +if (pid ==-1 ) { +die ("waitpid failed: %s\n" , +strerror (errno)); + } +if (pid != child) { +die ("waited for %d got %d\n" , + child, pid); + } +if (!WIFEXITED (status)) { +die ("child did not terminate cleanly\n" ); + } +return WEXITSTATUS (status) ==EXIT_SUCCESS ? true : false; + } + + orig_mnt_flags =read_mnt_flags (orig_path); + +create_and_enter_userns (); + ret =unshare (CLONE_NEWNS ); +if (ret !=0 ) { +die ("unshare(CLONE_NEWNS) failed: %s\n" , +strerror (errno)); + } + + ret =mount (orig_path, dest_path,"bind" ,MS_BIND |MS_REC ,NULL ); +if (ret !=0 ) { +die ("recursive bind mount of %s onto %s failed: %s\n" , + orig_path, dest_path,strerror (errno)); + } + + ret =mount (dest_path, dest_path,"none" , +MS_REMOUNT |MS_BIND | orig_mnt_flags ,NULL ); +if (ret !=0 ) { +/* system("cat /proc/self/mounts"); */ +die ("remount of /tmp failed: %s\n" , +strerror (errno)); + } + + remount_mnt_flags =read_mnt_flags (dest_path); +if (orig_mnt_flags != remount_mnt_flags) { +die ("Mount flags unexpectedly changed during remount of %s originally mounted on %s\n" , + dest_path, orig_path); + } +exit (EXIT_SUCCESS ); }int main (int argc,char **argv) { -if (!test_unpriv_remount_simple (MS_RDONLY |MS_NODEV )) { +if (!test_unpriv_remount_simple (MS_RDONLY )) {die ("MS_RDONLY malfunctions\n" ); } -if (!test_unpriv_remount_simple (MS_NODEV )) { +if (!test_unpriv_remount ("devpts" ,"newinstance" ,MS_NODEV ,MS_NODEV ,0 )) {die ("MS_NODEV malfunctions\n" ); } -if (!test_unpriv_remount_simple (MS_NOSUID |MS_NODEV )) { +if (!test_unpriv_remount_simple (MS_NOSUID )) {die ("MS_NOSUID malfunctions\n" ); } -if (!test_unpriv_remount_simple (MS_NOEXEC |MS_NODEV )) { +if (!test_unpriv_remount_simple (MS_NOEXEC )) {die ("MS_NOEXEC malfunctions\n" ); } -if (!test_unpriv_remount_atime (MS_RELATIME |MS_NODEV , -MS_NOATIME |MS_NODEV )) +if (!test_unpriv_remount_atime (MS_RELATIME , +MS_NOATIME )) {die ("MS_RELATIME malfunctions\n" ); } -if (!test_unpriv_remount_atime (MS_STRICTATIME |MS_NODEV , -MS_NOATIME |MS_NODEV )) +if (!test_unpriv_remount_atime (MS_STRICTATIME , +MS_NOATIME )) {die ("MS_STRICTATIME malfunctions\n" ); } -if (!test_unpriv_remount_atime (MS_NOATIME |MS_NODEV , -MS_STRICTATIME |MS_NODEV )) +if (!test_unpriv_remount_atime (MS_NOATIME , +MS_STRICTATIME )) { -die ("MS_RELATIME malfunctions\n" ); +die ("MS_NOATIME malfunctions\n" ); } -if (!test_unpriv_remount_atime (MS_RELATIME |MS_NODIRATIME |MS_NODEV , -MS_NOATIME |MS_NODEV )) +if (!test_unpriv_remount_atime (MS_RELATIME |MS_NODIRATIME , +MS_NOATIME )) { -die ("MS_RELATIME malfunctions\n" ); +die ("MS_RELATIME|MS_NODIRATIME malfunctions\n" ); } -if (!test_unpriv_remount_atime (MS_STRICTATIME |MS_NODIRATIME |MS_NODEV , -MS_NOATIME |MS_NODEV )) +if (!test_unpriv_remount_atime (MS_STRICTATIME |MS_NODIRATIME , +MS_NOATIME )) { -die ("MS_RELATIME malfunctions\n" ); +die ("MS_STRICTATIME|MS_NODIRATIME malfunctions\n" ); } -if (!test_unpriv_remount_atime (MS_NOATIME |MS_NODIRATIME |MS_NODEV , -MS_STRICTATIME |MS_NODEV )) +if (!test_unpriv_remount_atime (MS_NOATIME |MS_NODIRATIME , +MS_STRICTATIME )) { -die ("MS_RELATIME malfunctions\n" ); +die ("MS_NOATIME|MS_DIRATIME malfunctions\n" ); } -if (!test_unpriv_remount (MS_STRICTATIME |MS_NODEV ,MS_NODEV , -MS_NOATIME |MS_NODEV )) +if (!test_unpriv_remount ("ramfs" ,NULL ,MS_STRICTATIME ,0 ,MS_NOATIME )) {die ("Default atime malfunctions\n" ); } +if (!test_priv_mount_unpriv_remount ()) { +die ("Mount flags unexpectedly changed after remount\n" ); + }return EXIT_SUCCESS ; }
Signature · 1 line
1.9.1
PATCH 3/18 umount: Disallow unprivileged mount force
In reply to a message not in the archiveForced unmount affects not just the mount namespace but the underlying superblock as well. Restrict forced unmount to the global root user for now. Otherwise it becomes possible a user in a less privileged mount namespace to force the shutdown of a superblock of a filesystem in a more privileged mount namespace, allowing a DOS attack on root.
--- fs/namespace.c | 3 +++ 1 file changed, 3 insertions(+)
fs/namespace.c +3 -0
@@ -1544,6 +1544,9 @@ SYSCALL_DEFINE2(umount, char __user *, name, int, flags) goto dput_and_out;if (mnt->mnt.mnt_flags &MNT_LOCKED ) goto dput_and_out; + retval = -EPERM ; +if (flags &MNT_FORCE && !capable (CAP_SYS_ADMIN )) + goto dput_and_out; retval =do_umount (mnt, flags); dput_and_out:
Signature · 1 line
1.9.1
Re: [PATCH review 03/18] umount: Disallow unprivileged mount force
Quoted 6 lines · Eric W. Biederman
Forced unmount affects not just the mount namespace but the underlying superblock as well. Restrict forced unmount to the global root user for now. Otherwise it becomes possible a user in a less privileged mount namespace to force the shutdown of a superblock of a filesystem in a more privileged mount namespace, allowing a DOS attack on root.
I thought I already fixed this. Did I miss part of it?
Quoted 23 lines
Signed-off-by "Eric W. Biederman" <[email protected]>--- fs/namespace.c | 3 +++ 1 file changed, 3 insertions(+)fs/namespace.c +3
-1@@ -1544,6 +1544,9 @@ SYSCALL_DEFINE2(umount, char __user *, name, int, flags) goto dput_and_out;if (mnt->mnt.mnt_flags &MNT_LOCKED ) goto dput_and_out; + retval = -EPERM ; +if (flags &MNT_FORCE && !capable (CAP_SYS_ADMIN )) + goto dput_and_out; retval =do_umount (mnt, flags); dput_and_out: --1.9.1
Signature · 2 lines
Andy Lutomirski AMA Capital Management, LLC
A message that is not in the archive (sent off-list or not yet received): CALCETrV2kBfzypMbYKgxJ4BqB6yBG6Xvo=sZy3tvTng5ZRvAKQ-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org
Re: [PATCH review 03/18] umount: Disallow unprivileged mount force
Quoted 10 lines · Andy Lutomirski
Quoted 6 lines · Eric W. Biederman
Forced unmount affects not just the mount namespace but the underlying superblock as well. Restrict forced unmount to the global root user for now. Otherwise it becomes possible a user in a less privileged mount namespace to force the shutdown of a superblock of a filesystem in a more privileged mount namespace, allowing a DOS attack on root.
I thought I already fixed this. Did I miss part of it?
My tree is based at 3.18-rc6 and as of there I don't see another fix.
You fixed the remount_sb case in umount I don't think you fixed forced unmounts themselves.
If you did fix this and can point me at it I will be happy to drop this patch.
Eric
Quoted 23 lines
Quoted 23 lines
--- fs/namespace.c | 3 +++ 1 file changed, 3 insertions(+)fs/namespace.c +3
-1@@ -1544,6 +1544,9 @@ SYSCALL_DEFINE2(umount, char __user *, name, int, flags) goto dput_and_out;if (mnt->mnt.mnt_flags &MNT_LOCKED ) goto dput_and_out; + retval = -EPERM ; +if (flags &MNT_FORCE && !capable (CAP_SYS_ADMIN )) + goto dput_and_out; retval =do_umount (mnt, flags); dput_and_out: --1.9.1
Re: [PATCH review 03/18] umount: Disallow unprivileged mount force
Quoted 13 lines · Eric W. Biederman
Quoted 10 lines · Andy Lutomirski
Quoted 6 lines · Eric W. Biederman
Forced unmount affects not just the mount namespace but the underlying superblock as well. Restrict forced unmount to the global root user for now. Otherwise it becomes possible a user in a less privileged mount namespace to force the shutdown of a superblock of a filesystem in a more privileged mount namespace, allowing a DOS attack on root.
I thought I already fixed this. Did I miss part of it?
Quoted 8 lines
My tree is based at 3.18-rc6 and as of there I don't see another fix.
You fixed the
remount_sbcase in umount I don't think you fixed forced unmounts themselves.If you did fix this and can point me at it I will be happy to drop this patch.
Oh, right, I missed:
if (flags & MNT_FORCE && sb->s_op->umount_begin) {
sb->s_op->umount_begin(sb);
}whoops.
--Andy
Quoted 26 lines
Eric
Quoted 23 lines
Quoted 23 lines
Signed-off-by "Eric W. Biederman" <[email protected]>--- fs/namespace.c | 3 +++ 1 file changed, 3 insertions(+)fs/namespace.c +3
-1@@ -1544,6 +1544,9 @@ SYSCALL_DEFINE2(umount, char __user *, name, int, flags) goto dput_and_out;if (mnt->mnt.mnt_flags &MNT_LOCKED ) goto dput_and_out; + retval = -EPERM ; +if (flags &MNT_FORCE && !capable (CAP_SYS_ADMIN )) + goto dput_and_out; retval =do_umount (mnt, flags); dput_and_out: --1.9.1
Signature · 2 lines
Andy Lutomirski AMA Capital Management, LLC
A message that is not in the archive (sent off-list or not yet received): [email protected]
Re: [PATCH review 03/18] umount: Disallow unprivileged mount force
Quoted 13 lines · Eric W. Biederman
Quoted 10 lines · Andy Lutomirski
Quoted 6 lines · Eric W. Biederman
Forced unmount affects not just the mount namespace but the underlying superblock as well. Restrict forced unmount to the global root user for now. Otherwise it becomes possible a user in a less privileged mount namespace to force the shutdown of a superblock of a filesystem in a more privileged mount namespace, allowing a DOS attack on root.
I thought I already fixed this. Did I miss part of it?
Quoted 8 lines
My tree is based at 3.18-rc6 and as of there I don't see another fix.
You fixed the
remount_sbcase in umount I don't think you fixed forced unmounts themselves.If you did fix this and can point me at it I will be happy to drop this patch.
Oh, right, I missed:
if (flags & MNT_FORCE && sb->s_op->umount_begin) {
sb->s_op->umount_begin(sb);
}whoops.
--Andy
Quoted 26 lines
Eric
Quoted 23 lines
Quoted 23 lines
--- fs/namespace.c | 3 +++ 1 file changed, 3 insertions(+)fs/namespace.c +3
-1@@ -1544,6 +1544,9 @@ SYSCALL_DEFINE2(umount, char __user *, name, int, flags) goto dput_and_out;if (mnt->mnt.mnt_flags &MNT_LOCKED ) goto dput_and_out; + retval = -EPERM ; +if (flags &MNT_FORCE && !capable (CAP_SYS_ADMIN )) + goto dput_and_out; retval =do_umount (mnt, flags); dput_and_out: --1.9.1
Signature · 2 lines
Andy Lutomirski AMA Capital Management, LLC
A message that is not in the archive (sent off-list or not yet received): 1418424509-22389-3-git-send-email-ebiederm-aS9lmoZGLiVWk0Htik3J/[email protected]
Re: [PATCH review 03/18] umount: Disallow unprivileged mount force
Quoted 6 lines · Eric W. Biederman
Forced unmount affects not just the mount namespace but the underlying superblock as well. Restrict forced unmount to the global root user for now. Otherwise it becomes possible a user in a less privileged mount namespace to force the shutdown of a superblock of a filesystem in a more privileged mount namespace, allowing a DOS attack on root.
I thought I already fixed this. Did I miss part of it?
Quoted 23 lines
--- fs/namespace.c | 3 +++ 1 file changed, 3 insertions(+)fs/namespace.c +3
-1@@ -1544,6 +1544,9 @@ SYSCALL_DEFINE2(umount, char __user *, name, int, flags) goto dput_and_out;if (mnt->mnt.mnt_flags &MNT_LOCKED ) goto dput_and_out; + retval = -EPERM ; +if (flags &MNT_FORCE && !capable (CAP_SYS_ADMIN )) + goto dput_and_out; retval =do_umount (mnt, flags); dput_and_out: --1.9.1
Signature · 2 lines
Andy Lutomirski AMA Capital Management, LLC
PATCH 4/18 umount: Do not allow unmounting rootfs.
In reply to a message not in the archiveQuoted 24 lines · Andrew Vagin
#define
_GNU_SOURCE
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sched.h>
#include <unistd.h>
#include <sys/mount.h>int
main(int argc, char **argv){ int fd; fd = open("/proc/self/ns/mnt", O_RDONLY); if (fd < 0) return 1; while (1) { if (umount2("/", MNT_DETACH) || setns(fd, CLONE_NEWNS)) break; } return 0; }
Quoted 9 lines
root@ubuntu:/home/avagin# gcc -Wall nsenter.c -o nsenter
root@ubuntu:/home/avagin# strace ./nsenter
execve("./nsenter", ["./nsenter"], [/* 22 vars */]) = 0
...
open("/proc/self/ns/mnt", O_RDONLY) = 3
umount("/", MNT_DETACH) = 0
setns(3, 131072) = 0
umount("/", MNT_DETACHcauses:
Quoted 24 lines
[ 260.548301] ------------[ cut here ]------------ [ 260.550941] kernel BUG at /build/buildd/linux-3.13.0/fs/pnode.c:372! [ 260.552068] invalid opcode: 0000 [#1] SMP [ 260.552068] Modules linked in: xt_CHECKSUM iptable_mangle xt_tcpudp xt_addrtype xt_conntrack ipt_MASQUERADE iptable_nat nf_conntrack_ipv4 nf_defrag_ipv4 nf_nat_ipv4 nf_nat nf_conntrack bridge stp llc dm_thin_pool dm_persistent_data dm_bufio dm_bio_prison iptable_filter ip_tables x_tables crct10dif_pclmul crc32_pclmul ghash_clmulni_intel binfmt_misc nfsd auth_rpcgss nfs_acl aesni_intel nfs lockd aes_x86_64 sunrpc fscache lrw gf128mul glue_helper ablk_helper cryptd serio_raw ppdev parport_pc lp parport btrfs xor raid6_pq libcrc32c psmouse floppy [ 260.552068] CPU: 0 PID: 1723 Comm: nsenter Not tainted 3.13.0-30-generic #55-Ubuntu [ 260.552068] Hardware name: Bochs Bochs, BIOS Bochs 01/01/2011 [ 260.552068] task: ffff8800376097f0 ti: ffff880074824000 task.ti: ffff880074824000 [ 260.552068] RIP: 0010:[<ffffffff811e9483>] [<ffffffff811e9483>] propagate_umount+0x123/0x130 [ 260.552068] RSP: 0018:ffff880074825e98 EFLAGS: 00010246 [ 260.552068] RAX: ffff88007c741140 RBX: 0000000000000002 RCX: ffff88007c741190 [ 260.552068] RDX: ffff88007c741190 RSI: ffff880074825ec0 RDI: ffff880074825ec0 [ 260.552068] RBP: ffff880074825eb0 R08: 00000000000172e0 R09: ffff88007fc172e0 [ 260.552068] R10: ffffffff811cc642 R11: ffffea0001d59000 R12: ffff88007c741140 [ 260.552068] R13: ffff88007c741140 R14: ffff88007c741140 R15: 0000000000000000 [ 260.552068] FS: 00007fd5c7e41740(0000) GS:ffff88007fc00000(0000) knlGS:0000000000000000 [ 260.552068] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 260.552068] CR2: 00007fd5c7968050 CR3: 0000000070124000 CR4: 00000000000406f0 [ 260.552068] Stack: [ 260.552068] 0000000000000002 0000000000000002 ffff88007c631000 ffff880074825ed8 [ 260.552068] ffffffff811dcfac ffff88007c741140 0000000000000002 ffff88007c741160 [ 260.552068] ffff880074825f38 ffffffff811dd12b ffffffff811cc642 0000000075640000 [ 260.552068] Call Trace: [ 260.552068] [<ffffffff811dcfac>] umount_tree+0x20c/0x260 [ 260.552068] [<ffffffff811dd12b>] do_umount+0x12b/0x300
Quoted 8 lines
[ 260.552068] [<ffffffff811cc642>] ? final_putname+0x22/0x50 [ 260.552068] [<ffffffff811cc849>] ? putname+0x29/0x40 [ 260.552068] [<ffffffff811dd88c>] SyS_umount+0xdc/0x100 [ 260.552068] [<ffffffff8172aeff>] tracesys+0xe1/0xe6 [ 260.552068] Code: 89 50 08 48 8b 50 08 48 89 02 49 89 45 08 e9 72 ff ff ff 0f 1f 44 00 00 4c 89 e6 4c 89 e7 e8 f5 f6 ff ff 48 89 c3 e9 39 ff ff ff <0f> 0b 66 2e 0f 1f 84 00 00 00 00 00 90 66 66 66 66 90 55 b8 01 [ 260.552068] RIP [<ffffffff811e9483>] propagate_umount+0x123/0x130 [ 260.552068] RSP <ffff880074825e98> [ 260.611451] ---[ end trace 11c33d85f1d4c652 ]--
Which in practice is totally uninteresting. Only the global root user can do it, and it is just a stupid thing to do.
However that is no excuse to allow a silly way to oops the kernel.
We can avoid this silly problem by setting MNT_LOCKED on the rootfs mount point and thus avoid needing any special cases in the unmount code.
--- fs/namespace.c | 1 + 1 file changed, 1 insertion(+)
fs/namespace.c +1 -0
@@ -3011,6 +3011,7 @@ static void __init init_mount_tree(void) root.mnt = mnt; root.dentry = mnt->mnt_root; + mnt->mnt_flags |=MNT_LOCKED ;set_fs_pwd (current->fs, &root);set_fs_root (current->fs, &root);
Signature · 1 line
1.9.1
PATCH 5/18 mnt: Move the clear of MNT_LOCKED from copy_tree to it's callers.
In reply to a message not in the archiveClear MNT_LOCKED in the callers of copy_tree except copy_mnt_ns, and collect_mounts. In copy_mnt_ns it is necessary to create an exact copy of a mount tree, so not clearing MNT_LOCKED is important. Similarly collect_mounts is used to take a snapshot of the mount tree for audit logging purposes and auditing using a faithful copy of the tree is important.
This becomes particularly significant when we start setting MNT_LOCKED on rootfs to prevent it from being unmounted.
--- fs/namespace.c | 1 - fs/pnode.c | 1 + 2 files changed, 1 insertion(+), 1 deletion(-)
fs/namespace.c +0 -1
@@ -1613,7 +1613,6 @@ struct mount *copy_tree(struct mount *mnt, struct dentry *dentry,if (IS_ERR (q))return q; - q->mnt.mnt_flags &= ~MNT_LOCKED ; q->mnt_mountpoint = mnt->mnt_mountpoint; p = mnt;
fs/pnode.c +1 -0
@@ -242,6 +242,7 @@ static int propagate_one(struct mount *m) child =copy_tree (last_source, last_source->mnt.mnt_root, type);if (IS_ERR (child))return PTR_ERR (child); + child->mnt.mnt_flags &= ~MNT_LOCKED ;mnt_set_mountpoint (m, mp, child); last_dest = m; last_source = child;
Signature · 1 line
1.9.1
PATCH 6/18 mnt: Carefully set CL_UNPRIVILEGED in clone_mnt
In reply to a message not in the archiveold->mnt_expiry should be ignored unless CL_EXPIRE is set.
--- fs/namespace.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
fs/namespace.c +2 -1
@@ -963,7 +963,8 @@ static struct mount *clone_mnt(struct mount *old, struct dentry *root, }/* Don't allow unprivileged users to reveal what is under a mount */ -if ((flag &CL_UNPRIVILEGED ) &&list_empty (&old->mnt_expire)) +if ((flag &CL_UNPRIVILEGED ) && + (!(flag &CL_EXPIRE ) ||list_empty (&old->mnt_expire))) mnt->mnt.mnt_flags |=MNT_LOCKED ;atomic_inc (&sb->s_active);
Signature · 1 line
1.9.1
PATCH 7/18 mnt: Clear mnt_expire during pivot_root
In reply to a message not in the archiveWhen inspecting the pivot_root and the current mount expiry logic I realized that pivot_root fails to clear like mount move does.
Add the missing line in case someone does the interesting feat of moving an expirable submount. This gives a strong guarantee that root of the filesystem tree will never expire.
--- fs/namespace.c | 2 ++ 1 file changed, 2 insertions(+)
fs/namespace.c +2 -0
@@ -2967,6 +2967,8 @@ SYSCALL_DEFINE2(pivot_root, const char __user *, new_root,/* mount new_root on / */ attach_mnt (new_mnt,real_mount (root_parent.mnt), root_mp);touch_mnt_namespace (current->nsproxy->mnt_ns); +/* A moved mount should not expire automatically */ +list_del_init (&new_mnt->mnt_expire);unlock_mount_hash ();chroot_fs_refs (&root, &new);put_mountpoint (root_mp);
Signature · 1 line
1.9.1
PATCH 8/18 groups: Consolidate the setgroups permission checks
In reply to a message not in the archiveToday there are 3 instances of setgroups and due to an oversight their permission checking has diverged. Add a common function so that they may all share the same permission checking code.
This corrects the current oversight in the current permission checks and adds a helper to avoid this in the future.
A user namespace security fix will update this new helper, shortly.
--- arch/s390/kernel/compat_linux.c | 2 +- include/linux/cred.h | 1 + kernel/groups.c | 9 ++++++++- kernel/uid16.c | 2 +- 4 files changed, 11 insertions(+), 3 deletions(-)
arch/s390/kernel/compat_linux.c +1 -1
@@ -249,7 +249,7 @@ COMPAT_SYSCALL_DEFINE2(s390_setgroups16, int, gidsetsize, u16 __user *, grouplisstruct group_info *group_info;int retval; -if (!capable (CAP_SETGID )) +if (!may_setgroups ())return -EPERM ;if ((unsigned )gidsetsize >NGROUPS_MAX )return -EINVAL ;
include/linux/cred.h +1 -0
@@ -68,6 +68,7 @@ extern void groups_free(struct group_info *);extern int set_current_groups (struct group_info *);extern void set_groups (struct cred *,struct group_info *);extern int groups_search (const struct group_info *,kgid_t ); +extern bool may_setgroups (void );/* access the groups "array" with this macro */ #define GROUP_AT (gi, i) \
kernel/groups.c +8 -1
@@ -213,6 +213,13 @@ out:return i; } +bool may_setgroups (void ) +{ +struct user_namespace *user_ns =current_user_ns (); + +return ns_capable (user_ns,CAP_SETGID ); +} +/* * SMP: Our groups are copy-on-write. We can set them safely * without another task interfering.
@@ -223,7 +230,7 @@ SYSCALL_DEFINE2(setgroups, int, gidsetsize, gid_t __user *, grouplist)struct group_info *group_info;int retval; -if (!ns_capable (current_user_ns (),CAP_SETGID )) +if (!may_setgroups ())return -EPERM ;if ((unsigned )gidsetsize >NGROUPS_MAX )return -EINVAL ;
kernel/uid16.c +1 -1
@@ -176,7 +176,7 @@ SYSCALL_DEFINE2(setgroups16, int, gidsetsize, old_gid_t __user *, grouplist)struct group_info *group_info;int retval; -if (!ns_capable (current_user_ns (),CAP_SETGID )) +if (!may_setgroups ())return -EPERM ;if ((unsigned )gidsetsize >NGROUPS_MAX )return -EINVAL ;
Signature · 1 line
1.9.1
PATCH 9/18 userns: Document what the invariant required for safe unprivileged mappings.
In reply to a message not in the archiveThe rule is simple. Don't allow anything that wouldn't be allowed without unprivileged mappings.
It was previously overlooked that establishing gid mappings would allow dropping groups and potentially gaining permission to files and directories that had lesser permissions for a specific group than for all other users.
This is the rule needed to fix CVE-2014-8989 and prevent any other security issues with new_idmap_permitted.
The reason for this rule is that the unix permission model is old and there are programs out there somewhere that take advantage of every little corner of it. So allowing a uid or gid mapping to be established without privielge that would allow anything that would not be allowed without that mapping will result in expectations from some code somewhere being violated. Violated expectations about the behavior of the OS is a long way to say a security issue.
--- kernel/user_namespace.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
kernel/user_namespace.c +3 -1
@@ -812,7 +812,9 @@ static bool new_idmap_permitted(const struct file *file, struct user_namespace *ns, int cap_setid, struct uid_gid_map *new_map) { - /* Allow mapping to your own filesystem ids */ + /* Don't allow mappings that would allow anything that wouldn't + * be allowed without the establishment of unprivileged mappings. + */ if ((new_map->nr_extents == 1) && (new_map->extent[0].count == 1)) { u32 id = new_map->extent[0 ].lower_first;if (cap_setid ==CAP_SETUID ) {
Signature · 1 line
1.9.1
PATCH 10/18 userns: Don't allow setgroups until a gid mapping has been setablished
In reply to a message not in the archivesetgroups is unique in not needing a valid mapping before it can be called, in the case of setgroups(0, NULL) which drops all supplemental groups.
The design of the user namespace assumes that CAP_SETGID can not actually be used until a gid mapping is established. Therefore add a helper function to see if the user namespace gid mapping has been established and call that function in the setgroups permission check.
This is part of the fix for CVE-2014-8989, being able to drop groups without privilege using user namespaces.
--- include/linux/user_namespace.h | 5 +++++ kernel/groups.c | 4 +++- kernel/user_namespace.c | 14 ++++++++++++++ 3 files changed, 22 insertions(+), 1 deletion(-)
include/linux/user_namespace.h +5 -0
@@ -63,6 +63,7 @@ extern const struct seq_operations proc_projid_seq_operations;extern ssize_t proc_uid_map_write (struct file *,const char __user *,size_t ,loff_t *);extern ssize_t proc_gid_map_write (struct file *,const char __user *,size_t ,loff_t *);extern ssize_t proc_projid_map_write (struct file *,const char __user *,size_t ,loff_t *); +extern bool userns_may_setgroups (const struct user_namespace *ns);#else static inline struct user_namespace *get_user_ns (struct user_namespace *ns)
@@ -87,6 +88,10 @@ static inline void put_user_ns(struct user_namespace *ns) { } +static inline bool userns_may_setgroups (const struct user_namespace *ns) +{ +return true; +}#endif #endif /* _LINUX_USER_H */
kernel/groups.c +3 -1
@@ -6,6 +6,7 @@#include <linux/slab.h> #include <linux/security.h> #include <linux/syscalls.h> +#include <linux/user_namespace.h> #include <asm/uaccess.h> /* init to 2 - one for init_task, one to ensure it is never freed */
@@ -217,7 +218,8 @@ bool may_setgroups(void) {struct user_namespace *user_ns =current_user_ns (); -return ns_capable (user_ns,CAP_SETGID ); +return ns_capable (user_ns,CAP_SETGID ) && +userns_may_setgroups (user_ns); }/*
kernel/user_namespace.c +14 -0
@@ -843,6 +843,20 @@ static bool new_idmap_permitted(const struct file *file,return false; } +bool userns_may_setgroups (const struct user_namespace *ns) +{ +bool allowed; + +mutex_lock (&id_map_mutex); +/* It is not safe to use setgroups until a gid mapping in +* the user namespace has been established. +*/ + allowed = ns->gid_map.nr_extents !=0 ; +mutex_unlock (&id_map_mutex); + +return allowed; +} +static void *userns_get (struct task_struct *task) {struct user_namespace *user_ns;
Signature · 1 line
1.9.1
PATCH 11/18 userns: Don't allow unprivileged creation of gid mappings
In reply to a message not in the archiveAs any gid mapping will allow and must allow for backwards compatibility dropping groups don't allow any gid mappings to be established without CAP_SETGID in the parent user namespace.
For a small class of applications this change breaks userspace and removes useful functionality. This small class of applications includes tools/testing/selftests/mount/unprivilged-remount-test.c
Most of the removed functionality will be added back with the addition of a one way knob to disable setgroups. Once setgroups is disabled setting the gid_map becomes as safe as setting the uid_map.
For more common applications that set the uid_map and the gid_map with privilege this change will have no affect.
This is part of a fix for CVE-2014-8989.
--- kernel/user_namespace.c | 4 ---- 1 file changed, 4 deletions(-)
kernel/user_namespace.c +0 -4
@@ -821,10 +821,6 @@ static bool new_idmap_permitted(const struct file *file,kuid_t uid =make_kuid (ns->parent, id);if (uid_eq (uid, file->f_cred->fsuid))return true; - }else if (cap_setid ==CAP_SETGID ) { -kgid_t gid =make_kgid (ns->parent, id); -if (gid_eq (gid, file->f_cred->fsgid)) -return true; } }
Signature · 1 line
1.9.1
PATCH 12/18 userns: Check euid no fsuid when establishing an unprivileged uid mapping
In reply to a message not in the archivesetresuid allows the euid to be set to any of uid, euid, suid, and fsuid. Therefor it is safe to allow an unprivileged user to map their euid and use CAP_SETUID privileged with exactly that uid, as no new credentials can be obtained.
I can not find a combination of existing system calls that allows setting uid, euid, suid, and fsuid from the fsuid making the previous use of fsuid for allowing unprivileged mappings a bug.
This is part of a fix for CVE-2014-8989.
--- kernel/user_namespace.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/user_namespace.c +1 -1
@@ -819,7 +819,7 @@ static bool new_idmap_permitted(const struct file *file,u32 id = new_map->extent[0 ].lower_first;if (cap_setid ==CAP_SETUID ) {kuid_t uid =make_kuid (ns->parent, id); -if (uid_eq (uid, file->f_cred->fsuid)) +if (uid_eq (uid, file->f_cred->euid))return true; } }
Signature · 1 line
1.9.1
PATCH 13/18 userns: Only allow the creator of the userns unprivileged mappings
In reply to a message not in the archiveIf you did not create the user namespace and are allowed to write to uid_map or gid_map you should already have the necessary privilege in the parent user namespace to establish any mapping you want so this will not affect userspace in practice.
Limiting unprivileged uid mapping establishment to the creator of the user namespace makes it easier to verify all credentials obtained with the uid mapping can be obtained without the uid mapping without privilege.
Limiting unprivileged gid mapping establishment (which is temporarily absent) to the creator of the user namespace also ensures that the combination of uid and gid can already be obtained without privilege.
This is part of the fix for CVE-2014-8989.
--- kernel/user_namespace.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
kernel/user_namespace.c +4 -2
@@ -812,14 +812,16 @@ static bool new_idmap_permitted(const struct file *file, struct user_namespace *ns, int cap_setid, struct uid_gid_map *new_map) { + const struct cred *cred = file->f_cred;/* Don't allow mappings that would allow anything that wouldn't * be allowed without the establishment of unprivileged mappings. */ - if ((new_map->nr_extents == 1) && (new_map->extent[0].count == 1)) { +if ((new_map->nr_extents ==1 ) && (new_map->extent[0 ].count ==1 ) && +uid_eq (ns->owner, cred->euid)) {u32 id = new_map->extent[0 ].lower_first;if (cap_setid ==CAP_SETUID ) {kuid_t uid =make_kuid (ns->parent, id); -if (uid_eq (uid, file->f_cred->euid)) +if (uid_eq (uid, cred->euid))return true; } }
Signature · 1 line
1.9.1
PATCH 14/18 userns: Rename id_map_mutex to userns_state_mutex
In reply to a message not in the archiveGeneralize id_map_mutex so it can be used for more state of a user namespace.
--- kernel/user_namespace.c | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-)
kernel/user_namespace.c +6 -8
@@ -24,6 +24,7 @@#include <linux/fs_struct.h> static struct kmem_cache *user_ns_cachep__read_mostly ; +static DEFINE_MUTEX (userns_state_mutex); static bool new_idmap_permitted(const struct file *file, struct user_namespace *ns, int cap_setid,
@@ -583,9 +584,6 @@ static bool mappings_overlap(struct uid_gid_map *new_map,return false; } - -static DEFINE_MUTEX (id_map_mutex); - static ssize_t map_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos, int cap_setid,
@@ -602,7 +600,7 @@ static ssize_t map_write(struct file *file, const char __user *buf,ssize_t ret = -EINVAL ;/* -* The id_map_mutex serializes all writes to any given map. +* The userns_state_mutex serializes all writes to any given map. * * Any map is only ever written once. *
@@ -620,7 +618,7 @@ static ssize_t map_write(struct file *file, const char __user *buf,* order and smp_rmb() is guaranteed that we don't have crazy * architectures returning stale data. */ -mutex_lock (&id_map_mutex); +mutex_lock (&userns_state_mutex); ret = -EPERM ;/* Only allow one successful write to the map */
@@ -750,7 +748,7 @@ static ssize_t map_write(struct file *file, const char __user *buf, *ppos = count; ret = count; out: -mutex_unlock (&id_map_mutex); +mutex_unlock (&userns_state_mutex);if (page)free_page (page);return ret;
@@ -845,12 +843,12 @@ bool userns_may_setgroups(const struct user_namespace *ns) {bool allowed; -mutex_lock (&id_map_mutex); +mutex_lock (&userns_state_mutex);/* It is not safe to use setgroups until a gid mapping in * the user namespace has been established. */ allowed = ns->gid_map.nr_extents !=0 ; -mutex_unlock (&id_map_mutex); +mutex_unlock (&userns_state_mutex);return allowed; }
Signature · 1 line
1.9.1
PATCH 15/18 userns: Add a knob to disable setgroups on a per user namespace basis
In reply to a message not in the archive- Expose the knob to user space through a proc file /proc/<pid>/setgroups
A value of "deny" means the setgroups system call is disabled in the current processes user namespace and can not be enabled in the future in this user namespace.
A value of "allow" means the segtoups system call is enabled.
- Descendant user namespaces inherit the value of setgroups from their parents.
- A proc file is used (instead of a sysctl) as sysctls currently do not allow checking the permissions at open time.
- Writing to the proc file is restricted to before the gid_map for the user namespace is set.
This ensures that disabling setgroups at a user namespace level will never remove the ability to call setgroups from a process that already has that ability.
A process may opt in to the setgroups disable for itself by creating, entering and configuring a user namespace or by calling setns on an existing user namespace with setgroups disabled. Processes without privileges already can not call setgroups so this is a noop. Prodcess with privilege become processes without privilege when entering a user namespace and as with any other path to dropping privilege they would not have the ability to call setgroups. So this remains within the bounds of what is possible without a knob to disable setgroups permanently in a user namespace.
--- fs/proc/base.c | 53 ++++++++++++++++++++++++++ include/linux/user_namespace.h | 7 ++++ kernel/user.c | 1 + kernel/user_namespace.c | 85 ++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 146 insertions(+)
fs/proc/base.c +53 -0
@@ -2464,6 +2464,57 @@ static const struct file_operations proc_projid_map_operations = { .llseek = seq_lseek, .release = proc_id_map_release, }; + +static int proc_setgroups_open (struct inode *inode,struct file *file) +{ +struct user_namespace *ns =NULL ; +struct task_struct *task; +int ret; + + ret = -ESRCH ; + task =get_proc_task (inode); +if (task) { +rcu_read_lock (); + ns =get_user_ns (task_cred_xxx (task, user_ns)); +rcu_read_unlock (); +put_task_struct (task); + } +if (!ns) + goto err; + +if (file->f_mode &FMODE_WRITE ) { + ret = -EACCES ; +if (!ns_capable (ns,CAP_SYS_ADMIN )) + goto err_put_ns; + } + + ret =single_open (file, &proc_setgroups_show, ns); +if (ret) + goto err_put_ns; + +return 0 ; +err_put_ns: +put_user_ns (ns); +err: +return ret; +} + +static int proc_setgroups_release (struct inode *inode,struct file *file) +{ +struct seq_file *seq = file->private_data; +struct user_namespace *ns = seq->private; +int ret =single_release (inode, file); +put_user_ns (ns); +return ret; +} + +static const struct file_operations proc_setgroups_operations = { + .open = proc_setgroups_open, + .write = proc_setgroups_write, + .read = seq_read, + .llseek = seq_lseek, + .release = proc_setgroups_release, +};#endif /* CONFIG_USER_NS */ static int proc_pid_personality(struct seq_file *m, struct pid_namespace *ns,
@@ -2572,6 +2623,7 @@ static const struct pid_entry tgid_base_stuff[] = {REG ("uid_map" ,S_IRUGO |S_IWUSR , proc_uid_map_operations),REG ("gid_map" ,S_IRUGO |S_IWUSR , proc_gid_map_operations),REG ("projid_map" ,S_IRUGO |S_IWUSR , proc_projid_map_operations), +REG ("setgroups" ,S_IRUGO |S_IWUSR , proc_setgroups_operations), #endif #ifdef CONFIG_CHECKPOINT_RESTORE REG("timers", S_IRUGO, proc_timers_operations),
@@ -2913,6 +2965,7 @@ static const struct pid_entry tid_base_stuff[] = {REG ("uid_map" ,S_IRUGO |S_IWUSR , proc_uid_map_operations),REG ("gid_map" ,S_IRUGO |S_IWUSR , proc_gid_map_operations),REG ("projid_map" ,S_IRUGO |S_IWUSR , proc_projid_map_operations), + REG("setgroups", S_IRUGO|S_IWUSR, proc_setgroups_operations), #endif };
include/linux/user_namespace.h +7 -0
@@ -17,6 +17,10 @@ struct uid_gid_map { /* 64 bytes -- 1 cache line */ } extent[UID_GID_MAP_MAX_EXTENTS ]; }; +#define USERNS_SETGROUPS_ALLOWED 1UL + +#define USERNS_INIT_FLAGS USERNS_SETGROUPS_ALLOWED +struct user_namespace {struct uid_gid_map uid_map;struct uid_gid_map gid_map;
@@ -27,6 +31,7 @@ struct user_namespace {kuid_t owner;kgid_t group;unsigned int proc_inum; +unsigned long flags;/* Register of per-UID persistent keyrings for this namespace */ #ifdef CONFIG_PERSISTENT_KEYRINGS
@@ -63,6 +68,8 @@ extern const struct seq_operations proc_projid_seq_operations;extern ssize_t proc_uid_map_write (struct file *,const char __user *,size_t ,loff_t *);extern ssize_t proc_gid_map_write (struct file *,const char __user *,size_t ,loff_t *);extern ssize_t proc_projid_map_write (struct file *,const char __user *,size_t ,loff_t *); +extern ssize_t proc_setgroups_write (struct file *,const char __user *,size_t ,loff_t *); +extern int proc_setgroups_show (struct seq_file *m,void *v);extern bool userns_may_setgroups (const struct user_namespace *ns);#else
kernel/user.c +1 -0
@@ -51,6 +51,7 @@ struct user_namespace init_user_ns = { .owner = GLOBAL_ROOT_UID, .group = GLOBAL_ROOT_GID, .proc_inum = PROC_USER_INIT_INO, + .flags =USERNS_INIT_FLAGS , #ifdef CONFIG_PERSISTENT_KEYRINGS .persistent_keyring_register_sem = __RWSEM_INITIALIZER(init_user_ns.persistent_keyring_register_sem),
kernel/user_namespace.c +85 -0
103 lines not on this page · raw message
Signature · 1 line
1.9.1
PATCH 16/18 userns: Allow setting gid_maps without privilege when setgroups is disabled
In reply to a message not in the archiveNow that setgroups can be disabled and not reenabled, setting gid_map without privielge can now be enabled when setgroups is disabled.
This restores most of the functionality that was lost when unprivileged setting of gid_map was removed. Applications that use this functionality will need to check to see if they use setgroups or init_groups, and if they don't they can be fixed by simply disabling setgroups before writing to gid_map.
--- kernel/user_namespace.c | 5 +++++ 1 file changed, 5 insertions(+)
kernel/user_namespace.c +5 -0
@@ -826,6 +826,11 @@ static bool new_idmap_permitted(const struct file *file,kuid_t uid =make_kuid (ns->parent, id);if (uid_eq (uid, cred->euid))return true; + }else if (cap_setid ==CAP_SETGID ) { +kgid_t gid =make_kgid (ns->parent, id); +if (!(ns->flags &USERNS_SETGROUPS_ALLOWED ) && +gid_eq (gid, cred->egid)) +return true; } }
Signature · 1 line
1.9.1
PATCH 17/18 userns; Correct the comment in map_write
In reply to a message not in the archiveIt is important that all maps are less than PAGE_SIZE or else setting the last byte of the buffer to '0' could write off the end of the allocated storage.
Correct the misleading comment.
--- kernel/user_namespace.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/user_namespace.c +1 -1
@@ -643,7 +643,7 @@ static ssize_t map_write(struct file *file, const char __user *buf,if (!page) goto out; -/* Only allow <= page size writes at the beginning of the file */ +/* Only allow < page size writes at the beginning of the file */ ret = -EINVAL ;if ((*ppos !=0 ) || (count >=PAGE_SIZE )) goto out;
Signature · 1 line
1.9.1
PATCH 18/18 userns: Unbreak the unprivileged remount tests
In reply to a message not in the archiveA security fix in caused the way the unprivileged remount tests were using user namespaces to break. Tweak the way user namespaces are being used so the test works again.
--- .../selftests/mount/unprivileged-remount-test.c | 32 ++++++++++++++++------ 1 file changed, 24 insertions(+), 8 deletions(-)
tools/testing/selftests/mount/unprivileged-remount-test.c +24 -8
@@ -53,17 +53,14 @@ static void die(char *fmt, ...)exit (EXIT_FAILURE ); } -static void write_file (char *filename,char *fmt, ...) +static void vmaybe_write_file (bool enoent_ok,char *filename,char *fmt,va_list ap) {char buf[4096 ];int fd;ssize_t written;int buf_len; -va_list ap; -va_start (ap, fmt); buf_len =vsnprintf (buf,sizeof (buf), fmt, ap); -va_end (ap);if (buf_len <0 ) {die ("vsnprintf failed: %s\n" ,strerror (errno));
@@ -74,6 +71,8 @@ static void write_file(char *filename, char *fmt, ...) fd =open (filename,O_WRONLY );if (fd <0 ) { +if ((errno ==ENOENT ) && enoent_ok) +return ;die ("open of %s failed: %s\n" , filename,strerror (errno)); }
@@ -92,6 +91,26 @@ static void write_file(char *filename, char *fmt, ...) } } +static void maybe_write_file (char *filename,char *fmt, ...) +{ +va_list ap; + +va_start (ap, fmt); +vmaybe_write_file (true, filename, fmt, ap); +va_end (ap); + +} + +static void write_file (char *filename,char *fmt, ...) +{ +va_list ap; + +va_start (ap, fmt); +vmaybe_write_file (false, filename, fmt, ap); +va_end (ap); + +} +static int read_mnt_flags (const char *path) {int ret;
@@ -144,13 +163,10 @@ static void create_and_enter_userns(void) strerror(errno)); } +maybe_write_file ("/proc/self/setgroups" ,"deny" );write_file ("/proc/self/uid_map" ,"0 %d 1" , uid);write_file ("/proc/self/gid_map" ,"0 %d 1" , gid); -if (setgroups (0 ,NULL ) !=0 ) { -die ("setgroups failed: %s\n" , -strerror (errno)); - }if (setgid (0 ) !=0 ) {die ("setgid(0) failed %s\n" ,strerror (errno));
Signature · 1 line
1.9.1
Am 12.12.2014 um 23:32 schrieb Eric W. Biederman:
Quoted 16 lines
The entire tree for testing is available at:
git.kernel.org:/pub/scm/linux/kernel/git/ebiederm/user-namespace.git for-testingThis is my queue of important bug fixes for user namespaces. Most of these changes warrant being backported. A few are bug fixes for cases where only root can trigger the issue so have not been marked for being back ported to stable.
A few of these patches have not been posted for review preivously, so I a giving the light of mailling list before I send them to Linus. This patchset has seen some testing already.
Since there are small deliberate breakage of userspace in here the more reviewers/testers the better.
Quoted 6 lines
Baring complictions I intend to ask Linus to pull this patchset sometime early next week.
So far nothing broke on my libvirt-lxc test bed. :-) Tested with openSUSE 13.2 and libvirt 1.2.9.
FYI, this change set breaks util-linux's unshare(1) tool
as an unprivileged is no longer allowed to write to /proc/self/gid_map.
Thanks,
//richard
A message that is not in the archive (sent off-list or not yet received): 548DE7D7.3080607-/[email protected]
Quoted 20 lines · Richard Weinberger
Am 12.12.2014 um 23:32 schrieb Eric W. Biederman:
Quoted 19 lines
The entire tree for testing is available at:
git.kernel.org:/pub/scm/linux/kernel/git/ebiederm/user-namespace.git for-testingThis is my queue of important bug fixes for user namespaces. Most of these changes warrant being backported. A few are bug fixes for cases where only root can trigger the issue so have not been marked for being back ported to stable.
A few of these patches have not been posted for review preivously, so I a giving the light of mailling list before I send them to Linus. This patchset has seen some testing already.
Since there are small deliberate breakage of userspace in here the more reviewers/testers the better.
Baring complictions I intend to ask Linus to pull this patchset sometime early next week.
Quoted 7 lines
Quoted 3 lines
So far nothing broke on my libvirt-lxc test bed. :-) Tested with openSUSE 13.2 and libvirt 1.2.9.
FYI, this change set breaks util-linux's unshare(1) tool as an unprivileged is no longer allowed to write to
/proc/self/gid_map.
Only the --map-root-user option. The patch below fixes it. I will push this upstream after I push the main change to Linus.
This probably deseres a little discussion on the util-linux list. Most use cases will continue to work but with setgroups disabled some things won't work and can not be made to work without privilege.
From: "Eric W. Biederman" <ebiederm-aS9lmoZGLiVWk0Htik3J/[email protected]>
Date: Thu, 11 Dec 2014 20:05:25 -0600
Subject: [PATCH] unshare: Fix --map-root-user to work on new kernels
In rare cases droping groups with setgroups(0, NULL) is an operation that can grant a user additional privileges. User namespaces were allwoing that operation to unprivileged users and that had to be fixed.
Update unshare --map-root-user to disable the setgroups operation before setting the gid_map.
This is needed as after the security fix gid_map is restricted to privileged users unless setgroups has been disabled.
--- include/pathnames.h | 1 + sys-utils/unshare.c | 19 +++++++++++++++++++ 2 files changed, 20 insertions(+)
include/pathnames.h +1 -0
@@ -92,6 +92,7 @@#define _PATH_PROC_UIDMAP "/proc/self/uid_map"#define _PATH_PROC_GIDMAP "/proc/self/gid_map" +#define _PATH_PROC_SETGROUPS "/proc/self/setgroups"#define _PATH_PROC_ATTR_CURRENT "/proc/self/attr/current"#define _PATH_PROC_ATTR_EXEC "/proc/self/attr/exec"
sys-utils/unshare.c +19 -0
@@ -39,6 +39,24 @@#include "pathnames.h" #include "all-io.h" +static void disable_setgroups (void ) +{ +const char *file = _PATH_PROC_SETGROUPS; +const char *deny ="deny" ; +int fd; + + fd =open (file,O_WRONLY ); +if (fd <0 ) { +if (errno ==ENOENT ) +return ; +err (EXIT_FAILURE ,_ ("cannot open %s" ), file); + } + +if (write_all (fd, deny,strlen (deny))) +err (EXIT_FAILURE ,_ ("write failed %s" ), file); +close (fd); +} +static void map_id (const char *file,uint32_t from,uint32_t to) {char *buf;
@@ -178,6 +196,7 @@ int main(int argc, char *argv[]) }if (maproot) { +disable_setgroups ();map_id (_PATH_PROC_UIDMAP,0 , real_euid);map_id (_PATH_PROC_GIDMAP,0 , real_egid); }
Signature · 1 line
2.1.3
Quoted 20 lines · Richard Weinberger
Am 12.12.2014 um 23:32 schrieb Eric W. Biederman:
Quoted 19 lines
The entire tree for testing is available at:
git.kernel.org:/pub/scm/linux/kernel/git/ebiederm/user-namespace.git for-testingThis is my queue of important bug fixes for user namespaces. Most of these changes warrant being backported. A few are bug fixes for cases where only root can trigger the issue so have not been marked for being back ported to stable.
A few of these patches have not been posted for review preivously, so I a giving the light of mailling list before I send them to Linus. This patchset has seen some testing already.
Since there are small deliberate breakage of userspace in here the more reviewers/testers the better.
Baring complictions I intend to ask Linus to pull this patchset sometime early next week.
Quoted 7 lines
Quoted 3 lines
So far nothing broke on my libvirt-lxc test bed. :-) Tested with openSUSE 13.2 and libvirt 1.2.9.
Tested-by Richard Weinberger <[email protected]>FYI, this change set breaks util-linux's unshare(1) tool as an unprivileged is no longer allowed to write to
/proc/self/gid_map.
Only the --map-root-user option. The patch below fixes it. I will push this upstream after I push the main change to Linus.
This probably deseres a little discussion on the util-linux list. Most use cases will continue to work but with setgroups disabled some things won't work and can not be made to work without privilege.
From: "Eric W. Biederman" <[email protected]>
Date: Thu, 11 Dec 2014 20:05:25 -0600
Subject: [PATCH] unshare: Fix --map-root-user to work on new kernels
In rare cases droping groups with setgroups(0, NULL) is an operation that can grant a user additional privileges. User namespaces were allwoing that operation to unprivileged users and that had to be fixed.
Update unshare --map-root-user to disable the setgroups operation before setting the gid_map.
This is needed as after the security fix gid_map is restricted to privileged users unless setgroups has been disabled.
--- include/pathnames.h | 1 + sys-utils/unshare.c | 19 +++++++++++++++++++ 2 files changed, 20 insertions(+)
include/pathnames.h +1 -0
@@ -92,6 +92,7 @@#define _PATH_PROC_UIDMAP "/proc/self/uid_map"#define _PATH_PROC_GIDMAP "/proc/self/gid_map" +#define _PATH_PROC_SETGROUPS "/proc/self/setgroups"#define _PATH_PROC_ATTR_CURRENT "/proc/self/attr/current"#define _PATH_PROC_ATTR_EXEC "/proc/self/attr/exec"
sys-utils/unshare.c +19 -0
@@ -39,6 +39,24 @@#include "pathnames.h" #include "all-io.h" +static void disable_setgroups (void ) +{ +const char *file = _PATH_PROC_SETGROUPS; +const char *deny ="deny" ; +int fd; + + fd =open (file,O_WRONLY ); +if (fd <0 ) { +if (errno ==ENOENT ) +return ; +err (EXIT_FAILURE ,_ ("cannot open %s" ), file); + } + +if (write_all (fd, deny,strlen (deny))) +err (EXIT_FAILURE ,_ ("write failed %s" ), file); +close (fd); +} +static void map_id (const char *file,uint32_t from,uint32_t to) {char *buf;
@@ -178,6 +196,7 @@ int main(int argc, char *argv[]) }if (maproot) { +disable_setgroups ();map_id (_PATH_PROC_UIDMAP,0 , real_euid);map_id (_PATH_PROC_GIDMAP,0 , real_egid); }
Signature · 1 line
2.1.3
PATCH 2/18 mnt: Update unprivileged remount test
In reply to Eric W. Biederman- MNT_NODEV should be irrelevant except when reading back mount flags, no longer specify MNT_NODEV on remount.
- Test MNT_NODEV on devpts where it is meaningful even for unprivileged mounts.
- Add a test to verify that remount of a prexisting mount with the same flags is allowed and does not change those flags.
- Cleanup up the definitions of MS_REC, MS_RELATIME, MS_STRICTATIME that are used when the code is built in an environment without them.
- Correct the test error messages when tests fail. There were not 5 tests that tested MS_RELATIME.
--- .../selftests/mount/unprivileged-remount-test.c | 172 +++++++++++++++++---- 1 file changed, 142 insertions(+), 30 deletions(-)
tools/testing/selftests/mount/unprivileged-remount-test.c +142 -30
@@ -6,6 +6,8 @@#include <sys/types.h> #include <sys/mount.h> #include <sys/wait.h> +#include <sys/vfs.h> +#include <sys/statvfs.h> #include <stdlib.h> #include <unistd.h> #include <fcntl.h>
@@ -32,11 +34,14 @@# define CLONE_NEWPID 0x20000000#endif +#ifndef MS_REC +# define MS_REC 16384 +#endif #ifndef MS_RELATIME -#define MS_RELATIME (1 << 21) +# define MS_RELATIME (1 << 21)#endif #ifndef MS_STRICTATIME -#define MS_STRICTATIME (1 << 24) +# define MS_STRICTATIME (1 << 24)#endif static void die (char *fmt, ...)
@@ -87,6 +92,45 @@ static void write_file(char *filename, char *fmt, ...) } } +static int read_mnt_flags (const char *path) +{ +int ret; +struct statvfs stat; +int mnt_flags; + + ret =statvfs (path, &stat); +if (ret !=0 ) { +die ("statvfs of %s failed: %s\n" , + path,strerror (errno)); + } +if (stat.f_flag & ~(ST_RDONLY |ST_NOSUID |ST_NODEV | \ +ST_NOEXEC |ST_NOATIME |ST_NODIRATIME |ST_RELATIME | \ +ST_SYNCHRONOUS |ST_MANDLOCK )) { +die ("Unrecognized mount flags\n" ); + } + mnt_flags =0 ; +if (stat.f_flag &ST_RDONLY ) + mnt_flags |=MS_RDONLY ; +if (stat.f_flag &ST_NOSUID ) + mnt_flags |=MS_NOSUID ; +if (stat.f_flag &ST_NODEV ) + mnt_flags |=MS_NODEV ; +if (stat.f_flag &ST_NOEXEC ) + mnt_flags |=MS_NOEXEC ; +if (stat.f_flag &ST_NOATIME ) + mnt_flags |=MS_NOATIME ; +if (stat.f_flag &ST_NODIRATIME ) + mnt_flags |=MS_NODIRATIME ; +if (stat.f_flag &ST_RELATIME ) + mnt_flags |=MS_RELATIME ; +if (stat.f_flag &ST_SYNCHRONOUS ) + mnt_flags |=MS_SYNCHRONOUS ; +if (stat.f_flag &ST_MANDLOCK ) + mnt_flags |=ST_MANDLOCK ; + +return mnt_flags; +} +static void create_and_enter_userns (void ) {uid_t uid;
@@ -118,7 +162,8 @@ static void create_and_enter_userns(void) }static -bool test_unpriv_remount (int mount_flags,int remount_flags,int invalid_flags) +bool test_unpriv_remount (const char *fstype,const char *mount_options, +int mount_flags,int remount_flags,int invalid_flags) {pid_t child;
@@ -151,9 +196,11 @@ bool test_unpriv_remount(int mount_flags, int remount_flags, int invalid_flags) strerror(errno)); } -if (mount ("testing" ,"/tmp" ,"ramfs" , mount_flags,NULL ) !=0 ) { -die ("mount of /tmp failed: %s\n" , -strerror (errno)); +if (mount ("testing" ,"/tmp" , fstype, mount_flags, mount_options) !=0 ) { +die ("mount of %s with options '%s' on /tmp failed: %s\n" , + fstype, + mount_options? mount_options :"" , +strerror (errno)); }create_and_enter_userns ();
@@ -181,62 +228,127 @@ bool test_unpriv_remount(int mount_flags, int remount_flags, int invalid_flags)static bool test_unpriv_remount_simple (int mount_flags) { -return test_unpriv_remount (mount_flags, mount_flags,0 ); +return test_unpriv_remount ("ramfs" ,NULL , mount_flags, mount_flags,0 ); }static bool test_unpriv_remount_atime (int mount_flags,int invalid_flags) { -return test_unpriv_remount (mount_flags, mount_flags, invalid_flags); +return test_unpriv_remount ("ramfs" ,NULL , mount_flags, mount_flags, + invalid_flags); +} + +static bool test_priv_mount_unpriv_remount (void ) +{ +pid_t child; +int ret; +const char *orig_path ="/dev" ; +const char *dest_path ="/tmp" ; +int orig_mnt_flags, remount_mnt_flags; + + child =fork (); +if (child ==-1 ) { +die ("fork failed: %s\n" , +strerror (errno)); + } +if (child !=0 ) {/* parent */ +pid_t pid; +int status; + pid =waitpid (child, &status,0 ); +if (pid ==-1 ) { +die ("waitpid failed: %s\n" , +strerror (errno)); + } +if (pid != child) { +die ("waited for %d got %d\n" , + child, pid); + } +if (!WIFEXITED (status)) { +die ("child did not terminate cleanly\n" ); + } +return WEXITSTATUS (status) ==EXIT_SUCCESS ? true : false; + } + + orig_mnt_flags =read_mnt_flags (orig_path); + +create_and_enter_userns (); + ret =unshare (CLONE_NEWNS ); +if (ret !=0 ) { +die ("unshare(CLONE_NEWNS) failed: %s\n" , +strerror (errno)); + } + + ret =mount (orig_path, dest_path,"bind" ,MS_BIND |MS_REC ,NULL ); +if (ret !=0 ) { +die ("recursive bind mount of %s onto %s failed: %s\n" , + orig_path, dest_path,strerror (errno)); + } + + ret =mount (dest_path, dest_path,"none" , +MS_REMOUNT |MS_BIND | orig_mnt_flags ,NULL ); +if (ret !=0 ) { +/* system("cat /proc/self/mounts"); */ +die ("remount of /tmp failed: %s\n" , +strerror (errno)); + } + + remount_mnt_flags =read_mnt_flags (dest_path); +if (orig_mnt_flags != remount_mnt_flags) { +die ("Mount flags unexpectedly changed during remount of %s originally mounted on %s\n" , + dest_path, orig_path); + } +exit (EXIT_SUCCESS ); }int main (int argc,char **argv) { -if (!test_unpriv_remount_simple (MS_RDONLY |MS_NODEV )) { +if (!test_unpriv_remount_simple (MS_RDONLY )) {die ("MS_RDONLY malfunctions\n" ); } -if (!test_unpriv_remount_simple (MS_NODEV )) { +if (!test_unpriv_remount ("devpts" ,"newinstance" ,MS_NODEV ,MS_NODEV ,0 )) {die ("MS_NODEV malfunctions\n" ); } -if (!test_unpriv_remount_simple (MS_NOSUID |MS_NODEV )) { +if (!test_unpriv_remount_simple (MS_NOSUID )) {die ("MS_NOSUID malfunctions\n" ); } -if (!test_unpriv_remount_simple (MS_NOEXEC |MS_NODEV )) { +if (!test_unpriv_remount_simple (MS_NOEXEC )) {die ("MS_NOEXEC malfunctions\n" ); } -if (!test_unpriv_remount_atime (MS_RELATIME |MS_NODEV , -MS_NOATIME |MS_NODEV )) +if (!test_unpriv_remount_atime (MS_RELATIME , +MS_NOATIME )) {die ("MS_RELATIME malfunctions\n" ); } -if (!test_unpriv_remount_atime (MS_STRICTATIME |MS_NODEV , -MS_NOATIME |MS_NODEV )) +if (!test_unpriv_remount_atime (MS_STRICTATIME , +MS_NOATIME )) {die ("MS_STRICTATIME malfunctions\n" ); } -if (!test_unpriv_remount_atime (MS_NOATIME |MS_NODEV , -MS_STRICTATIME |MS_NODEV )) +if (!test_unpriv_remount_atime (MS_NOATIME , +MS_STRICTATIME )) { -die ("MS_RELATIME malfunctions\n" ); +die ("MS_NOATIME malfunctions\n" ); } -if (!test_unpriv_remount_atime (MS_RELATIME |MS_NODIRATIME |MS_NODEV , -MS_NOATIME |MS_NODEV )) +if (!test_unpriv_remount_atime (MS_RELATIME |MS_NODIRATIME , +MS_NOATIME )) { -die ("MS_RELATIME malfunctions\n" ); +die ("MS_RELATIME|MS_NODIRATIME malfunctions\n" ); } -if (!test_unpriv_remount_atime (MS_STRICTATIME |MS_NODIRATIME |MS_NODEV , -MS_NOATIME |MS_NODEV )) +if (!test_unpriv_remount_atime (MS_STRICTATIME |MS_NODIRATIME , +MS_NOATIME )) { -die ("MS_RELATIME malfunctions\n" ); +die ("MS_STRICTATIME|MS_NODIRATIME malfunctions\n" ); } -if (!test_unpriv_remount_atime (MS_NOATIME |MS_NODIRATIME |MS_NODEV , -MS_STRICTATIME |MS_NODEV )) +if (!test_unpriv_remount_atime (MS_NOATIME |MS_NODIRATIME , +MS_STRICTATIME )) { -die ("MS_RELATIME malfunctions\n" ); +die ("MS_NOATIME|MS_DIRATIME malfunctions\n" ); } -if (!test_unpriv_remount (MS_STRICTATIME |MS_NODEV ,MS_NODEV , -MS_NOATIME |MS_NODEV )) +if (!test_unpriv_remount ("ramfs" ,NULL ,MS_STRICTATIME ,0 ,MS_NOATIME )) {die ("Default atime malfunctions\n" ); } +if (!test_priv_mount_unpriv_remount ()) { +die ("Mount flags unexpectedly changed after remount\n" ); + }return EXIT_SUCCESS ; }
Signature · 1 line
1.9.1
PATCH 5/18 mnt: Move the clear of MNT_LOCKED from copy_tree to it's callers.
In reply to Eric W. BiedermanClear MNT_LOCKED in the callers of copy_tree except copy_mnt_ns, and collect_mounts. In copy_mnt_ns it is necessary to create an exact copy of a mount tree, so not clearing MNT_LOCKED is important. Similarly collect_mounts is used to take a snapshot of the mount tree for audit logging purposes and auditing using a faithful copy of the tree is important.
This becomes particularly significant when we start setting MNT_LOCKED on rootfs to prevent it from being unmounted.
--- fs/namespace.c | 1 - fs/pnode.c | 1 + 2 files changed, 1 insertion(+), 1 deletion(-)
fs/namespace.c +0 -1
@@ -1613,7 +1613,6 @@ struct mount *copy_tree(struct mount *mnt, struct dentry *dentry,if (IS_ERR (q))return q; - q->mnt.mnt_flags &= ~MNT_LOCKED ; q->mnt_mountpoint = mnt->mnt_mountpoint; p = mnt;
fs/pnode.c +1 -0
@@ -242,6 +242,7 @@ static int propagate_one(struct mount *m) child =copy_tree (last_source, last_source->mnt.mnt_root, type);if (IS_ERR (child))return PTR_ERR (child); + child->mnt.mnt_flags &= ~MNT_LOCKED ;mnt_set_mountpoint (m, mp, child); last_dest = m; last_source = child;
Signature · 1 line
1.9.1
PATCH 6/18 mnt: Carefully set CL_UNPRIVILEGED in clone_mnt
In reply to Eric W. Biedermanold->mnt_expiry should be ignored unless CL_EXPIRE is set.
--- fs/namespace.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
fs/namespace.c +2 -1
@@ -963,7 +963,8 @@ static struct mount *clone_mnt(struct mount *old, struct dentry *root, }/* Don't allow unprivileged users to reveal what is under a mount */ -if ((flag &CL_UNPRIVILEGED ) &&list_empty (&old->mnt_expire)) +if ((flag &CL_UNPRIVILEGED ) && + (!(flag &CL_EXPIRE ) ||list_empty (&old->mnt_expire))) mnt->mnt.mnt_flags |=MNT_LOCKED ;atomic_inc (&sb->s_active);
Signature · 1 line
1.9.1
PATCH 7/18 mnt: Clear mnt_expire during pivot_root
In reply to Eric W. BiedermanWhen inspecting the pivot_root and the current mount expiry logic I realized that pivot_root fails to clear like mount move does.
Add the missing line in case someone does the interesting feat of moving an expirable submount. This gives a strong guarantee that root of the filesystem tree will never expire.
--- fs/namespace.c | 2 ++ 1 file changed, 2 insertions(+)
fs/namespace.c +2 -0
@@ -2967,6 +2967,8 @@ SYSCALL_DEFINE2(pivot_root, const char __user *, new_root,/* mount new_root on / */ attach_mnt (new_mnt,real_mount (root_parent.mnt), root_mp);touch_mnt_namespace (current->nsproxy->mnt_ns); +/* A moved mount should not expire automatically */ +list_del_init (&new_mnt->mnt_expire);unlock_mount_hash ();chroot_fs_refs (&root, &new);put_mountpoint (root_mp);
Signature · 1 line
1.9.1
PATCH 8/18 groups: Consolidate the setgroups permission checks
In reply to Eric W. BiedermanToday there are 3 instances of setgroups and due to an oversight their permission checking has diverged. Add a common function so that they may all share the same permission checking code.
This corrects the current oversight in the current permission checks and adds a helper to avoid this in the future.
A user namespace security fix will update this new helper, shortly.
--- arch/s390/kernel/compat_linux.c | 2 +- include/linux/cred.h | 1 + kernel/groups.c | 9 ++++++++- kernel/uid16.c | 2 +- 4 files changed, 11 insertions(+), 3 deletions(-)
arch/s390/kernel/compat_linux.c +1 -1
@@ -249,7 +249,7 @@ COMPAT_SYSCALL_DEFINE2(s390_setgroups16, int, gidsetsize, u16 __user *, grouplisstruct group_info *group_info;int retval; -if (!capable (CAP_SETGID )) +if (!may_setgroups ())return -EPERM ;if ((unsigned )gidsetsize >NGROUPS_MAX )return -EINVAL ;
include/linux/cred.h +1 -0
@@ -68,6 +68,7 @@ extern void groups_free(struct group_info *);extern int set_current_groups (struct group_info *);extern void set_groups (struct cred *,struct group_info *);extern int groups_search (const struct group_info *,kgid_t ); +extern bool may_setgroups (void );/* access the groups "array" with this macro */ #define GROUP_AT (gi, i) \
kernel/groups.c +8 -1
@@ -213,6 +213,13 @@ out:return i; } +bool may_setgroups (void ) +{ +struct user_namespace *user_ns =current_user_ns (); + +return ns_capable (user_ns,CAP_SETGID ); +} +/* * SMP: Our groups are copy-on-write. We can set them safely * without another task interfering.
@@ -223,7 +230,7 @@ SYSCALL_DEFINE2(setgroups, int, gidsetsize, gid_t __user *, grouplist)struct group_info *group_info;int retval; -if (!ns_capable (current_user_ns (),CAP_SETGID )) +if (!may_setgroups ())return -EPERM ;if ((unsigned )gidsetsize >NGROUPS_MAX )return -EINVAL ;
kernel/uid16.c +1 -1
@@ -176,7 +176,7 @@ SYSCALL_DEFINE2(setgroups16, int, gidsetsize, old_gid_t __user *, grouplist)struct group_info *group_info;int retval; -if (!ns_capable (current_user_ns (),CAP_SETGID )) +if (!may_setgroups ())return -EPERM ;if ((unsigned )gidsetsize >NGROUPS_MAX )return -EINVAL ;
Signature · 1 line
1.9.1
PATCH 9/18 userns: Document what the invariant required for safe unprivileged mappings.
In reply to Eric W. BiedermanThe rule is simple. Don't allow anything that wouldn't be allowed without unprivileged mappings.
It was previously overlooked that establishing gid mappings would allow dropping groups and potentially gaining permission to files and directories that had lesser permissions for a specific group than for all other users.
This is the rule needed to fix CVE-2014-8989 and prevent any other security issues with new_idmap_permitted.
The reason for this rule is that the unix permission model is old and there are programs out there somewhere that take advantage of every little corner of it. So allowing a uid or gid mapping to be established without privielge that would allow anything that would not be allowed without that mapping will result in expectations from some code somewhere being violated. Violated expectations about the behavior of the OS is a long way to say a security issue.
--- kernel/user_namespace.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
kernel/user_namespace.c +3 -1
@@ -812,7 +812,9 @@ static bool new_idmap_permitted(const struct file *file, struct user_namespace *ns, int cap_setid, struct uid_gid_map *new_map) { - /* Allow mapping to your own filesystem ids */ + /* Don't allow mappings that would allow anything that wouldn't + * be allowed without the establishment of unprivileged mappings. + */ if ((new_map->nr_extents == 1) && (new_map->extent[0].count == 1)) { u32 id = new_map->extent[0 ].lower_first;if (cap_setid ==CAP_SETUID ) {
Signature · 1 line
1.9.1
PATCH 10/18 userns: Don't allow setgroups until a gid mapping has been setablished
In reply to Eric W. Biedermansetgroups is unique in not needing a valid mapping before it can be called, in the case of setgroups(0, NULL) which drops all supplemental groups.
The design of the user namespace assumes that CAP_SETGID can not actually be used until a gid mapping is established. Therefore add a helper function to see if the user namespace gid mapping has been established and call that function in the setgroups permission check.
This is part of the fix for CVE-2014-8989, being able to drop groups without privilege using user namespaces.
--- include/linux/user_namespace.h | 5 +++++ kernel/groups.c | 4 +++- kernel/user_namespace.c | 14 ++++++++++++++ 3 files changed, 22 insertions(+), 1 deletion(-)
include/linux/user_namespace.h +5 -0
@@ -63,6 +63,7 @@ extern const struct seq_operations proc_projid_seq_operations;extern ssize_t proc_uid_map_write (struct file *,const char __user *,size_t ,loff_t *);extern ssize_t proc_gid_map_write (struct file *,const char __user *,size_t ,loff_t *);extern ssize_t proc_projid_map_write (struct file *,const char __user *,size_t ,loff_t *); +extern bool userns_may_setgroups (const struct user_namespace *ns);#else static inline struct user_namespace *get_user_ns (struct user_namespace *ns)
@@ -87,6 +88,10 @@ static inline void put_user_ns(struct user_namespace *ns) { } +static inline bool userns_may_setgroups (const struct user_namespace *ns) +{ +return true; +}#endif #endif /* _LINUX_USER_H */
kernel/groups.c +3 -1
@@ -6,6 +6,7 @@#include <linux/slab.h> #include <linux/security.h> #include <linux/syscalls.h> +#include <linux/user_namespace.h> #include <asm/uaccess.h> /* init to 2 - one for init_task, one to ensure it is never freed */
@@ -217,7 +218,8 @@ bool may_setgroups(void) {struct user_namespace *user_ns =current_user_ns (); -return ns_capable (user_ns,CAP_SETGID ); +return ns_capable (user_ns,CAP_SETGID ) && +userns_may_setgroups (user_ns); }/*
kernel/user_namespace.c +14 -0
@@ -843,6 +843,20 @@ static bool new_idmap_permitted(const struct file *file,return false; } +bool userns_may_setgroups (const struct user_namespace *ns) +{ +bool allowed; + +mutex_lock (&id_map_mutex); +/* It is not safe to use setgroups until a gid mapping in +* the user namespace has been established. +*/ + allowed = ns->gid_map.nr_extents !=0 ; +mutex_unlock (&id_map_mutex); + +return allowed; +} +static void *userns_get (struct task_struct *task) {struct user_namespace *user_ns;
Signature · 1 line
1.9.1
PATCH 12/18 userns: Check euid no fsuid when establishing an unprivileged uid mapping
In reply to Eric W. Biedermansetresuid allows the euid to be set to any of uid, euid, suid, and fsuid. Therefor it is safe to allow an unprivileged user to map their euid and use CAP_SETUID privileged with exactly that uid, as no new credentials can be obtained.
I can not find a combination of existing system calls that allows setting uid, euid, suid, and fsuid from the fsuid making the previous use of fsuid for allowing unprivileged mappings a bug.
This is part of a fix for CVE-2014-8989.
--- kernel/user_namespace.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/user_namespace.c +1 -1
@@ -819,7 +819,7 @@ static bool new_idmap_permitted(const struct file *file,u32 id = new_map->extent[0 ].lower_first;if (cap_setid ==CAP_SETUID ) {kuid_t uid =make_kuid (ns->parent, id); -if (uid_eq (uid, file->f_cred->fsuid)) +if (uid_eq (uid, file->f_cred->euid))return true; } }
Signature · 1 line
1.9.1
PATCH 14/18 userns: Rename id_map_mutex to userns_state_mutex
In reply to Eric W. BiedermanGeneralize id_map_mutex so it can be used for more state of a user namespace.
--- kernel/user_namespace.c | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-)
kernel/user_namespace.c +6 -8
@@ -24,6 +24,7 @@#include <linux/fs_struct.h> static struct kmem_cache *user_ns_cachep__read_mostly ; +static DEFINE_MUTEX (userns_state_mutex); static bool new_idmap_permitted(const struct file *file, struct user_namespace *ns, int cap_setid,
@@ -583,9 +584,6 @@ static bool mappings_overlap(struct uid_gid_map *new_map,return false; } - -static DEFINE_MUTEX (id_map_mutex); - static ssize_t map_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos, int cap_setid,
@@ -602,7 +600,7 @@ static ssize_t map_write(struct file *file, const char __user *buf,ssize_t ret = -EINVAL ;/* -* The id_map_mutex serializes all writes to any given map. +* The userns_state_mutex serializes all writes to any given map. * * Any map is only ever written once. *
@@ -620,7 +618,7 @@ static ssize_t map_write(struct file *file, const char __user *buf,* order and smp_rmb() is guaranteed that we don't have crazy * architectures returning stale data. */ -mutex_lock (&id_map_mutex); +mutex_lock (&userns_state_mutex); ret = -EPERM ;/* Only allow one successful write to the map */
@@ -750,7 +748,7 @@ static ssize_t map_write(struct file *file, const char __user *buf, *ppos = count; ret = count; out: -mutex_unlock (&id_map_mutex); +mutex_unlock (&userns_state_mutex);if (page)free_page (page);return ret;
@@ -845,12 +843,12 @@ bool userns_may_setgroups(const struct user_namespace *ns) {bool allowed; -mutex_lock (&id_map_mutex); +mutex_lock (&userns_state_mutex);/* It is not safe to use setgroups until a gid mapping in * the user namespace has been established. */ allowed = ns->gid_map.nr_extents !=0 ; -mutex_unlock (&id_map_mutex); +mutex_unlock (&userns_state_mutex);return allowed; }
Signature · 1 line
1.9.1
PATCH 15/18 userns: Add a knob to disable setgroups on a per user namespace basis
In reply to Eric W. Biederman- Expose the knob to user space through a proc file /proc/<pid>/setgroups
A value of "deny" means the setgroups system call is disabled in the current processes user namespace and can not be enabled in the future in this user namespace.
A value of "allow" means the segtoups system call is enabled.
- Descendant user namespaces inherit the value of setgroups from their parents.
- A proc file is used (instead of a sysctl) as sysctls currently do not allow checking the permissions at open time.
- Writing to the proc file is restricted to before the gid_map for the user namespace is set.
This ensures that disabling setgroups at a user namespace level will never remove the ability to call setgroups from a process that already has that ability.
A process may opt in to the setgroups disable for itself by creating, entering and configuring a user namespace or by calling setns on an existing user namespace with setgroups disabled. Processes without privileges already can not call setgroups so this is a noop. Prodcess with privilege become processes without privilege when entering a user namespace and as with any other path to dropping privilege they would not have the ability to call setgroups. So this remains within the bounds of what is possible without a knob to disable setgroups permanently in a user namespace.
--- fs/proc/base.c | 53 ++++++++++++++++++++++++++ include/linux/user_namespace.h | 7 ++++ kernel/user.c | 1 + kernel/user_namespace.c | 85 ++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 146 insertions(+)
fs/proc/base.c +53 -0
@@ -2464,6 +2464,57 @@ static const struct file_operations proc_projid_map_operations = { .llseek = seq_lseek, .release = proc_id_map_release, }; + +static int proc_setgroups_open (struct inode *inode,struct file *file) +{ +struct user_namespace *ns =NULL ; +struct task_struct *task; +int ret; + + ret = -ESRCH ; + task =get_proc_task (inode); +if (task) { +rcu_read_lock (); + ns =get_user_ns (task_cred_xxx (task, user_ns)); +rcu_read_unlock (); +put_task_struct (task); + } +if (!ns) + goto err; + +if (file->f_mode &FMODE_WRITE ) { + ret = -EACCES ; +if (!ns_capable (ns,CAP_SYS_ADMIN )) + goto err_put_ns; + } + + ret =single_open (file, &proc_setgroups_show, ns); +if (ret) + goto err_put_ns; + +return 0 ; +err_put_ns: +put_user_ns (ns); +err: +return ret; +} + +static int proc_setgroups_release (struct inode *inode,struct file *file) +{ +struct seq_file *seq = file->private_data; +struct user_namespace *ns = seq->private; +int ret =single_release (inode, file); +put_user_ns (ns); +return ret; +} + +static const struct file_operations proc_setgroups_operations = { + .open = proc_setgroups_open, + .write = proc_setgroups_write, + .read = seq_read, + .llseek = seq_lseek, + .release = proc_setgroups_release, +};#endif /* CONFIG_USER_NS */ static int proc_pid_personality(struct seq_file *m, struct pid_namespace *ns,
@@ -2572,6 +2623,7 @@ static const struct pid_entry tgid_base_stuff[] = {REG ("uid_map" ,S_IRUGO |S_IWUSR , proc_uid_map_operations),REG ("gid_map" ,S_IRUGO |S_IWUSR , proc_gid_map_operations),REG ("projid_map" ,S_IRUGO |S_IWUSR , proc_projid_map_operations), +REG ("setgroups" ,S_IRUGO |S_IWUSR , proc_setgroups_operations), #endif #ifdef CONFIG_CHECKPOINT_RESTORE REG("timers", S_IRUGO, proc_timers_operations),
@@ -2913,6 +2965,7 @@ static const struct pid_entry tid_base_stuff[] = {REG ("uid_map" ,S_IRUGO |S_IWUSR , proc_uid_map_operations),REG ("gid_map" ,S_IRUGO |S_IWUSR , proc_gid_map_operations),REG ("projid_map" ,S_IRUGO |S_IWUSR , proc_projid_map_operations), + REG("setgroups", S_IRUGO|S_IWUSR, proc_setgroups_operations), #endif };
include/linux/user_namespace.h +7 -0
@@ -17,6 +17,10 @@ struct uid_gid_map { /* 64 bytes -- 1 cache line */ } extent[UID_GID_MAP_MAX_EXTENTS ]; }; +#define USERNS_SETGROUPS_ALLOWED 1UL + +#define USERNS_INIT_FLAGS USERNS_SETGROUPS_ALLOWED +struct user_namespace {struct uid_gid_map uid_map;struct uid_gid_map gid_map;
@@ -27,6 +31,7 @@ struct user_namespace {kuid_t owner;kgid_t group;unsigned int proc_inum; +unsigned long flags;/* Register of per-UID persistent keyrings for this namespace */ #ifdef CONFIG_PERSISTENT_KEYRINGS
@@ -63,6 +68,8 @@ extern const struct seq_operations proc_projid_seq_operations;extern ssize_t proc_uid_map_write (struct file *,const char __user *,size_t ,loff_t *);extern ssize_t proc_gid_map_write (struct file *,const char __user *,size_t ,loff_t *);extern ssize_t proc_projid_map_write (struct file *,const char __user *,size_t ,loff_t *); +extern ssize_t proc_setgroups_write (struct file *,const char __user *,size_t ,loff_t *); +extern int proc_setgroups_show (struct seq_file *m,void *v);extern bool userns_may_setgroups (const struct user_namespace *ns);#else
kernel/user.c +1 -0
@@ -51,6 +51,7 @@ struct user_namespace init_user_ns = { .owner = GLOBAL_ROOT_UID, .group = GLOBAL_ROOT_GID, .proc_inum = PROC_USER_INIT_INO, + .flags =USERNS_INIT_FLAGS , #ifdef CONFIG_PERSISTENT_KEYRINGS .persistent_keyring_register_sem = __RWSEM_INITIALIZER(init_user_ns.persistent_keyring_register_sem),
kernel/user_namespace.c +85 -0
103 lines not on this page · raw message
Signature · 1 line
1.9.1
PATCH 16/18 userns: Allow setting gid_maps without privilege when setgroups is disabled
In reply to Eric W. BiedermanNow that setgroups can be disabled and not reenabled, setting gid_map without privielge can now be enabled when setgroups is disabled.
This restores most of the functionality that was lost when unprivileged setting of gid_map was removed. Applications that use this functionality will need to check to see if they use setgroups or init_groups, and if they don't they can be fixed by simply disabling setgroups before writing to gid_map.
--- kernel/user_namespace.c | 5 +++++ 1 file changed, 5 insertions(+)
kernel/user_namespace.c +5 -0
@@ -826,6 +826,11 @@ static bool new_idmap_permitted(const struct file *file,kuid_t uid =make_kuid (ns->parent, id);if (uid_eq (uid, cred->euid))return true; + }else if (cap_setid ==CAP_SETGID ) { +kgid_t gid =make_kgid (ns->parent, id); +if (!(ns->flags &USERNS_SETGROUPS_ALLOWED ) && +gid_eq (gid, cred->egid)) +return true; } }
Signature · 1 line
1.9.1
PATCH 17/18 userns; Correct the comment in map_write
In reply to Eric W. BiedermanIt is important that all maps are less than PAGE_SIZE or else setting the last byte of the buffer to '0' could write off the end of the allocated storage.
Correct the misleading comment.
--- kernel/user_namespace.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/user_namespace.c +1 -1
@@ -643,7 +643,7 @@ static ssize_t map_write(struct file *file, const char __user *buf,if (!page) goto out; -/* Only allow <= page size writes at the beginning of the file */ +/* Only allow < page size writes at the beginning of the file */ ret = -EINVAL ;if ((*ppos !=0 ) || (count >=PAGE_SIZE )) goto out;
Signature · 1 line
1.9.1
PATCH 18/18 userns: Unbreak the unprivileged remount tests
In reply to Eric W. BiedermanA security fix in caused the way the unprivileged remount tests were using user namespaces to break. Tweak the way user namespaces are being used so the test works again.
--- .../selftests/mount/unprivileged-remount-test.c | 32 ++++++++++++++++------ 1 file changed, 24 insertions(+), 8 deletions(-)
tools/testing/selftests/mount/unprivileged-remount-test.c +24 -8
@@ -53,17 +53,14 @@ static void die(char *fmt, ...)exit (EXIT_FAILURE ); } -static void write_file (char *filename,char *fmt, ...) +static void vmaybe_write_file (bool enoent_ok,char *filename,char *fmt,va_list ap) {char buf[4096 ];int fd;ssize_t written;int buf_len; -va_list ap; -va_start (ap, fmt); buf_len =vsnprintf (buf,sizeof (buf), fmt, ap); -va_end (ap);if (buf_len <0 ) {die ("vsnprintf failed: %s\n" ,strerror (errno));
@@ -74,6 +71,8 @@ static void write_file(char *filename, char *fmt, ...) fd =open (filename,O_WRONLY );if (fd <0 ) { +if ((errno ==ENOENT ) && enoent_ok) +return ;die ("open of %s failed: %s\n" , filename,strerror (errno)); }
@@ -92,6 +91,26 @@ static void write_file(char *filename, char *fmt, ...) } } +static void maybe_write_file (char *filename,char *fmt, ...) +{ +va_list ap; + +va_start (ap, fmt); +vmaybe_write_file (true, filename, fmt, ap); +va_end (ap); + +} + +static void write_file (char *filename,char *fmt, ...) +{ +va_list ap; + +va_start (ap, fmt); +vmaybe_write_file (false, filename, fmt, ap); +va_end (ap); + +} +static int read_mnt_flags (const char *path) {int ret;
@@ -144,13 +163,10 @@ static void create_and_enter_userns(void) strerror(errno)); } +maybe_write_file ("/proc/self/setgroups" ,"deny" );write_file ("/proc/self/uid_map" ,"0 %d 1" , uid);write_file ("/proc/self/gid_map" ,"0 %d 1" , gid); -if (setgroups (0 ,NULL ) !=0 ) { -die ("setgroups failed: %s\n" , -strerror (errno)); - }if (setgid (0 ) !=0 ) {die ("setgid(0) failed %s\n" ,strerror (errno));
Signature · 1 line
1.9.1