Engenharia Reversa de Malware em Rust

Visão Geral

Rust tem se tornado cada vez mais popular para o desenvolvimento de malware devido à sua compilação cruzada, garantias de segurança de memória e à complexidade que introduz para engenheiros reversos. Binários Rust contêm toda a biblioteca padrão vinculada estaticamente, produzindo binários grandes com código boilerplate extenso. Desafios chave incluem strings não terminadas por nulo (Rust usa ponteiros "fat" com ponteiro+tamanho), monomorfização gerando código genérico duplicado, tratamento complexo de erros (cadeias de unwrap de Result/Option) e convenções de chamada desconhecidas. Descompilar Rust para C produz resultados inúteis em comparação com binários C/C++. Ferramentas como scripts Ghidra para extração de crates e treinamento focado em padrões específicos de Rust (2024-2025) ajudam a abordar esses desafios. Malware notável em Rust inclui ransomware BlackCat/ALPHV, variantes do ransomware Hive e Buer Loader.

Quando Usar

• Ao realizar testes de segurança autorizados que envolvam engenharia reversa de malware em Rust
• Ao analisar amostras de malware ou artefatos de ataque em um ambiente controlado
• Ao conduzir exercícios de equipe vermelha ou engajamentos de teste de penetração
• Ao construir capacidades de detecção com base na compreensão de técnicas ofensivas

Pré-requisitos

• IDA Pro 8.0+ ou Ghidra 11.0+
• Toolchain Rust para compilação de referência
• Python 3.9+ para scripts auxiliares
• Compreensão do modelo de memória Rust (propriedade, empréstimo)
• Familiaridade com tipos de string Rust (String, &str, CString)

Fluxo de Trabalho

Passo 1: Identificar e Analisar Metadados de Binários Rust

#!/usr/bin/env python3
"""Analisa metadados de binários de malware Rust e extrai dependências de crates."""
import re
import sys
import json


def identify_rust_binary(data):
    """Verifica se o binário foi compilado em Rust e extrai informações de versão."""
    indicators = {
        "rust_panic_strings": bool(re.search(rb'panicked at', data)),
        "rust_unwrap": bool(re.search(rb'called.*unwrap.*on.*None', data)),
        "core_panic": bool(re.search(rb'core::panicking', data)),
        "std_rt": bool(re.search(rb'std::rt::lang_start', data)),
        "cargo_path": bool(re.search(rb'\.cargo[/\\]registry', data)),
        "rustc_version": None,
    }

    version = re.search(rb'rustc\s+(\d+\.\d+\.\d+)', data)
    if version:
        indicators["rustc_version"] = version.group(1).decode()

    is_rust = sum(1 for v in indicators.values() if v) >= 2
    return is_rust, indicators


def extract_crates(data):
    """Extrai nomes de crates (dependências) Rust de strings do binário."""
    crate_pattern = re.compile(
        rb'(?:crates\.io-[a-f0-9]+/|\.cargo/registry/src/[^/]+/)'
        rb'([\w-]+)-(\d+\.\d+\.\d+)'
    )
    crates = {}
    for match in crate_pattern.finditer(data):
        name = match.group(1).decode()
        version = match.group(2).decode()
        crates[name] = version

    # Também verifica crates comuns relevantes para malware
    suspicious_crates = {
        "reqwest": "Cliente HTTP",
        "hyper": "Biblioteca HTTP",
        "tokio": "Runtime assíncrono",
        "aes": "Criptografia AES",
        "chacha20": "Criptografia ChaCha20",
        "rsa": "Criptografia RSA",
        "ring": "Biblioteca criptográfica",
        "base64": "Codificação Base64",
        "winapi": "Bindings para API do Windows",
        "winreg": "Acesso ao Registro",
        "sysinfo": "Informações do sistema",
        "screenshots": "Captura de tela",
        "clipboard": "Acesso à área de transferência",
        "keylogger": "Registro de teclas",
    }

    capabilities = []
    for crate_name, description in suspicious_crates.items():
        if crate_name in crates:
            capabilities.append({
                "crate": crate_name,
                "version": crates[crate_name],
                "capability": description,
            })

    return crates, capabilities


def extract_rust_strings(data):
    """Extrai strings lidando com o formato não terminado por nulo do Rust."""
    # Strings Rust são armazenadas como ponteiro+tamanho, mas literais de string
    # estão frequentemente em .rodata como sequências contíguas
    strings = []
    ascii_pattern = re.compile(rb'[\x20-\x7e]{8,500}')
    for match in ascii_pattern.finditer(data):
        s = match.group().decode('ascii')
        # Filtra strings relevantes para malware
        keywords = ['http', 'socket', 'encrypt', 'decrypt', 'shell',
                    'exec', 'cmd', 'upload', 'download', 'persist',
                    'registry', 'mutex', 'pipe', 'inject']
        if any(kw in s.lower() for kw in keywords):
            strings.append(s)


…