Analysieren von Prefetch-Dateien für die Ausführungshistorie
Wann verwenden
- Zur Bestimmung, welche Programme auf einem Windows-System ausgeführt wurden und wann
- Bei Malware-Untersuchungen, um die Ausführung verdächtiger Binaries zu bestätigen
- Zur Erstellung einer Zeitleiste der Anwendungsnutzung während eines Vorfalls
- Zur Korrelation der Programmausführung mit anderen forensischen Artefakten
- Zur Identifizierung von Anti-Forensik-Werkzeugen oder nicht autorisierter Software, die ausgeführt wurde
Voraussetzungen
- Zugriff auf das Windows Prefetch-Verzeichnis (C:\Windows\Prefetch) aus einem forensischen Image
- PECmd (Eric Zimmerman), WinPrefetchView oder python-prefetch Parser
- Verständnis des Prefetch-Dateiformats (Versionen 17, 23, 26, 30)
- Windows-System mit aktiviertem Prefetch (Standardeinstellung auf Client-BS, deaktiviert auf Servern)
- Kenntnis der Prefetch-Namenskonventionen (APPNAME-HASH.pf)
Arbeitsablauf
Schritt 1: Prefetch-Dateien aus dem forensischen Image extrahieren
# Forensisches Image mounten
mount -o ro,loop,offset=$((2048*512)) /cases/case-2024-001/images/evidence.dd /mnt/evidence
# Alle Prefetch-Dateien kopieren
mkdir -p /cases/case-2024-001/prefetch/
cp /mnt/evidence/Windows/Prefetch/*.pf /cases/case-2024-001/prefetch/
# Prefetch-Dateien zählen und auflisten
ls -la /cases/case-2024-001/prefetch/ | wc -l
ls -la /cases/case-2024-001/prefetch/ | head -30
# Alle Prefetch-Dateien zur Integritätssicherung hashen
sha256sum /cases/case-2024-001/prefetch/*.pf > /cases/case-2024-001/prefetch/pf_hashes.txt
# Hinweis: Das Prefetch-Dateinamenformat ist AUSFÜHRBARENAME-XXXXXXXX.pf
# Der Hash (XXXXXXXX) basiert auf dem Ausführungspfad
# Das gleiche Programm aus unterschiedlichen Pfaden erzeugt verschiedene Prefetch-Dateien
Schritt 2: Prefetch-Dateien mit PECmd parsen
# Verwendung von Eric Zimmermans PECmd (Windows oder via Mono/Wine auf Linux)
# Download von https://ericzimmerman.github.io/
# Einzelne Prefetch-Datei parsen
PECmd.exe -f "C:\cases\prefetch\POWERSHELL.EXE-A]B2C3D4.pf"
# Alle Prefetch-Dateien parsen und als CSV ausgeben
PECmd.exe -d "C:\cases\prefetch\" --csv "C:\cases\analysis\" --csvf prefetch_results.csv
# Mit JSON-Ausgabe parsen
PECmd.exe -d "C:\cases\prefetch\" --json "C:\cases\analysis\" --jsonf prefetch_results.json
# Die Ausgabe enthält für jede Datei:
# - Programmname und -pfad
# - Anzahl der Ausführungen
# - Letzte Ausführungszeit (bis zu 8 Zeitstempel unter Windows 10)
# - Während der Ausführung referenzierte Dateien und Verzeichnisse
# - Volumeninformationen (Seriennummer, Erstellungsdatum)
# - Erstellungszeit der Prefetch-Datei
Schritt 3: Mit Python für Linux-basierte Analyse parsen
pip install prefetch
python3 << 'PYEOF'
import os
import json
from datetime import datetime
# Prefetch-Dateien mit Python parsen
import struct
def parse_prefetch(filepath):
"""Parst eine Windows Prefetch-Datei."""
with open(filepath, 'rb') as f:
data = f.read()
# Auf MAM-komprimiertes Format prüfen (Windows 10)
if data[:4] == b'MAM\x04':
import lznt1 # oder DecompressBuffer verwenden
# Windows 10 Prefetch-Dateien sind komprimiert
print(f" [Komprimiertes Win10-Format - PECmd für vollständige Analyse verwenden]")
return None
# Version 17 (XP), 23 (Vista/7), 26 (8.1), 30 (10)
version = struct.unpack('<I', data[0:4])[0]
signature = data[4:8]
if signature != b'SCCA':
print(f" Ungültige Prefetch-Signatur")
return None
file_size = struct.unpack('<I', data[8:12])[0]
exec_name = data[16:76].decode('utf-16-le').strip('\x00')
run_count = struct.unpack('<I', data[208:212])[0] if version >= 23 else struct.unpack('<I', data[144:148])[0]
result = {
'version': version,
'executable': exec_name,
'file_size': file_size,
'run_count': run_count,
}
# Letzte Ausführungszeitstempel extrahieren
if version == 23: # Vista/7 - 1 Zeitstempel
ts = struct.unpack('<Q', data[128:136])[0]
result['last_run'] = filetime_to_datetime(ts)
elif version >= 26: # Win8+ - bis zu 8 Zeitstempel
timestamps = []
for i in range(8):
ts = struct.unpack('<Q', data[128+i*8:136+i*8])[0]
if ts > 0:
timestamps.append(filetime_to_datetime(ts))
result['last_run_times'] = timestamps
return result
def filetime_to_datetime(ft):
"""Konvertiert Windows FILETIME in einen Datums-String."""
if ft == 0:
return None
timestamp = (ft - 116444736000000000) / 10000000
try:
return datetime.utcfromtimestamp(timestamp).strftime('%Y-%m-%d %H:%M:%S UTC')
except (OSError, ValueError):
return None
# Alle Prefetch-Dateien verarbeiten
prefetch_dir = '/cases/case-2024-001/prefetch/'
results = []
for filename in sorted(os.listdir(prefetch_dir)):
if filename.lower().endswith('.pf'):
filepath = os.path.join(prefetch_dir, filename)
print(f"\n=== {filename} ===")
result = parse_prefetch(filepath)
if result:
print(f" Programm: {result['executable']}")
print(f" Ausführungen: {result['run_count']}")
if 'last_run' in result:
print(f" Letzte Ausf.: {result['last_run']}")
elif 'last_run_times' in result:
for i, ts in enumerate(result['last_run_times']):
print(f" Ausf.-Zeit {i+1}: {ts}")
results.append(result)
# Ergebnisse speichern
with open('/cases/case-2024-001/analysis/prefetch_analysis.json', 'w') as f:
json.dump(results, f, indent=2)
PYEOF
Schritt 4: Nachweis verdächtiger Ausführungen identifizieren
# Nach bekannten bösartigen Toolnamen in Prefetch suchen
ls /cases/case-2024-001/prefetch/ | grep -iE \
'(MIMIKATZ|PSEXEC|WMIC|COBALT|BEACON|PWDUMP|PROCDUMP|LAZAGNE|RUBEUS|BLOODHOUND|SHARPHOUND|CERTUTIL|BITSADMIN)'
# Nach Skript-Interpretern suchen (potenziell schädliche Ausführung)
ls /cases/case-2024-001/prefetch/ | grep -iE \
'(POWERSHELL|CMD\.EXE|WSCRIPT|CSCRIPT|MSHTA|REGSVR32|RUNDLL32|MSIEXEC)'
# Nach Remote-Zugriffstools suchen
ls /cases/case-2024-001/prefetch/ | grep -iE \
'(TEAMVIEWER|ANYDESK|LOGMEIN|VNC|SPLASHTOP|SCREENCONNECT|AMMYY)'
# Nach Datenexfiltrations-Tools suchen
ls /cases/case-2024-001/prefetch/ | grep -iE \
'(RAR|7Z|ZIP|RCLONE|MEGA|DROPBOX|ONEDRIVE|GDRIVE|FTP|CURL|WGET)'
# Kürzlich erstellte Prefetch-Dateien finden (neueste ausgeführte Programme)
ls -lt /cases/case-2024-001/prefetch/ | head -20
# Zur Bestätigung mit Shimcache und Amcache abgleichen
# Vorhandensein einer Prefetch-Datei = Programm wurde mindestens einmal ausgeführt
Schritt 5: Ausführungszeitleiste erstellen
# Zeitleiste aus Prefetch-Daten erstellen
python3 << 'PYEOF'
import json
import csv
with open('/cases/case-2024-001/analysis/prefetch_analysis.json') as f:
data = json.load(f)
timeline = []
for entry in data:
if 'last_run_times' in entry:
for ts in entry['last_run_times']:
if ts:
timeline.append({
'timestamp': ts,
'executable': entry['executable'],
'run_count': entry['run_count'],
'source': 'Prefetch'
})
elif 'last_run' in entry and entry['last_run']:
timeline.append({
'timestamp': entry['last_run'],
'executable': entry['executable'],
'run_count': entry['run_count'],
'source': 'Prefetch'
})
# Chronologisch sortieren
timeline.sort(key=lambda x: x['timestamp'])
# Zeitleiste als CSV schreiben
with open('/cases/case-2024-001/analysis/execution_timeline.csv', 'w', newline='') as f:
writer = csv.DictWriter(f, fieldnames=['timestamp', 'executable', 'run_count', 'source'])
writer.writeheader()
writer.writerows(timeline)
# Verdächtiges Zeitfenster ausgeben
for entry in timeline:
if '2024-01-15' in entry['timestamp'] or '2024-01-16' in entry['timestamp']:
print(f" {entry['timestamp']} | {entry['executable']} (x{entry['run_count']})")
PYEOF
Schlüsselkonzepte
| Konzept | Beschreibung |
|---|---|
| Prefetch | Windows-Leistungsoptimierung, die Anwendungsdaten vorlädt und die Ausführung nachverfolgt |
| SCCA-Signatur | Magische Bytes, die eine gültige Prefetch-Datei identifizieren |
| Pfad-Hash | CRC-basierter Hash des ausführbaren Pfads, der Teil des .pf-Dateinamens ist |
| Ausführungsanzahl | Anzahl der Starts des Programms (kann überlaufen) |
| Letzte Ausführungszeitstempel | Windows 8+ speichert bis zu 8 der letzten Ausführungszeitpunkte |
| Referenzierte Dateien | Liste der Dateien und Verzeichnisse, die in den ersten 10 Sekunden der Ausführung aufgerufen wurden |
| Volumeninformationen | Laufwerksseriennummer und Erstellungsdatum zur Identifizierung des Quellvolumens |
| MAM-Kompression | Windows 10 Prefetch-Dateien verwenden MAM4-Kompression, die vor der Analyse dekomprimiert werden muss |
Tools und Systeme
| Tool | Zweck |
|---|---|
| PECmd | Eric Zimmermans Prefetch-Parser mit CSV/JSON-Ausgabe |
| WinPrefetchView | NirSoft-GUI-Werkzeug zum Anzeigen von Prefetch-Dateien |
| python-prefetch | Python-Bibliothek zum Parsen von Prefetch-Dateien |
| Prefetch Hash Calculator | Tool zur Berechnung des erwarteten Hashs aus ausführbaren Pfaden |
| KAPE | Automatisierte Artefaktsammlung inklusive Prefetch |
| Autopsy | Forensik-Plattform mit Prefetch-Analysemodul |
| Plaso/log2timeline | Super-Timeline-Tool, das einen Prefetch-Parser enthält |
| Velociraptor | Endpunkt-Agent mit Prefetch-Sammel- und Analyse-Artefakten |
Häufige Szenarien
Szenario 1: Bestätigung der Malware-Ausführung Das Prefetch-Verzeichnis nach dem Malware-Programmnamen durchsuchen, die Ausführung über die Existenz der Prefetch-Datei bestätigen, Ausführungsanzahl und letzte Ausführungszeit extrahieren, referenzierte DLLs identifizieren, um das Malware-Verhalten zu verstehen, mit Registry-Autorun-Einträgen korrelieren.
Szenario 2: Zeitleiste der Nutzung von Angreifer-Tools Prefetch-Dateien für PsExec, Mimikatz, BloodHound und andere Angreifer-Tools identifizieren, eine chronologische Zeitleiste der Tool-Ausführung erstellen, die Reihenfolge des Angriffs bestimmen (Aufklärung, Credential Theft, Laterale Bewegung), Zeitstempel mit Netzwerkverbindungsprotokollen abgleichen.
Szenario 3: Daten-Staging und Exfiltration Nach Prefetch-Einträgen von Komprimierungstools (7z, WinRAR, zip) suchen, Ausführung von Dateiübertragungsdienstprogrammen (rclone, FTP-Clients) identifizieren, auf Ausführung von Cloud-Speicher-Clients prüfen, zeitliche Einordnung von Daten-Staging und -Transfer.
Szenario 4: Anti-Forensik-Erkennung Auf Ausführung bekannter Anti-Forensik-Werkzeuge (CCleaner, Eraser, SDelete) prüfen, feststellen, ob das Prefetch-Verzeichnis kürzlich geleert wurde (weniger Dateien als für ein aktives System zu erwarten), Zeitstempel der Ausführung von Anti-Forensik-Tools im Verhältnis zu anderen Beweisen notieren.
Ausgabeformat
Prefetch-Analyse-Zusammenfassung:
System: Windows 10 Pro (Build 19041)
Prefetch-Dateien: 234
Analysezeitraum: Gesamte verfügbare Ausführungshistorie
Ausführungsstatistik:
Einzigartige ausführbare Programme: 234
Erste Ausführung: 2023-06-15 (Systeminstallation)
Letzte Ausführung: 2024-01-18 23:45 UTC
Verdächtige Ausführungen:
MIMIKATZ.EXE-5F2A3B1C.pf
Ausführungen: 3 | Letzte: 2024-01-16 02:30:15 UTC
PSEXEC.EXE-AD70946C.pf
Ausführungen: 7 | Letzte: 2024-01-16 02:45:30 UTC
RCLONE.EXE-1F3E5A2B.pf
Ausführungen: 2 | Letzte: 2024-01-17 03:15:00 UTC
POWERSHELL.EXE-022A1004.pf
Ausführungen: 145 | Letzte: 2024-01-18 14:00:00 UTC
Angriffszeitleiste (aus Prefetch):
2024-01-15 14:32 - POWERSHELL.EXE (Erstzugriff)
2024-01-16 02:30 - MIMIKATZ.EXE (Credential Theft)
2024-01-16 02:45 - PSEXEC.EXE (Laterale Bewegung)
2024-01-17 03:15 - RCLONE.EXE (Datenexfiltration)
Bericht: /cases/case-2024-001/analysis/execution_timeline.csv