diff --git a/SOURCES/0001-nsenter-clone-proc-self-exe-to-avoid-exposing-host-b-runc.patch b/SOURCES/0001-nsenter-clone-proc-self-exe-to-avoid-exposing-host-b-runc.patch new file mode 100644 index 0000000..7975703 --- /dev/null +++ b/SOURCES/0001-nsenter-clone-proc-self-exe-to-avoid-exposing-host-b-runc.patch @@ -0,0 +1,290 @@ +From bf6405284aa3870a39b402309003633a1c230ed9 Mon Sep 17 00:00:00 2001 +From: Aleksa Sarai +Date: Wed, 9 Jan 2019 13:40:01 +1100 +Subject: [PATCH 1/1] nsenter: clone /proc/self/exe to avoid exposing host + binary to container + +There are quite a few circumstances where /proc/self/exe pointing to a +pretty important container binary is a _bad_ thing, so to avoid this we +have to make a copy (preferably doing self-clean-up and not being +writeable). + +As a hotfix we require memfd_create(2), but we can always extend this to +use a scratch MNT_DETACH overlayfs or tmpfs. The main downside to this +approach is no page-cache sharing for the runc binary (which overlayfs +would give us) but this is far less complicated. + +This is only done during nsenter so that it happens transparently to the +Go code, and any libcontainer users benefit from it. This also makes +ExtraFiles and --preserve-fds handling trivial (because we don't need to +worry about it). + +Fixes: CVE-2019-5736 +Co-developed-by: Christian Brauner +Signed-off-by: Aleksa Sarai +Signed-off-by: Mrunal Patel +--- + libcontainer/nsenter/cloned_binary.c | 221 +++++++++++++++++++++++++++ + libcontainer/nsenter/nsexec.c | 11 ++ + 2 files changed, 232 insertions(+) + create mode 100644 libcontainer/nsenter/cloned_binary.c + +diff --git a/libcontainer/nsenter/cloned_binary.c b/libcontainer/nsenter/cloned_binary.c +new file mode 100644 +index 00000000..d9f6093a +--- /dev/null ++++ b/libcontainer/nsenter/cloned_binary.c +@@ -0,0 +1,221 @@ ++#define _GNU_SOURCE ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include ++#include ++ ++/* Use our own wrapper for memfd_create. */ ++#if !defined(SYS_memfd_create) && defined(__NR_memfd_create) ++# define SYS_memfd_create __NR_memfd_create ++#endif ++#ifndef SYS_memfd_create ++# error "memfd_create(2) syscall not supported by this glibc version" ++#endif ++int memfd_create(const char *name, unsigned int flags) ++{ ++ return syscall(SYS_memfd_create, name, flags); ++} ++ ++/* This comes directly from . */ ++#ifndef F_LINUX_SPECIFIC_BASE ++# define F_LINUX_SPECIFIC_BASE 1024 ++#endif ++#ifndef F_ADD_SEALS ++# define F_ADD_SEALS (F_LINUX_SPECIFIC_BASE + 9) ++# define F_GET_SEALS (F_LINUX_SPECIFIC_BASE + 10) ++#endif ++#ifndef F_SEAL_SEAL ++# define F_SEAL_SEAL 0x0001 /* prevent further seals from being set */ ++# define F_SEAL_SHRINK 0x0002 /* prevent file from shrinking */ ++# define F_SEAL_GROW 0x0004 /* prevent file from growing */ ++# define F_SEAL_WRITE 0x0008 /* prevent writes */ ++#endif ++ ++ ++#define OUR_MEMFD_COMMENT "runc_cloned:/proc/self/exe" ++#define OUR_MEMFD_SEALS \ ++ (F_SEAL_SEAL | F_SEAL_SHRINK | F_SEAL_GROW | F_SEAL_WRITE) ++ ++static void *must_realloc(void *ptr, size_t size) ++{ ++ void *old = ptr; ++ do { ++ ptr = realloc(old, size); ++ } while(!ptr); ++ return ptr; ++} ++ ++/* ++ * Verify whether we are currently in a self-cloned program (namely, is ++ * /proc/self/exe a memfd). F_GET_SEALS will only succeed for memfds (or rather ++ * for shmem files), and we want to be sure it's actually sealed. ++ */ ++static int is_self_cloned(void) ++{ ++ int fd, seals; ++ ++ fd = open("/proc/self/exe", O_RDONLY|O_CLOEXEC); ++ if (fd < 0) ++ return -ENOTRECOVERABLE; ++ ++ seals = fcntl(fd, F_GET_SEALS); ++ close(fd); ++ return seals == OUR_MEMFD_SEALS; ++} ++ ++/* ++ * Basic wrapper around mmap(2) that gives you the file length so you can ++ * safely treat it as an ordinary buffer. Only gives you read access. ++ */ ++static char *read_file(char *path, size_t *length) ++{ ++ int fd; ++ char buf[4096], *copy = NULL; ++ ++ if (!length) ++ return NULL; ++ ++ fd = open(path, O_RDONLY | O_CLOEXEC); ++ if (fd < 0) ++ return NULL; ++ ++ *length = 0; ++ for (;;) { ++ int n; ++ ++ n = read(fd, buf, sizeof(buf)); ++ if (n < 0) ++ goto error; ++ if (!n) ++ break; ++ ++ copy = must_realloc(copy, (*length + n) * sizeof(*copy)); ++ memcpy(copy + *length, buf, n); ++ *length += n; ++ } ++ close(fd); ++ return copy; ++ ++error: ++ close(fd); ++ free(copy); ++ return NULL; ++} ++ ++/* ++ * A poor-man's version of "xargs -0". Basically parses a given block of ++ * NUL-delimited data, within the given length and adds a pointer to each entry ++ * to the array of pointers. ++ */ ++static int parse_xargs(char *data, int data_length, char ***output) ++{ ++ int num = 0; ++ char *cur = data; ++ ++ if (!data || *output != NULL) ++ return -1; ++ ++ while (cur < data + data_length) { ++ num++; ++ *output = must_realloc(*output, (num + 1) * sizeof(**output)); ++ (*output)[num - 1] = cur; ++ cur += strlen(cur) + 1; ++ } ++ (*output)[num] = NULL; ++ return num; ++} ++ ++/* ++ * "Parse" out argv and envp from /proc/self/cmdline and /proc/self/environ. ++ * This is necessary because we are running in a context where we don't have a ++ * main() that we can just get the arguments from. ++ */ ++static int fetchve(char ***argv, char ***envp) ++{ ++ char *cmdline = NULL, *environ = NULL; ++ size_t cmdline_size, environ_size; ++ ++ cmdline = read_file("/proc/self/cmdline", &cmdline_size); ++ if (!cmdline) ++ goto error; ++ environ = read_file("/proc/self/environ", &environ_size); ++ if (!environ) ++ goto error; ++ ++ if (parse_xargs(cmdline, cmdline_size, argv) <= 0) ++ goto error; ++ if (parse_xargs(environ, environ_size, envp) <= 0) ++ goto error; ++ ++ return 0; ++ ++error: ++ free(environ); ++ free(cmdline); ++ return -EINVAL; ++} ++ ++#define SENDFILE_MAX 0x7FFFF000 /* sendfile(2) is limited to 2GB. */ ++static int clone_binary(void) ++{ ++ int binfd, memfd, err; ++ ssize_t sent = 0; ++ ++ memfd = memfd_create(OUR_MEMFD_COMMENT, MFD_CLOEXEC | MFD_ALLOW_SEALING); ++ if (memfd < 0) ++ return -ENOTRECOVERABLE; ++ ++ binfd = open("/proc/self/exe", O_RDONLY | O_CLOEXEC); ++ if (binfd < 0) ++ goto error; ++ ++ sent = sendfile(memfd, binfd, NULL, SENDFILE_MAX); ++ close(binfd); ++ if (sent < 0) ++ goto error; ++ ++ err = fcntl(memfd, F_ADD_SEALS, OUR_MEMFD_SEALS); ++ if (err < 0) ++ goto error; ++ ++ return memfd; ++ ++error: ++ close(memfd); ++ return -EIO; ++} ++ ++int ensure_cloned_binary(void) ++{ ++ int execfd; ++ char **argv = NULL, **envp = NULL; ++ ++ /* Check that we're not self-cloned, and if we are then bail. */ ++ int cloned = is_self_cloned(); ++ if (cloned > 0 || cloned == -ENOTRECOVERABLE) ++ return cloned; ++ ++ if (fetchve(&argv, &envp) < 0) ++ return -EINVAL; ++ ++ execfd = clone_binary(); ++ if (execfd < 0) ++ return -EIO; ++ ++ fexecve(execfd, argv, envp); ++ return -ENOEXEC; ++} +diff --git a/libcontainer/nsenter/nsexec.c b/libcontainer/nsenter/nsexec.c +index cb224314..784fd9b0 100644 +--- a/libcontainer/nsenter/nsexec.c ++++ b/libcontainer/nsenter/nsexec.c +@@ -528,6 +528,9 @@ void join_namespaces(char *nslist) + free(namespaces); + } + ++/* Defined in cloned_binary.c. */ ++int ensure_cloned_binary(void); ++ + void nsexec(void) + { + int pipenum; +@@ -543,6 +546,14 @@ void nsexec(void) + if (pipenum == -1) + return; + ++ /* ++ * We need to re-exec if we are not in a cloned binary. This is necessary ++ * to ensure that containers won't be able to access the host binary ++ * through /proc/self/exe. See CVE-2019-5736. ++ */ ++ if (ensure_cloned_binary() < 0) ++ bail("could not ensure we are a cloned binary"); ++ + /* Parse all of the netlink configuration. */ + nl_parse(pipenum, &config); + +-- +2.20.1 + diff --git a/SOURCES/pivot-root.patch b/SOURCES/pivot-root.patch new file mode 100644 index 0000000..16679df --- /dev/null +++ b/SOURCES/pivot-root.patch @@ -0,0 +1,72 @@ +From 28a697cce3e4f905dca700eda81d681a30eef9cd Mon Sep 17 00:00:00 2001 +From: Giuseppe Scrivano +Date: Fri, 11 Jan 2019 21:53:45 +0100 +Subject: [PATCH] rootfs: umount all procfs and sysfs with --no-pivot + +When creating a new user namespace, the kernel doesn't allow to mount +a new procfs or sysfs file system if there is not already one instance +fully visible in the current mount namespace. + +When using --no-pivot we were effectively inhibiting this protection +from the kernel, as /proc and /sys from the host are still present in +the container mount namespace. + +A container without full access to /proc could then create a new user +namespace, and from there able to mount a fully visible /proc, bypassing +the limitations in the container. + +A simple reproducer for this issue is: + +unshare -mrfp sh -c "mount -t proc none /proc && echo c > /proc/sysrq-trigger" + +Signed-off-by: Giuseppe Scrivano +--- + libcontainer/rootfs_linux.go | 35 +++++++++++++++++++++++++++++++++++ + 1 file changed, 35 insertions(+) + +diff --git a/libcontainer/rootfs_linux.go b/libcontainer/rootfs_linux.go +index e7c2f8ada..6bd6da74a 100644 +--- a/libcontainer/rootfs_linux.go ++++ b/libcontainer/rootfs_linux.go +@@ -748,6 +748,41 @@ func pivotRoot(rootfs string) error { + } + + func msMoveRoot(rootfs string) error { ++ mountinfos, err := mount.GetMounts() ++ if err != nil { ++ return err ++ } ++ ++ absRootfs, err := filepath.Abs(rootfs) ++ if err != nil { ++ return err ++ } ++ ++ for _, info := range mountinfos { ++ p, err := filepath.Abs(info.Mountpoint) ++ if err != nil { ++ return err ++ } ++ // Umount every syfs and proc file systems, except those under the container rootfs ++ if (info.Fstype != "proc" && info.Fstype != "sysfs") || filepath.HasPrefix(p, absRootfs) { ++ continue ++ } ++ // Be sure umount events are not propagated to the host. ++ if err := unix.Mount("", p, "", unix.MS_SLAVE|unix.MS_REC, ""); err != nil { ++ return err ++ } ++ if err := unix.Unmount(p, unix.MNT_DETACH); err != nil { ++ if err != unix.EINVAL && err != unix.EPERM { ++ return err ++ } else { ++ // If we have not privileges for umounting (e.g. rootless), then ++ // cover the path. ++ if err := unix.Mount("tmpfs", p, "tmpfs", 0, ""); err != nil { ++ return err ++ } ++ } ++ } ++ } + if err := unix.Mount(rootfs, "/", "", unix.MS_MOVE, ""); err != nil { + return err + } diff --git a/SPECS/runc.spec b/SPECS/runc.spec index 8245972..e191f47 100644 --- a/SPECS/runc.spec +++ b/SPECS/runc.spec @@ -27,7 +27,7 @@ go build -buildmode pie -compiler gc -tags="rpm_crashtraceback no_openssl ${BUIL Name: %{repo} Version: 1.0.0 -Release: 54.rc5.dev.git%{shortcommit0}%{?dist} +Release: 55.rc5.dev.git%{shortcommit0}%{?dist} Summary: CLI for running Open Containers ExcludeArch: %{ix86} License: ASL 2.0 @@ -37,6 +37,8 @@ Source1: 99-containers.conf Patch0: change-default-root.patch Patch1: 0001-Revert-Apply-cgroups-earlier.patch Patch2: 1807.patch +Patch3: 0001-nsenter-clone-proc-self-exe-to-avoid-exposing-host-b-runc.patch +Patch4: pivot-root.patch Requires: criu Requires(pre): container-selinux >= 2:2.2-2 @@ -95,6 +97,9 @@ install -p -m 0644 contrib/completions/bash/%{name} %{buildroot}%{_datadir}/bash %{_datadir}/bash-completion/completions/%{name} %changelog +* Tue Feb 12 2019 Lokesh Mandvekar - 1.0.0-55.rc5.dev.git2abd837 +- Resolves: CVE-2019-5736 + * Tue Dec 18 2018 Frantisek Kluknavsky - 1.0.0-54.rc5.dev.git2abd837 - re-enable debuginfo