YARA

Contenidos

1. ¿Qué es YARA?
2. Instalación
3. Sintaxis Básica
4. Definiendo Strings
5. Condiciones
6. Metadatos
7. Ejemplos Prácticos
8. Uso de YARA
9. Técnicas Avanzadas
10. Herramientas Complementarias

¿Qué es YARA?

YARA es una herramienta diseñada para ayudar a los investigadores de malware a identificar y clasificar muestras de malware mediante la creación de descripciones de familias de malware basadas en patrones textuales o binarios.

En términos simples: YARA te permite crear "reglas" que describen patrones específicos. Cuando escaneas archivos con estas reglas, YARA te dice si encuentra esos patrones.

¿Para qué se utiliza?

• Detección de malware: Identificar virus, trojanos, ransomware, etc.
• Análisis forense: Buscar evidencias en discos duros y memoria
• Threat hunting: Caza proactiva de amenazas en redes
• Clasificación automática: Categorizar automáticamente muestras de malware

¿Por qué YARA es genial?

• Sintaxis simple y legible
• Muy rápido para escanear grandes volúmenes
• Flexible: texto, binario, expresiones regulares
• Ampliamente adoptado por la industria

Instalación

Ubuntu/Debian

sudo apt update
sudo apt install yara

CentOS/RHEL

sudo yum install epel-release
sudo yum install yara

macOS

brew install yara

Windows

Descarga el ejecutable desde: github.com/VirusTotal/yara/releases

Verificar instalación

yara --version

Sintaxis Básica

Una regla YARA tiene la siguiente estructura básica:

rule NombreDeLaRegla
{
    meta:
        description = "Descripción de la regla"
        author = "Tu nombre"
        date = "2024-01-01"
    
    strings:
        $cadena1 = "texto a buscar"
        $cadena2 = { 48 65 6C 6C 6F }  // bytes en hexadecimal
    
    condition:
        $cadena1 or $cadena2
}

Componentes principales:

• rule: Palabra clave que inicia la regla seguida del nombre
• meta: Metadatos descriptivos (opcional)
• strings: Patrones a buscar en los archivos
• condition: Lógica que determina cuándo la regla coincide

Importante:

• Los nombres de reglas deben ser únicos
• Los identificadores de strings deben empezar con $
• La sección condition es obligatoria

Definiendo Strings

1. Strings de texto

strings:
    $texto1 = "Hola mundo"
    $texto2 = "password"
    $texto3 = "malware" nocase    // insensible a mayúsculas
    $texto4 = "test" wide         // formato Unicode

2. Strings hexadecimales

strings:
    $hex1 = { 4D 5A }              // "MZ" en hexadecimal
    $hex2 = { 4D 5A ?? ?? 50 45 }  // ?? = cualquier byte
    $hex3 = { 4D 5A [0-100] 50 45} // salto de 0-100 bytes

3. Expresiones regulares

strings:
    $regex1 = /http:\/\/[a-z]+\.com/
    $regex2 = /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/  // IP
    $regex3 = /[a-zA-Z0-9]{32}/ nocase              // MD5 hash

Modificadores útiles:

• nocase: Ignora mayúsculas/minúsculas
• wide: Búsqueda en formato Unicode
• ascii: Solo caracteres ASCII
• fullword: Palabra completa
• xor: Búsqueda con XOR
• base64: Decodifica Base64
• base64wide: Base64 + wide

Consejo Pro: Combina modificadores para mayor flexibilidad: $string = "password" nocase wide ascii

Condiciones

Operadores lógicos básicos:

condition:
    $string1 and $string2        // Ambos deben existir
    $string1 or $string2         // Al menos uno debe existir
    not $string1                 // No debe existir
    ($string1 and $string2) or $string3

Contadores y rangos:

condition:
    #string1 > 5                 // Más de 5 ocurrencias
    #string1 in (1..10)          // Entre 1 y 10 ocurrencias
    any of ($string*)            // Cualquier string que empiece con "string"
    all of them                  // Todos los strings definidos
    2 of ($a, $b, $c)           // Al menos 2 de los 3 strings

Posición y tamaño del archivo:

condition:
    $string1 at 0               // String en el byte 0 (inicio)
    $string1 at entrypoint      // String en el punto de entrada
    filesize > 1MB              // Archivo mayor a 1 MB
    filesize < 10KB             // Archivo menor a 10 KB

Funciones útiles:

Información PE:

pe.number_of_sections > 3
pe.imports("kernel32.dll")

Hash del archivo:

hash.md5(0, filesize) == "abc123..."

Matemáticas:

math.entropy(0, filesize) > 7.5

Tiempo:

pe.timestamp > 1577836800

Ejemplo avanzado:

