YARA y Sigma Cheatsheet: Sintaxis y Ejemplos Rápidos

YARA: Deteccion de malware en ficheros y memoria

YARA es el estandar de la industria para crear reglas de deteccion de malware basadas en patrones. Creada por Victor Manuel Alvarez de VirusTotal, YARA permite definir patrones de strings, bytes hexadecimales y condiciones logicas para identificar muestras de malware.

Estructura basica de una regla YARA

rule NombreRegla : tag1 tag2
{
    meta:
        author = "MalwareIntel"
        description = "Detecta la familia X"
        date = "2026-06-08"
        reference = "https://example.com/report"
        severity = "high"

    strings:
        $s1 = "string de texto"
        $s2 = { 4D 5A 90 00 }
        $s3 = /regex[0-9]+pattern/

    condition:
        uint16(0) == 0x5A4D and
        filesize < 500KB and
        2 of ($s*)
}

Tipos de strings

Strings de texto:

$texto = "cadena exacta"
$texto_nocase = "CaDeNa" nocase           // case insensitive
$texto_wide = "unicode" wide              // UTF-16LE (Windows wide strings)
$texto_both = "ambos" ascii wide          // busca ASCII y Unicode
$texto_full = "palabra" fullword          // no coincide dentro de otra palabra
$texto_xor = "ofuscada" xor              // busca con XOR de 0x01 a 0xFF
$texto_base64 = "encoded" base64          // busca la version base64

Strings hexadecimales:

$hex = { 4D 5A 90 00 03 00 00 00 }       // bytes exactos
$hex_wild = { 4D 5A ?? 00 }              // ?? = cualquier byte
$hex_jump = { 4D 5A [2-4] 00 }           // salto de 2 a 4 bytes
$hex_alt = { 4D ( 5A | 5B ) 90 }         // alternativa: 5A o 5B
$hex_nibble = { 4D 5? 90 00 }            // ? = cualquier nibble

Expresiones regulares:

$regex = /https?:\/\/[a-z0-9\.\-]+\.[a-z]{2,6}/i
$regex2 = /[A-Z]{3}-[0-9]{4}/

Condiciones

Las condiciones combinan resultados de strings con logica booleana y funciones integradas.

Operadores basicos:

condition:
    $s1 and $s2                    // ambas presentes
    $s1 or $s2                     // al menos una
    not $s1                        // ausencia
    $s1 and not $s2                // una si, otra no

Contadores:

condition:
    #s1 > 3                        // $s1 aparece mas de 3 veces
    2 of ($s1, $s2, $s3)           // al menos 2 de las 3
    any of ($s*)                   // cualquiera del grupo
    all of ($s*)                   // todas del grupo
    3 of them                      // 3 de todas las strings

Funciones de fichero:

condition:
    filesize < 1MB                 // tamano del fichero
    uint16(0) == 0x5A4D            // magic number PE (MZ)
    uint32(0) == 0x464c457f        // magic number ELF
    uint16(0) == 0xCFFA            // magic number Mach-O

Posiciones:

condition:
    $s1 at 0                       // $s1 en offset 0
    $s1 in (0..100)                // $s1 en los primeros 100 bytes
    $s1 at entrypoint              // $s1 en el entry point (PE)

Modulos YARA

Modulo PE:

import "pe"

rule DetectaPacker {
    condition:
        pe.number_of_sections > 7 and
        pe.sections[0].name == ".UPX0" and
        pe.entry_point < pe.sections[0].raw_data_offset
}

Modulo math:

import "math"

rule AltaEntropia {
    condition:
        math.entropy(0, filesize) > 7.5
}

Modulo hash:

import "hash"

rule HashConocido {
    condition:
        hash.sha256(0, filesize) == "e3b0c44298fc1c149afbf4c8996fb924..."
}

Ejemplos practicos YARA

Detectar PowerShell codificado:

rule PowerShell_Encoded_Command
{
    meta:
        description = "Detecta ejecucion de PowerShell con comando codificado en base64"
        severity = "medium"

    strings:
        $ps1 = "powershell" nocase
        $ps2 = "-enc" nocase
        $ps3 = "-EncodedCommand" nocase
        $ps4 = "FromBase64String" nocase
        $b64 = /[A-Za-z0-9+\/]{50,}={0,2}/ wide ascii

    condition:
        ($ps1 and ($ps2 or $ps3)) or
        ($ps1 and $ps4 and $b64)
}

Detectar PE sospechoso:

import "pe"
import "math"

rule Suspicious_PE_High_Entropy
{
    meta:
        description = "PE con entropia alta en la seccion de codigo, posible packer"

    condition:
        uint16(0) == 0x5A4D and
        pe.number_of_sections > 0 and
        math.entropy(pe.sections[0].raw_data_offset,
                     pe.sections[0].raw_data_size) > 7.0
}

Detectar strings de C2:

rule Generic_C2_Indicators
{
    meta:
        description = "Indicadores genericos de comunicacion C2"

    strings:
        $ua1 = "Mozilla/5.0" wide ascii
        $cmd1 = "cmd.exe /c" nocase
        $cmd2 = "/bin/sh -c" nocase
        $sleep = "Sleep" wide ascii
        $beacon = "beacon" nocase wide ascii
        $shell = "reverse_shell" nocase
        $download = "DownloadFile" nocase wide ascii
        $upload = "UploadFile" nocase wide ascii

    condition:
        3 of them
}

Sigma: Deteccion de amenazas en logs

Sigma es a las reglas SIEM lo que YARA es a las reglas de ficheros: un formato estandar para escribir detecciones que se pueden convertir a cualquier plataforma.

Estructura basica de una regla Sigma

title: Ejecucion sospechosa de PowerShell
id: 5b23a520-3a58-4f3b-9d11-a5e0f4b32f3c
status: stable
description: Detecta ejecucion de PowerShell con parametros sospechosos
author: MalwareIntel Research
date: 2026/06/08
modified: 2026/06/08
references:
    - https://attack.mitre.org/techniques/T1059/001/
tags:
    - attack.execution
    - attack.t1059.001
logsource:
    category: process_creation
    product: windows
detection:
    selection:
        Image|endswith: '\powershell.exe'
        CommandLine|contains:
            - '-enc'
            - '-EncodedCommand'
            - 'FromBase64String'
            - '-nop'
            - 'bypass'
    condition: selection
falsepositives:
    - Administradores ejecutando scripts legitimos
    - Software de gestion que usa PowerShell
level: medium

Logsources comunes

# Creacion de procesos (Sysmon Event 1, Windows Security 4688)
logsource:
    category: process_creation
    product: windows

# Conexiones de red (Sysmon Event 3)
logsource:
    category: network_connection
    product: windows

# Creacion de ficheros (Sysmon Event 11)
logsource:
    category: file_creation
    product: windows

# Modificaciones de registro (Sysmon Event 13)
logsource:
    category: registry_set
    product: windows

# Acceso a procesos (Sysmon Event 10)
logsource:
    category: process_access
    product: windows

# DNS queries (Sysmon Event 22)
logsource:
    category: dns_query
    product: windows

# Logs de proxy web
logsource:
    category: proxy

# Logs de firewall
logsource:
    category: firewall

Operadores de deteccion

Modificadores de campo:

detection:
    selection:
        FieldName: 'valor exacto'
        FieldName|contains: 'subcadena'
        FieldName|startswith: 'inicio'
        FieldName|endswith: 'final'
        FieldName|re: 'regex.*pattern'
        FieldName|cidr: '10.0.0.0/8'
        FieldName|base64: 'decoded_value'
        FieldName|contains|all:
            - 'substring1'
            - 'substring2'

Condiciones logicas:

detection:
    selection1:
        Image|endswith: '\cmd.exe'
    selection2:
        CommandLine|contains: '/c'
    filter:
        ParentImage|endswith: '\explorer.exe'
    condition: selection1 and selection2 and not filter

Listas de valores (OR implicito):

detection:
    selection:
        Image|endswith:
            - '\powershell.exe'
            - '\pwsh.exe'
            - '\cmd.exe'
            - '\wscript.exe'
            - '\cscript.exe'

