COR Brief
COR Brief — AI Agents & AutomationFree Sample

Module 1: What You Just Gave AI Access To

OpenClaw Security Foundations

Published: February 2026Classification: Free Sample Briefing~15 min read

Executive Summary

OpenClaw is an open-source autonomous AI agent with 145,000+ GitHub stars that runs on your hardware and acts on your behalf through messaging platforms. Between January 27 and February 8, security researchers at Bitsight identified over 30,000 exposed instances on the public internet. Of the instances scanned independently by researcher Maor Dayan, 93.4% had authentication bypasses. Eight were completely open — no password, no token, full shell access to anyone who connected.

This briefing maps the complete attack surface of an OpenClaw deployment, identifies the specific permissions that create risk, and provides a threat model for decision-makers evaluating whether — and how — to deploy autonomous agents.

Bottom Line

OpenClaw is not a chatbot. It is a privileged local service with shell access, browser control, messaging platform tokens, and persistent memory. Deploying it without understanding the permission model is equivalent to giving a contractor the keys to every building in your organization and telling them to figure out what needs doing.

What OpenClaw Actually Is

Most AI tools operate in a sandbox. You open a browser tab, type a prompt, get a response. The AI has no access to your file system, your email, your calendar, or your infrastructure. It can suggest; it cannot act.

OpenClaw is architecturally different. It runs a persistent gateway process on hardware you control — a laptop, a Mac Mini, a Raspberry Pi, a cloud VPS — and connects to large language models (Anthropic, OpenAI, Google, or local models via Ollama) to interpret natural language instructions. You interact with it through messaging platforms you already use: WhatsApp, Telegram, Slack, Discord, Signal, iMessage, Microsoft Teams.

The gateway is the control plane. It manages sessions, tools, cron jobs, webhooks, and browser automation. It does not just generate text. It executes shell commands, reads and writes files, controls a browser via Chrome DevTools Protocol, sends messages on your behalf, and manages scheduled tasks that run while you sleep.

OpenClaw's creator, Peter Steinberger, has been direct about this: “Most non-techies should not install this. It's not finished, I know about the sharp edges.” The project went viral anyway. It reached 100,000 GitHub stars faster than any open-source project in history, outpacing even freeCodeCamp, which took years to reach the same milestone.

The speed of adoption has outrun the community's understanding of what they've deployed.

The Permission Model: What It Can Touch

OpenClaw organizes its capabilities into tool groups. Each group represents a category of system access. Understanding these groups is the foundation of any security assessment.

Tool Group: Runtime (exec, bash, process)

What it does: Executes arbitrary shell commands on the host machine. Supports synchronous and background execution with configurable timeouts. Can run processes, poll their output, write to their stdin, and kill them.

What this means: Any command you can run in a terminal, OpenClaw can run. rm -rf /, curl to exfiltrate data, ssh to pivot to other machines, docker to spin up containers. The exec tool is the single most dangerous capability. It transforms a language model from an advisor into an operator.

Default state: Enabled. If sandbox mode is off (and it is off by default for many deployment paths), exec runs directly on the gateway host without requiring approvals.

Tool Group: File System (read, write, edit, apply_patch)

What it does: Reads, creates, modifies, and patches files anywhere the gateway process has filesystem permissions.

What this means: OpenClaw can read your SSH keys (~/.ssh/), your AWS credentials (~/.aws/), your Kubernetes configs (~/.kube/), your environment files, your application source code, and anything else on disk. It can also write to those locations — modifying configuration files, injecting code, or creating new files.

Tool Group: Web (web_search, web_fetch)

What it does: Searches the web via Brave Search API and fetches/extracts content from URLs.

What this means: OpenClaw can access any publicly available URL and parse its content. This is also a prompt injection vector: if the agent fetches a web page containing malicious instructions, the language model may follow those instructions as if they came from the user.

Tool Group: Browser (browser control via CDP)

What it does: Launches and controls a dedicated Chrome/Chromium instance. Can open tabs, navigate to URLs, take screenshots, click elements, type text, fill forms, upload files, read console output, and generate PDFs.

