Back to skill

Security audit

CHEESE Agent Marketplace

Security checks for vulnerabilities and agentic risk

Overview

This skill is for a real on-chain work marketplace, but it asks users to run unaudited external code with wallet keys and money-moving authority.

Review this carefully before installing. Use only a dedicated low-balance wallet, verify the external ~/clawd/cheese repository and lockfiles yourself, avoid unpinned npx execution, pin or audit Docker images, and require explicit transaction review before creating, accepting, completing, or claiming any request.

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

T08 · Insecure Dependencies

Error
Location
SKILL.md:6
Finding
Unpinned Dependency Execution and Unauditable External Components## Vulnerability Details **File Location**: `SKILL.md`, lines 6, 23, 134–195, and 243–248 **Vulnerability Type**: Unpinned third-party dependency and execution of external components outside the audited project **Risk Level**: High ### Vulnerable Code ```yaml metadata: {"clawdbot":{"emoji":"🧀","requires":{"bins":["npx"]}}} ``` ```bash npx tsx scripts/cheese-cli.ts chat read <request_address> --watch ``` ```bash cd ~/clawd/cheese npx tsx scripts/cheese-cli.ts <command> [options] ``` ```typescript const client = new CHEESEClient({ wallet: { privateKey: process.env.CHEESE_PRIVATE_KEY as `0x${string}` }, rpcUrl: process.env.CHEESE_RPC_URL, }); ``` ```bash cd ~/clawd/cheese/infra/waku docker compose up -d ``` ### Technical Analysis The Skill repeatedly invokes `npx tsx` without pinning the `tsx` package to a reviewed version or supplying a lockfile or integrity hash. If `tsx` is unavailable locally, `npx` may retrieve and execute a package from the npm registry. Consequently, the code executed at runtime may differ from what was reviewed. The invoked CLI, SDK, and Docker Compose files are referenced under `~/clawd/cheese`, but they are not included in the audited project. The audited package contains only `SKILL.md`. Their behavior therefore cannot be verified even though the instructions expect these external components to: - Access `CHEESE_PRIVATE_KEY`. - Connect to external RPC and Waku services. - Sign and submit blockchain transactions. - Move escrow and collateral funds. - Start persistent Docker containers. - Process marketplace communications. This creates a supply-chain trust boundary around components with direct access to sensitive credentials and financial operations. ### Attack Path 1. An attacker compromises the unpinned npm dependency, substitutes the external `~/clawd/cheese` checkout, or alters an unpinned Docker image used by the referenced Compose configuration. 2. A user follows the Skill instructions and runs `npx tsx scripts/c ...[truncated 1240 chars]
Remediation
## Remediation Suggestions 1. Include the complete CLI, SDK, dependency manifests, lockfiles, and Docker Compose configuration in the Skill package so all executed components can be audited. 2. Pin `tsx` and every other npm dependency to exact reviewed versions. Commit a lockfile and enforce integrity verification during installation. 3. Avoid runtime package retrieval. Install dependencies through a controlled build process and invoke a pinned local binary, preferably with offline execution enabled. 4. Pin container images by immutable digest rather than mutable tags, and document their provenance. 5. Pin the external repository to a verified commit and validate its cryptographic checksum before execution. 6. Isolate wallet signing from the CLI. Prefer a hardware wallet, restricted signer, or approval interface instead of exposing a raw private key to general-purpose scripts. 7. Require explicit user confirmation before every transaction, displaying the chain ID, contract address, method, recipient, token, amount, and calldata summary. 8. Run the CLI and containers with least privilege, restricted filesystem mounts, a minimal environment, and narrowly scoped network access. 9. Never pass the wallet key to Waku or unrelated container services. Separate chat and transaction-signing processes and provide each only the credentials it strictly requires.
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Rogue AgentSelf-Modification, Session Persistence
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (14)

Natural-Language Policy Violations

Medium
Confidence
91% confidence
Finding
The skill mandates a specific communication channel ('YOU MUST USE WAKU CHAT') and frames it as non-optional, without user opt-in or safer alternatives. This can coerce agents into connecting to additional infrastructure, running persistent watchers, and sharing operational details through a channel they may not have independently trusted or configured.

Rp1

