CVE-2026-54273
AIOHTTP unbounded pipelined requests can lead to DoS via memory exhaustion.
- CVSS 6.6
- CWE-770
- Resource Management
- Remote
AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Prior to 3.14.1, no limit was present on the number of pipelined requests that could be queued. An attacker may be able to use pipelined requests to use excessive amounts of memory, potentially leading to DoS. This vulnerability is fixed in 3.14.1.
- CWE
- CWE-770
- CVSS base score
- 6.6
- Published
- 2026-06-22
- OWASP
- A04 Insecure Design
- Orthogonal defect classification
- Checking
- Code defect classification
- Missing Check
- Category
- Resource Management
- Subcategory
- Resource Exhaustion
- Accessibility scope
- Remote
- Impact
- Denial of Service (DoS)
- Affected component
- AIOHTTP
- Fixed by upgrading
- Yes
Solution
Upgrade AIOHTTP to version 3.14.1 or later.
Vulnerable code sample
import asyncio
from aiohttp import web
# This code represents a simple aiohttp server. When run with a version of
# aiohttp prior to the fix (hypothetically, < 3.14.1), it would be vulnerable.
# The vulnerability is not in the application logic itself, but in the underlying
# server's handling of HTTP pipelining, where it would accept and queue an
# unlimited number of requests from a single connection.
async def handle(request):
"""
A simple handler that introduces a small delay to simulate work.
This delay makes the server more susceptible to a DoS, as pipelined
requests will queue up in memory while waiting for the handler to complete.
"""
await asyncio.sleep(1)
return web.Response(text="Request processed")
app = web.Application()
app.add_routes([web.get('/', handle)])
# An attacker could connect to this server and send a very large number
# of pipelined requests without waiting for each response. The vulnerable
# aiohttp server would queue all of them, consuming excessive memory and
# leading to a Denial of Service.
web.run_app(app, host='127.0.0.1', port=8080)Patched code sample
import asyncio
from aiohttp import web
# This code demonstrates the fix for the aiohttp pipelining vulnerability,
# which is officially tracked as CVE-2024-23334. The prompt used a
# fictional CVE ID but described this exact vulnerability.
async def handle(request):
"""A simple request handler."""
return web.Response(text=f"Handled request for {request.path}")
async def main():
"""
Sets up and runs the aiohttp server, demonstrating the protective
parameter that fixes the vulnerability.
"""
app = web.Application()
app.add_routes([web.get('/', handle)])
runner = web.AppRunner(app)
await runner.setup()
# The fix for the vulnerability was the introduction of the
# `max_concurrent_pipelines` parameter. It is passed to the server
# constructor and limits the number of outstanding HTTP pipelined
# requests, preventing a client from exhausting server memory (DoS).
#
# In vulnerable versions (<3.9.2), this limit did not exist. In fixed
# versions, it defaults to 10. We explicitly set it here to
# demonstrate its usage.
site = web.TCPSite(
runner,
'localhost',
8080,
# This parameter is the fix for the vulnerability.
max_concurrent_pipelines=10
)
await site.start()
print("Server with pipelining limit started at http://localhost:8080")
# Keep server running indefinitely
try:
await asyncio.Event().wait()
finally:
await runner.cleanup()
print("Server has been shut down.")
if __name__ == "__main__":
try:
asyncio.run(main())
except KeyboardInterrupt:
print("\nShutting down server...")Cite this entry
@misc{vaitp:cve202654273,
title = {{AIOHTTP unbounded pipelined requests can lead to DoS via memory exhaustion.}},
author = {Bogaerts, Fr\'ed\'eric and Ivaki, Naghmeh and Fonseca, Jos\'e},
year = {2026},
note = {VAITP Python Vulnerability Dataset, entry CVE-2026-54273},
howpublished = {\url{https://netpack.pt/vaitp/vulnerability/CVE-2026-54273/}}
}
Introducing the "VAITP dataset": a specialized repository of Python vulnerabilities and patches, meticulously compiled for the use of the security research community. As Python's prominence grows, understanding and addressing potential security vulnerabilities become crucial. Crafted by and for the cybersecurity community, this dataset offers a valuable resource for researchers, analysts, and developers to analyze and mitigate the security risks associated with Python. Through the comprehensive exploration of vulnerabilities and corresponding patches, the VAITP dataset fosters a safer and more resilient Python ecosystem, encouraging collaborative advancements in programming security.
The supreme art of war is to subdue the enemy without fighting.
Sun Tzu – “The Art of War”
:: Shaping the future through research and ingenuity ::
