/

CVE-2026-44211

Severity:

CRITICAL RISK

(9.6)

Cross-Origin WebSocket Hijacking in Cline Kanban Servers

CVE-2026-44211

Analyzed

Vulnerability type

Category:

Cross-Origin WebSocket Hijacking

CWE:

CWE-306, CWE-1385

Impact:

Account Compromise and Unauthorized Actions via WebSocket

Severity:

CRITICAL RISK

(9.6)

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

Cline Kanban servers up to version 2.13.0 suffer from a cross-origin WebSocket hijacking weakness that allows browsers from untrusted origins to open or reuse privileged WebSocket sessions without proper origin or authentication enforcement.

Under the right conditions, a malicious website visited by a user of a vulnerable Cline Kanban deployment could interact with the Kanban backend as that user, potentially issuing unauthorized actions over the WebSocket channel.

Affected context

The vulnerability affects Cline Kanban servers that expose a WebSocket interface to browser clients and do not strictly enforce origin and authentication checks on that channel.

It is relevant where:

  • Users access the Kanban interface via a browser
  • The WebSocket endpoint is reachable from the internet or a shared network
  • The same browser session can reach both the attacker-controlled site and the Kanban server

In such environments, cross-origin requests may end up being treated as trusted traffic by the WebSocket backend.

Exploit preconditions

  • Attack surface: Browser-based WebSocket connection to the Cline Kanban server
  • Required access: Ability to lure a logged-in or network-reachable victim into visiting a malicious web page in a browser that can reach the Kanban server
  • Trigger point: The malicious page initiates or reuses a WebSocket connection to the Kanban endpoint, leveraging the victim's browser context (cookies, session, or network reachability)
  • Why exploitation is possible: The server does not adequately enforce origin checks and/or authentication on the WebSocket handshake, allowing cross-origin scripts to send and receive messages as if they were the legitimate Kanban client

Why this happens

The underlying issue is insufficient enforcement of trust boundaries on WebSocket connections, aligning with CWE-1385: Incorrect WebSocket Origin Validation and related authentication weaknesses such as CWE-306: Missing Authentication for Critical Function.

In affected Cline Kanban servers, the WebSocket handshake and subsequent message handling accept connections without robust verification that:

  • The request originates from an allowed domain, and
  • The caller is properly authenticated for the actions exposed over the WebSocket.

This breaks the same-origin assumptions that many frontends rely on, enabling untrusted web pages to hijack or impersonate legitimate WebSocket clients and perform actions on the Kanban server.

Potential impact

  • An attacker-controlled website could issue commands to the Kanban backend as the victim user
  • Unauthorized viewing or modification of Kanban boards, tasks, or project data may occur
  • Workflow automation or agent actions tied to Kanban events could be triggered maliciously
  • Session riding leading to escalation of privileges if administrative operations are exposed via WebSocket
  • Potential pivot into broader project or source-code environments integrated with Cline Kanban workflows

General mitigation guidance

Effective mitigation focuses on tightening the trust and authentication model around WebSocket endpoints, rather than on specific version updates.

Recommended patterns include:

  • Enforce strict origin checks on WebSocket handshakes: only allow connections from a controlled, allowlisted set of domains
  • Require strong authentication for all sensitive WebSocket operations, binding each connection to a verified user or API token
  • Avoid relying solely on ambient browser credentials (such as cookies) for WebSocket authorization; include explicit, short-lived tokens in the handshake
  • Design WebSocket handlers with least privilege, exposing only the minimal operations needed, and validating authorization server-side for each action
  • Separate internal/administrative WebSocket endpoints from user-facing ones and guard them with additional network or VPN controls
  • Use secure deployment defaults: TLS-only endpoints, restrictive CORS and origin policies at the reverse proxy or gateway layer

How teams detect issues like this

Detection is best approached through both code-level review and runtime analysis:

  • Static analysis & code review:
  • Search for WebSocket upgrade routes that lack explicit origin validation and authentication checks
  • Identify handlers that process sensitive operations over WebSocket without per-message authorization
  • Review gateway or reverse-proxy configuration to ensure origin and authentication enforcement on upgrade requests
  • Security testing:
  • Perform manual or automated browser-based tests to open WebSockets to the Kanban server from arbitrary origins
  • Validate whether cross-origin scripts can successfully send commands and receive sensitive data
  • Monitoring & logging:
  • Log WebSocket connection metadata (origin header, IP, user context) and flag connections from unexpected origins
  • Employ anomaly detection or rules in SIEM pipelines to alert on suspicious WebSocket activity patterns

Sources

SourceLink
github.comgithub.com/cline/cline/security/advisories/GHSA-5c57-rqjx-35g2

Frequently asked

questions

Yes, if the Cline Kanban WebSocket endpoint is reachable from the victim's browser over the network and origin checks are insufficient, a remote attacker hosting a malicious web page can attempt to exploit the issue through the victim's browser.

Not necessarily. If the WebSocket endpoint accepts connections or performs sensitive actions without rigorous authentication, or if it relies solely on browser-managed credentials, an attacker can often ride on the victim's existing session. The exact requirement depends on how authentication and authorization are implemented on the WebSocket layer.

Implement strict origin validation for all WebSocket handshakes and require explicit, verified authentication for every connection and sensitive action. Treat the WebSocket channel as an API surface, with the same level of access control and authorization checks as a REST or RPC endpoint.

Treat real-time channels as first-class security boundaries: design with clear origin allowlists, token-based authentication, per-operation authorization checks, and hard separation between trusted and untrusted network zones. Incorporate these rules into coding standards, automated tests, and static analysis so that any new WebSocket or real-time endpoint is automatically evaluated for origin and authentication enforcement.

Find out what's already
exploitable in your codebase.