Back to skill

Security audit

solo-mission

Security checks for vulnerabilities and agentic risk

Overview

This SOLO mission skill is coherent for hiring and payments, but it needs review because it combines autonomous payment workflows with unsafe wallet/install guidance and a contradictory funding path.

Install only if you intentionally want an agent to manage SOLO missions and payment workflows. Use a managed wallet, hardware-backed signer, KMS, or other signing boundary instead of exposing raw private keys to the agent process; avoid curl-to-shell installers; protect .claude/settings.local.json; and treat the media-review Solana/Base funding instructions as requiring manual correction before use.

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

T03 · Remote Payload Retrieval and Execution

Error
Location
SKILL.md:222
Finding
Unverified Foundry Installer Executed from a Mutable Remote Source<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:222-229` **Vulnerability Type**: Remote payload retrieval and execution **Risk Level**: Critical ### Vulnerable Code ```bash **3a — Check Foundry `cast`** ```bash if ! command -v cast > /dev/null 2>&1; then echo "Foundry cast not found. Install it with:" echo " curl -L https://foundry.paradigm.xyz | bash && foundryup" echo "Then restart this session." exit 1 fi ``` ### Technical Analysis The installation command pipes an HTTP response directly into `bash`. Although the referenced domain is associated with Foundry, the downloaded payload is mutable and is neither version-pinned nor authenticated with a checksum or release signature. The command therefore delegates arbitrary shell execution to the current contents of the remote endpoint. The effective code can change after the Skill has been reviewed. A compromise of the distribution endpoint, its deployment process, DNS resolution, or the TLS trust path could turn this instruction into arbitrary local code execution. This behavior is not required at the minimum privilege level necessary to detect that Foundry is unavailable. The Skill can instead direct the operator to a pinned release artifact and require integrity verification before installation. ### Attack Path 1. The Skill detects that `cast` is unavailable and displays the installation command. 2. The operator copies and runs the command as instructed. 3. `curl` downloads the current response from the remote installer endpoint. 4. The response is passed directly to `bash` without local inspection or integrity validation. 5. A compromised or malicious response executes with all privileges of the invoking account. 6. The payload can access local files, API credentials, wallet material available to the process, or install additional persistent components. ### Impact Assessment Successful exploitation provides arbitrary command execution as the invoking user. Because this Skil ...[truncated 485 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Remove all `curl | bash` installation instructions. - Pin an audited Foundry release version rather than using a mutable installer channel. - Download the release artifact to a temporary file before execution. - Verify a vendor-provided cryptographic signature or a hard-coded SHA-256 checksum. - Use a temporary directory created with restrictive permissions and delete it after installation. - Present the artifact and verification result to the operator before executing anything. - Perform installation under an unprivileged account and avoid `sudo` unless separately justified. - Prefer the operating system package manager or an internally mirrored and approved artifact repository. ]]>

T03 · Remote Payload Retrieval and Execution

