O que acontece quando um usuário não root envia sinais para o processo do usuário root?

Question

Eu estou querendo saber sobre a segurança dos sinais do UNIX.

SIGKILL irá matar o processo. Então, o que acontece quando um processo de usuário não raiz envia um sinal para o processo de um usuário root? O processo ainda realiza o manipulador de sinais?

Eu sigo a resposta aceita (gollum's), e eu digito man capabilites , e eu encontro muitas coisas sobre o kernel 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.

    

Answer 1

No Linux, depende das capacidades do arquivo.

Pegue a seguinte fonte simples de mykill.c :

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

construa:

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

Agora, como usuário root, inicie um processo de suspensão em segundo plano:

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

Agora, como o usuário normal tenta matá-lo:

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

Agora, como usuário root, altere o /tmp/mykill caps:

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

E tente novamente como usuário normal:

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

Por fim, exclua /tmp/mykill por motivos óbvios;)

    

Answer 2

Nada:

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

    

Answer 3

A página

kill(2) man explica:

Linux Notes

Across different kernel versions, Linux has enforced different rules for the permissions required for an unprivileged process to send a signal to another process. In kernels 1.0 to 1.2.2, a signal could be sent if the effective user ID of the sender matched that of the receiver, or the real user ID of the sender matched that of the receiver. From kernel 1.2.3 until 1.3.77, a signal could be sent if the effective user ID of the sender matched either the real or effective user ID of the receiver. The current rules, which conform to POSIX.1-2001, were adopted in kernel 1.3.78.

    

Answer 4

o sinal seria transmitido, mas o proprietário do processo pertence à raiz. assim, o outro usuário não tem o direito de encerrar o processo, portanto, você receberá um problema de erro de permissão.

encerra o processo só é possível quando você possui a propriedade (direitos adequados) do processo.