Back to skill

Security audit

Agent Gary AI Powered Memecoin trader.

Security checks for vulnerabilities and agentic risk

Overview

The skill is a disclosed autonomous crypto-trading helper, but it asks the agent to run unverified remote code with wallet and API secrets.

Review this carefully before installing. Use only a burner wallet with a strict small balance, avoid putting valuable credentials in the profile, and do not run the curl-to-node command unless you have independently reviewed and pinned the exact CLI version. Prefer a sandboxed run with a private profile file, owner-only permissions, redacted logs, and hard trading limits.

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

T03 · Remote Payload Retrieval and Execution

Error
Location
SKILL.md:108
Finding
Mutable Remote JavaScript Is Downloaded and Executed Without Integrity Verification## Vulnerability Details **File Location**: `SKILL.md`, lines 108-118 **Vulnerability Type**: Remote payload retrieval and execution **Risk Level**: Critical **Vulnerable Code**: ```markdown 1) Generate a local profile file (with sensitive values) at runtime (example filename: `./profile.json`). 2) Fetch `cli.mjs`. 3) Run `--run-profile` pointing at the local profile file. Primary (recommended) execution: - `curl -fsSL https://fdv.lol/cli.mjs | node - run-profile --profile-url ./profile.json --log-to-console` Alternate fetch (directly from GitHub): - `curl -fsSL https://raw.githubusercontent.com/build23w/fdv.lol/main/cli.mjs | node - run-profile --profile-url ./profile.json --log-to-console` ``` ### Technical Analysis The documented commands pipe JavaScript obtained from an external network location directly into Node.js. Neither source is pinned to a reviewed release or immutable commit, and the instructions do not require verification of a cryptographic digest or signature. The primary source is controlled through the `fdv.lol` domain, while the alternate source follows the mutable `main` branch of a GitHub repository. Consequently, the effective code executed by the Skill may change after the Skill package has been reviewed. A compromise of the domain, hosting infrastructure, repository, maintainer account, DNS path, or release process could substitute arbitrary JavaScript. The retrieved process receives the path to `./profile.json`, which the preceding instruction explicitly describes as containing sensitive values. It executes with the same operating-system privileges as the Agent and is therefore technically capable of reading the profile, environment variables, wallet material, and other files available to that account. The Skill's textual instruction not to upload secrets cannot constrain the behavior of subsequently downloaded JavaScript. ### Attack Path 1. An attacker compromises the `fdv.lol` hosting e ...[truncated 1604 chars]
Remediation
## Remediation Suggestions 1. Do not pipe network responses directly into Node.js or another interpreter. 2. Bundle the reviewed CLI implementation in the Skill package whenever licensing and distribution constraints permit. 3. If remote retrieval is unavoidable, use an immutable, versioned release artifact rather than a mutable branch or unversioned URL. 4. Publish a trusted SHA-256 or stronger digest independently and verify the downloaded file before execution. Prefer signed releases with verification against a pinned maintainer key. 5. Abort execution if download, signature validation, digest validation, ownership validation, or version validation fails. 6. Review the exact pinned CLI version for secret handling, transaction construction, logging, telemetry, and network destinations. 7. Execute the CLI in a sandbox with a restrictive filesystem allowlist and network allowlist. 8. Isolate wallet signing behind a narrowly scoped signer that validates transaction destination, amount, slippage, and spending limits rather than exposing the raw private key. 9. Require explicit user confirmation for material transactions and impose hard balance, per-trade, and cumulative-loss limits that remote code cannot bypass.

T09 · Insecure Skill Coding Practices