condition:
    (filesize > 10KB and filesize < 1MB) and
    (any of ($malware*) or #suspicious > 3) and
    pe.number_of_sections between 3 and 8

Metadatos

Los metadatos proporcionan información adicional sobre la regla sin afectar la lógica de detección:

rule MiReglaDetallada
{
    meta:
        description = "Detecta la familia de malware XYZ"
        author = "Tu Nombre "
        date = "2024-08-15"
        version = "1.2"
        severity = "high"
        family = "trojan"
        sample = "abc123def456..."
        reference = "https://blog.security.com/analysis"
        tags = "trojan,banking,stealer"
        tlp = "white"
    
    strings:
        // ... definiciones de strings
    
    condition:
        // ... condiciones
}

Metadatos comunes y recomendados:

• description: Qué detecta la regla
• author: Quién creó la regla
• date: Fecha de creación
• version: Versión de la regla
• severity: Criticidad (low/medium/high)
• family: Familia de malware
• reference: Enlaces relacionados
• sample: Hash de muestra
• tags: Etiquetas para clasificación
• tlp: Traffic Light Protocol

Buenas prácticas:

• Siempre incluye description, author y date
• Usa tags para facilitar la organización
• Incluye reference para análisis detallados
• Actualiza version cuando modifiques la regla

Ejemplos Prácticos

Ejemplo 1: Detector de ejecutables sospechosos

rule Suspicious_PE_File
{
    meta:
        description = "Detecta ejecutables PE con strings sospechosos"
        author = "Security Analyst"
        date = "2024-08-15"
    
    strings:
        $mz = { 4D 5A }  // Firma MZ
        $pe = "PE"
        $sus1 = "keylogger" nocase
        $sus2 = "password" nocase
        $sus3 = "backdoor" nocase
        $sus4 = "rootkit" nocase
    
    condition:
        $mz at 0 and $pe and any of ($sus*)
}

Ejemplo 2: Detector de ransomware

rule Ransomware_Generic
{
    meta:
        description = "Detecta comportamientos típicos de ransomware"
        author = "Malware Hunter"
        severity = "high"
        family = "ransomware"
    
    strings:
        $ransom1 = "Your files have been encrypted" nocase
        $ransom2 = "pay bitcoin" nocase
        $ransom3 = "decrypt" nocase
        $ransom4 = "ransom" nocase
        $ext1 = ".locked"
        $ext2 = ".encrypted"
        $ext3 = ".crypto"
    
    condition:
        (2 of ($ransom*)) or 
        (any of ($ransom*) and any of ($ext*))
}

Ejemplo 3: Detector de URLs maliciosas

rule Malicious_URLs
{
    meta:
        description = "Detecta URLs con patrones sospechosos"
        author = "Web Security Team"
    
    strings:
        $url1 = /https?:\/\/[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}/
        $url2 = /bit\.ly\/[a-zA-Z0-9]{6,}/
        $url3 = /tinyurl\.com\/[a-zA-Z0-9]{6,}/
        $phish1 = "paypal-secure" nocase
        $phish2 = "bank-update" nocase
        $phish3 = "account-verify" nocase
    
    condition:
        any of ($url*) or any of ($phish*)
}

Ejemplo 4: Detector de archivos PDF maliciosos

rule Malicious_PDF
{
    meta:
        description = "Detecta PDFs con JavaScript sospechoso"
        author = "Document Security"
    
    strings:
        $pdf_header = "%PDF-"
        $js1 = "/JavaScript" nocase
        $js2 = "/JS" nocase
        $suspicious1 = "eval(" nocase
        $suspicious2 = "unescape(" nocase
        $suspicious3 = "String.fromCharCode(" nocase
        $action = "/OpenAction" nocase
    
    condition:
        $pdf_header at 0 and
        (any of ($js*)) and
        (any of ($suspicious*) or $action)
}

Uso de YARA

Comandos básicos:

1. Escanear un archivo:

yara mi_regla.yar archivo_sospechoso.exe

2. Escanear un directorio:

yara -r mi_regla.yar /ruta/del/directorio/

3. Usar múltiples reglas:

yara regla1.yar regla2.yar archivo.exe

Consejo: Para aprender más sobre YARA, consulta la documentación oficial.

Técnicas Avanzadas

Reglas con múltiples condiciones

rule Advanced_YARA_Rule
{
    meta:
        description = "Regla avanzada para detectar malware específico"
        author = "Security Researcher"
        date = "2024-08-15"
    
    strings:
        $header = { 4D 5A }              // Firma MZ
        $pe = "PE"                       // Firma PE
        $signature1 = "malware_pattern_1" nocase
        $signature2 = /http:\/\/[a-z]+\.com/  // URL con expresión regular
    
    condition:
        $header at 0 and $pe and 
        (any of ($signature*) or #suspicious > 5)
}

Uso de funciones avanzadas

rule Complex_Analysis
{
    meta:
        description = "Análisis complejo de archivos"
        author = "Security Analyst"
    
    strings:
        $pattern1 = "suspicious_string" nocase
        $pattern2 = { 4D 5A [0-100] 50 45 }  // Saltando bytes
    
    condition:
        (filesize > 1KB and filesize < 10MB) and
        (pe.number_of_sections between 1 and 10) and
        (any of ($pattern*) or math.entropy(0, filesize) > 7.0)
}

Recomendación: Combina diferentes técnicas para crear reglas más robustas y precisas.

Herramientas Complementarias

• YARA-GUI: Interfaz gráfica para crear y probar reglas YARA
• YARA-Rule-Generator: Herramienta para generar reglas automáticamente

Recursos útiles:

• Documentación oficial de YARA
• Repositorio de reglas YARA
• Análisis de tráfico de malware

Recomendación: Practica con herramientas como YARA-GUI para aprender mejor las reglas.