Back to skill

Security audit

Claw Messenger

Security checks for vulnerabilities and agentic risk

Overview

This skill is for connecting OpenClaw to a messaging service, but it asks users to install an unpinned external plugin and store a live messaging API key locally without enough safeguards.

Review this before installing. Use a pinned, verified plugin version if possible, avoid pasting live API keys into chat, keep .openclaw.json out of source control and readable only by your user account, and assume message content and metadata will pass through the provider's infrastructure.

Vulnerability Patterns
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
Findings (2)

T08 · Insecure Dependencies

Warning
Location
SKILL.md:18
Finding
Unpinned Third-Party Plugin Installation<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 18-22 **Vulnerability Type**: Unpinned third-party dependency **Risk Level**: Medium ### Vulnerable Code ```markdown ### Step 2: Install the plugin Run this in your terminal: \`\`\` openclaw plugins install @emotion-machine/claw-messenger \`\`\` ``` ### Technical Analysis The installation command references `@emotion-machine/claw-messenger` without specifying an immutable version or integrity hash. Consequently, the package resolved at installation time may differ from the package that was originally reviewed or intended by the Skill author. The plugin implementation is not included in this project, so its behavior, requested permissions, handling of credentials, and message-processing logic cannot be verified by this audit. Although no evidence establishes that the current package is malicious, this mutable dependency creates a supply-chain trust boundary that is not controlled by the reviewed repository. ### Attack Path 1. An attacker compromises the package publisher account, registry release process, or another relevant supply-chain component. 2. The attacker publishes a malicious release under the same package name or modifies the package resolved by the unpinned command. 3. A user follows the Skill instructions and installs the package without verifying a version or integrity digest. 4. The malicious plugin executes within the OpenClaw environment. 5. Subject to the plugin runtime's actual permissions, it could access configuration data, intercept messaging content, misuse API credentials, or perform other actions available to the plugin process. ### Impact Assessment Successful exploitation could provide the malicious dependency with the privileges granted to an OpenClaw plugin. The precise privilege scope cannot be determined from `SKILL.md` alone because the plugin source and runtime permission model were not provided. Potentially exposed assets include the Claw Messen ...[truncated 277 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin the plugin to a specific, reviewed version rather than installing the latest mutable release: ```text openclaw plugins install @emotion-machine/claw-messenger@<reviewed-version> ``` 2. Verify the package using a cryptographic integrity digest or signed provenance before installation. 3. Publish or vendor the corresponding plugin source so its behavior can be audited together with the Skill. 4. Use a trusted lockfile and a registry configuration that prevents dependency substitution. 5. Review package ownership, release history, lifecycle scripts, transitive dependencies, and requested runtime permissions. 6. Run the plugin with least privilege, restricting filesystem access, environment variables, network destinations, and access to unrelated OpenClaw secrets. 7. Establish an explicit update process in which new versions are reviewed before changing the pinned dependency. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:24
Finding
Live API Key Exposed to Conversation Context and Plaintext Configuration<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 24-40 **Vulnerability Type**: Plaintext sensitive credential handling **Risk Level**: Medium ### Vulnerable Code ```markdown ### Step 3: Add the channel config to .openclaw.json This is your job as the agent. Ask your human for the API key from the dashboard (it starts with `cm_live_`), or for the special prompt including the key that is shown on the API keys page after your human purchases a pack. Once you have the key, edit your `.openclaw.json` file and add the `claw-messenger` channel under `channels`: \`\`\`json { "channels": { "claw-messenger": { "enabled": true, "apiKey": "cm_live_XXXXXXXX_YYYYYYYYYYYYYY", "serverUrl": "wss://claw-messenger.onrender.com", "preferredService": "iMessage", "dmPolicy": "pairing", "allowFrom": ["+15551234567"] } } } \`\`\` ``` ### Technical Analysis The instructions encourage the user to provide a live API key directly to the agent, potentially through a “special prompt,” and then store that reusable credential in `.openclaw.json`. This exposes the secret to both conversation processing and plaintext local configuration. No safeguards are specified for: - Restricting the configuration file's permissions. - Preventing the API key from appearing in conversation histories, telemetry, logs, error reports, or backups. - Loading the credential from a dedicated secret manager. - Redacting the key from agent output and tool-call records. - Rotating a credential after accidental disclosure. An API key prefix is not itself sensitive, and the example contains only a placeholder. The vulnerability arises when the documented process is followed with a real `cm_live_` credential. ### Attack Path 1. A user follows the instructions and submits a live API key in a prompt or other agent-visible context. 2. The agent writes the key as plaintext into `.openclaw.json`. 3. The key is retained in one or more locations ...[truncated 1119 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Do not request that users place live credentials directly into conversational prompts. 2. Store the API key in an operating-system credential store, dedicated secret manager, or similarly protected mechanism. 3. If OpenClaw supports environment-variable or secret references, configure `.openclaw.json` to reference a secret rather than containing its value directly. 4. If plaintext configuration is unavoidable, restrict the file to the owning account, such as mode `0600` on compatible systems, and prevent it from entering source control or backups. 5. Add `.openclaw.json` and related secret-bearing files to relevant ignore and secret-scanning policies. 6. Redact values matching the `cm_live_` credential pattern from agent output, logs, telemetry, diagnostics, and error reports. 7. Avoid echoing the credential in tool calls or command histories. 8. Provide explicit key-revocation and rotation instructions for any credential exposed through a prompt, log, or configuration leak. 9. Scope API keys to the minimum required tenant and messaging operations, and support expiration where possible. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
Findings (1)

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The skill instructs the agent to place a live `cm_live_` API key into `.openclaw.json` and route SMS/iMessage/RCS content through a third-party WebSocket service, but it does not clearly warn about the security and privacy implications of storing a production credential locally or sending message content and metadata off-platform. This can lead users to expose secrets in plaintext config files, backups, logs, or source control, and to unknowingly transmit sensitive communications through an external provider.