¿Qué es YARA y para qué se usa en peritaje forense?

YARA es una herramienta que identifica malware y archivos sospechosos mediante reglas personalizadas. En peritaje forense se usa para: detectar malware en dispositivos incautados, clasificar amenazas (ransomware, troyanos, APTs), buscar archivos específicos en grandes volúmenes de datos, y generar evidencia técnica documentada de infección.

¿Cómo funciona una regla YARA?

Una regla YARA define patrones a buscar: cadenas de texto (strings), secuencias de bytes hexadecimales, condiciones lógicas. YARA escanea archivos/memoria comparando su contenido con estas reglas. Si encuentra coincidencias (match), marca el archivo como sospechoso y genera un reporte forense.

¿YARA detecta todos los malware?

NO. YARA solo detecta lo que sus reglas definen. Malware desconocido (zero-day) o altamente polimórfico puede evadir reglas. Por eso en análisis forense se combina YARA con: análisis de hashes (VirusTotal), sandboxing, análisis de comportamiento, y análisis de red para detección completa.

YARA Rules - Identificación de Malware en Peritaje Forense | Glosario

¿Qué es YARA?

YARA (Yet Another Recursive Acronym) es una herramienta de análisis forense y seguridad que permite:

Identificar malware mediante patrones y firmas personalizadas
Clasificar amenazas (ransomware, troyanos, APTs, webshells)
Buscar archivos específicos en grandes volúmenes de datos
Detectar indicadores de compromiso (IOCs) en memoria y disco
Generar evidencia forense documentada de infecciones

Creada por Víctor Álvarez

YARA fue desarrollada por Víctor Álvarez (VirusTotal, ahora Google) en 2008 como herramienta interna de VirusTotal. Es open source y se ha convertido en estándar de facto para investigadores de malware y analistas forenses.

¿Cómo Funciona YARA?

Concepto Básico

YARA funciona mediante reglas que definen patrones a buscar:

┌──────────────────────────────┐
│ Regla YARA                   │
│ ────────────────             │
│ rule Ransomware_WannaCry {   │
│   strings:                   │
│     $str1 = "tasksche.exe"   │
│     $str2 = "msg/m_spanish"  │
│   condition:                 │
│     all of them              │
│ }                            │
└──────────────────────────────┘
           │
           │ Escanea
           ↓
┌──────────────────────────────┐
│ Archivo sospechoso.exe       │
│ ────────────────             │
│ [Bytes del archivo...]       │
│ ...tasksche.exe...           │ ← Match!
│ ...msg/m_spanish...          │ ← Match!
└──────────────────────────────┘
           │
           │ Si condición cumple
           ↓
      ✓ MATCH: WannaCry detectado

Anatomía de una Regla YARA

rule NombreDeLaRegla {
    meta:
        author = "Jonathan Izquierdo"
        description = "Detecta ransomware X"
        date = "2026-01-26"

    strings:
        $cadena_texto = "C2_SERVER_ADDRESS"
        $bytes_hex = { 4D 5A 90 00 03 }
        $regex = /[A-Z]{32}/ nocase

    condition:
        $cadena_texto and $bytes_hex
}

Componentes:

meta: Metadatos (autor, descripción, referencias)
strings: Patrones a buscar (texto, bytes, regex)
condition: Lógica para determinar match (AND, OR, NOT)

Tipos de Patrones YARA

1. Cadenas de Texto

rule Backdoor_Strings {
    strings:
        $cmd1 = "cmd.exe /c"
        $cmd2 = "powershell.exe -enc"
        $exfil = "http://malicious-c2.com"

    condition:
        2 of ($cmd*, $exfil)
}

2. Bytes Hexadecimales

rule PE_Executable {
    strings:
        // Cabecera MZ de ejecutables Windows
        $mz_header = { 4D 5A }

        // Cabecera PE
        $pe_header = { 50 45 00 00 }

    condition:
        $mz_header at 0 and $pe_header
}

3. Expresiones Regulares

rule Email_Exfiltration {
    strings:
        // Patrón de email
        $email = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[A-Z]{2,}/ nocase

        // Patrón de tarjeta de crédito
        $cc = /\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b/

    condition:
        $email and $cc
}

4. Condiciones Avanzadas

rule Malware_Packed {
    strings:
        $upx = "UPX!" // Empaquetador UPX
        $entropy_high = { [1-255] } // Bytes aleatorios

    condition:
        // Archivo > 100KB y empieza con MZ y contiene UPX
        filesize > 100KB and
        uint16(0) == 0x5A4D and
        $upx and
        math.entropy(0, filesize) > 7.5  // Alta entropía = código ofuscado
}

Uso Forense de YARA

1. Escaneo de Archivos en Disco

# Escanear archivo individual
yara rules/malware.yar archivo_sospechoso.exe

# Escanear directorio recursivamente
yara -r rules/ /ruta/evidencia/

# Escanear con múltiples reglas
yara -r /usr/share/yara/rules/ /mnt/imagen_forense/

