/

CVE-2026-45743

Severity:

HIGH RISK

(8.1)

Broken Session Authorization (CWE-639) in Termix File Manager Endpoints

CVE-2026-45743

Modified

Vulnerability type

Category:

Broken Access Control / Insecure Direct Object Reference

CWE:

CWE-639

Impact:

Unauthorized Remote File Access and Command Execution on Managed SSH Hosts

Severity:

HIGH RISK

(8.1)

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, a web-based server management platform, contains an authorization flaw in 16 file-manager endpoints that fail to verify ownership of SSH sessions identified by sessionId.

An authenticated attacker who can guess or observe another user's active sessionId may gain full file management capabilities on the victim's connected SSH host, including reading, modifying, deleting, downloading, and executing files.

Affected context

The vulnerability arises in Termix deployments where multiple users manage SSH sessions through the web interface.

Affected instances expose file-manager operations via HTTP endpoints that take a sessionId parameter to identify the backend SSH connection.

In vulnerable versions, these endpoints do not reliably confirm that the caller is the owner of the referenced SSH session, enabling cross-session access within the same Termix instance under certain conditions.

Exploit preconditions

  • Attack surface: HTTP(S) API and web UI file-manager endpoints in the Termix application.
  • Required access: Valid authenticated Termix account on the same instance as the target user.
  • Knowledge/guessing requirement: Ability to know, infer, or brute-force a victim's active sessionId value (e.g., through predictable identifiers, observation, logging artifacts, or weak entropy).
  • Trigger point: Sending requests to file-manager endpoints (e.g., read, write, delete, download, execute) that include a victim's sessionId.
  • Why exploitation is possible: The server-side logic authorizes file-manager operations solely based on the provided sessionId, without verifying that the session belongs to the requesting principal, violating object-level authorization expectations.

Why this happens

This is a broken access control issue specifically mapped to CWE-639: Authorization Bypass Through User-Controlled Key.

The application exposes sessionId as an externally controllable identifier for SSH sessions and uses it as the primary key for file-manager operations.

Instead of binding the SSH session to the authenticated user and enforcing that relationship on every request, the server trusts any sessionId value provided by a logged-in user.

This pattern effectively turns sessionId into an insecure direct object reference, allowing attackers to act on resources they do not own whenever they can supply another user's session identifier.

Potential impact

  • Unauthorized reading of files on a victim's connected SSH host.
  • Unauthorized modification, creation, and deletion of files on the victim's host.
  • Unauthorized download of sensitive data from the victim's system through the Termix interface.
  • Execution of files or commands via file-manager-related functionality on the victim's remote host.
  • Potential lateral movement inside the victim's infrastructure if the compromised SSH session has broad privileges.
  • Escalation of impact to data exfiltration, service disruption, or deployment of malicious tools on managed servers.

General mitigation guidance

Effective mitigation focuses on strong per-object authorization and session binding:

  • Bind each SSH sessionId to the authenticated user (or account/tenant) that created it and store this relationship server-side.
  • On every file-manager endpoint, enforce an authorization check that confirms the current user is allowed to operate on the referenced sessionId.
  • Avoid relying solely on client-supplied identifiers for security decisions; treat them as lookups that must be validated against server-side ownership and role rules.
  • Apply least-privilege principles to SSH sessions and file-manager capabilities (e.g., scoping access to specific directories or roles).
  • Centralize access control logic so that adding new endpoints or operations automatically inherits consistent authorization checks.
  • Consider rate limiting and monitoring around sessionId usage to reduce the feasibility of guessing attacks and to surface abnormal patterns.

How teams detect issues like this

Detection can combine code-level review with runtime monitoring:

  • Static analysis / code review:
  • Look for endpoints that accept sessionId or similar identifiers and ensure they perform explicit checks linking the identifier to the authenticated user.
  • Flag patterns where business logic trusts user-controlled keys as the sole condition for accessing resources.
  • Review controller and service methods for shared authorization middleware; endpoints that bypass or duplicate this logic warrant extra scrutiny.
  • Automated tooling:
  • Configure SAST rules to detect common IDOR patterns (e.g., direct use of query/path parameters in data lookups without user scoping).
  • Use DAST or API security scanners to fuzz sessionId parameters and observe whether cross-user access is possible.
  • Operational monitoring:
  • Log file-manager requests along with authenticated user identity and sessionId, and alert on patterns where one user accesses many different session identifiers.
  • Track anomalies such as repeated 4xx/5xx responses when random sessionId values are used, which may indicate probing.

Sources

SourceLink
github.comgithub.com/Termix-SSH/Termix/releases/tag/release-2.3.2-tag
github.comgithub.com/Termix-SSH/Termix/security/advisories/GHSA-5fqh-77cr-jj5x

Frequently asked

questions

Yes, if the Termix instance is exposed over the network (e.g., internet or corporate WAN), any remote attacker with valid Termix credentials could attempt to exploit this issue, provided they can obtain or guess other users' sessionId values.

No. The attacker generally only needs a regular authenticated Termix account. The flaw is in cross-session authorization, so horizontal privilege escalation is possible without elevated roles, though higher-privileged accounts may increase the impact.

The robust fix is to enforce strict object-level authorization by associating each SSH session with its creator (or owning account) and validating this relationship on every file-manager request. All endpoints that accept sessionId must confirm that the current user is authorized to use that session before performing any file operations.

Adopt a security design that treats all client-supplied identifiers as untrusted and enforces centralized authorization checks. Implement consistent access control middleware, conduct regular reviews for IDOR patterns, and include automated tests that verify users cannot act on resources or sessions they do not own.

Find out what's already
exploitable in your codebase.