CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



GHSA-52Q4-3XJC-6778

GHSA-52Q4-3XJC-6778: Authorization Bypass via Mutable Metadata in OpenClaw Google Chat Integration

Alon Barad
Alon Barad
Software Engineer

Mar 29, 2026·5 min read·32 visits

Executive Summary (TL;DR)

A flaw in OpenClaw's Google Chat extension (<= 2026.3.24) allows attackers to bypass authorization by renaming a chat space to match a privileged group name. This grants unauthorized access to AI agent tools and data. The vulnerability is fixed in version 2026.3.25.

OpenClaw versions prior to 2026.3.25 suffer from an authorization bypass vulnerability in the Google Chat integration. The flaw occurs due to reliance on mutable room names for policy enforcement, allowing unprivileged users to escalate privileges by renaming chat spaces.

Vulnerability Overview

The openclaw npm package provides an AI agent framework with various platform integrations. The Google Chat extension implements authorization logic to restrict specific agent capabilities to designated chat spaces. Vulnerable versions of this extension suffer from an authorization bypass flaw due to improper reliance on mutable metadata for access control.

This vulnerability is classified under CWE-863 (Incorrect Authorization) and CWE-639 (Authorization Bypass Through User-Controlled Key). The defect resides in the policy resolution routing logic which maps incoming chat messages to configured permission models. By exploiting this mechanism, unauthorized users achieve privilege escalation within the context of the AI agent's operational permissions.

The core issue stems from using the Google Chat space displayName as a primary key for security policy enforcement. Administrators frequently map privileged agent tools to human-readable room names rather than immutable identifiers. Attackers exploit this by instantiating a new space and applying the targeted name, thus inheriting the associated authorization profile.

Root Cause Analysis

The root cause is located in the resolveGroupConfig function within the extensions/googlechat/src/monitor-access.ts file. This component evaluates incoming webhook payloads from Google Chat to determine the appropriate authorization tier for the request. The function constructs a list of lookup candidates based on the message metadata.

In versions prior to 2026.3.25, the candidate array prioritized the immutable groupId but subsequently fell back to the mutable groupName and a normalized representation of the groupName. The system then executed a mapping lookup against the configured policy definitions. If the administrator configured the bot using a human-readable room name, the lookup succeeded based entirely on user-controlled metadata.

Because any Google Chat user with management permissions can arbitrarily modify the displayName of a space they control, the groupName variable is completely untrusted. The application incorrectly elevated this untrusted string to an authoritative policy key. This architectural flaw broke the fundamental security boundary between distinct chat spaces.

Code Analysis and Patch Review

The vulnerable implementation constructed an array of lookup keys and evaluated them sequentially. The application used the find(Boolean) method to select the first matching policy configuration based on the provided candidates.

// Vulnerable implementation in monitor-access.ts
const candidates = [groupId, groupName ?? "", normalizedName ?? ""].filter(Boolean);
let entry = candidates.map((candidate) => entries[candidate]).find(Boolean);

The patch introduced in commit 11ea1f67863d88b6cbcb229dd368a45e07094bff fundamentally alters this trust model. The revised logic strictly enforces the use of the immutable groupId for policy resolution. The application now explicitly evaluates whether a match would have occurred using the legacy, mutable groupName variables.

// Patched implementation in monitor-access.ts
const entry = entries[groupId]; // Use stable ID only
const deprecatedNameMatch = !entry && Boolean(
  groupName && keys.some((key) => {
    return trimmed === groupName || trimmed.toLowerCase() === normalizedGroupName;
  })
);

When a deprecatedNameMatch is detected, the application explicitly nullifies the resolved entry and flags the request. The downstream message handler evaluates this flag and drops the incoming payload. Furthermore, this logic explicitly prevents the system from falling back to a global wildcard policy if an invalid legacy name is utilized.

Exploitation Methodology

Exploitation requires the attacker to possess basic interaction access with the OpenClaw agent and the ability to create new Google Chat spaces. The attacker begins by enumerating or inferring the target organization's privileged group names. Common naming conventions or leaked bot configurations often reveal these identifiers.

The attacker provisions a new Google Chat space and grants themselves administrative control over the space settings. They then invoke the renaming function to alter the displayName to match the targeted privileged group. Once the space is renamed, the attacker invites the OpenClaw agent into the compromised environment.

