knowledgebase content

2025-08-10 21:50:47 +02:00
parent a816c0630f
commit e6cee2ab0e
14 changed files with 4579 additions and 115 deletions
--- a/src/content/knowledgebase/concept-network-protocols.md
+++ b/src/content/knowledgebase/concept-network-protocols.md
@@ -0,0 +1,517 @@
+---
+title: "Netzwerkprotokoll-Analyse für forensische Untersuchungen"
+description: "Umfassender Leitfaden zur forensischen Analyse von Netzwerkprotokollen Layer 2-7, Session-Rekonstruktion aus PCAP-Dateien, C2-Kommunikations-Pattern-Erkennung und APT-Hunting-Techniken für Incident Response."
+author: "Claude 4 Sonnett (Prompt: Mario Stöckl)"
+last_updated: 2024-01-15
+difficulty: intermediate
+categories: ["analysis", "troubleshooting", "case-study"]
+tags: ["protocol-analysis", "packet-inspection", "session-reconstruction", "c2-analysis", "traffic-patterns", "network-baseline", "payload-extraction", "anomaly-detection", "incident-response", "apt-hunting"]
+tool_name: "Network Protocols & Packet Analysis"
+related_tools: ["Wireshark", "NetworkMiner", "tcpdump"]
+published: true
+---
+
+# Netzwerkprotokoll-Analyse für forensische Untersuchungen
+
+Die forensische Analyse von Netzwerkprotokollen ist ein fundamentaler Baustein moderner Incident Response und APT-Hunting-Aktivitäten. Dieser Leitfaden vermittelt systematische Methoden zur Untersuchung von Netzwerkverkehr von Layer 2 bis Layer 7 des OSI-Modells.
+
+## Warum Netzwerkprotokoll-Forensik?
+
+In komplexen Cyberangriffen hinterlassen Angreifer Spuren in der Netzwerkkommunikation, die oft die einzigen verfügbaren Beweise darstellen. Command & Control (C2) Kommunikation, Datenexfiltration und laterale Bewegungen manifestieren sich als charakteristische Netzwerkmuster, die durch systematische Protokoll-Analyse erkennbar werden.
+
+## Voraussetzungen
+
+### Technische Kenntnisse
+- Grundverständnis des OSI-7-Schichten-Modells
+- TCP/IP-Stack-Funktionsweise
+- HTTP/HTTPS-Request/Response-Struktur
+- DNS-Query-Mechanismen
+- Grundlagen der Kryptographie (TLS/SSL)
+
+### Systemanforderungen
+- Wireshark 4.0+ oder vergleichbare Packet-Analyzer
+- Leistungsfähiges System für große PCAP-Analysen (16GB+ RAM)
+- NetworkMiner oder ähnliche Session-Rekonstruktions-Tools
+- Python 3.8+ für Automatisierungsskripte
+
+### Rechtliche Überlegungen
+- Erforderliche Genehmigungen für Netzwerk-Monitoring
+- Datenschutzbestimmungen bei der Payload-Analyse
+- Chain-of-Custody-Anforderungen für Netzwerk-Evidence
+
+## Fundamentale Protokoll-Analyse-Methodik
+
+### Layer 2 - Data Link Layer Forensik
+
+**Ethernet-Frame-Analyse für Asset-Discovery:**
+
+```bash
+# MAC-Adressen-Inventarisierung aus PCAP
+tshark -r capture.pcap -T fields -e eth.src -e eth.dst | sort -u
+```
+
+**Switch-Infrastruktur-Mapping:**
+- Spanning Tree Protocol (STP) Topologie-Rekonstruktion
+- VLAN-Segmentierung-Analyse
+- ARP-Spoofing-Detection durch MAC-IP-Binding-Inkonsistenzen
+
+**Kritische Anomalien:**
+- Unerwartete MAC-Präfixe (OUI-Analysis)
+- ARP-Reply ohne vorhergehende ARP-Request
+- Broadcast-Storm-Patterns bei DDoS-Aktivitäten
+
+### Layer 3 - Network Layer Investigation
+
+**IP-Header-Forensik für Geolocation und Routing:**
+
+```python
+# IP-Geolocation-Mapping mit Python
+import ipaddress
+from geolite2 import geolite2
+
+def analyze_ip_origins(pcap_ips):
+    reader = geolite2.reader()
+    for ip in pcap_ips:
+        if not ipaddress.ip_address(ip).is_private:
+            location = reader.get(ip)
+            print(f"{ip}: {location['country']['names']['en']}")
+```
+
+**TTL-Fingerprinting für OS-Detection:**
+- Windows: TTL 128 (typisch 128, 64, 32)
+- Linux/Unix: TTL 64
+- Cisco/Network-Equipment: TTL 255
+
+**Fragmentierungs-Analyse:**
+- Evil Fragmentation für IDS-Evasion
+- Teardrop-Attack-Patterns
+- Fragment-Overlap-Anomalien
+
+### Layer 4 - Transport Layer Forensik
+
+**TCP-Session-Rekonstruktion:**
+
+```bash
+# TCP-Streams extrahieren und analysieren
+tshark -r capture.pcap -q -z follow,tcp,ascii,0
+```
+
+**TCP-Fingerprinting-Techniken:**
+- Initial Window Size (IWS) Analysis
+- TCP-Options-Sequenz-Patterns
+- Maximum Segment Size (MSS) Charakteristika
+
+**UDP-Traffic-Anomalien:**
+- DNS-Tunneling über ungewöhnliche Record-Types
+- VoIP-Protokoll-Missbrauch für Datenexfiltration
+- TFTP-basierte Malware-Distribution
+
+## HTTP/HTTPS-Forensik für Web-basierte Angriffe
+
+### HTTP-Header-Deep-Dive
+
+**User-Agent-String-Forensik:**
+```python
+# Verdächtige User-Agent-Patterns
+suspicious_agents = [
+    "curl/",           # Command-line tools
+    "python-requests", # Scripted access
+    "Nikto",          # Vulnerability scanners
+    "sqlmap"          # SQL injection tools
+]
+```
+
+**HTTP-Method-Anomalien:**
+- PUT/DELETE-Requests auf produktiven Servern
+- TRACE-Method für XSS-Exploitation
+- Nicht-standard Methods (PATCH, OPTIONS) Analysis
+
+**Content-Type-Diskrepanzen:**
+- Executable-Content mit image/jpeg MIME-Type
+- JavaScript-Code in PDF-Dateien
+- Suspicious Content-Length vs. Actual-Payload-Size
+
+### HTTPS-Traffic-Analysis ohne Decryption
+
+**TLS-Handshake-Fingerprinting:**
+```bash
+# TLS-Version und Cipher-Suite-Analyse
+tshark -r capture.pcap -Y "tls.handshake.type == 1" \
+       -T fields -e tls.handshake.version -e tls.handshake.ciphersuites
+```
+
+**Certificate-Chain-Investigation:**
+- Self-signed Certificate-Anomalien
+- Certificate-Transparency-Log-Validation
+- Subject Alternative Name (SAN) Missbrauch
+
+**Encrypted-Traffic-Patterns:**
+- Packet-Size-Distribution-Analysis
+- Inter-arrival-Time-Patterns
+- Burst-Communication vs. Steady-State-Traffic
+
+## DNS-Forensik und Tunneling-Detection
+
+### DNS-Query-Pattern-Analysis
+
+**DNS-Tunneling-Indicators:**
+```python
+# DNS-Query-Length-Distribution-Analysis
+def analyze_dns_queries(pcap_file):
+    queries = extract_dns_queries(pcap_file)
+    avg_length = sum(len(q) for q in queries) / len(queries)
+    
+    # Normal DNS: 15-30 chars, Tunneling: 50+ chars
+    if avg_length > 50:
+        return "POTENTIAL_TUNNELING"
+```
+
+**Subdomain-Enumeration-Detection:**
+- Excessive NXDOMAIN-Responses
+- Sequential-Subdomain-Queries
+- High-Entropy-Subdomain-Names
+
+**DNS-over-HTTPS (DoH) Investigation:**
+- DoH-Provider-Identification (Cloudflare, Google, Quad9)
+- Encrypted-DNS-vs-Clear-DNS-Ratio-Analysis
+- Bootstrap-DNS-Query-Patterns
+
+## Command & Control (C2) Communication-Patterns
+
+### C2-Channel-Identification
+
+**HTTP-basierte C2-Kommunikation:**
+```bash
+# Beaconing-Pattern-Detection
+tshark -r capture.pcap -T fields -e frame.time_epoch -e ip.dst \
+       -Y "http" | awk 'script für regelmäßige Intervalle'
+```
+
+**Timing-Analysis für Beaconing:**
+- Jitter-Analyse bei Sleep-Intervallen
+- Callback-Frequency-Patterns
+- Network-Outage-Response-Behavior
+
+**Payload-Obfuscation-Techniques:**
+- Base64-encoded Commands in HTTP-Bodies
+- Steganographie in Bilddateien
+- JSON/XML-Structure-Abuse für Command-Transport
+
+### Advanced Persistent Threat (APT) Network-Signatures
+
+**Long-Duration-Connection-Analysis:**
+```python
+# Langzeit-Verbindungs-Identifikation
+def find_persistent_connections(pcap_data):
+    for session in tcp_sessions:
+        duration = session.end_time - session.start_time
+        if duration > timedelta(hours=24):
+            analyze_session_behavior(session)
+```
+
+**Multi-Stage-Payload-Delivery:**
+- Initial-Compromise-Vector-Analysis
+- Secondary-Payload-Download-Patterns
+- Lateral-Movement-Network-Signatures
+
+## Protokoll-Anomalie-Detection-Algorithmen
+
+### Statistical-Baseline-Establishment
+
+**Traffic-Volume-Baselines:**
+```python
+# Netzwerk-Baseline-Erstellung
+def establish_baseline(historical_data):
+    baseline = {
+        'avg_bandwidth': calculate_average_bps(historical_data),
+        'peak_hours': identify_peak_traffic_windows(historical_data),
+        'protocol_distribution': analyze_protocol_ratios(historical_data)
+    }
+    return baseline
+```
+
+**Port-Usage-Pattern-Analysis:**
+- Unexpected-Port-Combinations
+- High-Port-Range-Communication (> 32768)
+- Service-Port-Mismatches (HTTP on Port 443 without TLS)
+
+### Machine-Learning-Enhanced-Detection
+
+**Traffic-Classification-Models:**
+- Protocol-Identification via Payload-Analysis
+- Encrypted-Traffic-Classification
+- Anomaly-Score-Calculation für Unknown-Traffic
+
+## Session-Rekonstruktion und Payload-Extraktion
+
+### TCP-Stream-Reassembly
+
+**Bidirectional-Communication-Timeline:**
+```bash
+# Vollständige Session-Rekonstruktion
+mkdir session_analysis
+cd session_analysis
+
+# TCP-Streams einzeln extrahieren
+for stream in $(tshark -r ../capture.pcap -T fields -e tcp.stream | sort -u); do
+    tshark -r ../capture.pcap -q -z follow,tcp,raw,$stream > stream_$stream.raw
+done
+```
+
+**File-Carving aus Network-Streams:**
+- HTTP-File-Download-Reconstruction
+- Email-Attachment-Extraction via SMTP/POP3
+- FTP-Data-Channel-File-Recovery
+
+### Application-Layer-Protocol-Parsing
+
+**Custom-Protocol-Analysis:**
+```python
+# Proprietary-Protocol-Reverse-Engineering
+def analyze_custom_protocol(payload):
+    # Header-Structure-Identification
+    if len(payload) > 8:
+        magic_bytes = payload[:4]
+        length_field = struct.unpack('>I', payload[4:8])[0]
+        
+        if validate_structure(magic_bytes, length_field, payload):
+            return parse_protocol_fields(payload)
+```
+
+## Verschlüsselte Protokoll-Forensik
+
+### TLS/SSL-Traffic-Analysis
+
+**Certificate-Chain-Validation:**
+```bash
+# Certificate-Extraktion aus PCAP
+tshark -r capture.pcap -Y "tls.handshake.certificate" \
+       -T fields -e tls.handshake.certificate > certificates.hex
+
+# Certificate-Parsing
+xxd -r -p certificates.hex | openssl x509 -inform DER -text
+```
+
+**TLS-Version-Downgrade-Attacks:**
+- Forced-SSLv3-Negotiation-Detection
+- Weak-Cipher-Suite-Selection-Patterns
+- Certificate-Pinning-Bypass-Indicators
+
+### VPN-Traffic-Characterization
+
+**VPN-Protocol-Identification:**
+- OpenVPN: UDP Port 1194, specific packet-patterns
+- IPSec: ESP (Protocol 50), IKE (UDP 500)
+- WireGuard: UDP mit characteristic handshake-patterns
+
+**VPN-Tunnel-Analysis:**
+```python
+# VPN-Endpoint-Discovery
+def identify_vpn_endpoints(pcap_data):
+    potential_endpoints = []
+    for packet in pcap_data:
+        if detect_vpn_signature(packet):
+            potential_endpoints.append(packet.src_ip)
+    return analyze_endpoint_patterns(potential_endpoints)
+```
+
+## Häufige Herausforderungen und Troubleshooting
+
+### Performance-Optimierung bei großen PCAP-Dateien
+
+**Memory-Management:**
+```bash
+# Große PCAP-Dateien in kleinere Segmente aufteilen
+editcap -c 100000 large_capture.pcap segment.pcap
+
+# Zeitbasierte Segmentierung
+editcap -A "2024-01-01 00:00:00" -B "2024-01-01 01:00:00" \
+        large_capture.pcap hour_segment.pcap
+```
+
+**Selective-Filtering:**
+```bash
+# Nur relevanten Traffic extrahieren
+tshark -r large_capture.pcap -w filtered.pcap \
+       -Y "ip.addr == 192.168.1.100 or dns or http"
+```
+
+### False-Positive-Reduction
+
+**Legitimate-Traffic-Whitelisting:**
+- Corporate-Application-Signatures
+- Known-Good-Certificate-Authorities
+- Approved-Remote-Access-Solutions
+
+**Context-Aware-Analysis:**
+```python
+# Business-Context-Integration
+def validate_alert(network_event, business_context):
+    if is_maintenance_window(network_event.timestamp):
+        return False
+    if is_authorized_admin(network_event.source_ip):
+        return validate_admin_action(network_event)
+    return True
+```
+
+## Praktische Anwendungsszenarien
+
+### Szenario 1: Data Exfiltration Detection
+
+**Ausgangslage:** Verdacht auf Datendiebstahl aus dem Unternehmensnetzwerk
+
+**Analyse-Workflow:**
+1. **Baseline-Establishment:** Normale ausgehende Datenvolumen ermitteln
+2. **Spike-Detection:** Ungewöhnlich hohe Upload-Aktivitäten identifizieren
+3. **Destination-Analysis:** Externe Ziele der Datenübertragungen
+4. **Content-Classification:** Art der übertragenen Daten (soweit möglich)
+
+```bash
+# Ausgehende Datenvolumen-Analyse
+tshark -r capture.pcap -q -z io,stat,300 \
+       -Y "ip.src == 192.168.0.0/16 and ip.dst != 192.168.0.0/16"
+```
+
+### Szenario 2: APT-Lateral-Movement-Investigation
+
+**Ausgangslage:** Kompromittierter Host, Verdacht auf laterale Bewegung
+
+**Detection-Methoden:**
+- SMB-Authentication-Patterns (Pass-the-Hash-Attacks)
+- RDP-Session-Establishment-Chains
+- WMI/PowerShell-Remote-Execution-Signatures
+
+```python
+# Lateral-Movement-Timeline-Construction
+def construct_movement_timeline(network_data):
+    timeline = []
+    for connection in extract_internal_connections(network_data):
+        if detect_admin_protocols(connection):
+            timeline.append({
+                'timestamp': connection.start_time,
+                'source': connection.src_ip,
+                'target': connection.dst_ip,
+                'protocol': connection.protocol,
+                'confidence': calculate_suspicion_score(connection)
+            })
+    return sort_by_timestamp(timeline)
+```
+
+### Szenario 3: Malware C2 Communication Analysis
+
+**Ausgangslage:** Identifizierte Malware-Infection, C2-Channel-Mapping erforderlich
+
+**Systematic C2-Analysis:**
+1. **Beaconing-Pattern-Identification**
+2. **C2-Server-Geolocation**
+3. **Command-Structure-Reverse-Engineering**
+4. **Kill-Chain-Reconstruction**
+
+```bash
+# C2-Communication-Timeline
+tshark -r malware_capture.pcap -T fields \
+       -e frame.time -e ip.src -e ip.dst -e tcp.dstport \
+       -Y "ip.src == <infected_host>" | \
+       awk '{print $1, $4}' | sort | uniq -c
+```
+
+## Erweiterte Analyse-Techniken
+
+### Protocol-State-Machine-Analysis
+
+**TCP-State-Tracking:**
+```python
+class TCPStateAnalyzer:
+    def __init__(self):
+        self.connections = {}
+    
+    def process_packet(self, packet):
+        key = (packet.src_ip, packet.src_port, packet.dst_ip, packet.dst_port)
+        
+        if key not in self.connections:
+            self.connections[key] = TCPConnection()
+        
+        conn = self.connections[key]
+        conn.update_state(packet.tcp_flags)
+        
+        if conn.is_anomalous():
+            self.flag_suspicious_connection(key, conn)
+```
+
+**Application-Protocol-State-Validation:**
+- HTTP-Request/Response-Pairing-Validation
+- DNS-Query/Response-Correlation
+- SMTP-Session-Command-Sequence-Analysis
+
+### Geospatial-Network-Analysis
+
+**IP-Geolocation-Correlation:**
+```python
+# Geographische Anomalie-Detection
+def detect_geographic_anomalies(connections):
+    for conn in connections:
+        src_country = geolocate_ip(conn.src_ip)
+        dst_country = geolocate_ip(conn.dst_ip)
+        
+        if calculate_distance(src_country, dst_country) > 10000:  # km
+            if not is_known_global_service(conn.dst_ip):
+                flag_suspicious_connection(conn)
+```
+
+## Automatisierung und Tool-Integration
+
+### SIEM-Integration
+
+**Log-Format-Standardization:**
+```python
+# Network-Events zu SIEM-Format
+def convert_to_siem_format(network_event):
+    return {
+        'timestamp': network_event.time_iso,
+        'event_type': 'network_connection',
+        'source_ip': network_event.src_ip,
+        'destination_ip': network_event.dst_ip,
+        'protocol': network_event.protocol,
+        'risk_score': calculate_risk_score(network_event),
+        'indicators': extract_iocs(network_event)
+    }
+```
+
+### Threat-Intelligence-Integration
+
+**IOC-Matching:**
+```bash
+# Threat-Feed-Integration
+curl -s "https://threatfeed.example.com/api/ips" | \
+tee threat_ips.txt
+
+tshark -r capture.pcap -T fields -e ip.dst | \
+sort -u | \
+grep -f threat_ips.txt
+```
+
+## Nächste Schritte und Vertiefung
+
+### Weiterführende Analyse-Techniken
+- **Behavioral-Analysis:** Machine-Learning-basierte Anomalie-Detection
+- **Graph-Analysis:** Netzwerk-Relationship-Mapping
+- **Temporal-Analysis:** Time-Series-basierte Pattern-Recognition
+
+### Spezialisierung-Richtungen
+- **Cloud-Network-Forensics:** AWS VPC Flow Logs, Azure NSG Analysis
+- **IoT-Network-Analysis:** Constrained-Device-Communication-Patterns
+- **Industrial-Network-Security:** SCADA/Modbus-Protocol-Forensics
+
+### Tool-Ecosystem-Erweiterung
+- **Zeek (Bro):** Scriptable Network Security Monitor
+- **Suricata:** IDS/IPS mit Network-Forensik-Capabilities
+- **Moloch:** Full-Packet-Capture und Search-Platform
+
+Die systematische Netzwerkprotokoll-Analyse bildet das Fundament moderner Cyber-Forensik. Durch die Kombination von Deep-Protocol-Knowledge, statistischer Analyse und Threat-Intelligence entsteht ein mächtiges Arsenal für die Aufdeckung und Untersuchung von Cyberangriffen.
+
+**Empfohlene Übungen:**
+1. Analysieren Sie einen selbst erzeugten Netzwerk-Capture mit bekanntem "böswilligem" Traffic
+2. Implementieren Sie ein automatisiertes C2-Detection-Script
+3. Führen Sie eine komplette APT-Simulation durch und dokumentieren Sie die Netzwerk-Artefakte
+
+Die kontinuierliche Weiterentwicklung von Angriffstechniken erfordert permanente Aktualisierung der Analyse-Methoden. Bleiben Sie über aktuelle Threat-Research und neue Protocol-Exploitation-Techniques informiert.