GhostAcademy
GhostAcademy
CyberChef — Navaja Suiza del Análisis
unfantasmaenelsistema.com
Manual Completo
CyberChef
La Navaja Suiza del Análisis de Datos

CyberChef es una aplicación web creada por GCHQ que permite aplicar más de 500 operaciones criptográficas, de codificación, compresión y análisis de datos de forma visual, encadenándolas en "recetas". Sin instalar nada, directamente en el navegador.

⚠ Disclaimer LegalEste manual es para fines educativos y entornos de laboratorio. El análisis de malware debe realizarse en entornos aislados. GhostAcademy promueve la seguridad ética.

¿Por qué CyberChef?

Antes de CyberChef, analizar un payload ofuscado requería encadenar a mano herramientas de línea de comandos: base64, openssl, gzip, xxd… y recordar la sintaxis exacta de cada una. CyberChef convierte ese proceso en un flujo visual, reproducible y compartible mediante una URL.

Acceso
Sin instalación
Corre 100% en el navegador. También disponible como aplicación offline descargable para entornos sin internet.
gchq.github.io/CyberChef
Potencia
500+ Operaciones
Desde Base64 hasta AES, desde GZIP hasta XOR, pasando por regex, parsing de fechas, geolocalización de IPs y más.
Crypto + Data
Workflow
Recetas (Recipes)
Encadenar operaciones en orden. El output de una se convierte en el input de la siguiente. Compartible como URL o fichero JSON.
Pipeline visual
IA integrada
Magic Operation
Detecta automáticamente el tipo de dato (Base64, hex, gzip…) e intenta encontrar la receta para decodificarlo. Mágico para CTFs.
Auto-detect
Forense
Análisis de Malware
Desempaquetar payloads multicapa, extraer IOCs de tráfico de red, analizar strings ofuscados. El caso de uso principal en seguridad.
Malware Analysis
Automatización
API + Node.js
CyberChef puede usarse como biblioteca Node.js. Integra recetas en scripts de automatización de análisis forense.
cyberchef-server

Acceso y Versiones

VersiónURL / MétodoCuándo usarla
Online (GCHQ)gchq.github.io/CyberChefAnálisis general, sin datos sensibles
Offline (descarga)Releases en GitHub → .zipEntornos aislados, malware real
Docker self-hostedmpepping/cyberchefSOC / equipos corporativos
Node.js libnpm install cyberchefScripts de automatización
⚠ PrivacidadNunca subas malware real o datos sensibles a la versión online. Todo se procesa localmente en el navegador pero la URL puede contener el payload codificado. Usa siempre la versión offline para muestras reales.
Fundamentos — 01
🖥 La Interfaz de CyberChef

CyberChef tiene 4 paneles principales. Entender cómo interactúan es la base para construir recetas eficientes.

Operations
Recipe
Input
Output
① Operations
From Base64
RC4 Decrypt
Gunzip
To Hex
AES Decrypt
Extract URLs
MD5
② Recipe (Receta activa)
1
From Base64
Alphabet: Standard | Strict: false
↓
2
RC4
Key: "GhostKey" | Scheme: Latin1
↓
3
Gunzip
→ procesando…
③ Input / ④ Output
INPUT:
H4sIAAAAAAAA/0rNyclRSk/…
OUTPUT:
<?xml version="1.0"?>
<payload>
  <c2>evil.com/beacon</c2>
  <key>XOR_K3Y_H3R3</key>
</payload>

Los 4 Paneles

①
Operations (Operaciones)
Panel izquierdo. Contiene todas las operaciones disponibles organizadas por categorías. Búsqueda en tiempo real. Arrastra al panel Recipe o haz doble clic para añadir.
②
Recipe (Receta)
Panel central-superior. La lista ordenada de operaciones que se aplicarán. Reordenables con drag-and-drop. Cada operación tiene sus propios parámetros configurables.
③
Input (Entrada)
Panel derecho superior. El dato a procesar. Soporta texto, hex, binario. Puedes pegar directamente, arrastrar ficheros o cargar desde URL.
④
Output (Salida)
Panel derecho inferior. El resultado tras aplicar todas las operaciones de la receta. Actualización en tiempo real. Exportable como fichero o como input para la siguiente receta.

Atajos de Teclado Esenciales

AtajoAcción
Ctrl + EnterEjecutar la receta manualmente (si auto-bake está desactivado)
Ctrl + Shift + FBuscar operación en el panel Operations
Alt + Shift + CLimpiar la receta actual
Ctrl + SGuardar la receta como fichero JSON
URL shareLa URL contiene la receta + input codificados — comparte directamente
Fundamentos — 02
📦 Operaciones Clave

