/

CVE-2026-43580

Severity:

HIGH RISK

(7.7)

Broken / Missing Authorization in OpenClaw Navigation Guard

CVE-2026-43580

Analyzed

Vulnerability type

Category:

Broken / Missing Authorization

CWE:

CWE-862

Impact:

Unauthorized Navigation and SSRF Policy Bypass

Severity:

HIGH RISK

(7.7)

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 versions prior to 2026.4.10 contain an incomplete navigation guard that allows certain browser interaction flows to trigger navigation without full server-side SSRF policy enforcement.

Attackers who can simulate or control pressKey or type/submit style interactions may be able to force unauthorized outbound navigations that bypass intended post-action security checks.

Affected context

The vulnerability manifests in OpenClaw's navigation handling logic, specifically around browser-like interaction flows such as pressKey and type-then-submit actions.

In deployments where OpenClaw is used to drive automated browser navigation or to orchestrate HTTP requests on behalf of users, certain interaction-triggered navigations are not fully gated by the same SSRF (Server-Side Request Forgery) policy checks as other code paths.

This issue is most relevant where OpenClaw has the ability to reach internal services or sensitive network segments and relies on navigation guards to enforce outbound request policies.

Exploit preconditions

  • Attack surface: Interfaces that expose or embed OpenClaw's navigation capabilities (e.g., automation APIs, scripting hooks, or higher-level orchestration layers).
  • Required access: Ability to issue or influence pressKey, type, or submit actions that cause a navigation event; this could be via authenticated automation scripts, misconfigured integrations, or exposed control endpoints.
  • Trigger point: Browser press/type style interactions that lead to a navigation step, where post-action SSRF checks are either skipped or only partially applied.
  • Why exploitation is possible: The navigation guard logic does not consistently enforce SSRF policies across all navigation paths, leaving a subset of interaction-driven flows without complete authorization or policy validation before the navigation executes.

Why this happens

This issue stems from inconsistent application of authorization and SSRF policy checks in navigation control logic.

Conceptually, different entry points into the navigation subsystem (such as direct navigation commands versus pressKey/type submit flows) are treated asymmetrically: some routes perform full, centralized checks, while others rely on post-action or incomplete validation.

This maps to CWE-862: Missing Authorization, where certain actions (in this case, navigation to potentially sensitive or internal endpoints) can be performed without verifying that the request complies with the defined SSRF and access control policies.

The core pattern is a fragmented guard implementation instead of a single, mandatory enforcement point for all navigation-triggering operations.

Potential impact

  • Attackers could cause OpenClaw to initiate unauthorized navigations to internal or restricted network resources.
  • SSRF protections may be bypassed, potentially allowing access to metadata services, internal APIs, or administrative interfaces.
  • Sensitive data exposure could occur if internal endpoints return configuration, credentials, or system information.
  • Existing network segmentation assumptions may be undermined, enabling lateral movement or reconnaissance via controlled navigations.
  • Logging and monitoring might miss or misclassify these navigation events if they are not processed by the usual SSRF enforcement layer.

General mitigation guidance

Mitigation generally involves centralizing and strengthening authorization and SSRF checks around all navigation operations.

Useful patterns include:

  • Implementing a single, mandatory navigation guard that executes before any outbound request, regardless of how the navigation was initiated (direct command, pressKey, type/submit, or other interactions).
  • Treating all user- or script-driven navigation inputs as untrusted, enforcing strict allowlists or policy-based routing for target URLs and destinations.
  • Normalizing interaction flows so that underlying navigation calls always pass through the same validation and SSRF enforcement logic.
  • Applying defense-in-depth controls such as isolating OpenClaw's network access, limiting reachable internal resources, and running navigation workers with least-privilege network permissions.
  • Designing the system so that silent or implicit navigations cannot bypass centralized policy checks, even under error conditions or asynchronous flows.

How teams detect issues like this

Detection efforts can focus on both code-level and runtime perspectives:

  • Static analysis and code review: Look for navigation APIs or HTTP request paths that are not consistently wrapped by shared guard or policy-enforcement functions; identify any code that calls navigation primitives directly from interaction handlers (pressKey, type, submit) without passing through common validation layers.
  • Policy enforcement checks: Define architectural rules (e.g., "all navigation must pass through GuardX") and use automated tools or linters to flag deviations from this pattern.
  • Runtime monitoring: Instrument logging for all navigation events, tagging them with the triggering interaction type and enforcement decision; analyze logs for navigations that lack corresponding SSRF policy evaluations.
  • Behavioral testing: Create regression tests that simulate pressKey and type/submit flows to verify that they are subject to the same SSRF and authorization policies as direct navigation commands.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/049acf23cb03e1b92f5c71cd99c6ec5f35cc56fe
github.comgithub.com/openclaw/openclaw/commit/5f5b3d733bdd791cb457f838514179e1288b10b3
github.comgithub.com/openclaw/openclaw/commit/e0b8ddc1a55185aff1cf9e0e095014d2e4f1d894
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-536q-mj95-h29h
vulncheck.comvulncheck.com/advisories/openclaw-incomplete-navigation-guard-coverage-in-browser-interactions

Frequently asked

questions

Exploitability depends on how OpenClaw is integrated and exposed; if attackers can control or influence interaction-like inputs (pressKey, type, submit) that trigger navigation, they may be able to abuse the incomplete guard to perform unauthorized outbound requests.

In many setups, access to OpenClaw's navigation or automation interfaces is restricted to authenticated or internal users, but the core risk arises once an attacker has that level of access. If those interfaces are exposed or misconfigured, an external attacker might leverage them as well.

The most robust fix is to centralize navigation enforcement so that every navigation path—regardless of how it is initiated—must pass through a single, well-defined guard that applies SSRF policies, authorization checks, and logging before the request is executed.

Preventive strategies include designing navigation and request subsystems with mandatory control points, defining architectural rules for access control enforcement, consistently using shared guard utilities, and incorporating automated checks in CI/CD pipelines to detect any new navigation paths that bypass these controls.

Find out what's already
exploitable in your codebase.