The attacker subsequently issues a privileged command to the agent. The webhook payload dispatched to the OpenClaw backend includes the attacker-controlled groupName. The vulnerable routing logic matches this string against the administrative policy and grants the requested access, resulting in arbitrary execution of the agent's restricted toolset.

Impact Assessment

The primary impact is unauthorized access to the functionality and data exposed by the OpenClaw AI agent. Because AI agents frequently integrate with backend infrastructure, databases, and continuous integration pipelines, the scope of the impact mirrors the permissions granted to the agent itself.

An attacker successfully exploiting this vulnerability executes actions under the authorization context of the targeted high-privilege group. If the agent possesses read access to financial records or write access to source code repositories, the attacker gains identical capabilities. The bypass renders all platform-side access controls ineffective.

The vulnerability scores an 8.1 on the CVSS v3 framework based on patch analysis. The attack vector is network-based, requires low privileges, and does not require user interaction from a victim. The impact on confidentiality and integrity is high, contingent upon the specific tools integrated into the OpenClaw deployment.

Remediation and Detection

Organizations utilizing the OpenClaw framework must upgrade the openclaw npm package to version 2026.3.25 or later. This release enforces strict validation of the immutable groupId parameter and implements a fail-closed mechanism for legacy configuration attempts.

Administrators must proactively audit and update their channels.googlechat.groups configuration file. All human-readable room names must be replaced with the corresponding immutable Space IDs. These identifiers utilize the format spaces/XXXXXXXX and remain static regardless of user-initiated metadata changes.

Security teams can detect exploitation attempts by monitoring application logs. Patched versions of OpenClaw emit specific warnings when legacy routing matches occur. Search for the log entry Deprecated Google Chat group key detected: group routing now requires stable space ids or drop group message (deprecated mutable group key matched) to identify in-progress attacks or misconfigured environments.

Official Patches

OpenClawOfficial fix commit in the OpenClaw repository

Fix Analysis (1)

Technical Appendix

CVSS Score
8.1/ 10
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H

Affected Systems

OpenClaw Google Chat IntegrationNode.js npm openclaw package

Affected Versions Detail

Product
Affected Versions
Fixed Version
openclaw
OpenClaw
<= 2026.3.242026.3.25
AttributeDetail
CWE IDCWE-863, CWE-639
Attack VectorNetwork
CVSS Score8.1
ImpactAuthorization Bypass / Privilege Escalation
Exploit StatusProof of Concept Available
KEV StatusNot Listed

MITRE ATT&CK Mapping

T1190Exploit Public-Facing Application
Initial Access
T1548.002Bypass User Access Control
Privilege Escalation
CWE-863
Incorrect Authorization

The software performs an authorization check when an actor attempts to access a resource or perform an action, but it does not correctly perform the check.

Vulnerability Timeline

Initial reports of spillover and bypass vulnerabilities discussed on community forums
2026-02-01
Fix commit 11ea1f67863d88b6cbcb229dd368a45e07094bff merged into the main branch
2026-03-26
GHSA-52Q4-3XJC-6778 formally published to the GitHub Advisory Database
2026-03-27

References & Sources

  • [1]GitHub Advisory Database: GHSA-52Q4-3XJC-6778
  • [2]OpenClaw Fix Commit
  • [3]OpenClawCVEs Security Tracker

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•37 minutes ago•CVE-2026-109478
7.5

CVE-2026-109478: Algorithmic Complexity Denial of Service in ASP.NET Core Header Parsing

CVE-2026-109478 is a network-accessible Denial of Service (DoS) vulnerability in ASP.NET Core caused by inefficient algorithmic complexity (CWE-407) when parsing comma-separated HTTP request headers. Prior to the patch, the internal helper method ParsingHelpers.GetHeaderSplit repeatedly called StringValues.Concat inside a loop iterating over each comma-separated token. Because StringValues allocates a new array of size k + 1 and copies all existing elements upon each concatenation, processing N tokens incurs O(N^2) time and space complexity. An unauthenticated remote attacker can send HTTP requests with headers containing thousands of short, comma-separated values to exhaust CPU cycles and induce severe Garbage Collection (GC) pauses, rendering the web application unresponsive.

Alon Barad
Alon Barad
2 views•11 min read
•about 2 hours ago•CVE-2026-114147
7.5

