/

CVE-2026-45746

Severity:

CRITICAL RISK

(9.0)

Broken Access Control via Session ID (CWE-284) in Termix File Manager

CVE-2026-45746

Modified

Vulnerability type

Category:

Broken Access Control

CWE:

CWE-284, CWE-639

Impact:

Remote Code Execution via Cross-Tenant Session Hijacking

Severity:

CRITICAL RISK

(9.0)

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

Termix's web-based File Manager contained a critical broken access control issue where the backend trusted a client-supplied sessionId without confirming ownership by the authenticated user.

By manipulating this identifier, an attacker could hijack another user's active File Manager session, gaining unauthorized SSH-level access to that user's remote VPS filesystem and enabling arbitrary command execution.

Affected context

This vulnerability arises in Termix deployments where:

  • The File Manager feature is used to manage files over SSH on remote VPS instances
  • Active file management sessions are referenced by a sessionId parameter
  • The backend accepts this sessionId directly from client requests and uses it to bind to an existing session

In such environments, any user with access to the Termix interface could potentially target other users' active File Manager sessions if session identifiers are predictable or discoverable.

Exploit preconditions

  • Attack surface: HTTP(S) endpoints backing the Termix File Manager feature.
  • Required access: Valid access to the Termix application (e.g., as any authenticated user) plus the ability to send crafted requests with manipulated sessionId values.
  • Trigger point: Any File Manager operation (e.g., open directory, read file, write file, upload, execute) that relies on the provided sessionId to attach to an existing SSH-backed session.
  • Why exploitation is possible: The server trusts a client-controlled sessionId without confirming that it belongs to the current authenticated user, leading to horizontal privilege escalation (CWE-639) and broken authorization checks (CWE-284).

Why this happens

The core issue is an authorization design flaw where the backend uses a client-supplied session identifier as the sole basis for binding a request to an internal File Manager/SSH session.

Instead of deriving session ownership from authenticated context (e.g., user ID, server-side session), the code path assumes that any sessionId presented by the client is valid and belongs to the current user.

This maps to CWE-284 (Improper Access Control) and CWE-639 (Authorization Bypass Through User-Controlled Key), where object or session references are exposed and reused without ownership validation, enabling one user to operate on another user's active SSH-backed session.

Potential impact

  • Unauthorized access to another user's remote VPS filesystem through their File Manager session
  • Reading sensitive configuration files, credentials, or application data on the victim's VPS
  • Modifying, uploading, or deleting files on the victim's remote server
  • Executing arbitrary commands or scripts on the victim's VPS via exposed file execution capabilities
  • Pivoting into additional systems if credentials or keys are discovered on the compromised VPS
  • Disruption of services hosted on the affected VPS instances

General mitigation guidance

Effective mitigation focuses on enforcing strict server-side ownership checks and avoiding trust in client-controlled identifiers:

  • Bind File Manager/SSH sessions to the authenticated user identity on the server side and verify that any requested sessionId belongs to the current user before use.
  • Use non-guessable, opaque session identifiers stored and validated server-side, and never rely on them alone for authorization; always combine them with user context and role checks.
  • Centralize authorization logic so all File Manager operations reuse the same, well-reviewed access control layer rather than ad hoc checks per endpoint.
  • Apply least-privilege principles by scoping what each user's File Manager sessions can access, limiting the blast radius if a session is misused.
  • Introduce defense-in-depth controls, such as per-user isolation of SSH credentials and filesystem namespaces, reducing cross-tenant impact if an access control flaw appears.

How teams detect issues like this

Detection efforts can target both code-level anti-patterns and runtime anomalies:

  • Static analysis and code reviews should flag endpoints that:
  • Accept user-controlled identifiers (e.g., sessionId) and use them directly to load resources or sessions.
  • Perform resource lookups without explicit checks tying the resource/session to the authenticated user.
  • Security reviewers can search for patterns where object references (IDs, tokens) are passed from the client to the server and used in queries or lookups without filtering by user identity.
  • Logging and monitoring can track File Manager operations by sessionId, user ID, and target VPS; anomalies such as one user routinely acting on sessions created by another can indicate abuse.
  • Automated API security tests or fuzzers can systematically manipulate IDs in File Manager endpoints to confirm that access is restricted per user scope.

Sources

SourceLink
github.comgithub.com/Termix-SSH/Termix/security/advisories/GHSA-cx2r-843c-vww8

Frequently asked

questions

Yes, if Termix is exposed over the internet and reachable by users, an attacker with network access to the Termix interface can exploit the broken access control remotely by manipulating the sessionId parameter in File Manager requests.

In typical deployments, the attacker needs at least an account or some form of access to the Termix web interface to reach the File Manager endpoints.

Once logged in, they can attempt to guess or enumerate sessionId values and hijack other users' active sessions if no ownership checks are in place.

The safest pattern is to ensure that all resource and session lookups are consistently scoped by the authenticated user identity on the server side.

Any client-supplied identifier such as sessionId must be treated as a hint only and validated against server-side mappings to confirm ownership and permissions before use.

Organizations can prevent similar flaws by adopting a centralized authorization framework, mandating user-bound checks for all resources, and enforcing secure coding guidelines around user-controlled identifiers.

Regular security reviews, automated tests for IDOR and broken access control, and continuous monitoring of authorization logic changes help catch regressions early.

Find out what's already
exploitable in your codebase.