Provided by: manpages-fr-dev_4.15.0-9_all 
NOM
seccomp – Agir sur l'état de calcul sécurisé (Secure Computing State) du processus
SYNOPSIS
#include <linux/seccomp.h> /* Definition of SECCOMP_* constants */
#include <linux/filter.h> /* Definition of struct sock_fprog */
#include <linux/audit.h> /* Definition of AUDIT_* constants */
#include <linux/signal.h> /* Definition of SIG* constants */
#include <sys/ptrace.h> /* Definition of PTRACE_* constants */
#include <sys/syscall.h> /* Definition of SYS_* constants */
#include <unistd.h>
int syscall(SYS_seccomp, unsigned int operation, unsigned int flags,
void *args);
Note: glibc provides no wrapper for seccomp(), necessitating the use of syscall(2).
DESCRIPTION
L'appel système seccomp() agit sur l'état de calcul sécurisé (seccomp) du processus
appelant.
Actuellement, Linux gère les valeurs d'operation suivantes :
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 termination of the calling thread, or termination of the entire
process with the SIGKILL signal when there is only one thread. 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.
Remarquez que si le thread appelant ne peut plus appeler sigprocmask(2), il peut
utiliser sigreturn(2) pour bloquer tous les signaux, sauf ceux provenant de SIGKILL
et de SIGSTOP. Cela veut dire que alarm(2) (par exemple) n'est pas suffisant pour
restreindre la durée d'exécution d'un processus. Pour terminer de manière fiable un
processus, SIGKILL doit être utilisé. On peut le faire en utilisant timer_create(2)
avec SIGEV_SIGNAL et sigev_signo positionné à SIGKILL ou en utilisant setrlimit(2)
pour positionner la limite ferme de RLIMIT_CPU.
Cette opération n'est disponible que si le noyau a été configuré avec
CONFIG_SECCOMP.
La valeur de flags doit être de 0 et args doit être NULL.
Cette opération est fonctionnellement identique à l'appel :
prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT);
SECCOMP_SET_MODE_FILTER
Les appels système autorisés sont définis par un pointeur vers un filtre Berkeley
Packet (BPF) fourni à l'aide de args. Ce paramètre est un pointeur vers une
struct sock_fprog ; il peut être conçu pour filtrer des appels système de votre
choix ainsi que des paramètres d'appel système. Si le filtre n'est pas valable,
seccomp() échoue en renvoyant EINVAL dans errno.
Si fork(2) ou clone(2) est autorisé par le filtre, les processus enfants seront
contraints par les mêmes filtres d'appel système que leur parent. Si execve(2) est
autorisé, les filtres existants seront préservés lors d'un appel à execve(2).
Pour utiliser l'opération SECCOMP_SET_MODE_FILTER, soit le thread appelant doit
avoir la capacité CAP_SYS_ADMIN dans son espace de noms utilisateur, soit il doit
avoir déjà le bit no_new_privs défini. Si ce bit n'a pas déjà été positionné par un
ascendant du thread, le thread doit effectuer l'appel suivant :
prctl(PR_SET_NO_NEW_PRIVS, 1);
Sinon, l'opération SECCOMP_SET_MODE_FILTER échoue et renvoie EACCES dans errno.
Cette exigence garantit qu'un processus non privilégié ne peut pas appliquer un
filtre malveillant et appeler un programme set-user-ID ou avec d'autres privilèges
en utilisant execve(2), compromettant ainsi le programme (un tel filtre malveillant
pourrait, par exemple, conduire setuid(2) à essayer de définir les identifiants
utilisateur de l'appelant à des valeurs non nulles pour renvoyer plutôt 0 sans
faire d'appel système. Ainsi, le programme pourrait être bidouillé pour garder les
privilèges du super-utilisateur à des moments où il est possible de l'influencer
pour faire des choses dangereuses vu qu'il n'a pas abandonné ses privilèges).
Si prctl(2) ou seccomp() est autorisé par le filtre rattaché, d'autres filtres
peuvent être ajoutés. Cela augmentera le temps d'évaluation mais permet d'autres
réductions de la surface d'attaque lors de l'exécution d'un thread.
L'opération SECCOMP_SET_MODE_FILTER n'est disponible que si le noyau a été
configuré avec CONFIG_SECCOMP_FILTER.
Quand flags vaut 0, cette opération est fonctionnellement identique à l'appel :
prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, args);
Les paramètres reconnus de flags sont :
SECCOMP_FILTER_FLAG_LOG (depuis Linux 4.14)
Toutes les actions de renvoi des filtres, sauf SECCOMP_RET_ALLOW, doivent
être journalisées. Un administrateur peut outrepasser cet attribut de filtre
en empêchant des actions spécifiques d'être journalisées à l'aide du fichier
/proc/sys/kernel/seccomp/actions_logged.
SECCOMP_FILTER_FLAG_NEW_LISTENER (since Linux 5.0)
After successfully installing the filter program, return a new user-space
notification file descriptor. (The close-on-exec flag is set for the file
descriptor.) When the filter returns SECCOMP_RET_USER_NOTIF a notification
will be sent to this file descriptor.
At most one seccomp filter using the SECCOMP_FILTER_FLAG_NEW_LISTENER flag
can be installed for a thread.
See seccomp_unotify(2) for further details.
SECCOMP_FILTER_FLAG_SPEC_ALLOW (depuis Linux 4.17)
Désactiver la mitigation Speculative Store Bypass.
SECCOMP_FILTER_FLAG_TSYNC
Lors de l'ajout d'un filtre, synchroniser tous les autres threads du
processus appelant sur la même arborescence de filtres seccomp. Une
« arborescence de filtres » est une liste ordonnée de filtres rattachés à un
thread (le rattachement de filtres identiques dans des appels seccomp()
distincts génère différents filtres depuis cette perspective).
Si un thread ne peut pas se synchroniser avec l'arborescence de filtres,
l'appel ne rattachera pas le nouveau filtre seccomp et échouera en renvoyant
le premier identifiant de thread qui n'a pas pu se synchroniser. La
synchronisation échouera si un autre thread du même processus est en
SECCOMP_MODE_STRICT ou si des filtres seccomp lui sont rattachés, en
décalage par rapport à l'arborescence de filtres du thread appelant.
SECCOMP_GET_ACTION_AVAIL (depuis Linux 4.14)
Tester pour savoir si une action est prise en charge par le noyau. Cette opération
peut aider à confirmer que le noyau connaît l'action de renvoi d'un filtre
récemment ajouté puisque le noyau traite toutes les actions inconnues comme des
SECCOMP_RET_KILL_PROCESS.
La valeur de flags doit être de 0 et args doit être un pointeur vers une action de
renvoi de filtre 32 bits non signé.
SECCOMP_GET_NOTIF_SIZES (since Linux 5.0)
Get the sizes of the seccomp user-space notification structures. Since these
structures may evolve and grow over time, this command can be used to determine how
much memory to allocate for sending and receiving notifications.
The value of flags must be 0, and args must be a pointer to a struct
seccomp_notif_sizes, which has the following form:
struct seccomp_notif_sizes
__u16 seccomp_notif; /* Size of notification structure */
__u16 seccomp_notif_resp; /* Size of response structure */
__u16 seccomp_data; /* Size of 'struct seccomp_data' */
};
See seccomp_unotify(2) for further details.
Filtres
Lors de l'ajout d'un filtre à l'aide de SECCOMP_SET_MODE_FILTER, args pointe vers un
programme de filtrage :
struct sock_fprog {
unsigned short len; /* Nombre d'instructions BPF */
struct sock_filter *filter; /* Pointeur vers le tableau
d'instructions BPF */
};
Chaque programme doit contenir une ou plusieurs instructions BPF :
struct sock_filter { /* Filter block */
__u16 code; /* Code du filtre réel */
__u8 jt; /* Jump true (sauter le vrai) */
__u8 jf; /* Jump false (sauter le faux) */
__u32 k; /* Champ générique multiusages */
};
Lors de l'exécution des instructions, le programme BPF agit sur les informations de
l'appel système qui sont rendues disponibles (c'est-à-dire qu'il utilise le mode
d'adressage BPF_ABS) en tant que tampon (en lecture seule) ayant la forme suivante :
struct seccomp_data {
int nr; /* Numéro de l'appel système */
__u32 arch; /* Valeur AUDIT_ARCH_*
(voir <linux/audit.h>) */
__u64 instruction_pointer; /* pointeur vers l'instruction du processeur */
__u64 args[6]; /* Jusqu'à 6 paramètres de l'appel système */
};
Comme la numérotation des appels système varie entre les architectures et comme certaines
(comme x86-64) autorisent du code de l'espace utilisateur à utiliser les conventions de
l'appelant d'autres architectures (et comme cette convention peut varier pendant la vie
d'un processus qui utilise execve(2) pour exécuter des binaires qui utilisent différentes
conventions), il est généralement nécessaire de vérifier la valeur du champ arch.
Il est fortement recommandé d'utiliser une approche par liste d'autorisations autant que
possible, parce qu'une telle approche est plus robuste et plus simple. Une liste
d'interdictions devra être mise à jour à chaque fois qu'un appel système dangereux sera
ajouté (ou un attribut ou une option si elles font partie de la liste des interdictions)
et il est souvent possible de modifier la représentation d'une valeur sans changer sa
signification, conduisant à contourner la liste d'interdictions. Voir aussi Mises en garde
ci-dessous.
Le champ arch n'est pas unique pour toutes les conventions d'appelant. Les ABI x86-64 et
x32 utilisent AUDIT_ARCH_X86_64 en tant que arch et elles fonctionnent sur les mêmes
processeurs. Au contraire, le masque __X32_SYSCALL_BIT est utilisé sur le numéro d'appel
système pour parler indépendamment aux deux ABI.
Cela veut dire qu'une politique peut soit interdire tous les appels système avec
__X32_SYSCALL_BIT, soit elle doit les reconnaître avec le positionnement ou pas de
__X32_SYSCALL_BIT. Une liste des appels système à interdire qui s'appuie sur nr et qui ne
contient pas de valeurs nr où __X32_SYSCALL_BIT est positionné peut être contournée par un
programme malveillant qui positionne __X32_SYSCALL_BIT.
En outre, les noyaux précédant Linux 5.4 autorisaient à tort nr dans les intervalles
512–547 ainsi que les appels système non x32 correspondants reliés (opération OU) avec
__X32_SYSCALL_BIT. Par exemple, nr == 521 et nr == (101 | __X32_SYSCALL_BIT) créeraient
des appels ptrace(2) avec une sémantique potentiellement confondue entre x32 et x86_64
dans le noyau. Les politiques prévues pour fonctionner sur des noyaux antérieurs à
Linux 5.4 doivent garantir qu'elles interdisent ou qu'elles gèrent correctement ces appels
système. Sur Linux 5.4 et plus récents, de tels appels système échoueront avec une erreur
ENOSYS sans rien faire.
Le champ instruction_pointer fournit l'adresse de l'instruction en langage machine qui a
effectué l'appel système. Cela pourrait être utile avec /proc/[pid]/maps pour effectuer
des vérifications à partir de la région (projection) du programme qui a fait l'appel
système (il est probablement raisonnable de verrouiller les appels système mmap(2) et
mprotect(2) pour empêcher le programme de contourner de telles vérifications).
Lors de la vérification des valeurs de args, gardez en tête que les paramètres sont
souvent tronqués silencieusement avant d'être traités mais après la vérification seccomp.
Cela arrive par exemple si l'ABI i386 est utilisée sur un noyau x86-64 : bien que le noyau
n'ira normalement pas regarder au-delà des 32 bits les plus faibles des paramètres, les
valeurs des registres 64 bits complets seront présentes dans les données de seccomp. Un
exemple moins surprenant est que si l'ABI x86-64 est utilisée pour effectuer un appel
système prenant un paramètre de type int, la moitié du registre du paramètre la plus
significative est ignorée par l'appel système mais visible dans les données de seccomp.
Un filtre seccomp renvoie une valeur 32 bits en deux parties : la plus significative, de
16 bits (correspondant au masque défini par la constante SECCOMP_RET_ACTION_FULL),
contient une des valeurs « action » listée ci-dessous ; la moins significative, de 16 bits
(définie par la constante SECCOMP_RET_DATA), contient des « data » à associer à ce code de
retour.
Si plusieurs filtres existent, ils sont tous exécutés dans l'ordre inverse de leur
apparition dans l'arbre des filtres – si bien que le filtre le plus récemment installé est
exécuté en premier) (remarquez que tous les filtres seront appelés même si l'un des
premiers appellés renvoie SECCOMP_RET_KILL. Cela pour simplifier le code du noyau et pour
fournir une petite accélération d’exécution d’ensembles de filtres en évitant la
vérification de ce cas particulier). La valeur renvoyée de l'évaluation d'un appel système
donné est la première valeur vue de l'action de plus haute priorité (ainsi que ses données
associées) renvoyée par l'exécution de tous les filtres.
Dans l'ordre décroissant de priorité, les valeurs d'action qui peuvent être renvoyées par
un filtre seccomp sont :
SECCOMP_RET_KILL_PROCESS (depuis Linux 4.14)
Cette valeur aboutit à la fin immédiate du processus, avec un vidage mémoire.
L'appel système n'est pas exécuté. Contrairement à SECCOMP_RET_KILL_THREAD
ci-dessous, tous les threads du groupe de threads sont terminés (pour un point sur
les groupes de thread, voir la description de l'attribut CLONE_THREAD de clone(2)).
Le processus se termine parce que il a été tué par un signal SIGSYS. Même si un
gestionnaire de signal a été enregistré pour SIGSYS, le gestionnaire sera ignoré
dans ce cas et le processus se termine toujours. Le processus parent qui attend ce
processus (en utilisant waitpid(2) ou équivalent) reçoit wstatus qui indique que
son enfant s'est terminé suite à un signal SIGSYS.
SECCOMP_RET_KILL_THREAD (ou SECCOMP_RET_KILL)
Cette valeur provoque la fin immédiate du thread qui a effectué l'appel système.
L'appel système n'est pas exécuté. Les autres threads du même groupe de threads
continueront à s'exécuter.
Le thread s'est terminé comme tué par un signal SIGSYS. Voir
SECCOMP_RET_KILL_PROCESS ci-dessus.
Avant Linux 4.11, tout processus qui se terminait de cette manière ne générait pas
de vidage mémoire (bien que SIGSYS soit documenté dans signal(7) pour avoir comme
action par défaut celle de terminer avec un vidage mémoire). Depuis Linux 4.11, un
processus d'un seul thread créera un vidage mémoire s'il se termine dans ce cadre.
Avec l'apparition de SECCOMP_RET_KILL_PROCESS dans Linux 4.14,
SECCOMP_RET_KILL_THREAD a été ajouté comme synonyme de SECCOMP_RET_KILL, afin de
distinguer plus clairement les deux actions.
Remarque : l'utilisation de SECCOMP_RET_KILL_THREAD pour tuer un thread unique d'un
processus de plusieurs threads va probablement mettre le processus dans un état
incohérent et corrompre pour toujours son état.
SECCOMP_RET_TRAP
Cette valeur fait envoyer par le noyau un signal SIGSYS adressé au thread
déclencheur (l'appel système n'est pas exécuté). Divers champs seront positionnés
dans la structure siginfo_t (voir sigaction(2)) associée au signal :
– si_signo contiendra SIGSYS.
– si_call_addr affichera l'adresse de l'instruction de l'appel système.
– si_syscall et si_arch indiqueront l'appel système qui a été essayé.
– si_code contiendra SYS_SECCOMP.
– si_errno contiendra la partie SECCOMP_RET_DATA du code de retour du filtre.
Le compteur du programme sera arrêté sitôt l'appel système fait (c'est-à-dire que
le compteur du programme ne pointera pas vers l'instruction de l'appel système). Le
registre du code de retour contiendra une valeur dépendante de l'architecture ; en
cas de relance de l'exécution, positionnez-la sur quelque chose adapté à l'appel
système (la dépendance de l'architecture provient du fait que son remplacement par
ENOSYS écraserait des informations utiles).
SECCOMP_RET_ERRNO
Cette valeur fait passer la partie SECCOMP_RET_DATA du code de retour du filtre à
l'espace utilisateur en tant que valeur errno sans exécuter l'appel système.
SECCOMP_RET_USER_NOTIF (since Linux 5.0)
Forward the system call to an attached user-space supervisor process to allow that
process to decide what to do with the system call. If there is no attached
supervisor (either because the filter was not installed with the
SECCOMP_FILTER_FLAG_NEW_LISTENER flag or because the file descriptor was closed),
the filter returns ENOSYS (similar to what happens when a filter returns
SECCOMP_RET_TRACE and there is no tracer). See seccomp_unotify(2) for further
details.
Note that the supervisor process will not be notified if another filter returns an
action value with a precedence greater than SECCOMP_RET_USER_NOTIF.
SECCOMP_RET_TRACE
Quand cette valeur est renvoyée, le noyau essaiera de notifier à un observateur
basé sur ptrace(2) avant d'exécuter l'appel système. Si aucun observateur n'est
présent, l'appel système n'est pas exécuté et renvoie un échec en positionnant
errno sur ENOSYS.
Un observateur sera notifié s'il demande PTRACE_O_TRACESECCOMP en utilisant
ptrace(PTRACE_SETOPTIONS). Il sera notifié d'un PTRACE_EVENT_SECCOMP et la partie
SECCOMP_RET_DATA du code de retour du filtre sera mise à la disposition de
l'observateur à l'aide de PTRACE_GETEVENTMSG.
L'observateur peut ignorer l'appel système en modifiant le numéro de l'appel
système à -1. Autrement, l'observateur peut modifier l'appel système demandé en le
passant à un numéro d'appel système valable. Si l'observateur demande à ignorer
l'appel système, ce dernier renverra la valeur que l'observateur place dans le
registre du code de retour.
Avant le noyau 4.8, la vérification seccomp ne sera pas refaite après que
l'observateur ait reçu une notification (cela signifie que sur les anciens noyaux,
les conteneurs basés sur seccomp ne doivent pas autoriser l'utilisation de
ptrace(2) – même sur d'autres processus encapsulés – sans une prudence extrême ;
les ptracers peuvent utiliser ce mécanisme pour sortir d'un conteneur seccomp).
Remarquez que le processus d'un observateur ne sera pas notifié si un autre filtre
renvoie une valeur d'action ayant une priorité supérieure à SECCOMP_RET_TRACE.
SECCOMP_RET_LOG (depuis Linux 4.14)
Cette valeur fait exécuter l'appel système après l'enregistrement de l'action de
retour du filtre. Un administrateur peut supplanter la journalisation de cette
action à l'aide du fichier /proc/sys/kernel/seccomp/actions_logged.
SECCOMP_RET_ALLOW
Cette valeur provoque l'exécution de l'appel système.
Si on indique un code d'action différent de ceux ci-dessus, l'action de filtre est traitée
soit comme un SECCOMP_RET_KILL_PROCESS (depuis Linux 4.14), soit comme un
SECCOMP_RET_KILL_THREAD (dans Linux 4.13 et antérieurs).
Interfaces /proc
Les fichiers du répertoire /proc/sys/kernel/seccomp offrent des informations et des
configurations seccomp supplémentaires :
actions_avail (depuis Linux 4.14)
Une liste ordonnée en lecture seule d'actions de renvoi de filtre seccomp sous la
forme d'une chaîne. L'ordre, de gauche à droite, est décroissant pour la priorité.
La liste représente l'ensemble des actions de renvoi de filtre seccomp gérées par
le noyau.
actions_logged (depuis Linux 4.14)
Une liste ordonnée en lecture-écriture d'actions de renvoi de filtre seccomp
autorisées pour la journalisation. Les écritures dans le fichier n'ont pas besoin
d'être ordonnées, mais les lectures se feront dans le même ordre que pour
actions_avail.
Il est important de remarquer que la valeur de actions_logged n'empêche pas
certaines actions de renvoi de filtre de s'enregistrer quand le sous-système
d'audit est configuré pour auditer une tâche. Si l'action n'est pas retrouvée dans
le fichier actions_logged, la décision finale d'auditer l'action de cette tâche
revient au sous-système d'audit pour toutes les actions de renvoi de filtre autres
que SECCOMP_RET_ALLOW.
La chaîne « allow » n'est pas acceptée dans le fichier actions_logged car il n'est
pas possible d'enregistrer les actions SECCOMP_RET_ALLOW. Essayer d'écrire
« allow » dans le fichier échouera avec l'erreur EINVAL.
Enregistrement d'audit des actions seccomp
Depuis Linux 4.14, le noyau offre la possibilité d'enregistrer les actions renvoyées par
des filtres seccomp dans le compte-rendu d'audit. Le noyau prend la décision d'enregistrer
une action à partir du type d'action, de sa présence dans le fichier actions_logged et de
l'activation de l'audit du noyau (par exemple avec l'option d'amorçage du noyau audit=1).
Les règles sont les suivantes :
– Si l'action est SECCOMP_RET_ALLOW, l'action n'est pas enregistrée.
– Sinon, si l'action est SECCOMP_RET_KILL_PROCESS ou SECCOMP_RET_KILL_THREAD et si elle
apparaît dans le fichier actions_logged, l'action est enregistrée.
– Sinon, si le filtre a demandé l'enregistrement (l'attribut SECCOMP_FILTER_FLAG_LOG) et
si elle apparaît dans le fichier actions_logged, l'action est enregistrée.
– Sinon, si l'audit du noyau est activé et si le processus doit être audité (autrace(8)),
l'action est enregistrée.
– Sinon, l'action n'est pas enregistrée.
VALEUR RENVOYÉE
En cas de succès, seccomp() renvoie 0. En cas d'erreur, si SECCOMP_FILTER_FLAG_TSYNC a été
utilisé, le code de retour est l'identifiant du thread à l'origine de l'échec de la
synchronisation (cet identifiant est un identifiant de thread du noyau du type renvoyé par
clone(2) et gettid(2)). Si une autre erreur arrive, -1 est renvoyé et errno est positionné
pour indiquer l'erreur.
ERREURS
seccomp() peut échouer pour les raisons suivantes :
EACCES L'appelant n'avait pas la capacité CAP_SYS_ADMIN dans son espace de noms
utilisateur ou n'avait pas positionné no_new_privs avant d'utiliser
SECCOMP_SET_MODE_FILTER.
EBUSY While installing a new filter, the SECCOMP_FILTER_FLAG_NEW_LISTENER flag was
specified, but a previous filter had already been installed with that flag.
EFAULT args n'était pas une adresse valable.
EINVAL L'operation est inconnue ou n'est pas prise en charge par cette version ou cette
configuration du noyau.
EINVAL Les flags spécifiés ne sont pas valables pour l'operation donnée.
EINVAL L'operation comprenait BPF_ABS, mais la position indiquée n'était pas alignée sur
une limite 32 bits ou elle dépassait sizeof(struct seccomp_data).
EINVAL Un mode de calcul sécurisé a déjà été défini et l'operation diffère du paramétrage
existant.
EINVAL operation indiquait SECCOMP_SET_MODE_FILTER mais le programme de filtre vers lequel
pointait args n'était pas valable ou sa longueur était de zéro ou dépassait
BPF_MAXINSNS instructions (4096).
ENOMEM Plus assez de mémoire.
ENOMEM La taille totale de tous les programmes de filtre rattachés au thread appelant
dépasserait MAX_INSNS_PER_PATH instructions (32768). Remarquez qu'afin de calculer
cette limite, chaque programme de filtre déjà existant intègre une pénalité de
dépassement de 4 instructions.
EOPNOTSUPP
operation indiquait SECCOMP_GET_ACTION_AVAIL mais le noyau ne gère pas l'action de
renvoi de filtre indiquée par args.
ESRCH Un autre thread a provoqué un échec pendant la synchronisation, mais son
identifiant n'a pas pu être déterminé.
VERSIONS
L'appel système seccomp() est apparu pour la première fois dans Linux 3.17.
CONFORMITÉ
L'appel système seccomp() est une extension Linux non standard.
NOTES
Au lieu de coder à la main des filtres seccomp comme démontré dans l'exemple ci-dessous,
vous pourriez préférer utiliser la bibliothèque libseccomp qui fournit une interface de
génération de filtres seccomp.
Le champ Seccomp du fichier /proc/[pid]/status offre une méthode de visualisation du mode
seccomp du processus ; voir proc(5).
seccomp() fournit un sur-ensemble de fonctionnalités de l'opération PR_SET_SECCOMP de
prctl(2) (qui ne prend pas en charge les flags).
Depuis Linux 4.4, l'opération PTRACE_SECCOMP_GET_FILTER de ptrace(2) peut être utilisée
pour obtenir un fichier des filtres seccomp d'un processus.
Gestion d'architecture pour le BPF seccomp
La gestion d'architecture pour le filtrage de BPF seccomp est disponible sur les
architectures suivantes :
– x86-64, i386, x32 (depuis Linux 3.5)
– ARM (depuis Linux 3.8)
– s390 (depuis Linux 3.8)
– MIPS (depuis Linux 3.16)
– ARM-64 (depuis Linux 3.19)
– PowerPC (depuis Linux 4.3)
– Tile (depuis Linux 4.3)
– PA-RISC (depuis Linux 4.6)
Mises en garde
Il y a beaucoup de subtilités à prendre en compte lorsqu'on applique des filtres seccomp à
un programme, notamment :
– Certains appels système traditionnels ont des implémentations dans l'espace utilisateur
dans le vdso(7) de nombreuses architectures. Parmi les exemples remarquables, se
trouvent clock_gettime(2), gettimeofday(2) et time(2). Sur de telles architectures, le
filtrage seccomp de ces appels système sera sans effet (il y a cependant des cas où les
implémentations vdso(7) se rabattent sur le véritable appel système, alors les filtres
seccomp verraient l'appel système).
– Le filtrage seccomp s'appuie sur les numéros d'appel système. Cependant, les
applications n'appellent généralement pas directement les appels système, mais plutôt
les fonctions enveloppe de la bibliothèque C qui appellent à leur tour les appels
système. Par conséquent, vous devez garder en tête ce qui suit :
• Les enveloppes de la glibc pour certains appels système traditionnels peuvent
utiliser des appels système ayant des noms différents dans le noyau. Par exemple, la
fonction enveloppe exit(2) utilise en fait l'appel système exit_group(2) et la
fonction fork(2) utilise en réalité les appels clone(2).
• Le comportement des fonctions enveloppe peut changer en fonction des architectures,
selon la plage d'appels système fournie sur ces architectures. Autrement dit, la
même fonction enveloppe peut appeler différents appels système selon les
architectures.
• Enfin, le comportement des fonctions enveloppe peut changer selon les versions de la
glibc. Par exemple, dans d'anciennes versions, la fonction enveloppe de la glibc de
open(2) appelait l'appel système du même nom, mais à partir de la 2.26,
l'implémentation est passée à l'appel openat(2) sur toutes les architectures.
La conséquence des points ci-dessus est qu'il pourrait être nécessaire de filtrer un appel
système autre que celui prévu. Plusieurs pages de manuel de la section 2 donnent des
détails utiles sur les différences entre les fonctions enveloppe et les appels système
sous-jacents dans les sous-sections intitulées Différences entre le noyau et la
bibliothèque C.
En outre, remarquez que l'application de filtres seccomp risque même de provoquer des
bogues dans une application, quand les filtres provoquent des échecs inattendus
d'opérations légitimes que l'application a besoin d'effectuer. De tels bogues pourraient
ne pas être facilement identifiés lors d'un test des filtres seccomp s'ils se produisent à
des endroits du code rarement utilisés.
Détails BPF spécifiques à seccomp
Remarquez que les détails BPF suivants sont spécifiques aux filtres seccomp :
– Les modificateurs de taille BPF_H et BPF_B ne sont pas pris en charge : toutes les
opérations doivent charger et stocker des mots (4 octets) (BPF_W).
– Pour accéder au contenu du tampon seccomp_data, utilisez le modificateur du mode
d'adressage BPF_ABS.
– Le modificateur du mode d'adressage BPF_LEN produit un opérande de mode immédiatement
dont la valeur est la taille du tampon seccomp_data.
EXEMPLES
Le programme ci-dessous accepte quatre paramètres ou plus. Les trois premiers sont un
numéro d'appel système, un identifiant numérique d'architecture et un numéro d'erreur. Le
programme utilise ces valeurs pour construire un filtre BPF utilisé lors de l'exécution
pour effectuer les vérifications suivantes :
[1] Si le programme ne tourne pas sur l'architecture indiquée, le filtre BPF fait échouer
les appels système avec l'erreur ENOSYS.
[2] Si le programme essaie d'exécuter l'appel système ayant le numéro indiqué, le filtre
BPF fait échouer l'appel système en positionnant errno sur le numéro d'erreur indiqué.
Les autres paramètres de la ligne de commande indiquent le chemin et les paramètres
supplémentaires d'un programme que notre exemple doit essayer d'exécuter en utilisant
execv(3) (une fonction de bibliothèque qui utilise l'appel système execve(2)). Certains
exemples d’exécution du programme sont présentées ci-dessous.
Tout d'abord, on affiche l'architecture sur laquelle on est (x86-64) puis on construit une
fonction d’interpréteur qui cherche les numéros d'appels système sur cette architecture :
$ uname -m
x86_64
$ syscall_nr() {
cat /usr/src/linux/arch/x86/syscalls/syscall_64.tbl | \
awk '$2 != "x32" && $3 == "'$1'" { print $1 }'
}
Quand le filtre BPF rejette un appel système (cas n° 2 ci-dessus), il fait échouer l'appel
système avec le numéro d'erreur indiqué sur la ligne de commande. Dans les exemples
présentés ici, nous utiliserons le numéro d'erreur 99 :
$ errno 99
EADDRNOTAVAIL 99 Ne peut pas affecter l'adresse demandée
Dans l'exemple suivant, on essaie d'exécuter la commande whoami(1), mais le filtre BPF
rejette l'appel système execve(2), donc la commande n'est même pas exécutée :
$ syscall_nr execve
59
$ ./a.out
Utilisation : ./a.out <syscall_nr> <arch> <errno> <prog> [<args>]
Astuce pour <arch> : AUDIT_ARCH_I386: 0x40000003
AUDIT_ARCH_X86_64 : 0xC000003E
$ ./a.out 59 0xC000003E 99 /bin/whoami
execv : Ne peut pas affecter l'adresse demandée
Dans le prochain exemple, le filtre BPF rejette l'appel système write(2) pour que, même si
elle a pu démarrer, la commande whoami(1) ne puisse pas écrire de sortie :
$ syscall_nr write
1
$ ./a.out 1 0xC000003E 99 /bin/whoami
Dans le dernier exemple, le filtre BPF rejette un appel système qui n'est pas utilisé par
la commande whoami(1), elle peut donc s'exécuter et produire une sortie :
$ syscall_nr preadv
295
$ ./a.out 295 0xC000003E 99 /bin/whoami
cecilia
Source du programme
#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>
#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)
{
unsigned int upper_nr_limit = 0xffffffff;
/* On suppose que AUDIT_ARCH_X86_64 renvoie à l'ABI x86-64 normale
(dans l'ABI x32, tous les appels système ont le bit 30 positionné
dans le champ 'nr', donc les numéros sont >= X32_SYSCALL_BIT). */
if (t_arch == AUDIT_ARCH_X86_64)
upper_nr_limit = X32_SYSCALL_BIT - 1;
struct sock_filter filter[] = {
/* [0] Charger l'architecture depuis le tampon 'seccomp_data'
dans l'accumulateur. */
BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
(offsetof(struct seccomp_data, arch))),
/* [1] Revenir en arrière de 5 instructions si l'architecture
ne correspond pas à 't_arch'. */
BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, t_arch, 0, 5),
/* [2] Charger le numéro d'appel système depuis le tampon
'seccomp_data' dans l'accumulateur. */
BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
(offsetof(struct seccomp_data, nr))),
/* [3] Vérifier l'ABI - nécessaire seulement pour x86-64 si on
utilise une liste d'interdictions. Utiliser BPF_JGT au lieu de
vérifier par rapport au masque de bits pour ne pas devoir
recharger le numéro d'appel système. */
BPF_JUMP(BPF_JMP | BPF_JGT | BPF_K, upper_nr_limit, 3, 0),
/* [4] Reculer d'une instruction si le numéro d'appel système
ne correspond pas à 'syscall_nr'. */
BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, syscall_nr, 0, 1),
/* [5] Architecture et appel système correspondants : ne pas
exécuter l'appel système et renvoyer 'f_errno' dans
'errno'. */
BPF_STMT(BPF_RET | BPF_K,
SECCOMP_RET_ERRNO | (f_errno & SECCOMP_RET_DATA)),
/* [6] Cible du numéro d’appel système inadéquate :
autoriser d'autres appels système. */
BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
/* [7] Cible de l’architecture inadéquate : tuer le processus. */
BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_KILL_PROCESS),
};
struct sock_fprog prog = {
.len = ARRAY_SIZE(filter),
.filter = filter,
};
if (seccomp(SECCOMP_SET_MODE_FILTER, 0, &prog)) {
perror("seccomp");
return 1;
}
return 0;
}
int
main(int argc, char *argv[])
{
if (argc < 5) {
fprintf(stderr, "Usage: "
"%s <syscall_nr> <arch> <errno> <prog> [<args>]\n"
"Hint for <arch>: AUDIT_ARCH_I386: 0x%X\n"
" AUDIT_ARCH_X86_64: 0x%X\n"
"\n", argv[0], AUDIT_ARCH_I386, AUDIT_ARCH_X86_64);
exit(EXIT_FAILURE);
}
if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0)) {
perror("prctl");
exit(EXIT_FAILURE);
}
if (install_filter(strtol(argv[1], NULL, 0),
strtol(argv[2], NULL, 0),
strtol(argv[3], NULL, 0)))
exit(EXIT_FAILURE);
execv(argv[4], &argv[4]);
perror("execv");
exit(EXIT_FAILURE);
}
VOIR AUSSI
bpfc(1), strace(1), bpf(2), prctl(2), ptrace(2), seccomp_unotify(2), sigaction(2),
proc(5), signal(7), socket(7)
Plusieurs pages de la bibliothèque libseccomp, dont : scmp_sys_resolver(1),
seccomp_export_bpf(3), seccomp_init(3), seccomp_load(3) et seccomp_rule_add(3).
Les fichiers Documentation/networking/filter.txt et
Documentation/userspace-api/seccomp_filter.rst des sources du noyau (ou
Documentation/prctl/seccomp_filter.txt avant Linux 4.13).
McCanne, S. et Jacobson, V. (1992) The BSD Packet Filter : une nouvelle architecture de
captation de paquets au niveau utilisateur, colloque de la conférence USENIX à l'hiver
1993 ⟨http://www.tcpdump.org/papers/bpf-usenix93.pdf⟩
COLOPHON
Cette page fait partie de la publication 5.13 du projet man-pages Linux. Une description
du projet et des instructions pour signaler des anomalies et la dernière version de cette
page peuvent être trouvées à l'adresse https://www.kernel.org/doc/man-pages/.
TRADUCTION
La traduction française de cette page de manuel a été créée par Christophe Blaess
<https://www.blaess.fr/christophe/>, Stéphan Rafin <stephan.rafin@laposte.net>, Thierry
Vignaud <tvignaud@mandriva.com>, François Micaux, Alain Portal <aportal@univ-montp2.fr>,
Jean-Philippe Guérard <fevrier@tigreraye.org>, Jean-Luc Coulon (f5ibh) <jean-
luc.coulon@wanadoo.fr>, Julien Cristau <jcristau@debian.org>, Thomas Huriaux
<thomas.huriaux@gmail.com>, Nicolas François <nicolas.francois@centraliens.net>, Florentin
Duneau <fduneau@gmail.com>, Simon Paillard <simon.paillard@resel.enst-bretagne.fr>, Denis
Barbier <barbier@debian.org>, David Prévot <david@tilapin.org> et Jean-Philippe MENGUAL
<jpmengual@debian.org>
Cette traduction est une documentation libre ; veuillez vous reporter à la GNU General
Public License version 3 ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩ concernant les
conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.
Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un
message à ⟨debian-l10n-french@lists.debian.org⟩.