Outras ferramentas sinalizam padrões. O SEC-AF comprova explorabilidade: cada descoberta vem com um veredito, um rastro de fluxo de dados e evidências acionáveis. Gratuito, código aberto, uma chamada de API. Uma auditoria completa com 30 descobertas verificadas custa cerca de US$ 1,40 em chamadas LLM.

DX de Chamada Única

Acione com a CLI af (requer af ≥ 0.1.87) — ela transmite progresso ao vivo e imprime o resultado:```bash af call sec-af.audit --in '{"repo_url": "https://github.com/dolevf/Damn-Vulnerable-GraphQL-Application"}'

Prefere HTTP puro? Acesse a API diretamente com 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"}}'

O que você recebe de volta

Esta é uma descoberta real da auditoria SEC-AF DVGA (um aplicativo GraphQL deliberadamente vulnerável):```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()" } }

Cada descoberta inclui um **veredito** (`confirmed` / `likely` / `inconclusive` / `not_exploitable`), um **objeto de prova** com o rastreamento completo de contaminação (taint trace) e a localização exata do código. Não é "isso pode ser um problema." SEC-AF rastreia dados da origem ao destino (source to sink) e comprova se é realmente explorável.

> Saída completa do benchmark (30 descobertas): [`exampl/dvga-benchmark-result.json`](https://github.com/agent-field/sec-af/blob/main/exampl/dvga-benchmark-result.json) | Análise de desempenho: [`exampl/benchmark-analysis.json`](https://github.com/agent-field/sec-af/blob/main/exampl/benchmark-analysis.json)

## Benchmark: DVGA

Executamos o SEC-AF contra a [Damn Vulnerable GraphQL Application](https://github.com/dolevf/Damn-Vulnerable-GraphQL-Application), um aplicativo deliberadamente vulnerável com 21 cenários de segurança documentados.

| Métrica | Valor |
|---|---|
| Descobertas brutas encontradas | 106 |
| Após deduplicação por IA | 61 |
| **Após verificação adversarial** | **28 confirmados** |
| Inconclusivo (necessita revisão manual) | 1 |
| Não explorável (corretamente rejeitado) | 1 |
| Redução de ruído | 94% |
| Arestas do DAG (chamadas de reasoner) | 82 |
| Chamadas de agente | ~166–255 |
| Estratégias executadas | 11 |
| Tempo real (wall-clock) | ~78 min |
| Custo estimado (Kimi K2.5) | ~$0.18–$0.90 |

<details>
<summary><strong>Detalhamento: 30 descobertas verificadas por categoria</strong></summary>

| Categoria | Contagem | Exemplos |
|---|---|---|
| Autenticação ausente | 8 | ImportPaste, delete_all_pastes, system_debug, CreateUser, upload de arquivo |
| Injeção de comando | 4 | `os.popen(cmd)` via ImportPaste, system_debug, system_diagnostics |
| Injeção SQL | 3 | `filter` não sanitizado em `resolve_pastes`, injeção de padrão LIKE, login |
| Bypass de autenticação | 3 | Assinatura JWT desabilitada, bypass de autorização JWT, autenticação de senha quebrada |
| Credenciais em texto plano | 3 | Armazenamento de senha em texto claro, comparação em texto plano, senha em diagnósticos |
| SSRF | 2 | Mutação ImportPaste segue URLs fornecidas pelo usuário no lado do servidor |
| Lógica de negócios / Sanitização de URL | 2 | Sanitização inadequada de URL, exclusão em massa não autenticada |
| DoS / Exaustão de recursos | 3 | Falta de paginação em consultas de usuários/auditorias, simulate_load descontrolado |
| Configuração / Segredos | 2 | Segredos JWT/Flask codificados, modo debug ativado em produção |

</details>

<details>
<summary><strong>Padrões de design: como a análise de segurança nativa em IA funciona</strong></summary>

O SEC-AF aplica vários padrões arquiteturais que são exclusivamente possibilitados pela composição de muitos agentes de IA focados em vez de executar uma varredura monolítica. Esses padrões abordam desafios fundamentais na análise de segurança orientada por IA.

**1. Tensão adversarial de agentes (HUNT vs. PROVE)**

A maioria das ferramentas de segurança com IA pergunta a um único modelo "isso é vulnerável?" e aceita a resposta. O SEC-AF separa estruturalmente os agentes de _descoberta_ dos agentes de _refutação_. Os caçadores (hunters) são incentivados a encontrar vulnerabilidades; os provadores (provers) são incentivados a refutá-las. Cada descoberta passa por uma cadeia de verificação de 4 agentes — um rastreador (tracer) reconstrói o fluxo de dados, um analisador de sanitização procura mitigações que o caçador pode ter perdido, um hipotetizador de exploit constrói um cenário de ataque concreto, e um agente de veredito pondera todas as evidências conflitantes. Essa tensão adversarial entre agentes é o que impulsiona a redução de ruído de 94% — a própria arquitetura codifica o ceticismo.

**2. Cascata de sinal com estreitamento progressivo**

Em vez de despejar todas as descobertas no usuário, o pipeline comprime o sinal em cada estágio: 106 descobertas brutas → 61 após deduplicação por IA → 30 após verificação adversarial. Cada fase é um filtro. Isso espelha como as equipes de segurança humanas realizam a triagem — descoberta ampla primeiro, depois escrutínio progressivamente mais rigoroso. A principal percepção é que cada filtro é um _tipo diferente_ de raciocínio de IA: similaridade semântica para deduplicação, análise de contaminação (taint analysis) para verificação, construção de exploit para confirmação.

**3. Economia de informação via poda de contexto**