sech0us3/waf-checkerStrumento automatizzato di valutazione WAF che rileva i vendor di firewall, testa 19 categorie di attacco con payload di evasione avanzati e fornisce un'analisi di bypass con codice colore tramite CLI, Cloudflare Worker o Docker.
# WAF Checker
[](https://github.com/SecH0us3/waf-checker/releases)
[](https://github.com/SecH0us3/waf-checker/releases)
[](packages/core)
[](packages/cli)
[]()
Questo progetto ti aiuta a verificare quanto bene il tuo Web Application Firewall (WAF) protegge il tuo prodotto contro i comuni attacchi web. Può essere eseguito come Cloudflare Worker (con una Web UI interattiva integrata) oppure come strumento CLI standalone per Node.js.
## 🧪 Copertura dei Test e Stato
Tutti i pacchetti sono testati approfonditamente con suite automatizzate di unit test, integration test, property-based testing (fuzzing con fast-check), resilienza di rete e reverse engineering (100% di conformità alla sicurezza SSRF, tecniche di evasione dei protocolli e formattatori di report):
| Pacchetto | Copertura delle righe | Istruzioni | Funzioni | Suite di test |
| :--- | :---: | :---: | :---: | :---: |
| [**`@waf-checker/core`**](https://github.com/sech0us3/waf-checker/blob/main/packages/core) | `93.0%` 🟢 | `92.6%` | `96.4%` | 🟢 282 superati |
| [**`@waf-checker/cli`**](https://github.com/sech0us3/waf-checker/blob/main/packages/cli) | `93.5%` 🟢 | `92.8%` | `96.7%` | 🟢 54 superati |
| [**`@waf-checker/worker`**](https://github.com/sech0us3/waf-checker/blob/main/packages/worker) | `Superato` 🟢 | — | — | 🟢 30 superati |
| **Suite totale del monorepo** | **`93.2%`** | **`92.7%`** | **`96.6%`** | **🟢 366 test superati** |
## Funzionalità
### Test Principali
- Inserisci un URL di destinazione, seleziona i metodi HTTP (GET, POST, ecc.) e le categorie di attacco.
- Invia richieste con payload di attacco (nei parametri, negli header o come percorsi di file).
- Risultati a colori nel terminale e nel web: 🟢 403/BLOCCATO = bloccato, 🔴 2xx/5xx = potenziale bypass, 🟠 3xx = reindirizzamento.
- Risultati visualizzati in una tabella filtrabile con dettagli per ciascun payload.
### 🕵️ Reverse Engineering del WAF e Matrice CRS (`--reverse`)
- **Mappatura dell'OWASP Core Rule Set (CRS v3/v4)**: Verifica gli ID delle regole attive rispetto a quelle disabilitate (`920xxx`, `921xxx`, `930xxx`, `931xxx`, `932xxx`, `933xxx`, `934xxx`, `941xxx`, `942xxx`, `943xxx`, `944xxx`) con i Paranoia Levels (PL1-PL4).
- **Rilevamento del Limite del Corpo Ispezionato**: Sondaggio tramite ricerca binaria (8KB – 128KB, precisione ~1KB) per identificare i confini di troncamento del buffer.
- **Rilevamento della Modalità di Anomaly Scoring**: Verifica la modalità di scoring collaborativo rispetto alla modalità di blocco rigoroso tramite regex e identifica le soglie di punteggio.
- **Sondaggio Sicuro del Rate Limit**: Ramp-up sicuro fino a 30 req/s con terminazione anticipata immediata al ricevimento di HTTP 429 ed estrazione dell'header `Retry-After`.
### 🛡️ WAF Virtual Patching e Auto-Remediation (`--patch` / comando `patch`)
- **Mitigazione Istantanea**: Trasforma automaticamente i bypass WAF rilevati (HTTP 200) in regole firewall pronte per il deployment, configurazioni di reverse proxy e Infrastructure-as-Code (Terraform HCL / Cloud CLI).
- **Piattaforme Supportate (11 Dialetti)**:
- **Cloudflare WAF**: Espressioni Wirefilter (`http.request.uri.query contains ...` / `matches ...`) e Terraform HCL `cloudflare_ruleset`.
- **AWS WAF v2**: JSON Rule Statements nativi (`ByteMatchStatement`, `RegexPatternSet`, `OrStatement`) e Terraform HCL `aws_wafv2_rule_group`.
- **Google Cloud Armor**: Espressioni CEL (`request.path.matches(...)`, `request.headers[...]`), comandi CLI `gcloud compute security-policies` e Terraform `google_compute_security_policy`.
- **Azure WAF (Front Door e App Gateway)**: Definizioni JSON di Custom Rule, comandi CLI `az network front-door waf-policy` e Terraform `azurerm_cdn_frontdoor_firewall_policy`.
- **ModSecurity e OWASP Coraza**: Direttive `SecRule` compatibili con OWASP CRS (SecLang) con token collapsing `@pm`. Supportato tramite `--patch modsecurity` o `--patch coraza`.
- **NGINX**: Blocchi di configurazione nativi `location ~* \.(ext)$ { return 403; }`, `location ~ /\.(git|svn)` e `map`.
- **HAProxy**: ACL native ad alte prestazioni (`path_end -i`, `path_beg -i`, `query -m sub -i`, `req.hdr()`) con `http-request deny deny_status 403`.
- **Caddy Server**: Matcher denominati idiomatici di Caddyfile (`@waf_patch_*`) con espressioni CEL (`expression {http.request.uri.query}.matches(...)`) e `respond 403`.
- **Apache HTTP Server**: Regole `mod_rewrite` (`RewriteCond %{QUERY_STRING}` / `%{REQUEST_URI}` / `%{HTTP_USER_AGENT}` + `RewriteRule ^ - [F,L]`) per `httpd.conf`, `<VirtualHost>` o `.htaccess`. Supportato tramite `--patch apache`.
- **Envoy Proxy**: Voci di route che corrispondono a `:path`/header tramite RE2 `safe_regex` con `direct_response: 403` (o forward-and-tag in modalità simulate) per un virtual_host di route_configuration. Supportato tramite `--patch envoy`.
- **Kubernetes Ingress (K8s)**: Manifest YAML `kind: Ingress` pronti per la produzione con annotazioni `nginx.ingress.kubernetes.io/server-snippet`.
- **Difesa a Due Livelli**:
- **Hotfix Rigoroso**: Firme esatte dei token con **0% di rischio di falsi positivi** per una risposta immediata agli incidenti zero-day.
- **Pattern Euristico**: Espressioni regolari generalizzate che coprono l'intera struttura della classe di vulnerabilità.
- **Web UI Remediation Studio**: Modale interattiva della dashboard con anteprime live per tutti i vendor, copia negli appunti con 1 clic, toggle di formato ed esportazione su file.
### Categorie di Attacco (28 totali)
SQL Injection, XSS, Command Injection, Path Traversal, SSRF, Local File Inclusion, File Sensibili, Open Redirect, SSTI, XXE, NoSQL Injection, GraphQL Injection, JWT Attack (Header), JWT Attack (Param), Prototype Pollution (JSON Body), Prototype Pollution (URL/Param), LDAP Injection, XPath Injection, Spreadsheet Formula Injection, Log4Shell (JNDI), CRLF Injection, HTTP Parameter Pollution, User-Agent, IP Bypass, HTTP Request Smuggling, Web Cache Poisoning, UTF8/Unicode Bypass, WAF Inspection Limit Bypass (Padding).
### Rilevamento WAF
- Rilevamento automatico del tipo di WAF prima del test (Cloudflare, AWS WAF, OWASP Coraza, BunkerWeb, ModSecurity, Akamai, Imperva, F5 BIG-IP, ecc.).
- Suggerisce tecniche di bypass specifiche in base al WAF rilevato.
- Può passare automaticamente a payload avanzati specifici per il WAF.
### Payload Avanzati e Codifica
- Payload di Bypass WAF — doppia codifica, unicode, maiuscole/minuscole miste, comment injection, payload poliglotti.
- Payload Migliorati — tecniche di evasione moderne.
- Variazioni di Codifica — codifica URL, Unicode, HTML Entity, Hex, Ottale, Base64 con combinazioni automatiche.
- Bypass specifici per WAF per Cloudflare, AWS WAF, ModSecurity.
### Manipolazione del protocollo HTTP
- HTTP Verb Tampering — testa metodi HTTP non comuni.
- Parameter Pollution — duplica e suddivide i parametri tra query/body.
- Content-Type Confusion — utilizza content type alternativi per aggirare le regole.
- Header di Request Smuggling.
- Varianti di Host Header Injection.
- HTTP Method Override tramite header (`X-HTTP-Method-Override`, ecc.).
### Test in batch
- Testa più URL contemporaneamente.
- Concorrenza e ritardo tra le richieste configurabili.
- Monitoraggio del progresso in tempo reale.
### 🔀 Diff di regressione (`--compare` / `--fail-on-regression`)
- Confronta una scansione con un report JSON salvato in precedenza per evidenziare **nuovi bypass** (precedentemente bloccati, ora non più), payload **nuovamente bloccati** e test aggiunti/rimossi.
- Gate CI (`--fail-on-regression`) che fallisce solo in caso di *peggioramento* della postura del WAF, non sull'intero elenco dei risultati — ideale per rilevare la deriva dei managed-ruleset.
---
## Struttura del progetto
Il progetto è strutturato come monorepo NPM Workspaces:
- [**`packages/core/`**](file:///Users/alex/src/waf-checker/packages/core): La libreria core per i test di sicurezza, la definizione dei payload, le firme di fingerprinting del WAF e gli encoder di offuscamento.
- [**`packages/worker/`**](file:///Users/alex/src/waf-checker/packages/worker): Pacchetto Cloudflare Worker che serve la Web UI statica HTML/JS e gli endpoint API JSON.
- [**`packages/cli/`**](file:///Users/alex/src/waf-checker/packages/cli): Strumento da interfaccia a riga di comando Node.js per eseguire audit direttamente dal terminale.
---
## Installazione e build
Dalla directory root, installa le dipendenze e compila tutti i workspace:
```bash
npm install
npm run build
```
## Come eseguirlo
### 1. Versione Web (Cloudflare Worker)
Per avviare il server di sviluppo del Worker in locale (richiede Wrangler):
```bash
npm run dev:worker
```
La Web UI sarà accessibile all'indirizzo `http://localhost:8787` (o su un'altra porta se la 8787 è occupata).
Per distribuire il Worker su Cloudflare:
```bash
npx wrangler deploy --workspace=packages/worker
```
Il Worker richiede il piano **Workers Paid**: le pagine di scansione e audit sono dimensionate per le sue 10.000 subrequest per richiesta (`[limits] subrequests` in `wrangler.toml`, `WORKER_SUBREQUEST_LIMIT` in `packages/core/src/check.ts`). Il piano Free consente solo 50 subrequest esterne per richiesta: una pagina di scansione con il test di bypass dello User-Agent (attivo per impostazione predefinita nell'interfaccia utente) o con i redirect seguiti supera tale limite.
### 2. Versione CLI (Node.js)
#### Installarlo come comando globale `waf-checker` (consigliato)
Dopo `npm install && npm run build` nella radice del repository, collegare la CLI in modo che venga eseguita
da **qualsiasi directory** — senza `cd` nel repository e senza lunghi percorsi `node .../dist`:
```bash
# Expose `waf-checker` on your PATH from the built workspace
npm link --workspace @waf-checker/cli
# …now, from anywhere:
waf-checker --help
waf-checker check https://example.com
# Uninstall later with:
npm rm -g @waf-checker/cli
```
Il pacchetto pubblicato include il proprio codice, quindi puoi anche installare una build pacchettizzata
globalmente senza il repository: `npm pack --workspace @waf-checker/cli` poi
`npm i -g ./waf-checker-cli-*.tgz`.
#### Completamento shell (bash / zsh / fish)
`waf-checker completion <shell>` stampa uno script di completamento (ometti `<shell>` per
rilevarlo automaticamente da `$SHELL`):
```bash
# bash
waf-checker completion bash | sudo tee /etc/bash_completion.d/waf-checker
# or, without root: echo 'source <(waf-checker completion bash)' >> ~/.bashrc
# zsh (into a directory on your $fpath)
waf-checker completion zsh > "${fpath[1]}/_waf-checker"
# fish
waf-checker completion fish > ~/.config/fish/completions/waf-checker.fish
```
#### Esecuzione senza installazione globale
È sempre possibile invocare direttamente il punto di ingresso compilato:
```bash
# Print general CLI help and usage
node packages/cli/dist/index.js --help
# Print check command help (lists all methods, categories, and WAF vendors)
node packages/cli/dist/index.js check --help
# Discover detectable WAF vendors and payload categories (JSON for automation)
node packages/cli/dist/index.js list-wafs --json
node packages/cli/dist/index.js list-categories --json
```
#### Rilevamento WAF
Rileva il fornitore del WAF dietro un URL di destinazione:
```bash
node packages/cli/dist/index.js detect <url>
```
#### Verifica del payload delle vulnerabilità
Esegui una verifica contro un URL di destinazione:
```bash
# Default check (GET method, all payload categories)
node packages/cli/dist/index.js check https://example.com
# Custom check with specific methods, categories, and WAF evasion enabled
node packages/cli/dist/index.js check https://example.com -m GET,POST -c "SQL Injection,XSS" --auto-detect-waf --encoding-variations
```
#### Audit in batch
Esegui audit in batch per un elenco di URL definiti in un file:
```bash
node packages/cli/dist/index.js batch targets.txt --concurrency 3
```
#### Generazione dei report
Salva i risultati dell'audit in formato **SARIF**, **JUnit XML**, **HTML**, **Markdown**, **CSV** o **JSON**:
```bash
# Generate SARIF report for GitHub Code Scanning
node packages/cli/dist/index.js check https://example.com -o results.sarif
# Generate JUnit XML for CI test reporting (GitHub Actions, GitLab CI, Jenkins)
node packages/cli/dist/index.js check https://example.com -o results.xml
# Generate interactive HTML report
node packages/cli/dist/index.js check https://example.com -o report.html
# Generate Markdown summary for CI
node packages/cli/dist/index.js check https://example.com -o summary.md
```
> Il formato del report viene dedotto dall'estensione del file di output, oppure impostato esplicitamente con `-f, --format` (`json`, `csv`, `html`, `sarif`, `markdown`, `junit`). Ogni payload di attacco diventa un `<testcase>` JUnit; i bypass del WAF vengono segnalati come `failure` e gli errori di trasporto/server come `error`, così i runner CI li evidenziano direttamente.
#### Integrazione CI/CD e soglie di protezione
Fai fallire le pipeline CI/CD quando il tasso di protezione è inferiore alla soglia richiesta o quando vengono rilevati bypass:
```bash
# Fail if WAF protection rate is below 95%
node packages/cli/dist/index.js check https://example.com --threshold 95 -q
# Fail immediately on any detected bypass
node packages/cli/dist/index.js check https://example.com --fail-on-bypass -q
```
#### 🔀 Regression Diffing (Scan vs Scan)
La postura del WAF cambia con il tempo — un fornitore rilascia un aggiornamento del ruleset gestito, una regola CRS viene disabilitata, una modifica all'origine altera un verdetto. Invece di riesaminare l'intero elenco dei risultati a ogni esecuzione, confronta con un report JSON salvato in precedenza e vincola la CI solo sul *peggioramento*. Un payload che era `blocked` nel report di riferimento e non è più bloccato conta come regressione; un payload bloccato di recente conta come miglioramento. La corrispondenza avviene tramite `(category, method, evasion technique, payload)`, e gli errori di rete / i blocchi lato origine sono trattati come inconcludenti, così non compaiono mai come falsi positivi di regressione.
```bash
# Save a known-good baseline report
node packages/cli/dist/index.js check https://example.com -f json -o baseline.json -q
# Later: diff the current scan against it and print regressions/improvements
node packages/cli/dist/index.js check https://example.com --compare baseline.json -q
# Fail CI only when a previously-blocked payload is no longer blocked
node packages/cli/dist/index.js check https://example.com --compare baseline.json --fail-on-regression -q
```
#### 🛡️ Virtual Patching e Auto-Remediation
Genera automaticamente regole firewall pronte per il deployment su tutte le 11 piattaforme supportate (`cloudflare`, `aws`, `gcp`, `azure`, `modsecurity`, `nginx`, `haproxy`, `caddy`, `apache`, `envoy`, `k8s`, o `all`):
```bash
# Generate and save Cloudflare Terraform rules during audit
node packages/cli/dist/index.js check https://example.com --patch cloudflare --patch-output ./cloudflare-patch.tf
# Generate GCP Cloud Armor gcloud commands and Terraform
node packages/cli/dist/index.js check https://example.com --patch gcp --patch-output ./cloud-armor.sh
# Generate Azure WAF rules with simulation (Log) mode
node packages/cli/dist/index.js check https://example.com --patch azure --patch-action simulate --patch-output ./azure-rules.json
# Generate HAProxy ACLs for haproxy.cfg
node packages/cli/dist/index.js check https://example.com --patch haproxy --patch-output ./haproxy-patches.cfg
# Generate Caddyfile named matchers
node packages/cli/dist/index.js check https://example.com --patch caddy --patch-output ./patches.caddyfile
# Generate Apache mod_rewrite rules for .htaccess
node packages/cli/dist/index.js check https://example.com --patch apache --patch-output ./patches.htaccess
# Generate Kubernetes Ingress YAML manifests
node packages/cli/dist/index.js check https://example.com --patch k8s --patch-output ./ingress-patch.yaml
# Generate patches for all vendors from a saved JSON audit report file
node packages/cli/dist/index.js patch audit-report.json --waf all --output ./patches/
```
#### 🐳 Test dell'ambiente locale Docker e di staging (`--allow-local`)
Per impostazione predefinita, `waf-checker` blocca rigorosamente gli intervalli di IP privati (`127.0.0.1`, `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) per prevenire la Server-Side Request Forgery (SSRF). Quando si testano i propri container Docker locali o i server di staging, utilizzare `--allow-local`:
```bash
# Audit a local OWASP ModSecurity Docker container and run reverse engineering
node packages/cli/dist/index.js check http://127.0.0.1:8088/ --allow-local --reverse
# Audit a local Caddy or HAProxy reverse proxy and generate patches
node packages/cli/dist/index.js check http://127.0.0.1:8089/ --allow-local --patch caddy
```
#### 🧪 Suite E2E Docker live automatizzata (`npm run test:e2e`)
Esegui audit di integrazione end-to-end su container Docker live (ModSecurity CRS, Caddy, HAProxy, NGINX e Backend) con un solo comando:
```bash
npm run test:e2e
```
Consulta la [Guida completa ai test WAF locali e alla validazione E2E](https://github.com/sech0us3/waf-checker/blob/main/docs/LOCAL_WAF_TESTING.md) per benchmark completi, diagrammi di architettura e passaggi di riproduzione manuale.
---
## 🚀 GitHub Action (CI/CD)
Integra i test di sicurezza WAF automatizzati nel tuo workflow di GitHub Actions:
```yaml
name: WAF Security Audit
on:
push:
branches: [ main ]
schedule:
- cron: '0 0 * * 1' # Weekly audit
jobs:
waf-audit:
runs-on: ubuntu-latest
permissions:
security-events: write # Required for SARIF upload
contents: read
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Run WAF Checker
uses: SecH0us3/waf-checker@main
with:
target-url: 'https://staging.example.com'
threshold: '95'
enhanced: 'true'
advanced: 'true'
sarif-output: 'waf-results.sarif'
html-output: 'waf-report.html'
- name: Upload SARIF to GitHub Security Tab
if: always()
uses: github/codeql-action/upload-sarif@v3
with:
sarif_file: 'waf-results.sarif'
- name: Upload HTML Report Artifact
if: always()
uses: actions/upload-artifact@v4
with:
name: waf-audit-report
path: waf-report.html
```
### 3. Versione Docker
Puoi eseguire la CLI usando Docker, sia scaricando l'immagine precompilata da GitHub Container Registry sia compilandola localmente.
#### Utilizzo dell'immagine precompilata (consigliato)
L'immagine Docker precompilata è disponibile su [GitHub Container Registry](https://github.com/SecH0us3/waf-checker/pkgs/container/waf-checker-cli) all'indirizzo `ghcr.io/sech0us3/waf-checker-cli`.
##### Scarica l'immagine
```bash
docker pull ghcr.io/sech0us3/waf-checker-cli:latest
```
##### Mostra l'aiuto
```bash
docker run --rm ghcr.io/sech0us3/waf-checker-cli:latest --help
```
##### Esegui un controllo
```bash
docker run --rm -it ghcr.io/sech0us3/waf-checker-cli:latest check https://example.com
```
##### Eseguire audit in batch (montando una directory locale)
```bash
docker run --rm -it -v "$(pwd):/data" ghcr.io/sech0us3/waf-checker-cli:latest batch /data/targets.txt --concurrency 3
```
#### Compilazione in locale
##### Compila l'immagine
```bash
docker build -t waf-checker-cli .
```
##### Mostra l'aiuto
```bash
docker run --rm waf-checker-cli --help
```
##### Esegui un controllo
```bash
docker run --rm -it waf-checker-cli check https://example.com
```
##### Eseguire audit in batch (montando una directory locale)
```bash
docker run --rm -it -v "$(pwd):/data" waf-checker-cli batch /data/targets.txt --concurrency 3
```
## 🔌 API e integrazione (per consumatori esterni e fuzzer)
Il Cloudflare Worker espone un'API REST pubblica utilizzata da scanner e fuzzer (incluso [swazz](https://github.com/SecH0us3/swazz)). La specifica completa OpenAPI 3.1 è disponibile in [`docs/openapi.yaml`](https://github.com/sech0us3/waf-checker/blob/main/docs/openapi.yaml).
### Panoramica degli endpoint
| Endpoint | Metodo | Descrizione |
|---|---|---|
| `/api/waf-detect` | `GET` | Identifica il vendor WAF, il punteggio di confidenza e i bypass suggeriti. |
| `/api/check` | `GET`, `POST` | Sonda il target con payload di attacco. Supporta la paginazione e il filtraggio per categoria. |
| `/api/virtual-patch` | `POST` | Genera regole di remediation per Cloudflare, AWS, ModSec, NGINX, Caddy, HAProxy, Coraza. |
| `/api/reverse-engineer` | `GET`, `POST` | Esegue il reverse engineering delle regole OWASP CRS, delle soglie di anomalia e dei limiti del body. |
| `/api/audit` | `GET`, `POST` | **Audit unificato**: esegue rilevamento, controlli di sicurezza e virtual patch, solitamente in un'unica richiesta (vedi Audit Paging). |
### Funzionalità chiave di integrazione
- **Envelope di paginazione (`?envelope=1` o `?envelope=true`)**:
Avvolge i risultati in un envelope strutturato con metadati di paginazione:
```json
{
"results": [...],
"page": 0,
"pageSize": 50,
"total": 72,
"hasMore": true
}
```
*(Omettere `?envelope=1` per ricevere l'array JSON semplice predefinito per retrocompatibilità).*
- **Paginazione dell'audit (`/api/audit`)**:
Un audit restituisce tutto in un'unica risposta (`hasMore: false`) a meno che il suo piano non superi ciò che consente il budget di sotto-richieste di una singola richiesta Cloudflare Worker (1658 elementi). Ciò copre l'assenza di WAF rilevato (513 elementi) e tutte le varianti di bypass di ogni WAF fino a Sophos (1321); un target protetto da Qrator (2441 elementi) viene restituito su due pagine, così come qualsiasi audit in cui si passi un `pageSize` più piccolo. Le risposte contengono `page`, `pageSize`, `total`, `hasMore` e `detectedWAF` (`""` se non ne è stato trovato nessuno). Finché `hasMore` è true, richiedere `page=<page + 1>&detectedWAF=<detectedWAF>`; passare nuovamente `detectedWAF` evita la ri-rilevazione (`detection` è quindi `null`) e mantiene stabili i confini delle pagine. `patches` copre i risultati di quella risposta; per un singolo bundle su più pagine, eseguire `POST` dei `results` combinati su `/api/virtual-patch`.
- **Confidenza normalizzata (`/api/waf-detect`)**:
Fornisce `confidencePercent` (0–100) insieme a `confidence` e `confidenceThreshold` grezzi (`40`).
- **Verdetto per risultato e flag di blocco**:
Ogni `AuditResultItem` include:
- `blocked: boolean` — Indica se il WAF è intervenuto prima di raggiungere l'origine.
- `verdict: 'blocked' | 'passed' | 'exposed'` — Esito distinto che differenzia tra fughe (`exposed`) e lacune di copertura (`passed`).
- `error: string | null` — Categoria di errore esplicita in caso di caduta di rete (ad es. `'timeout'`, `'dns'`, `'connection_reset'`).
- **Rifiuto dell'auto-scansione (HTTP 422)**:
Rifiuta le auto-scansioni accidentali rivolte all'infrastruttura del servizio con `{ "error": "self-scan refused", "code": "SELF_SCAN_REFUSED" }`.
---
## Testing
Per eseguire la suite di test dell'intero workspace (utilizzando Vitest):
```bash
npm test
```
Leggi il mio blog su [yoursec.substack.com](https://yoursec.substack.com/)