pe-signgen

Assinaturas binárias entre versões e deslocamentos RVA para funções PE do Windows

---

Visão Geral

pe-signgen é uma ferramenta para engenheiros reversos e pesquisadores de segurança que gera automaticamente:

• Assinaturas binárias (padrões de bytes com curingas) para funções não exportadas e exportadas
• Deslocamentos RVA e de arquivo para localizar funções diretamente em binários
• Assinaturas entre builds que funcionam em muitas versões do Windows
• Múltiplos formatos de saída otimizados para diferentes casos de uso
• Suporte para arquiteturas x64, ARM64 e WoW64

A ideia central é fornecer uma maneira sistemática e robusta de acessar funções não exportadas em builds do Windows 10/11. Ela aproveita:

• O Winbindex para metadados de builds do Windows
• Os servidores públicos de símbolos da Microsoft para PDBs
• Cache local para fluxos de trabalho reproduzíveis e amigáveis offline

⚠️ Suporte a versões do Windows pe-signgen suporta apenas Windows 10 e Windows 11. Esta é uma escolha de design deliberada: o Winbindex não fornece dados completos para versões mais antigas.

---

Casos de Uso

• Internos não exportados do Windows Gere assinaturas para funções como LdrpInitializeTls, RtlpInsertInvertedFunctionTableEntry, etc.

• Pesquisa em game hacking / anti-cheat Gere assinaturas estáveis que sobrevivem a atualizações de jogos

• Pesquisa de segurança Localize rotinas críticas de segurança em builds do Windows

• Automação Geração de assinaturas e deslocamentos programável para conjuntos inteiros de APIs internas

---

Formatos de Saída

pe-signgen fornece três formatos de saída distintos para diferentes casos de uso:

1. Formato JSON

Dados estruturados para automação, scripts e integração com outras ferramentas.```bash pe-signgen --signature ntdll!NtCreateFile -o ntcreatefile.json --output-format json

**Estrutura de saída:**```json
{
  "dll_name": "ntdll",
  "function_name": "NtCreateFile",
  "architecture": "x64",
  "generated": "2024-12-11T15:30:00.123456",
  "total_builds": 1247,
  "unique_signatures": 3,
  "signature_groups": [
    {
      "matched_symbol": "NtCreateFile",
      "signature": "4C 8B DC 49 89 5B 08 49 89 6B 10 49 89 73 18 ...",
      "length": 48,
      "build_count": 845,
      "versions": [
        { "major": 10240, "minor": 16384, "build": "10240.16384" },
        { "major": 10586, "minor": 0, "build": "10586.0" }
      ]
    }
  ]
}

Notas:

• major e minor são derivados da string de build dividindo no primeiro .. Exemplo: "10240.16384" → major = 10240, minor = 16384.
• build é a chave da string de build original usada internamente.

---

2. Formato Binário (WSIG/WOFF)

Formatos binários compactos e prontos para execução otimizados para sistemas embarcados e varredura de baixa sobrecarga.

Eles correspondem ao layout em disco implementado em write_wsig() e write_woff().

---

Formato WSIG (Assinatura do Windows)

Magic: WSO\0 (0x57 0x53 0x4F 0x00) Versão Atual: 1 Propósito: Armazenar assinaturas binárias com máscaras curinga e versões de build associadas do Windows

