CVE-2026-44982: CrowdSec AppSec WAF Partial Inspection Bypass via Transfer-Encoding Chunked and HTTP/2 Framing
HERMES THREAT SCORE & PERIMETER GATEWAY DEFENSE EVALUATION
Target:CrowdSec Security Engine - AppSec WAF Inspection Engine (pkg/appsec) NVD and generic vulnerability scoring models evaluate this flaw between 7.2 and 8.6, considering it solely as an inspection engine failure. The Hermes Threat Score elevates this assessment to 91 (CRITICAL) based on active in-the-wild threat campaigns identified by CrowdSec CTI telemetry. In enterprise perimeter architectures, CrowdSec AppSec operates as an inline reverse-proxy defense layer guarding backend application servers. A silent body-inspection bypass blinds all ModSecurity and AppSec rule evaluations (REQUEST_BODY, ARGS_POST, JSON, XML), enabling attackers to route malicious SQLi, command injection, and deserialization exploits directly to internal backends without triggering security alerts.
CVE-2026-44982: CrowdSec AppSec WAF Partial Inspection Bypass via Transfer-Encoding Chunked and HTTP/2 FramingVULNERABILITY
Software platform affected by security vulnerabilities and agentic attack patterns.
๐ Why is this related? (Evidence & 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 (Reliability: VERY_HIGH)
1. Technical Context & Affected Software Matrix
Section titled โ1. Technical Context & Affected Software MatrixโCrowdSec Security Engine is an open-source, collaborative intrusion detection and prevention system widely deployed as an ingress controller, API gateway filter, and reverse-proxy WAF (via Nginx, Traefik, HAProxy, and OpenResty remediation bouncers).
| Parameter | Technical Specification | Operational Impact |
|---|---|---|
| CVE Identifier | CVE-2026-44982 | International security tracking reference |
| Vendor / Ecosystem | CrowdSec | Open-Source Collaborative Cyber Defense |
| Vulnerable Component | pkg/appsec/request.go (NewParsedRequestFromRequest) | AppSec datasource parsing pipeline |
| Flaw Classification | CWE-670 / CWE-693 / CWE-436 | Control Flow Implementation / WAF Bypass |
| Attack Vector | Network (Port 80/443 TCP) | Remote, unauthenticated HTTP/1.1 & HTTP/2 requests |
| Remediation Release | CrowdSec v1.7.8 | Mandatory software update across all nodes |
| Remediation Bouncers | Nginx & OpenResty Bouncers (Latest) | Component sync required to eliminate bypass |
2. In-Depth Technical Decomposition
Section titled โ2. In-Depth Technical DecompositionโThe Buffer Allocation Failure in Goโs net/http
Section titled โThe Buffer Allocation Failure in Goโs net/httpโIn Goโs net/http implementation, incoming HTTP requests populate the http.Request struct. When a request defines a standard content length, r.ContentLength reflects that integer value. However, when an HTTP/1.1 client streams data using Transfer-Encoding: chunked, or when an HTTP/2 connection sends data frames without a Content-Length header, r.ContentLength is set to -1 to denote an undefined body stream length.
In vulnerable versions of CrowdSec prior to 1.7.8, the function NewParsedRequestFromRequest inside pkg/appsec/request.go attempted to allocate an internal byte buffer for AppSec inspection rules:
// Vulnerable Implementation in pkg/appsec/request.go (< 1.7.8)func NewParsedRequestFromRequest(r *http.Request) (*ParsedRequest, error) { pr := &ParsedRequest{ // ... header and URI extraction ... }
// FLAW: If r.ContentLength is -1 (chunked or 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}Because bodyBuf was allocated with a capacity and length of 0, the io.ReadFull(r.Body, bodyBuf) call immediately succeeded having read exactly zero bytes. The remaining body stream remained unread by AppSec, and pr.Body was saved as an empty slice []byte{}.
UNAUTHENTICATED ATTACKER โ โ [1] Send HTTP/1.1 POST with "Transfer-Encoding: chunked" โ Body: "union select username,password from users--" โผ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ CROWDSEC APPSEC INLINE WAF โ โ โ โ โข Evaluates r.ContentLength == -1 โ โ โข Executes make([]byte, max(-1, 0)) -> make([]byte, 0)โ โ โข Reads 0 bytes from request stream โ โ โข AppSec Engine: Evaluates rules against empty body: โ โ - REQUEST_BODY: "" -> [NO MATCH] โ โ - ARGS_POST: {} -> [NO MATCH] โ โ - JSON / XML: {} -> [NO MATCH] โ โ โข Result: Decision = "ALLOW", Threat Score = 0 โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ โ [2] Forward uninspected request to upstream โผ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ UPSTREAM BACKEND APPLICATION โ โ โข HTTP server decodes chunked payload โ โ โข Executes SQL injection in database context โ โ โข FULL COMPROMISE (Zero CrowdSec alerts triggered) โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโThe Upstream Resolution (v1.7.8)
Section titled โThe Upstream Resolution (v1.7.8)โIn CrowdSec 1.7.8, the AppSec request ingestion logic was rewritten to check whether r.ContentLength < 0 or read via io.ReadAll with an explicit memory ceiling (maxBodySize), ensuring that chunked and HTTP/2 payloads are fully materialized into memory before rule evaluation:
// Patched Implementation in 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("failed to read request body: %w", err) } pr.Body = bodyBytes // Restore r.Body for downstream remediation bouncers if needed r.Body = io.NopCloser(bytes.NewReader(bodyBytes)) } return pr, nil}3. Attack Vectors & Real-World Weaponization
Section titled โ3. Attack Vectors & Real-World WeaponizationโThreat actors actively targeting perimeter gateways exploit this flaw to execute defense evasion against web applications guarded by CrowdSec:
- Blind SQL Injection via Chunked Encoding: Attackers issue
POSTrequests to public forms usingTransfer-Encoding: chunked. Any AppSec rules inspecting SQL injection keywords (UNION,SELECT,' OR 1=1) look exclusively atARGS_POSTandREQUEST_BODY. Because those fields are empty, the WAF forwards the request cleanly. - Remote Code Execution via Deserialization or Multipart Payloads: When exploiting backend flaws like deserialization or fast-acting RCE chains, the attacker uses HTTP/2 streams without a
Content-Lengthheader. The exploit lands directly in the backend runtime. - Absence of Forensic Alerting: Because the WAF rules evaluate to false, CrowdSec does not generate alerts, does not increment the IPโs threat score in the Local API (LAPI), and does not share attack telemetry with the CrowdSec Consensus Community.
4. Forensic Triage & Threat Hunting
Section titled โ4. Forensic Triage & Threat Huntingโtitle: Potential CrowdSec AppSec WAF Bypass Attempt via Chunked Transfer-Encodingid: cve-2026-44982-crowdsec-bypassstatus: experimentaldescription: Detects inbound POST/PUT requests using Transfer-Encoding chunked targeting web applications, a technique used to evade CrowdSec AppSec body inspection prior to v1.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: - Legitimate API clients uploading large streaming media or telemetry batches.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# Test whether AppSec inspects chunked bodies for a known test rule (e.g. 942100 SQLi)curl -v -X POST "https://target-service.domain.internal/login" \ -H "Transfer-Encoding: chunked" \ -H "Content-Type: application/x-www-form-urlencoded" \ --data-binary @- <<EOF0auser=' OR '1'='10
EOF# If the response returns 200 OK without a CrowdSec AppSec 403 block, the node is vulnerable.5. Mitigation & Defensive Hardening Strategy
Section titled โ5. Mitigation & Defensive Hardening Strategyโ-
Upgrade CrowdSec Security Engine: Immediately update all CrowdSec instances to version 1.7.8 or later using the official package repositories:
Terminal window sudo apt-get update && sudo apt-get install --only-upgrade crowdsecsudo systemctl restart crowdsec -
Update Remediation Components: Ensure that remediation bouncers (specifically
crowdsec-nginx-bouncer,crowdsec-openresty-bouncer, and Kubernetes Ingress Controllers) are updated to the latest available releases to support full body buffering. -
Enforce Ingress Reverse Proxy Restrictions: If upgrading CrowdSec requires staging, configure front-facing load balancers (such as Cloudflare or Nginx) to enforce HTTP
Content-Lengthheaders and buffer chunked requests before handing them off to internal microservices:# Disable chunked transfer-encoding pass-through on sensitive APIsclient_max_body_size 10M;chunked_transfer_encoding on; # Ensure Nginx re-buffers before forwarding