/

CVE-2026-28392

Severity:

HIGH RISK

(7.5)

Authorization Bypass in OpenClaw Slack Slash-Command DM

CVE-2026-28392

Analyzed

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-863

Impact:

Privilege Escalation and Access Control Bypass

Severity:

HIGH RISK

(7.5)

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's Slack integration contains an authorization flaw in the slash-command handler that, when dmPolicy is configured to open, treats any direct message sender as authorized for privileged commands.

Under these conditions, an attacker can issue privileged slash commands via direct message to bypass configured allowlists and access-group restrictions, resulting in critical privilege escalation within the OpenClaw environment.

Affected context

This vulnerability affects OpenClaw deployments that integrate with Slack and have:

  • Slash commands enabled, and
  • The dmPolicy option explicitly configured to open for direct messages.

In this context, the slash-command handler in direct messages incorrectly treats any DM sender as authorized, rather than enforcing the intended allowlists or access-group checks. The issue manifests specifically in the path that processes privileged commands sent via Slack DMs.

Exploit preconditions

  • Attack surface: Slack workspace where OpenClaw's app or bot is installed and exposes slash commands.
  • Required access: Ability to send a direct message to the OpenClaw Slack app/bot or a configured command endpoint in Slack. This typically means being a member of the Slack workspace; no special OpenClaw role is required.
  • Trigger point: Sending a privileged slash command through a Slack direct message while dmPolicy is set to open.
  • Why exploitation is possible: The DM handler performs insufficient authorization checks (CWE-863), implicitly trusting any DM sender and skipping the usual allowlist or access-group validation that would apply in channels or correctly configured contexts.

Why this happens

The root cause lies in incorrect authorization logic for the Slack slash-command handler when processing direct messages.

When dmPolicy is set to open, the implementation treats the fact that a command comes from a DM as sufficient proof of authorization and does not consistently apply the same allowlist or access-group checks used for channel-based commands.

This pattern aligns with CWE-863: Incorrect Authorization, where the system makes an authorization decision based on incomplete or inappropriate attributes (here, the DM context) instead of explicit user permissions or group membership.

Potential impact

  • Attackers may execute administrative or otherwise privileged OpenClaw slash commands.
  • Configuration changes could be made that affect projects, pipelines, or security settings.
  • Sensitive data or operational metadata may be exposed via privileged diagnostic or reporting commands.
  • Integrity of automation workflows and integrations can be compromised by unauthorized command execution.
  • Lateral movement to other integrated systems may become possible if privileged commands control external connectors.

General mitigation guidance

Effective mitigation focuses on enforcing strict, context-independent authorization checks and reducing the trust placed in messaging context:

  • Apply the same allowlist, role, and access-group validation for direct-message commands as for channel commands, ensuring authorization is user- or group-centric rather than DM-centric.
  • Treat dmPolicy as a security-sensitive setting; prefer restrictive behaviors (e.g., closed or limited DMs) as the default and require explicit justification to open it.
  • Introduce explicit capability or role checks per command, so each privileged action has a clear, verifiable permission requirement.
  • Implement defense-in-depth with server-side checks that do not rely solely on Slack-side configuration or assumptions about DM privacy.
  • Log all privileged command executions with actor identity and context to support incident response and monitoring.

These patterns help ensure that future integrations do not implicitly grant elevated privileges based on communication channels alone.

How teams detect issues like this

Detection can combine code-level review with runtime monitoring:

  • Static analysis / code review:
  • Look for authorization branches that treat DMs differently from channels, especially where DM paths omit group or role checks.
  • Identify handlers where a Slack user ID or DM context is accepted without cross-checking against an internal access-control list or RBAC system.
  • Flag any logic that ties authorization to message type (dm, channel, group) instead of explicit permissions.
  • Policy and configuration checks:
  • Periodically scan integration settings for dmPolicy or similar configuration options that default to open or permissive modes.
  • Define internal guidelines requiring a consistent authorization layer for all entry points, including bots and chat-based commands.
  • Operational monitoring:
  • Monitor logs for privileged command execution originating from direct messages, especially from users not in expected admin or privileged groups.
  • Set up alerts on unusual spikes or anomalies in privileged DM command usage.

Automated security review tools, including SAST and configuration analyzers, can help highlight authorization inconsistencies in chat-based integrations.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/f19eabee54c49e9a2e264b4965edf28a2f92e657
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-v773-r54f-q32w
vulncheck.comvulncheck.com/advisories/openclaw-privilege-escalation-in-slack-slash-command-handler-via-direct-messages

Frequently asked

questions

Exploitation occurs through Slack, but from OpenClaw's perspective it is effectively remote: any user with access to the Slack workspace where the integration is installed and dmPolicy is open can attempt to send privileged commands via direct message.

An attacker generally needs to be a member of the Slack workspace and able to send direct messages to the OpenClaw app or bot. They do not need to be part of the intended allowlist or privileged access groups because the vulnerable DM handler does not enforce those checks.

The safest fix is to centralize and standardize authorization so that every slash command—regardless of channel or DM context—verifies the caller's identity against a consistent, server-side permissions model. The DM handler should perform the same allowlist and access-group checks as other handlers, and dmPolicy should not bypass or weaken these checks.

Design integrations so that channel type, DM status, or other contextual attributes never substitute for explicit permission checks. Use a unified RBAC or capability system, enforce least privilege for each command, and establish security reviews for new bot features or configuration options. Automated tests and code review checklists should explicitly cover authorization consistency across all message types and entry points.

Find out what's already
exploitable in your codebase.