Forensic
Master Edition

1.1 Was ist digitale Forensik?

Digitale Forensik ist die Wissenschaft der Beweissicherung, Analyse und Rekonstruktion digitaler Informationen. Sie dient nicht nur der Strafverfolgung, sondern auch der Datenrettung, der Incident Response und der technischen Rekonstruktion vergangener Vorgänge.

Der Kern besteht aus vier Grundaufgaben:

1.2 Anwendungsgebiete

Digitale Forensik wird in vielfältigen Kontexten eingesetzt:

• Datenrettung — Wiederherstellung von Daten nach Hardware-Ausfällen
• Incident Response — Reaktion auf IT-Sicherheitsvorfälle
• Cybercrime-Untersuchungen — Strafverfolgung digitaler Kriminalität
• Systemrekonstruktion — Wiederaufbau beschädigter IT-Umgebungen
• Wallet-Recovery — Wiedererlangung von Krypto-Wallets, Seeds, Zugangsdaten
• Datensortierung — Umgang mit großen heterogenen Datenbeständen
• Digitales Erbe — Datenwiederherstellung für Hinterbliebene

1.3 Was dieses Buch behandelt

Dieses Werk bildet einen vollständigen forensischen Workflow ab — von der ersten Berührung eines defekten Datenträgers bis zum finalen Abschlussbericht:

• Arbeiten nach internationalen Standards (ACPO, RFC 3227, NIST 800-86)
• Physische und logische Analyse von Datenträgern
• Imaging mit ddrescue und Hash-Validierung
• Arbeiten ausschließlich am forensischen Abbild
• Tiefgreifende MIME-Analyse
• Kodierungsreparaturen (UTF-8, Latin-1, MacRoman, NFC)
• Vollautomatische Sortierlogik für Millionen Dateien
• Erstellung vollständiger Abschlussberichte

1.4 Ethische Grenzen

1.5 Zentrale Risiken

Digitale Forensik ist hochriskant, wenn Fehler gemacht werden. Die Konsequenzen können irreversibel sein:

• Daten können irreversibel überschrieben werden
• Dateisysteme können beschädigt werden
• Hashwerte können ungültig werden
• Metadaten können manipuliert wirken
• Juristische Verwertbarkeit kann verloren gehen

Diese Regeln sichern vier fundamentale Eigenschaften:

• Integrität — Daten bleiben unverändert
• Reproduzierbarkeit — Ergebnisse sind wiederholbar
• Transparenz — Jeder Schritt ist nachvollziehbar
• Nachvollziehbarkeit — Die Beweiskette ist lückenlos

2.1 ACPO-Prinzipien (UK Home Office)

Die Association of Chief Police Officers (ACPO) definierte grundlegende Leitlinien für digitale Beweissicherung. Diese vier Kernprinzipien bilden die Basis jedes seriösen Workflows:

2.2 RFC 3227 — Incident Response Evidence Handling

RFC 3227 definiert die Reihenfolge der Beweissicherung, also die Priorität, in der Daten abgegriffen werden müssen:

2.3 NIST Special Publication 800-86

Das US National Institute of Standards and Technology definiert in SP 800-86 den vollständigen Rahmen für forensische Untersuchungen:

• Rollen — Wer ist wofür verantwortlich?
• Arbeitsabläufe — Wie ist der Prozess strukturiert?
• Analyseprozess — Welche Schritte sind notwendig?
• Reporting — Wie werden Ergebnisse dokumentiert?
• Hashvalidierung — Wie wird Integrität sichergestellt?
• Dokumentationsstruktur — Was muss festgehalten werden?

Dieses Buch folgt weitgehend der NIST-Methodik.

2.4 ISO/IEC 27037

Diese internationale Norm beschreibt:

• Identifikation digitaler Beweise
• Sicherstellung und Handhabung
• Dokumentationsanforderungen
• Umgang mit verschiedenen Speichergeräten

Sie bildet den internationalen Rahmen der Beweiserhebung.

3.1 Niemals am Originalmedium arbeiten

Gründe für diese strikte Regel:

• Jeder Zugriff ändert Access-Timestamps
• Das Betriebssystem schreibt versteckte Metadaten
• Indexer und Dienste könnten Dateien verändern
• Beschädigte Medien können durch Zugriffe weiter zerstört werden

3.2 Write-Blocker & Read-Only-Mount

Ein Write-Blocker verhindert hardwareseitig jede Schreiboperation. Dies ist der sicherste Ansatz für forensische Arbeit.

Softwareseitige Alternative (weniger sicher):

mount -o ro /dev/sdX /mnt/original

3.3 Dokumentation jeder Handlung

Eine forensische Dokumentation muss lückenlos sein. Jede Handlung, jeder Befehl, jede Beobachtung wird festgehalten:

3.4 Reproduzierbarkeit

Jede Analyse muss so durchführbar sein, dass ein zweiter Experte zum gleichen Ergebnis kommt. Das bedeutet:

• Alle Schritte standardisieren
• Alle Befehle exakt dokumentieren
• Keine proprietären Blackbox-Tools verwenden
• Open-Source-Werkzeuge bevorzugen

3.5 Integrität & Hashing

4.1 Mechanische Festplatten (HDD)

Eine klassische HDD besteht aus folgenden Komponenten:

• Platters — Mehrere Magnetscheiben, auf denen Daten gespeichert werden
• Heads — Schreib-/Leseköpfe, die über den Plattern schweben
• Aktuator — Der Arm, der die Heads positioniert
• Spindel — Motor, der die Platters dreht
• Controller — Mit eingebetteter Firmware

4.1.1 Strukturrelevante Eigenschaften

4.2 SSD & NVMe (Flashspeicher)

4.2.1 Architektur

• NAND-Flash — Speicherzellen (SLC, MLC, TLC, QLC)
• Controller — Verwaltet Wear-Leveling und Fehlerkorrektur
• Bad Block Management — Automatisches Ausblenden defekter Bereiche
• Garbage Collection — Hintergrundbereinigung
• TRIM — Informiert SSD über gelöschte Blöcke

4.2.2 HDD vs. SSD im Vergleich

4.3 USB-Sticks, SD-Karten, Smartphones

Diese Medien teilen gemeinsame Eigenschaften:

• Billige Controller mit hoher Fehlerquote
• Unzuverlässige Firmware
• Fragmentierung auf Blockebene
• „Silent Corruption" — stilles Remappen von Blöcken

Besonderheiten:

• USB-Sticks remappen Blöcke oft still (Silent Corruption)
• SD-Karten sterben häufig schlagartig ohne Vorwarnung
• Smartphones benötigen logische Extraktion (ADB, MTP) oder physische Dumping-Methoden

4.4 Firmware, Cache & versteckte Bereiche

4.4.1 HPA (Host Protected Area)

Ein versteckter Bereich auf HDDs, der vom normalen Betriebssystem nicht gesehen wird. Kann Daten verbergen und wird bei professionellem Imaging explizit geprüft.

4.4.2 DCO (Device Configuration Overlay)

Manipulierbar und gefährlich — kann Partitionstabellen verschleiern und die sichtbare Kapazität eines Laufwerks reduzieren.

4.5 Typische physische Fehlerbilder

5.1 Partitionstabellen

5.1.1 MBR (Master Boot Record)

• 512 Byte Gesamtgröße
• Maximal 4 primäre Partitionen
• Über 30 Jahre alt
• Häufig korrupt durch Schreibfehler

fdisk -l /dev/sdX
testdisk /dev/sdX

5.1.2 GPT (GUID Partition Table)

• Moderner Standard, seit ~2010
• Redundante Partitionstabelle (Primary & Backup)
• CRC32 Integritätsprüfung
• Bis zu 128 Partitionen

5.2 Dateisysteme im Überblick

