YARA: Guía Completa de Reglas de Detección de Malware

Por qué YARA es esencial en ciberseguridad

YARA es el lenguaje de detección de malware más utilizado en la industria. Sandboxes como Cuckoo y Any.run lo usan para clasificar muestras. Los EDR/XDR lo aplican en endpoints. Los feeds de threat intelligence lo distribuyen como formato estándar.

En un panorama donde las amenazas evolucionan constantemente, la capacidad de compartir indicadores de compromiso (IOCs) de forma estructurada es crítica. YARA ofrece un formato legible tanto para humanos como para herramientas automatizadas, lo que lo convierte en el puente ideal entre el análisis manual de malware y la detección a escala. Cuando un investigador de una empresa privada descubre una nueva familia de ransomware, puede crear una regla YARA y compartirla con su sector a través de ISACs (Information Sharing and Analysis Centers). Esta regla puede ser importada por decenas de organizaciones en minutos, protegiendo miles de endpoints sin necesidad de un archivo de firma tradicional.

Además, YARA se integra nativamente con plataformas de orquestación como MISP y frameworks de threat intelligence como OpenCTI, lo que permite automatizar desde la ingestión de inteligencia hasta la respuesta ante incidentes.

Si trabajas en SOC, respuesta a incidentes o análisis de malware, YARA es una herramienta que debes dominar.

Estructura de una regla YARA

rule Nombre_de_la_Regla {
    meta:
        description = "Descripción de qué detecta"
        author = "Tu nombre"
        date = "2026-07-23"
        severity = "high"

    strings:
        $texto1 = "cadena a buscar" ascii wide
        $hex_pattern = { 8B 45 ?? 03 C1 89 45 }
        $regex = /https?:\/\/[a-z]+\.[a-z]+\/gate/i

    condition:
        2 of them
}

Componentes:

• Metadatos: información descriptiva de la regla
• Strings: patrones de texto, bytes o regex que identifican el malware
• Condiciones: lógica que determina cuándo la regla aplica

Instalación

# Ubuntu/Debian
sudo apt install yara

# macOS
brew install yara

# Verificar
yara --version

Regla básica: detectar un servidor C2

rule Detect_C2_Server {
    meta:
        description = "Detecta malware que contacta evil-server.com"
        severity = "high"
        reference = "https://threat-intel.example.com/report"

    strings:
        $c2_url = "http://evil-server.com/beacon" ascii wide
        $c2_path = "/gate.php" ascii
        $mutex = "Global\\Mutex_Malware_v3" ascii

    condition:
        2 of them
}

Uso:

yara detect_c2.yar suspicious_file.exe
yara -r detect_c2.yar /tmp/samples/  # recursivo
yara -s detect_c2.yar file.exe  # muestra strings que matchearon

Regla avanzada: detectar ransomware por comportamiento

import "pe"

rule Detect_Ransomware {
    meta:
        description = "Detección de ransomware por comportamiento"
        severity = "critical"

    strings:
        $readme1 = "YOUR FILES ARE ENCRYPTED" ascii wide nocase
        $readme2 = "DECRYPT" ascii wide nocase
        $ext = ".locked" ascii
        $vssadmin = "vssadmin delete shadows" ascii wide nocase
        $bcdedit = "bcdedit /set {default} recoveryenabled no" ascii wide nocase

    condition:
        uint16(0) == 0x5A4D and
        filesize < 10MB and
        (
            (2 of ($readme*) and 1 of ($ext, $vssadmin)) or
            ($vssadmin and $bcdedit)
        )
}

Explicación de la condición:

• uint16(0) == 0x5A4D: debe ser un ejecutable PE (MZ header)
• filesize < 10MB: exclusión de archivos legítimos grandes
• Combinación de strings de ransomware con comportamiento destructivo

Reglas modulares con private rules

// base_rules.yar — strings comunes reutilizables
private rule Is_PE {
    condition:
        uint16(0) == 0x5A4D
}