Error
Location
references/wallet-setup.md:31
Finding
Base Wallet Setup Recommends Direct Execution of a Remote Foundry Installer<![CDATA[ ## Vulnerability Details **File Location**: `references/wallet-setup.md:31-35` **Vulnerability Type**: Remote payload retrieval and execution **Risk Level**: Critical ### Vulnerable Code ```markdown ### Prerequisites - Foundry installed: `curl -L https://foundry.paradigm.xyz | bash && foundryup` - Verify: `cast --version` ``` ### Technical Analysis The wallet setup documentation instructs the operator to execute the mutable response from `https://foundry.paradigm.xyz` directly in a shell. Checking `cast --version` after installation does not establish the integrity of the code that already executed. No release version, checksum, signature, or trusted artifact digest is specified. Consequently, the reviewed Skill does not determine the actual code that will run when the instruction is followed. The Base path is described as closed to new mission creation, which further reduces the justification for retaining a high-risk installer command in the active documentation. Users managing legacy Base missions should be directed to a pinned, independently verifiable installation procedure. ### Attack Path 1. An operator follows the documented Base wallet prerequisites. 2. The operator runs the provided pipeline. 3. The remote endpoint returns shell code controlled by its current deployment. 4. `bash` executes the response before any integrity check can occur. 5. If the endpoint or delivery chain is compromised, attacker commands run under the operator’s account. 6. The attacker can target wallet files, decrypted private keys, API credentials, or blockchain transaction tooling. ### Impact Assessment Exploitation grants arbitrary execution with the invoking user’s privileges. In the documented workflow, this may occur on a machine used to generate or operate a sponsor wallet. The exposed scope can therefore include wallet keys, encrypted wallet files, shell configuration, cloud credentials, and the ability to alter later transaction commands. The ris ...[truncated 156 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Replace the pipeline with a version-pinned release download. - Provide an expected SHA-256 digest or require verification of the vendor’s signed release. - Download the artifact without executing it, validate it, and only then install it. - Explicitly instruct operators not to run installers on systems where wallet keys are accessible. - Remove or archive the legacy Base setup instructions if they are no longer necessary for supported operations. - If legacy support must remain, place it behind a clear opt-in and use a hardened, reproducible installation process. ]]>

T03 · Remote Payload Retrieval and Execution

Error
Location
references/solana-wallet.md:61
Finding
Solana CLI Installation Executes an Unverified Remote Shell Payload<![CDATA[ ## Vulnerability Details **File Location**: `references/solana-wallet.md:61-65` **Vulnerability Type**: Remote payload retrieval and execution **Risk Level**: Critical ### Vulnerable Code ```bash # Install the Solana CLI sh -c "$(curl -sSfL https://release.anza.xyz/stable/install)" solana --version ``` ### Technical Analysis The command downloads the current `stable/install` response and immediately passes it to `sh -c`. The `stable` path is mutable, so neither the tool version nor the executed installer content is fixed by the audited package. The use of `-sSfL` improves HTTP failure handling but does not provide payload authenticity or reproducibility. TLS alone authenticates the endpoint at request time; it does not ensure that the returned installer corresponds to a reviewed release. This command is especially sensitive because the same document subsequently creates and references a Solana sponsor keypair. A malicious installer running before key generation could modify binaries, shell initialization, or filesystem locations in order to capture the generated key later. ### Attack Path 1. The operator follows the Solana wallet creation instructions on a local machine. 2. The command fetches the mutable `stable/install` script. 3. `sh -c` executes the response immediately. 4. A compromised installer modifies the Solana CLI, shell configuration, or local environment. 5. The operator runs `solana-keygen new` and later signs transactions. 6. The modified environment captures wallet material or alters transaction behavior. ### Impact Assessment The immediate impact is arbitrary command execution with the operator’s privileges. Because execution occurs directly before wallet generation, a successful attack can compromise future key material even if no wallet existed when the installer first ran. Potential scope includes theft of generated keypairs, manipulation of transaction-signing tools, unauthorized transfer authorization, local file acce ...[truncated 86 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Pin a specific Solana CLI release rather than using the mutable `stable` installer. - Download a signed release archive from an official release channel. - Validate its signature and a documented checksum before extraction or execution. - Run installation in an isolated environment that has no access to wallet material. - Generate the wallet only after confirming the installed binary’s provenance and digest. - Prefer a managed wallet, hardware-backed signer, or KMS-backed signer that does not expose raw key bytes to general-purpose tooling. - Document an upgrade procedure that repeats integrity validation for every new version. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:119
Finding
Agent API Key Is Persisted in a Plaintext Project File Without Explicit Permission Hardening<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:119-134` **Vulnerability Type**: Plaintext sensitive credential storage **Risk Level**: Medium ### Vulnerable Code ```bash REGISTER=$(curl -s -X POST https://api.mission.projectsolo.ai/agent/register \ -H "Content-Type: application/json" \ -d "{\"name\": \"$AGENT_NAME\"}") SOLO_AGENT_KEY=$(echo $REGISTER | jq -r '.api_key') export SOLO_AGENT_KEY # Persist immediately — api_key is returned only once mkdir -p .claude SETTINGS=".claude/settings.local.json" if [ -f "$SETTINGS" ]; then TMP=$(mktemp) jq --arg k "$SOLO_AGENT_KEY" '.env.SOLO_AGENT_KEY = $k' "$SETTINGS" > "$TMP" \ && mv "$TMP" "$SETTINGS" else jq -n --arg k "$SOLO_AGENT_KEY" '{env: {SOLO_AGENT_KEY: $k}}' > "$SETTINGS" fi echo "Agent registered and key saved. Do NOT print the key value in chat." ``` ### Technical Analysis The registration credential is written in plaintext to `.claude/settings.local.json`. The code does not establish a restrictive `umask`, set the destination to mode `0600`, verify file ownership, or use an operating-system credential store. When updating an existing file, `mktemp` commonly creates a restrictive temporary file, but behavior is environment-dependent and the final security posture is not explicitly enforced. When creating the file directly through shell redirection, its permissions depend on the process umask. The `.claude` directory permissions are likewise not hardened. The code also does not show a source-control exclusion rule. A project-local credential file may therefore be copied into backups, workspace snapshots, artifacts, or commits. ### Attack Path 1. Registration returns a one-time agent API key. 2. The Skill writes the key to `.claude/settings.local.json`. 3. The file is created with permissions derived from the surrounding environment. 4. Another local user, process, backup service, workspace integration, or accidental repository commit obtains the file. 5. The exposed key ...[truncated 743 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Store the API key in an operating-system keychain, managed secret store, or platform-provided secret facility. - If file persistence is unavoidable, set `umask 077` before creating the directory or file. - Create `.claude` with mode `0700` and the settings file with mode `0600`. - Verify that the destination is owned by the expected user and is not a symbolic link. - Add `.claude/settings.local.json` to source-control ignore rules and secret-scanning policies. - Avoid placing credentials in workspace artifacts, logs, backups, or diagnostic bundles. - Provide a documented credential rotation and revocation procedure. - Consider using a short-lived, narrowly scoped token rather than a long-lived agent key. ]]>

T09 · Insecure Skill Coding Practices

Note
Location
SKILL.md:1194
Finding
Retry Helper Uses Shell Eval and Creates a Command-Injection Primitive<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:1194-1209` **Vulnerability Type**: Unsafe dynamic shell evaluation **Risk Level**: Low ### Vulnerable Code ```bash _api_with_retry() { local CMD="$@" local DELAY=20 for ATTEMPT in 0 1 2 3; do RESULT=$(eval "$CMD") if echo "$RESULT" | grep -q '"429"'; then [ $ATTEMPT -eq 3 ] && echo "ERROR: 429 after 4 attempts" && return 1 echo "429 — retrying in ${DELAY}s" sleep $DELAY DELAY=$((DELAY * 2)) else echo "$RESULT" return 0 fi done } ``` ### Technical Analysis `eval` causes its argument to be parsed again as shell syntax. Shell separators, command substitutions, redirects, variable expansions, and quoting constructs present in `CMD` can therefore become executable behavior. If a caller builds the command from mission data, API responses, participant input, state-file values, or operator-provided text, an attacker may inject shell syntax rather than merely supplying an argument. Quoting at the original call site is difficult to preserve safely through string concatenation and reparsing. No invocation of `_api_with_retry` was found in the reviewed package. Therefore, a currently reachable injection source-to-sink path was not confirmed, and the risk is rated Low. The helper nevertheless creates a dangerous primitive likely to become exploitable if reused. ### Attack Path A potential exploitation path, if the helper is later called with untrusted data, is: 1. A caller constructs a command string containing a mission ID, conversation ID, URL, message, or another externally influenced value. 2. An attacker supplies shell metacharacters or command substitution syntax in that value. 3. The caller passes the resulting string to `_api_with_retry`. 4. `local CMD="$@"` stores the complete command as text. 5. `eval "$CMD"` reparses the malicious text as shell syntax. 6. Injected commands execute with the privileges and environment of the agent pr ...[truncated 635 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Remove `eval` entirely. - Pass the command and each argument separately rather than serializing them into one string. - In Bash, store command arguments in an array and invoke them with `"${cmd[@]}"`. - Prefer a retry helper dedicated to a fixed HTTP operation rather than a generic command evaluator. - Keep untrusted values in quoted argument positions and never reinterpret them as shell source. - Add static-analysis checks such as ShellCheck and reject new uses of `eval`. - Add tests using values containing spaces, semicolons, substitutions, redirects, and newlines to verify that they remain inert arguments. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
Findings (5)

Intent-Code Divergence

Medium
Confidence
97% confidence
Finding
The skill repeatedly says new on-chain missions are Solana-only, but this media-review subsection instructs the operator to fund via Base-style `createTask()`/`confirm-funding`. In a high-privilege financial workflow, contradictory chain/funding instructions can cause operators or agents to sign the wrong transaction path, strand funds, or leave missions permanently unfunded while believing they followed the documented process.

Intent-Code Divergence

Medium
Confidence
91% confidence
Finding
The document correctly says wallet creation should not be performed by the agent, but it later instructs operators to export the plaintext private key into the runtime environment, where an autonomous agent or surrounding tooling may access, log, or leak it. In the context of a mission/agent platform that can act on-chain, exposing a live signing key to the agent runtime materially increases the chance of secret disclosure and unauthorized transaction signing.

Vague Triggers

Medium
Confidence
92% confidence
Finding
The trigger scope is so broad that it activates on virtually any mention of SOLO or its API, causing a powerful skill with payment, hiring, and on-chain transaction guidance to engage in contexts that may not require it. Over-broad activation increases the chance of unintended external actions, misrouting user requests into this skill, and exposing operators to unnecessary financial or state-changing workflows.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The documentation instructs operators to pass a raw private key directly on the command line via `--private-key $PRIVATE_KEY`. Even if supplied through an environment variable, CLI arguments are commonly exposed through shell history, process listings, logs, CI job output, and debugging tooling, which can leak the sponsor wallet key and enable full unauthorized control of mission funds. In this skill context, the key is used for on-chain escrow operations, so compromise can directly lead to theft or irreversible fund movement.

External Script Fetching

High
Category
Supply Chain
Content
### Prerequisites

- Foundry installed: `curl -L https://foundry.paradigm.xyz | bash && foundryup`
- Verify: `cast --version`

### Generate the keypair
Confidence
97% confidence
Finding
Piping a remote script directly into bash executes unverified code from the network with the user's privileges, creating a supply-chain and man-in-the-middle risk. In a wallet setup guide for on-chain operations, compromise of the install step could lead to malware installation, credential theft, or theft of wallet material and funds.

Static analysis

No suspicious patterns detected.