Analyse von Ransomware-Verschlüsselungsmechanismen

Was macht Analyse von Ransomware-Verschlüsselungsmechanismen?

Wann verwenden

• Eine Ransomware-Infektion ist aufgetreten, und die Wiederherstellung erfordert das Verständnis des verwendeten Verschlüsselungsschemas.
• Bewertung, ob eine Entschlüsselung ohne Lösegeldzahlung möglich ist (Implementierungsfehler, bekannte Entschlüsselungstools).
• Reverse Engineering von Ransomware zur Identifizierung des Verschlüsselungsalgorithmus, der Schlüsselableitung und des Schlüsselspeichermechanismus.
• Entwicklung eines Entschlüsselungstools, wenn eine Schwachstelle in der kryptografischen Implementierung der Ransomware identifiziert wurde.
• Klassifizierung einer Ransomware-Probe anhand ihres Verschlüsselungsansatzes, um sie einer bekannten Familie zuzuordnen.

Nicht verwenden für Produktionsdaten-Wiederherstellungen, ohne zuvor die Entschlüsselungsmethode an Testkopien der verschlüsselten Dateien zu verifizieren.

Voraussetzungen

• Ghidra oder IDA Pro für das Reverse Engineering der Ransomware-Binärdatei.
• Python 3.8+ mit der Bibliothek pycryptodome zum Testen von Ver-/Entschlüsselungsroutinen.
• Beispielhafte verschlüsselte Dateien und deren entsprechende Klartext-Originale (known-plaintext pairs).
• Zugriff auf die Ransomware-Binärdatei (falls gepackt, entpackt).
• Vertrautheit mit symmetrischen (AES, ChaCha20) und asymmetrischen (RSA) kryptografischen Algorithmen.
• NoMoreRansom.org-Datenbank zur Überprüfung auf bestehende kostenlose Entschlüsselungstools.

Arbeitsablauf

Schritt 1: Identifiziere den Verschlüsselungsalgorithmus

Bestimme, welchen kryptografischen Algorithmus die Ransomware verwendet:

# Überprüfung auf Windows Crypto API-Nutzung in den Imports
import pefile

pe = pefile.PE("ransomware.exe")

crypto_apis = {
    "CryptAcquireContextA": "Windows CryptoAPI",
    "CryptAcquireContextW": "Windows CryptoAPI",
    "CryptGenKey": "Windows CryptoAPI - Schlüsselerzeugung",
    "CryptEncrypt": "Windows CryptoAPI - Verschlüsselung",
    "CryptImportKey": "Windows CryptoAPI - Schlüsselimport",
    "BCryptOpenAlgorithmProvider": "Windows CNG (moderne Kryptographie)",
    "BCryptEncrypt": "Windows CNG - Verschlüsselung",
    "BCryptGenerateKeyPair": "Windows CNG - asymmetrische Schlüsselerzeugung",
}

print("Crypto API Imports:")
for entry in pe.DIRECTORY_ENTRY_IMPORT:
    for imp in entry.imports:
        if imp.name and imp.name.decode() in crypto_apis:
            print(f"  {entry.dll.decode()} -> {imp.name.decode()}: {crypto_apis[imp.name.decode()]}")

Häufige Ransomware-Verschlüsselungsschemata:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
AES-256-CBC + RSA-2048:    Häufigste Hybrid-Implementierung (LockBit, REvil, Conti)
AES-256-CTR + RSA-4096:    Stream-Cipher-Modus-Variante (BlackCat/ALPHV)
ChaCha20 + RSA-4096:       Moderne Stream-Chiffre (Hive, Royal)
Salsa20 + ECDH:            Curve25519-Schlüsselaustausch (Babuk)
AES-128-ECB:               Schwacher Modus - potenzielle Entschlüsselung via known-plaintext
XOR-only:                  Triviale Verschlüsselung - immer wiederherstellbar
Eigener Algorithmus:       Enthält oft Implementierungsfehler

Schritt 2: Analysiere Schlüsselerzeugung und -verwaltung

Führe Reverse Engineering durch, um zu verstehen, wie Verschlüsselungsschlüssel erzeugt und gespeichert werden:

Schlüsselverwaltungsmuster in Ransomware:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. STARK (keine Wiederherstellung ohne Schlüssel möglich):
   - Pro-Datei AES-Schlüssel mit CryptGenRandom erzeugt
   - AES-Schlüssel mit eingebettetem RSA öffentlichen Schlüssel verschlüsselt
   - Verschlüsselter Schlüssel an jede Datei angehängt oder separat gespeichert
   - RSA privater Schlüssel nur auf dem C2-Server des Angreifers

