Was passiert, wenn ein Benutzer ohne Rootberechtigung Signale an den Prozess des Rootberechtigten sendet?

Ich frage mich über die Sicherheit von UNIX-Signalen.

SIGKILLbricht den Prozess ab. Was passiert also, wenn ein Nicht-Root-Benutzer ein Signal an den Prozess eines Root-Benutzers sendet? Führt der Prozess den Signalhandler noch aus?

Ich folge der akzeptierten Antwort (gollum's), tippe man capabilitesund finde viele Dinge über den Linux-Kernel. Von 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.

Unter Linux hängt es von den Dateifunktionen ab.

Nehmen Sie die folgende einfache mykill.cQuelle:

#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;
}

baue es:

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

Starten Sie nun als Benutzer root einen Sleep-Prozess im Hintergrund:

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

Jetzt als normaler Benutzer versuchen, es zu töten:

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

Ändern Sie nun als Root-Benutzer die /tmp/mykillCaps:

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

Und versuchen Sie es als normaler Benutzer erneut:

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

Zum Schluss bitte /tmp/mykillaus offensichtlichen Gründen streichen ;)

Nichts:

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

kill(2) Manpage erklärt:

Linux-Notizen

In verschiedenen Kernelversionen hat Linux unterschiedliche Regeln für die Berechtigungen festgelegt, die erforderlich sind, damit ein nicht privilegierter Prozess ein Signal an einen anderen Prozess sendet. In den Kerneln 1.0 bis 1.2.2 könnte ein Signal gesendet werden, wenn die effektive Benutzer-ID des Absenders mit der des Empfängers übereinstimmt oder die tatsächliche Benutzer-ID des Absenders mit der des Empfängers übereinstimmt. Von Kernel 1.2.3 bis 1.3.77 konnte ein Signal gesendet werden, wenn die effektive Benutzer-ID des Absenders entweder mit der tatsächlichen oder der effektiven Benutzer-ID des Empfängers übereinstimmte. Die aktuellen Regeln, die POSIX.1-2001 entsprechen, wurden in Kernel 1.3.78 übernommen.

das Signal würde tragen, aber der Prozessbesitzer gehört zu root. Daher hat der andere Benutzer nicht das Recht, den Vorgang zu beenden, sodass Sie ein Berechtigungsfehlerproblem erhalten.

Das Beenden eines Prozesses ist nur möglich, wenn Sie das Eigentum (die entsprechenden Rechte) an dem Prozess besitzen.