Jul 29, 2026·6 min read·29 visits
Configuring the goshs file server with an empty password causes the SFTP engine to bypass password handler registration. This defaults the underlying gliderlabs/ssh library to NoClientAuth=true, allowing unauthenticated network clients to gain full SFTP access.
A critical authentication bypass vulnerability in the SFTP server module of goshs version 2.1.3 allows remote, unauthenticated attackers to read, write, modify, or delete files on the target hosting environment. This vulnerability is caused by an incomplete logic check during initialization that falls back to a password-less configuration when an empty password string is specified.
goshs is a single-binary, multi-protocol file server designed in Go for developer testing and offensive security operations. The server supports hosting file structures over HTTP, HTTPS, WebDAV, and SFTP. The utility's rapid deployment capability and rich feature set make it a common fixture in environments that require ad-hoc file transfers or staging capabilities.
A critical logic vulnerability exists in the SFTP server module within version 2.1.3. When the server is initialized using basic authentication but configured with an empty password string, the application fails to register any active authentication handler. The service is classified under CWE-306 (Missing Authentication for Critical Function).
The consequence of this registration failure is a complete exposure of the target system's exposed file structure. Because the underlying SSH handler defaults to an unsecured state when no validators are explicitly configured, remote, unauthenticated network entities can successfully establish full SFTP read, write, and deletion permissions. The vulnerability demands no privileged credentials and occurs transparently upon client connection.
The emergence of CVE-2026-62325 is directly linked to an incomplete resolution of its predecessor, CVE-2026-40884. In the prior vulnerability, configuring an empty username (e.g., -b ':password') led to a failed validation check, which left the initialization handlers empty. To remediate this, the developers added a validation check to sanity/checks.go that strictly blocks startup if the configuration string begins with a colon.
However, this sanitization logic only evaluated the prefix of the credential parameter, failing to inspect the trailing structure. As a result, starting the file server with a configuration like -b 'admin:' (valid username but empty password) is accepted by the validation layer. The system parses the configuration into the internal state variables, setting s.Username to "admin" and s.Password to "" (an empty string).
When initializing the SFTP backend inside sftpserver/sftpserver.go, the application executes the following check: if s.Username != "" && s.Password != "". Because s.Password is empty, the logical AND operation fails. Consequently, the program completely skips the registration of sshServer.PasswordHandler.
Because the administrator did not supply authorized keys via -fkf, the PublicKeyHandler also remains unassigned. Under the rules of the third-party SSH framework gliderlabs/ssh, if both authentication callbacks are unassigned, the platform falls back to enabling anonymous access via NoClientAuth = true. This implicit framework-level fallback is the direct source of the authentication bypass.
The critical failure point resides in the conditional initialization logic inside sftpserver/sftpserver.go. The following visual model illustrates the progression from command-line parsing to the unsecured fallback state:
// Vulnerable Code Path: sftpserver/sftpserver.go
// If the password is empty, the block is completely skipped
if s.Username != "" && s.Password != "" {
sshServer.PasswordHandler = func(ctx ssh.Context, password string) bool {
return subtle.ConstantTimeCompare([]byte(ctx.User()), []byte(s.Username)) == 1 && subtle.ConstantTimeCompare([]byte(password), []byte(s.Password)) == 1
}
}In the patched version, the developer modified the logical operator from a conjunct (&&) to a disjunct (||). This modification guarantees that as long as at least one of the variables contains a string, the handler registers.
// Patched Code Path: sftpserver/sftpserver.go
// Changing to logical OR ensures the handler registers and enforces validation
if s.Username != "" || s.Password != "" {
sshServer.PasswordHandler = func(ctx ssh.Context, password string) bool {
return subtle.ConstantTimeCompare([]byte(ctx.User()), []byte(s.Username)) == 1 && subtle.ConstantTimeCompare([]byte(password), []byte(s.Password)) == 1
}
}Under this corrected construction, registering the handler prevents the underlying framework from falling back to NoClientAuth = true. A connecting client must now undergo password validation. For an empty-password configuration, the client must successfully supply an empty password to establish authorization, removing the unauthenticated bypass vector.
Exploitation of CVE-2026-62325 does not require deep memory corruption techniques or payload construction. To successfully execute the bypass, an attacker must identify an exposed goshs instance running version 2.1.3 where the administrator enabled SFTP but passed an empty password configuration.
The attacker initiates standard SSH transport negotiation. During the authentication handshake, the client queries the available authentication mechanisms. Because NoClientAuth is active, the server advertises none as a valid authentication technique.
The exploit script below demonstrates how a connection can be established without providing a password:
#!/usr/bin/env bash
set -euo pipefail
TARGET_HOST="127.0.0.1"
TARGET_PORT="2121"
echo "[*] Attempting unauthenticated connection to SFTP..."
# By enforcing 'none' authentication, we skip password entry entirely
sftp -o StrictHostKeyChecking=no \
-o UserKnownHostsFile=/dev/null \
-o PreferredAuthentications=none \
-P "$TARGET_PORT" \
"admin@$TARGET_HOST" << 'EOF'
ls -la
pwd
EOFIf the server is running in a vulnerable configuration, the directory index of the served directory is immediately returned. The attacker gains full read, write, and command-line execution access within the restricted scope of the file server's working directory.
The impact of this vulnerability is critical for exposed assets. An unauthenticated remote attacker can read every file present in the shared directory structure. In environments where goshs is deployed for administrative tasks or rapid sharing, this exposure can lead to the leaking of software source code, deployment variables, or personal developer credentials.
Because the SFTP server permits modifications, the impact on integrity is also severe. Attackers can upload files, overwrite executable files with malicious payloads, or delete critical resources. If the file server points to sensitive areas of a production host, an attacker can append public keys to local user .ssh/authorized_keys configurations to secure persistent system shells.
While the application does not allow general remote command execution on the host operating system directly through the SFTP interface, the arbitrary write capabilities make lateral escalation highly probable. If goshs runs under highly privileged system user contexts, the server compromise translates directly to a host compromise.
To address this vulnerability, administrators must upgrade all deployed instances of goshs to version v2.1.4 or newer. The update alters the internal logical gates within the SFTP server code to ensure that a handler is consistently defined when partial credential structures are supplied.
If immediate upgrading is impossible, temporary mitigation requires checking running parameters. Administrators must audit operational scripts and ensure that no trailing colon is present inside the basic authentication configuration flag. For example, replacing -b 'admin:' with -b 'admin:strong_password' immediately forces the system to register the authentication block and eliminates the bypass vector.
For added security, organizations should use network security controls to limit file transfer utilities. Exposing goshs SFTP interfaces (typically port 2121) directly to external WAN IP addresses should be strictly prohibited. Using network address translations or localized VPN access reduces the attack surface and secures the service.
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
goshs goshs-labs | >= 2.1.3, < 2.1.4 | 2.1.4 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-306 |
| Attack Vector | Network |
| CVSS v3.1 Score | 9.1 (Critical) |
| Exploit Status | Proof of Concept (PoC) Available |
| KEV Status | Not Listed |
| Impact | High (Confidentiality and Integrity) |
The application fails to enforce authentication checks on operations requiring authorization, allowing remote users to run operations without credentials.
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.
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.
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.
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.
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.
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.