5.2.1 NTFS (Windows)

Wichtigste Strukturen:

• $MFT — Master File Table (zentrales Verzeichnis)
• $Bitmap — Cluster-Belegung
• $AttrDef — Attributdefinitionen
• $LogFile — Transaktionsjournal
• $BadClus — Defekte Cluster

NTFS ist sehr robust, aber bei Beschädigung extrem komplex zu reparieren.

5.2.2 ext4 (Linux)

• Journaling für Crash-Recovery
• Sehr robust und gut dokumentiert
• Hervorragende Recovery-Möglichkeiten

5.2.3 exFAT

• Oft bei USB-Sticks und SD-Karten
• Empfindlich und wenig redundant
• Minimale Metadaten → leicht zerstörbar

5.2.4 APFS (Apple)

• Container-basierte Architektur
• Snapshots und Klone
• Standardmäßig verschlüsselt
• Forensisch schwierig zu analysieren

5.3 Metadaten — die versteckte Wahrheit

Daten bestehen zu einem erheblichen Teil aus Metadaten — Informationen über die eigentlichen Inhalte. Forensiker können daraus rekonstruieren:

• Zeitlinien — Wann wurde was erstellt, geändert, zugegriffen?
• Geräte — Mit welcher Kamera/welchem Gerät wurde aufgenommen?
• Benutzeraktivitäten — Wer hat wann was getan?
• Geokoordinaten — Wo wurde ein Foto aufgenommen?
• Software — Welche Anwendung hat die Datei erstellt?

Metadatenquellen:

• Dateisystem — ctime, mtime, atime
• Dateiheader — Format-spezifische Informationen
• EXIF — Bildinformationen
• IPTC — Pressemetadaten
• XMP — Adobe-Metadaten
• PDF-Objekte — Dokumenteninformationen
• Video-Container — MP4/MOV Atoms

6.1 SMART-Analyse im Detail

SMART (Self-Monitoring, Analysis and Reporting Technology) zeigt kritische Indikatoren:

smartctl -a /dev/sdX

Beispielausgabe einer sterbenden Festplatte:

SMART overall-health: FAILING
Reallocated_Sector_Ct = 138
Current_Pending_Sectors = 46
Offline_Uncorrectable = 12

6.2 dmesg-Meldungen verstehen

Der Kernel-Log enthält wertvolle Informationen über Hardware-Probleme:

dmesg -wH

6.3 Fehler beim Lesen & Schreiben

6.4 Tools zur Fehlererkennung

7.1 Was ist ein forensisches Image?

Eigenschaften eines professionellen Images:

• 1:1 unveränderliche Kopie
• Hash-identisch mit dem Original
• Unabhängig vom Dateisystem
• Enthält ALLE Spuren
• Vollständig offline analysierbar
• Rechtlich verwertbar

7.2 Hardware-Anforderungen

7.2.1 Stromversorgung

Eine instabile Stromversorgung erzeugt:

• Head jumps bei HDDs
• Schreibfehler im Cache
• Abbrüche während des Imaging
• Zerstörte Logfiles

7.2.2 Kabel & Ports

Schlechte USB-Kabel verursachen:

• CRC-Errors
• Device Resets
• Defekte Image-Fragmente
• device descriptor read/64, error -71 Meldungen

7.2.3 Write Blocker (Hardware)

Seriöse Forensik nutzt Hardware-Write-Blocker:

• Tableau Forensic Imager
• WiebeTech Forensic Write Blocker
• Voom ShadowDrive

Software kann immer trickreich umgangen werden — Hardware nicht.

7.2.4 Software-Write-Block (Alternative)

mount -o ro /dev/sdX /mnt/readonly

7.3 Dokumentation vorbereiten

Ein Imaging ohne Dokumentation ist wertlos. Zu dokumentieren:

7.4 Dead Box vs. Live Imaging

7.5 Vorbereitung des Zielsystems

• Zielplatte muss größer oder gleich der Quelle sein
• Formatierung egal — ddrescue schreibt blockweise
• SSD als Ziel nicht ideal (TRIM), Empfehlung: HDD
• Logverzeichnis anlegen
• LVM/RAID vorher erkennen

8.1 Grundprinzipien von ddrescue

ddrescue arbeitet:

• Intelligent — Erkennt Muster in defekten Bereichen
• Adaptiv — Passt Strategie an Medium an
• Blockbasiert — Arbeitet auf Sektorebene
• Mit Logfile-Strategie — Unterbrechbar und fortsetzbar
• Wiederholbar — Mehrere Durchläufe möglich
• Nicht-destruktiv — Liest nur, schreibt nie auf die Quelle

ddrescue führt mehrere Durchläufe aus:

1. Schnelles Lesen — Blocks, Trimming, Scraping
2. Retry-Phasen — Wiederholte Leseversuche
3. Fehlerbehandlung — Defekte Bereiche markieren
4. Reverse Reading — Rückwärts lesen für Head-Alignment
5. Feinrekonstruktion — Kleine Blöcke gezielt lesen

8.2 Aufbau einer ddrescue-Logdatei

Eine typische Logdatei enthält Segmente wie:

# Mapfile. Created by GNU ddrescue version 1.27
# Command line: ddrescue -f -n /dev/sdb image.raw image.log
# Start time:   2025-12-10 14:32:15
# Current time: 2025-12-10 15:47:23
# Finished
0x00000000  0x40000000  +
0x40000000  0x00002000  -
0x40002000  0x00001000  ?
0x40003000  0x3BFFD000  +

8.3 Das perfekte Imaging-Kommando

8.3.1 Erster Durchlauf — schnell, non-intrusive

sudo ddrescue -f -n /dev/sdX /evidence/image.raw /evidence/image.log

• -f = Force (überschreibt Ziel)
• -n = No scrape (kein Retry)
• Ziel: Maximal schnell alles retten, was leicht lesbar ist
• Minimale Belastung des Datenträgers

8.3.2 Zweiter Durchlauf — intensiver

sudo ddrescue -d -r3 /dev/sdX /evidence/image.raw /evidence/image.log

• -d = Direct Disk Access (umgeht OS-Cache)
• -r3 = Drei Wiederholungsversuche pro Block
• Ziel: Schwierige/semi-defekte Blöcke retten

8.3.3 Dritter Durchlauf — reverse

sudo ddrescue -R -r2 /dev/sdX /evidence/image.raw /evidence/image.log

• -R = Reverse (liest rückwärts)
• Sehr effektiv bei Head-Alignment-Problemen
• Kann Bereiche lesen, die vorwärts nicht lesbar waren

8.4 ddrescue-Fehlerbilder

8.5 Vollständiger Imaging-Workflow

# 1. Verzeichnisse anlegen
mkdir -p /evidence/case001/{images,logs,hashes}

# 2. SMART prüfen
smartctl -a /dev/sdX > /evidence/case001/logs/smart_before.txt

# 3. Phase 1: Schnelles Lesen
ddrescue -f -n /dev/sdX /evidence/case001/images/disk.raw \
    /evidence/case001/logs/disk.log

# 4. Phase 2: Retries
ddrescue -d -r3 /dev/sdX /evidence/case001/images/disk.raw \
    /evidence/case001/logs/disk.log

# 5. Phase 3: Reverse
ddrescue -R -r2 /dev/sdX /evidence/case001/images/disk.raw \
    /evidence/case001/logs/disk.log

# 6. Hash erstellen
sha256sum /evidence/case001/images/disk.raw > \
    /evidence/case001/hashes/disk.sha256

8.6 Image-Formate

Dieses Buch verwendet RAW — das universellste und schnellste Format.

9.1 Warum Hashing?

Ein Hashwert:

• Beweist Integrität — Daten sind unverändert
• Zeigt Manipulationen — Jede Änderung ändert den Hash
• Ist ein digitaler Fingerabdruck — Eindeutig identifizierend
• Ist unverzichtbar in jedem forensischen Prozess

