CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



GHSA-C2M8-H5V5-343R

GHSA-C2M8-H5V5-343R: Path Traversal via Improper Link Resolution in Tornado StaticFileHandler

Amit Schendel
Amit Schendel
Senior Security Researcher

Oct 1, 2026·4 min read·21 visits

Executive Summary (TL;DR)

Tornado's StaticFileHandler prior to 6.5.9 is vulnerable to path traversal and arbitrary file disclosure. By performing lexical validation instead of physical path resolution, the application serves files targeted by symbolic links that point outside the static root.

A path traversal and arbitrary file disclosure vulnerability exists in Tornado's StaticFileHandler. In versions prior to 6.5.9, the handler follows symbolic links that point outside of the configured root static directory. This behavior occurs because the handler performs lexical path validation rather than physical filesystem resolution, allowing unauthenticated remote attackers to read arbitrary files if they can access or control symbolic links within the served static root.

Vulnerability Overview

The affected component is tornado.web.StaticFileHandler, which serves static files from a configured root directory in web applications. It exposes an attack surface by receiving client-controlled path inputs and resolving them against the local filesystem.

The vulnerability is classified as CWE-59 (Improper Link Resolution Before File Access) and CWE-22 (Path Traversal). In vulnerable configurations, if an attacker can access or create a symbolic link inside the configured static root directory, they can traverse boundaries. This allows unauthorized retrieval of arbitrary files from the server's local filesystem.

Root Cause Analysis

The core of the vulnerability lies in the use of lexical resolution instead of physical resolution during path validation. The affected handler validated the absolute path using os.path.abspath, which performs pure string manipulation. Lexical resolution does not query the filesystem to determine whether path elements are symbolic links.

Because os.path.abspath validated that the path was lexically inside the configured root directory, the boundary check succeeded. However, when the file was subsequently opened, the operating system's filesystem resolved the physical symbolic link. This redirection allowed access to files located entirely outside the designated static root directory.

Furthermore, deferring physical resolution created a potential "existence oracle" vulnerability. If physical path resolution occurs after checking if a directory exists, requesting an out-of-bounds directory could cause a redirect (HTTP 301). Requesting a non-existent directory would return a standard error (HTTP 403 or 404), revealing the host layout to the attacker.

Code-Level Patch Analysis

The fix in version 6.5.9 addresses the bug by introducing an explicit physical resolution step during validation. The StaticFileHandler was updated with a new initializer argument named allowed_symlink_directory. This argument defaults to the configured base path but can be expanded manually.

The validation workflow first runs the lexical check, which remains a low-overhead defense against standard relative path traversal attempts. Following this, the method calls _resolve_symlink_target to obtain the physical canonical path using os.path.realpath. This canonical path is verified to ensure it begins with the allowed symlink directory path.

Additionally, the patch replaces multiple filesystem checks with a single-pass os.stat call. This optimization binds the validated path details to a static local state. By preventing multiple lookups during header generation, the code mitigates potential Time of Check to Time of Use (TOCTOU) race conditions.

Exploitation Methodology

Exploitation of this vulnerability requires that a symbolic link pointing outside the static root directory exists inside the static folder. This condition typically occurs in shared multi-tenant filesystems, repositories containing checked-in symlinks, or applications allowing custom file uploads.

An attacker executes the payload by requesting the symlink or a subpath of the symlinked directory over HTTP. The StaticFileHandler receives the path segment and matches it against its routing table. Because the requested URI does not contain direct lexical traversal characters like .., the initial validation steps are bypassed.

When the request finishes processing, the physical file is read and returned to the client. This exposes sensitive system files such as database configurations, application source code, or system credentials.

Remediation and Defensive Mitigations

The primary remediation strategy is upgrading the tornado package to version 6.5.9 or higher. This upgrade implements physical symlink target validation by default. If symlinks are required, administrators must configure allowed_symlink_directory explicitly to safe boundaries.

Operational workarounds include structuring filesystems to disallow symbolic links in directories handled by the static handler. Security teams should also filter user-uploaded archives to block the extraction of symbolic links. Running the application inside an isolated read-only container also restricts filesystem access.

Fix Analysis (2)

Technical Appendix

CVSS Score
7.5/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N

Affected Systems

Tornado web framework StaticFileHandler deployments

Affected Versions Detail

Product
Affected Versions
Fixed Version
Tornado
Tornadoweb
< 6.5.96.5.9
AttributeDetail
CWE IDCWE-59, CWE-22
Attack VectorNetwork
CVSS Score7.5 (High)
ImpactArbitrary File Disclosure
Exploit StatusPoC / Functional (via unit tests)
KEV StatusNot listed

MITRE ATT&CK Mapping

T1190Exploit Public-Facing Application
Initial Access
T1083File and Directory Discovery
Discovery
CWE-59
Improper Link Resolution Before File Access ('Link Following')

The application attempts to access a file based on a filename, but it does not properly validate whether that file is a symbolic link or shortcut that redirects the access to an unintended resource.