Las 500+ operaciones de CyberChef se agrupan en categorías. Estas son las más usadas en análisis de seguridad.

Encodings / Conversión

Encoding
From / To Base64
El más común. Configurable: alfabeto estándar, URL-safe, sin padding. Detecta si hay basura al inicio/final.
Bidireccional
Encoding
To / From Hex
Convierte entre bytes y representación hexadecimal. Separador configurable (espacio, 0x, nada).
Bidireccional
Encoding
URL Encode/Decode
Encodifica/decodifica caracteres especiales para URLs. Útil en análisis de tráfico HTTP malicioso.
HTTP
Encoding
From Charcode
Convierte array de códigos de caracteres (decimal/hex) a string. Muy usado en ofuscación JavaScript.
JS Deobfusc
Encoding
ROT13 / ROT47
Cifrado de sustitución clásico. ROT47 actúa sobre todos los caracteres imprimibles ASCII.
Classic
Encoding
Escape / Unescape
Maneja secuencias de escape: \n, \t, \uXXXX, %XX. Fundamental para analizar strings ofuscados.
Strings

Criptografía Simétrica

Simétrico
AES Decrypt/Encrypt
AES en modos CBC, CTR, GCM, ECB, CFB, OFB. Clave y IV configurables. El cifrado más común en malware moderno.
AES-128/192/256
Simétrico
RC4
Cifrado de stream clásico. Muy usado en malware por su simplicidad de implementar. Solo requiere una clave.
RC4
Simétrico
XOR
La operación XOR byte a byte contra una clave. El ofuscador más simple y más usado. Soporta claves multi-byte.
Más común
Simétrico
ChaCha20 / Salsa20
Cifrados de stream modernos. Aparecen en ransomware avanzado. Nonce + clave de 256 bits.
Moderno
Simétrico
Blowfish / DES
Cifrados legacy pero aún presentes en malware antiguo o sistemas heredados. Útil en análisis forense histórico.
Legacy
Simétrico
AES Key Schedule
Herramienta avanzada para inspeccionar el key expansion de AES. Útil en análisis profundo de implementaciones custom.
Avanzado

Hashing e Integridad

Hash
MD5 / SHA-1 / SHA-256
Hashes estándar para identificar ficheros, verificar integridad y buscar en VirusTotal por hash.
IOC
Hash
HMAC
Hash con clave secreta. Aparece en tokens JWT, firmas de API y verificación de integridad con secreto compartido.
Auth
Hash
Compare Digests
Compara dos hashes en tiempo constante (evita timing attacks). Útil para verificar checksums de muestras.
Verificación

Compresión

Compresión
Gzip / Gunzip
El formato de compresión más común. Magic bytes: 1f 8b. Frecuente en payloads multicapa con Base64 exterior.
1f 8b
Compresión
Zlib Inflate/Deflate
Formato Deflate sin headers Gzip. Magic bytes: 78 9c (nivel normal) o 78 da (máximo). Muy común en tráfico HTTP.
78 9c / 78 da
Compresión
Bzip2 / Lzma
Compresiones alternativas. Bzip2 en distribuciones Linux, LZMA en archivos 7-zip y payloads de malware avanzado.
BZ2 / 7z
Crypto — 01
🔤 Encodings: Base64 y familia

Los encodings no son cifrado: son solo representaciones alternativas de los mismos bytes. Base64 es el más ubicuo en seguridad. Entenderlo a fondo es esencial.

Base64 en profundidad

Base64 convierte 3 bytes (24 bits) en 4 caracteres del alfabeto A-Z a-z 0-9 + /. El = es padding. Hay variantes con alfabetos distintos: URL-safe (-_ en lugar de +/), Base32, Base58 (Bitcoin), Base85.

Receta CyberChef — Detectar variantes de Base64
// Input: H4sIAAAAAAAAA6tWKkktLlGyUlJQsjI0MAAAdIuT2RAAAAA=
// ¿Es Base64 estándar? → sí, contiene +/ y padding =
// ¿Es URL-safe Base64? → si contiene - o _ en lugar de + o /

Receta 1 — Base64 estándar:
From Base64 [alphabet: A-Za-z0-9+/=]

Receta 2 — Base64 URL-safe:
From Base64 [alphabet: A-Za-z0-9-_]

Receta 3 — Detectar automáticamente con Magic:
Magic [depth: 3, intensive: true]

Truco: si el resultado tiene bytes inválidos, prueba con la otra variante

Múltiples Capas de Base64