9.2 Hashverfahren im Vergleich

9.3 Hash des Originals erstellen

sha256sum /dev/sdX > /evidence/original.sha256

9.4 Hash des Images erstellen

sha256sum /evidence/image.raw > /evidence/image.sha256

9.5 Hashvergleich

# Manueller Vergleich
cat /evidence/original.sha256
cat /evidence/image.sha256

# Automatischer Vergleich
diff /evidence/original.sha256 /evidence/image.sha256 && echo "✓ Identisch"

9.6 Integritätskette dokumentieren

Eine vollständige Beweiskette enthält:

1. Hash des Originaldatenträgers
2. Hash des RAW-Images
3. Hash der sortierten Struktur (später)
4. Hash des Archivs (später)

Somit ist jede Manipulation in jeder Phase erkennbar.

10.1 RAW-Image einhängen

sudo mkdir -p /mnt/image
sudo mount -o ro,loop /evidence/image.raw /mnt/image

Falls das Image mehrere Partitionen enthält:

fdisk -l /evidence/image.raw

Beispielausgabe:

Device          Boot   Start      End  Sectors  Size Id Type
image.raw1      *       2048  1026047  1024000  500M  7 HPFS/NTFS
image.raw2           1026048 41943039 40916992 19.5G  7 HPFS/NTFS

10.2 Partitionen separat mounten

# Loop-Device erstellen
sudo losetup -f --show /evidence/image.raw

# Partitionen verfügbar machen
sudo kpartx -av /dev/loop0

# Einzelne Partition mounten
sudo mount -o ro /dev/mapper/loop0p2 /mnt/image

10.3 Typische Fehlerszenarien

10.4 Offset-Berechnung für manuelle Mounts

Wenn kpartx nicht funktioniert, manuell berechnen:

# Start-Sektor aus fdisk-Ausgabe: 1026048
# Sektorgröße: 512 Bytes
# Offset = 1026048 × 512 = 525336576

sudo mount -o ro,loop,offset=525336576 /evidence/image.raw /mnt/image

10.5 Forensische Snapshot-Techniken

Für sichere Analyse können Copy-on-Write-Layer verwendet werden:

# Arbeitsverzeichnisse anlegen
mkdir -p /tmp/overlay/{upper,work,merged}

# Overlay mounten (Änderungen gehen nach upper)
sudo mount -t overlay overlay \
    -o lowerdir=/mnt/image,upperdir=/tmp/overlay/upper,workdir=/tmp/overlay/work \
    /tmp/overlay/merged

So bleiben alle Änderungen isoliert und das Original-Image unberührt.

11.1 Der High-Level Scan

Ziel: Schneller Überblick ohne Details.

find /mnt/image -type f | wc -l

du -sh /mnt/image

tree -d -L 3 /mnt/image

11.2 Strukturierte Dateistatistik

find /mnt/image -type f | sed 's|.*\.||' | sort | uniq -c | sort -nr | head -30

find /mnt/image -type f -printf "%h\n" | sort | uniq -c | sort -nr | head -20

Diese Werte verraten:

• Dominante Dateitypen
• Große Ordner (potenzielle Backups)
• Mögliche Backup-Strukturen
• Typische Benutzerverhalten

11.3 Zeitliche Rekonstruktion (Timeline-Envelope)

find /mnt/image -type f -printf "%TY\n" | sort | uniq -c | sort -k2

find /mnt/image -type f -printf "%TY-%Tm\n" | sort | uniq -c

Interpretation der Timeline:

• Aktivitätsperioden — Wann wurde das Gerät hauptsächlich genutzt?
• Zeitlöcher — Migrationen oder Systemwechsel
• Spitzen — Besondere Ereignisse (Urlaub, Backup)

11.4 Identifikation besonderer Dateien

11.4.1 Große Dateien (>1 GB)

find /mnt/image -type f -size +1G -printf "%s %p\n" | sort -nr | head -20

Oft relevant: Videos, Disk-Images, Backups, Datenbanken.

11.4.2 Sensible Dateitypen

grep -RilE "mnemonic|wallet|seed|ledger|trezor|keystore" /mnt/image 2>/dev/null

grep -RilE "password|passwort|pin|secret" /mnt/image 2>/dev/null

11.5 Detektion beschädigter Dateien

find /mnt/image -type f -size 0

Korruptionsanzeiger:

• 0-Byte-Dateien
• Abgebrochene Downloads
• Verschobene Endungen
• Ungewöhnlich kleine Dateien für ihren Typ

12.1 Warum Dateiendungen nutzlos sind

Forensik darf niemals Dateiendungen vertrauen.

12.2 Die MIME-Analyse-Masterpipeline

find /mnt/image -type f -print0 \
  | xargs -0 file --mime-type --brief \
  | sort | uniq -c | sort -nr

Dies erzeugt ein „Fingerprint-Diagramm" der gesamten HDD — eine Übersicht aller tatsächlich vorhandenen Dateitypen.

12.3 MIME-Klassen

12.4 Die „Octet-Stream"-Hölle

application/octet-stream bedeutet: Ich weiß nicht, was das ist.

Mögliche Ursachen:

• Beschädigte Header
• Verschlüsselte Dateien
• Archivfragmente
• RAW-Datenbereiche
• Zufällige Bitströme

12.5 MIME-Anomalieerkennung

Eine Anomalie ist:

• Ein Bild im Dokumentenordner
• Ein ZIP in einem Fotos-Ordner
• Ein ausführbares Binary in „Downloads"
• Eine 3GB-Datei auf dem Desktop
• Ein MOV im System-Cache

MIME-Anomalien sind Indikatoren für:

• Migrationen zwischen Systemen
• Manuelle Verschiebungen
• Doppelte Backups
• Benutzeraktionen außerhalb der Norm
• Potenzielle Malware
• Fragment-Recovery-Potenzial

12.6 MIME → Sortierlogik

Die tiefe Erklärung der Sortierlogik erfolgt in Teil V.

13.1 Arten von Kodierungsproblemen

13.1.1 Nicht-UTF-8-Namen

Alte Dateisysteme verwenden verschiedene Kodierungen:

• Latin-1 (ISO-8859-1) — Westeuropa
• CP437 — DOS
• Windows-1252 — Windows
• MacRoman — Alte Mac-Systeme

13.1.2 NFD-Normalisierung (macOS)

macOS speichert Umlaute anders als Linux:

• macOS (NFD): ä als a + ¨ (zwei Zeichen)
• Linux (NFC): ä als ein Zeichen

Dies führt zu:

• Nicht auflösbaren Pfaden
• Fehlern in Shell-Skripten
• Sortierabbrüchen

13.2 Nicht-UTF-8 Dateien erkennen

find /mnt/image -print0 | LC_ALL=C grep -zPv '^[\x00-\x7F]+$'

13.3 Kodierungen konvertieren

convmv -f latin1 -t utf8 --notest -r /mnt/image

convmv -f cp437 -t utf8 --notest -r /mnt/image

convmv -f utf8 -t utf8 --nfc --notest -r /mnt/image

13.4 Illegale Zeichen reparieren

Diese Zeichen sind in vielen Dateisystemen illegal:

< > : " | ? * \ NUL

find /mnt/image -depth -print0 | while IFS= read -r -d '' file; do
    clean=$(printf "%s" "$file" | sed 's#[<>:"/\\|?*]#_#g')
    [ "$clean" != "$file" ] && mv "$file" "$clean"
done

13.5 Der „Permission denied"-Irrtum

Deshalb ist dieses Kapitel kritisch wichtig für jeden Sortierprozess.

14.1 EXIF-Forensik (Fotos, Videos)

