jay123anta/laravel-threat-detectionMiddleware Laravel passivo que detecta e registra injeção de SQL, XSS, RCE, scanners de bot e mais de 175 padrões de ataque. Inclui painel integrado, alertas do Slack, API REST e enriquecimento geográfico. IDS, não WAF.
Monitoramento de segurança e registro de ataques para Laravel. Detecte e registre injeção de SQL,
XSS, RCE, travessia de diretórios, scanners de bots e sondagens de reconhecimento no estilo /wp-admin —
cada requisição hostil é gravada no seu banco de dados com contexto completo da aplicação.
É um IDS, não um WAF: nunca bloqueia, filtra ou modifica uma requisição.
GET /wp-admin/setup-config.php 404 — on a site that isn't WordPress GET /.env 404 — someone wants your database password GET /?id=1' UNION SELECT password FROM 200 — SQL injection against a real route GET /phpmyadmin/index.php 404 — scanning for an admin panel
Essas solicitações já estão chegando ao seu aplicativo Laravel. Seu log de acesso mostra a URL
e o código de status, e nada mais — não o payload decodificado, não qual das suas
rotas foi alvo, não se o mesmo IP tentou outras quarenta coisas nesta hora.
Este pacote responde a essas perguntas. Instale-o em qualquer aplicativo Laravel 10–13 e ele começa
a examinar cada solicitação HTTP contra mais de 150 padrões de ataque, pontuando cada correspondência por
confiança e gravando-a no seu banco de dados — com um painel integrado, alertas do Slack,
enriquecimento geográfico e exportações para fail2ban/blocklist. Nenhuma solicitação é bloqueada. Pense
em câmera de segurança, não em cadeado: ele mostra exatamente quem está sondando suas rotas, com que
frequência e com quais técnicas.
> Extraído de um aplicativo de produção e testado em tráfego real. 335 testes, sem dependências de
> tempo de execução além do próprio Laravel, e nenhuma conexão com a internet necessária para detecção.
>
> Atualizando? Consulte [UPGRADING.md](https://github.com/jay123anta/laravel-threat-detection/blob/main/UPGRADING.md). Contribuindo? Consulte [CONTRIBUTING.md](https://github.com/jay123anta/laravel-threat-detection/blob/main/CONTRIBUTING.md).
## Comece em menos de um minuto```bash
composer require jayanta/laravel-threat-detection
php artisan vendor:publish --tag=threat-detection-migrations
php artisan migrate
Em seguida, adicione o middleware ao seu grupo web (uma linha em bootstrap/app.php no Laravel 11+,
ou app/Http/Kernel.php no Laravel 10) — trecho completo em Início Rápido abaixo.
É isso; a detecção está ativa.```bash
php artisan threat-detection:doctor # confirms it is actually recording
---
## Onde se encaixa: IDS vs WAF vs edge
Este pacote é um **IDS passivo de nível de aplicação** — ele observa e registra, não
bloqueia. Ele foi feito para ficar *ao lado* de um WAF ou serviço de edge, não para
substituí-los. Cada camada vê algo que as outras não conseguem:
| | **Este pacote** (IDS de app) | **WAF** (mod_security, Cloudflare WAF) | **Edge / CDN** (Cloudflare) |
|---|:---:|:---:|:---:|
| Bloqueia requisições maliciosas | ❌ apenas registra | ✅ | ✅ |
| Contexto completo do app (rota exata, payload decodificado, usuário autenticado) | ✅ | ⚠️ parcial | ❌ |
| Dashboard integrado + log de ameaças no seu banco de dados | ✅ | ⚠️ varia | ⚠️ apenas no edge |
| Detecções específicas do app (ex.: PII de Aadhaar / PAN / IFSC) | ✅ padrões personalizados | ❌ | ❌ |
| Funciona offline / sem serviço externo | ✅ | ⚠️ depende | ❌ |
| Interrompe o tráfego antes de chegar ao seu app | ❌ | ✅ edge | ✅ |
| Configuração | um `composer require` | médio–alto | baixo–médio |
| Custo | gratuito, MIT | varia | nível gratuito + pago |
**A versão resumida:** um edge/WAF é a sua fechadura na porta; este é a câmera de segurança
*por dentro*, com o contexto do app para dizer exatamente o que está sendo tentado em qual
rota, por quem e com que frequência. Use-o para alimentar decisões reais — bans do
fail2ban, limites de taxa, bloqueio geográfico — com dados que sua camada de edge nunca vê.
### O que ele deliberadamente NÃO é
- **Não é um WAF.** Ele nunca bloqueia, filtra ou modifica uma requisição. Use Cloudflare,
mod_security ou um WAF de verdade para aplicação de regras. (Sem camada de edge para
repassar? Os [helpers do lado do operador](#acting-on-the-data-operator-side-blocking)
expõem as decisões do pacote para que você escreva seu próprio middleware de bloqueio
com cinco linhas — o código de aplicação de regras continua sendo seu, não do pacote.)
- **Não substitui a codificação segura.** Consultas parametrizadas, validação de entrada e
escape de saída são suas defesas reais. Este pacote assume que seu código já é
seguro e oferece *visibilidade*, não proteção.
- **Não é um serviço de edge.** Se você pode colocar o Cloudflare na frente, faça — e
depois adicione este para o detalhe de nível de aplicação que os serviços de edge não
conseguem ver.
### Então, o que você realmente faz com ele?
A pergunta mais comum sobre um detector que nunca bloqueia. Quatro respostas, em
ordem crescente de esforço:
| Você quer | Use | Esforço |
|---|---|---|
| Ver o que está atingindo você | O [dashboard](#dashboard) ou `threat-detection:stats` | nenhum, já está rodando |
| Banir reincidentes no firewall | [`threat-detection:export-fail2ban`](#artisan-commands) — envie para um cron | uma linha |
| Negar no servidor web | [`threat-detection:export-blocklist`](#artisan-commands) → diretivas do nginx/apache | uma linha |
| Recusar requisições no app | [Helpers do lado do operador](#acting-on-the-data-operator-side-blocking) — `isBlocklisted()`, `isDdosThresholdExceeded()` | ~10 linhas do seu próprio middleware |
| Reagir em tempo real | O [evento `ThreatDetected`](#threatdetected-event) — Telegram, SIEM, PagerDuty | um listener |
O pacote fornece a inteligência; você fornece a recusa. Essa divisão é
deliberada — código de aplicação de regras que vive no seu app é código que você pode ler,
testar e desligar, e isso significa que um bug de detecção nunca pode derrubar seu site.
### Como ele se compara a outros pacotes de segurança do Laravel
Eles resolvem problemas diferentes e se compõem bem — a tabela é sobre escolher a
ferramenta certa, não sobre vencer.
| Pacote | O que faz | Bloqueia? | Use quando |
|---|---|:---:|---|
| **este pacote** | Examina cada requisição contra 150+ padrões, registra com contexto completo do app | ❌ | Você quer *ver* o que está sendo tentado no seu app |
| `spatie/laravel-honeypot` | Campo de formulário oculto que captura bots de spam | ✅ apenas formulário | Você tem formulários públicos recebendo spam |
| `graham-campbell/security` | Remove marcação tipo XSS da entrada | ✅ muta | Você quer sanitização ingênua de entrada |
| `spatie/laravel-csp` | Envia cabeçalhos de Content-Security-Policy | ✅ navegador | Você quer restringir o que o navegador carrega |
| `laravel/fortify` + limites de taxa | Limitação de autenticação e bloqueio | ✅ | Você precisa de proteção contra força bruta no login |
| Cloudflare / mod_security | WAF de edge, bloqueia antes do seu app | ✅ | Você quer tráfego interrompido antes de chegar |
O resumo honesto: um honeypot captura spam de formulário, um WAF bloqueia tráfego
conhecidamente ruim no edge e o CSP restringe o navegador. **Nenhum deles diz o que um
atacante tentou contra suas rotas específicas, com o payload decodificado e o
usuário autenticado anexado.** Essa lacuna é o que este preenche — e é por isso que o
pacote deliberadamente não bloqueia: você pode executá-lo junto com todos os itens acima
sem que nenhum deles entre em conflito.
---
## Requisitos
- PHP 8.2+ (Laravel 13 exige PHP 8.3+)
- Laravel 10.x, 11.x, 12.x ou 13.x
- Qualquer banco de dados suportado pelo Laravel (MySQL, PostgreSQL, SQLite, SQL Server)
- Qualquer driver de cache — **nenhum Redis ou worker de fila necessário**. Redis/Memcached é
apenas *recomendado* para habilitar a verificação opcional de DDoS (que se desativa
automaticamente em drivers não atômicos). Gravações em fila são opcionais e desativadas por padrão.
---
## Como Funciona
1. Um middleware examina cada requisição HTTP recebida
2. A requisição é verificada contra 158 padrões de regex que cobrem injeção de SQL, XSS, RCE, travessia de arquivos, SSRF, LDAP, XPath, SSTI e mais
3. Se um padrão de ameaça corresponder, um registro é gravado na sua tabela `threat_logs` do banco de dados com o IP, URL, tipo de ameaça, nível de severidade e uma pontuação de confiança
4. Opcionalmente, um alerta do Slack é enviado para ameaças de alta severidade
5. A requisição prossegue normalmente — **nada é bloqueado**
Nenhuma conexão com a internet é necessária para a detecção.
---
## Início Rápido
### 1. Instale o pacote```bash
composer require jayanta/laravel-threat-detection
Este passo é obrigatório. Sem ele, o pacote detectará ameaças, mas não poderá armazená-las no banco de dados. Se você pular este passo, sua tabela
threat_logsnão existirá e todas as detecções serão silenciosamente perdidas (você só verá erros emstorage/logs/laravel.log).```bash php artisan vendor:publish --tag=threat-detection-migrations php artisan migrate
Isto cria duas tabelas: `threat_logs` (armazena ameaças detetadas) e `threat_exclusion_rules` (armazena regras de falsos positivos).
**Verifique se as tabelas foram criadas:**```bash
php artisan migrate:status
Look for create_threat_logs_table, add_confidence_to_threat_logs_table, e create_threat_exclusion_rules_table - todos devem mostrar Ran.
O middleware é o que analisa os pedidos. Tens de o adicionar ao teu grupo de middleware web.
Se usas Laravel 11 ou 12 - abre bootstrap/app.php:```php
->withMiddleware(function (Middleware $middleware) {
$middleware->web(append: [
\JayAnta\ThreatDetection\Http\Middleware\ThreatDetectionMiddleware::class,
]);
})
> **Como verificar a sua versão do Laravel:** Execute `php artisan --version` no seu terminal.
**Se você usa Laravel 10** - abra `app/Http/Kernel.php`:```php
protected $middlewareGroups = [
'web' => [
// ... existing middleware
\JayAnta\ThreatDetection\Http\Middleware\ThreatDetectionMiddleware::class,
],
];
php artisan vendor:publish --tag=threat-detection-config
O pacote funciona com padrões sensatos. Publicar a configuração permite personalizar padrões de deteção, modos de sensibilidade, notificações do Slack e muito mais. Se omitir este passo, tudo continua a funcionar.
**É só isto.** A sua aplicação está agora a detetar ameaças.
---
## Verificar se Funciona
Após a instalação, acione uma ameaça de teste e confirme que foi registada.
### Passo 1: Inicie a sua aplicação```bash
php artisan serve
Adicione um parâmetro de consulta malicioso a qualquer rota existente na sua aplicação (sua página inicial, uma página de produto, etc.). Por exemplo:
Injeção de SQL:``` http://localhost:8000/?q=' UNION SELECT * FROM users--
**XSS (Cross-Site Scripting):**```
http://localhost:8000/?q=<script>alert(1)</script>
Directory Traversal:``` http://localhost:8000/?file=../../etc/passwd
**RCE (Execução Remota de Código):**```
http://localhost:8000/?cmd=system('ls -la')
Shellshock (CVE-2014-6271):``` http://localhost:8000/?cmd=() { :;}; /bin/bash
**Injeção de Comando no Windows:**```
http://localhost:8000/?cmd=powershell -c whoami
DROP TABLE (DDL de SQL):``` http://localhost:8000/?q=DROP TABLE users
> Use uma rota que realmente exista no seu aplicativo (como `/`). Se a URL retornar um 404, o middleware pode não ter sido executado.
### Etapa 3: Verifique se as ameaças foram registradas
**Opção A - Comando Artisan (mais rápido):**```bash
php artisan threat-detection:stats
You should see a table with Total Threats, severity counts, and top IPs.
Opção B - Tinker:```bash php artisan tinker
```php
DB::table('threat_logs')->latest()->take(5)->get(['ip_address', 'type', 'threat_level', 'confidence_score']);
Opção C - Arquivo de log do Laravel:
Cada ameaça detectada é gravada como um aviso em storage/logs/laravel.log:```
[high] Threat Detected: [middleware] SQL Injection UNION from 127.0.0.1 (http://localhost:8000/?q=...) [confidence: 50%]
### Coisas a saber ao testar
| Comportamento | Explicação |
|----------|-------------|
| A mesma ameaça só é registada uma vez a cada 5 minutos | Deduplicação: o mesmo IP + o mesmo tipo de ameaça é armazenado em cache durante 5 minutos. Use **tipos de ataque diferentes** para cada teste, ou aguarde entre os testes. |
| Os pedidos `curl` acionam deteção extra | Usar `curl` também regista uma deteção de user-agent "cURL Command" (gravidade baixa). Isto é esperado — o pacote deteta ferramentas automatizadas. |
| O pacote nunca bloqueia pedidos | A sua aplicação continua a funcionar normalmente. A deteção é passiva. |
| Não é necessária configuração do Slack | As notificações estão desativadas por predefinição. |
| Não é necessária ligação à internet | A deteção principal é 100% local. Apenas o comando opcional `threat-detection:enrich` chama uma API externa para dados geográficos. |
### Resolução de problemas
**Comece aqui — um único comando responde à maior parte disto:**```bash
php artisan threat-detection:doctor
Verifica as coisas que fazem a deteção falhar silenciosamente — onde o painel permanece vazio, o que parece idêntico a "sem ataques" — e imprime a correção exata para cada uma. Sai com código não-zero numa falha real, por isso é seguro executá-lo em CI ou numa etapa de deploy.``` Threat Detection — health check
PASS Detection is enabled for this environment FAIL 'threat_logs' is missing confidence_label — EVERY threat is being discarded Run: php artisan vendor:publish --tag=threat-detection-migrations && php artisan migrate WARN 1 custom pattern(s) shadow a built-in: Localhost SSRF Your copy runs instead of the maintained one, so later fixes to it never reach you.
O que cobre: deteção ativada para este ambiente; todas as colunas que o
escritor precisa (uma em falta descarta **todas** as ameaças); colunas do
dashboard/API; a tabela de regras de exclusão; se o middleware está realmente
ligado a uma rota ou grupo; configuração publicada que antecede esta versão;
padrões personalizados a sobrepor os incorporados; um driver de cache que não
consegue fazer contagem de DDoS; e um dashboard ou API deixados abertos sem
autenticação.
**"Testei, mas `threat-detection:stats` mostra zero ameaças" / "As ameaças não são armazenadas na base de dados"**
Se o doctor passou, a instalação está correta e o problema é o próprio pedido de
teste. Três coisas que ele não consegue verificar por si:
| Verificação | Como verificar |
|-------|---------------|
| O IP não está na lista de permissões | Se adicionou `THREAT_DETECTION_WHITELISTED_IPS` ao `.env`, remova-o durante os testes |
| Usou uma rota existente | O URL de teste deve corresponder a uma rota real (ex.: `/`). Um 404 significa que o middleware nunca foi executado |
| Cache de deduplicação | O mesmo IP + o mesmo tipo de ataque fica em cache durante 5 minutos - tente um tipo de ataque diferente |
> Executar `php artisan migrate` sozinho nunca é suficiente: os ficheiros de
> migração vivem dentro do pacote e devem ser publicados para a pasta
> `database/migrations/` da sua aplicação primeiro. O doctor imprime o comando
> exato quando este é o problema.
**"A API devolve 401 Unauthorized"**
Consulte [Autenticação da API](#api-authentication) abaixo.
**"O dashboard mostra 404"**
O dashboard está desativado por predefinição. Adicione `THREAT_DETECTION_DASHBOARD=true` ao `.env` e limpe a cache de rotas:```bash
php artisan route:clear
/wp-admin, /.env, /phpmyadmin, /actuator, etc.) com mais de 50 caminhos de sonda padrãoapplication/json) são inspecionadosstrict, balanced (padrão) e relaxed - sensibilidade ajustávelO pacote funciona sem qualquer alteração no .env. Todos os valores abaixo são opcionais - adicione-os apenas se quiser substituir os padrões.```env
THREAT_DETECTION_ENABLED=true
THREAT_DETECTION_MODE=balanced
### Modos de Deteção
| Modo | Limiar de Confiança | Comportamento |
|------|---------------------|----------|
| `strict` | 0 (regista tudo) | Todos os padrões ativos, limiares mais baixos. Captura tudo, mas pode sinalizar tráfego legítimo. |
| `balanced` | 10 | Predefinido. Pontuação de confiança ativa, limiares padrão. Bom para a maioria das aplicações. |
| `relaxed` | 40 | Apenas padrões de alta gravidade acionam. Melhor para sites com muito conteúdo e falsos positivos frequentes. |
### Ambientes Ativados
Por predefinição, a deteção é executada em `production`, `staging` e `local`. Para alterar, publique a configuração e edite:```php
'enabled_environments' => ['production', 'staging', 'local'],
Para desativar a detecção na sua suíte de testes, defina APP_ENV=testing (não está na lista acima) ou adicione ao seu phpunit.xml:```xml
### Referência de Configuração
Publique o arquivo de configuração para ver todas as opções disponíveis:```bash
php artisan vendor:publish --tag=threat-detection-config
Configurações-chave das seções: skip_paths (caminhos a ignorar), only_paths (modo de lista de permissões), auth_paths (detecção inteligente de rotas de login), content_paths (suprimir alertas não críticos), safe_fields (excluir campos específicos da varredura), safe_paths (exclusão de campos ciente de caminho para JSON aninhado), probe_tracking (detecção de sondas 404), context_weights (multiplicadores de pontuação), threat_levels (mapeamento de palavras-chave de gravidade), api_route_filtering (suprimir baixo/médio em rotas de API), queue (processamento assíncrono), retention (purga automática), max_detections_per_request (limite de desempenho), dashboard.guard / api.guard (modo de autenticação).
only_paths)Se o seu aplicativo tiver muitas rotas, mas você só se importa com algumas, use only_paths para escanear apenas essas rotas. Todas as outras rotas são ignoradas automaticamente — sem sobrecarga de middleware.```php
// config/threat-detection.php
'only_paths' => [
'admin/',
'api/',
'login',
'register',
],
Deixe vazio (padrão) para escanear todas as rotas (sujeito a `skip_paths`). Quando ambos estiverem configurados, `only_paths` é verificado primeiro e, em seguida, `skip_paths` é aplicado dentro do conjunto correspondente.
### Suporte a Fila
Por padrão, o registro de ameaças ocorre de forma síncrona no ciclo da requisição. Para aplicativos de alto tráfego, você pode descarregar gravações no banco de dados e notificações do Slack para uma fila:```env
THREAT_DETECTION_QUEUE=true
THREAT_DETECTION_QUEUE_CONNECTION=redis
THREAT_DETECTION_QUEUE_NAME=threat-logs
Isto despacha um job StoreThreatLog (3 tentativas, backoff 10s/30s). A deteção continua a acontecer em tempo real — apenas a escrita é adiada.
Elimina automaticamente os registos de ameaças antigos numa agenda diária:```env THREAT_DETECTION_RETENTION=true THREAT_DETECTION_RETENTION_DAYS=90
Requer que o agendador do Laravel esteja em execução (`php artisan schedule:run`). É executado diariamente às 02:00 via `threat-detection:purge`.
### Evento ThreatDetected
Cada ameaça confirmada despacha um evento `ThreatDetected` ao qual você pode ouvir:```php
// app/Providers/EventServiceProvider.php
use JayAnta\ThreatDetection\Events\ThreatDetected;
protected $listen = [
ThreatDetected::class => [
YourCustomListener::class,
],
];
O evento carrega $threatLog (array completo da linha do banco de dados), $ipAddress e $threatLevel. Use-o para acionar ações personalizadas - enviar alertas do Telegram, atualizar uma lista de bloqueio, alimentar um SIEM, etc.
Quando um cliente ultrapassa o limite de DDoS configurado (ddos.threshold solicitações dentro de
ddos.window segundos), um evento DdosThresholdExceeded é despachado junto com a
entrada do log de ameaça:```php
use JayAnta\ThreatDetection\Events\DdosThresholdExceeded;
protected $listen = [ DdosThresholdExceeded::class => [ YourFloodListener::class, ], ];
O evento carrega `$ipAddress`, `$requestCount`, `$threshold` e `$windowSeconds`. Ele é
limitado a uma vez por IP por janela de deduplicação (mesma limitação da linha de log), para que uma inundação não
sobrecarregue seus listeners. Use-o para alertas ou para alimentar um armazenamento externo de banimentos; para *recusar*
clientes acima do limite, use `ThreatDetection::isDdosThresholdExceeded($ip)` a partir do seu próprio
middleware — veja [Agindo sobre os Dados](#acting-on-the-data-operator-side-blocking).
---
## Notificações do Slack
Os alertas do Slack estão desabilitados por padrão. Para habilitar:```env
THREAT_DETECTION_NOTIFICATIONS=true
THREAT_DETECTION_SLACK_WEBHOOK=https://hooks.slack.com/services/YOUR/WEBHOOK/URL
THREAT_DETECTION_SLACK_CHANNEL=#threat-alerts
Apenas ameaças de alta gravidade acionam notificações por padrão (configurável via notify_levels no config).
Laravel 10: Usa a classe de notificação integrada SlackMessage. Nenhum pacote extra é necessário.
Laravel 11+: O canal Slack integrado foi removido. O pacote detecta isso automaticamente e envia webhooks HTTP POST brutos para a sua URL do Slack. Nenhum pacote extra é necessário. Se preferir o canal de notificação completo, instale:```bash composer require laravel/slack-notification-channel
---
## Dashboard
<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/12500/fc7950bd0cc6323bcc2d62b03e31c99edc7450b0ef76f9cbfa5133b527b25269.png" alt="Painel de Detecção de Ameaças — estatísticas, linha do tempo de 7 dias, registro de ameaças em tempo real, principais IPs ofensores e ameaças por país" width="100%">
</p>
O pacote inclui um painel integrado em modo escuro (Alpine.js + Tailwind CDN — sem necessidade de etapa de build).```
+-------------------------------------------------------------------------+
| Threat Detection Dashboard |
+-------------------------------------------------------------------------+
| Total: 847 | High: 23 | Med: 156 | Low: 668 | IPs: 94 |
+-------------------------------------------------------------------------+
| [Timeline Chart - 7 Day Stacked Bar] |
+-------------------------------------------------------------------------+
| Search: [___________] Level: [All] |
| Time IP Type Level Confidence Actions |
| Mar 2 14:02 185.220.101.4 SQL Injection HIGH 80% [FP] |
| Mar 2 13:58 45.33.32.156 XSS Script Tag HIGH 65% [FP] |
| Mar 2 13:45 192.168.1.10 Scanner: Nikto MED 35% [FP] |
+-------------------------------------------------------------------------+
| Top IPs | Threats by Country |
| 185.220.101.4 [23] | US 234 |
| 45.33.32.156 [18] | CN 156 |
| 103.152.220.1 [12] | RU 98 |
+-------------------------------------------------------------------------+
Adicione ao .env:```env
THREAT_DETECTION_DASHBOARD=true
Visite: `http://your-app.test/threat-detection`
### Acesso durante o desenvolvimento local
O painel usa o middleware `['web', 'auth']` por padrão, portanto os usuários devem estar conectados. Se o seu aplicativo ainda não tiver autenticação, restrinja-o apenas à sua própria máquina:```env
THREAT_DETECTION_DASHBOARD_GUARD=ip
THREAT_DETECTION_DASHBOARD_IPS=127.0.0.1
Todas as opções de guard, e o guard separado nos endpoints que desativam as detecções, são abordados em Dashboard e Autenticação da API.
Se o dashboard mostrar dados vazios, a página carregou, mas suas chamadas de API não. Consulte Autenticação da API.
O pacote fornece 15 endpoints REST para criar dashboards ou integrações personalizadas.
As rotas da API usam o middleware auth:sanctum por padrão. O pacote lida com isso de forma elegante:
['api']. A API funciona sem autenticação.Se você não usa o Sanctum, mas deseja proteger sua API, você tem duas opções:
Opção 1 - Use o guard de autenticação integrado:```env THREAT_DETECTION_API_GUARD=auth
**Opção 2 - Alterar o middleware diretamente:**```php
// config/threat-detection.php
'api' => [
'enabled' => true,
'prefix' => 'api/threat-detection',
'middleware' => ['api', 'auth'], // or 'auth:your-guard'
],
Para testes locais (se o Sanctum bloquear o acesso), altere temporariamente:```php 'middleware' => ['api'], // remove 'auth:sanctum'
> Restaure a autenticação antes de implantar em produção.
### Referência de Endpoints
| Método | Endpoint | Descrição |
|--------|----------|-------------|
| GET | `/api/threat-detection/threats` | Listar ameaças (paginado, filtrável) |
| GET | `/api/threat-detection/threats/{id}` | Detalhes de uma única ameaça |
| POST | `/api/threat-detection/threats/{id}/false-positive` | Marcar ameaça como falso positivo |
| GET | `/api/threat-detection/stats` | Estatísticas gerais |
| GET | `/api/threat-detection/summary` | Detalhamento por tipo, nível, IP |
| GET | `/api/threat-detection/live-count` | Ameaças na última hora |
| GET | `/api/threat-detection/by-country` | Agrupado por país |
| GET | `/api/threat-detection/by-cloud-provider` | Agrupado por provedor de nuvem |
| GET | `/api/threat-detection/top-ips` | Principais IPs infratores |
| GET | `/api/threat-detection/timeline` | Linha do tempo de ameaças (para gráficos) |
| GET | `/api/threat-detection/ip-stats?ip=x.x.x.x` | Estatísticas para IP específico |
| GET | `/api/threat-detection/correlation` | Análise de correlação |
| GET | `/api/threat-detection/export` | Exportar para CSV |
| GET | `/api/threat-detection/exclusion-rules` | Listar regras de exclusão |
| DELETE | `/api/threat-detection/exclusion-rules/{id}` | Excluir uma regra de exclusão |
### Parâmetros de Consulta para `/threats`
| Parâmetro | Descrição |
|-----------|-------------|
| `keyword` | Pesquisar em IP, URL, tipo |
| `ip` | Filtrar por endereço IP |
| `level` | Filtrar por nível de ameaça (`high`, `medium`, `low`) |
| `type` | Filtrar por tipo de ameaça |
| `country` | Filtrar por código de país |
| `is_foreign` | Filtrar IPs estrangeiros (`true`/`false`) |
| `cloud_provider` | Filtrar por provedor de nuvem |
| `is_false_positive` | Filtrar por status de falso positivo (`true`/`false`) |
| `date_from` / `date_to` | Filtro de intervalo de datas |
| `per_page` | Itens por página (padrão: 20, máximo: 100) |
### Exemplo de Resposta da API
**GET `/api/threat-detection/stats`:**```json
{
"success": true,
"data": {
"total_threats": 847,
"high_severity": 23,
"medium_severity": 156,
"low_severity": 668,
"unique_ips": 94,
"foreign_ips": 67,
"cloud_attacks": 12,
"today": 34,
"last_hour": 5
}
}
Vue.js:```javascript async mounted() { const response = await fetch('/api/threat-detection/stats'); this.stats = await response.json();
const threats = await fetch('/api/threat-detection/threats?per_page=20');
this.threats = await threats.json();
}
**React:**```jsx
useEffect(() => {
fetch('/api/threat-detection/stats')
.then(res => res.json())
.then(data => setStats(data));
}, []);
Se a sua API usa
auth:sanctum, inclua cabeçalhos de autenticação ou configure a autenticação SPA do Sanctum para requisições baseadas em cookies.
php artisan threat-detection:doctor
php artisan threat-detection:stats
php artisan threat-detection:enrich --days=7
php artisan threat-detection:purge --days=30
php artisan threat-detection:export-fail2ban --level=high --since=24h --min-hits=5 php artisan threat-detection:export-fail2ban --format=plain > /tmp/banlist.txt
php artisan threat-detection:export-blocklist --format=nginx > /etc/nginx/blocklist.conf php artisan threat-detection:export-blocklist --format=apache > .htaccess-deny php artisan threat-detection:export-blocklist --format=csv --since=7d
---
## Agir sobre os Dados (Bloqueio no Lado do Operador)
O pacote nunca bloqueia uma requisição — essa é a sua identidade, não um padrão. As exportações acima
alimentam camadas de aplicação de regras que você já executa (fail2ban, nginx, um WAF de borda). Mas algumas implantações
não têm essa camada para alimentar — hospedagem compartilhada, PaaS, contêineres atrás de um balanceador de carga que você
não controla. Para essas, o pacote expõe suas *decisões* como auxiliares, e você escreve o
middleware de aplicação de regras você mesmo. Mesma arquitetura das exportações: **nós fornecemos a
inteligência, você fornece a recusa.**```php
// app/Http/Middleware/EnforceThreatDecisions.php
namespace App\Http\Middleware;
use Closure;
use Illuminate\Http\Request;
use JayAnta\ThreatDetection\Facades\ThreatDetection;
class EnforceThreatDecisions
{
public function handle(Request $request, Closure $next)
{
$ip = (string) $request->ip();
// Static operator denylist (config: blocklisted_ips).
// CIDR supported; whitelisted_ips wins on overlap.
if (ThreatDetection::isBlocklisted($ip)) {
abort(403);
}
// Volumetric flood: refuse over-threshold clients until the window resets.
if (ThreatDetection::isDdosThresholdExceeded($ip)) {
return response('Too Many Requests', 429, [
'Retry-After' => (string) config('threat-detection.ddos.window', 60),
]);
}
return $next($request);
}
}
Antes de aplicar a política no IP, configure o
TrustProxies.Tudo acima depende de
$request->ip(). Atrás de um balanceador de carga, CDN ou proxy reverso, isso retorna o IP do cliente somente quando o Laravel é informado sobre quais proxies confiar. Se não for, duas coisas quebram ao mesmo tempo: cada requisição parece vir do proxy, então uma entrada na denylist bloqueia todo o seu tráfego ou nada dele — e pior, se o app confiar em um cabeçalho encaminhado que não deveria, um atacante defineX-Forwarded-Fore atravessa direto a blocklist.Isso importa mais aqui do que para
whitelisted_ips. Uma correspondência errada na whitelist apenas significa que o pacote escaneia uma requisição que poderia ter pulado: ela falha com segurança. Uma denylist usada para recusar tráfego falha aberta — você acredita que um endereço está bloqueado quando não está. Verifiqueapp/Http/Middleware/TrustProxies.php(ou a chamadatrustProxiesembootstrap/app.phpno Laravel 11+) antes de confiar em qualquer um dos helpers para aplicação da política.
Registre-o globalmente (antes do middleware de detecção é aceitável — os helpers leem a configuração e o cache, eles não dependem da ordem dos middlewares):```php // bootstrap/app.php (Laravel 11+) ->withMiddleware(function ($middleware) { $middleware->prepend(\App\Http\Middleware\EnforceThreatDecisions::class); })
Os helpers:
| Helper | Retorna | Baseado em |
|---|---|---|
| `ThreatDetection::isBlocklisted($ip)` | `bool` | config `blocklisted_ips` (CIDR via `IpUtils`; a whitelist vence) |
| `ThreatDetection::isWhitelisted($ip)` | `bool` | config `whitelisted_ips` |
| `ThreatDetection::ddosRequestCount($ip)` | `int` | o contador de flood que o middleware de detecção mantém |
| `ThreatDetection::isDdosThresholdExceeded($ip)` | `bool` | esse contador vs `ddos.threshold` |
Notas:
- **A denylist é estática e mantida pelo operador.** Nada no pacote jamais adiciona a ela —
ela executa a mesma decisão que uma jail do fail2ban tomaria ("li o dashboard; este /24
é hostil"), apenas dentro do aplicativo.
- O contador de DDoS conta apenas requisições que chegaram à detecção (`skip_paths`, IPs
na whitelist e ambientes desabilitados nunca são contados), e permanece em 0 em drivers de cache
onde a detecção de DDoS está desabilitada (`file`, `database`, `null`).
- Quando um cliente ultrapassa o limite, um evento [`DdosThresholdExceeded`](#ddosthresholdexceeded-event)
também é disparado — útil para alertas ou para alimentar uma lista de banimento externa. Não chame `abort()`
a partir do listener, no entanto: os listeners são executados dentro do `try/catch` fail-open
do middleware de detecção, então a recusa pertence ao seu próprio middleware, como acima.
---
## Rastreamento de Sondas 404
O pacote detecta sondas de reconhecimento — bots que acessam caminhos vulneráveis conhecidos como `/wp-admin`, `/.env` ou `/phpmyadmin` no seu site que não é WordPress nem phpMyAdmin. Elas não possuem payload malicioso; o próprio caminho é o sinal.
Registradas com uma tag de tipo `[probe]`, separadas da detecção baseada em payload. Se uma requisição de sonda também contiver um payload malicioso, ambas são registradas de forma independente.
Habilitado por padrão com mais de 50 caminhos de sonda. Personalize em `config/threat-detection.php`:```php
'probe_tracking' => [
'enabled' => true,
'default_level' => 'medium',
'paths' => [
'/wp-admin' => 'WordPress Admin',
'/wp-admin/*' => 'WordPress Admin',
'/.env' => 'Environment File',
'/phpmyadmin' => 'phpMyAdmin',
'/actuator/*' => 'Spring Actuator',
// Add your own probe paths...
],
],
Desative com THREAT_DETECTION_PROBE_TRACKING=false.
Se campos de formulário específicos contêm legitimamente HTML, palavras-chave SQL ou código (por exemplo, editores de CMS, entradas de trechos de código), você pode excluí-los da verificação:```php // config/threat-detection.php 'safe_fields' => ['content', 'body', 'html', 'description', 'code'],
Campos listados aqui são removidos dos parâmetros de consulta e do corpo da requisição — tanto codificados em formulário quanto JSON (`application/json`) — antes da detecção ser executada. Outros campos na mesma requisição ainda são totalmente verificados.
### Caminhos Seguros (conscientes de caminho, para APIs JSON aninhadas)
`safe_fields` corresponde a um nome de chave **em qualquer lugar** onde ele apareça. Para APIs JSON aninhadas, isso geralmente é amplo demais — você pode querer isentar o valor de um campo específico sem isentar essa chave em todos os lugares. Use `safe_paths`, que corresponde por **caminho** em notação de ponto e suporta curingas `fnmatch`:```php
// config/threat-detection.php
'safe_paths' => ['search.query', 'filters.*.value'],
Por exemplo, search.query isenta o valor de {"search": {"query": "..."}} (uma caixa de pesquisa cujo texto contém legitimamente palavras como SELECT), enquanto um campo query em qualquer outro lugar do pedido ainda é analisado. Tudo o que não está listado é analisado exatamente como antes.
Uma regex sozinha não consegue expressar todas as restrições: qualquer sequência de 12 dígitos corresponde ao padrão Aadhaar, mas um número Aadhaar real também passa no checksum Verhoeff. Associe um rótulo de padrão (padrão ou personalizado) a um validador nomeado, e uma correspondência de regex só conta como deteção quando pelo menos um valor correspondente o valida:```php // config/threat-detection.php 'pattern_validators' => [ 'Aadhaar Number Detected' => 'verhoeff', // shipped default ],
Validadores disponíveis:
| Validador | Checksum | Uso típico |
|-----------|----------|-------------|
| `verhoeff` | Verhoeff | Números Aadhaar |
| `luhn` | Luhn | Números de cartões de crédito/débito |
Com o mapeamento incluído, timestamps, IDs de pedidos e códigos de barras que por acaso tenham 12 dígitos deixam de ser registados como PII — enquanto números Aadhaar genuínos continuam a ser. Se vários valores corresponderem e apenas um passar no checksum, a deteção ainda é acionada: um número real entre ruído continua a ser uma fuga.
Combine um validador com o seu próprio padrão para deteção de cartões com validação por checksum:```php
'custom_patterns' => ['/\b(?:\d[ -]?){13,19}\b/' => 'Card Number Detected'],
'pattern_validators' => ['Card Number Detected' => 'luhn'],
Um nome de validador desconhecido falha aberto — a correspondência é contada sem validação e um aviso é registrado uma única vez — portanto, um erro de digitação nunca pode desativar silenciosamente um padrão de detecção. Configs publicadas antes deste recurso simplesmente não possuem a chave e mantêm exatamente seu comportamento atual.
Detectar dados sensíveis costumava significar armazená-los. Um formulário de perfil contendo um número de celular, PAN e conta bancária acionaria três padrões de PII, e cada uma das três linhas gravadas mantinha o corpo inteiro da requisição literalmente — retido por todo o período de retenção, legível por qualquer pessoa com acesso ao dashboard ou ao banco de dados. Um valor em uma query string também caía na coluna url. O detector se tornava uma segunda cópia concentrada exatamente daquilo sobre o qual ele o alerta.
Ativado por padrão desde a v1.7.0. Quando um padrão cujo rótulo está listado é acionado, o valor que ele correspondeu é mascarado no payload e na URL armazenados:``` BODY: {"name":"Jane Doe","mobile":"[REDACTED]","pan":"[REDACTED]","bank_account":"[REDACTED]"}
O alerta, o endpoint, os nomes dos campos e o IP atacante permanecem — apenas o valor é removido. A redação ocorre *após* a detecção, para que nada seja perdido.```php
// config/threat-detection.php
'redact' => [
'enabled' => env('THREAT_DETECTION_REDACT', true),
'mask' => '[REDACTED]',
'labels' => ['Aadhaar Number Detected', 'PAN Number Detected', /* ... */],
],
Os payloads de ataque são deliberadamente deixados intactos — uma string de injeção é evidência, não um segredo, e mascarar isso destruiria a investigação. Apenas os rótulos que você listar são alterados.
Isso não substitui os Campos Seguros. Eles impedem que um campo seja escaneado; a redação permite que você continue escaneando e pare de armazenar. Defina
THREAT_DETECTION_REDACT=falsese precisar de payloads completos para perícia forense.
O dashboard e a API suportam guards de autenticação configuráveis via .env:```env
THREAT_DETECTION_DASHBOARD_GUARD=auth
THREAT_DETECTION_DASHBOARD_GUARD=role THREAT_DETECTION_DASHBOARD_ROLE=admin
THREAT_DETECTION_DASHBOARD_GUARD=ip THREAT_DETECTION_DASHBOARD_IPS=127.0.0.1,10.0.0.0/8
As mesmas opções estão disponíveis para rotas de API com `THREAT_DETECTION_API_GUARD`.
Quando `guard=none` (padrão), o pacote registra um aviso uma vez por dia para lembrá-lo de configurar a autenticação.
O guard **falha de forma segura**: um valor de guard não reconhecido (por exemplo, um erro de digitação) é negado com um 403 e um aviso registrado, em vez de conceder acesso silenciosamente, e `guard=role` nega (com um aviso) quando o modelo de usuário autenticado não possui um método `hasRole()`.
### Desativar uma detecção exige mais do que acesso de leitura
Marcar uma ameaça como falso positivo e excluir uma regra de exclusão silenciam um tipo de detecção para todos, o que é um privilégio diferente de ler o log. Esses dois endpoints são verificados contra um guard separado:```env
# Options: none, auth, role, ip. Default: role
THREAT_DETECTION_API_WRITE_GUARD=role
Aplica-se apenas a essas rotas, portanto a leitura e o painel comportam-se exatamente como THREAT_DETECTION_API_GUARD indica. Sem isso, qualquer utilizador autenticado da sua aplicação poderia desativar uma deteção.
Se o seu modelo de utilizador não tiver hasRole(), use =auth. Para restaurar o comportamento anterior à versão 1.7.0, em que qualquer utilizador autenticado podia desativar deteções, use =none - o threat-detection:doctor emitirá um aviso enquanto essa opção estiver definida.
Nota sobre painel ↔ API: o painel integrado obtém os seus dados das rotas da API usando o cookie de sessão do navegador. Se as suas rotas da API estiverem protegidas com
auth:sanctum, configure a autenticação stateful/SPA do Sanctum (ou aponte o painel para um guard autenticado por cookie) para que essas chamadas AJAX sejam autorizadas - caso contrário, o painel é renderizado vazio.
Adicione os seus próprios padrões de regex de deteção em config/threat-detection.php:```php
'custom_patterns' => [
'/your-regex-here/i' => 'Your Threat Label',
],
**Exemplo - detetar uma sonda de endpoint de administração personalizada:**```php
'/\/my-admin-panel/i' => 'Custom Admin Panel Probe',
Além do formato clássico de string, o valor de um padrão pode ser um array para controle total:```php 'custom_patterns' => [ '/\b(?:\d[ -]?){13,19}\b/' => [ 'label' => 'Card Number Detected', // required 'level' => 'high', // low|medium|high — overrides keyword derivation 'contexts' => ['query', 'body'], // query|body|headers — default: all segments 'validator' => 'luhn', // post-match checksum, wins over pattern_validators ], ],
- **`level`** define o nível de ameaça diretamente, em vez de derivá-lo das palavras-chave de `threat_levels` no rótulo.
- **`contexts`** restringe a varredura a segmentos específicos da solicitação — por exemplo, um padrão de cartão que só faz sentido no corpo para de corresponder a sequências de dígitos nos cabeçalhos.
- **`validator`** nomeia uma verificação pós-correspondência inline (veja [Validadores Pós-Correspondência](#post-match-validators-checksum-aware-false-positive-reduction)); ele tem precedência sobre o mapa de rótulos `pattern_validators`.
Entradas de string e array se misturam livremente na mesma configuração. Opções malformadas **falham abertamente** — o padrão ainda varre, sem restrições, e um aviso é registrado — então um erro de configuração nunca pode desativar ou restringir silenciosamente uma detecção.
> **Nota:** Caminhos de sondagem comuns como `/wp-login.php`, `/.env`, `/phpmyadmin` agora são tratados automaticamente pelo recurso de [Rastreamento de Sondagem 404](#404-probe-tracking). Você não precisa de padrões personalizados para eles.
O nível de ameaça para cada padrão é determinado automaticamente pela correspondência de palavras-chave no rótulo com a configuração `threat_levels`:```php
'threat_levels' => [
'high' => ['XSS', 'SQL Injection', 'SQL DDL', 'SQL DML', 'SQL File', 'SQL Hex', 'RCE', ..., 'Shellshock', 'Spring4Shell', 'PowerShell', 'CRLF', 'Null Byte', 'SSTI', 'Java', 'LDAP', 'XPath', 'PHP assert', ...],
'medium' => ['Directory Traversal', 'LFI', 'SSRF', 'Sensitive', 'Config', ..., 'Open Redirect', 'LF Injection', 'GraphQL', 'Spring Boot Actuator', ...],
'low' => ['User-Agent', 'JS Redirect', 'SEO Bot', 'Empty', 'Rate', 'Command-line Downloader', 'DNS Rebinding'],
],
Se o rótulo não corresponder a nenhuma palavra-chave, a ameaça assume por padrão a severidade low.
Padrões de regex inválidos são ignorados automaticamente e registrados como avisos — eles não derrubarão sua aplicação.
Para acesso programático aos dados de ameaças fora do middleware:```php use JayAnta\ThreatDetection\Facades\ThreatDetection;
// Get attack statistics for a specific IP $stats = ThreatDetection::getIpStatistics('192.168.1.1');
// Detect coordinated attacks (multiple IPs targeting same URL within 15 minutes) $attacks = ThreatDetection::detectCoordinatedAttacks(15, 3);
// Detect attack campaigns (same threat type from 5+ IPs in last 24 hours) $campaigns = ThreatDetection::detectAttackCampaigns(24);
// Get a summary of all correlation data $summary = ThreatDetection::getCorrelationSummary();
// Operator-side decision helpers (see "Acting on the Data") $blocked = ThreatDetection::isBlocklisted('203.0.113.7'); // static denylist, CIDR, whitelist wins $trusted = ThreatDetection::isWhitelisted('10.0.0.5'); $count = ThreatDetection::ddosRequestCount('203.0.113.7'); // requests in the current DDoS window $flooded = ThreatDetection::isDdosThresholdExceeded('203.0.113.7');
---
## Ir para Produção
O pacote é passivo por design — ele nunca bloqueia, rejeita ou altera uma requisição, e o middleware de detecção envolve todo o seu corpo em `try/catch`, então uma falha de detecção nunca pode quebrar sua aplicação. Ele vem com padrões sensatos e não precisa de serviços externos para funcionar. Antes de entrar em produção, vale a pena conferir esta pequena lista de verificação:
1. **Proteja o dashboard e a API.** Ambos usam `guard = none` por padrão para uma primeira execução sem configuração, e registram um aviso diário enquanto estiverem desprotegidos. Antes da produção, defina um guard — `THREAT_DETECTION_DASHBOARD_GUARD` e `THREAT_DETECTION_API_GUARD` (`auth`, `role` ou `ip`). Um valor não reconhecido ou um guard `role` em um modelo de usuário sem `hasRole()` agora **falha de forma segura** (403), então um erro de digitação não exporá dados silenciosamente. Desabilitar uma detecção é controlado separadamente por `THREAT_DETECTION_API_WRITE_GUARD`, que usa `role` por padrão. Veja [Autenticação do Dashboard e da API](#dashboard-and-api-authentication).
2. **Execute as migrações** (`vendor:publish --tag=threat-detection-migrations && migrate`). Republicar é seguro — migrações já publicadas são ignoradas.
3. **Escolha um modo de detecção.** `balanced` (padrão) atende à maioria dos aplicativos; use `relaxed` para sites com muito conteúdo, `strict` para superfícies de alta segurança. Ajuste com `content_paths`, `safe_fields` e `min_confidence` — veja [Reduzindo Falsos Positivos](#reducing-false-positives).
4. **Revise os padrões regionais de PII / personalizados.** Os padrões padrão são focados na Índia (Aadhaar, PAN, IFSC) e os padrões numéricos amplos (ex.: conta bancária) podem corresponder a IDs numéricos longos fora das rotas de autenticação. Substitua ou ajuste `custom_patterns` para sua região e aplicativo, e adicione rotas com muito conteúdo a `auth_paths` / `content_paths`.
5. **Ative a retenção** se você espera volume: `THREAT_DETECTION_RETENTION=true` (purga automática via agendador). Requer que o agendador do Laravel (`schedule:run`) seja acionado por cron.
6. **Extras opcionais, todos desativados por padrão:** alertas do Slack (`THREAT_DETECTION_NOTIFICATIONS`), enriquecimento geográfico (`php artisan threat-detection:enrich` — o único recurso que faz uma chamada externa, para o gratuito ip-api.com), e gravações em fila (`THREAT_DETECTION_QUEUE` — ative apenas se você já executa um worker de fila; caso contrário, as gravações são síncronas e não precisam de Redis).
Nenhum Redis, nenhum worker de fila e nenhuma chamada de rede externa são necessários para detecção e registro principais.
---
## Reduzindo Falsos Positivos
O pacote fornece várias ferramentas para reduzir falsos positivos. Use a que se adequar à sua situação:
### Campos Seguros e Caminhos Seguros
Exclua um campo da varredura completamente, seja por nome em todos os lugares (`safe_fields`) ou por caminho em notação de ponto para JSON aninhado (`safe_paths`). A abordagem mais simples e a mais direta — o campo é ignorado, então nenhuma detecção é executada nele.
Detalhes completos e exemplos: [Campos Seguros](#safe-fields-false-positive-reduction).
### Supressão de Caminhos de Conteúdo
Se você tem editores de CMS, formulários de postagens de blog ou seções de comentários onde os usuários enviam conteúdo rico, esses caminhos frequentemente disparam falsos positivos (ex.: uma postagem de blog contendo exemplos de código `<script>`). Adicione esses caminhos para suprimir alertas baixos/médios:```php
// config/threat-detection.php
'content_paths' => [
'admin/posts/*',
'admin/pages/*',
'blog/*/edit',
'comments',
],
Nestes caminhos, apenas ameaças de alta gravidade são registradas.
Clique no botão FP em qualquer ameaça no painel para marcá-la como falso positivo. Isso:
is_false_positive = trueGerencie regras de exclusão via API:```bash GET /api/threat-detection/exclusion-rules DELETE /api/threat-detection/exclusion-rules/{id}
### Pontuação de Confiança
Cada ameaça recebe uma pontuação de confiança (0-100) com base em:
- Número de correspondências de padrões na mesma solicitação
- Gravidade do padrão correspondido
- Onde o padrão foi encontrado (string de consulta > cabeçalhos > corpo)
- Se o user-agent corresponde a uma ferramenta de ataque conhecida
- Modo de detecção atual
Ameaças abaixo do limite de confiança para o seu modo de detecção não são registradas (consulte [Modos de Detecção](#detection-modes)).
---
## Tipos de Ataque Detectados
| Categoria | Exemplos |
|----------|---------|
| **Injeção de SQL** | UNION, booleano, baseado em tempo, codificação CHAR, DDL (DROP/ALTER/CREATE), DML (INSERT/UPDATE/DELETE), operações de arquivo (INTO OUTFILE, LOAD_FILE), enumeração ORDER BY, strings hex, UNHEX |
| **Injeção de NoSQL** | Operadores MongoDB $ne, $gt, $regex, $where |
| **XSS** | Tags de script, manipuladores de eventos SVG (`<svg onload=`), manipuladores de eventos HTML (`<body onload=`, `<img onerror=`), expressões CSS, URIs JavaScript, manipulação de DOM |
| **Execução de Código** | Funções de shell RCE, desserialização PHP, desserialização Java (bytes mágicos base64 + hex), injeção de template (Blade, JSP, ASP, Jinja2, Velocity), eval(), decodificação base64, assert() do PHP, create_function(), preg_replace /e |
| **SSTI** | Sondas matemáticas (`{{7*7}}`), import/config Jinja2, templates Velocity, Expression Language |
| **Injeção de Comandos** | Linux (funções de shell, cadeias de comandos, curl, wget, nc), Windows (cmd.exe, PowerShell, wscript, cscript, net user) |
| **Acesso a Arquivos** | Directory traversal, protocolos LFI/RFI, sondas de arquivos sensíveis (.env, .git, composer.json) |
| **SSRF** | Localhost (127.0.0.1, 0.0.0.0, ::1), metadados AWS/GCP, IPs privados, localhost codificado em hex/decimal, DNS rebinding (xip.io, nip.io, sslip.io) |
| **Injeção de LDAP** | Manipulação de filtros LDAP, injeção OR |
| **Injeção de XPath** | Seletores de atributos, funções XPath (contains, substring) |
| **CRLF / Injeção de Cabeçalhos** | CRLF codificado em URL (`%0d%0a`), injeção LF, injeção de byte nulo |
| **Ataques de Protocolo** | HTTP request smuggling (CL+TE), injeção SSI |
| **Explorações de CVEs** | Shellshock (CVE-2014-6271), Spring4Shell (CVE-2022-22965), RCE PHPUnit (CVE-2017-9841), Drupalgeddon, Log4Shell |
| **Rastreamento de Sondas** | WordPress (`/wp-admin`, `/wp-login.php`), arquivos de configuração (`/.env`, `/.git`), ferramentas de banco de dados (`/phpmyadmin`), sondas de tecnologia (`.asp`, `.jsp`), Spring actuator, Swagger/documentação de API - mais de 50 caminhos |
| **Scanners** | SQLMap, Nikto, Nmap, Burp Suite, FeroxBuster, FFUF, XSStrike, Dalfox, Netsparker, Qualys, Nuclei e mais de 20 outros (53 no total) |
| **Raspadores de IA** | GPTBot, ClaudeBot, ChatGPT, ByteSpider, Cohere, Common Crawl |
| **Navegadores Headless** | HeadlessChrome, PhantomJS, Selenium, Puppeteer, Playwright |
| **Bots** | Scripts Python, clientes HTTP Go, cURL, wget, AhrefsBot, SEMRushBot, user agents vazios |
| **Autenticação** | Detecção de força bruta, vazamentos de tokens, exposição de senhas, exposição de IDs de sessão |
| **DDoS** | Detecção de solicitações excessivas baseada em taxa |
| **Evasão** | Inserção de comentários SQL, codificação dupla de URL, codificação de entidades HTML, escapes Unicode, IIS Unicode, escapes hex |
| **Outros** | Introspecção GraphQL, prototype pollution, open redirect, XXE, web shells, mineração de criptomoedas, detecção de PII |
---
## Executando o Conjunto de Testes```bash
composer test
O pacote inclui 335 testes (856 asserções) cobrindo padrões de detecção, comportamento de middleware, endpoints de API, pontuação de confiança, regras de exclusão, detecção de DDoS, resistência a evasão, padrões de CVE, injeção LDAP/XPath/SSTI, detecção de bots/scanners, rastreamento de sondas, comandos de exportação, autenticação do dashboard, campos seguros, otimizações de desempenho e verificação completa de HTTP para banco de dados.
Licença MIT. Consulte LICENSE para obter detalhes.
Contribuições são bem-vindas! Envie um Pull Request.