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

•17 minutes ago•CVE-2026-91115
8.8

CVE-2026-91115: Remote Code Execution in Silverstripe Framework via i18nTextCollectorTask

CVE-2026-91115 (GHSA-c94f-87xg-65wf) is an unsafe reflection vulnerability in the Silverstripe Framework affecting versions 6.0.0 prior to 6.2.13. The built-in development task i18nTextCollectorTask passes the user-supplied 'writer' parameter directly to Silverstripe's dependency injection container (Injector::inst()->get()) without verifying that the requested class implements the expected Writer interface. Because the dependency injector supports instantiating arbitrary classes with attacker-supplied constructor arguments, and because nested task URLs bypassed interactive confirmation middleware, an attacker can achieve remote code execution via unauthenticated requests on development instances or via Cross-Site Request Forgery (CSRF) against authenticated administrators on production instances.

Amit Schendel
Amit Schendel
1 views•8 min read
•about 1 hour ago•CVE-2026-129237
5.4

CVE-2026-129237: Partial Path Traversal (Zip Slip) in qbee-agent Tar Extractor

CVE-2026-129237 is a partial path traversal (Zip Slip) vulnerability in qbee-agent, the device agent for the qbee.io IoT device management platform. Prior to version 2026.41, the tar archive extraction routine in app/utils/tar.go used strings.HasPrefix without enforcing a directory separator boundary. When the Docker Compose bundle configuration has UseContext enabled, an authenticated user with delegated configuration or file management privileges can supply a crafted tar archive containing sibling-prefix traversal sequences, allowing directory creation and file writes into adjacent sibling directories outside the intended extraction root.

Alon Barad
Alon Barad
2 views•11 min read
•about 2 hours ago•CVE-2026-128118
7.5

CVE-2026-128118: Server-Only Module Guard Bypass and Secret Exposure in SvelteKit

CVE-2026-128118 (GHSA-m9j8-jcmv-hp69) is an information disclosure vulnerability affecting the SvelteKit framework (@sveltejs/kit) from version 3.0.0 through 3.1.0. A design flaw in the build-time Vite module guard plugin (plugin_guard) failed to register src/params.js as a client entry point and implemented a fail-open validation model. Consequently, server-only modules and private environment variables imported directly or dynamically within parameter matchers were compiled into publicly accessible client-side JavaScript bundles without triggering a build error.

Amit Schendel
Amit Schendel
3 views•10 min read
•about 3 hours ago•CVE-2026-128071
6.5

CVE-2026-128071: Route-Rule Authorization Bypass via Encoded Slashes in Nuxt

CVE-2026-128071 is a route-rule authorization bypass and security policy circumvention vulnerability in the Nuxt web framework, affecting `nuxt`, `@nuxt/nitro-server`, and `@nuxt/vite-server` prior to version 4.6.4. Serving as an incomplete fix for GHSA-6gq8-jgmh-3ffp, the flaw arises from an interpretation conflict between Nuxt's route-rule matching logic and Vue Router's catch-all route parameter decoding. When processing an incoming HTTP request containing percent-encoded forward slashes (`%2F` or `%2f`), the route-rule evaluation engine preserves the encoded sequence as a single path segment, failing to match prefix-based rules such as `/admin/**`. However, when the request is subsequently dispatched to a catch-all page route (`app/pages/[...slug].vue`) or a multi-segment parameter handler, the parameters are URL-decoded into literal slash delimiters. This discrepancy allows unauthenticated remote attackers to bypass route-level redirects, authentication middleware (`appMiddleware`), security headers, proxy configurations, and rendering constraints (`ssr: false`, `noScripts`), while the catch-all page resolves and renders the protected resource.

Amit Schendel
Amit Schendel
3 views•11 min read
•about 4 hours ago•CVE-2026-128134
7.8

CVE-2026-128134: Local Code Execution via Untrusted Search Path in NLTK dependencygraph

In Natural Language Toolkit (NLTK) versions prior to 3.10.4, the nltk.parse.dependencygraph.dot2img function resolves the Graphviz dot binary through the system PATH using find_binary('dot') and invokes it directly via subprocess.run() instead of routing execution through nltk.pathsec.spawn_trusted(). This omission bypasses file ownership validation, directory writability checks, and dynamic loader environment scrubbing. On multi-user POSIX systems where a victim's PATH contains a directory writable by a local low-privileged attacker, the attacker can plant a malicious dot binary that executes under the victim's privileges when dependency graphs are rendered.

Amit Schendel
Amit Schendel
2 views•11 min read
•about 5 hours ago•CVE-2026-119790
6.3

CVE-2026-119790: Cross-Request Cache Poisoning and Information Disclosure via Race Condition in Next.js

A race condition in Next.js versions 16.3.0 through 16.4.4 allows cross-request cache poisoning and unauthorized information disclosure across root parameters. When an application invokes the same `'use cache'` function both directly during rendering and wrapped inside `unstable_cache()`, a concurrent `unstable_cache()` request arriving during a cold start cache fill joins the in-flight execution. Because the `unstable_cache()` execution context lacks root parameter tracking, the parameter mismatch verification fails, causing `unstable_cache()` to persist root-parameter-scoped data under a global cache key.

Alon Barad
Alon Barad
5 views•9 min read