WAF com e sem IA: Testando Firewalls de Aplicação com Semgrep via MCP no Whitebox Testing
Todo pentester que já enfrentou um WAF (Web Application Firewall) sabe: o problema não é encontrar a vulnerabilidade — é fazê-la passar pelo filtro. SQL injection, XSS, path traversal, command injection — o WAF bloqueia por padrão e você gasta horas em bypass. Mas e se você tiver acesso ao código-fonte? O whitebox testing muda completamente o jogo. Com o [Semgrep MCP](https://github.com/semgrep/mcp) (666 stars, projeto oficial da Semgrep), você combina análise estática (SAST) com a capacidade de raciocínio de um LLM para identificar vulnerabilidades antes mesmo de pensar em evasão de WAF — e depois usar essa inteligência para construir payloads que o WAF nunca espera.
O cenário: whitebox vs blackbox contra WAFs
No blackbox, você está cego. Envia payloads, observa respostas, itera. O WAF é uma caixa preta que ouve tudo e bloqueia o que reconhece como malicioso. É eficaz, mas tem limitações estruturais: não conhece a lógica da aplicação, não sabe quais inputs são validados serverside, não tem contexto de negócio.
No whitebox, você tem o código. Sabe onde a sanitização acontece (ou não), conhece os endpoints, entende a lógica de validação. A questão muda de “como bypassar o WAF” para “onde o código é vulnerável independentemente do WAF”. O WAF é a última camada de defesa — se o código é vulnerável, o WAF é um patch, não uma solução.
O Semgrep MCP é a ferramenta que conecta essa análise de código ao raciocínio de um LLM via MCP, transformando o processo de whitebox testing numa sessão interativa onde você pergunta, investiga, e refina.
Semgrep MCP: o que é e como funciona
O Semgrep MCP é o servidor MCP oficial da Semgrep, agora integrado ao binário principal do Semgrep (o repo standalone foi arquivado). Exponhe ferramentas para scanning de segurança, análise de código, e criação de regras customizadas — tudo via conversa com um LLM.
Ferramentas expostas
– `security_check`: scan de segurança rápido
– `semgrep_scan`: scan com config customizada
– `semgrep_scan_with_custom_rule`: scan com regra Semgrep custom
– `get_abstract_syntax_tree`: extrai a AST do código
– `supported_languages`: lista linguagens suportadas
– `semgrep_rule_schema`: schema para escrever regras
Alem disso, o prompt `write_custom_semgrep_rule` ajuda a criar regras sob medida e os recursos `semgrep://rule/schema` e `semgrep://rule/{rule_id}/yaml` fornecem referência técnica sem chamadas API adicionais.
Instalação
“`bash
Via uv (recomendado)
uvx semgrep-mcp
Via Docker
docker run -i –rm ghcr.io/semgrep/mcp -t stdio
Via pip
pipx install semgrep-mcp
“`
Integração com Claude Code:
“`json
{
“mcpServers”: {
“semgrep”: {
“command”: “uvx”,
“args”: [“semgrep-mcp”],
“env”: {
“SEMGREP_APP_TOKEN”: “
}
}
}
}
“`
Integração com VS Code Copilot:
“`json
{
“mcpServers”: {
“semgrep”: {
“command”: “uvx”,
“args”: [“semgrep-mcp”]
}
}
}
“`
Fluxo de whitebox testing com Semgrep MCP
Passo 1: Scan inicial
No Claude Code ou VS Code:
“`
Scaneie o diretório /app/src por vulnerabilidades de segurança
“`
O LLM invoca `security_check` ou `semgrep_scan` com as regras padrão do Semgrep Registry (5000+ regras). Resultado: lista de findings com severidade, arquivo, linha, e código vulnerável.
Passo 2: Investigar findings específicos
“`
Mostre detalhes das vulnerabilidades de SQL injection encontradas. Para cada uma, mostre o código vulnerável e a regra Semgrep que detectou.
“`
O LLM pode carregar a regra via `semgrep://rule/{rule_id}/yaml` para explicar exatamente o padrão que foi匹配ado.
Passo 3: Criar regras customizadas
Se o scan padrão não encontrou o que você procura (a aplicação tem um padrão de sanitização custom, por exemplo):
“`
Crie uma regra Semgrep que detecte quando a função sanitize_input() é usada antes de queries SQL mas sem tratar caracteres de comentário (–) e newline (%0a)
“`
O LLM usa o prompt `write_custom_semgrep_rule` para gerar a regra, depois `semgrep_scan_with_custom_rule` para rodá-la:
“`yaml
rules:
- id: weak-sanitization-sqli
patterns:
- pattern-either:
- pattern: |
sanitize_input($VAR)
…
$DB.query(“… $VAR …”)
- pattern: |
sanitize_input($VAR)
…
cursor.execute(“… $VAR …”)
message: “Sanitização fraca: sanitize_input() não trata comentários SQL (–, /)”
languages: [python, java, php]
severity: WARNING
“`
Passo 4: Análise de AST para bypass de sanitização
“`
Para cada sanitizador customizado encontrado, extraia a AST e identifique casos onde caracteres perigosos passam pela função.
“`
O LLM invoca `get_abstract_syntax_tree` para analisar a estrutura lógica da função de sanitização — revelando gaps que o scan superficial não captura.
WAF com IA vs WAF sem IA: análise comparativa
Cenário de teste
Aplicação web em PHP com:
- WAF ModSecurity com OWASP CRS
- Sanitização customizada serverside
- Endpoint de login vulnerável a SQL injection boolean-based blind
#### Sem Semgrep MCP (abordagem manual)
1. Rodar SQLMap com tamper scripts
2. Identificar que payloads padrão são bloqueados
3. Testar variações manualmente (case alternation, inline comments, double encoding)
4. Sem acesso ao código: tentativa e erro contra o WAF
5. Sem acesso ao código: não sabe quais inputs são sanitizados serverside
Tempo típico: 2-4 horas para bypass. Taxa de sucesso: 60-70%.
#### Com Semgrep MCP (whitebox + IA)
1. Scaneia o código-fonte com `security_check`
2. Identifica que a sanitização de login usa `addslashes()` mas não `mysql_real_escape_string()`
3. O LLM nota que `addslashes()` não escapa todos os bytes multibyte em certos charsets
4. Cria regra custom para detectar esse padrão no restante do código
5. Identifica 3 outros endpoints com o mesmo problema
6. Com conhecimento do vetor exato, constrói payloads que o WAF não espera (explorando charset GBK, por exemplo)
Tempo típico: 30-60 minutos. Taxa de sucesso: 85-95%.
Tabela comparativa
| Aspecto | Sem IA | Com Semgrep MCP |
|———|——–|—————–|
| Identificação de sanitização fraca | Tentativa e erro | Análise estática do código |
| Criação de regras customizadas | Manual, knowledge-based | Gerada por LLM e validada |
| Cobertura de regras | Limitada às padrão | 5000+ padrão + custom |
| Análise de AST | Manual, IDE | Automática via MCP |
| Correlação entre findings | Cerebro do pentester | LLM cross-references |
| Documentação dos gaps | Relatório manual | Gerado na conversa |
| Custo | Horas de trabalho | Minutos + API tokens |
Detecção de WAF bypass vectors no código
O whitebox com Semgrep MCP permite identificar vetores de bypass antes de testar:
Sanitização inconsistente:
“`python
Semgrep detecta: sanitização diferente para o mesmo campo em endpoints distintos
def login(request):
user = sanitize_html(request.POST[‘user’]) # HTML-only sanitization
query = f”SELECT FROM users WHERE user='{user}'” # SQLi!
“`
Concatenação post-sanitização:
“`python
clean = sanitize(input)
final = clean + request.GET[‘extra’] # Re-contamination!
cursor.execute(f”SELECT FROM t WHERE x='{final}'”)
“`
Type juggling:
“`php
$id = sanitize($_GET[‘id’]);
// Semgrep com regra custom detecta: comparação frouxa
if ($row[‘id’] == $id) { // == ao invés de ===
“`
Encoding/decoding mismatch:
“`java
String input = sanitize(request.getParameter(“q”));
String decoded = URLDecoder.decode(input); // Decodifica depois de sanitizar!
“`
Cada um desses padrões é uma porta para WAF bypass — o WAF bloqueia payloads maliciosos, mas se a aplicação reconstrói o ataque internamente (decodifica depois de sanitizar, concatena depois de filtrar), o WAF nunca vê o payload final.
Limitações honestas
Falso senso de segurança. Um scan limpo no Semgrep não significa que o código é seguro. SAST é ferramenta de detecção de padrões, não de prova de segurança. Lógica de negócio, race conditions, e vulnerabilidades de lógica (IDOR com verificação de permissão deficiente) escapam à análise estática.
Dependência de regras. O Semgrep é tão bom quanto suas regras. Regras padrão cobrem os OWASP Top 10, mas padrões de sanitização customizados da sua aplicação precisam de regras customizadas. Criar boas regras exige conhecimento tanto de Semgrep quanto do domínio.
Custo de tokens. Scans grandes geram volumes enormes de findings. Cada finding consumido pelo LLM é tokens. Projetos enterprise podem gerar milhares de findings — o custo de processar tudo via LLM é não-trivial.
O LLM erra. Semgrep dá os findings; o LLM interpreta. E LLMs ainda cometem erros de interpretação técnica. Um falso positivo interpretado como verdadeiro leva a esforço desperdiçado; um falso negativo (vuln não detectada) leva a falsa confiança.
WAFs evolutionários. WAFs modernos (Cloudflare, AWS WAF) usam machine learning e behavioral analysis. Identificar a vulnerabilidade no código é metade do trabalho — a outra metade é bypassar um WAF que aprende com cada tentativa.
Semgrep MCP vs mcp-server-semgrep (VetCoders)
Existe uma segunda implementação: o [mcp-server-semgrep](https://github.com/vetcoders/mcp-server-semgrep) (28 stars), em JavaScript, com features adicionais como `scan_directory`, `compare_results` (diff before/after), `export_results`, e `filter_results`. A instalação é mais simples via Smithery.ai.
Para whitebox testing de segurança, o servidor oficial (semgrep/mcp) é mais confiável — é mantido pela equipe da Semgrep, usa o binário oficial, e tem mais de 5000 regras no registry. O VetCoders é útil se você precisa das features de comparação e exportação.
Conclusão
Whitebox testing com Semgrep MCP não é uma replacement para testes blackbox — é um acelerador que muda a estratégia. Em vez de “bater no WAF até ele ceder”, você identifica a vulnerabilidade no código, entende o mecanismo exato de exploração, e constrói um payload cirúrgico que o WAF não está preparado para bloquear.
Para equipes de segurança que já têm acesso ao código (code review, DevSecOps, assessments internos), adicionar Semgrep MCP ao workflow é um upgrade de produtividade significativo. Para pentesters externos em blackbox puro, o valor é limitado — mas se você conseguir acesso ao repo (GitHub leak, repo privado acessível, engenharia social), o Semgrep MCP transforma horas de análise manual em minutos de conversa com um LLM.
O WAF é uma parede. O código é a porta. Semgrep MCP ajuda a encontrar a porta — e a chave.
Repositórios:
- [semgrep/mcp](https://github.com/semgrep/mcp) (oficial, 666 stars)
- [vetcoders/mcp-server-semgrep](https://github.com/vetcoders/mcp-server-semgrep) (alternativa, 28 stars)