Nano-analyzer

Un scanner de vulnérabilités zero-day minimal propulsé par LLM par AISLE.

Prototype de recherche à des fins de démonstration. Il s'agit d'un harnais simple et monofichier capable de détecter de véritables vulnérabilités zero-day. Notez qu'il s'agit d'un prototype, orienté vers les bugs de sécurité mémoire en C/C++, et qu'il produira des faux positifs. Nous le partageons tel quel dans un esprit de recherche ouverte — attendez-vous à des angles vifs.

Ce qu'il fait

Nano-analyzer est un scanner Python simple et monofichier qui envoie le code source à travers un pipeline LLM en trois étapes :

1. Génération de contexte — un modèle rédige un briefing de sécurité sur le fichier : ce qu'il fait, où circulent les données non fiables, quels tampons existent et quelle est leur taille.
2. Analyse de vulnérabilités — le même modèle, amorcé avec le contexte, cherche les bugs zero-day fonction par fonction et produit des résultats structurés.
3. Tri sceptique — chaque résultat est contesté sur plusieurs rounds par un réviseur sceptique qui peut grepper la base de code pour vérifier (ou réfuter) les défenses. Un arbitre prend la décision finale.

Les résultats sont sauvegardés sous forme de fichiers Markdown et JSON pour examen humain.

Limitations actuelles

Ceci est un prototype v0.1. Veuillez garder à l'esprit les points suivants :

• Biais C/C++. Les invites, exemples few-shot et heuristiques sont fortement ajustés pour les vulnérabilités de sécurité mémoire en C/C++ (débordements de tampon, déréférencements NULL, débordements d'entiers, confusion de types). Il analysera d'autres langages mais y est beaucoup moins efficace.
• Faux positifs. Même avec un tri en plusieurs rounds, attendez-vous à des résultats qui ne tiennent pas lors d'un examen plus approfondi. Vérifiez toujours manuellement.
• Faux négatifs. Le scanner peut manquer des classes entières de vulnérabilités — bugs logiques, conditions de course, problèmes cryptographiques, contournements d'authentification, etc. Une analyse propre ne signifie pas que le code est sûr.
• Analyse monofichier. Chaque fichier est analysé indépendamment. Les vulnérabilités inter-fichiers qui dépendent d'interactions entre unités de compilation seront probablement manquées.
• Dépendant du LLM. Les résultats varient selon le modèle utilisé. Différents modèles trouveront différentes choses et hallucineront différents faux positifs.

Configuration

Prérequis

• Python 3.8+
• Une clé API OpenAI (pour les modèles OpenAI) ou une clé API OpenRouter (pour les autres fournisseurs)
• Optionnel : ripgrep (rg) pour les recherches grep de tri
• Optionnel : Google codesearch (csearch/cindex) pour un grep plus rapide sur les grands dépôts

Installation

git clone https://github.com/weareaisle/nano-analyzer.git
cd nano-analyzer
# Aucune installation de dépendance nécessaire. Exécutez directement :
python3 scan.py --help

Clés API

Définissez votre clé API en tant que variable d'environnement :

# Pour les modèles OpenAI (noms de modèles sans barre oblique, ex. "gpt-5.4-nano") :
export OPENAI_API_KEY=sk-...

# Pour les modèles OpenRouter (noms de modèles avec barre oblique, ex. "qwen/qwen3-32b") :
export OPENROUTER_API_KEY=sk-or-...

Le scanner détermine quelle clé utiliser en fonction du nom du modèle : s'il contient un /, il passe par OpenRouter ; sinon, il utilise directement l'API OpenAI.

Utilisation

Analyse de base

# Analyser un seul fichier
python3 scan.py ./chemin/vers/fichier.c

# Analyser un dossier de manière récursive
python3 scan.py ./chemin/vers/src/

Options courantes

# Utiliser un modèle différent
python3 scan.py ./src --model gpt-5.4

# Contrôler le parallélisme
python3 scan.py ./src --parallel 30

# Pointer le grep de tri vers la racine complète du dépôt (utile lors de l'analyse d'un sous-dossier)
python3 scan.py ./lib/crypto/ --repo-dir ./

# N'afficher que les résultats à haute confiance
python3 scan.py ./src --min-confidence 0.7

# Plus de rounds de tri pour une meilleure précision (par défaut : 5)
python3 scan.py ./src --triage-rounds 7

Tous les drapeaux

Sortie

Les résultats sont sauvegardés dans ~/nano-analyzer-results/<timestamp>/ (ou --output-dir) :

<timestamp>/
├── summary.json              # résumé d'analyse lisible par machine
├── summary.md                # résumé d'analyse lisible par humain
├── <filename>.md             # sortie brute du scanner par fichier
├── <filename>.context.md     # briefing de contexte par fichier
├── <filename>.json           # données complètes des résultats par fichier
├── triages/                  # raisonnement détaillé du tri
│   └── T0001_<file>_<title>.md
├── findings/                 # résultats ayant survécu au tri
│   └── VULN-001_<file>.md
├── triage.json               # tous les verdicts de tri
└── triage_survivors.md       # résumé des résultats validés

Comment fonctionne le tri

Lorsqu'une analyse trouve un problème de sévérité moyenne ou supérieure, le pipeline de tri s'enclenche :

1. Un réviseur sceptique examine le résultat par rapport au code réel et peut grepper la base de code pour vérifier ou réfuter les défenses revendiquées.
2. Cela se répète sur plusieurs rounds (par défaut : 5), chaque réviseur voyant les arguments précédents et étant encouragé à trouver des preuves nouvelles plutôt que de ressasser les anciens points.
3. Un arbitre final lit tous les rounds et prend une décision VALIDE/NON VALIDE.
4. Le score de confiance (par ex. 80% [VVIVV→V]) reflète la fraction des rounds qui ont dit VALIDE.

Les résultats qui survivent au tri sont écrits dans le dossier findings/ avec les chaînes de raisonnement complètes.

Avertissement

Cet outil est un prototype de recherche. Il ne remplace pas les audits de sécurité professionnels, la revue manuelle de code ou les outils d'analyse statique établis. Ne vous fiez pas à lui comme votre seul moyen d'évaluation de sécurité. Utilisez-le à vos propres risques.

Licence

Apache License 2.0