EXIF-Felder enthalten wertvolle Informationen:

• Kamera — Hersteller und Modell
• Linsenmodell — Objektiv-Details
• GPS — Geokoordinaten
• Seriennummer — Eindeutige Kamera-ID
• Zeitstempel — Aufnahmedatum und -zeit
• Software — Bearbeitungsprogramme

exiftool -a -u -g1 foto.jpg

14.2 PDF-Forensik

Wichtigste PDF-Strukturen:

• Objekt-Streams — Enthaltene Ressourcen
• XRef-Tabellen — Querverweise
• Trailer — Dokumentende mit Metadaten
• Embedded Files — Eingebettete Dateien

pdfinfo dokument.pdf
pdfimages -list dokument.pdf

14.3 Video-/Audio-Container

MP4/MOV bestehen aus „Atoms":

• ftyp — Dateityp-Deklaration
• moov — Metadaten und Index (kritisch!)
• mdat — Mediendaten
• udta — Benutzerdaten

14.4 Signaturbasiertes File Carving

Tools wie photorec können anhand von Signaturen Dateien wiederherstellen:

• JPEG-Signaturen (FFD8FFE0)
• MP4-Atoms
• ZIP-Köpfe (504B0304)

photorec /d /recovery /evidence/image.raw

14.5 Wallet- & Seed-Suche

grep -RiaE "seed|wallet|mnemonic|ledger|trezor|passphrase" /mnt/image

strings -n 8 /evidence/image.raw | grep -Ei "seed|wallet|mnemonic"

Weitere Suchziele:

• JSON-Dateien
• Windows Registry
• Browser-Extension-Daten
• LevelDB-Dumps

15.1 Warum systematische Sortierung?

Unsortierte Daten sind:

• Schwer durchsuchbar
• Nicht reproduzierbar analysierbar
• Voller versteckter Duplikate
• Zeitfresser bei jeder Suche
• Potenzielle Datengräber

Sortierte Daten sind:

• Sofort auffindbar
• Logisch strukturiert
• Duplikatfrei oder -bewusst
• Archivierbar
• Übergabefähig

15.2 Das MIME-First-Prinzip

15.3 Die Zielstruktur

Die ideale Sortierstruktur:

OUTPUT/
├── 01_Images/
│   ├── jpg/
│   ├── png/
│   ├── gif/
│   ├── webp/
│   ├── raw/
│   └── other/
├── 02_Videos/
│   ├── mp4/
│   ├── mov/
│   ├── avi/
│   ├── mkv/
│   └── other/
├── 03_Audio/
│   ├── mp3/
│   ├── wav/
│   ├── flac/
│   └── other/
├── 04_Documents/
│   ├── pdf/
│   ├── office/
│   ├── text/
│   └── other/
├── 05_Archives/
│   ├── zip/
│   ├── rar/
│   ├── tar/
│   └── other/
├── 06_Code/
│   ├── scripts/
│   ├── web/
│   ├── data/
│   └── other/
├── 07_System/
│   ├── executables/
│   ├── libraries/
│   ├── config/
│   └── other/
├── 08_Unknown/
│   └── octet-stream/
└── 09_Logs/
    ├── sort.log
    ├── errors.log
    └── manifest.txt

15.4 Sortierregeln

1. MIME-Typ ist Master — Immer zuerst MIME prüfen
2. Keine Duplikate überschreiben — Konflikte mit Suffix lösen
3. Alle Fehler loggen — Nichts stillschweigend ignorieren
4. Originalpfad bewahren — Im Manifest dokumentieren
5. Kodierung reparieren — Vor dem Kopieren normalisieren

15.5 Kopieren vs. Verschieben

16.1 Die Master-Sortierpipeline

#!/bin/bash
# ═══════════════════════════════════════════════════════════════════════════
# FORENSIC MASTER SORTER v2.0
# Vollautomatische MIME-basierte Datensortierung
# ═══════════════════════════════════════════════════════════════════════════

set -euo pipefail

# ─── KONFIGURATION ────────────────────────────────────────────────────────
SOURCE="${1:-/mnt/image}"
OUTPUT="${2:-/evidence/sorted}"
LOGDIR="$OUTPUT/09_Logs"
MANIFEST="$LOGDIR/manifest.txt"
ERRORLOG="$LOGDIR/errors.log"
SORTLOG="$LOGDIR/sort.log"

# ─── VERZEICHNISSE ANLEGEN ────────────────────────────────────────────────
mkdir -p "$OUTPUT"/{01_Images/{jpg,png,gif,webp,raw,other},02_Videos/{mp4,mov,avi,mkv,other}}
mkdir -p "$OUTPUT"/{03_Audio/{mp3,wav,flac,other},04_Documents/{pdf,office,text,other}}
mkdir -p "$OUTPUT"/{05_Archives/{zip,rar,tar,other},06_Code/{scripts,web,data,other}}
mkdir -p "$OUTPUT"/{07_System/{executables,libraries,config,other},08_Unknown/octet-stream}
mkdir -p "$LOGDIR"

# ─── LOGGING INITIALISIEREN ───────────────────────────────────────────────
echo "# Forensic Sort Manifest - $(date -Is)" > "$MANIFEST"
echo "# Source: $SOURCE" >> "$MANIFEST"
echo "# ═══════════════════════════════════════════════════════════════" >> "$MANIFEST"

log() { echo "[$(date '+%H:%M:%S')] $*" | tee -a "$SORTLOG"; }
error() { echo "[ERROR] $*" | tee -a "$ERRORLOG"; }

log "Starte Sortierung von: $SOURCE"

# ─── ZÄHLER ───────────────────────────────────────────────────────────────
COUNT_TOTAL=0
COUNT_SUCCESS=0
COUNT_ERROR=0