Estrutura do Arquivo (conceitual)```

┌─────────────────────────────────────┐ │ Header (36 bytes) │ ├─────────────────────────────────────┤ │ DLL Name (variable) │ ├─────────────────────────────────────┤ │ Function Name (variable) │ ├─────────────────────────────────────┤ │ Signature / Mask / Build blobs │ ← Arbitrary order, see notes ├─────────────────────────────────────┤ ← Aligned to 4 bytes │ Groups Table (24 × N bytes) │ └─────────────────────────────────────┘

**Notas importantes de layout (corresponde a `write_wsig`)**

* Após o cabeçalho, os nomes da DLL e da função são escritos como bytes UTF‑8.
* Para cada grupo de assinatura, os bytes de padrão e os bytes de máscara são escritos, seguidos pelo vetor de construção para aquele grupo.
* Essas regiões por grupo **não** são agrupadas globalmente por tipo: padrões, máscaras e vetores de construção podem estar intercalados.
* O construtor alinha a **4 bytes** antes de cada vetor de construção e antes da tabela de grupos. Isso pode introduzir preenchimento.
* Os consumidores devem **sempre** seguir os deslocamentos no cabeçalho e nas entradas de grupo; **não** confie no diagrama conceitual para contiguidade física.

##### Layout do Cabeçalho (36 bytes)```c
// Packed as: "<4sIIIIIIII" (little-endian)

typedef struct {
    char     magic[4];   // "WSO\0" (WSIG_MAGIC)
    uint32_t version;    // FORMAT_VERSION (currently 1)
    uint32_t arch;       // Architecture code (1=x64, 2=ARM64, 3=WoW64)
    uint32_t dll_off;    // Offset to DLL name string
    uint32_t dll_len;    // Length of DLL name in bytes
    uint32_t func_off;   // Offset to function name string
    uint32_t func_len;   // Length of function name in bytes
    uint32_t group_count;// Number of signature groups
    uint32_t groups_off; // Offset to groups table
} wsig_header_t; // 36 bytes

Entrada de Grupo (24 bytes)

Cada grupo de assinatura representa um padrão único que se aplica a uma ou mais builds do Windows.```c // Packed as: "<IIIIII" (little-endian)

typedef struct { uint32_t sig_off; // Offset to signature pattern bytes uint32_t sig_len; // Length of signature pattern (in bytes) uint32_t mask_off; // Offset to wildcard mask bytes uint32_t mask_len; // Length of wildcard mask (≈ ceil(sig_len/8)) uint32_t builds_off; // Offset to build version array uint32_t build_cnt; // Number of builds using this signature } wsig_group_t; // 24 bytes

##### Entrada de Versão de Build (8 bytes)

Cada entrada de build identifica uma versão específica do Windows que usa esta assinatura.```c
typedef struct {
    uint32_t major; // e.g. 19041
    uint32_t minor; // e.g. 1234
} wsig_build_t; // 8 bytes

major e minor vêm da divisão da string de build ("A.B" → A, B). A string de build original não é armazenada no formato binário; se precisar dela, mantenha-a externamente (ela está presente na saída JSON).

Formato de Máscara Curinga

A máscara é uma bitmask onde cada bit corresponde a um byte no padrão de assinatura:

• Bit = 1: O byte deve corresponder exatamente (byte fixo)
• Bit = 0: O byte é curinga (ignore este byte durante a correspondência)

Exemplo:``` Signature: 4C 8B DC 49 89 ?? 08 49 Mask bits: 1 1 1 1 1 0 1 1 (MSB first within each byte) Mask byte: 0xBF (binary: 10111111)

Os bytes de máscara são armazenados e interpretados em **ordem de bits little-endian** dentro de cada byte (exatamente como usado nos helpers C e `parse_signature`):```c
uint8_t bit = (mask_bytes[byte_index >> 3] >> (byte_index & 7)) & 1u;

Armazenamento de Strings

• Os nomes de DLL e funções são armazenados como UTF‑8, sem terminadores nulos.
• Use *_len para determinar o comprimento; não leia além disso.
• Não há requisitos de alinhamento para as próprias strings.
• Regiões adicionais de dados (arrays de build e a tabela de grupos) estão alinhadas a limites de 4 bytes; trate qualquer preenchimento como opaco.

---

Formato WOFF (Offset do Windows)

Magic: WOF\0 (0x57 0x4F 0x46 0x00) Versão Atual: 1 Propósito: Armazenar RVA diretos e offsets de arquivo para funções em diferentes versões do Windows