seccomp как выйти на EXIT_SUCCESS?

Как описано в eigenstate.org и в SECCOMP (2):

Единственные системные вызовы, которые разрешено выполнять вызывающему потоку, это read(2), write(2), _exit(2) (но не exit_group(2)), и сигретерн(2). Другие системные вызовы приводят к доставке сигнала SIGKILL.

В результате можно было бы ожидать, что _exit() будет работать, но это функция-оболочка, которая вызывает exit_group(2), что не разрешено в строгом режиме ([1],[2]), поэтому процесс уничтожается.

Об этом даже сообщается в exit(2) - man-странице Linux:

В glibc до версии 2.3 функция-оболочка _exit() вызывала одноименный системный вызов ядра. Начиная с glibc 2.3, функция-оболочка вызывает exit_group(2), чтобы завершить все потоки в процессе.

То же самое происходит с оператором return, который должен закончиться прекращением вашего процесса, очень похожим образом с _exit().

Отслеживание процесса предоставит дополнительное подтверждение (чтобы это отображалось, вы должны не установить PR_SET_SECCOMP; просто прокомментируйте prctl()), и я получил одинаковый результат для обоих нерабочих случаев:

linux12:/home/users/grad1459>gcc seccomp.c -o seccomp
linux12:/home/users/grad1459>strace ./seccomp
execve("./seccomp", ["./seccomp"], [/* 24 vars */]) = 0
brk(0)                                  = 0x8784000
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
mmap2(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb775f000
access("/etc/ld.so.preload", R_OK)      = -1 ENOENT (No such file or directory)
open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
fstat64(3, {st_mode=S_IFREG|0644, st_size=97472, ...}) = 0
mmap2(NULL, 97472, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7747000
close(3)                                = 0
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
open("/lib/i386-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
read(3, "\177ELF\1\1\1\0\0\0\0\0\0\0\0\0\3\0\3\0\1\0\0\0\220\226\1\0004\0\0\0"..., 512) = 512
fstat64(3, {st_mode=S_IFREG|0755, st_size=1730024, ...}) = 0
mmap2(NULL, 1739484, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0xdd0000
mmap2(0xf73000, 12288, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x1a3) = 0xf73000
mmap2(0xf76000, 10972, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0xf76000
close(3)                                = 0
mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb7746000
set_thread_area({entry_number:-1 -> 6, base_addr:0xb7746900, limit:1048575, seg_32bit:1, contents:0, read_exec_only:0, limit_in_pages:1, seg_not_present:0, useable:1}) = 0
mprotect(0xf73000, 8192, PROT_READ)     = 0
mprotect(0x8049000, 4096, PROT_READ)    = 0
mprotect(0x16e000, 4096, PROT_READ)     = 0
munmap(0xb7747000, 97472)               = 0
exit_group(0)                           = ?
linux12:/home/users/grad1459>

Как видите, exit_group() называется, все объясняя!

Теперь, как вы правильно сказали, "SYS_exit equals __NR_exit"; например, он определен в mit.syscall .ч:

#define SYS_exit __NR_exit

поэтому последние два вызова эквивалентны, т.е. вы можете использовать тот, который вам нравится, и вывод должен быть таким:

linux12:/home/users/grad1459>gcc seccomp.c -o seccomp && ./seccomp ; echo "${?}" 
0

PS

Конечно, вы можете определить filter самостоятельно и использовать:

prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, filter);

как объяснено в ссылке на собственное состояние, разрешить _exit() (или, строго говоря, exit_group(2)), но делайте это только в том случае, если вам это действительно нужно и вы знаете, что делаете.

Проблема возникает из-за того, что библиотека GNU C использует системный вызов exit_group, если он доступен, в Linux вместо exit для функции _exit() (см. sysdeps/unix/sysv/linux/_exit.c для проверки), и как описано в man 2 prctl, системный вызов exit_group не разрешен строгим фильтром seccomp.

Поскольку вызов функции _exit() происходит внутри библиотеки C, мы не можем вставить его в нашу собственную версию (это просто вызовет системный вызов exit). (Обычная очистка процесса выполняется в другом месте; в Linux функция _exit() выполняет только последний системный вызов, завершающий процесс.)

Мы могли бы попросить разработчиков библиотеки GNU C использовать системный вызов exit_group в Linux только тогда, когда в текущем процессе более одного потока, но, к сожалению, это было бы непросто, и даже если бы его добавили прямо сейчас, потребовалось бы довольно много времени для эта функция будет доступна в большинстве дистрибутивов Linux.

К счастью, мы можем отказаться от строгого фильтра по умолчанию и вместо этого определить свой собственный. Есть небольшая разница в поведении: видимый сигнал, убивающий процесс, изменится с SIGKILL на SIGSYS. (Сигнал на самом деле не доставляется, так как ядро ​​​​убивает процесс; изменяется только кажущийся номер сигнала, вызвавший смерть процесса.)

Более того, это даже не так сложно. Я потратил немного времени на изучение некоторых трюков с макросами GCC, которые упростили бы управление списком разрешенных системных вызовов, но я решил, что это не будет хорошим подходом: список разрешенных системных вызовов должен быть тщательно продуман — мы только добавить exit_group() по сравнению со строгим фильтром, здесь! -- так что если сделать его немного сложным, это нормально.

Следующий код, например example.c, проверен для работы с ядром 4.4 (должен работать с ядром 3.5 или более поздней версии) на платформе x86-64 (как для x86, так и для x86-64, т. е. 32-разрядные и 64-битные двоичные файлы). Однако он должен работать на всех архитектурах Linux и не требует и не использует библиотеку libseccomp.

#define  _GNU_SOURCE
#include <stdlib.h>
#include <stddef.h>
#include <sys/prctl.h>
#include <sys/syscall.h>
#include <linux/seccomp.h>
#include <linux/filter.h>
#include <stdio.h>

static const struct sock_filter  strict_filter[] = {
    BPF_STMT(BPF_LD | BPF_W | BPF_ABS, (offsetof (struct seccomp_data, nr))),

    BPF_JUMP(BPF_JMP | BPF_JEQ, SYS_rt_sigreturn, 5, 0),
    BPF_JUMP(BPF_JMP | BPF_JEQ, SYS_read,         4, 0),
    BPF_JUMP(BPF_JMP | BPF_JEQ, SYS_write,        3, 0),
    BPF_JUMP(BPF_JMP | BPF_JEQ, SYS_exit,         2, 0),
    BPF_JUMP(BPF_JMP | BPF_JEQ, SYS_exit_group,   1, 0),

    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_KILL),
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW)
};

static const struct sock_fprog  strict = {
    .len = (unsigned short)( sizeof strict_filter / sizeof strict_filter[0] ),
    .filter = (struct sock_filter *)strict_filter
};

int main(void)
{
    /* To be able to set a custom filter, we need to set the "no new privs" flag.
       The Documentation/prctl/no_new_privs.txt file in the Linux kernel
       recommends this exact form: */
    if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0)) {
        fprintf(stderr, "Cannot set no_new_privs: %m.\n");
        return EXIT_FAILURE;
    }
    if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &strict)) {
        fprintf(stderr, "Cannot install seccomp filter: %m.\n");
        return EXIT_FAILURE;
    }

    /* The seccomp filter is now active.
       It differs from SECCOMP_SET_MODE_STRICT in two ways:
         1. exit_group syscall is allowed; it just terminates the
            process
         2. Parent/reaper sees SIGSYS as the killing signal instead of
            SIGKILL, if the process tries to do a syscall not in the
            explicitly allowed list
    */

    return EXIT_SUCCESS;
}

