Resumen Ejecutivo

AgentTesla es un RAT (Remote Access Trojan) e infostealer comercial activo desde 2014, vendido en foros underground como Malware-as-a-Service por precios que van desde $15 hasta $69 USD por suscripción mensual. Es uno de los malware más distribuidos globalmente, consistentemente en el top 10 de familias de malware más detectadas según reportes de Cofense, ANY.RUN y Check Point.

Capacidades principales

• Keylogging — captura todas las pulsaciones del teclado

• Robo de credenciales — más de 70 aplicaciones: Chrome, Firefox, Outlook, Thunderbird, FileZilla, WinSCP, OpenVPN, y más

• Captura de pantalla — screenshots periódicos del escritorio

• Clipboard hijacking — monitoreo del portapapeles

• Exfiltración — vía SMTP, FTP, HTTP o Telegram Bot API

Entorno de Análisis

Infraestructura

Preparación del entorno Windows

Para evitar que Windows Defender interfiera durante el análisis, se desactivaron las protecciones en tiempo real y se agregaron exclusiones sobre las carpetas de trabajo.

# PowerShell como Administrador
Set-MpPreference -DisableRealtimeMonitoring $true
Set-MpPreference -DisableIOAVProtection $true
Set-MpPreference -DisableBehaviorMonitoring $true

