Vous préférez le HTTP brut ? Utilisez l'API directement avec curl :```bash
curl -X POST http://localhost:8080/api/v1/execute/async/sec-af.audit \
  -H "Content-Type: application/json" \
  -d '{"input": {"repo_url": "https://github.com/dolevf/Damn-Vulnerable-GraphQL-Application"}}'

Chaque constat inclut un **verdict** (`confirmed` / `likely` / `inconclusive` / `not_exploitable`), un **objet de preuve** avec la trace de contamination complète et l'emplacement exact du code. Pas un « cela pourrait être un problème ». SEC-AF trace les données de la source à la destination et prouve si c'est réellement exploitable.

> Sortie complète du benchmark (30 constats) : [`exampl/dvga-benchmark-result.json`](https://github.com/agent-field/sec-af/blob/HEAD/exampl/dvga-benchmark-result.json) | Analyse de performance : [`exampl/benchmark-analysis.json`](https://github.com/agent-field/sec-af/blob/HEAD/exampl/benchmark-analysis.json)

## Benchmark : DVGA

Nous exécutons SEC-AF sur [Damn Vulnerable GraphQL Application](https://github.com/dolevf/Damn-Vulnerable-GraphQL-Application), une application délibérément vulnérable avec 21 scénarios de sécurité documentés.

| Métrique | Valeur |
|---|---|
| Constats bruts découverts | 106 |
| Après déduplication IA | 61 |
| **Après vérification adversariale** | **28 confirmés** |
| Non concluant (nécessite une revue manuelle) | 1 |
| Non exploitable (correctement rejeté) | 1 |
| Réduction du bruit | 94 % |
| Arêtes du DAG (appels reasoner) | 82 |
| Appels d'agents | ~166–255 |
| Stratégies exécutées | 11 |
| Temps réel | ~78 min |
| Coût estimé (Kimi K2.5) | ~0,18 $–0,90 $ |

<details>
<summary><strong>Répartition : 30 constats vérifiés par catégorie</strong></summary>

| Catégorie | Nombre | Exemples |
|---|---|---|
| Authentification manquante | 8 | ImportPaste, delete_all_pastes, system_debug, CreateUser, file upload |
| Injection de commande | 4 | `os.popen(cmd)` via ImportPaste, system_debug, system_diagnostics |
| Injection SQL | 3 | `filter` non assaini dans `resolve_pastes`, injection par motif LIKE, login |
| Contournement d'authentification | 3 | Signature JWT désactivée, contournement d'autorisation JWT, authentification par mot de passe cassée |
| Identifiants en clair | 3 | Stockage de mot de passe en clair, comparaison en clair, mot de passe dans les diagnostics |
| SSRF | 2 | La mutation ImportPaste suit les URLs fournies par l'utilisateur côté serveur |
| Logique métier / Assainissement d'URL | 2 | Assainissement d'URL inadéquate, suppression en masse non authentifiée |
| DoS / Épuisement des ressources | 3 | Pagination manquante sur les requêtes utilisateurs/audits, simulate_load non contrôlé |
| Configuration / Secrets | 2 | Secrets JWT/Flask codés en dur, mode débogage activé en production |

</details>

<details>
<summary><strong>Patrons de conception : comment fonctionne l'analyse de sécurité native IA</strong></summary>

SEC-AF applique plusieurs patrons architecturaux qui sont rendus possibles uniquement en composant de nombreux agents IA ciblés plutôt qu'en exécutant un scan monolithique unique. Ces patrons répondent à des défis fondamentaux de l'analyse de sécurité pilotée par l'IA.

**1. Tension adversariale entre agents (HUNT vs. PROVE)**

La plupart des outils de sécurité IA demandent à un seul modèle « est-ce vulnérable ? » et acceptent la réponse. SEC-AF sépare structurellement les agents de _découverte_ des agents de _réfutation_. Les chasseurs sont incités à trouver des vulnérabilités ; les prouveurs sont incités à les réfuter. Chaque constat passe par une chaîne de vérification à 4 agents — un traceur reconstruit le flux de données, un analyseur de désinfection recherche des mesures d'atténuation que le chasseur aurait pu manquer, un hypothéseur d'exploitation construit un scénario d'attaque concret, et un agent de verdict pèse toutes les preuves contradictoires. Cette tension adversariale entre agents est ce qui entraîne la réduction de bruit de 94 % — l'architecture elle‑même encode le scepticisme.

**2. Cascade de signaux avec rétrécissement progressif**

Au lieu de déverser tous les constats sur l'utilisateur, le pipeline comprime le signal à chaque étape : 106 constats bruts → 61 après déduplication IA → 30 après vérification adversariale. Chaque phase est un filtre. Cela reflète la façon dont les équipes de sécurité humaines trient — découverte large d'abord, puis un examen de plus en plus strict. L'idée clé est que chaque filtre est un _type différent_ de raisonnement IA : similarité sémantique pour la déduplication, analyse de taints pour la vérification, construction d'exploit pour la confirmation.

**3. Économie d'information via l'élagage du contexte**

Les LLM hallucinent davantage lorsqu'on leur donne un contexte non pertinent. SEC-AF achemine uniquement les informations dont chaque agent a besoin : un chasseur d'injection reçoit le contexte de reconnaissance élagué pour les cartes de flux de données et les points d'entrée, tandis qu'un chasseur de crypto reçoit les arbres de dépendances et les modèles de gestion des clés. Les vérificateurs reçoivent des vues projetées des constats avec seulement les champs nécessaires à leur méthode de vérification spécifique. Cet élagage du contexte par stratégie réduit à la fois les hallucinations et les coûts — les agents ne peuvent pas se confondre avec des informations qu'ils ne voient jamais.

**4. Chevauchement des phases en flux**

Les pipelines traditionnels s'exécutent séquentiellement : terminer la reconnaissance, puis commencer la chasse, puis commencer la preuve. SEC-AF chevauche les phases via `asyncio.Queue` — les chasseurs commencent à consommer les résultats de la reconnaissance dès leur arrivée, et la déduplication traite les constats à mesure que chaque chasseur termine. Les prouveurs commencent à vérifier les premiers constats dédupliqués alors que les derniers chasseurs sont encore en cours d'exécution. Cette architecture en flux réduit le temps réel sans sacrifier la cascade de signaux — chaque constat passe toujours par chaque filtre, mais plus tôt.

**5. Routage dynamique via des portes IA**

Le pipeline s'adapte à l'exécution en fonction de ce qu'il découvre. Une porte IA examine les résultats de la reconnaissance et sélectionne les stratégies de chasse à activer — une application Flask avec JWT déclenche des chasseurs différents d'un microservice Go avec gRPC. Une porte d'expansion CWE distincte élargit dynamiquement la liste des vulnérabilités cibles en fonction de la pile technologique détectée. Une porte d'atteignabilité évalue si les vulnérabilités de dépendance ont des chemins d'appel exploitables avant de gaspiller des ressources de vérification sur du code inaccessible.

**6. Autonomie guidée pour les agents de codage**

SEC-AF s'exécute au‑dessus d'agents de codage (Claude Code, OpenCode, Codex) via le harnais AgentField. Plutôt que de donner à l'agent une seule invite massive, chaque raisonneur fournit une autonomie guidée par phase : l'agent reçoit une définition de tâche étroite, un schéma de sortie plat (2-4 champs) et un contexte spécifique à la stratégie. L'agent a une autonomie totale dans ces limites — il peut lire des fichiers, tracer du code et raisonner librement — mais le harnais contraint la _forme_ de sa sortie. Cela évite le mode de défaillance courant où les agents autonomes s'écartent de la tâche ou produisent des résultats non structurés.

**7. DAG de raisonneurs composable avec observabilité totale**

Chaque appel d'agent passe par le plan de contrôle AgentField, créant un graphe acyclique dirigé complet de l'audit. Vous pouvez voir quel chasseur a trouvé quel constat, combien de temps chaque vérification a pris, quelle preuve le prouveur a générée et où le pipeline a passé son temps. Ajouter une nouvelle classe de vulnérabilité est un fichier — un nouveau chasseur. L'orchestrateur le découvre, lui achemine le contexte et intègre ses constats dans le pipeline existant de déduplication → preuve → correction. Le DAG est l'architecture.

</details>

<details>
<summary><strong>Ce qui a été manqué (et pourquoi)</strong></summary>

Les 9 scénarios manqués sont principalement des **attaques au niveau du protocole GraphQL** : requêtes par lots, récursion profonde, abus d'alias, duplication de champs, exposition de l'introspection. Celles-ci nécessitent une analyse d'exécution/DAST. SEC-AF est actuellement axé sur la SAST. La détection au niveau du protocole est sur la feuille de route.

</details>

## Comment ça marche

SEC-AF est construit sur la philosophie de l'[Intelligence Composite](https://github.com/Agent-Field/agentfield) : au lieu de s'appuyer sur un seul appel LLM monolithique, il compose de nombreux appels LLM ciblés et guidés en un **DAG de reasoners** où l'architecture elle-même encode l'intelligence (pour une explication plus approfondie de ce patron, voir [The Atomic Unit of Intelligence](https://www.santoshkumarradha.com/writing/atomic-unit-of-intelligence)). Chaque appel LLM gère une tâche petite et bien définie avec un schéma Pydantic plat (2-4 attributs). L'orchestrateur gère le flux de contexte, le parallélisme et le routage dynamique.

### Architecture : Graphe d'appels des reasoners (DAG)

Chaque phase est un `@reasoner` qui appelle des sous-reasoners via le plan de contrôle AgentField, totalisant environ ~200-300 agents travaillant de manière synchrone pour une requête donnée :

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/7491/d3e99c5c9b7067b17005f71ecb0f7c7abeb9d7fc8843d33938de9f755f416b7b.png" alt="SEC-AF Signal Cascade Pipeline — RECON → HUNT → DEDUP → PROVE → OUTPUT" width="100%" />
</p>

### Pipeline de cascade de signaux

Chaque phase rétrécit le signal. Les constats bruts sont filtrés à travers des barrières de plus en plus strictes :

| Phase | Objectif | Parallélisme |
|---|---|---|
| **RECON** | Cartographier l'architecture, les dépendances, les flux de données, le contexte de sécurité | Parallèle à 3 voies (arch + dép + config), puis à 2 voies (flux de données + sécurité) |
| **HUNT** | Exécuter 10+ chasseurs de stratégies spécialisés | Parallèle limité par sémaphore (4 concurrents par défaut) avec déduplication incrémentale |
| **PROVE** | Vérification adversariale : essayer de **réfuter** chaque constat | Parallèle limité par sémaphore (3 concurrents par défaut) |
| **REMEDIATION** | Générer des suggestions de correctifs pour les constats confirmés/probables | Parallèle limité par sémaphore (3 concurrents par défaut) |

### Pourquoi une architecture multi-reasoner

La plupart des outils de sécurité IA exécutent une seule et grande invite et espèrent que le LLM fera les choses correctement. SEC-AF décompose le problème en ~258 appels d'agents ciblés, chacun avec un schéma plat (2-4 champs) et une tâche étroite. L'architecture encode la stratégie de raisonnement, pas l'invite (voir [The Atomic Unit of Intelligence](https://www.santoshkumarradha.com/writing/atomic-unit-of-intelligence) pour comprendre pourquoi cela compte).

- **De nombreux agents ciblés > un agent puissant.** Un seul appel LLM ne peut pas simultanément cartographier l'architecture, tracer les flux de données, chasser les injections, vérifier l'exploitabilité et suggérer des correctifs. SEC-AF confie chacune de ces tâches à un raisonneur distinct qui fait bien une chose. L'orchestrateur gère la composition, le parallélisme et le routage du contexte.
- **Vérification adversariale, pas biais de confirmation.** La phase PROVE exécute 4 sous-agents par constat avec des objectifs opposés : le traceur reconstitue le flux de données, l'analyseur de désinfection recherche des blocages, l'hypothéseur d'exploitation construit une attaque, et l'agent de verdict pèse toutes les preuves. Cette tension entre agents produit une confiance plus élevée que de demander à un seul modèle « est-ce exploitable ? »
- **Routage dynamique via des portes IA.** Le système s'adapte à l'exécution. Une porte IA examine les résultats de la reconnaissance et sélectionne les stratégies de chasse à activer. Une porte distincte élargit la liste des cibles CWE en fonction de la pile détectée. Une application Flask avec JWT obtient des chasseurs différents d'un microservice Go avec gRPC.
- **Rétrécissement progressif du signal.** 106 constats bruts deviennent 61 après déduplication, puis 30 après vérification adversariale — 94 % de réduction du bruit. Chaque phase est un filtre. Le pipeline comprime le bruit, il ne se contente pas de détecter des vulnérabilités et de les déverser.
- **Économie d'information.** Chaque agent ne voit que ce dont il a besoin. Les chasseurs reçoivent le contexte de reconnaissance élagué pour leur stratégie. Les vérificateurs reçoivent des vues projetées des constats avec un nombre minimal de champs. Cela réduit les hallucinations, réduit les coûts et maintient chaque appel LLM concentré.
- **Flux incrémental.** La déduplication s'exécute en tant que consommateur pendant que les chasseurs produisent encore. Les constats sont dédupliqués par empreinte à mesure que chaque chasseur termine, puis un dernier passage sémantique capture les doublons inter-stratégies. Le pipeline diffuse en continu, il ne traite pas par lots.

## Comparaison

> Les affirmations proviennent des docs officiels et des pages de tarification. Si quelque chose est incorrect, [ouvrez un problème](https://github.com/Agent-Field/sec-af/issues).

| | SEC-AF | Nullify | Snyk Code | Semgrep | CodeQL |
|---|---|---|---|---|---|
| **Approche** | **Native IA** | **Native IA** | **Assistée par IA** | **Basée sur des règles** | **Basée sur des règles** |
| | DAG multi-reasoner · LLM raisonne sur le code | Workforce de sécurité autonome | Moteur DeepCode IA | Correspondance de motifs + taint | Analyse sémantique + flux de données |
| **Open source** | ✅ Apache 2.0 | ❌ Propriétaire | ❌ Propriétaire | Moteur : LGPL-2.1 · Règles Pro : propriétaires | Requêtes : MIT · Moteur : propriétaire |
| **Constat vérifiés** | ✅ Phase PROVE adversariale · verdict + preuve par constat | ✅ Génération de preuve d'exploit | ❌ Score de priorité (opaque) · aucune preuve d'exploit | ❌ Correspondances de motifs uniquement | ❌ Alertes d'analyse statique |
| **Preuve par constat** | Trace de flux de données avec propagation de taint | Chemin d'exploit + étapes de reproduction | Flux source-à-puits affiché | - | Les requêtes de chemin montrent le flux de données |
| **Architecture** | DAG de raisonneurs composable avec observabilité totale | Agent monolithique | Moteur à passage unique | Moteur de règles | Moteur de requêtes |
| **Parallélisme** | ✅ Chasseurs, vérificateurs, correcteurs parallèles avec déduplication incrémentale | Non documenté | Non documenté | ✅ Parallélisme des règles | ✅ Parallélisme des requêtes |
| **Notation** | ✅ Formule composite publiée | Interne | Score de priorité opaque | Interne | - |
| **SARIF** | ✅ Natif 2.1.0 | Non documenté | ✅ | ✅ | ✅ Natif |
| **Cartographie de conformité** | PCI-DSS, SOC2, OWASP, HIPAA, ISO27001 | Non documenté | Conformité plateforme uniquement | Règles OWASP disponibles | - |
| **Langages** | Tout langage supporté par LLM | Non documenté | 14+ | 35+ (basé sur analyseur syntaxique) | 10 |
| **Tarification** | **Gratuit · open source** (~0,18–0,90 $/audit en coûts LLM) | **6 000 $/mo** | 25-105 $/mo/développeur | Moteur OSS : gratuit · Pro : 30 $/mo/contributeur | Gratuit pour les dépôts publics · 49 $/mo/contributeur (GHAS) |

**Là où SEC-AF est le plus fort** : Constats vérifiés avec objets de preuve, notation transparente, cartographie de conformité, architecture multi-agent composable avec observabilité complète du DAG, et entièrement open source.

**Là où les autres sont plus forts** : Semgrep et CodeQL ont des années de couverture de règles éprouvées sur 35+ langages. Snyk a une intégration IDE/SCA approfondie. Nullify ajoute un contexte cloud à l'exécution et des campagnes de correction automatique. SEC-AF est plus récent et actuellement le plus fort sur l'analyse au niveau du code pilotée par l'IA.

> **Même architecture, domaine différent :** [Contract-AF](https://github.com/Agent-Field/contract-af) applique la méthode adversariale HUNT→PROVE aux contrats juridiques — les agents engendrent des agents pour trouver des interactions de clauses que les LLM seuls manquent.

### Pourquoi l'architecture multi-agent est importante

Les scanners de sécurité traditionnels sont monolithiques : un moteur, un passage, un ensemble de règles. L'architecture multi-reasoner de SEC-AF offre des avantages structurels :

- **Spécialisation** : Chaque chasseur est un spécialiste LLM guidé — un chasseur d'injection raisonne différemment d'un chasseur de crypto. L'architecture encode la connaissance du domaine dans le routage, pas seulement dans les invites.
- **Composabilité** : Ajoutez une nouvelle classe de vulnérabilité en ajoutant un fichier de chasseur. L'orchestrateur le découvre et l'exécute automatiquement. Aucune modification du pipeline.
- **Vérification adversariale** : La phase PROVE est structurellement séparée de HUNT. Les chasseurs essaient de trouver des vulnérabilités ; les prouveurs essaient de les réfuter. Cette tension adversariale réduit les faux positifs.
- **Observabilité** : Chaque appel de raisonneur passe par le plan de contrôle, créant un DAG complet. Vous pouvez voir exactement quel chasseur a trouvé quel constat, combien de temps chaque phase a pris et ce que le LLM a raisonné à chaque étape.
- **Efficacité des coûts** : L'élagage du contexte et les vues de schéma font que chaque appel LLM ne reçoit que le contexte dont il a besoin. Un audit standard en profondeur avec 30 constats vérifiés coûte environ ~0,18–0,90 $ en appels LLM (Kimi K2.5 via OpenRouter).

## Démarrage rapide

### Installation dans AgentField (`af install`)

Vous exécutez déjà un plan de contrôle [AgentField](https://github.com/Agent-Field/agentfield) ? Installez SEC-AF directement depuis GitHub — pas de clonage, pas de configuration locale :```bash
af install https://github.com/Agent-Field/sec-af
af run sec-af

Nouveau sur AgentField ? Installez d'abord le plan de contrôle avec `curl -fsSL https://agentfield.ai/install.sh | bash`, ou utilisez les options Docker / Railway ci-dessous.

### Déploiement en un clic (Railway)

[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/sec-af)

Déploie le plan de contrôle AgentField + l'agent SEC-AF. Vous aurez besoin d'une `OPENROUTER_API_KEY`.

### Local (Docker Compose)```bash
git clone https://github.com/Agent-Field/sec-af.git && cd sec-af
cp .env.example .env          # Add OPENROUTER_API_KEY
docker compose up --build

Interroger pour les résultats :```bash
curl http://localhost:8080/api/v1/executions/<execution_id>

**Étape 2 — Créer et activer un environnement virtuel**```bash
python3 -m venv .venv
source .venv/bin/activate

**Étape 4 — Configurer les variables d'environnement**```bash
cp .env.example .env

Optionnel — définissez un répertoire de travail personnalisé pour éviter les problèmes de permissions :```
SEC_AF_WORKSPACES_DIR=~/.sec-af/workspaces

Cela s'exécute sur `http://localhost:8080` par défaut.

**Étape 6 — Démarrer l'agent SEC-AF** (dans un autre terminal, avec le venv actif)```bash
python3 main.py

## API

<details>
<summary><strong>Options complètes de la requête</strong></summary>```bash
curl -X POST http://localhost:8080/api/v1/execute/async/sec-af.audit \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "repo_url": "https://github.com/org/repo",
      "branch": "main",
      "depth": "thorough",
      "severity_threshold": "high",
      "scan_types": ["sast", "sca", "secrets", "config"],
      "output_formats": ["sarif", "json", "markdown"],
      "compliance_frameworks": ["pci-dss", "soc2", "owasp", "hipaa"],
      "max_cost_usd": 15.0,
      "max_provers": 30,
      "max_duration_seconds": 1800,
      "include_paths": ["src/"],
      "exclude_paths": ["tests/", "vendor/"]
    }
  }'