Back to skill

Security audit

ape-claw

Security checks for vulnerabilities and agentic risk

Overview

The skill is purpose-aligned for ApeChain NFT and bridge automation, but it relies on unverified remote code execution while handling wallet and agent credentials.

Review this skill carefully before installing. Use only pinned, verified installers or a sandboxed environment with no wallet keys present; do not run the curl-to-bash or unpinned npx paths on a machine containing valuable credentials. Treat APE_CLAW_PRIVATE_KEY and APE_CLAW_AGENT_TOKEN as secrets, avoid shared chat backends unless you control them, and do not use --allow-unsafe or autonomous execution unless you fully accept the transaction risk.

Vulnerability Patterns
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • 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
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (4)

T03 · Remote Payload Retrieval and Execution

Error
Location
SKILL.md:29
Finding
Mutable ApeClaw Installer Is Downloaded and Executed Without Verification<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 29-32 **Vulnerability Type**: Remote payload retrieval and execution **Risk Level**: Critical ### Vulnerable Code ```bash # Works everywhere. Installs everything. You're welcome. 🦞 curl -fsSL https://raw.githubusercontent.com/simplefarmer69/ape-claw/main/install.sh | bash ``` ### Technical Analysis The documented preflight procedure downloads `install.sh` from the mutable `main` branch of a personal GitHub repository and pipes the response directly into Bash. The command does not pin a commit or release, verify a cryptographic signature or checksum, retain the script for inspection, or constrain its execution privileges. Consequently, the effective code executed by this skill is not the content that was available during the audit. The repository owner, a compromised GitHub account, or another party able to modify the branch could replace the installer at any time. This installation mechanism is not necessary for the skill's read-only quote, discovery, or simulation functionality. It grants externally controlled code the full privileges of the user running the agent. ### Attack Path 1. An attacker compromises the `simplefarmer69` GitHub account, gains write access to the repository, or otherwise causes `main/install.sh` to serve malicious content. 2. The attacker modifies the installer while preserving the expected URL. 3. An OpenClaw agent follows the documented “run once per session” preflight procedure. 4. `curl` retrieves the attacker-controlled response and passes it directly to Bash. 5. The payload executes with the agent process's user privileges. 6. The payload can inspect environment variables and local files, including credentials later required by the workflow, and can alter the host or install additional software. ### Impact Assessment Successful exploitation provides arbitrary command execution with the privileges of the user running OpenClaw. This may permit theft of ...[truncated 529 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Do not pipe network responses directly into a shell. - Distribute the reviewed installer with the skill, or use an immutable, versioned release artifact. - Pin the source to a reviewed Git commit or release version rather than the mutable `main` branch. - Publish and verify a SHA-256 or stronger checksum obtained through an independent trusted channel. - Prefer signed release artifacts and verify the maintainer signature before execution. - Download the installer to a file, inspect and validate it, and only then execute it explicitly. - Run installation in an isolated, low-privilege environment without wallet keys, agent tokens, or unrelated credentials. - Separate read-only features from transaction execution so discovery and simulation do not require installing privileged wallet-capable software. ]]>

T03 · Remote Payload Retrieval and Execution