⚠ MulticapaEl malware suele aplicar Base64 varias veces. Si después de decodificar obtienes otro string Base64, aplica el bloque de nuevo. En CyberChef puedes usar el bloque "From Base64" múltiples veces en la misma receta o usar un bucle.
CyberChef — Decodificar 3 capas de Base64
Input: VkdocGN5QmpZWEpsWkNCc1lYa2dZbUZqYXc9PQ==

Receta:
1. From Base64  → "VGhpcyBjYWxlZCBsYYkgYmFjaw=="
2. From Base64  → "This called laY back"

Exportar receta como URL → compartir con el equipo en un clic

Otros Encodings Frecuentes en Malware

EncodingIdentificador visualOperación CyberChefDónde aparece
Base64A-Za-z0-9+/=From Base64Muy común
Hex0-9a-f, en paresFrom HexMuy común
URL encode%XXURL DecodeHTTP, C2
HTML entities&amp; &lt; 'Unescape HTML EntitiesPhishing
Unicode escapes\u0041\u006CUnescape Unicode CharsJS ofusc
Charcode dec72,101,108,108,111From Charcode (base 10)PowerShell
Base32A-Z2-7, sin minúscFrom Base32DNS tunneling
Crypto — 02
#️⃣ Hashing: MD5, SHA y familia

Los hashes son funciones unidireccionales: dato → hash, nunca al revés. CyberChef calcula hashes para identificar muestras, verificar integridad y buscar en bases de datos de amenazas.

CyberChef — Calcular múltiples hashes a la vez
// Identificar una muestra de malware por hash
// Input: contenido del fichero (cargar con el botón de fichero)

Receta para generar IOCs de hash:
1. MD5        → d41d8cd98f00b204e9800998ecf8427e
2. Label      → [MD5]

// O usar "Generate all hashes" para obtener MD5+SHA1+SHA256 juntos
1. Generate all hashes
MD5:      d41d8cd98f00b204e9800998ecf8427e
SHA-1:    da39a3ee5e6b4b0d3255bfef95601890afd80709
SHA-256:  e3b0c44298fc1c149afbf4c8996fb92427ae41e...

Buscar por Hash en VirusTotal

💡 Flujo de análisisCalcula el SHA-256 con CyberChef → copia el hash → busca en virustotal.com/gui/file/[SHA256]. Sin subir el fichero, solo por hash. Seguro y rápido.

Identificar Hashes Desconocidos

Tabla de identificación por longitud
// ¿Qué hash es este? → medir longitud en hex
32 chars hex  → MD5    (128 bits)
40 chars hex  → SHA-1  (160 bits)
56 chars hex  → SHA-224
64 chars hex  → SHA-256 ← más común en malware moderno
96 chars hex  → SHA-384
128 chars hex → SHA-512

// En CyberChef: pegar el hash + usar "Analyse Hash" para identificarlo
Crypto — 03
🔒 Cifrado Simétrico

AES, RC4 y XOR son los tres cifrados que aparecen en el 90% del malware. CyberChef los soporta todos con sus parámetros completos.

XOR — El más simple y más común

CyberChef — Descifrar XOR con clave desconocida
// Estrategia 1: XOR con clave conocida
// Input (hex): 1b 0e 1a 13 1e 08 1a 0d 1e 13 1d
1. From Hex
2. XOR [key: "ghost" (UTF-8), scheme: standard]
→ plaintext desencriptado

// Estrategia 2: clave de 1 byte desconocida → fuerza bruta
1. From Hex
2. XOR Brute Force [key length: 1, print key: true, output: hex]
→ muestra 256 resultados, buscar el que tenga texto legible

// Estrategia 3: XOR de clave repetida
1. From Hex
2. XOR [key: 41 42 43 (hex), scheme: standard]

RC4 — Cifrado de Stream Clásico

ℹ RC4 en malwareRC4 es extremadamente popular en malware por su simplicidad: solo necesita una clave, sin IV ni modos de operación. La misma operación sirve para cifrar y descifrar (simétrico perfecto). La clave suele estar hardcodeada en el código del malware.
CyberChef — RC4 Decrypt
// Supuesto: tenemos el payload cifrado en hex y sabemos la clave
// Input: e59f8b2a... (hex del ciphertext)
1. From Hex        ← convertir hex a bytes raw
2. RC4 [key: "GhostKey2024", key format: UTF8, input: Raw, output: Raw]
→ plaintext o próxima capa del payload

// Si la clave está en hex:
1. From Hex
2. RC4 [key: "4768 6f73 744b 6579", key format: Hex]

AES — El Estándar Moderno

