---

   user_namespaces - обзор пользовательских пространств имён Linux

---

Попытки записи, нарушающие перечисленные выше правила, завершаются с ошибкой EPERM.

Взаимодействие с системными вызовами, которые изменяют UID или GID процесса.

Для ID пользователя, это относится к следующим системным вызовам: setuid(2), setfsuid(2), setreuid(2) и setresuid(2). Для ID группы, это относится к следующим системным вызовам: setgid(2), setfsgid(2), setregid(2), setresgid(2) и setgroups(2).

Запись "deny" в файле /proc/[pid]/setgroups перед записью в /proc/[pid]/gid_map насовсем отключает setgroups(2) в пользовательском пространстве имён, а также разрешает запись в /proc/[pid]/gid_map без мандата CAP_SETGID в родительском пользовательском пространстве имён.

Файл /proc/[pid]/setgroups

Привилегированный процесс (с мандатом CAP_SYS_ADMIN в пространстве имён) может записать строку "allow" или "deny" в этот файл до записи отображения ID групп для этого пользовательского пространства имён в файл /proc/[pid]/gid_map. Запись строки "deny" запрещает любому процессу в пользовательском пространстве имён выполнять setgroups(2).

Сущность ограничений, описанных в предыдущем абзаце в том, чтобы разрешить запись в /proc/[pid]/setgroups только когда запрещено вызывать setgroups(2), так как /proc/[pid]gid_map не настроен. Это гарантирует, что процесс не сможет перейти из состояния, в котором setgroups(2) разрешён, в состояние, в котором setgroups(2) запрещён; процесс может переходить только из состояния, когда setgroups(2) запрещён, в состояние, когда setgroups(2) разрешён.

Значение по умолчанию в этом файле для начального состояния пользовательского пространства имён равно "allow".

После записи в /proc/[pid]/gid_map (что действует как разрешение работы setgroups(2) в пользовательском пространстве имён), больше невозможно запретить setgroups(2) записью "deny" в /proc/[pid]/setgroups (запись завершается ошибкой EPERM).

Дочернее пользовательское пространство имён наследует значение /proc/[pid]/setgroups своего родителя.

Если файл setgroups содержит значение "deny", то системный вызов setgroups(2) не может быть повторно включён в дальнейшем (записью "allow" в файл) в этом пользовательском пространстве имён (попытка это сделать завершается с ошибкой EPERM). Это ограничение также распространяется на всех потомков пользовательского пространства имён этого пользовательского пространства имён.

Файл /proc/[pid]/setgroups был добавлен в Linux 3.19, но перенесён и в старшие серии ядра, так как служит для обеспечения безопасности. В частности, это влияет на файлы с правами доступа «rwx---rwx». Эти файлы меньшие права «группе» по сравнению с группой «остальные». Это означает, что удаление группы с помощью setgroups(2) может открыть доступ к файлу, тем которые не имели его. До существования пользовательских пространств имён это не было проблемой, так как только привилегированный процесс (с мандатом CAP_SETGID) мог вызывать setgroups(2). Однако с введение пользовательских пространств имён стало возможным и непривилегированному процессу создавать новое пространство имён, в котором пользователь имеет все права. После этого ранее непривилегированный пользователь может удалить группы и таким образом получить доступ к файлу, которого раньше не имел. Файл /proc/[pid]/setgroups был добавлен для решения этой проблемы безопасности; он запрещает непривилегированному процессу удалять группы с помощью setgroups(2).

Неотображённые пользовательские и групповые ID

Есть несколько мест, где в пользовательском пространстве могут появиться неотображённые пользовательские ID (групповые ID). Например, первый процесс в новом пользовательском пространстве имён может вызвать getuid() до определения отображения пользовательских ID для пространства имён. В большинстве случаев, неотображённый пользовательский ID преобразуется в пользовательский ID (групповой ID) переполнения (overflow); значение по умолчанию для пользовательского ID (группового ID) переполнения равно 65534. Смотрите описание /proc/sys/kernel/overflowuid и /proc/sys/kernel/overflowgid в proc(5).

