Blog ENI : Toute la veille numérique !
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
  1. Livres et vidéos
  2. Hacking et Forensic
  3. Le fuzzing
Extrait - Hacking et Forensic Développez vos propres outils en Python (2ième édition)
Extraits du livre
Hacking et Forensic Développez vos propres outils en Python (2ième édition)
3 avis
Revenir à la page d'achat du livre

Le fuzzing

Introduction

Issu du terme anglais fuzzy (flou en français), le fuzzing est une méthode d’automatisation des tests. Elle s’appuie sur des fuzzers (outils logiciels) pour automatiser l’identification de bugs ou de failles dans des applications. Elle apporte un gain de temps important face à des programmes pouvant comporter des milliers de lignes de code.

Le processus consiste à vérifier les entrées possibles pour une application donnée, et à forcer des opérations dans le cas où celle-ci réagit de manière anormale. Le fuzzer servira ainsi à bombarder l’application de codes volontairement malformés.

Sa finalité est l’amélioration des développements, une fois un bug identifié. Le fuzzing se destine avant tout aux développeurs et aux chercheurs en sécurité. Toutefois, les pirates s’avèrent également des utilisateurs du procédé.

Il existe des fuzzers « clés en main » qui nous permettent de faire les premiers tests et nous donnent souvent de bons résultats, mais souvent nous devrons pour un cas spécifique créer nous-mêmes notre fuzzer.

Nous pouvons lister quelques fuzzers tels que Spike, Fusil, zzuf, wfuzz...

Des fuzzers seront spécifiques à un protocole ou un service comme par exemple des fuzzers...

Fuzzing FTP

Prenons pour commencer un cas simple avec l’application Ability Server 2.34 qui est un logiciel commercial permettant de créer simplement un serveur FTP, HTTP ou e-mail.

Nous nous attaquerons au serveur FTP puisque faillible et connu.

images/04EP01.png

Allons dans Settings pour configurer un utilisateur avec l’identifiant ftp et le mot de passe ftp par exemple.

images/04EP02.png

À partir de ce moment, lorsque nous cliquons sur Activate sur la ligne de FTP Server, nous obtenons un accès au FTP en nous connectant en tant qu’utilisateur ftp avec le mot de passe ftp.

Nous partirons donc de ce constat pour créer un script qui va tenter de faire planter l’application.

Nous sommes en présence du protocole FTP, il nous faut donc savoir quels sont les tests que nous pourrons effectuer.

Un des tests possibles est de fournir en argument d’une commande un nombre d’arguments non prévu.

Il nous faut donc répertorier les commandes FTP qui acceptent des arguments. Pour cela, nous avons une documentation très utile qui est la RFC.

Nous pouvons donc aller consulter la RFC 959 et nous pourrons voir que les commandes CWD, MKD et STOR acceptent des arguments.

Pour l’exemple, nous ne prendrons que ces trois commandes, mais dans la pratique, il faudrait tester toutes les commandes acceptant un argument.

Nous allons donc commencer par écrire un script en Python qui effectue la connexion pour tester celle-ci.

script_connexion_ftp.py...

Fuzzing avec Scapy

La fonction fuzz() est capable de changer n’importe quelle valeur par défaut, telle que le checksum par un objet dont la valeur est aléatoire et le type adapté au champ. Ce qui va nous permettre de créer rapidement un fuzzer et de l’envoyer dans une boucle

Dans l’exemple suivant, la couche IP est normale et les couches UDP et NTP sont fuzzées. Le checksum UDP sera correct, le port UDP de destination sera surchargé, NTP aura la valeur 123 et la version sera forcée à 4. Tous les autres ports seront rendus aléatoires.

images/04EP06.png

Nous pouvons bien entendu, comme nous l’avons vu au chapitre Réseau : la bibliothèque Scapy, configurer comme nous le voulons la fonction fuzz().

images/04EP07.png

Nous pouvons maintenant lancer le fuzzing et observer avec un "renifleur de paquet", tel que Wireshark ou tcpdump, l’échange entre le client et le serveur.

La capture d’écran suivante montre le résultat sous Wireshark. Wireshark est un logiciel gratuit, disponible en téléchargement et les tutoriels sont multiples. Son utilisation est simple et instinctive.

images/04EP08.png
images/04EP09.png

Nous voyons bien ici les paquets envoyés à la machine 10.0.0.2.

Tentons maintenant un fuzzing sur notre serveur Ability Server en lançant la commande suivante :


 send(IP(dst="10.0.0.2")/fuzz(TCP(dport=21)),loop=1)
 

Nous pouvons constater que de multiples...

Fuzzing avec PyDbg : format string

1. Introduction

Le but est ici aussi de réécrire des données pour contrôler le flux d’exécution afin d’augmenter nos privilèges.

Ce type de faille vient aussi d’erreurs de programmation qui apparemment n’engendrent pas de risque de sécurité.

Le format string - ou format de chaîne - est issu des fonctions de type printf et de tous ses dérivés qui sont mal utilisés.

Nous allons dans un premier temps étudier la fonction printf et ses arguments pour comprendre la faille pour ensuite pouvoir l’exploiter.