What this means: OpenClaw can log into web applications using stored sessions, interact with authenticated dashboards, fill out forms, make purchases, and navigate any web interface. It can also screenshot what it sees and send those images through messaging channels.

Tool Group: Messaging (message)

What it does: Sends messages, polls, reactions, edits, and deletions across WhatsApp, Telegram, Slack, Discord, Google Chat, Signal, iMessage, and Microsoft Teams. Supports threads, pins, member management, role assignment, kicks, and bans.

What this means: OpenClaw can impersonate you on every connected messaging platform. It can send messages to your colleagues, your clients, your family. It can delete message history. It can create polls, manage Discord roles, and kick users from channels. If compromised, an attacker communicates as you.

Tool Group: Automation (cron, gateway)

What it does: Creates and manages scheduled tasks (cron jobs) that run on a recurring basis. Can restart the gateway process itself and modify its own configuration.

What this means: OpenClaw can schedule actions that execute without your knowledge or presence. A compromised instance could schedule data exfiltration at 3 AM, modify its own configuration to disable security controls, or restart itself with elevated permissions.

Tool Group: Sessions

What it does: Lists all active sessions, reads full conversation transcripts, sends messages to other sessions, and spawns sub-agent processes.

What this means: In a multi-user or multi-agent deployment, session access allows reading other users' conversations, sending messages that appear to come from the system, and spawning new agent processes with their own capabilities.

Tool Group: Memory

What it does: Searches and retrieves from OpenClaw's persistent memory — information retained across conversations and sessions.

What this means: Everything you've told OpenClaw is searchable. Passwords shared in casual conversation, personal details, business strategies, financial information. If the instance is compromised, the attacker gets your complete interaction history.

Tool Group: Nodes (device control)

What it does: Discovers paired devices (macOS, iOS, Android), sends notifications, executes commands on remote devices, captures camera and screen content, and retrieves GPS location.

What this means: If you've paired your phone or laptop as a node, OpenClaw can take photos with your camera, record your screen, track your physical location, and execute commands on your device. This is full device control.

The Attack Surface Map

Every OpenClaw deployment exposes multiple entry points. An attacker needs to compromise only one.

Entry Point 1: The Gateway (Port 18789)

The gateway is the WebSocket control plane. If exposed to the internet — and Bitsight found over 30,000 instances that were — it's the primary attack vector.

Authentication: OpenClaw requires a token or password for non-local connections, but enforces no complexity requirements. A single character is accepted as valid. Brute force is trivial.

Common misconfiguration: Users bind the gateway to 0.0.0.0 (all interfaces) for remote access convenience, then set a weak token or use gateway.controlUi.allowInsecureAuth to bypass the HTTPS requirement. Honeypot research by Pillar Security found that the first probes arrived within minutes of exposure, including prompt injection attempts and direct WebSocket API exploitation.
Known vulnerability: CVE-2026-25253 (CVSS 8.8) is a one-click remote code execution vulnerability affecting earlier OpenClaw versions. An attacker can trick a user into visiting a malicious web page, which exploits the gateway to execute arbitrary code on the host. This was patched in version 2026.1.29, but unpatched instances remain in the wild — particularly those still running under the Clawdbot or Moltbot names.

Entry Point 2: Messaging Platform Tokens

Each connected messaging platform requires authentication tokens stored in OpenClaw's configuration. WhatsApp uses Baileys (a reverse-engineered Web client). Telegram uses bot tokens. Slack and Discord use OAuth or bot tokens.

Risk: These tokens are stored in the openclaw.json configuration file or environment variables on the gateway host. If the host is compromised, all tokens are compromised. Bitsight researchers demonstrated that simply asking OpenClaw to read its own configuration file and search for API keys successfully extracted credentials.

Entry Point 3: Prompt Injection via Incoming Content

Even if only you can message the bot, prompt injection can still happen via any untrusted content the bot reads — web search results, browser pages, emails, documents, attachments, pasted logs, or code.

