/

CVE-2026-28469

Severity:

HIGH RISK

(7.5)

Improper Authorization / Context Confusion in OpenClaw

CVE-2026-28469

Analyzed

Vulnerability type

Category:

Improper Authorization / Context Confusion

CWE:

CWE-639

Impact:

Cross-Account Policy Bypass and Unauthorized Action Execution

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 Google Chat monitor component contains a webhook routing flaw that can mis-associate incoming events with the wrong customer account when multiple webhook targets share the same HTTP path.

By abusing first-match verification semantics, an attacker can cause inbound webhook requests to be processed under an incorrect policy context, effectively bypassing intended allowlists and session-based controls.

Affected context

This vulnerability appears in OpenClaw deployments that:

  • Use the Google Chat monitor component to receive inbound webhooks
  • Configure multiple tenant or account webhooks that terminate on identical HTTP paths (e.g., shared routes, reverse proxies, or multi-tenant ingress)
  • Depend on per-account policies (allowlists, session rules, or tenant isolation) enforced after routing

Under these conditions, the routing logic can incorrectly bind a webhook request to the wrong account context when processing is based on the first matching configuration entry.

Exploit preconditions

  • Attack surface: Public-facing or externally reachable Google Chat webhook endpoint(s) exposed by OpenClaw.
  • Required access: Ability to send crafted HTTP requests to the webhook URL, or control a Google Chat integration that posts to the shared endpoint.
  • Trigger point: Routing and verification step where the handler chooses the account configuration for an incoming webhook based on first-match semantics.
  • Why exploitation is possible: The system matches webhook requests to account configurations primarily by shared HTTP path and order of evaluation, rather than using a unique, strongly bound account identifier. As a result, a request intended for one account can be verified and processed under another account's context, bypassing that account's intended allowlists and session policies.

Why this happens

The core issue is an improper authorization decision based on ambiguous resource identification, aligning with CWE-639.

Instead of binding each webhook to a unique, unambiguous URL or token, OpenClaw's Google Chat monitor allows different accounts to share the same HTTP path and relies on first-match lookup logic.

When a request arrives, the authorization check is applied after the routing decision, and is tied to whichever account entry is matched first.

This design couples access control to configuration order and non-unique identifiers, enabling account context confusion and cross-tenant authorization bypass when an attacker crafts requests that satisfy a more permissive or earlier-matching configuration.

Potential impact

  • Webhook events may be processed under the wrong customer or tenant account, leading to cross-account data or action exposure.
  • Attackers could bypass allowlists, session policies, or IP-based restrictions configured for their own account by being routed through a more permissive account's context.
  • Unauthorized execution of automation, alerting, or policy-triggered actions associated with another account.
  • Potential data integrity issues where logs, audit trails, or policy decisions are recorded against the wrong tenant.
  • Escalation of access across accounts in a multi-tenant OpenClaw deployment, undermining isolation guarantees.

General mitigation guidance

Mitigation should focus on eliminating ambiguous account binding and ensuring that authorization is enforced using unique, strong identifiers rather than path matching or configuration order:

  • Assign each account or integration a unique webhook endpoint or distinct routing key so that multiple tenants do not share the same HTTP path.
  • Bind account context to cryptographically strong, per-account secrets (e.g., verification tokens or signed identifiers) that must be validated before any policy or session context is applied.
  • Perform authorization checks early in the request lifecycle, using attributes that cannot overlap between accounts (such as unique IDs or dedicated subpaths), rather than relying on first-come configuration matches.
  • Implement explicit tenant boundary checks, where the handler rejects any request that cannot be uniquely associated with exactly one account under configured rules.
  • Prefer secure-by-default configuration templates that discourage or prevent shared-path webhook setups, especially in multi-tenant deployments.

How teams detect issues like this

Useful detection strategies include:

  • Static analysis and configuration review:
  • Search for routing logic that selects account or tenant configurations using first-match or ordered iteration over handlers sharing the same path.
  • Flag cases where multiple webhook configurations use identical HTTP paths or overlapping route patterns without secondary unique keys.
  • Code review signals:
  • Authorization decisions that depend on configuration order, loose pattern matching, or non-unique identifiers (e.g., URL paths only).
  • Post-routing policy enforcement where the account context is set before verifying a tenant-specific secret or token.
  • Policy enforcement and testing:
  • Add CI checks that reject new configurations creating path collisions between webhook endpoints unless additional unique binding is present.
  • Introduce automated tests that simulate multiple tenants posting to shared paths and assert that each request is bound to the correct account or rejected.
  • Automated review tools or custom linters can be configured to highlight insecure routing-plus-authorization patterns and path collisions within webhook configurations.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/61d59a802869177d9cef52204767cd83357ab79e
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-rq6g-px6m-c248
vulncheck.comvulncheck.com/advisories/openclaw-cross-account-policy-context-misrouting-via-shared-webhook-path-ambiguity

Frequently asked

questions

Yes. If the webhook endpoint is exposed to the internet or to external Google Chat integrations, an attacker who can send HTTP requests to the shared path can potentially trigger cross-account context misrouting.

The attacker typically needs the ability to post to the vulnerable webhook URL, either by controlling a Google Chat space/bot configured with that URL or by directly reaching the endpoint over HTTP. No additional privileges on the OpenClaw platform are required beyond that network or integration access.

The most robust fix is to enforce a one-to-one binding between webhook identifiers and accounts—using unique URLs or strong per-account secrets—and to perform authorization based on those unique identifiers before establishing any account context. Shared paths without a disambiguating secret or ID should be eliminated.

Future designs should treat webhooks as authenticated entry points: assign unique, non-guessable identifiers per tenant, validate them before routing, and avoid any reliance on configuration order or shared routes for authorization. Combining strong tenant identifiers with defense-in-depth validation and automated checks for path collisions helps prevent context confusion vulnerabilities.

Find out what's already
exploitable in your codebase.