mstoeck3/forensic-pathways
2
0
Fork 0
Code Issues 3 Pull Requests Projects Releases Activity

main #11

Merged
mstoeck3 merged 66 commits from main into forensic-ai 2025-08-11 12:02:56 +00:00
Conversation 0 Commits 66 Files Changed 54 +4579 -115
14 changed files with 4579 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit e6cee2ab0e - Show all commits

616
src/content/knowledgebase/concept-digital-evidence-chain.md Normal file
View File

@ -0,0 +1,616 @@
---
title: "Digital Evidence Chain of Custody: Lückenlose Beweisführung in der digitalen Forensik"
description: "Umfassender Leitfaden für die rechtssichere Dokumentation digitaler Beweise von der Sicherstellung bis zur Gerichtsverhandlung. Praktische Umsetzung von ISO 27037, Dokumentationsstandards und häufige Fallstricke."
author: "Claude 4 Sonnett (Prompt: Mario Stöckl)"
last_updated: 2024-01-15
difficulty: advanced
categories: ["standards", "documentation", "legal-compliance", "case-management"]
tags: ["chain-of-custody", "iso-27037", "court-admissible", "audit-trail", "hash-verification", "tamper-evidence", "legal-compliance", "documentation", "process-management", "evidence-handling"]
published: true
---
# Digital Evidence Chain of Custody: Lückenlose Beweisführung in der digitalen Forensik
Die **Chain of Custody** (Beweiskette) ist das Rückgrat jeder forensischen Untersuchung und entscheidet oft über Erfolg oder Misserfolg vor Gericht. Dieser Leitfaden erklärt die rechtssicheren Verfahren für die lückenlose Dokumentation digitaler Beweise von der Sicherstellung bis zur Gerichtsverhandlung.
## Warum ist die Chain of Custody entscheidend?
In der digitalen Forensik können Beweise innerhalb von Sekunden manipuliert, gelöscht oder verfälscht werden. Eine ordnungsgemäße Chain of Custody gewährleistet:
- **Gerichtliche Verwertbarkeit** der Beweise
- **Nachweis der Authentizität** und Integrität
- **Schutz vor Manipulationsvorwürfen**
- **Rechtssicherheit** für alle Beteiligten
- **Compliance** mit internationalen Standards
> **Warnung**: Bereits kleine Fehler in der Beweiskette können zur kompletten Verwerfung der Beweise führen und jahrelange Ermittlungsarbeit zunichte machen.
## Rechtliche Grundlagen und Standards
### Internationale Standards
**ISO/IEC 27037:2012** - "Guidelines for identification, collection, acquisition and preservation of digital evidence"
- Definiert Best Practices für digitale Beweismittel
- International anerkannter Standard
- Basis für nationale Implementierungen
**ISO/IEC 27041:2015** - "Guidance on assuring suitability and adequacy of incident investigative method"
- Ergänzt ISO 27037 um Qualitätssicherung
- Fokus auf Angemessenheit der Methoden
### Nationale Rahmenwerke
**Deutschland**:
- § 81a StPO (Körperliche Untersuchung)
- § 94 ff. StPO (Beschlagnahme)
- BSI-Standards zur IT-Forensik
**USA**:
- Federal Rules of Evidence (Rule 901, 902)
- NIST Special Publication 800-86
**EU**:
- GDPR-Compliance bei der Beweissicherung
- eIDAS-Verordnung für digitale Signaturen
## Die vier Säulen der Chain of Custody
### 1. Authentizität (Echtheit)
**Definition**: Nachweis, dass die Beweise tatsächlich von der behaupteten Quelle stammen.
**Praktische Umsetzung**:
```bash
# Cryptographic Hash Generation
sha256sum /dev/sdb1 > evidence_hash.txt
md5sum /dev/sdb1 >> evidence_hash.txt
# Mit Zeitstempel
echo "$(date -u +%Y-%m-%dT%H:%M:%SZ): $(sha256sum /dev/sdb1)" >> chain_log.txt
```
### 2. Integrität (Unversehrtheit)
**Definition**: Sicherstellung, dass die Beweise seit der Sicherstellung unverändert geblieben sind.
**Maßnahmen**:
- **Write-Blocker** bei allen Zugriffen
- **Hash-Verifizierung** vor und nach jeder Bearbeitung
- **Versionskontrolle** für alle Arbeitskopien
### 3. Nachvollziehbarkeit (Traceability)
**Definition**: Lückenlose Dokumentation aller Personen, die Zugang zu den Beweisen hatten.
**Dokumentationspflicht**: Wer, Was, Wann, Wo, Warum
### 4. Nicht-Abstreitbarkeit (Non-Repudiation)
**Definition**: Verhinderung, dass Beteiligte ihre Handlungen später abstreiten können.
**Technische Lösung**: Digitale Signaturen, Blockchain-Timestamping
## Praktische Implementierung: Schritt-für-Schritt
### Phase 1: Vorbereitung der Sicherstellung
**Equipment-Check**:
```checklist
□ Kalibrierte Write-Blocker
□ Forensische Imaging-Tools
□ Chain of Custody Formulare
□ Tamper-evident Bags/Labels
□ Digitalkamera für Dokumentation
□ Messgeräte (falls erforderlich)
□ Backup-Ausrüstung
```
**Dokumentation vor Ort**:
1. **Umgebungsfotografie** (360°-Dokumentation)
2. **Hardware-Identifikation** (Seriennummern, Labels)
3. **Netzwerkzustand** (aktive Verbindungen)
4. **Bildschirmzustand** (Screenshots vor Herunterfahren)
### Phase 2: Sichere Akquisition
**Write-Blocker Setup**:
```bash
# Hardware Write-Blocker Verification
lsblk -o NAME,SIZE,RO,TYPE,MOUNTPOINT
# RO sollte "1" anzeigen für geschützte Devices
# Software Write-Blocker (Linux)
blockdev --setro /dev/sdb
blockdev --getro /dev/sdb # Should return 1
```
**Imaging mit Integrity Check**:
```bash
# dd mit Hash-Berechnung
dd if=/dev/sdb | tee >(sha256sum > image.sha256) | dd of=evidence.dd
# Oder mit dcfldd für bessere Forensik-Features
dcfldd if=/dev/sdb of=evidence.dd hash=sha256,md5 hashlog=hashlog.txt bs=4096
```
### Phase 3: Dokumentation und Versiegelung
**Chain of Custody Form - Kernelemente**:
```
DIGITAL EVIDENCE CUSTODY FORM
Fall-ID: _______________ Datum: _______________
Ermittler: _______________ Badge/ID: _______________
BEWEISMITTEL DETAILS:
- Beschreibung: ________________________________
- Seriennummer: _______________________________
- Hersteller/Modell: ___________________________
- Kapazität: __________________________________
- Hash-Werte:
* SHA256: ___________________________________
* MD5: _____________________________________
CUSTODY CHAIN:
[Datum/Zeit] [Übernommen von] [Übergeben an] [Zweck] [Unterschrift]
_________________________________________________________________
_________________________________________________________________
INTEGRITÄT BESTÄTIGT:
□ Write-Blocker verwendet
□ Hash-Werte verifiziert
□ Tamper-evident versiegelt
□ Fotos dokumentiert
```
**Versiegelung**:
```
Tamper-Evident Label Nummer: ______________
Siegeltyp: _______________________________
Platzierung: _____________________________
Foto-Referenz: ___________________________
```
### Phase 4: Transport und Lagerung
**Sichere Aufbewahrung**:
- **Klimakontrollierte Umgebung** (15-25°C, <60% Luftfeuchtigkeit)
- **Elektromagnetische Abschirmung** (Faraday-Käfig)
- **Zugangskontrolle** (Biometrie, Kartenleser)
- **Überwachung** (24/7 Video, Alarme)
**Transport-Protokoll**:
```
TRANSPORT LOG
Von: ______________________ Nach: ______________________
Datum/Zeit Start: _____________ Ankunft: _______________
Transportmittel: ___________________________________
Begleitpersonen: ___________________________________
Spezielle Vorkehrungen: ____________________________
Integrität bei Ankunft:
□ Siegel unversehrt
□ Hash-Werte überprüft
□ Keine physischen Schäden
□ Dokumentation vollständig
Empfänger: _________________ Unterschrift: _____________
```
## Digitale Chain of Custody Tools
### Laboratory Information Management Systems (LIMS)
**Kommerzielle Lösungen**:
- **FRED (Forensic Recovery of Evidence Device)**
- **CaseGuard** von AccessData
- **EnCase Legal** von OpenText
**Open Source Alternativen**:
```python
# Beispiel: Python-basierte CoC Tracking
import hashlib
import datetime
import json
from cryptography.fernet import Fernet
class ChainOfCustody:
def __init__(self):
self.evidence_log = []
self.key = Fernet.generate_key()
self.cipher = Fernet(self.key)
def add_custody_event(self, evidence_id, handler, action, location):
event = {
'timestamp': datetime.datetime.utcnow().isoformat(),
'evidence_id': evidence_id,
'handler': handler,
'action': action,
'location': location,
'hash': self.calculate_hash(evidence_id)
}
# Encrypt sensitive data
encrypted_event = self.cipher.encrypt(json.dumps(event).encode())
self.evidence_log.append(encrypted_event)
return event
def calculate_hash(self, evidence_path):
"""Calculate SHA256 hash of evidence file"""
hash_sha256 = hashlib.sha256()
with open(evidence_path, "rb") as f:
for chunk in iter(lambda: f.read(4096), b""):
hash_sha256.update(chunk)
return hash_sha256.hexdigest()
```
### Blockchain-basierte Lösungen
**Unveränderliche Timestamps**:
```solidity
// Ethereum Smart Contract Beispiel
pragma solidity ^0.8.0;
contract EvidenceChain {
struct CustodyEvent {
uint256 timestamp;
string evidenceId;
string handler;
string action;
string hashValue;
}
mapping(string => CustodyEvent[]) public evidenceChain;
event CustodyTransfer(
string indexed evidenceId,
string handler,
uint256 timestamp
);
function addCustodyEvent(
string memory _evidenceId,
string memory _handler,
string memory _action,
string memory _hashValue
) public {
evidenceChain[_evidenceId].push(CustodyEvent({
timestamp: block.timestamp,
evidenceId: _evidenceId,
handler: _handler,
action: _action,
hashValue: _hashValue
}));
emit CustodyTransfer(_evidenceId, _handler, block.timestamp);
}
}
```
## Häufige Fehler und Fallstricke
### Kritische Dokumentationsfehler
**1. Unvollständige Handler-Information**
```
❌ Falsch: "IT-Abteilung"
✅ Richtig: "Max Mustermann, IT-Administrator, Badge #12345, Abteilung IT-Security"
```
**2. Unspezifische Aktionsbeschreibungen**
```
❌ Falsch: "Analyse durchgeführt"
✅ Richtig: "Keyword-Suche nach 'vertraulich' mit EnCase v21.2,
Read-Only Zugriff, Image Hash vor/nach verifiziert"
```
**3. Lückenhafte Zeiterfassung**
```
❌ Falsch: "15:30"
✅ Richtig: "2024-01-15T15:30:27Z (UTC), Zeitzone CET+1"
```
### Technische Fallstricke
**Hash-Algorithmus Schwächen**:
```bash
# Vermeide MD5 für neue Fälle (Kollisionsanfällig)
❌ md5sum evidence.dd
# Verwende stärkere Algorithmen
✅ sha256sum evidence.dd
✅ sha3-256sum evidence.dd # Noch sicherer
```
**Write-Blocker Bypass**:
```bash
# Prüfe IMMER Write-Protection
blockdev --getro /dev/sdb
if [ $? -eq 0 ]; then
echo "Write protection AKTIV"
else
echo "WARNUNG: Write protection NICHT aktiv!"
exit 1
fi
```
### Rechtliche Fallstricke
**GDPR-Compliance bei EU-Fällen**:
- **Datenschutz-Folgenabschätzung** vor Imaging
- **Zweckbindung** der Beweiserhebung
- **Löschfristen** nach Verfahrensabschluss
**Jurisdiktionsprobleme**:
- **Cloud-Evidence** in verschiedenen Ländern
- **Verschiedene Beweisstandards** (Common Law vs. Civil Law)
- **Internationale Rechtshilfe** erforderlich
## Qualitätssicherung und Audit
### Peer Review Verfahren
**4-Augen-Prinzip**:
```
Imaging-Protokoll:
Techniker A: _________________ (Durchführung)
Techniker B: _________________ (Verifikation)
Supervisor: __________________ (Freigabe)
```
**Hash-Verifikation Zeitplan**:
```
Initial: SHA256 bei Akquisition
Transport: Hash-Check vor/nach Transport
Labor: Hash-Check bei Laborankunft
Analyse: Hash-Check vor jeder Analyse
Archiv: Hash-Check bei Archivierung
Vernichtung: Final Hash-Check vor Vernichtung
```
### Continuous Monitoring
**Automated Integrity Checks**:
```bash
#!/bin/bash
# integrity_monitor.sh
EVIDENCE_DIR="/secure/evidence"
LOG_FILE="/var/log/evidence_integrity.log"
for evidence_file in "$EVIDENCE_DIR"/*.dd; do
stored_hash=$(cat "${evidence_file}.sha256")
current_hash=$(sha256sum "$evidence_file" | cut -d' ' -f1)
if [ "$stored_hash" != "$current_hash" ]; then
echo "ALERT: Integrity violation detected for $evidence_file" | \
tee -a "$LOG_FILE"
# Send immediate alert
mail -s "Evidence Integrity Alert" admin@forensics.org < \
"$LOG_FILE"
fi
done
```
## Internationale Gerichtspraxis
### Deutschland - BGH Rechtsprechung
**BGH 1 StR 142/18** (2018):
- Digitale Beweise müssen **nachvollziehbar erhoben** werden
- **Hash-Werte allein** reichen nicht aus
- **Gesamter Erhebungsprozess** muss dokumentiert sein
### USA - Federal Courts
**United States v. Tank (2018)**:
- **Authentication** unter Federal Rule 901(b)(9)
- **Best Practices** sind nicht immer **rechtlich erforderlich**
- **Totality of circumstances** entscheidet
### EU - EuGH Rechtsprechung
**Rechtssache C-203/15** (2016):
- **Grundrechte** vs. **Strafverfolgung**
- **Verhältnismäßigkeit** der Beweiserhebung
- **GDPR-Compliance** auch bei strafrechtlichen Ermittlungen
## Fallstudien aus der Praxis
### Case Study 1: Ransomware-Angriff Automobilhersteller
**Szenario**:
Ransomware-Angriff auf Produktionssysteme, 50+ Systeme betroffen
**CoC-Herausforderungen**:
- **Zeitdruck** durch Produktionsstillstand
- **Verschiedene Standorte** (Deutschland, Tschechien, Mexiko)
- **Rechtliche Anforderungen** in 3 Jurisdiktionen
**Lösung**:
```
Parallel Teams:
- Team 1: Incident Response (Live-Analyse)
- Team 2: Evidence Preservation (Imaging)
- Team 3: Documentation (CoC-Protokoll)
Zentrale Koordination:
- Shared CoC-Database (Cloud-basiert)
- Video-Calls für Custody-Transfers
- Digital Signatures für Remote-Bestätigung
```
**Lessons Learned**:
- **Vorab-Planung** für Multi-Jurisdiktion essentiell
- **Remote-CoC-Verfahren** erforderlich
- **24/7-Verfügbarkeit** der Dokumentationssysteme
### Case Study 2: Betrugsermittlung Finanzdienstleister
**Szenario**:
Verdacht auf Insiderhandel, E-Mail-Analyse von 500+ Mitarbeitern
**CoC-Komplexität**:
- **Privacy Laws** (GDPR, Bankengeheimnis)
- **Privileged Communications** (Anwalt-Mandant)
- **Regulatory Oversight** (BaFin, SEC)
**Chain of Custody Strategie**:
```
Segregated Processing:
1. Initial Triage (Automated)
2. Legal Review (Attorney-Client Privilege)
3. Regulatory Notification (Compliance)
4. Technical Analysis (Forensik-Team)
Access Controls:
- Role-based Evidence Access
- Need-to-know Principle
- Audit Log for every Access
```
## Technologie-Trends und Zukunftsausblick
### KI-basierte CoC-Automatisierung
**Machine Learning für Anomalie-Erkennung**:
```python
from sklearn.ensemble import IsolationForest
import pandas as pd
# CoC Event Anomaly Detection
def detect_custody_anomalies(custody_events):
"""
Detect unusual patterns in custody transfers
"""
features = pd.DataFrame(custody_events)
# Feature Engineering
features['time_delta'] = features['timestamp'].diff()
features['handler_changes'] = features['handler'].ne(features['handler'].shift())
# Anomaly Detection
model = IsolationForest(contamination=0.1)
anomalies = model.fit_predict(features.select_dtypes(include=[np.number]))
return features[anomalies == -1]
```
### Quantum-Safe Cryptography
**Vorbereitung auf Post-Quantum Era**:
```
Current: RSA-2048, SHA-256
Transitional: RSA-4096, SHA-3
Future: Lattice-based, Hash-based Signatures
```
### Cloud-Native Evidence Management
**Container-basierte Forensik-Pipelines**:
```yaml
# docker-compose.yml für Forensik-Lab
version: '3.8'
services:
evidence-intake:
image: forensics/evidence-intake:v2.1
volumes:
- ./evidence:/data
environment:
- AUTO_HASH=true
- BLOCKCHAIN_LOGGING=true
chain-tracker:
image: forensics/chain-tracker:v1.5
depends_on:
- postgres
environment:
- DATABASE_URL=postgresql://user:pass@postgres:5432/custody
```
## Best Practices Zusammenfassung
### Präventive Maßnahmen
**1. Standardisierte Verfahren**
```
□ SOPs für alle Custody-Schritte
□ Regelmäßige Team-Schulungen
□ Tool-Kalibrierung und -Wartung
□ Backup-Verfahren für Ausfälle
```
**2. Technische Safeguards**
```
□ Redundante Hash-Algorithmen
□ Automated Integrity Monitoring
□ Secure Transport Protocols
□ Environmental Monitoring
```
**3. Rechtliche Compliance**
```
□ Jurisdiction-spezifische SOPs
□ Regular Legal Updates
□ Attorney Consultation Process
□ International Cooperation Agreements
```
### Reaktive Maßnahmen
**Incident Response bei CoC-Verletzungen**:
```
1. Immediate Containment
- Stop all evidence processing
- Secure affected items
- Document incident details
2. Impact Assessment
- Determine scope of compromise
- Identify affected cases
- Assess legal implications
3. Remediation
- Re-establish chain where possible
- Alternative evidence strategies
- Legal notification requirements
4. Prevention
- Root cause analysis
- Process improvements
- Additional controls
```
## Fazit
Die Chain of Custody ist mehr als eine administrative Pflicht - sie ist das **Fundament der digitalen Forensik**. Ohne ordnungsgemäße Beweiskette können selbst die stärksten technischen Beweise vor Gericht wertlos werden.
**Schlüsselprinzipien für den Erfolg**:
1. **Vorbereitung ist alles** - SOPs und Tools vor dem Incident
2. **Dokumentation über alles** - Im Zweifel mehr dokumentieren
3. **Technologie als Enabler** - Automatisierung wo möglich
4. **Menschen im Fokus** - Training und Awareness entscheidend
5. **Kontinuierliche Verbesserung** - Lessons Learned Integration
Die Investition in robuste Chain of Custody Verfahren zahlt sich langfristig aus - durch höhere Erfolgsraten vor Gericht, reduzierte Compliance-Risiken und erhöhte Glaubwürdigkeit der forensischen Arbeit.
> **Merksatz**: "Eine Kette ist nur so stark wie ihr schwächstes Glied - in der digitalen Forensik ist das oft die menschliche Komponente, nicht die technische."
## Weiterführende Ressourcen
**Standards und Guidelines**:
- [ISO/IEC 27037:2012](https://www.iso.org/standard/44381.html) - Digital Evidence Guidelines
- [NIST SP 800-86](https://csrc.nist.gov/publications/detail/sp/800-86/final) - Computer Forensics Guide
- [RFC 3227](https://tools.ietf.org/html/rfc3227) - Evidence Collection Guidelines
**Training und Zertifizierung**:
- SANS FOR500 (Windows Forensic Analysis)
- SANS FOR508 (Advanced Incident Response)
- IACIS Certified Forensic Computer Examiner (CFCE)
- CISSP (Chain of Custody Domain)
**Tools und Software**:
- [FTK Imager](https://www.exterro.com/digital-forensics-software/ftk-imager) - Free Imaging Tool
- [Autopsy](https://www.sleuthkit.org/autopsy/) - Open Source Platform
- [MSAB XRY](https://www.msab.com/) - Mobile Forensics
- [Cellebrite UFED](https://www.cellebrite.com/) - Mobile Evidence Extraction

471
src/content/knowledgebase/concept-file-system-storage-forensics.md Normal file
View File

@ -0,0 +1,471 @@
---
title: "Dateisystem-Forensik: Von NTFS-Strukturen bis Cloud-Storage-Artefakten"
description: "Umfassender Leitfaden zur forensischen Analyse von Dateisystemen - NTFS-Metadaten, ext4-Journaling, APFS-Snapshots und Cloud-Storage-Forensik für professionelle Datenrekonstruktion"
author: "Claude 4 Sonnett (Prompt: Mario Stöckl)"
last_updated: 2024-01-15
difficulty: intermediate
categories: ["analysis", "configuration", "troubleshooting"]
tags: ["filesystem-analysis", "metadata-extraction", "deleted-data-recovery", "slack-space", "journaling-analysis", "timestamp-forensics", "partition-analysis", "cloud-storage", "ntfs", "ext4", "apfs", "data-carving"]
tool_name: "File Systems & Storage Forensics"
related_tools: ["Autopsy", "The Sleuth Kit", "FTK Imager", "Volatility", "X-Ways Forensics"]
published: true
---
# Dateisystem-Forensik: Von NTFS-Strukturen bis Cloud-Storage-Artefakten
Die forensische Analyse von Dateisystemen bildet das Fundament moderner Digital Forensics. Dieser umfassende Leitfaden behandelt die kritischen Aspekte der Dateisystem-Forensik von traditionellen lokalen Speichermedien bis hin zu modernen Cloud-Storage-Umgebungen.
## Grundlagen der Dateisystem-Forensik
### Was ist Dateisystem-Forensik?
Dateisystem-Forensik umfasst die systematische Untersuchung von Speicherstrukturen zur Rekonstruktion digitaler Beweise. Dabei werden nicht nur sichtbare Dateien analysiert, sondern auch Metadaten, gelöschte Inhalte und versteckte Artefakte untersucht.
### Zentrale forensische Konzepte
**Metadaten-Analyse**: Jedes Dateisystem speichert umfangreiche Metadaten über Dateien, Verzeichnisse und Systemaktivitäten. Diese Informationen sind oft aussagekräftiger als der eigentliche Dateiinhalt.
**Slack Space**: Der ungenutzte Bereich zwischen dem Ende einer Datei und dem Ende des zugewiesenen Clusters kann Reste vorheriger Dateien enthalten.
**Journaling**: Moderne Dateisysteme protokollieren Änderungen in Journal-Dateien, die wertvolle Timeline-Informationen liefern.
**Timeline-Rekonstruktion**: Durch Kombination verschiedener Timestamp-Quellen lassen sich detaillierte Aktivitätszeitlinien erstellen.
## NTFS-Forensik: Das Windows-Dateisystem im Detail
### Master File Table (MFT) Analyse
Die MFT ist das Herzstück von NTFS und enthält Einträge für jede Datei und jeden Ordner auf dem Volume.
**Struktur eines MFT-Eintrags:**
```
Offset 0x00: FILE-Signatur
Offset 0x04: Update Sequence Array Offset
Offset 0x06: Update Sequence Array Größe
Offset 0x08: $LogFile Sequence Number (LSN)
Offset 0x10: Sequence Number
Offset 0x12: Hard Link Count
Offset 0x14: Erste Attribut-Offset
```
**Forensisch relevante Attribute:**
- `$STANDARD_INFORMATION`: Timestamps, Dateiberechtigungen
- `$FILE_NAME`: Dateiname, zusätzliche Timestamps
- `$DATA`: Dateiinhalt oder Cluster-Referenzen
- `$SECURITY_DESCRIPTOR`: Zugriffsberechtigungen
**Praktische Analyse-Techniken:**
1. **Gelöschte MFT-Einträge identifizieren**: Einträge mit FILE0-Signatur sind oft gelöschte Dateien
2. **Timeline-Anomalien erkennen**: Vergleich zwischen $STANDARD_INFORMATION und $FILE_NAME Timestamps
3. **Resident vs. Non-Resident Data**: Kleine Dateien (< 700 Bytes) werden direkt in der MFT gespeichert
### $LogFile Analyse für Aktivitäts-Tracking
Das NTFS-Journal protokolliert alle Dateisystem-Änderungen und ermöglicht detaillierte Aktivitäts-Rekonstruktion.
**Relevante Log-Record-Typen:**
- `CreateFile`: Datei-/Ordnererstellung
- `DeleteFile`: Löschvorgänge
- `RenameFile`: Umbenennungen
- `SetInformationFile`: Metadaten-Änderungen
**Analyse-Workflow:**
```bash
# Mit istat (Sleuth Kit) MFT-Eintrag analysieren
istat /dev/sda1 5 # MFT-Eintrag 5 anzeigen
# Mit fls gelöschte Dateien auflisten
fls -r -d /dev/sda1
# Mit tsk_recover gelöschte Dateien wiederherstellen
tsk_recover /dev/sda1 /recovery/
```
### Alternate Data Streams (ADS) Detection
ADS können zur Datenverbergung missbraucht werden und sind oft übersehen.
**Erkennungsstrategien:**
1. **MFT-Analyse auf mehrere $DATA-Attribute**: Dateien mit ADS haben multiple $DATA-Einträge
2. **Powershell-Erkennung**: `Get-Item -Path C:\file.txt -Stream *`
3. **Forensik-Tools**: Autopsy zeigt ADS automatisch in der File-Analyse
### Volume Shadow Copies für Timeline-Rekonstruktion
VSCs bieten Snapshots des Dateisystems zu verschiedenen Zeitpunkten.
**Forensische Relevanz:**
- Wiederherstellung gelöschter/überschriebener Dateien
- Timeline-Rekonstruktion über längere Zeiträume
- Registry-Hive-Vergleiche zwischen Snapshots
**Zugriff auf VSCs:**
```cmd
# VSCs auflisten
vssadmin list shadows
# VSC mounten
vshadow -p C: -script=shadow.cmd
```
## ext4-Forensik: Linux-Dateisystem-Analyse
### Ext4-Journal-Analyse
Das ext4-Journal (`/journal`) protokolliert Transaktionen und bietet wertvolle forensische Artefakte.
**Journal-Struktur:**
- **Descriptor Blocks**: Beschreiben bevorstehende Transaktionen
- **Data Blocks**: Enthalten die eigentlichen Datenänderungen
- **Commit Blocks**: Markieren abgeschlossene Transaktionen
- **Revoke Blocks**: Listen widerrufene Blöcke auf
**Praktische Analyse:**
```bash
# Journal-Informationen anzeigen
tune2fs -l /dev/sda1 | grep -i journal
# Mit debugfs Journal untersuchen
debugfs /dev/sda1
debugfs: logdump -a journal_file
# Ext4-Metadaten extrahieren
icat /dev/sda1 8 > journal.raw # Inode 8 ist typisch das Journal
```
### Inode-Struktur und Deleted-File-Recovery
**Ext4-Inode-Aufbau:**
```
struct ext4_inode {
__le16 i_mode; # Dateityp und Berechtigungen
__le16 i_uid; # Benutzer-ID
__le32 i_size; # Dateigröße
__le32 i_atime; # Letzter Zugriff
__le32 i_ctime; # Inode-Änderung
__le32 i_mtime; # Letzte Modifikation
__le32 i_dtime; # Löschzeitpunkt
...
__le32 i_block[EXT4_N_BLOCKS]; # Block-Pointer
};
```
**Recovery-Techniken:**
1. **Inode-Scanning**: Suche nach Inodes mit gesetztem dtime aber erhaltenen Blöcken
2. **Journal-Recovery**: Replay von Journal-Einträgen vor Löschzeitpunkt
3. **Directory-Entry-Recovery**: Undelfs-Techniken für kürzlich gelöschte Dateien
### Extended Attributes (xattr) Forensik
Extended Attributes speichern zusätzliche Metadaten und Sicherheitskontext.
**Forensisch relevante xattrs:**
- `security.selinux`: SELinux-Kontext
- `user.*`: Benutzerdefinierte Attribute
- `system.posix_acl_*`: ACL-Informationen
- `security.capability`: File-Capabilities
```bash
# Alle xattrs einer Datei anzeigen
getfattr -d /path/to/file
# Spezifisches Attribut extrahieren
getfattr -n user.comment /path/to/file
```
## APFS und HFS+ Forensik: macOS-Dateisysteme
### APFS-Snapshots für Point-in-Time-Analysis
APFS erstellt automatisch Snapshots, die forensische Goldgruben darstellen.
**Snapshot-Management:**
```bash
# Snapshots auflisten
tmutil listlocalsnapshots /
# Snapshot mounten
diskutil apfs mount -snapshot snapshot_name
# Snapshot-Metadaten analysieren
diskutil apfs list
```
**Forensische Anwendung:**
- Vergleich von Dateisystem-Zuständen über Zeit
- Recovery von gelöschten/modifizierten Dateien
- Malware-Persistenz-Analyse
### HFS+-Katalog-Datei-Forensik
Die Katalog-Datei ist das Äquivalent zur NTFS-MFT in HFS+.
**Struktur:**
- **Header Node**: Baum-Metadaten
- **Index Nodes**: Verweise auf Leaf Nodes
- **Leaf Nodes**: Eigentliche Datei-/Ordner-Records
- **Map Nodes**: Freie/belegte Nodes
**Forensische Techniken:**
```bash
# Mit hfsdump Katalog analysieren
hfsdump -c /dev/disk1s1
# Gelöschte Dateien suchen
fls -r -f hfsplus /dev/disk1s1
```
## Cloud Storage Forensics
### OneDrive-Artefakt-Analyse
**Lokale Artefakte:**
- `%USERPROFILE%\OneDrive\*`: Synchronisierte Dateien
- Registry: `HKCU\Software\Microsoft\OneDrive`
- Event Logs: OneDrive-spezifische Ereignisse
**Forensische Analyse-Punkte:**
1. **Sync-Status**: Welche Dateien wurden synchronisiert?
2. **Conflict-Resolution**: Wie wurden Konflikte gelöst?
3. **Version-History**: Zugriff auf vorherige Datei-Versionen
4. **Sharing-Activities**: Geteilte Dateien und Berechtigungen
```powershell
# OneDrive-Status abfragen
Get-ItemProperty -Path "HKCU:\Software\Microsoft\OneDrive\Accounts\*"
# Sync-Engine-Logs analysieren
Get-WinEvent -LogName "Microsoft-Windows-OneDrive/Operational"
```
### Google Drive Forensik
**Client-seitige Artefakte:**
- `%LOCALAPPDATA%\Google\Drive\*`: Lokaler Cache
- SQLite-Datenbanken: Sync-Metadaten
- Temporary Files: Unvollständige Downloads
**Wichtige Datenbanken:**
- `sync_config.db`: Sync-Konfiguration
- `cloud_graph.db`: Cloud-Dateienstruktur
- `metadata_database`: Datei-Metadaten
```bash
# SQLite-Datenbank analysieren
sqlite3 sync_config.db
.tables
SELECT * FROM data WHERE key LIKE '%sync%';
```
### Dropbox-Forensik
**Forensische Artefakte:**
- `%APPDATA%\Dropbox\*`: Konfiguration und Logs
- `.dropbox.cache\*`: Lokaler Cache
- Database-Dateien: Sync-Historie
**Wichtige Dateien:**
- `config.dbx`: Verschlüsselte Konfiguration
- `filecache.dbx`: Datei-Cache-Informationen
- `deleted.dbx`: Gelöschte Dateien-Tracking
## File Carving und Datenrekonstruktion
### Header/Footer-basiertes Carving
**Klassische Ansätze:**
```bash
# Mit foremost File-Carving durchführen
foremost -t jpg,pdf,doc -i /dev/sda1 -o /recovery/
# Mit scalpel erweiterte Pattern verwenden
scalpel -b -o /recovery/ /dev/sda1
# Mit photorec interaktives Recovery
photorec /dev/sda1
```
**Custom Carving-Patterns:**
```
# scalpel.conf Beispiel
jpg y 200000000 \xff\xd8\xff\xe0\x00\x10 \xff\xd9
pdf y 200000000 %PDF- %%EOF\x0d
zip y 100000000 PK\x03\x04 PK\x05\x06
```
### Fragmentierte Datei-Rekonstruktion
**Bifragment-Gap-Carving:**
1. Identifikation von Header-Fragmenten
2. Berechnung wahrscheinlicher Fragment-Größen
3. Gap-Analyse zwischen Fragmenten
4. Reassembly mit Plausibilitätsprüfung
**Smart-Carving-Techniken:**
- Semantic-aware Carving für Office-Dokumente
- JPEG-Quantization-Table-Matching
- Video-Keyframe-basierte Rekonstruktion
## Timestamp-Manipulation und -Analyse
### MACB-Timeline-Erstellung
**Timestamp-Kategorien:**
- **M** (Modified): Letzter Schreibzugriff auf Dateiinhalt
- **A** (Accessed): Letzter Lesezugriff (oft deaktiviert)
- **C** (Changed): Metadaten-Änderung (Inode/MFT)
- **B** (Born): Erstellungszeitpunkt
```bash
# Mit fls Timeline erstellen
fls -r -m C: > timeline.bodyfile
mactime -d -b timeline.bodyfile > timeline.csv
# Mit log2timeline umfassende Timeline
log2timeline.py --storage-file timeline.plaso image.dd
psort.py -o l2tcsv -w timeline_full.csv timeline.plaso
```
### Timestamp-Manipulation-Detection
**Erkennungsstrategien:**
1. **Chronologie-Anomalien**: Created > Modified Timestamps
2. **Präzisions-Analyse**: Unnatürliche Rundung auf Sekunden/Minuten
3. **Filesystem-Vergleich**: Inkonsistenzen zwischen verschiedenen Timestamp-Quellen
4. **Batch-Manipulation**: Verdächtige Muster bei mehreren Dateien
**Registry-basierte Evidenz:**
```
HKLM\SYSTEM\CurrentControlSet\Control\FileSystem\NtfsDisableLastAccessUpdate
```
## Häufige Herausforderungen und Lösungsansätze
### Performance-Optimierung bei großen Images
**Problem**: Analyse von Multi-TB-Images dauert Tage
**Lösungen**:
1. **Selective Processing**: Nur relevante Partitionen analysieren
2. **Parallel Processing**: Multi-threaded Tools verwenden
3. **Hardware-Optimierung**: NVMe-SSDs für temporäre Dateien
4. **Cloud-Processing**: Verteilte Analyse in der Cloud
### Verschlüsselte Container und Volumes
**BitLocker-Forensik**:
```bash
# Mit dislocker BitLocker-Volume mounten
dislocker -r -V /dev/sda1 -p password -- /tmp/bitlocker
# Recovery-Key-basierter Zugriff
dislocker -r -V /dev/sda1 -k recovery.key -- /tmp/bitlocker
```
**VeraCrypt-Analyse**:
- Header-Backup-Analyse für mögliche Passwort-Recovery
- Hidden-Volume-Detection durch Entropie-Analyse
- Keyfile-basierte Entschlüsselung
### Anti-Forensik-Techniken erkennen
**Wiping-Detection**:
- Pattern-Analyse für DoD 5220.22-M Wiping
- Random-Data vs. Encrypted-Data Unterscheidung
- Unvollständige Wiping-Artefakte
**Timestomp-Detection**:
```bash
# Mit analyzeMFT.py Timestamp-Anomalien finden
analyzeMFT.py -f $MFT -o analysis.csv
# Analyse der $SI vs. $FN Timestamp-Diskrepanzen
```
## Tool-Integration und Workflows
### Autopsy-Integration
**Workflow-Setup**:
1. **Image-Import**: E01/DD-Images mit Hash-Verifikation
2. **Ingest-Module**: File-Type-Detection, Hash-Lookup, Timeline-Creation
3. **Analysis**: Keyword-Search, Timeline-Analysis, File-Category-Review
4. **Reporting**: Automatisierte Report-Generierung
### TSK-Kommandozeilen-Pipeline
```bash
#!/bin/bash
# Vollständiger Dateisystem-Analyse-Workflow
IMAGE="/cases/evidence.dd"
OUTPUT="/analysis/case001"
# 1. Partitionstabelle analysieren
mmls "$IMAGE" > "$OUTPUT/partitions.txt"
# 2. Dateisystem-Info extrahieren
fsstat "$IMAGE" > "$OUTPUT/filesystem_info.txt"
# 3. Timeline erstellen
fls -r -m "$IMAGE" > "$OUTPUT/timeline.bodyfile"
mactime -d -b "$OUTPUT/timeline.bodyfile" > "$OUTPUT/timeline.csv"
# 4. Gelöschte Dateien auflisten
fls -r -d "$IMAGE" > "$OUTPUT/deleted_files.txt"
# 5. File-Carving durchführen
foremost -t all -i "$IMAGE" -o "$OUTPUT/carved/"
# 6. Hash-Analyse
hfind -i nsrl "$OUTPUT/timeline.bodyfile" > "$OUTPUT/known_files.txt"
```
## Best Practices und Methodologie
### Dokumentation und Chain of Custody
**Kritische Dokumentationspunkte**:
1. **Acquisition-Details**: Tool, Version, Hash-Werte, Zeitstempel
2. **Analysis-Methodik**: Verwendete Tools und Parameter
3. **Findings-Dokumentation**: Screenshots, Befund-Zusammenfassung
4. **Timeline-Rekonstruktion**: Chronologische Ereignis-Dokumentation
### Qualitätssicherung
**Verifikations-Checkliste**:
- [ ] Hash-Integrität von Original-Images
- [ ] Tool-Version-Dokumentation
- [ ] Kreuz-Validierung mit verschiedenen Tools
- [ ] Timeline-Plausibilitätsprüfung
- [ ] Anti-Forensik-Artefakt-Suche
### Rechtliche Aspekte
**Admissibility-Faktoren**:
1. **Tool-Reliability**: Verwendung etablierter, validierter Tools
2. **Methodology-Documentation**: Nachvollziehbare Analyse-Schritte
3. **Error-Rate-Analysis**: Bekannte Limitationen dokumentieren
4. **Expert-Qualification**: Forensiker-Qualifikation nachweisen
## Weiterführende Ressourcen
### Spezialisierte Tools
- **X-Ways Forensics**: Kommerzielle All-in-One-Lösung
- **EnCase**: Enterprise-Forensik-Platform
- **AXIOM**: Mobile und Computer-Forensik
- **Oxygen Detective**: Mobile-Spezialist
- **BlackBag**: macOS-Forensik-Spezialist
### Fortgeschrittene Techniken
- **Memory-Forensics**: Volatility für RAM-Analyse
- **Network-Forensics**: Wireshark für Netzwerk-Traffic
- **Mobile-Forensics**: Cellebrite/Oxygen für Smartphone-Analyse
- **Cloud-Forensics**: KAPE für Cloud-Artefakt-Collection
### Continuous Learning
- **SANS FOR508**: Advanced Digital Forensics
- **Volatility Training**: Memory-Forensics-Spezialisierung
- **FIRST Conference**: Internationale Forensik-Community
- **DFRWS**: Digital Forensics Research Workshop
Die moderne Dateisystem-Forensik erfordert ein tiefes Verständnis verschiedener Speichertechnologien und deren forensischer Artefakte. Durch systematische Anwendung der beschriebenen Techniken und kontinuierliche Weiterbildung können Forensiker auch komplexeste Fälle erfolgreich bearbeiten und gerichtsfeste Beweise sicherstellen.

377
src/content/knowledgebase/concept-hash-functions Normal file
View File

@ -0,0 +1,377 @@
---
title: "Hash-Funktionen und digitale Signaturen: Grundlagen der digitalen Beweissicherung"
description: "Umfassender Leitfaden zu kryptographischen Hash-Funktionen, digitalen Signaturen und deren praktischer Anwendung in der digitalen Forensik für Integritätsprüfung und Beweissicherung"
author: "Claude 4 Sonnett (Prompt: Mario Stöckl)"
last_updated: 2024-01-15
difficulty: advanced
categories: ["analysis", "configuration", "case-study"]
tags: ["hashing", "integrity-check", "chain-of-custody", "standards-compliant", "deduplication", "known-bad-detection", "fuzzy-hashing", "digital-signatures", "timestamping", "blockchain-evidence", "md5", "sha256", "ssdeep"]
tool_name: "Hash Functions & Digital Signatures"
published: true
---
# Hash-Funktionen und digitale Signaturen: Grundlagen der digitalen Beweissicherung
Hash-Funktionen und digitale Signaturen bilden das fundamentale Rückgrat der digitalen Forensik. Sie gewährleisten die Integrität von Beweismitteln, ermöglichen die Authentifizierung von Daten und sind essentiell für die rechtssichere Dokumentation forensischer Untersuchungen.
## Was sind kryptographische Hash-Funktionen?
Eine kryptographische Hash-Funktion ist ein mathematisches Verfahren, das aus beliebig großen Eingabedaten einen festen, eindeutigen "Fingerabdruck" (Hash-Wert) erzeugt. Dieser Wert verändert sich drastisch, wenn auch nur ein einzelnes Bit der Eingabe modifiziert wird.
### Eigenschaften einer kryptographischen Hash-Funktion
**Einwegfunktion (One-Way Function)**
- Aus dem Hash-Wert kann nicht auf die ursprünglichen Daten geschlossen werden
- Mathematisch praktisch irreversibel
**Determinismus**
- Identische Eingabe erzeugt immer identischen Hash-Wert
- Reproduzierbare Ergebnisse für forensische Dokumentation
**Kollisionsresistenz**
- Extrem schwierig, zwei verschiedene Eingaben zu finden, die denselben Hash erzeugen
- Gewährleistet Eindeutigkeit in forensischen Anwendungen
**Lawineneffekt**
- Minimale Änderung der Eingabe führt zu völlig anderem Hash-Wert
- Erkennung von Manipulationen
## Wichtige Hash-Algorithmen in der Forensik
### MD5 (Message Digest Algorithm 5)
```bash
# MD5-Hash berechnen
md5sum evidence.dd
# Output: 5d41402abc4b2a76b9719d911017c592 evidence.dd
```
**Eigenschaften:**
- 128-Bit Hash-Wert (32 Hexadezimal-Zeichen)
- Entwickelt 1991, kryptographisch gebrochen seit 2004
- **Nicht mehr sicher**, aber weit verbreitet in Legacy-Systemen
- Kollisionen sind praktisch erzeugbar
**Forensische Relevanz:**
- Noch in vielen bestehenden Systemen verwendet
- Für forensische Zwecke nur bei bereits vorhandenen MD5-Hashes
- Niemals für neue forensische Implementierungen verwenden
### SHA-1 (Secure Hash Algorithm 1)
```bash
# SHA-1-Hash berechnen
sha1sum evidence.dd
# Output: aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d evidence.dd
```
**Eigenschaften:**
- 160-Bit Hash-Wert (40 Hexadezimal-Zeichen)
- Entwickelt von NSA, standardisiert 1995
- **Deprecated seit 2017** aufgrund praktischer Kollisionsangriffe
- SHAttered-Angriff bewies Schwachstellen 2017
### SHA-2-Familie (SHA-256, SHA-512)
```bash
# SHA-256-Hash berechnen
sha256sum evidence.dd
# Output: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 evidence.dd
# SHA-512-Hash berechnen
sha512sum evidence.dd
```
**SHA-256 Eigenschaften:**
- 256-Bit Hash-Wert (64 Hexadezimal-Zeichen)
- Aktueller Standard für forensische Anwendungen
- NIST-approved, FIPS 180-4 konform
- Keine bekannten praktischen Angriffe
**SHA-512 Eigenschaften:**
- 512-Bit Hash-Wert (128 Hexadezimal-Zeichen)
- Höhere Sicherheit, aber größerer Hash-Wert
- Optimal für hochsensible Ermittlungen
### SHA-3 (Keccak)
- Neuester Standard (seit 2015)
- Andere mathematische Grundlage als SHA-2
- Zukünftiger Standard bei SHA-2-Kompromittierung
## Forensische Anwendungen von Hash-Funktionen
### 1. Datenträger-Imaging und Verifikation
**Vor dem Imaging:**
```bash
# Original-Datenträger hashen
sha256sum /dev/sdb > original_hash.txt
```
**Nach dem Imaging:**
```bash
# Image-Datei hashen
sha256sum evidence.dd > image_hash.txt
# Vergleichen
diff original_hash.txt image_hash.txt
```
**Best Practice:**
- Immer mehrere Hash-Algorithmen verwenden (SHA-256 + SHA-512)
- Hash-Berechnung vor, während und nach dem Imaging
- Dokumentation in Chain-of-Custody-Protokoll
### 2. Deduplizierung mit Hash-Sets
Hash-Sets ermöglichen die Identifikation bekannter Dateien zur Effizienzsteigerung:
**NSRL (National Software Reference Library)**
```bash
# NSRL-Hash-Set laden
autopsy --load-hashset /path/to/nsrl/NSRLFile.txt
# Bekannte Dateien ausschließen
hashdeep -s -e nsrl_hashes.txt /evidence/mount/
```
**Eigene Hash-Sets erstellen:**
```bash
# Hash-Set von bekannten guten Dateien
hashdeep -r /clean_system/ > clean_system_hashes.txt
# Vergleich mit verdächtigem System
hashdeep -s -e clean_system_hashes.txt /suspect_system/
```
### 3. Known-Bad-Erkennung
**Malware-Hash-Datenbanken:**
- VirusTotal API-Integration
- Threat Intelligence Feeds
- Custom IoC-Listen
```python
# Beispiel: Datei-Hash gegen Known-Bad-Liste prüfen
import hashlib
def check_malware_hash(filepath, malware_hashes):
with open(filepath, 'rb') as f:
file_hash = hashlib.sha256(f.read()).hexdigest()
if file_hash in malware_hashes:
return True, file_hash
return False, file_hash
```
### 4. Fuzzy Hashing mit ssdeep
Fuzzy Hashing erkennt ähnliche, aber nicht identische Dateien:
```bash
# ssdeep-Hash berechnen
ssdeep malware.exe
# Output: 768:gQA1M2Ua3QqQm8+1QV7Q8+1QG8+1Q:gQ1Ma3qmP1QV7P1QGP1Q
# Ähnlichkeit zwischen Dateien prüfen
ssdeep -d malware_v1.exe malware_v2.exe
# Output: 85 (85% Ähnlichkeit)
```
**Anwendungsfälle:**
- Erkennung von Malware-Varianten
- Identifikation modifizierter Dokumente
- Versionsverfolgung von Dateien
### 5. Timeline-Analyse und Integritätsprüfung
```bash
# Erweiterte Metadaten mit Hashes
find /evidence/mount -type f -exec stat -c "%Y %n" {} \; | while read timestamp file; do
hash=$(sha256sum "$file" | cut -d' ' -f1)
echo "$timestamp $hash $file"
done > timeline_with_hashes.txt
```
## Digitale Signaturen in der Forensik
Digitale Signaturen verwenden asymmetrische Kryptographie zur Authentifizierung und Integritätssicherung.
### Funktionsweise digitaler Signaturen
1. **Erstellung:**
- Hash des Dokuments wird mit privatem Schlüssel verschlüsselt
- Verschlüsselter Hash = digitale Signatur
2. **Verifikation:**
- Signatur wird mit öffentlichem Schlüssel entschlüsselt
- Entschlüsselter Hash wird mit neuem Hash des Dokuments verglichen
### Certificate Chain Analysis
**X.509-Zertifikate untersuchen:**
```bash
# Zertifikat-Details anzeigen
openssl x509 -in certificate.crt -text -noout
# Zertifikatskette verfolgen
openssl verify -CAfile ca-bundle.crt -untrusted intermediate.crt certificate.crt
```
**Forensische Relevanz:**
- Authentizität von Software-Downloads
- Erkennung gefälschter Zertifikate
- APT-Gruppenattribution durch Code-Signing-Zertifikate
### Timestamping für Chain-of-Custody
**RFC 3161-Zeitstempel:**
```bash
# Zeitstempel für Beweisdatei erstellen
openssl ts -query -data evidence.dd -no_nonce -sha256 -out request.tsq
openssl ts -verify -in response.tsr -data evidence.dd -CAfile tsa-ca.crt
```
**Blockchain-basierte Zeitstempel:**
- Unveränderliche Zeitstempel in öffentlichen Blockchains
- OriginStamp, OpenTimestamps für forensische Anwendungen
## Praktische Tools und Integration
### Autopsy Integration
```xml
<!-- Autopsy Hash Database Configuration -->
<hashDb>
<dbType>NSRL</dbType>
<dbPath>/usr/share/autopsy/nsrl/NSRLFile.txt</dbPath>
<searchDuringIngest>true</searchDuringIngest>
</hashDb>
```
### YARA-Integration mit Hash-Regeln
```yara
rule Malware_Hash_Detection {
condition:
hash.sha256(0, filesize) == "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
}
```
### FTK Imager Hash-Verifikation
- Automatische Hash-Berechnung während Imaging
- MD5, SHA-1, SHA-256 parallel
- Verify-Funktion für Image-Integrität
## Advanced Topics
### Rainbow Table Attacks
**Funktionsweise:**
- Vorberechnete Hash-Tabellen für Passwort-Cracking
- Trade-off zwischen Speicher und Rechenzeit
- Effektiv gegen unsalted Hashes
**Forensische Anwendung:**
```bash
# Hashcat mit Rainbow Tables
hashcat -m 0 -a 0 hashes.txt wordlist.txt
# John the Ripper mit Rainbow Tables
john --format=NT --wordlist=rockyou.txt ntlm_hashes.txt
```
### Blockchain Evidence Management
**Konzept:**
- Unveränderliche Speicherung von Hash-Werten
- Distributed Ledger für Chain-of-Custody
- Smart Contracts für automatisierte Verifikation
**Implementierung:**
```solidity
// Ethereum Smart Contract für Evidence Hashes
contract EvidenceRegistry {
mapping(bytes32 => bool) public evidenceHashes;
function registerEvidence(bytes32 _hash) public {
evidenceHashes[_hash] = true;
}
}
```
## Häufige Probleme und Lösungsansätze
### Hash-Kollisionen
**Problem:** Zwei verschiedene Dateien mit identischem Hash
**Lösung:**
- Verwendung mehrerer Hash-Algorithmen
- Sichere Algorithmen (SHA-256+) verwenden
- Bei Verdacht: Bitweise Vergleich der Originaldateien
### Performance bei großen Datenmengen
**Problem:** Langsame Hash-Berechnung bei TB-großen Images
**Optimierung:**
```bash
# Parallele Hash-Berechnung
hashdeep -r -j 8 /large_dataset/ # 8 Threads
# Hardware-beschleunigte Hashing
sha256sum --tag /dev/nvme0n1 # NVMe für bessere I/O
```
### Rechtliche Anforderungen
**Problem:** Verschiedene Standards in verschiedenen Jurisdiktionen
**Lösung:**
- NIST-konforme Algorithmen verwenden
- Dokumentation aller verwendeten Verfahren
- Regelmäßige Algorithmus-Updates
## Best Practices
### 1. Algorithmus-Auswahl
- **Neu:** SHA-256 oder SHA-3 verwenden
- **Legacy:** MD5/SHA-1 nur bei vorhandenen Systemen
- **High-Security:** SHA-512 oder SHA-3-512
### 2. Dokumentation
```text
Evidence Hash Verification Report
=================================
Evidence ID: CASE-2024-001-HDD
Original Hash (SHA-256): a1b2c3d4...
Image Hash (SHA-256): a1b2c3d4...
Verification Status: VERIFIED
Timestamp: 2024-01-15 14:30:00 UTC
Investigator: John Doe
```
### 3. Redundanz
- Mindestens zwei verschiedene Hash-Algorithmen
- Mehrfache Verifikation zu verschiedenen Zeitpunkten
- Verschiedene Tools für Cross-Validation
### 4. Automation
```bash
#!/bin/bash
# Automatisiertes Hash-Verification-Script
EVIDENCE_FILE="$1"
LOG_FILE="hash_verification.log"
echo "Starting hash verification for $EVIDENCE_FILE" >> $LOG_FILE
MD5_HASH=$(md5sum "$EVIDENCE_FILE" | cut -d' ' -f1)
SHA256_HASH=$(sha256sum "$EVIDENCE_FILE" | cut -d' ' -f1)
SHA512_HASH=$(sha512sum "$EVIDENCE_FILE" | cut -d' ' -f1)
echo "MD5: $MD5_HASH" >> $LOG_FILE
echo "SHA-256: $SHA256_HASH" >> $LOG_FILE
echo "SHA-512: $SHA512_HASH" >> $LOG_FILE
echo "Verification completed at $(date)" >> $LOG_FILE
```
## Zukunftsperspektiven
### Quantum-Resistant Hashing
- Vorbereitung auf Quantum Computing
- NIST Post-Quantum Cryptography Standards
- Migration bestehender Systeme
### AI/ML-Integration
- Anomalie-Erkennung in Hash-Mustern
- Automated Similarity Analysis
- Intelligent Deduplizierung
Hash-Funktionen und digitale Signaturen sind und bleiben das Fundament der digitalen Forensik. Das Verständnis ihrer mathematischen Grundlagen, praktischen Anwendungen und rechtlichen Implikationen unterscheidet professionelle Forensiker von Amateuren. Mit der kontinuierlichen Weiterentwicklung der Technologie müssen auch forensische Praktiken angepasst werden, um die Integrität und Authentizität digitaler Beweise zu gewährleisten.

666
src/content/knowledgebase/concept-memory-forensics.md Normal file
View File

@ -0,0 +1,666 @@
---
title: "Memory Forensics und Process Analysis: Advanced Malware Detection in Volatile Memory"
description: "Umfassender Leitfaden zur forensischen Analyse von Arbeitsspeicher-Strukturen, Process-Injection-Techniken und Advanced-Malware-Detection. Von Kernel-Analysis bis Cross-Platform-Memory-Forensik."
author: "Claude 4 Sonnett (Prompt: Mario Stöckl)"
last_updated: 2024-01-15
difficulty: advanced
categories: ["analysis", "advanced-techniques", "malware-investigation"]
tags: ["memory-structures", "process-injection", "rootkit-detection", "kernel-analysis", "address-space", "live-analysis", "malware-hiding", "system-internals", "volatility", "dll-hollowing", "process-ghosting"]
related_tools: ["Volatility 3", "Rekall", "WinDbg", "GDB"]
published: true
---
# Memory Forensics und Process Analysis: Advanced Malware Detection in Volatile Memory
Memory Forensics stellt eine der komplexesten und gleichzeitig aufschlussreichsten Disziplinen der digitalen Forensik dar. Während traditionelle Festplatten-Forensik auf persistente Daten zugreift, ermöglicht die Analyse des Arbeitsspeichers Einblicke in aktive Prozesse, verschleierte Malware und Angriffstechniken, die keine Spuren auf der Festplatte hinterlassen.
## Einführung in Memory Forensics
### Was ist Memory Forensics?
Memory Forensics ist die Wissenschaft der Analyse von Computer-Arbeitsspeicher (RAM) zur Aufdeckung digitaler Artefakte. Im Gegensatz zur traditionellen Festplatten-Forensik konzentriert sich Memory Forensics auf volatile Daten, die nur temporär im Speicher existieren.
**Zentrale Vorteile:**
- Erkennung von Malware, die nur im Speicher residiert
- Aufdeckung von Process-Injection und Code-Hiding-Techniken
- Analyse von verschlüsselten oder obfuscierten Prozessen
- Rekonstruktion von Netzwerkverbindungen und Benutzeraktivitäten
- Untersuchung von Kernel-Level-Rootkits
### Virtual Memory Layout verstehen
Das Virtual Memory System moderner Betriebssysteme bildet die Grundlage für Memory Forensics. Jeder Prozess erhält einen eigenen virtuellen Adressraum, der in verschiedene Segmente unterteilt ist:
**Windows Virtual Memory Layout:**
```
0x00000000 - 0x7FFFFFFF: User Space (2GB)
0x80000000 - 0xFFFFFFFF: Kernel Space (2GB)
User Space Segmente:
- 0x00000000 - 0x0000FFFF: NULL Pointer Region
- 0x00010000 - 0x7FFEFFFF: User Code und Data
- 0x7FFF0000 - 0x7FFFFFFF: System DLLs (ntdll.dll)
```
**Linux Virtual Memory Layout:**
```
0x00000000 - 0xBFFFFFFF: User Space (3GB)
0xC0000000 - 0xFFFFFFFF: Kernel Space (1GB)
User Space Segmente:
- Text Segment: Executable Code
- Data Segment: Initialized Variables
- BSS Segment: Uninitialized Variables
- Heap: Dynamic Memory Allocation
- Stack: Function Calls und Local Variables
```
## Process Internals und Strukturen
### Process Control Blocks (PCB)
Jeder Prozess wird durch eine zentrale Datenstruktur repräsentiert, die alle relevanten Informationen enthält:
**Windows EPROCESS Structure:**
```c
typedef struct _EPROCESS {
KPROCESS Pcb; // Process Control Block
EX_PUSH_LOCK ProcessLock; // Process Lock
LARGE_INTEGER CreateTime; // Creation Timestamp
LARGE_INTEGER ExitTime; // Exit Timestamp
EX_RUNDOWN_REF RundownProtect; // Rundown Protection
HANDLE UniqueProcessId; // Process ID (PID)
LIST_ENTRY ActiveProcessLinks; // Double Linked List
RTL_AVL_TREE VadRoot; // Virtual Address Descriptors
// ... weitere Felder
} EPROCESS, *PEPROCESS;
```
**Wichtige Felder für Forensik:**
- `ImageFileName`: Name der ausführbaren Datei
- `Peb`: Process Environment Block Pointer
- `VadRoot`: Virtual Address Descriptor Tree
- `Token`: Security Token des Prozesses
- `HandleTable`: Tabelle geöffneter Handles
### Thread Control Blocks (TCB)
Threads sind die ausführbaren Einheiten innerhalb eines Prozesses:
**Windows ETHREAD Structure:**
```c
typedef struct _ETHREAD {
KTHREAD Tcb; // Thread Control Block
LARGE_INTEGER CreateTime; // Thread Creation Time
LIST_ENTRY ThreadListEntry; // Process Thread List
EX_RUNDOWN_REF RundownProtect; // Rundown Protection
PEPROCESS ThreadsProcess; // Parent Process Pointer
PVOID StartAddress; // Thread Start Address
// ... weitere Felder
} ETHREAD, *PETHREAD;
```
## Advanced Malware Detection Techniken
### Process Injection Erkennung
Process Injection ist eine häufig verwendete Technik zur Umgehung von Security-Lösungen. Verschiedene Injection-Methoden erfordern spezifische Erkennungsansätze:
#### DLL Injection Detection
**Erkennungsmerkmale:**
```bash
# Volatility 3 Command
python vol.py -f memory.dmp windows.dlllist.DllList --pid 1234
# Verdächtige Indikatoren:
# - Ungewöhnliche DLL-Pfade
# - DLLs ohne digitale Signatur
# - Temporäre oder versteckte Pfade
# - Diskrepanzen zwischen Image und Memory
```
**Manuelle Verifikation:**
```python
# Pseudocode für DLL-Validierung
def validate_dll_integrity(dll_base, dll_path):
memory_hash = calculate_memory_hash(dll_base)
disk_hash = calculate_file_hash(dll_path)
if memory_hash != disk_hash:
return "POTENTIAL_INJECTION_DETECTED"
return "CLEAN"
```
#### Process Hollowing Detection
Process Hollowing ersetzt den ursprünglichen Code eines legitimen Prozesses:
**Erkennungsmerkmale:**
- Diskrepanz zwischen ImageFileName und tatsächlichem Code
- Ungewöhnliche Memory Protection Flags
- Fehlende oder modifizierte PE Header
- Unerwartete Entry Points
**Volatility Detection:**
```bash
# Process Hollowing Indicators
python vol.py -f memory.dmp windows.malfind.Malfind
python vol.py -f memory.dmp windows.vadinfo.VadInfo --pid 1234
```
#### Process Ghosting Detection
Eine der neuesten Evasion-Techniken, die Prozesse ohne korrespondierende Dateien auf der Festplatte erstellt:
**Erkennungsmerkmale:**
```bash
# File Object Analysis
python vol.py -f memory.dmp windows.handles.Handles --pid 1234
# Suche nach:
# - Deleted File Objects
# - Processes ohne korrespondierende Image Files
# - Ungewöhnliche Creation Patterns
```
### DLL Hollowing und Memory Manipulation
DLL Hollowing überschreibt legitimierte DLL-Sektionen mit malicious Code:
**Detection Workflow:**
1. **Section Analysis:**
```bash
python vol.py -f memory.dmp windows.vadinfo.VadInfo --pid 1234
```
2. **Memory Permission Analysis:**
```bash
# Suche nach ungewöhnlichen Permissions
# RWX (Read-Write-Execute) Bereiche sind verdächtig
```
3. **Entropy Analysis:**
```python
def calculate_section_entropy(memory_region):
entropy = 0
for byte_value in range(256):
probability = memory_region.count(byte_value) / len(memory_region)
if probability > 0:
entropy += probability * math.log2(probability)
return -entropy
```
## Kernel-Level Analysis
### System Call Hooking Detection
Rootkits manipulieren häufig System Call Tables (SSDT):
**Windows SSDT Analysis:**
```bash
# System Service Descriptor Table
python vol.py -f memory.dmp windows.ssdt.SSDT
# Verdächtige Indikatoren:
# - Hooks außerhalb bekannter Module
# - Ungewöhnliche Sprungadressen
# - Modifizierte System Call Nummern
```
**Linux System Call Table:**
```bash
# System Call Table Analysis für Linux
python vol.py -f linux.dmp linux.check_syscall.Check_syscall
```
### Driver Analysis
Kernel-Mode-Rootkits nutzen Device Driver für persistente Angriffe:
**Windows Driver Enumeration:**
```bash
# Loaded Modules Analysis
python vol.py -f memory.dmp windows.modules.Modules
# Driver IRP Analysis
python vol.py -f memory.dmp windows.driverscan.DriverScan
```
**Verdächtige Driver-Eigenschaften:**
- Fehlende Code-Signierung
- Ungewöhnliche Load-Adressen
- Versteckte oder gelöschte Driver-Files
- Modifizierte IRP (I/O Request Packet) Handler
### Rootkit Detection Methoden
#### Direct Kernel Object Manipulation (DKOM)
DKOM-Rootkits manipulieren Kernel-Datenstrukturen direkt:
**Process Hiding Detection:**
```bash
# Process Scan vs. Process List Comparison
python vol.py -f memory.dmp windows.psscan.PsScan > psscan.txt
python vol.py -f memory.dmp windows.pslist.PsList > pslist.txt
# Vergleich zeigt versteckte Prozesse
diff psscan.txt pslist.txt
```
#### EPROCESS Link Manipulation
```python
# Pseudocode für EPROCESS Validation
def validate_process_links(eprocess_list):
for process in eprocess_list:
flink = process.ActiveProcessLinks.Flink
blink = process.ActiveProcessLinks.Blink
# Validate bidirectional links
if flink.Blink != process or blink.Flink != process:
return "LINK_MANIPULATION_DETECTED"
```
## Memory Dump Acquisition Strategien
### Live Memory Acquisition
**Windows Memory Acquisition:**
```bash
# DumpIt (Comae)
DumpIt.exe /output C:\memory.dmp
# WinPmem
winpmem-2.1.post4.exe C:\memory.raw
# Magnet RAM Capture
MRCv1.20.exe /go /output C:\memory.dmp
```
**Linux Memory Acquisition:**
```bash
# LiME (Linux Memory Extractor)
insmod lime.ko "path=/tmp/memory.lime format=lime"
# AVML (Azure Virtual Machine Memory Extractor)
./avml memory.dmp
# dd (für /dev/mem falls verfügbar)
dd if=/dev/mem of=memory.dd bs=1M
```
### Memory Acquisition Challenges
**Volatility Considerations:**
- Memory-Inhalte ändern sich kontinuierlich
- Acquisition-Tools können Memory-Layout beeinflussen
- Anti-Forensic-Techniken können Acquisition verhindern
- Verschlüsselte Memory-Bereiche
**Best Practices:**
- Multiple Acquisition-Methoden verwenden
- Acquisition-Logs dokumentieren
- Hash-Werte für Integrität generieren
- Timestamp-Synchronisation
## Address Space Reconstruction
### Virtual Address Translation
Das Verständnis der Address Translation ist essentiell für Memory Forensics:
**Windows Page Table Walkthrough:**
```
Virtual Address (32-bit):
┌─────────────┬─────────────┬──────────────┐
│ PDE (10bit) │ PTE (10bit) │ Offset(12bit)│
└─────────────┴─────────────┴──────────────┘
1. Page Directory Entry → Page Table Base
2. Page Table Entry → Physical Page Frame
3. Offset → Byte within Physical Page
```
**Linux Page Table Structure:**
```
Virtual Address (64-bit):
┌───┬───┬───┬───┬──────────┐
│PGD│PUD│PMD│PTE│ Offset │
└───┴───┴───┴───┴──────────┘
4-Level Page Table (x86_64):
- PGD: Page Global Directory
- PUD: Page Upper Directory
- PMD: Page Middle Directory
- PTE: Page Table Entry
```
### Memory Mapping Analysis
**Windows VAD (Virtual Address Descriptor) Trees:**
```bash
# VAD Tree Analysis
python vol.py -f memory.dmp windows.vadinfo.VadInfo --pid 1234
# Memory Mapping Details
python vol.py -f memory.dmp windows.memmap.Memmap --pid 1234
```
**Linux Memory Maps:**
```bash
# Process Memory Maps
python vol.py -f linux.dmp linux.proc_maps.Maps --pid 1234
```
## Cross-Platform Memory Forensics
### Windows-Specific Artefakte
**Registry in Memory:**
```bash
# Registry Hives
python vol.py -f memory.dmp windows.registry.hivelist.HiveList
# Registry Keys
python vol.py -f memory.dmp windows.registry.printkey.PrintKey --key "Software\Microsoft\Windows\CurrentVersion\Run"
```
**Windows Event Logs:**
```bash
# Event Log Analysis
python vol.py -f memory.dmp windows.evtlogs.EvtLogs
```
### Linux-Specific Artefakte
**Process Environment:**
```bash
# Environment Variables
python vol.py -f linux.dmp linux.envars.Envars
# Process Arguments
python vol.py -f linux.dmp linux.psaux.PsAux
```
**Network Connections:**
```bash
# Network Sockets
python vol.py -f linux.dmp linux.netstat.Netstat
```
### macOS Memory Forensics
**Darwin Kernel Structures:**
```bash
# Process List (macOS)
python vol.py -f macos.dmp mac.pslist.PsList
# Network Connections
python vol.py -f macos.dmp mac.netstat.Netstat
```
## Live Analysis vs. Dead Analysis
### Live Memory Analysis
**Vorteile:**
- Vollständige System-Sicht
- Kontinuierliche Überwachung möglich
- Interaktive Analysis-Möglichkeiten
- Integration mit Incident Response
**Tools für Live Analysis:**
- Rekall (Live Mode)
- WinDbg (Live Debugging)
- GDB (Linux Live Debugging)
- Volatility mit Live Memory Plugins
**Live Analysis Workflow:**
```bash
# Rekall Live Analysis
rekall --live Memory
# Memory-basierte Malware Detection
rekall> pslist
rekall> malfind
rekall> hollowfind
```
### Dead Memory Analysis
**Vorteile:**
- Stabile Analysis-Umgebung
- Reproduzierbare Ergebnisse
- Tiefere forensische Untersuchung
- Legal-konforme Beweisführung
**Typical Workflow:**
```bash
# 1. Memory Dump Analysis
python vol.py -f memory.dmp windows.info.Info
# 2. Process Analysis
python vol.py -f memory.dmp windows.pslist.PsList
python vol.py -f memory.dmp windows.pstree.PsTree
# 3. Malware Detection
python vol.py -f memory.dmp windows.malfind.Malfind
# 4. Network Analysis
python vol.py -f memory.dmp windows.netstat.NetStat
# 5. Registry Analysis
python vol.py -f memory.dmp windows.registry.hivelist.HiveList
```
## Encrypted Memory Handling
### Windows BitLocker Memory
BitLocker-verschlüsselte Systeme stellen besondere Herausforderungen dar:
**Memory Encryption Bypass:**
- Cold Boot Attacks auf Encryption Keys
- DMA (Direct Memory Access) Attacks
- Hibernation File Analysis
### Full Memory Encryption (TME)
Intel Total Memory Encryption (TME) verschlüsselt den gesamten Arbeitsspeicher:
**Forensic Implications:**
- Hardware-basierte Key-Extraktion erforderlich
- Firmware-Level-Access notwendig
- Acquisition vor Memory-Locking
## Advanced Analysis Techniken
### Machine Learning in Memory Forensics
**Anomaly Detection:**
```python
# Pseudocode für ML-basierte Process Analysis
def detect_process_anomalies(memory_dump):
features = extract_process_features(memory_dump)
# Features: Memory Permissions, API Calls, Network Connections
model = load_trained_model('process_anomaly_detection.pkl')
anomalies = model.predict(features)
return anomalies
```
### Timeline Reconstruction
**Memory-basierte Timeline:**
```bash
# Process Creation Timeline
python vol.py -f memory.dmp windows.pslist.PsList --output-format=timeline
# File Object Timeline
python vol.py -f memory.dmp windows.handles.Handles --object-type=File
```
### Memory Forensics Automation
**Automated Analysis Framework:**
```python
#!/usr/bin/env python3
class MemoryForensicsAutomation:
def __init__(self, memory_dump):
self.dump = memory_dump
self.results = {}
def run_baseline_analysis(self):
# Basic System Information
self.results['info'] = self.run_volatility_plugin('windows.info.Info')
# Process Analysis
self.results['processes'] = self.run_volatility_plugin('windows.pslist.PsList')
# Malware Detection
self.results['malware'] = self.run_volatility_plugin('windows.malfind.Malfind')
# Network Analysis
self.results['network'] = self.run_volatility_plugin('windows.netstat.NetStat')
return self.results
def detect_anomalies(self):
# Implementation für automatisierte Anomaly Detection
pass
```
## Häufige Herausforderungen und Lösungsansätze
### Anti-Forensic Techniken
**Memory Wiping:**
- Erkennung durch Memory Allocation Patterns
- Analyse von Memory Page Timestamps
- Reconstruction durch Memory Slack
**Process Masquerading:**
- PE Header Validation
- Import Address Table (IAT) Analysis
- Code Signing Verification
**Timing Attacks:**
- Memory Acquisition Race Conditions
- Process Termination während Acquisition
- Kontinuierliche Monitoring-Strategien
### Performance Optimierung
**Large Memory Dumps:**
```bash
# Parallel Processing
python vol.py -f memory.dmp --parallel=4 windows.pslist.PsList
# Targeted Analysis
python vol.py -f memory.dmp windows.pslist.PsList --pid 1234,5678
```
**Memory Usage Optimization:**
- Streaming Analysis für große Dumps
- Indexed Memory Access
- Selective Plugin Execution
## Tools und Framework Integration
### Volatility 3 Framework
**Plugin Development:**
```python
class CustomMalwareDetector(interfaces.plugins.PluginInterface):
"""Custom Plugin für Advanced Malware Detection"""
@classmethod
def get_requirements(cls):
return [requirements.TranslationLayerRequirement(name='primary'),
requirements.SymbolTableRequirement(name="nt_symbols")]
def run(self):
# Implementation der Detection-Logik
pass
```
### Integration mit SIEM-Systemen
**ElasticSearch Integration:**
```python
def export_to_elasticsearch(memory_analysis_results):
es = Elasticsearch(['localhost:9200'])
for artifact in memory_analysis_results:
doc = {
'timestamp': artifact.timestamp,
'process_name': artifact.process_name,
'suspicious_score': artifact.score,
'detection_method': artifact.method
}
es.index(index='memory-forensics', body=doc)
```
## Best Practices und Empfehlungen
### Forensic Methodology
1. **Preservation First**: Memory Dump Acquisition vor anderen Aktionen
2. **Documentation**: Vollständige Dokumentation aller Analysis-Schritte
3. **Validation**: Cross-Referencing verschiedener Evidence Sources
4. **Chain of Custody**: Lückenlose Beweiskette
5. **Reproducibility**: Wiederholbare Analysis-Prozesse
### Quality Assurance
**Hash Verification:**
```bash
# MD5/SHA256 Hashes für Memory Dumps
md5sum memory.dmp > memory.dmp.md5
sha256sum memory.dmp > memory.dmp.sha256
```
**Analysis Documentation:**
```markdown
# Memory Forensics Analysis Report
## System Information
- OS Version: Windows 10 Pro 1909
- Architecture: x64
- Memory Size: 16GB
- Acquisition Time: 2024-01-15 14:30:00 UTC
## Tools Used
- Volatility 3.2.0
- Rekall 1.7.2
- Custom Scripts: malware_detector.py
## Key Findings
1. Process Injection detected in explorer.exe (PID 1234)
2. Unknown driver loaded: malicious.sys
3. Network connections to suspicious IPs
```
## Fazit
Memory Forensics stellt ein mächtiges Werkzeug für die Aufdeckung komplexer Angriffe dar, die traditionelle Festplatten-Forensik umgehen. Die kontinuierliche Weiterentwicklung von Angriffstechniken erfordert eine entsprechende Evolution der forensischen Methoden.
**Zukünftige Entwicklungen:**
- Hardware-basierte Memory Protection Bypass
- Machine Learning für Automated Threat Detection
- Cloud Memory Forensics
- Containerized Environment Analysis
- Real-time Memory Threat Hunting
Die Beherrschung von Memory Forensics erfordert ein tiefes Verständnis von Betriebssystem-Internals, Malware-Techniken und forensischen Methoden. Kontinuierliche Weiterbildung und praktische Erfahrung sind essentiell für erfolgreiche Memory-basierte Investigations.
## Weiterführende Ressourcen
- **Volatility Labs Blog**: Aktuelle Research zu Memory Forensics
- **SANS FOR508**: Advanced Incident Response und Digital Forensics
- **Black Hat/DEF CON**: Security Conference Presentations
- **Academic Papers**: IEEE Security & Privacy, USENIX Security
- **Open Source Tools**: GitHub Repositories für Custom Plugins

517
src/content/knowledgebase/concept-network-protocols.md Normal file
View File

@ -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.

556
src/content/knowledgebase/concept-regular-expressions-regex.md Normal file
View File

@ -0,0 +1,556 @@
---
title: "Regular Expressions in der Digitalen Forensik: Vom Grundmuster zur Beweisextraktion"
description: "Umfassender Leitfaden für Regex-Anwendungen in der forensischen Analyse: IP-Adressen, E-Mails, Hashes und komplexe Logparser-Patterns für effiziente Beweissammlung"
author: "Claude 4 Sonnett (Prompt: Mario Stöckl)"
last_updated: 2024-01-15
difficulty: intermediate
categories: ["analysis", "automation", "log-analysis"]
tags: ["regex", "pattern-matching", "log-analysis", "data-extraction", "text-processing", "automation", "yara-rules", "grep", "powershell", "python"]
tool_name: "Regular Expressions (Regex)"
related_tools: ["YARA", "Grep", "PowerShell", "Python"]
published: true
---
# Regular Expressions in der Digitalen Forensik: Vom Grundmuster zur Beweisextraktion
Regular Expressions (Regex) sind das Schweizer Taschenmesser der digitalen Forensik. Diese universelle Mustererkennungssprache ermöglicht es Forensikern, komplexe Textsuchen durchzuführen, relevante Daten aus Terabytes von Logs zu extrahieren und Beweise systematisch zu identifizieren. Von der einfachen IP-Adressen-Suche bis zur komplexen Malware-Signaturerstellung - Regex-Kenntnisse unterscheiden oft einen guten von einem großartigen Forensiker.
## Warum Regex in der Forensik unverzichtbar ist
In modernen Untersuchungen konfrontieren uns massive Datenmengen: Gigabytes von Logfiles, Speicherabbilder, Netzwerkverkehr und Dateisysteme mit Millionen von Einträgen. Manuelle Durchsuchung ist unmöglich - hier kommt Regex ins Spiel:
- **Präzise Mustersuche**: Findet spezifische Datenformate (IP-Adressen, E-Mails, Hashes) in unstrukturierten Texten
- **Automatisierung**: Ermöglicht Skripterstellung für wiederkehrende Analysemuster
- **Tool-Integration**: Kernfunktionalität in allen Major-Forensik-Tools
- **Effizienzsteigerung**: Reduziert Analysezeit von Stunden auf Minuten
## Forensik-relevante Regex-Grundlagen
### Grundlegende Metacharakter
```regex
. # Beliebiges Zeichen (außer Newline)
* # 0 oder mehr Wiederholungen des vorherigen Elements
+ # 1 oder mehr Wiederholungen
? # 0 oder 1 Wiederholung (optional)
^ # Zeilenanfang
$ # Zeilenende
[] # Zeichenklasse
() # Gruppierung
| # ODER-Verknüpfung
\ # Escape-Zeichen
```
### Quantifizierer für präzise Treffer
```regex
{n} # Exakt n Wiederholungen
{n,} # Mindestens n Wiederholungen
{n,m} # Zwischen n und m Wiederholungen
{,m} # Maximal m Wiederholungen
```
### Zeichenklassen für strukturierte Daten
```regex
\d # Ziffer (0-9)
\w # Wort-Zeichen (a-z, A-Z, 0-9, _)
\s # Whitespace (Leerzeichen, Tab, Newline)
\D # Nicht-Ziffer
\W # Nicht-Wort-Zeichen
\S # Nicht-Whitespace
[a-z] # Kleinbuchstaben
[A-Z] # Großbuchstaben
[0-9] # Ziffern
[^abc] # Alles außer a, b, c
```
## Forensische Standardmuster
### IP-Adressen (IPv4)
```regex
# Basis-Pattern (weniger präzise)
\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}
# Präzise IPv4-Validierung
^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$
# Praktisches Pattern für Log-Analyse
(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)
```
**Anwendungsbeispiel**: Extraktion aller IP-Adressen aus IIS-Logs:
```bash
grep -oE '(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)' access.log | sort | uniq -c | sort -nr
```
### E-Mail-Adressen
```regex
# Einfaches Pattern für schnelle Suche
[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}
# RFC-konforme E-Mail (vereinfacht)
^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$
# Für Forensik optimiert (weniger strikt)
\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b
```
### Hash-Werte
```regex
# MD5 (32 Hexadezimalzeichen)
\b[a-fA-F0-9]{32}\b
# SHA-1 (40 Hexadezimalzeichen)
\b[a-fA-F0-9]{40}\b
# SHA-256 (64 Hexadezimalzeichen)
\b[a-fA-F0-9]{64}\b
# Universelles Hash-Pattern
\b[a-fA-F0-9]{32,64}\b
```
### Bitcoin-Adressen
```regex
# Legacy Bitcoin-Adressen (P2PKH und P2SH)
\b[13][a-km-zA-HJ-NP-Z1-9]{25,34}\b
# Bech32 (SegWit) Adressen
\bbc1[a-z0-9]{39,59}\b
# Kombiniert
\b(?:[13][a-km-zA-HJ-NP-Z1-9]{25,34}|bc1[a-z0-9]{39,59})\b
```
### Windows-Dateipfade
```regex
# Vollständiger Windows-Pfad
^[a-zA-Z]:\\(?:[^\\/:*?"<>|\r\n]+\\)*[^\\/:*?"<>|\r\n]*$
# UNC-Pfade
^\\\\[^\\]+\\[^\\]+(?:\\[^\\]*)*$
# Für Log-Parsing (flexibler)
[a-zA-Z]:\\[^"\s<>|]*
```
### Kreditkartennummern
```regex
# Visa (13-19 Ziffern, beginnt mit 4)
4[0-9]{12,18}
# MasterCard (16 Ziffern, beginnt mit 5)
5[1-5][0-9]{14}
# American Express (15 Ziffern, beginnt mit 34 oder 37)
3[47][0-9]{13}
# Universell (mit optionalen Trennzeichen)
(?:\d{4}[-\s]?){3,4}\d{4}
```
## Tool-spezifische Regex-Implementierungen
### PowerShell-Integration
```powershell
# Suche nach IP-Adressen in Eventlogs
Get-WinEvent -LogName Security | Where-Object {
$_.Message -match '\b(?:\d{1,3}\.){3}\d{1,3}\b'
} | Select-Object TimeCreated, Id, Message
# E-Mail-Extraktion aus Speicherabbild
Select-String -Path "memdump.raw" -Pattern '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}' -AllMatches
# Hash-Werte aus Malware-Samples
Get-ChildItem -Recurse | Get-FileHash | Where-Object {
$_.Hash -match '^[a-fA-F0-9]{64}$'
}
```
### Grep-Anwendungen
```bash
# Verdächtige ausführbare Dateien
grep -r -E '\.(exe|dll|scr|bat|cmd)$' /mnt/evidence/
# Zeitstempel-Extraktion (ISO 8601)
grep -oE '\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}' application.log
# Base64-kodierte Daten
grep -oE '[A-Za-z0-9+/]{20,}={0,2}' suspicious.txt
# Windows-Ereignis-IDs
grep -E 'Event ID: (4624|4625|4648|4656)' security.log
```
### Python-Implementierung
```python
import re
import hashlib
# IP-Adressen mit Kontext extrahieren
def extract_ips_with_context(text, context_chars=50):
ip_pattern = r'\b(?:\d{1,3}\.){3}\d{1,3}\b'
matches = []
for match in re.finditer(ip_pattern, text):
start = max(0, match.start() - context_chars)
end = min(len(text), match.end() + context_chars)
context = text[start:end]
matches.append({
'ip': match.group(),
'position': match.start(),
'context': context
})
return matches
# Malware-Signaturen generieren
def generate_yara_strings(binary_data, min_length=10):
# Suche nach druckbaren ASCII-Strings
ascii_pattern = rb'[ -~]{' + str(min_length).encode() + rb',}'
strings = re.findall(ascii_pattern, binary_data)
yara_strings = []
for i, string in enumerate(strings[:20]): # Erste 20 Strings
# Escape problematische Zeichen
escaped = string.decode('ascii').replace('\\', '\\\\').replace('"', '\\"')
yara_strings.append(f'$s{i} = "{escaped}"')
return yara_strings
```
## YARA-Rules mit Regex
```yara
rule SuspiciousEmailPattern {
strings:
$email = /[a-zA-Z0-9._%+-]+@(tempmail|guerrillamail|10minutemail)\.(com|net|org)/ nocase
$bitcoin = /\b[13][a-km-zA-HJ-NP-Z1-9]{25,34}\b/
$ransom_msg = /your files have been encrypted/i
condition:
$email and ($bitcoin or $ransom_msg)
}
rule LogAnalysisPattern {
strings:
$failed_login = /Failed login.*from\s+(\d{1,3}\.){3}\d{1,3}/
$brute_force = /authentication failure.*rhost=(\d{1,3}\.){3}\d{1,3}/
$suspicious_ua = /User-Agent:.*(?:sqlmap|nikto|nmap|masscan)/i
condition:
any of them
}
```
## Performance-Optimierung und Fallstricke
### Catastrophic Backtracking vermeiden
**Problematisch**:
```regex
(a+)+b # Exponentieller Zeitverbrauch bei "aaaa...c"
(.*)* # Verschachtelte Quantifizierer
```
**Optimiert**:
```regex
a+b # Atomare Gruppierung
[^b]*b # Negierte Zeichenklasse statt .*
```
### Anker für Effizienz nutzen
```regex
# Langsam
\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}
# Schneller mit Wortgrenzen
\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b
# Am schnellsten für Zeilensuche
^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$
```
### Compiled Patterns verwenden
```python
import re
# Einmal kompilieren, oft verwenden
ip_pattern = re.compile(r'\b(?:\d{1,3}\.){3}\d{1,3}\b')
email_pattern = re.compile(r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}')
def analyze_log_file(filepath):
with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
content = f.read()
ips = ip_pattern.findall(content)
emails = email_pattern.findall(content)
return ips, emails
```
## Praktische Forensik-Szenarien
### Incident Response: Lateral Movement Detection
```bash
# Suche nach PsExec-Aktivitäten
grep -E 'PSEXESVC.*started|PsExec.*\\\\[^\\]+\\' security.log
# Pass-the-Hash Angriffe
grep -E 'Logon Type:\s+9.*NTLM.*[0-9a-fA-F]{32}' security.log
# WMI-basierte Ausführung
grep -E 'WmiPrvSE.*ExecuteShellCommand|wmic.*process.*call.*create' system.log
```
### Malware-Analyse: C2-Kommunikation
```python
# Domain Generation Algorithm (DGA) Detection
dga_pattern = re.compile(r'\b[a-z]{8,20}\.(com|net|org|info)\b')
def detect_suspicious_domains(pcap_text):
# Extrahiere DNS-Queries
dns_pattern = r'DNS.*query.*?([a-zA-Z0-9.-]+\.[a-zA-Z]{2,})'
domains = re.findall(dns_pattern, pcap_text)
suspicious = []
for domain in domains:
# Prüfe auf DGA-Charakteristika
if dga_pattern.match(domain.lower()):
# Zusätzliche Heuristiken
vowel_ratio = len(re.findall(r'[aeiou]', domain.lower())) / len(domain)
if vowel_ratio < 0.2: # Wenige Vokale = verdächtig
suspicious.append(domain)
return suspicious
```
### Data Exfiltration: Ungewöhnliche Datenübertragungen
```regex
# Base64-kodierte Daten in URLs
[?&]data=([A-Za-z0-9+/]{4})*([A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?
# DNS-Tunneling (ungewöhnlich lange Subdomains)
\b[a-z0-9]{20,}\.[a-z0-9.-]+\.[a-z]{2,}\b
# Hex-kodierte Dateninhalte
[?&]payload=[0-9a-fA-F]{40,}
```
## Debugging und Testing
### Online-Tools für Regex-Entwicklung
1. **regex101.com**: Interaktive Regex-Entwicklung mit Erklärungen
2. **regexr.com**: Visuelle Regex-Darstellung
3. **regexpal.com**: Schnelle Tests ohne Anmeldung
### Regex-Validierung in der Praxis
```python
import re
def validate_regex_pattern(pattern, test_cases):
"""
Validiert Regex-Pattern gegen bekannte Test-Cases
"""
try:
compiled = re.compile(pattern)
except re.error as e:
return False, f"Regex-Syntax-Fehler: {e}"
results = []
for test_input, expected in test_cases:
match = compiled.search(test_input)
found = match.group() if match else None
results.append({
'input': test_input,
'expected': expected,
'found': found,
'correct': found == expected
})
return True, results
# Test-Cases für IP-Pattern
ip_tests = [
('192.168.1.1', '192.168.1.1'),
('999.999.999.999', None), # Ungültige IP
('text 10.0.0.1 more text', '10.0.0.1'),
('no.ip.here', None)
]
pattern = r'\b(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\b'
valid, results = validate_regex_pattern(pattern, ip_tests)
```
## Häufige Fehler und Lösungen
### Problem: Gierige vs. nicht-gierige Quantifizierer
```regex
# Problematisch: Gierig
<.*> # Matched "<tag>content</tag>" komplett
# Lösung: Nicht-gierig
<.*?> # Matched nur "<tag>"
# Alternative: Spezifisch
<[^>]*> # Matched keine ">" innerhalb
```
### Problem: Unbeabsichtigte Metacharakter
```regex
# Falsch: . als Literalzeichen gemeint
192.168.1.1 # Matched auch "192x168x1x1"
# Richtig: Escape von Metacharaktern
192\.168\.1\.1 # Matched nur echte IP
```
### Problem: Fehlende Wortgrenzen
```regex
# Problematisch: Matcht Teilstrings
\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3} # Matched "1192.168.1.10"
# Lösung: Wortgrenzen verwenden
\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b # Nur vollständige IPs
```
## Integration in Forensik-Workflows
### Automatisierte Triage-Scripts
```bash
#!/bin/bash
# forensic_triage.sh - Automatisierte erste Analyse
LOG_DIR="/evidence/logs"
OUTPUT_DIR="/analysis/regex_results"
# IP-Adressen extrahieren und häufigste finden
echo "=== IP-Analyse ===" > $OUTPUT_DIR/summary.txt
find $LOG_DIR -name "*.log" -exec grep -h -oE '\b(?:\d{1,3}\.){3}\d{1,3}\b' {} \; | \
sort | uniq -c | sort -nr | head -20 >> $OUTPUT_DIR/summary.txt
# E-Mail-Adressen sammeln
echo -e "\n=== E-Mail-Adressen ===" >> $OUTPUT_DIR/summary.txt
find $LOG_DIR -name "*.log" -exec grep -h -oE '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}' {} \; | \
sort | uniq >> $OUTPUT_DIR/summary.txt
# Verdächtige Prozessnamen
echo -e "\n=== Verdächtige Prozesse ===" >> $OUTPUT_DIR/summary.txt
find $LOG_DIR -name "*.log" -exec grep -h -iE '(powershell|cmd|wmic|psexec|mimikatz)' {} \; | \
head -50 >> $OUTPUT_DIR/summary.txt
```
### PowerShell-Module für wiederkehrende Aufgaben
```powershell
function Get-ForensicPatterns {
param(
[string]$Path,
[string[]]$Patterns = @(
'\b(?:\d{1,3}\.){3}\d{1,3}\b', # IP-Adressen
'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}', # E-Mails
'\b[a-fA-F0-9]{32,64}\b' # Hash-Werte
)
)
$results = @{}
foreach ($pattern in $Patterns) {
$matches = Select-String -Path $Path -Pattern $pattern -AllMatches
$results[$pattern] = $matches | ForEach-Object {
[PSCustomObject]@{
File = $_.Filename
Line = $_.LineNumber
Match = $_.Matches.Value
Context = $_.Line
}
}
}
return $results
}
```
## Weiterführende Techniken
### Lookahead und Lookbehind
```regex
# Positive Lookahead: Password gefolgt von Ziffer
password(?=.*\d)
# Negative Lookahead: IP nicht in private ranges
(?!(?:10\.|192\.168\.|172\.(?:1[6-9]|2[0-9]|3[01])\.))(?:\d{1,3}\.){3}\d{1,3}
# Positive Lookbehind: Zahl nach "Port:"
(?<=Port:)\d+
# Negative Lookbehind: Nicht nach "Comment:"
(?<!Comment:).+@.+\..+
```
### Named Capture Groups
```python
import re
# Strukturierte Log-Parsing
log_pattern = re.compile(
r'(?P<timestamp>\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}) '
r'\[(?P<level>\w+)\] '
r'(?P<source>\w+): '
r'(?P<message>.*)'
)
def parse_log_entry(line):
match = log_pattern.match(line)
if match:
return match.groupdict()
return None
# Verwendung
log_line = "2024-01-15 14:30:25 [ERROR] auth: Failed login from 192.168.1.100"
parsed = parse_log_entry(log_line)
# Result: {'timestamp': '2024-01-15 14:30:25', 'level': 'ERROR',
# 'source': 'auth', 'message': 'Failed login from 192.168.1.100'}
```
## Nächste Schritte
Nach diesem umfassenden Überblick können Sie:
1. **Praktische Übung**: Implementieren Sie die vorgestellten Patterns in Ihren aktuellen Untersuchungen
2. **Tool-Integration**: Integrieren Sie Regex in Ihre bevorzugten Forensik-Tools
3. **Automatisierung**: Entwickeln Sie Scripts für wiederkehrende Analysemuster
4. **Spezialisierung**: Vertiefen Sie sich in tool-spezifische Regex-Implementierungen
5. **Community**: Teilen Sie Ihre Patterns und lernen Sie von anderen Forensikern
### Weiterführende Ressourcen
- **SANS Regex Cheat Sheet**: Kompakte Referenz für Forensiker
- **RegexBuddy**: Professionelle Regex-Entwicklungsumgebung
- **Python re-Modul Dokumentation**: Detaillierte Syntax-Referenz
- **YARA-Rules Repository**: Sammlung forensik-relevanter Regex-Patterns
Regular Expressions sind ein mächtiges Werkzeug, das Zeit spart und die Präzision forensischer Analysen erhöht. Die Investition in solide Regex-Kenntnisse zahlt sich in jeder Untersuchung aus und ermöglicht es, komplexe Muster zu erkennen, die manuell übersehen werden würden.

770
src/content/knowledgebase/concept-sql.md Normal file
View File

@ -0,0 +1,770 @@
---
title: "SQL in der digitalen Forensik: Von SQLite-Datenbanken zur Timeline-Analyse"
description: "Umfassender Leitfaden für SQL-basierte Forensik-Analysen: SQLite-Datenbanken untersuchen, Timeline-Rekonstruktion durchführen, mobile App-Daten analysieren und komplexe Korrelationen aufdecken."
author: "Claude 4 Sonnett (Prompt: Mario Stöckl)"
last_updated: 2024-12-19
difficulty: intermediate
categories: ["analysis", "configuration", "case-study"]
tags: ["sqlite-viewer", "correlation-engine", "mobile-app-data", "browser-history", "data-extraction", "timeline-queries", "join-operations", "aggregate-analysis", "wal-analysis", "python-integration"]
tool_name: "SQL"
related_tools: ["DB Browser for SQLite", "Autopsy", "Cellebrite UFED"]
published: true
---
# SQL in der digitalen Forensik: Von SQLite-Datenbanken zur Timeline-Analyse
SQL (Structured Query Language) ist eine der mächtigsten und unterschätztesten Fähigkeiten in der modernen digitalen Forensik. Während viele Ermittler auf GUI-basierte Tools setzen, ermöglicht SQL direkten Zugriff auf Rohdaten und komplexe Analysen, die mit herkömmlichen Tools unmöglich wären.
## Warum SQL in der Forensik unverzichtbar ist
### SQLite dominiert die mobile Forensik
- **WhatsApp-Chats**: Nachrichten, Metadaten, gelöschte Inhalte
- **Browser-History**: Zeitstempel, Besuchshäufigkeit, Suchverläufe
- **App-Daten**: Standortdaten, Nutzerverhalten, Cache-Inhalte
- **System-Logs**: Verbindungsprotokoll, Fehleraufzeichnungen
### Vorteile gegenüber GUI-Tools
- **Flexibilität**: Komplexe Abfragen jenseits vordefinierter Filter
- **Performance**: Direkte Datenbankzugriffe ohne Interface-Overhead
- **Automatisierung**: Skript-basierte Analysen für wiederkehrende Aufgaben
- **Tiefe**: Zugriff auf Metadaten und versteckte Tabellenstrukturen
## Grundlagen: SQLite-Struktur verstehen
### Datenbank-Anatomie in der Forensik
```sql
-- Tabellen einer WhatsApp-Datenbank analysieren
.tables
-- Tabellenstruktur untersuchen
.schema messages
-- Beispiel-Output:
CREATE TABLE messages (
_id INTEGER PRIMARY KEY AUTOINCREMENT,
key_remote_jid TEXT,
key_from_me INTEGER,
key_id TEXT,
status INTEGER,
needs_push INTEGER,
data TEXT,
timestamp INTEGER,
media_url TEXT,
media_mime_type TEXT,
media_wa_type INTEGER,
media_size INTEGER,
latitude REAL,
longitude REAL
);
```
### SQLite-spezifische Forensik-Herausforderungen
**WAL-Mode (Write-Ahead Logging)**:
```sql
-- WAL-Datei auf nicht-committete Transaktionen prüfen
PRAGMA journal_mode;
-- Temporäre Daten in WAL-Datei finden
-- (Erfordert spezielle Tools wie sqlitewalreader)
```
**Gelöschte Records**:
```sql
-- Freespace-Analyse für gelöschte Daten
-- Hinweis: Erfordert spezialisierte Recovery-Tools
```
## Timeline-Rekonstruktion: Der Forensik-Klassiker
### Grundlegende Timeline-Abfrage
```sql
-- Chronologische Ereignisübersicht erstellen
SELECT
datetime(timestamp/1000, 'unixepoch', 'localtime') as ereignis_zeit,
CASE
WHEN key_from_me = 1 THEN 'Ausgehend'
ELSE 'Eingehend'
END as richtung,
key_remote_jid as kontakt,
substr(data, 1, 50) || '...' as nachricht_preview
FROM messages
WHERE timestamp > 0
ORDER BY timestamp DESC
LIMIT 100;
```
### Erweiterte Timeline mit Kontextinformationen
```sql
-- Timeline mit Geolocation und Media-Daten
SELECT
datetime(m.timestamp/1000, 'unixepoch', 'localtime') as zeitstempel,
c.display_name as kontakt_name,
CASE
WHEN m.key_from_me = 1 THEN '→ Gesendet'
ELSE '← Empfangen'
END as richtung,
CASE
WHEN m.media_wa_type IS NOT NULL THEN 'Media: ' || m.media_mime_type
ELSE 'Text'
END as nachricht_typ,
CASE
WHEN m.latitude IS NOT NULL THEN
'Standort: ' || ROUND(m.latitude, 6) || ', ' || ROUND(m.longitude, 6)
ELSE substr(m.data, 1, 100)
END as inhalt
FROM messages m
LEFT JOIN wa_contacts c ON m.key_remote_jid = c.jid
WHERE m.timestamp BETWEEN
strftime('%s', '2024-01-01') * 1000 AND
strftime('%s', '2024-01-31') * 1000
ORDER BY m.timestamp;
```
## Kommunikations-Analyse: Soziale Netzwerke aufdecken
### Häufigste Kontakte identifizieren
```sql
-- Top-Kommunikationspartner nach Nachrichtenvolumen
SELECT
c.display_name,
m.key_remote_jid,
COUNT(*) as nachrichten_gesamt,
SUM(CASE WHEN m.key_from_me = 1 THEN 1 ELSE 0 END) as gesendet,
SUM(CASE WHEN m.key_from_me = 0 THEN 1 ELSE 0 END) as empfangen,
MIN(datetime(m.timestamp/1000, 'unixepoch', 'localtime')) as erster_kontakt,
MAX(datetime(m.timestamp/1000, 'unixepoch', 'localtime')) as letzter_kontakt
FROM messages m
LEFT JOIN wa_contacts c ON m.key_remote_jid = c.jid
GROUP BY m.key_remote_jid
HAVING nachrichten_gesamt > 10
ORDER BY nachrichten_gesamt DESC;
```
### Kommunikationsmuster-Analyse
```sql
-- Tägliche Aktivitätsmuster
SELECT
strftime('%H', timestamp/1000, 'unixepoch', 'localtime') as stunde,
COUNT(*) as nachrichten_anzahl,
AVG(length(data)) as durchschnittliche_laenge
FROM messages
WHERE timestamp > 0 AND data IS NOT NULL
GROUP BY stunde
ORDER BY stunde;
```
```sql
-- Verdächtige Aktivitätsspitzen identifizieren
WITH hourly_stats AS (
SELECT
date(timestamp/1000, 'unixepoch', 'localtime') as tag,
strftime('%H', timestamp/1000, 'unixepoch', 'localtime') as stunde,
COUNT(*) as nachrichten_pro_stunde
FROM messages
WHERE timestamp > 0
GROUP BY tag, stunde
),
avg_per_hour AS (
SELECT stunde, AVG(nachrichten_pro_stunde) as durchschnitt
FROM hourly_stats
GROUP BY stunde
)
SELECT
h.tag,
h.stunde,
h.nachrichten_pro_stunde,
a.durchschnitt,
ROUND((h.nachrichten_pro_stunde - a.durchschnitt) / a.durchschnitt * 100, 2) as abweichung_prozent
FROM hourly_stats h
JOIN avg_per_hour a ON h.stunde = a.stunde
WHERE h.nachrichten_pro_stunde > a.durchschnitt * 2
ORDER BY abweichung_prozent DESC;
```
## Browser-Forensik: Digitale Spuren verfolgen
### Chrome/Chromium History-Analyse
```sql
-- Browser-History mit Besuchshäufigkeit
SELECT
url,
title,
visit_count,
datetime(last_visit_time/1000000-11644473600, 'unixepoch', 'localtime') as letzter_besuch,
CASE
WHEN typed_count > 0 THEN 'Direkt eingegeben'
ELSE 'Über Link/Verlauf'
END as zugriff_art
FROM urls
WHERE last_visit_time > 0
ORDER BY last_visit_time DESC
LIMIT 100;
```
### Such-Verlauf analysieren
```sql
-- Google-Suchen aus Browser-History extrahieren
SELECT
datetime(last_visit_time/1000000-11644473600, 'unixepoch', 'localtime') as suchzeit,
CASE
WHEN url LIKE '%google.com/search%' THEN
replace(substr(url, instr(url, 'q=') + 2,
case when instr(substr(url, instr(url, 'q=') + 2), '&') > 0
then instr(substr(url, instr(url, 'q=') + 2), '&') - 1
else length(url) end), '+', ' ')
ELSE 'Andere Suchmaschine'
END as suchbegriff,
url
FROM urls
WHERE url LIKE '%search%' OR url LIKE '%q=%'
ORDER BY last_visit_time DESC;
```
## Anomalie-Erkennung mit SQL
### Ungewöhnliche Datei-Zugriffe identifizieren
```sql
-- Dateizugriffe außerhalb der Arbeitszeiten
WITH file_access AS (
SELECT
datetime(timestamp, 'unixepoch', 'localtime') as zugriffszeit,
strftime('%H', timestamp, 'unixepoch', 'localtime') as stunde,
strftime('%w', timestamp, 'unixepoch', 'localtime') as wochentag,
file_path,
action_type
FROM file_access_logs
)
SELECT *
FROM file_access
WHERE (
stunde < '08' OR stunde > '18' OR -- Außerhalb 8-18 Uhr
wochentag IN ('0', '6') -- Wochenende
) AND action_type IN ('read', 'write', 'delete')
ORDER BY zugriffszeit DESC;
```
### Datenexfiltration-Indikatoren
```sql
-- Große Dateiübertragungen in kurzen Zeiträumen
SELECT
datetime(transfer_start, 'unixepoch', 'localtime') as start_zeit,
SUM(file_size) as gesamt_bytes,
COUNT(*) as anzahl_dateien,
destination_ip,
GROUP_CONCAT(DISTINCT file_extension) as dateitypen
FROM network_transfers
WHERE transfer_start BETWEEN
strftime('%s', 'now', '-7 days') AND strftime('%s', 'now')
GROUP BY
date(transfer_start, 'unixepoch', 'localtime'),
strftime('%H', transfer_start, 'unixepoch', 'localtime'),
destination_ip
HAVING gesamt_bytes > 100000000 -- > 100MB
ORDER BY gesamt_bytes DESC;
```
## Erweiterte Techniken: Window Functions und CTEs
### Sliding Window-Analyse für Ereigniskorrelation
```sql
-- Ereignisse in 5-Minuten-Fenstern korrelieren
WITH event_windows AS (
SELECT
datetime(timestamp, 'unixepoch', 'localtime') as ereigniszeit,
event_type,
user_id,
LAG(timestamp, 1) OVER (PARTITION BY user_id ORDER BY timestamp) as prev_timestamp,
LEAD(timestamp, 1) OVER (PARTITION BY user_id ORDER BY timestamp) as next_timestamp
FROM security_events
ORDER BY timestamp
)
SELECT
ereigniszeit,
event_type,
user_id,
CASE
WHEN (timestamp - prev_timestamp) < 300 THEN 'Schnelle Aufeinanderfolge'
WHEN (next_timestamp - timestamp) < 300 THEN 'Vor schnellem Event'
ELSE 'Isoliert'
END as ereignis_kontext
FROM event_windows;
```
### Temporäre Anomalie-Scores
```sql
-- Anomalie-Score basierend auf Abweichung vom Normalverhalten
WITH user_baseline AS (
SELECT
user_id,
AVG(daily_logins) as avg_logins,
STDEV(daily_logins) as stddev_logins
FROM (
SELECT
user_id,
date(login_time, 'unixepoch', 'localtime') as login_date,
COUNT(*) as daily_logins
FROM user_logins
WHERE login_time > strftime('%s', 'now', '-30 days')
GROUP BY user_id, login_date
)
GROUP BY user_id
HAVING COUNT(*) > 7 -- Mindestens 7 Tage Daten
),
current_behavior AS (
SELECT
user_id,
date(login_time, 'unixepoch', 'localtime') as login_date,
COUNT(*) as daily_logins
FROM user_logins
WHERE login_time > strftime('%s', 'now', '-7 days')
GROUP BY user_id, login_date
)
SELECT
c.user_id,
c.login_date,
c.daily_logins,
b.avg_logins,
ROUND(ABS(c.daily_logins - b.avg_logins) / b.stddev_logins, 2) as anomalie_score
FROM current_behavior c
JOIN user_baseline b ON c.user_id = b.user_id
WHERE anomalie_score > 2.0 -- Mehr als 2 Standardabweichungen
ORDER BY anomalie_score DESC;
```
## Python-Integration für Automatisierung
### SQLite-Forensik mit Python
```python
import sqlite3
import pandas as pd
from datetime import datetime
import matplotlib.pyplot as plt
class ForensicSQLAnalyzer:
def __init__(self, db_path):
self.conn = sqlite3.connect(db_path)
self.conn.row_factory = sqlite3.Row
def extract_timeline(self, start_date=None, end_date=None):
"""Timeline-Extraktion mit Datumsfilterung"""
query = """
SELECT
datetime(timestamp/1000, 'unixepoch', 'localtime') as timestamp,
event_type,
details,
user_context
FROM events
WHERE 1=1
"""
params = []
if start_date:
query += " AND timestamp >= ?"
params.append(int(start_date.timestamp() * 1000))
if end_date:
query += " AND timestamp <= ?"
params.append(int(end_date.timestamp() * 1000))
query += " ORDER BY timestamp"
return pd.read_sql_query(query, self.conn, params=params)
def communication_analysis(self):
"""Kommunikationsmuster analysieren"""
query = """
SELECT
contact_id,
COUNT(*) as message_count,
AVG(message_length) as avg_length,
MIN(timestamp) as first_contact,
MAX(timestamp) as last_contact
FROM messages
GROUP BY contact_id
HAVING message_count > 5
ORDER BY message_count DESC
"""
return pd.read_sql_query(query, self.conn)
def detect_anomalies(self, threshold=2.0):
"""Statistische Anomalie-Erkennung"""
query = """
WITH daily_stats AS (
SELECT
date(timestamp, 'unixepoch', 'localtime') as day,
COUNT(*) as daily_events
FROM events
GROUP BY day
),
stats AS (
SELECT
AVG(daily_events) as mean_events,
STDEV(daily_events) as stddev_events
FROM daily_stats
)
SELECT
d.day,
d.daily_events,
s.mean_events,
ABS(d.daily_events - s.mean_events) / s.stddev_events as z_score
FROM daily_stats d, stats s
WHERE z_score > ?
ORDER BY z_score DESC
"""
return pd.read_sql_query(query, self.conn, params=[threshold])
def export_findings(self, filename):
"""Ermittlungsergebnisse exportieren"""
timeline = self.extract_timeline()
comms = self.communication_analysis()
anomalies = self.detect_anomalies()
with pd.ExcelWriter(filename) as writer:
timeline.to_excel(writer, sheet_name='Timeline', index=False)
comms.to_excel(writer, sheet_name='Communications', index=False)
anomalies.to_excel(writer, sheet_name='Anomalies', index=False)
# Verwendung
analyzer = ForensicSQLAnalyzer('/path/to/evidence.db')
findings = analyzer.export_findings('investigation_findings.xlsx')
```
## Häufige Fallstricke und Best Practices
### Datenintegrität sicherstellen
```sql
-- Konsistenz-Checks vor Analyse
SELECT
'Null Timestamps' as issue_type,
COUNT(*) as count
FROM messages
WHERE timestamp IS NULL OR timestamp = 0
UNION ALL
SELECT
'Missing Contact Info' as issue_type,
COUNT(*) as count
FROM messages m
LEFT JOIN wa_contacts c ON m.key_remote_jid = c.jid
WHERE c.jid IS NULL;
```
### Performance-Optimierung
```sql
-- Index für häufige Abfragen erstellen
CREATE INDEX IF NOT EXISTS idx_messages_timestamp
ON messages(timestamp);
CREATE INDEX IF NOT EXISTS idx_messages_contact_timestamp
ON messages(key_remote_jid, timestamp);
-- Query-Performance analysieren
EXPLAIN QUERY PLAN
SELECT * FROM messages
WHERE timestamp BETWEEN ? AND ?
ORDER BY timestamp;
```
### Forensische Dokumentation
```sql
-- Metadaten für Gerichtsverwertbarkeit dokumentieren
SELECT
'Database Schema Version' as info_type,
user_version as value
FROM pragma_user_version
UNION ALL
SELECT
'Last Modified',
datetime(mtime, 'unixepoch', 'localtime')
FROM pragma_file_control;
```
## Spezialisierte Forensik-Szenarien
### Mobile App-Forensik: Instagram-Datenbank
```sql
-- Instagram-Nachrichten mit Medien-Metadaten
SELECT
datetime(m.timestamp/1000, 'unixepoch', 'localtime') as nachricht_zeit,
u.username as absender,
CASE
WHEN m.item_type = 1 THEN 'Text: ' || m.text
WHEN m.item_type = 2 THEN 'Bild: ' || mi.media_url
WHEN m.item_type = 3 THEN 'Video: ' || mi.media_url
ELSE 'Anderer Typ: ' || m.item_type
END as inhalt,
m.thread_key as chat_id
FROM direct_messages m
LEFT JOIN users u ON m.user_id = u.pk
LEFT JOIN media_items mi ON m.media_id = mi.id
WHERE m.timestamp > 0
ORDER BY m.timestamp DESC;
```
### Incident Response: Systemprotokoll-Korrelation
```sql
-- Korrelation zwischen Login-Events und Netzwerk-Aktivität
WITH suspicious_logins AS (
SELECT
login_time,
user_id,
source_ip,
login_time + 3600 as investigation_window -- 1 Stunde nach Login
FROM login_events
WHERE source_ip NOT LIKE '192.168.%' -- Externe IPs
AND login_time > strftime('%s', 'now', '-7 days')
),
network_activity AS (
SELECT
connection_time,
source_ip,
destination_ip,
bytes_transferred,
protocol
FROM network_connections
)
SELECT
datetime(sl.login_time, 'unixepoch', 'localtime') as verdaechtiger_login,
sl.user_id,
sl.source_ip as login_ip,
COUNT(na.connection_time) as netzwerk_aktivitaeten,
SUM(na.bytes_transferred) as gesamt_daten_bytes,
GROUP_CONCAT(DISTINCT na.destination_ip) as ziel_ips
FROM suspicious_logins sl
LEFT JOIN network_activity na ON
na.connection_time BETWEEN sl.login_time AND sl.investigation_window
AND na.source_ip = sl.source_ip
GROUP BY sl.login_time, sl.user_id, sl.source_ip
HAVING netzwerk_aktivitaeten > 0
ORDER BY gesamt_daten_bytes DESC;
```
## Erweiterte WAL-Analyse und Recovery
### WAL-Datei Untersuchung
```sql
-- WAL-Mode Status prüfen
PRAGMA journal_mode;
PRAGMA wal_checkpoint;
-- Uncommitted transactions in WAL identifizieren
-- Hinweis: Erfordert spezielle Tools oder Hex-Editor
-- Zeigt Konzept für manuelle Analyse
SELECT
name,
rootpage,
sql
FROM sqlite_master
WHERE type = 'table'
ORDER BY name;
```
### Gelöschte Daten-Recovery
```python
# Python-Script für erweiterte SQLite-Recovery
import sqlite3
import struct
import os
class SQLiteForensics:
def __init__(self, db_path):
self.db_path = db_path
self.page_size = self.get_page_size()
def get_page_size(self):
"""SQLite Page-Size ermitteln"""
with open(self.db_path, 'rb') as f:
f.seek(16) # Page size offset
return struct.unpack('>H', f.read(2))[0]
def analyze_freespace(self):
"""Freespace auf gelöschte Records analysieren"""
conn = sqlite3.connect(self.db_path)
cursor = conn.cursor()
# Freespace-Informationen sammeln
cursor.execute("PRAGMA freelist_count;")
free_pages = cursor.fetchone()[0]
cursor.execute("PRAGMA page_count;")
total_pages = cursor.fetchone()[0]
recovery_potential = {
'total_pages': total_pages,
'free_pages': free_pages,
'recovery_potential': f"{(free_pages/total_pages)*100:.2f}%"
}
conn.close()
return recovery_potential
def extract_unallocated(self):
"""Unallocated Space für Recovery extrahieren"""
# Vereinfachtes Beispiel - echte Implementation erfordert
# detaillierte SQLite-Interna-Kenntnisse
unallocated_data = []
with open(self.db_path, 'rb') as f:
file_size = os.path.getsize(self.db_path)
pages = file_size // self.page_size
for page_num in range(1, pages + 1):
f.seek((page_num - 1) * self.page_size)
page_data = f.read(self.page_size)
# Suche nach Text-Patterns in Freespace
# (Vereinfacht - echte Recovery ist komplexer)
if b'WhatsApp' in page_data or b'@' in page_data:
unallocated_data.append({
'page': page_num,
'potential_data': page_data[:100] # Erste 100 Bytes
})
return unallocated_data
# Verwendung für Recovery-Assessment
forensics = SQLiteForensics('/path/to/damaged.db')
recovery_info = forensics.analyze_freespace()
print(f"Recovery-Potenzial: {recovery_info['recovery_potential']}")
```
## Compliance und Rechtssicherheit
### Audit-Trail erstellen
```sql
-- Forensische Dokumentation aller durchgeführten Abfragen
CREATE TABLE IF NOT EXISTS forensic_audit_log (
id INTEGER PRIMARY KEY AUTOINCREMENT,
timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
investigator TEXT,
query_type TEXT,
sql_query TEXT,
affected_rows INTEGER,
case_number TEXT,
notes TEXT
);
-- Beispiel-Eintrag
INSERT INTO forensic_audit_log
(investigator, query_type, sql_query, affected_rows, case_number, notes)
VALUES
('Max Mustermann', 'TIMELINE_EXTRACTION',
'SELECT * FROM messages WHERE timestamp BETWEEN ? AND ?',
1247, 'CASE-2024-001',
'Timeline-Extraktion für Zeitraum 01.01.2024 - 31.01.2024');
```
### Hash-Verifikation implementieren
```python
import hashlib
import sqlite3
def verify_database_integrity(db_path, expected_hash=None):
"""Datenbank-Integrität durch Hash-Verifikation prüfen"""
# SHA-256 Hash der Datenbankdatei
sha256_hash = hashlib.sha256()
with open(db_path, "rb") as f:
for chunk in iter(lambda: f.read(4096), b""):
sha256_hash.update(chunk)
current_hash = sha256_hash.hexdigest()
# Zusätzlich: Struktureller Integritäts-Check
conn = sqlite3.connect(db_path)
cursor = conn.cursor()
try:
cursor.execute("PRAGMA integrity_check;")
integrity_result = cursor.fetchall()
is_structurally_intact = integrity_result == [('ok',)]
except Exception as e:
is_structurally_intact = False
integrity_result = [f"Error: {str(e)}"]
finally:
conn.close()
return {
'file_hash': current_hash,
'hash_matches': current_hash == expected_hash if expected_hash else None,
'structurally_intact': is_structurally_intact,
'integrity_details': integrity_result,
'verified_at': datetime.now().isoformat()
}
# Chain of Custody dokumentieren
def log_database_access(db_path, investigator, purpose):
"""Datenbankzugriff für Chain of Custody protokollieren"""
verification = verify_database_integrity(db_path)
log_entry = {
'timestamp': datetime.now().isoformat(),
'investigator': investigator,
'database_path': db_path,
'access_purpose': purpose,
'pre_access_hash': verification['file_hash'],
'database_integrity': verification['structurally_intact']
}
# Log in separater Audit-Datei speichern
with open('forensic_access_log.json', 'a') as log_file:
json.dump(log_entry, log_file)
log_file.write('\n')
return log_entry
```
## Fazit und Weiterführende Ressourcen
SQL in der digitalen Forensik ist mehr als nur Datenbankabfragen - es ist ein mächtiges Werkzeug für:
- **Timeline-Rekonstruktion** mit präziser zeitlicher Korrelation
- **Kommunikationsanalyse** für soziale Netzwerk-Aufklärung
- **Anomalie-Erkennung** durch statistische Analyse
- **Automatisierung** wiederkehrender Untersuchungsschritte
- **Tiefe Datenextraktion** jenseits GUI-Limitationen
### Nächste Schritte
1. **Praktische Übung**: Beginnen Sie mit einfachen WhatsApp-Datenbank-Analysen
2. **Tool-Integration**: Kombinieren Sie SQL mit Python für erweiterte Analysen
3. **Spezialisierung**: Vertiefen Sie mobile-spezifische oder Browser-Forensik
4. **Automation**: Entwickeln Sie wiederverwendbare SQL-Scripts für häufige Szenarien
5. **Rechtssicherheit**: Implementieren Sie Audit-Trails und Hash-Verifikation
### Empfohlene Tools
- **DB Browser for SQLite**: GUI für interaktive Exploration
- **SQLiteStudio**: Erweiterte SQLite-Verwaltung
- **Python sqlite3**: Programmbasierte Automatisierung
- **Autopsy**: Integration in forensische Workflows
- **Cellebrite UFED**: Mobile Forensik mit SQL-Export
Die Kombination aus SQL-Kenntnissen und forensischem Verständnis macht moderne Ermittler zu hocheffizienten Datenanalytikern. In einer Welt zunehmender Datenmengen wird diese Fähigkeit zum entscheidenden Wettbewerbsvorteil.

601
src/content/knowledgebase/concept-timeline-analysis.md Normal file
View File

@ -0,0 +1,601 @@
---
title: "Timeline-Analyse & Event-Korrelation: Methodische Rekonstruktion forensischer Ereignisse"
description: "Umfassende Anleitung zur systematischen Timeline-Erstellung aus heterogenen Datenquellen, Super-Timeline-Processing und Advanced-Correlation-Techniken für komplexe Incident-Response-Szenarien."
author: "Claude 4 Sonnett (Prompt: Mario Stöckl)"
last_updated: 2024-01-15
difficulty: advanced
categories: ["analysis", "methodology", "incident-response"]
tags: ["timeline-correlation", "event-sequencing", "temporal-analysis", "super-timeline", "pivot-points", "behavioral-patterns", "anomaly-detection", "anti-forensics-detection", "incident-response", "log2timeline", "plaso"]
tool_name: "Timeline Analysis & Event Correlation"
related_tools: ["Autopsy", "Volatility", "Wireshark", "SIFT Workstation"]
published: true
---
# Timeline-Analyse & Event-Korrelation: Methodische Rekonstruktion forensischer Ereignisse
Timeline-Analyse bildet das Rückgrat moderner forensischer Untersuchungen und ermöglicht die chronologische Rekonstruktion von Ereignissen aus heterogenen digitalen Artefakten. Diese methodische Herangehensweise korreliert zeitbasierte Evidenz für präzise Incident-Response und belastbare Beweisführung.
## Grundlagen der forensischen Timeline-Analyse
### Was ist Timeline-Analyse?
Timeline-Analyse ist die systematische Korrelation zeitbasierter Artefakte aus verschiedenen digitalen Quellen zur Rekonstruktion von Ereignissequenzen. Sie ermöglicht Forensikern, das "Was", "Wann", "Wo" und "Wie" von Sicherheitsvorfällen zu verstehen.
**Kernprinzipien:**
- **Chronologische Ordnung**: Alle Ereignisse werden in temporaler Reihenfolge arrangiert
- **Multi-Source-Integration**: Daten aus verschiedenen Systemen werden vereint
- **Zeitstempel-Normalisierung**: UTC-Konvertierung für einheitliche Referenz
- **Korrelationsbasierte Analyse**: Zusammenhänge zwischen scheinbar unabhängigen Events
### Typologie forensischer Zeitstempel
**MAC-Times (Modified, Accessed, Created)**
```
Filesystem-Timestamps:
- $STANDARD_INFORMATION (SI) - NTFS-Metadaten
- $FILE_NAME (FN) - Directory-Entry-Timestamps
- Born Date - Erste Erstellung im Filesystem
- $USNJrnl - Change Journal Entries
```
**Registry-Timestamps**
```
Windows Registry:
- Key Last Write Time - Letzte Modifikation
- Value Creation Time - Wert-Erstellung
- Hive Load Time - Registry-Hive-Mounting
```
**Event-Log-Timestamps**
```
Windows Event Logs:
- TimeCreated - Event-Generierung
- TimeWritten - Log-Persistierung
- CorrelationActivityID - Cross-System-Tracking
```
## Super-Timeline-Erstellung: Methodisches Vorgehen
### Phase 1: Artefakt-Akquisition und Preprocessing
**Datenquellen-Inventar erstellen:**
```bash
# Filesystem-Timeline mit fls
fls -r -p -m /mnt/evidence/image.dd > filesystem_timeline.body
# Registry-Timeline mit regtime
regtime.py -r /mnt/evidence/registry/ > registry_timeline.csv
# Event-Log-Extraktion mit python-evtx
evtx_dump.py Security.evtx > security_events.xml
```
**Memory-Artefakte integrieren:**
```bash
# Volatility Timeline-Generierung
vol.py -f memory.vmem --profile=Win10x64 timeliner > memory_timeline.csv
# Process-Timeline mit detailed Metadata
vol.py -f memory.vmem --profile=Win10x64 pslist -v > process_details.txt
```
### Phase 2: Zeitstempel-Normalisierung und UTC-Konvertierung
**Timezone-Handling:**
```python
# Python-Script für Timezone-Normalisierung
import datetime
import pytz
def normalize_timestamp(timestamp_str, source_timezone):
"""
Konvertiert lokale Timestamps zu UTC für einheitliche Timeline
"""
local_tz = pytz.timezone(source_timezone)
dt = datetime.datetime.strptime(timestamp_str, '%Y-%m-%d %H:%M:%S')
localized_dt = local_tz.localize(dt)
utc_dt = localized_dt.astimezone(pytz.utc)
return utc_dt.strftime('%Y-%m-%d %H:%M:%S UTC')
```
**Anti-Timestomp-Detection:**
```bash
# Timestomp-Anomalien identifizieren
analyzeMFT.py -f $MFT -o mft_analysis.csv
# Suche nach: SI-Time < FN-Time (Timestomp-Indikator)
```
### Phase 3: Log2timeline/PLASO Super-Timeline-Processing
**PLASO-basierte Timeline-Generierung:**
```bash
# Multi-Source-Timeline mit log2timeline
log2timeline.py --storage-file evidence.plaso \
--parsers "win7,chrome,firefox,skype" \
--timezone "Europe/Berlin" \
/mnt/evidence/
# CSV-Export für Analysis
psort.py -w timeline_super.csv evidence.plaso
```
**Advanced PLASO-Filtering:**
```bash
# Zeitfenster-spezifische Extraktion
psort.py -w incident_window.csv \
--date-filter "2024-01-10,2024-01-12" \
evidence.plaso
# Ereignis-spezifisches Filtering
psort.py -w web_activity.csv \
--filter "parser contains 'chrome'" \
evidence.plaso
```
## Advanced Correlation-Techniken
### Pivot-Point-Identifikation
**Initial Compromise Detection:**
```sql
-- SQL-basierte Timeline-Analyse (bei CSV-Import in DB)
SELECT timestamp, source, event_type, description
FROM timeline
WHERE description LIKE '%powershell%'
OR description LIKE '%cmd.exe%'
OR description LIKE '%rundll32%'
ORDER BY timestamp;
```
**Lateral Movement Patterns:**
```python
# Python-Script für Lateral-Movement-Detection
def detect_lateral_movement(timeline_data):
"""
Identifiziert suspicious Login-Patterns über Zeitfenster
"""
login_events = timeline_data[
timeline_data['event_type'].str.contains('4624|4625', na=False)
]
# Gruppierung nach Source-IP und Zeitfenster-Analyse
suspicious_logins = login_events.groupby(['source_ip']).apply(
lambda x: len(x[x['timestamp'].diff().dt.seconds < 300]) > 5
)
return suspicious_logins[suspicious_logins == True]
```
### Behavioral Pattern Recognition
**User Activity Profiling:**
```bash
# Regelmäßige Aktivitätsmuster extrahieren
grep -E "(explorer\.exe|chrome\.exe|outlook\.exe)" timeline.csv | \
awk -F',' '{print substr($1,1,10), $3}' | \
sort | uniq -c | sort -nr
```
**Anomalie-Detection durch Statistical Analysis:**
```python
import pandas as pd
from scipy import stats
def detect_activity_anomalies(timeline_df):
"""
Identifiziert ungewöhnliche Aktivitätsmuster via Z-Score
"""
# Aktivität pro Stunde aggregieren
timeline_df['hour'] = pd.to_datetime(timeline_df['timestamp']).dt.hour
hourly_activity = timeline_df.groupby('hour').size()
# Z-Score Berechnung für Anomalie-Detection
z_scores = stats.zscore(hourly_activity)
anomalous_hours = hourly_activity[abs(z_scores) > 2]
return anomalous_hours
```
## Network-Event-Korrelation
### Cross-System Timeline Correlation
**SIEM-Integration für Multi-Host-Korrelation:**
```bash
# Splunk-Query für korrelierte Events
index=windows EventCode=4624 OR EventCode=4625 OR EventCode=4648
| eval login_time=strftime(_time, "%Y-%m-%d %H:%M:%S")
| stats values(EventCode) as event_codes by src_ip, login_time
| where mvcount(event_codes) > 1
```
**Network Flow Timeline Integration:**
```python
# Zeek/Bro-Logs mit Filesystem-Timeline korrelieren
def correlate_network_filesystem(conn_logs, file_timeline):
"""
Korreliert Netzwerk-Connections mit File-Access-Patterns
"""
# Zeitfenster-basierte Korrelation (±30 Sekunden)
correlations = []
for _, conn in conn_logs.iterrows():
conn_time = pd.to_datetime(conn['ts'])
time_window = pd.Timedelta(seconds=30)
related_files = file_timeline[
(pd.to_datetime(file_timeline['timestamp']) >= conn_time - time_window) &
(pd.to_datetime(file_timeline['timestamp']) <= conn_time + time_window)
]
if not related_files.empty:
correlations.append({
'connection': conn,
'related_files': related_files,
'correlation_strength': len(related_files)
})
return correlations
```
## Anti-Forensik-Detection durch Timeline-Inkonsistenzen
### Timestamp Manipulation Detection
**Timestomp-Pattern-Analyse:**
```bash
# MFT-Analyse für Timestomp-Detection
analyzeMFT.py -f \$MFT -o mft_full.csv
# Suspekte Timestamp-Patterns identifizieren
python3 << EOF
import pandas as pd
import numpy as np
mft_data = pd.read_csv('mft_full.csv')
# Pattern 1: SI-Time vor FN-Time (klassischer Timestomp)
timestomp_candidates = mft_data[
pd.to_datetime(mft_data['SI_Modified']) < pd.to_datetime(mft_data['FN_Modified'])
]
# Pattern 2: Unrealistische Timestamps (z.B. 1980-01-01)
epoch_anomalies = mft_data[
pd.to_datetime(mft_data['SI_Created']).dt.year < 1990
]
print(f"Potential Timestomp: {len(timestomp_candidates)} files")
print(f"Epoch Anomalies: {len(epoch_anomalies)} files")
EOF
```
### Event Log Manipulation Detection
**Windows Event Log Gap Analysis:**
```python
def detect_log_gaps(event_log_df):
"""
Identifiziert verdächtige Lücken in Event-Log-Sequenzen
"""
# Event-Record-IDs sollten sequenziell sein
event_log_df['RecordNumber'] = pd.to_numeric(event_log_df['RecordNumber'])
event_log_df = event_log_df.sort_values('RecordNumber')
# Gaps in Record-Sequenz finden
record_diffs = event_log_df['RecordNumber'].diff()
large_gaps = record_diffs[record_diffs > 100] # Threshold anpassbar
return large_gaps
```
## Automated Timeline Processing & ML-basierte Anomalie-Erkennung
### Machine Learning für Pattern Recognition
**Unsupervised Clustering für Event-Gruppierung:**
```python
from sklearn.cluster import DBSCAN
from sklearn.feature_extraction.text import TfidfVectorizer
import pandas as pd
def cluster_timeline_events(timeline_df):
"""
Gruppiert ähnliche Events via DBSCAN-Clustering
"""
# TF-IDF für Event-Descriptions
vectorizer = TfidfVectorizer(max_features=1000, stop_words='english')
event_vectors = vectorizer.fit_transform(timeline_df['description'])
# DBSCAN-Clustering
clustering = DBSCAN(eps=0.5, min_samples=5).fit(event_vectors.toarray())
timeline_df['cluster'] = clustering.labels_
# Anomalie-Events (Cluster -1)
anomalous_events = timeline_df[timeline_df['cluster'] == -1]
return timeline_df, anomalous_events
```
**Time-Series-Anomalie-Detection:**
```python
from sklearn.ensemble import IsolationForest
import matplotlib.pyplot as plt
def detect_temporal_anomalies(timeline_df):
"""
Isolation Forest für zeitbasierte Anomalie-Detection
"""
# Stündliche Aktivität aggregieren
timeline_df['timestamp'] = pd.to_datetime(timeline_df['timestamp'])
hourly_activity = timeline_df.groupby(
timeline_df['timestamp'].dt.floor('H')
).size().reset_index(name='event_count')
# Isolation Forest Training
iso_forest = IsolationForest(contamination=0.1)
anomaly_labels = iso_forest.fit_predict(
hourly_activity[['event_count']]
)
# Anomale Zeitfenster identifizieren
hourly_activity['anomaly'] = anomaly_labels
anomalous_periods = hourly_activity[hourly_activity['anomaly'] == -1]
return anomalous_periods
```
## Enterprise-Scale Timeline Processing
### Distributed Processing für große Datasets
**Apache Spark für Big-Data-Timeline-Analyse:**
```python
from pyspark.sql import SparkSession
from pyspark.sql.functions import *
def process_enterprise_timeline(spark_session, timeline_path):
"""
Spark-basierte Verarbeitung für TB-große Timeline-Daten
"""
# Timeline-Daten laden
timeline_df = spark_session.read.csv(
timeline_path,
header=True,
inferSchema=True
)
# Zeitfenster-basierte Aggregation
windowed_activity = timeline_df \
.withColumn("timestamp", to_timestamp("timestamp")) \
.withColumn("hour_window", window("timestamp", "1 hour")) \
.groupBy("hour_window", "source_system") \
.agg(
count("*").alias("event_count"),
countDistinct("user").alias("unique_users"),
collect_set("event_type").alias("event_types")
)
return windowed_activity
```
### Cloud-Forensics Timeline Integration
**AWS CloudTrail Timeline Correlation:**
```bash
# CloudTrail-Events mit lokaler Timeline korrelieren
aws logs filter-log-events \
--log-group-name CloudTrail \
--start-time 1642636800000 \
--end-time 1642723200000 \
--filter-pattern "{ $.eventName = \"AssumeRole\" }" \
--output json > cloudtrail_events.json
# JSON zu CSV für Timeline-Integration
jq -r '.events[] | [.eventTime, .sourceIPAddress, .eventName, .userIdentity.type] | @csv' \
cloudtrail_events.json > cloudtrail_timeline.csv
```
## Praktische Anwendungsszenarien
### Szenario 1: Advanced Persistent Threat (APT) Investigation
**Mehrstufige Timeline-Analyse:**
1. **Initial Compromise Detection:**
```bash
# Web-Browser-Downloads mit Malware-Signaturen korrelieren
grep -E "(\.exe|\.zip|\.pdf)" browser_downloads.csv | \
while read line; do
timestamp=$(echo $line | cut -d',' -f1)
filename=$(echo $line | cut -d',' -f3)
# Hash-Verification gegen IOC-Liste
sha256=$(sha256sum "/mnt/evidence/$filename" 2>/dev/null | cut -d' ' -f1)
grep -q "$sha256" ioc_hashes.txt && echo "IOC Match: $timestamp - $filename"
done
```
2. **Lateral Movement Tracking:**
```sql
-- Cross-System-Bewegung via RDP/SMB
SELECT t1.timestamp, t1.source_ip, t2.timestamp, t2.dest_ip
FROM network_timeline t1
JOIN filesystem_timeline t2 ON
t2.timestamp BETWEEN t1.timestamp AND t1.timestamp + INTERVAL 5 MINUTE
WHERE t1.protocol = 'RDP' AND t2.activity_type = 'file_creation'
ORDER BY t1.timestamp;
```
### Szenario 2: Insider-Threat-Analyse
**Behavioral Baseline vs. Anomalie-Detection:**
```python
def analyze_insider_threat(user_timeline, baseline_days=30):
"""
Vergleicht User-Aktivität mit historischer Baseline
"""
# Baseline-Zeitraum definieren
baseline_end = pd.to_datetime('2024-01-01')
baseline_start = baseline_end - pd.Timedelta(days=baseline_days)
baseline_activity = user_timeline[
(user_timeline['timestamp'] >= baseline_start) &
(user_timeline['timestamp'] <= baseline_end)
]
# Anomale Aktivitätsmuster
analysis_period = user_timeline[
user_timeline['timestamp'] > baseline_end
]
# Metriken: Off-Hours-Activity, Data-Volume, Access-Patterns
baseline_metrics = calculate_user_metrics(baseline_activity)
current_metrics = calculate_user_metrics(analysis_period)
anomaly_score = compare_metrics(baseline_metrics, current_metrics)
return anomaly_score
```
## Herausforderungen und Lösungsansätze
### Challenge 1: Timezone-Komplexität in Multi-Domain-Umgebungen
**Problem:** Inkonsistente Timezones zwischen Systemen führen zu falschen Korrelationen.
**Lösung:**
```python
def unified_timezone_conversion(timeline_entries):
"""
Intelligente Timezone-Detection und UTC-Normalisierung
"""
timezone_mapping = {
'windows_local': 'Europe/Berlin',
'unix_utc': 'UTC',
'web_browser': 'client_timezone' # Aus Browser-Metadaten
}
for entry in timeline_entries:
source_tz = detect_timezone_from_source(entry['source'])
entry['timestamp_utc'] = convert_to_utc(
entry['timestamp'],
timezone_mapping.get(source_tz, 'UTC')
)
return timeline_entries
```
### Challenge 2: Volume-Skalierung bei Enterprise-Investigations
**Problem:** TB-große Timeline-Daten überschreiten Memory-Kapazitäten.
**Lösung - Streaming-basierte Verarbeitung:**
```python
def stream_process_timeline(file_path, chunk_size=10000):
"""
Memory-effiziente Timeline-Processing via Chunks
"""
for chunk in pd.read_csv(file_path, chunksize=chunk_size):
# Chunk-weise Verarbeitung
processed_chunk = apply_timeline_analysis(chunk)
# Streaming-Output zu aggregated Results
yield processed_chunk
```
### Challenge 3: Anti-Forensik und Timeline-Manipulation
**Problem:** Adversaries manipulieren Timestamps zur Evidence-Destruction.
**Lösung - Multi-Source-Validation:**
```bash
# Cross-Reference-Validation zwischen verschiedenen Timestamp-Quellen
python3 << EOF
# $MFT vs. $UsnJrnl vs. Event-Logs vs. Registry
def validate_timestamp_integrity(file_path):
sources = {
'mft_si': get_mft_si_time(file_path),
'mft_fn': get_mft_fn_time(file_path),
'usnjrnl': get_usnjrnl_time(file_path),
'prefetch': get_prefetch_time(file_path),
'eventlog': get_eventlog_time(file_path)
}
# Timestamp-Inkonsistenzen identifizieren
inconsistencies = detect_timestamp_discrepancies(sources)
confidence_score = calculate_integrity_confidence(sources)
return inconsistencies, confidence_score
EOF
```
## Tool-Integration und Workflow-Optimierung
### Timeline-Tool-Ecosystem
**Core-Tools-Integration:**
```bash
#!/bin/bash
# Comprehensive Timeline-Workflow-Automation
# 1. Multi-Source-Acquisition
log2timeline.py --storage-file case.plaso \
--parsers "win7,chrome,firefox,apache,nginx" \
--hashers "sha256" \
/mnt/evidence/
# 2. Memory-Timeline-Integration
volatility -f memory.vmem --profile=Win10x64 timeliner \
--output=csv --output-file=memory_timeline.csv
# 3. Network-Timeline-Addition
zeek -r network.pcap Log::default_path=/tmp/zeek_logs/
python3 zeek_to_timeline.py /tmp/zeek_logs/ > network_timeline.csv
# 4. Timeline-Merge und Analysis
psort.py -w comprehensive_timeline.csv case.plaso
python3 merge_timelines.py comprehensive_timeline.csv \
memory_timeline.csv network_timeline.csv > unified_timeline.csv
# 5. Advanced-Analysis-Pipeline
python3 timeline_analyzer.py unified_timeline.csv \
--detect-anomalies --pivot-analysis --correlation-strength=0.7
```
### Autopsy Timeline-Viewer Integration
**Autopsy-Import für Visual Timeline Analysis:**
```python
def export_autopsy_timeline(timeline_df, case_name):
"""
Konvertiert Timeline zu Autopsy-kompatiblem Format
"""
autopsy_format = timeline_df[['timestamp', 'source', 'event_type', 'description']].copy()
autopsy_format['timestamp'] = pd.to_datetime(autopsy_format['timestamp']).astype(int) // 10**9
# Autopsy-CSV-Format
autopsy_format.to_csv(f"{case_name}_autopsy_timeline.csv",
columns=['timestamp', 'source', 'event_type', 'description'],
index=False)
```
## Fazit und Best Practices
Timeline-Analyse repräsentiert eine fundamentale Investigationstechnik, die bei korrekter Anwendung präzise Incident-Rekonstruktion ermöglicht. Die Kombination aus methodischer Multi-Source-Integration, Advanced-Correlation-Techniken und ML-basierter Anomalie-Detection bildet die Basis für moderne forensische Untersuchungen.
**Key Success Factors:**
1. **Systematic Approach**: Strukturierte Herangehensweise von Akquisition bis Analysis
2. **Multi-Source-Validation**: Cross-Reference zwischen verschiedenen Artefakt-Typen
3. **Timezone-Awareness**: Konsistente UTC-Normalisierung für akkurate Korrelation
4. **Anti-Forensik-Resistenz**: Detection von Timestamp-Manipulation und Evidence-Destruction
5. **Scalability-Design**: Enterprise-fähige Processing-Pipelines für Big-Data-Szenarien
Die kontinuierliche Weiterentwicklung von Adversary-Techniken erfordert adaptive Timeline-Methoden, die sowohl traditionelle Artefakte als auch moderne Cloud- und Container-Umgebungen erfassen. Die Integration von Machine Learning in Timeline-Workflows eröffnet neue Möglichkeiten für automatisierte Anomalie-Detection und Pattern-Recognition bei gleichzeitiger Reduktion des manuellen Aufwands.
**Nächste Schritte:**
- Vertiefung spezifischer Tool-Implementierungen (Autopsy, SIFT, etc.)
- Cloud-native Timeline-Techniken für AWS/Azure-Umgebungen
- Advanced Correlation-Algorithmen für Zero-Day-Detection
- Integration von Threat-Intelligence in Timeline-Workflows

2
src/content/knowledgebase/android-logical-imaging.md → src/content/knowledgebase/method-android-logical-imaging.md
View File

@ -3,7 +3,7 @@ title: "Extraktion logischer Dateisysteme alter Android-Smartphones - eine KI-Re
tool_name: "Android Logical Imaging"
description: "Wie man alte Android-Handys aufbekommen könnte - eine Recherche von Claude"
last_updated: 2025-07-21
author: "Claude 4 Sonnet (Research)"
author: "Claude 4 Sonnett (Prompt: Mario Stöckl)"
difficulty: "advanced"
categories: ["data-collection"]
tags: ["imaging", "filesystem", "hardware-interface"]

110
src/content/knowledgebase/regular-expressions-regex.md
View File

@ -1,110 +0,0 @@
---
title: "Regular Expressions (Regex) – Musterbasierte Textanalyse"
tool_name: "Regular Expressions (Regex)"
description: "Pattern matching language für Suche, Extraktion und Manipulation von Text in forensischen Analysen."
last_updated: 2025-07-20
author: "Claude 4 Sonnet"
difficulty: "intermediate"
categories: ["incident-response", "malware-analysis", "network-forensics", "fraud-investigation"]
tags: ["pattern-matching", "text-processing", "log-analysis", "string-manipulation", "search-algorithms"]
sections:
overview: true
installation: false
configuration: false
usage_examples: true
best_practices: true
troubleshooting: false
advanced_topics: true
review_status: "published"
---
> **⚠️ Hinweis**: Dies ist ein vorläufiger, KI-generierter Knowledgebase-Eintrag. Wir freuen uns über Verbesserungen und Ergänzungen durch die Community!
# Übersicht
**Regular Expressions (Regex)** sind ein leistungsfähiges Werkzeug zur Erkennung, Extraktion und Transformation von Zeichenfolgen anhand vordefinierter Muster. In der digitalen Forensik sind Regex-Ausdrücke unverzichtbar: Sie helfen beim Auffinden von IP-Adressen, Hash-Werten, Dateipfaden, Malware-Signaturen oder Kreditkartennummern in großen Mengen unstrukturierter Daten wie Logdateien, Netzwerktraces oder Memory Dumps.
Regex ist nicht auf eine bestimmte Plattform oder Software beschränkt – es wird in nahezu allen gängigen Programmiersprachen, Texteditoren und forensischen Tools unterstützt.
## Verwendungsbeispiele
### 1. IP-Adressen extrahieren
```regex
\b(?:\d{1,3}\.){3}\d{1,3}\b
````
Verwendung:
* Finden von IP-Adressen in Firewall-Logs oder Packet Captures.
* Beispiel-Zeile:
```
Connection from 192.168.1.101 to port 443 established
```
### 2. E-Mail-Adressen identifizieren
```regex
[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}
```
Verwendung:
* Erkennung von kompromittierten Accounts in Phishing-E-Mails.
* Analyse von Useraktivitäten oder Kommunikationsverläufen.
### 3. Hash-Werte erkennen (z. B. SHA-256)
```regex
\b[A-Fa-f0-9]{64}\b
```
Verwendung:
* Extraktion von Malware-Hashes aus Memory Dumps oder YARA-Logs.
### 4. Zeitstempel in Logdateien extrahieren
```regex
\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}
```
Verwendung:
* Zeitsensitive Korrelationsanalysen (z. B. bei Intrusion Detection oder Timeline-Rekonstruktionen).
## Best Practices
* **Regex testen**: Nutze Plattformen wie [regexr.com](https://regexr.com/) oder [regex101.com](https://regex101.com/) zur Validierung.
* **Performance beachten**: Komplexe Ausdrücke können ineffizient sein und Systeme verlangsamen – verwende Lazy Quantifiers (`*?`, `+?`) bei Bedarf.
* **Escape-Zeichen korrekt anwenden**: Spezielle Zeichen wie `.` oder `\` müssen bei Bedarf mit `\\` oder `\.` maskiert werden.
* **Portabilität prüfen**: Unterschiedliche Regex-Engines (z. B. Python `re`, PCRE, JavaScript) interpretieren manche Syntax leicht unterschiedlich.
* **Lesbarkeit fördern**: Verwende benannte Gruppen (`(?P<name>...)`) und Kommentare (`(?x)`), um reguläre Ausdrücke besser wartbar zu machen.
## Weiterführende Themen
### Lookaheads und Lookbehinds
Mit **Lookaheads** (`(?=...)`) und **Lookbehinds** (`(?<=...)`) können Bedingungen formuliert werden, ohne dass der Text Teil des Matchs wird.
Beispiel: Alle `.exe`-Dateinamen **ohne** das Wort `safe` davor matchen:
```regex
(?<!safe\s)[\w-]+\.exe
```
### Regex in Forensik-Tools
* **YARA**: Unterstützt Regex zur Erstellung von Malware-Signaturen.
* **Wireshark**: Filtert Payloads anhand von Regex-ähnlicher Syntax.
* **Splunk & ELK**: Verwenden Regex für Logparsing und Visualisierung.
* **Volatility Plugins**: Extrahieren Artefakte mit Regex-basierten Scans.
---
> 🔤 **Regex ist ein universelles Werkzeug für Analysten, Ermittler und Entwickler, um versteckte Informationen schnell und flexibel aufzuspüren.**
>
> Nutze es überall dort, wo Textdaten eine Rolle spielen.

2
src/content/knowledgebase/kali-linux.md → src/content/knowledgebase/tool-kali-linux.md
View File

@ -3,7 +3,7 @@ title: "Kali Linux - Die Hacker-Distribution für Forensik & Penetration Testing
tool_name: "Kali Linux"
description: "Leitfaden zur Installation, Nutzung und Best Practices für Kali Linux – die All-in-One-Plattform für Security-Profis."
last_updated: 2025-07-20
author: "Claude 4 Sonnet"
author: "Claude 4 Sonnett (Prompt: Mario Stöckl)"
difficulty: "intermediate"
categories: ["incident-response", "forensics", "penetration-testing"]
tags: ["live-boot", "tool-collection", "penetration-testing", "forensics-suite", "virtualization", "arm-support"]

2
src/content/knowledgebase/misp.md → src/content/knowledgebase/tool-misp.md
View File

@ -3,7 +3,7 @@ title: "MISP - Plattform für Threat Intelligence Sharing"
tool_name: "MISP"
description: "Das Rückgrat des modernen Threat-Intelligence-Sharings mit über 40.000 aktiven Instanzen weltweit."
last_updated: 2025-07-20
author: "Claude 4 Sonnet"
author: "Claude 4 Sonnett (Prompt: Mario Stöckl)"
difficulty: "intermediate"
categories: ["incident-response", "static-investigations", "malware-analysis", "network-forensics", "cloud-forensics"]
tags: ["web-based", "threat-intelligence", "api", "correlation", "ioc-sharing", "automation"]

2
src/content/knowledgebase/nextcloud.md → src/content/knowledgebase/tool-nextcloud.md
View File

@ -3,7 +3,7 @@ title: "Nextcloud - Sichere Kollaborationsplattform"
tool_name: "Nextcloud"
description: "Detaillierte Anleitung und Best Practices für Nextcloud in forensischen Einsatzszenarien"
last_updated: 2025-07-20
author: "Claude 4 Sonnet"
author: "Claude 4 Sonnett (Prompt: Mario Stöckl)"
difficulty: "novice"
categories: ["collaboration-general"]
tags: ["web-based", "collaboration", "file-sharing", "api", "encryption", "document-management"]

2
src/content/knowledgebase/velociraptor.md → src/content/knowledgebase/tool-velociraptor.md
View File

@ -3,7 +3,7 @@ title: "Velociraptor – Skalierbare Endpoint-Forensik mit VQL"
tool_name: "Velociraptor"
description: "Detaillierte Anleitung und Best Practices für Velociraptor – Remote-Forensik der nächsten Generation"
last_updated: 2025-07-20
author: "Claude 4 Sonnet"
author: "Claude 4 Sonnett (Prompt: Mario Stöckl)"
difficulty: "advanced"
categories: ["incident-response", "malware-analysis", "network-forensics"]
tags: ["web-based", "endpoint-monitoring", "artifact-extraction", "scripting", "live-forensics", "hunting"]