Случаи, где неотображённые ID отображаются в таком виде, относятся к системным вызовам, которые возвращают пользовательские ID (getuid(2), getgid(2) и подобные), мандаты, передаваемые через доменный сокет UNIX, мандаты, возвращаемые stat(2), waitid(2) и System V IPC «ctl»-операциями IPC_STAT, мандаты, показываемые в /proc/PID/status и файлах в /proc/sysvipc/*, мандаты, возвращаемые в поле si_uid структуры siginfo_t, полученной по сигналу (смотрите sigaction(2)), мандаты, записываемые в файл учёта процесса (смотрите acct(5)), и мандаты, возвращаемые с уведомлениями очереди сообщений POSIX (смотрите mq_notify(3)).

Есть один известный случай, где неотображённый пользовательский и групповой ID не преобразуется в соответствующее значение ID переполнения. Если при просмотре файла uid_map или gid_map обнаруживается, что для второго поля нет отображения, то поле отображается как 4294967295 (-1 для беззнакового целого);

Программы с установленными битами set-user-ID и set-group-ID

Когда процесс внутри пользовательского пространства имён выполняет программу с установленным битом set-user-ID (set-group-ID), то эффективный ID пользователя (группы) внутри пространства имён изменяется на значение, отображённое для ID пользователя (группы) файла. Однако, если ID пользователя или группы файла не имеет отображения внутри пространства имён, то бит set-user-ID (set-group-ID) просто игнорируется: выполняется новая программа, но эффективный ID пользователя (группы) остаётся не изменённым (такое поведение зеркально семантике выполнения программы с set-user-ID или set-group-ID, располагающейся в файловой системе, которая была смонтирована с флагом MS_NOSUID, как описано в mount(2)).

Разное

Когда ID пользователя и группы процесса передаются через доменный сокет UNIX в процесс в другом пользовательском пространстве имён (смотрите описание SCM_CREDENTIALS в unix(7)), то они транслируются в соответствующие значения согласно отображению ID пользователя и группы принимающего процесса.

---

СООТВЕТСТВИЕ СТАНДАРТАМ

---

ЗАМЕЧАНИЯ

Доступность

В Linux 3.8 самые важные подсистемы поддерживают пользовательские пространства имён, но значительное количество файловых систем не имеют инфраструктуры для отображения пользовательских и групповых ID между пользовательскими пространствами имён. В Linux 3.9 добавлена требуемая поддержка инфраструктуры во многие неподдерживаемые файловые системы (Plan 9 (9P), Andrew File System (AFS), Ceph, CIFS, CODA, NFS и OCFS2). В Linux 3.11 добавлена поддержка в последние основные файловые системы (XFS).

---

ПРИМЕР

Сначала, посмотрим на окружение выполнения:

$ uname -rs     # требуется Linux 3.8 или новее
Linux 3.8.0
$ id -u         # работа от непривилегированного пользователя
1000
$ id -g
1000

Теперь запустим новую оболочку в новых пользовательском (-U), монтирования (-m) и PID (-p) пространствах имён с пользовательским (-M) и групповым ID (-G) 1000, отображающимся в 0 внутри пользовательского пространства имён:

$ ./userns_child_exec -p -m -U -M '0 1000 1' -G '0 1000 1' bash

У оболочки PID равен 1, так как это первый процесс в новом пространстве имён PID:

bash$ echo $$
1

Внутри пользовательского пространства имён идентификаторы пользователя и группы оболочки равны 0, и она имеет полный набор разрешённых и эффективных мандатов:

bash$ cat /proc/$$/status | egrep '^[UG]id'
Uid:    0       0       0       0
Gid:    0       0       0       0
bash$ cat /proc/$$/status | egrep '^Cap(Prm|Inh|Eff)'
CapInh: 0000000000000000
CapPrm: 0000001fffffffff
CapEff: 0000001fffffffff

Смонтируем новую файловую систему /proc и просмотрим все процессы, видимые в новом пространстве имён PID; убедимся, что оболочка не видит ни одного процесса вне своего пространства имён PID:

bash$ mount -t proc proc /proc
bash$ ps ax
  PID TTY      STAT   TIME COMMAND
    1 pts/3    S      0:00 bash
   22 pts/3    R+     0:00 ps ax

Исходный код программы

/* userns_child_exec.c
   Лицензируется на условиях Универсальной общественной лицензии
   GNU версии 2 и новее
   Создаёт дочерний процесс, который запускает командную оболочку
   в новых пространствах имён; может выполнять отображение UID и GID,
   если они указаны при создании пользовательского пространства имён.
*/
#define _GNU_SOURCE
#include <sched.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <signal.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <errno.h>
/* Простая функция обработки ошибок: выводит сообщение об ошибке согласно
   значению в «errno» и завершает вызвавший процесс */
#define errExit(msg)    do { perror(msg); exit(EXIT_FAILURE); \
                        } while (0)
