Comprendre les appels système Linux avec la commande strace

Lorsque des programmes exécutés sous Linux veulent utiliser les ressources gérées par le système d'exploitation (lecture de fichiers, création de processus, etc.), ils effectuent des appels système à l'OS. Les appels système fonctionnent au niveau du noyau et effectuent les opérations nécessaires, laissant le contrôle au programme appelant. L'outil strace permet de tracer ces appels système sous Linux.

Utilisation typique de la commande strace

Pour surveiller les appels système d'une application, invoquez simplement la commande avec tracer au format suivant :

strace ls/tmp

Cependant, il existe souvent des processus qui démarrent beaucoup plus tôt et continuent de fonctionner en arrière-plan. En raison de problèmes, vous souhaiterez peut-être collecter des informations supplémentaires associées à ces processus. Vous pouvez joindre tracer à toute application en cours d'exécution en donnant l'ID de processus du processus au -p paramètre:

strace -p 2759

Production:

Gardez une trace des threads et des fourches d'une application

Avec strace, vous pouvez vérifier tous les threads et autres processus enfants qui sont un fork de l'application en utilisant le -F drapeau.

strace-f-p 2759

Production:

Vérifier certains appels système avec strace

La sortie strace par défaut peut parfois être assez encombrée à suivre. Si vous ne souhaitez suivre que certains appels système, vous pouvez le faire avec le -e paramètre:

strace -f -e trace=ouvrir, écrire, fermer, se connecter,sélectionner -p 19770

Pour tracer uniquement les appels système liés aux opérations sur les fichiers, utilisez -e trace=fichier:

strace -e trace=fichier -p 19770

Pour filtrer uniquement les appels système liés au réseau, spécifiez -e trace=réseau dans la commande :

strace -e trace=réseau -p 19770

Obtenez des informations sur le temps en quelques secondes

Lors de la sortie d'appels système, vous pouvez utiliser le -t paramètre pour obtenir des informations de temps avec une précision en secondes. La plupart du temps, la précision ne suffira pas à vos besoins. Dans de telles situations, vous pouvez utiliser le -tt paramètre pour obtenir des informations temporelles avec une précision de l'ordre de la microseconde :

strace -tt ls /tmp

Collecter des statistiques sur les appels système

Avec le -c paramètre, vous pouvez collecter des statistiques sur les appels système aussi longtemps que vous le souhaitez :

strace-f-c-p 19770

Enregistrer les journaux dans un fichier

Si vous exécutez strace pendant une longue période et souhaitez examiner les journaux résultants plus en détail ultérieurement, vous devrez enregistrer les journaux. Avec le -o paramètre, vous pouvez spécifier le fichier dans lequel strace doit enregistrer les journaux :

strace -f -o /tmp/strace.log -e trace=fichier ls /tmp

Processus de blocage de ptrace

En utilisant l'appel système prctl, toute application sous Linux peut s'empêcher d'être contrôlée par des utilisateurs non root utilisant ptrace. Si l'application efface le PR_SET_DUMPABLE flag pour lui-même via prctl, les utilisateurs autres que root ne pourront pas contrôler cette application avec ptrace, même s'ils ont le droit de signaler l'application.

L'une des utilisations les plus typiques de cette fonctionnalité est observée dans le logiciel d'agent d'authentification OpenSSH. Ainsi, le contrôle de l'application par une autre application avec ptrace est empêché lors de l'authentification de l'utilisateur.

ptrace et sécurité

En raison de la fonction ptrace définie dans le modèle de processus Linux traditionnel, tout logiciel que vous exécutez sur votre système avec votre utilisateur a le pouvoir d'y insérer du code malveillant. De l'outil xterm le plus simple à applications de navigateur Web avancées, ces logiciels malveillants peuvent prendre le contrôle de toutes vos autres applications en cours d'exécution, grâce à l'appel système ptrace, et copier des informations importantes sans que vous vous en rendiez compte.

En réponse à cette situation, dont beaucoup d'utilisateurs ne sont pas conscients, un mécanisme de protection a été développé avec le module de sécurité appelé Yama dans le noyau Linux.