References & Sources

  • [1]GitHub Advisory Entry GHSA-C2M8-H5V5-343R
  • [2]Tornado Pull Request #3719
  • [3]Tornado v6.5.9 Release Tag

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•1 day ago•CVE-2026-128087
3.7

CVE-2026-128087: Premature Key Exchange Callback Invocation Prior to Host Key Verification in russh

CVE-2026-128087 (GHSA-9264-jvgf-6w2f) is an incorrect behavior order (CWE-696) and improper authorization (CWE-863) vulnerability in the russh Rust SSH library, affecting versions 0.55.0 through 0.65.0. During the initial SSH key exchange (KEX) handshake, the client state machine invokes the client::Handler::kex_done() callback—providing the negotiated raw shared secret bytes—prior to validating the remote server's host key or certificate via check_server_key(). Consequently, an untrusted or rogue SSH server can complete cryptographic key agreement and force a connecting client to execute side-effecting application logic inside kex_done() before the server's identity is checked and rejected.

Amit Schendel
Amit Schendel
5 views•10 min read
•1 day ago•CVE-2026-128082
7.5

CVE-2026-128082: Uncontrolled Recursion and Denial of Service in AutoMapper via Constructor Parameter Mapping

CVE-2026-128082 (GHSA-6vhm-j9h7-f9gh) is an uncontrolled recursion vulnerability (CWE-674) in AutoMapper, a convention-based object-object mapper for .NET. When mapping nested or self-referential types into destination models that rely on parameterized constructors, C# positional records, or recursive ConstructUsing expressions, AutoMapper evaluates child constructor arguments prior to incrementing the parent's recursion depth counter. This ordering flaw bypasses both explicit MaxDepth limits and the default depth limit of 64. An unauthenticated remote attacker can supply deeply nested input payloads to affected endpoints, exhausting the thread call stack and triggering an uncatchable System.StackOverflowException that terminates the hosting .NET process.

Amit Schendel
Amit Schendel
7 views•11 min read
•1 day ago•CVE-2026-128080
5.8

CVE-2026-128080: Sensitive Query Parameter Disclosure on Incoming Server Spans in OpenTelemetry JavaScript (@opentelemetry/instrumentation-http)

An information exposure vulnerability in the @opentelemetry/instrumentation-http package for OpenTelemetry JavaScript versions 0.204.0 prior to 0.222.0 causes incoming HTTP server spans to record raw, unredacted query string parameters under the url.query attribute. While outgoing client spans applied built-in and user-configured query parameter redaction, incoming server spans bypassed this sanitization completely, resulting in the transmission of sensitive credentials such as pre-signed cloud URLs and API tokens to external observability backends.

Alon Barad
Alon Barad
7 views•10 min read
•1 day ago•CVE-2026-128089
7.5

CVE-2026-128089: Uncontrolled Resource Consumption in dnspython WKS Record Parser

CVE-2026-128089 is an uncontrolled resource consumption vulnerability in the dnspython toolkit for Python, affecting all versions prior to 2.9.2. When parsing Well-Known Service (WKS) records from text via dns.rdtypes.IN.WKS.WKS.from_text(), the parser fails to validate that numeric service port identifiers fall within the RFC 1035 valid range of 0 through 65535. An attacker capable of supplying untrusted zone files or RDATA text strings containing an arbitrarily large service port integer can force the parser to allocate an unbounded bitmap array using an inefficient linear append loop, resulting in severe CPU exhaustion, application hangs, or Out-Of-Memory (OOM) process termination.

Amit Schendel
Amit Schendel
7 views•10 min read
•1 day ago•CVE-2026-126347
3.1

CVE-2026-126347: Open Redirect via Triple-Slash Redirect Paths in Tornado RedirectHandler

CVE-2026-126347 (GHSA-5cjw-f85j-cv6r) is an open redirect vulnerability (CWE-601) in Tornado, an asynchronous Python networking library and web framework. The flaw resides in tornado.web.RedirectHandler when dynamic URL redirection templates incorporate unvalidated user input. Due to a parser differential between RFC 3986 (used by Python's urllib.parse.urlsplit) and the WHATWG URL Standard (used by modern web browsers), inputs containing three or more leading slashes bypass Tornado 6.6.0's validation logic, allowing unauthenticated attackers to redirect users to arbitrary external domains.

Alon Barad
Alon Barad
8 views•11 min read
•1 day ago•CVE-2026-128123
5.9

CVE-2026-128123: Uncaught Exception and Denial of Service in SvelteKit @sveltejs/adapter-node

A Denial of Service (DoS) vulnerability exists in @sveltejs/adapter-node versions 5.5.7 and 6.0.0-next.0 through 6.0.0. When a SvelteKit server route returns a direct response from a fetch() call with a Content-Type of text/event-stream, the Node.js adapter attempts to mutate the response headers to disable proxy buffering. Because headers returned directly by the WHATWG Fetch API carry an immutable guard, this mutation throws an unhandled TypeError, terminating the underlying Node.js process and denying service to all active and subsequent clients.

Alon Barad
Alon Barad
7 views•9 min read