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



CVE-2026-54650

CVE-2026-54650: Remote Path Traversal in openhole-server and openhole CLI Client

Alon Barad
Alon Barad
Software Engineer

Jul 29, 2026·5 min read·30 visits

Executive Summary (TL;DR)

A path traversal flaw in the openhole proxy server decodes percent-encoded dot-dot-slash segments and forwards them to the local agent, which executes raw, unauthorized file retrieval requests against local development services.

A critical path traversal vulnerability (CWE-22) in openhole-server version 0.1.1 and earlier allows remote, unauthenticated attackers to traverse directories and access restricted files or endpoints on local backend services exposed via the tunnel proxy. The issue stems from improper handling of decoded URL paths inside the proxy handler, which are then reconstructed and executed literally by the CLI client.

Vulnerability Overview

The openhole suite is an open-source utility designed to expose local development servers to the public internet. This exposure is accomplished by routing traffic through a public-facing gateway to an internal agent running on the developer's local system.

A critical vulnerability exists within openhole-server version 0.1.1 and earlier, classified under CWE-22 (Improper Limitation of a Pathname to a Restricted Directory). The core issue lies in the public proxy component, which fails to preserve raw, percent-encoded request paths when forwarding them to the local agent.

This behavior allows a remote attacker to perform a directory traversal attack against the underlying local services. By submitting specifically crafted requests with percent-encoded directory traversal sequences, the attacker can access restricted resources residing outside the intended document root of the local application.

Root Cause Analysis

To understand the root cause of CVE-2026-54650, one must analyze how Go handles URL parsing in the standard net/http library. When the standard library parses an incoming HTTP request, it populates the r.URL structure with fields that interpret percent-encoding differently.

The r.URL.Path property is designed to represent the decoded or unescaped path string. Consequently, any percent-encoded dot segments (%2e%2e representing ..) and path separators (%2f representing /) are automatically converted back into their literal characters before the handler processes the request.

In internal/server/public_proxy.go, the application assigned the incoming request path directly from r.URL.Path. This architectural choice resulted in the immediate expansion of all percent-encoded directory traversal segments inside the proxy server context. The proxy server subsequently wrapped this normalized path into a JSON-based protocol control message and dispatched it down the tunnel stream.

Code Analysis

An examination of the vulnerable codebase in internal/client/local_proxy.go shows how the client reconstructed the destination URL. The client utilized string formatting with fmt.Sprintf to merge the local host, port, and the decoded path directly into a target string.

// Vulnerable implementation
url := fmt.Sprintf("http://%s:%d%s", host, port, req.Path)

This string formatting step meant that if req.Path contained the literal string /../../etc/passwd, the client requested that exact URL from the local server. The Go HTTP client then transmitted a literal, canonicalized directory traversal request to the local backend service.

The remediation introduced in version 0.1.2 modifies both the server and client components. The server now calls r.URL.EscapedPath(), ensuring that percent-encoded structures remain encoded during transit. The client now properly instantiates a url.URL struct to parse the path safely.

// Patched client implementation
target := &url.URL{
	Scheme: "http",
	Host:   fmt.Sprintf("%s:%d", host, port),
}
httpReq, err := http.NewRequest(req.Method, target.String(), bytes.NewReader(body))
// ...
path := req.Path
if path == "" {
	path = "/"
}
httpReq.URL.RawPath = path
httpReq.URL.Path, err = url.PathUnescape(path)
if err != nil {
	httpReq.URL.Path = path
}

This structured assignment forces Go's HTTP client to output the exact original, percent-encoded string to the downstream local backend service, delegating path canonicalization to the local server instead of validating traversal at the proxy client boundary.

Exploitation Methodology

An attacker begins by identifying a publicly exposed openhole tunnel, represented by a domain such as https://temp-tunnel.openhole.dev. Since the endpoint is accessible over the public internet, no authentication is required to interact with the server interface.

The attacker crafts a custom HTTP GET request targeting the public endpoint. The request includes percent-encoded directory traversal indicators aimed at sensitive operating system files or local configuration assets.

