Anatomia de uma Regra YARA

YARA

YARA é um acrônimo que significa “Yet Another Recursive Acronym“. A YARA é uma ferramenta utilizada para identificar e classificar amostras de malware baseadas em padrões textuais ou binários.

Eu já fiz um artigo de introdução a YARA chamado Threat hunting com YARA – Mimikatz

Importar Módulo:

A YARA permite estender sua funcionalidade através de módulos. Os módulos podem ser utilizados para corresponder a dados específicos de um arquivo Executável Portátil (PE).
Exemplos de módulos:
- pe: para propriedades de arquivos PE, como pe.number_of_exports ou pe.sections[0].name.
- elf: para propriedades de arquivos ELF.
- hash: para funções de hashing, como hash.md5(0, filesize).
- time: para verificação de carimbo de data/hora.

Nome da Regra:

Identifica a sua regra YARA e deve ser significativo. Existem diferentes tipos de regras, como:
- Regras globais: aplicam-se a todos os seus arquivos.
- Regras privadas: podem ser chamadas na condição de uma regra, mas não são relatadas.
- Tags: usadas para filtrar a saída da YARA.

Metadados:

Uma seção para informações adicionais sobre sua regra, que pode incluir nome do autor, data de criação, descrição, etc.

Strings:

Definem os padrões textuais ou binários para combinar com os arquivos.
Existem três tipos de strings:
- Strings de texto: "Hello World".
- Strings hexadecimais: { E2 34 A1 }.
- Regex: /MD5: [A-Fa-f0-9]{32}/.

Condição:

Expressões booleanas usadas para corresponder ao padrão definido. Inclui operadores lógicos (como and, or, not), aritméticos (como >, <, ==, !=) e bitwise (como &, |, ^).

Strings de Texto:

Podem incluir modificadores, como:
- nocase: insensibilidade a maiúsculas/minúsculas.
- wide: strings codificadas UTF-16.
- fullword: corresponde a palavras inteiras.
- base64: para strings codificadas em base64.

Strings Hexadecimais:

Usadas para combinar padrões binários e podem incluir coringas e alternâncias.

Expressões Regulares (Regex):

Expressões regulares também podem ser usadas e são definidas como strings de texto, mas delimitadas por barras.

Condição Avançada:

Condições adicionais, como verificar o tamanho do arquivo ou verificar dados específicos em uma posição dada.

Exemplo de uma Regra YARA:

import "pe"

rule exemplo_regra_yara: Tag1 Demo
{
    meta:
        autor = "Thomas Roccia"
        descricao = "demo"
        hash = ""
    
    strings:
        $string1 = "hello" nocase wide
        $hex_string = { E2 34 A1 00 20 25 30 }
        $regex = /MD5: [A-Fa-f0-9]{32}/
    
    condition:
        filesize > 200KB and
        pe.number_of_exports == 10 and
        ($string1 or $hex_string)
}

Analisando uma Regra YARA Avançada

A regra a seguir serve para um arquivo de DLL do Windows de 64 bits chamada a.dll, que é executada por a.bat como um parâmetro para o arquivo a.exe. O arquivo a.exe carrega este arquivo no processo LSASS em execução na máquina infectada. O arquivo a.dll chama a API do Windows CreateFileW para criar um arquivo chamado a.png no caminho C:\Users\Public.

Em seguida, a.dll carrega DbgCore.dll e utiliza a função MiniDumpWriteDump para despejar a memória do processo LSASS no disco. Se bem-sucedido, a memória do processo despejada é escrita em a.png. Uma vez isso concluído, o arquivo a.bat especifica que o arquivo a.png é usado para criar o arquivo de gabinete chamado a.cab no caminho C:\Windows\Tasks.

Essa regra está disponível em https://www.cisa.gov/news-events/cybersecurity-advisories/aa23-075a no artigo #StopRansomware: LockBit 3.0

rule CISA_10478915_03 : trojan steals_authentication_credentials credential_exploitation
{ 
meta:
author = "CISA Code & Media Analysis"
incident = "10478915"
date = "2023-11-06"
last_modified = "20231108_1500"
actor = "n/a"
family = "n/a"
capabilities = "steals-authentication-credentials"
malware_type = "trojan"
tool_type = "credential-exploitation"
description = "Detects trojan DLL samples"
sha256 = "17a27b1759f10d1f6f1f51a11c0efea550e2075c2c394259af4d3f855bbcc994"
strings:
$s1 = { 64 65 6c 65 74 65 }
$s2 = { 3c 2f 74 72 75 73 74 49 6e 66 6f 3e }
$s3 = { 42 61 73 65 20 43 6c 61 73 73 20 44 65 73 63 72 69 70 74 6f 72 20 61 74 20 28 }
$s4 = { 49 6e 69 74 69 61 6c 69 7a 65 43 72 69 74 69 63 61 6c 53 65 63 74 69 6f 6e 45 78 }
$s5 = { 46 69 6e 64 46 69 72 73 74 46 69 6c 65 45 78 57 }
$s6 = { 47 65 74 54 69 63 6b 43 6f 75 6e 74 }
condition:
uint16(0) == 0x5a4d and pe.subsystem == pe.SUBSYSTEM_WINDOWS_CUI and pe.size_of_code == 56832 and all of
them
}

Vamos dividir em 3 blocos e podemos usar os documentos oficiais no site https://yara.readthedocs.io/en/stable/index.html para melhor entendimento.

Meta: Metadados da regra, incluindo:
- author: Autor da regra, “CISA Code & Media Analysis”.
- incident: Número do incidente associado, “10478915”.
- date: Data de criação da regra, “2023-11-06”.
- last_modified: Última data de modificação, “20231108_1500”.
- actor: Ator associado ao malware, neste caso, não especificado (“n/a”).
- family: Família do malware, não especificada (“n/a”).
- capabilities: Capacidades do malware, “steals-authentication-credentials”.
- malware_type: Tipo de malware, “trojan”.
- tool_type: Tipo de ferramenta, “credential-exploitation”.
- description: Descrição da regra, “Detects trojan DLL samples”.
- sha256: Hash SHA256 de uma amostra específica do malware.
Strings: Sequências de bytes usadas para identificar o malware. Cada $sX representa uma string hexadecimal que, se encontrada, indica a presença do malware.
- Hexadecimal pode ajudar a detectar malware ofuscado, observando a assinatura do arquivo. As regras YARA que usam hexadecimal são muito flexíveis. Você pode criar uma string e adicionar a assinatura hexadecimal para qualquer tipo de arquivo em sua regra.
- Essas informações partem de analise de malware e pode ser qualquer trecho de uma parte do arquivo malicioso.
Condição: Define quando a regra deve considerar um arquivo como malicioso. Esta regra especifica que:
- O arquivo deve iniciar com o “magic number” 0x5a4d, que é típico de arquivos executáveis no Windows.
- O subsistema do arquivo PE (Portable Executable) deve ser pe.SUBSYSTEM_WINDOWS_CUI, o que indica um aplicativo de console.
- O tamanho do código deve ser exatamente 56832 bytes.
- Todas as strings definidas ($s1 a $s6) devem estar presentes no arquivo.