Provided by: manpages-fr-dev_4.21.0-2_all 
NOM
ptrace - Suivre un processus
BIBLIOTHÈQUE
Bibliothèque C standard (libc, -lc)
SYNOPSIS
#include <sys/ptrace.h>
long ptrace(enum __ptrace_request request, pid_t pid,
void *addr, void *data);
DESCRIPTION
L'appel système ptrace() fournit à un processus (l'« observateur ») un moyen d'observer et
de contrôler l'exécution d'un autre processus (l'« observé »), et d'examiner et éditer la
mémoire et les registres de l'observé. L'utilisation principale de cette fonction est
l'implémentation de points d'arrêt pour le débogage, et pour suivre les appels système.
Un observé doit d'abord être attaché à l'observateur. L'attachement et les commandes
suivantes sont par thread : dans un processus multithreadé, chaque thread peut être
attaché individuellement à un observateur (éventuellement différent), ou être laissé
détaché et donc non débogué. Par conséquent, l'« observé » signifie toujours « (un)
thread », jamais « un processus (éventuellement multithreadé) ». Les commandes ptrace sont
toujours envoyées à un observé spécifique en utilisant un appel de la forme
ptrace(PTRACE_truc, pid, ...)
où pid est l'identifiant de thread du thread Linux correspondant.
(Remarquez que dans cette page, un « processus multithreadé » signifie un groupe de
threads constitué de threads créés en utilisant l'attribut CLONE_THREAD de clone(2).)
Un processus peut démarrer un suivi en appelant fork(2) et faire en sorte que l'enfant
créé fasse un PTRACE_TRACEME, suivi (en général) par un execve(2). Autrement, un processus
peut commencer à suivre un autre processus en utilisant PTRACE_ATTACH ou PTRACE_SEIZE.
L'observé s'arrêtera à chaque fois qu'un signal lui sera distribué, même si le signal est
ignoré (à l'exception de SIGKILL qui a les effets habituels). L'observateur sera prévenu à
son prochain appel de waitpid(2) (ou un des appels système liés à « wait ») ; cet appel
renverra une valeur status contenant les renseignements indiquant la raison de l'arrêt de
l'observé. Lorsque l'observé est arrêté, l'observateur peut utiliser plusieurs requêtes
ptrace pour inspecter et modifier l'observé. L'observateur peut également laisser
continuer l'exécution de l'observé, en ignorant éventuellement le signal ayant déclenché
l'arrêt, ou même en envoyant un autre signal.
Si l'option PTRACE_O_TRACEEXEC n'est pas effective, tous les appels réussis d'execve(2)
par le processus suivi déclencheront l'envoi d'un signal SIGTRAP, ce qui permet au parent
de reprendre le contrôle avant que le nouveau programme commence son exécution.
Quand l'observateur a fini le suivi, il peut forcer l'observé à continuer normalement, en
mode non suivi, avec PTRACE_DETACH.
La valeur de l'argument request indique précisément l'action à entreprendre.
PTRACE_TRACEME
Le processus en cours va être suivi par son parent. Un processus ne devrait sans
doute pas envoyer cette requête si son parent n'est pas prêt à le suivre. Dans
cette requête pid, addr, et data sont ignorés.
La requête PTRACE_TRACEME ne sert qu'à l'observé. Les requêtes restantes ne servent
qu'à l'observateur. Par la suite, pid précise l'identifiant de thread de l'observé
sur lequel agir. Pour d'autres requêtes que PTRACE_ATTACH, PTRACE_SEIZE,
PTRACE_INTERRUPT et PTRACE_KILL, l'observé doit être arrêté.
PTRACE_PEEKTEXT, PTRACE_PEEKDATA
Lire un mot à l'adresse addr dans l'espace mémoire de l'observé et le renvoyer en
résultat de l'appel ptrace(). Linux ne sépare pas les espaces d'adressage de code
et de données, donc ces deux requêtes sont équivalentes (data est ignoré, consultez
la section NOTES).
PTRACE_PEEKUSER
Lire un mot à la position addr dans l'espace USER de l'observé, qui contient les
registres et divers renseignements sur le processus (voir <sys/user.h>). Le mot est
renvoyée en résultat de ptrace(). En principe, l'adresse doit être alignée sur une
frontière de mots, bien que cela varie selon les architectures. Consultez la
section NOTES. (data est ignoré, consultez la section NOTES).
PTRACE_POKETEXT, PTRACE_POKEDATA
Copier le mot data vers l'adresse addr de la mémoire de l'observé. Comme pour
PTRACE_PEEKTEXT et PTRACE_PEEKDATA, ces deux requêtes sont équivalentes.
PTRACE_POKEUSER
Copier le mot data vers l'adresse addr dans l'espace USER de l'observé. Comme pour
PTRACE_PEEKUSER, les emplacements doivent être alignés sur une frontière de mot.
Pour maintenir l'intégrité du noyau, certaines modifications de la zone USER sont
interdites.
PTRACE_GETREGS, PTRACE_GETFPREGS
Copier les registres généraux ou du processeur en virgule flottante de l'observé,
vers l'adresse data de l'observateur. Consultez <sys/user.h> pour les détails sur
le format de ces données (addr est ignoré). Remarquez que les systèmes SPARC ont la
signification de data et addr inversée, c'est-à-dire que data est ignoré et les
registres sont copiés vers l'adresse addr. PTRACE_GETREGS et PTRACE_GETFPREGS ne
sont pas présents sur toutes les architectures.
PTRACE_GETREGSET (depuis Linux 2.6.34)
Lire les registres de l'observé. addr indique, de manière dépendante de
l'architecture, le type de registres à lire. NT_PRSTATUS (avec une valeur numérique
de 1) a pour conséquence habituelle la lecture de registres généraux. Si le
processeur a, par exemple, des registres en virgule flottante ou en vecteur, ils
peuvent être récupéré en configurant addr à la constante NT_foo correspondante.
data pointe vers une struct iovec, qui décrit l'emplacement et la taille du tampon
de destination. Le noyau modifie iov.len au retour pour indiquer le véritable
nombre d'octets renvoyés.
PTRACE_SETREGS, PTRACE_SETFPREGS
Modifier les registres généraux ou du processeur en virgule flottante de l'observé,
depuis l'adresse data de l'observateur. Comme pour PTRACE_POKEUSER, certaines
modifications de registres généraux pourraient être interdites (addr est ignoré).
Remarquez que les systèmes SPARC ont la signification de data et addr inversée,
c'est-à-dire que data est ignoré et les registres sont copiés depuis l'adresse
addr. PTRACE_SETREGS et PTRACE_SETFPREGS ne sont pas présents sur toutes les
architectures.
PTRACE_SETREGSET (depuis Linux 2.6.34)
Modifier les registres de l'observé. La signification de addr et data est analogue
à PTRACE_GETREGSET.
PTRACE_GETSIGINFO (depuis Linux 2.3.99-pre6)
Récupérer des renseignements sur le signal qui a provoqué l'arrêt. Pour ce faire,
copier une structure siginfo_t (consultez sigaction(2)) de l'observé à l'adresse
data de l'observateur (addr est ignoré).
PTRACE_SETSIGINFO (depuis Linux 2.3.99-pre6)
Définir les renseignements de signaux : copier une structure siginfo_t de l'adresse
data de l'observateur vers l'observé. Cela n'affecte que les signaux qui auraient
dû être distribués à l'observé et ont été interceptés à cause de ptrace().
Différencier ces signaux normaux des signaux créés par ptrace() lui-même peut être
délicat (addr est ignoré).
PTRACE_PEEKSIGINFO (depuis Linux 3.10)
Récupérer les structures siginfo_t sans supprimer les signaux d’une file d’attente.
addr pointe vers une structure ptrace_peeksiginfo_args qui indique la position
ordinale à partir de laquelle la copie des signaux devrait commencer et le nombre
de signaux à copier. Les structures siginfo_t sont copiées dans le tampon pointé
par data. La valeur de retour contient le nombre de signaux copiés (zéro indique
qu’il n’y a pas de signal correspondant à la position ordinale indiquée). Dans les
structures siginfo renvoyées, le champ si_code contient des renseignements
(__SI_CHLD, __SI_FAULT, etc.) qui sinon ne sont pas exposés à l’espace utilisateur.
struct ptrace_peeksiginfo_args {
u64 off; /* Position ordinale dans la file d’attente
où commencer la copie de signaux */
u32 flags; /* PTRACE_PEEKSIGINFO_SHARED ou 0 */
s32 nr; /* Nombre de signaux à copier */
};
Actuellement, seul l’attribut PTRACE_PEEKSIGINFO_SHARED permet de vider les signaux
de la file de signaux par processus. Si cet attribut n’est pas défini, les signaux
sont lus depuis la file par thread du thread indiqué.
PTRACE_GETSIGMASK (depuis Linux 3.11)
Placer une copie du masque des signaux bloqués (consultez sigprocmask(2)) dans le
tampon pointé par data qui devrait être un pointeur vers un tampon de type
sigset_t. L’argument addr contient la taille du tampon pointé par data
(c’est-à-dire sizeof(sigset_t)).
PTRACE_SETSIGMASK (depuis Linux 3.11)
Modifier le masque des signaux bloqués (consultez sigprocmask(2)) à la valeur
indiquée dans le tampon pointé par data qui devrait être un pointeur vers un tampon
de type sigset_t. L’argument addr contient la taille du tampon pointé par data
(c’est-à-dire sizeof(sigset_t)).
PTRACE_SETOPTIONS (depuis Linux 2.4.6, consultez les remarques de BOGUES)
Définir les options de ptrace à partir de l'adresse data (addr est ignoré). data
est interprété comme un masque d'options, qui est construit à partir des attributs
suivants.
PTRACE_O_EXITKILL (depuis Linux 3.8)
Envoyer un signal SIGKILL à l'observé si l'observateur existe. Cet option
est utile pour les gardiens ptrace qui veulent s'assurer que les observés ne
peuvent jamais échapper au contrôle de l'observateur.
PTRACE_O_TRACECLONE (depuis Linux 2.5.46)
Arrêter l'observé au prochain clone(2) et commencer automatiquement à suivre
le nouveau processus cloné, qui démarrera avec un signal SIGSTOP, ou
PTRACE_EVENT_STOP si PTRACE_SEIZE est utilisé. Un waitpid(2) par
l'observateur renverra une valeur status comme
status>>8 == (SIGTRAP | (PTRACE_EVENT_CLONE<<8))
Le PID du nouveau processus peut être récupéré avec PTRACE_GETEVENTMSG.
Cette option peut ne pas intercepter tous les appels clone(2). Si l'observé
appelle clone(2) avec l'attribut CLONE_VFORK, PTRACE_EVENT_VFORK sera envoyé
si PTRACE_O_TRACEVFORK est utilisé. Sinon, si l'observé appelle clone(2)
avec SIGCHLD comme signal de terminaison, PTRACE_EVENT_FORK sera envoyé si
PTRACE_O_TRACEFORK est utilisé.
PTRACE_O_TRACEEXEC (depuis Linux 2.5.46)
Arrêter l'observé au prochain execve(2). Un waitpid(2) par l'observateur
renverra une valeur status comme
status>>8 == (SIGTRAP | (PTRACE_EVENT_EXEC<<8))
Si le thread en cours d'exécution n'est pas un leader de groupe de threads,
l'identifiant de thread est réinitialisé à l'identifiant du leader de groupe
de threads avant cet arrêt. Depuis Linux 3.0, le premier identifiant de
thread peut être récupéré avec PTRACE_GETEVENTMSG.
PTRACE_O_TRACEEXIT (depuis Linux 2.5.60)
Arrêter l'observé à la terminaison. Un waitpid(2) par l'observateur renverra
une valeur status comme
status>>8 == (SIGTRAP | (PTRACE_EVENT_EXIT<<8))
L'état de fin de l'observé peut être récupéré avec PTRACE_GETEVENTMSG.
L'observé est arrêté tôt dans la terminaison du processus, alors que les
registres sont toujours disponibles, ce qui permet au processus utilisant
ptrace() de voir où la terminaison s'est produite, alors que la notification
de terminaison normale a lieu à la fin de cette terminaison. Même si le
contexte est disponible, l'observateur ne peut pas empêcher la terminaison à
ce moment là.
PTRACE_O_TRACEFORK (depuis Linux 2.5.46)
Arrêter l'observé au prochain fork(2) et commencer automatiquement à suivre
le nouveau processus créé, qui démarrera avec un signal SIGSTOP, ou
PTRACE_EVENT_STOP si PTRACE_SEIZE est utilisé. Un waitpid(2) par
l'observateur renverra une valeur status comme
status>>8 == (SIGTRAP | (PTRACE_EVENT_FORK<<8))
Le PID du nouveau processus peut être récupéré avec PTRACE_GETEVENTMSG.
PTRACE_O_TRACESYSGOOD (depuis Linux 2.4.6)
Lors des interceptions d'appel système, positionner le bit 7 sur le numéro
de signal (envoyer SIGTRAP|0x80). Cela facilite pour l'observateur la
distinction entre les interceptions normales et celles provoquées par un
appel système.
PTRACE_O_TRACEVFORK (depuis Linux 2.5.46)
Arrêter l'observé au prochain vfork(2) et commencer automatiquement à suivre
le nouveau processus créé, qui démarrera avec un signal SIGSTOP, ou
PTRACE_EVENT_STOP si PTRACE_SEIZE est utilisé. Un waitpid(2) par
l'observateur renverra une valeur status comme
status>>8 == (SIGTRAP | (PTRACE_EVENT_VFORK<<8))
Le PID du nouveau processus peut être récupéré avec PTRACE_GETEVENTMSG.
PTRACE_O_TRACEVFORKDONE (depuis Linux 2.5.60)
Arrêter l'observé à la fin du prochain vfork(2). Un waitpid(2) par
l'observateur renverra une valeur status comme
status>>8 == (SIGTRAP | (PTRACE_EVENT_VFORK_DONE<<8))
Le PID du nouveau processus peut (depuis Linux 2.6.18) être récupéré avec
PTRACE_GETEVENTMSG.
PTRACE_O_TRACESECCOMP (depuis Linux 3.5)
Arrêter l'observé quand une règle SECCOMP_RET_TRACE de seccomp(2) est
déclenchée. Un waitpid(2) par l'observateur renverra une valeur status comme
status>>8 == (SIGTRAP | (PTRACE_EVENT_SECCOMP<<8))
Si cela entraîne un arrêt PTRACE_EVENT, c'est équivalent à un
arrêt-entrée-appel-système. Pour des détails, voir la remarque sur
PTRACE_EVENT_SECCOMP ci-dessous. Les données du message de l'événement
seccomp (issues de la partie SECCOMP_RET_DATA de la règle du filtre seccomp)
peuvent être récupérées avec PTRACE_GETEVENTMSG.
PTRACE_O_SUSPEND_SECCOMP (depuis Linux 4.3)
Suspendre les protections seccomp de l'observé. Cela s'applique quel que
soit le mode et peut être utilisé lorsque l'observé n'a pas encore installé
de filtres seccomp. Cela veut dire qu'un cas d'utilisation valable consiste
à suspendre les protections seccomp d'un observé avant qu'elles ne soient
installées par l'observé, laisser l'observé installer les filtres et vider
cet attribut quand les filtres doivent être réactivés. La définition de
cette option implique que l'observateur ait la capacité CAP_SYS_ADMIN, n'ait
pas de protection seccomp installée et n'ait pas de PTRACE_O_SUSPEND_SECCOMP
positionné sur lui-même.
PTRACE_GETEVENTMSG (depuis Linux 2.5.46)
Récupérer un message (dans un unsigned long) concernant l'événement ptrace qui
vient d'arriver, en le plaçant à l'adresse data de l'observateur. Pour
PTRACE_EVENT_EXIT, il s'agit du code de retour de l'observé. Pour
PTRACE_EVENT_FORK, PTRACE_EVENT_VFORK, PTRACE_EVENT_VFORK_DONE et
PTRACE_EVENT_CLONE, il s'agit du PID du nouveau processus. Pour
PTRACE_EVENT_SECCOMP, il s'agit des SECCOMP_RET_DATA du filtre seccomp(2) associées
à la règle déclenchée (addr est ignorée).
PTRACE_CONT
Redémarrer l'observé arrêté. Si data est non nul, il est interprété comme un numéro
de signal à distribuer à l'observé ; sinon aucun signal n'est distribué.
L'observateur peut ainsi contrôler si un signal envoyé à l'observé doit lui être
distribué ou non (addr est ignoré).
PTRACE_SYSCALL, PTRACE_SINGLESTEP
Redémarrer l'observé arrêté comme pour PTRACE_CONT, mais en s'arrangeant pour qu'il
soit arrêté à la prochaine entrée ou sortie d'un appel système, ou après la
prochaine instruction, respectivement (l'observé sera aussi arrêté par l'arrivée
d'un signal). Du point de vue de l'observateur, l'observé semblera être arrêté par
SIGTRAP. Ainsi, pour PTRACE_SYSCALL l'idée est d'inspecter les arguments de l'appel
système au premier arrêt puis de faire un autre PTRACE_SYSCALL et d'inspecter la
valeur de retour au second arrêt. Le paramètre data est interprété comme pour
PTRACE_CONT (addr est ignoré).
PTRACE_SET_SYSCALL (depuis Linux 2.6.16)
Lorsqu'il est en arrêt-entrée-appel-système, passer le numéro de l'appel système
qui va être exécuté à celui indiqué dans le paramètre data. Le paramètre addr est
ignoré. Cette requête n'est actuellement prise en charge que sur arm (et arm64,
quoique uniquement à des fins de rétrocompatibilité), mais la plupart des autres
architectures ont d'autres moyens de faire cela (en général en modifiant le
registre qui a passé l'appel système au code au niveau de l'utilisateur).
PTRACE_SYSEMU, PTRACE_SYSEMU_SINGLESTEP (depuis Linux 2.6.14)
Pour PTRACE_SYSEMU, continuer puis s'arrêter lors du prochain appel système, qui ne
sera pas exécuté. Voir la documentation des syscall-stops ci-dessous. Pour
PTRACE_SYSEMU_SINGLESTEP, faire la même chose, mais exécuter pas à pas s'il ne
s'agit pas d'un appel système. Cette fonction est utilisée par des programmes comme
User Mode Linux, qui veulent émuler tous les appels système de l'observé. Le
paramètre data est interprété comme pour PTRACE_CONT. L'argument addr est ignoré.
Ces requêtes ne sont pour l'instant disponibles que sur x86.
PTRACE_LISTEN (depuis Linux 3.4)
Redémarrer l'observé arrêté, mais en l'empêchant de s'exécuter. L'état résultant de
l'observé est similaire a celui d'un processus qui a été arrêté par un SIGSTOP (ou
autre signal d'arrêt). Consultez la sous-section Arrêt-groupe pour des
renseignements supplémentaires. PTRACE_LISTEN ne fonctionne que sur les observés
attachés par PTRACE_SEIZE.
PTRACE_KILL
Envoyer à l'observé un signal SIGKILL pour le terminer (addr et data sont ignorés).
Cette opération est obsolète, ne l'utilisez pas. À la place, envoyez un SIGKILL
directement en utilisant kill(2) ou tgkill(2). Le problème avec PTRACE_KILL est
qu'il nécessite que l'observé soit en arrêt-distribution-signal, sinon cela risque
de ne pas fonctionner (c'est-à-dire risque de se terminer avec succès sans tuer
l'observé). En revanche, envoyer SIGKILL directement n'est pas concerné par cette
limite.
PTRACE_INTERRUPT (depuis Linux 3.4)
Arrêter un observé. Si l’observé est en cours d’exécution ou en sommeil dans
l’espace utilisateur et que PTRACE_SYSCALL est effectif, l’appel système est
interrompu et l'arrêt-sortie-appel-système est signalé (l’appel système interrompu
est redémarré quand l’observé est redémarré). Si l’observé avait déjà été arrêté
par un signal et que PTRACE_LISTEN lui avait été envoyé, l’observé s’arrête avec
PTRACE_EVENT_STOP et WSTOPSIG(status) renvoie le signal d’arrêt. Si n’importe quel
autre arrêt-ptrace est créé en même temps (par exemple, si un signal est envoyé à
l’observé), cet arrêt-ptrace arrive. Si rien de ce qui précède ne s’applique (par
exemple si l’observé est en cours d’exécution en espace utilisateur), il s’arrête
avec PTRACE_EVENT_STOP avec WSTOPSIG(status) == SIGTRAP. PTRACE_INTERRUPT ne
fonctionne que sur les observés attachés par PTRACE_SEIZE.
PTRACE_ATTACH
Attacher le processus numéro pid, pour le suivre. L'observé va recevoir un SIGSTOP,
mais il ne sera peut-être pas arrêté tout de suite, utilisez waitid(2) pour
attendre son arrêt. Consultez la sous-section Attachement et détachement pour
obtenir de plus amples renseignements (addr et data sont ignorés).
Le droit d'effectuer un PTRACE_ATTACH est géré par la vérification
PTRACE_MODE_ATTACH_REALCREDS du mode d'accès de ptrace ; voir ci-dessous.
PTRACE_SEIZE (depuis Linux 3.4)
Attacher au processus indiqué dans pid, en faire un observé du processus appelant.
Contrairement à PTRACE_ATTACH, PTRACE_SEIZE n'arrête pas le processus. Les
arrêts-groupe sont signalés en tant que PTRACE_EVENT_STOP et WSTOPSIG(status)
renvoie le signal d'arrêt. Les enfants automatiquement attachés avec
PTRACE_EVENT_STOP et WSTOPSIG(status) renvoient SIGTRAP au lieu de recevoir un
signal SIGSTOP. execve(2) n'envoie pas d'autres SIGTRAP. Seul un processus
PTRACE_SEIZEé peut accepter des commandes PTRACE_INTERRUPT et PTRACE_LISTEN. Le
comportement « seized » qui vient d'être décrit est récupéré par les enfants
automatiquement attachés en utilisant PTRACE_O_TRACEFORK, PTRACE_O_TRACEVFORK et
PTRACE_O_TRACECLONE. addr doit être de zéro. data contient un masque de bit des
options ptrace à activer immédiatement.
Le droit d'effectuer un PTRACE_SEIZE est géré par une vérification
PTRACE_MODE_ATTACH_REALCREDS du mode d'accès ptrace ; voir ci-dessous.
PTRACE_SECCOMP_GET_FILTER (depuis Linux 4.4)
Cette opération autorise l'observateur à vider les filtres BPF classiques de
l'observé.
addr est un entier indiquant l'index du filtre à vider. Le filtre le plus récemment
installé a le numéro d'index 0. Si addr est supérieur aux numéros des filtres
installés, l'opération échoue avec l'erreur ENOENT.
data est soit un pointeur vers un tableau struct sock_filter assez grand pour
stocker le programme BPF, soit NULL si le programme ne va pas être stocké.
En cas de succès, le code de retour est le nombre d'instructions du programme BPF.
Si data était NULL, ce code de retour peut être utilisé pour dimensionner
correctement le tableau struct sock_filter passé dans un appel ultérieur.
Cette opération échoue avec l'erreur EACCES si l'appelant n'a pas la capacité
CAP_SYS_ADMIN ou s'il est en mode seccomp filtré ou restreint. Si le filtre auquel
renvoie addr n'est pas un filtre BPF classique, l'opération échoue avec l'erreur
EMEDIUMTYPE.
Cette opération n'est disponible que si le noyau a été configuré avec les options
CONFIG_SECCOMP_FILTER et CONFIG_CHECKPOINT_RESTORE.
PTRACE_DETACH
Relancer l'observé arrêté comme avec PTRACE_CONT, mais en commençant par s'en
détacher. Sous Linux un observé peut être détaché ainsi quelque soit la méthode
employée pour démarrer le suivi (addr est ignoré).
PTRACE_GET_THREAD_AREA (depuis Linux 2.6.0)
Cette opération effectue une tâche identique à get_thread_area(2). Elle lit
l'entrée TLS dans le GDT dont l'index est donné dans addr, mettant une copie de
l'entrée dans la struct user_desc vers laquelle pointe data (contrairement à
get_thread_area(2), entry_number de la struct user_desc est ignorée).
PTRACE_SET_THREAD_AREA (depuis Linux 2.6.0)
Cette opération effectue la même tâche que set_thread_area(2). Elle positionne
l'entrée TLS dans le GDT dont l'index est donné dans addr, en lui affectant les
données fournies dans la struct user_desc vers laquelle pointe data (contrairement
à set_thread_area(2), entry_number de la struct user_desc est ignorée ; autrement
dit, cette opération de ptrace ne peut pas être utilisée pour affecter une entrée
TLS libre).
PTRACE_GET_SYSCALL_INFO (depuis Linux 5.3)
Récupérer des informations sur l'appel système qui a provoqué l'arrêt. Les
informations sont placées dans le tampon vers lequel pointe le paramètre data,
lequel doit être un pointeur vers un tampon de type struct ptrace_syscall_info. Le
paramètre addr contient la taille du tampon vers lequel pointe le paramètre data (à
savoir sizeof(struct ptrace_syscall_info)). Le code de retour contient le nombre
d'octets que le noyau peut écrire. Si la taille des données que le noyau doit
écrire dépasse celle indiquée par le paramètre addr, les données de sortie sont
tronquées.
La structure ptrace_syscall_info contient les champs suivants :
struct ptrace_syscall_info {
__u8 op; /* Type d'appel système d'arrêt */
__u32 arch; /* Valeur AUDIT_ARCH_* ; voir seccomp(2) */
__u64 instruction_pointer; /* Pointeur vers l'instruction du processeur */
__u64 stack_pointer; /* Pointeur vers la pile du processeur */
union {
struct { /* op == PTRACE_SYSCALL_INFO_ENTRY */
__u64 nr; /* Numéro de l'appel système */
__u64 args[6]; /* Paramètres de l'appel système */
} entry;
struct { /* op == PTRACE_SYSCALL_INFO_EXIT */
__s64 rval; /* Code de retour de l'appel système */
__u8 is_error; /* Attribut d'erreur de l'appel système ;
Booléen : rval contient-il
un code d'erreur (-ERRCODE) ou
un code de retour de non erreur ? */
} exit;
struct { /* op == PTRACE_SYSCALL_INFO_SECCOMP */
__u64 nr; /* Numéro de l'appel système */
__u64 args[6]; /* Paramètres de l'appel système */
__u32 ret_data; /* Partie SECCOMP_RET_DATA de la valeur
de retour de SECCOMP_RET_TRACE */
} seccomp;
};
};
Les champs op, arch, instruction_pointer et stack_pointer sont définis pour tous
les types d'arrêts de l'appel système ptrace. Le reste de la structure est une
union ; on ne doit lire que les champs significatifs pour le type d'arrêt de
l'appel système indiqué par le champ op.
Le champ op prend une des valeurs suivantes (définies dans <linux/ptrace.h>),
indiquant le type d'arrêt qui s'est produit et la partie remplie de l'union :
PTRACE_SYSCALL_INFO_ENTRY
Le composant entry de l'union contient des informations liées à un arrêt
d'entrée appel système.
PTRACE_SYSCALL_INFO_EXIT
Le composant exit de l'union contient des informations sur un arrêt de
sortie d'appel système.
PTRACE_SYSCALL_INFO_SECCOMP
Le composant seccomp de l'union contient des informations concernant un
arrêt PTRACE_EVENT_SECCOMP.
PTRACE_SYSCALL_INFO_NONE
Aucun composant de l'union ne contient d'informations pertinentes.
Mort sous ptrace
Quand un processus (éventuellement multithreadé) reçoit un signal pour le tuer (un dont la
disposition est configurée à SIG_DFL et dont l'action par défaut est de tuer le
processus), tous les threads se terminent. Chaque observé signale sa mort à son ou ses
observateurs. La notification de cet événement est distribuée par waitpid(2).
Remarquez que le signal tueur provoquera d'abord un arrêt-distribution-signal (sur un seul
observé) et, seulement après être injecté par l'observateur (ou après être envoyé à un
thread qui n'est pas suivi), la mort du signal arrivera sur tous les observés d'un
processus multithreadé (le terme « arrêt-distribution-signal » est expliqué plus bas).
SIGKILL ne génère pas d'arrêt-distribution-signal et l'observateur ne peut par conséquent
pas le supprimer. SIGKILL tue même à l'intérieur des appels systèmes
(arrêt-sortie-appel-système n'est pas créé avant la mort par SIGKILL). L'effet direct est
que SIGKILL tue toujours le processus (tout ses threads), même si certains threads du
processus sont suivis avec ptrace.
Quand l'observé appelle _exit(2), il signale sa mort à son observateur. Les autres threads
ne sont pas concernés.
Quand n'importe quel thread exécute exit_group(2), tous les observés de son groupe de
threads signalent leur mort à leur observateur.
Si l'option PTRACE_O_TRACEEXIT est active, PTRACE_EVENT_EXIT arrivera avant la mort
réelle. Cela s'applique aux terminaisons avec exit(2), exit_group(2) et aux morts de
signal (sauf SIGKILL, selon la version du noyau ; voir les BOGUES ci-dessous), et lorsque
les threads sont détruits par execve(2) dans un processus multithreadé.
L'observateur ne peut pas assumer que l'observé arrêté-ptrace existe. L'observé risque de
mourir avant d'être arrêté dans plusieurs cas (comme avec SIGKILL). Par conséquent, le
tracé doit être préparé pour traiter une erreur ESRCH sur n'importe quelle opération
ptrace. Malheureusement, la même erreur est renvoyée si l'observé existe mais n'est pas
arrêté-ptrace (pour les commandes qui nécessitent un observé arrêté), ou s'il n'est pas
suivi par le processus qui a envoyé l'appel ptrace. L'observateur doit garder une trace de
l'état arrêté ou en fonctionnement de l'observé, et interpréter ESRCH comme « l'observé
s'est achevé de manière inattendue » seulement s'il sait que l'observé est effectivement
entré en arrêt-ptrace. Remarquez qu'il n'est pas garanti que waitpid(WNOHANG) signale de
façon fiable l'état de mort de l'observé si une opération ptrace renvoie ESRCH.
waitpid(WNOHANG) pourrait plutôt renvoyer 0. Autrement dit, l'observé pourrait « ne pas
être encore mort », mais déjà refuser des requêtes ptrace.
L'observateur ne peut pas assumer que l'observé finit toujours sa vie en signalant
WIFEXITED(status) ou WIFSIGNALED(status) ; dans certains cas ça n'arrive pas. Par exemple
si un thread différent du leader de groupe de threads fait un execve(2), il disparaît ;
son PID ne sera plus jamais vu, tous les arrêts suivants de ptrace seront signalés sous le
PID du leader de groupe de threads.
États arrêtés
Deux états existent pour un observé : en cours d'exécution ou à l'arrêt. Du point de vue
de ptrace, un observé qui est bloqué dans un appel système (comme read(2), pause(2), etc.)
est néanmoins considéré en cours d’exécution, même si l’observé est bloqué depuis
longtemps. L’état de l’observé après PTRACE_LISTEN est en quelque sorte une zone d’ombre :
il n’est dans aucun arrêt-ptrace (les commandes ptrace n’auront aucun effet sur lui et il
distribuera des notifications waitpid(2)), mais il pourrait aussi être considéré
« arrêté » parce qu’il n’est pas en train d’exécuter des instructions (pas de
programmation) et, s’il était en arrêt-groupe avant PTRACE_LISTEN, il ne répondra pas aux
signaux avant de recevoir SIGCONT.
De nombreuses sortes d'états sont possibles quand l'observé est arrêté, et les discussions
dans ptrace sont souvent confondues. Par conséquent, l'utilisation de termes précis est
importante.
Dans cette page de manuel, tous les états d'arrêt dans lesquels l'observé est prêt à
accepter des commandes ptrace de l'observateur sont appelés arrêt-ptrace. Les
arrêts-ptrace peuvent ensuite être sous-divisés en arrêt-distribution-signal,
arrêt-groupe, arrêt-appel-système, arrêt-PTRACE_EVENT, etc. Ces états d'arrêt sont décrits
en détail ci-dessous.
Lorsque l'observé en cours d'exécution entre en arrêt-ptrace, il avise son observateur en
utilisant waitpid(2) (ou un des autres appels système « wait »). La plupart de cette page
de manuel suppose que l'observateur attend avec :
pid = waitpid(pid_ou_moins_1, &status, __WALL);
Les observés arrêtés-ptrace sont signalés comme renvoyés avec un pid strictement positif
et WIFSTOPPED(status) vrai.
L'attribut __WALL ne contient pas les attributs WSTOPPED et WEXITED, mais implique leur
fonctionnalité.
La configuration de l'attribut WCONTINUED en appelant waitpid(2) n'est pas conseillée :
l'état « exécuté » est relatif au processus et l'utiliser peut embrouiller le vrai parent
de l'observé.
Utiliser l'attribut WNOHANG pourrait forcer waitpid(2) à renvoyer 0 (« aucun résultat
d'attente encore disponible ») même si l'observateur sait qu'il devrait y avoir une
notification. Exemple :
errno = 0;
ptrace(PTRACE_CONT, pid, 0L, 0L);
if (errno == ESRCH) {
/* l'observé est mort */
r = waitpid(tracee, &status, __WALL | WNOHANG);
/* r peut encore valoir 0 ici ! */
}
Les sortes d'arrêts-ptrace suivants existent : arrêts-distribution-signal, arrêts-groupe,
arrêts PTRACE_EVENT et arrêts-appel-système. Ils sont signalés par waitpid(2) avec
WIFSTOPPED(status) vrai. Ils peuvent être distingués en examinant la valeur status>>8, et
en cas d'ambiguïté dans cette valeur, en faisant une requête PTRACE_GETSIGINFO (remarque :
la macro WSTOPSIG(status) ne peut pas être utilisée pour réaliser cet examen, car elle
renvoie la valeur (status>>8) & 0xff.)
Arrêt-distribution-signal
Quand un processus (éventuellement multithreadé) reçoit n'importe quel signal sauf
SIGKILL, le noyau choisi un thread arbitraire pour traiter le signal (si le signal est
créé avec tgill(2), le thread cible peut être explicitement choisi par l'appelant). Si le
thread choisi est observé, il entre en arrêt-distribution-signal. À ce moment là, le
signal n'est pas encore distribué au processus, et peut être supprimé par l'observateur.
Si l'observateur ne supprime pas le signal, il passe le signal à l'observé lors de la
requête suivante de redémarrage de ptrace. Cette deuxième étape de distribution de signal
est appelée injection de signal dans cette page de manuel. Remarquez que si le signal est
bloqué, l'arrêt-distribution-signal n'arrive pas avant que le signal soit débloqué, à
l'exception habituelle que SIGSTOP ne peut pas être bloqué.
L'arrêt-distribution-signal est respecté par l'observateur tant que waitpid(2) retourne
avec WIFSTOPPED(status) vrai, avec le signal renvoyé par WSTOPSIG(status). Si le signal
est SIGTRAP, cela pourrait être un arrêt-ptrace de nature différente ; consultez les
sections Arrêts-appel-système et execve(2) sous ptrace plus bas pour obtenir de plus
amples précisions. Si WSTOPSIG(status) renvoie un signal d'arrêt, cela pourrait être un
arrêt-groupe ; voir ci-dessous.
Injection et suppression de signal
Après un arrêt-distribution-signal respecté par l'observateur, l'observateur devrait
redémarrer l'observé avec l'appel
ptrace(PTRACE_restart, pid, 0, sig)
où PTRACE_restart est une des requêtes ptrace de redémarrage. Si sig est 0, alors aucun
signal n'est distribué. Sinon, le signal sig est distribué. Cette opération est appelée
injection de signal dans cette page de manuel, pour la distinguer de
l'arrêt-distribution-signal.
La valeur de sig peut être différente de celle de WSTOPSIG(status) : l'observateur peut
provoquer l'injection d'un autre signal.
Remarquez qu'un signal supprimé provoque toujours un retour prématuré des appels système.
Dans ce cas, les appels système seront redémarrés : l'observateur forcera l'observé à
réexécuter l'appel système interrompu (ou l'appel système restart_syscall(2) pour les
quelques appels système qui utilisent un autre mécanisme de redémarrage) si l'observateur
utilise PTRACE_SYSCALL. Même les appels système (comme poll(2)) qui ne sont pas
redémarrables après le signal sont redémarrés après la suppression du signal ; cependant,
des bogues du noyau existent et certains appels système échouent avec EINTR même si aucun
signal observable n'est injecté dans l'observé.
Lors du redémarrage des commandes ptrace émises dans d'autres arrêts-ptrace
qu'arrêt-distribution-signal, l'injection de signal n'est pas garantie, même si sig est
non nul. Aucune erreur n'est signalée ; un sig non nul risque simplement d'être ignoré.
Les utilisateurs de ptrace ne devraient pas essayer de « créer un nouveau signal » de
cette façon : utilisez plutôt tgkill(2).
Le fait que des requêtes d'injection de signal puissent être ignorées lors du redémarrage
de l'observé après des arrêts ptrace qui ne sont pas des arrêts-distribution-signal est
une source de confusion pour les utilisateurs de ptrace. Un scénario typique est que
l'observateur remarque un arrêt-groupe, le confonde avec un arrêt-distribution-signal, et
redémarre l'observé avec
ptrace(PTRACE_restart, pid, 0, stopsig)
dans le but d'injecter stopsig, mais stopsig sera ignoré et l'observé continuera de
fonctionner.
Le signal SIGCONT a pour effet de bord de réveiller (tous les threads d')un processus
arrêté-groupe. Cet effet de bord arrive avant un arrêt-distribution-signal. L'observateur
ne peut pas supprimer cet effet de bord (il ne peut que supprimer l'injection de signal,
qui force seulement le gestionnaire de SIGCONT à ne pas être exécuté dans l'observé, si un
gestionnaire de ce type est installé). En fait, le réveil depuis un arrêt-groupe pourrait
être suivi par un arrêt-distribution-signal pour le ou les signaux différents de SIGCONT,
s'ils étaient en attente quand SIGCONT a été distribué. Autrement dit, SIGCONT pourrait ne
pas être le premier signal remarqué par l'observé après avoir été envoyé.
L'arrêt de signaux force (tous les threads d')un processus à entrer en arrêt-groupe. Cet
effet de bord arrive après une injection de signal, et peut par conséquent être supprimé
par l'observateur.
Sous Linux 2.4 et les versions précédentes, le signal SIGSTOP ne pouvait pas être injecté.
PTRACE_GETSIGINFO peut être utilisé pour récupérer une structure siginfo_t qui correspond
au signal distribué. PTRACE_SETSIGINFO pourrait être utilisé pour le modifier. Si
PTRACE_SETSIGINFO a été utilisé pour modifier siginfo_t, le champ si_signo et le paramètre
sig de la commande de redémarrage doivent correspondre, sinon le résultat est indéfini.
Arrêt-groupe
Quand un processus (éventuellement multithreadé) reçoit un signal d'arrêt, tous les
threads s'arrêtent. Si certains threads sont suivis, ils entrent en arrêt-groupe.
Remarquez que le signal d'arrêt provoquera d'abord un arrêt-distribution-signal (sur un
seul observé) et, seulement après avoir été injecté par l'observateur (ou après avoir été
envoyé à un thread qui n'est pas suivi), l'arrêt-groupe sera initié sur tous les observés
d'un processus multithreadé. Comme d'habitude, tous les observés signalent leur
arrêt-groupe séparément à l'observateur correspondant.
L'arrêt-groupe est respecté par l'observateur tant que waitpid(2) retourne avec
WIFSTOPPED(status) vrai, avec le signal d'arrêt disponible par l'intermédiaire de
WSTOPSIG(status). Le même résultat est renvoyé par d'autres classes d'arrêts-ptrace, par
conséquent la méthode conseillée est de réaliser l'appel
ptrace(PTRACE_GETSIGINFO, pid, 0, &siginfo)
L'appel peut être évité si le signal n'est pas SIGSTOP, SIGTSTP, SIGTTIN ou SIGTTOU ;
seuls ces quatre signaux sont des signaux d'arrêt. Si l'observateur voit autre chose, ce
ne peut pas être un arrêt-groupe. Sinon, l'observateur doit appeler PTRACE_GETSIGINFO. Si
PTRACE_GETSIGINFO échoue avec EINVAL, alors c'est définitivement un arrêt-groupe (d'autres
codes d'échec sont possibles, comme ESRCH (« pas de processus de ce type ») si un SIGKILL
a tué l'observé).
Si l’observé était attaché en utilisant PTRACE_SEIZE, un arrêt-groupe est indiqué par
PTRACE_EVENT_STOP : status>>16 == PTRACE_EVENT_STOP. Cela permet la détection
d’arrêts-groupe sans nécessiter d’appel PTRACE_GETSIGINFO supplémentaire.
Depuis Linux 2.6.38, après que l'observateur a vu l'arrêt-ptrace de l'observé et jusqu'à
ce qu'il le redémarre ou le tue, l'observé ne fonctionnera pas, et n'enverra pas de
notification (sauf mort par SIGKILL) à l'observateur, même si l'observateur entre dans un
autre appel waitpid(2).
Le comportement du noyau décrit dans le paragraphe précédent pose un problème avec la
gestion transparente de signaux d'arrêt. Si l'observateur redémarre l'observé après un
arrêt-groupe, le signal d'arrêt est effectivement ignoré — l'observé ne reste pas arrêté,
il fonctionne. Si l'observateur ne redémarre pas l'observé avant d'entrer dans le prochain
waitpid(2), les signaux SIGCONT suivants ne seront pas signalés à l'observateur ; cela
pourrait forcer des signaux SIGCONT à être sans effet sur l'observé.
Depuis Linux 3.4, une méthode permet d'éviter ce problème : à la place de PTRACE_CONT, une
commande PTRACE_LISTEN peut être utilisée pour redémarrer un observé de façon à ce qu'il
ne s'exécute pas, mais attende un nouvel événement qu'il peut signaler à l'aide de
waitpid(2) (comme s'il était redémarré par un SIGCONT).
Arrêts PTRACE_EVENT
Si l'observateur configure des options PTRACE_O_TRACE_*, l'observé entrera en
arrêts-ptrace appelés arrêts PTRACE_EVENT.
Les arrêts PTRACE_EVENT sont respectés par l'observateur pendant que waitpid(2) renvoie
WIFSTOPPED(status) et que WSTOPSIG(status) renvoie SIGTRAP (ou pour PTRACE_EVENT_STOP,
renvoie le signal d'arrêt si l'observé est dans un arrêt de groupe). Un bit supplémentaire
est configuré dans l'octet le plus haut du mot d'état : la valeur status>>8 sera
((PTRACE_EVENT_foo<<8) | SIGTRAP).
Les événements suivants existent.
PTRACE_EVENT_VFORK
Arrêt avant de revenir de vfork(2) ou clone(2) avec l'attribut CLONE_VFORK. Quand
l'observé est continué après cet arrêt, il attendra une sortie ou exécution de
l'enfant avant de continuer son exécution (autrement dit, le comportement normal
avec vfork(2)).
PTRACE_EVENT_FORK
Arrêt avant de revenir de fork(2) ou clone(2) avec le signal de sortie configuré à
SIGCHLD.
PTRACE_EVENT_CLONE
Arrêt avant de revenir de clone(2).
PTRACE_EVENT_VFORK_DONE
Arrêt avant de revenir de vfork(2) ou clone(2) avec l'attribut CLONE_VFORK, mais
après que l'enfant a débloqué son observé par sortie ou exécution.
Pour les quatre arrêts décrits ci-dessus, l'arrêt arrive dans le parent (c'est-à-dire
l'observé), pas dans le nouveau thread créé. PTRACE_GETEVENTMSG permet de récupérer
l'identifiant du nouveau thread.
PTRACE_EVENT_EXEC
Arrêt avant le retour d'execve(2). Depuis Linux 3.0, PTRACE_GETEVENTMSG renvoie le
premier identifiant de thread.
PTRACE_EVENT_EXIT
Arrêt avant la sortie (y compris la mort depuis exit_group(2)), la mort du signal
ou la sortie provoquée par execve(2) dans un processus multithreadé.
PTRACE_GETEVENTMSG renvoie l'état de sortie. Les registres peuvent être examinés
(contrairement à quand une « vraie » sortie arrive). L'observé est toujours actif ;
il a besoin de PTRACE_CONT ou PTRACE_DETACH pour terminer sa sortie.
PTRACE_EVENT_STOP
Arrêt causé par la commande PTRACE_INTERRUPT, ou arrêt-groupe, ou arrêt-ptrace
initial quand un nouvel enfant est attaché (seulement s’il est attaché en utilisant
PTRACE_SEIZE).
PTRACE_EVENT_SECCOMP
Arrêt différé par une règle seccomp(2) sur l'entrée appel système de l'observé
quand PTRACE_O_TRACESECCOMP a été positionné par l'observateur. Les données du
message de l'événement seccomp (issues de la portion SECCOMP_RET_DATA de la règle
de filtrage seccomp) peuvent être récupérées avec PTRACE_GETEVENTMSG. La sémantique
de cet arrêt est décrit en détails dans une section distincte ci-dessous.
PTRACE_GETSIGINFO sur les arrêts PTRACE_EVENT renvoie SIGTRAP dans si_signo, avec si_code
configuré à (event<<8) | SIGTRAP.
Arrêts-appel-système
Si l'observé était redémarré par PTRACE_SYSCALL ou PTRACE_SYSEMU, l'observé entre en
arrêt-entrée-appel-système juste avant d'entrer dans n'importe quel appel système (qui ne
sera pas exécuté si le redémarrage utilisait PTRACE_SYSEMU, quels que soient les
changements apportés aux registres à ce point ou à la manière dont l'observé redémarre
après cet arrêt). Peu importe la méthode qui a conduit en arrêt-entrée-appel-système si
l’observateur redémarre l’observé avec PTRACE_SYSCALL, l’observé entre en
arrêt-sortie-appel-système quand l’appel système est terminé ou s'il est interrompu par un
signal (c'est-à-dire qu'un arrêt-distribution-signal n'arrive jamais entre un
arrêt-entrée-appel-système et un arrêt-sortie-appel-système ; il arrive après
l'arrêt-sortie-appel-système). Si l'observé est poursuivi en utilisant une autre méthode
(notamment PTRACE_SYSEMU), aucun arrêt-sortie-appel-système ne se produit. Remarquez que
toutes les mentions PTRACE_SYSEMU s'appliquent également à PTRACE_SYSEMU_SINGLESTEP.
Toutefois, même si l'observé a été poursuivi en utilisant PTRACE_SYSCALL, il n'est pas
garanti que le prochain arrêt sera un arrêt-sortie-appel-système. D'autres possibilités
sont que l'observé pourrait s'arrêter dans un arrêt PTRACE_EVENT, sortir (s'il est entré
en _exit(2) ou exit_group(2)), être tué par SIGKILL ou mourir silencieusement (s'il s'agit
d'un leader de groupe de threads, que l'execve(2) est arrivé dans un autre thread et que
ce thread n'est pas suivi par le même observateur ; cette situation sera abordée plus
tard).
Les arrêt-entrée-appel-système et arrêt-sortie-appel-système sont respectés par
l'observateur tant que waitpid(2) retourne avec WIFSTOPPED(status) vrai, et que
WSTOPSIG(status) donne SIGTRAP. Si l'option PTRACE_O_TRACESYSGOOD était configurée par
l'observateur, alors WSTOPSIG(status) donnera la valeur (SIGTRAP | 0x80).
Les arrêts-appel-système peuvent être distingués d'un arrêt-distribution-signal avec
SIGTRAP en demandant PTRACE_GETSIGINFO pour les cas suivants.
si_code <= 0
SIGTRAP a été distribué comme résultat d'une action en espace utilisateur, par
exemple, un appel système (tgkill(2), kill(2), sigqueue(3), etc.), l'expiration
d'un minuteur POSIX, la modification d'état sur une file de messages POSIX où la
fin d'une requête d'E/S asynchrone.
si_code == SI_KERNEL (0x80)
SIGTRAP a été envoyé par le noyau.
si_code == SIGTRAP ou si_code == (SIGTRAP|0x80)
C'est un arrêt-appel-système.
Cependant, les arrêts-appel-système arrivent très souvent (deux fois par appel système) et
réaliser PTRACE_GETSIGINFO pour chaque arrêt-appel-système pourrait être assez coûteux.
Certaines architectures permettent de distinguer ces cas en examinant les registres. Par
exemple, sur x86, rax == -ENOSYS en arrêt-entrée-appel-système. Puisque SIGTRAP (comme
tout autre signal) arrive toujours après l'arrêt-sortie-appel-système et que rax ne
contient à ce moment presque jamais -ENOSYS, le SIGTRAP ressemble à un
« arrêt-appel-système qui n'est pas un arrêt-entrée-appel-système » ; autrement dit, il
ressemble à un « arrêt-sortie-appel-système perdu » et peut être détecté de cette façon.
Une telle détection est néanmoins fragile, elle est donc a éviter.
L'utilisation de l'option PTRACE_O_TRACESYSGOOD est la méthode conseillée pour distinguer
les arrêts-appel-système des autres sortes d'arrêts-ptrace, puisqu'il est fiable et
n'induit pas de perte de performances.
Les arrêt-entrée-appel-système et arrêt-sortie-appel-système ne sont pas différentiables
l'un de l'autre. L'observateur doit garder une trace de la suite d'arrêts-ptrace afin de
ne pas mal interpréter un arrêt-entrée-appel-système comme un arrêt-sortie-appel-système
ou vice versa. Généralement, l'arrêt-entrée-appel-système est toujours suivi par un
arrêt-sortie-appel-système, un arrêt PTRACE_EVENT ou la mort de l'observé ; aucune autre
sorte d'arrêt-ptrace ne peut arriver entre-deux. Toutefois, remarquez que les arrêts
seccomp (voir ci-dessous) peuvent provoquer des arrêts-sortie-appel-système sans
arrêt-entrée-appel-système préalable. Si seccomp, il faut faire attention à ne pas mal
interpréter de tels arrêts en arrêts-entrée-appel-système.
Si suite à un arrêt-entrée-appel-système, l'observateur utilise une commande de
redémarrage différente de PTRACE_SYSCALL, l'arrêt-sortie-appel-système n'est pas créé.
PTRACE_GETSIGINFO sur les arrêts-appel-système renvoie SIGTRAP dans si_signo, avec si_code
configuré à SIGTRAP ou (SIGTRAP | 0x80).
Arrêts PTRACE_EVENT_SECCOMP (Linux 3.5 à Linux 4.7)
Le comportement des arrêts PTRACE_EVENT_SECCOMP et leur interaction avec les autres types
d'arrêt ptrace a changé entre les versions du noyau. Nous documentons ici le comportement
lors de leur introduction dans Linux 4.7 (inclus). Le comportement dans les versions
postérieures du noyau est documenté dans la section suivante.
Un arrêt PTRACE_EVENT_SECCOMP se produit à chaque fois qu'une règle SECCOMP_RET_TRACE est
déclenchée. Cela est indépendant de la méthode utilisée pour redémarrer l'appel système.
En particulier, seccomp s'exécute toujours même si l'observé a été redémarré en utilisant
PTRACE_SYSEMU et cet appel système est sauté sans condition.
Les redémarrages à partir de cet arrêt se comporteront comme si l'arrêt s'était produit
juste avant l'appel système en question. En particulier, tant PTRACE_SYSCALL que
PTRACE_SYSEMU provoqueront normalement un arrêt-entrée-appel-système ultérieur. Cependant,
si après le PTRACE_EVENT_SECCOMP le numéro de l'appel système est négatif,
l'arrêt-entrée-appel-système et l'appel lui-même seront tous deux sautés. Cela veut dire
que si le numéro d'appel système est négatif après un PTRACE_EVENT_SECCOMP et si l'observé
est redémarré en utilisant PTRACE_SYSCALL, le prochain arrêt observé sera un
arrêt-sortie-appel-système et non un arrêt-entrée-appel-système qui comme on aurait pu s'y
attendre.
Arrêts PTRACE_EVENT_SECCOMP (depuis Linux 4.8)
À partir de Linux 4.8, l'arrêt PTRACE_EVENT_SECCOMP a été réaménagé pour intervenir entre
l'arrêt-entrée-appel-système et l'arrêt-sortie-appel-système. Remarquez que seccomp ne
s'exécute plus (et aucun PTRACE_EVENT_SECCOMP ne sera renvoyé) si l'appel système est
sauté du fait d'un PTRACE_SYSEMU.
Pratiquement, un arrêt PTRACE_EVENT_SECCOMP fonctionne comme un arrêt-entrée-appel-système
(à savoir que les reprises utilisant PTRACE_SYSCALL provoqueront des
arrêts-sortie-appel-système, le numéro de l'appel système peut être modifié et tous les
registres modifiés sont visibles également à l'appel système à exécuter). Remarquez qu'il
peut y avoir, sans obligation qu'il y ait déjà eu, un arrêt-entrée-appel-système
précédent.
Après un arrêt PTRACE_EVENT_SECCOMP, seccomp sera réexécuté, avec une règle
SECCOMP_RET_TRACE qui fonctionne désormais de la même manière que SECCOMP_RET_ALLOW. En
particulier, cela veut dire que si les registres ne sont pas modifiés lors d'un arrêt
PTRACE_EVENT_SECCOMP, l'appel système aura alors l'autorisation.
Arrêts PTRACE_SINGLESTEP
[Les précisions sur ces types d'arrêts sont encore à documenter.]
Commandes ptrace d'information et de redémarrage
La plupart des commandes ptrace (toutes sauf PTRACE_ATTACH, PTRACE_SEIZE, PTRACE_TRACEME,
PTRACE_INTERRUPT et PTRACE_KILL) nécessitent que l'observé soit en arrêt-ptrace, sinon il
échoue avec ESRCH.
Quand l'observé est en arrêt-ptrace, l'observateur peut lire et écrire les donnés sur
l'observé en utilisant les commandes d'information. Ces commandes laissent l'observé en
état arrêté-ptrace :
ptrace(PTRACE_PEEKTEXT/PEEKDATA/PEEKUSER, pid, addr, 0);
ptrace(PTRACE_POKETEXT/POKEDATA/POKEUSER, pid, addr, long_val);
ptrace(PTRACE_GETREGS/GETFPREGS, pid, 0, &struct);
ptrace(PTRACE_SETREGS/SETFPREGS, pid, 0, &struct);
ptrace(PTRACE_GETREGSET, pid, NT_foo, &iov);
ptrace(PTRACE_SETREGSET, pid, NT_foo, &iov);
ptrace(PTRACE_GETSIGINFO, pid, 0, &siginfo);
ptrace(PTRACE_SETSIGINFO, pid, 0, &siginfo);
ptrace(PTRACE_GETEVENTMSG, pid, 0, &long_var);
ptrace(PTRACE_SETOPTIONS, pid, 0, PTRACE_O_flags);
Remarquez que certaines erreurs ne sont pas signalées. Par exemple, la configuration
d'informations de signal (siginfo) pourrait être sans effet pour certains arrêts-ptrace,
alors que l'appel pourrait-être réussi (en renvoyant 0 et sans définir errno) ; la demande
de PTRACE_GETEVENTMSG pourrait réussir et renvoyer une quelconque valeur aléatoire si
l'arrêt-ptrace actuel n'est pas documenté comme renvoyant un message d'événement
significatif.
L'appel
ptrace(PTRACE_SETOPTIONS, pid, 0, PTRACE_O_flags);
ne concerne qu'un observé. Les attributs actuels de l'observé sont remplacés. Les
attributs sont hérités par les nouveaux observés créés et « attachés automatiquement » à
l'aide d'options PTRACE_O_TRACEFORK, PTRACE_O_TRACEVFORK ou PTRACE_O_TRACECLONE actives.
Un autre groupe de commandes peut redémarrer l'observé arrêté-ptrace. Ils sont de la
forme :
ptrace(cmd, pid, 0, sig);
où cmd est PTRACE_CONT, PTRACE_LISTEN, PTRACE_DETACH, PTRACE_SYSCALL, PTRACE_SINGLESTEP,
PTRACE_SYSEMU ou PTRACE_SYSEMU_SINGLESTEP. Si l'observé est en arrêt-distribution-signal,
sig est le signal à injecter (s'il est non nul). Sinon, sig pourrait être ignoré (lors du
redémarrage d'un observé depuis un arrêt-ptrace différent d'un arrêt-distribution-signal,
il est conseillé de toujours passer 0 à sig).
Attachement et détachement
Un thread peut être attaché à l'observateur en utilisant l'appel
ptrace(PTRACE_ATTACH, pid, 0, 0);
ou
ptrace(PTRACE_SEIZE, pid, 0, PTRACE_O_flags);
PTRACE_ATTACH envoie aussi SIGSTOP à ce thread. Si l'observateur veut que SIGSTOP soit
sans effet, il doit le supprimer. Remarquez que si d'autres signaux sont envoyés en même
temps à ce thread pendant l'attachement, l'observateur pourrait voir l'observé entrer en
arrêt-distribution-signal avec d'autres signaux d'abord ! Ces signaux sont d'habitude
réinjectés jusqu'à ce que SIGSTOP soit vu, puis l'injection SIGSTOP est supprimée. Le
bogue de conception ici est qu'un attachement ptrace et un SIGSTOP distribués en même
temps peuvent entrer en compétition et le SIGSTOP risque d'être perdu.
Puisque l'attachement envoie SIGSTOP et que l'observateur le supprime normalement, cela
risque de forcer le retour d'un EINTR perdu de l'appel système en cours d'exécution dans
l'observé, tel que c'est décrit dans la section Injection et suppression de signal.
Depuis Linux 3.4, PTRACE_SEIZE peut être utilisé à la place de PTRACE_ATTACH. PTRACE_SEIZE
n'arrête pas le processus attaché. Si vous devez l'arrêter après attachement (ou à
n'importe quel autre moment) sans lui envoyer de signal du tout, utilisez la commande
PTRACE_INTERRUPT.
La requête
ptrace(PTRACE_TRACEME, 0, 0, 0);
transforme le thread appelant en observé. L'appel continue d'être exécuté (n'entre pas en
arrêt-ptrace). PTRACE_TRACEME est habituellement suivi avec
raise(SIGSTOP);
et permet au parent (qui est maintenant l'observateur) de respecter
l'arrêt-distribution-signal.
Si les options PTRACE_O_TRACEFORK, PTRACE_O_TRACEVFORK ou PTRACE_O_TRACECLONE font effet,
alors les enfants respectivement créés par vfork(2) ou clone(2) avec l'attribut
CLONE_VFORK, fork(2) ou clone(2) avec le signal de sortie configuré à SIGCHLD, et d'autres
sortes de clone(2), sont automatiquement attachés au même observateur qui à suivi leur
parent. SIGSTOP est distribué aux enfants, les forçant à entrer en
arrêt-distribution-signal après être sortis de l'appel système qu'ils ont créé.
Le détachement de l'observé est réalisé par :
ptrace(PTRACE_DETACH, pid, 0, sig);
PTRACE_DETACH est une opération de redémarrage ; par conséquent elle nécessite que
l'observé soit en arrêt-ptrace. Si l'observé est en arrêt-distribution-signal, un signal
peut être injecté. Sinon, le paramètre sig pourrait être silencieusement ignoré.
Si l'observé est en cours d'exécution quand l'observateur veut le détacher, la solution
habituelle est d'envoyer SIGSTOP (en utilisant tgkill(2), pour s'assurer qu'il va au bon
thread), d'attendre que l'observé s'arrête en arrêt-distribution-signal pour SIGSTOP et
ensuite de le détacher (en supprimant l'injection SIGSTOP). Un bogue de conception est que
l'observé pourrait entrer dans d'autres arrêts-ptrace et avoir besoin d'être redémarré et
attendre encore, jusqu'à ce que SIGSTOP soit vu. Encore une autre complication est de
s'assurer que l'observé n'est pas déjà arrêté-ptrace, parce qu'aucune distribution de
signal n'arrive tant qu'il l'est — pas même SIGSTOP.
Si l'observateur meurt, tous les observés sont automatiquement détachés et redémarrés,
sauf s'il étaient en arrêt-groupe. Le gestion de redémarrage depuis un arrêt-groupe est en
ce moment dysfonctionnelle, mais le comportement « prévu » est de laisser les observés
arrêtés et d'attendre un SIGCONT. Si l'observé est redémarré depuis un
arrêt-distribution-signal, le signal en attente est injecté.
execve(2) sous ptrace
Quand un thread de processus multithreadé appelle execve(2), le noyau détruit tous les
autres threads du processus, et réinitialise l'identifiant de thread du thread exécuté à
l'identifiant de groupe de threads (PID) (ou, pour le présenter autrement, quand un
processus multithreadé fait un execve(2), à la fin de l'appel, il apparaît comme si
l'execve(2) s'était appliqué au leader de groupe de threads, quelque soit le thread qui a
fait execve(2)). Cette réinitialisation de l'identifiant de thread semble est très
déroutante pour les observateurs.
- Tous les autres threads s'arrêtent en arrêt PTRACE_EVENT_EXIT, si l'option
PTRACE_O_TRACEEXIT était activée. Alors tous les autres threads sauf le leader de
groupe de threads signalent leur mort comme s'il s'étaient terminés par l'intermédiaire
de _exit(2) avec un code de retour 0.
- L'observé en cours d'exécution modifie son identifiant de thread pendant qu'il est dans
l'execve(2) (rappelez-vous que, sous ptrace, le « pid » renvoyé par waitpid(2) ou
fourni dans les appels ptrace, est l'identifiant de thread de l'observé). Ainsi,
l'identifiant de thread de l'observé est réinitialisé pour être le même que son
identifiant de processus (PID), qui est le même que l'identifiant de thread du leader
de groupe de threads.
- Ensuite un arrêt PTRACE_EVENT_EXEC arrive, si l'option PTRACE_O_TRACEEXEC était
activée.
- Si le leader de groupe de threads a signalé son arrêt PTRACE_EVENT_EXIT pendant ce
temps, le leader de thread mort à l'air de « revenir de nulle part » du point de vue de
l'observateur (remarque : le leader de groupe de threads ne signale pas sa mort à
l'aide de WIFEXITED(status) tant qu'au moins un autre thread est en vie. Cela enlève la
possibilité à l'observateur de le voir mourir puis réapparaître). Si le leader de
groupe de threads était encore en vie, cela pourrait être vu par l'observateur comme si
le leader de groupe revenait d'un autre appel système que celui dans lequel il était
entré, ou même « revenait d'un appel système même s'il n'y avait pas d'appel système ».
Si le leader de groupe de threads n'était pas suivi (ou était suivi par un autre
observateur), alors pendant execve(2) il apparaîtra comme s'il était devenu un observé
de l'observateur de l'observé en cours d'exécution.
Tous les effets précédents sont des artifices de la modification d'identifiant de thread
de l'observé.
L'option PTRACE_O_TRACEEXEC est l'outil conseillé pour s'occuper de cette situation.
D'abord, elle active l'arrêt PTRACE_EVENT_EXEC, qui arrive avant le retour d'execve(2).
Dans cet arrêt, l'observateur peut utiliser PTRACE_GETEVENTMSG pour récupérer l'ancien
identifiant de thread de l'observé (cette fonctionnalité a été introduite avec Linux 3.0).
Ensuite, l'option PTRACE_O_TRACEEXEC désactive la création obsolète de SIGTRAP dans
execve(2).
Quand l'observé reçoit une notification d'arrêt PTRACE_EVENT_EXEC, il est garanti qu'à
part cet observé et le leader de groupe de threads, aucun autre thread du processus n'est
en vie.
Lors de la réception d'une notification d'arrêt PTRACE_EVENT_EXEC, l'observateur devrait
nettoyer toutes ses structures de données internes décrivant les threads de ce processus
et ne garder qu'une seule structure de données — celle qui décrit l'unique observé en
cours d'exécution, avec
identifiant de thread == identifiant de groupe de threads == identifiant de processus.
Par exemple, soient deux threads qui appellent execve(2) en même temps :
*** arrêt-entrée-appel-système obtenu dans le thread 1 : **
PID1 execve("/bin/truc", "truc" <pas terminé…>
*** PTRACE_SYSCALL émis pour le thread 1 **
*** arrêt-entrée-appel-système obtenu dans le thread 2 : **
PID2 execve("/bin/bidule", "bidule" <pas terminé…>
*** PTRACE_SYSCALL émis pour le thread 2 **
*** PTRACE_EVENT_EXEC obtenu pour PID0, PTRACE_SYSCALL émis **
*** arrêt-sortie-appel-système obtenu pour PID0 : **
PID0 <… retour d'execve> ) = 0
Si l'option PTRACE_O_TRACEEXEC n'est pas effective pour l'observé en cours d'exécution et
si l'observé a été PTRACE_ATTACHé et non PTRACE_SEIZEé, le noyau distribue un SIGTRAP
supplémentaire à l'observé après le retour d'execve(2). C'est un signal normal (similaire
à celui qui peut être créé par kill -TRAP), pas une sorte spéciale d'arrêt-ptrace.
L'utilisation de PTRACE_GETSIGINFO pour ce signal renvoie si_code configuré à 0 (SI_USER).
Ce signal pourrait être bloqué par un masque de signal et pourrait ainsi être distribué
(bien) plus tard.
Normalement, l'observateur (par exemple strace(1)) ne voudrait pas montrer ce signal
SIGTRAP supplémentaire postérieur à execve à l'utilisateur, et voudrait supprimer sa
distribution à l'observé (si SIGTRAP est configuré à SIG_DFL, c'est un signal tueur).
Cependant, déterminer quel est le SIGTRAP à supprimer n'est pas simple. La configuration
de l'option PTRACE_O_TRACEEXEC ou l'utilisation de PTRACE_SEIZE et par conséquent la
suppression du SIGTRAP supplémentaire est l'approche conseillée.
Vrai parent
L'interface de programmation de ptrace utilise (parfois mal) la norme UNIX de signalement
de parent ou enfant par l'intermédiaire de waitpid(2). Cela a régulièrement forcé le vrai
parent du processus à arrêter de recevoir plusieurs sortes de notifications de waitpid(2)
quand le processus enfant est suivi par un autre processus.
De nombreux bogues de ce type ont été corrigés, mais il en reste encore beaucoup dans
Linux 2.6.38. Consultez la section BOGUES ci dessous.
Depuis Linux 2.6.38, ce qui suit est censé fonctionner correctement :
- l'exécution ou la mort par signal sont d'abord signalées à l'observateur, puis, quand
l'observateur consomme le résultat de waitpid(2), au vrai parent (au vrai parent
seulement quand l'intégralité du processus multithreadé se termine). Si l'observateur
et le vrai parent sont le même processus, le signalement n'est envoyé qu'une fois.
VALEUR RENVOYÉE
En cas de succès, la requête PTRACE_PEEK* renvoie les données demandées (mais consultez
les NOTES), la requête PTRACE_SECCOMP_GET_FILTER renvoie le nombre d'instructions du
programme BPF, la requête PTRACE_GET_SYSCALL_INFO renvoie le nombre d'octets disponibles
disponible pour être écrits par le noyau, alors que les autres requêtes renvoient zéro.
En cas d'erreur, toutes les requêtes renvoient -1 et errno est défini pour indiquer
l'erreur. Comme la valeur renvoyée par une requête PTRACE_PEEK* peut légitimement être -1,
l'appelant doit effacer errno avant l'appel, et ensuite le vérifier pour savoir si une
erreur s'est produite.
ERREURS
EBUSY (i386 seulement) Une erreur est survenue lors de l'allocation ou de la libération
d'un registre de débogage.
EFAULT Tentative de lire ou écrire dans une zone mémoire non valable de l'observateur ou
de l'observé, probablement parce que la zone n'était pas projetée ou accessible.
Malheureusement sous Linux, certaines variantes de cette erreur déclencheront EIO
ou EFAULT plus ou moins arbitrairement.
EINVAL Tentative d'utiliser une option non valable.
EIO La requête request n'est pas valable ou une tentative de lecture ou d'écriture dans
une zone non valable de mémoire de l'observateur ou de l'observé a eu lieu. Un
problème d'alignement a aussi pu survenir sur une frontière de mot, ou une
tentative de redémarrage en envoyant un signal non valable.
EPERM Le processus indiqué ne peut pas être suivi. Cela peut être dû à un manque de
privilège de l'observateur (la capacité nécessaire est CAP_SYS_PTRACE). Les
processus non privilégiés ne peuvent pas suivre les processus auxquels ils ne
peuvent envoyer de signal, ou ceux qui s'exécutent Set-UID/Set-GID, pour des
raisons évidentes. En outre, le processus visé peut être déjà suivi, ou (avant
Linux 2.6.26) être init(8) (le processus numéro 1).
ESRCH Le processus indiqué n'existe pas, ou n'est pas suivi par l'appelant, ou n'est pas
arrêté (pour les requêtes qui ont besoin d'un observé arrêté).
STANDARDS
SVr4, 4.3BSD.
NOTES
Bien que les arguments de ptrace() soient interprétés comme dans le prototype donné, la
bibliothèque glibc déclare ptrace comme une fonction variadique où seul l'argument request
est corrigé. Il vaut mieux toujours fournir quatre arguments, même si l'opération demandée
ne les utilise pas, en configurant les arguments non utilisés ou ignorés à 0L ou
(void *) 0.
Avant Linux 2.6.26, init(8), le processus numéro 1, ne peut pas être suivi.
Le parent d'observés reste observateur même s'il appelle execve(2).
La disposition du contenu de la mémoire et de la zone USER dépendent du système
d'exploitation et de l'architecture. Le décalage fourni et les données renvoyées peuvent
ne pas correspondre entièrement avec la définition d'une structure struct user.
La taille d'un mot (« word ») est déterminée par la version du système d'exploitation (par
exemple 32 bits pour Linux 32 bits).
Cette page documente le fonctionnement actuel de ptrace() sous Linux. Celui-ci peut varier
significativement d'autres types d'UNIX. De toute façon, l'utilisation de ptrace() dépend
fortement de l'architecture et du système d'exploitation.
Vérification du mode d'accès ptrace
Divers endroits de l'API de l'espace utilisateur du noyau (pas seulement les opérations
ptrace()) exigent ce qu'on appelle des « vérifications de mode d'accès ptrace », dont le
résultat détermine si une opération est autorisée (ou, dans certains cas, fait renvoyer à
l'opération « read » des données nettoyées). Ces vérifications sont effectuées dans les
cas où un processus peut accéder à des informations sensibles concernant un autre
processus ou modifier son état. Les vérifications s'opèrent sur la base de facteurs tels
que les droits et les capacités des deux processus, le fait que le processus « cible »
puisse générer un fichier core, et des résultats des vérifications effectuées par un
module de sécurité Linux activé (LSM) (par exemple SELinux, Yama ou Smack) et par le LSM
commoncap (qui est toujours appelé).
Avant Linux 2.6.27, toutes les vérifications d'accès étaient d'un seul type. Depuis
Linux 2.6.27, on distingue deux niveaux de modes d'accès :
PTRACE_MODE_READ
Pour les opérations « read » ou d'autres moins dangereuses telles que :
get_robust_list(2) ; kcmp(2) ; la lecture de /proc/pid/auxv, /proc/pid/environ ou
de /proc/pid/stat ; ou le readlink(2) d'un fichier /proc/pid/ns/*.
PTRACE_MODE_ATTACH
Pour les opérations « write » ou d'autres plus dangereuses telles que : le
rattachement de ptrace (PTRACE_ATTACH) à un autre processus ou un appel
process_vm_writev(2) (PTRACE_MODE_ATTACH était celui par défaut avant
Linux 2.6.27).
Depuis Linux 4.5, les vérifications de mode d'accès ci-dessus sont combinées (opération
OU) avec un ou plusieurs des modificateurs suivants :
PTRACE_MODE_FSCREDS
Utiliser l'identifiant de groupe ou d’utilisateur du système de fichiers de
l'appelant (voir credentials(7)) ou les capacités effectives pour les vérifications
LSM.
PTRACE_MODE_REALCREDS
Utiliser l'identifiant de groupe ou d’utilisateur réel de l'appelant ou les
capacités autorisées pour les vérifications LSM. C'était l'action par défaut avant
Linux 4.5.
La combinaison d'un des modificateurs de droits avec un des modes d'accès ci-dessus étant
classique, certaines macros sont définies dans les sources du noyau pour les
combinaisons :
PTRACE_MODE_READ_FSCREDS
Définie en tant que PTRACE_MODE_READ | PTRACE_MODE_FSCREDS.
PTRACE_MODE_READ_REALCREDS
Définie en tant que PTRACE_MODE_READ | PTRACE_MODE_REALCREDS.
PTRACE_MODE_ATTACH_FSCREDS
Définie en tant que PTRACE_MODE_ATTACH | PTRACE_MODE_FSCREDS.
PTRACE_MODE_ATTACH_REALCREDS
Définie en tant que PTRACE_MODE_ATTACH | PTRACE_MODE_REALCREDS.
Un modificateur supplémentaire peut être lié (opération OU) au mode d'accès :
PTRACE_MODE_NOAUDIT (depuis Linux 3.3)
Ne pas effectuer la vérification de ce mode d'accès. Ce modificateur est utilisé
pour les vérifications de mode d'accès ptrace (telles que celles faites lors de la
lecture de /proc/pid/stat) qui filtrent ou nettoient la sortie au lieu de renvoyer
une erreur à l'appelant. Dans ces cas, l'accès au fichier n'est pas une violation
de sécurité et il n'y aucune raison de générer un enregistrement de l'évaluation de
la sécurité. Ce modificateur supprime la génération d'un tel enregistrement pour
cette vérification d'accès particulière.
Remarquez que toutes les constantes PTRACE_MODE_* décrites dans cette sous-section sont
internes au noyau et invisibles à l'espace utilisateur. Le nom des constantes est
mentionné ici pour identifier les différents types de vérification des modes d'accès
ptrace effectuées pour divers appels système et divers accès à des pseudofichiers (comme
dans /proc). Ces noms sont utilisés dans d'autres pages de manuel pour fournir un
raccourci simple d'identification des vérifications du noyau.
L'algorithme utilisé pour la vérification des modes d'accès ptrace détermine si le
processus appelant est autorisé à effectuer l'action correspondante sur le processus cible
(pour l'ouverture des fichiers /proc/pid, le « processus appelant » est celui qui ouvre le
fichier et le processus dont le PID correspond est le « processus cible »). L’algorithme
est comme suit :
(1) Si le thread appelant et cible sont dans le même groupe de threads, l'accès est
toujours autorisé.
(2) Si le mode d'accès indique PTRACE_MODE_FSCREDS, lors de la vérification de la
prochaine étape, utiliser l'identifiant d'utilisateur et de groupe du système de
fichiers appelant (comme indiqué dans credentials(7), les identifiants d'utilisateur
et de groupe du système de fichiers ont presque toujours la même valeur que les
identifiants effectifs correspondant).
Sinon le mode d'accès indique PTRACE_MODE_REALCREDS, donc utiliser l'identifiant
d'utilisateur et de groupe réels de l'appelant lors des vérifications de la prochaine
étape (la plupart des API qui vérifient les identifiants d’utilisateur et de groupe
utilisent les identifiants effectifs. Pour des raisons historiques, la vérification
PTRACE_MODE_REALCREDS utilise plutôt ceux réels).
(3) Interdire l'accès si rien de ce qui suit n'est vrai :
- Les identifiants utilisateur réel, effectif et défini de la cible correspondent à
l'identifiant utilisateur de l'appelant et les identifiants réels, effectifs et
définis de groupe de la cible correspondent à ceux de groupe de l'appelant.
- L'appelant a la capacité CAP_SYS_PTRACE dans l'espace de noms utilisateur de la
cible.
(4) Interdire l'accès si l'attribut « dumpable » du processus cible a une autre valeur
que 1 (SUID_DUMP_USER ; voir le point sur PR_SET_DUMPABLE dans prctl(2)) et
l'appelant n'a pas la capacité CAP_SYS_PTRACE dans l'espace de noms de l'utilisateur
du processus cible.
(5) L'interface security_ptrace_access_check() du LSM du noyau est appelée pour voir si
l'accès ptrace est autorisé. Le résultat dépend des LSM. L'implémentation de cette
interface dans le LSM commoncap suit les étapes suivantes :
(5.1) Si le mode d'accès comprend PTRACE_MODE_FSCREDS, utiliser l’ensemble des
capacités effectives de l'appelant dans la prochaine vérification ; sinon (si
le mode d'accès indique PTRACE_MODE_REALCREDS), utiliser l’ensemble des
capacités autorisées de l'appelant.
(5.2) Interdire l'accès si rien de ce qui suit n'est vrai :
- Les processus appelant et cible sont dans le même espace de noms
utilisateur et les capacités de l'appelant sont un surensemble des
capacités autorisées du processus cible.
- L'appelant a la capacité CAP_SYS_PTRACE dans l'espace de noms utilisateur
du processus cible.
Remarquez que le LSM commoncap ne fait pas de différence entre
PTRACE_MODE_READ et PTRACE_MODE_ATTACH.
(6) Si l'accès n'a pas été interdit par une étape précédente, il est autorisé.
/proc/sys/kernel/yama/ptrace_scope
Sur des systèmes ayant un Yama Linux Security Module (LSM) installé (donc si le noyau a
été configuré avec CONFIG_SECURITY_YAMA), le fichier /proc/sys/kernel/yama/ptrace_scope
(disponible depuis Linux 3.4) peut être utilisé pour restreindre la possibilité d'observer
un processus avec ptrace() (et ainsi, celle d'utiliser des outils tels que strace(1) et
gdb(1)). Le but de telles restrictions est d'empêcher des attaques en cascade par
lesquelles un processus infecté peut s'attacher avec un ptrace à d'autres processus
sensibles (comme un agent GPG ou une session SSH) appartenant à l'utilisateur, afin
d'obtenir d'autres droits qui pourraient exister en mémoire et ainsi, élargir l'objectif
de l'attaque.
Plus précisément, le Yama LSM limite deux types d'opérations :
- Toute opération qui effectue une vérification PTRACE_MODE_ATTACH de mode d'accès (par
exemple, PTRACE_ATTACH de ptrace(), voir le point sur les « vérifications de mode
d'accès ptrace » ci-dessus).
- PTRACE_TRACEME ptrace().
Un processus ayant la capacité CAP_SYS_PTRACE peut mettre à jour le fichier
/proc/sys/kernel/yama/ptrace_scope avec une ou plusieurs des valeurs suivantes :
0 (droits ptrace « classiques »)
Aucune restriction supplémentaire sur les opérations qui effectuent des
vérifications PTRACE_MODE_ATTACH (au-delà de celles imposées par le LSM commoncap
et les autres).
L'utilisation de PTRACE_TRACEME ne change pas.
1 (« ptrace restreint » (valeur par défaut)
Lors d'une opération qui exige une vérification PTRACE_MODE_ATTACH, le processus
appelant doit avoir soit la capacité CAP_SYS_PTRACE dans l'espace de noms
utilisateur du processus cible, soit une relation prédéfinie avec le processus
cible. Par défaut, la relation prédéfinie est que le processus cible doit être un
descendant de l'appelant.
Un processus cible peut utiliser l'opération PR_SET_PTRACER de prctl(2) pour
déclarer un PID supplémentaire autorisé à effectuer des opérations
PTRACE_MODE_ATTACH sur la cible. Voir le fichier
Documentation/admin-guide/LSM/Yama.rst des sources du noyau (ou
Documentation/security/Yama.txt avant Linux 4.13) pour plus de détails.
L'utilisation de PTRACE_TRACEME ne change pas.
2 (attachement « admin-only »)
Seuls les processus ayant la capacité CAP_SYS_PTRACE dans l'espace de noms de
l'utilisateur du processus cible peuvent effectuer des opérations
PTRACE_MODE_ATTACH ou observer les enfants qui utilisent PTRACE_TRACEME.
3 (« pas d'attachement »)
Aucun processus ne peut effectuer d'opération PTRACE_MODE_ATTACH ou observer les
enfants qui utilisent PTRACE_TRACEME.
Une fois que cette valeur a été écrite dans le fichier, elle ne peut pas être
modifiée.
Par rapport aux valeurs 1 et 2, remarquez que la création d'un nouvel espace de noms
utilisateur supprime de fait la protection apportée par Yama. Cela parce qu'un processus
dans l'espace de noms de l'utilisateur parent dont l'identifiant utilisateur effectif
correspond à celui de l'espace de noms enfant a toutes les capacités (y compris
CAP_SYS_PTRACE) lorsqu'il effectue des opérations dans l'espace de noms utilisateur de
l'enfant (et les descendants supprimés plus tard de cet espace de noms). Par conséquent,
quand un processus essaie d'utiliser les espaces de noms utilisateur pour s'isoler
lui-même, il affaiblit à son insu les protections apportées par le Yama LSM.
Différences entre bibliothèque C et noyau
L'interface de programmation de l'appel système est différente pour les requêtes
PTRACE_PEEKTEXT, PTRACE_PEEKDATA et PTRACE_PEEKUSER : elles stockent le résultat à
l’adresse indiquée par le paramètre data, et la valeur de retour est l’attribut d’erreur.
La fonction glibc encapsulant cet appel fournit une interface détaillée dans la section
DESCRIPTION ci-dessus, et le résultat qu'elle renvoie est le résultat de l'appel système.
BOGUES
Sur les machines ayant des en-têtes du noyau Linux 2.6, PTRACE_SETOPTIONS est déclaré avec
une valeur différente de celle de Linux 2.4. De ce fait, les applications compilées avec
des en-têtes du noyau Linux 2.6 ne peuvent pas s'exécuter sous Linux 2.4. Il est possible
de contourner cette difficulté en redéfinissant PTRACE_SETOPTIONS à PTRACE_OLDSETOPTIONS,
si cette dernière constante est définie.
Les notifications d'arrêt-groupe sont envoyées à l'observateur, mais pas au vrai parent.
C'était encore vrai sur 2.6.38.6.
Si un leader de groupe de threads est suivi et existe en appelant _exit(2), un arrêt
PTRACE_EVENT_EXIT lui arrivera (si réclamé), mais la notification WIFEXITED suivante ne
sera pas distribuée avant la fin de tous les autres threads. Comme expliqué précédemment,
si un des autres threads appelle execve(2), la mort du leader de groupe de threads ne sera
jamais signalée. Si le thread exécuté n'est pas suivi par cet observateur, l'observé ne
saura jamais qu'execve(2) est arrivé. Un contournement possible est de PTRACE_DETACHer le
leader de groupe de threads au lieu de le redémarrer dans ce cas. C'était encore vrai sur
2.6.38.6.
Un signal SIGKILL pourrait encore provoquer un arrêt PTRACE_EVENT_EXIT avant une véritable
mort du signal. Cela pourrait évoluer à l'avenir. SIGKILL est supposé tuer immédiatement
les tâches même sous ptrace. C'était encore vrai sur Linux 3.13.
Certains appels système renvoient EINTR si un signal a été envoyé à l'observé, mais que la
distribution a été supprimée par l'observateur (c'est une opération tout à fait
caractéristique : elle est normalement réalisée par les débogueurs sur tous les
attachements, afin de ne pas introduire de SIGSTOP défectueux). Depuis Linux 3.2.9, les
appels système suivants sont concernés (cette liste est sans doute incomplète) :
epoll_wait(2) et read(2) depuis un descripteur de fichier inotify(7). Le symptôme
classique de ce bogue est qu'en attachant à un processus quiescent avec la commande
strace -p <process-ID>
alors, au lieu de la ligne de sortie habituelle attendue comme
restart_syscall(<... reprise de l'appel interrompu ...>_
ou
select(6, [5], NULL, [5], NULL_
(« _ » indique la position du curseur), plusieurs lignes sont affichées. Par exemple :
clock_gettime(CLOCK_MONOTONIC, {15370, 690928118}) = 0
epoll_wait(4,_
Ce qui n'est pas visible ici est que le processus a été bloqué dans epoll_wait(2) avant
que strace(1) ne s'y soit attaché. L'attachement a forcé epoll_wait(2) à revenir dans
l'espace utilisateur avec l'erreur EINTR. Dans ce cas particulier, le programme a réagit à
EINTR en vérifiant l'heure actuelle et en exécutant encore epoll_wait(2) (les programmes
qui ne s'attendent pas à de telles erreurs EINTR « perdue » risquent de se comporter de
façon inattendue sur une attache strace(1)).
Contrairement aux règles normales, l'enveloppe de la glibc pour ptrace() peut positionner
errno sur zéro.
VOIR AUSSI
gdb(1), ltrace(1), strace(1), clone(2), execve(2), fork(2), gettid(2), prctl(2),
seccomp(2), sigaction(2), tgkill(2), vfork(2), waitpid(2), exec(3), capabilities(7),
signal(7)
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⟩.