Merge pull request #5 from steved/release-v17.06.2

 add support for non-memfd_create support

Author: ibuildthecloud

libcontainer/nsenter/cloned_binary.c

@@ -1,3 +1,20 @@
+/*
+ * Copyright (C) 2019 Aleksa Sarai <cyphar@cyphar.com>
+ * Copyright (C) 2019 SUSE LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 #define _GNU_SOURCE
 #include <unistd.h>
 #include <stdio.h>
@@ -6,6 +23,7 @@
 #include <string.h>
 #include <limits.h>
 #include <fcntl.h>
+#include <errno.h>
 
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -14,57 +32,80 @@
 #include <sys/sendfile.h>
 #include <sys/syscall.h>
 
-#include <linux/magic.h>
-#include <linux/memfd.h>
-
-#define MEMFD_COMMENT "runc_cloned:/proc/self/exe"
-#define MEMFD_LNKNAME "/memfd:" MEMFD_COMMENT " (deleted)"
-
 /* Use our own wrapper for memfd_create. */
+#ifndef DISABLE_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
+#ifdef SYS_memfd_create
+#  define HAVE_MEMFD_CREATE
+/* memfd_create(2) flags -- copied from <linux/memfd.h>. */
+#  ifndef MFD_CLOEXEC
+#    define MFD_CLOEXEC       0x0001U
+#    define MFD_ALLOW_SEALING 0x0002U
+#  endif
 int memfd_create(const char *name, unsigned int flags)
 {
 	return syscall(SYS_memfd_create, name, flags);
 }
+#endif
+#endif
 
 /* This comes directly from <linux/fcntl.h>. */
 #ifndef F_LINUX_SPECIFIC_BASE
