BurpAPISecuritySuite — Extensão do Burp Suite para testes de segurança de API com 15 tipos de ataque, 108+ payloads, fuzzing inteligente, detecção de BOLA/IDOR, integração de IA e reconhecimento automatizado. Suporta APIs REST/GraphQL/SOAP com Nuclei, Turbo Intruder e integração de ferramentas externas. Cobertura do OWASP API Top 10. | Kitploit

Recurso	BurpAPISecuritySuite	Burp Scanner Pro	OWASP ZAP	Postman
Preço	Gratuito	US$ 449/ano	Gratuito	Gratuito/Pago
Foco Específico em API	✅ Sim	⚠️ Parcial	⚠️ Parcial	✅ Sim
Captura Automática e Normalização	✅ Sim	❌ Não	⚠️ Básico	❌ Não
Detecção de BOLA/IDOR	✅ Automatizada	⚠️ Manual	⚠️ Manual	❌ Não
Tipos de Ataque	15 tipos	100+ (genéricos)	50+ (genéricos)	Limitados
Payloads de API	108+ focados em API	Web genérica	Web genérica	Básicos
Análise de JWT	✅ Automática	⚠️ Extensão necessária	⚠️ Extensão necessária	⚠️ Manual
Testes de GraphQL	✅ Integrado	❌ Não	⚠️ Limitado	⚠️ Manual
Teste de Condição de Corrida	✅ Turbo Intruder	✅ Turbo Intruder	❌ Não	❌ Não
Integração com IA	✅ Exporta AI Bundle + payloads de LLM	❌ Não	❌ Não	❌ Não
Scanner de Versões	✅ Integrado	❌ Não	❌ Não	❌ Não
Mineração de Parâmetros	✅ Integrada	⚠️ Extensão necessária	❌ Não	❌ Não
Descoberta no Wayback	✅ Integrada	❌ Não	❌ Não	❌ Não
Integração com Ferramentas Externas	✅ ApiHunter, Nuclei, SQLMap, Dalfox, HTTPX, Katana, FFUF, Subfinder, DNSX	❌ Não	⚠️ Limitada	⚠️ Limitada
Técnicas de Bypass de WAF	✅ Mais de 20 métodos	⚠️ Algumas	⚠️ Algumas	❌ Não
Formatos de Exportação	JSON, Intruder, Turbo, Nuclei, cURL

