seccomp (2) - Linux Manuals
seccomp: operate on Secure Computing state of the process
NAME
seccomp - operate on Secure Computing state of the process
SYNOPSIS
#include <linux/seccomp.h> #include <linux/filter.h> #include <linux/audit.h> #include <linux/signal.h> #include <sys/ptrace.h> int seccomp(unsigned int operation, unsigned int flags, void *args);
DESCRIPTION
The seccomp() system call operates on the Secure Computing (seccomp) state of the calling process.Currently, Linux supports the following operation values:
- SECCOMP_SET_MODE_STRICT
- The only system calls that the calling thread is permitted to make are read(2), write(2), _exit(2) (but not exit_group(2)), and sigreturn(2). Other system calls result in the delivery of a SIGKILL signal. Strict secure computing mode is useful for number-crunching applications that may need to execute untrusted byte code, perhaps obtained by reading from a pipe or socket.
- Note that although the calling thread can no longer call sigprocmask(2), it can use sigreturn(2) to block all signals apart from SIGKILL and SIGSTOP. This means that alarm(2) (for example) is not sufficient for restricting the process's execution time. Instead, to reliably terminate the process, SIGKILL must be used. This can be done by using timer_create(2) with SIGEV_SIGNAL and sigev_signo set to SIGKILL, or by using setrlimit(2) to set the hard limit for RLIMIT_CPU.
- This operation is available only if the kernel is configured with CONFIG_SECCOMP enabled.
- The value of flags must be 0, and args must be NULL.
- This operation is functionally identical to the call:
- prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT);
- SECCOMP_SET_MODE_FILTER
- The system calls allowed are defined by a pointer to a Berkeley Packet Filter (BPF) passed via args. This argument is a pointer to a struct sock_fprog; it can be designed to filter arbitrary system calls and system call arguments. If the filter is invalid, seccomp() fails, returning EINVAL in errno.
- If fork(2) or clone(2) is allowed by the filter, any child processes will be constrained to the same system call filters as the parent. If execve(2) is allowed, the existing filters will be preserved across a call to execve(2).
- In order to use the SECCOMP_SET_MODE_FILTER operation, either the calling thread must have the CAP_SYS_ADMIN capability in its user namespace, or the thread must already have the no_new_privs bit set. If that bit was not already set by an ancestor of this thread, the thread must make the following call:
- prctl(PR_SET_NO_NEW_PRIVS, 1);
- Otherwise, the SECCOMP_SET_MODE_FILTER operation fails and returns EACCES in errno. This requirement ensures that an unprivileged process cannot apply a malicious filter and then invoke a set-user-ID or other privileged program using execve(2), thus potentially compromising that program. (Such a malicious filter might, for example, cause an attempt to use setuid(2) to set the caller's user IDs to nonzero values to instead return 0 without actually making the system call. Thus, the program might be tricked into retaining superuser privileges in circumstances where it is possible to influence it to do dangerous things because it did not actually drop privileges.)
- If prctl(2) or seccomp() is allowed by the attached filter, further filters may be added. This will increase evaluation time, but allows for further reduction of the attack surface during execution of a thread.
- The SECCOMP_SET_MODE_FILTER operation is available only if the kernel is configured with CONFIG_SECCOMP_FILTER enabled.
- When flags is 0, this operation is functionally identical to the call:
- prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, args);
-
The recognized
flags
are:
-
- SECCOMP_FILTER_FLAG_TSYNC
- When adding a new filter, synchronize all other threads of the calling process to the same seccomp filter tree. A "filter tree" is the ordered list of filters attached to a thread. (Attaching identical filters in separate seccomp() calls results in different filters from this perspective.)
- If any thread cannot synchronize to the same filter tree, the call will not attach the new seccomp filter, and will fail, returning the first thread ID found that cannot synchronize. Synchronization will fail if another thread in the same process is in SECCOMP_MODE_STRICT or if it has attached new seccomp filters to itself, diverging from the calling thread's filter tree.
- SECCOMP_FILTER_FLAG_LOG (since Linux 4.14)
- All filter return actions except SECCOMP_RET_ALLOW should be logged. An administrator may override this filter flag by preventing specific actions from being logged via the /proc/sys/kernel/seccomp/actions_logged file.
- SECCOMP_FILTER_FLAG_SPEC_ALLOW (since Linux 4.17)
- Disable Speculative Store Bypass mitigation.
-
- SECCOMP_GET_ACTION_AVAIL (since Linux 4.14)
- Test to see if an action is supported by the kernel. This operation is helpful to confirm that the kernel knows of a more recently added filter return action since the kernel treats all unknown actions as SECCOMP_RET_KILL_PROCESS.
- The value of flags must be 0, and args must be a pointer to an unsigned 32-bit filter return action.
Filters
When adding filters via SECCOMP_SET_MODE_FILTER, args points to a filter program:
struct sock_fprog {
Each program must contain one or more BPF instructions:
struct sock_filter { /* Filter block */
When executing the instructions, the BPF program operates on the
system call information made available (i.e., use the
BPF_ABS
addressing mode) as a (read-only)
buffer of the following form:
struct seccomp_data {
Because numbering of system calls varies between architectures and
some architectures (e.g., x86-64) allow user-space code to use
the calling conventions of multiple architectures
(and the convention being used may vary over the life of a process that uses
execve(2)
to execute binaries that employ the different conventions),
it is usually necessary to verify the value of the
arch
field.
It is strongly recommended to use an allow-list approach whenever
possible because such an approach is more robust and simple.
A deny-list will have to be updated whenever a potentially
dangerous system call is added (or a dangerous flag or option if those
are deny-listed), and it is often possible to alter the
representation of a value without altering its meaning, leading to
a deny-list bypass.
See also
Caveats
below.
The
arch
field is not unique for all calling conventions.
The x86-64 ABI and the x32 ABI both use
AUDIT_ARCH_X86_64
as
arch,
and they run on the same processors.
Instead, the mask
__X32_SYSCALL_BIT
is used on the system call number to tell the two ABIs apart.
This means that a policy must either deny all syscalls with
__X32_SYSCALL_BIT
or it must recognize syscalls with and without
__X32_SYSCALL_BIT
set.
A list of system calls to be denied based on
nr
that does not also contain
nr
values with
__X32_SYSCALL_BIT
set can be bypassed by a malicious program that sets
__X32_SYSCALL_BIT.
Additionally, kernels prior to Linux 5.4 incorrectly permitted
nr
in the ranges 512-547 as well as the corresponding non-x32 syscalls ORed
with
__X32_SYSCALL_BIT.
For example,
nr
== 521 and
nr
== (101 |
__X32_SYSCALL_BIT)
would result in invocations of
ptrace(2)
with potentially confused x32-vs-x86_64 semantics in the kernel.
Policies intended to work on kernels before Linux 5.4 must ensure that they
deny or otherwise correctly handle these system calls.
On Linux 5.4 and newer,
such system calls will fail with the error
ENOSYS,
without doing anything.
The
instruction_pointer
field provides the address of the machine-language instruction that
performed the system call.
This might be useful in conjunction with the use of
/proc/[pid]/maps
to perform checks based on which region (mapping) of the program
made the system call.
(Probably, it is wise to lock down the
mmap(2)
and
mprotect(2)
system calls to prevent the program from subverting such checks.)
When checking values from
args,
keep in mind that arguments are often
silently truncated before being processed, but after the seccomp check.
For example, this happens if the i386 ABI is used on an
x86-64 kernel: although the kernel will normally not look beyond
the 32 lowest bits of the arguments, the values of the full
64-bit registers will be present in the seccomp data.
A less surprising example is that if the x86-64 ABI is used to perform
a system call that takes an argument of type
int,
the more-significant half of the argument register is ignored by
the system call, but visible in the seccomp data.
A seccomp filter returns a 32-bit value consisting of two parts:
the most significant 16 bits
(corresponding to the mask defined by the constant
SECCOMP_RET_ACTION_FULL)
contain one of the "action" values listed below;
the least significant 16-bits (defined by the constant
SECCOMP_RET_DATA)
are "data" to be associated with this return value.
If multiple filters exist, they are all executed,
in reverse order of their addition to the filter tree---that is,
the most recently installed filter is executed first.
(Note that all filters will be called
even if one of the earlier filters returns
SECCOMP_RET_KILL.
This is done to simplify the kernel code and to provide a
tiny speed-up in the execution of sets of filters by
avoiding a check for this uncommon case.)
The return value for the evaluation of a given system call is the first-seen
action value of highest precedence (along with its accompanying data)
returned by execution of all of the filters.
In decreasing order of precedence,
the action values that may be returned by a seccomp filter are:
If an action value other than one of the above is specified,
then the filter action is treated as either
SECCOMP_RET_KILL_PROCESS
(since Linux 4.14)
or
SECCOMP_RET_KILL_THREAD
(in Linux 4.13 and earlier).
The
Seccomp
field of the
/proc/[pid]/status
file provides a method of viewing the seccomp mode of a process; see
proc(5).
seccomp()
provides a superset of the functionality provided by the
prctl(2)
PR_SET_SECCOMP
operation (which does not support
flags).
Since Linux 4.4, the
ptrace(2)
PTRACE_SECCOMP_GET_FILTER
operation can be used to dump a process's seccomp filters.
The consequence of the above points is that it may be necessary
to filter for a system call other than might be expected.
Various manual pages in Section 2 provide helpful details
about the differences between wrapper functions and
the underlying system calls in subsections entitled
C library/kernel differences.
Furthermore, note that the application of seccomp filters
even risks causing bugs in an application,
when the filters cause unexpected failures for legitimate operations
that the application might need to perform.
Such bugs may not easily be discovered when testing the seccomp
filters if the bugs occur in rarely used application code paths.
The remaining command-line arguments specify
the pathname and additional arguments of a program
that the example program should attempt to execute using
execv(3)
(a library function that employs the
execve(2)
system call).
Some example runs of the program are shown below.
First, we display the architecture that we are running on (x86-64)
and then construct a shell function that looks up system call
numbers on this architecture:
$ uname -m
x86_64
$ syscall_nr() {
When the BPF filter rejects a system call (case [2] above),
it causes the system call to fail with the error number
specified on the command line.
In the experiments shown here, we'll use error number 99:
$ errno 99
EADDRNOTAVAIL 99 Cannot assign requested address
In the following example, we attempt to run the command
whoami(1),
but the BPF filter rejects the
execve(2)
system call, so that the command is not even executed:
$ syscall_nr execve
59
$ ./a.out
Usage: ./a.out <syscall_nr> <arch> <errno> <prog> [<args>]
Hint for <arch>: AUDIT_ARCH_I386: 0x40000003
In the next example, the BPF filter rejects the
write(2)
system call, so that, although it is successfully started, the
whoami(1)
command is not able to write output:
$ syscall_nr write
1
$ ./a.out 1 0xC000003E 99 /bin/whoami
In the final example,
the BPF filter rejects a system call that is not used by the
whoami(1)
command, so it is able to successfully execute and produce output:
$ syscall_nr preadv
295
$ ./a.out 295 0xC000003E 99 /bin/whoami
cecilia
#define X32_SYSCALL_BIT 0x40000000
#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
static int
install_filter(int syscall_nr, int t_arch, int f_errno)
{
/proc interfaces
The files in the directory
/proc/sys/kernel/seccomp
provide additional seccomp information and configuration:
Audit logging of seccomp actions
Since Linux 4.14, the kernel provides the facility to log the
actions returned by seccomp filters in the audit log.
The kernel makes the decision to log an action based on
the action type, whether or not the action is present in the
actions_logged
file, and whether kernel auditing is enabled
(e.g., via the kernel boot option
audit=1).
The rules are as follows:
RETURN VALUE
On success,
seccomp()
returns 0.
On error, if
SECCOMP_FILTER_FLAG_TSYNC
was used,
the return value is the ID of the thread
that caused the synchronization failure.
(This ID is a kernel thread ID of the type returned by
clone(2)
and
gettid(2).)
On other errors, -1 is returned, and
errno
is set to indicate the cause of the error.
ERRORS
seccomp()
can fail for the following reasons:
VERSIONS
The
seccomp()
system call first appeared in Linux 3.17.
CONFORMING TO
The
seccomp()
system call is a nonstandard Linux extension.
NOTES
Rather than hand-coding seccomp filters as shown in the example below,
you may prefer to employ the
libseccomp
library, which provides a front-end for generating seccomp filters.
Architecture support for seccomp BPF
Architecture support for seccomp BPF filtering
is available on the following architectures:
Caveats
There are various subtleties to consider when applying seccomp filters
to a program, including the following:
Seccomp-specific BPF details
Note the following BPF details specific to seccomp filters:
EXAMPLES
The program below accepts four or more arguments.
The first three arguments are a system call number,
a numeric architecture identifier, and an error number.
The program uses these values to construct a BPF filter
that is used at run time to perform the following checks:
Program source
#include <errno.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <linux/audit.h>
#include <linux/filter.h>
#include <linux/seccomp.h>
#include <sys/prctl.h>