Que se passe-t-il lorsqu'un utilisateur non root envoie des signaux au processus de l'utilisateur root?

33

Je m'interroge sur la sécurité des signaux UNIX.

SIGKILLva tuer le processus. Alors, que se passe-t-il lorsqu'un processus d'utilisateur non root envoie un signal au processus d'un utilisateur root? Le processus exécute-t-il toujours le gestionnaire de signaux?

Je suis la réponse acceptée (gollum), et je tape man capabilites, et je trouve beaucoup de choses sur le noyau Linux. De man capabilities:

NAME

   capabilities - overview of Linux capabilities
DESCRIPTION

   For the purpose of performing permission checks, traditional UNIX
   implementations distinguish two categories of processes: privileged
   processes (whose effective user ID is 0, referred to as superuser or
   root), and unprivileged processes (whose effective UID is nonzero).
   Privileged processes bypass all kernel permission checks, while
   unprivileged processes are subject to full permission checking based
   on the process's credentials (usually: effective UID, effective GID,
   and supplementary group list).

   Starting with kernel 2.2, Linux divides the privileges traditionally
   associated with superuser into distinct units, known as capabilities,
   which can be independently enabled and disabled.  Capabilities are a
   per-thread attribute.
source d'amour
la source
5
Autre que SIGKILL, cas particulier géré entièrement par le noyau, les signaux ne sont que des requêtes. Le processus de réception peut faire tout ce qu'ils veulent avec eux.
Chepner
3
@chepner Autre que SIGKILL et SIGSTOP ...
mercredi
1
@chepner Le processus de réception doit décider activement qu'il veut gérer le signal. Si le processus de réception ne l’a pas encore fait, beaucoup de signaux le tueront par défaut de la même manière SIGKILL. Initialement SIGINT, SIGKILLet SIGTERMaura exactement le même effet, la seule différence est que le processus de réception peut modifier ce paramètre par défaut pour certains d’entre eux.
Kasperd

Réponses:

34

Sous Linux, cela dépend des capacités du fichier.

Prenez la mykill.csource simple suivante :

#include <stdio.h>
#include <sys/types.h>
#include <signal.h>
#include <stdlib.h>

void exit_usage(const char *prog) {
        printf("usage: %s -<signal> <pid>\n", prog);
        exit(1);
}

int main(int argc, char **argv) {
        pid_t pid;
        int sig;

        if (argc != 3)
                exit_usage(argv[0]);

        sig = atoi(argv[1]);
        pid = atoi(argv[2]);

        if (sig >= 0 || pid < 2)
                exit_usage(argv[0]);

        if (kill(pid, -sig) == -1) {
                perror("failed");
                return 1;
        }
        printf("successfully sent signal %d to process %d\n", -sig, pid);

        return 0;
}

construit le:

gcc -Wall mykill.c -o /tmp/mykill

Maintenant, en tant qu'utilisateur root, démarrez un processus de veille en arrière-plan:

root@horny:/root# /bin/sleep 3600 &
[1] 16098

Maintenant, en tant qu'utilisateur normal, essayez de le tuer:

demouser@horny:/home/demouser$ ps aux | grep sleep
root     16098  0.0  0.0  11652   696 pts/20   S    15:06   0:00 sleep 500

demouser@horny:/home/demouser$ /tmp/mykill -9 16098
failed: Operation not permitted

Maintenant, en tant qu'utilisateur root, modifiez les /tmp/mykillmajuscules:

root@horny:/root# setcap cap_kill+ep /tmp/mykill

Et essayez à nouveau en tant qu'utilisateur normal:

demouser@horny:/home/demouser$ /tmp/mykill -9 16098
successfully sent signal 9 to process 16098

Enfin, veuillez supprimer /tmp/mykillpour des raisons évidentes;)

gollum
la source
3
Suivez votre indice, je tape "manbility" et je trouve pas mal de choses sur le noyau linux
lovespring, le
24

Rien:

strace kill -HUP 1
[...]
kill(1, SIGHUP)    = -1 EPERM (Operation not permitted)
[...]
Hauke ​​Laging
la source
1
Ce type de sécurité est-il effectué par niveau OS ou codé en dur dans le gestionnaire de signal de l'utilisateur?
Lovespring
3
@lovespring Le noyau ne transmet pas le signal au processus cible. L'appel système est renvoyé avec une erreur et mis à part ignoré.
Hauke ​​Laging
Ce n'est pas vrai en général. Cela dépend des capacités.
Gollum
1
@psmears oui, mais d'autres ont des concepts similaires (par exemple, "privilèges" sur solaris). Donc, la réponse "Rien" est définitivement fausse.
Gollum
1
@gollum: Ce n'est pas tout à fait faux (après tout, c'est le comportement par défaut de tous les systèmes d'exploitation de la famille Unix, et le seul possible sur de nombreux noyaux - y compris les anciens noyaux Linux) - mais vous avez raison de dire qu'il est incomplet - mais il suffit de mentionner Les "capacités" sans entrer plus dans le détail sur l'endroit où elles sont signalées est également incomplet dans une question sur Unix général :)
psmears le
5

kill(2) La page de manuel explique:

Notes Linux

À travers différentes versions du noyau, Linux a imposé différentes règles pour les autorisations requises pour qu'un processus sans privilège envoie un signal à un autre processus. Dans les noyaux 1.0 à 1.2.2, un signal pourrait être envoyé si l'ID utilisateur effectif de l'expéditeur correspond à celui du destinataire, ou si l'ID utilisateur réel de l'expéditeur correspond à celui du destinataire. À partir du noyau 1.2.3 jusqu'à la version 1.3.77, un signal peut être envoyé si l'ID utilisateur effectif de l'expéditeur correspond à l'ID utilisateur réel ou effectif du destinataire. Les règles actuelles, conformes à POSIX.1-2001, ont été adoptées dans le noyau 1.3.78.

jai_s
la source
1.3.78 est une histoire extrêmement ancienne, tout comme 1.3. date de 1995 ou à peu près. 1.3 était la série de développement menant à 2.0 (en 1996)
vonbrand
-1

le signal serait acheminé mais le propriétaire du processus appartiendrait à root. donc, l'autre utilisateur n'a pas le droit de mettre fin au processus, vous recevrez donc un problème d'erreur d'autorisation.

mettre fin au processus n'est possible que si vous possédez la propriété (les droits appropriés) du processus.

Naveen Dharman
la source
Non, sys_kill renvoie -1 et errno sera -EPERM.
Peter dit réintégrer Monica