Módulos YARA: pe, elf, dotnet, math, hash y más

Los módulos amplían las condiciones con analizadores de formatos y funciones auxiliares: en vez de calcular offsets en una cabecera PE, preguntas pe.number_of_sections o si una DLL importa VirtualAllocEx.

Importar un módulo

Un módulo solo analiza los archivos que reconoce: en un archivo de texto, pe.is_pe es falso y la mayoría de campos pe quedan indefinidos, lo que hace falsas las expresiones que los usan.

import "pe"
import "math"

rule Module_Import_Example
{
    condition:
        pe.is_pe and math.entropy(0, filesize) > 7.2
}

La versión WebAssembly de YARA-X del escáner y el editor incluye pe, elf, macho, dotnet, lnk, math, hash, time, console, string, dex, crx, cuckoo y vt; no incluye magic.

pe: ejecutables de Windows

import "pe"

rule PE_Injection_Imports
{
    condition:
        uint16(0) == 0x5A4D and filesize < 2MB and
        pe.imports("kernel32.dll", "VirtualAllocEx") and
        pe.imports("kernel32.dll", "WriteProcessMemory") and
        pe.imports("kernel32.dll", "CreateRemoteThread")
}

rule PE_Odd_Section_Name
{
    condition:
        uint16(0) == 0x5A4D and
        for any s in pe.sections : ( s.name == ".detourd" or s.name == "UPX0" )
}

elf, macho, dotnet y lnk

import "elf"
import "dotnet"
import "lnk"

rule ELF_Small_x64_Executable
{
    condition:
        uint32(0) == 0x464C457F and elf.type == elf.ET_EXEC and elf.machine == elf.EM_X86_64 and filesize < 1MB
}

rule DotNet_Assembly_Name
{
    condition:
        dotnet.is_dotnet and dotnet.assembly.name == "SharpExample"
}

rule LNK_Launches_Mshta
{
    condition:
        lnk.is_lnk and lnk.local_base_path contains "mshta"
}

macho hace lo mismo que elf para macOS, incluidos binarios universales. En .NET, el GUID de módulo y el nombre del ensamblado suelen ser estables entre compilaciones de una misma herramienta.

math y hash

math.entropy(offset, tamaño) devuelve la entropía de Shannon (0 a 8); por encima de ~7,2 los datos suelen estar comprimidos o cifrados. hash.md5/sha1/sha256(offset, tamaño) devuelven hex en minúsculas.

import "math"
import "hash"

rule Encrypted_Overlay_Or_Known_Blob
{
    condition:
        filesize < 5MB and (
            math.entropy(filesize - 4096, 4096) > 7.5 or
            hash.sha256(0, 1024) == "0000000000000000000000000000000000000000000000000000000000000000"
        )
}

Calcular hash o entropía sobre todo el archivo es caro: protégelo con filesize y comprobaciones previas (ver rendimiento).

console, string, time, dex, crx, cuckoo y vt

console.log() ayuda a depurar condiciones; string.to_int() convierte valores; time.now() devuelve la hora Unix. dex analiza bytecode Android, crx extensiones de Chrome. cuckoo y vt necesitan datos externos (informe de sandbox, metadatos de VirusTotal) y solo tienen sentido donde se proporcionan (ver YARA en VirusTotal).

Diferencias con YARA-X

Nombres de módulos y campos son casi siempre los mismos que en YARA 4.x. Algunos se reorganizaron, y YARA-X trata un campo desconocido como error de compilación. Si algo falla, yr dump -m pe muestra.exe muestra la estructura exacta. Las páginas de la biblioteca indican si cada regla compila con YARA-X.

¿Módulo o bytes?

Para «¿es un PE?», uint16(0) == 0x5A4D es más rápido y suficiente. Usa módulos para lo que los bytes expresan mal: imports, firmas, recursos, tablas de secciones. El linter avisa cuando se llama a pe o elf sin comprobar antes los magic bytes.