Summary
Coral Server's Server-Sent Events (SSE) endpoint did not sufficiently verify that a connecting agent was an authorized participant in a given session.
Under weak or missing authorization checks, a malicious agent could potentially inject messages into, or passively observe, SSE streams belonging to other sessions.
Affected context
This vulnerability affects Coral Server deployments that expose the /sse/v1/... endpoint for real-time collaboration between agents.
It is relevant in environments where multiple agents or tenants connect concurrently and where the server relies on session-based participation rules.
The issue manifests when authorization for SSE connections is either absent or not tightly bound to session membership, leaving room for unauthorized agents to attach to an existing session's event stream.
Exploit preconditions
- Attack surface: Network-accessible SSE endpoint at
/sse/v1/.... - Required access: Ability to reach the Coral Server API (e.g., via the same network or API gateway); no guaranteed need for valid session membership if authorization is weak.
- Trigger point: Initiating or hijacking an SSE connection using identifiers or parameters associated with an existing session.
- Why exploitation is possible: The server did not robustly confirm that the connecting client was a legitimate participant in the specific session, so possession or guessing of session-related identifiers could be enough to receive or inject events.
Why this happens
The root cause aligns with CWE-862: Missing Authorization, where the system fails to enforce access control on a sensitive operation.
In this case, establishing an SSE connection for a particular collaboration session was treated as a relatively trustable action, without a strict check that the caller was an authenticated and authorized participant in that session.
This design gap allowed the SSE channel—which can carry sensitive coordination and payment-related events between agents—to be accessed or influenced by agents that should not have had visibility or control.
Potential impact
- Unauthorized observation of real-time collaboration messages between legitimate agents.
- Injection of forged or misleading events into a session's SSE stream.
- Disruption of coordination flows between agents (e.g., causing confusion, race conditions, or incorrect state transitions).
- Potential manipulation of trust or payment-related messages exchanged over the SSE channel.
- Escalation from a single compromised agent to broader compromise of multi-agent workflows.
General mitigation guidance
Mitigation centers on enforcing robust, session-bound authorization for all real-time channels:
- Require strong authentication for every SSE connection, binding it explicitly to an authenticated principal (agent, user, or service account).
- Enforce per-session authorization checks so that only agents recognized as participants in a given session can subscribe to its SSE stream.
- Use opaque, unguessable session identifiers and avoid trusting client-supplied identity or role claims without server-side verification.
- Apply the principle of least privilege so agents only receive events for sessions and scopes they strictly need to access.
- Implement consistent access control logic across all channels (REST, WebSocket, SSE) via centralized middleware or policy engines, rather than bespoke checks per endpoint.
How teams detect issues like this
Effective detection combines design-time review with runtime monitoring:
- Static analysis / code review: Look for SSE and other streaming endpoints that lack explicit authorization middleware or policy checks, particularly those that accept session identifiers from clients.
- Access control review: Verify that the same authorization model used for standard API calls is enforced for long-lived connections like SSE or WebSockets.
- Logging and analytics: Instrument connection attempts with detailed metadata (session ID, agent ID, outcome of authorization) and alert on suspicious patterns such as one agent connecting to many unrelated sessions.
- Security testing: Include SSE endpoints in regular penetration tests and automated API security scans, ensuring that attempts to connect with invalid or foreign session identifiers are rejected.

