/

CVE-2026-41349

Severity:

HIGH RISK

(8.8)

Missing Authorization / Consent Bypass in OpenClaw Agent

CVE-2026-41349

Analyzed

Vulnerability type

Category:

Missing Authorization / Consent Bypass

CWE:

CWE-862

Impact:

Unauthorized Action Execution Without User Consent

Severity:

HIGH RISK

(8.8)

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 before 2026.3.28 contains an agentic consent bypass issue where LLM agents can silently disable execution approval using the config.patch parameter.

Remote attackers who can influence or invoke an agent with crafted configuration patches may bypass security controls and trigger unauthorized operations without explicit user consent.

Affected context

This vulnerability affects OpenClaw deployments that rely on agent execution approval or consent gates to ensure that potentially sensitive or irreversible actions are explicitly confirmed by a human.

The weakness appears when agents are allowed to modify their own or other agents' configuration through config.patch (or similar configuration mutation) without strong authorization and consistency checks.

In such environments, a remotely triggered or integrated agent can adjust approval-related settings at runtime, effectively downgrading or removing the requirement for user confirmation prior to executing protected operations.

Exploit preconditions

  • Attack surface: Any interface (API, workflow orchestration, plugin integration, or external connector) that accepts or constructs config.patch parameters for OpenClaw agents.
  • Required access: Ability to send or influence agent tasks, prompts, or configurations that include a config.patch payload, either directly via an API or indirectly via an integrated system.
  • Trigger point: Submission of a configuration patch that alters execution approval settings, which the system applies without enforcing separate, higher-privilege authorization.
  • Why exploitation is possible: Changes to consent or approval-related configuration are not adequately protected by independent authorization or policy checks, allowing the same channel that requests work from an agent to also weaken or disable the safety controls governing that work.

Why this happens

The underlying bug aligns with CWE-862: Missing Authorization, where security-critical operations proceed without verifying that the actor is permitted to perform them.

In this case, consent and execution approval behave like an authorization layer for high-risk actions, yet the configuration path (config.patch) that governs these safety controls is treated as a regular runtime parameter.

Because the system does not enforce a stronger, separate permission check or policy boundary around modifications to approval settings, an agent (or caller controlling the agent) can silently flip those settings off.

Abstractly, this represents an insecure pattern where:

  • Safety or authorization configuration is mutable at runtime,
  • The same untrusted input channel is used both to request actions and to alter the guardrails for those actions, and
  • No higher-privilege or out-of-band consent is required to modify those guardrails.

Potential impact

  • Agents may execute high-risk operations (file access, network calls, data exfiltration, system changes) without human review or consent.
  • Security and compliance workflows that depend on explicit approvals can be silently bypassed.
  • Unauthorized modification or deletion of data handled by OpenClaw-integrated agents can occur.
  • Chained actions through connected tools, plugins, or APIs may amplify impact, leading to broader system or account compromise.
  • Audit trails may misleadingly suggest that operations were performed under normal policy, obscuring the loss of consent enforcement.

General mitigation guidance

Effective mitigation revolves around treating consent and approval controls as privileged configuration and separating them from routine agent runtime parameters.

Recommended patterns include:

  • Separate privilege for safety controls: Require a distinct, higher-privilege channel or role to modify approval/consent-related configuration (e.g., admin-only or out-of-band UI), disallowing regular tasks or prompts from changing these settings.
  • Immutable consent at runtime: Treat execution approval requirements as immutable for the lifetime of an agent session or task, so they cannot be altered by config.patch or similar runtime updates.
  • Configuration whitelisting: Restrict what fields config.patch (or equivalent mechanisms) may touch, explicitly excluding safety, auth, and policy-related flags from being modified via untrusted input.
  • Policy-based enforcement: Introduce a policy layer that enforces minimum safety requirements (such as mandatory approvals for certain operation types) regardless of per-agent configuration.
  • Least-privilege tools and connectors: Ensure downstream tools and integrations invoked by agents are themselves scoped to the minimum capabilities needed, reducing the damage if consent checks degrade.

How teams detect issues like this

Detection approaches should focus on identifying unauthorized changes to safety configuration and patterns where untrusted inputs reach consent controls:

  • Static analysis and configuration linting:
  • Flag uses of generic configuration patching (e.g., config.patch, dynamic merges) that can affect safety or auth-related fields.
  • Detect code paths where consent/approval flags are derived from request parameters, agent prompts, or other low-trust sources.
  • Enforce architectural rules such as "approval_required must not be settable from user-controlled input."
  • Code review signals:
  • Pay attention to any code that:
  • Adjusts approval/consent flags,
  • Mutates agent configuration mid-execution, or
  • Accepts broad JSON/YAML patches without field-level validation.
  • Review that all such changes are guarded by explicit authorization checks or restricted to administrative flows.
  • Runtime monitoring and policy enforcement:
  • Log all changes to execution approval or consent-related settings, including who/what initiated them.
  • Add alerts for suspicious patterns such as:
  • Approval requirements being turned off.
  • Frequent toggling of consent flags.
  • High-risk actions occurring without corresponding approval events.
  • Use automated governance tools or security scanners that understand policy metadata to verify that safety controls cannot be disabled from normal agent invocation paths.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/76411b2afc4ae721e36c12e0ea24fd23e2fed61e
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-v3qc-wrwx-j3pw
vulncheck.comvulncheck.com/advisories/openclaw-agentic-consent-bypass-via-config-patch

Frequently asked

questions

Yes. If an attacker can remotely submit or influence agent requests or configurations that include config.patch, they may be able to disable execution approval without any local system access.

The attacker generally needs access to any interface that can initiate or modify agent tasks in OpenClaw—such as an API client, integrated application, or workflow engine—where config.patch or similar configuration patches are accepted without strict authorization controls.

Treat consent and approval settings as protected security configuration. Make them non-modifiable through normal agent inputs, and require separate, strongly authenticated and authorized channels (e.g., administrative UI or dedicated API with stronger controls) to change them.

Architect agentic systems so that:

  • Safety and authorization policies are enforced by a dedicated layer, not by mutable per-request configuration.
  • Any configuration changes affecting consent, approvals, or permissions are subject to explicit authorization and are not derived from user-controlled or agent-generated data.
  • Regular security reviews and automated checks specifically examine how configuration patches and dynamic agent settings interact with safety controls.
Find out what's already
exploitable in your codebase.