Récupérer un login et mot de passe d'un paquet HTTP via un fichier pcap avec Scapy

Scapy est un logiciel libre en Python qui permet de manipuler des paquets réseaux. Une de ces nombreuses fonctionnalités est la gestion des fichiers pcap, qui peuvent être créés par des outils d'analyse réseau (comme WireShark ou Scapy).

Récupération des paquets HTTP avec un login et un mot de passe

  1. Installez Scapy (par exemple avec le paquet python-scapy sous Debian) et enregistrez un fichier pcap.
  2. Démarrez un shell texte scapy (généralement avec la commande… scapy !).
  3. Mettez les paquets du fichier pcap dans une variable, avec packets = rdpcap("a-pass-somewhere.pcap").
  4. Les paquets HTTP avec un login et un mot de passe sont vraisemblablement encapsulés dans un paquet TCP, filtrez les avec packets = packets.filter(lambda packet: TCP in packet).
  5. Les paquets TCP ne contiennent pas forcément du HTTP, il faut donc filtrer le numéro de port (ou faire du DPI). Le port habituel pour le HTTP est 80, et dans de rares cas le port 8080 est utilisé. Faites un nouveau filtrage avec packets = packets.filter(lambda packet: packet[TCP].dport == 80 or packet[TCP].dport == 8080) ou (plus court) packets = packets.filter(lambda packet: packet[TCP].dport in (80, 8080)).
  6. Il reste à filter pour n'avoir que les paquets avec un login et un mot de passe. On peut faire un filtrage simple pour vérifier qu'il y a un login, avec packets = packets.filter(lambda packet: "login" in str(packet)). On peut faire de même pour pour vérifier qu'il y a un mot de passe, avec packets = packets.filter(lambda packet: "pass" in str(packet) or "pwd" in str(packet)).
Exemple de paquet récupéré ouvert dans Wireshark (1.10)

Trucs et astuces

La fonction sniff

Pour lire un fichier pcap, on peut utiliser la fonction rdpcap, mais aussi la fonction sniff avec le paramètre offline pour le chemin de fichier. rdpcap("pass.pcap") est donc remplacable par sniff(offline="pass.pcap"). sniff a un paramètre lfilter pour un filtre sous forme de fonction, ce qui évite de charger en mémoire des paquets pour les libérer juste après avec un filtre.

La fonction sniff a un paramètre prn. Celui-ci prend une fonction qui sera appliquée à chaque paquet. On peut y faire le filtrage et le traitement, ainsi on peut économiser de la mémoire puisqu'il n'est pas utile de conserver le ou les paquets qui ont passé le filtre. Cependant, par défaut, sniff conserve les paquets pour les retourner, mais il a un paramètre store (conserver en français) que l'on peut assigner à False.

Champs HTTP "inutiles"

Dans notre cas, nous voulons récupérer des logins et des mots de passe, pour potentiellement les exploiter. Certains champs du protocole HTTP nous sont donc inutiles : ils ne peuvent ni contenir de login ou mot de passe, ni une information pour les exploiter.

On peut par exemple citer :

URL avec paramètre