Scenario: OpenClaw monitors your inbox and summarizes new emails. An attacker sends an email containing invisible instructions (white text on white background, zero-width characters, or encoded in HTML comments). The language model processes the email content and follows the embedded instructions — exfiltrating data, modifying files, or sending messages on your behalf.
Documented attack — HEARTBEAT.md injection: Security researchers demonstrated a specific prompt injection where a malicious web page, when summarized by OpenClaw, silently appends attacker-controlled instructions to the agent's ~/.openclaw/workspace/HEARTBEAT.md file. Because HEARTBEAT.md is read automatically on a recurring schedule, the injected instructions persist and execute later — effectively creating a command-and-control channel that survives the original conversation.

Entry Point 4: Community Skills (Supply Chain)

OpenClaw's functionality is extended through skills — community-contributed plugins available via ClawHub. In February 2026, over 400 malicious skills were discovered out of nearly 4,000 total on the marketplace. A single supply chain attack was responsible for the initial wave of 335 infections, with additional malicious skills identified through subsequent security audits.

Risk: Skills are code. They execute with the same permissions as the OpenClaw process. A malicious skill can steal credentials, exfiltrate data, establish persistence, and download additional payloads.

Supply chain pattern: Security analysis by Bitdefender found that malicious skills are frequently cloned and republished under slight name variations, with payloads staged through paste services like glot.io and public GitHub repositories. This makes visual inspection of skill names insufficient — code review of the actual skill source is required.

OpenClaw has since integrated VirusTotal scanning for ClawHub skills, but this is reactive — new malicious skills may exist before detection.

For teams building custom skills or auditing community contributions before deployment, automated code security scanning can identify vulnerabilities, hardcoded credentials, and injection risks that manual review misses at scale. VettIQ is purpose-built for this workflow.

Entry Point 5: DM Policy Misconfiguration

By default, OpenClaw routes all direct messages into a shared main session. If multiple people can DM the bot (open DMs on Discord, a multi-person Slack workspace), all conversations share context.

Risk: Cross-user context leakage. A colleague's casual question about OpenClaw could return information from your private conversations, including credentials, business data, or personal details.

Threat Model: What Happens When It Goes Wrong

Scenario 1: Exposed Gateway — Full Compromise

Precondition: Gateway bound to 0.0.0.0 with weak or default authentication.

Attack chain: Attacker scans port 18789, connects to WebSocket API, authenticates with brute force or known default token, executes shell commands via exec tool.

Impact: Complete host compromise. All connected services compromised. All stored credentials exfiltrated. Attacker can send messages as the user, access email, modify code repositories, and establish persistent access via cron jobs.

Observed in the wild: Yes. Pillar Security documented sophisticated attackers who bypassed the AI layer entirely and exploited the gateway WebSocket API directly, targeting specific RPC methods from the source code.

Scenario 2: Prompt Injection via Email

Precondition: OpenClaw connected to email with read/reply permissions.

Attack chain: Attacker sends email containing hidden prompt injection. OpenClaw processes email content. Language model follows injected instructions to forward sensitive emails to attacker's address or exfiltrate inbox contents via web_fetch to an external endpoint.

Impact: Complete email compromise without accessing the email account directly.

Observed in the wild: Prompt injection attacks against AI agents are well-documented. OpenClaw's security docs explicitly warn about this vector.

Scenario 3: Malicious Skill Installation

Precondition: User installs a popular-looking skill from ClawHub without auditing the code.

Attack chain: Skill executes with full OpenClaw permissions. On installation, it reads the configuration file, extracts API keys and messaging tokens, and sends them to an external server. It then modifies its own skill configuration to persist across updates.

Impact: All API keys compromised. Attacker has messaging platform access. All future interactions are potentially monitored.

Observed in the wild: Yes. Over 400 malicious skills discovered on ClawHub in February 2026, with new variants appearing weekly.

Scenario 4: Shadow AI in the Enterprise

Precondition: An employee installs OpenClaw on a personal device and connects it to corporate Slack, GitHub, and email for “productivity.”

Attack chain: No external attacker needed. The employee's OpenClaw instance now has access to corporate communication, source code, and email. The instance runs on an unmanaged device outside corporate security controls. Any compromise of the personal device — or the OpenClaw instance itself — becomes a corporate data breach.

Impact: Corporate data exposure via unmanaged, unmonitored AI agent. No audit trail in corporate security tools. Potential regulatory implications (GDPR, HIPAA, SOX) if sensitive data transits through an unmanaged system.

