Reglas YARA

YARA es el lenguaje estándar para describir y detectar malware mediante patrones: defines reglas que buscan secuencias de bytes, strings o condiciones en ficheros y en memoria, y YARA te dice qué muestras coinciden. Es la herramienta puente entre el análisis (ver Análisis estático de malware/Análisis dinámico de malware) y la detección: una vez entiendes una muestra, escribes una regla YARA que detecta esa familia en toda tu flota. Lo usan AV, EDR, sandboxes y threat hunters.

Anatomía de una regla

rule NombreFamilia_Variante
{
    meta:
        author = "theoffsecgirl"
        description = "Detecta la familia X"
        hash = "sha256..."
        date = "2026-01-01"
    strings:
        $s1 = "cadena_caracteristica" ascii
        $s2 = "C:\\ruta\\del\\malware" wide
        $hex = { 48 8B ?? ?? E8 ?? ?? ?? ?? }   // bytes con comodines
        $re = /mutex_[a-f0-9]{8}/               // expresión regular
    condition:
        uint16(0) == 0x5A4D and                 // es un PE (cabecera MZ)
        2 of ($s*) and $hex                     // lógica de coincidencia
}

Los componentes

meta       metadatos (autor, descripción, hash, referencia) -> documentación
strings    patrones a buscar:
  "texto" ascii/wide/nocase    cadenas (ASCII/UTF-16/sin distinguir mayúsculas)
  { 48 8B ?? }                 bytes en hex, ?? = comodín, [n-m] = salto
  /regex/                      expresiones regulares
condition  la lógica booleana que decide si coincide:
  any of them / all of them / N of ($s*)
  uint16(0)==0x5A4D            comprobaciones sobre el fichero (cabeceras, offsets)
  filesize < 100KB             condiciones de tamaño
  módulos: pe.imports(...), math.entropy(...) -> análisis avanzado del PE

Escribir una buena regla

# del análisis sacas los patrones ÚNICOS de la familia:
- strings características (mensajes, rutas, mutexes, user-agents, config)
- secuencias de bytes de código propio (no de librerías comunes)
- imports/estructura (módulo pe: pe.imphash, pe.imports)
# objetivo: detectar la FAMILIA (variantes incluidas), no solo una muestra
#   -> patrones estables entre variantes, evitar strings que cambian cada build
# evitar FALSOS POSITIVOS:
- no usar strings genéricas ("error", "http") ni bytes de código de compilador/libc
- probar la regla contra un corpus benigno (goodware) antes de desplegar

Usar YARA

# escanear ficheros
yara regla.yar muestra            ; yara -r reglas/ /ruta/a/escanear/
# escanear MEMORIA (clave: la muestra desempacada/descifrada tiene firmas que en disco no)
yara regla.yar -p <pid>           ; o sobre un dump de memoria (ver mal-dynamic)
# a escala
yara en EDR/sandboxes, THOR/Loki (escáneres de IOCs basados en YARA), VirusTotal Retrohunt

YARA en memoria (muy potente)

Un binario empacado no coincide con firmas en disco porque su código real está cifrado. Pero en memoria, ya desempacado, sí: por eso escanear la memoria de procesos con YARA detecta malware que evade la detección estática (ver Ofuscación y packing).

Relación con otras firmas

YARA     ficheros y memoria (el "qué es")
Sigma    logs/eventos (el "qué hizo") -> detección por comportamiento en el SIEM
IOCs     indicadores atómicos (hash, dominio, IP) -> bloqueo directo
# los tres se complementan: YARA para la muestra, Sigma para la actividad, IOCs para bloquear

Para la defensa

Escribir reglas desde el análisis: cada muestra estudiada → una regla que detecta su familia.
Desplegar YARA en memoria y disco (EDR, escáneres como Loki/THOR) en toda la flota.
Compartir y consumir reglas de la comunidad (YARA rules públicas, threat intel).
Validar contra falsos positivos con un corpus benigno antes de desplegar en producción.
Combinar con Sigma (comportamiento) e IOCs para una detección en capas.

Checklist de prueba

Del análisis, extraer patrones únicos (strings/bytes/imports)
Escribir la regla con meta/strings/condition
Priorizar la detección de la FAMILIA (variantes), no una muestra
Probar contra goodware (evitar falsos positivos)
Escanear en disco y en MEMORIA (desempacado)
Usar módulos (pe.imphash, math.entropy) si aporta
Desplegar en EDR/escáneres a escala
Combinar con Sigma e IOCs