Search

Find a vulnerability

Search criteria

    Related vulnerabilities

    BREW-BUMP-MY-VERSION-CVE… (GHSA-F2FP-RGF2-35CP)

    Vulnerability from osv_homebrew – Published: 2026-09-10 18:58 – Updated: 2026-10-26 09:35 – Source website
    VLAI
    Summary
    HTTPX2: Quadratic SSE line buffering can cause CPU denial of service
    Details

    Summary

    HTTPX2's Server-Sent Events (SSE) parser repeatedly copied and rescanned buffered text when a server split one unterminated line across many response chunks. The total work grows quadratically with the length of the line. An attacker-controlled or compromised SSE endpoint can exploit this behavior to consume excessive client CPU.

    Details

    Before version 2.10.0, HTTPX2 combined the complete pending SSE line with each newly received chunk and then scanned the combined text for line separators. If an SSE server sends a long line as many small chunks without a line separator, every chunk causes all previously received text to be copied and scanned again. For n fixed-size chunks, this results in O(n²) processing.

    The behavior affects both httpx2.Client.sse() and httpx2.AsyncClient.sse(). Other response APIs do not use the SSE parsing path.

    Impact

    Applications that consume SSE from an attacker-controlled or compromised endpoint can experience excessive CPU usage. A crafted stream can block a synchronous worker or the asynchronous event loop that is consuming it, degrading availability for other work in that process. Confidentiality and integrity are not affected.

    Mitigation

    Upgrade to HTTPX2 2.10.0 or later. SSE parsing now accumulates incomplete line fragments and combines them only when necessary, making processing linear in the amount of received data. HTTPX2 2.10.0 also limits buffered SSE events to 1 MiB by default through max_event_size.

    If upgrading is not immediately possible, only consume SSE from trusted endpoints and enforce an external size or time budget on the stream.


    {
      "affected": [
        {
          "ecosystem_specific": {
            "fix": "bump",
            "range_state": "fixed",
            "resource": "httpx2",
            "resource_purl": "pkg:pypi/httpx2@2.16.0",
            "upstream_fixed_in": "2.10.0"
          },
          "package": {
            "ecosystem": "Homebrew",
            "name": "bump-my-version",
            "purl": "pkg:brew/bump-my-version"
          },
          "ranges": [
            {
              "events": [
                {
                  "introduced": "1.5.0"
                },
                {
                  "fixed": "1.5.1_1"
                }
              ],
              "type": "ECOSYSTEM"
            }
          ]
        }
      ],
      "database_specific": {
        "confidence": "high",
        "source": "matched",
        "strategy": "registry",
        "upstream_evidence": [
          {
            "ecosystem": "PyPI",
            "key": "pkg:pypi/httpx2@2.16.0",
            "name": "httpx2",
            "resource": "httpx2",
            "strategy": "registry",
            "subject_version": "2.16.0"
          }
        ]
      },
      "details": "### Summary\n\nHTTPX2\u0027s Server-Sent Events (SSE) parser repeatedly copied and rescanned buffered text when a server split one unterminated line across many response chunks. The total work grows quadratically with the length of the line. An attacker-controlled or compromised SSE endpoint can exploit this behavior to consume excessive client CPU.\n\n### Details\n\nBefore version 2.10.0, HTTPX2 combined the complete pending SSE line with each newly received chunk and then scanned the combined text for line separators. If an SSE server sends a long line as many small chunks without a line separator, every chunk causes all previously received text to be copied and scanned again. For `n` fixed-size chunks, this results in O(n\u00b2) processing.\n\nThe behavior affects both `httpx2.Client.sse()` and `httpx2.AsyncClient.sse()`. Other response APIs do not use the SSE parsing path.\n\n### Impact\n\nApplications that consume SSE from an attacker-controlled or compromised endpoint can experience excessive CPU usage. A crafted stream can block a synchronous worker or the asynchronous event loop that is consuming it, degrading availability for other work in that process. Confidentiality and integrity are not affected.\n\n### Mitigation\n\nUpgrade to HTTPX2 2.10.0 or later. SSE parsing now accumulates incomplete line fragments and combines them only when necessary, making processing linear in the amount of received data. HTTPX2 2.10.0 also limits buffered SSE events to 1 MiB by default through `max_event_size`.\n\nIf upgrading is not immediately possible, only consume SSE from trusted endpoints and enforce an external size or time budget on the stream.",
      "id": "BREW-bump-my-version-CVE-2026-84378",
      "modified": "2026-10-26T09:35:16Z",
      "published": "2026-09-10T18:58:22Z",
      "references": [
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/security/advisories/GHSA-f2fp-rgf2-35cp"
        },
        {
          "type": "ADVISORY",
          "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-84378"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/pull/1071"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/pull/1117"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/commit/cbfc0e04ef6507da29ccbb3b9c2e5b23dd693414"
        },
        {
          "type": "PACKAGE",
          "url": "https://github.com/pydantic/httpx2"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/releases/tag/v2.10.0"
        }
      ],
      "schema_version": "1.7.3",
      "severity": [
        {
          "score": "CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H",
          "type": "CVSS_V3"
        }
      ],
      "summary": "HTTPX2: Quadratic SSE line buffering can cause CPU denial of service",
      "upstream": [
        "GHSA-f2fp-rgf2-35cp",
        "CVE-2026-84378",
        "PYSEC-2026-3847"
      ]
    }

    BREW-HATCH-CVE-2026-84378 (GHSA-F2FP-RGF2-35CP)

    Vulnerability from osv_homebrew – Published: 2026-09-10 19:26 – Updated: 2026-10-23 09:20 – Source website
    VLAI
    Summary
    HTTPX2: Quadratic SSE line buffering can cause CPU denial of service
    Details

    Summary

    HTTPX2's Server-Sent Events (SSE) parser repeatedly copied and rescanned buffered text when a server split one unterminated line across many response chunks. The total work grows quadratically with the length of the line. An attacker-controlled or compromised SSE endpoint can exploit this behavior to consume excessive client CPU.

    Details

    Before version 2.10.0, HTTPX2 combined the complete pending SSE line with each newly received chunk and then scanned the combined text for line separators. If an SSE server sends a long line as many small chunks without a line separator, every chunk causes all previously received text to be copied and scanned again. For n fixed-size chunks, this results in O(n²) processing.

    The behavior affects both httpx2.Client.sse() and httpx2.AsyncClient.sse(). Other response APIs do not use the SSE parsing path.

    Impact

    Applications that consume SSE from an attacker-controlled or compromised endpoint can experience excessive CPU usage. A crafted stream can block a synchronous worker or the asynchronous event loop that is consuming it, degrading availability for other work in that process. Confidentiality and integrity are not affected.

    Mitigation

    Upgrade to HTTPX2 2.10.0 or later. SSE parsing now accumulates incomplete line fragments and combines them only when necessary, making processing linear in the amount of received data. HTTPX2 2.10.0 also limits buffered SSE events to 1 MiB by default through max_event_size.

    If upgrading is not immediately possible, only consume SSE from trusted endpoints and enforce an external size or time budget on the stream.


    {
      "affected": [
        {
          "ecosystem_specific": {
            "fix": "bump",
            "range_state": "fixed",
            "resource": "httpx2",
            "resource_purl": "pkg:pypi/httpx2@2.16.0",
            "upstream_fixed_in": "2.10.0"
          },
          "package": {
            "ecosystem": "Homebrew",
            "name": "hatch",
            "purl": "pkg:brew/hatch"
          },
          "ranges": [
            {
              "events": [
                {
                  "introduced": "1.17.1"
                },
                {
                  "fixed": "1.18.0"
                }
              ],
              "type": "ECOSYSTEM"
            }
          ]
        }
      ],
      "database_specific": {
        "confidence": "high",
        "source": "matched",
        "strategy": "registry",
        "upstream_evidence": [
          {
            "ecosystem": "PyPI",
            "key": "pkg:pypi/httpx2@2.16.0",
            "name": "httpx2",
            "resource": "httpx2",
            "strategy": "registry",
            "subject_version": "2.16.0"
          }
        ]
      },
      "details": "### Summary\n\nHTTPX2\u0027s Server-Sent Events (SSE) parser repeatedly copied and rescanned buffered text when a server split one unterminated line across many response chunks. The total work grows quadratically with the length of the line. An attacker-controlled or compromised SSE endpoint can exploit this behavior to consume excessive client CPU.\n\n### Details\n\nBefore version 2.10.0, HTTPX2 combined the complete pending SSE line with each newly received chunk and then scanned the combined text for line separators. If an SSE server sends a long line as many small chunks without a line separator, every chunk causes all previously received text to be copied and scanned again. For `n` fixed-size chunks, this results in O(n\u00b2) processing.\n\nThe behavior affects both `httpx2.Client.sse()` and `httpx2.AsyncClient.sse()`. Other response APIs do not use the SSE parsing path.\n\n### Impact\n\nApplications that consume SSE from an attacker-controlled or compromised endpoint can experience excessive CPU usage. A crafted stream can block a synchronous worker or the asynchronous event loop that is consuming it, degrading availability for other work in that process. Confidentiality and integrity are not affected.\n\n### Mitigation\n\nUpgrade to HTTPX2 2.10.0 or later. SSE parsing now accumulates incomplete line fragments and combines them only when necessary, making processing linear in the amount of received data. HTTPX2 2.10.0 also limits buffered SSE events to 1 MiB by default through `max_event_size`.\n\nIf upgrading is not immediately possible, only consume SSE from trusted endpoints and enforce an external size or time budget on the stream.",
      "id": "BREW-hatch-CVE-2026-84378",
      "modified": "2026-10-23T09:20:47Z",
      "published": "2026-09-10T19:26:02Z",
      "references": [
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/security/advisories/GHSA-f2fp-rgf2-35cp"
        },
        {
          "type": "ADVISORY",
          "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-84378"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/pull/1071"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/pull/1117"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/commit/cbfc0e04ef6507da29ccbb3b9c2e5b23dd693414"
        },
        {
          "type": "PACKAGE",
          "url": "https://github.com/pydantic/httpx2"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/releases/tag/v2.10.0"
        }
      ],
      "schema_version": "1.7.3",
      "severity": [
        {
          "score": "CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H",
          "type": "CVSS_V3"
        }
      ],
      "summary": "HTTPX2: Quadratic SSE line buffering can cause CPU denial of service",
      "upstream": [
        "GHSA-f2fp-rgf2-35cp",
        "CVE-2026-84378",
        "PYSEC-2026-3847"
      ]
    }

    BREW-HERMES-AGENT-CVE-20… (GHSA-F2FP-RGF2-35CP)

    Vulnerability from osv_homebrew – Published: 2026-10-04 11:46 – Updated: 2026-10-27 17:56 – Source website
    VLAI
    Summary
    HTTPX2: Quadratic SSE line buffering can cause CPU denial of service
    Details

    Summary

    HTTPX2's Server-Sent Events (SSE) parser repeatedly copied and rescanned buffered text when a server split one unterminated line across many response chunks. The total work grows quadratically with the length of the line. An attacker-controlled or compromised SSE endpoint can exploit this behavior to consume excessive client CPU.

    Details

    Before version 2.10.0, HTTPX2 combined the complete pending SSE line with each newly received chunk and then scanned the combined text for line separators. If an SSE server sends a long line as many small chunks without a line separator, every chunk causes all previously received text to be copied and scanned again. For n fixed-size chunks, this results in O(n²) processing.

    The behavior affects both httpx2.Client.sse() and httpx2.AsyncClient.sse(). Other response APIs do not use the SSE parsing path.

    Impact

    Applications that consume SSE from an attacker-controlled or compromised endpoint can experience excessive CPU usage. A crafted stream can block a synchronous worker or the asynchronous event loop that is consuming it, degrading availability for other work in that process. Confidentiality and integrity are not affected.

    Mitigation

    Upgrade to HTTPX2 2.10.0 or later. SSE parsing now accumulates incomplete line fragments and combines them only when necessary, making processing linear in the amount of received data. HTTPX2 2.10.0 also limits buffered SSE events to 1 MiB by default through max_event_size.

    If upgrading is not immediately possible, only consume SSE from trusted endpoints and enforce an external size or time budget on the stream.


    {
      "affected": [
        {
          "ecosystem_specific": {
            "fix": "bump",
            "range_state": "fixed",
            "resource": "httpx2",
            "resource_purl": "pkg:pypi/httpx2@2.12.0",
            "upstream_fixed_in": "2.10.0"
          },
          "package": {
            "ecosystem": "Homebrew",
            "name": "hermes-agent",
            "purl": "pkg:brew/hermes-agent"
          },
          "ranges": [
            {
              "events": [
                {
                  "introduced": "0.21.6"
                },
                {
                  "fixed": "0.22.2"
                }
              ],
              "type": "ECOSYSTEM"
            },
            {
              "events": [
                {
                  "introduced": "2026.8.31_1"
                },
                {
                  "last_affected": "2026.9.24"
                }
              ],
              "type": "ECOSYSTEM"
            }
          ]
        }
      ],
      "database_specific": {
        "confidence": "high",
        "source": "matched",
        "strategy": "registry",
        "upstream_evidence": [
          {
            "ecosystem": "PyPI",
            "key": "pkg:pypi/httpx2@2.12.0",
            "name": "httpx2",
            "resource": "httpx2",
            "strategy": "registry",
            "subject_version": "2.12.0"
          }
        ]
      },
      "details": "### Summary\n\nHTTPX2\u0027s Server-Sent Events (SSE) parser repeatedly copied and rescanned buffered text when a server split one unterminated line across many response chunks. The total work grows quadratically with the length of the line. An attacker-controlled or compromised SSE endpoint can exploit this behavior to consume excessive client CPU.\n\n### Details\n\nBefore version 2.10.0, HTTPX2 combined the complete pending SSE line with each newly received chunk and then scanned the combined text for line separators. If an SSE server sends a long line as many small chunks without a line separator, every chunk causes all previously received text to be copied and scanned again. For `n` fixed-size chunks, this results in O(n\u00b2) processing.\n\nThe behavior affects both `httpx2.Client.sse()` and `httpx2.AsyncClient.sse()`. Other response APIs do not use the SSE parsing path.\n\n### Impact\n\nApplications that consume SSE from an attacker-controlled or compromised endpoint can experience excessive CPU usage. A crafted stream can block a synchronous worker or the asynchronous event loop that is consuming it, degrading availability for other work in that process. Confidentiality and integrity are not affected.\n\n### Mitigation\n\nUpgrade to HTTPX2 2.10.0 or later. SSE parsing now accumulates incomplete line fragments and combines them only when necessary, making processing linear in the amount of received data. HTTPX2 2.10.0 also limits buffered SSE events to 1 MiB by default through `max_event_size`.\n\nIf upgrading is not immediately possible, only consume SSE from trusted endpoints and enforce an external size or time budget on the stream.",
      "id": "BREW-hermes-agent-CVE-2026-84378",
      "modified": "2026-10-27T17:56:27Z",
      "published": "2026-10-04T11:46:48Z",
      "references": [
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/security/advisories/GHSA-f2fp-rgf2-35cp"
        },
        {
          "type": "ADVISORY",
          "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-84378"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/pull/1071"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/pull/1117"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/commit/cbfc0e04ef6507da29ccbb3b9c2e5b23dd693414"
        },
        {
          "type": "PACKAGE",
          "url": "https://github.com/pydantic/httpx2"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/releases/tag/v2.10.0"
        }
      ],
      "schema_version": "1.7.3",
      "severity": [
        {
          "score": "CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H",
          "type": "CVSS_V3"
        }
      ],
      "summary": "HTTPX2: Quadratic SSE line buffering can cause CPU denial of service",
      "upstream": [
        "GHSA-f2fp-rgf2-35cp",
        "CVE-2026-84378",
        "PYSEC-2026-3847"
      ]
    }

    BREW-HTTPX2-CVE-2026-84378 (GHSA-F2FP-RGF2-35CP)

    Vulnerability from osv_homebrew – Published: 2026-09-10 19:29 – Updated: 2026-11-18 10:12 – Source website
    VLAI
    Summary
    HTTPX2: Quadratic SSE line buffering can cause CPU denial of service
    Details

    Summary

    HTTPX2's Server-Sent Events (SSE) parser repeatedly copied and rescanned buffered text when a server split one unterminated line across many response chunks. The total work grows quadratically with the length of the line. An attacker-controlled or compromised SSE endpoint can exploit this behavior to consume excessive client CPU.

    Details

    Before version 2.10.0, HTTPX2 combined the complete pending SSE line with each newly received chunk and then scanned the combined text for line separators. If an SSE server sends a long line as many small chunks without a line separator, every chunk causes all previously received text to be copied and scanned again. For n fixed-size chunks, this results in O(n²) processing.

    The behavior affects both httpx2.Client.sse() and httpx2.AsyncClient.sse(). Other response APIs do not use the SSE parsing path.

    Impact

    Applications that consume SSE from an attacker-controlled or compromised endpoint can experience excessive CPU usage. A crafted stream can block a synchronous worker or the asynchronous event loop that is consuming it, degrading availability for other work in that process. Confidentiality and integrity are not affected.

    Mitigation

    Upgrade to HTTPX2 2.10.0 or later. SSE parsing now accumulates incomplete line fragments and combines them only when necessary, making processing linear in the amount of received data. HTTPX2 2.10.0 also limits buffered SSE events to 1 MiB by default through max_event_size.

    If upgrading is not immediately possible, only consume SSE from trusted endpoints and enforce an external size or time budget on the stream.


    {
      "affected": [
        {
          "ecosystem_specific": {
            "fix": "bump",
            "range_state": "fixed",
            "upstream_fixed_in": "2.10.0"
          },
          "package": {
            "ecosystem": "Homebrew",
            "name": "httpx2",
            "purl": "pkg:brew/httpx2"
          },
          "ranges": [
            {
              "events": [
                {
                  "introduced": "2.9.1"
                },
                {
                  "fixed": "2.10.0"
                }
              ],
              "type": "ECOSYSTEM"
            }
          ]
        }
      ],
      "database_specific": {
        "confidence": "high",
        "source": "matched",
        "strategy": "registry",
        "upstream_evidence": [
          {
            "ecosystem": "PyPI",
            "key": "pkg:pypi/httpx2@2.16.2",
            "name": "httpx2",
            "strategy": "registry",
            "subject_version": "2.16.2"
          }
        ]
      },
      "details": "### Summary\n\nHTTPX2\u0027s Server-Sent Events (SSE) parser repeatedly copied and rescanned buffered text when a server split one unterminated line across many response chunks. The total work grows quadratically with the length of the line. An attacker-controlled or compromised SSE endpoint can exploit this behavior to consume excessive client CPU.\n\n### Details\n\nBefore version 2.10.0, HTTPX2 combined the complete pending SSE line with each newly received chunk and then scanned the combined text for line separators. If an SSE server sends a long line as many small chunks without a line separator, every chunk causes all previously received text to be copied and scanned again. For `n` fixed-size chunks, this results in O(n\u00b2) processing.\n\nThe behavior affects both `httpx2.Client.sse()` and `httpx2.AsyncClient.sse()`. Other response APIs do not use the SSE parsing path.\n\n### Impact\n\nApplications that consume SSE from an attacker-controlled or compromised endpoint can experience excessive CPU usage. A crafted stream can block a synchronous worker or the asynchronous event loop that is consuming it, degrading availability for other work in that process. Confidentiality and integrity are not affected.\n\n### Mitigation\n\nUpgrade to HTTPX2 2.10.0 or later. SSE parsing now accumulates incomplete line fragments and combines them only when necessary, making processing linear in the amount of received data. HTTPX2 2.10.0 also limits buffered SSE events to 1 MiB by default through `max_event_size`.\n\nIf upgrading is not immediately possible, only consume SSE from trusted endpoints and enforce an external size or time budget on the stream.",
      "id": "BREW-httpx2-CVE-2026-84378",
      "modified": "2026-11-18T10:12:49Z",
      "published": "2026-09-10T19:29:22Z",
      "references": [
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/security/advisories/GHSA-f2fp-rgf2-35cp"
        },
        {
          "type": "ADVISORY",
          "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-84378"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/pull/1071"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/pull/1117"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/commit/cbfc0e04ef6507da29ccbb3b9c2e5b23dd693414"
        },
        {
          "type": "PACKAGE",
          "url": "https://github.com/pydantic/httpx2"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/releases/tag/v2.10.0"
        }
      ],
      "schema_version": "1.7.3",
      "severity": [
        {
          "score": "CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H",
          "type": "CVSS_V3"
        }
      ],
      "summary": "HTTPX2: Quadratic SSE line buffering can cause CPU denial of service",
      "upstream": [
        "GHSA-f2fp-rgf2-35cp",
        "CVE-2026-84378",
        "PYSEC-2026-3847"
      ]
    }

    BREW-OTERM-CVE-2026-84378 (GHSA-F2FP-RGF2-35CP)

    Vulnerability from osv_homebrew – Published: 2026-09-10 20:19 – Updated: 2026-10-23 08:59 – Source website
    VLAI
    Summary
    HTTPX2: Quadratic SSE line buffering can cause CPU denial of service
    Details

    Summary

    HTTPX2's Server-Sent Events (SSE) parser repeatedly copied and rescanned buffered text when a server split one unterminated line across many response chunks. The total work grows quadratically with the length of the line. An attacker-controlled or compromised SSE endpoint can exploit this behavior to consume excessive client CPU.

    Details

    Before version 2.10.0, HTTPX2 combined the complete pending SSE line with each newly received chunk and then scanned the combined text for line separators. If an SSE server sends a long line as many small chunks without a line separator, every chunk causes all previously received text to be copied and scanned again. For n fixed-size chunks, this results in O(n²) processing.

    The behavior affects both httpx2.Client.sse() and httpx2.AsyncClient.sse(). Other response APIs do not use the SSE parsing path.

    Impact

    Applications that consume SSE from an attacker-controlled or compromised endpoint can experience excessive CPU usage. A crafted stream can block a synchronous worker or the asynchronous event loop that is consuming it, degrading availability for other work in that process. Confidentiality and integrity are not affected.

    Mitigation

    Upgrade to HTTPX2 2.10.0 or later. SSE parsing now accumulates incomplete line fragments and combines them only when necessary, making processing linear in the amount of received data. HTTPX2 2.10.0 also limits buffered SSE events to 1 MiB by default through max_event_size.

    If upgrading is not immediately possible, only consume SSE from trusted endpoints and enforce an external size or time budget on the stream.


    {
      "affected": [
        {
          "ecosystem_specific": {
            "fix": "bump",
            "range_state": "fixed",
            "resource": "httpx2",
            "resource_purl": "pkg:pypi/httpx2@2.16.0",
            "upstream_fixed_in": "2.10.0"
          },
          "package": {
            "ecosystem": "Homebrew",
            "name": "oterm",
            "purl": "pkg:brew/oterm"
          },
          "ranges": [
            {
              "events": [
                {
                  "introduced": "0.20.0"
                },
                {
                  "fixed": "0.24.0"
                }
              ],
              "type": "ECOSYSTEM"
            }
          ]
        }
      ],
      "database_specific": {
        "confidence": "high",
        "source": "matched",
        "strategy": "registry",
        "upstream_evidence": [
          {
            "ecosystem": "PyPI",
            "key": "pkg:pypi/httpx2@2.16.0",
            "name": "httpx2",
            "resource": "httpx2",
            "strategy": "registry",
            "subject_version": "2.16.0"
          }
        ]
      },
      "details": "### Summary\n\nHTTPX2\u0027s Server-Sent Events (SSE) parser repeatedly copied and rescanned buffered text when a server split one unterminated line across many response chunks. The total work grows quadratically with the length of the line. An attacker-controlled or compromised SSE endpoint can exploit this behavior to consume excessive client CPU.\n\n### Details\n\nBefore version 2.10.0, HTTPX2 combined the complete pending SSE line with each newly received chunk and then scanned the combined text for line separators. If an SSE server sends a long line as many small chunks without a line separator, every chunk causes all previously received text to be copied and scanned again. For `n` fixed-size chunks, this results in O(n\u00b2) processing.\n\nThe behavior affects both `httpx2.Client.sse()` and `httpx2.AsyncClient.sse()`. Other response APIs do not use the SSE parsing path.\n\n### Impact\n\nApplications that consume SSE from an attacker-controlled or compromised endpoint can experience excessive CPU usage. A crafted stream can block a synchronous worker or the asynchronous event loop that is consuming it, degrading availability for other work in that process. Confidentiality and integrity are not affected.\n\n### Mitigation\n\nUpgrade to HTTPX2 2.10.0 or later. SSE parsing now accumulates incomplete line fragments and combines them only when necessary, making processing linear in the amount of received data. HTTPX2 2.10.0 also limits buffered SSE events to 1 MiB by default through `max_event_size`.\n\nIf upgrading is not immediately possible, only consume SSE from trusted endpoints and enforce an external size or time budget on the stream.",
      "id": "BREW-oterm-CVE-2026-84378",
      "modified": "2026-10-23T08:59:58Z",
      "published": "2026-09-10T20:19:30Z",
      "references": [
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/security/advisories/GHSA-f2fp-rgf2-35cp"
        },
        {
          "type": "ADVISORY",
          "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-84378"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/pull/1071"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/pull/1117"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/commit/cbfc0e04ef6507da29ccbb3b9c2e5b23dd693414"
        },
        {
          "type": "PACKAGE",
          "url": "https://github.com/pydantic/httpx2"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/releases/tag/v2.10.0"
        }
      ],
      "schema_version": "1.7.3",
      "severity": [
        {
          "score": "CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H",
          "type": "CVSS_V3"
        }
      ],
      "summary": "HTTPX2: Quadratic SSE line buffering can cause CPU denial of service",
      "upstream": [
        "GHSA-f2fp-rgf2-35cp",
        "CVE-2026-84378",
        "PYSEC-2026-3847"
      ]
    }

    BREW-PAPIS-CVE-2026-84378 (GHSA-F2FP-RGF2-35CP)

    Vulnerability from osv_homebrew – Published: 2026-09-10 20:21 – Updated: 2026-11-14 11:55 – Source website
    VLAI
    Summary
    HTTPX2: Quadratic SSE line buffering can cause CPU denial of service
    Details

    Summary

    HTTPX2's Server-Sent Events (SSE) parser repeatedly copied and rescanned buffered text when a server split one unterminated line across many response chunks. The total work grows quadratically with the length of the line. An attacker-controlled or compromised SSE endpoint can exploit this behavior to consume excessive client CPU.

    Details

    Before version 2.10.0, HTTPX2 combined the complete pending SSE line with each newly received chunk and then scanned the combined text for line separators. If an SSE server sends a long line as many small chunks without a line separator, every chunk causes all previously received text to be copied and scanned again. For n fixed-size chunks, this results in O(n²) processing.

    The behavior affects both httpx2.Client.sse() and httpx2.AsyncClient.sse(). Other response APIs do not use the SSE parsing path.

    Impact

    Applications that consume SSE from an attacker-controlled or compromised endpoint can experience excessive CPU usage. A crafted stream can block a synchronous worker or the asynchronous event loop that is consuming it, degrading availability for other work in that process. Confidentiality and integrity are not affected.

    Mitigation

    Upgrade to HTTPX2 2.10.0 or later. SSE parsing now accumulates incomplete line fragments and combines them only when necessary, making processing linear in the amount of received data. HTTPX2 2.10.0 also limits buffered SSE events to 1 MiB by default through max_event_size.

    If upgrading is not immediately possible, only consume SSE from trusted endpoints and enforce an external size or time budget on the stream.


    {
      "affected": [
        {
          "ecosystem_specific": {
            "fix": "bump",
            "range_state": "fixed",
            "resource": "httpx2",
            "resource_purl": "pkg:pypi/httpx2@2.16.0",
            "upstream_fixed_in": "2.10.0"
          },
          "package": {
            "ecosystem": "Homebrew",
            "name": "papis",
            "purl": "pkg:brew/papis"
          },
          "ranges": [
            {
              "events": [
                {
                  "introduced": "0.15.0_5"
                },
                {
                  "fixed": "0.16.0"
                }
              ],
              "type": "ECOSYSTEM"
            }
          ]
        }
      ],
      "database_specific": {
        "confidence": "high",
        "source": "matched",
        "strategy": "registry",
        "upstream_evidence": [
          {
            "ecosystem": "PyPI",
            "key": "pkg:pypi/httpx2@2.16.0",
            "name": "httpx2",
            "resource": "httpx2",
            "strategy": "registry",
            "subject_version": "2.16.0"
          }
        ]
      },
      "details": "### Summary\n\nHTTPX2\u0027s Server-Sent Events (SSE) parser repeatedly copied and rescanned buffered text when a server split one unterminated line across many response chunks. The total work grows quadratically with the length of the line. An attacker-controlled or compromised SSE endpoint can exploit this behavior to consume excessive client CPU.\n\n### Details\n\nBefore version 2.10.0, HTTPX2 combined the complete pending SSE line with each newly received chunk and then scanned the combined text for line separators. If an SSE server sends a long line as many small chunks without a line separator, every chunk causes all previously received text to be copied and scanned again. For `n` fixed-size chunks, this results in O(n\u00b2) processing.\n\nThe behavior affects both `httpx2.Client.sse()` and `httpx2.AsyncClient.sse()`. Other response APIs do not use the SSE parsing path.\n\n### Impact\n\nApplications that consume SSE from an attacker-controlled or compromised endpoint can experience excessive CPU usage. A crafted stream can block a synchronous worker or the asynchronous event loop that is consuming it, degrading availability for other work in that process. Confidentiality and integrity are not affected.\n\n### Mitigation\n\nUpgrade to HTTPX2 2.10.0 or later. SSE parsing now accumulates incomplete line fragments and combines them only when necessary, making processing linear in the amount of received data. HTTPX2 2.10.0 also limits buffered SSE events to 1 MiB by default through `max_event_size`.\n\nIf upgrading is not immediately possible, only consume SSE from trusted endpoints and enforce an external size or time budget on the stream.",
      "id": "BREW-papis-CVE-2026-84378",
      "modified": "2026-11-14T11:55:47Z",
      "published": "2026-09-10T20:21:27Z",
      "references": [
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/security/advisories/GHSA-f2fp-rgf2-35cp"
        },
        {
          "type": "ADVISORY",
          "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-84378"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/pull/1071"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/pull/1117"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/commit/cbfc0e04ef6507da29ccbb3b9c2e5b23dd693414"
        },
        {
          "type": "PACKAGE",
          "url": "https://github.com/pydantic/httpx2"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/releases/tag/v2.10.0"
        }
      ],
      "schema_version": "1.7.3",
      "severity": [
        {
          "score": "CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H",
          "type": "CVSS_V3"
        }
      ],
      "summary": "HTTPX2: Quadratic SSE line buffering can cause CPU denial of service",
      "upstream": [
        "GHSA-f2fp-rgf2-35cp",
        "CVE-2026-84378",
        "PYSEC-2026-3847"
      ]
    }

    BREW-RAPID-MLX-CVE-2026-84378 (GHSA-F2FP-RGF2-35CP)

    Vulnerability from osv_homebrew – Published: 2026-09-10 20:37 – Updated: 2026-11-19 10:42 – Source website
    VLAI
    Summary
    HTTPX2: Quadratic SSE line buffering can cause CPU denial of service
    Details

    Summary

    HTTPX2's Server-Sent Events (SSE) parser repeatedly copied and rescanned buffered text when a server split one unterminated line across many response chunks. The total work grows quadratically with the length of the line. An attacker-controlled or compromised SSE endpoint can exploit this behavior to consume excessive client CPU.

    Details

    Before version 2.10.0, HTTPX2 combined the complete pending SSE line with each newly received chunk and then scanned the combined text for line separators. If an SSE server sends a long line as many small chunks without a line separator, every chunk causes all previously received text to be copied and scanned again. For n fixed-size chunks, this results in O(n²) processing.

    The behavior affects both httpx2.Client.sse() and httpx2.AsyncClient.sse(). Other response APIs do not use the SSE parsing path.

    Impact

    Applications that consume SSE from an attacker-controlled or compromised endpoint can experience excessive CPU usage. A crafted stream can block a synchronous worker or the asynchronous event loop that is consuming it, degrading availability for other work in that process. Confidentiality and integrity are not affected.

    Mitigation

    Upgrade to HTTPX2 2.10.0 or later. SSE parsing now accumulates incomplete line fragments and combines them only when necessary, making processing linear in the amount of received data. HTTPX2 2.10.0 also limits buffered SSE events to 1 MiB by default through max_event_size.

    If upgrading is not immediately possible, only consume SSE from trusted endpoints and enforce an external size or time budget on the stream.


    {
      "affected": [
        {
          "ecosystem_specific": {
            "fix": "bump",
            "range_state": "fixed",
            "resource": "httpx2",
            "resource_purl": "pkg:pypi/httpx2@2.16.2",
            "upstream_fixed_in": "2.10.0"
          },
          "package": {
            "ecosystem": "Homebrew",
            "name": "rapid-mlx",
            "purl": "pkg:brew/rapid-mlx"
          },
          "ranges": [
            {
              "events": [
                {
                  "introduced": "0.11.3"
                },
                {
                  "fixed": "0.12.8"
                }
              ],
              "type": "ECOSYSTEM"
            }
          ]
        }
      ],
      "database_specific": {
        "confidence": "high",
        "source": "matched",
        "strategy": "registry",
        "upstream_evidence": [
          {
            "ecosystem": "PyPI",
            "key": "pkg:pypi/httpx2@2.16.2",
            "name": "httpx2",
            "resource": "httpx2",
            "strategy": "registry",
            "subject_version": "2.16.2"
          }
        ]
      },
      "details": "### Summary\n\nHTTPX2\u0027s Server-Sent Events (SSE) parser repeatedly copied and rescanned buffered text when a server split one unterminated line across many response chunks. The total work grows quadratically with the length of the line. An attacker-controlled or compromised SSE endpoint can exploit this behavior to consume excessive client CPU.\n\n### Details\n\nBefore version 2.10.0, HTTPX2 combined the complete pending SSE line with each newly received chunk and then scanned the combined text for line separators. If an SSE server sends a long line as many small chunks without a line separator, every chunk causes all previously received text to be copied and scanned again. For `n` fixed-size chunks, this results in O(n\u00b2) processing.\n\nThe behavior affects both `httpx2.Client.sse()` and `httpx2.AsyncClient.sse()`. Other response APIs do not use the SSE parsing path.\n\n### Impact\n\nApplications that consume SSE from an attacker-controlled or compromised endpoint can experience excessive CPU usage. A crafted stream can block a synchronous worker or the asynchronous event loop that is consuming it, degrading availability for other work in that process. Confidentiality and integrity are not affected.\n\n### Mitigation\n\nUpgrade to HTTPX2 2.10.0 or later. SSE parsing now accumulates incomplete line fragments and combines them only when necessary, making processing linear in the amount of received data. HTTPX2 2.10.0 also limits buffered SSE events to 1 MiB by default through `max_event_size`.\n\nIf upgrading is not immediately possible, only consume SSE from trusted endpoints and enforce an external size or time budget on the stream.",
      "id": "BREW-rapid-mlx-CVE-2026-84378",
      "modified": "2026-11-19T10:42:42Z",
      "published": "2026-09-10T20:37:33Z",
      "references": [
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/security/advisories/GHSA-f2fp-rgf2-35cp"
        },
        {
          "type": "ADVISORY",
          "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-84378"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/pull/1071"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/pull/1117"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/commit/cbfc0e04ef6507da29ccbb3b9c2e5b23dd693414"
        },
        {
          "type": "PACKAGE",
          "url": "https://github.com/pydantic/httpx2"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/releases/tag/v2.10.0"
        }
      ],
      "schema_version": "1.7.3",
      "severity": [
        {
          "score": "CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H",
          "type": "CVSS_V3"
        }
      ],
      "summary": "HTTPX2: Quadratic SSE line buffering can cause CPU denial of service",
      "upstream": [
        "GHSA-f2fp-rgf2-35cp",
        "CVE-2026-84378",
        "PYSEC-2026-3847"
      ]
    }

    BREW-STRANDS-AGENTS-SOPS… (GHSA-F2FP-RGF2-35CP)

    Vulnerability from osv_homebrew – Published: 2026-09-10 21:05 – Updated: 2026-11-15 10:04 – Source website
    VLAI
    Summary
    HTTPX2: Quadratic SSE line buffering can cause CPU denial of service
    Details

    Summary

    HTTPX2's Server-Sent Events (SSE) parser repeatedly copied and rescanned buffered text when a server split one unterminated line across many response chunks. The total work grows quadratically with the length of the line. An attacker-controlled or compromised SSE endpoint can exploit this behavior to consume excessive client CPU.

    Details

    Before version 2.10.0, HTTPX2 combined the complete pending SSE line with each newly received chunk and then scanned the combined text for line separators. If an SSE server sends a long line as many small chunks without a line separator, every chunk causes all previously received text to be copied and scanned again. For n fixed-size chunks, this results in O(n²) processing.

    The behavior affects both httpx2.Client.sse() and httpx2.AsyncClient.sse(). Other response APIs do not use the SSE parsing path.

    Impact

    Applications that consume SSE from an attacker-controlled or compromised endpoint can experience excessive CPU usage. A crafted stream can block a synchronous worker or the asynchronous event loop that is consuming it, degrading availability for other work in that process. Confidentiality and integrity are not affected.

    Mitigation

    Upgrade to HTTPX2 2.10.0 or later. SSE parsing now accumulates incomplete line fragments and combines them only when necessary, making processing linear in the amount of received data. HTTPX2 2.10.0 also limits buffered SSE events to 1 MiB by default through max_event_size.

    If upgrading is not immediately possible, only consume SSE from trusted endpoints and enforce an external size or time budget on the stream.


    {
      "affected": [
        {
          "ecosystem_specific": {
            "fix": "bump",
            "range_state": "fixed",
            "resource": "httpx2",
            "resource_purl": "pkg:pypi/httpx2@2.16.0",
            "upstream_fixed_in": "2.10.0"
          },
          "package": {
            "ecosystem": "Homebrew",
            "name": "strands-agents-sops",
            "purl": "pkg:brew/strands-agents-sops"
          },
          "ranges": [
            {
              "events": [
                {
                  "introduced": "1.1.3"
                },
                {
                  "fixed": "1.1.3_1"
                }
              ],
              "type": "ECOSYSTEM"
            }
          ]
        }
      ],
      "database_specific": {
        "confidence": "high",
        "source": "matched",
        "strategy": "registry",
        "upstream_evidence": [
          {
            "ecosystem": "PyPI",
            "key": "pkg:pypi/httpx2@2.16.0",
            "name": "httpx2",
            "resource": "httpx2",
            "strategy": "registry",
            "subject_version": "2.16.0"
          }
        ]
      },
      "details": "### Summary\n\nHTTPX2\u0027s Server-Sent Events (SSE) parser repeatedly copied and rescanned buffered text when a server split one unterminated line across many response chunks. The total work grows quadratically with the length of the line. An attacker-controlled or compromised SSE endpoint can exploit this behavior to consume excessive client CPU.\n\n### Details\n\nBefore version 2.10.0, HTTPX2 combined the complete pending SSE line with each newly received chunk and then scanned the combined text for line separators. If an SSE server sends a long line as many small chunks without a line separator, every chunk causes all previously received text to be copied and scanned again. For `n` fixed-size chunks, this results in O(n\u00b2) processing.\n\nThe behavior affects both `httpx2.Client.sse()` and `httpx2.AsyncClient.sse()`. Other response APIs do not use the SSE parsing path.\n\n### Impact\n\nApplications that consume SSE from an attacker-controlled or compromised endpoint can experience excessive CPU usage. A crafted stream can block a synchronous worker or the asynchronous event loop that is consuming it, degrading availability for other work in that process. Confidentiality and integrity are not affected.\n\n### Mitigation\n\nUpgrade to HTTPX2 2.10.0 or later. SSE parsing now accumulates incomplete line fragments and combines them only when necessary, making processing linear in the amount of received data. HTTPX2 2.10.0 also limits buffered SSE events to 1 MiB by default through `max_event_size`.\n\nIf upgrading is not immediately possible, only consume SSE from trusted endpoints and enforce an external size or time budget on the stream.",
      "id": "BREW-strands-agents-sops-CVE-2026-84378",
      "modified": "2026-11-15T10:04:58Z",
      "published": "2026-09-10T21:05:20Z",
      "references": [
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/security/advisories/GHSA-f2fp-rgf2-35cp"
        },
        {
          "type": "ADVISORY",
          "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-84378"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/pull/1071"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/pull/1117"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/commit/cbfc0e04ef6507da29ccbb3b9c2e5b23dd693414"
        },
        {
          "type": "PACKAGE",
          "url": "https://github.com/pydantic/httpx2"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/releases/tag/v2.10.0"
        }
      ],
      "schema_version": "1.7.3",
      "severity": [
        {
          "score": "CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H",
          "type": "CVSS_V3"
        }
      ],
      "summary": "HTTPX2: Quadratic SSE line buffering can cause CPU denial of service",
      "upstream": [
        "GHSA-f2fp-rgf2-35cp",
        "CVE-2026-84378",
        "PYSEC-2026-3847"
      ]
    }

    BREW-YEWTUBE-CVE-2026-84378 (GHSA-F2FP-RGF2-35CP)

    Vulnerability from osv_homebrew – Published: 2026-09-10 21:31 – Updated: 2026-10-04 22:23 – Source website
    VLAI
    Summary
    HTTPX2: Quadratic SSE line buffering can cause CPU denial of service
    Details

    Summary

    HTTPX2's Server-Sent Events (SSE) parser repeatedly copied and rescanned buffered text when a server split one unterminated line across many response chunks. The total work grows quadratically with the length of the line. An attacker-controlled or compromised SSE endpoint can exploit this behavior to consume excessive client CPU.

    Details

    Before version 2.10.0, HTTPX2 combined the complete pending SSE line with each newly received chunk and then scanned the combined text for line separators. If an SSE server sends a long line as many small chunks without a line separator, every chunk causes all previously received text to be copied and scanned again. For n fixed-size chunks, this results in O(n²) processing.

    The behavior affects both httpx2.Client.sse() and httpx2.AsyncClient.sse(). Other response APIs do not use the SSE parsing path.

    Impact

    Applications that consume SSE from an attacker-controlled or compromised endpoint can experience excessive CPU usage. A crafted stream can block a synchronous worker or the asynchronous event loop that is consuming it, degrading availability for other work in that process. Confidentiality and integrity are not affected.

    Mitigation

    Upgrade to HTTPX2 2.10.0 or later. SSE parsing now accumulates incomplete line fragments and combines them only when necessary, making processing linear in the amount of received data. HTTPX2 2.10.0 also limits buffered SSE events to 1 MiB by default through max_event_size.

    If upgrading is not immediately possible, only consume SSE from trusted endpoints and enforce an external size or time budget on the stream.


    {
      "affected": [
        {
          "ecosystem_specific": {
            "fix": "bump",
            "range_state": "fixed",
            "resource": "httpx2",
            "resource_purl": "pkg:pypi/httpx2@2.13.1",
            "upstream_fixed_in": "2.10.0"
          },
          "package": {
            "ecosystem": "Homebrew",
            "name": "yewtube",
            "purl": "pkg:brew/yewtube"
          },
          "ranges": [
            {
              "events": [
                {
                  "introduced": "2.13.1_4"
                },
                {
                  "fixed": "2.13.1_5"
                }
              ],
              "type": "ECOSYSTEM"
            }
          ]
        }
      ],
      "database_specific": {
        "confidence": "high",
        "source": "matched",
        "strategy": "registry",
        "upstream_evidence": [
          {
            "ecosystem": "PyPI",
            "key": "pkg:pypi/httpx2@2.13.1",
            "name": "httpx2",
            "resource": "httpx2",
            "strategy": "registry",
            "subject_version": "2.13.1"
          }
        ]
      },
      "details": "### Summary\n\nHTTPX2\u0027s Server-Sent Events (SSE) parser repeatedly copied and rescanned buffered text when a server split one unterminated line across many response chunks. The total work grows quadratically with the length of the line. An attacker-controlled or compromised SSE endpoint can exploit this behavior to consume excessive client CPU.\n\n### Details\n\nBefore version 2.10.0, HTTPX2 combined the complete pending SSE line with each newly received chunk and then scanned the combined text for line separators. If an SSE server sends a long line as many small chunks without a line separator, every chunk causes all previously received text to be copied and scanned again. For `n` fixed-size chunks, this results in O(n\u00b2) processing.\n\nThe behavior affects both `httpx2.Client.sse()` and `httpx2.AsyncClient.sse()`. Other response APIs do not use the SSE parsing path.\n\n### Impact\n\nApplications that consume SSE from an attacker-controlled or compromised endpoint can experience excessive CPU usage. A crafted stream can block a synchronous worker or the asynchronous event loop that is consuming it, degrading availability for other work in that process. Confidentiality and integrity are not affected.\n\n### Mitigation\n\nUpgrade to HTTPX2 2.10.0 or later. SSE parsing now accumulates incomplete line fragments and combines them only when necessary, making processing linear in the amount of received data. HTTPX2 2.10.0 also limits buffered SSE events to 1 MiB by default through `max_event_size`.\n\nIf upgrading is not immediately possible, only consume SSE from trusted endpoints and enforce an external size or time budget on the stream.",
      "id": "BREW-yewtube-CVE-2026-84378",
      "modified": "2026-10-04T22:23:47Z",
      "published": "2026-09-10T21:31:38Z",
      "references": [
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/security/advisories/GHSA-f2fp-rgf2-35cp"
        },
        {
          "type": "ADVISORY",
          "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-84378"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/pull/1071"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/pull/1117"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/commit/cbfc0e04ef6507da29ccbb3b9c2e5b23dd693414"
        },
        {
          "type": "PACKAGE",
          "url": "https://github.com/pydantic/httpx2"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pydantic/httpx2/releases/tag/v2.10.0"
        }
      ],
      "schema_version": "1.7.3",
      "severity": [
        {
          "score": "CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H",
          "type": "CVSS_V3"
        }
      ],
      "summary": "HTTPX2: Quadratic SSE line buffering can cause CPU denial of service",
      "upstream": [
        "GHSA-f2fp-rgf2-35cp",
        "CVE-2026-84378",
        "PYSEC-2026-3847"
      ]
    }

    CVE-2026-84378 (GCVE-0-2026-84378)

    Vulnerability from cvelistv5 – Published: 2026-09-02 17:54 – Updated: 2026-09-02 19:00
    VLAI
    Title
    HTTPX2: Quadratic SSE line buffering can cause CPU denial of service
    Summary
    HTTPX2 is a next generation HTTP client for Python. From 2.5.0 until 2.10.0, the HTTPX2 Server-Sent Events parser in src/httpx2/httpx2/_sse.py repeatedly copies and rescans buffered text in _SSELineDecoder.decode() when an attacker-controlled or compromised SSE endpoint splits one unterminated line across many response chunks. The behavior affects httpx2.Client.sse() and httpx2.AsyncClient.sse(), and the total processing work grows quadratically with the line length, allowing a crafted stream to consume excessive CPU and block a synchronous worker or asynchronous event loop. This issue is fixed in version 2.10.0.
    SSVC
    Exploitation: none Automatable: no Technical Impact: partial
    CISA Coordinator · CISA-ADP (v2.0.3)
    Decision recorded 2026-09-02 19:00 UTC
    CWE
    • CWE-407 - Inefficient Algorithmic Complexity
    Assigner
    GitHub_M CNA
    Impacted products
    Vendor Product Version
    pydantic httpx2 Affected: >= 2.5.0, < 2.10.0
    Create a notification for this product.
    Show details on NVD website

    {
      "containers": {
        "adp": [
          {
            "metrics": [
              {
                "other": {
                  "content": {
                    "id": "CVE-2026-84378",
                    "options": [
                      {
                        "Exploitation": "none"
                      },
                      {
                        "Automatable": "no"
                      },
                      {
                        "Technical Impact": "partial"
                      }
                    ],
                    "role": "CISA Coordinator",
                    "timestamp": "2026-09-02T19:00:16.905501Z",
                    "version": "2.0.3"
                  },
                  "type": "ssvc"
                }
              }
            ],
            "providerMetadata": {
              "dateUpdated": "2026-09-02T19:00:24.511Z",
              "orgId": "134c704f-9b21-4f2e-91b3-4a467353bcc0",
              "shortName": "CISA-ADP"
            },
            "title": "CISA ADP Vulnrichment"
          }
        ],
        "cna": {
          "affected": [
            {
              "product": "httpx2",
              "vendor": "pydantic",
              "versions": [
                {
                  "status": "affected",
                  "version": "\u003e= 2.5.0, \u003c 2.10.0"
                }
              ]
            }
          ],
          "descriptions": [
            {
              "lang": "en",
              "value": "HTTPX2 is a next generation HTTP client for Python. From 2.5.0 until 2.10.0, the HTTPX2 Server-Sent Events parser in src/httpx2/httpx2/_sse.py repeatedly copies and rescans buffered text in _SSELineDecoder.decode() when an attacker-controlled or compromised SSE endpoint splits one unterminated line across many response chunks. The behavior affects httpx2.Client.sse() and httpx2.AsyncClient.sse(), and the total processing work grows quadratically with the line length, allowing a crafted stream to consume excessive CPU and block a synchronous worker or asynchronous event loop. This issue is fixed in version 2.10.0."
            }
          ],
          "metrics": [
            {
              "cvssV3_1": {
                "attackComplexity": "HIGH",
                "attackVector": "NETWORK",
                "availabilityImpact": "HIGH",
                "baseScore": 5.9,
                "baseSeverity": "MEDIUM",
                "confidentialityImpact": "NONE",
                "integrityImpact": "NONE",
                "privilegesRequired": "NONE",
                "scope": "UNCHANGED",
                "userInteraction": "NONE",
                "vectorString": "CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H",
                "version": "3.1"
              }
            }
          ],
          "problemTypes": [
            {
              "descriptions": [
                {
                  "cweId": "CWE-407",
                  "description": "CWE-407: Inefficient Algorithmic Complexity",
                  "lang": "en",
                  "type": "CWE"
                }
              ]
            }
          ],
          "providerMetadata": {
            "dateUpdated": "2026-09-02T17:54:19.431Z",
            "orgId": "a0819718-46f1-4df5-94e2-005712e83aaa",
            "shortName": "GitHub_M"
          },
          "references": [
            {
              "name": "https://github.com/pydantic/httpx2/security/advisories/GHSA-f2fp-rgf2-35cp",
              "tags": [
                "x_refsource_CONFIRM"
              ],
              "url": "https://github.com/pydantic/httpx2/security/advisories/GHSA-f2fp-rgf2-35cp"
            },
            {
              "name": "https://github.com/pydantic/httpx2/pull/1071",
              "tags": [
                "x_refsource_MISC"
              ],
              "url": "https://github.com/pydantic/httpx2/pull/1071"
            },
            {
              "name": "https://github.com/pydantic/httpx2/pull/1117",
              "tags": [
                "x_refsource_MISC"
              ],
              "url": "https://github.com/pydantic/httpx2/pull/1117"
            },
            {
              "name": "https://github.com/pydantic/httpx2/commit/cbfc0e04ef6507da29ccbb3b9c2e5b23dd693414",
              "tags": [
                "x_refsource_MISC"
              ],
              "url": "https://github.com/pydantic/httpx2/commit/cbfc0e04ef6507da29ccbb3b9c2e5b23dd693414"
            },
            {
              "name": "https://github.com/pydantic/httpx2/releases/tag/v2.10.0",
              "tags": [
                "x_refsource_MISC"
              ],
              "url": "https://github.com/pydantic/httpx2/releases/tag/v2.10.0"
            }
          ],
          "source": {
            "advisory": "GHSA-f2fp-rgf2-35cp",
            "discovery": "UNKNOWN"
          },
          "title": "HTTPX2: Quadratic SSE line buffering can cause CPU denial of service"
        }
      },
      "cveMetadata": {
        "assignerOrgId": "a0819718-46f1-4df5-94e2-005712e83aaa",
        "assignerShortName": "GitHub_M",
        "cveId": "CVE-2026-84378",
        "datePublished": "2026-09-02T17:54:19.431Z",
        "dateReserved": "2026-09-01T16:27:58.130Z",
        "dateUpdated": "2026-09-02T19:00:24.511Z",
        "state": "PUBLISHED"
      },
      "dataType": "CVE_RECORD",
      "dataVersion": "5.2"
    }