/

CVE-2026-41394

Severity:

HIGH RISK

(8.2)

Missing Authorization in OpenClaw

CVE-2026-41394

Analyzed

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-862

Impact:

Privilege Escalation and Unauthorized Runtime Modification

Severity:

HIGH RISK

(8.2)

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

OpenClaw before 2026.3.31 contains an authentication bypass where certain plugin-auth HTTP routes are exposed with operator-level runtime write scopes but do not enforce authorization checks.

An attacker who can reach these routes over the network can invoke privileged runtime actions intended only for authorized operators, potentially altering system state or configuration without authentication.

Affected context

This vulnerability arises in OpenClaw deployments that expose plugin-auth HTTP routes as part of their operator or administrative interfaces.

The affected context is where these plugin-auth endpoints are reachable over the network (e.g., within a cluster, via a reverse proxy, or directly over HTTP) and are configured or deployed under the assumption that middleware or routing rules will enforce authentication and authorization.

In vulnerable versions, these assumptions do not hold for specific plugin-auth routes, enabling unauthenticated callers to receive operator runtime write scopes.

Exploit preconditions

  • Attack surface: Network-accessible plugin-auth HTTP endpoints on the OpenClaw service.
  • Required access: Ability to send HTTP requests to the affected routes; no valid credentials are required.
  • Trigger point: Invoking vulnerable plugin-auth routes that are incorrectly assigned operator runtime write scopes without verifying the caller's identity or role.
  • Why exploitation is possible: The authorization layer fails to enforce checks on these routes (CWE-862), so endpoints perform privileged actions purely based on reaching the route, rather than on authenticated identity or explicit authorization.

Why this happens

The root cause is a missing authorization control on plugin-auth HTTP routes that are granted operator-level runtime write scopes.

At the design and implementation level, these routes were treated as if they were behind proper authentication and role checks, but the enforcement mechanism is absent or misconfigured for these specific paths.

This maps to CWE-862: Missing Authorization, where the software allows access to privileged functionality without verifying that the user is authorized to access that functionality.

Conceptually, the bug stems from tightly coupling privilege scopes to routes without binding them to authenticated identities, and from inconsistent application of authentication/authorization middleware across administrative endpoints.

Potential impact

  • Unauthenticated modification of runtime configuration or operational state.
  • Execution of privileged operator actions, such as starting, stopping, or modifying components or plugins.
  • Unauthorized deployment or alteration of plugins that could introduce further security risks.
  • Potential disruption of service availability through malicious runtime changes.
  • Escalation from unauthenticated network access to effective operator-level control within the affected OpenClaw instance.

General mitigation guidance

Effective mitigation focuses on enforcing consistent, least-privilege authorization across all operator and plugin-auth routes.

Common defensive patterns include:

  • Ensuring all administrative and plugin-auth endpoints are protected by mandatory authentication and role-based access control, enforced at a central middleware or gateway layer rather than per-endpoint ad hoc checks.
  • Applying the principle of least privilege to runtime scopes so that routes expose only the minimal write capabilities required, and never default to operator-level scopes.
  • Segregating administrative/operator APIs from public or plugin-facing APIs, using separate listeners, paths, or network segments so that they are not accidentally exposed.
  • Implementing security-by-default configurations where new routes are denied or require explicit authorization policies before being exposed.
  • Using defense in depth with network controls (firewalls, service meshes, API gateways) to restrict who can reach operator and plugin-auth endpoints even if application-level checks fail.

How teams detect issues like this

Detection typically involves a combination of code-level and operational reviews:

  • Static analysis and code review: Search for HTTP routes or controllers associated with plugin-auth or operator actions that are not wrapped in authentication/authorization middleware or do not perform explicit access checks. Flag any route that assigns high-privilege scopes without verifying identity or role.
  • Policy enforcement: Use API gateway or service mesh policies that require authentication (e.g., mutual TLS, OAuth2/JWT validation) for all administrative paths, and monitor for exceptions or bypass rules.
  • Configuration and routing audits: Periodically review routing tables, ingress configurations, and plugin registration logic to ensure no privileged endpoints are marked as public or anonymous.
  • Runtime monitoring: Inspect logs for access to plugin-auth routes from unauthenticated or unexpected sources, and alert on privileged actions that lack corresponding authentication events.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/2a1db0c0f1fa375004a95ba0ef030534790a6d47
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-mhgq-xpfq-6r66
vulncheck.comvulncheck.com/advisories/openclaw-unauthorized-operator-scope-access-in-unauthenticated-plugin-auth-routes

Frequently asked

questions

Yes, if the vulnerable OpenClaw plugin-auth routes are reachable over the network (e.g., via a public endpoint, VPN, or internal network), an attacker can exploit them remotely without valid credentials.

The attacker only needs network access to the affected plugin-auth HTTP routes. No prior authentication, valid account, or special capabilities are required beyond being able to send HTTP requests to the exposed service.

The most robust fix is to ensure that all operator and plugin-auth routes are consistently enforced behind strong authentication and role-based authorization, using centralized middleware or an API gateway. Every privileged action should require an authenticated identity and an explicit permission check, and routes should not default to operator-level write scopes.

Prevention strategies include establishing a standard security architecture where administrative endpoints are isolated and always require authentication, enforcing least-privilege access control policies, including authorization checks in coding standards and code review checklists, and using automated tooling to flag any new routes that lack mandatory authentication/authorization decorators or middleware.

Find out what's already
exploitable in your codebase.