CyberChef — AES Decrypt CBC
// AES-128-CBC: clave 16 bytes, IV 16 bytes
// Común en ransomware y C2 de malware avanzado
// Input: base64 del ciphertext
1. From Base64
2. AES Decrypt
    Mode: CBC
    Key: 4768 6f73 7441 6361 6465 6d79 3230 3234   (hex: "GhostAcademy2024")
    IV:  3132 3334 3536 3738 3930 3132 3334 3536    (hex: "1234567890123456")
    Input: Raw
    Output: Raw
→ plaintext desencriptado

// AES-256-GCM: clave 32 bytes, nonce 12 bytes, tag 16 bytes
1. From Base64
2. AES Decrypt [mode: GCM, key: 32-byte-key, nonce: 12-byte-nonce]
Crypto — 04
📦 Compresión: GZIP y familia

La compresión aparece en payloads multicapa para reducir el tamaño y dificultar el análisis. Identificar el formato correcto por sus magic bytes es el primer paso.

Identificar Magic Bytes

Referencia de Magic Bytes para compresión
// Convertir a hex primero y mirar los primeros bytes:
1f 8b          → GZIP      → operación: Gunzip
78 9c          → Zlib      → operación: Zlib Inflate
78 da          → Zlib best → operación: Zlib Inflate
50 4b 03 04    → ZIP       → operación: Unzip
42 5a 68       → BZIP2     → operación: Bzip2 Decompress
fd 37 7a 58 5a → XZ/LZMA   → operación: LZMA Decompress
52 61 72 21    → RAR       → no soportado, usar herramienta externa

// En CyberChef: pegar los bytes en hex → "Detect File Type" te lo dice automáticamente
1. Detect File Type  → "gzip compressed data"

Receta para Datos Comprimidos Desconocidos

CyberChef — Identificar y descomprimir
// Si recibes bytes y no sabes el formato:
1. To Hex         ← ver los magic bytes
// Si ves "1f 8b":
1. Gunzip
// Si ves "78 9c" o "78 da":
1. Zlib Inflate

// Receta automática con Magic:
1. Magic [depth: 5, intensive: true]
→ CyberChef detecta el formato y propone la receta completa
Laboratorio Principal
☠️ Lab: Desempaquetar un Payload
Base64 + RC4 + GZIP

Caso de uso real: un analista de malware recibe un payload sospechoso. Está en Base64, luego cifrado con RC4 y finalmente comprimido con GZIP. Hay que recorrer el camino inverso con CyberChef para ver qué hay dentro.

☠️LAB-CHEF-01 — Multicapa: B64 → RC4 → GZIPMEDIO

Simularemos el flujo completo: primero construimos el payload (para entender cómo lo fabrica el atacante) y luego lo desempaquetamos como lo haría un analista.

Arquitectura del Payload Multicapa

El atacante aplica las capas en este orden para crear el payload. El analista debe recorrerlas en orden inverso.

📄
Payload
XML config
con C2 y claves
ORIGEN
→
📦
GZIP
Comprimir
con gzip
CAPA 1
→
🔒
RC4
Cifrar
key: "GhostKey"
CAPA 2
→
🔤
Base64
Encodificar
para transporte
CAPA 3
→
📡
C2 Server
Payload listo
para enviar
DESTINO
★ El analista recorre el camino inversoC2 recibe el payload → Detectar Base64 → Decodificar → Detectar RC4 → Buscar la clave → Descifrar → Detectar GZIP → Descomprimir → Ver el payload original
Laboratorio — Construcción
🏗 Construir el Payload

Fase 1: construir el payload multicapa como lo haría el atacante. Esto nos permite entender la estructura y generar datos reales para el ejercicio de análisis.

Payload Original

Payload XML — Configuración de C2
<?xml version="1.0" encoding="utf-8"?>
<malwareConfig>
  <c2>https://evil.ghostacademy.lab/beacon</c2>
  <sleepTime>60</sleepTime>
  <jitterPct>20</jitterPct>
  <xorKey>0xDEADBEEF</xorKey>
  <killDate>2025-12-31</killDate>
  <userAgent>Mozilla/5.0 (Windows NT 10.0; Win64; x64)</userAgent>
</malwareConfig>

Receta CyberChef para Construir el Payload (Atacante)

Recipe — Construir payload
Receta de construcción (orden atacante)
1
Gzip
Comprimir el XML con GZIP
↓
2
RC4
Key: "GhostKey2024" | format: UTF8
↓
3
To Base64
Alphabet: Standard (A-Za-z0-9+/=)
Output final (payload listo)
TxUBHvZ3k2F8...
[base64 del payload
multicapa listo
para enviar al C2]
CyberChef — Receta construcción (pegar en CyberChef)
// Instrucciones para reproducir en CyberChef:
// 1. Abre CyberChef en gchq.github.io/CyberChef
// 2. Pega el XML en el panel Input
// 3. Añade estas operaciones en orden:

Paso 1: Buscar "Gzip" → arrastrar a Recipe
         Parámetros: Compression level: 9

Paso 2: Buscar "RC4" → arrastrar a Recipe
         Key: GhostKey2024
         Key format: UTF8
         Input: Raw | Output: Raw

Paso 3: Buscar "To Base64" → arrastrar a Recipe
         Alphabet: A-Za-z0-9+/= (estándar)

// El Output es tu payload listo. Cópialo para el ejercicio de análisis.

Payload de Ejemplo (para el Lab)

💡 Payload de laboratorioUsa este string como input en el ejercicio de análisis. Es el resultado de aplicar la receta de construcción al XML de arriba con la clave "GhostKey2024".
Payload multicapa — Pegar como Input en CyberChef
H4sIAAAAAAAA/0rNyclRSkvMTQUA5WJl9gwAAAA=

Nota: este es un ejemplo simplificado para ilustrar el flujo.
En el lab completo, construye tu propio payload con la receta anterior.
Clave RC4 a usar en el descifrado: GhostKey2024
Laboratorio — Análisis
🔓 Desempaquetar el Payload
Paso a Paso

Fase 2: el analista recibe el payload y debe reconstruir su contenido. Metodología completa con CyberChef, incluyendo cómo identificar cada capa sin conocer la estructura de antemano.

Metodología: Análisis de Capas Desconocido

★ Regla del analistaNunca asumir la estructura. Siempre identificar cada capa antes de procesarla. Magic bytes → tipo de dato → operación correcta. Si algo falla, retroceder y probar otra operación.
1
Recibir e inspeccionar el payload
Pegar el string en el Input de CyberChef. Observar las características visuales: solo caracteres A-Za-z0-9+/=, posiblemente con = al final. Claro indicador de Base64.
Paso 1 — Inspección inicial
Input (payload recibido)
TxUBHvZ3k2F8qLmN...==

Observaciones:
• Solo A-Za-z0-9+/=
• Termina en == (padding)
• Longitud múltiplo de 4
→ Diagnóstico: BASE64
Operaciones para este paso
1
From Base64
Alphabet: Standard
Tras decodificar: output son bytes binarios (no texto legible). Normal: hay más capas.
2
Identificar la capa oculta bajo el Base64
Después de decodificar el Base64, el output no es texto legible. Hay que inspeccionarlo en hex para identificar magic bytes y determinar la siguiente operación.
CyberChef — Identificar la capa interna
// Receta de diagnóstico: ¿qué hay bajo el Base64?
1. From Base64
2. To Hex           ← para ver los primeros bytes

Output (primeros bytes en hex):
e5 9f 8b 2a 4f ...   → NO empieza por 1f 8b → NO es GZIP directamente
                      → Los bytes son "ruido" → cifrado!

// Diagnóstico: entre el Base64 y el GZIP hay una capa de cifrado (RC4/AES/XOR)
// En un análisis real: revisar el código del malware o buscar la clave por ingeniería inversa
// En este lab: sabemos que es RC4 con clave "GhostKey2024"
3
Descifrar la capa RC4
Con la clave RC4 identificada (ya sea por análisis estático del binario, OSINT, o se nos facilita en el ejercicio), añadir la operación RC4 a la receta.
Paso 3 — Receta acumulada
Recipe actual
1
From Base64
Standard alphabet ✓
↓
2
RC4
Key: GhostKey2024 | UTF8
Output tras RC4 (en hex)
1f 8b 08 00 ...

¡Magic bytes 1f 8b!
→ Es GZIP comprimido
→ Añadir Gunzip a la receta
4
Descomprimir la capa GZIP
Los magic bytes 1f 8b confirman GZIP. Añadir Gunzip a la receta. El output debería ser el payload original en texto claro.
Receta Final — Completa
Recipe completa ✓
1
From Base64
Standard | Strict: off ✓
↓
2
RC4
Key: GhostKey2024 | UTF8 ✓
↓
3
Gunzip
→ payload descomprimido ✓
Output FINAL — Payload al descubierto
<?xml version="1.0"?>
<malwareConfig>
 <c2>https://evil.ghost...
 <xorKey>0xDEADBEEF</xorKey>
 <killDate>2025-12-31</k...
