Back to skill

Security audit

Clawked

Security checks for vulnerabilities and agentic risk

Overview

The skill is purpose-aligned but should be reviewed because it recommends unpinned npm execution for cryptocurrency privacy operations that handle withdrawal secrets and can be registered persistently as an MCP server.

Install only if you are comfortable trusting the current and future `ceaser-mcp` npm package with local execution, note secrets, and withdrawal flows. Prefer a pinned, audited version, verify transaction recipients and outputs before signing or settling, and treat backups and `~/.ceaser-mcp/notes.json` as funds-controlling secrets that should not enter chats, logs, shell history, or insecure backups.

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:198
Finding
Unpinned Remote npm Package Is Automatically Downloaded and Executed<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 198–239; repeated at lines 260–284 **Vulnerability Type**: `T08: Insecure Dependencies` **Risk Level**: Medium ### Vulnerable Code ```bash npx -y ceaser-mcp shield 0.001 ``` ```bash npx -y ceaser-mcp notes ``` ```bash npx -y ceaser-mcp unshield <noteId> 0x742d35Cc6634C0532925a3b844Bc9e7595f2bD18 ``` ```bash npx -y ceaser-mcp import eyJzIjoiMTIzLi4uIn0= ``` ```bash npx -y ceaser-mcp help ``` The same unsafe dependency execution pattern is repeated in the transaction instructions: ```bash # Shield npx -y ceaser-mcp shield 0.001 # List notes to get noteId npx -y ceaser-mcp notes # Unshield npx -y ceaser-mcp unshield <noteId> <recipient> ``` It is also used when registering the package as an MCP server: ```bash claude mcp add --transport stdio ceaser -- npx -y ceaser-mcp ``` ### Technical Analysis The Skill directs the Agent to invoke `npx -y ceaser-mcp` without an exact package version or integrity constraint. If the package is not already present in the local npm cache, `npx` can retrieve the package from the configured npm registry and immediately execute it. The `-y` option suppresses the normal installation confirmation. Consequently, the effective executable payload is not fixed by the audited Skill files. It can change when a new package release is published, when registry resolution changes, or if the publisher account, package, registry, or local npm configuration is compromised. The risk is elevated because the package is expected to: - Generate zero-knowledge proofs. - Read and write privacy-note secrets. - Import note backup material. - Construct cryptocurrency transactions. - Select withdrawal recipients and submit settlement requests. - Run persistently as an MCP server with access to the Agent's tool environment. The package source and dependency tree are not included in the audited project, so their implementation and security properties could not be verified. ...[truncated 1762 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin the package to an exact, reviewed version: ```bash npx --yes ceaser-mcp@<audited-exact-version> shield 0.001 ``` Do not use version ranges or tags such as `latest`. 2. Verify package integrity using a lockfile, an approved npm cache, or an artifact whose cryptographic digest is validated before execution. 3. Prefer vendoring the reviewed package and its locked dependency tree into a controlled distribution instead of downloading executable code at invocation time. 4. Audit the package source, install scripts, transitive dependencies, proof-generation behavior, note-storage behavior, recipient handling, and network destinations before approval. 5. Remove automatic `-y` installation where feasible. Require explicit user approval before downloading or installing executable dependencies. 6. Separate dependency installation from financial operations. Installation should occur during a controlled setup phase, not while processing a shield or unshield request. 7. Run the package in a restricted environment with: - Minimal filesystem access. - No unrelated credentials in environment variables. - Network egress limited to required, verified endpoints. - A dedicated low-privilege operating-system account or sandbox. 8. Require explicit confirmation that displays the chain, contract, amount, fees, destination address, and transaction data before every financial operation. 9. Pin and verify the command used for MCP registration as well as the CLI commands. Do not register an unversioned package as a trusted MCP server. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:205
Finding
Spend-Authorizing Privacy-Note Secrets Are Stored in a Predictable JSON File Without Documented Protection<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 205–239 **Vulnerability Type**: `T09: Insecure Skill Coding Practices` **Risk Level**: Medium ### Vulnerable Code ```text IMPORTANT: The `backup` field in the output contains the note's private keys. It MUST be saved securely -- it is the only way to later unshield the funds. ``` ```bash npx -y ceaser-mcp import eyJzIjoiMTIzLi4uIn0= ``` ```text Notes are stored at `~/.ceaser-mcp/notes.json`. All commands output JSON to stdout on success and JSON to stderr on failure. ``` The Skill further explains the sensitivity of the stored content: ```text Note: A private record containing secret, nullifier, amount, and commitment. Notes are never stored on-chain -- only their Poseidon hash (commitment) is. ``` ### Technical Analysis The Skill identifies note backups as containing private keys and defines a note as containing the secret and nullifier required for withdrawal. It then documents storage in the predictable path `~/.ceaser-mcp/notes.json`. The audited files do not specify encryption at rest, restrictive file permissions, operating-system keystore integration, access isolation, or protection from backup and indexing services. They also state that command results are emitted as JSON to standard output or standard error. In Agent or automation environments, these streams may be captured in transcripts, build logs, telemetry, shell history, or diagnostic records. The actual `ceaser-mcp` implementation is not included, so this audit cannot establish whether the package independently applies secure permissions or encryption. The confirmed weakness in the Skill is that it directs users toward storage and output of highly sensitive withdrawal material without defining or enforcing the controls necessary for that material. ### Attack Path 1. A user shields ETH or imports an existing note through the documented CLI. 2. The package stores the note, including withdrawal-authorizing secret mat ...[truncated 1650 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Encrypt note secrets at rest with authenticated encryption. Derive the encryption key from a user-controlled secret or store it in an operating-system credential manager, hardware-backed keystore, or supported wallet. 2. Enforce restrictive permissions when creating storage: - Set the `~/.ceaser-mcp` directory to mode `0700`. - Set `notes.json`, if retained, to mode `0600`. - Reject operation or prominently warn the user if ownership or permissions are unsafe. 3. Avoid storing plaintext note backups in a general JSON file. Separate public metadata from withdrawal-authorizing secrets and minimize the duration for which decrypted secrets remain on disk or in memory. 4. Do not print note private keys or complete backup strings to standard output or standard error by default. Use a dedicated secure export operation requiring explicit user confirmation. 5. Redact secrets from Agent transcripts, shell history, diagnostics, telemetry, crash reports, and structured logs. Output only a secret reference or confirmation unless the user explicitly requests an export. 6. Warn users that copying a backup into a chat, command line, log, issue report, or clipboard manager can compromise funds. 7. Provide secure backup guidance, including offline encrypted backups, recovery testing, rotation where supported, and secure deletion of obsolete copies. 8. Validate recipient addresses and require explicit confirmation before unshielding. The confirmation should display the selected note, amount, network, protocol fee, and complete recipient address. 9. Document the package's actual encryption, permissions, secret lifecycle, and logging guarantees. Add automated tests that verify safe permissions and confirm that secrets never appear in routine command output or logs. ]]>
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
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (19)