Multiples campos (AND implicito):

detection:
    selection:
        Image|endswith: '\schtasks.exe'
        CommandLine|contains: '/create'

Ejemplos practicos Sigma

Detectar persistencia via Registry Run:

title: Persistencia via Registry Run Key
id: a7b8c1d2-3e4f-5678-9abc-def012345678
status: stable
description: Detecta modificacion de claves de registro Run para persistencia
tags:
    - attack.persistence
    - attack.t1547.001
logsource:
    category: registry_set
    product: windows
detection:
    selection:
        TargetObject|contains:
            - '\CurrentVersion\Run'
            - '\CurrentVersion\RunOnce'
    filter_legitimate:
        Image|endswith:
            - '\msiexec.exe'
            - '\setup.exe'
    condition: selection and not filter_legitimate
level: medium

Detectar acceso a LSASS:

title: Acceso sospechoso a LSASS
id: b2c3d4e5-6f7a-8901-bcde-f01234567890
status: stable
description: Detecta acceso al proceso lsass.exe para dumping de credenciales
tags:
    - attack.credential_access
    - attack.t1003.001
logsource:
    category: process_access
    product: windows
detection:
    selection:
        TargetImage|endswith: '\lsass.exe'
        GrantedAccess|contains:
            - '0x1010'
            - '0x1038'
            - '0x1fffff'
    filter_system:
        SourceImage|endswith:
            - '\csrss.exe'
            - '\wininit.exe'
            - '\lsm.exe'
    condition: selection and not filter_system
level: high

Detectar DNS tunneling:

title: Posible DNS Tunneling
id: c3d4e5f6-7a8b-9012-cdef-012345678901
status: experimental
description: Detecta queries DNS con subdominios inusualmente largos
tags:
    - attack.command_and_control
    - attack.t1071.004
logsource:
    category: dns_query
    product: windows
detection:
    selection:
        QueryName|re: '^[a-z0-9]{30,}\.'
    condition: selection
falsepositives:
    - CDNs con nombres de subdominio largos
    - Servicios cloud con identificadores en subdominios
level: medium

Herramientas para YARA y Sigma

YARA

• yara: el binario de linea de comandos oficial para ejecutar reglas contra ficheros
• yara-python: libreria Python para integrar YARA en scripts y pipelines
• YARA Editor (VSCode): extension con syntax highlighting y autocompletado
• YARAify (abuse.ch): servicio online para compartir y buscar reglas YARA
• yarGen: generador automatico de reglas YARA a partir de muestras

Sigma

• sigma-cli: conversor oficial de Sigma a formatos nativos de SIEM
• pySigma: libreria Python para trabajar con reglas Sigma programaticamente
• Uncoder.IO: conversor online de Sigma a SPL, KQL, AQL y otros
• SigmaHQ: repositorio oficial con miles de reglas clasificadas y mantenidas
• Sigma Rule Creator (Socprime): editor visual de reglas Sigma

Flujo de trabajo combinado

La combinacion de YARA y Sigma proporciona cobertura completa: YARA detecta el malware como artefacto (fichero, region de memoria) y Sigma detecta su comportamiento en el sistema (procesos, red, registro).

Un flujo tipico para crear detecciones de una nueva familia de malware:

1. Analiza la muestra y extrae strings, patrones hex y comportamientos
2. Escribe reglas YARA para detectar el binario y sus variantes
3. Escribe reglas Sigma para detectar su comportamiento (creacion de procesos, persistencia, C2)
4. Testa las reglas YARA contra muestras conocidas y ficheros limpios (falsos positivos)
5. Testa las reglas Sigma contra logs de sistemas limpios (falsos positivos)
6. Publica ambas reglas con metadatos completos (autor, fecha, ATT&CK mapping, severidad)

Conclusion

YARA y Sigma son las dos herramientas fundamentales del detection engineer. Este cheatsheet cubre la sintaxis esencial de ambas con ejemplos practicos que puedes adaptar inmediatamente. La clave es escribir reglas, testarlas y refinarlas: no hay mejor forma de aprender que crear tus propias detecciones para las amenazas que afectan a tu organizacion.