Analyse des Netzwerkverkehrs von Malware

Was macht Analyse des Netzwerkverkehrs von Malware?

Verwendungszweck

• Die Sandbox-Ausführung hat eine PCAP-Datei erfasst und das Netzwerkverhalten muss detailliert analysiert werden.
• Identifikation der C2-Protokollstruktur zum Schreiben von Netzwerkerkennungssignaturen.
• Bestimmung, welche Daten die Malware exfiltriert und an welche externe Infrastruktur.
• Analyse von DNS-Tunneling, Domain-Generationsalgorithmen (DGA) oder Fast-Flux-Verhalten.
• Erstellung von Suricata/Snort-Signaturen basierend auf beobachteten Malware-Netzwerkmustern.

Nicht verwenden für hostbasierte Analysen des Malware-Verhaltens; verwenden Sie Cuckoo-Sandbox-Berichte oder Volatility-Speicheranalyse für Aktivitäten auf Prozessebene.

Voraussetzungen

• Wireshark 4.x installiert für interaktive PCAP-Analyse.
• tshark (Wireshark CLI) für skriptbasierte Paketextraktion.
• Zeek installiert für automatisierte Metadatengenerierung aus PCAPs.
• Suricata mit ET Open/ET Pro-Regelsätzen für Signaturvergleiche.
• NetworkMiner für Dateiextraktion und Erkennung von Anmeldeinformationen aus PCAPs.
• Python 3.8+ mit scapy und dpkt für programmatische Paketanalyse.

Arbeitsablauf

Schritt 1: Erste PCAP-Übersicht

Verschaffen Sie sich einen Überblick über den Netzwerkverkehr:

# Erfassungsstatistiken
capinfos malware.pcap

# Protokollhierarchie
tshark -r malware.pcap -q -z io,phs

# Endpunktstatistiken (Top-Talker)
tshark -r malware.pcap -q -z endpoints,ip

# Gesprächsstatistiken
tshark -r malware.pcap -q -z conv,tcp

# DNS-Abfragezusammenfassung
tshark -r malware.pcap -q -z dns,tree

Schritt 2: DNS-Aktivität analysieren

Untersuchen Sie DNS-Abfragen auf DGA, Tunneling oder C2-Domänenauflösung:

# Alle DNS-Abfragen extrahieren
tshark -r malware.pcap -T fields -e frame.time -e dns.qry.name -e dns.a \
  -Y "dns.flags.response == 1" | sort

# DGA-Muster erkennen (Domänennamen mit hoher 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)

# DNS-Abfragen aus tshark-Ausgabe parsen
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("Verdächtige DNS-Abfragen (hohe 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

# DNS-Tunneling erkennen (große TXT-Antworten)
tshark -r malware.pcap -T fields -e dns.qry.name -e dns.txt \
  -Y "dns.resp.type == 16 and dns.resp.len > 100"

Schritt 3: HTTP/HTTPS C2-Kommunikation analysieren

Untersuchen Sie webbasierte Command-and-Control-Kommunikation:

# HTTP-Anfragen extrahieren
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"

# HTTP-Antwortkörper extrahieren (potenzielle Payload-Downloads)
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"

# POST-Daten extrahieren (potenzielle Exfiltration)
tshark -r malware.pcap -T fields \
  -e http.host -e http.request.uri -e http.file_data \
  -Y "http.request.method == POST"

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

# TLS-Zertifikatsdetails extrahieren
tshark -r malware.pcap -T fields \
  -e x509ce.dNSName -e x509af.serialNumber \
  -e x509sat.utf8String \
  -Y "tls.handshake.type == 11"

# HTTP-Objekte exportieren (heruntergeladene Dateien)
tshark -r malware.pcap --export-objects http,exported_files/

Schritt 4: Beaconing-Muster erkennen

Identifizieren Sie regelmäßige periodische Kommunikation, die auf C2-Beaconing hinweist:

# Beacon-Erkennung aus PCAP
from scapy.all import rdpcap, IP, TCP
from collections import defaultdict
import statistics

packets = rdpcap("malware.pcap")

# Verbindungen nach Ziel-IP:Port gruppieren
connections = defaultdict(list)
for pkt in packets:
    if IP in pkt and TCP in pkt:
        if pkt[TCP].flags & 0x02:  # SYN-Flag
            dst = f"{pkt[IP].dst}:{pkt[TCP].dport}"
            connections[dst].append(float(pkt.time))

# Zeitintervalle auf Beaconing analysieren
print("Beacon-Analyse:")
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:  # Regelmäßiges Intervall mit < 30% Jitter
            print(f"  [!] {dst}: {len(times)} Verbindungen")
            print(f"      Intervall: {avg:.1f}s ± {stdev:.1f}s (Jitter: {jitter:.1f}%)")
            print(f"      Muster: WAHRSCHEINLICH BEACONING")

Schritt 5: Netzwerkerkennungssignaturen erstellen

Erstellen Sie Suricata/Snort-Regeln basierend auf beobachteten Verkehrsmustern:

# Suricata gegen die PCAP ausführen, um vorhandene Signaturtreffer zu erhalten
suricata -r malware.pcap -l suricata_output/ -c /etc/suricata/suricata.yaml

# Alarme überprüfen
cat suricata_output/fast.log

# Benutzerdefinierte Suricata-Regel aus beobachteten Mustern erstellen
cat << 'EOF' > custom_malware.rules
# C2-Beacon-Erkennung basierend auf beobachtetem URI-Muster
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;
)