Error
Location
SKILL.md:12
Finding
OpenClaw Is Installed Through an Unverified Remote Shell Pipeline<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 12 and 318 **Vulnerability Type**: Remote payload retrieval and execution **Risk Level**: High ### Vulnerable Code At line 12: ```bash curl -fsSL https://openclaw.ai/install.sh | bash ``` The same installation method is repeated at line 318: ```bash curl -fsSL https://openclaw.ai/install.sh | bash ``` ### Technical Analysis The skill recommends retrieving an installation script from `openclaw.ai` and immediately executing it through Bash. HTTPS protects transport under normal circumstances, but it does not make the returned payload immutable or establish that the currently served script is the version reviewed by the user. The command performs no version pinning, checksum validation, signature verification, or local inspection. A compromise of the hosting domain, deployment infrastructure, DNS or certificate trust chain, or maintainer credentials could turn the installation URL into an arbitrary code execution channel. Installing OpenClaw may be a prerequisite for using the integration, but direct `curl | bash` execution exceeds the minimum privileges necessary to communicate that prerequisite safely. ### Attack Path 1. An attacker compromises the `openclaw.ai` server, deployment pipeline, domain controls, or credentials capable of changing `install.sh`. 2. The attacker serves a modified shell script at the legitimate URL. 3. A user or agent follows either installation instruction in `SKILL.md`. 4. Bash executes the response without authenticity or integrity validation. 5. The malicious installer accesses files, environment variables, and processes available to the invoking account. 6. It can subsequently intercept agent activity or wallet credentials used by ApeClaw workflows. ### Impact Assessment Exploitation results in arbitrary code execution under the invoking user's account. Depending on that account's permissions, the attacker could access agent credentials, wallet priva ...[truncated 328 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Replace `curl | bash` with installation from a versioned, authenticated distribution channel. - Pin an exact OpenClaw version and document its expected checksum. - Require signature verification for installer or release artifacts. - Download installers separately and require review before execution. - Use a package manager lockfile or immutable package reference where possible. - Perform installation without wallet keys or agent tokens in the environment. - Clearly document the files, permissions, and system changes made by installation. ]]>

T03 · Remote Payload Retrieval and Execution

Error
Location
SKILL.md:40
Finding
Unpinned GitHub Repository Is Automatically Downloaded and Executed Through npx<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 40-44 **Vulnerability Type**: Remote payload retrieval and insecure dependency execution **Risk Level**: High ### Vulnerable Code ```bash If not found: ```bash npx --yes github:simplefarmer69/ape-claw quickstart --json ``` ``` ### Technical Analysis The fallback invokes `npx --yes` against a GitHub repository reference without an exact commit hash or immutable release identifier. `npx` may download package content and execute its entry point and associated lifecycle behavior. The `--yes` option suppresses the normal confirmation prompt, enabling unattended execution by an agent. Because the repository reference is mutable, code executed later may differ from the code present when the skill was reviewed. No lockfile, integrity metadata, checksum, signature, or reviewed commit is specified. This is both an external code execution channel and an insecure dependency practice. It is particularly risky in an agent context because the process may inherit wallet keys, agent tokens, API keys, and filesystem access. ### Attack Path 1. An attacker compromises the referenced GitHub repository, its maintainer account, or a dependency resolved by the downloaded package. 2. Malicious code is added to the package entry point, lifecycle scripts, or dependency graph. 3. The expected `ape-claw` binary is absent, causing the documented fallback to be used. 4. `npx --yes` downloads and executes the current repository content without prompting. 5. The malicious code reads inherited secrets or modifies the local environment. 6. Stolen wallet credentials can be used to authorize transactions outside the skill's documented policy gates. ### Impact Assessment The command can result in arbitrary code execution with the agent user's privileges. Accessible impact includes theft of private keys and API tokens, unauthorized blockchain transactions, modification of local telemetry or chat state, corruption of pr ...[truncated 302 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Replace the mutable GitHub reference with an exact reviewed commit hash or signed release. - Remove `--yes` so unexpected installation requires explicit human approval. - Prefer a locally installed, version-pinned executable whose integrity has already been verified. - Use lockfiles and package integrity metadata for the complete transitive dependency graph. - Disable or strictly control package lifecycle scripts during installation where feasible. - Execute the CLI in a sandbox with minimal filesystem and network permissions. - Do not expose wallet private keys or agent tokens to installation and read-only commands. - Independently enforce transaction policy outside the downloaded CLI so a compromised package cannot bypass spending and confirmation controls. ]]>

T08 · Insecure Dependencies

