AutoPiff

Framework automatisé d'intelligence et de recherche de correctifs

Un moteur d'analyse sémantique pour détecter les corrections de vulnérabilités dans les correctifs de pilotes du noyau Windows. AutoPiff utilise des règles YAML conservatrices pour identifier les modifications de code pertinentes pour la sécurité avec une haute précision et une explicabilité.

Aperçu

AutoPiff analyse les différences entre les versions vulnérables et corrigées des pilotes pour détecter automatiquement :

• Corrections de Use-After-Free (assignations nulles après ExFreePool)
• Ajouts de vérifications de limites (validation de longueur avant memcpy)
• Renforcement de la frontière utilisateur/noyau (ProbeForRead/ProbeForWrite)
• Protections contre les débordements d'entiers (assistants mathématiques sécurisés)
• Renforcement d'état (comptage de référence verrouillé)
• Validation des entrées IOCTL, gardes de corruption de pool, vérifications de privilèges, et plus encore

Fonctionnalités clés

• Haute précision : Les règles conservatrices minimisent les faux positifs
• Explicabilité : Chaque résultat inclut une justification et des preuves
• Conscient des sinks : Les règles tiennent compte de la proximité avec des API dangereuses
• Modèle de notation : Classe les résultats selon l'exploitabilité et l'accessibilité
• Intégration Karton : Fonctionne comme un service distribué dans les pipelines d'analyse de logiciels malveillants

Pourquoi AutoPiff ?

Aiguille dans une botte de foin

Vendor releases 500 driver updates/year
├── 490 are feature/performance/cosmetic changes
├── 8 are minor bug fixes
└── 2 are silent security fixes (no CVE assigned)

Without automation: Manually review 500 to find 2
With AutoPiff:      Review 10 high-scorers to find 2

Les correctifs de sécurité sont souvent publiés sans attribution de CVE. Analyser manuellement en rétro-ingénierie chaque mise à jour de pilote pour trouver celles pertinentes pour la sécurité n'est pas réalisable. AutoPiff résout ce problème en faisant remonter automatiquement les changements qui comptent.

Ce qu'AutoPiff automatise

Total : 4 à 12 heures par paire de pilotes réduites à 2 à 5 minutes

Ce qui nécessite encore une expertise humaine

┌─────────────────────────────────────────────────────────────────┐
│  AUTOMATISÉ par AutoPiff                                        │
│  ├── Trouver l'aiguille : "Cette fonction a changé près de      │
│  │   ExFreePool"                                                │
│  ├── Classifier : "On dirait une correction de use-after-free"  │
│  └── Classer : "Score 5.5 - vaut la peine d'être investigué"   │
├─────────────────────────────────────────────────────────────────┤
│  ENCORE MANUEL (Votre expertise)                                │
│  ├── Confirmer l'exploitabilité : "Puis-je vraiment déclencher  │
│  │   cela ?"                                                    │
│  ├── Analyse des causes profondes : "Pourquoi cela était-il     │
│  │   vulnérable ?"                                              │
│  ├── Développement d'exploit : "Comment atteindre ce sink ?"    │
│  └── Évaluation de l'impact : "Quel est le risque réel ?"       │
└─────────────────────────────────────────────────────────────────┘

AutoPiff ne remplace pas la recherche d'exploitation. Il la rend réalisable à grande échelle en automatisant la phase de reconnaissance.

Cas d'utilisation

1. Détection de correctifs silencieux

• Surveillez les pilotes pour les correctifs de sécurité publiés sans CVE
• Recevez des alertes lorsque des deltas sémantiques à score élevé apparaissent
• Attrapez les vulnérabilités avant qu'elles ne soient divulguées publiquement

2. Recherche de vulnérabilités 1-Day

• Lorsqu'un CVE est annoncé, identifiez rapidement le correctif exact
• Corrélez les motifs de correctifs avec les classes de vulnérabilités
• Accélérez les délais de développement d'exploit

3. Audit de sécurité des fournisseurs

• Analysez toutes les versions d'une famille de pilotes au fil du temps
• Générez des chronologies montrant quand les correctifs sont apparus
• Identifiez les modèles de la manière dont les fournisseurs traitent les vulnérabilités

4. Construction d'un corpus historique de CVE

• Traitez les paires de pilotes CVE connues pour construire des données d'entraînement
• Validez et améliorez les règles de détection
• Créez une base de connaissances de signatures de correctifs

Architecture

AutoPiff s'exécute en tant que pipeline Karton avec 8 étapes séquentielles plus une branche parallèle de triage DriverAtlas. Chaque étape est un microservice indépendant communiquant via Redis/RabbitMQ.