# Output con metadatos
yara -m -r rules/ evidencia/ > resultados_yara.txt

Output ejemplo:

WannaCry_Ransomware /mnt/evidencia/Desktop/archivo.exe
  [meta:author="Researcher X"]
  [meta:description="WannaCry ransomware variant"]

CobaltStrike_Beacon /mnt/evidencia/Temp/svchost.exe
  [meta:family="CobaltStrike"]

2. Escaneo de Memoria RAM

# Volcar memoria con herramienta forense
sudo lime-dump -o memoria.lime

# Escanear dump de memoria con YARA
yara -s rules/memory_malware.yar memoria.lime

# Usando Volatility + YARA
volatility -f memoria.lime --profile=Win10x64 yarascan \
  --yara-file=rules/backdoor.yar

3. Integración con Herramientas Forenses

Autopsy (The Sleuth Kit):

# YARA integrado en Autopsy
# File Analysis → YARA Rule Search

ClamAV (Antivirus):

# Convertir reglas YARA a formato ClamAV
yara2clamav rules/malware.yar > malware.clamav

VirusTotal Intelligence:

# Buscar archivos que cumplan regla YARA en VT
vt search "content:{yara_rule}"

Casos de Uso en Peritaje Informático

Caso 1: Detección de Ransomware en Análisis Post-Infección

Situación: Empresa víctima de ransomware, necesita determinar variante y alcance

Regla YARA para detección:

rule Ransomware_Generic {
    meta:
        author = "Perito Forense"
        description = "Detecta comportamiento típico de ransomware"
        severity = "critical"

    strings:
        // Extensiones típicas de ransomware
        $ext1 = ".encrypted"
        $ext2 = ".locked"
        $ext3 = ".crypt"

        // Notas de rescate
        $ransom1 = "Bitcoin" nocase
        $ransom2 = "decrypt" nocase
        $ransom3 = "payment" nocase

        // APIs de cifrado Windows
        $api1 = "CryptEncrypt"
        $api2 = "CryptGenKey"

    condition:
        // Al menos 1 extensión + 2 términos de rescate + 1 API
        (any of ($ext*)) and
        (2 of ($ransom*)) and
        (any of ($api*))
}

Proceso forense:

Preservar evidencia
- Imagen forense del disco
- Dump de memoria RAM

Escanear con YARA

yara -r ransomware_rules/ /mnt/imagen_forense/ > infeccion_yara.txt

Analizar matches

Ransomware_Generic /mnt/evidencia/Users/Admin/AppData/Roaming/system.exe
Ransomware_Generic /mnt/evidencia/Windows/Temp/updater.exe

Clasificar variante
- Comparar con bases de datos (MITRE ATT&CK, Malpedia)
- Identificar familia específica (WannaCry, REvil, LockBit)
Documentar en informe pericial
- Archivos infectados detectados por YARA
- Variante identificada
- Alcance de la infección

Caso 2: Búsqueda de Webshells en Servidor Comprometido

Situación: Servidor web hackeado, sospecha de webshell persistente

Regla YARA para webshells PHP:

rule Webshell_PHP_Generic {
    meta:
        description = "Detecta webshells PHP comunes"
        author = "Perito Forense"

    strings:
        // Funciones peligrosas PHP
        $exec1 = "exec(" nocase
        $exec2 = "shell_exec(" nocase
        $exec3 = "system(" nocase
        $exec4 = "passthru(" nocase

        // Evaluación de código remoto
        $eval = "eval(" nocase
        $assert = "assert(" nocase

        // Input de usuario (parámetros HTTP)
        $input1 = "$_GET"
        $input2 = "$_POST"
        $input3 = "$_REQUEST"

    condition:
        // Archivo PHP con funciones peligrosas + input HTTP
        (2 of ($exec*, $eval, $assert)) and
        (any of ($input*))
}

Escaneo forense:

# Escanear directorio web
yara -r webshell_rules.yar /var/www/html/ > webshells_detectados.txt

# Output:
Webshell_PHP_Generic /var/www/html/wp-content/uploads/plugin.php
Webshell_PHP_Generic /var/www/html/admin/config.php.bak

Caso 3: Detección de APTs (Advanced Persistent Threats)

Situación: Análisis de intrusión sofisticada en infraestructura corporativa

Regla YARA para APT específico:

import "pe"

rule APT_CobaltStrike_Beacon {
    meta:
        description = "Detecta Cobalt Strike Beacon"
        reference = "https://www.cobaltstrike.com/"
        family = "CobaltStrike"

    strings:
        // Artefactos de Cobalt Strike
        $beacon_dll = "beacon.dll" nocase
        $cobaltstrike_str = "%s as %s\\%s: %d"

        // Configuración de C2
        $c2_config = { 00 01 00 01 00 02 }

        // Named pipes típicos
        $pipe1 = "\\\\.\\pipe\\msagent_"
        $pipe2 = "\\\\.\\pipe\\MSSE-"

    condition:
        // Ejecutable Windows
        uint16(0) == 0x5A4D and
        // Con al menos 2 indicadores de Beacon
        (2 of them)
}

