CVE-2025-69229: Aiohttp Chunked Message DoS Vulnerability

CVE-2025-69229 Overview

CVE-2025-69229 affects aiohttp, an asynchronous HTTP client/server framework for asyncio and Python. Versions 3.13.2 and earlier mishandle chunked HTTP messages, resulting in excessive blocking CPU consumption when a server receives requests containing a large number of chunks. Applications that invoke request.read() inside an endpoint are exposed, allowing attackers to force the server to spend measurable blocking CPU time (roughly 1 second per request) parsing crafted input. The vulnerability is categorized as an Allocation of Resources Without Limits or Throttling weakness [CWE-770]. Version 3.13.3 addresses the issue.

Critical Impact
Remote unauthenticated attackers can trigger sustained blocking CPU usage on aiohttp servers, degrading availability for concurrent requests and enabling denial-of-service conditions.

Affected Products

aiohttp versions <= 3.13.2
Python applications using aiohttp server components with request.read() in endpoints
Fixed in aiohttp 3.13.3

Discovery Timeline

2026-01-06 - CVE-2025-69229 published to NVD
2026-06-17 - Last updated in NVD database

Technical Details for CVE-2025-69229

Vulnerability Analysis

The flaw resides in the chunked-message processing path within aiohttp/streams.py. When a client sends an HTTP request encoded with many small chunks, the framework tracks each chunk boundary in a Python List[int] and performs linear-time operations across that list. As the number of chunks grows, the aggregate cost of these operations grows super-linearly, blocking the asyncio event loop.

Because asyncio relies on cooperative scheduling, any blocking CPU work in a single request stalls all other coroutines on the same worker. An attacker submitting a single crafted request can therefore delay every other in-flight request. Combined with concurrent attacker connections, this pattern effectively denies service to legitimate clients.

Root Cause

The root cause is missing throttling on chunk-boundary bookkeeping and the use of an inefficient data structure for chunk splits [CWE-770]. The _http_chunk_splits field was implemented as a Python list, and the stream reader did not pause reading based on the number of accumulated chunks. Only byte-level high-water marks were enforced.

Attack Vector

Exploitation requires no authentication or user interaction. An attacker sends an HTTP request with Transfer-Encoding: chunked containing a large number of small chunks toward an endpoint that calls request.read(). The server consumes blocking CPU while assembling and tracking chunk splits, degrading responsiveness for the duration of the request.

python

# Patch: aiohttp/streams.py — switch chunk splits to collections.deque
        self._loop = loop
        self._size = 0
        self._cursor = 0
-        self._http_chunk_splits: Optional[List[int]] = None
+        self._http_chunk_splits: Optional[Deque[int]] = None
        self._buffer: Deque[bytes] = collections.deque()
        self._buffer_offset = 0
        self._eof = False
# Source: https://github.com/aio-libs/aiohttp/commit/dc3170b56904bdf814228fae70a5501a42a6c712

python

# Patch: aiohttp/streams.py — add chunk-count high/low water marks to pause reading
        "_protocol",
        "_low_water",
        "_high_water",
+        "_low_water_chunks",
+        "_high_water_chunks",
        "_loop",
        "_size",
        "_cursor",
# Source: https://github.com/aio-libs/aiohttp/commit/4ed97a4e46eaf61bd0f05063245f613469700229

The first patch replaces the List[int] with a collections.deque, giving O(1) append and pop-left semantics. The second patch introduces chunk-count water marks so the reader pauses when too many chunks accumulate. Together they cap the CPU work attributable to a single request.

Detection Methods for CVE-2025-69229

Indicators of Compromise

Inbound HTTP requests with Transfer-Encoding: chunked containing an unusually high number of small chunks from a single source.
Sustained elevated CPU on aiohttp worker processes with a concurrent drop in requests-per-second throughput.
Access logs showing repeated slow-completing requests to endpoints known to call request.read().

Detection Strategies

Inspect network traffic or reverse-proxy logs for chunked requests whose chunk count vastly exceeds payload size (many chunks of a few bytes each).
Alert on aiohttp process event-loop lag using asyncio debug metrics or APM instrumentation.
Correlate spikes in per-request processing time with source IPs to identify abusive clients.

Monitoring Recommendations

Track the version of aiohttp in production inventories and flag any instance at or below 3.13.2.
Monitor connection duration and CPU-per-request percentiles; investigate outliers exceeding 500 ms of blocking time.
Log endpoints that invoke request.read() and prioritize them for rate limiting behind an upstream proxy.

How to Mitigate CVE-2025-69229

Immediate Actions Required

Upgrade aiohttp to version 3.13.3 or later across all server deployments.
Audit application code for endpoints calling request.read() and apply per-endpoint request-size and rate limits.
Place aiohttp services behind a reverse proxy that normalizes or rejects abusive chunked encoding.

Patch Information

The fix ships in aiohttp 3.13.3. Two upstream commits address the issue: GitHub Commit dc3170b5 migrates _http_chunk_splits to collections.deque, and GitHub Commit 4ed97a4 adds chunk-count water marks to pause reading. Full details are available in the GitHub Security Advisory GHSA-g84x-mcqj-x9qq.

Workarounds

Terminate TLS and HTTP at an upstream proxy such as Nginx or Envoy that rebuffers chunked requests before forwarding to aiohttp.
Reject requests exceeding a reasonable chunk count or body size at the proxy layer.
Where feasible, avoid request.read() in favor of streaming iteration with explicit size caps until upgrades are complete.

bash

# Upgrade aiohttp to the patched release
pip install --upgrade 'aiohttp>=3.13.3'

# Verify installed version
python -c "import aiohttp; print(aiohttp.__version__)"