/

CVE-2026-30970

Severity:

CRITICAL RISK

(9.1)

Missing Authorization in Coral Server

CVE-2026-30970

Analyzed

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-862

Impact:

Unauthorized Resource Consumption and Potential Denial of Service

Severity:

CRITICAL RISK

(9.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

Coral Server exposed an unauthenticated /api/v1/sessions endpoint that allowed arbitrary agent session creation without strong authorization checks.

An attacker who can reach this endpoint may trigger resource-intensive initialization, including container spawning and memory context setup, leading to unauthorized usage and potential denial of service.

Affected context

This vulnerability affects Coral Server deployments that expose the /api/v1/sessions endpoint to networks where untrusted or partially trusted clients can reach it.

It is most relevant in environments where Coral Server is accessible over the internet or shared infrastructure, and where session creation initiates costly backend operations such as container startup and memory context initialization.

The issue assumes that the endpoint can be invoked without prior robust authentication or fine-grained authorization tied to a specific principal.

Exploit preconditions

  • Attack surface: HTTP/HTTPS API surface at /api/v1/sessions.
  • Required access: Network reachability to the Coral Server API; no valid credentials or tokens are strictly required under the vulnerable behavior.
  • Trigger point: Sending a request that initiates a new agent session via the session creation endpoint.
  • Why exploitation is possible: The endpoint lacks sufficient authorization enforcement (CWE-862), so it does not verify that the calling party is allowed to create sessions or consume the associated backend resources.

Why this happens

The underlying flaw is the absence of mandatory authorization checks on a high-impact control action: creating new agent sessions.

In an authorization-aware design, operations that spawn containers, allocate memory contexts, or otherwise consume significant compute resources must be gated behind authentication and permission validation tied to a user, agent, or service identity.

Instead, the /api/v1/sessions endpoint effectively treated any caller as authorized, conflating network reachability with permission to act.

This maps to CWE-862: Missing Authorization, where security-sensitive operations are exposed without verifying that the requester is entitled to perform them.

Potential impact

  • Unauthenticated creation of arbitrary agent sessions.
  • Excessive consumption of CPU, memory, and storage resources due to repeated container spawning and context initialization.
  • Degradation of service quality or complete denial of service for legitimate users.
  • Increased operational costs from unplanned resource utilization.
  • Potential abuse of the platform as a free compute backend for malicious or unauthorized workloads.

General mitigation guidance

Effective mitigation centers on enforcing strong authorization around session lifecycle APIs and constraining resource usage:

  • Require robust authentication (e.g., API keys, OAuth tokens, mutual TLS) for all session-creating endpoints, and validate identity before performing any heavy initialization.
  • Implement fine-grained authorization checks that explicitly bind session creation rights to specific roles, tenants, or service accounts.
  • Introduce rate limiting and per-identity quotas on session creation to cap resource consumption even for authorized clients.
  • Apply defense-in-depth controls such as maximum concurrent sessions per identity, global caps, and back-pressure when the system is under load.
  • Design the API so that expensive initialization is deferred until after authorization has been conclusively established and basic request validation passes.
  • Run backend container orchestration and memory management under least-privilege principles so that abuse of one endpoint has limited blast radius.

How teams detect issues like this

Organizations can use a combination of static, dynamic, and operational techniques to detect similar authorization gaps:

  • Static analysis & code review:
  • Look for controller or handler methods (e.g., /sessions, /login, /spawn, /create) that do not invoke a common authorization middleware or policy check.
  • Flag routes that perform container orchestration, process spawning, or high-cost operations without checking a principal, role, or tenant context.
  • Review authentication/authorization filters to ensure they are applied to all mutating and resource-intensive endpoints by default.
  • Policy enforcement:
  • Adopt API gateway rules that require valid authentication for all non-read-only endpoints.
  • Enforce security-as-code policies (e.g., OpenAPI + policy lints) that disallow unprotected endpoints that create sessions or allocate compute.
  • Runtime monitoring:
  • Monitor session creation metrics and alert on spikes, especially from anonymous or unauthenticated sources.
  • Inspect logs for repeated access to session-related endpoints from the same IPs or networks without corresponding authentication events.
  • Automated API security testing tools can also probe for unauthenticated access to sensitive endpoints as part of CI/CD pipelines.

Sources

SourceLink
github.comgithub.com/Coral-Protocol/coral-server/releases/tag/v1.1.0
github.comgithub.com/Coral-Protocol/coral-server/security/advisories/GHSA-wqfm-hhqf-9hgp

Frequently asked

questions

Yes, if Coral Server is exposed over the network and the /api/v1/sessions endpoint is reachable from untrusted clients, an attacker can exploit it remotely by issuing session creation requests.

The attacker only needs network access to the vulnerable endpoint; because authorization is missing, no valid user account, agent identity, or token is strictly required to trigger resource-intensive operations.

The safest approach is to enforce strong, centralized authentication and authorization for all session-related endpoints, ensuring that session creation is only permitted for authenticated principals with explicit permissions, and that heavy operations are not performed until after these checks succeed.

Preventive strategies include designing with "deny by default" access control, using standardized auth middleware applied to all non-public endpoints, validating that all state-changing and resource-intensive operations have explicit authorization checks, and enforcing API security policies and automated tests in the development and deployment pipelines.

Find out what's already
exploitable in your codebase.