Les autres outils signalent des motifs. SEC-AF prouve l'exploitabilité : chaque résultat est accompagné d'un verdict, d'une trace de flux de données et de preuves exploitables. Gratuit, open source, un seul appel API. Un audit complet avec 30 résultats vérifiés coûte environ $1.40 en appels LLM.

DX en un appel

Déclenchez-le avec la CLI af (nécessite af ≥ 0.1.87) — il diffuse la progression en direct et imprime le résultat :```bash af call sec-af.audit --in '{"repo_url": "https://github.com/dolevf/Damn-Vulnerable-GraphQL-Application"}'

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"}}'

Ce que vous obtenez en retour

Ceci est un résultat réel d'un audit SEC-AF sur DVGA (une application GraphQL délibérément vulnérable) :```jsonc { "title": "OS Command Injection in run_cmd Helper Function", "severity": "critical", "verdict": "confirmed", // not "maybe" — confirmed exploitable "evidence_level": 5, "cwe_id": "CWE-78",

"rationale": "Tracer confirms complete data flow from GraphQL parameters (host, port, path, scheme, cmd, arg) to os.popen(cmd).read() sink. Sanitization functions are bypassable in Easy mode...",

"proof": { "verification_method": "composite_subagent_chain:sast", "data_flow_trace": [ { "description": "core/views.py:203 — GraphQL args defined (host, port, path, scheme)", "tainted": true }, { "description": "core/views.py:210 — URL constructed from user input", "tainted": true }, { "description": "core/views.py:211 — helpers.run_cmd(f'curl {url}') called", "tainted": true }, { "description": "core/helpers.py:9 — os.popen(cmd).read() executes input", "tainted": true } ] },

"location": { "file_path": "core/helpers.py", "start_line": 9, "code_snippet": "def run_cmd(cmd):\n return os.popen(cmd).read()" } }

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/main/exampl/dvga-benchmark-result.json) | Analyse de performance : [`exampl/benchmark-analysis.json`](https://github.com/agent-field/sec-af/blob/main/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**