2. SCHWACH (potenzielle Wiederherstellung):
   - AES-Schlüssel von vorhersagbarer Quelle abgeleitet (Zeitstempel, PID)
   - Gleicher AES-Schlüssel für alle Dateien (ein Schlüsselkompromiss = vollständige Wiederherstellung)
   - Schlüssel vor Beginn der Verschlüsselung an C2 übertragen (PCAP kann Schlüssel enthalten)
   - XOR mit kurzem, sich wiederholendem Schlüssel (brute-force fähig)
   - PRNG mit GetTickCount oder time() gespeist (eingeschränkter Schlüsselraum)

3. FEHLERHAFTE IMPLEMENTIERUNG:
   - ECB-Modus (bewahrt Klartextmuster)
   - Wiederverwendung des Initialisierungsvektors (IV) über Dateien hinweg
   - Schlüssel im Klartext im Speicher (aus Speicherabbild wiederherstellbar)
   - Teilweise Verschlüsselung (nur die ersten N Bytes verschlüsselt)

Schritt 3: Untersuche die Dateiverschlüsselungsroutine

Führe Reverse Engineering der Dateiverarbeitungslogik durch:

// Typischer Ransomware-Dateiverschlüsselungsablauf (dekompilierter Pseudo-Code aus Ghidra):

void encrypt_file(char *filepath) {
    // 1. Dateiendung gegen Zielliste prüfen
    if (!is_target_extension(filepath)) return;

    // 2. Pro-Datei AES-Schlüssel erzeugen (32 Bytes für AES-256)
    BYTE aes_key[32];
    CryptGenRandom(hProv, 32, aes_key);

    // 3. Zufälligen IV erzeugen (16 Bytes)
    BYTE iv[16];
    CryptGenRandom(hProv, 16, iv);

    // 4. Dateiinhalt lesen
    HANDLE hFile = CreateFile(filepath, GENERIC_READ, ...);
    BYTE *plaintext = read_entire_file(hFile);

    // 5. Mit AES-256-CBC verschlüsseln
    aes_cbc_encrypt(plaintext, file_size, aes_key, iv);

    // 6. AES-Schlüssel mit RSA öffentlichem Schlüssel verschlüsseln
    BYTE encrypted_key[256];  // RSA-2048 Ausgabe
    rsa_encrypt(aes_key, 32, rsa_pubkey, encrypted_key);

    // 7. Schreiben: verschlüsselte_Daten + verschlüsselter_Schlüssel + IV in Datei
    write_file(filepath, encrypted_data, encrypted_key, iv);

    // 8. Datei mit Ransomware-Endung umbenennen
    rename_file(filepath, strcat(filepath, ".locked"));
}

Schritt 4: Überprüfe auf kryptografische Schwachstellen

Teste die Implementierung auf ausnutzbare Fehler:

from Crypto.Cipher import AES
import os
import struct

# Test 1: Prüfe, ob derselbe Schlüssel für mehrere Dateien verwendet wird
# Vergleiche verschlüsselte Versionen bekannter Dateien
def check_key_reuse(file1_enc, file2_enc):
    with open(file1_enc, "rb") as f:
        data1 = f.read()
    with open(file2_enc, "rb") as f:
        data2 = f.read()

    # IVs extrahieren (Position hängt von der Ransomware-Familie ab)
    # Wenn IVs gleich sind und Dateien gemeinsame verschlüsselte Blöcke haben -> gleicher Schlüssel
    iv1 = data1[-16:]  # Beispiel: IV am Ende
    iv2 = data2[-16:]
    if iv1 == iv2:
        print("[!] Gleicher IV erkannt - Schlüsselwiederverwendung wahrscheinlich")

# Test 2: Prüfe auf vorhersagbare Schlüsselableitung
# Wenn Schlüssel von einem Zeitstempel abgeleitet ist, iteriere mögliche Werte
def brute_force_timestamp_key(encrypted_file, known_header, timestamp_range):
    with open(encrypted_file, "rb") as f:
        encrypted_data = f.read()

    for ts in timestamp_range:
        # Schlüssel wie die Ransomware ableiten
        import hashlib
        key = hashlib.sha256(str(ts).encode()).digest()
        iv = encrypted_data[-16:]
        cipher = AES.new(key, AES.MODE_CBC, iv)
        decrypted = cipher.decrypt(encrypted_data[:16])

        if decrypted[:len(known_header)] == known_header:
            print(f"[!] Schlüssel gefunden! Zeitstempel: {ts}")
            return key

    return None