Des logins et mots de passe peuvent être dans des URL avec paramètre(s). Une URL avec des paramètres est de la forme : "http://domaine.tld/page?param1=value1¶m2=value2" (avec "?" pour indiquer que l'on commence la liste des paramètres et "&" pour séparer les paramètres). Si au moins un des paramètres est un login ou un mot de passe, il est aisé d'extraire d'une manière automatisé et fiable l'exact début et fin de la valeur.

Mais si le nom d'un paramètre ou une valeur contient "&", c'est un problème ? Non et heureusement. En effet, si c'était le cas, une application web qui recevrait la réponse serait aussi embêtée. Pour pallier ce problème les noms de paramètres et leurs valeurs sont encodés. Ainsi quand "&" n'est pas un séparateur, il est transformé en "%26". En Python, vous pouvez faire cette opération avec la fonction quote du module urllib2, l'inverse peut se faire avec la fonction unquote du même module.

Automatiser avec un script

Script simpliciste

#!/usr/bin/env python2

from scapy.all import *

packets = rdpcap("pass.pcap")
packets = packets.filter(lambda packet: TCP in packet)
packets = packets.filter(lambda packet: packet[TCP].dport in (80, 8080))
packets = packets.filter(lambda packet: "login" in str(packet))
packets = packets.filter(lambda packet: "pass" in str(packet) or "pwd" in str(packet))

for i in range(len(packets)):
    if i > 0:
        print("")
    print(str(packets[i][Raw]))

Script malin

#!/usr/bin/env python2


from scapy.all import *
from sys       import argv
from os.path   import isfile


if len(argv) < 2 or argv[1] == "":
    print("Please provide a file as an argument")
    exit(1)

if not isfile(argv[1]):
    print(argv[1] +" is not a file")
    exit(1)


packets = rdpcap(argv[1])
packets = packets.filter(lambda packet: TCP in packet)
packets = packets.filter(lambda packet: packet[TCP].dport in (80, 8080))
packets = packets.filter(lambda packet: "login" in str(packet))
packets = packets.filter(lambda packet: "pass" in str(packet) or "pwd" in str(packet))


USELESS_HTTP_HEADERS = [
    "User-Agent",
    "Accept",
    "Accept-Language",
    "Accept-Encoding",
    "Connection",
    "Content-Length"
]

def remove_http_headers_from_string(a_string, http_headers):
    new_string = ""
    for line in unicode(a_string).splitlines():
        if not any(line.lower().startswith(http_header.lower())
                   for http_header in http_headers):
            new_string += line +"\n"
    return new_string

def remove_useless_http_headers_from_string(a_string):
    return remove_http_headers_from_string(a_string, USELESS_HTTP_HEADERS)


nb_packets = len(packets)
for i in range(nb_packets):
    packet = packets[i]
    if i > 0:
        print("")
    print("# Packet "+ str(i) +"\n")
    
    packet_string = packet[Raw].load
    packet_string = remove_useless_http_headers_from_string(packet_string)
    print(packet_string)
    
    # The webpage path can contain "login" or something similar
    packet_string = remove_http_headers_from_string(packet_string,
                                                    ("GET", "POST", "Referer"))
    
    login_position = packet_string.find("login")
    if login_position < 0:
        login_position = packet_string.find("user")
        if login_position < 0:
            login_position = packet_string.find("name")
    login_part = packet_string[login_position:].split('\n', 1)[0]
    
    password_position = packet_string.find("pass")
    if password_position < 0:
        password_position = packet_string.find("pwd")
    password_part = packet_string[password_position:].split('\n', 1)[0]
    
    print(login_part)
    print(password_part)

Script très malin

#!/usr/bin/env python2


from scapy.all import *
from sys       import argv
from os.path   import isfile
from re        import *
from urllib2   import unquote as url_unquote


if len(argv) < 2 or argv[1] == "":
    print("Please provide a file as an argument")
    exit(1)

if not isfile(argv[1]):
    print(argv[1] +" is not a file")
    exit(1)


HTTP_PORTS = (80, 8080)
PASS_REGEX = re.compile(r"pass|pwd")

def packer_filter_if_login_and_pass(packet):
    if TCP in packet and packet[TCP].dport in HTTP_PORTS:
        packet_string = str(packet).strip().lower()
        return ("login" in packet_string and PASS_REGEX.search(packet_string))
    return False

packets = sniff(offline = argv[1],
                lfilter = packer_filter_if_login_and_pass)


USELESS_HTTP_HEADERS = [
    "User-Agent",
    "Accept",
    "Accept-Language",
    "Accept-Encoding",
    "Connection",
    "Content-Length"
]

def remove_http_headers_from_string(a_string, http_headers):
    new_string = ""
    http_headers_lowered = [ header.lower() for header in http_headers ]
    for line in unicode(a_string).splitlines():
        if not any(line.lower().startswith(http_header)
                   for http_header in http_headers_lowered):
            new_string += line +"\n"
    return new_string

def remove_useless_http_headers_from_string(a_string):
    return remove_http_headers_from_string(a_string, USELESS_HTTP_HEADERS)

def is_urlencoded_content_type(a_string):
    for line in unicode(a_string).splitlines():
        if line == "":
            return False
        
        line = line.lower()
        if line == "content-type: application/x-www-form-urlencoded":
            return True
    
    return False

def get_content_of_string_http_packet(a_string):
    is_content = False
    content = ""
    for line in unicode(a_string).splitlines():
        if is_content:
            content += line +"\n"
        if line == "":
            is_content = True
    return content

def get_parameter_value_of_urlencoded(a_url_encoded, a_parameter):
    param_pos = a_url_encoded.find(a_parameter +"=")
    if param_pos < 0:
        return None

    param_value = a_url_encoded[param_pos + len(a_parameter) + 1:]
    param_pos = param_value.find("&")
    if param_pos > 0:
        param_value = param_value[:param_pos]
    return url_unquote(param_value)

def get_one_of_parameters_value_of_urlencoded(a_url_encoded, parameters):
    for a_parameter in parameters:
        value = get_parameter_value_of_urlencoded(a_url_encoded, a_parameter)
        if value is not None:
            return value
    return None


nb_packets = len(packets)
for i in range(nb_packets):
    packet = packets[i]
    if i > 0:
        print("")
    print("# Packet "+ str(i) +"\n")
    
    packet_string = packet[Raw].load
    packet_string = remove_useless_http_headers_from_string(packet_string)
    print(packet_string)
    
    # The webpage path can contain "login" or something similar
    packet_string = remove_http_headers_from_string(packet_string,
                                                    ("GET", "POST", "Referer"))
    
    login_part    = None
    password_part = None
    
    if is_urlencoded_content_type(packet_string):
        packet_content_string = get_content_of_string_http_packet(packet_string)
        login_part = get_one_of_parameters_value_of_urlencoded(packet_content_string,
                                                               ("login", "user", "name"))
        password_part = get_one_of_parameters_value_of_urlencoded(packet_content_string,
                                                                  ("pass", "pwd"))
    else:
        login_position = packet_string.find("login")
        if login_position < 0:
            login_position = packet_string.find("user")
            if login_position < 0:
                login_position = packet_string.find("name")
        if login_position >= 0:
            login_part = packet_string[login_position:].split('\n', 1)[0]
        
        password_position = packet_string.find("pass")
        if password_position < 0:
            password_position = packet_string.find("pwd")
        if password_position >= 0:
            password_part = packet_string[password_position:].split('\n', 1)[0]
    
    print(login_part)
    print(password_part)

Script encore plus malin

À vous de l'écrire, et ce serait gentil de le publier sous licence(s) libre(s).

Comment se protéger ?

Pour se protéger, il faut que les données soient chiffrées. Le mieux est qu'elles soient chiffrées de bout-en-bout, c'est-à-dire de votre ordinateur à l'ordinateur qui aura à les utiliser. Pour les sites web, cela se fait avec le HTTPS (qui utilise TLS). Vous pouvez aussi chiffrer de point-à-point, par exemple avec WPA2 pour votre routeur Wi-Fi, via Tor ou un VPN. Notez que vous pouvez chiffrer de bout-en-bout et de point-à-point un même paquet.