</malwareConfig>
5
Extraer IOCs del payload
Con el payload en texto claro, añadir operaciones para extraer automáticamente IOCs: URLs, IPs, dominios, hashes. CyberChef tiene operaciones dedicadas para cada tipo.
CyberChef — Receta completa con extracción de IOCs
// Receta final: desempaquetar + extraer IOCs
1. From Base64
2. RC4           [key: GhostKey2024, key format: UTF8]
3. Gunzip
4. Extract URLs  → https://evil.ghostacademy.lab/beacon
// O en paralelo, guardar el resultado en paso 3 y luego:
4b. Extract IP addresses
4c. Extract domain names

// Guardar la receta como URL para compartir con el equipo:
// Menú → Save Recipe → URL (la URL contiene la receta codificada)
Casos de Uso
🦠 Análisis de Malware con CyberChef

Flujos de trabajo reales para analistas de malware. CyberChef como primera herramienta de triaje antes de pasar al análisis estático/dinámico profundo.

Flujo 1 — PowerShell Ofuscado

ℹ ContextoEl 70% del malware que llega por email usa PowerShell ofuscado como dropper. La técnica más común: IEX con string invertido + Base64 + charcode. CyberChef lo deshace en segundos.
CyberChef — Deofuscar PowerShell típico
// PowerShell malicioso ofuscado (ejemplo real simplificado):
powershell -NoP -NonI -W Hidden -Exec Bypass -Enc
JABjACAAPQAgAFsAUwB5AHMAdABlAG0ALgBDAG8AbgB2AGUAcgB0AF0A...

// La clave: "-Enc" significa Base64 encodificado en UTF-16LE (no UTF-8)
// Receta CyberChef:
1. From Base64     [alphabet: standard]
2. Decode text    [encoding: UTF-16LE]
→ $c = [System.Convert]::FromBase64String("...")
→ IEX([System.Text.Encoding]::Unicode.GetString($c))

// Si hay una capa más de Base64 dentro:
3. Regex           [expr: '(?<=")[A-Za-z0-9+/=]{20,}', output: List]
4. From Base64

Flujo 2 — Shellcode en Hex/VBA

CyberChef — Analizar shellcode de documento Office
// Shellcode extraído de macro VBA (array de bytes en decimal)
Dim buf() As Byte = Array(72,101,108,108,111,32,83,104,101,108,108,99,111,100,101)

// Extraer solo los números:
1. Regular expression [expr: '\d+', output: List matches]
2. From Charcode      [delimiter: Line feed, base: 10]
→ Hello Shellcode

// Si el shellcode está en hex con prefijo 0x:
1. Regular expression [expr: '0x([0-9a-fA-F]{2})', output: List capture groups]
2. From Hex
// Luego buscar strings interesantes:
3. Strings            [min length: 5]

Flujo 3 — Tráfico C2 Sospechoso

CyberChef — Analizar petición HTTP sospechosa
// Cookie sospechosa capturada con Wireshark:
Cookie: session=H4sIAAAAAAAA%2FyrNyclRSkvMTQUAXxRH3AwAAAA%3D%3D

// Receta de análisis:
1. URL Decode     → H4sIAAAAAAAA/yrNyclRSkvMTQUAXxRH3AwAAAA==
2. From Base64
3. Gunzip         → {"cmd":"shell","id":"abc123"}

// Extraer IPs del pcap completo:
1. Extract IP addresses  [display total: true]
2. Sort
3. Unique
Casos de Uso
🏴 CTF con CyberChef

CyberChef es una herramienta imprescindible en CTFs de categoría Crypto, Forensics y Misc. Aquí los patrones más frecuentes y cómo resolverlos en segundos.

Patrón 1 — "Esto parece Base64 pero no decodifica"

CyberChef — CTF Crypto típico
// Flag encodeada múltiples veces con diferentes métodos
Flag: 5a 6d 78 68 5a 79 39 58 53 6b 39 54 56 41 3d 3d

// Parece hex → From Hex → parece Base64 → From Base64
1. From Hex       → ZmxhZy9XSk9TVA==
2. From Base64    → flag/WJOST

// Si aún no es la flag → ROT13, Caesar, invertir...
3. ROT13          → flag/JWBFG... (no es)
3. Reverse        → TSOJW/galf... (no es)
// Usar Magic para que CyberChef lo intente solo:
1. Magic          [depth: 5, intensive: true]

Patrón 2 — Cifrado por sustitución

CyberChef — Análisis de frecuencia + Caesar
// Texto cifrado por sustitución clásica
Syj{p1nz3r_z31gu3_a13_v0e3}

