/

CVE-2026-62187

Severity:

HIGH RISK

(8.1)

Authorization Bypass (CWE-863) in OpenClaw Feishu Tools

CVE-2026-62187

Analyzed

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-863

Impact:

Privilege Escalation / Unauthorized Operations

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

An authorization bypass in @openclaw/feishu allows certain operations to be executed even when per-account disablement should prevent them.

If a lower-trust caller or configured input path can invoke these features, they may trigger actions that should have required stronger authorization or policy checks.

Affected context

This vulnerability appears in deployments using the @openclaw/feishu npm package where per-account disablement or policy-based restrictions are expected to control feature access.

It is most relevant when multiple trust levels of callers exist (e.g., background automation, webhooks, or lower-privilege services) and those callers can reach the affected functionality through configured input paths.

Risk increases when operators rely heavily on account-level disablement as a primary enforcement mechanism rather than layering additional checks.

Exploit preconditions

  • Attack surface: Application logic that routes requests or events into @openclaw/feishu features.
  • Required access: Ability for a lower-trust caller, workflow, or inbound integration to trigger operations via the configured input path.
  • Trigger point: Invocation of actions that should be gated by per-account disablement or stronger authorization and policy checks.
  • Why exploitation is possible: The implementation can ignore or inadequately enforce per-account disablement, causing some operations to proceed without honoring expected authorization constraints.

Why this happens

The underlying issue is a flawed authorization design where policy enforcement does not correctly account for per-account disablement in all code paths.

This aligns with CWE-863: Incorrect Authorization, where a system relies on incomplete or incorrectly applied authorization checks, allowing lower-trust inputs to perform operations intended only for higher-trust actors.

In practice, this often stems from missing guard conditions, inconsistent policy evaluation logic, or bypassable routing layers that call privileged functionality without re-verifying the effective permissions of the requester.

Potential impact

  • Lower-trust callers may perform actions reserved for higher-privilege accounts.
  • Account-level disablement policies could be rendered ineffective for certain operations.
  • Automated workflows or integrations could trigger unintended changes in connected Feishu environments.
  • Operators may experience data modification or messaging actions that occur outside of expected policy boundaries.

General mitigation guidance

Effective mitigation generally focuses on enforcing consistent, central authorization checks for all sensitive operations.

Recommended design patterns include:

  • Treat per-account disablement as an explicit authorization constraint that is evaluated in every entry point before executing privileged actions.
  • Implement a single, reusable authorization layer or policy engine rather than duplicating checks across disparate code paths.
  • Categorize operations by sensitivity and enforce defense-in-depth for high-impact actions (e.g., multi-factor conditions, separate approval flows, or higher-trust service accounts).
  • Reduce trust in inbound configuration and routing logic by assuming that any reachable path can be driven by lower-trust input unless proven otherwise.
  • Align privilege models to least-privilege principles, ensuring that default behaviors are restrictive and require explicit opt-in for elevated capabilities.

How teams detect issues like this

Detection typically relies on a combination of design review and behavioral monitoring:

  • Perform code reviews focused on authorization boundaries, checking that all routes and handlers invoking @openclaw/feishu features consistently consult per-account disablement and relevant policies.
  • Use static analysis or linting rules to flag calls into privileged operations that bypass centralized authorization utilities or policy evaluation modules.
  • Define security-focused test cases (including negative tests) that simulate lower-trust callers attempting to access disabled or restricted operations.
  • Monitor logs and audit trails for actions occurring from accounts or integration contexts that should be disabled or limited, and alert on policy violations.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-2q7j-2vhx-56g8
vulncheck.comvulncheck.com/advisories/openclaw-feishu-tools-authorization-bypass

Frequently asked

questions

Exploitability depends on how the package is integrated; if lower-trust callers or inbound inputs can reach the affected operations, they may trigger actions that should have been blocked by per-account disablement or stricter policies.

Not necessarily. Any actor or integration with the ability to drive the configured input path—such as background jobs, webhooks, or service-to-service calls—could potentially exploit the flaw if they can reach the vulnerable functionality.

Centralize authorization enforcement and ensure that every entry point to sensitive functionality reevaluates per-account disablement and policy constraints before execution, avoiding implicit trust in routing or configuration.

Adopt a uniform access-control architecture with reusable authorization checks, apply least-privilege defaults, regularly test disabled or restricted states, and incorporate authorization-focused reviews and automated checks into your development and deployment pipelines.

Find out what's already
exploitable in your codebase.