/

CVE-2026-10281

Severity:

HIGH RISK

(7.3)

Missing Authentication in Enderfga claw-orchestrator

CVE-2026-10281

Deferred

Vulnerability type

Category:

Missing Authentication

CWE:

CWE-287, CWE-306

Impact:

Unauthorized Remote Access to API Functionality

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 authentication flaw in the EmbeddedServer API endpoint of Enderfga claw-orchestrator up to version 3.5.5 allows remote access to exposed functionality without proper identity checks.

If the embedded API is reachable over the network, an attacker may invoke privileged operations as an anonymous user, potentially impacting availability, configuration, or orchestrated workloads.

Affected context

The vulnerability appears in the EmbeddedServer function within src/embedded-server.ts, affecting the embedded API endpoint exposed by claw-orchestrator.

It is relevant in deployments where:

  • The embedded server is enabled and listening on a network interface
  • The API endpoint is reachable from untrusted networks or shared environments
  • Consumers assume the API is protected by authentication when it is not consistently enforced

In such scenarios, remote callers may be able to interact with APIs that were intended to require authenticated or authorized access.

Exploit preconditions

  • Attack surface: Network-accessible embedded API server exposed by claw-orchestrator.
  • Required access: Ability to send HTTP (or supported protocol) requests to the EmbeddedServer endpoint; no valid credentials required if the vulnerable path is reachable.
  • Trigger point: Directly invoking affected API routes/endpoints that fail to check authentication or session state.
  • Why exploitation is possible: The EmbeddedServer implementation does not consistently enforce authentication or session validation, allowing anonymous requests to perform operations that should require a verified identity.

Why this happens

The core issue is the absence or misapplication of authentication controls around the embedded API surface.

This maps to:

  • CWE-287: Improper Authentication, where the system either does not perform required identity checks or performs them incorrectly.
  • CWE-306: Missing Authentication for Critical Function, where sensitive operations are exposed without any authentication guard.

At an abstract level, the server trusts any incoming request to the affected endpoints, failing to:

  • Verify who the caller is (no credential or token verification), or
  • Centralize and enforce authentication middleware on all critical routes.

This design oversight leaves management or operational APIs accessible to arbitrary remote clients.

Potential impact

  • Remote attackers may invoke administrative or operational API endpoints without authentication.
  • Attackers could modify orchestrator configuration or managed resources, depending on the exposed routes.
  • Orchestrated workloads could be started, stopped, or altered, impacting availability or integrity.
  • System state or sensitive metadata may be disclosed via unauthenticated read endpoints.
  • The orchestrator could be abused as a pivot point to interact with downstream services under its control.

General mitigation guidance

Effective mitigation focuses on enforcing robust, centralized authentication and tightening exposure of embedded services:

  • Introduce mandatory authentication for all embedded API endpoints, using well-vetted schemes (e.g., token-based, mTLS, or session-based) applied via common middleware.
  • Explicitly mark critical operations (configuration changes, orchestration commands, access to sensitive data) as requiring strong authentication and appropriate authorization checks.
  • Restrict the embedded server's network exposure:
  • Bind only to localhost when remote access is not strictly required.
  • Place the service behind an authenticated reverse proxy or API gateway that enforces identity and access policies.
  • Apply least-privilege principles to API capabilities, ensuring that authenticated identities can access only what they truly need.
  • Document security expectations for operators so that embedded endpoints are not inadvertently exposed to untrusted networks.

How teams detect issues like this

Detection generally involves a combination of code-centric and operational techniques:

  • Static analysis & code review:
  • Search for route or handler registrations on the embedded server that omit authentication middleware or guards.
  • Flag endpoints reachable without checks for tokens, sessions, or client certificates.
  • Review security annotations or decorators to confirm they are applied consistently to all critical functions.
  • Configuration & policy checks:
  • Enforce policies that disallow network-facing services without authentication configurations.
  • Scan deployment manifests (e.g., container configs, orchestrator manifests) for embedded services bound to non-local interfaces without a fronting auth layer.
  • Runtime testing:
  • Use automated security tests to attempt unauthenticated access to known endpoints and verify that requests are rejected.
  • Integrate these checks into CI/CD pipelines as regression tests when routes or authentication logic change.
  • Monitoring & logging:
  • Enable detailed access logs for embedded endpoints and alert on suspicious patterns of unauthenticated access.

Sources

SourceLink
github.comgithub.com/Enderfga/claw-orchestrator/
github.comgithub.com/Enderfga/claw-orchestrator/commit/d0b02a800aa0689d9428cc4cc170e0b6589fb2c3
github.comgithub.com/Enderfga/claw-orchestrator/issues/61
github.comgithub.com/Enderfga/claw-orchestrator/releases/tag/v3.5.6
vuldb.comvuldb.com/cve/CVE-2026-10281
vuldb.comvuldb.com/submit/825429
vuldb.comvuldb.com/vuln/367574
vuldb.comvuldb.com/vuln/367574/cti

Frequently asked

questions

Yes, if the embedded API server is reachable over a network from an attacker-controlled host. The flaw specifically concerns remote, unauthenticated access to affected endpoints.

No. The issue arises because certain API functionality can be invoked without any authentication. Network reachability to the embedded server is the primary prerequisite.

Centralize authentication enforcement for all embedded API routes and ensure that critical operations are only accessible after successful identity verification and, where appropriate, authorization checks. Additionally, restrict network exposure of the embedded server to trusted environments.

Adopt a security-by-default approach where all new endpoints require authentication unless explicitly designated public, enforce route registration patterns that require specifying auth policies, include authentication and authorization checks in code review standards, and continuously test for unauthenticated access using automated security tests in CI/CD.

Find out what's already
exploitable in your codebase.