WAF e protezione contro le iniezioni

1) Perché WAF nell'era API

• «lunghe code» integrazioni (codice ereditario, web partner),
• parsing (proxy)
• nuove tecniche di bypass protocollari/di controllo.
• WAF fornisce il limite del primo guasto (early deny) e del «patching virtuale» prima del rilascio del codice, ma non sostituisce lo sviluppo sicuro.

2) Modello di minaccia: tipi di iniezioni per API

SQLi/ORMi: classic/boolean/time-based/stacked; blind attraverso ritardi.
NoSQLi (Mongo/Elastic): operatori «$ ne/$ gt», JSON injection, regex-DoS.
Command Ingection/RCE: shell-metacaratteri, scambi di argomenti, unsafe deserialization e code exec.
XXE - Entità/DTD esterne in XML.
SSRF: accesso al "169. 254. 169. 254 '/servizi interni; DNS-rebinding.
Template Injection: Jinja/Thymeleaf/Handlebars; `{{77}}`.
LDAP/EL Injection, XPath, Header injection (CRLF), Path traversal.
GraphQL-specifico: «__ schema» introspection, profondità/complessità delle query.
JSON/JS-specifico: Prototype Pollolution.
gRPC/Protobuf: messaggi oversized, field smuggling attraverso diagrammi non corrispondenti.

3) Architetture WAF

Perimetro CDN-WAF: filtraggio veloce geo/ASN, bot control di base, cache/antipadding.
Perimetro L7 (NGINX/Avvoy/APISIX/Kong): parsing preciso, regole profonde, integrazione con PDP/limiti.
Saidkar/Mash (Avvoy WASM/Filter): un servizio per i dati molto vicino, meno falso positivo per le API interne.
Raccomandazione: modello a due strati (CDN-WAF + L7 WAF).

4) Parsing, normalizzazione e anti-aggirazione

• Normalizzazione dei percorsi ('/a/% 2e% 2e/b '→),' UTF-8 '/Unicode confusabili, byte NUL.
• Un unico decoding: URL/HTML/Unicode-/Base64, il divieto di decoding doppio.
• Vincoli: «max _ headers», «max _ header _ size», «max _ body _ size», «max _ args», profondità JSON, limite delle parti multipart, divieto 2x gzip/zip-bombe.
• Criteri Content-Type: 'application/json'solo sugli endpoint JSON; rifiutare «polyglot».

5) Modelli di regole

Negativo (firme): OWASP CRS (SQLI/XSS/SSRF/Java/Node RCE, ecc.). Partenza veloce.
Positivo (allow-list) - Diagrammi rigorosi (JSON Schema/Protobuf), tipi e intervalli; lungo le rotte.
Anomalo/screening, sommando i segni sospetti alla soglia di blocco.
Contestuale: profili diversi per «POST/payments» e «GET/status»; meno FP.

6) Blocchi di blocco (in collegamento)

1. Schemi e tipi: JSON Schema/Protobuf convalida fino alla logica aziendale.
2. Parametrizzazione: espressioni preparate, binding ORM, proibizione concatenazione.
3. Output-escaping: HTML/JS/SQL contestuale.
4. Regole del corpo: Content-Type, dimensioni, vincoli multipart, interruzione dei binari sulle maniglie JSON.
5. Regole WAF: CRS + castoma negativo/positivo.
6. Rate/Quota/Concorrency - soppressione del DDoS di una tartaruga, capci/challenge protettivi per forme pubbliche.
7. Isolamento delle reti: egress-policy per SSRF (deny RFC1918/metadata/Unix sockets).
8. Headers-igiene: 'X-Content-Type-Options: nosniff',' Content-Security-Policy ',' Referer-Policy '.
9. GraphQL guard: limiti di profondità/complessità, disattivazione introspection (o ruolo-gate).

7) Esempi di configurazione

7. 1 NGINX + ModSecurity (OWASP CRS)

nginx load_module modules/ngx_http_modsecurity_module.so;

modsecurity on;
modsecurity_rules_file /etc/modsecurity/modsecurity.conf;
modsecurity_rules '
SecRuleEngine On
Подключаем CRS
Include /etc/modsecurity/crs/crs-setup.conf
Include /etc/modsecurity/crs/rules/.conf

Позитивные правила: только JSON и ограничение размера
SecRule REQUEST_HEADERS:Content-Type "!@rx ^application/json($;)" "id:10001,phase:1,deny,status:415,msg:'Only JSON allowed'"
SecRequestBodyLimit 1048576
SecRequestBodyNoFilesLimit 1048576

Блок локальных адресов (SSRF)
SecRule REQUEST_HEADERS:Host "@ipmatch 127.0.0.0/8 10.0.0.0/8 169.254.0.0/16 192.168.0.0/16" \
"id:10002,phase:1,deny,status:403,msg:'Blocked private range'"
';

server {
listen 443 ssl http2;
server_name api.example.com;

client_max_body_size 1m;
proxy_request_buffering on;  # защита от slow-POST proxy_read_timeout 300ms;
proxy_connect_timeout 100ms;

location /v1/ {
proxy_pass http://app_backends;
}
}