GET /%2e%2e/%2e%2e/%2e%2e/%2e%2e/etc/passwd HTTP/1.1
Host: temp-tunnel.openhole.dev
Connection: close

When the vulnerable public-facing proxy receives this request, it decodes the URI, generating a literal string /../../../../etc/passwd. The proxy encapsulates this string in a WebSocket-based request payload and forwards it down the active tunnel. The local CLI client translates this payload into an active localhost request, triggering file retrieval on the developer's workstation.

Impact Assessment & Security Scope

The primary impact of CVE-2026-54650 is unauthorized read-access to arbitrary files on the local workstation hosting the openhole client. This includes access to source code, environment variables, localized databases, and critical system files.

The CVSS v3.1 base score of 8.6 reflects high severity. Significantly, the Scope metric is evaluated as Changed (S:C). While the vulnerability resides in the internet-facing proxy server, the actual security impact occurs entirely within the security domain of the internal localhost development environment.

Because developers frequently run local databases and backend components with minimized security configurations, exposing these services via an openhole tunnel bypasses perimeter defenses. The vulnerability allows a remote attacker to gain direct access to assets that were otherwise assumed to be shielded behind firewalls or restricted to localized loopback interfaces.

Remediation & Defense-in-Depth

Remediation requires upgrading both the openhole-server and the local openhole CLI agent to version 0.1.2 or higher. The updated software implements rigorous URL parameter formatting, ensuring that raw, percent-encoded values are preserved during routing.

For systems where immediate upgrades are impossible, developers should implement temporary workarounds. These include restricting access to the public proxy via firewall rules or IP address whitelisting, limiting exposure only to authorized external clients.

Additionally, developers should ensure that local development applications do not run with root or administrative privileges. Minimizing system-level access prevents traversal attacks from retrieving highly privileged operating system components if a local application is exposed to malicious input routing.

Fix Analysis (1)

Technical Appendix

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

Affected Systems

openhole-server <= 0.1.1openhole CLI client <= 0.1.1

Affected Versions Detail

Product
Affected Versions
Fixed Version
openhole
bablilayoub
<= 0.1.10.1.2
AttributeDetail
CWE IDCWE-22
Attack VectorNetwork
CVSS v3.18.6
EPSS ScoreN/A
ImpactConfidentiality (High)
Exploit StatusProof-of-Concept
KEV StatusNot Listed

MITRE ATT&CK Mapping

T1083File and Directory Discovery
Discovery
T1005Data from Local System
Collection
CWE-22
Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal')

Improper limitation of a pathname to a restricted directory, allowing path traversal.

Known Exploits & Detection

GitHubVerification tests and proof-of-concept components in test suites

References & Sources

  • [1]openhole GitHub Repository
  • [2]openhole Security Patch Commit

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

•37 minutes ago•CVE-2026-126295
7.1

CVE-2026-126295: Path Traversal and Unconfined File Access in NLTK BllipParser

CVE-2026-126295 (also tracked as GHSA-fg9w-wfp5-j933) is a path confinement bypass vulnerability in the Natural Language Toolkit (NLTK) affecting versions 3.10.0 prior to 3.10.4. The flaw resides in nltk/parse/bllip.py within the BllipParser class and its factory method BllipParser.from_unified_model_dir(). Unlike sibling tool wrappers in NLTK that enforce data-root confinement via the nltk.pathsec module, BllipParser passes caller-supplied filesystem paths directly into the third-party bllipparser native C extension without validation. When an application passes untrusted input as model paths or directories to BllipParser, an attacker can force the native extension to open arbitrary files on the local filesystem. This leads to information disclosure through parser diagnostic oracles, local model tampering via shared directories, and denial of service by hanging worker threads on blocking special files (such as FIFOs or device nodes) or exhausting memory via oversized files.

Amit Schendel
Amit Schendel
1 views•11 min read
•about 2 hours ago•CVE-2026-126300
5.3

