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

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.

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;)

Rien:

strace kill -HUP 1
[...]
kill(1, SIGHUP)    = -1 EPERM (Operation not permitted)
[...]

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.

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.