rtfm

Voilà un nouvel article sur mes deux modules adorés : pcapy/impacket.

Introduction :

Aujourd'hui nous allons écrire une petite classe qui permet de sniffer de mot de passe.
Tout comme dsniff, qui supporte une collection de protocole d'identification en plaintext, nous nous orienterons vers le protocole ftp. Il vous suffira alors d'établir les motifs  de recherche pour inclure d'autres protocoles et arriver à faire un dsniff like.

Rappel du protocole TCP/IP et exemple d'un message du protocole ftp :

On voit ici que chaque protocole est emboité(on préférera le terme d'encapsulation) avec un autre, chacun a son but, et ils finissent par créer un packet complet.

A chaque étape, notre paquet s'agrandit et porte un nom différent. Un simple message au niveau de la couche applicative, un segment quand le transport s'ajoute(celle qui contrôle ou pas les données), un datagramme pour la couche internet(celle qui s'occupe du routage), et enfin une trame pour le réseau LAN.

Concernant l'exemple de capture, bien evidemment je n'ai pas détaillé les champs des en-têtes car ce n'est pas le but ici. Globalement on voit quel type de donnée contient chaque couche, on en comprend mieux son utilité.

Schéma global de pcapy/impacket :

Voilà un schéma de pcapy et impacket et de l'expérience que j'ai pu tiré de l'étude de ces deux modules. On voit que le front-end de la libpcap, alias pcapy, envoit les paquets vers les classes d'impacket. Impacket qui posséde en son sein, quelques protocoles hauts-niveaux comme ntlm, smb...

ImpactPacket et ImpactDecoder sont deux classes qui gére les couches, ImpactDecoder est basé sur ImpactPacket. ImpactPacket posséde une collection de classe et méthode bas niveau pour jouer avec un paquet à toutes les couches. C'est d'ailleur pour ca qu'il est sur la base du TCP/IP sur le schéma et que la pyramide décroissante pousse en direction d'Impacket. ImpactDecoder est réservé à la désencapsulation.

On notera la présence de self.child(), il représente l'instance hérité, en d'autre mot la couche supérieur. En effet dans impacket, les classes sont contruits hiérarchiquement, en respectant le modèle TCP/IP. Nous l'utiliserons pour être plus explicite, dans le code du sniffer. À l'opposé on aurait pu noter la méthode self.set_parent(parent), qui permet d'ajouter la couche inférieur. Nous reverrons dans un autre billet la création de paquet.

Je n'ai pas non plus ici détaillé le schéma, notamment en imposant une limite(ici la libpcap), pour ne pas sortir du cadre de cet article.

Le sniffer de mot de passe ftp :

Le code est vraiment basic, nous allons intercepter des paquets, poser un filtre bpf sur le port 21, et lire le message envoyé. Ce message sera comparé à notre expression régulière.
Ici l'interface utilisé est ath0

# -*- Encoding: Latin-1 -*-
import pcapy
from impacket.ImpactDecoder import EthDecoder
#expression reguliere
import re

class Sniffer():      
"""I Can sniff ftp pass!"""    
         def __init__(self, promisc, device):
               self.promisc = promisc
               self.dev = device
               self.mtu = 1500 #Maximum transmission unit
               self.timer = 100 # Timer before handling captured data
               self.sniffer = pcapy.open_live(self.dev, self.mtu, self.promisc, 100)  #Return pcapy instance object 
	       self.sniffer.setfilter("dst port 21")

         def start(self):
         """Starting sniffing"""
                print "Sniffing en cours (Ctrl-C pour quitter)"
                self.sniffer.loop(0, self.analyze)

         def analyze(self, header, data): 
         """ analyze and find ftp pass"""
         #Retourne une instance EthDecoder, identique à l'ensemble des couches du paquet, soit la trame
         eth = EthDecoder().decode(data) 
         ip = eth.child() #L'instance du datagramme)
         tcp = ip.child() #L'instance du segment
         msg = tcp.child() #L'instance du message 
  
         #Retourne un type string  du contenu du message
         message = msg.get_buffer_as_string()
         #Place aux expressions régulières :
         ftp = re.compile("(?:user|pass) .{1,30}", re.IGNORECASE) 
         verdict = re.findall(ftp, message)
 
          if (len(verdict)):
               print "From >", ip.get_ip_src(), "   port :", tcp.get_th_sport()
               print "To  >", ip.get_ip_dst(), "   port :", tcp.get_th_dport()
               print ">", "".join(verdict)

passftp = Sniffer(0, 'ath0')
passftp.starting()

Voilà en une trentaine de ligne, nous aurions passé beaucoup plus de temps dans d'autres langages(comme le C par exemple, sans vouloir vexer personne =)

Conclusion:

Cette seconde approche a permis d'éclaircir la relation d'impacket avec le modèle TCP/IP. On a pu ainsi comprendre l'utilité de la hiérarchie au sein des classes, nous pouvions aussi hériter pcapy ici à notre classe Sniffer pour accéder directement aux méthodes interressantes.

Le prochain article sur impacket/pcapy, traitera du multithread, ainsi que d'une méthode très utile pour réaliser un sniffer propre : next() de la classe pcapy. En effet si vous avez testé les codes présents, vous remarquerez qu'il est impossible d'interrompre la capture sans agir avec les signaux. Nous créons en effet une boucle (loop()) bloquante.

A bientôt & Have fun!

Introduction

Impacket et Pcapy sont des modules pour python qui permettent de jouer avec les paquets réseaux. A l'instar de Scapy, ces modules sont indépendants l'un de l'autre, et ont chacunes leurs particularités.

Impacket est une collection de classes. Elles permettent ainsi de crafter(forger) ses propres paquets, ou dans le cas contraire de dissequer les paquets. Parmis les protocoles supportés, on retrouve donc IP, TCP, UDP, ICMP, ARP, et pleins d'autres... Pcapy, quant à lui, s'occupe de la capture des paquets. Inutile de vous faire un dessin...

Ces deux modules, ont été écrit par le Core Security Technologie. Une compagnie active dans le milieu de la sécurité. Ils sont responsables du CoreImpact(Environnement de pentest avancée pour les professionnels), et ont rendu plusieurs projets libres, dont InlineEgg(permet de créer des payloads), Heapdraw(permet de suivre l'évolution du tas dans un processus), et pleins d'autres outils libres(voir référence, pour plus d'information).

Comparaison Impacket/Pcapy vs Scapy ?

Points communs :

     + Références pour la manipulation de paquet en python.

     + Plusieurs protocoles supportés

     + Outils fournis (ping, tracer...)

     + Code portable

     - Souffre cruellement de documentation francaise.

     - Pas de réelle communauté(si ce n'est une mailing list...)

Scapy :

     + Fléxibilité

     - Instable avec le multithread

     - Perte de paquet dans certaines conditions

     - Lenteur

     - ?

Impacket/Pcapy :

     + Syntaxe plus explicite

     + Support du multithread

     + Realisé par le CoreImpact

     ?

Si vous avez des remarques, ou vous voulez compléter ce tableau, n'hésitez pas à laisser vos commentaires.

Cours n°1 : "Introduction globale sur les fonctionnalités des jumeaux"

Les exemples suivants sont à lancés en mode root, dans le shell interfactif de python.

Pcapy

findalldevs()
Liste tout simplement les interfaces activent sous forme de liste.

>>> from pcapy import *
>>> dev = findalldevs()
>>> type (dev)
<type 'list'>
>>> print dev
['eth0', 'wifi0', 'ath0', 'eth0:avahi', 'any', 'lo']

open_live(device, snaplen, promisc, to_ms)
Permet d'initialiser la capture en renvoyant un descripteur de paquet capturé. Les arguments sont :
device, l'interface utilisé lors de la capture(Mettez "null", ou "any", pour écouter sur toutes les interfaces)
snaplen, correspond à la taille maximum(en octect) d'un paquet.
promisc, Etat boléen, si il est à 1 l'interface sera mis en mode promiscious.
to_ms, est un timeout. Un timeout de 100, n'affichera les paquets capturé que toutes les 100millisecondes. Celà permet donc de cumuler un certain nombre de paquet avant de les traiter. Attention certains système d'exploitation ne gère pas ce timeout.
A noter, que cette fonction ne lance en aucun cas le sniffing en lui même.

>>> p = open_live('ath0', 1500, 0, 0)
>>> print "Réseau : ", p.getnet()
Réseau : 192.168.1.0
>>> print "Masque : ", p.getmask()
Masque : 255.255.255.0

Les méthodes getnet et getmask retournent l'adresse du réseau et son masque associé.

open_offline(filename)
Permet d'ouvrir un fichier de paquet capturé de type pcap.

int loop(maxcant, (* callback))
Cette fonction permet de lancer le sniffing, elle retourne le nombre de paquet capturé. Elle prend en argument :
maxcant, qui est le nombre maximum de paquet à capturer('0', pour ne pas s'imposer cette limite).
* callback, est une routine qui sera appelé à chaque paquet capturé. Cette fonction se compose de deux arguments. Elle retourne deux instances, qui seront les deux arguments da la routine, le header qui contient comme méthodes, getcaplen(qui retourne la taille du paquet), getlen(qui retourne la taille totale, en cas de fragmentation par exemple), et getts(Renvoie un tuple de deux éléments : Nombre de seconde depuis la date d'epoch et une autre valeur en microseconde qui d'après ce que j'ai compris n'est vraiment pas interressante.). Et comme second argument le paquet lui-même.
Cette fonction peut se définir comme ca :

>>> def routine(info, data):
>>> ....print "Taille du paquet recu : ", info.getcaplen()
>>> ....print "Taille total : ", info.getlen()
>>> ....print "Sec. depuis l'epoch : %d | Ecart entre la capture et date du paquet en micro-seconde -_-' : %d"%(info.getts()[0], info.getts()[1])
>>> ....print "Paquet recu : ", data
>>> (ligne vide, tapez entrée)
>>> p.loop(1, routine)

Respectez l'indentation en python(remplacer les points par des espaces).

setfilter(bpf)
Applique un filtre bpf(comme ceux de tcpdump) à l'objet pcap du descripteur de paquet captué.

>>> p.setfilter("dst 192.168.1.1")

Relancer la fonction loop(celle de l'exemple précédent), et tapez dans un shell à part :

ping -c 1 192.168.1.1

Cool, on voit que le filtre est bien appliqué.

Néanmoins la sortie est "illisible"! C'est de là qu'intervient impacket.

Impacket

Nous allons donc utiliser la classe EthDecoder, qui décode les paquets dont la couche de liaison utilise le protocole Ethernet.
Importons là :

>>> from impacket.ImpactDecoder import EthDecoder

Reprenons la fonction routine, modifions là de telle sorte que le code devient le suivant :

>>> def routine(info, data):
>>> ....print "Taille du paquet recu : ", info.getcaplen())
>>> ....print "Taille total : ", info.getlen())
>>> ....print "Paquet recu (avant) : ", data
>>> ....print "Paquet recu (après) : ", EthDecoder().decode(data)
>>> (ligne vide, tapez entrée)
>>> p.loop(1, routine)

Voilà vous aurez, dorénavant, quelque chose comme :

packet = Ether: 00:17:9A:XX:XX:XX -> 00:19:4b:XX:XX:XX
IP 192.168.1.13 -> 208.71.XX.XX
TCP ack 56341 -> 6667
......TCP Option: No Operation
......TCP Option: No Operation
......TCP Option: Timestamp
[Données en Hexadecimal] [Données en ASCII]

C'est mieux ! Vous avez bien sur, une large panoplie de fonction, vous pouvez également extraire les champs à part en accédant aux méthodes des sous classes decode().
Par exemple :

EthDecoder().decode(data).child().get_ip_src()

Vous affichera l'adresse ip source.

Je vous laisse le soin de vous aventurer plus loin.

Conclusion & références :

Page d'impacket
Page de pcapy

J'ai été ravi de vous présenter ce qui se présente comme l'un des premiers articles francophones traitant d'impacket, et pcapy.
Vous l'aurez compris, pcapy sans impacket, ne vaut rien, d'autres billets viendront compléter cette première approche.
Bien évidemment, je tiens à préciser que je ne suis pas un maitre en la matière, et je m'excuse d'avance des erreurs qui auraient pu être commises(tant orthographique que technique), n'hésitez donc pas à m'envoyer un mail.

HaveFun!

Mon identitié n'existe plus.
Mon esprit est sa philosophie.
Ma vie est son but.

 
   Join us now and share the software;

   You'll be free, hackers, you'll be free.

   Join us now and share the software;

   You'll be free, hackers, you'll be free.

   Hoarders may get piles of money,

   That is true, hackers, that is true.

   But they cannot help their neighbors;

   That's not good, hackers, that's not good.

   When we have enough free software

   At our call, hackers, at our call,

   We'll kick out those dirty licenses

   Ever more, hackers, ever more.

   Join us now and share the software;

   You'll be free, hackers, you'll be free.

   Join us now and share the software;

   You'll be free, hackers, you'll be free.

A travers ce texte, je fais le serment de servir le libre. Et de rejoindre cette communauté qui contribue pour le libre et bien plus.

Certains auront pu remarquer la modification de ce billet. Oui ma présensation n'égale pas un Hommage pareil.

Je témoigne mon plus grand respect pour cet Homme si Grand, si Admirable, qui se dévoue corps et âme au Libre! Merci à toi RMS, de nous offrir tant de plaisir chaque jour, et nous montrer la vraie voie d'un Homme...

je te dédie ce post.