New-ItemProperty -Path "HKLM:\SOFTWARE\Policies\Microsoft\Windows Defender" `
-Name "DisableAntiSpyware" -Value 1 -PropertyType DWORD -Force

Add-MpPreference -ExclusionPath "C:\Users\Flare-Malware\Downloads"
Add-MpPreference -ExclusionPath "C:\Tools"

Herramientas

Obtención del sample

Transferencia al host para análisis estático

Para correr file, strings y checksec desde BlackArch sin riesgo de ejecución, el sample fue transferido al host vía HTTP usando el servidor embebido de Python en la VM.

Fase 1: Reconocimiento Estático

Identificación del binario

Black4rch # file sample.exe
sample.exe: PE32 executable for MS Windows 6.00 (GUI),
Intel i386 Mono/.Net assembly, 3 sections

Mitigaciones del PE

Black4rch # winchecksec sample.exe
Warn: No load config in the PE
Results for: sample.exe
Dynamic Base    : "Present"
ASLR            : "Present"
High Entropy VA : "Present"
Force Integrity : "NotPresent"
Isolation       : "Present"
NX              : "Present"
SEH             : "NotPresent"
CFG             : "NotPresent"
RFG             : "NotPresent"
SafeSEH         : "NotPresent"
GS              : "NotPresent"
Authenticode    : "NotPresent"
.NET            : "Present"

Strings relevantes

Black4rch # strings -a sample.exe | grep -iE \
"smtp|ftp|telegram|password|aes|key" | head -50

lSystem.Resources.ResourceReader, mscorlib, Version=4.0.0.0...
lSystem.Resources.ResourceReader, mscorlib, Version=4.0.0.0...
[solo referencias al runtime de .NET -- sin strings de C2 en claro]

FLOSS — strings ofuscadas

Black4rch # floss sample.exe 2>/dev/null | grep -iE \
"smtp|ftp|telegram|password|aes|key|mail|host|port|http"

http://semaforhatti.yerel/semalar
OrtalamaIletimSuresiSaniye
RaporTarihi
ISupportInitialize

Análisis de estructura PE con pefile

Black4rch # python3 -c "
import pefile
pe = pefile.PE('sample.exe')

print('=== SECCIONES ===')
for s in pe.sections:
print(s.Name.decode().strip(),
'VirtualSize:', hex(s.Misc_VirtualSize),
'Entropy:', s.get_entropy())

print()
print('=== IMPORTS ===')
if hasattr(pe, 'DIRECTORY_ENTRY_IMPORT'):
for lib in pe.DIRECTORY_ENTRY_IMPORT:
print(lib.dll.decode())
for imp in lib.imports:
if imp.name:
print('  ->', imp.name.decode())
"

=== SECCIONES ===
.text   VirtualSize: 0xbeb14  Entropy: 7.657726995689024
.rsrc   VirtualSize: 0x61c    Entropy: 3.462825542308141
.reloc  VirtualSize: 0xc      Entropy: 0.07763316234324169

=== IMPORTS ===
mscoree.dll
-> _CorExeMain

Detección de packer o protector

Análisis del ensamblado .NET con dnSpyEx

Búsqueda de configuración y lógica maliciosa

Sandbox online: Any.run

Análisis dinámico en VM Windows

Process Monitor

Wireshark

Debugging con dnSpyEx

Fase 3: Threat Intelligence

IOCs

Infraestructura C2

Black4rch # dig smtp.yandex.com

;; ANSWER SECTION:
smtp.yandex.com.    600    IN    CNAME    smtp.yandex.ru.
smtp.yandex.ru.     600    IN    A        77.88.21.158

Campañas relacionadas

MITRE ATT&CK

YARA Rules

Regla específica: AgentTesla_SemaphoreLine_Specific_2026

import "pe"
import "dotnet"
import "math"

rule AgentTesla_SemaphoreLine_Specific_2026
{
    meta:
    author      = "Jesus Avila (Avilx)"
    date        = "2026-10-05"
    description = "Detecta AgentTesla disfrazado de software de
    simulacion de telegrafo optico turco (SemaphoreLine)"
    hash        = "e76c5c79066d31f5e84b172d61ba575926a18505efa47a9d9a0c7c1c0ced4768"
    tlp         = "WHITE"
    family      = "AgentTesla"
    
    strings:
    // identidad falsa del binario
    $s1 = "SemaphoreLine Systems" ascii wide
    $s2 = "Semafor Hatti Optik Telgraf Simulasyonu" ascii wide
    $s3 = "Zsbw" ascii wide
    // C2 config cifrada en runtime - no visible en disco
    // smtp.yandex.com, [email protected]
    
    condition:
    uint16(0) == 0x5A4D and
    filesize < 2MB and
    pe.number_of_sections == 3 and
    pe.number_of_imports == 1 and
    dotnet.is_dotnet and
    math.entropy(pe.sections[0].raw_data_offset,
    pe.sections[0].raw_data_size) > 7.5 and
    all of ($s1, $s2, $s3)
}

Regla genérica: AgentTesla_Generic

import "pe"
import "dotnet"
import "math"

rule AgentTesla_Generic
{
    meta:
    author      = "Jesus Avila (Avilx)"
    date        = "2026-10-05"
    description = "Detecta variantes de AgentTesla con exfiltracion
    SMTP y protector .NET Reactor"
    tlp         = "WHITE"
    family      = "AgentTesla"
    
    condition:
    uint16(0) == 0x5A4D and
    filesize < 5MB and
    pe.number_of_imports == 1 and
    dotnet.is_dotnet and
    math.entropy(pe.sections[0].raw_data_offset,
    pe.sections[0].raw_data_size) > 7.0
}

Validación

Black4rch # yara agenttesla_semaphoreline.yar sample.exe
AgentTesla_SemaphoreLine_Specific_2026 sample.exe
Black4rch # yara agenttesla_semaphoreline.yar /usr/bin/ls
Black4rch # yara agenttesla_semaphoreline.yar /usr/bin/python3
Black4rch #
Black4rch # yara agentTesla_Generic.yar sample.exe
AgentTesla_Generic sample.exe
Black4rch # yara agentTesla_Generic.yar /usr/bin/ls
Black4rch # yara agentTesla_Generic.yar /usr/bin/python3
Black4rch #

Cadena de ataque

Recomendaciones

Vector de entrada — Malspam

• Implementar capacitaciones periódicas de concienciación sobre phishing, con énfasis en adjuntos con doble extensión (.com.exe, .pdf.exe) y nombres de archivo que simulan facturas o documentos de envío.

• Configurar el gateway de correo para bloquear ejecutables adjuntos (.exe, .com, .scr) directamente desde el servidor de email.

• Habilitar la visualización de extensiones de archivo en Windows para que los usuarios vean la extensión real del archivo antes de ejecutarlo.

Método de exfiltración — SMTP

• Bloquear o restringir tráfico SMTP saliente (puerto 587) a dominios no autorizados por la organización. Si el negocio no usa smtp.yandex.com como servidor de correo, bloquearlo en el firewall perimetral.

• Implementar inspección de tráfico saliente (DLP) para detectar exfiltración de credenciales por email.

• Monitorear conexiones SMTP salientes inusuales desde estaciones de trabajo — un endpoint nunca debería iniciar conexiones SMTP directamente.

Disfraz de software legítimo

• Antes de ejecutar cualquier ejecutable recibido por email, verificar el hash en sandboxes públicos como Any.run o VirusTotal. Un archivo legítimo no debería requerir protectores como .NET Reactor.

• Implementar una política de software autorizado (allowlisting) que impida la ejecución de binarios no firmados digitalmente por proveedores conocidos.

• Desconfiar de software recibido por email con Authenticode: NotPresent — software legítimo comercial siempre está firmado digitalmente.

Detección

• Desplegar las reglas YARA desarrolladas en este análisis en el EDR corporativo para detectar variantes de AgentTesla: la regla específica (AgentTesla_SemaphoreLine _Specific_2026) detecta este sample exacto y la regla genérica (AgentTesla_Generic) detecta variantes empaquetadas con .NET Reactor y alta entropía.

• Subir los IOCs (SHA256, servidor SMTP, buzón de exfiltración) a la plataforma de threat intelligence corporativa para correlación automática con futuros eventos.

Reflexión Final

Qué salió bien

Todas las herramientas utilizadas durante el análisis estático y dinámico funcionaron correctamente. El punto más destacado fue el análisis en Any.run, ver el malware ejecutarse en un entorno controlado, extraer la configuración SMTP completa y confirmar que era AgentTesla fue un momento muy motivador. A pesar de no encontrar la lógica maliciosa en dnSpyEx durante el análisis estático, Any.run confirmó que era un malware real, lo cual fue una lección importante sobre los límites del análisis estático frente al dinámico.

Otro hallazgo positivo fue entender por qué los autores de malware prefieren compilar en x32 y no x64: maximizar la compatibilidad con infraestructura legacy. Esto no lo sabía antes de comenzar el análisis.

Qué salió mal

El principal obstáculo fue que el malware no ejecutó correctamente en la VM local. A pesar de desactivar Windows Defender, el firewall y usar FakeNet-NG como red simulada, el proceso no completó la exfiltración. Esto limitó el análisis dinámico local y obligó a depender de Any.run para los hallazgos de comportamiento.

Otro problema fue que checksec no es compatible con binarios PE, solo funciona con ELF. Fue necesario instalar winchecksec como alternativa, lo cual no estaba contemplado inicialmente en el flujo de análisis.

También de4dot no reconoció .NET Reactor 6.X porque su base de datos data de 2011-2015. Fue necesario usar NETReactorSlayer como alternativa más actualizada.

Lecciones aprendidas

• El análisis estático tiene límites claros con malware empaquetado. Cuando el código visible no muestra comportamiento malicioso, el análisis dinámico es indispensable para confirmar la amenaza.

• Los autores de malware compilan en x32 para maximizar compatibilidad con sistemas legacy — un detalle técnico con implicaciones prácticas directas en el alcance del ataque.

• Un malware puede estar tan bien disfrazado que el software falso sea funcionalmente completo. Este sample tenía una aplicación de simulación de telégrafo óptico turco completamente funcional, lo que dificultó identificar dónde estaba la lógica maliciosa.

• Siempre verificar la compatibilidad de las herramientas con el formato del binario antes de iniciar el análisis. checksec es para ELF, winchecksec es para PE.

• Invertir más tiempo en cada fase del análisis y documentar hipótesis antes de avanzar a la siguiente fase.

Tiempo total

Este análisis se realizó a lo largo de 4 días, combinando la configuración del laboratorio, el análisis estático, el análisis dinámico, la inteligencia de amenazas, las reglas YARA y la documentación del reporte. Para ser el primer análisis de malware real, el resultado fue satisfactorio. Los próximos análisis incorporarán mayor profundidad en cada fase y más tiempo de investigación en las herramientas disponibles.