ApiHunter Path: Configurar o caminho do binário apihunter (a auto-detecção padrão procura no PATH em tempo de execução e depois via sondas de shell (bash -lc e bash -ic) usando command -v, e copia o caminho absoluto encontrado; sem candidatos estáticos de fallback)
Note: ApiHunter é uma ferramenta proprietária disponível em https://github.com/Teycir/ApiHunter
Runtime PATH Resolve: Ao executar Run ApiHunter, a suíte re-resolve apihunter a partir do PATH (processo + sonda de shell) e atualiza automaticamente o campo para o binário absoluto resolvido, quando disponível
Calibration: Quick (Desktop Preset), Balanced (Desktop Preset) (padrão), Deep (Desktop Preset)
Auth Mode: Unauth Only, Auth Only, Auth + Unauth (padrão). No modo de dupla passagem, as URLs base de-duplicadas são divididas em listas de alvos auth-associated e unauth-associated; cada passagem é executada na sua própria lista. A associação de auth usa tanto cabeçalhos de auth da requisição quanto sinais de auth fora de cabeçalho (auth_detected, marcadores de token/cookie/sessão nos metadados da requisição).
Auth Mode: Unauth Only, Auth Only, Auth + Unauth (padrão). No modo de dupla passagem, as URLs base de-duplicadas são divididas em listas de alvos auth-associated e unauth-associated; cada passagem é executada na sua própria lista. A associação de auth usa tanto cabeçalhos de auth da requisição quanto sinais de auth fora de cabeçalho (auth_detected, marcadores de token/cookie/sessão nos metadados da requisição).
Top Findings Min: Limite de Critical / High / Medium configurável pelo operador para controle de ruído no resumo da triagem
Use Custom Targets: Caixa de seleção para forçar a entrada do ApiHunter a partir do popup Custom Targets... em vez do escopo filtrado do Recon
Custom Targets Popup: Editor de múltiplas linhas (máx. 20 entradas, uma por linha) com sanitização rigorosa e normalização canônica de URL base (scheme://host[:port]/), incluindo de-duplicação e rejeição de linhas inválidas
Validation Enforcement: Quando Use Custom Targets está habilitado, as execuções falham rapidamente se o conteúdo do popup estiver vazio, exceder o limite ou contiver linhas de URL inválidas
Always Filtered Source: Consome a visualização filtrada atual do Recon e emite alvos de base de host de-duplicados (scheme://host[:port]/) para o ApiHunter
Run ApiHunter: Executa o ApiHunter usando o comportamento de comando nativo do ApiHunter (o Burp atua como um launcher leve + renderizador de resultados)
Default Command Model: O Burp não aplica heurísticas extras em tempo de execução (sem limites watchdog do lado do Burp ou substituições de expansão de endpoint); os sinalizadores padrão espelham os presets Desktop do ApiHunter
Desktop Preset Parity:
- Quick: --no-discovery, --max-endpoints 40, --concurrency 4, --timeout-secs 12, --retries 1, --delay-ms 0, e desativa scanners pesados (mass-assignment, oauth-oidc, rate-limit, cve-templates, websocket)
- Balanced: --no-discovery, --max-endpoints 80, --concurrency 5, --timeout-secs 15, --retries 1, --delay-ms 50
Enable Custom: Optar pela substituição completa do comando com placeholders ({apihunter_path}, {targets_file}, {results_file})
Custom + Auth Note: No modo customizado, a dupla passagem Auth + Unauth é bloqueada; use Auth Only ou Unauth Only, ou desative o modo customizado para execução automática de dupla passagem.
Preset Visibility: O dropdown de presets está sempre visível e preenchido com modelos equivalentes aos do Desktop
Stop / PKill Tools: Cancelar execuções ativas com segurança ou interromper processos externos do scanner em emergência
Export Targets: Salvar lista de alvos de base de host filtrada/de-duplicada para uso offline do ApiHunter
Output: Resumo de descobertas NDJSON analisado com detalhamento de severidade/scanner/tempo de execução, além de erros de launcher/parse/execução
Top Findings Signal Mode: Mostra descobertas retornadas pela saída do comando ApiHunter (ordenadas por severidade com contexto de evidência/remediação)
Top Findings Display Filtering: A severidade mínima selecionada é aplicada à renderização de Top Findings no Burp (Critical / High / Medium), enquanto as estatísticas de saída do scanner permanecem completas.

Kiterunner Path: Configurar o caminho para o binário local kr
Wordlist/Alias: Usar um arquivo .kite local ou um alias do Assetnote como apiroutes-260227:20000
Profile: Ajuste de scan de rotas Fast, Balanced, Deep, com Balanced selecionado por padrão para cobertura mais ampla na primeira passagem; Fast mantém um limite mais rígido de 10 minutos para triagem mais rápida e Deep gasta um teto de 15 minutos em menos hosts com scans mais completos
Use Custom Targets: Caixa de seleção para forçar a entrada do Kiterunner a partir do popup Custom Targets... em vez do escopo filtrado do Recon
Custom Targets Popup: Editor de múltiplas linhas (máx. 20 entradas, uma por linha) com sanitização rigorosa e normalização canônica de URL base (scheme://host[:port]/)
Target Bases...: Abrir popup de múltiplas linhas para definir URLs bases/hosts explícitos
Only Base+Derivatives: Restringir scans ao escopo do popup e aos mesmos derivados de domínio base
Run Kiterunner: Descoberta de rotas de API com escopo definido, seja em URLs base definidas no popup ou na visualização filtrada atual do Recon
Startup Summary: Imprime o modo selecionado, a origem dos alvos e a lista de URLs alvo antes de o scan começar
Always Filtered Source: Quando os alvos customizados estão desativados, o Kiterunner consome a visualização filtrada atual do Recon, então o controle Filter Noise do Recon, que inicia selecionado na inicialização, comprime o conjunto padrão de alvos
Runtime Boundaries: O Kiterunner escaneia alvos de host/base classificados em vez de cada URL do Recon e aplica limites específicos de perfil para hosts, orçamento de rotas e tempo decorrido, para que as execuções não se estendam indefinidamente
WAF-Evasion Defaults: Concorrência menor, atraso de requisição, cabeçalhos de spoofing de IP encaminhado e controles de quarentena de redirect
PKill Tools: Kill de emergência para processos do scanner
Export Results: Salvar resultados da descoberta de rotas
Send to Intruder: Exportar descobertas de método/caminho para o Burp Intruder

BOLA (Broken Object Level Authorization)
- Testa TODOS os endpoints autenticados
- Escalação de privilégio horizontal/vertical
- Manipulação de token, requisições em lote
IDOR (Insecure Direct Object Reference)
- Enumeração de ID (numérico, UUID, ObjectID)
- Injeção de curinga, bypass de codificação
- Poluição de parâmetros
SQL Injection
- Baseada em booleano, baseada em união, cega baseada em tempo
- Baseada em erro, consultas empilhadas
- 38+ payloads
XSS (Cross-Site Scripting)
- Exploração de parâmetro refletido
- Quebra de contexto, payloads poliglota
- Event handlers, injeção de template
NoSQL Injection
- Operadores MongoDB ($gt, $ne, $regex)
- Notação de array, injeção em cláusula where
JWT Exploitation
- Confusão de algoritmo (alg:none)
- Injeção de kid, manipulação de claims
GraphQL Abuse
- Consultas de introspecção (extração de schema)
- Ataques de batching (baseados em array e em alias)
- Ataques de profundidade (DoS por consultas aninhadas)
- Sobrecarga de diretivas (abuso de @skip, @include)
- Sugestão de campos (descoberta de schema por typo)
- Fragmentos circulares (DoS recursivo)
- Injeção de mutação
SSTI (Server-Side Template Injection)
- Jinja2, Freemarker, Velocity
- Payloads de RCE
Race Conditions
- Exploração de TOCTOU
- Técnicas de requisição paralela
Business Logic
- Manipulação de preço/quantidade
- Bypass de fluxo de trabalho
WAF Bypass
- Injeção de cabeçalho (X-Forwarded-For, X-Original-URL)
- Bypass de codificação (URL, Unicode, Hex, entidades HTML)
- Substituição de método HTTP (X-HTTP-Method-Override)
- Manipulação de caminho (dot encoding, null bytes, ponto e vírgula)
- Manipulação de Content-Type
- Contrabando de protocolo (CL.TE, TE.CL)
Path Traversal
- Payloads de traversal de diretório
- Manipulação de caminho codificado
- Injeção de null byte
SSRF (Server-Side Request Forgery)
- Segmentação de IP interno
- Acesso a metadados de nuvem
- DNS rebinding
XXE (XML External Entity)
- Divulgação de arquivos
- SSRF via XXE
- Negação de Serviço
Deserialization
- Desserialização Java
- Injeção de objeto PHP
- Exploração de pickle Python

## Dados e exportação

### O que é capturado

### Por endpoint
- Método HTTP e caminho normalizado
- Host, protocolo, porta
- Query string e todos os tipos de parâmetro (URL, corpo, cookie, JSON)
- Cabeçalhos de requisição/resposta
- Corpos de requisição/resposta (truncados para 20KB)
- Códigos de status de resposta
- Tipos de conteúdo
- Métodos de autenticação detectados
- Padrões de API (REST, GraphQL, SOAP, etc.)

### Análise
- Visão geral da estrutura da API (tipos, métodos, autenticação, caminhos base)
- Observações de segurança (endpoints não autenticados, dados sensíveis)
- Agrupamento e deduplicação de endpoints
- Requisições de exemplo para cada endpoint

## Integração

### Integração com prompts de LLM

A exportação inclui prompts e contexto prontos para IA que priorizam:

1. Caminhos de exploração de dados sensíveis (exposição entre contas/tenants)
2. Alterações de estado não autorizadas (abuso de fluxo de trabalho/ciclo de vida)
3. Falhas de lógica não óbvias em vez de achados genéricos propensos à duplicação
4. Deltas de evidências reproduzíveis e requisições com dados ausentes

Artefatos de IA principais:
- `ai_bundle.json`
- `ai_all_tabs_context.json`
- `ai_openai_request.json`
- `ai_anthropic_request.json`
- `ai_ollama_request.json`

### Fluxo de trabalho do repositório complementar (APIPentesting)

`BurpAPISecuritySuite` e `APIPentesting` foram projetados para serem usados em conjunto:

1. Capture e analise o tráfego no BurpAPISecuritySuite.
2. Em `Recon`, clique em `Export AI Bundle`.
3. No APIPentesting, execute:
   - `./scripts/scan-nuclei-prioritize.sh /path/to/ai_bundle.json <scan-name>`
4. Revise `Reports/<scan-name>-<timestamp>/priority.json` e `results.jsonl`.
5. Use `scripts/AI_TRIAGE_PROMPT.md` (do APIPentesting) com sua interface de IA para triagem que prioriza dados sensíveis.

Divisão de responsabilidades:
- BurpAPISecuritySuite: captura no Burp, enriquecimento, análise de lógica profunda, empacotamento de IA/exportação.
- APIPentesting: orquestração de varredura externa, ranqueamento e triagem de exploração assistida por IA.

## Exemplos de fluxo de trabalho

### 1. Geração de payload com IA```bash
# 1. Capture API traffic in Burp
# 2. (Optional) Run Passive Discovery → "Run Invariants"
# 3. (Optional) In Recon, click "Refresh Invariants"
# 4. In Recon, click "Export AI Bundle"
# 5. Run APIPentesting scan from the exported bundle:
#    ./scripts/scan-nuclei-prioritize.sh /path/to/ai_bundle.json burp-ai-scan
# 6. Feed Reports/.../priority.json + results.jsonl to AI with
#    scripts/AI_TRIAGE_PROMPT.md for sensitive-data-first exploit triage.

### 3. Burp Intruder com Posições Automáticas```bash
# 1. Generate fuzzing attacks
# 2. Click "Send to Intruder"
# 3. Burp Intruder opens with §markers§ pre-configured
# 4. Load payloads from exported payloads.json
# 5. Launch attack

~/burp_APIRecon/ ├── FullExport_TIMESTAMP/ │ ├── api_analysis.json │ └── excalibur_bridge_bundle.json ├── HostExport_HOSTNAME_TIMESTAMP/ │ ├── api_analysis.json │ └── excalibur_bridge_bundle.json ├── Payloads_TIMESTAMP/ │ └── payloads.json (idor, sqli, xss, nosqli, ssrf, xxe, ssti, deserialization, waf_bypass) ├── AI_Context_TIMESTAMP/ │ ├── ai_context.json │ ├── ai_bundle.json │ ├── ai_all_tabs_context.json │ ├── ai_vulnerability_context.json │ ├── ai_behavioral_analysis.json │ ├── ai_counterfactual_differential_findings.json │ ├── ai_counterfactual_differential_summary.json │ ├── ai_sequence_invariant_findings.json │ ├── ai_sequence_evidence_ledger.json │ ├── ai_golden_ticket_findings.json │ ├── ai_golden_ticket_ledger.json │ ├── ai_state_transition_findings.json │ ├── ai_state_transition_ledger.json │ ├── ai_token_lineage_findings.json │ ├── ai_token_lineage_ledger.json │ ├── ai_parity_drift_findings.json │ ├── ai_parity_drift_ledger.json │ ├── ai_openai_request.json │ ├── ai_anthropic_request.json │ └── ai_ollama_request.json ├── SequenceInvariant_Export_TIMESTAMP/ │ ├── counterfactual_differential_findings.json │ ├── counterfactual_differential_summary.json │ ├── sequence_invariant_findings.json │ ├── sequence_evidence_ledger.json │ ├── golden_ticket_findings.json │ ├── golden_ticket_ledger.json │ ├── state_transition_findings.json │ ├── state_transition_ledger.json │ ├── token_lineage_findings.json │ ├── token_lineage_ledger.json │ ├── parity_drift_findings.json │ └── parity_drift_ledger.json ├── TurboIntruder_TIMESTAMP/ │ ├── race_condition.py │ ├── bola_enum.py │ └── jwt_brute.py ├── VersionScan_Export_TIMESTAMP/ │ └── version_scan.txt ├── ParamMiner_Export_TIMESTAMP/ │ └── param_mining.txt └── NucleiTargets_TIMESTAMP/ └── targets.txt

### Melhores Práticas

### Fase de Reconhecimento
- **Capture Tráfego Autenticado**: Faça login primeiro para capturar endpoints protegidos
- **Exercite Todos os Recursos**: Navegue por toda a aplicação para cobertura completa
- **Use Múltiplos Papéis**: Capture tráfego como admin, usuário e convidado para detecção de BOLA
- **Revise as Estatísticas**: Verifique as contagens Critical/High/Medium no painel de estatísticas

### Fase de Fuzzing
- **Comece com "All"**: Gere uma campanha de ataques abrangente primeiro
- **Concentre-se em Alto Risco**: Filtre por severidade para endpoints críticos
- **Verifique as Detecções**: Revise os ataques gerados antes de enviar para o Intruder
- **Testes em Lote**: Use o Turbo Intruder para condições de corrida e enumeração em alta velocidade

### Integração com IA
- **Exporte o Contexto Cedo**: Gere o contexto de IA após a captura inicial
- **Execute + Atualize Invariantes Antes de Exportar**: Adicione evidências novas de lógica profunda (Differential + Sequence + Golden + State Matrix + Token Lineage + Parity Drift) antes de enviar dados para a IA
- **Itere Payloads**: Use payloads gerados por IA, teste e refine o prompt
- **Combine Técnicas**: Mescle payloads de IA com a biblioteca de payloads integrada

### Automação
- **Integração com Nuclei**: Execute o Nuclei para validação rápida de vulnerabilidades
- **Exporte Alvos**: Use listas de alvos com ffuf, wfuzz ou scripts personalizados
- **Integração CI/CD**: Automatize exportações para testes de regressão

## Informações Técnicas

### Detalhes Técnicos

- **Normalização**: Substitui IDs numéricos, UUIDs e ObjectIDs por espaços reservados
- **Deduplicação**: Rastreia endpoints únicos por método + caminho normalizado
- **Truncamento**: Corpos limitados a 20KB, amostras limitadas a 3 por endpoint
- **Detecção de Autenticação**: Identifica Bearer, Basic, API Key, Session Cookie
- **Correspondência de Padrões**: Detecção baseada em regex para REST, GraphQL, SOAP

### Limitações

- Não captura tráfego WebSocket
- Respostas binárias não são totalmente analisadas
- Respostas grandes são truncadas (limite de 20KB)
- Requer Jython (sintaxe Python 2.7)

## Casos de Uso

- **Teste de Penetração de API**: Fuzzing abrangente com mais de 108 vetores de ataque
- **Caça a Bug Bounties**: Detecção e exploração automatizadas de BOLA/IDOR
- **Pesquisa de Segurança**: Técnicas avançadas de ataque (condições de corrida, JWT, GraphQL)
- **Operações de Red Team**: Scripts Turbo Intruder para ataques em alta velocidade
- **Testes Assistidos por IA**: Gere payloads personalizados com ChatGPT/Claude
- **Segurança em CI/CD**: Exporte alvos para testes automatizados de regressão
- **Treinamento e Educação**: Aprenda vulnerabilidades de API com exemplos do mundo real

## Documentação

- [Índice Completo da Documentação](https://github.com/teycir/burpapisecuritysuite/blob/main/docs/DOCUMENTATION-INDEX.md)
- [Visão Geral da Arquitetura](https://github.com/teycir/burpapisecuritysuite/blob/main/docs/Architecture.md)
- [Validação de Fuzzing GraphQL](https://github.com/teycir/burpapisecuritysuite/blob/main/docs/GRAPHQL_VALIDATION.md)
- [Referência de Tags do Logger++](https://github.com/teycir/burpapisecuritysuite/blob/main/docs/loggerpp_tags.md)

## FAQ

### Perguntas Gerais

**P: Isso funciona com o Burp Suite Community Edition?**

R: Sim! Todos os recursos principais funcionam com as edições Community e Professional. No entanto, alguns recursos avançados do Burp, como a integração com o Scanner, exigem a versão Pro.

**P: Por que a extensão não está capturando tráfego?**

R: Verifique se:
- O botão Auto-Capture está habilitado na aba Recon
- Você está navegando pelo proxy do Burp
- O alvo está enviando tráfego HTTP/HTTPS (WebSockets não suportados)
- Verifique o Activity Log para ver se há mensagens de erro

**P: Como instalo o Jython?**

R: Baixe o JAR Standalone do Jython em https://www.jython.org/download e, no Burp: Extender → Options → Python Environment → Select File → Escolha o arquivo jython-standalone-*.jar.

### Desempenho e Limites

**P: Quantos endpoints ela pode manipular?**

R: A extensão lida com eficiência com mais de 500 endpoints, com rotação automática quando o limite (800) é atingido. Endpoints mais antigos são removidos automaticamente.

**P: Por que as respostas são truncadas em 20KB?**

R: Para evitar problemas de memória com respostas grandes, preservando ao mesmo tempo o contexto útil de análise. O limite padrão atual de captura de corpo é 20KB.

**P: Posso aumentar o limite de amostras por endpoint?**

R: Sim, use o menu suspenso "Samples" na aba Recon (1, 3, 5 ou 10 amostras por endpoint).

### Fuzzing e Ataques

**P: Por que não estou vendo ataques de BOLA/Auth Bypass?**

R: Esses ataques exigem endpoints autenticados. Certifique-se de:
- Fazer login na aplicação primeiro
- Capturar tráfego enquanto autenticado
- Procurar endpoints com tokens Bearer, chaves de API ou cookies de sessão

**P: Como uso os ataques gerados?**

R: De três maneiras:
1. **Burp Intruder**: Clique em "Send to Intruder" para testes automatizados
2. **Turbo Intruder**: Exporte scripts para ataques em alta velocidade
3. **Manual**: Use "Copy as cURL" para testes via linha de comando

**P: Qual é a diferença entre "All" e tipos de ataque específicos?**

R: "All" gera ataques abrangentes em todos os tipos de vulnerabilidade. Tipos específicos (por exemplo, "SQLi") focam apenas naquela classe de vulnerabilidade para testes direcionados.

**P: Como testar endpoints GraphQL de forma eficaz?**

R: Abordagem em três frentes:
1. **Aba Fuzzer**: Selecione o tipo de ataque "GraphQL" para mais de 40 payloads específicos de GraphQL (introspection, batching, sobrecarga de diretivas, sugestão de campos)
2. **Aba Nuclei**: Execute com `-tags graphql` para mais de 29 templates cobrindo configurações incorretas e detecção
3. **Testes Manuais**: Use "Copy as cURL" para testar introspection, batching e ataques de profundidade manualmente

O Fuzzer detecta endpoints GraphQL automaticamente e gera ataques para:
- Extração de schema via introspection
- DoS via batching (array/alias) e ataques de profundidade
- Sugestão de campos para descoberta de schema quando a introspection está desabilitada
- Sobrecarga de diretivas (abuso de @skip, @include)
- DoS por fragmentos circulares
- Mutações não autorizadas

### Ferramentas Externas

**P: Preciso instalar ApiHunter/Nuclei/HTTPX/Katana/FFUF/Kiterunner?**

R: Somente se você quiser usar essas abas específicas. A extensão principal funciona sem elas. Instale a partir de:
- ApiHunter: https://github.com/Teycir/ApiHunter (ferramenta proprietária - requer instalação separada ou build local em `~/Repos/ApiHunter`, depois execute o build `target/release/apihunter`)
- Nuclei: https://github.com/projectdiscovery/nuclei
- HTTPX: https://github.com/projectdiscovery/httpx
- Katana: https://github.com/projectdiscovery/katana
- FFUF: https://github.com/ffuf/ffuf
- Kiterunner: https://github.com/assetnote/kiterunner

**P: Onde devo instalar essas ferramentas?**

R: Caminhos padrão:
- `~/Repos/ApiHunter/target/release/apihunter`
- `~/go/bin/nuclei`
- `~/go/bin/httpx`
- `~/go/bin/katana`
- `~/go/bin/ffuf`
- `~/.local/bin/kr`
- No Windows, os padrões comuns ficam em `C:\\Users\\<you>\\go\\bin\\*.exe`

Ou configure caminhos personalizados em cada aba.
As abas agora detectam automaticamente locais de binários Go no estilo Unix e no Windows `*.exe`, quando presentes.

**P: Como funcionam as substituições de comandos personalizados?**

R:
- Deixe `Enable Custom` desmarcado para usar os padrões seguros integrados.
- Marque `Enable Custom` para executar exatamente o que você digitar na caixa de comando.
- Use `Preset Cmd...` para preencher rapidamente comandos comuns (ainda opt-in até que `Enable Custom` esteja marcado).
- Clique em `?` para ver espaços reservados e exemplos para cada aba.
- Comandos personalizados são executados com `cmd /c` no Windows e `bash/sh -lc` no Linux/macOS.
- Os padrões integrados de HTTPX e Katana usam flags nativas de lista de arquivos (`-l` / `-list`) para execução multiplataforma.

### Notas de Segurança

- O modo de comando personalizado é intencionalmente rigoroso e **opt-in** (`Enable Custom` deve estar marcado).
- Comandos personalizados renderizados são validados quanto a fragmentos de shell proibidos (por exemplo, encadeamento de comandos/redirecionamento/sintaxe de subshell).
- Os executáveis são restritos por listas de permissão por ferramenta no modo personalizado (por exemplo, `nuclei`, `httpx`, `katana`, `waybackurls`/`gau`, `apihunter`, `subfinder`).
- Os valores de contexto dos espaços reservados são sanitizados antes da renderização do template, e variantes entre aspas estão disponíveis (`{targets_file_q}`, `{urls_file_q}`, etc.) para interpolação de caminho mais segura.
- Se seu fluxo de trabalho precisar de lógica de shell complexa fora desta política, execute esse comando manualmente fora da extensão.

**P: Por que o HTTPX mostra erros de opção inválida?**

R:
- Certifique-se de estar usando o `httpx` do ProjectDiscovery, não a ferramenta CLI `httpx` do Python.
- Caminho recomendado: `~/go/bin/httpx`.
- A extensão agora valida as assinaturas das ferramentas locais e mostra uma dica de correção quando há incompatibilidade.

**P: Como preencho rapidamente os cabeçalhos Guest/User/Admin para Auth Replay?**

R:
- Em `Auth Replay`, clique em `Extract` ao lado de Guest/User/Admin.
- Um popup pesquisável é aberto com cabeçalhos capturados como candidatos.
- Filtre por texto do endpoint, nome do cabeçalho ou fragmento de token.
- Selecione um item e clique em `OK`; o campo é preenchido no formato `Name: value`.

### Exportação e Integração

**P: Onde os arquivos exportados são salvos?**

R: Todas as exportações vão para `~/burp_APIRecon/` com subdiretórios com carimbo de data/hora. Verifique o Activity Log para os caminhos exatos.

**P: Como uso a exportação de Contexto de IA?**

R:
1. (Opcional) Execute `Passive Discovery` → `Run Invariants`
2. (Opcional) Na aba `Recon`, clique em `Refresh Invariants`
3. Na aba `Recon`, clique em `Export AI Bundle`
4. Use o APIPentesting para escanear a partir dessa exportação:
   - `./scripts/scan-nuclei-prioritize.sh /path/to/ai_bundle.json burp-ai-scan`
5. Alimente `Reports/.../priority.json` + `results.jsonl` na sua interface de IA usando o APIPentesting `scripts/AI_TRIAGE_PROMPT.md`
6. Use `ai_sequence_evidence_ledger.json`, `ai_golden_ticket_ledger.json` e `ai_state_transition_ledger.json` para priorizar o que validar primeiro

**P: Posso importar dados exportados anteriormente?**

R: Sim. `Import` aceita:
- `api_analysis.json` (exportação do BurpAPISecuritySuite)
- Exportações `.har` do Excalibur (Excalibur é uma ferramenta proprietária: https://github.com/Teycir/Excalibur)
- Sidecars do Excalibur `-replay-studio.json` / `-cookies.json` / `-insights.json` (descobertos automaticamente pelo mesmo prefixo de sessão)
- `excalibur_bridge_bundle.json` (`schema: excalibur-burp-bridge/v1`)

Se artefatos do Excalibur forem detectados, a ferramenta executa automaticamente `Refresh Invariants` após a importação, para que os caches Differential + Sequence + Golden + State + Token Lineage + Parity Drift fiquem imediatamente prontos.

**P: Posso enviar requisições capturadas para o Postman ou Insomnia?**

R: Sim. Na aba Recon, use:
- `Postman` para exportar `postman_collection.json` (Collection v2.1)
- `Insomnia` para exportar `insomnia_collection.json` (formato de importação do Insomnia)
- Ambos suportam seleção de escopo: `All Endpoints`, `Filtered View` ou `Current Host`.

### Solução de Problemas

**P: Extensão carregada, mas não aparece nas abas?**

R: Verifique a aba Extender → Extensions do Burp para ver erros. Problemas comuns:
- Jython não configurado corretamente
- Erros de sintaxe do Python 2.7 (a extensão usa Jython/Python 2.7)
- Memória insuficiente (aumente o tamanho do heap do Burp)

**P: Mensagem "No endpoints captured"?**

R: Certifique-se de:
- Estar navegando ativamente pelo proxy do Burp
- Auto-Capture estar habilitado
- O alvo estar fazendo requisições HTTP (não apenas carregando arquivos estáticos)
- Verificar se os endpoints estão sendo filtrados (imagens/fontes são filtradas automaticamente)

**P: O scan do Nuclei/HTTPX trava ou expira?**

R:
- Verifique se a ferramenta está instalada e se o caminho está correto
- Verifique a conectividade de rede com os alvos
- Scans grandes podem levar vários minutos (tempo máximo padrão: 15 minutos)
- Use **Target Bases...** com **Only Base+Derivatives** para forçar escopo estrito de alvo único
- Use o botão **Stop** na mesma aba para cancelar ferramentas externas em execução
- Verifique o Activity Log para mensagens de erro detalhadas

**P: Por que alguns endpoints são marcados como "Critical" ou "High"?**

R: A severidade é baseada em:
- **Critical**: endpoints de debug/admin, IDOR/BOLA não autenticado
- **High**: IDOR/BOLA autenticado, exposição de dados sensíveis, criptografia fraca
- **Medium**: respostas de erro, parâmetros refletidos
- **Info**: endpoints padrão

### Uso Avançado

**P: Como testo condições de corrida?**

R:
1. Gere ataques de fuzzing (aba Fuzzer)
2. Clique no botão "Turbo Intruder"
3. Carregue o script `race_condition.py` exportado no Turbo Intruder do Burp
4. Configure para mais de 50 requisições paralelas

**P: Posso personalizar payloads de ataque?**

R: Sim! Exporte payloads para JSON, modifique-os e então:
- Use no Burp Intruder manualmente
- Alimente a IA para aprimoramento
- Crie scripts personalizados com a biblioteca de payloads

**P: Como comparo duas versões de API?**

R:
1. Exporte os dados da API da versão 1 ("Export All")
2. Limpe os dados e capture a versão 2
3. Exporte a versão 2
4. Use a aba Diff → Carregue as duas exportações → Compare

**P: Qual é o melhor fluxo de trabalho para caça a bug bounties?**

R:
1. Capture tráfego autenticado (todos os papéis de usuário)
2. Revise primeiro os endpoints de severidade Critical/High
3. Gere ataques "All" no Fuzzer
4. Concentre-se em endpoints BOLA/IDOR
5. Use o Version Scanner para encontrar APIs legadas
6. Execute o Param Miner em endpoints de alto valor
7. Exporte para o Nuclei para validação automatizada

### Destaques Técnicos

- **Arquitetura Jython Limpa**: Design modular com lógica central testável
- **Extração Modular**: Fluxos de trabalho pesados extraídos para módulos auxiliares (`heavy_runners.py`, `ai_prep_layer.py`, `behavior_analysis.py`)
- **Detecção Inteligente**: Identificação de vulnerabilidades sensível ao contexto
- **Desempenho Otimizado**: Lida com mais de 500 endpoints com eficiência
- **Multiplataforma**: Funciona em Windows, macOS e Linux
- **Extensível**: Fácil adicionar novos tipos de ataque e payloads
- **UI Profissional**: Severidade codificada por cores, interface com abas, estatísticas em tempo real
- **Cobertura de Replay**: Inclui testes de corpus de replay dourado para detecção de invariantes de sequência + saída de registro de confiança

## 💼 Serviços Profissionais

Precisa de ferramentas de segurança personalizadas ou soluções de teste de API? Eu construo aplicativos prontos para produção e ferramentas de segurança.

### Projetos em Destaque

- **[ApiHunter](https://github.com/Teycir/ApiHunter)** - Ferramenta automatizada de reconhecimento e teste de segurança de API com descoberta inteligente de endpoints
- **[TimeSeal](https://timeseal.online)** ([GitHub](https://github.com/Teycir/Timeseal)) - Cofre criptográfico com bloqueio por tempo e interruptor de homem morto com criptografia zero-trust
- **[Ghost Chat](https://ghost-chat.pages.dev)** - Chat P2P seguro com WebRTC, sem armazenamento em servidor, temporizadores de autodestruição
- **[BurpCopyIssues](https://github.com/Teycir/BurpCopyIssues)** - Extensão do Burp Suite para navegar, copiar e exportar resultados de scan
- **[BurpWpsScan](https://github.com/Teycir/BurpWpsScan)** - Scanner de segurança WordPress para Burp Suite com integração com a API do WPScan
- **[Excalibur](https://github.com/Teycir/Excalibur)** - Ferramenta de descoberta de superfície de ataque de API e fluxo de trabalho de sessão para operações práticas de pentest (ferramenta proprietária)
- **[APIPentesting](https://github.com/Teycir/APIPentesting)** - Fluxo de trabalho complementar de escaneamento externo e triagem de exploração com foco no Burp para caça a bug bounties em API
- **Ferramentas de Segurança Personalizadas** - Extensões do Burp, frameworks de teste de API, scripts de automação

### Serviços Oferecidos

- 🔒 **Desenvolvimento de Ferramentas de Segurança** - Extensões personalizadas do Burp, ferramentas de teste de penetração, frameworks de automação
- 🚀 **Desenvolvimento de Aplicações Web** - Desenvolvimento full-stack com tecnologias modernas
- 🔧 **Consultoria em Segurança de API** - Revisão de arquitetura, avaliação de vulnerabilidades, orientação de remediação
- 🤖 **Integração com IA** - Ferramentas de segurança com tecnologia LLM, geração automatizada de payloads, fuzzing inteligente

**Entre em Contato**: [teycirbensoltane.tn](https://teycirbensoltane.tn) | Disponível para projetos freelance e consultoria

## Contribuindo

### Autor

Desenvolvido por [Teycir Ben Soltane](https://teycirbensoltane.tn)

### Licença

Licença MIT - Livre para uso em testes de segurança autorizados e fins de pesquisa.

## Changelog

Veja [CHANGELOG.md](https://github.com/teycir/burpapisecuritysuite/blob/main/CHANGELOG.md) para o histórico completo de versões.

BurpAPISecuritySuite

Mais Populares

Sobre

Apoie o Desenvolvimento

BurpAPISecuritySuite

Por que uma extensão com várias abas?

Índice

Capturas de Tela

Interface Principal

Aba Scope

Aba Fuzzer

Análise de Parâmetros

Visualização Diff

Aba ApiHunter

Aba Nuclei

Aba Katana

Aba HTTPX

Aba FFUF

Aba Wayback

Opções de Exportação

Exportação Turbo Intruder

Informações da Versão

Propósito

Principais Recursos

🎯 Reconhecimento

⚡ Fuzzing Avançado

🔍 Ferramentas de Descoberta

🚀 Exportação e Integração

Comparação com Ferramentas Semelhantes

Por que escolher o BurpAPISecuritySuite?

Instalação

Requisitos

Uso

Fluxo de Trabalho Básico

Visão Geral das Abas

1. Aba Scope

2. Aba Recon

Aba Logger

3. Aba Diff

4. Aba Scanner de Versões

5. Aba Param Miner

7. Aba Auth Replay

8. Aba Descoberta Passiva

Aba Dados Sensíveis

9. Aba ApiHunter

10. Aba Nuclei

11. Aba HTTPX

12. Aba Katana

13. Aba FFUF

14. Aba Kiterunner

15. Aba Wayback

16. Aba SQLMap Verify

17. Aba Dalfox Verify

18. Aba API Assets

19. Aba OpenAPI Drift

20. Aba GraphQL

Capacidades Avançadas de Fuzzing

Tipos de Ataque Detectados

Estrutura de Dados Exportada```json

2. Turbo Intruder Condição de Corrida```bash

1. Generate fuzzing attacks

2. Click "Turbo Intruder" button

3. In Burp: Extensions → Turbo Intruder

4. Right-click target request → Send to Turbo Intruder

5. Load race_condition.py script

6. Execute for 50 parallel requests

Locais de Saída```