7. 2 Envoy HTTP WAF (WASM + JSON Schema + SSRF egress-deny)

yaml http_filters:
- name: envoy.filters.http.wasm typed_config:
config:
vm_config: { vm_id: waf, code: { local: { filename: /plugins/waf.wasm } } }
configuration:
"@type": type.googleapis.com/google.protobuf.Struct value:
crs_profile: "strict"
deny_patterns: ["(?i)union.select", "(?i)(sleep    benchmark)\\s\\("]
json_schema:
"/v1/payments:create": "/schemas/payments_create.json"
- name: envoy.filters.http.router

Egress SSRF guard (L4): deny private ranges from gateway filter_chains:
- filters:
- name: envoy.filters.network.tcp_proxy typed_config:
stat_prefix: egress cluster: internet access_log: [...]
tunneling_config:
hostname: "%REQ(:authority)%"
transport_socket:
name: envoy.transport_sockets.tls

7. 3 APISIX - Vincolo di tipo e anti-imbottigliamento

yaml routes:
- uri: /v1/
plugins:
cors: { allow_origins: "https://app.example.com" }
request-validation:
body_schema:
{"type":"object","properties":{"amount":{"type":"number","minimum":1}},"required":["amount"]}
uri-blocker:
block_rules: ["..","%2e%2e","%2f..","\\x00"]  # traversal/NULL proxy-rewrite:
headers:
set:
X-Content-Type-Options: "nosniff"

8) Sintonizzazione e riduzione dei falsi effetti (FP)

Profili per-route: regole rigorose solo se appropriate (ad esempio, '/search'permette '/'% ').
Shadow/Report-Only - Logifichiamo le operazioni prima del blocco; A/B confronto metriche.
Elenchi allow custom per i parametri legittimi «rumorosi».
Copia - Blocca solo la somma degli indicatori> soglia.
Esperimenti: una piccola percentuale di traffico su nuove regole auto-rollback.

9) Osservabilità e forenza

Метрики: `waf_block_total{rule}`, `waf_anomaly_score`, `request_body_rejected_total`, `schema_violation_total`, `ssrf_block_total`.
Logi (tramilati): regola, parte della query (modificata), «trace _ id», «tenant», «route», motivo. Maschera PII/segreti.
Dashboard: top regole/percorsi, FP-cluster, altoparlanti dopo la release.
Incidenti: conservazione di manufatti (payload, pcap se necessario), prodotti RCA e patch virtuali.

10) Test e script di caos

Caselle di ricerca WAF (SQLI/XSS/SSRF), codifiche doppie/tripliche, combinate Unicode.
Differenze di parsing: invia payload in cui il proxy e il framework possono variare (doppie di parametri, array, ';' vs '&').
Slow-POST/oversize, zip-bombe, forme multiple, boundary errati.
Generatore di profondità/complessità, controllo dei limiti e dei timeout.

11) Antipattern

«Accendere il CRS e dimenticarlo», senza schemi, senza tuning lungo le rotte.
Fogli crudi di query e PII.
Non ci sono normalizzazioni o limiti di dimensioni di un giro di , ma parsing.
Omissione dì Content-Type '/charset dei controlli di attacco poliglotto.
Nessun filtro egress → SSRF al metadato della nuvola.
Un profilo condiviso per API interne e esterne.
Le eccezioni incontrollate «per il partner» → un buco nel perimetro.

12) Specificità iGaming/finanza

I profili rinforzati su maniglie di pagamento/output sono piccoli limiti body, diagrammi rigorosi, deny list per account/BAN/PAN (maschera, controlli di formattazione).
Webhook da PSP/KYC: firma HMAC/TLS mutuale, singoli profili WAF, anti-replay.
Filtri Geo/ASN e limiti comportamentali per prevenire le immatricolazioni bot e bonus-abyus.
Registri di incidenti invariati (verifiche), archiviazione giurisdizionale.

13) Assegno-foglio prod-pronto

• WAF a due strati (CDN + L7), normalizzazione e limiti di quota unificati.
• CRS OWASP abilitato, regole custome per-route; JSON Schema/Protobuf con maniglie write.
• Criteri Content-Type/charset divieto di decoding doppio/NULL/traversal.
• unità SSRF-egress per intervalli privati/metadata; Protezione DNS-rebinding.
• Rate/Quota/Concorrency e anti-bot (challenge) su forme pubbliche.
• Shadow/Report-Only → canary → enforce; auto-rollback SLO e FP.
• Metriche/fogli/trailer mascherati; dashboard «regole top »/FP.
• playbook di patch virtuale e RCA; Controlli regolari.
• Profili separati per siti web PSP/KYC, maniglie di pagamento e API interne.

14) TL; DR

Creare una protezione su livelli - Normalizzazione e limiti di dello schema/tipo di parametrizzazione WAF (CRS + casta) del filtro rate/bot egress SSRF. Tinge per-route, avvia nuove regole in shadow → canary, controlla le metriche/FP e fa «patch virtuali» fino al codice del codice. Per i percorsi di pagamento/webhook, i singoli profili rigorosi, le finestre minime e le finestre di fiducia.