Aller au contenu

CVE-2026-44982 : contournement partiel de l'inspection WAF CrowdSec AppSec par requêtes chunked et HTTP/2

Densité :
HERMES

SCORE DE MENACE HERMES & ÉVALUATION DU RISQUE DE DÉFENSE PÉRIMÉTRIQUE

Cible : CrowdSec Security Engine - Moteur d'inspection WAF AppSec (pkg/appsec)
Confiance : 98%
91 / 100
CRITIQUE

Mesure la pertinence opérationnelle réelle, la militarisation de l'exploit et la posture de menace active.

Décomposition des dimensions
Exploitabilité 19 / 20
Activité de menace 18 / 20
Militarisation 18 / 20
Exposition 19 / 20
Prévalence 17 / 20
Impact 18 / 20
Maturité de l'exploit 18 / 20
Potentiel d'attaque en chaîne 19 / 20
⚖️ Divergence & Justification opérationnelle

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é.

🕸️ Graphe de connaissances connecté & Provenance

CVE-2026-44982: CrowdSec AppSec WAF Partial Inspection Bypass via Transfer-Encoding Chunked and HTTP/2 FramingVULNÉRABILITÉ

Nœuds connectés : 1
Relations sortantes actives
→ affectsCOMPOSANTCrowdSec Security Engine & AppSec WAF
98% VERY_HIGH

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.”

Preuves vérifiées associées :

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ètreSpécification TechniqueImpact Opérationnel
Identifiant CVECVE-2026-44982Référence internationale de suivi de sécurité
Éditeur / écosystèmeCrowdSecCyberdéfense collaborative open source
Composant vulnérablepkg/appsec/request.go (NewParsedRequestFromRequest)Chaîne d’analyse des requêtes AppSec
Type de vulnérabilitéCWE-670 / CWE-693 / CWE-436Défaut de flux de contrôle / Contournement de WAF
Vecteur d’attaqueRéseau (Port 80/443 TCP)Requêtes distantes HTTP/1.1 et HTTP/2 sans authentification
Version correctiveCrowdSec v1.7.8Mise à niveau impérative sur tous les nœuds
Bouncers associésBouncers Nginx & OpenResty (Dernière version)Synchronisation des composants requise

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) │
└────────────────────────────────────────────────────────┘

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 :

  1. Injection SQL aveugle par encodage segmenté : les attaquants soumettent des requêtes POST en utilisant l’en-tête Transfer-Encoding: chunked. Les règles AppSec inspectant les mots-clés SQL (UNION, SELECT, ' OR 1=1) scrutent exclusivement ARGS_POST et REQUEST_BODY. Ces champs étant vides, la requête est transmise sans obstacle.
  2. 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.
  3. 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.

title: Tentative de contournement WAF CrowdSec AppSec par requêtes chunked
id: cve-2026-44982-crowdsec-bypass
status: experimental
description: 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 Intelligence
date: 2026-09-27
references:
- https://github.com/crowdsecurity/crowdsec/security/advisories/GHSA-79v8-67p5-2h8g
tags:
- attack.defense_evasion
- attack.t1562.001
logsource:
category: webserver
product: nginx
detection:
selection:
cs_method:
- 'POST'
- 'PUT'
- 'PATCH'
cs_header_transfer_encoding|contains: 'chunked'
condition: selection
falsepositives:
- Clients API légitimes téléversant des flux de télémétrie volumineux.
level: medium

  1. 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 crowdsec
    sudo systemctl restart crowdsec
  2. Mettre à jour les bouncers de remédiation : s’assurer que les bouncers (crowdsec-nginx-bouncer, crowdsec-openresty-bouncer ou contrôleurs Kubernetes) sont mis à jour vers leur version la plus récente afin de supporter la mise en mémoire tampon complète.

  3. 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-Length ou 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