Back to skill

Security audit

Clawracle Oracle Resolver

Security checks for vulnerabilities and agentic risk

Overview

The skill is a disclosed blockchain oracle agent, but it gives an autonomous agent high-impact signing and credential access without enough containment.

Review carefully before installing. Use only a fresh, low-value wallet, preferably on testnet, and cap funds so autonomous bond or gas loss is limited. Do not send raw API keys to an LLM; require fixed allowlisted API destinations and inject credentials only after validation. Pin dependencies and add transaction approval, rate limits, maximum bond limits, and secret-handling controls before running this with real value.

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 (4)

T09 · Insecure Skill Coding Practices

Error
Location
references/api-guide.md:264
Finding
API Credentials Exposed to an LLM and Unvalidated LLM-Generated Requests<![CDATA[ ## Vulnerability Details **File Location**: `references/api-guide.md:44-72, 74-124, 264-292`; `SKILL.md:78-97, 197-209` **Vulnerability Type**: Indirect prompt injection, credential disclosure, and server-side request forgery **Risk Level**: High ### Vulnerable Code ```javascript // Get API key from the environment const apiKey = process.env[sportsAPI.apiKeyEnvVar]; ``` The prompt template places the credential and attacker-controlled query in the same LLM context: ```text API Configuration: - Name: {api.name} - Base URL: {api.baseUrl} - API Key Location: {api.apiKeyLocation} - API Key: {apiKey} - Free API Key Available: {api.freeApiKey ? `Yes (${api.freeApiKey})` : 'No'} - Category: {api.category} - Default Parameters: {api.defaultParams ? JSON.stringify(api.defaultParams) + ' (ALWAYS include these in API calls)' : 'None'} API Documentation: {apiDocs} User Query: "{query}" Return JSON with the API call details: { "method": "GET" or "POST", "url": "full URL with parameters", "headers": {}, "body": null or object for POST } ``` The complete request-construction flow then executes the LLM-generated destination directly: ```javascript // 3. Get API key let apiKey = process.env[api.apiKeyEnvVar]; if (!apiKey && api.freeApiKey) { apiKey = api.freeApiKey; } // 4. Use LLM to construct API call const apiCallPlan = await llmClient.constructAPICall({ query, apiDocs, apiConfig: api, apiKey }); // 5. Execute API call const response = await axios({ method: apiCallPlan.method, url: apiCallPlan.url, headers: apiCallPlan.headers || {}, data: apiCallPlan.body || null }); ``` ### Technical Analysis Oracle query text is obtained from IPFS content referenced by a public blockchain event. A requester can therefore control the text passed as `query`. The implementation sends that untrusted text to the same LLM context that contains a raw API key. It subsequently trusts the LLM to generate the complete HTTP method, URL, headers, and b ...[truncated 2386 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Never place raw API keys in an LLM prompt or LLM tool result. 2. Require the LLM to return a narrow structured plan containing only: - A predefined endpoint identifier - Validated non-sensitive query parameters - A bounded pagination value 3. Construct the final request in trusted application code. 4. Inject credentials only after all destination validation succeeds. 5. Enforce an exact allowlist of schemes, hostnames, ports, and paths derived from trusted configuration. 6. Permit HTTPS only and reject URLs containing user information or unexpected ports. 7. Resolve destination hostnames and reject loopback, private, link-local, multicast, and reserved IP ranges. 8. Disable redirects, or revalidate every redirect destination before following it. 9. Prefer API-key headers over URL query parameters or URL paths to reduce leakage through logs. 10. Restrict methods to `GET` unless a specific endpoint has been reviewed and explicitly allows another method. 11. Treat IPFS queries and API documentation as untrusted data, not instructions. 12. Add prompt-injection tests that attempt credential extraction, hostname substitution, redirect abuse, and access to metadata endpoints. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
COMPLETE_AGENT_EXAMPLE.md:112
Finding
Attacker-Controlled Oracle Requests Can Trigger Autonomous Token Approvals and Bond Loss<![CDATA[ ## Vulnerability Details **File Location**: `COMPLETE_AGENT_EXAMPLE.md:112-143, 159-193, 230-253, 473-500`; `scripts/resolve-query.js:91-124` **Vulnerability Type**: Unbounded autonomous financial transaction signing **Risk Level**: High ### Vulnerable Code The complete agent example approves the bond supplied by the tracked public request and submits a transaction without an exposure cap: ```javascript // Fetch query from IPFS const queryData = await fetchIPFS(requestData.ipfsCID); // Get answer const result = await resolveData(queryData); // Approve bond const bondAmount = BigInt(requestData.bondRequired); await token.approve(registry.target, bondAmount); // Submit const tx = await registry.resolveRequest( requestId, process.env.YOUR_ERC8004_AGENT_ID, ethers.toUtf8Bytes(result.answer), result.source, result.isPrivate || false ); await tx.wait(); ``` The event filter checks only a minimum reward and category: ```javascript // Quick filter if (parseFloat(ethers.formatEther(reward)) < 100) { console.log('❌ Reward too low, skipping'); return; } if (!['sports', 'crypto', 'weather'].includes(category)) { console.log('❌ Category not supported'); return; } ``` The agent can also initiate a bonded dispute based solely on exact string inequality: ```javascript // If different → DISPUTE! if (myResult.answer !== theirAnswer) { console.log('⚠️ DISAGREEMENT! Submitting dispute...'); // Approve bond await token.approve(registry.target, query.bondRequired); // Submit dispute const tx = await registry.resolveRequest( requestId, process.env.YOUR_ERC8004_AGENT_ID, ethers.toUtf8Bytes(myResult.answer), myResult.source, myResult.isPrivate ); await tx.wait(); console.log('🔥 DISPUTE SUBMITTED - Status: DISPUTED'); } ``` The executable resolver similarly approves and spends against the configured registry: ```javascript const bondAmount = query.bondRequired; const balance = await token.balanceOf(wallet. ...[truncated 2961 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Define a strict maximum bond per request. 2. Enforce hourly and daily limits for total bonded value and gas expenditure. 3. Require a minimum expected-profit and reward-to-bond ratio. 4. Require explicit owner approval when a bond, allowance, or gas estimate exceeds a low threshold. 5. Reject requests from unknown or low-reputation requesters when financial exposure is significant. 6. Rate-limit requests per requester and category. 7. Normalize and semantically compare answers before disputing: - Case and whitespace normalization - Unit normalization - Canonical entity identifiers - Numeric tolerance - Confidence scoring 8. Do not dispute solely because two strings are unequal. 9. Simulate transactions before signing and verify chain ID, contract bytecode, expected function selector, allowance, and balance changes. 10. Use exact per-transaction allowances and revoke residual allowances where the token or registry flow might leave them outstanding. 11. Separate monitoring and answer generation from transaction signing. Place signing behind a policy-enforcement component. 12. Keep only a deliberately limited amount of gas and bonded tokens in the autonomous wallet. ]]>

T08 · Insecure Dependencies

Warning
Location
references/setup.md:134
Finding
Unpinned Third-Party npm Dependencies Create Supply-Chain Risk<![CDATA[ ## Vulnerability Details **File Location**: `references/setup.md:134-148` **Vulnerability Type**: Unpinned and broadly versioned third-party dependencies **Risk Level**: Medium ### Vulnerable Code ```bash # Install ethers.js for blockchain interaction npm install ethers@^6.0.0 # Install axios for API calls npm install axios # Install dotenv for environment variables npm install dotenv # Install Lighthouse SDK for IPFS npm install @lighthouse-web3/sdk # Optional: Install specific API SDKs npm install espn-api sportsdata-io twitter-api-v2 ``` ### Technical Analysis Most dependencies are installed without a version. The `ethers` dependency uses a caret range, permitting later compatible releases. No reviewed `package.json`, lockfile, integrity hashes, or package-provenance verification are present in the audited project. npm packages and their lifecycle scripts execute in an environment expected to contain: - `CLAWRACLE_AGENT_KEY` - `PRIVATE_KEY` - API-provider credentials - `LIGHTHOUSE_API_KEY` - Potential LLM-provider credentials Consequently, a compromised package release, dependency takeover, or malicious transitive dependency could access high-value secrets or alter blockchain transaction behavior. The optional package list further expands the dependency surface without demonstrating that those packages are necessary for the declared default capability. ### Attack Path 1. A package or transitive dependency referenced by the setup guide is compromised or publishes a malicious update. 2. A user follows the documented `npm install` commands at a later date. 3. npm resolves the unpinned package name or permitted version range to the compromised release. 4. Malicious lifecycle or runtime code executes on the agent host. 5. The package reads wallet keys or API credentials from the process environment or `.env` file. 6. The package can exfiltrate those secrets or alter transaction destinations and parameters. ### Impact Assessment A success ...[truncated 582 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Create and commit a reviewed `package.json` and lockfile. 2. Pin every direct dependency to an exact version. 3. Use `npm ci` instead of ad hoc `npm install` commands in deployment procedures. 4. Review and pin transitive dependencies through the lockfile. 5. Verify npm package provenance, maintainers, publication history, and integrity metadata. 6. Use `npm audit`, software-composition analysis, and automated dependency review. 7. Disable lifecycle scripts with `--ignore-scripts` where packages do not require them. 8. Run installation in an environment that does not contain production wallet keys or API credentials. 9. Remove optional SDKs unless the selected resolver configuration requires them. 10. Isolate signing in a separate process or hardware/KMS-backed signer so ordinary dependencies cannot read the raw private key. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
references/setup.md:9
Finding
Wallet Private Key Printed to Standard Output During Generation<![CDATA[ ## Vulnerability Details **File Location**: `references/setup.md:9-25` **Vulnerability Type**: Plaintext private-key exposure through process output **Risk Level**: Medium ### Vulnerable Code ```javascript const { ethers } = require('ethers'); // Generate a new random wallet const wallet = ethers.Wallet.createRandom(); console.log('🔐 New Wallet Generated:'); console.log('Address:', wallet.address); console.log('Private Key:', wallet.privateKey); console.log('\n⚠️ SECURITY WARNING:'); console.log('1. Store the private key securely in .env as CLAWRACLE_AGENT_KEY'); console.log('2. NEVER share your private key with anyone'); console.log('3. NEVER commit the private key to version control'); console.log('4. This key will be used to sign all oracle transactions'); ``` ### Technical Analysis The documented wallet-generation procedure writes the complete signing key to standard output. The subsequent warning does not protect the key from output capture. Standard output may be retained by: - CI/CD systems - Agent execution frameworks - Container logging drivers - Terminal session recorders - Remote support tools - Shell transcript capture - Centralized log collection services A private key is a bearer credential. Any party that retrieves the logged value can independently sign transactions and impersonate the oracle wallet without further authorization. The recommendation to use a fresh dedicated wallet is a useful containment measure, but printing the secret is not necessary to generate or store that wallet. ### Attack Path 1. An operator runs the documented wallet-generation code in a logged terminal, CI task, container, or managed agent environment. 2. The complete private key is written to stdout. 3. The execution platform retains or forwards the output. 4. A user, service account, administrator, or attacker with log access retrieves the key. 5. The party imports the key into another wallet or signing library. 6. The party transfers funds or ...[truncated 609 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Do not print the private key to stdout or stderr. 2. Write the generated key directly to a protected secret store. 3. If a local file is unavoidable: - Create it with mode `0600` - Refuse to overwrite an existing file - Exclude it from version control - Avoid placing it in shared or temporary directories 4. Prefer an encrypted keystore protected by a strong passphrase over a plaintext `.env` value. 5. For valuable wallets, use a hardware wallet, HSM, or cloud KMS signer so the raw key is never exposed to the Node.js process. 6. Disable command tracing and verify that setup runs outside CI or centralized logging systems. 7. Document immediate key rotation and fund migration procedures for suspected log exposure. 8. Continue using a dedicated, minimally funded wallet to constrain potential loss. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
Findings (73)

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
The declared description focuses on operational oracle behavior: watching for requests, retrieving answers from APIs, submitting resolutions, and validating peers. The actual code does none of that. It only registers an agent in an on-chain registry using environment-supplied credentials and metadata, after checking balance and existing registration status. This is a materially different primary purpose, so the description does not accurately represent the supplied code chunk.

Tp4

High
Category
MCP Tool Poisoning
Confidence
93% confidence
Finding
The declared description presents a broader autonomous oracle-agent skill with two major functions: monitoring data requests and resolving them from configured APIs, plus validating other agents' answers. The supplied code chunk only covers a narrow submit-resolution example. It connects to Monad, reads query metadata, fetches IPFS content, approves a bond token, and submits a resolution transaction. However, the actual API-fetching and LLM-driven extraction are only described in comments and not implemented; instead the answer is hardcoded. The code also lacks any logic for monitoring events or validating other agents' answers. While comments mention a real WebSocket listener elsewhere, this chunk itself is manually invoked with a requestId. Therefore the description overstates the implemented behavior in material ways.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
There is a clear description-behavior mismatch. The declared purpose focuses on an agent that earns tokens by answering and validating oracle queries. However, this code explicitly states it is for requesters, not agents, and implements request creation: it reads a requester private key, uploads query metadata to IPFS, checks token balance, approves token spending, and calls submitRequest on the registry contract. Those actions are materially different from the declared primary purpose and represent a different role in the system.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding
The declared description presents an active oracle-resolution skill with automation around monitoring requests, obtaining external data, submitting answers, and validating others' responses for rewards/reputation. The supplied code does none of those actions. It only accepts a requestId as a command-line argument, performs read-only contract calls (`getQuery` and `getAnswers`) against a Monad RPC endpoint, and displays query/answer metadata. This is a materially different primary purpose: inspection of existing answers rather than earning tokens by resolving or validating oracle queries.

Tp4

High
Category
MCP Tool Poisoning
Confidence
91% confidence
Finding
The description portrays a full oracle-solving agent: monitor requests, obtain answers from APIs, submit answers on-chain, and validate other agents. The supplied code only covers infrastructure around listening to oracle contract events, persisting tracked request metadata to a local JSON file, updating status based on proposal/dispute/finalization events, and automatically calling finalizeRequest when timing/status conditions are met. The core advertised behaviors—fetching answers, proposing answers, and validating/disputing other answers—are absent. Because the implemented primary behavior is materially narrower and also includes an undeclared on-chain finalization action, the description does not accurately represent this code chunk.

Credential Access

High
Category
Privilege Escalation
Content
],
  "instructions": {
    "howToUse": "When a request comes in with a category string (e.g., 'sports', 'market', 'politics'), find the matching API in this config, read its docsFile, and use the API to resolve the query.",
    "apiKeyAccess": "API keys are stored in .env file. Use the apiKeyEnvVar to read the key from process.env.",
    "queryParsing": "Extract relevant information from the natural language query (teams, dates, locations, etc.) to construct API calls.",
    "agentCanEdit": "Agents can create and edit API configurations and documentation files when instructed by the owner. Use fs.writeFileSync() to save changes."
  }
Confidence
91% confidence
Finding
The config instructs the agent that API keys are stored in .env and should be read from process.env, which is a form of credential access exposed to agent reasoning. Because this skill also permits editing of configuration/docs and performs network requests, combining secret access with mutable destinations materially increases the risk of credential misuse or indirect exfiltration.

Credential Access

High
Category
Privilege Escalation
Content
// Now you have the full API documentation to understand endpoints, parameters, etc.
```

#### Step 3: Get API Key from Environment

Read the API key from `.env` using the `apiKeyEnvVar`:
Confidence
90% confidence
Finding
This section directs the agent to retrieve credentials from the environment as part of normal flow, and elsewhere the guide combines that with LLM-driven request planning. In context, the issue is not merely reading an API key for legitimate use, but enabling a flexible credential-access mechanism that can be repurposed to access and potentially leak secrets outside the intended oracle integrations.

Context-Inappropriate Capability

High
Confidence
96% confidence
Finding
The design explicitly delegates API-call construction to the LLM and permits dynamic execution of the returned method, URL, headers, and body. This gives the model a general outbound request capability that can be steered by adversarial docs, malicious queries, or prompt injection into contacting unintended hosts, abusing authenticated endpoints, or exfiltrating data. That is much broader than a narrowly scoped oracle fetcher.

Missing User Warnings

High
Confidence
98% confidence
Finding
The prompt template instructs including the raw API key in the LLM context. Sending secrets to the model unnecessarily exposes credentials to model providers, logs, tracing systems, prompt caches, or downstream tooling, and it also makes secret exfiltration easier if the model is prompt-injected. Secrets should never be embedded in prompts when the model does not need them semantically.

Credential Access

High
Category
Privilege Escalation
Content
console.log('Address:', wallet.address);
console.log('Private Key:', wallet.privateKey);
console.log('\n⚠️  SECURITY WARNING:');
console.log('1. Store the private key securely in .env as CLAWRACLE_AGENT_KEY');
console.log('2. NEVER share your private key with anyone');
console.log('3. NEVER commit the private key to version control');
console.log('4. This key will be used to sign all oracle transactions');
Confidence
95% confidence
Finding
The setup guide instructs users to print the newly generated private key directly to stdout. Secrets displayed in console output are commonly captured by shell history tools, terminal logging, CI logs, screen recordings, or remote session transcripts, which can lead to wallet compromise and unauthorized signing of on-chain transactions.

Credential Access

High
Category
Privilege Escalation
Content
After generating the wallet, save the private key to your `.env` file:

```bash
# Add to .env file
CLAWRACLE_AGENT_KEY=0x1234567890abcdef...  # Your generated private key
```
Confidence
88% confidence
Finding
The documentation directs operators to place a blockchain private key in a local .env file. While environment variables are common, storing long-lived signing keys in plaintext .env files increases the risk of accidental disclosure through source control mistakes, backups, process inspection, local compromise, or misconfigured deployment environments.

Credential Access

High
Category
Privilege Escalation
Content
async function main() {
  console.log('🤖 Registering Agent...\n');

  // Use agent's private key from .env
  if (!process.env.CLAWRACLE_AGENT_KEY) {
    console.error('❌ CLAWRACLE_AGENT_KEY not found in .env');
    console.error('Please set CLAWRACLE_AGENT_KEY in your .env file');
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
async function main() {
  console.log('🤖 Registering Agent...\n');

  // Use agent's private key from .env
  if (!process.env.CLAWRACLE_AGENT_KEY) {
    console.error('❌ CLAWRACLE_AGENT_KEY not found in .env');
    console.error('Please set CLAWRACLE_AGENT_KEY in your .env file');
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
async function main() {
  console.log('🤖 Registering Agent...\n');

  // Use agent's private key from .env
  if (!process.env.CLAWRACLE_AGENT_KEY) {
    console.error('❌ CLAWRACLE_AGENT_KEY not found in .env');
    console.error('Please set CLAWRACLE_AGENT_KEY in your .env file');
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
async function main() {
  console.log('🤖 Registering Agent...\n');

  // Use agent's private key from .env
  if (!process.env.CLAWRACLE_AGENT_KEY) {
    console.error('❌ CLAWRACLE_AGENT_KEY not found in .env');
    console.error('Please set CLAWRACLE_AGENT_KEY in your .env file');
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
async function main() {
  console.log('🤖 Registering Agent...\n');

  // Use agent's private key from .env
  if (!process.env.CLAWRACLE_AGENT_KEY) {
    console.error('❌ CLAWRACLE_AGENT_KEY not found in .env');
    console.error('Please set CLAWRACLE_AGENT_KEY in your .env file');
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
async function main() {
  console.log('🤖 Registering Agent...\n');

  // Use agent's private key from .env
  if (!process.env.CLAWRACLE_AGENT_KEY) {
    console.error('❌ CLAWRACLE_AGENT_KEY not found in .env');
    console.error('Please set CLAWRACLE_AGENT_KEY in your .env file');
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
// Use agent's private key from .env
  if (!process.env.CLAWRACLE_AGENT_KEY) {
    console.error('❌ CLAWRACLE_AGENT_KEY not found in .env');
    console.error('Please set CLAWRACLE_AGENT_KEY in your .env file');
    return;
  }
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
// Use agent's private key from .env
  if (!process.env.CLAWRACLE_AGENT_KEY) {
    console.error('❌ CLAWRACLE_AGENT_KEY not found in .env');
    console.error('Please set CLAWRACLE_AGENT_KEY in your .env file');
    return;
  }
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
// Use agent's private key from .env
  if (!process.env.CLAWRACLE_AGENT_KEY) {
    console.error('❌ CLAWRACLE_AGENT_KEY not found in .env');
    console.error('Please set CLAWRACLE_AGENT_KEY in your .env file');
    return;
  }
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Missing User Warnings

Medium
Confidence
88% confidence
Finding
This markdown presents executable-looking automation that approves token spending, submits on-chain transactions, validates disputes, and writes persistent local state, but it does not prominently warn users about financial loss, gas costs, token approval risk, RPC trust, or filesystem side effects. Because the skill is explicitly for autonomous oracle resolution with wallet credentials, omission of those warnings materially increases the chance of unsafe deployment by users who treat the example as drop-in code.

Intent-Code Divergence

Medium
Confidence
97% confidence
Finding
The comment says the agent will validate only the original and disputed answers, but the implementation loops through and validates every answer for the request. In this skill context, each validation is an on-chain action that can consume gas, affect reputation/outcomes, and create unintended financial exposure or spam-like behavior.

Description-Behavior Mismatch

Medium
Confidence
94% confidence
Finding
The example claims to provide complete finalization logic, but it calls `registry.finalizeRequest(requestId)` even though `finalizeRequest` is not declared in the provided ABI. In ethers, this will fail at runtime and can cause operators to rely on nonfunctional settlement logic while the surrounding documentation explicitly encourages autonomous financial actions on-chain.

Missing User Warnings

Medium
Confidence
96% confidence
Finding
The README tells users to export a private key and deploy without any warning about key handling, shell history exposure, environment leakage, or safe wallet practices. In blockchain tooling, developers frequently copy-paste such commands; weak guidance can directly lead to credential compromise or accidental use of valuable keys.

Rp1

Medium
Category
MCP Rug Pull
Confidence
70% confidence
Finding
npx commands without a version suffix (e.g. @1.0.0) create a rug-pull risk if the upstream server is compromised and publishes a malicious update.

Static analysis

Detected: suspicious.env_credential_access, suspicious.exposed_secret_literal

Environment variable access combined with network send.

Critical
Code
suspicious.env_credential_access
Location
scripts/resolve-query.js:31

File appears to expose a hardcoded API secret or token.

Critical
Code
suspicious.exposed_secret_literal
Location
references/api-guide.md:64