analyse-du-trafic-reseau-des-logiciels-malveillants

Analyse du Trafic Réseau des Logiciels Malveillants

Quand l'Utiliser

• L'exécution en sandbox a capturé un fichier PCAP et une analyse détaillée du comportement réseau est nécessaire
• Identifier la structure du protocole C2 pour rédiger des signatures de détection réseau
• Déterminer quelles données le malware exfiltre et vers quelle infrastructure externe
• Analyser le DNS tunneling, les algorithmes de génération de domaines (DGA) ou le comportement fast-flux
• Créer des signatures Suricata/Snort basées sur les motifs réseau observés du malware

Ne pas utiliser pour l'analyse comportementale au niveau hôte du malware ; utiliser les rapports de sandbox Cuckoo ou l'analyse mémoire avec Volatility pour l'activité au niveau des processus.

Prérequis

• Wireshark 4.x installé pour l'analyse interactive des PCAP
• tshark (CLI de Wireshark) pour l'extraction scriptée de paquets
• Zeek installé pour la génération automatisée de métadonnées à partir des PCAP
• Suricata avec les règles ET Open/ET Pro pour la correspondance de signatures
• NetworkMiner pour l'extraction de fichiers et la détection d'identifiants à partir des PCAP
• Python 3.8+ avec scapy et dpkt pour l'analyse programmatique de paquets

Flux de Travail

Étape 1 : Aperçu Initial du PCAP

Obtenez une vue d'ensemble du trafic réseau :

# Statistiques de capture
capinfos malware.pcap

# Hiérarchie des protocoles
tshark -r malware.pcap -q -z io,phs

# Statistiques des points de terminaison (principaux émetteurs)
tshark -r malware.pcap -q -z endpoints,ip

# Statistiques des conversations
tshark -r malware.pcap -q -z conv,tcp

# Résumé des requêtes DNS
tshark -r malware.pcap -q -z dns,tree

Étape 2 : Analyser l'Activité DNS

Examinez les requêtes DNS pour détecter les DGA, le tunneling ou la résolution de domaines C2 :

# Extraire toutes les requêtes DNS
tshark -r malware.pcap -T fields -e frame.time -e dns.qry.name -e dns.a \
  -Y "dns.flags.response == 1" | sort

# Détecter les motifs DGA (noms de domaine à haute entropie)
python3 << 'PYEOF'
import math
from collections import Counter

def entropy(s):
    p = [n/len(s) for n in Counter(s).values()]
    return -sum(pi * math.log2(pi) for pi in p if pi > 0)

# Analyser les requêtes DNS depuis la sortie tshark
import subprocess
result = subprocess.run(
    ["tshark", "-r", "malware.pcap", "-T", "fields", "-e", "dns.qry.name",
     "-Y", "dns.flags.response == 0"],
    capture_output=True, text=True
)

domains = set(result.stdout.strip().split('\n'))
print("Requêtes DNS suspectes (haute entropie) :")
for domain in domains:
    if domain:
        subdomain = domain.split('.')[0]
        ent = entropy(subdomain)
        if ent > 3.5 and len(subdomain) > 10:
            print(f"  {domain} (entropie : {ent:.2f})")
PYEOF

# Détecter le DNS tunneling (réponses TXT volumineuses)
tshark -r malware.pcap -T fields -e dns.qry.name -e dns.txt \
  -Y "dns.resp.type == 16 and dns.resp.len > 100"

Étape 3 : Analyser la Communication C2 HTTP/HTTPS

Examinez le trafic de commande et contrôle basé sur le web :

# Extraire les requêtes HTTP
tshark -r malware.pcap -T fields \
  -e frame.time -e ip.src -e ip.dst -e http.host \
  -e http.request.method -e http.request.uri -e http.user_agent \
  -Y "http.request"

# Extraire les corps de réponses HTTP (téléchargements de charge utile potentiels)
tshark -r malware.pcap -T fields \
  -e http.host -e http.request.uri -e http.content_type -e tcp.len \
  -Y "http.response and tcp.len > 1000"

# Extraire les données POST (exfiltration potentielle)
tshark -r malware.pcap -T fields \
  -e http.host -e http.request.uri -e http.file_data \
  -Y "http.request.method == POST"

# Analyse TLS (SNI, empreintes JA3)
tshark -r malware.pcap -T fields \
  -e tls.handshake.extensions_server_name \
  -e tls.handshake.ja3 \
  -Y "tls.handshake.type == 1"

# Extraire les détails des certificats TLS
tshark -r malware.pcap -T fields \
  -e x509ce.dNSName -e x509af.serialNumber \
  -e x509sat.utf8String \
  -Y "tls.handshake.type == 11"

