/

CVE-2026-34515

Severity:

HIGH RISK

(7.5)

Information Exposure / Path Traversal in AIOHTTP on Windows

CVE-2026-34515

Analyzed

Vulnerability type

Category:

Information Exposure / Path Traversal

CWE:

CWE-36, CWE-918

Impact:

Information Disclosure of Internal NTLMv2 Remote Paths

Severity:

HIGH RISK

(7.5)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

AIOHTTP's static resource handler on Windows can inadvertently expose information about an NTLMv2 remote path, potentially leaking internal filesystem or network share details.

When serving static content, path handling on Windows may reveal these NTLMv2 remote paths to clients, which can assist attackers in reconnaissance and targeting of internal resources.

Affected context

This vulnerability affects AIOHTTP-based applications running on Windows that use the static resource handler to serve files.

It becomes relevant when:

  • The application is configured to serve static files from locations that may be NTLMv2 remote paths (e.g., UNC paths or network shares).
  • Clients can make HTTP requests to these static endpoints.

Under these conditions, details about the NTLMv2 remote path configuration may be exposed through HTTP responses or error handling, rather than being fully abstracted away by the server.

Exploit preconditions

  • Attack surface: HTTP endpoints served by AIOHTTP's static resource handler on Windows.
  • Required access: Ability to send HTTP requests to the static file routes (typically unauthenticated web access).
  • Trigger point: Requests to static resources that are mapped to or interact with NTLMv2 remote paths (e.g., network shares).
  • Why exploitation is possible: The static handler's path processing and response behavior may reveal internal NTLMv2 remote path details instead of strictly sanitizing or hiding environment-specific configuration data.

Why this happens

The core issue stems from how the static resource handler represents and exposes filesystem paths on Windows when those paths reference NTLMv2 remote locations.

Instead of treating these remote paths as purely internal configuration, the handler may surface them in responses (such as directory listings, error messages, or redirect/normalization behavior).

Conceptually, this maps to:

  • CWE-36 (Path Traversal): Improper handling and normalization of filesystem paths, especially when network or remote paths are involved.
  • CWE-918 (Server-Side Request Forgery): The design pattern resembles SSRF-related problems where server-side access to remote resources can be influenced or revealed, even if in this case the primary issue is information leakage rather than full SSRF.

The abstract insecure pattern is that server-controlled path or network resource information is not fully contained within the server but becomes visible to external clients.

Potential impact

  • Attackers may discover internal NTLMv2 remote path names and structures used by the server.
  • Adversaries could infer details about internal network shares, domains, or hostnames.
  • Information disclosure may aid in lateral movement, targeted phishing, or password guessing against exposed NTLM-related infrastructure.
  • Internal architecture details (such as file server naming conventions or share layout) may be revealed and used to plan further attacks.

General mitigation guidance

Mitigation strategies focus on reducing exposure of internal path information and hardening filesystem mappings:

  • Prefer serving static files from local, application-controlled directories rather than directly from NTLMv2 remote paths or network shares.
  • Introduce an application-level abstraction layer for static file roots so that internal paths are not reflected in HTTP responses, logs returned to the client, or error messages.
  • Configure error handling to avoid returning raw filesystem or share paths to users; provide generic messages instead of detailed path information.
  • Apply strict path normalization and sanitization for static routes, ensuring that the web-visible URL structure is decoupled from platform-specific or network-specific path formats.
  • Use least-privilege principles when configuring access to remote shares, and limit which parts of the filesystem are ever exposed through static handlers.

How teams detect issues like this

Detection typically relies on a combination of code inspection and behavioral testing:

  • Static analysis / code review:
  • Search for use of AIOHTTP's static resource handler configured with UNC paths, network shares, or NTLM-authenticated resources.
  • Review error handling logic to see if raw Path or UNC/NTLMv2 path strings are written into HTTP responses.
  • Dynamic testing:
  • Perform black-box testing of static endpoints, intentionally requesting non-existent or malformed resources and observing whether detailed path information (including remote share names) appears in responses.
  • Use automated scanners or integration tests that flag responses containing patterns typical of Windows network paths (e.g., \\server\share or domain-qualified shares).
  • Policy enforcement:
  • Establish internal guidelines that prohibit exposing direct network share paths via web servers.
  • Employ automated review tools or CI hooks that scan configuration and code for static mappings to remote paths.

Sources

SourceLink
github.comgithub.com/aio-libs/aiohttp/commit/0ae2aa076c84573df83fc1fdc39eec0f5862fe3d
github.comgithub.com/aio-libs/aiohttp/releases/tag/v3.13.4
github.comgithub.com/aio-libs/aiohttp/security/advisories/GHSA-p998-jp59-783m

Frequently asked

questions

Yes, it can generally be exploited remotely by anyone who can reach the affected AIOHTTP static endpoints over HTTP, since it relies on observing how the server responds to requests for static resources.

Typically only network access to the web application's static file routes is required. No prior authentication or system-level access is necessary if those endpoints are publicly exposed.

The safest pattern is to avoid exposing NTLMv2 remote paths directly through the static resource handler. Use local, controlled directories for static content, ensure responses never contain raw internal paths, and introduce abstraction layers so that internal path details remain server-only information.

Adopt a design rule that web-exposed paths are logical URLs, not direct reflections of underlying filesystem or network paths. Combine this with systematic code review for path handling, strict error message sanitization, and configuration policies that discourage serving files directly from sensitive or network-based locations.

Find out what's already
exploitable in your codebase.