// Estrategia 1: probar ROT con el formato de la flag
// Si vemos que empieza por "Syj{" y las flags empiezan por "CTF{" → ROT 15
1. ROT13 Brute Force  [output: incluyendo el número de rotación]
ROT15: CTF{a1ma3r_m31gj3_n13_k0p3} → revisar manualmente

// Estrategia 2: análisis de frecuencia
1. Chi Square   ← muestra la distribución de frecuencias

// Estrategia 3: Substitute cipher (si conocemos algunos pares)
1. Substitute   [plaintext: ABCD..., ciphertext: ZYXW...]

Patrón 3 — Esteganografía básica

CyberChef — Imagen / fichero con datos ocultos
// Un PNG que contiene datos al final del fichero
// Cargar la imagen en CyberChef como Input
1. To Hex
2. Regex          [expr: '89504e47(.*)504b0304', output: List] ← PNG header a ZIP header
3. From Hex
4. Unzip

// Detectar strings sospechosos al final de un PNG:
1. Strings        [minimum length: 4]
2. Regex          [expr: '[A-Za-z0-9+/=]{20,}']  ← buscar Base64
Casos de Uso
🔬 Forense de Red

Analizar tráfico de red capturado (PCAP/logs) para identificar comunicaciones maliciosas, extraer payloads y reconstruir el ataque.

Extraer y Analizar Cookies/Headers Sospechosos

CyberChef — Analizar User-Agent sospechoso
// User-Agent que no coincide con el navegador declarado
User-Agent: Mozilla/5.0 (compatible; bingbot/2.0; H4sIAAAAAAAA/yrNyclRSk==)

// Extraer el Base64 embebido:
1. Regex      [expr: '[A-Za-z0-9+/]{10,}={0,2}', output: List matches]
→ H4sIAAAAAAAA/yrNyclRSk==
2. From Base64
3. Gunzip     → {"victim":"PC-LAB01","user":"admin","domain":"CORP"}

Reconstruir Ficheros de Tráfico HTTP

CyberChef — Extraer fichero de stream HTTP
// Body de respuesta HTTP con fichero embebido (hex dump de Wireshark)
// Copiar el hex del payload del stream HTTP
1. From Hex
2. Detect File Type  → "Zip archive"
3. Unzip             → malware.exe (dentro del ZIP)
4. MD5               → hash para buscar en VirusTotal

// Si está comprimido con Content-Encoding: gzip:
1. From Hex
2. Gunzip
3. Strings           [min length: 8]  ← buscar IOCs

Análisis de DNS Tunneling

CyberChef — Detectar datos en peticiones DNS
// Queries DNS sospechosas (exfiltración por DNS tunneling)
Queries: JBSWY3DPFQQFO33SNRSCC.evil.com
         JBSWY3DPEBLW64TMMQ2TE.evil.com
         JBSWY3DPEB3W65LSMUQQ.evil.com

// Extraer el subdominio (la parte de datos):
1. Regex          [expr: '^([A-Z2-7]+)\.', output: List capture groups]
2. Join           [delimiter: '']   ← unir todos los fragmentos
3. From Base32    → Hello World!... (datos exfiltrados)
Avanzado — 01
✨ Magic Operation

La operación más potente de CyberChef para el analista sin contexto. Intenta detectar automáticamente el tipo de dato e identificar la receta para decodificarlo.

