Extraindo Configuração do RAT Agent Tesla

Visão Geral

Agent Tesla é um Trojan de Acesso Remoto (RAT) e keylogger baseado em .NET que ficou entre as 10 principais variantes de malware em 2024, impactando 6,3% das redes corporativas globalmente. Ele exfiltra credenciais roubadas via e-mail SMTP, upload FTP, API de bot do Telegram ou webhooks do Discord. A configuração do malware está embutida na assembly .NET, geralmente ofuscada usando criptografia de strings, criptografia de recursos ou carregadores personalizados que descriptografam e executam o Agent Tesla na memória via .NET Reflection (fileless). A extração de configuração envolve a descompilação da assembly .NET com dnSpy ou ILSpy, a identificação da rotina de descriptografia para strings de configuração e a extração de endereços de servidores SMTP, credenciais, endpoints FTP, tokens de bot do Telegram e aplicativos visados.

Quando Usar

• Ao realizar testes de segurança autorizados que envolvam a extração de configuração do RAT Agent Tesla.
• Ao analisar amostras de malware ou artefatos de ataque em um ambiente controlado.
• Ao conduzir exercícios de red team ou engajamentos de testes de penetração.
• Ao construir capacidades de detecção com base na compreensão de técnicas ofensivas.

Pré-requisitos

• dnSpy ou ILSpy para descompilação .NET.
• Python 3.9+ com dnlib ou pythonnet para extração automatizada.
• de4dot para desofuscação .NET.
• Compreensão de código IL .NET e Reflection.
• Sandbox para análise dinâmica (ANY.RUN, CAPE).

Fluxo de Trabalho

Etapa 1: Desofuscar e Extrair Configuração

#!/usr/bin/env python3
"""Extrai a configuração do RAT Agent Tesla de assemblies .NET."""
import re
import sys
import json
import base64
import hashlib
from pathlib import Path


def extract_strings_from_dotnet(filepath):
    """Extrai strings legíveis de binários .NET para análise de configuração."""
    with open(filepath, 'rb') as f:
        data = f.read()

    # Extrai o heap US (User Strings) dos metadados .NET
    strings = []

    # Procura por padrões comuns de configuração do Agent Tesla
    patterns = {
        "smtp_server": re.compile(rb'smtp[\.\-][\w\.\-]+\.\w{2,}', re.I),
        "email": re.compile(rb'[\w\.\-]+@[\w\.\-]+\.\w{2,}'),
        "ftp_url": re.compile(rb'ftp://[\w\.\-:/]+', re.I),
        "telegram_token": re.compile(rb'\d{8,10}:[A-Za-z0-9_-]{35}'),
        "telegram_chat": re.compile(rb'(?:chat_id=|chatid[=:])[\-]?\d{5,15}', re.I),
        "discord_webhook": re.compile(rb'https://discord\.com/api/webhooks/\d+/[\w-]+'),
        "password": re.compile(rb'(?:pass(?:word)?|pwd)[=:]\s*[\w!@#$%^&*]{4,}', re.I),
        "port": re.compile(rb'(?:port|smtp_port)[=:]\s*\d{2,5}', re.I),
    }

    results = {}
    for name, pattern in patterns.items():
        matches = pattern.findall(data)
        if matches:
            results[name] = [m.decode('utf-8', errors='replace') for m in matches]

    # Extrai strings codificadas em Base64 (ofuscação comum)
    b64_pattern = re.compile(rb'[A-Za-z0-9+/]{20,}={0,2}')
    b64_decoded = []
    for match in b64_pattern.finditer(data):
        try:
            decoded = base64.b64decode(match.group())
            text = decoded.decode('utf-8', errors='strict')
            if text.isprintable() and len(text) > 5:
                b64_decoded.append(text)
        except Exception:
            pass

    if b64_decoded:
        results["base64_decoded_strings"] = b64_decoded[:30]

    return results


def decrypt_agenttesla_strings(data, key_hex):
    """Descriptografa strings de configuração criptografadas do Agent Tesla."""
    key = bytes.fromhex(key_hex)
    # Agent Tesla V1: XOR simples com chave
    decrypted_strings = []

    # Encontra blobs criptografados (sequências de bytes de alta entropia)
    blob_pattern = re.compile(rb'[\x80-\xff]{16,256}')
    for match in blob_pattern.finditer(data):
        blob = match.group()
        # Tenta descriptografia XOR
        decrypted = bytes(b ^ key[i % len(key)] for i, b in enumerate(blob))
        try:
            text = decrypted.decode('utf-8', errors='strict')
            if text.isprintable() and len(text.strip()) > 3:
                decrypted_strings.append(text.strip())
        except UnicodeDecodeError:
            pass

    # V2: Derivação de chave baseada em SHA256 e depois AES
    sha256_key = hashlib.sha256(key).digest()

    return decrypted_strings


def analyze_exfiltration_config(config):
    """Analisa a configuração extraída para métodos de exfiltração."""
    methods = []

    if config.get("smtp_server"):
        methods.append({
            "type": "SMTP",
            "servers": config["smtp_server"],

…