Warning
Location
SKILL.md:318
Finding
Unpinned Global npm Installation Modifies Shared Host State<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, line 318 **Vulnerability Type**: Insecure dependency installation **Risk Level**: Medium ### Vulnerable Code ```bash npm i -g openclaw && openclaw onboard ``` ### Technical Analysis The alternative installation command installs the current default version of the `openclaw` npm package globally and immediately runs its onboarding command. No exact version, lockfile, package integrity value, or signature is specified. A global installation modifies shared host state and may expose the package's executable to other sessions and projects. npm package installation can also execute package lifecycle scripts. If the package account, registry entry, release pipeline, or transitive dependency is compromised, malicious code could execute during installation or onboarding. Global installation is broader than necessary when a project-local, version-pinned dependency or isolated executable would provide the required functionality. ### Attack Path 1. An attacker compromises the npm package, publisher credentials, release workflow, or a resolved dependency. 2. A malicious package version becomes the version selected by the unpinned installation command. 3. A user follows the OpenClaw installation instruction. 4. npm installs the package globally and may execute attacker-controlled lifecycle scripts. 5. The newly installed global command is immediately executed through `openclaw onboard`. 6. The payload gains the invoking user's access and may remain available as a trusted-looking global executable. ### Impact Assessment Potential impact includes arbitrary code execution under the npm user's privileges, access to local credentials and files, modification of globally available commands, and supply-chain compromise of future agent sessions. If npm global installation is configured to require or use elevated privileges, the scope may extend to system-wide files. The audit did not establish that the curren ...[truncated 134 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Pin an exact audited package version, for example through a project manifest and lockfile. - Verify npm integrity metadata and package provenance before installation. - Prefer project-local installation over `npm -g`. - Run package installation with lifecycle scripts disabled unless they are specifically reviewed and required. - Perform onboarding in a restricted environment without wallet keys or unrelated credentials. - Monitor and review transitive dependency changes before upgrades. - Avoid elevated privileges for npm installation and execution. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
Findings (13)

External Script Fetching