# ─── MIME → ZIELORDNER MAPPING ────────────────────────────────────────────
get_target() {
    local mime="$1"
    local ext="$2"
    
    case "$mime" in
        image/jpeg)                     echo "01_Images/jpg" ;;
        image/png)                      echo "01_Images/png" ;;
        image/gif)                      echo "01_Images/gif" ;;
        image/webp)                     echo "01_Images/webp" ;;
        image/x-*|image/tiff)           echo "01_Images/raw" ;;
        image/*)                        echo "01_Images/other" ;;
        
        video/mp4|video/x-m4v)          echo "02_Videos/mp4" ;;
        video/quicktime)                echo "02_Videos/mov" ;;
        video/x-msvideo)                echo "02_Videos/avi" ;;
        video/x-matroska)               echo "02_Videos/mkv" ;;
        video/*)                        echo "02_Videos/other" ;;
        
        audio/mpeg)                     echo "03_Audio/mp3" ;;
        audio/x-wav|audio/wav)          echo "03_Audio/wav" ;;
        audio/flac|audio/x-flac)        echo "03_Audio/flac" ;;
        audio/*)                        echo "03_Audio/other" ;;
        
        application/pdf)                echo "04_Documents/pdf" ;;
        application/msword|application/vnd.openxmlformats*|application/vnd.ms-*)
                                        echo "04_Documents/office" ;;
        text/plain|text/markdown)       echo "04_Documents/text" ;;
        text/html|text/css)             echo "06_Code/web" ;;
        text/x-script*|text/x-python|text/x-shellscript|application/x-sh)
                                        echo "06_Code/scripts" ;;
        application/json|application/xml|text/xml|text/csv)
                                        echo "06_Code/data" ;;
        text/*)                         echo "04_Documents/other" ;;
        
        application/zip|application/x-zip*)
                                        echo "05_Archives/zip" ;;
        application/x-rar*|application/vnd.rar)
                                        echo "05_Archives/rar" ;;
        application/x-tar|application/gzip|application/x-bzip2|application/x-xz)
                                        echo "05_Archives/tar" ;;
        application/x-7z*|application/x-compress*)
                                        echo "05_Archives/other" ;;
        
        application/x-executable|application/x-mach-binary|application/x-dosexec)
                                        echo "07_System/executables" ;;
        application/x-sharedlib|application/x-archive)
                                        echo "07_System/libraries" ;;
        
        application/octet-stream)       echo "08_Unknown/octet-stream" ;;
        *)                              echo "08_Unknown/octet-stream" ;;
    esac
}

# ─── DATEINAME BEREINIGEN ─────────────────────────────────────────────────
sanitize_name() {
    local name="$1"
    # Illegale Zeichen entfernen, NFD→NFC
    printf "%s" "$name" | sed 's/[<>:"/\\|?*]/_/g' | sed 's/\x00//g'
}

# ─── KONFLIKTAUFLÖSUNG ────────────────────────────────────────────────────
resolve_conflict() {
    local target="$1"
    local base="${target%.*}"
    local ext="${target##*.}"
    local counter=1
    
    while [[ -e "$target" ]]; do
        if [[ "$base" == "$ext" ]]; then
            target="${base}_${counter}"
        else
            target="${base}_${counter}.${ext}"
        fi
        ((counter++))
    done
    
    echo "$target"
}

# ─── HAUPTSCHLEIFE ────────────────────────────────────────────────────────
process_file() {
    local file="$1"
    ((COUNT_TOTAL++))
    
    # MIME-Typ ermitteln
    local mime
    mime=$(file --mime-type --brief "$file" 2>/dev/null) || {
        error "MIME-Fehler: $file"
        ((COUNT_ERROR++))
        return 1
    }
    
    # Dateiname extrahieren und bereinigen
    local basename
    basename=$(basename "$file")
    local clean_name
    clean_name=$(sanitize_name "$basename")
    local ext="${clean_name##*.}"
    
    # Zielordner bestimmen
    local target_dir
    target_dir=$(get_target "$mime" "$ext")
    
    # Zielpfad erstellen
    local target_path="$OUTPUT/$target_dir/$clean_name"
    target_path=$(resolve_conflict "$target_path")
    
    # Kopieren
    if cp --preserve=timestamps "$file" "$target_path" 2>/dev/null; then
        echo "$file → $target_path [$mime]" >> "$MANIFEST"
        ((COUNT_SUCCESS++))
    else
        error "Kopieren fehlgeschlagen: $file"
        ((COUNT_ERROR++))
    fi
}

export -f process_file sanitize_name resolve_conflict get_target log error
export OUTPUT MANIFEST ERRORLOG COUNT_TOTAL COUNT_SUCCESS COUNT_ERROR

# ─── AUSFÜHRUNG ───────────────────────────────────────────────────────────
log "Scanne Dateien..."

find "$SOURCE" -type f -print0 | while IFS= read -r -d '' file; do
    process_file "$file"
    
    # Fortschritt alle 1000 Dateien
    if (( COUNT_TOTAL % 1000 == 0 )); then
        log "Fortschritt: $COUNT_TOTAL Dateien verarbeitet"
    fi
done

# ─── ABSCHLUSS ────────────────────────────────────────────────────────────
log "═══════════════════════════════════════════════════════════════"
log "Sortierung abgeschlossen!"
log "Gesamt:    $COUNT_TOTAL"
log "Erfolg:    $COUNT_SUCCESS"
log "Fehler:    $COUNT_ERROR"
log "═══════════════════════════════════════════════════════════════"

# Hash des Outputs erstellen
find "$OUTPUT" -type f -exec sha256sum {} \; > "$LOGDIR/output.sha256"
log "Prüfsummen erstellt: $LOGDIR/output.sha256"

16.2 Verwendung des Skripts

chmod +x forensic-sort.sh
./forensic-sort.sh /mnt/image /evidence/sorted

16.3 Parallelisierung für große Datenmengen

find /mnt/image -type f -print0 | \
    parallel -0 -j8 --bar ./process_single_file.sh {}

16.4 Post-Sort-Validierung

# Dateien pro Kategorie zählen
for dir in /evidence/sorted/*/; do
    echo "$(basename "$dir"): $(find "$dir" -type f | wc -l)"
done

# MIME-Verteilung im Output prüfen
find /evidence/sorted -type f -print0 | \
    xargs -0 file --mime-type -b | sort | uniq -c | sort -nr

17.1 Timestamps verstehen

17.2 Timeline-Export

find /mnt/image -type f -printf "%T+ %p\n" | sort > timeline.txt

find /mnt/image -type f -printf "%TY-%Tm-%Td,%TH:%TM:%TS,%s,%p\n" > timeline.csv

17.3 Aktivitätsmuster erkennen

find /mnt/image -type f -printf "%Ta\n" | sort | uniq -c

find /mnt/image -type f -printf "%TH\n" | sort | uniq -c

Diese Muster verraten:

• Arbeitszeiten vs. Freizeit
• Typische Nutzungsgewohnheiten
• Anomalien (nächtliche Aktivität)
• Automatisierte Prozesse (regelmäßige Timestamps)

17.4 EXIF-basierte Timeline

exiftool -DateTimeOriginal -csv /mnt/image/**/*.jpg > photo_timeline.csv

18.1 Arten von Duplikaten

18.2 Hash-basierte Duplikaterkennung

find /mnt/image -type f -exec md5sum {} \; | sort > all_hashes.txt

awk '{print $1}' all_hashes.txt | sort | uniq -d > duplicate_hashes.txt
grep -Ff duplicate_hashes.txt all_hashes.txt > duplicates.txt

18.3 fdupes — Das Standardtool

fdupes -r /mnt/image > duplicates_report.txt

fdupes -rS /mnt/image

18.4 Duplikat-Strategien

18.5 Perceptual Hashing für Bilder

Für ähnliche (nicht identische) Bilder:

findimagedupes -R /mnt/image > similar_images.txt

Nützlich für:

• Unterschiedliche Kompressionen des gleichen Bildes
• Reskalierte Versionen
• Leicht bearbeitete Kopien

19.1 Archivformat-Vergleich

19.2 Das optimale Archivkommando

tar --zstd -cvf archiv_$(date +%Y%m%d).tar.zst /evidence/sorted/

tar -cvJf archiv_$(date +%Y%m%d).tar.xz /evidence/sorted/

tar -cvzf archiv_$(date +%Y%m%d).tar.gz /evidence/sorted/

19.3 Split-Archive für große Datenmengen

tar -cvf - /evidence/sorted/ | split -b 4G - archiv_part_

cat archiv_part_* | tar -xvf -

19.4 Verschlüsselte Archive

tar -cvf - /evidence/sorted/ | gpg --symmetric --cipher-algo AES256 > archiv.tar.gpg

gpg --decrypt archiv.tar.gpg | tar -xvf -

20.1 Prüfsummen für alle Dateien

find /evidence/sorted -type f -exec sha256sum {} \; > manifest.sha256

sha256sum -c manifest.sha256

20.2 Archiv-Hash

sha256sum archiv.tar.zst > archiv.tar.zst.sha256

20.3 Das forensische Manifest

Ein vollständiges Manifest enthält:

# FORENSIC ARCHIVE MANIFEST
# ═══════════════════════════════════════════════════════════════
# Erstellt: 2025-12-10 15:42:33 UTC
# Ersteller: JJ
# Case-ID: CASE-2025-001
# ═══════════════════════════════════════════════════════════════

[QUELLE]
Original: Samsung 870 EVO 1TB
Seriennummer: S6VBNF123456Z
Imaging-Tool: ddrescue 1.27
Original-Hash: SHA256:7f83b1657ff1fc53b92dc18148a1d65dfc2d4b1fa3d677284addd200126d9069

