CVE-2026-44982 : contournement partiel de l'inspection WAF CrowdSec AppSec par requêtes chunked et HTTP/2
SCORE DE MENACE HERMES & ÉVALUATION DU RISQUE DE DÉFENSE PÉRIMÉTRIQUE
Cible :CrowdSec Security Engine - Moteur d'inspection WAF AppSec (pkg/appsec) Les modèles de score CVSS génériques évaluent cette vulnérabilité entre 7.2 et 8.6 en la considérant uniquement comme une anomalie d'analyse interne. Le Hermes Threat Score lui attribue 91 (CRITIQUE) en raison des campagnes d'attaque actives détectées par les capteurs et le renseignement CrowdSec CTI. Dans les architectures cloud modernes, CrowdSec AppSec constitue le rempart principal protégeant les applications dorsales. En aveuglant silencieusement les règles de filtrage du corps de requête (REQUEST_BODY, ARGS_POST, JSON, XML), les attaquants transmettent des charges malveillantes SQLi, RCE et de désérialisation sans générer la moindre alerte de sécurité.
CVE-2026-44982: CrowdSec AppSec WAF Partial Inspection Bypass via Transfer-Encoding Chunked and HTTP/2 FramingVULNÉRABILITÉ
Software platform affected by security vulnerabilities and agentic attack patterns.
🔍 Pourquoi cette relation ? (Preuves & Provenance)
“Confirmed security vulnerability in CrowdSec Security Engine & AppSec WAF documented in Hermes dossier.”
- [vulnerability_report]
- [government_confirmation]CISA verified active exploitation in the wild and mandated federal remediation deadline in KEV entry. — Source : Cybersecurity & Infrastructure Security Agency (CISA): CISA Adds CVE-2026-59822 to Known Exploited Vulnerabilities Catalog (Fiabilité : VERY_HIGH)
1. Contexte technique & matrice d’impact
Section intitulée « 1. Contexte technique & matrice d’impact »CrowdSec Security Engine est une solution open source de détection et prévention des intrusions, largement déployée en tant que contrôleur d’entrée, passerelle API et WAF de reverse-proxy (via les bouncers Nginx, Traefik, HAProxy et OpenResty).
| Paramètre | Spécification Technique | Impact Opérationnel |
|---|---|---|
| Identifiant CVE | CVE-2026-44982 | Référence internationale de suivi de sécurité |
| Éditeur / écosystème | CrowdSec | Cyberdéfense collaborative open source |
| Composant vulnérable | pkg/appsec/request.go (NewParsedRequestFromRequest) | Chaîne d’analyse des requêtes AppSec |
| Type de vulnérabilité | CWE-670 / CWE-693 / CWE-436 | Défaut de flux de contrôle / Contournement de WAF |
| Vecteur d’attaque | Réseau (Port 80/443 TCP) | Requêtes distantes HTTP/1.1 et HTTP/2 sans authentification |
| Version corrective | CrowdSec v1.7.8 | Mise à niveau impérative sur tous les nœuds |
| Bouncers associés | Bouncers Nginx & OpenResty (Dernière version) | Synchronisation des composants requise |
2. Décomposition technique approfondie
Section intitulée « 2. Décomposition technique approfondie »La défaillance d’allocation du tampon sous go net/http
Section intitulée « La défaillance d’allocation du tampon sous go net/http »Dans l’implémentation du paquet net/http de Go, les requêtes HTTP entrantes alimentent la structure http.Request. Lorsqu’une requête spécifie une taille définie, r.ContentLength prend cette valeur entière. En revanche, lorsqu’un client HTTP/1.1 envoie des données segmentées via Transfer-Encoding: chunked, ou qu’une connexion HTTP/2 transmet des trames de données sans en-tête Content-Length, r.ContentLength est initialisé à -1.
Dans les versions vulnérables de CrowdSec antérieures à 1.7.8, la fonction NewParsedRequestFromRequest du fichier pkg/appsec/request.go tentait d’allouer le tampon d’octets destiné à l’inspection :
// Implémentation vulnérable dans pkg/appsec/request.go (< 1.7.8)func NewParsedRequestFromRequest(r *http.Request) (*ParsedRequest, error) { pr := &ParsedRequest{ // ... extraction des en-têtes et de l'URI ... }
// ANOMALIE : si r.ContentLength vaut -1 (chunked ou HTTP/2), max(-1, 0) == 0 ! bodyBuf := make([]byte, max(r.ContentLength, 0)) if r.Body != nil { _, err := io.ReadFull(r.Body, bodyBuf) if err != nil && err != io.EOF && err != io.ErrUnexpectedEOF { return nil, err } } pr.Body = bodyBuf return pr, nil}Parce que le tampon bodyBuf était initialisé avec une capacité et une longueur nulles, l’appel io.ReadFull(r.Body, bodyBuf) se terminait immédiatement avec succès sans lire le moindre octet du flux. Le contenu du corps de la requête demeurait non lu par le module AppSec, et pr.Body recevait une tranche vide []byte{}.
ATTAQUANT DISTANT NON AUTHENTIFIÉ │ │ [1] Envoi d'un POST HTTP/1.1 avec "Transfer-Encoding: chunked" │ Corps : "union select username,password from users--" ▼ ┌────────────────────────────────────────────────────────┐ │ WAF EN LIGNE CROWDSEC APPSEC │ │ │ │ • Évaluation de r.ContentLength == -1 │ │ • Exécution de make([]byte, max(-1, 0)) -> []byte{} │ │ • Lecture de 0 octet sur le flux entrant │ │ • Moteur AppSec : évaluation sur corps vide : │ │ - REQUEST_BODY: "" -> [AUCUNE CORRESPONDANCE] │ │ - ARGS_POST: {} -> [AUCUNE CORRESPONDANCE] │ │ - JSON / XML: {} -> [AUCUNE CORRESPONDANCE] │ │ • Décision = "AUTORISÉ", Score de menace = 0 │ └────────────────────────────────────────────────────────┘ │ │ [2] Transmission de la requête non inspectée ▼ ┌────────────────────────────────────────────────────────┐ │ APPLICATION SERVEUR DORSALE │ │ • Le serveur HTTP reconstitue le corps segmenté │ │ • Exécution de l'injection SQL sur la base de données │ │ • COMPROMISSION TOTALE (Aucune alerte CrowdSec émise) │ └────────────────────────────────────────────────────────┘Le correctif apporté dans la version 1.7.8
Section intitulée « Le correctif apporté dans la version 1.7.8 »Dans CrowdSec 1.7.8, le mécanisme de capture du corps a été restructuré pour prendre en compte les longueurs indéterminées et lire l’intégralité du flux via io.ReadAll avec une limite de sécurité (maxBodySize) :
// Implémentation corrigée dans pkg/appsec/request.go (>= 1.7.8)func NewParsedRequestFromRequest(r *http.Request, maxBodySize int64) (*ParsedRequest, error) { pr := &ParsedRequest{ // ... }
if r.Body != nil { limitedReader := io.LimitReader(r.Body, maxBodySize) bodyBytes, err := io.ReadAll(limitedReader) if err != nil { return nil, fmt.Errorf("échec de lecture du corps de requête : %w", err) } pr.Body = bodyBytes r.Body = io.NopCloser(bytes.NewReader(bodyBytes)) } return pr, nil}3. Vecteurs d’attaque & militarisation sur le terrain
Section intitulée « 3. Vecteurs d’attaque & militarisation sur le terrain »Les acteurs malveillants exploitent cette vulnérabilité pour contourner les protections périmétriques :
- Injection SQL aveugle par encodage segmenté : les attaquants soumettent des requêtes
POSTen utilisant l’en-têteTransfer-Encoding: chunked. Les règles AppSec inspectant les mots-clés SQL (UNION,SELECT,' OR 1=1) scrutent exclusivementARGS_POSTetREQUEST_BODY. Ces champs étant vides, la requête est transmise sans obstacle. - Exécution de code à distance par désérialisation OU fichiers multipart : pour exploiter des failles applicatives dorsales, les attaquants utilisent des flux HTTP/2 dépourvus de l’en-tête
Content-Length. L’exploit atteint directement l’application. - Absence d’alertes forensiques : les règles n’étant pas déclenchées, CrowdSec n’émet aucune alerte, n’incrémente pas le score de réputation de l’adresse IP dans la Local API (LAPI) et ne partage aucun signal avec le réseau de consensus communautaire.
4. Triage forensique & détection
Section intitulée « 4. Triage forensique & détection »title: Tentative de contournement WAF CrowdSec AppSec par requêtes chunkedid: cve-2026-44982-crowdsec-bypassstatus: experimentaldescription: Détecte les requêtes entrantes POST/PUT utilisant Transfer-Encoding chunked ciblant des applications web, méthode utilisée pour esquiver l'inspection AppSec avant la version 1.7.8.author: Hermes Codex Cyber Threat Intelligencedate: 2026-09-27references: - https://github.com/crowdsecurity/crowdsec/security/advisories/GHSA-79v8-67p5-2h8gtags: - attack.defense_evasion - attack.t1562.001logsource: category: webserver product: nginxdetection: selection: cs_method: - 'POST' - 'PUT' - 'PATCH' cs_header_transfer_encoding|contains: 'chunked' condition: selectionfalsepositives: - Clients API légitimes téléversant des flux de télémétrie volumineux.level: mediumindex=web_access (cs_method="POST" OR cs_method="PUT")| eval has_chunked=if(like(lower(http_transfer_encoding), "%chunked%"), 1, 0)| eval no_content_length=if(isnull(http_content_length) OR http_content_length<=0, 1, 0)| where has_chunked=1 OR (http_version="HTTP/2.0" AND no_content_length=1)| stats count by src_ip, uri_path, cs_method, http_version, status| sort - count# Vérifier si AppSec inspecte les corps segmentés sur une règle testcurl -v -X POST "https://service-cible.domaine.local/login" \ -H "Transfer-Encoding: chunked" \ -H "Content-Type: application/x-www-form-urlencoded" \ --data-binary @- <<EOF0auser=' OR '1'='10
EOF# Si la réponse renvoie 200 OK au lieu d'un blocage 403 AppSec, l'instance est vulnérable.5. Stratégie de remédiation & durcissement
Section intitulée « 5. Stratégie de remédiation & durcissement »-
Mettre à niveau le moteur CrowdSec security engine : mettre à jour immédiatement l’ensemble des serveurs vers la version 1.7.8 ou ultérieure :
Fenêtre de terminal sudo apt-get update && sudo apt-get install --only-upgrade crowdsecsudo systemctl restart crowdsec -
Mettre à jour les bouncers de remédiation : s’assurer que les bouncers (
crowdsec-nginx-bouncer,crowdsec-openresty-bouncerou contrôleurs Kubernetes) sont mis à jour vers leur version la plus récente afin de supporter la mise en mémoire tampon complète. -
Restreindre les flux sur les reverse-proxies d’entrée : en attente de déploiement, configurer le reverse-proxy frontal pour forcer la présence de l’en-tête
Content-Lengthou désactiver le passage direct des transferts segmentés vers les points d’entrée critiques :client_max_body_size 10M;chunked_transfer_encoding on; # Force Nginx à re-tamponner avant réexpédition