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 <asarai@suse.de>
+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 <christian.brauner@ubuntu.com>
+Signed-off-by: Aleksa Sarai <asarai@suse.de>
+Signed-off-by: Mrunal Patel <mrunalp@gmail.com>
+---
+ 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 <unistd.h>
++#include <stdio.h>
++#include <stdlib.h>
++#include <stdbool.h>
++#include <string.h>
++#include <limits.h>
++#include <fcntl.h>
++#include <errno.h>
++
++#include <sys/types.h>
++#include <sys/stat.h>
++#include <sys/vfs.h>
++#include <sys/mman.h>
++#include <sys/sendfile.h>
++#include <sys/syscall.h>
++
++#include <linux/magic.h>
++#include <linux/memfd.h>
++
++/* 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 <linux/fcntl.h>. */
++#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 <gscrivan@redhat.com>
+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 <gscrivan@redhat.com>
+---
+ 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 <lsm5@redhat.com> - 1.0.0-55.rc5.dev.git2abd837
+- Resolves: CVE-2019-5736
+
* Tue Dec 18 2018 Frantisek Kluknavsky <fkluknav@redhat.com> - 1.0.0-54.rc5.dev.git2abd837
- re-enable debuginfo