WAF și protecție împotriva injecției

1) De ce WAF în era API

• „cozi lungi” de integrare (cod moștenit, carti web afiliate),
• parsarea discrepanțelor (cadru de ↔ proxy)
• noi tehnici de bypass protocol/obfuscation.
• WAF oferă o limită de negare și „patching virtual” înainte de eliberarea codului, dar nu înlocuiește dezvoltarea sigură.

2) Model de amenințare: Tipuri de injecție API

SQLi/ORMi: clasic/boolean/pe bază de timp/stivuite; orb prin întârzieri.
NoSQLi (Mongo/Elastic): operatorii '$ ne/$ gt', injecție JSON, regex-DoS.
Injecție de comandă/RCE: metacaractere de coajă, substituție de argumente, deserializare nesigură → code μ.
XXE: entități externe/DTD-uri în XML.
SSRF: acces la '169. 254. 169. 254 '/servicii interne; DNS-rebinding.
Injecție șablon: Jinja/Thymeleaf/Ghidon; '{{77}}}'.
LDAP/EL Injection, XPath, Header injection (CRLF), Path traversal.
GraphQL-specific: introspecția „schemei __”, adâncimea/complexitatea interogărilor.
JSON/JS-specific: Poluarea prototipului („__ proto __”, „constructor”).
gRPC/Protobuf: mesaje supradimensionate, contrabandă pe teren prin nepotrivire schemă.

3) arhitecturi WAF

Perimetrul CDN-WAF: filtrare rapidă geo/ASN, control de bază bot, cache/anti-padding.
Perimetrul L7 (NGINX/Envoy/APISIX/Kong): parsare precisă, reguli profunde, integrare cu PDP/limite.
Sidecar/mash (Envoy WASM/Filter): per-service, aproape de date, mai puțin fals pozitiv pentru API-uri interne.
Recomandare: model cu două straturi (CDN-WAF + L7 WAF).

4) Parsarea, normalizarea și anti-by-pass

• Normalizarea traseului („/a/% 2e% 2e/b ”eșec →),„ UTF-8 ”/confuzabile Unicode, octeți NUL.
• Decodare unică: URL-/HTML-/Unicode-/Base64-layers, interzicerea decodării duble.
• Restricții: 'max _ headers', 'max _ header _ size', 'max _ body _ size', 'max _ args', adâncime JSON, limită multipart, bombe 2x gzip/zip interzise.
• Politici de tip conținut: „aplicare/json” numai pentru punctele finale JSON; respinge „poliglot”.

5) Modele de reguli

Negativ (semnături): OWASP CRS (SQLi/XSS/SSRF/Java/Node RCE, etc.). Quick Start.
Pozitive (allow-list): scheme stricte (JSON Schema/Protobuf), tipuri și intervale; pe rute.
Anormal/scoring: însumarea semnelor „suspecte” → pragul de blocare.
Contextual: profiluri diferite pentru „POST/plăți” și „GET/status”; mai puțin FP.

6) Unități de protecție (într-un pachet)

1. Scheme și tipuri: Schema JSON/Validarea Protobuf pentru logica de afaceri.
2. Parametrizare: expresii pregătite, legături ORM, interdicție de concatenare.
3. Ieșire-evadare: HTML/JS/SQL contextual.
4. Politici corporale: Tip de conținut, dimensiune, restricții multipart, interzicerea binare pe mânere JSON.
5. Reguli WAF: SIR + personalizat negativ/pozitiv.
6. Rata/Cota/Concurență: suprimarea brută/broască țestoasă DDoS, captchas de protecție/provocări pentru formele publice.
7. Izolarea rețelei: politici de ieșire pentru SSRF (nega prize RFC1918/metadata/Unix).
8. Anteturi-igienă: „X-Content-Type-Options: nosniff”, „Content-Security-Policy” pentru front, „Referrer-Policy”.
9. Garda GraphQL: limite de adâncime/complexitate, interzicerea introspecției în prod (sau role-gate).