printf(’’votre choix: %d\n, choix_user);

  • %d : sert à afficher choix_user au format décimal

  • %u : décimal non signé

  • %x : hexadécimal

  • %s : chaîne de caractères

  • %n : stocke le nombre de caractères écrits par la fonction printf

  • %n : mot mémoire

  • %hn : "short" (16 bits)

  • %hhn : "char" (8 bits)

Quand l’utilisateur entre le paramètre %x et que celui-ci est passé en argument de la fonction printf(), la représentation hexadécimale d’un mot de 4 octets de la pile est affichée (par exemple 0xbfe3b024).

Ce paramètre peut être utilisé pour examiner la mémoire.

On pourrait utiliser d’autres paramètres tels que %s ou %n pour lire des chaînes de caractères ou pour aller écrire en mémoire.

C’est ce type de faille que nous souhaitons tester grâce à PyDbg.

2. Fuzzer de fichiers

Les vulnérabilités de type format string vont vite devenir un des principaux choix pour les attaques côté client, c’est pourquoi nous allons nous y intéresser ici.

Fuzzer_fichier.py


from pydbg import * 
from pydbg.defines import * 
 
import utils 
import random 
import sys 
import struct 
import threading 
import os 
import shutil 
import time 
import getopt 
 
 
class file_fuzzer: 
    def __init__(self, exe_path, ext, notify): 
        self.exe_path               = exe_path 
        self.ext                    =...

Sulley

1. Introduction

Il existe de nombreux outils, bibliothèques, framework en Python pour effectuer du fuzzing. Dans le cadre de ce livre, nous allons étudier un framework, très complet, du nom de Sulley.

2. Installation

a. Installation normale

L’installation standard nécessite quelques installations de logiciels à effectuer dans l’ordre ci-dessous :

 Installez WinPcaP avec une installation par défaut. Téléchargez donc WinPcaP developer’s pack qui est nécessaire pour la compilation de pcapy (http://www.winpcap.org/install/bin/WpdPack_4_1_2.zip).

 Installez MinGW (http://sourceforge.net/projects/mingw/files/Automated%20MinGW%20Installer/mingw-get-inst/mingw-get-inst-20110530/mingw-get-inst-20110530-src.tar.gz/download). Réalisez l’installation par défaut, excepté l’étape de sélection du type de compilateur où vous cocherez C++ compiler. Après l’installation, indiquez le chemin vers le binaire MinGW dans la variable PATH (C:\MinGW\bin).

 Installez Python (http://www.python.org/ftp/python/2.7.2/python-2.7.2.msi). Après l’installation, indiquez le chemin vers le binaire dans la variable PATH.

 Installez pydasm, téléchargez libdasm (http://code.google.com/p/libdasm/downloads/list), extrayez-le, entrez dans le répertoire pydasm, compilez et installez comme indiqué ci-dessous :

C:\Documents and Settings\fasm\Desktop\libdasm-1.5\pydasm>python 
setup.py build_ext -c mingw32 
running build_ext 
building 'pydasm' extension 
---[snip]--- 
C:\MinGW\bin\gcc.exe -mno-cygwin -shared -s build\temp.win32- 
2.7\Release\..\libdasm.o build\temp.win32-2.7\Release\pydasm.o  
build\temp.win32-2.7\Release\..\pydasm.def -LC:\Python27\libs  
-LC:\Python27\PCbuild -lpython27 -lmsvcr90 -o build\lib.win32- 
2.7\pydasm.pyd 
C:\Documents and Settings\fasm\Desktop\libdasm-1.5\pydasm>python 
setup.py install 
running install 
---[snip]--- 
Writing C:\Python27\Lib\site-packages\pydasm-1.5-py2.7.egg-info 
C:\Documents and Settings\fasm\Desktop\libdasm-1.5\pydasm> 
Install PaiMei by issuing ”python setup.py install” from whatever 
directory you checked it out to. Post installation - delete or 
rename C:\Python27\Lib\site-packages\pydbg\pydasm.pyd ...

Mise en pratique

1. Fuzzing 1 : HTTP

Énoncé

Prérequis : Sulley, protocole HTTP.

But : créer un fuzzing de site web.

Énoncé :

Nous voudrions créer un fuzzer avec plusieurs blocks.

Un block, par exemple, permettra de fuzzer toutes les chaînes de caractères de l’argument /index.html HTTP/1.1 pour toutes les commandes : GET, HEADPOSTOPTIONS, TRACE, PUT, DELETE et PROPFIND.

Vous implémenterez plusieurs blocks selon votre imagination, seule celle-ci et les limites du protocole peuvent vous bloquer.

Exemple de corrigé


from sulley import * 
################################################################ 
s_initialize("HTTP VERBS") 
s_group("verbs", values=["GET", "HEAD", "POST", "OPTIONS",  
"TRACE", "PUT", "DELETE", "PROPFIND"]) 
if s_block_start("body", group="verbs"): 
      s_delim(" ") 
      s_delim("/") 
      s_string("index.html") 
      s_delim(" ") 
      s_string("HTTP") 
      s_delim("/") 
      s_string("1") 
      s_delim(".") 
      s_string("1") 
      s_static("\r\n\r\n") 
s_block_end() 
################################################################ 
s_initialize("HTTP VERBS BASIC") 
s_group("verbs"...