CVE-2026-114147: Denial of Service via Memory Leak in ASP.NET Core SignalR Redis Backplane

CVE-2026-114147 is a high-severity Denial of Service (DoS) vulnerability affecting ASP.NET Core and specifically the Microsoft.AspNetCore.SignalR.StackExchangeRedis scale-out provider across .NET 8.0, 9.0, 10.0, and 11.0 preview releases. The vulnerability originates from a string comparison mismatch between internal per-connection group collections and the centralized Redis channel subscription registry, compounded by a race condition during connection teardown. Remote unauthenticated attackers can exploit this flaw to leave orphaned connection contexts and active Redis pub/sub listeners pinned in memory, leading to unbounded memory exhaustion and application process termination.

Amit Schendel
Amit Schendel
2 views•10 min read
•about 3 hours ago•CVE-2026-114156
6.5

CVE-2026-114156: Path Equivalence Security Feature Bypass in Microsoft ASP.NET Core

CVE-2026-114156 is an improper resolution of path equivalence vulnerability (CWE-41) in Microsoft ASP.NET Core affecting .NET 11.0 preview releases and Microsoft Visual Studio 2026. The vulnerability stems from a discrepancy between how path prefix validation helpers (such as PathString.StartsWithSegments) and downstream routing mechanisms handle alternate path separators and percent-encoded characters. An unauthenticated remote attacker can exploit this mismatch over the network to bypass path-based authorization middleware and access restricted endpoints.

Amit Schendel
Amit Schendel
5 views•8 min read
•about 4 hours ago•CVE-2026-114157
7.5

CVE-2026-114157: Local Privilege Escalation via Race Condition in ASP.NET Core Kestrel Named Pipes Transport

CVE-2026-114157 is a high-severity local privilege escalation and security feature bypass vulnerability affecting ASP.NET Core on Microsoft Windows. The flaw resides in the Kestrel web server's Named Pipes transport layer (Microsoft.AspNetCore.Server.Kestrel.Transport.NamedPipes) and stems from a race condition (CWE-362) during broken pipe error recovery. When an active connection throws an IOException during handshake acceptance, the connection listener previously disposed of the broken NamedPipeServerStream instance before acquiring a replacement stream from its internal pool. This sequence created a momentary window where zero server instances of the named pipe existed in the Windows Named Pipe File System (NPFS). A local, low-privileged attacker can exploit this timing window to create a named pipe with the identical name and a permissive Discretionary Access Control List (DACL), hijacking subsequent inter-process communications and escalating privileges across security boundaries.

Amit Schendel
Amit Schendel
6 views•11 min read
•about 4 hours ago•CVE-2026-124194
6.5

CVE-2026-124194: Forced Authentication and NetNTLMv2 Credential Leakage in Microsoft Office Outlook

CVE-2026-124194 is a forced authentication and spoofing vulnerability in Microsoft Office Outlook caused by a missing user interface warning before dereferencing remote network paths (CWE-356). By embedding an attacker-controlled Universal Naming Convention (UNC) path within MAPI message properties such as PidLidReminderFileParameter, an unauthenticated remote attacker can force a victim's system to initiate an outbound SMB or WebDAV connection upon opening or previewing a crafted message. This automatic authentication handshake leaks the user's NetNTLMv2 hash, enabling offline password cracking or real-time NTLM relay attacks. The vulnerability was exploited in the wild as a zero-day prior to its remediation in Microsoft's November 2026 Patch Tuesday updates and is listed in the CISA Known Exploited Vulnerabilities (KEV) catalog.

Alon Barad
Alon Barad
16 views•10 min read
•about 5 hours ago•CVE-2026-114154
7.5

CVE-2026-114154: Denial of Service in ASP.NET Core HttpSys Request Header Processing

CVE-2026-114154 is a high-severity Denial of Service (DoS) and uncontrolled resource consumption vulnerability in the Microsoft.AspNetCore.Server.HttpSys component of ASP.NET Core. When processing an HTTP request that simultaneously contains a chunked Transfer-Encoding header, a Content-Length header, and an explicit X-Content-Length header, the server throws an unhandled ArgumentException during header normalization. In certain versions, subsequent exception handling attempts to dereference a disposed native request context, aborting error response dispatch and leaking unmanaged HTTP.sys request structures.

Amit Schendel
Amit Schendel
4 views•9 min read