graph LR
    sources["WinBIndex<br/>VirusTotal"]:::src --> s0["Stage 0<br/>Monitor"]
    s0 --> s14["Stages 1-4<br/>Patch Differ"]
    s0 --> triage["DriverAtlas<br/>Triage"]:::triage
    s14 --> s5["Stage 5<br/>Reachability"]
    s5 --> s6["Stage 6<br/>Ranking"]
    s6 --> s7["Stage 7<br/>Report"]
    s6 --> s8["Stage 8<br/>Alerter"]
    triage --> alerts["MWDB Tags<br/>+ Alerts"]:::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

Règles sémantiques

AutoPiff inclut 58 règles réparties dans 22 catégories. Voir Docs/semantic_rules.md pour la spécification complète et Docs/SEMANTIC_RULES_REFERENCE.md pour la référence technique.

Groupes de sinks

Le moteur de règles suit plus de 50 symboles d'API dangereux répartis dans 8 groupes de sinks :

• 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

Modèle de notation

Les résultats sont notés à l'aide d'un modèle configurable (rules/scoring.yaml) :

final_score = semantic_score + reachability_bonus + sink_bonus - penalties

Composantes du score :

• Score sémantique : Poids de la règle x confiance x multiplicateur de catégorie
• Bonus d'accessibilité : IOCTL (+4.0), IRP (+2.5), PnP (+2.0), Interne (+0.5)
• Bonus de sink : memory_copy (+1.5), user_probe (+1.5), pool_alloc (+1.2)
• Pénalités : Faible qualité de correspondance, risque de bruit élevé

Seuils :

• Les résultats avec une confiance < 0,45 sont abandonnés
• Une confiance de correspondance < 0,40 plafonne le score à 3,0

Installation

En tant que service Karton (Recommandé)

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

Pour la pile de production complète avec MWDB, tableaux de bord et surveillance, voir driver_analyzer.

Bibliothèque autonome

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)

Configuration

Variables d'environnement

Personnalisation des règles

Modifiez rules/semantic_rules.yaml pour ajouter ou modifier des règles :

rules:
  - rule_id: my_custom_rule
    category: bounds_check
    confidence: 0.85
    required_signals:
      - sink_group: memory_copy
      - change_type: guard_added
      - guard_kind: length_check
    plain_english_summary: Added length validation before memory copy.

Format de sortie

AutoPiff produit des rapports JSON attachés aux échantillons 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": "Pointer is now set to NULL after freeing memory."
      }
    ],
    "summary": {
      "total_deltas": 1,
      "top_score": 5.5,
      "match_rate": 100.0
    }
  }
}

Documentation

Structure du projet

AutoPiff/
├── Docs/                          # Documents de conception et spécifications
├── ghidra/scripts/                # Scripts Ghidra sans tête
│   └── autopiff_reachability.py   # BFS d'accessibilité + export de décompilation
├── rules/
│   ├── semantic_rules.yaml        # 58 règles de détection
│   ├── sinks.yaml                 # Plus de 50 symboles d'API dangereux
│   └── scoring.yaml               # Configuration du modèle de notation
├── schemas/                       # Schémas JSON pour chaque étape
├── services/
│   ├── karton-patch-differ/       # Étapes 1-4 : diff + analyse sémantique
│   ├── karton-reachability/       # Étape 5 : graphe d'appels + décompilation
│   ├── karton-ranking/            # Étape 6 : notation
│   ├── karton-report/             # Étape 7 : génération de rapports
│   ├── karton-driver-triage/      # Triage de la surface d'attaque DriverAtlas
│   ├── autopiff-alerter/          # Étape 8 : alertes Telegram
│   ├── driver-monitor/            # Étape 0 : interrogation de versions
│   └── dashboard/                 # Interface Web
├── tests/unit/                    # 137 tests unitaires
├── docker-compose.yml
└── README.md

Intégration avec driver_analyzer

AutoPiff est conçu pour fonctionner avec driver_analyzer, qui fournit l'infrastructure de production complète (MWDB, Karton, MinIO, tableaux de bord). Le fichier compose de driver_analyzer construit directement les services AutoPiff :

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

Voir le README de driver_analyzer pour les instructions d'installation.

Licence

Licence MIT - Voir LICENSE pour les détails.

Remerciements

• Karton - Cadre de traitement distribué de logiciels malveillants
• MWDB Core - Répertoire de logiciels malveillants
• Ghidra - Cadre de rétro-ingénierie logicielle de la NSA