Error
Location
SKILL.md:18
Finding
Sensitive Wallet and API Credentials Are Consolidated in a Plaintext Local Profile Without Required File Protections## Vulnerability Details **File Location**: `SKILL.md`, lines 18-20 **Vulnerability Type**: Insecure plaintext secret handling **Risk Level**: High **Vulnerable Code**: ```markdown ClawDBot contract: - It must create the real profile JSON locally at runtime (with secrets) and run the CLI against that local file. - It must not upload or publish the profile anywhere. ``` The required profile structure is illustrated in `openclaw.example.json`, lines 3-16: ```json "rpc": { "url": "<YOUR_SOLANA_MAINNET_RPC_URL_FROM_QUICKNODE_https://quicknode.com/signup?via=lf>", "headers": {} }, "wallet": { "secret": "<BASE58_64_BYTE_SECRETKEY_OR_JSON_ARRAY_STRING>", "recipientPub": "<OPTIONAL_SOLANA_PUBKEY_FOR_RETURNS>" }, "jupiter": { "apiKey": "<YOUR_JUPITER_API_KEY_FROM_https://portal.jup.ag/pricing>" }, "agentGaryFullAi": { "enabled": true, "model": "gpt-4o-mini", "provider": "openai", "riskLevel": "degen", "fullAiControl": true, "apiKey": "<YOUR_OPENAI_API_KEY>" ``` ### Technical Analysis The Skill requires the Agent to create a local JSON file containing a Solana private key and several API credentials. Although it prohibits intentionally uploading or publishing that file, it does not require restrictive filesystem permissions, a protected storage directory, symlink-safe creation, lifecycle cleanup, encryption at rest, or separation of credentials. The resulting file is also intentionally supplied to another process. In combination with the remotely retrieved CLI, this consolidates high-value credentials into a single plaintext target. Default file-creation behavior may expose the file to other local principals depending on the runtime directory and process `umask`. A predictable path such as `./profile.json` may additionally be vulnerable to accidental inclusion in source control, backup systems, diagnostic bundles, or broad working-directory access. ...[truncated 1609 chars]
Remediation
## Remediation Suggestions 1. Avoid storing the raw wallet private key in the same profile as service configuration. 2. Use an operating-system credential store, hardware-backed signer, dedicated wallet service, or isolated signing process. 3. Expose only a constrained signing interface that enforces permitted programs, recipient rules, per-transaction limits, daily budgets, slippage limits, and transaction expiry. 4. Store API credentials separately and inject only the credential required by each component. 5. If a temporary profile is unavoidable, create it atomically in a private directory with owner-only permissions, such as mode `0600` for the file and `0700` for its directory. 6. Defend against symlink and path-substitution attacks by using secure temporary-file APIs and refusing pre-existing or non-regular files. 7. Exclude the profile path from version control, backups, telemetry, crash reports, shell history, and diagnostic output. 8. Ensure logs redact wallet material, authorization headers, API keys, and profile contents. 9. Delete temporary secret material immediately after use and document the limitations of deletion on journaling or copy-on-write filesystems. 10. Use a dedicated burner wallet with a strictly limited balance and narrowly scoped, revocable API keys. 11. Run the consumer process with a minimal environment, restricted filesystem access, and an explicit network-destination allowlist.
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
Findings (5)

External Script Fetching

High
Category
Supply Chain
Content
Primary (recommended) execution:

- `curl -fsSL https://fdv.lol/cli.mjs | node - run-profile --profile-url ./profile.json --log-to-console`

Alternate fetch (directly from GitHub):
Confidence
99% confidence
Finding
This command performs direct remote-code execution from fdv.lol into Node. In this skill's context, the executed process is expected to access a local profile containing wallet and API secrets and to make trading decisions, so compromise of the fetched script could immediately lead to credential theft or unauthorized transactions.

Missing User Warnings

High
Confidence
99% confidence
Finding
The skill recommends executing code fetched live from a remote URL by piping curl output directly into Node.js, which prevents review, integrity verification, or pinning to a trusted version. If the site, GitHub account, network path, or referenced script is compromised, the attacker can execute arbitrary code locally and steal wallet secrets, API keys, or funds.

Missing User Warnings

Medium
Confidence
88% confidence
Finding
The skill directs the agent to generate and store a new Solana private key locally, but does not require an explicit, prominent warning that this creates highly sensitive key material controlling real funds. In the context of an autonomous trading skill with 'Full AI Control', this increases the chance users will unknowingly entrust spend authority to a locally stored secret without understanding theft, malware, backup, and irreversible-loss risks.

Missing User Warnings

Medium
Confidence
92% confidence
Finding
The skill instructs ClawDBot to write RPC, wallet, Jupiter, and LLM secrets into ./profile.json, which implies plaintext local storage of credentials and a trading private key. Without an explicit warning or protective guidance, users may expose secrets through weak filesystem permissions, backups, logs, shell history, or later accidental publication.

External Script Fetching

Low
Category
Supply Chain
Content
Alternate fetch (directly from GitHub):

- `curl -fsSL https://raw.githubusercontent.com/build23w/fdv.lol/main/cli.mjs | node - run-profile --profile-url ./profile.json --log-to-console`

Notes:
- `--profile-url` accepts local paths too (like `./dev.json` or `./profile.json`).
Confidence
96% confidence
Finding
Although GitHub is generally more reputable than a custom domain, piping a raw GitHub script directly into Node is still unverified remote-code execution. A compromised repository, malicious update, or branch change could execute arbitrary code with access to the user's local secrets and trading wallet.

Static analysis

No suspicious patterns detected.