/

CVE-2026-62197

Severity:

HIGH RISK

(8.5)

SSRF via CDP Discovery (CWE-918) in OpenClaw

CVE-2026-62197

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Policy Bypass and Internal Network Access

Severity:

HIGH RISK

(8.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 CDP discovery feature contains a policy enforcement gap that allows connections to WebSocket URLs which should be blocked.

When this feature is enabled, attackers with lower-trust access may be able to pivot through OpenClaw to reach internal or otherwise restricted network destinations.

Affected context

The vulnerability appears in deployments of OpenClaw using versions prior to 2026.6.6, specifically when the browser CDP discovery feature is enabled and configured to discover or connect to WebSocket endpoints.

It becomes relevant in environments where OpenClaw enforces network or WebSocket access policies and is positioned in a way that provides connectivity to internal, segmented, or otherwise restricted destinations.

Exploit preconditions

  • Attack surface: OpenClaw browser CDP discovery mechanism handling WebSocket URLs
  • Required access: Ability for a lower-trust user, tenant, or integration to trigger CDP discovery or supply target URLs
  • Trigger point: Submission or indirect control of WebSocket URLs that pass through the CDP discovery logic
  • Why exploitation is possible: Policy checks that should block certain network destinations are not correctly applied when CDP discovery accepts and connects to blocked WebSocket URLs, resulting in an SSRF-like channel to restricted endpoints

Why this happens

The underlying issue maps to CWE-918: Server-Side Request Forgery (SSRF), where a server-side component initiates outbound network requests based on attacker-influenced input.

In this case, the browser CDP discovery feature appears to accept WebSocket URLs without fully enforcing the same network or policy constraints applied elsewhere, allowing requests to destinations that should be blocked.

Conceptually, this reflects an authorization and policy enforcement gap in a server-originated network client, where URL validation, target filtering, or policy mapping is incomplete or inconsistently applied.

Potential impact

  • Attackers could reach internal or restricted network services that OpenClaw is able to connect to.
  • Sensitive internal APIs, metadata services, or management endpoints may be probed or interacted with.
  • Network segmentation and policy-based isolation can be weakened or bypassed.
  • OpenClaw could be abused as a pivot point for lateral movement or reconnaissance.

General mitigation guidance

Mitigation typically centers on tightening server-side control of outbound connections and normalizing policy enforcement across all discovery and connection paths.

Common defensive patterns include:

  • Applying a single, central policy engine for all outbound URL and WebSocket destinations, including CDP discovery and similar helper features.
  • Implementing strict allowlists for network destinations that CDP discovery can reach, particularly when dealing with dynamic or user-controlled URLs.
  • Normalizing and validating URLs (scheme, host, port) before any connection is initiated, and mapping them through consistent policy checks.
  • Reducing OpenClaw's network reach by running it with minimal necessary connectivity, using network segmentation and firewall rules to constrain potential SSRF paths.
  • Applying least-privilege principles to tenants and integrations, limiting who can influence discovery targets or configure related features.

How teams detect issues like this

Detection approaches generally focus on identifying unexpected outbound connections and weak policy enforcement paths:

  • Static and configuration review: Examine CDP discovery and related modules to ensure they invoke the same policy filters and allowlists used elsewhere; look for any direct socket or WebSocket clients that bypass centralized enforcement.
  • Code review signals: Watch for URL or endpoint parameters flowing from user or tenant input into network clients without clear, centralized validation or policy checks.
  • Logging and monitoring: Instrument detailed logs for CDP discovery operations, capturing destination hosts and policy decisions; alert on connections to internal or disallowed subnets.
  • Network-level monitoring: Use firewall logs, egress proxies, or IDS/IPS to detect OpenClaw-originated traffic to unusual or restricted network segments.
  • Automated tooling: Leverage SAST/DAST or custom linters that flag modules initiating outbound requests based on external input where policy hooks are missing or inconsistent.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-3x84-qq85-fj65
vulncheck.comvulncheck.com/advisories/openclaw-policy-bypass-via-cdp-discovery

Frequently asked

questions

It can be, if a lower-trust user or integration can interact with OpenClaw's CDP discovery interface over the network. The exploitability depends on how that feature is exposed and who can influence the WebSocket URLs being processed.

An attacker typically needs lower-trust access, such as a limited tenant account, API integration, or any role that can trigger or influence browser CDP discovery targets. They do not need direct access to the internal network; they instead leverage OpenClaw's position and connectivity.

The safest pattern is to route all CDP discovery and WebSocket connection logic through a centralized, explicit policy enforcement layer that applies strict allowlists and consistent checks. Any URL or endpoint used by server-side discovery should be normalized, validated, and filtered before connections occur.

Future prevention involves treating any server-initiated network request as untrusted if its target can be influenced externally, enforcing uniform network policies across all features, and including SSRF-focused reviews in design, code review, and automated security testing.

Find out what's already
exploitable in your codebase.