/

CVE-2026-24469

Severity:

HIGH RISK

(7.5)

Path Traversal in C++ HTTP Server Request Handler

CVE-2026-24469

Awaiting Analysis

Vulnerability type

Category:

Path Traversal

CWE:

CWE-22

Impact:

Arbitrary File Read

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

C++ HTTP Server versions 1.0 and below contain a path traversal vulnerability in the RequestHandler::handleRequest method that allows attackers to escape the intended web root directory.

By sending crafted HTTP GET requests with ../ sequences in the URL path, a remote, unauthenticated attacker can read arbitrary files that the server process can access on the filesystem.

Affected context

This vulnerability occurs in deployments of C++ HTTP Server (version 1.0 and below) where the server uses RequestHandler::handleRequest to translate URL paths into filesystem paths.

The issue is present when:

  • The server exposes HTTP endpoints that serve files from a configured files_directory
  • The filename is derived directly from the user-controlled URL path segment
  • There is no canonicalization or validation of path components like ../ or absolute paths
  • The server process has filesystem access to sensitive directories outside the intended web root

Exploit preconditions

  • Attack surface: Network-exposed HTTP interface of the C++ HTTP Server
  • Required access: None; exploitation is possible without authentication
  • Trigger point: A crafted HTTP GET request whose path includes directory traversal sequences (e.g., ../) targeting RequestHandler::handleRequest
  • Why exploitation is possible: The server concatenates the user-supplied filename directly with files_directory without sanitizing or normalizing the path, allowing traversal outside the designated content root

Why this happens

The root cause aligns with CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal').

The RequestHandler::handleRequest method constructs a filesystem path by directly appending a user-controlled filename variable to a trusted base directory (files_directory).

Because the implementation does not normalize the path, reject traversal tokens (../), or enforce that the resolved path remains inside the intended root, attackers can supply specially crafted paths that navigate to parent directories and access files that were never meant to be exposed over HTTP.

Potential impact

  • Reading configuration files that may contain credentials, keys, or internal endpoints
  • Accessing system files that can reveal OS, user, and environment information
  • Disclosure of application source code, templates, or scripts
  • Exposure of log files that may contain sensitive operational or user data
  • Gathering information that facilitates further attacks, such as privilege escalation or lateral movement

General mitigation guidance

Effective mitigation centers on strictly controlling how URL paths map to filesystem paths and treating all user input as untrusted.

Common defensive patterns include:

  • Normalizing and canonicalizing filesystem paths before access, then verifying that the resolved path remains within the configured files_directory
  • Explicitly rejecting any request paths that contain traversal sequences (../, ..\, or encoded equivalents) or absolute-path indicators
  • Using high-level, whitelisted resource mapping (e.g., mapping logical resource names to known files) instead of exposing direct filesystem paths
  • Enforcing least privilege for the server process so it cannot read highly sensitive system or application files even if traversal is attempted
  • Separating publicly served content into a dedicated directory with restricted and predictable contents

How teams detect issues like this

Detection can focus on both code-level review and runtime monitoring:

  • Static analysis: Look for patterns where user-controlled URL segments are concatenated with filesystem paths without validation or canonicalization; flag direct use of ../ in path handling logic
  • Code review: Examine request handlers and routing layers for direct string concatenation between request paths and filesystem paths; ensure there is a clear check that resolved paths stay within the allowed directory
  • Automated tooling: Use SAST tools or security linters configured with rules for CWE-22 to identify unvalidated path construction in C++ codebases
  • Runtime monitoring: Analyze HTTP access logs for suspicious paths containing ../ or encoded traversal patterns, especially if they result in 200 responses; integrate WAF rules that detect and block traversal attempts

Sources

SourceLink
github.comgithub.com/frustratedProton/http-server/security/advisories/GHSA-qp54-6gfq-3gff

Frequently asked

questions

It is broadly exploitable wherever the C++ HTTP Server (v1.0 and below) is reachable over the network, because no authentication is required and the vulnerable handler is part of normal HTTP request processing.

No. A remote attacker can exploit the issue over HTTP without credentials by sending crafted GET requests containing directory traversal sequences in the URL path.

The safest pattern is to canonicalize the requested path, verify that the resolved path remains strictly within the intended root directory, and reject any request that attempts to break out of that directory, while avoiding direct concatenation of raw user input into filesystem paths.

Treat all path components derived from user input as untrusted, use centralized helper functions for safe path resolution, apply allowlists for accessible resources, and incorporate static analysis and security-focused code review to catch unsafe path handling early in development.

Find out what's already
exploitable in your codebase.