AutoPiff

Estrutura Automatizada de Inteligência e Descoberta de Patches

Um motor de análise semântica para detecção de correções de vulnerabilidades em patches de drivers do kernel do Windows. AutoPiff usa regras YAML conservadoras para identificar alterações de código relevantes para segurança com alta precisão e explicabilidade.

Visão Geral

O AutoPiff analisa as diferenças entre versões vulneráveis e corrigidas de drivers para detectar automaticamente:

• Correções de Use-After-Free (atribuições nulas após ExFreePool)
• Adição de verificações de limites (validação de tamanho antes de memcpy)
• Endurecimento de fronteira usuário/kernel (ProbeForRead/ProbeForWrite)
• Proteções contra estouro de inteiro (auxiliares matemáticos seguros)
• Endurecimento de estado (contagem de referência intercravada)
• Validação de entrada IOCTL, proteções contra corrupção de pool, verificações de privilégio e mais

Principais Características

• Alta Precisão: Regras conservadoras minimizam falsos positivos
• Explicável: Cada descoberta inclui fundamentação e evidências
• Consciente de Sinks: Regras consideram proximidade com APIs perigosas
• Modelo de Pontuação: Classifica descobertas por explorabilidade e alcançabilidade
• Integração Karton: Executa como um serviço distribuído em pipelines de análise de malware

Por que AutoPiff?

Agulha no Palheiro

Fornecedor lança 500 atualizações de driver/ano
├── 490 são alterações de funcionalidade/desempenho/estética
├── 8 são correções de bugs menores
└── 2 são correções de segurança silenciosas (sem CVE atribuído)

Sem automação: Revisar manualmente 500 para encontrar 2
Com AutoPiff:      Revisar 10 de alta pontuação para encontrar 2

Patches de segurança são frequentemente lançados sem atribuição de CVE. Reverter manualmente todas as atualizações de driver para encontrar as relevantes para segurança não é viável. O AutoPiff resolve isso exibindo automaticamente as alterações que importam.

O Que o AutoPiff Automatiza

Total: 4-12 horas por par de drivers reduzido para 2-5 minutos

O Que Ainda Requer Expertise Humana

┌─────────────────────────────────────────────────────────────────┐
│  AUTOMATIZADO pelo AutoPiff                                     │
│  ├── Encontrar a agulha: "Esta função mudou perto de ExFreePool"│
│  ├── Classificar: "Parece uma correção de use-after-free"       │
│  └── Classificar: "Pontuação 5.5 - vale a pena investigar"     │
├─────────────────────────────────────────────────────────────────┤
│  AINDA MANUAL (Sua expertise)                                   │
│  ├── Confirmar explorabilidade: "Posso realmente acionar isso?" │
│  ├── Análise de causa raiz: "Por que isso era vulnerável?"      │
│  ├── Desenvolvimento de exploit: "Como alcanço este sink?"      │
│  └── Avaliação de impacto: "Qual é o risco no mundo real?"      │
└─────────────────────────────────────────────────────────────────┘

O AutoPiff não substitui a pesquisa de exploração. Torna-a viável em escala ao automatizar a fase de reconhecimento.

Casos de Uso

1. Detecção de Patch Silencioso

• Monitorar drivers em busca de correções de segurança lançadas sem CVEs
• Receber alertas quando deltas semânticos de alta pontuação aparecem
• Capturar vulnerabilidades antes que sejam divulgadas publicamente

2. Pesquisa de Vulnerabilidade de 1 Dia

• Quando um CVE é anunciado, identificar rapidamente o patch exato
• Correlacionar padrões de patch com classes de vulnerabilidade
• Acelerar cronogramas de desenvolvimento de exploits

3. Auditoria de Segurança do Fornecedor

• Analisar todas as versões de uma família de drivers ao longo do tempo
• Gerar linhas do tempo mostrando quando as correções apareceram
• Identificar padrões de como os fornecedores lidam com vulnerabilidades

4. Construção de Corpus CVE Histórico

• Processar pares de drivers CVE conhecidos para construir dados de treinamento
• Validar e melhorar regras de detecção
• Criar uma base de conhecimento de assinaturas de patch

Arquitetura

O AutoPiff executa como um pipeline Karton com 8 estágios sequenciais mais uma ramificação paralela de triagem DriverAtlas. Cada estágio é um microsserviço independente que se comunica via Redis/RabbitMQ.

graph LR
    sources["WinBIndex<br/>VirusTotal"]:::src --> s0["Estágio 0<br/>Monitor"]
    s0 --> s14["Estágios 1-4<br/>Differ de Patch"]
    s0 --> triage["DriverAtlas<br/>Triagem"]:::triage
    s14 --> s5["Estágio 5<br/>Alcançabilidade"]
    s5 --> s6["Estágio 6<br/>Classificação"]
    s6 --> s7["Estágio 7<br/>Relatório"]
    s6 --> s8["Estágio 8<br/>Alertador"]
    triage --> alerts["Tags MWDB<br/>+ Alertas"]:::triage

    classDef src fill:#1a1a2e,stroke:#e94560,color:#eee
    classDef triage fill:#1a1a2e,stroke:#e9a345,color:#eee
    classDef default fill:#16213e,stroke:#0f3460,color:#eee

Regras Semânticas

