Vérification des binaires de commande avant exécution

Existe-t-il des méthodes pour vérifier ce que vous exécutez réellement à partir d'un script bash?

Supposons que votre script bash appelle plusieurs commandes (par exemple: tar, mail, scp, mysqldump) et vous êtes prêt à vous assurer que tarle réel, réel tar, qui est déterminable par l' rootutilisateur étant le fichier et le répertoire parent propriétaire et le seul avec des autorisations d'écriture et pas certains /tmp/surprise/taravec www-dataou apache2étant le propriétaire.

Bien sûr, je connais PATHet l'environnement, je suis curieux de savoir si cela peut également être vérifié à partir d'un script bash en cours d'exécution et, si oui, comment exactement?

Exemple: (pseudo-code)

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

Au lieu de valider les binaires que vous allez exécuter, vous pouvez exécuter les bons binaires dès le départ. Par exemple, si vous voulez vous assurer de ne pas exécuter /tmp/surprise/tar, exécutez simplement /usr/bin/tarvotre script. Alternativement, définissez votre $PATHvaleur saine avant d'exécuter quoi que ce soit.

Si vous ne faites pas confiance aux fichiers /usr/bin/et aux autres répertoires système, il n'y a aucun moyen de reprendre confiance. Dans votre exemple, vous vérifiez auprès du propriétaire ls, mais comment savez-vous que vous pouvez faire confiance ls? Le même argument s'applique à d'autres solutions telles que md5sumet strace.

Lorsqu'une confiance élevée dans l'intégrité du système est requise, des solutions spécialisées comme IMA sont utilisées. Mais ce n'est pas quelque chose que vous pourriez utiliser à partir d'un script: l'ensemble du système doit être configuré de manière spéciale, avec le concept de fichiers immuables en place.

Si un intrus a accédé à votre système et est en mesure de modifier votre $PATH(ce qui ne devrait /tmpen aucun cas inclure ), il est trop tard pour commencer à vous soucier de la propriété des exécutables.

Au lieu de cela, vous devriez lire comment gérer une intrusion .

Mieux vaut se concentrer sur l'évitement des intrusions.

Si vous avez un système où ce genre de choses est important, il peut être judicieux d'isoler les parties qui doivent être publiques des parties qui doivent être privées, ainsi que d'effectuer un audit des modes de communication entre ceux-ci.

C'est possible dans une certaine mesure en vérifiant le md5sumfichier. Ainsi, sur les systèmes qui utilisent la aptgestion des packages - dans mon cas particulier, Ubuntu 16.04 - il y a le fichier /var/lib/dpkg/info/tar.md5sums, qui stocke les sommes md5 de tous les fichiers provenant de l' tarinstallation. Vous pouvez donc écrire une simple instruction if qui vérifie si la sortie de md5sum /bin/tarcorrespond à ce qui se trouve dans ce fichier.

Cela suppose bien sûr que le fichier lui-même n'a pas été falsifié. Bien sûr, cela ne peut se produire que si l'attaquant a obtenu un accès root / sudo, auquel cas tous les paris sont désactivés.

Oui, il existe une méthode: le builtin type. Contrairement à la whichcommande qui ne recherche que dans votre PATH, typevous dira si le nom de la commande est en fait un mot clé réservé, un builtin, un alias, une fonction ou un fichier disque.

$ 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

De plus type -avous donnera tous les candidats à votre commandement (du premier au dernier choix):

$ 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

Enfin, si vous n'êtes concerné que par les binaires sur votre disque, vous pouvez utiliser type -Papour obtenir tous les binaires de votre PATH (même ordre que ci-dessus):

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

Cela dit, typeseul ne vous dira pas exactement quelle commande sera appelée à la fin. Par exemple, si votre tarest un alias qui appelle un binaire (par exemple alias tar="/tmp/tar"), il typevous dira que c'est un alias.

Vous pouvez vérifier quelles commandes sont exactement exécutées par un script à l'aide de strace. Par exemple:

strace -f -e execve ./script.sh

Avec le script suivant:

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

stracevous indiquera le chemin exact des commandes exécutées lorsqu'il est utilisé avec le -e execveparamètre:

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 +++

Paramètres (de strace man):

-f: Trace les processus enfants tels qu'ils sont créés par les processus actuellement tracés à la suite des appels système fork (2), vfork (2) et clone (2). Notez que -p PID -fva attacher tous les threads du processus PID s'il est multi-thread, pas seulement le thread avec thread_id = PID.

-e trace=file: Trace tous les appels système qui prennent un nom de fichier comme argument. Vous pouvez considérer cela comme une abréviation pour -e trace=open,stat,chmod,unlink,...laquelle il est utile de voir à quels fichiers le processus fait référence. De plus, l'utilisation de l'abréviation garantira que vous n'oublierez pas accidentellement d'inclure un appel comme lstat dans la liste.

Le système d'exploitation Linux est basé sur des fichiers et de nombreuses commandes exécutées sur linux résoudront probablement certains changements dans les fichiers situés sur votre machine. À cause de cela, c'est peut - être la meilleure solution à votre problème. Vous pouvez tester vos commandes pour tout changement sur le système de fichiers avant qu'il ne soit exécuté.

Il y a la commande 'strace' qui décompile votre commande en plusieurs parties ...

Si vous voulez vraiment aller plus loin, vous devez vérifier les décompilateurs pour les scripts qui vont être exécutés. En d'autres termes, vous devez vérifier l'interprétation par l'assembleur de cette commande. Pour bash là-bas objdump -d. Les scripts bin Linux sont principalement créés avec Cun langage de programmation, utilisez donc un bon Cdécompilateur.