Verificación de los binarios de comando antes de la ejecución

¿Hay algún método para verificar lo que realmente está ejecutando desde un script bash?

Digamos que su escritura del golpe está llamando a varios comandos (por ejemplo: tar, mail, scp, mysqldump) y que está dispuesto para asegurarse de que tares la real, verdadera tar, que es determinable por el rootusuario sea el propietario del archivo y directorio padre y el único que tiene permiso de escritura y no algunos /tmp/surprise/tarcon www-datao apache2siendo el dueño.

Claro que sé sobre PATHel medio ambiente, tengo curiosidad por saber si esto se puede verificar adicionalmente desde un script bash en ejecución y, de ser así, ¿cómo exactamente?

Ejemplo: (pseudocódigo)

tarfile=$(which tar)
isroot=$(ls -l "$tarfile") | grep "root root"
#and so on...

En lugar de validar los archivos binarios que va a ejecutar, puede ejecutar los archivos binarios correctos desde el principio. Por ejemplo, si desea asegurarse de que no va a ejecutar /tmp/surprise/tar, simplemente ejecute /usr/bin/taren su secuencia de comandos. Alternativamente, establezca su $PATHvalor cuerdo antes de ejecutar cualquier cosa.

Si no confía en los archivos /usr/bin/y en otros directorios del sistema, no hay forma de recuperar la confianza. En su ejemplo, está controlando al propietario ls, pero ¿cómo sabe que puede confiar ls? El mismo argumento se aplica a otras soluciones como md5sumy strace.

Cuando se requiere una gran confianza en la integridad del sistema, se utilizan soluciones especializadas como IMA . Pero esto no es algo que pueda usar desde un script: todo el sistema debe configurarse de una manera especial, con el concepto de archivos inmutables.

Si un intruso ha obtenido acceso a su sistema y puede modificarlo $PATH(lo que no debe incluir /tmpbajo ninguna circunstancia), entonces es demasiado tarde para comenzar a preocuparse por la propiedad de los ejecutables.

En cambio, debería leer sobre cómo lidiar con una intrusión .

Es mejor concentrarse en evitar la intrusión por completo.

Si tiene un sistema donde este tipo de cosas son importantes, puede ser una buena idea aislar las partes que deben ser públicas de las partes que deben ser privadas, así como realizar una auditoría de los modos de comunicación. entre estos

Es posible hasta cierto punto verificando el md5sumde un archivo. Por lo tanto, en los sistemas que usan aptadministración de paquetes, en mi caso particular, Ubuntu 16.04, existe el archivo /var/lib/dpkg/info/tar.md5sums, que almacena las sumas md5 de todos los archivos que vinieron tardurante la instalación. Por lo tanto, podría escribir una declaración if simple que verifique si la salida de md5sum /bin/tarcoincide con lo que está en ese archivo.

Eso, por supuesto, supone que el archivo en sí no ha sido alterado. Por supuesto, esto solo puede suceder cuando el atacante ha obtenido acceso root / sudo, momento en el que todas las apuestas están desactivadas.

Sí, hay un método: el incorporado type. Al contrario del whichcomando que solo busca en su RUTA, typele dirá si el nombre del comando es en realidad una palabra clave reservada, un nombre incorporado, un alias, una función o un archivo de disco.

$ type -t foobar || echo "Not found"
Not found

$ type -t echo
builtin

$ enable -n echo; type -t echo; type -p echo
file
/usr/bin/echo

$ echo() { printf "(echoing) %s\n" "$*"; }; type -t echo
function

$ alias echo="/bin/echo 'I say: ' "; type -t echo
alias

Además type -ale dará todos los candidatos para su comando (desde la primera hasta la última opción):

$ type -a echo
echo is aliased to `/bin/echo 'I say: ' '
echo is a function
echo () 
{ 
    printf "(echoing) %s\n" "$*"
}
echo is a shell builtin
echo is /usr/local/bin/echo
echo is /bin/echo

Finalmente, si solo le preocupan los binarios en su disco, puede usar type -Papara obtener todos los binarios en su RUTA (el mismo orden que el anterior):

$ type -Pa tar
/home/me/bin/tar                <= oh oh, is this normal?
/bin/tar

Dicho esto, typesolo no le dirá exactamente qué comando se llamará al final. Por ejemplo, si su tares un alias que llama a un binario (por ejemplo alias tar="/tmp/tar"), typele dirá que es un alias.

Puede verificar qué comandos está ejecutando exactamente un script utilizando strace. Por ejemplo:

strace -f -e execve ./script.sh

Con el siguiente script:

#!/bin/bash
touch testfile.txt
echo "Hello" >> testfile.txt
cat testfile.txt
rm testfile.txt

stracele dirá la ruta exacta a los comandos ejecutados cuando se usa con el -e execveparámetro:

execve("./script.sh", ["./script.sh"], [/* 69 vars */]) = 0 
Process 8524 attached
[pid  8524] execve("/usr/bin/touch", ["touch", "testfile.txt"], [/* 68 vars */]) = 0 
[pid  8524] +++ exited with 0 +++
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=8524, si_status=0, si_utime=0, si_stime=0} --- 
Process 8525 attached [pid > 8525] execve("/bin/cat", ["cat", "testfile.txt"], [/* 68 vars */]) = 0
Hello [pid  8525] +++ exited with 0 +++
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=8525, si_status=0, si_utime=0, si_stime=0} --- 
Process 8526 attached [pid > 8526] execve("/bin/rm", ["rm", "testfile.txt"], [/* 68 vars */]) = 0
[pid  8526] +++ exited with 0 +++
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=8526, si_status=0, si_utime=0, si_stime=0} ---
+++ exited with 0 +++

Parámetros (de strace man):

-f: Rastree procesos secundarios tal como se crean mediante procesos actualmente rastreados como resultado de las llamadas al sistema fork (2), vfork (2) y clone (2). Tenga en cuenta que -p PID -fadjuntará todos los subprocesos del PID del proceso si es multiproceso, no solo el subproceso con thread_id = PID.

-e trace=file: Rastrea todas las llamadas del sistema que toman un nombre de archivo como argumento. Puede pensar en esto como una abreviatura para la -e trace=open,stat,chmod,unlink,...que es útil ver a qué archivos hace referencia el proceso. Además, el uso de la abreviatura asegurará que no olvide accidentalmente incluir una llamada como lstat en la lista.

El sistema operativo Linux se basa en archivos y muchos comandos ejecutados en Linux probablemente resolverán algunos cambios en los archivos ubicados en su máquina. Debido a eso, tal vez sea ​​la mejor solución para su problema. Puede probar sus comandos para cualquier cambio en el sistema de archivos antes de que se ejecute.

Hay un comando 'strace' que descompila su comando en partes ...

Si realmente quiere profundizar, desea verificar los descompiladores para los scripts que se ejecutarán. En otras palabras, debe verificar la interpretación del ensamblador de ese comando. Para golpear allí objdump -d. Los scripts bin de Linux se crean principalmente con Clenguaje de programación, por lo tanto, use un buen Cdescompilador.