Analisando Mecanismos de Criptografia de Ransomware

Quando Usar

• Ocorreu uma infecção por ransomware e a recuperação exige o entendimento do esquema de criptografia utilizado
• Avaliar se a descriptografia é possível sem pagar o resgate (falhas de implementação, descriptografadores conhecidos)
• Engenharia reversa de ransomware para identificar o algoritmo de criptografia, derivação de chave e mecanismo de armazenamento de chave
• Desenvolver uma ferramenta de descriptografia quando uma fraqueza na implementação criptográfica do ransomware é identificada
• Classificar uma amostra de ransomware por sua abordagem de criptografia para atribuí-la a uma família conhecida

Não use para operações de recuperação de dados em produção sem antes verificar o método de descriptografia em cópias de teste de arquivos criptografados.

Pré-requisitos

• Ghidra ou IDA Pro para engenharia reversa do binário do ransomware
• Python 3.8+ com a biblioteca pycryptodome para testar rotinas de criptografia/descriptografia
• Amostras de arquivos criptografados e seus originais em texto plano correspondentes (pares texto plano/texto cifrado conhecidos)
• Acesso ao binário do ransomware (descompactado, se aplicável)
• Familiaridade com algoritmos criptográficos simétricos (AES, ChaCha20) e assimétricos (RSA)
• Banco de dados do NoMoreRansom.org para verificar descriptografadores gratuitos existentes

Fluxo de Trabalho

Passo 1: Identificar o Algoritmo de Criptografia

Determine qual algoritmo criptográfico o ransomware utiliza:

# Check for Windows Crypto API usage in imports
import pefile

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

crypto_apis = {
    "CryptAcquireContextA": "Windows CryptoAPI",
    "CryptAcquireContextW": "Windows CryptoAPI",
    "CryptGenKey": "Windows CryptoAPI key generation",
    "CryptEncrypt": "Windows CryptoAPI encryption",
    "CryptImportKey": "Windows CryptoAPI key import",
    "BCryptOpenAlgorithmProvider": "Windows CNG (modern crypto)",
    "BCryptEncrypt": "Windows CNG encryption",
    "BCryptGenerateKeyPair": "Windows CNG asymmetric key gen",
}

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()]}")

Common Ransomware Encryption Schemes:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
AES-256-CBC + RSA-2048:    Most common hybrid scheme (LockBit, REvil, Conti)
AES-256-CTR + RSA-4096:    Stream cipher mode variant (BlackCat/ALPHV)
ChaCha20 + RSA-4096:       Modern stream cipher (Hive, Royal)
Salsa20 + ECDH:            Curve25519 key exchange (Babuk)
AES-128-ECB:               Weak mode - potential decryption via known-plaintext
XOR-only:                  Trivial encryption - always recoverable
Custom algorithm:          Often contains implementation flaws

Passo 2: Analisar Geração e Gerenciamento de Chaves

Faça engenharia reversa de como as chaves de criptografia são geradas e armazenadas:

Key Management Patterns in Ransomware:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. STRONG (no recovery possible without key):
   - Per-file AES key generated with CryptGenRandom
   - AES key encrypted with embedded RSA public key
   - Encrypted key appended to each file or stored separately
   - RSA private key held only by attacker's C2 server

2. WEAK (potential recovery):
   - AES key derived from predictable seed (timestamp, PID)
   - Same AES key used for all files (single key compromise = full recovery)
   - Key transmitted to C2 before encryption starts (PCAP may contain key)
   - XOR with short repeating key (brute-forceable)
   - PRNG seeded with GetTickCount or time() (limited keyspace)

3. FLAWED IMPLEMENTATION:
   - ECB mode (preserves plaintext patterns)
   - Initialization vector (IV) reuse across files
   - Key stored in plaintext in memory (recoverable from memory dump)
   - Partial encryption (only first N bytes encrypted)

Passo 3: Examinar Rotina de Criptografia de Arquivos

Faça engenharia reversa da lógica de processamento de arquivos:

// Fluxo típico de criptografia de arquivos por ransomware (pseudo-código descompilado do Ghidra):

void encrypt_file(char *filepath) {
    // 1. Verifica a extensão do arquivo contra a lista de alvos
    if (!is_target_extension(filepath)) return;

    // 2. Gera chave AES por arquivo (32 bytes para AES-256)
    BYTE aes_key[32];
    CryptGenRandom(hProv, 32, aes_key);

    // 3. Gera IV aleatório (16 bytes)
    BYTE iv[16];
    CryptGenRandom(hProv, 16, iv);

    // 4. Lê o conteúdo do arquivo
    HANDLE hFile = CreateFile(filepath, GENERIC_READ, ...);
    BYTE *plaintext = read_entire_file(hFile);

    // 5. Criptografa com AES-256-CBC

…