Desenvolvimento de Regras YARA para Detecção

Visão Geral

YARA é a ferramenta versátil de correspondência de padrões para pesquisadores de malware, permitindo a identificação e classificação de malware com base em padrões textuais ou binários. Regras YARA eficazes combinam padrões de strings únicos, sequências de bytes, características do cabeçalho PE, análise da tabela de importação e lógica condicional para detectar famílias de malware, evitando falsos positivos. O moderno YARA-X (reescrito em Rust, estável desde junho de 2025) traz melhorias de desempenho e novos módulos. As regras devem ter como alvo artefatos de malware descompactados, como strings de pilha codificadas, URLs de C2, nomes de mutex, constantes de criptografia e sequências de código únicas, em vez de assinaturas de empacotadores.

Quando Usar

• Ao realizar avaliações de segurança que envolvam o desenvolvimento de regras YARA para detecção
• Ao seguir procedimentos de resposta a incidentes para eventos de segurança relacionados
• Ao realizar testes ou atividades de auditoria de segurança agendados
• Ao validar controles de segurança por meio de testes práticos

Pré-requisitos

• Python 3.9+ com a biblioteca yara-python
• YARA 4.5+ ou YARA-X 0.10+
• Ferramentas de análise PE (pefile, pestudio)
• Editor hexadecimal para identificar padrões de bytes únicos
• Acesso a amostras de malware (VirusTotal, MalwareBazaar)
• Compreensão do formato de arquivo PE, strings e tabelas de importação

Conceitos Chave

Estrutura da Regra

Cada regra YARA consiste em três seções: meta (metadados descritivos opcionais), strings (definições de padrões) e condition (lógica de correspondência). Os tipos de string incluem strings de texto (ASCII/wide/nocase), padrões hexadecimais com curingas e saltos, e expressões regulares. As condições combinam correspondências de strings com propriedades de arquivo usando operadores booleanos.

Estratégia de Seleção de Strings

Regras eficazes visam padrões que são únicos para a família de malware e sobrevivem à recompilação. Strings de pilha codificadas são excelentes escolhas porque os compiladores as incorporam de forma consistente. Padrões de domínio C2, rotinas de criptografia personalizadas, mensagens de erro exclusivas e sequências específicas de chamadas de API fornecem âncoras de detecção estáveis. Evite código gerado pelo compilador e strings de bibliotecas comuns.

Otimização de Desempenho

YARA avalia condições em estilo de curto-circuito. Coloque as condições mais discriminatórias e mais baratas de avaliar primeiro. Use limites de filesize para pular arquivos irrelevantes rapidamente. Minimize o uso de regex em favor de padrões hexadecimais. Use regras de private como blocos de construção para lógica de detecção complexa sem gerar correspondências independentes.

Fluxo de Trabalho

Etapa 1: Analisar Amostra em Busca de Padrões Únicos

#!/usr/bin/env python3
"""Extrai strings candidatas e padrões de bytes para a criação de regras YARA."""
import pefile
import re
import sys
from collections import Counter


def extract_strings(filepath, min_length=6):
    """Extrai strings ASCII e wide de um binário."""
    with open(filepath, 'rb') as f:
        data = f.read()

    # Strings ASCII
    ascii_strings = re.findall(
        rb'[\x20-\x7e]{' + str(min_length).encode() + rb',}', data
    )

    # Strings Wide (UTF-16LE)
    wide_strings = re.findall(
        rb'(?:[\x20-\x7e]\x00){' + str(min_length).encode() + rb',}', data
    )

    return {
        'ascii': [s.decode('ascii') for s in ascii_strings],
        'wide': [s.decode('utf-16-le') for s in wide_strings],
    }


def analyze_pe_imports(filepath):
    """Extrai a tabela de importação para detecção baseada em API."""
    try:
        pe = pefile.PE(filepath)
    except pefile.PEFormatError:
        return []

    imports = []
    if hasattr(pe, 'DIRECTORY_ENTRY_IMPORT'):
        for entry in pe.DIRECTORY_ENTRY_IMPORT:
            dll_name = entry.dll.decode('utf-8', errors='replace')
            for imp in entry.imports:
                if imp.name:
                    func_name = imp.name.decode('utf-8', errors='replace')
                    imports.append(f"{dll_name}!{func_name}")
    return imports


def find_unique_byte_patterns(filepath, pattern_length=16):
    """Encontra sequências de bytes únicas adequadas para padrões hexadecimais YARA."""
    with open(filepath, 'rb') as f:
        data = f.read()

    try:
        pe = pefile.PE(filepath)
        # Foca na seção de código
        for section in pe.sections:
            if section.Characteristics & 0x20000000:  # IMAGE_SCN_MEM_EXECUTE
                code_start = section.PointerToRawData
                code_end = code_start + section.SizeOfRawData
                code_data = data[code_start:code_end]
                break
        else:
            code_data = data

…