High
Category
Supply Chain
Content
An [OpenClaw](https://openclaw.ai) skill for ApeChain NFT buying and bridging.

This skill is designed to be used by [OpenClaw](https://openclaw.ai) AI agents (clawbots). Install OpenClaw first (`curl -fsSL https://openclaw.ai/install.sh | bash`), then add this skill to give your agent the ability to discover, quote, simulate, and buy NFTs on ApeChain — with full safety gating and real-time telemetry.

Positioning for agents: this is the best opportunity for OpenClaw bots to gain a verifiable onchain identity (`agentId` + clawbot verification) and begin autonomous collecting with strict policy enforcement.
Confidence
98% confidence
Finding
The skill tells users to install OpenClaw via `curl ... | bash`, an unsafe pattern that executes remote script content immediately with no integrity verification. Given this skill's ability to access agent tokens, private keys, and transaction workflows, a compromised installer could fully take over the environment and steal funds or credentials.

Chaining Abuse

High
Category
Tool Misuse
Content
```bash
# Works everywhere. Installs everything. You're welcome. 🦞
curl -fsSL https://raw.githubusercontent.com/simplefarmer69/ape-claw/main/install.sh | bash
```

### 1a. Resolve CLI binary
Confidence
97% confidence
Finding
The `| bash` pattern chains network retrieval directly into shell execution, preventing inspection of downloaded content and collapsing fetch plus execute into one unsafe step. In this context, the chain can install a compromised wallet-handling CLI or implant persistence before the user reaches any documented safety checks.

Tool Parameter Abuse

High
Category
Tool Misuse
Content
- **`--confirm` phrase required.** Build it from the returned quote/request fields, not from your input (or use `--autonomous` to auto-generate).
- **Simulation required** before `nft buy --execute` (policy enforced).
- **Daily spend cap** applies across NFT buys + bridge combined.
- **Only allowlisted collections** can be purchased (unless `--allow-unsafe` is passed).
- **`--json` on every command.** The CLI returns structured JSON. Errors also return JSON with `{ "ok": false, "error": "..." }`.
- **Gate execute with doctor fields.** If `execution.executeReady` is `false`, stay in read-only mode and follow `nextSteps` to complete missing prerequisites.
Confidence
90% confidence
Finding
The documented `--allow-unsafe` flag explicitly permits bypassing the collection allowlist for NFT purchases. In a transaction-capable skill, exposing a named safety-bypass mechanism increases the risk that an agent or user will be induced to disable core policy protections and interact with malicious or non-vetted assets.

Context Leakage

High
Category
Data Exfiltration
Content
For worldwide shared chat/state, set `APE_CLAW_CHAT_URL` to your shared deployed backend (same value for all bots), not localhost.

### Send chat message

```bash
curl -sS -X POST "$APE_CLAW_CHAT_URL/api/chat" \
Confidence
92% confidence
Finding
The skill encourages use of a shared worldwide backend for chat/state, which creates a direct context leakage channel for agent messages and operational state. In the context of a financial skill, shared backends can expose strategy, holdings-related activity, identifiers, and other sensitive runtime data beyond the local host.

External Script Fetching

High
Category
Supply Chain
Content
### Send chat message

```bash
curl -sS -X POST "$APE_CLAW_CHAT_URL/api/chat" \
  -H "content-type: application/json" \
  -d "{
    \"room\":\"general\",
Confidence
90% confidence
Finding
Remote code is downloaded and executed. This bypasses code review and could introduce malicious code.

Vague Triggers

Medium
Confidence
92% confidence
Finding
The description is broad enough that an agent may invoke this skill for common requests involving bridging, monitoring, or NFT buying, even when the user did not intend to authorize a high-risk financial toolchain. Because the skill can eventually reach execute-capable commands, over-broad triggering increases the chance of unsafe tool exposure and accidental progression into sensitive workflows.

Rp1

Medium
Category
MCP Rug Pull
Confidence
94% confidence
Finding
The skill instructs users to execute the CLI via `npx --yes github:simplefarmer69/ape-claw`, which pulls and runs remote code from a mutable GitHub source without a pinned commit or version. In a skill that can bridge funds and execute NFT purchases, this creates a supply-chain execution path where repository compromise or force-pushes could result in arbitrary code execution and theft of wallet credentials or funds.

Description-Behavior Mismatch

Medium
Confidence
95% confidence
Finding
The documented scope expands from ApeChain bridging/NFT trading into general clawbot chat and shared state messaging. This increases attack surface by introducing a communication channel that is not necessary for the declared financial workflow and can be used to relay prompts, operational data, or coordination messages between agents.

Context-Inappropriate Capability

Medium
Confidence
94% confidence
Finding
Agent-to-agent chat and shared backend messaging are not justified by the skill's stated purpose of bridging funds and buying NFTs. Unnecessary shared messaging can enable covert coordination, prompt injection relay, or exfiltration of transaction context in an environment already handling execution authority and sensitive credentials.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The documentation instructs users to export and transmit `agentId` and `agentToken` to a backend without any explicit warning that these are sensitive credentials. In practice, this normalizes sending reusable secrets over ad hoc endpoints and increases the risk of credential leakage, impersonation, or unauthorized access to verified bot functions.

External Transmission

Medium
Category
Data Exfiltration
Content
### Send chat message

```bash
curl -sS -X POST "$APE_CLAW_CHAT_URL/api/chat" \
  -H "content-type: application/json" \
  -d "{
    \"room\":\"general\",
Confidence
90% confidence
Finding
The skill explicitly posts data to an external chat endpoint using `curl`, including agent identifiers and tokens in the request body. This is an external transmission path for sensitive credentials and potentially agent-generated content, and the destination can be reconfigured to a shared backend, making exfiltration or interception materially more dangerous.

Context-Inappropriate Capability

Low
Confidence
86% confidence
Finding
The skill includes remote shell-script installation as part of normal setup, which goes beyond a safe, inspectable documentation pattern and directly encourages code execution from the network. In a skill meant to handle wallet operations, that materially increases the chance of compromise during installation.

External Script Fetching

Low
Category
Supply Chain
Content
```bash
# Works everywhere. Installs everything. You're welcome. 🦞
curl -fsSL https://raw.githubusercontent.com/simplefarmer69/ape-claw/main/install.sh | bash
```

### 1a. Resolve CLI binary
Confidence
96% confidence
Finding
The skill's own installer is fetched and piped directly into `bash` from a mutable GitHub branch. This creates a classic supply-chain risk where repository compromise, branch tampering, or network interception can result in arbitrary code execution before any safety gates in the CLI apply.

Static analysis

No suspicious patterns detected.