7) Exemple de configurare

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 de ieșire-negare)

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: restricție de tip și anti-obfuscare

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) Tuning și reducerea fals pozitive (FP)

Profiluri pe traseu: reguli stricte numai dacă este cazul (de ex. '/search 'permite '/'%').
Shadow/Report-Only: log responses before the block; Compararea A/B a măsurătorilor.
Personalizat permite liste pentru parametrii legitimi „zgomotoase”.
Scoring: Blocați numai atunci când suma indicatorului> prag.
Experimente: un procent mic de trafic la noi reguli → auto-rollback.

9) Observabilitate și incidență

Метрики: 'waf _ block _ total {rule}', 'waf _ anomaly _ score', 'request _ body _ respinsed _ total', 'schema _ violation _ total', 'ssrf _ block _ total'.
Jurnale (eșantionate): regulă, parte a cererii (editate), 'trace _ id',' chiriaș ',' traseu ', motiv. Deghizare PII/secrete.
Tablouri de bord: reguli/căi de top, clustere FP, dinamică după eliberare.
Incidente: salvarea artefactelor (sarcină utilă, pcap, dacă este necesar), a produselor RCA și a „patch-urilor virtuale”.

10) Scenarii de testare și haos

WAF bypass enclosures (SQLi/XSS/SSRF), dublu/triplu Unicode codificări mixte.
Parsarea diferențelor: trimiteți sarcină utilă, unde proxy-ul și cadrul pot diverge (duplicate de parametri, matrice, „;” vs „&”).
Slow-POST/supradimensionare, bombe zip, forme multi-parte, graniță eronată.
GraphQL: generator de adâncime/complexitate, limite de verificare și timeout.

11) Antipattern

„Activat CRS și uitat”: fără scheme, fără tuning de-a lungul rutelor.
Bușteni cu corp de cerere brută și PII.
Fără limite de normalizare/dimensiune → ocolire, DoS pentru parsare.
Skipping 'Content-Type '/charset checks → polyglot attacks.
Nu există filtre de ieșire → SSRF la metadate cloud.
Un profil comun pentru API-uri externe și interne.
Excepții necontrolate „pentru partener” → găuri în perimetru.

12) Specificul iGaming/Finanțe

Profile consolidate pe mânere de plată/ieșire: limite mici ale corpului, scheme stricte, liste de refuzuri pentru câmpurile de cont/IBAN/PAN (mascare, verificări de format).
Cârlige Web de la PSP/KYC: semnătură HMAC/TLS reciproc, profile WAF individuale, anti-reluare.
Filtre Geo/ASN și limite comportamentale pentru a preveni înregistrările bot și abuzul de bonus.
Jurnalele incidente sunt imuabile (audit), stocate în funcție de jurisdicție.

13) Lista de verificare Prod Readiness

• WAF cu două straturi (CDN + L7), normalizare unică și limite de dimensiune.
• OWASP CRS activat, reguli personalizate pe traseu; JSON Schema/Protobuf pe scrie stilouri.
• Content-Type/charset policies; disallow double decoding/NULL/traversal.
• SSRF-egress bloc pentru benzi private/metadate; Protecție DNS rebinding.
• Rata/Cota/Concurență și anti-bot (provocări) pe forme publice.
• Umbra/Raport-Numai → canar → pune în aplicare; auto-rollback de SLO și FP.
• Metrici/busteni/trasee cu mascare; tablouri de bord „reguli de top „/FP.
• Patch-uri virtuale și playbookuri RCA; teste de by-pass regulate.
• Profile separate pentru carti web PSP/KYC, pixuri de plata si API-uri interne.

14) TL; DR

Construiți protecție prin straturi: normalizare și limite → scheme/tipuri → parametrizare → WAF (CRS + caste) → filtre rată/bot → bloc de ieșire SSRF. Tune pe traseu, rulați noi reguli în umbră → canar, monitorizați metrici/FP și faceți „patch-uri virtuale” înainte de fixarea codului. Pentru căi de plată/webhook - profile stricte separate, HMAC/mTLS și ferestre de încredere minime.