Rp1

Medium
Category
MCP Rug Pull
Confidence
91% confidence
Finding
The manifest/metadata references running `npx ceaser-mcp` without a fixed version, which bakes an unpinned remote execution dependency into the skill itself. This creates a reproducibility and supply-chain trust problem at the foundation of the skill.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
The skill repeatedly instructs agents to run `npx ceaser-mcp` without pinning an exact package version. Because `npx` fetches and executes remote npm code at runtime, a compromised publisher account, malicious update, or dependency hijack could result in arbitrary code execution on the agent host.

External Transmission

Medium
Category
Data Exfiltration
Content
### Verify a ZK proof (dry run, no on-chain submission)

```bash
curl -s -X POST "https://ceaser.org/verify" \
  -H "Content-Type: application/json" \
  -d '{
    "protocol": "ceaser",
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
### Submit ZK proof on-chain (gasless settlement)

```bash
curl -s -X POST "https://ceaser.org/settle" \
  -H "Content-Type: application/json" \
  -d '{
    "protocol": "ceaser",
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
This builds an unsigned transaction for shielding ETH. The user must sign and submit it from their own wallet.

```bash
curl -s -X POST "https://ceaser.org/api/ceaser/shield/prepare" \
  -H "Content-Type: application/json" \
  -d '{
    "proof": "0x...",
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
This line tells agents to generate proofs using `ceaser-mcp` from npm without a version pin. That creates a supply-chain execution path where the package contents can change over time and arbitrary code may run locally with access to filesystem data and environment context.

Context-Inappropriate Capability

Medium
Confidence
90% confidence
Finding
The skill explicitly instructs agents to install and run an external npm package via `npx`, which goes beyond passive API interaction and grants third-party code execution on the local system. In this skill's context, that code also handles privacy-sensitive proofs, note backups, and transaction-related data, increasing the consequences of compromise.

Rp1

Medium
Category
MCP Rug Pull
Confidence
97% confidence
Finding
Running `npx -y ceaser-mcp shield 0.001` executes unpinned third-party npm code and also initiates privacy-sensitive transaction preparation. The combination of code execution plus handling wallet-related data increases the risk from any malicious or trojanized package update.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
The `notes` example uses `npx -y ceaser-mcp` without version pinning, allowing runtime retrieval and execution of mutable external code. Because this command reads local note state, a malicious package version could exfiltrate private note material or other local secrets.

Rp1

Medium
Category
MCP Rug Pull
Confidence
97% confidence
Finding
The unshield command executes unpinned npm code while handling private note material and generating a withdrawal proof. If the package or dependency chain is compromised, attackers could steal notes, redirect recipients, or tamper with proof submission logic.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
The import command runs a floating npm package against highly sensitive backup strings that represent note secrets. Unpinned execution here is especially dangerous because the command processes exactly the kind of secret material an attacker would want to capture.

Rp1

Medium
Category
MCP Rug Pull
Confidence
93% confidence
Finding
Even the help command uses unpinned `npx`, which still downloads and executes remote code. Although less directly sensitive than shield/unshield flows, it remains a supply-chain execution risk with unnecessary exposure.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
The skill states that notes are stored at `~/.ceaser-mcp/notes.json` but does not clearly warn that this file may contain private note material whose disclosure can enable theft or loss of privacy. In a privacy-protocol skill, omission of filesystem-sensitivity guidance materially increases the chance of unsafe handling.

Missing User Warnings

Medium
Confidence
90% confidence
Finding
The recommended transaction commands are presented as straightforward operational steps without clearly warning that they execute third-party code via `npx` and create or submit privacy-sensitive transaction data. This can mislead agents or users into treating the flow as low-risk when it combines code execution, secret handling, and financial operations.

Rp1

Medium
Category
MCP Rug Pull
Confidence
97% confidence
Finding
This recommended shield workflow again instructs execution of unpinned npm code for a transaction-creation path. The skill context makes this more dangerous because the command produces private note backups and transaction payloads that could be altered or exfiltrated by malicious code.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
This line recommends unpinned execution for listing notes, exposing local private state to mutable external code. A malicious update could harvest notes or profile user balances and activity.

Rp1

Medium
Category
MCP Rug Pull
Confidence
97% confidence
Finding
This unshield example combines unpinned code execution with a withdrawal operation to an arbitrary recipient address. If tampered, the package could redirect funds, leak note secrets, or submit manipulated proofs.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
The MCP server setup command invokes `npx -y ceaser-mcp` without pinning, embedding a floating remote code execution path into agent configuration. That can persistently expose the host environment to compromised package updates beyond a single command invocation.

Context-Inappropriate Capability

Low
Confidence
84% confidence
Finding
The skill introduces local storage and import of private note backup material, which is sensitive secret data capable of controlling withdrawals. While this is functionally related to the protocol, the guidance underemphasizes the security implications of creating, storing, and importing such material on the local host.

Static analysis

No suspicious patterns detected.