# Exporter les objets HTTP (fichiers téléchargés)
tshark -r malware.pcap --export-objects http,exported_files/

Étape 4 : Détecter les Motifs de Beaconing

Identifiez les communications périodiques régulières indiquant un beaconing C2 :

# Détection de beaconing à partir d'un PCAP
from scapy.all import rdpcap, IP, TCP
from collections import defaultdict
import statistics

packets = rdpcap("malware.pcap")

# Grouper les connexions par destination IP:port
connections = defaultdict(list)
for pkt in packets:
    if IP in pkt and TCP in pkt:
        if pkt[TCP].flags & 0x02:  # Drapeau SYN
            dst = f"{pkt[IP].dst}:{pkt[TCP].dport}"
            connections[dst].append(float(pkt.time))

# Analyser les intervalles temporels pour le beaconing
print("Analyse du Beaconing :")
for dst, times in connections.items():
    if len(times) >= 5:
        intervals = [times[i+1] - times[i] for i in range(len(times)-1)]
        avg = statistics.mean(intervals)
        stdev = statistics.stdev(intervals) if len(intervals) > 1 else 0
        jitter = (stdev / avg * 100) if avg > 0 else 0

        if 10 < avg < 3600 and jitter < 30:  # Intervalle régulier avec < 30% de gigue
            print(f"  [!] {dst} : {len(times)} connexions")
            print(f"      Intervalle : {avg:.1f}s ± {stdev:.1f}s (gigue : {jitter:.1f}%)")
            print(f"      Motif : BEACONING PROBABLE")

Étape 5 : Générer des Signatures de Détection Réseau

Créez des règles Suricata/Snort à partir des motifs de trafic observés :

# Exécuter Suricata contre le PCAP pour les correspondances de signatures existantes
suricata -r malware.pcap -l suricata_output/ -c /etc/suricata/suricata.yaml

# Consulter les alertes
cat suricata_output/fast.log

# Créer une règle Suricata personnalisée à partir des motifs observés
cat << 'EOF' > custom_malware.rules
# Détection de beaconing C2 basée sur le motif URI observé
alert http $HOME_NET any -> $EXTERNAL_NET any (
    msg:"MALWARE MalwareX C2 Beacon";
    flow:established,to_server;
    http.method; content:"POST";
    http.uri; content:"/gate.php?id=";
    http.user_agent; content:"Mozilla/5.0 (compatible; MSIE 10.0)";
    sid:9000001; rev:1;
)

# Requête DNS pour un domaine C2 connu
alert dns $HOME_NET any -> any any (
    msg:"MALWARE MalwareX C2 DNS Query";
    dns.query; content:"update.malicious.com";
    sid:9000002; rev:1;
)

# Correspondance de hachage JA3 pour le client TLS du malware
alert tls $HOME_NET any -> $EXTERNAL_NET any (
    msg:"MALWARE MalwareX JA3 Match";
    ja3.hash; content:"a0e9f5d64349fb13191bc781f81f42e1";
    sid:9000003; rev:1;
)
EOF

Étape 6 : Extraire Fichiers et Artefacts du Trafic

Récupérez les fichiers transférés et les données intégrées :

# Extraire les fichiers avec Zeek
zeek -r malware.pcap /opt/zeek/share/zeek/policy/frameworks/files/extract-all-files.zeek
ls extract_files/

# Extraire les fichiers avec NetworkMiner (interface graphique)
# Ou utiliser tshark pour des exports de protocoles spécifiques
tshark -r malware.pcap --export-objects http,http_objects/
tshark -r malware.pcap --export-objects smb,smb_objects/
tshark -r malware.pcap --export-objects tftp,tftp_objects/