Observed in the wild: Bitsight's entity mapping found OpenClaw instances deployed across healthcare, finance, government, and insurance sectors.

Who Should and Shouldn't Run OpenClaw

You should consider OpenClaw if:

  • You are a technical user who understands network security, authentication, and the principle of least privilege
  • You have a dedicated machine (not your primary workstation) for the gateway
  • You use Tailscale or another VPN for remote access (not direct internet exposure)
  • You are willing to audit community skills before installation
  • You understand prompt injection risks and can configure tool restrictions appropriately
  • You treat the gateway token like a root password

You should not run OpenClaw if:

  • You followed a YouTube tutorial and are deploying to a $5 VPS for the first time
  • You plan to bind the gateway to the public internet
  • You would connect it to corporate services without your security team's knowledge
  • You don't understand what tools.allow / tools.deny does
  • You want a “set it and forget it” AI assistant
  • You plan to give it access to financial accounts, medical records, or other high-sensitivity data without sandboxing

Your organization should be concerned if:

  • Employees are deploying OpenClaw and connecting corporate services without authorization
  • Your endpoint monitoring doesn't detect or flag the OpenClaw gateway process
  • Your network monitoring doesn't alert on unexpected WebSocket connections on port 18789
  • Your DLP controls don't cover data exfiltration via AI agent tool calls
  • Enterprise detection tooling now exists — CrowdStrike has released an OpenClaw Search & Removal Content Pack for Falcon for IT, enabling automated discovery and remediation of OpenClaw across managed endpoints

Minimum Security Posture Before Installation

If you've read this far and still want to deploy, these are non-negotiable:

1

Dedicated hardware. Never run OpenClaw on your primary workstation. A compromised agent means a compromised everything.

2

Gateway bound to loopback only. 127.0.0.1, not 0.0.0.0. Use Tailscale Serve for remote access. Never expose port 18789 to the public internet.

3

Strong authentication. gateway.auth.mode: "token" with a cryptographically random token of 32+ characters. Treat it like a root password.

4

Sandbox mode enabled. Agent execution runs in ephemeral Docker containers, not on the host filesystem. If an agent goes rogue, it destroys its own container, not your host.

5

Tool restrictions configured. Use tools.deny to block capabilities you don't need. If you don't need shell access, deny group:runtime. If you don't need browser control, deny group:ui.

6

DM policies locked down. Configure allowFrom to restrict who can message the bot. Use session.dmScope: "per-channel-peer" for multi-user environments to prevent cross-context leakage.

7

Skill auditing. Never install a community skill without reading the source code. Pin versions. Monitor for updates. The 400+ malicious skills discovered on ClawHub are not an anomaly — they're the beginning.

8

Model selection. Use modern, instruction-hardened models (Anthropic Claude Opus 4.6 is OpenClaw's own recommendation) that are more resistant to prompt injection. Older or cheaper models are significantly more vulnerable.

What Comes Next

This briefing establishes the threat landscape. Module 2 of this series provides the step-by-step hardened installation guide — specific configuration files, network architecture, and tool permission matrices that transform OpenClaw from a liability into a defensible deployment.

Module 3 covers the ten most common use cases with minimum-privilege configurations for each. Module 4 delivers weekly operational intelligence: what shipped, what broke, and what you need to change.

The autonomous agent era is here. The question isn't whether to engage — it's whether you'll engage with your eyes open.

Sources & References

COR Brief — AI Agents & Automation is a vertical of COR Brief, the strategic intelligence platform from LumenIQ. Subscribe at corbrief.com for daily briefings across AI, Crypto, Functional Health, Fintech, Geopolitics, and AI Agents & Automation.

Related from LumenIQ

This briefing is published by COR Brief, a product of LumenIQ. If your team writes or reviews code produced by AI agents like OpenClaw, VettIQ scans AI-generated and community-contributed code for vulnerabilities, secrets exposure, and dependency risks before they reach production.

Learn more at vettiq.ai

Get the Full OpenClaw Intelligence Series

Modules 2-5 cover hardened installation, secure workflows, weekly threat digests, and architecture deep dives.

Subscribe