[IMAGE]
Datei: disk.raw
Größe: 1000204886016 Bytes
Hash: SHA256:7f83b1657ff1fc53b92dc18148a1d65dfc2d4b1fa3d677284addd200126d9069
Status: Verifiziert ✓

[SORTIERUNG]
Dateien gesamt: 847293
Erfolg: 847156
Fehler: 137
Sortiert nach: MIME-Type

[ARCHIV]
Format: tar.zst
Teile: 1
Größe: 312.4 GB
Hash: SHA256:a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146e

[PRÜFSUMMEN]
manifest.sha256: 847293 Einträge
Verifiziert: 2025-12-10 16:03:12 UTC
Status: Alle Dateien OK ✓

20.4 Signierte Manifeste

gpg --clearsign manifest.sha256

Die Signatur beweist:

• Wer das Manifest erstellt hat
• Dass es nicht verändert wurde
• Wann es signiert wurde

21.1 Struktur eines Abschlussberichts

1. Zusammenfassung — Executive Summary
2. Auftragsbeschreibung — Was wurde beauftragt?
3. Methodik — Welche Werkzeuge und Verfahren?
4. Quelldokumentation — Details zum Ursprungsmedium
5. Imaging-Protokoll — Alle Schritte dokumentiert
6. Analyseergebnisse — Gefundene Erkenntnisse
7. Integritätsnachweis — Hashes und Verifikation
8. Übergabeliste — Was wird übergeben?
9. Anhänge — Logs, Manifeste, Screenshots

21.2 Übergabeprotokoll

═══════════════════════════════════════════════════════════════
ÜBERGABEPROTOKOLL
═══════════════════════════════════════════════════════════════

Datum: ________________
Case-ID: ________________

ÜBERGEBEN VON:
Name: ________________
Rolle: ________________
Unterschrift: ________________

ÜBERGEBEN AN:
Name: ________________
Organisation: ________________
Unterschrift: ________________

ÜBERGABEOBJEKTE:
[ ] Originaldatenträger (versiegelt)
[ ] Forensisches Image (verifiziert)
[ ] Sortierte Datenstruktur
[ ] Archiv mit Prüfsummen
[ ] Abschlussbericht
[ ] Manifest-Dateien
[ ] Log-Dateien

INTEGRITÄTSSTATUS:
Image-Hash: ________________
Archiv-Hash: ________________
Status: [ ] Verifiziert [ ] Nicht verifiziert

Bemerkungen:
________________________________________
________________________________________

═══════════════════════════════════════════════════════════════

21.3 Langzeitarchivierung

Empfohlene Medien für Langzeitarchivierung:

• M-DISC — 1000+ Jahre haltbar (theoretisch)
• LTO-Tape — 30+ Jahre, industriestandard
• Mehrere HDDs — An verschiedenen Orten
• Cold Storage — Cloud-Archiv (verschlüsselt!)

22.1 Klassifikation von Schäden

22.2 Erste-Hilfe-Protokoll

1. Strom aus — Sofort bei Klickgeräuschen
2. Nicht nochmal versuchen — Jeder Versuch verschlimmert
3. Diagnose — SMART lesen wenn möglich
4. Entscheidung — Selbst oder Profi?
5. Wenn selbst — ddrescue mit konservativen Settings

22.3 ddrescue für schwer beschädigte Medien

# Phase 1: Nur schnell lesbare Bereiche
ddrescue -f -n -T 5s /dev/sdX image.raw log.map

# Phase 2: Vorsichtige Retries
ddrescue -d -r1 -T 10s /dev/sdX image.raw log.map

# Phase 3: Reverse (bei Head-Problemen)
ddrescue -R -r1 /dev/sdX image.raw log.map

Parameter erklärt:

• -T 5s — Timeout nach 5 Sekunden pro Sektor
• -r1 — Nur 1 Retry pro Block
• -R — Reverse (rückwärts lesen)

22.4 Temperatur-Management

22.5 Wann zum Profi?

• Klick-Geräusche (Head Crash)
• Kratzen (Plattenoberfläche beschädigt)
• Geruch (verbrannte Elektronik)
• Wasser-/Brandschaden
• Verschlüsselte SSD ohne Key

23.1 Grundprinzip des File Carving

File Carving sucht nach:

• Magic Bytes — Dateianfang-Signaturen
• Footer — Dateiende-Marker
• Strukturen — Interne Muster

23.2 PhotoRec — Das Standard-Carving-Tool

photorec /d /evidence/carved /evidence/image.raw

PhotoRec erkennt über 480 Dateiformate automatisch.

23.3 Scalpel — Konfigurierbar

scalpel -c /etc/scalpel/scalpel.conf -o /evidence/carved /evidence/image.raw

Beispiel-Konfiguration für spezifische Dateitypen:

# /etc/scalpel/scalpel.conf
jpg     y   20000000    \xff\xd8\xff    \xff\xd9
png     y   20000000    \x89PNG         IEND
pdf     y   50000000    %PDF            %%EOF

23.4 Foremost — Schnell und einfach

foremost -t jpeg,png,pdf -i /evidence/image.raw -o /evidence/carved

23.5 Video-Fragment-Recovery

Videos sind besonders schwierig:

• Fragmentiert auf der Platte
• Komplexe Container-Strukturen
• Fehlende Index-Atome

# Benötigt eine "gute" Referenz-Datei
untrunc good_reference.mp4 broken_video.mp4

24.1 Wallet-Arten

24.2 Systematische Wallet-Suche

find /mnt/image -name "wallet.dat" -type f 2>/dev/null

grep -RiaE "(seed|mnemonic|recovery).{0,20}(phrase|words)" /mnt/image 2>/dev/null

grep -RoaE "\b[13][a-km-zA-HJ-NP-Z1-9]{25,34}\b" /mnt/image 2>/dev/null

grep -RoaE "\b0x[a-fA-F0-9]{40}\b" /mnt/image 2>/dev/null

24.3 Browser-Extension-Daten

MetaMask und andere Browser-Wallets speichern in:

# Chrome
~/.config/google-chrome/Default/Local Extension Settings/nkbihfbeogaeaoehlefnkodbefgpgknn/