Repositorios de Reglas YARA Públicas

Repositorio	URL	Contenido
YARA-Rules (Official)	github.com/Yara-Rules/rules	Reglas comunitarias variadas
Malware Bazaar	bazaar.abuse.ch/browse.php?search=yara	Reglas de malware reciente
ReversingLabs	github.com/reversinglabs/reversinglabs-yara-rules	APTs, ransomware, trojans
Florian Roth	github.com/Neo23x0/signature-base	THOR APT Scanner rules
MITRE ATT&CK	car.mitre.org	Reglas basadas en tácticas ATT&CK

Crear Reglas YARA Personalizadas para Peritaje

Método: Ingeniería Inversa

Obtener muestra del malware
- De evidencia del caso
- De repositorios públicos (Malware Bazaar, VirusTotal)

Análisis estático

# Ver strings
strings malware.exe | less

# Ver imports/exports
objdump -p malware.exe

# Ver secciones PE
pev malware.exe

Identificar patrones únicos
- Cadenas de texto hardcodeadas
- Direcciones C2
- Claves de registro específicas
- Mutexes únicos

Escribir regla YARA

rule MalwareCustom_Case2025 {
    meta:
        case_id = "2025-034"
        description = "Malware encontrado en caso peritaje"
        author = "Jonathan Izquierdo"

    strings:
        // Cadenas únicas identificadas
        $c2 = "malicious-domain.com"
        $mutex = "Global\\UniqueMutexName"
        $key = "HKLM\\Software\\Malware\\Config"

    condition:
        all of them
}

Validar regla

# Escanear muestra original (debe dar match)
yara regla_custom.yar malware.exe

# Escanear archivos limpios (NO debe dar match)
yara regla_custom.yar /bin/ls

Evitar Falsos Positivos

Reglas Demasiado Genéricas

Una regla como strings: $str = "error" dará falsos positivos en miles de archivos legítimos. Las reglas deben ser específicas combinando múltiples indicadores únicos.

Buenas prácticas:

✓ Combinar al menos 3-5 indicadores distintos ✓ Usar condiciones lógicas estrictas (AND, not just OR) ✓ Verificar con archivos legítimos conocidos ✓ Incluir hashes de archivos maliciosos conocidos

Limitaciones de YARA

❌ Limitación 1: Solo Detecta Lo Que Se Define

Problema: Malware desconocido (zero-day) no tiene reglas

Mitigación: Combinar con análisis heurístico, sandboxing, detección por comportamiento

❌ Limitación 2: Malware Polimórfico

Problema: Malware que cambia su código en cada ejecución

Mitigación: Crear reglas basadas en comportamiento (APIs llamadas) en lugar de bytes estáticos

❌ Limitación 3: Performance en Grandes Volúmenes

Problema: Escanear imágenes forenses de TB puede ser lento

Mitigación: Paralelización, escaneo selectivo, pre-filtrado por extensiones

❌ Limitación 4: Reglas Desactualizadas

Problema: Malware evoluciona, reglas quedan obsoletas

Mitigación: Actualizar regularmente repositorios, suscribirse a threat intelligence

Documentación Forense con YARA

Informe Pericial: Sección de Análisis YARA

Ejemplo:

3. Análisis de Malware con YARA
Se realizó escaneo forense del disco incautado utilizando herramienta YARA v4.5.0 con repositorio de reglas actualizado al 20/03/2025.
Reglas aplicadas:
Repositorio YARA-Rules (github.com/Yara-Rules/rules)
Reglas personalizadas para ransomware conocido
Total: 1,247 reglas activas
Resultados:
Archivo Ruta Regla YARA Familia
svchost.exe C:\Users\Admin\AppData\Roaming\ Ransomware_Lockbit3 LockBit 3.0
updater.exe C:\Windows\Temp\ Ransomware_Lockbit3 LockBit 3.0
Hash SHA-256 de archivos detectados:
svchost.exe: a3b2c1d4e5f6...
updater.exe: 7f8e9d0c1b2a...
Conclusión: La presencia de archivos que coinciden con reglas YARA de la familia LockBit 3.0 confirma la infección por ransomware. Los hashes fueron verificados contra VirusTotal (70/72 antivirus detectan como malicioso).

Archivo	Ruta	Regla YARA	Familia
svchost.exe	C:\Users\Admin\AppData\Roaming\	Ransomware_Lockbit3	LockBit 3.0
updater.exe	C:\Windows\Temp\	Ransomware_Lockbit3	LockBit 3.0

Conclusión

YARA es una herramienta fundamental en el arsenal forense para identificación y clasificación de malware. Su flexibilidad mediante reglas personalizadas permite adaptar la detección a las necesidades específicas de cada investigación pericial. La combinación de YARA con análisis de hashes, sandboxing y análisis de comportamiento proporciona evidencia técnica sólida de infecciones.

Última actualización: 26 de enero de 2026 Categoría: Técnico Código: YAR-001

Artículos relacionados: