Cosa succede quando un utente non root invia segnali al processo dell'utente root?

Mi chiedo la sicurezza dei segnali UNIX.

SIGKILLucciderà il processo. Quindi, cosa succede quando il processo di un utente non root invia un segnale al processo di un utente root? Il processo esegue ancora il gestore del segnale?

Seguo la risposta accettata (di Gollum) e scrivo man capabilitese trovo molte cose sul kernel di Linux. Da 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.

Su Linux dipende dalle capacità del file.

Prendi la seguente semplice mykill.cfonte:

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

costruiscilo:

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

Ora come utente root avvia un processo di sospensione in background:

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

Ora come normale utente tenta di ucciderlo:

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

Ora come utente root cambia i /tmp/mykilltappi:

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

E riprova come utente normale:

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

Infine, /tmp/mykillper favore cancella per ovvi motivi;)

Niente:

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

kill(2) la pagina man spiega:

Note Linux

In diverse versioni del kernel, Linux ha imposto regole diverse per le autorizzazioni necessarie per un processo senza privilegi per inviare un segnale a un altro processo. Nei kernel da 1.0 a 1.2.2, un segnale potrebbe essere inviato se l'ID utente effettivo del mittente corrispondesse a quello del destinatario, o l'ID utente reale del mittente corrispondesse a quello del destinatario. Dal kernel 1.2.3 all'1.3.77, potrebbe essere inviato un segnale se l'ID utente effettivo del mittente corrispondesse all'ID utente reale o effettivo del destinatario. Le regole attuali, conformi a POSIX.1-2001, sono state adottate nel kernel 1.3.78.

il segnale sarebbe portato ma il proprietario del processo appartiene al root. quindi, l'altro utente non ha il diritto di terminare il processo in modo da ricevere un problema di errore di autorizzazione.

terminare il processo è possibile solo se si possiede la proprietà (diritti propri) del processo.