/

CVE-2026-62188

Severity:

HIGH RISK

(8.1)

Incorrect Authorization (CWE-863) in Feishu Tools

CVE-2026-62188

Analyzed

Vulnerability type

Category:

Incorrect Authorization

CWE:

CWE-863

Impact:

Privilege Escalation and Policy Bypass

Severity:

HIGH RISK

(8.1)

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 Feishu permission tooling contains an incorrect authorization flaw where per-account disablement settings can be ignored under certain conditions.

When the affected feature is enabled and reachable, lower-trust callers or configured input paths may perform actions that should require stronger authorization or policy checks.

Affected context

This vulnerability occurs in deployments using the OpenClaw Feishu integration where permission tools are exposed to multiple accounts or automation flows.

It is most relevant when:

  • Per-account disablement or restriction settings are expected to enforce access boundaries
  • The affected feature is enabled and reachable via APIs, bots, or workflow integrations
  • Lower-trust callers or less-privileged automation paths can invoke permission-related actions

In such environments, misapplied authorization checks can cause actions to be processed as if account-level restrictions did not exist.

Exploit preconditions

  • Attack surface: Feishu permission tooling and related APIs or workflow endpoints
  • Required access: Ability to invoke the affected feature as a lower-trust caller or via a configured input path (e.g., bot, webhook, workflow task)
  • Trigger point: Calling operations that rely on per-account disablement or restriction settings for enforcement
  • Why exploitation is possible: Authorization logic does not consistently honor per-account disablement flags, allowing operations to proceed without the intended policy checks

Why this happens

This issue stems from incorrect or incomplete authorization logic that fails to apply the intended per-account disablement rules before executing sensitive operations.

In the context of CWE-863: Incorrect Authorization, the system validates some conditions but does not ensure that every request is evaluated against the correct account-level policy state.

Typical contributing patterns include:

  • Authorization checks implemented at a coarse-grained level, without tying decisions to the specific account or caller context
  • Separation between configuration parsing and runtime permission enforcement, leaving gaps where disabled accounts are not rechecked
  • A mismatch between the policy model (per-account disablement) and the actual implementation (global or feature-wide gate)

Potential impact

  • Lower-trust callers may perform actions reserved for higher-privilege accounts
  • Account-level disablement or suspension policies can be bypassed
  • Unauthorized changes to Feishu-related permissions or configurations could occur
  • Automation workflows may execute operations that violate organizational access policies
  • Audit trails may show activity under accounts that were believed to be restricted

General mitigation guidance

Effective mitigation focuses on strengthening authorization logic around account-specific policy enforcement:

  • Ensure that every sensitive operation re-evaluates the current account policy state, including disablement and restriction flags
  • Centralize authorization decisions in a single, reusable component instead of duplicating logic across endpoints or workflows
  • Tie permission checks to both the caller identity and the target account or resource, avoiding reliance on global feature flags alone
  • Apply defense-in-depth by layering authorization: route-level checks, domain-level checks, and business-rule validation
  • Design policy models so that "disabled" or "restricted" states default to deny, minimizing reliance on optional checks
  • Reduce the privileges of automation paths and integrations by default, granting only the minimum permissions necessary

How teams detect issues like this

Organizations can detect incorrect authorization issues using a combination of review and testing:

  • Perform targeted code reviews looking for authorization checks that do not reference account-level policy or disablement flags
  • Use static analysis or linters to flag endpoints that perform sensitive operations without passing through centralized authorization helpers
  • Implement policy-as-code tests that assert disabled or restricted accounts cannot perform certain operations across all access paths
  • Conduct negative security tests in QA environments, attempting operations from disabled or low-privilege accounts and verifying enforcement
  • Monitor logs and audit trails for actions executed by accounts marked as disabled, restricted, or low-trust, and investigate anomalies

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-w8wf-3qvj-6xqf
vulncheck.comvulncheck.com/advisories/openclaw-feishu-authorization-bypass

Frequently asked

questions

Exploitability depends on how widely the affected Feishu permission tools are exposed. If many integrations or workflows can invoke these tools, the scope can be broad, affecting multiple accounts and automation paths.

An attacker typically needs the ability to act as a lower-trust caller, such as a standard user account, bot, or configured workflow input that can reach the affected feature. They do not need the higher-privilege level that the actions should normally require.

The safest fix pattern is to centralize authorization decisions and ensure that every sensitive operation explicitly checks the current account policy state, including disablement and restrictions, defaulting to deny when policy information is missing or inconsistent.

Prevention strategies include adopting a unified authorization layer, defining policies as code with automated tests, enforcing least privilege for all integrations, and performing regular security-focused reviews of access control logic and account state handling.

Find out what's already
exploitable in your codebase.