/

CVE-2026-42426

Severity:

HIGH RISK

(8.8)

Improper Authorization in OpenClaw node.pair.approve

CVE-2026-42426

Analyzed

Vulnerability type

Category:

Improper Authorization

CWE:

CWE-863

Impact:

Privilege Escalation and Unauthorized Node Access

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 versions before 2026.4.8 contain an improper authorization vulnerability where the node.pair.approve method accepts a broad operator.write scope instead of the intended operator.pairing scope.

This mis-scoping allows users with operator.write permissions to approve node pairings they should not control, enabling unauthorized access to exec-capable nodes when pairing approvals are used as a security gate.

Affected context

The vulnerability occurs in OpenClaw deployments that:

  • Rely on scoped operator permissions to control node pairing approvals
  • Use node.pair.approve as a gating mechanism before granting access to exec-capable nodes
  • Assign operator.write broadly (e.g., to automation, operators, or service accounts)

In these environments, pairing approval is expected to require a narrower, dedicated operator.pairing scope, but the implementation instead treats generic operator.write as sufficient.

Exploit preconditions

  • Attack surface: OpenClaw control APIs or UI paths that invoke node.pair.approve
  • Required access: Valid credentials or tokens with operator.write scope, but without the intended operator.pairing scope
  • Trigger point: An attacker issues a pairing approval operation (direct API call or indirect through management tools) against nodes that are pending pairing
  • Why exploitation is possible: The authorization check on node.pair.approve validates the broader operator.write scope instead of the narrower operator.pairing scope, effectively collapsing the separation of duties between general operator actions and security-sensitive pairing approval

Why this happens

This issue stems from a misconfigured authorization decision in the access control layer, where a privileged operation is tied to an overly broad permission.

Instead of requiring a specific operator.pairing scope for node pairing approval, the code treats possession of the generic operator.write scope as sufficient to invoke node.pair.approve.

Conceptually, this maps to CWE-863: Improper Authorization, in which an application performs authorization checks but uses the wrong permission, role, or scope, allowing users with partial or unrelated privileges to execute sensitive actions that should be reserved for a more narrowly defined actor set.

Potential impact

  • Attackers with operator.write may approve node pairings without proper oversight.
  • Unauthorized access to exec-capable nodes, potentially enabling command execution or administrative actions on those nodes.
  • Bypass of pairing-based security workflows and change-control processes.
  • Lateral movement within the infrastructure by onboarding additional nodes into trusted groups.
  • Escalation of operational capabilities beyond what the attacker's role or token was intended to allow.

General mitigation guidance

Effective mitigation focuses on correcting and hardening authorization boundaries around pairing operations:

  • Require a dedicated, narrowly scoped permission (e.g., operator.pairing) for any action that approves node pairing, ensuring it is distinct from general write or operational scopes.
  • Apply the principle of least privilege when assigning operator roles, avoiding broad scopes for automation or service accounts where pairing approval is not explicitly needed.
  • Centralize authorization checks for security-sensitive methods like node.pair.approve to reduce the chance of inconsistent or incorrect scope validation.
  • Introduce policy-based access control (e.g., RBAC/ABAC) that explicitly models who may approve node pairing and under what conditions.
  • Implement workflow or multi-party approval patterns for pairing exec-capable nodes, so no single broad operator permission can bypass intended review processes.
  • Regularly review and audit permission templates and role definitions to ensure security-sensitive operations are not tied to generalized write permissions.

How teams detect issues like this

Organizations can detect and monitor for this class of improper authorization via:

  • Static analysis and code review:
  • Look for sensitive operations (e.g., node pairing, node onboarding, exec enablement) that check for broad permissions instead of dedicated, narrow scopes.
  • Flag authorization calls where the same high-level scope is reused across both routine and security-critical methods.
  • Review policy and role mappings to ensure that methods like node.pair.approve are bound to specific security roles.
  • Runtime monitoring and logging:
  • Log all node.pair.approve invocations with the caller identity, scopes/roles, target node, and outcome.
  • Alert on pairing approvals performed by accounts or tokens that are not designated for pairing workflows (e.g., general operator service accounts).
  • Correlate pairing approval events with subsequent exec or remote access to detect suspicious patterns.
  • Policy and configuration checks:
  • Use configuration linters or security policy engines to validate that security-sensitive operations are not granted via generic write permissions.
  • Incorporate automated checks into CI/CD pipelines that ensure access control definitions for pairing-related APIs require specialized scopes.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/d7c3210cd6f5fdfdc1beff4c9541673e814354d5
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-67mf-f936-ppxf
vulncheck.comvulncheck.com/advisories/openclaw-improper-authorization-in-node-pair-approve-via-operator-write-scope

Frequently asked

questions

It is highly exploitable in environments where operator.write is commonly granted to operators, automation tools, or service accounts, because any holder of that scope can approve node pairing without needing the intended pairing-specific permission.

The attacker must possess valid credentials or tokens with operator.write scope. They do not need the more restrictive operator.pairing scope that should ideally be required for node pairing approval.

Enforce strict, operation-specific permissions for security-sensitive actions. For node pairing approval, this means requiring a dedicated scope such as operator.pairing, ensuring that only explicitly authorized roles or accounts can perform the operation, and that general write permissions are insufficient.

Design the authorization model with clear separation between routine operations and security-critical workflows, define dedicated scopes for sensitive actions, enforce least privilege in role assignments, and subject all access-control changes to security-focused review and automated validation.

Find out what's already
exploitable in your codebase.