# Test 3: Prüfe auf ECB-Modus (Musterbewahrung)
def check_ecb_mode(encrypted_file):
    with open(encrypted_file, "rb") as f:
        data = f.read()
    # ECB erzeugt identischen Chiffrattext für identische Klartextblöcke
    blocks = [data[i:i+16] for i in range(0, len(data), 16)]
    unique = len(set(blocks))
    total = len(blocks)
    if unique < total * 0.95:
        print(f"[!] ECB-Modus wahrscheinlich: {total-unique} doppelte Blöcke von {total}")

Schritt 5: Versuche die Schlüsselsammlung

Nutze identifizierte Schwachstellen zur Schlüsselsammlung:

# Wiederherstellungsmethode 1: Schlüssel aus Speicherabbild extrahieren
# Volatility-Plugin zum Scannen nach AES-Schlüsselplänen
# vol3 -f memory.dmp windows.yarascan --yara-rule "aes_key_schedule"

# Wiederherstellungsmethode 2: Known-Plaintext-Angriff (schwache Algorithmen)
def xor_key_recovery(encrypted_file, known_plaintext):
    """XOR-Schlüssel aus bekanntem Klartext-Chiffrat-Paar wiederherstellen"""
    with open(encrypted_file, "rb") as f:
        ciphertext = f.read()

    key = bytes(c ^ p for c, p in zip(ciphertext, known_plaintext))
    # Finde wiederholte Schlüssellänge
    for key_len in range(1, 256):
        candidate = key[:key_len]
        if all(key[i] == candidate[i % key_len] for i in range(min(len(key), key_len * 4))):
            print(f"XOR-Schlüssel (Länge {key_len}): {candidate.hex()}")
            return candidate
    return None

# Wiederherstellungsmethode 3: Prüfe NoMoreRansom auf vorhandene Entschlüsselungstools
# https://www.nomoreransom.org/en/decryption-tools.html

Schritt 6: Dokumentiere die Verschlüsselungsanalyse

Fasse die Ergebnisse in einem strukturierten Bericht zusammen:

Die Analyse sollte dokumentieren:
- Identifizierter Algorithmus (AES, RSA, ChaCha20, benutzerdefiniert)
- Schlüsselgröße und Betriebsmodus (CBC, CTR, ECB, GCM)
- Methode der Schlüsselerzeugung (CSPRNG, vorhersagbarer Seed, statischer Schlüssel)
- Speicherort des Schlüssels (an Datei angehängt, Registry, C2-Übertragung)
- Dateiänderungsmuster (vollständige Verschlüsselung, partiell, nur Header)
- Gezielte Dateierweiterungen
- Format der Lösegeldforderung und Zahlungsinfrastruktur
- Bewertung der Entschlüsselungsmachbarkeit (möglich/unmöglich/teilweise)
- Empfohlener Wiederherstellungsansatz

Schlüsselkonzepte

Begriff	Definition
Hybride Verschlüsselung	Kombination von symmetrischer (AES) für schnelle Dateiverschlüsselung mit asymmetrischer (RSA) für sichere Schlüsselumhüllung; der Standardansatz von Ransomware
Schlüsselumhüllung	Verschlüsselung des pro-Datei symmetrischen Schlüssels mit dem RSA öffentlichen Schlüssel des Angreifers, sodass nur der private Schlüssel des Angreifers ihn entschlüsseln kann
ECB-Modus	Electronic Codebook Modus verschlüsselt jeden Block unabhängig; bewahrt Muster im Klartext, eine kritische Schwachstelle, die teilweise Wiederherstellung ermöglicht
Known-Plaintext-Angriff	Verwendung einer bekannten Originaldatei und ihrer verschlüsselten Version, um den Verschlüsselungsschlüssel abzuleiten; effektiv gegen XOR und schwache Stream-Chiffren
Schlüsselplan	Die erweiterte Form eines AES-Schlüssels im Speicher; in Speicherabbildern durchsuchbar, um Verschlüsselungsschlüssel wiederherzustellen, bevor sie gelöscht werden
CSPRNG	Kryptographisch sicherer Pseudozufallszahlengenerator; Ransomware, die CryptGenRandom verwendet, erzeugt unvorhersagbare Schlüssel
Partielle Verschlüsselung	Einige Ransomware verschlüsselt nur die ersten N Bytes oder jeden N-ten Block aus Geschwindigkeitsgründen; nicht verschlüsselte Teile können die Wiederherstellung unterstützen

Tools & Systeme

• Ghidra: Reverse-Engineering-Suite zur Analyse von Ransomware-Verschlüsselungsroutinen auf Assembly-Ebene
• PyCryptodome: Python-Kryptographiebibliothek zur Implementierung und zum Testen von Entschlüsselungsroutinen
• NoMoreRansom.org: Kostenloses Entschlüsselungstool-Repository, betrieben von Europol und Sicherheitsanbietern für bekannte Ransomware-Familien
• Volatility: Memory-Forensik-Framework zum Extrahieren von Verschlüsselungsschlüsseln aus RAM-Abbildern infizierter Systeme
• CryptoTester: Tool zur Identifizierung kryptografischer Algorithmen anhand von Konstanten und Codemustern

