/

CVE-2026-15541

Severity:

HIGH RISK

(7.3)

Missing Authorization (CWE-862) in Isaiah Websocket API

CVE-2026-15541

Deferred

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-862, CWE-863

Impact:

Unauthorized Access and Action Execution

Severity:

HIGH RISK

(7.3)

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

A missing authorization flaw in the Isaiah Master Websocket Handler allows manipulation of the Agent argument without proper access checks.

When exposed remotely, this can enable unauthorized clients to perform actions or access data reserved for trusted agents.

Affected context

The vulnerability occurs in deployments of the Isaiah application (up to version 1.36.9) that expose the Master Websocket Handler (Server.Handle in app/server/server/server.go) to remote clients.

It manifests when the Agent parameter is accepted and processed without consistent authorization checks tied to authenticated identities or roles.

Environments that rely on agent identifiers for routing privileged commands or data streams are particularly exposed when these identifiers can be freely manipulated.

Exploit preconditions

  • Attack surface: Remote access to the Master Websocket Handler endpoint.
  • Required access: Ability to establish a websocket connection and control the Agent argument or related request fields.
  • Trigger point: Invocation of Server.Handle where agent-related logic is executed without confirming authorization.
  • Why exploitation is possible: The handler trusts the Agent value and does not consistently enforce permission checks, leading to behavior mapped to CWE-862 (Missing Authorization) and CWE-863 (Incorrect Authorization).

Why this happens

The underlying bug class is improper authorization handling in a central websocket routing function.

The Server.Handle method appears to rely on the Agent argument as a logical identifier or selector but does not consistently verify that the caller is permitted to act as, or on behalf of, that agent.

This aligns with CWE-862: Missing Authorization, where an application performs security-sensitive operations without verifying the user's permissions, and CWE-863: Incorrect Authorization, where checks are incomplete or applied to the wrong subject or resource.

Abstractly, this is an insecure pattern where trust is placed in client-supplied identifiers or context labels instead of deriving permissions from authenticated and validated security principals.

Potential impact

  • Unauthorized access to data or control channels associated with specific agents.
  • Ability to perform privileged operations intended for trusted or internal agents.
  • Impersonation of other agents, leading to data tampering or operational disruption.
  • Expansion of attack paths within the application by abusing misrouted websocket messages.

General mitigation guidance

Effective mitigation focuses on enforcing robust, consistent authorization around agent-based operations.

Common defensive patterns include:

  • Deriving agent identity and permissions from authenticated session context rather than client-supplied parameters.
  • Implementing centralized authorization checks for all websocket handlers, with clear mapping between roles, agents, and allowed actions.
  • Validating that any Agent identifier presented by a client is both authentic and associated with that client's authenticated principal.
  • Applying least-privilege principles so that default websocket connections have minimal capabilities until authorization is explicitly confirmed.
  • Designing handler APIs to minimize reliance on mutable identifiers and to favor server-side assignment of agent context.

How teams detect issues like this

Organizations can detect missing authorization flaws through:

  • Static analysis rules that flag security-sensitive handlers lacking explicit authorization checks.
  • Code review practices that trace agent identifiers from input to privileged operations, confirming that they pass through well-defined authorization gates.
  • Security testing that attempts to manipulate the Agent argument to gain access to other agents' channels or actions.
  • Policy enforcement in CI/CD requiring that all externally accessible websocket endpoints use standardized authentication and authorization middleware.
  • Logging and monitoring of agent-related access patterns to spot anomalies such as one client rapidly assuming multiple distinct agent identities.

Sources

SourceLink
github.comgithub.com/will-moss/isaiah/
github.comgithub.com/will-moss/isaiah/issues/34
github.comgithub.com/will-moss/isaiah/pull/35
vuldb.comvuldb.com/cve/CVE-2026-15541
vuldb.comvuldb.com/submit/855074
vuldb.comvuldb.com/vuln/377891
vuldb.comvuldb.com/vuln/377891/cti

Frequently asked

questions

Exploitability depends on how widely the Master Websocket Handler is exposed and how much privilege is attached to different agents. In internet-facing deployments with privileged agent channels, it can significantly broaden an attacker's reach.

An attacker typically needs only the ability to establish a websocket connection to the affected endpoint and supply or modify the Agent argument. No prior authorization is required if the handler itself does not enforce it.

The safest approach is to enforce centralized, consistent authorization checks for all websocket operations, derive agent identity from authenticated session state, and ensure that each requested action is validated against the caller's permissions.

Prevention involves adopting a clear access-control model, standardizing authentication and authorization middleware for all entry points, avoiding trust in client-supplied identifiers, and incorporating authorization-focused code review and automated analysis into the development lifecycle.

Find out what's already
exploitable in your codebase.