Jul 29, 2026·5 min read·30 visits
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.
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.
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.
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.
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: closeWhen 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.
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 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.
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:N/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
openhole bablilayoub | <= 0.1.1 | 0.1.2 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-22 |
| Attack Vector | Network |
| CVSS v3.1 | 8.6 |
| EPSS Score | N/A |
| Impact | Confidentiality (High) |
| Exploit Status | Proof-of-Concept |
| KEV Status | Not Listed |
Improper limitation of a pathname to a restricted directory, allowing path traversal.
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.
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.
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.
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.
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.
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.