CVE-2026-126300: Algorithmic Complexity Denial of Service in NLTK TreebankWordTokenizer.span_tokenize

CVE-2026-126300 (GHSA-ffr9-mgrr-wcvr) is an inefficient algorithmic complexity vulnerability (CWE-407) in the Natural Language Toolkit (NLTK) Python library affecting versions 3.2.5 prior to 3.10.4. The flaw resides in the quote-restoration routine of TreebankWordTokenizer.span_tokenize and NLTKWordTokenizer.span_tokenize, where repeated calls to list.pop(0) over matched quote tokens introduce quadratic O(n^2) time complexity. An unauthenticated remote attacker who supplies input containing long sequences of double-quote characters can exhaust CPU resources and degrade service availability.

Amit Schendel
Amit Schendel
3 views•10 min read
•about 3 hours ago•GHSA-GPWC-27CW-RH9R
5.3

CVE-2026-126301: Quadratic CPU Exhaustion in NLTK LegalitySyllableTokenizer

The Natural Language Toolkit (NLTK) versions 3.6 through 3.10.3 contain an algorithmic complexity vulnerability in the LegalitySyllableTokenizer.tokenize method. When processing tokens composed of continuous runs of vowels, an unguarded string reversal and set membership lookup loop executes in quadratic time relative to the input token length. Remote attackers capable of submitting arbitrary text to applications utilizing this tokenizer can trigger sustained single-core CPU exhaustion and application-level denial of service.

Amit Schendel
Amit Schendel
4 views•10 min read
•about 4 hours ago•CVE-2026-126304
8.7

CVE-2026-126304: Symlink Path Traversal in NLTK YCOECorpusReader

CVE-2026-126304 is a symlink path traversal vulnerability (CWE-59) in the Natural Language Toolkit (NLTK) versions 3.10.0 prior to 3.10.4. The YCOECorpusReader class constructs internal sub-readers for the 'psd' and 'pos' subdirectories using FileSystemPathPointer.join(), which relies exclusively on lexical string-prefix validation rather than canonical path resolution. An attacker who supplies a crafted YCOE corpus containing symbolic links in place of the 'psd' or 'pos' subdirectories can bypass directory confinement and read arbitrary files from sibling corpora or sensitive directories within the NLTK data sandbox.

Amit Schendel
Amit Schendel
6 views•9 min read
•about 5 hours ago•CVE-2026-128077
6.5

CVE-2026-128077: Authorization Bypass via Request Path Desynchronization in Nuxt and @nuxt/nitro-server

CVE-2026-128077 (GHSA-r99w-jh2x-3mg9) is an authorization bypass and interpretation conflict vulnerability affecting Nuxt and its underlying @nuxt/nitro-server package in versions 4.6.0 through 4.6.3. When an incoming HTTP request path begins with a double forward slash (e.g., //x/admin), the WHATWG URL parser within the Nuxt server-side page renderer interprets the initial segment as a network host/authority and resolves the remaining path (/admin) against the application's page router. Because Nitro server middleware, route-scoped serverHandlers, and Nitro routeRules evaluate the unparsed request path (//x/admin), path-based access controls, redirects, and security header policies configured for /admin fail to match and are bypassed.

Amit Schendel
Amit Schendel
5 views•10 min read
•about 6 hours ago•CVE-2026-128084
4.8

CVE-2026-128084: Integer Truncation and SQL Query Truncation in sqlite3-ruby

Prior to version 2.10.2, the sqlite3-ruby gem explicitly cast 64-bit Ruby string lengths (long) to 32-bit signed integers (int) when invoking the underlying SQLite C API. On 64-bit platforms, providing a string of 4 GiB (2^32 bytes) or larger causes integer truncation, instructing SQLite to process only a prefix of the string. This flaw affects SQL query preparation, bound parameter values, and return values from custom Ruby-defined SQL functions and aggregates, allowing trailing SQL clauses such as WHERE restrictions to be silently dropped under specific conditions.

Alon Barad
Alon Barad
5 views•11 min read