¿Alguien sabe una manera simple de monitorear la generación del proceso raíz

Quiero ejecutar un script cuando se genera un nuevo proceso raíz. (en Linux) ¿Cómo puedo simplemente hacer eso?

Gracias

Esto suena como un trabajo perfecto para auditados. Una vez que haya auditado la ejecución, un servicio predeterminado en los sistemas modernos basados ​​en RedHat, puede crear una regla que haga exactamente lo que desea ejecutando

auditctl -a task,always -F uid=0

Al romper esta regla de comando, haciendo un uso excesivo de la página de manual, encontramos que:

   -a list,action
          task       Add  a  rule to the per task list. This rule list is used
                     only at the time a task is created -- when fork() or
                     clone() are called by the parent task. When using this
                     list, you should only use fields that are known at task
                     creation time, such as the uid, gid, etc.
          always     Allocate an audit context, always fill it in at syscall 
                     entry time, and always write out a record at syscall exit
                     time.

Por lo tanto, siempre escriba un registro para esta acción cada vez que salga una llamada de fork o sistema de clonación.

La opción final puede considerarse como una cadena de filtro, en nuestro uso -F uid=0simplemente nos restringe a los casos en que el uid del propietario del proceso es 0.

Tenga en cuenta que esta regla se puede ejecutar en tiempo de ejecución asegurándose de que auditado esté configurado correctamente y agregando la regla
-a task,always -F uid=0
al archivo relevante para su distribución, lo más probable/etc/audit/audit.rules

Solo tenga en cuenta que esto será bastante ruidoso, y cualquiera que esté haciendo sus revisiones de registro deberá estar preparado para ello.

No creo que haya una manera limpia de hacer esto sin recompilar su kernel con CONFIG_PROC_EVENTS y ​​/ o CONFIG_KPROBES (aunque me encantaría saber si hay una manera de hacerlo, así que he votado su pregunta).

Tuve una idea de usar iwatch / inotify para la creación de directorios dentro de / proc, pero no pareció funcionar, ni auditctl. Parece que su mejor opción, aunque sucia, es analizar continuamente ps para un cambio de un script. El siguiente código de Perl lo haría, aunque sería propenso a perder algo e ignorarlo ps(ya que de lo contrario se dispararía):

perl -e 'my %pids; while(1) { my @pids = `ps -U root -u root`; foreach (@pids) { next if /ps$/; ($pid) = /^\s*(\d+)\D/; if (!$pids{$pid}) { $pids{$pid}++; print "Process $pid created (" . `cat /proc/$pid/cmdline` . ")\n"; } } }

La mejor forma en que puedo pensar sería construir a partir de la biblioteca de snoopy . snoopy es una biblioteca compartida muy pequeña que se engancha /etc/ld.so.preloady envuelve las execve()llamadas del sistema. Es configurable para registrar todos exec(), o solo aquellos desde la raíz. En su encarnación actual, snoopy registra en syslog cada vez que execve()ocurre un evento coincidente (una llamada al sistema ). Sin embargo, no es un programa grande (un par de cientos de líneas de código, como máximo), y podría modificarse sin tanta dificultad para ejecutar un script en lugar de (o además de) registrar la actividad. Snoopy está escrito en C.

Algunas cosas a tener en cuenta:

• Si ejecuta un script cada vez que se genera un proceso raíz, su script será un proceso raíz, que deberá generar el script nuevamente, que será otro proceso raíz, etc. Tenga cuidado de no entrar en un ciclo allí.
• En una caja típica de Linux, hay muchos procesos que se ejecutan como root y se generan regularmente. Por ejemplo, cron puede generar cronjobs del sistema como root cada minuto o pocos minutos. Si solo está buscando que esto suceda cuando un usuario inicie sesión como root, será más trabajo.