/

CVE-2026-32025

Severity:

HIGH RISK

(7.5)

Authentication Throttling and Brute-Force Protection

CVE-2026-32025

Analyzed

Vulnerability type

Category:

Authentication Throttling and Brute-Force Protection Weakness

CWE:

CWE-307

Impact:

Unauthorized Operator Access via Credential Brute Force

Severity:

HIGH RISK

(7.5)

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's browser-origin WebSocket clients contain an authentication hardening gap that allows attackers to bypass origin checks and rate limiting on loopback deployments.

By luring a user to a malicious webpage, an attacker can brute-force gateway credentials in the background and potentially obtain an authenticated operator session to invoke control-plane methods.

Affected context

This vulnerability manifests in OpenClaw deployments where browser-based WebSocket clients talk to a gateway service, particularly over loopback (localhost-style) configurations.

In such setups, origin checks and authentication throttling are not consistently enforced, leaving the gateway exposed to scripted login attempts initiated from a user's browser session.

The risk is most pronounced when:

  • The gateway is reachable from a user's browser (e.g., local management UI, loopback-bound admin endpoints)
  • The same credentials protect sensitive control-plane methods
  • Users can be enticed into visiting untrusted web content while the gateway is accessible.

Exploit preconditions

  • Attack surface: Browser-accessible WebSocket gateway endpoint used for authentication and operator interactions.
  • Required attacker capability: Ability to host or control a malicious webpage and convince a user to open it (e.g., phishing, malicious link).
  • Network/location requirements: The victim's browser must be able to reach the OpenClaw gateway (commonly via loopback or local network).
  • Trigger point: The malicious page establishes WebSocket connections from the victim's browser to the gateway and repeatedly attempts logins.
  • Why exploitation is possible: Origin checks can be bypassed and authentication throttling is ineffective in the affected browser/WebSocket context, allowing high-volume or targeted password guessing without appropriate blocking or delay.

Why this happens

The underlying issue is an insufficient enforcement of authentication-hardening controls—specifically rate limiting and origin validation—on a sensitive WebSocket authentication surface.

In loopback deployments, the gateway implicitly trusts connections from the browser without robust origin verification and does not apply stringent throttling or lockout logic to repeated failed logins.

This aligns with CWE-307: Improper Restriction of Excessive Authentication Attempts, where authentication endpoints fail to adequately limit repeated attempts, enabling brute-force strategies to be executed from a user's browser against local administrative services.

Potential impact

  • An attacker may obtain valid operator credentials through automated password guessing.
  • A compromised operator session could allow invocation of control-plane methods and administrative APIs.
  • Attackers could modify configurations, policies, or routing behavior managed by the gateway.
  • Successful compromise might facilitate lateral movement into connected systems or further privilege escalation in the environment.

General mitigation guidance

Mitigation focuses on enforcing strong, context-aware authentication controls on WebSocket-based gateway endpoints, even in loopback scenarios.

Useful defensive patterns include:

  • Applying strict rate limiting, exponential backoff, and account lockout policies on repeated failed authentication attempts, regardless of client origin.
  • Enforcing robust origin and CSRF-style protections for browser-initiated WebSocket connections, minimizing implicit trust in loopback or local origins.
  • Segmenting operator interfaces from general user-facing endpoints and binding administrative surfaces to dedicated interfaces or higher-assurance authentication mechanisms.
  • Requiring strong, unique operator credentials and preferably multi-factor authentication for control-plane access.
  • Designing gateway components with "secure by default" settings that treat browser-origin requests as untrusted unless explicitly hardened.

How teams detect issues like this

Detection generally involves monitoring authentication flows and reviewing gateway access patterns:

  • Log analysis: Track failed login attempts, especially high-frequency sequences from loopback or local browser-origin sessions, and alert on anomalous authentication patterns.
  • Rate-limit verification: Implement tests or automated checks that simulate repeated failed WebSocket logins to ensure throttling, delays, or lockouts are enforced.
  • Static and configuration review: Examine authentication middleware and WebSocket gateway configuration for:
  • Missing or relaxed rate limits.
  • Lack of origin checks or insufficient browser-context protections.
  • Shared authentication endpoints exposed to both user and operator roles.
  • Policy enforcement: Integrate security linters or configuration analyzers in CI/CD pipelines to flag endpoints that terminate authentication without adequate brute-force protections.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/c736f11a16d6bc27ea62a0fe40fffae4cb071fdb
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-jmmg-jqc7-5qf4
vulncheck.comvulncheck.com/advisories/openclaw-password-brute-force-via-browser-origin-websocket-authentication-bypass

Frequently asked

questions

It can be, but only indirectly. The attacker's traffic originates from the victim's browser, so the gateway must be reachable from that browser (for example via loopback or local network). The attacker typically needs to lure the victim into visiting a malicious page rather than directly connecting to the gateway themselves.

No. The vulnerability concerns the lack of effective throttling and origin protections for failed authentication attempts. The attacker can start from no knowledge of the password and rely on repeated guesses executed by the victim's browser.

Enforce strict brute-force mitigation (rate limiting, lockout, and backoff) on all authentication flows, including WebSocket-based ones, and do not treat loopback or browser-origin traffic as inherently trusted. Combine this with strong origin validation and separation of administrative endpoints.

Treat every authentication surface (REST, WebSocket, or otherwise) as exposed to untrusted automation, design with explicit rate-limiting and abuse controls from the outset, and regularly test those controls. Additionally, adopt a threat model that includes drive-by browser attacks against local services and incorporate origin/CSRF protections accordingly.

Find out what's already
exploitable in your codebase.