#define RLIM_NLIMITS 16
#endif
+#include <assert.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include "seccomp-oci.h"
#include "cgroups.h"
-#include <libubox/utils.h>
#include <libubox/blobmsg.h>
#include <libubox/blobmsg_json.h>
#include <libubox/list.h>
#include <libubox/vlist.h>
#include <libubox/uloop.h>
+#include <libubox/utils.h>
#include <libubus.h>
#ifndef CLONE_NEWCGROUP
int pw_uid;
int pw_gid;
int gr_gid;
+ int root_map_uid;
gid_t *additional_gids;
size_t num_additional_gids;
mode_t umask;
opts.namespace);
}
+static void free_oci_envp(char **p) {
+ char **tmp;
+
+ if (p) {
+ tmp = p;
+ while (*tmp)
+ free(*(tmp++));
+
+ free(p);
+ }
+}
+
static void free_hooklist(struct hook_execvpe **hooklist)
{
struct hook_execvpe *cur;
- char **tmp;
if (!hooklist)
return;
cur = *hooklist;
while (cur) {
+ free_oci_envp(cur->argv);
+ free_oci_envp(cur->envp);
free(cur->file);
- tmp = cur->argv;
- while (tmp)
- free(*(tmp++));
-
- free(cur->argv);
-
- tmp = cur->envp;
- while (tmp)
- free(*(tmp++));
-
- free(cur->envp);
free(cur++);
}
free(hooklist);
}
static void free_opts(bool parent) {
- char **tmp;
+
+ free_library_search();
+ mount_free();
+ cgroups_free();
/* we need to keep argv, envp and seccomp filter in child */
if (parent) { /* parent-only */
free(opts.ociseccomp);
}
- tmp = opts.jail_argv;
- while(tmp)
- free(*(tmp++));
-
- free(opts.jail_argv);
-
- tmp = opts.envp;
- while (tmp)
- free(*(tmp++));
-
- free(opts.envp);
- } else { /* child-only */
- if (opts.ocibundle)
- cgroups_free();
+ free_oci_envp(opts.jail_argv);
+ free_oci_envp(opts.envp);
}
free_rlimits();
free_devices();
free(opts.hostname);
free(opts.cwd);
- free(opts.extroot);
free(opts.uidmap);
free(opts.gidmap);
free(opts.annotations);
- free(opts.ocibundle);
- free(opts.pidfile);
free_hooklist(opts.hooks.createRuntime);
free_hooklist(opts.hooks.createContainer);
free_hooklist(opts.hooks.startContainer);
fd = creat(upperresolvconf, 0644);
if (fd == -1) {
- ERROR("creat(%s) failed: %m\n", upperresolvconf);
- goto upper_resolvconf_printf;
+ if (errno != EEXIST)
+ ERROR("creat(%s) failed: %m\n", upperresolvconf);
+ } else {
+ close(fd);
}
- close(fd);
-
DEBUG("mount -t overlay %s %s (%s)\n", jail_root, jail_root, optsstr);
if (mount(jail_root, jail_root, "overlay", MS_NOATIME, optsstr))
- goto opts_printf;
+ goto upper_resolvconf_printf;
ret = 0;
snprintf(dev_console_path, sizeof(dev_console_path), "%s/dev/console", jail_root);
close(creat(dev_console_path, 0620));
- if (mount(console_fname, dev_console_path, NULL, MS_BIND, NULL))
+ if (mount(console_fname, dev_console_path, "bind", MS_BIND, NULL))
goto no_console;
/* use PTY slave for stdio */
}
/* oldroot can't be MS_SHARED else pivot_root() fails */
- if (mount("none", "/", NULL, MS_REC|MS_PRIVATE, NULL)) {
+ if (mount("none", "/", "none", MS_REC|MS_PRIVATE, NULL)) {
ERROR("private mount failed %m\n");
return -1;
}
if (opts.extroot) {
- if (mount(opts.extroot, jail_root, NULL, MS_BIND, NULL)) {
+ if (mount(opts.extroot, jail_root, "bind", MS_BIND, NULL)) {
ERROR("extroot mount failed %m\n");
return -1;
}
return 0;
}
+static bool exit_from_child;
+static void free_and_exit(int ret)
+{
+ if (!exit_from_child && opts.ocibundle)
+ cgroups_free();
+
+ if (!exit_from_child && parent_ctx)
+ ubus_free(parent_ctx);
+
+ free_opts(!exit_from_child);
+
+ exit(ret);
+}
+
static void post_jail_fs(void);
static void enter_jail_fs(void)
{
if (pivot_root(jail_root, dirbuf) == -1) {
ERROR("pivot_root(%s, %s) failed: %m\n", jail_root, dirbuf);
- exit(-1);
+ free_and_exit(-1);
}
if (chdir("/")) {
ERROR("chdir(/) (after pivot_root) failed: %m\n");
- exit(-1);
+ free_and_exit(-1);
}
snprintf(dirbuf, sizeof(dirbuf), "/old%s", jail_root);
if (create_devices()) {
ERROR("create_devices() failed\n");
- exit(-1);
+ free_and_exit(-1);
}
if (opts.ronly)
- mount(NULL, "/", NULL, MS_REMOUNT | MS_BIND | MS_RDONLY, 0);
+ mount(NULL, "/", "bind", MS_REMOUNT | MS_BIND | MS_RDONLY, 0);
umask(old_umask);
post_jail_fs();
}
close(map_file);
- free(mapstr);
return 0;
}
if (!p) {
ERROR("failed to get uid/gid for user %s: %d (%s)\n",
opts.user, errno, strerror(errno));
- exit(EXIT_FAILURE);
+ free_and_exit(EXIT_FAILURE);
}
*user = p->pw_uid;
*user_gid = p->pw_gid;
g = getgrnam(opts.group);
if (!g) {
ERROR("failed to get gid for group %s: %m\n", opts.group);
- exit(EXIT_FAILURE);
+ free_and_exit(EXIT_FAILURE);
}
*gr_gid = g->gr_gid;
} else {
{
if (opts.user && (user_gid != -1) && initgroups(opts.user, user_gid)) {
ERROR("failed to initgroups() for user %s: %m\n", opts.user);
- exit(EXIT_FAILURE);
+ free_and_exit(EXIT_FAILURE);
}
if ((gr_gid != -1) && setregid(gr_gid, gr_gid)) {
ERROR("failed to set group id %d: %m\n", gr_gid);
- exit(EXIT_FAILURE);
+ free_and_exit(EXIT_FAILURE);
}
if ((pw_uid != -1) && setreuid(pw_uid, pw_uid)) {
ERROR("failed to set user id %d: %m\n", pw_uid);
- exit(EXIT_FAILURE);
+ free_and_exit(EXIT_FAILURE);
}
}
return 0;
}
-#define MAX_ENVP 8
+#define MAX_ENVP 16
static char** build_envp(const char *seccomp, char **ocienvp)
{
static char *envp[MAX_ENVP];
static char preload_var[PATH_MAX];
static char seccomp_var[PATH_MAX];
+ static char seccomp_debug_var[20];
static char debug_var[] = "LD_DEBUG=all";
static char container_var[] = "container=ujail";
const char *preload_lib = find_lib("libpreload-seccomp.so");
if (seccomp) {
snprintf(seccomp_var, sizeof(seccomp_var), "SECCOMP_FILE=%s", seccomp);
envp[count++] = seccomp_var;
+ snprintf(seccomp_debug_var, sizeof(seccomp_debug_var), "SECCOMP_DEBUG=%2d", debug);
+ envp[count++] = seccomp_debug_var;
snprintf(preload_var, sizeof(preload_var), "LD_PRELOAD=%s", preload_lib);
envp[count++] = preload_var;
}
fprintf(stderr, " -E\t\tfail if jail cannot be setup\n");
fprintf(stderr, " -y\t\tprovide jail console\n");
fprintf(stderr, " -J <dir>\tcreate container from OCI bundle\n");
- fprintf(stderr, " -j\t\tstart container immediately\n");
+ fprintf(stderr, " -i\t\tstart container immediately\n");
fprintf(stderr, " -P <pidfile>\tcreate <pidfile>\n");
fprintf(stderr, "\nWarning: by default root inside the jail is the same\n\
and he has the same powers as root outside the jail,\n\
{
int *fd = get_namespace_fd(nstype);
- if (!*fd)
- return EFAULT;
+ assert(fd != NULL);
if (*fd == -1)
return 0;
{
char buf[1];
+ exit_from_child = true;
+ prctl(PR_SET_SECUREBITS, 0);
+
uloop_init();
signals_init();
if (opts.namespace & CLONE_NEWCGROUP)
unshare(CLONE_NEWCGROUP);
+ setns_open(CLONE_NEWCGROUP);
+
if ((opts.namespace & CLONE_NEWUSER) || (opts.setns.user != -1)) {
if (setregid(0, 0) < 0) {
ERROR("setgid\n");
- exit(EXIT_FAILURE);
+ free_and_exit(EXIT_FAILURE);
}
if (setreuid(0, 0) < 0) {
ERROR("setuid\n");
- exit(EXIT_FAILURE);
+ free_and_exit(EXIT_FAILURE);
}
if (setgroups(0, NULL) < 0) {
ERROR("setgroups\n");
- exit(EXIT_FAILURE);
+ free_and_exit(EXIT_FAILURE);
}
}
if (opts.namespace && opts.hostname && strlen(opts.hostname) > 0
&& sethostname(opts.hostname, strlen(opts.hostname))) {
ERROR("sethostname(%s) failed: %m\n", opts.hostname);
- exit(EXIT_FAILURE);
+ free_and_exit(EXIT_FAILURE);
}
uloop_timeout_add(&pre_exec_timeout);
uloop_run();
- exit(-1);
+ free_and_exit(-1);
+ return -1;
}
static void pre_exec_jail(struct uloop_timeout *t)
{
if ((opts.namespace & CLONE_NEWNS) && build_jail_fs()) {
ERROR("failed to build jail fs\n");
- exit(EXIT_FAILURE);
+ free_and_exit(EXIT_FAILURE);
} else {
run_hooks(opts.hooks.createContainer, post_jail_fs);
}
if (read(pipes[2], buf, 1) < 1) {
ERROR("can't read from parent\n");
- exit(EXIT_FAILURE);
+ free_and_exit(EXIT_FAILURE);
}
if (buf[0] != '!') {
ERROR("parent had an error, child exiting\n");
- exit(EXIT_FAILURE);
+ free_and_exit(EXIT_FAILURE);
}
close(pipes[2]);
{
int pw_uid, pw_gid, gr_gid;
- if (prctl(PR_SET_SECUREBITS, SECBIT_NO_SETUID_FIXUP)) {
- ERROR("prctl(PR_SET_SECUREBITS) failed: %m\n");
- exit(EXIT_FAILURE);
+ /*
+ * make sure setuid/setgid won't drop capabilities in case capabilities
+ * have been specified explicitely.
+ */
+ if (opts.capset.apply) {
+ if (prctl(PR_SET_SECUREBITS, SECBIT_NO_SETUID_FIXUP)) {
+ ERROR("prctl(PR_SET_SECUREBITS) failed: %m\n");
+ free_and_exit(EXIT_FAILURE);
+ }
}
/* drop capabilities, retain those still needed to further setup jail */
if (applyOCIcapabilities(opts.capset, (1LLU << CAP_SETGID) | (1LLU << CAP_SETUID) | (1LLU << CAP_SETPCAP)))
- exit(EXIT_FAILURE);
+ free_and_exit(EXIT_FAILURE);
/* use either cmdline-supplied user/group or uid/gid from OCI spec */
get_jail_user(&pw_uid, &pw_gid, &gr_gid);
if (opts.additional_gids &&
(setgroups(opts.num_additional_gids, opts.additional_gids) < 0)) {
ERROR("setgroups failed: %m\n");
- exit(EXIT_FAILURE);
+ free_and_exit(EXIT_FAILURE);
}
if (opts.set_umask)
umask(opts.umask);
- if (prctl(PR_SET_SECUREBITS, 0)) {
- ERROR("prctl(PR_SET_SECUREBITS) failed: %m\n");
- exit(EXIT_FAILURE);
+ /* restore securebits back to normal (and lock them if not in userns) */
+ if (opts.capset.apply) {
+ if (prctl(PR_SET_SECUREBITS, (opts.namespace & CLONE_NEWUSER)?0:
+ SECBIT_KEEP_CAPS_LOCKED|SECBIT_NO_SETUID_FIXUP_LOCKED|SECBIT_NOROOT_LOCKED)) {
+ ERROR("prctl(PR_SET_SECUREBITS) failed: %m\n");
+ free_and_exit(EXIT_FAILURE);
+ }
}
/* drop remaining capabilities to end up with specified sets */
if (applyOCIcapabilities(opts.capset, 0))
- exit(EXIT_FAILURE);
+ free_and_exit(EXIT_FAILURE);
if (opts.no_new_privs && prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0)) {
ERROR("prctl(PR_SET_NO_NEW_PRIVS) failed: %m\n");
- exit(EXIT_FAILURE);
+ free_and_exit(EXIT_FAILURE);
}
char **envp = build_envp(opts.seccomp, opts.envp);
if (!envp)
- exit(EXIT_FAILURE);
+ free_and_exit(EXIT_FAILURE);
if (opts.cwd && chdir(opts.cwd))
- exit(EXIT_FAILURE);
+ free_and_exit(EXIT_FAILURE);
if (opts.ociseccomp && applyOCIlinuxseccomp(opts.ociseccomp))
- exit(EXIT_FAILURE);
+ free_and_exit(EXIT_FAILURE);
uloop_end();
free_opts(false);
}
return 0;
-};
+}
+static void get_jail_root_user(bool is_gidmap, uint32_t container_id, uint32_t host_id, uint32_t size)
+{
+ if (container_id == 0 && size >= 1)
+ if (!is_gidmap)
+ opts.root_map_uid = host_id;
+}
enum {
OCI_LINUX_UIDGIDMAP_CONTAINERID,
static int parseOCIuidgidmappings(struct blob_attr *msg, bool is_gidmap)
{
- const char *map_format = "%d %d %d\n";
struct blob_attr *tb[__OCI_LINUX_UIDGIDMAP_MAX];
struct blob_attr *cur;
- int rem, len;
- char **mappings;
- char *map, *curstr;
- unsigned int cnt = 0;
- size_t totallen = 0;
-
- /* count number of mappings */
- blobmsg_for_each_attr(cur, msg, rem)
- cnt++;
-
- if (!cnt)
- return 0;
-
- /* allocate array for mappings */
- mappings = calloc(1 + cnt, sizeof(char*));
- if (!mappings)
- return ENOMEM;
-
- mappings[cnt] = NULL;
+ int rem;
+ char *map;
+ size_t len, pos, totallen = 0;
- cnt = 0;
blobmsg_for_each_attr(cur, msg, rem) {
blobmsg_parse(oci_linux_uidgidmap_policy, __OCI_LINUX_UIDGIDMAP_MAX, tb, blobmsg_data(cur), blobmsg_len(cur));
!tb[OCI_LINUX_UIDGIDMAP_SIZE])
return EINVAL;
- /* write mapping line into allocated string */
- len = asprintf(&mappings[cnt++], map_format,
+ /* count length */
+ totallen += snprintf(NULL, 0, "%d %d %d\n",
blobmsg_get_u32(tb[OCI_LINUX_UIDGIDMAP_CONTAINERID]),
blobmsg_get_u32(tb[OCI_LINUX_UIDGIDMAP_HOSTID]),
blobmsg_get_u32(tb[OCI_LINUX_UIDGIDMAP_SIZE]));
-
- if (len < 0)
- return ENOMEM;
-
- totallen += len;
}
/* allocate combined mapping string */
- map = calloc(1 + totallen, sizeof(char));
+ map = malloc(totallen + 1);
if (!map)
return ENOMEM;
- map[0] = '\0';
+ pos = 0;
+ blobmsg_for_each_attr(cur, msg, rem) {
+ blobmsg_parse(oci_linux_uidgidmap_policy, __OCI_LINUX_UIDGIDMAP_MAX, tb, blobmsg_data(cur), blobmsg_len(cur));
+
+ get_jail_root_user(is_gidmap, blobmsg_get_u32(tb[OCI_LINUX_UIDGIDMAP_CONTAINERID]),
+ blobmsg_get_u32(tb[OCI_LINUX_UIDGIDMAP_HOSTID]),
+ blobmsg_get_u32(tb[OCI_LINUX_UIDGIDMAP_SIZE]));
- /* concatenate mapping strings into combined string */
- curstr = mappings[0];
- while (curstr) {
- strcat(map, curstr);
- free(curstr++);
+ /* write mapping line into pre-allocated string */
+ len = snprintf(&map[pos], totallen + 1, "%d %d %d\n",
+ blobmsg_get_u32(tb[OCI_LINUX_UIDGIDMAP_CONTAINERID]),
+ blobmsg_get_u32(tb[OCI_LINUX_UIDGIDMAP_HOSTID]),
+ blobmsg_get_u32(tb[OCI_LINUX_UIDGIDMAP_SIZE]));
+ pos += len;
+ totallen -= len;
}
- free(mappings);
+
+ assert(totallen == 0);
if (is_gidmap)
opts.gidmap = map;
if (tb[OCI_LINUX_MASKEDPATHS]) {
blobmsg_for_each_attr(cur, tb[OCI_LINUX_MASKEDPATHS], rem) {
- res = add_mount((void *)(-1), blobmsg_get_string(cur), NULL, 0, 0, NULL, 1);
+ res = add_mount((void *)(-1), blobmsg_get_string(cur), NULL, 0, 0, NULL, 0);
if (res)
return res;
}
int res;
blob_buf_init(&ocibuf, 0);
- if (!blobmsg_add_json_from_file(&ocibuf, jsonfile))
- return ENOENT;
+
+ if (!blobmsg_add_json_from_file(&ocibuf, jsonfile)) {
+ res=ENOENT;
+ goto errout;
+ }
blobmsg_parse(oci_policy, __OCI_MAX, tb, blob_data(ocibuf.head), blob_len(ocibuf.head));
- if (!tb[OCI_VERSION])
- return ENOMSG;
+ if (!tb[OCI_VERSION]) {
+ res=ENOMSG;
+ goto errout;
+ }
if (strncmp("1.0", blobmsg_get_string(tb[OCI_VERSION]), 3)) {
ERROR("unsupported ociVersion %s\n", blobmsg_get_string(tb[OCI_VERSION]));
- return ENOTSUP;
+ res=ENOTSUP;
+ goto errout;
}
if (tb[OCI_HOSTNAME])
opts.hostname = strdup(blobmsg_get_string(tb[OCI_HOSTNAME]));
- if (!tb[OCI_PROCESS])
- return ENODATA;
+ if (!tb[OCI_PROCESS]) {
+ res=ENODATA;
+ goto errout;
+ }
if ((res = parseOCIprocess(tb[OCI_PROCESS])))
- return res;
-
- if (!tb[OCI_ROOT])
- return ENODATA;
+ goto errout;
+ if (!tb[OCI_ROOT]) {
+ res=ENODATA;
+ goto errout;
+ }
if ((res = parseOCIroot(jsonfile, tb[OCI_ROOT])))
- return res;
+ goto errout;
- if (!tb[OCI_MOUNTS])
- return ENODATA;
+ if (!tb[OCI_MOUNTS]) {
+ res=ENODATA;
+ goto errout;
+ }
blobmsg_for_each_attr(cur, tb[OCI_MOUNTS], rem)
if ((res = parseOCImount(cur)))
- return res;
+ goto errout;
if (tb[OCI_LINUX] && (res = parseOCIlinux(tb[OCI_LINUX])))
- return res;
+ goto errout;
if (tb[OCI_HOOKS] && (res = parseOCIhooks(tb[OCI_HOOKS])))
- return res;
+ goto errout;
if (tb[OCI_ANNOTATIONS])
opts.annotations = blob_memdup(tb[OCI_ANNOTATIONS]);
+errout:
blob_buf_free(&ocibuf);
- return 0;
+ return res;
}
static int set_oom_score_adj(void)
umask(022);
mount_list_init();
init_library_search();
+ cgroups_prepare();
+ exit_from_child = false;
while ((ch = getopt(argc, argv, OPT_ARGS)) != -1) {
switch (ch) {
opts.namespace |= CLONE_NEWCGROUP;
break;
case 'R':
- opts.extroot = strdup(optarg);
+ opts.extroot = optarg;
break;
case 's':
opts.namespace |= CLONE_NEWNS;
opts.console = 1;
break;
case 'J':
- opts.ocibundle = strdup(optarg);
+ opts.ocibundle = optarg;
break;
case 'i':
opts.immediately = true;
break;
case 'P':
- opts.pidfile = strdup(optarg);
+ opts.pidfile = optarg;
break;
}
}
opts.setns.time = -1;
#endif
+ /*
+ * uid in parent user namespace representing root user in new
+ * user namespace, defaults to nobody unless specified in uidMappings
+ */
+ opts.root_map_uid = 65534;
+
if (opts.capabilities && parseOCIcapabilities_from_file(&opts.capset, opts.capabilities)) {
ERROR("failed to read capabilities from file %s\n", opts.capabilities);
- return -1;
+ ret=-1;
+ goto errout;
}
if (opts.ocibundle) {
char *jsonfile;
int ocires;
+ if (!opts.name) {
+ ERROR("OCI bundle needs a named jail\n");
+ ret=-1;
+ goto errout;
+ }
asprintf(&jsonfile, "%s/config.json", opts.ocibundle);
ocires = parseOCI(jsonfile);
free(jsonfile);
if (ocires) {
ERROR("parsing of OCI JSON spec has failed: %s (%d)\n", strerror(ocires), ocires);
- return ocires;
+ ret=ocires;
+ goto errout;
}
}
+ if (opts.namespace & CLONE_NEWNET) {
+ if (!opts.name) {
+ ERROR("netns needs a named jail\n");
+ ret=-1;
+ goto errout;
+ }
+ }
+
+
if (opts.tmpoverlaysize && strlen(opts.tmpoverlaysize) > 8) {
ERROR("size parameter too long: \"%s\"\n", opts.tmpoverlaysize);
- return -1;
+ ret=-1;
+ goto errout;
}
/* no <binary> param found */
if (!opts.ocibundle && (argc - optind < 1)) {
usage();
- return EXIT_FAILURE;
+ ret=EXIT_FAILURE;
+ goto errout;
}
if (!(opts.ocibundle||opts.namespace||opts.capabilities||opts.seccomp)) {
ERROR("Not using namespaces, capabilities or seccomp !!!\n\n");
usage();
- return EXIT_FAILURE;
+ ret=EXIT_FAILURE;
+ goto errout;
}
DEBUG("Using namespaces(0x%08x), capabilities(%d), seccomp(%d)\n",
opts.namespace,
if (opts.ocibundle) {
char *objname;
- if (asprintf(&objname, "container.%s", opts.name) < 0)
- exit(-ENOMEM);
+ if (asprintf(&objname, "container.%s", opts.name) < 0) {
+ ret=-ENOMEM;
+ goto errout;
+ }
container_object.name = objname;
ret = ubus_add_object(parent_ctx, &container_object);
if (ret) {
ERROR("Failed to add object: %s\n", ubus_strerror(ret));
- exit(-1);
+ ret=-1;
+ goto errout;
}
}
if (!opts.ocibundle) {
/* allocate NULL-terminated array for argv */
opts.jail_argv = calloc(1 + argc - optind, sizeof(char**));
- if (!opts.jail_argv)
- return EXIT_FAILURE;
-
+ if (!opts.jail_argv) {
+ ret=EXIT_FAILURE;
+ goto errout;
+ }
for (size_t s = optind; s < argc; s++)
opts.jail_argv[s - optind] = strdup(argv[s]);
if (!opts.extroot) {
if (opts.namespace && add_path_and_deps(*opts.jail_argv, 1, -1, 0)) {
ERROR("failed to load dependencies\n");
- return -1;
+ ret=-1;
+ goto errout;
}
}
if (opts.namespace && opts.seccomp && add_path_and_deps("libpreload-seccomp.so", 1, -1, 1)) {
ERROR("failed to load libpreload-seccomp.so\n");
opts.seccomp = 0;
- if (opts.require_jail)
- return -1;
+ if (opts.require_jail) {
+ ret=-1;
+ goto errout;
+ }
}
uloop_timeout_add(&post_main_timeout);
uloop_run();
- /* unreachable */
- return 0;
+errout:
+ if (opts.ocibundle)
+ cgroups_free();
+
+ free_opts(true);
+
+ return ret;
}
static void post_main(struct uloop_timeout *t)
{
if (apply_rlimits()) {
ERROR("error applying resource limits\n");
- exit(EXIT_FAILURE);
+ free_and_exit(EXIT_FAILURE);
}
if (opts.name)
prctl(PR_SET_NAME, opts.name, NULL, NULL, NULL);
if (pipe(&pipes[0]) < 0 || pipe(&pipes[2]) < 0)
- exit(-1);
+ free_and_exit(-1);
if (has_namespaces()) {
if (opts.namespace & CLONE_NEWNS) {
#endif
if (!(opts.namespace & CLONE_NEWNET)) {
- add_mount_bind("/etc/resolv.conf", 1, -1);
+ add_mount_bind("/etc/resolv.conf", 1, 0);
} else if (opts.setns.net == -1) {
char hostdir[PATH_MAX];
snprintf(hostdir, PATH_MAX, "/tmp/resolv.conf-%s.d", opts.name);
mkdir_p(hostdir, 0755);
- add_mount(hostdir, "/dev/resolv.conf.d", NULL, MS_BIND | MS_NOEXEC | MS_NOATIME | MS_NOSUID | MS_NODEV | MS_RDONLY, 0, NULL, -1);
+ add_mount(hostdir, "/dev/resolv.conf.d", NULL, MS_BIND | MS_NOEXEC | MS_NOATIME | MS_NOSUID | MS_NODEV | MS_RDONLY, 0, NULL, 0);
}
/* default mounts */
}
if (opts.sysfs || opts.ocibundle)
- add_mount("sysfs", "/sys", "sysfs", MS_NOATIME | MS_NODEV | MS_NOEXEC | MS_NOSUID | MS_RDONLY, 0, NULL, -1);
+ add_mount("sysfs", "/sys", "sysfs", MS_RELATIME | MS_NODEV | MS_NOEXEC | MS_NOSUID | MS_RDONLY, 0, NULL, -1);
if (opts.ocibundle)
add_mount("shm", "/dev/shm", "tmpfs", MS_NOSUID | MS_NOEXEC | MS_NODEV, 0, "mode=1777", -1);
if (opts.setns.time != -1) {
timens_fd = ns_open_pid("time", getpid());
setns_open(CLONE_NEWTIME);
+ } else {
+ timens_fd = -1;
}
#endif
+ if (opts.namespace & CLONE_NEWUSER) {
+ if (prctl(PR_SET_SECUREBITS, SECBIT_NO_SETUID_FIXUP)) {
+ ERROR("prctl(PR_SET_SECUREBITS) failed: %m\n");
+ free_and_exit(EXIT_FAILURE);
+ }
+ seteuid(opts.root_map_uid);
+ }
+
jail_process.pid = clone(exec_jail, child_stack + STACK_SIZE, SIGCHLD | (opts.namespace & (~CLONE_NEWCGROUP)), NULL);
} else {
jail_process.pid = fork();
uloop_process_add(&jail_process);
jail_running = 1;
seteuid(0);
+ prctl(PR_SET_SECUREBITS, 0);
+
if (pidns_fd != -1) {
setns(pidns_fd, CLONE_NEWPID);
close(pidns_fd);
close(pipes[2]);
if (read(pipes[0], sig_buf, 1) < 1) {
ERROR("can't read from child\n");
- exit(-1);
+ free_and_exit(-1);
}
close(pipes[0]);
set_oom_score_adj();
if (opts.namespace & CLONE_NEWUSER) {
if (write_setgroups(jail_process.pid, true)) {
ERROR("can't write setgroups\n");
- exit(-1);
+ free_and_exit(-1);
}
if (!opts.uidmap) {
bool has_gr = (opts.gr_gid != -1);
}
if (opts.namespace & CLONE_NEWNET) {
- if (!opts.name) {
- ERROR("netns needs a named jail\n");
- exit(-1);
- }
netns_fd = ns_open_pid("net", jail_process.pid);
netns_updown(jail_process.pid, true);
}
+
if (jail_writepid(jail_process.pid)) {
ERROR("failed to write pidfile: %m\n");
- exit(-1);
+ free_and_exit(-1);
}
} else if (jail_process.pid == 0) {
/* fork child process */
- exit(exec_jail(NULL));
+ free_and_exit(exec_jail(NULL));
} else {
ERROR("failed to clone/fork: %m\n");
- exit(EXIT_FAILURE);
+ free_and_exit(EXIT_FAILURE);
}
run_hooks(opts.hooks.createRuntime, post_create_runtime);
}
sig_buf[0] = 'O';
if (write(pipes[3], sig_buf, 1) < 0) {
ERROR("can't write to child\n");
- exit(-1);
+ free_and_exit(-1);
}
jail_oci_state = OCI_STATE_CREATED;
sig_buf[0] = '!';
if (write(pipes[3], sig_buf, 1) < 0) {
ERROR("can't write to child\n");
- exit(-1);
+ free_and_exit(-1);
}
close(pipes[3]);
projects / project / procd.git / blobdiff