★ Cuándo usar MagicCuando recibes un dato y no tienes idea de qué es. Magic ejecuta cientos de decodificaciones en paralelo, analiza el output buscando texto legible o tipos de archivo conocidos, y te muestra los resultados más prometedores ordenados por puntuación.
CyberChef — Configuración óptima de Magic
// Añadir Magic a la receta con estos parámetros:
Depth:      3   ← número de capas que intentará (3-5 para payloads multicapa)
Intensive:  ✓   ← prueba más combinaciones (más lento pero más completo)
Extensive:  ✓   ← incluye operaciones de cifrado con claves comunes
Crib:       CTF{  ← texto que esperas encontrar (ayuda a Magic a identificar hits)
                   En malware: "<?xml", "MZ", "PK", "#!/"

// Magic con crib para malware:
Magic [depth: 5, intensive: true, crib: "MZ"]
→ Encuentra que bajo 2 capas de Base64 hay un ejecutable PE (MZ = magic bytes de .exe)

Limitaciones de Magic

⚠ Cuándo Magic fallaMagic no puede adivinar claves de cifrado simétricas arbitrarias. Si el payload usa AES con clave random o RC4 con clave compleja, Magic no encontrará la solución. Requiere análisis estático del binario o fuentes externas para obtener la clave.
Avanzado — 02
🔍 Regex y Extracción

CyberChef tiene operaciones de regex de primer nivel. Combinadas con operaciones de extracción especializada, permiten extraer IOCs masivamente de cualquier fuente de texto.

Extracción de IOCs con Operaciones Dedicadas

CyberChef — Extracción masiva de IOCs
// Extraer IPs de un log de firewall
1. Extract IP addresses  [IPv4: ✓, IPv6: ✓, display total: ✓]
2. Sort
3. Unique
4. Filter                [regex: '^(?!10\.|192\.168\.|172\.(1[6-9]|2|3))']
   ← eliminar IPs privadas, solo quedan IPs públicas sospechosas

// Extraer URLs de texto/HTML malicioso
1. Extract URLs          [display total: ✓]
2. Filter                [regex: '(?i)(exe|dll|bat|ps1|php|aspx)$']
   ← solo URLs que apuntan a ficheros ejecutables

// Extraer dominios (sin la parte de ruta)
1. Extract domains
2. Unique

Regex Avanzada para Análisis de Malware

CyberChef — Patrones regex útiles en análisis
// Encontrar strings Base64 largos (posibles payloads)
Regex: [A-Za-z0-9+/]{40,}={0,2}

// Encontrar hashes MD5 sueltos en un texto
Regex: \b[0-9a-fA-F]{32}\b

// Encontrar SHA-256
Regex: \b[0-9a-fA-F]{64}\b

// Encontrar rutas de Windows en logs
Regex: [A-Za-z]:\\(?:[^\\/:*?"<>|\r\n]+\\)*[^\\/:*?"<>|\r\n]*

// Encontrar comandos PowerShell ofuscados
Regex: (?i)(-enc|-encodedcommand)\s+[A-Za-z0-9+/=]{10,}

// Extraer user-agents en logs de apache
Regex: (?<=")(Mozilla[^"]+)(?=")
Avanzado — 03
⚙️ Scripting con la API de CyberChef

CyberChef puede usarse como librería Node.js para automatizar el procesamiento de muestras. Ideal para integrar en pipelines de análisis forense o SOAR.

Node.js — CyberChef como librería
// Instalar
npm install cyberchef

// Script: desempaquetar payload B64+RC4+GZIP automáticamente
const { chef } = require('cyberchef');

async function unpackPayload(encodedPayload, rc4Key) {
  const result = await chef.bake(encodedPayload, [
    { "op": "From Base64",
      "args": ["A-Za-z0-9+/=", true] },
    { "op": "RC4",
      "args": [{"option":"UTF8","string":rc4Key}, "Latin1", "Latin1"] },
    { "op": "Gunzip",
      "args": [] }
  ]);
  return result.value;
}

// Procesar un directorio de muestras
const samples = ["TxUBHv...", "H4sIAA...", "eJyrVk..."];
for (const sample of samples) {
  const plain = await unpackPayload(sample, 'GhostKey2024');
  console.log('[+] Payload:', plain);
}
Docker — CyberChef como servidor REST
# Levantar CyberChef como API REST
docker run -d -p 3000:3000 mpepping/cyberchef

# Llamar a la API con una receta codificada
curl -s "http://localhost:3000/api/v1/bake" \
  -H "Content-Type: application/json" \
  -d '{
    "input": "SGVsbG8gV29ybGQ=",
    "recipe": [{"op": "From Base64", "args": ["A-Za-z0-9+/=", true]}]
  }' | jq .value
"Hello World"
Recursos
✅ Referencia Rápida

Checklist de análisis y tabla de referencia para el día a día con CyberChef.

Checklist de Análisis de Payload Desconocido

Tabla de Referencia — Payload Multicapa

Pista VisualTipo ProbableOperación CyberChefSiguiente paso
A-Za-z0-9+/= (multiplo 4)Base64From Base64Ver hex del output
A-Za-z0-9-_ (url-safe)Base64 URLFrom Base64 URLVer hex del output
Solo 0-9a-f en paresHexFrom HexDetect File Type
%XX repetidoURL EncodeURL DecodeSiguiente capa
1f 8b (hex)GZIPGunzipTexto/binario
78 9c / 78 da (hex)ZlibZlib InflateTexto/binario
50 4b 03 04 (hex)ZIPUnzipFicheros internos
4d 5a (hex) = "MZ"PE .exeStrings / MD5Análisis estático
Bytes "aleatorios"CifradoXOR BF / RC4 / AESBuscar la clave
JABjACAAP… (Base64 UTF16)PowerShellFrom Base64 → Decode UTF-16LEDeofuscar PS

URLs Esenciales