Come terminare un processo iniziato con un altro utente senza essere root o sudoer?

in un ambiente Linux, devo terminare un processo che è stato avviato dall'utente2 se sono utente1 senza essere sudoer o usare root. Sai se esiste un modo per impostarlo quando si avvia il processo? Come un elenco di utenti autorizzati a terminare il processo?

Il fatto è che istanze simultanee dello stesso processo possono essere avviate da utenti diversi, ecco perché non è conveniente per me impostare l'id di gruppo sul processo. Altri utenti che non fanno parte del gruppo non saranno in grado di avviare un secondo processo parallelo.

Quello che ho è un elenco di utenti autorizzati ad avviare il processo, definito nel database, prima di iniziare il processo controllo che l'utente corrente nell'elenco e, in caso affermativo, avvio il processo con l'utente corrente. Se un secondo utente ha permesso di fare ciò che vuole uccidere il processo, mi piacerebbe che fosse autorizzato a farlo, ma non voglio che sia sudoer.

Pertanto, stavo pensando di creare un processo in esecuzione come root che riceve la richiesta di uccidere i processi da un utente, controlla se l'utente è autorizzato ad avviare / interrompere il processo e uccide il processo.

Pensi che potrebbe essere la soluzione migliore?

Mi dispiace, ma questo semplicemente non è possibile (questo è di progettazione). Tuttavia, se membri di un gruppo comune, user1 potrebbe scrivere su un file che il processo di user2 verifica, indicando al processo che dovrebbe terminare.

Oppure, user2 potrebbe eseguire qualcosa in background che controlla un file, quindi invia i segnali appropriati. L'utente1 deve semplicemente scrivere su quel file. Questo potrebbe essere più semplice, in quanto non richiederebbe alcuna modifica dei programmi di user2.

Convenzionalmente, no, l'utente1 non può inviare segnali POSIX al processo dell'utente2.

A meno che ACL o SELinux o qualcos'altro abbiano un modo migliore per farlo, il modo in cui l'ho visto è con uno script SetUID . Come puoi immaginare, sono famosi per essere rischi per la sicurezza.

Per quanto riguarda il tuo caso, supponi che procOwner sia il nome utente per il proprietario del processo e che userA (uid 1000), userB (uid 1201) e userC (uid 1450) siano le persone autorizzate ad interrompere il processo.

killmyproc.bash:

#!/bin/bash
case ${UID} in
1000|1201|1450) ;;
*) echo "You are not allowed to kill the process."
   exit 1;;
esac

kill ${PROCESS_ID}
# PROCESS_ID could also be stored somewhere in /var/run.

Quindi impostare il proprietario e le autorizzazioni con:

chown procOwner:procGroup killmyproc.bash
chmod 6750 killmyproc.bash

Inoltre, inserisci userA, userB e userC nel gruppo procGroup.

Non convenzionalmente: avere un utente che viene e uccide i processi di qualcun altro è la massima vulnerabilità di negazione del servizio.

Può essere fatto se il processo target coopera. Un modo potrebbe essere quello di monitorare un evento esterno (come un file creato in / var / tmp, o un messaggio su un socket), chiedendogli di uccidersi. Se non è possibile scriverlo per farlo, è possibile scrivere un wrapper per esso che lo avvia e quindi esegue il monitoraggio, uccidendo il processo figlio se si verifica l'evento.

No, non puoi.

Se si desidera condividere i processi con altri utenti, è necessario avviare il processo con un ID utente comune.

Naturalmente, è possibile scrivere il programma in modo tale da terminare con grazia quando riceve un determinato segnale (termine usato in modo generico per indicare "un evento predeterminato", non un segnale POSIX) da un determinato (elenco di) utenti.

È possibile scrivere un programma di suid che solo gli utenti di un determinato gruppo possono eseguire e che invia il segnale appropriato al processo. Non sono sicuro che avresti voluto escludere anche i sussidi.

il bit di suid non funziona con gli script bash. imho, il modo migliore è scrivere uno script wrapper "killservice". Supponiamo che il tuo servizio sia in esecuzione come utente del servizio utente

#!/bin/bash
sudo -u serviceuser /usr/bin/killserviceworker

poi

# addgroup servicekiller
# chown root:servicekiller /usr/bin/killservice
# chmod 750 /usr/bin/killservice
# adduser bob servicekiller

quindi, devi solo aggiungere la regola in / etc / sudoers per consentire loro di eseguire / usr / bin / killserviceworker come utente del servizio utente senza chiedere una password:

servicekiller        ALL = (serviceuser:serviceuser) NOPASSWD: /usr/bin/killserviceworker

killserviceworker può assomigliare a questo:

#!/bin/bash
kill ${cat /run/service.pid}