Häufige Szenarien

Szenario: Bewertung der Entschlüsselungsmachbarkeit für einen Ransomware-Vorfall

Kontext: Eine Organisation wird von Ransomware getroffen, die Dateiserver verschlüsselt. Das Management muss wissen, ob eine Entschlüsselung ohne Lösegeldzahlung möglich ist, bevor eine Wiederherstellungsentscheidung getroffen wird.

Vorgehen:

1. Identifiziere die Ransomware-Familie anhand der Lösegeldnote, Dateierweiterung und des Probe-Hashs (Überprüfung mittels ID Ransomware)
2. Überprüfe NoMoreRansom.org auf bestehende kostenlose Entschlüsselungstools für diese Familie
3. Führe Reverse Engineering der Verschlüsselungsroutine in Ghidra durch, um Algorithmus und Schlüsselverwaltung zu identifizieren
4. Teste auf Implementierungsschwächen (Schlüsselwiederverwendung, vorhersagbare Seeds, ECB-Modus)
5. Überprüfe, ob der PCAP des Vorfalls die Schlüsselübertragung an C2 erfasst hat (falls Schlüssel vor der Verschlüsselung gesendet wurde)
6. Scanne Speicherabbilder betroffener Maschinen auf AES-Schlüsselpläne im RAM
7. Berichte Ergebnisse: Entschlüsselung möglich/unmöglich mit spezifischer technischer Begründung

Fallstricke:

• Testen von Entschlüsselungsmethoden an der einzigen Kopie verschlüsselter Dateien (immer an Kopien arbeiten)
• Annahme, dass alle Dateien denselben Schlüssel verwenden, ohne dies zu überprüfen (manche Ransomware verwendet pro-Datei Schlüssel)
• Nicht überprüfen von Volumen-Schattenkopien (vssadmin), die Ransomware möglicherweise nicht gelöscht hat
• Verwechseln des Dateiverschlüsselungsalgorithmus mit dem Schlüsselumhüllungsalgorithmus in Berichten

Ausgabeformat

RANSOMWARE VERSCHLÜSSELUNGSANALYSE
================================
Probe:            lockbit3.exe
Familie:          LockBit 3.0 / LockBit Black
SHA-256:          abc123def456...

VERSCHLÜSSELUNGSSCHEMA
Datei-Chiffre:      AES-256-CTR (pro-Datei eindeutiger Schlüssel)
Schlüsselumhüllung:  RSA-2048 (öffentlicher Schlüssel in Binärdatei eingebettet)
Schlüsselerzeugung:  CryptGenRandom (CSPRNG - unvorhersagbar)
IV-Erzeugung:       Zufällige 16 Bytes pro Datei
Dateistruktur:      [verschlüsselte_Daten][rsa_verschlüsselter_Schlüssel(256B)][iv(16B)][magic(8B)]

ZIELERWEITERUNGEN
Gesamt:            412 Zielerweiterungen
Kategorien:        Dokumente (.doc, .xls, .pdf), Datenbanken (.sql, .mdb),
                   Archive (.zip, .7z), Quellcode (.py, .java, .cs)
Ausgeschlossen:    .exe, .dll, .sys, .lnk (Systemdateien erhalten)

IMPLEMENTIERUNGSANALYSE
Schlüsselstärke:    STARK - pro-Datei zufällige Schlüssel, keine Wiederverwendung
Modus-Sicherheit:   STARK - CTR-Modus mit eindeutigen Nonces
Schlüsselspeicher:  RSA-verschlüsselter Schlüssel an jede Datei angehängt
Schattenkopien:    Gelöscht via vssadmin und WMI

ENTSCHLÜSSELUNGSMACHBARKEIT
Ohne Schlüssel:     NICHT MÖGLICH
  - Keine Implementierungsfehler identifiziert
  - RSA-2048 Schlüsselumhüllung verhindert Brute Force
  - CSPRNG verhindert Schlüsselvorhersage
  - Kein bestehendes kostenloses Entschlüsselungstool verfügbar

WIEDERHERSTELLUNGSOPTIONEN
1. Wiederherstellung aus Offline-Backups (empfohlen)
2. Überprüfung auf Volumen-Schattenkopien (geringe Wahrscheinlichkeit - Ransomware löscht sie)
3. Memory-Forensik, wenn die Maschine nicht neu gestartet wurde (Schlüssel kann im RAM verbleiben)
4. Verhandlung mit dem Angreifer (letzter Ausweg - keine Garantie auf Entschlüsselung)