-# define F_LINUX_SPECIFIC_BASE 1024
+#  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)
+#  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 */
+#  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 RUNC_SENDFILE_MAX 0x7FFFF000 /* sendfile(2) is limited to 2GB. */
+#ifdef HAVE_MEMFD_CREATE
+#  define RUNC_MEMFD_COMMENT "runc_cloned:/proc/self/exe"
+#  define RUNC_MEMFD_SEALS \
+	(F_SEAL_SEAL | F_SEAL_SHRINK | F_SEAL_GROW | F_SEAL_WRITE)
+#endif
+
+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. It's not really
- * possible to trivially identify a memfd compared to a regular tmpfs file, so
- * the best we can do is to check whether the readlink(2) looks okay and that
- * it is on a tmpfs.
+ * 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)
 {
-	struct statfs statfsbuf = {0};
-	char linkname[PATH_MAX + 1] = {0};
+	int fd, ret, is_cloned = 0;
 
-	if (statfs("/proc/self/exe", &statfsbuf) < 0)
-		return -1;
-	if (readlink("/proc/self/exe", linkname, PATH_MAX) < 0)
-		return -1;
+	fd = open("/proc/self/exe", O_RDONLY|O_CLOEXEC);
+	if (fd < 0)
+		return -ENOTRECOVERABLE;
 
-	return statfsbuf.f_type == TMPFS_MAGIC &&
-		!strncmp(linkname, MEMFD_LNKNAME, PATH_MAX);
+#ifdef HAVE_MEMFD_CREATE
+	ret = fcntl(fd, F_GET_SEALS);
+	is_cloned = (ret == RUNC_MEMFD_SEALS);
+#else
+	struct stat statbuf = {0};
+	ret = fstat(fd, &statbuf);
+	if (ret >= 0)
+		is_cloned = (statbuf.st_nlink == 0);
+#endif
+	close(fd);
+	return is_cloned;
 }
 
 /*
@@ -77,38 +118,32 @@ static char *read_file(char *path, size_t *length)
 	char buf[4096], *copy = NULL;
 
 	if (!length)
-		goto err;
-	*length = 0;
+		return NULL;
 
-	fd = open(path, O_RDONLY|O_CLOEXEC);
+	fd = open(path, O_RDONLY | O_CLOEXEC);
 	if (fd < 0)
-		goto err_free;
+		return NULL;
 
+	*length = 0;
 	for (;;) {
 		int n;
-		char *old = copy;
 
 		n = read(fd, buf, sizeof(buf));
 		if (n < 0)
-			goto err_fd;
+			goto error;
 		if (!n)
 			break;
 
-		do {
-			copy = realloc(old, (*length + n) * sizeof(*old));
-		} while(!copy);
-
+		copy = must_realloc(copy, (*length + n) * sizeof(*copy));
 		memcpy(copy + *length, buf, n);
 		*length += n;
 	}
 	close(fd);
 	return copy;
 
-err_fd:
+error:
 	close(fd);
-err_free:
 	free(copy);
-err:
 	return NULL;
 }
 
@@ -122,21 +157,12 @@ static int parse_xargs(char *data, int data_length, char ***output)
 	int num = 0;
 	char *cur = data;
 
-	if (!data || *output)
+	if (!data || *output != NULL)
 		return -1;
 
-	do {
-		*output = malloc(sizeof(**output));
-	} while (!*output);
-
 	while (cur < data + data_length) {
-		char **old = *output;
-
 		num++;
-		do {
-			*output = realloc(old, (num + 1) * sizeof(*old));
-		} while (!*output);
-
+		*output = must_realloc(*output, (num + 1) * sizeof(**output));
 		(*output)[num - 1] = cur;
 		cur += strlen(cur) + 1;
 	}
@@ -151,67 +177,75 @@ static int parse_xargs(char *data, int data_length, char ***output)
  */
 static int fetchve(char ***argv, char ***envp)
 {
-	char *cmdline, *environ;
+	char *cmdline = NULL, *environ = NULL;
 	size_t cmdline_size, environ_size;
 
 	cmdline = read_file("/proc/self/cmdline", &cmdline_size);
 	if (!cmdline)
-		goto err;
+		goto error;
 	environ = read_file("/proc/self/environ", &environ_size);
 	if (!environ)
-		goto err_free;
+		goto error;
 
 	if (parse_xargs(cmdline, cmdline_size, argv) <= 0)
-		goto err_free_both;
+		goto error;
 	if (parse_xargs(environ, environ_size, envp) <= 0)
-		goto err_free_both;
+		goto error;
 
 	return 0;
 
-err_free_both:
+error:
 	free(environ);
-err_free:
 	free(cmdline);
-err:
-	return -1;
+	return -EINVAL;
 }
 
 static int clone_binary(void)
 {
-	int binfd, memfd, err;
+	int binfd, memfd;
 	ssize_t sent = 0;
-	struct stat statbuf = {0};
-
-	binfd = open("/proc/self/exe", O_RDONLY|O_CLOEXEC);
-	if (binfd < 0)
-		goto err;
-	if (fstat(binfd, &statbuf) < 0)
-		goto err_binfd;
 
-	memfd = memfd_create(MEMFD_COMMENT, MFD_CLOEXEC|MFD_ALLOW_SEALING);
+#ifdef HAVE_MEMFD_CREATE
+	memfd = memfd_create(RUNC_MEMFD_COMMENT, MFD_CLOEXEC | MFD_ALLOW_SEALING);
+#else
+	memfd = open("/tmp", O_TMPFILE | O_EXCL | O_RDWR | O_CLOEXEC, 0711);
+#endif
 	if (memfd < 0)
-		goto err_binfd;
+		return -ENOTRECOVERABLE;
 
-	while (sent < statbuf.st_size) {
-		ssize_t n = sendfile(memfd, binfd, NULL, statbuf.st_size - sent);
-		if (n < 0)
-			goto err_memfd;
-		sent += n;
-	}
+	binfd = open("/proc/self/exe", O_RDONLY | O_CLOEXEC);
+	if (binfd < 0)
+		goto error;
 
-	err = fcntl(memfd, F_ADD_SEALS, F_SEAL_SHRINK|F_SEAL_GROW|F_SEAL_WRITE|F_SEAL_SEAL);
+	sent = sendfile(memfd, binfd, NULL, RUNC_SENDFILE_MAX);
+	close(binfd);
+	if (sent < 0)
+		goto error;
+
+#ifdef HAVE_MEMFD_CREATE
+	int err = fcntl(memfd, F_ADD_SEALS, RUNC_MEMFD_SEALS);
 	if (err < 0)
-		goto err_memfd;
+		goto error;
+#else
+	/* Need to re-open "memfd" as read-only to avoid execve(2) giving -EXTBUSY. */
+	int newfd;
+	char *fdpath = NULL;
+
+	if (asprintf(&fdpath, "/proc/self/fd/%d", memfd) < 0)
+		goto error;
+	newfd = open(fdpath, O_RDONLY | O_CLOEXEC);
+	free(fdpath);
+	if (newfd < 0)
+		goto error;
 
-	close(binfd);
+	close(memfd);
+	memfd = newfd;
+#endif
 	return memfd;
 
-err_memfd:
+error:
 	close(memfd);
-err_binfd:
-	close(binfd);
-err:
-	return -1;
+	return -EIO;
 }
 
 int ensure_cloned_binary(void)
@@ -221,16 +255,16 @@ int ensure_cloned_binary(void)
 
 	/* Check that we're not self-cloned, and if we are then bail. */
 	int cloned = is_self_cloned();
-	if (cloned != 0)
+	if (cloned > 0 || cloned == -ENOTRECOVERABLE)
 		return cloned;
 
 	if (fetchve(&argv, &envp) < 0)
-		return -1;
+		return -EINVAL;
 
 	execfd = clone_binary();
 	if (execfd < 0)
-		return -1;
+		return -EIO;
 
 	fexecve(execfd, argv, envp);
-	return -1;
+	return -ENOEXEC;
 }