# Hacher tous les fichiers extraits
sha256sum http_objects/* smb_objects/* 2>/dev/null

# Générer les logs Zeek pour des métadonnées complètes
zeek -r malware.pcap
# Sortie : conn.log, dns.log, http.log, ssl.log, files.log, etc.

Concepts Clés

Terme	Définition
Beaconing	Connexions périodiques régulières du malware vers le serveur C2, identifiables par des intervalles de temps et des tailles de paquets cohérents
JA3/JA3S	Méthode d'empreinte TLS créant un hachage à partir des paramètres ClientHello/ServerHello pour identifier de manière unique les implémentations TLS des malwares
DGA (Algorithme de Génération de Domaines)	Algorithme générant des noms de domaine pseudo-aléatoires que le malware interroge pour localiser les serveurs C2, contournant les listes de blocage de domaines statiques
DNS Tunneling	Encodage de données dans les requêtes et réponses DNS pour établir un canal C2 ou exfiltrer des données via l'infrastructure DNS
Fast Flux	Technique DNS faisant rapidement alterner les adresses IP d'un domaine pour éviter le démantèlement et distribuer le C2 sur de nombreux hôtes compromis
SNI (Indication de Nom de Serveur)	Extension TLS révélant le nom d'hôte auquel le client se connecte ; visible même dans les connexions HTTPS chiffrées
Signature Réseau	Règle Suricata/Snort correspondant à des motifs spécifiques dans le trafic réseau (en-têtes, charges utiles, temporisation) pour détecter les communications malveillantes

Outils & Systèmes

• Wireshark : Analyseur de paquets open-source pour une inspection interactive approfondie du trafic réseau au niveau des protocoles
• Zeek : Framework d'analyse réseau générant des logs de métadonnées structurées (conn, dns, http, ssl) à partir de trafic en direct ou capturé
• Suricata : IDS/IPS réseau haute performance pour la détection basée sur des signatures avec scripts Lua pour une logique de détection personnalisée
• NetworkMiner : Outil d'analyse forensique réseau pour extraire fichiers, images et identifiants des fichiers PCAP
• Scapy : Bibliothèque Python de manipulation de paquets pour l'analyse programmatique, la détection de beaconing et le décodage de protocoles

Scénarios Courants

Scénario : Décoder un Protocole C2 Binaire Personnalisé

Contexte : Le malware communique avec son serveur C2 en utilisant un protocole binaire personnalisé sur le port TCP 8443. L'analyse HTTP standard ne donne aucun résultat. La structure du protocole doit être rétroconçue à partir du PCAP.

Approche :

1. Filtrer le PCAP pour les conversations sur le port TCP 8443 et suivre le flux TCP
2. Identifier le cadrage des messages (préfixe de longueur, délimiteur, en-têtes de taille fixe)
3. Comparer plusieurs messages pour identifier les champs d'en-tête fixes par rapport aux champs de données variables
4. Recouper avec les résultats de rétro-ingénierie de Ghidra (si le binaire a été analysé)
5. Écrire un dissecteur Wireshark ou un analyseur Scapy pour le protocole personnalisé
6. Créer des règles Suricata correspondant aux octets d'en-tête statiques pour la détection réseau
7. Documenter la spécification complète du protocole pour le partage de renseignements sur les menaces

Pièges à éviter :

• N'analyser que les premiers paquets ; certains protocoles C2 changent de comportement après la poignée de main initiale
• Ne pas déchiffrer le trafic TLS lorsque la sandbox dispose de capacités MITM
• Confondre le trafic CDN ou cloud légitime avec du C2 (valider les IP de destination)
• Manquer le trafic C2 qui utilise DNS ou ICMP au lieu de TCP/UDP

Format de Sortie

ANALYSE DU TRAFIC RÉSEAU DU MALWARE
===================================
Fichier PCAP :        malware_sandbox.pcap
Durée :               300 secondes
Paquets totaux :      12 847
Octets totaux :       4,2 Mo

ACTIVITÉ DNS
Requêtes totales :    47
DGA détecté :         Oui (23 requêtes à haute entropie vers le TLD .com)
Tunneling :           Non
C2 résolu :           update.malicious[.]com -> 185.220.101[.]42

COMMUNICATION C2
Protocole :           HTTPS (TLS 1.2)
Serveur :             185.220.101[.]42:443
SNI :                 update.malicious[.]com
Hachage JA3 :         a0e9f5d64349fb13191bc781f81f42e1
Intervalle Beacon :   60,2s ± 6,8s (gigue 11,3%)
Sessions totales :    237
Données envoyées :    147 Mo
Données reçues :     2,3 Mo
Certificat :          CN=update.malicious[.]com (auto-signé, expiré)

TÉLÉCHARGEMENTS DE CHARGES UTILES
GET /payload.dll depuis compromised-site[.]com
  Taille : 98 304 octets
  SHA-256 : abc123def456...
  Type de contenu : application/octet-stream

EXFILTRATION
Méthode :             HTTPS POST vers /gate.php
Type de contenu :     application/octet-stream
Taille moyenne :      15 432 octets par requête
Volume total :        147 Mo sur 4 heures

ALERTES SURICATA
[1:2028401] ET MALWARE Generic C2 Beacon Pattern
[1:2028500] ET POLICY Self-Signed Certificate

SIGNATURES GÉNÉRÉES
SID 9000001 : Motif HTTP MalwareX beaconing
SID 9000002 : Domaine DNS C2 MalwareX
SID 9000003 : Empreinte TLS JA3 MalwareX