O AutoPiff inclui 58 regras em 22 categorias. Veja Docs/semantic_rules.md para a especificação completa e Docs/SEMANTIC_RULES_REFERENCE.md para a referência técnica.

Grupos de Sink

O mecanismo de regras rastreia 50+ símbolos de API perigosos em 8 grupos de sink:

• memory_copy: RtlCopyMemory, memcpy, memmove
• pool_alloc: ExAllocatePool, ExAllocatePoolWithTag
• pool_free: ExFreePool, ExFreePoolWithTag
• user_probe: ProbeForRead, ProbeForWrite
• io_sanitization: RtlULongAdd, RtlSizeTMult
• exceptions: __try, __except
• string_copy: strcpy, wcsncpy
• refcounting: InterlockedIncrement/Decrement

Modelo de Pontuação

As descobertas são pontuadas usando um modelo configurável (rules/scoring.yaml):

pontuacao_final = pontuacao_semantica + bonus_alcançabilidade + bonus_sink - penalidades

Componentes da Pontuação:

• Pontuação Semântica: Peso da regra x confiança x multiplicador de categoria
• Bônus de Alcançabilidade: IOCTL (+4.0), IRP (+2.5), PnP (+2.0), Interno (+0.5)
• Bônus de Sink: memory_copy (+1.5), user_probe (+1.5), pool_alloc (+1.2)
• Penalidades: Baixa qualidade de correspondência, alto risco de ruído

Limites:

• Descobertas com confiança < 0.45 são descartadas
• Confiança de correspondência < 0.40 limita a pontuação a 3.0

Instalação

Como Serviço Karton (Recomendado)

git clone https://github.com/splintersfury/AutoPiff.git
cd AutoPiff
docker compose up -d

Para a stack completa de produção com MWDB, dashboards e monitoramento, veja driver_analyzer.

Biblioteca Independente

pip install pyyaml

from services.karton_patch_differ.rule_engine import SemanticRuleEngine

engine = SemanticRuleEngine('rules/semantic_rules.yaml', 'rules/sinks.yaml')
hits = engine.evaluate(func_name, old_code, new_code, diff_lines)

Configuração

Variáveis de Ambiente

Personalização de Regras

Edite rules/semantic_rules.yaml para adicionar ou modificar regras:

rules:
  - rule_id: minha_regra_personalizada
    category: bounds_check
    confidence: 0.85
    required_signals:
      - sink_group: memory_copy
      - change_type: guard_added
      - guard_kind: length_check
    plain_english_summary: Validação de tamanho adicionada antes da cópia de memória.

Formato de Saída

O AutoPiff produz relatórios JSON anexados a amostras MWDB:

{
  "pairing": {
    "driver_new": {"sha256": "...", "version": "2.0.9.0"},
    "driver_old": {"sha256": "...", "version": "2.0.8.0"},
    "decision": "accept",
    "confidence": 0.95
  },
  "semantic_deltas": {
    "deltas": [
      {
        "function": "HandleIoctl",
        "rule_id": "null_after_free_added",
        "category": "lifetime_fix",
        "confidence": 0.88,
        "sinks": ["pool_free"],
        "final_score": 5.5,
        "why_matters": "O ponteiro agora é definido como NULL após liberar memória."
      }
    ],
    "summary": {
      "total_deltas": 1,
      "top_score": 5.5,
      "match_rate": 100.0
    }
  }
}

Documentação

Estrutura do Projeto

AutoPiff/
├── Docs/                          # Documentos de design e especificações
├── ghidra/scripts/                # Scripts Ghidra headless
│   └── autopiff_reachability.py   # BFS de alcançabilidade + exportação de decompilação
├── rules/
│   ├── semantic_rules.yaml        # 58 regras de detecção
│   ├── sinks.yaml                 # 50+ símbolos de API perigosos
│   └── scoring.yaml               # Configuração do modelo de pontuação
├── schemas/                       # Schemas JSON para cada estágio
├── services/
│   ├── karton-patch-differ/       # Estágios 1-4: diff + análise semântica
│   ├── karton-reachability/       # Estágio 5: grafo de chamadas + decompilação
│   ├── karton-ranking/            # Estágio 6: pontuação
│   ├── karton-report/             # Estágio 7: geração de relatório
│   ├── karton-driver-triage/      # Triagem de superfície de ataque DriverAtlas
│   ├── autopiff-alerter/          # Estágio 8: alertas Telegram
│   ├── driver-monitor/            # Estágio 0: consulta de versões
│   └── dashboard/                 # Interface web
├── tests/unit/                    # 137 testes unitários
├── docker-compose.yml
└── README.md

Integração com driver_analyzer

O AutoPiff foi projetado para funcionar com driver_analyzer, que fornece a infraestrutura completa de produção (MWDB, Karton, MinIO, dashboards). O arquivo compose do driver_analyzer constrói os serviços AutoPiff diretamente:

# Em driver_analyzer/docker-compose.yml
karton-driver-patch-differ:
  build:
    context: ../AutoPiff
    dockerfile: services/karton-patch-differ/Dockerfile
  volumes:
    - ../AutoPiff/rules:/app/rules:ro

Veja o README do driver_analyzer para instruções de configuração.

Licença

Licença MIT - Veja LICENSE para detalhes.

Agradecimentos

• Karton - Estrutura de processamento distribuído de malware
• MWDB Core - Repositório de malware
• Ghidra - Estrutura de engenharia reversa de software da NSA