Скомпилируйте, используя, например.

gcc -Wall -O2 example.c -o example

и запустить с помощью

./example

или под strace, чтобы увидеть выполненные системные и библиотечные вызовы;

strace ./example

Программа strict_filter BPF действительно тривиальна. Первый код операции загружает номер системного вызова в аккумулятор. Следующие пять кодов операций сравнивают его с приемлемым номером системного вызова и, если он найден, выполняют переход к последнему коду операции, разрешающему системный вызов. В противном случае предпоследний код операции убивает процесс.

Обратите внимание, что хотя в документации указано, что sigreturn является разрешенным системным вызовом, фактическое имя системного вызова в Linux — rt_sigreturn. (sigreturn было объявлено устаревшим в пользу rt_sigreturn веков назад.)

Кроме того, при установке фильтра коды операций копируются в память ядра (см. kernel/seccomp.c в исходных кодах ядра Linux), поэтому он никак не повлияет на фильтр, если данные будут изменены позже. Другими словами, наличие структур static const не оказывает никакого влияния на безопасность.

Я использовал static, поскольку нет необходимости, чтобы символы были видны за пределами этой единицы компиляции (или в удаленном двоичном файле), и const, чтобы поместить данные в раздел данных только для чтения двоичного файла ELF.

Форма BPF_JUMP(BPF_JMP | BPF_JEQ, nr, equals, differs) проста: аккумулятор (номер системного вызова) сравнивается с nr. Если они равны, то следующие equals опкодов пропускаются. В противном случае следующие коды операций differs пропускаются.

Поскольку случаи равенства переходят к самому последнему коду операции, вы можете добавлять новые коды операций вверху (то есть сразу после начального кода операции), увеличивая счетчик пропусков равных для каждого из них.

Обратите внимание, что printf() не будет работать после установки фильтра seccomp, поскольку внутри библиотеки C требуется выполнить системный вызов fstat (на стандартный вывод) и системный вызов brk, чтобы выделить часть памяти для буфера.