# Firefox
~/.mozilla/firefox/*.default/storage/default/

# Brave
~/.config/BraveSoftware/Brave-Browser/Default/Local Extension Settings/

24.4 Carving für Krypto-Daten

strings -n 12 /evidence/image.raw | \
    grep -iE "(mnemonic|seed phrase|wallet|bitcoin|ethereum|ledger|trezor)" > crypto_hits.txt

24.5 BIP39 Seed-Wörter erkennen

Die 2048 BIP39-Wörter können als Suchmuster dienen:

# Bekannte Seed-Anfänge suchen
grep -RiaE "\b(abandon|ability|able|about|above)\b.{0,100}\b(abandon|ability|able|about|above)\b" /mnt/image

25.1 Das Master-Automatisierungsskript

#!/bin/bash
# ═══════════════════════════════════════════════════════════════════════════
# FORENSIC MASTER AUTOMATION v1.0
# Vollständiger Workflow: Device → Image → Sort → Archive → Report
# ═══════════════════════════════════════════════════════════════════════════

set -euo pipefail

# ─── KONFIGURATION ────────────────────────────────────────────────────────
CASE_ID="${1:-CASE-$(date +%Y%m%d-%H%M%S)}"
DEVICE="${2:-/dev/sdb}"
WORKDIR="/evidence/$CASE_ID"
ANALYST="$(whoami)"

# ─── FARBEN ───────────────────────────────────────────────────────────────
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m'

log() { echo -e "${BLUE}[$(date '+%H:%M:%S')]${NC} $*"; }
success() { echo -e "${GREEN}[✓]${NC} $*"; }
warn() { echo -e "${YELLOW}[!]${NC} $*"; }
error() { echo -e "${RED}[✗]${NC} $*"; exit 1; }

# ─── VERZEICHNISSE ────────────────────────────────────────────────────────
log "Erstelle Arbeitsverzeichnisse..."
mkdir -p "$WORKDIR"/{images,sorted,logs,hashes,reports}

# ─── PHASE 1: VORBEREITUNG ────────────────────────────────────────────────
log "═══════════════════════════════════════════════════════════════"
log "PHASE 1: Vorbereitung"
log "═══════════════════════════════════════════════════════════════"

# Device prüfen
[[ -b "$DEVICE" ]] || error "Device $DEVICE nicht gefunden"

# SMART auslesen
log "Lese SMART-Daten..."
smartctl -a "$DEVICE" > "$WORKDIR/logs/smart_before.txt" 2>&1 || warn "SMART nicht verfügbar"

# Geräteinfo
log "Dokumentiere Geräteinformationen..."
{
    echo "Case-ID: $CASE_ID"
    echo "Analyst: $ANALYST"
    echo "Datum: $(date -Is)"
    echo "Device: $DEVICE"
    echo "Seriennummer: $(smartctl -i "$DEVICE" | grep -i serial || echo 'N/A')"
    echo "Modell: $(smartctl -i "$DEVICE" | grep -i "Device Model" || echo 'N/A')"
    echo "Kapazität: $(blockdev --getsize64 "$DEVICE" | numfmt --to=iec)"
} > "$WORKDIR/logs/device_info.txt"

success "Vorbereitung abgeschlossen"

# ─── PHASE 2: IMAGING ─────────────────────────────────────────────────────
log "═══════════════════════════════════════════════════════════════"
log "PHASE 2: Imaging mit ddrescue"
log "═══════════════════════════════════════════════════════════════"

IMAGE="$WORKDIR/images/disk.raw"
IMGLOG="$WORKDIR/logs/ddrescue.log"

log "Phase 2.1: Schnelles Lesen..."
ddrescue -f -n "$DEVICE" "$IMAGE" "$IMGLOG"

log "Phase 2.2: Retries..."
ddrescue -d -r3 "$DEVICE" "$IMAGE" "$IMGLOG"

log "Phase 2.3: Reverse Pass..."
ddrescue -R -r2 "$DEVICE" "$IMAGE" "$IMGLOG"

# Image-Hash
log "Erstelle Image-Hash..."
sha256sum "$IMAGE" > "$WORKDIR/hashes/image.sha256"

success "Imaging abgeschlossen"

# ─── PHASE 3: MOUNT & ANALYSE ─────────────────────────────────────────────
log "═══════════════════════════════════════════════════════════════"
log "PHASE 3: Mount & Analyse"
log "═══════════════════════════════════════════════════════════════"

MOUNTPOINT="/mnt/$CASE_ID"
mkdir -p "$MOUNTPOINT"

# Loop-Device erstellen
LOOPDEV=$(losetup -f --show "$IMAGE")
kpartx -av "$LOOPDEV" || true

# Versuche zu mounten
for part in /dev/mapper/$(basename "$LOOPDEV")p*; do
    [[ -b "$part" ]] || continue
    mount -o ro "$part" "$MOUNTPOINT" 2>/dev/null && break
done

if mountpoint -q "$MOUNTPOINT"; then
    success "Image gemountet"
    
    # Statistiken
    log "Erstelle Statistiken..."
    {
        echo "Dateien gesamt: $(find "$MOUNTPOINT" -type f | wc -l)"
        echo "Verzeichnisse: $(find "$MOUNTPOINT" -type d | wc -l)"
        echo "Gesamtgröße: $(du -sh "$MOUNTPOINT" | cut -f1)"
    } > "$WORKDIR/logs/statistics.txt"
else
    warn "Mount fehlgeschlagen - nutze alternative Methoden"
fi

# ─── PHASE 4: SORTIERUNG ──────────────────────────────────────────────────
log "═══════════════════════════════════════════════════════════════"
log "PHASE 4: MIME-basierte Sortierung"
log "═══════════════════════════════════════════════════════════════"

# (Hier das Sortierskript aus Kapitel 16 aufrufen)
# ./forensic-sort.sh "$MOUNTPOINT" "$WORKDIR/sorted"

success "Sortierung abgeschlossen"

# ─── PHASE 5: ARCHIVIERUNG ────────────────────────────────────────────────
log "═══════════════════════════════════════════════════════════════"
log "PHASE 5: Archivierung"
log "═══════════════════════════════════════════════════════════════"

ARCHIVE="$WORKDIR/${CASE_ID}_archive.tar.zst"

log "Erstelle Archiv..."
tar --zstd -cvf "$ARCHIVE" -C "$WORKDIR" sorted/

log "Erstelle Archiv-Hash..."
sha256sum "$ARCHIVE" > "$WORKDIR/hashes/archive.sha256"

success "Archivierung abgeschlossen"

# ─── PHASE 6: CLEANUP ─────────────────────────────────────────────────────
log "═══════════════════════════════════════════════════════════════"
log "PHASE 6: Cleanup"
log "═══════════════════════════════════════════════════════════════"

umount "$MOUNTPOINT" 2>/dev/null || true
kpartx -dv "$LOOPDEV" 2>/dev/null || true
losetup -d "$LOOPDEV" 2>/dev/null || true
rmdir "$MOUNTPOINT" 2>/dev/null || true

success "Cleanup abgeschlossen"

# ─── ABSCHLUSS ────────────────────────────────────────────────────────────
log "═══════════════════════════════════════════════════════════════"
echo -e "${GREEN}"
echo "╔═══════════════════════════════════════════════════════════════╗"
echo "║           FORENSISCHE VERARBEITUNG ABGESCHLOSSEN              ║"
echo "╠═══════════════════════════════════════════════════════════════╣"
echo "║  Case-ID:  $CASE_ID"
echo "║  Workdir:  $WORKDIR"
echo "║  Image:    $IMAGE"
echo "║  Archiv:   $ARCHIVE"
echo "╚═══════════════════════════════════════════════════════════════╝"
echo -e "${NC}"

25.2 Verwendung

sudo ./forensic-master.sh CASE-2025-001 /dev/sdb

26.1 Imaging-Probleme

26.2 Mount-Probleme

26.3 Sortier-Probleme

26.4 Performance-Optimierung

• RAM-Disk für Logs — mount -t tmpfs -o size=1G tmpfs /tmp/logs
• Parallelisierung — GNU parallel für find/xargs
• SSD als Ziel — Schnelleres Schreiben
• ionice — I/O-Priorität setzen

28.1 MIME-Typen Schnellreferenz

28.2 Magic Bytes (Dateisignaturen)

28.3 SMART-Attribute

29.1 Imaging & Datenrettung

# ddrescue — Imaging
ddrescue -f -n /dev/sdX image.raw log.map          # Phase 1: Schnell
ddrescue -d -r3 /dev/sdX image.raw log.map         # Phase 2: Retries
ddrescue -R -r2 /dev/sdX image.raw log.map         # Phase 3: Reverse

# Hashing
sha256sum /dev/sdX > original.sha256               # Original hashen
sha256sum image.raw > image.sha256                 # Image hashen
sha256sum -c manifest.sha256                       # Verifizieren

# SMART
smartctl -a /dev/sdX                               # Alle SMART-Daten
smartctl -H /dev/sdX                               # Health Status

29.2 Mount & Analyse

# Image mounten
mount -o ro,loop image.raw /mnt/image              # Einfach
losetup -f --show image.raw                        # Loop-Device
kpartx -av /dev/loop0                              # Partitionen
mount -o ro /dev/mapper/loop0p1 /mnt/image         # Partition mounten

# Analyse
fdisk -l image.raw                                 # Partitionen anzeigen
file --mime-type datei                             # MIME-Typ
exiftool bild.jpg                                  # EXIF-Daten
strings -n 8 image.raw | grep -i password          # Strings suchen

29.3 Suche & Statistik

# Dateien finden
find /mnt -type f | wc -l                          # Anzahl Dateien
find /mnt -type f -size +1G                        # Große Dateien
find /mnt -name "*.jpg" -type f                    # Nach Name
find /mnt -type f -mtime -7                        # Letzte 7 Tage

# MIME-Statistik
find /mnt -type f -print0 | xargs -0 file --mime-type -b | sort | uniq -c | sort -nr

# Timeline
find /mnt -type f -printf "%T+ %p\n" | sort > timeline.txt

29.4 Sortierung & Archivierung

# Kodierung reparieren
convmv -f latin1 -t utf8 --notest -r /mnt          # Latin-1 → UTF-8
convmv -f utf8 -t utf8 --nfc --notest -r /mnt      # NFD → NFC

# Duplikate
fdupes -r /mnt > duplicates.txt                    # Duplikate finden

# Archivierung
tar --zstd -cvf archiv.tar.zst /evidence/sorted    # Zstandard
tar -cvJf archiv.tar.xz /evidence/sorted           # XZ
tar -cvzf archiv.tar.gz /evidence/sorted           # Gzip

29.5 Recovery-Tools

# Partitionen wiederherstellen
testdisk /dev/sdX                                  # Interaktiv

# File Carving
photorec /d /recovery image.raw                    # PhotoRec
foremost -t jpeg,png,pdf -i image.raw -o /carved   # Foremost
scalpel -c scalpel.conf -o /carved image.raw       # Scalpel

30.1 Hauptworkflow

┌─────────────────────────────────────────────────────────────────┐
│                    FORENSISCHER HAUPTWORKFLOW                    │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
              ┌───────────────────────────────┐
              │  1. VORBEREITUNG              │
              │  • Hardware prüfen            │
              │  • Write-Blocker              │
              │  • Dokumentation starten      │
              └───────────────────────────────┘
                              │
                              ▼
              ┌───────────────────────────────┐
              │  2. IMAGING                   │
              │  • ddrescue Phase 1-3         │
              │  • Hash des Originals         │
              │  • Hash des Images            │
              │  • Vergleich                  │
              └───────────────────────────────┘
                              │
                              ▼
              ┌───────────────────────────────┐
              │  3. ANALYSE                   │
              │  • Image mounten              │
              │  • MIME-Analyse               │
              │  • Timeline erstellen         │
              │  • Kodierung prüfen           │
              └───────────────────────────────┘
                              │
                              ▼
              ┌───────────────────────────────┐
              │  4. SORTIERUNG                │
              │  • MIME-basierte Sortierung   │
              │  • Duplikaterkennung          │
              │  • Manifest erstellen         │
              └───────────────────────────────┘
                              │
                              ▼
              ┌───────────────────────────────┐
              │  5. ARCHIVIERUNG              │
              │  • Komprimiertes Archiv       │
              │  • Prüfsummen                 │
              │  • Signatur                   │
              └───────────────────────────────┘
                              │
                              ▼
              ┌───────────────────────────────┐
              │  6. ABSCHLUSS                 │
              │  • Bericht erstellen          │
              │  • Übergabeprotokoll          │
              │  • Langzeitarchivierung       │
              └───────────────────────────────┘

30.2 ddrescue-Entscheidungsbaum

                    ┌─────────────────────┐
                    │  Medium anschließen │
                    └──────────┬──────────┘
                               │
                               ▼
                    ┌─────────────────────┐
              ┌─────│ Wird es erkannt?    │─────┐
              │ NEIN└─────────────────────┘ JA  │
              │                                 │
              ▼                                 ▼
    ┌─────────────────┐              ┌─────────────────┐
    │ Kabel prüfen    │              │ SMART auslesen  │
    │ Port wechseln   │              └────────┬────────┘
    │ → Profi?        │                       │
    └─────────────────┘                       ▼
                                   ┌─────────────────────┐
                             ┌─────│ SMART OK?           │─────┐
                             │ NEIN└─────────────────────┘ JA  │
                             │                                 │
                             ▼                                 ▼
                   ┌─────────────────┐            ┌─────────────────┐
                   │ ddrescue        │            │ ddrescue        │
                   │ konservativ     │            │ normal          │
                   │ (-n -T 5s)      │            │ (-f -n)         │
                   └─────────────────┘            └─────────────────┘

31.1 Vor dem Imaging

• Write-Blocker angeschlossen
• Zielmedium groß genug
• Zielmedium formatiert/leer
• Dokumentation vorbereitet
• Case-ID vergeben
• SMART-Daten gesichert
• Seriennummer dokumentiert
• Fotos des Originals gemacht

31.2 Nach dem Imaging

• Hash des Originals erstellt
• Hash des Images erstellt
• Hashes verglichen und identisch
• ddrescue-Log gesichert
• Fehlerrate dokumentiert
• Image erfolgreich gemountet
• Dateisystem lesbar

31.3 Vor der Übergabe

• Alle Hashes dokumentiert
• Manifest vollständig
• Archiv erstellt
• Archiv-Hash erstellt
• Bericht fertiggestellt
• Übergabeprotokoll vorbereitet
• Backup an zweitem Ort
• Original versiegelt

31.4 Qualitätskontrolle

• Alle Befehle dokumentiert
• Alle Fehler geloggt
• Prozess reproduzierbar
• Zweite Person gegenlesen lassen
• Standards eingehalten (ACPO/NIST)

32.1 Case-Dokumentation

═══════════════════════════════════════════════════════════════
                    CASE DOCUMENTATION
═══════════════════════════════════════════════════════════════

Case-ID:        _______________________
Datum:          _______________________
Analyst:        _______________________

QUELLE
──────────────────────────────────────────────────────────────
Gerätetyp:      [ ] HDD  [ ] SSD  [ ] USB  [ ] SD  [ ] Andere
Hersteller:     _______________________
Modell:         _______________________
Seriennummer:   _______________________
Kapazität:      _______________________
Zustand:        _______________________

IMAGING
──────────────────────────────────────────────────────────────
Tool:           _______________________
Version:        _______________________
Start:          _______________________
Ende:           _______________________
Dauer:          _______________________

Original-Hash:  SHA256: ________________________________
Image-Hash:     SHA256: ________________________________
Status:         [ ] Identisch  [ ] Abweichend

Fehlerrate:     _______ Sektoren von _______ (______%)

BEMERKUNGEN
──────────────────────────────────────────────────────────────
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________

Unterschrift:   _______________________  Datum: _____________
═══════════════════════════════════════════════════════════════

33.1 Standards

• ACPO Good Practice Guide — Good Practice Guide for Digital Evidence
• RFC 3227 — Guidelines for Evidence Collection and Archiving
• NIST SP 800-86 — Guide to Integrating Forensic Techniques
• ISO/IEC 27037 — Guidelines for identification, collection, acquisition and preservation of digital evidence

33.2 Tool-Dokumentation

• GNU ddrescue Manual — gnu.org/software/ddrescue/manual/
• The Sleuth Kit — sleuthkit.org/sleuthkit/docs.php
• PhotoRec — cgsecurity.org/wiki/PhotoRec
• ExifTool — exiftool.org

33.3 Weiterführende Literatur

• File System Forensic Analysis — Brian Carrier
• The Art of Memory Forensics — Ligh, Case, Levy, Walters
• Digital Forensics with Kali Linux — Shiva V. N. Parasram
• Practical Forensic Imaging — Bruce Nikkel

33.4 Online-Ressourcen

• SANS Digital Forensics — sans.org/digital-forensics-incident-response/
• Forensics Wiki — forensicswiki.xyz
• DFIR Training — dfir.training