Vous pouvez contrôler la réponse à l'appel système ptrace via le /proc/sys/kernel/yama/ptrace_scope dossier. Par défaut, ce fichier écrit une valeur de 0.

Les valeurs suivantes sont acceptables :

De nombreux développeurs ne savent pas que les applications peuvent désactiver elles-mêmes ptrace via prctl, à l'exception de l'utilisateur root. Bien que des logiciels liés à la sécurité tels que l'agent OpenSSH effectuent ces opérations, il ne serait pas juste d'attendre le même comportement de tous les logiciels exécutés sur le système.

Récemment, certaines distributions Linux ont commencé à définir la valeur par défaut du ptrace_scope fichier, décrit ci-dessus, à 1. Ainsi, avec des opérations ptrace restreintes, un environnement de travail plus sûr est fourni dans tout le système.

Utilisation d'un exemple de strace

Enregistrez l'exemple d'application ci-dessous avec le nom minitrace.c. Ensuite, vous pouvez le compiler avec la commande suivante :

gcc-ominitraceminitrace.c

Code:

#inclure <sys/ptrace.h>
#inclure <sys/reg.h>
#inclure <sys/wait.h>
#inclure <sys/types.h>
#inclure <unistd.h>
#inclure <stdlib.h>
#inclure <stdio.h>
#inclure <erreur.h>
#inclure <chaîne.h>
entierwait_for_syscall(enfant pid_t)
	{
entier statut;
pendant que (1) {
 ptrace (PTRACE_SYSCALL, enfant, 0, 0);
 waitpid (enfant, &statut, 0);
 si (WIFSTOPPED(statut) && WSTOPSIG(statut) & 0x80)
retourner0;
 si (WIFEXITE (statut))
retourner1;
 }
	}
entierfaire_enfant(entier argc, carboniser **argv)
	{
carboniser *args [argc+1];
 memcpy (args, argv, argc * sizeof(carboniser*));
 args[argc] = NUL;
 ptrace(PTRACE_TRACEME);
tuer(getpid(), SIGSTOP);
retourner execvp (arguments[0], arguments) ;
	}
entierdo_trace(enfant pid_t)
	{
entier état, appel système, retval ;
 waitpid (enfant, &statut, 0);
 ptrace (PTRACE_SETOPTIONS, enfant, 0, PTRACE_O_TRACESYSGOOD);
pendant que(1) {
si (wait_for_syscall (enfant) != 0) Pause;
syscall = ptrace (PTRACE_PEEKUSER, enfant, sizeof(longue)*ORIG_RAX);
 fprintf (stderr, "appel système(%d) = ", appel système);
si (wait_for_syscall (enfant) != 0) Pause;
retval = ptrace (PTRACE_PEEKUSER, enfant, sizeof(longue)*RAX);
 fprintf (stderr, "%ré
", récupération);
 }
retourner0;
	}
entierprincipale(entier argc, carboniser **argv)
	{
 si (argc < 2) {
 fprintf (stderr, "Utilisation: %s arguments de prog
", argv[0]);
sortie(1);
 }
 pid_t enfant = fourche();
 si (enfant == 0) {
retourner do_child (argc-1, argv+1);
 } autre {
retourner do_trace (enfant);
 }
	}

Après avoir compilé l'application, vous pouvez exécuter n'importe quelle commande avec minitrace et examinez la sortie :

Vous pouvez utiliser strace à de nombreuses fins

strace peut aider à trouver des bogues dans des programmes qui utilisent inutilement des ressources système. De même, la caractéristique qu'un programme présente lors de l'utilisation des ressources du système d'exploitation peut également être révélée avec strace.

Étant donné que strace écoute directement les appels système, il peut révéler la dynamique d'exécution, que le code du programme en cours d'exécution soit ouvert/fermé. Il est possible d'avoir une idée de la raison pour laquelle les programmes génèrent une erreur lorsqu'ils commencent à utiliser strace.

De même, strace vous aide à comprendre pourquoi un programme se termine de manière inattendue. Par conséquent, être familier avec strace est très important dans le développement du noyau Linux et l'administration système.

Créez votre propre système d'exploitation avec Linux From Scratch [Linux]

Lire la suite