Medium
Category
MCP Rug Pull
Confidence
90% confidence
Finding
The skill repeatedly instructs the agent to run `npx tsx ...`, which can fetch and execute packages without a pinned version, creating a supply-chain execution risk. In this skill, those commands are tied to wallet operations and escrow handling, so a compromised or changed package could directly affect funds, secrets, or transaction behavior.

Rp1

Medium
Category
MCP Rug Pull
Confidence
90% confidence
Finding
Using `npx tsx` without version pinning allows remote code resolution at execution time, which is unsafe for a skill that may be run by autonomous agents. Because this marketplace skill handles private keys, chat signing, and on-chain actions, even a transient dependency compromise could lead to theft or unauthorized transactions.

Rp1

Medium
Category
MCP Rug Pull
Confidence
90% confidence
Finding
The command example invokes `npx tsx` in a way that may download and execute whatever version is current at runtime. In the context of a financial/on-chain skill, that materially increases the blast radius of a package takeover or typo-supply-chain event.

Rp1

Medium
Category
MCP Rug Pull
Confidence
90% confidence
Finding
This instruction relies on unpinned `npx tsx`, exposing agents to unintended code execution from dependency resolution. Since the surrounding workflow includes browsing and later accepting on-chain jobs, compromise here can pivot into wallet or transaction abuse.

Rp1

Medium
Category
MCP Rug Pull
Confidence
90% confidence
Finding
The `details` example still uses unpinned `npx tsx`, so an agent following documentation could execute attacker-controlled dependency code before any trust decision is made. That risk is amplified by the skill's access to environment-stored private keys and RPC endpoints.

Session Persistence

Medium
Category
Rogue Agent
Content
# Get request details
npx tsx scripts/cheese-cli.ts details 0x1234...

# Create a new request (interactive)
npx tsx scripts/cheese-cli.ts create

# Accept and complete a request
Confidence
80% confidence
Finding
The documented workflow encourages interactive creation followed by acceptance/completion flows that imply ongoing stateful participation and wallet context across steps. Combined with the surrounding instructions to continuously watch chat, this can lead agents to maintain long-lived sessions with sensitive environment variables and unclear boundaries between requests, increasing the chance of cross-request confusion or unintended actions.

Rp1

Medium
Category
MCP Rug Pull
Confidence
90% confidence
Finding
The interactive `create` flow is launched via unpinned `npx tsx`, enabling arbitrary package code execution at a sensitive point where the user is about to create escrowed requests. A malicious dependency could alter prompts, exfiltrate keys, or submit different transaction parameters.

Rp1

Medium
Category
MCP Rug Pull
Confidence
90% confidence
Finding
The accept command is especially sensitive because it deposits collateral, yet it is invoked through unpinned `npx tsx`. A compromised dependency could change the target address, collateral amount, or capture secrets, causing direct financial loss.

Rp1

Medium
Category
MCP Rug Pull
Confidence
90% confidence
Finding
Completing a request via unpinned `npx tsx` introduces supply-chain risk into a state-changing on-chain action. If the executed package is malicious or unexpectedly updated, it could mis-handle settlement or submit unauthorized transactions.

Rp1

Medium
Category
MCP Rug Pull
Confidence
90% confidence
Finding
Claiming funds is a wallet-sensitive operation, and routing it through unpinned `npx tsx` makes remote dependency compromise directly exploitable. In this context, the impact includes fund redirection, private key theft, or silent transaction manipulation.

Rp1

Medium
Category
MCP Rug Pull
Confidence
85% confidence
Finding
Even the chat-status operation is launched via unpinned `npx tsx`, which can still execute arbitrary dependency code on the host. While less immediately dangerous than a fund-moving command, it still provides a foothold in an environment that stores wallet credentials.

Rp1

Medium
Category
MCP Rug Pull
Confidence
90% confidence
Finding
Sending signed chat messages through unpinned `npx tsx` is risky because it combines dependency execution with wallet-based signing. A malicious package could exfiltrate keys, forge messages, or manipulate request identifiers, affecting disputes and fund release outcomes.

Rp1

Medium
Category
MCP Rug Pull
Confidence
85% confidence
Finding
Watching chat via unpinned `npx tsx` remains a code-execution risk despite being presented as a monitoring command. Because the skill strongly pressures continuous monitoring, users may keep a potentially compromised process running for long periods, increasing exposure.

Static analysis

No suspicious patterns detected.