private rule Has_Network {
    strings:
        $http = "http://" ascii
        $https = "https://" ascii
        $tor = ".onion" ascii
    condition:
        2 of them
}

// malware_rules.yar — reutiliza las reglas base
import "pe"

rule Malware_Generic {
    strings:
        $api1 = "CreateRemoteThread" ascii
        $api2 = "VirtualAllocEx" ascii
        $api3 = "WriteProcessMemory" ascii

    condition:
        Is_PE and
        Has_Network and
        2 of ($api*)
}

Uso en respuesta a incidentes

Escaneo de dumps de memoria

# Extraer dumps con Volatility
python vol.py -f imagen.raw windows.memmap --pid 1234 --dump-dir ./dumps/

# Escanear dumps con YARA
yara -r rules/ ./dumps/*.bin > vol_yara_results.txt

Escaneo de filesystem

# Buscar indicadores en todo el sistema
yara -r iocs_rules/ / --exclude-dir=proc 2>/dev/null > system_scan.txt

Integración con Cuckoo Sandbox

# Cuckoo ejecuta YARA automáticamente sobre muestras
# Configurar en /etc/cuckoo/conf/analysis.conf:
# [yara]
# enabled = yes
# rules_path = /opt/yara/rules/

Mejores prácticas

1. Sé específico: mejor 3 strings específicos que 1 genérico
2. Siempre incluye metadatos: descripción, autor, severidad, referencia
3. Usa private rules para reutilizar strings comunes
4. Testea contra el sistema limpio: escanea /usr/bin/ y Windows/system32
5. Versiona tus reglas en Git para mantener historial de cambios
6. Evita falsos positivos con condiciones específicas y exclusiones

Automatización con scripts

#!/bin/bash
# Escáner YARA automatizado
RULES="/opt/yara/rules"
TARGETS=("/tmp/suspicious" "/mnt/evidence")
REPORT="/var/log/yara_$(date +%Y%m%d).log"

echo "=== ESCANEO YARA $(date) ===" > "$REPORT"
for dir in "${TARGETS[@]}"; do
    yara -r "$RULES" "$dir" 2>/dev/null >> "$REPORT"
done

# Enviar alerta si hay coincidencias
if grep -q "^[a-z].*:" "$REPORT"; then
    echo "ALERTA: Coincidencias YARA" | mail -s "YARA Alert" soc@empresa.com
fi

YARA en Threat Intelligence

YARA no es solo una herramienta de análisis local: es un pilar del intercambio de inteligencia de amenazas a nivel global. Existen múltiples plataformas y comunidades que distribuyen reglas YARA como parte de sus feeds de inteligencia.

MISP (Malware Information Sharing Platform)

MISP es la plataforma open-source más utilizada para compartir IOCs entre organizaciones. Soporta reglas YARA nativamente: cuando se publica un evento en MISP, las reglas YARA asociadas se distribuyen a todos los peers suscritos. Puedes importar reglas directamente con el módulo misp-modules:

# Importar regla YARA desde MISP
misp-modules -s yara -i /opt/misp-modules/

AlienVault OTX (Open Threat Exchange)

OTX permite a la comunidad compartir pulsos de amenazas que incluyen reglas YARA. Cada pulso contiene IOCs enlazados con contextos geográficos, tácticos MITRE ATT&CK y referencias a CVEs. Puedes descargar reglas YARA de cualquier pulso y ejecutarlas contra tus endpoints:

# Descargar reglas desde OTX API
curl -H "X-OTX-API-KEY: tu_api_key" \
  https://otx.alienvault.com/api/v1/pulses/download_rules?format=yara > otx_rules.yar

Repositorios públicos de reglas YARA

Existen repositorios mantenidos por la comunidad con miles de reglas listas para usar:

• Neo23x0/signature-base: una de las colecciones más completas, con reglas para APTs, webshells, exploits y malware genérico
• Yara-Rules/rules: repositorio colaborativo en GitHub con reglas verificadas por la comunidad
• FireEye/arc-a-rules: reglas de Mandiant para detección de tactics de APTs
• Malpedia: repositorio académico con reglas asociadas a cada familia de malware catalogada

# Clonar y usar reglas de Neo23x0
git clone https://github.com/Neo23x0/signature-base.git /opt/yara/signature-base
yara -r /opt/yara/signature-base/yara/ suspicious_file.exe

Integración con EDR y SIEM

Muchos EDR modernos (CrowdStrike, SentinelOne, Carbon Black) permiten cargar reglas YARA personalizadas como políticas de detección. En entornos SIEM como Splunk o Elastic, puedes usar YARA como paso intermedio en pipelines de ingestion de archivos sospechosos, ejecutándola contra archivos extraídos de correos electrónicos o descargas antes de indexarlos.

Patrones comunes en reglas YARA

Existen patrones recurrentes que toda regla YARA efectiva tiende a incluir. Conocerlos te permite escribir detecciones más rápidas y precisas.

Detección por cabeceras de archivo

rule Detect_ELF_Binary {
    condition:
        uint32(0) == 0x464C457F  # .ELF
}

rule Detect_PDF_Document {
    strings:
        $pdf = "%PDF-"
    condition:
        $pdf at 0
}

Detección por APIs sospechosas (PE)

rule Suspicious_API_Combination {
    strings:
        $api1 = "VirtualAllocEx" ascii
        $api2 = "WriteProcessMemory" ascii
        $api3 = "CreateRemoteThread" ascii
        $api4 = "NtUnmapViewOfSection" ascii
    condition:
        uint16(0) == 0x5A4D and 3 of ($api*)
}

Detección por URLs y dominios

rule Detect_C2_URL_Pattern {
    strings:
        $url = /https?:\/\/[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\/[a-z]+\/gate/i
        $domain = /\/[a-z0-9]{8,16}\.(top|xyz|buzz|tk)\/c2/i
    condition:
        $url or $domain
}

Detección por comportamiento de ransomware

rule Ransomware_Behavior_Indicators {
    strings:
        $shadow = "vssadmin delete shadows" ascii wide nocase
        $bcdedit = "bcdedit /set {default} recoveryenabled no" ascii wide nocase
        $wmi = "wmic shadowcopy delete" ascii wide nocase
        $readme = "DECRYPT" ascii wide nocase
        $bitcoin = "bitcoin" ascii wide nocase
    condition:
        ($shadow or $wmi) and $bcdedit and ($readme or $bitcoin)
}

Detección de webshells

rule Detect_PHP_Webshell {
    strings:
        $eval = "eval($_" ascii
        $base64 = "base64_decode" ascii
        $shell_exec = "shell_exec(" ascii
        $passthru = "passthru(" ascii
    condition:
        filesize < 500KB and
        ($eval and $base64) or
        (2 of ($shell_exec, $passthru, $eval, $base64))
}

Mejores prácticas

1. Sé específico: mejor 3 strings específicos que 1 genérico. Una regla con un solo string como "cmd.exe" generará falsos positivos infinitos en cualquier sistema Windows.
2. Siempre incluye metadatos: descripción, autor, severidad, referencia, fecha y fuente de la amenaza. Cuando tu regla sea compartida, otros analistas necesitarán contexto para evaluar si es relevante para su entorno.
3. Usa private rules para reutilizar strings comunes. Esto reduce la duplicación y facilita el mantenimiento: si necesitas actualizar un patrón de detección de PE, lo haces una sola vez.
4. Testea contra el sistema limpio: escanea /usr/bin/, /usr/lib/, Windows/system32 y directorios de Office antes de activar una regla en producción. Si genera falsos positivos en binarios legítimos, ajusta las condiciones.
5. Versiona tus reglas en Git para mantener historial de cambios. Usa tags para marcar versiones y ramas para desarrollo de reglas en staging.
6. Evita falsos positivos con condiciones específicas y exclusiones. Combinar la detección de strings con verificaciones de cabecera de archivo, tamaño y secciones PE reduce drásticamente el ruido.
7. Documenta la fuente de la amenaza: incluye en los metadatos el reporte original, el actor APT o la campaña asociada. Esto facilita la correlación con otros IOCs.
8. Mantén tus reglas actualizadas: los autores de malware modifican sus tools para evadir detecciones. Revisa y actualiza reglas periódicamente, especialmente si cubren familias activas.
9. Usa import "pe" y import "math" para análisis estático más preciso. Puedes verificar la sección .text, el entropy de secciones o la presencia de overlays sospechosos.
10. Comparte reglas con la comunidad: publica en repositorios abiertos o a través de ISACs. La detección colaborativa es más efectiva que la individual.

Errores comunes al escribir reglas YARA

Incluso analistas experimentados cometen errores al escribir reglas YARA. Estos son los más frecuentes y cómo evitarlos.

Falsos positivos por strings genéricos

El error más común. Usar strings como "password" o "admin" detectará miles de archivos legítimos. La solución es combinar múltiples strings específicos con condiciones que validen el contexto del archivo.

// MAL: demasiado genérico, miles de falsos positivos
rule Bad_Rule {
    strings:
        $s = "password"
    condition:
        $s
}

// BIEN: combinación específica con contexto
rule Good_Rule {
    strings:
        $s1 = "password" ascii
        $s2 = "cmd.exe /c" ascii
        $s3 = "HKLM\\Software" ascii
    condition:
        uint16(0) == 0x5A4D and filesize < 2MB and 2 of ($s*)
}

Reglas demasiado amplias en condición

Usar condition: any of them sin restricciones de tipo de archivo o tamaño causa falsos positivos en binarios, scripts, documentos y bases de datos. Siempre acota el dominio de detección.

Ignorar la arquitectura del archivo

No verificar si el archivo es PE, ELF o PDF antes de buscar strings específicos de una plataforma puede generar falsos positivos. Usa uint16(0) o uint32(0) para validar cabeceras.

No usar nocase cuando es necesario

Si el malware varía el casing de sus strings para evadir detección (por ejemplo, "DeCrYpT" en vez de "DECRYPT"), olvidar nocase hará que la regla falle.

Strings hex demasiado flexibles

Los wildcards ?? en patrones hex son útiles para saltar bytes variables, pero usar demasiados consecutivos genera coincidencias en archivos no relacionados. Limita los wildcards a bytes que realmente varían entre variantes.

No testear en diferentes sistemas operativos

Una regla que funciona en Windows puede no funcionar en Linux por diferencias en paths, encodings o formatos de archivo. Testea siempre en el sistema operativo objetivo.

# Testear regla en un conjunto conocido de malware
yara -r rules/ /opt/malware-samples/ --fail-on-warnings 2>&1 | head -50

Olvidar actualizar reglas cuando cambia la infraestructura del atacante

Si tu regla detecta un dominio C2 específico y el atacante lo cambia, la regla deja de ser útil. Mantén un ciclo regular de revisión y actualización de reglas, especialmente para amenazas activas.

• GREM (GIAC Reverse Engineering Malware): documentación y producción de firmas YARA
• GCIH (GIAC Certified Incident Handler): detección de malware durante incidentes
• GCFE (GIAC Certified Forensics Examiner): análisis forense con detección de malware
• eCDFP (Certified Digital Forensics Professional): análisis forense con herramientas de detección

Conclusión

YARA es una herramienta fundamental para cualquier equipo de ciberseguridad defensiva. Permite automatizar la detección de malware, compartir indicadores de amenazas y clasificar muestras de forma consistente.

La clave: empieza con reglas simples, testea contra colecciones conocidas y ve complejizándolas a medida que entiendas los patrones de las amenazas que enfrentas.

---

Herramientas relacionadas: Volatility (análisis forense de memoria), Wireshark (análisis de red)

Artículos relacionados:

• Análisis de malware: técnicas estáticas y dinámicas
• Análisis forense de memoria con Volatility