struct child_args {
    char **argv;        /* команда, выполняемая потомком с параметрами */
    int    pipe_fd[2];  /* канал для синхронизации родителя и потомка */
};
static int verbose;
static void
usage(char *pname)
{
    fprintf(stderr, "Использование: %s [параметры] кмд [арг…]\n\n", pname);
    fprintf(stderr, "Создаёт дочерний процесс, который запускает командную "
            "оболочку в новом пользовательском пространстве имён,\n"
            "и, возможно, также в других новых пространствах имён.\n\n");
    fprintf(stderr, "Параметры:\n\n");
#define fpe(str) fprintf(stderr, "    %s", str);
    fpe("-i          Новое пространство имён IPC\n");
    fpe("-m          Новое пространство имён монтирования\n");
    fpe("-n          Новое сетевое пространство имён\n");
    fpe("-p          Новое пространство имён PID\n");
    fpe("-u          Новое пространство имён UTS\n");
    fpe("-U          Новое пользовательское пространство имён\n");
    fpe("-M uid_map  карта UID для пользовательского пространства имён\n");
    fpe("-G gid_map  карта GID для пользовательского пространства имён\n");
    fpe("-z          Отображать пользовательский UID и GID в 0 в пользовательском пространстве имён\n");
    fpe("            (эквивалентно: -M '0 <uid> 1' -G '0 <gid> 1')\n");
    fpe("-v          показывать дополнительные сообщения\n");
    fpe("\n");
    fpe("Если указан -z, -M или -G, то требуется -U.\n");
    fpe("Нельзя указывать -z вместе с -M или -G.\n");
    fpe("\n");
    fpe("Строка карты для -M и -G состоит из записей вида:\n");
    fpe("\n");
    fpe("    ID-внутри-ns   ID-вне-ns   длина\n");
    fpe("\n");
    fpe("Строка карты может содержать несколько записей через запятую;\n");
    fpe("запятые замещаются на символы новой строки перед записью"
        " в файлы карт.\n");
    exit(EXIT_FAILURE);
}
/* Обновляем файл отображения «map_file» значением из
   «mapping» — строкой, в которой определены отображения UID или GID.
   Отображения UID или GID состоят из одной или более записей
   (разделённых символом новой строки) вида:
       ID-внутри-ns    ID-снаружи-ns   длина
   Требовать от пользователя указывать строку с символами новой строки
   в командной строке неприемлемо. Поэтому мы позволим использовать
   для разделения записей запятые и заменим их символами новой строки
   перед записью строки в файл. */
static void
update_map(char *mapping, char *map_file)
{
    int fd, j;
    size_t map_len;     /* длина «mapping» */
    /* Заменяем запятые на символы новой строки в строке отображения */
    map_len = strlen(mapping);
    for (j = 0; j < map_len; j++)
        if (mapping[j] == ',')
            mapping[j] = '\n';
    fd = open(map_file, O_RDWR);
    if (fd == -1) {
        fprintf(stderr, "ОШИБКА: open %s: %s\n", map_file,
                strerror(errno));
        exit(EXIT_FAILURE);
    }
    if (write(fd, mapping, map_len) != map_len) {
        fprintf(stderr, "ОШИБКА: write %s: %s\n", map_file,
                strerror(errno));
        exit(EXIT_FAILURE);
    }
    close(fd);
}
/* В Linux 3.19 изменена работа с setgroups(2) и добавлен файл
   'gid_map' для обеспечения безопасности. Задача в том,
   чтобы запретить удалять группы *непривилегированному* пользователю
   через создание пространства имён. Результат изменений 3.19 в том, что
   для обновления файла 'gid_maps', сначала нужно запретить системный
   вызов setgroups() в этом пользовательском пространстве имён, записав
   "deny" в один из файлов /proc/PID/setgroups в этом пространстве имён.
   Это цель данной функции. */
static void
proc_setgroups_write(pid_t child_pid, char *str)
{
    char setgroups_path[PATH_MAX];
    int fd;
    snprintf(setgroups_path, PATH_MAX, "/proc/%ld/setgroups",
            (long) child_pid);
    fd = open(setgroups_path, O_RDWR);
    if (fd == -1) {
        /* Система может не поддерживать
           /proc/PID/setgroups. В этом случае файл не существует,
           и система не закладывает ограничений, добавленных в Linux 3.19.
           Хорошо, нам не нужно ничего делать, чтобы разрешить
           обновлять 'gid_map'.
           Однако, если ошибка open() отличается от
           ENOENT, сообщим об этом пользователю. */
        if (errno != ENOENT)
            fprintf(stderr, "ERROR: open %s: %s\n", setgroups_path,
                strerror(errno));
        return;
    }
    if (write(fd, str, strlen(str)) == -1)
        fprintf(stderr, "ОШИБКА: write %s: %s\n", setgroups_path,
            strerror(errno));
    close(fd);
}
static int              /* Начальная функция клонированного потомка */
childFunc(void *arg)
{
    struct child_args *args = (struct child_args *) arg;
    char ch;
    /* Ждём пока родитель обновит отображения UID и GID.
       Смотрите комментарий в main(). Мы ждём конца файла в канале,
       который будет закрыт родительским процессом после обновления
       отображений. */
    close(args->pipe_fd[1]);    /* закрываем наш дескриптор для записи
                                   конца канала для того, чтобы мы
                                   увидели EOF, когда родитель закроет
                                   свой дескриптор */
    if (read(args->pipe_fd[0], &ch, 1) != 0) {
        fprintf(stderr,
                "Ошибка в потомке: при чтении из канала получен != 0\n");
        exit(EXIT_FAILURE);
    }
    /* Запускаем командную оболочку */
    printf("О exec %s\n", args->argv[0]);
    execvp(args->argv[0], args->argv);
    errExit("execvp");
}
#define STACK_SIZE (1024 * 1024)
static char child_stack[STACK_SIZE];    /* место под стек в потомке */
int
main(int argc, char *argv[])
{
    int flags, opt, map_zero;
    pid_t child_pid;
    struct child_args args;
    char *uid_map, *gid_map;
    const int MAP_BUF_SIZE = 100;
    char map_buf[MAP_BUF_SIZE];
    char map_path[PATH_MAX];
    /* Разбираем параметры командной строки. Начальный символ «+» в
       последнем аргументе getopt() предотвращает подстановку параметров
       командной строки в стиле GNU. Это полезно, так как иногда
       «команда», выполняемая этой программой, сама имеет параметры
       командной строки. Мы не хотим, чтобы getopt() передала их
       нашей программе. */
    flags = 0;
    verbose = 0;
    gid_map = NULL;
    uid_map = NULL;
    map_zero = 0;
    while ((opt = getopt(argc, argv, "+imnpuUM:G:zv")) != -1) {
        switch (opt) {
        case 'i': flags |= CLONE_NEWIPC;        break;
        case 'm': flags |= CLONE_NEWNS;         break;
        case 'n': flags |= CLONE_NEWNET;        break;
        case 'p': flags |= CLONE_NEWPID;        break;
        case 'u': flags |= CLONE_NEWUTS;        break;
        case 'v': verbose = 1;                  break;
        case 'z': map_zero = 1;                 break;
        case 'M': uid_map = optarg;             break;
        case 'G': gid_map = optarg;             break;
        case 'U': flags |= CLONE_NEWUSER;       break;
        default:  usage(argv[0]);
        }
    }
    /* -M или -G без -U не имеют смысла */
    if (((uid_map != NULL || gid_map != NULL || map_zero) &&
                !(flags & CLONE_NEWUSER)) ||
            (map_zero && (uid_map != NULL || gid_map != NULL)))
        usage(argv[0]);
    args.argv = &argv[optind];
    /* Мы используем канал для синхронизации родителя и потомка, чтобы
       родитель настроил отображения UID и GID до того, как потомок
       вызовет execve(). Это гарантирует, что потомок предъявит свои
       мандаты при execve(); обычно мы хотим отобразить эффективный
       пользовательский ID потомка в 0 в новом пользовательском
       пространстве имён. Без этой синхронизации потомок потерял
       бы свои мандаты при вызове execve() с ненулевым пользовательским
       ID (смотрите в справочной странице capabilities(7) подробности
       преобразования мандатов процесса при execve()). */
    if (pipe(args.pipe_fd) == -1)
        errExit("pipe");
    /* создаём потомка в новом пространстве имён */
    child_pid = clone(childFunc, child_stack + STACK_SIZE,
                      flags | SIGCHLD, &args);
    if (child_pid == -1)
        errExit("clone");
    /* предок попадает сюда */
    if (verbose)
        printf("%s: PID потомка, созданного clone(): %ld\n",
                argv[0], (long) child_pid);
    /* обновляем отображения UID и GID в потомке */
    if (uid_map != NULL || map_zero) {
        snprintf(map_path, PATH_MAX, "/proc/%ld/uid_map",
                (long) child_pid);
        if (map_zero) {
            snprintf(map_buf, MAP_BUF_SIZE, "0 %ld 1", (long) getuid());
            uid_map = map_buf;
        }
        update_map(uid_map, map_path);
    }
    if (gid_map != NULL || map_zero) {
        proc_setgroups_write(child_pid, "deny");
        snprintf(map_path, PATH_MAX, "/proc/%ld/gid_map",
                (long) child_pid);
        if (map_zero) {
            snprintf(map_buf, MAP_BUF_SIZE, "0 %ld 1", (long) getgid());
            gid_map = map_buf;
        }
        update_map(gid_map, map_path);
    }
    /* закрываем конец канала на стороне записи для сообщения потомку
       о том, что мы обновили отображения UID и GID */
    close(args.pipe_fd[1]);
    if (waitpid(child_pid, NULL, 0) == -1)      /* ждём потомка */
        errExit("waitpid");
    if (verbose)
        printf("%s: завершение\n", argv[0]);
    exit(EXIT_SUCCESS);
}