# DNS-Abfrage für bekannte C2-Domäne
alert dns $HOME_NET any -> any any (
    msg:"MALWARE MalwareX C2 DNS-Abfrage";
    dns.query; content:"update.malicious.com";
    sid:9000002; rev:1;
)

# JA3-Hash-Übereinstimmung für Malware-TLS-Client
alert tls $HOME_NET any -> $EXTERNAL_NET any (
    msg:"MALWARE MalwareX JA3-Übereinstimmung";
    ja3.hash; content:"a0e9f5d64349fb13191bc781f81f42e1";
    sid:9000003; rev:1;
)
EOF

Schritt 6: Dateien und Artefakte aus dem Verkehr extrahieren

Stellen Sie übertragene Dateien und eingebettete Daten wieder her:

# Dateien mit Zeek extrahieren
zeek -r malware.pcap /opt/zeek/share/zeek/policy/frameworks/files/extract-all-files.zeek
ls extract_files/

# Dateien mit NetworkMiner extrahieren (GUI)
# Oder tshark für spezifische Protokollexporte verwenden
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/

# Alle extrahierten Dateien hashen
sha256sum http_objects/* smb_objects/* 2>/dev/null

# Zeek-Protokolle für umfassende Metadaten erstellen
zeek -r malware.pcap
# Ausgabe: conn.log, dns.log, http.log, ssl.log, files.log, etc.

Schlüsselkonzepte

Begriff	Definition
Beaconing	Regelmäßige periodische Verbindungen von Malware zum C2-Server, erkennbar an konsistenten Zeitintervallen und Paketgrößen
JA3/JA3S	TLS-Fingerprinting-Methode, die einen Hash aus ClientHello/ServerHello-Parametern erstellt, um Malware-TLS-Implementierungen eindeutig zu identifizieren
DGA (Domain-Generationsalgorithmus)	Algorithmus, der pseudo-zufällige Domainnamen generiert, die Malware abfragt, um C2-Server zu lokalisieren und so statische Domain-Blocklisten zu umgehen
DNS-Tunneling	Kodierung von Daten in DNS-Abfragen und -Antworten, um einen C2-Kanal einzurichten oder Daten über die DNS-Infrastruktur zu exfiltrieren
Fast Flux	DNS-Technik, die IP-Adressen einer Domain schnell rotiert, um die Stilllegung zu erschweren und C2 über viele kompromittierte Hosts zu verteilen
SNI (Server Name Indication)	TLS-Erweiterung, die den Hostnamen preisgibt, mit dem der Client verbindet; auch in verschlüsselten HTTPS-Verbindungen sichtbar
Netzwerksignatur	Suricata/Snort-Regel, die bestimmte Muster im Netzwerkverkehr (Header, Payloads, Zeitsteuerung) erkennt, um schädliche Kommunikation zu identifizieren

Tools & Systeme

• Wireshark: Open-Source-Paketanalysator für tiefgehende interaktive Inspektion von Netzwerkverkehr auf Protokollebene.
• Zeek: Netzwerkanalyse-Framework, das strukturierte Metadatenprotokolle (conn, dns, http, ssl) aus Live- oder aufgezeichnetem Verkehr erstellt.
• Suricata: Hochleistungs-Netzwerk-IDS/IPS für signaturbasierte Erkennung mit Lua-Scripting für benutzerdefinierte Erkennungslogik.
• NetworkMiner: Netzwerkforensik-Tool zum Extrahieren von Dateien, Bildern und Anmeldeinformationen aus PCAP-Dateien.
• Scapy: Python-Paketmanipulationsbibliothek für programmatische Paketanalyse, Beacon-Erkennung und Protokolldekodierung.

Häufige Szenarien

Szenario: Dekodierung eines benutzerdefinierten binären C2-Protokolls

Kontext: Malware kommuniziert mit ihrem C2-Server über ein benutzerdefiniertes binäres Protokoll auf TCP-Port 8443. Die Standard-HTTP-Analyse liefert keine Ergebnisse. Die Protokollstruktur muss aus der PCAP rückentwickelt werden.

Vorgehensweise:

1. Filtern Sie die PCAP auf TCP-Port 8443-Gespräche und folgen Sie dem TCP-Stream.
2. Identifizieren Sie das Nachrichten-Framing (Längenpräfix, Trennzeichen, Header mit fester Größe).
3. Vergleichen Sie mehrere Nachrichten, um statische Headerfelder von variablen Datenfeldern zu unterscheiden.
4. Gleichen Sie die Ergebnisse mit Reverse-Engineering-Erkenntnissen aus Ghidra ab (falls die Binärdatei analysiert wurde).
5. Schreiben Sie einen Wireshark-Dissector oder Scapy-Parser für das benutzerdefinierte Protokoll.
6. Erstellen Sie Suricata-Regeln, die auf die statischen Header-Bytes abzielen, für die Netzwerkerkennung.
7. Dokumentieren Sie die vollständige Protokollspezifikation zum Austausch von Bedrohungsinformationen.

Fallstricke:

• Analyse nur der ersten Pakete; einige C2-Protokolle ändern ihr Verhalten nach dem ersten Handshake.
• Nicht-Entschlüsselung von TLS-Verkehr, wenn die Sandbox MITM-Fähigkeiten hat.
• Verwechslung von legitimen CDN- oder Cloud-Verkehr mit C2 (Ziel-IPs validieren).
• Übersehen von C2-Verkehr, der DNS oder ICMP anstelle von TCP/UDP verwendet.

Ausgabeformat

MALWARE-NETZWERKVERKEHRSANALYSE
===================================
PCAP-Datei:        malware_sandbox.pcap
Dauer:             300 Sekunden
Gesamtpakete:      12.847
Gesamtbytes:       4,2 MB

DNS-AKTIVITÄT
Gesamtabfragen:    47
DGA erkannt:       Ja (23 Abfragen mit hoher Entropie auf .com-TLD)
Tunneling:         Nein
Aufgelöstes C2:    update.malicious[.]com -> 185.220.101[.]42

C2-KOMMUNIKATION
Protokoll:         HTTPS (TLS 1.2)
Server:            185.220.101[.]42:443
SNI:               update.malicious[.]com
JA3-Hash:          a0e9f5d64349fb13191bc781f81f42e1
Beacon-Intervall:  60,2s ± 6,8s (11,3% Jitter)
Gesamtsitzungen:   237
Gesendete Daten:   147 MB
Empfangene Daten:  2,3 MB
Zertifikat:        CN=update.malicious[.]com (selbstsigniert, abgelaufen)

PAYLOAD-DOWNLOADS
GET /payload.dll von compromised-site[.]com
  Größe: 98.304 Bytes
  SHA-256: abc123def456...
  Content-Type: application/octet-stream

EXFILTRATION
Methode:           HTTPS POST an /gate.php
Content-Type:      application/octet-stream
Durchschnittliche Größe: 15.432 Bytes pro Anfrage
Gesamtvolumen:     147 MB über 4 Stunden

SURICATA-ALARME
[1:2028401] ET MALWARE Generisches C2-Beacon-Muster
[1:2028500] ET POLICY Selbstsigniertes Zertifikat

ERSTELLTE SIGNATUREN
SID 9000001: MalwareX HTTP-Beacon-Muster
SID 9000002: MalwareX DNS-C2-Domäne
SID 9000003: MalwareX JA3-TLS-Fingerabdruck