Back to skill

Security audit

Claws Nft

Security checks for vulnerabilities and agentic risk

Overview

The skill has a coherent NFT-minting purpose, but it asks users to sign a server-created Solana transaction without requiring transaction validation first.

Install only if you are comfortable reviewing the transaction before signing. Use a dedicated wallet funded with only the minimum SOL needed, decode the transaction independently, verify expected mint programs/accounts/fees/transfers, and abort if anything is unclear or extra.

Vulnerability Patterns
  • 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
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (1)

T09 · Insecure Skill Coding Practices

Error
Location
SKILL.md:73
Finding
Unverified Signing of a Server-Controlled Solana Transaction<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 73–105 **Vulnerability Type**: Blind signing of an opaque, remotely supplied blockchain transaction **Risk Level**: High ### Vulnerable Code ```javascript const tx = VersionedTransaction.deserialize( Buffer.from(transaction, "base64") ); tx.sign([yourKeypair]); ``` ```javascript const signedTxBase64 = Buffer.from(tx.serialize()).toString("base64"); ``` ```bash curl -X POST https://clawsnft.com/api/execute \ -H "Content-Type: application/json" \ -d '{ "transaction": "<base64_encoded_signed_transaction>" }' ``` ### Technical Analysis The Skill instructs the agent to deserialize a base64-encoded Solana versioned transaction supplied by the remote `/api/mint` endpoint and sign it using the user's keypair. It does not require semantic validation of the transaction before signing. No checks are specified for: - Solana program IDs invoked by the transaction - Instruction types and instruction data - Recipient and destination accounts - SOL or SPL token transfer amounts - Signer and writable-account permissions - Mint, Candy Machine, collection, or backend signer addresses - Address lookup tables used by the versioned transaction - Additional instructions unrelated to the intended NFT mint - Transaction fees and the user's maximum expected cost - Authority delegation, approval, revocation, or account-closing operations Local signing protects the private key from direct disclosure, but it does not protect assets from malicious transactions authorized by that key. A malicious or compromised backend can return a transaction containing unintended instructions alongside, or instead of, the expected NFT mint operation. Once signed, the transaction carries valid authorization from the wallet. Submitting the signed transaction back to the service compounds the issue because the backend controls both transaction construction and the suggested submission channel. The documentation prov ...[truncated 2063 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. **Decode and validate every transaction before signing** - Parse every compiled instruction, including instructions that use address lookup tables. - Reject transactions containing unknown, unsupported, or unparseable instructions. - Do not rely solely on a backend-provided description of transaction behavior. 2. **Use strict allowlists** - Allow only the expected Solana program IDs. - Pin the expected Candy Machine, collection, mint authority, backend signer, treasury, and recipient addresses. - Reject unexpected signer accounts, writable accounts, program invocations, and address lookup tables. 3. **Validate financial effects** - Calculate the maximum SOL debit, token movements, rent, mint price, and transaction fees. - Enforce a documented maximum cost. - Reject transfers or debits unrelated to the intended mint. 4. **Validate instruction semantics** - Require the exact expected mint instruction sequence. - Reject token approvals, delegate assignments, authority changes, account closures, arbitrary transfers, and unrelated instructions. - Verify that the returned `nftMint` matches the mint account encoded in the transaction. 5. **Present a human-readable summary** - Display programs, accounts, transfers, fees, mint identity, and all expected balance changes. - Require explicit user approval after presenting this information and before accessing the signing key. 6. **Limit wallet exposure** - Recommend a dedicated wallet funded only with the minimum amount needed for the verified mint and fees. - Avoid using a wallet that holds unrelated SOL, tokens, NFTs, or valuable authorities. 7. **Use an independent submission path** - After validation and signing, submit through a trusted Solana RPC provider rather than returning the signed transaction exclusively to the transaction-construction service. - Verify transaction confirmation and post-transaction balance changes i ...[truncated 227 chars]
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Rogue AgentSelf-Modification, Session Persistence
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
Findings (6)

Intent-Code Divergence

High
Confidence
98% confidence
Finding
The skill claims it does not execute arbitrary code, yet the mint flow explicitly tells the user/agent to evaluate challenge content that may be 'math, code, or logic.' If challenge prompts are supplied by a remote server and code evaluation is performed automatically, this can lead to untrusted code execution or unsafe interpretation of attacker-controlled input.

Session Persistence

Medium
Category
Rogue Agent
Content
**Install locally:**
```bash
mkdir -p ~/.openclaw/skills/claws-nft
curl -s https://clawsnft.com/skill.md > ~/.openclaw/skills/claws-nft/SKILL.md
```
Confidence
60% confidence
Finding
Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.

Skill Enumeration

Medium
Category
Agent Snooping
Content
**Install locally:**
```bash
mkdir -p ~/.openclaw/skills/claws-nft
curl -s https://clawsnft.com/skill.md > ~/.openclaw/skills/claws-nft/SKILL.md
```

**Or just read the URL directly!**
Confidence
80% confidence
Finding
Skill enumerates or reads other installed skills. Access to other skills' SKILL.md files or the skills directory reveals prompt instructions, capabilities, and secrets that should be invisible to peer skills.

External Transmission

Medium
Category
Data Exfiltration
Content
**Install locally:**
```bash
mkdir -p ~/.openclaw/skills/claws-nft
curl -s https://clawsnft.com/skill.md > ~/.openclaw/skills/claws-nft/SKILL.md
```

**Or just read the URL directly!**
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Unrestricted Tool Access

Medium
Category
Excessive Agency
Content
🔒 **CRITICAL:**

- Your Solana private key should **never** leave your local environment — signing happens locally
- This skill makes only HTTPS API calls. It does not access your filesystem, run shell commands, or execute arbitrary code

## How It Works
Confidence
80% confidence
Finding
Skill grants unrestricted tool access without appropriate constraints. An agent with unfettered tool access can perform arbitrary actions including file modification, network requests, and code execution.

Missing User Warnings

Medium
Confidence
98% confidence
Finding
The skill instructs the user/agent to deserialize, sign, and submit a backend-provided Solana transaction without requiring inspection of the instructions, accounts, fees, or transfers. A partially signed transaction from a remote service could include unintended token/SOL transfers, approvals, or other harmful instructions, causing wallet loss once countersigned.

Static analysis

No suspicious patterns detected.