Back to skill

Security audit

OpenFunderse Participant

Security checks for vulnerabilities and agentic risk

Overview

This skill is not clearly malicious, but it needs review because it handles wallet keys, can mutate shared OpenClaw state, and documents broader financial actions than its allocation-only purpose suggests.

Install only if you are comfortable reviewing and trusting the external npm runtime. Avoid the clawhub@latest path for production, use a dedicated minimally funded participant key, keep treasury or admin keys out of this skill, prefer file-only/no-restart options unless you intentionally want to update shared OpenClaw state, and protect or remove plaintext key backups after setup.

Vulnerability Patterns
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • 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
Findings (3)

T08 · Insecure Dependencies

Error
Location
SKILL.md:6
Finding
External npm Packages Are Downloaded and Executed During Installation<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:6`, `SKILL.md:32`, `SKILL.md:47-53`, and `SKILL.md:63-66` **Vulnerability Type**: Supply-chain code execution through externally retrieved npm packages **Risk Level**: High ### Vulnerable Code ```yaml installCommand: npx @wiimdy/openfunderse@2.0.0 install openfunderse-participant --with-runtime ``` ```markdown - Installing via `npx @wiimdy/openfunderse@2.0.0 ...` executes code fetched from npm. Prefer pinning a known version (as shown) and reviewing the package source before running in production. ``` ```bash npm init -y && npx @wiimdy/openfunderse@2.0.0 install openfunderse-participant --with-runtime ``` ```bash npx clawhub@latest install openfunderse-participant ``` ```bash npx @wiimdy/openfunderse@2.0.0 bot-init \ --skill-name participant \ --yes \ --no-restart-openclaw-gateway ``` ### Technical Analysis The project contains only `SKILL.md`; the implementation that performs installation, wallet initialization, environment synchronization, and runtime behavior is retrieved from npm and executed through `npx`. Consequently, the security-relevant implementation is outside the reviewed artifact. The scoped `@wiimdy/openfunderse` dependency is pinned to version `2.0.0`, which limits ordinary version drift but does not protect against registry compromise, maintainer account compromise, malicious transitive dependencies, or package-integrity substitution. The alternative `clawhub@latest` command is not pinned at all and can resolve to different code after this Skill has been reviewed. An npm CLI or lifecycle script executes with the invoking user's permissions. In this context, such code may be able to access the OpenClaw workspace, wallet files, `openclaw.json`, environment variables, and the participant private key. ### Attack Path 1. An attacker compromises the npm package, its maintainer account, a transitive dependency, or the package-resolution channel. 2. The attacker publishes ...[truncated 1293 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin every executable dependency, including ClawHub, to an exact reviewed version. Do not use `@latest`. 2. Verify package integrity with a trusted digest, signed provenance, or a reproducible artifact before execution. 3. Publish the runtime source with the Skill or link each release to an immutable source commit so the executed behavior can be audited. 4. Use a lockfile with integrity metadata and install from a controlled registry or reviewed offline package cache. 5. Run installation in a sandbox without wallet credentials, sensitive environment variables, or access to production OpenClaw configuration. 6. Separate installation from secret provisioning so downloaded package code never executes while production private keys are present. 7. Review package lifecycle scripts and transitive dependencies before production deployment. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
SKILL.md:33
Finding
Participant Private Key Is Duplicated Across Plaintext Configuration and Backup Locations<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:33-38` **Vulnerability Type**: Excessive plaintext storage and propagation of private wallet credentials **Risk Level**: High ### Vulnerable Code ```markdown - `PARTICIPANT_PRIVATE_KEY` is highly sensitive. Use a dedicated wallet key for this bot; never reuse treasury/admin keys. - `bot-init` is a **destructive** rotation tool: it generates a fresh wallet, updates `.env.participant`, and stores wallet backups under `~/.openclaw/workspace/openfunderse/wallets`. - By default, `install` and `bot-init` also sync env vars into `~/.openclaw/openclaw.json` and `bot-init` runs `openclaw gateway restart`. This mutates global OpenClaw runtime state and can affect other skills. - Use `--no-sync-openclaw-env` for file-only behavior. - Use `--no-restart-openclaw-gateway` to avoid restarting the gateway. - Before mutating global config, back up `~/.openclaw/openclaw.json`. ``` The same storage model is reinforced at lines 58 and 75-78: ```markdown If you already have a key, set `PARTICIPANT_PRIVATE_KEY` and `PARTICIPANT_ADDRESS` directly in OpenClaw env (`/home/ubuntu/.openclaw/openclaw.json` -> `env.vars`) or in `~/.openclaw/workspace/.env.participant`. You do not need to run `bot-init`. ``` ```markdown - In OpenClaw runtime on Ubuntu, treat `/home/ubuntu/.openclaw/openclaw.json` (`env.vars`) as the canonical env source. - Do not require manual `.env` sourcing for normal skill execution. - If `.env*` and `openclaw.json` disagree, use `openclaw.json` values. - When user asks env setup, direct them to update `openclaw.json` first. ``` ### Technical Analysis The documented initialization process can place the participant private key in several filesystem locations: - `.env.participant`. - The global `~/.openclaw/openclaw.json` configuration. - Wallet backups under `~/.openclaw/workspace/openfunderse/wallets`. - Potential additional backups of `openclaw.json`. The Skill does not require encryption at ...[truncated 2059 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Store private keys in an operating-system keyring, hardware signer, or dedicated secret-management service rather than plaintext JSON or environment files. 2. Expose only a constrained signing operation to the Skill; do not expose raw private-key material to the general OpenClaw process. 3. Keep participant credentials in a role-specific secret scope instead of the global `openclaw.json` environment. 4. Disable wallet and configuration backups containing plaintext keys by default. If backups are necessary, encrypt them with a separately managed key. 5. Enforce owner-only permissions on every secret-bearing file and verify permissions before reading or writing. 6. Define key-retention, rotation, revocation, and secure-deletion procedures. 7. Avoid exporting the private key into a general-purpose shell. If debugging requires it, use a temporary isolated process and clear the environment afterward. 8. Ensure logs, crash reports, command output, and support bundles redact all key material. 9. Continue requiring a dedicated, minimally funded participant wallet and prohibit treasury, custody, or administrator keys. ]]>

T05 · Unauthorized Access and Privilege Escalation

Warning
Location
SKILL.md:34
Finding
Default Initialization Mutates Shared OpenClaw Configuration and Restarts the Global Gateway<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:34-38` and `SKILL.md:127-130` **Vulnerability Type**: Excessive modification of shared runtime state **Risk Level**: Medium ### Vulnerable Code ```markdown - `bot-init` is a **destructive** rotation tool: it generates a fresh wallet, updates `.env.participant`, and stores wallet backups under `~/.openclaw/workspace/openfunderse/wallets`. - By default, `install` and `bot-init` also sync env vars into `~/.openclaw/openclaw.json` and `bot-init` runs `openclaw gateway restart`. This mutates global OpenClaw runtime state and can affect other skills. - Use `--no-sync-openclaw-env` for file-only behavior. - Use `--no-restart-openclaw-gateway` to avoid restarting the gateway. - Before mutating global config, back up `~/.openclaw/openclaw.json`. ``` The behavior is repeated later: ```markdown - `install` / `bot-init` sync env keys into `~/.openclaw/openclaw.json` (`env.vars`) by default. - `bot-init` also runs `openclaw gateway restart` after a successful env sync, so the gateway picks up updates. - Use `--no-sync-openclaw-env` for file-only behavior, or `--no-restart-openclaw-gateway` to skip the restart. - If env still looks stale: run `openclaw gateway restart` and verify values in `/home/ubuntu/.openclaw/openclaw.json`. ``` ### Technical Analysis Generating a participant wallet does not inherently require modifying shared OpenClaw configuration or restarting a global gateway. These actions are enabled by default, while safer file-only and no-restart behavior requires opt-out flags. Writing role-specific variables into shared runtime configuration crosses a least-privilege boundary because unrelated skills and gateway components may depend on the same file and process. Restarting the gateway also creates an availability and integrity impact outside the participant Skill's direct scope. The documentation explicitly warns that other skills may be affected, which confirms that the operation is ...[truncated 1234 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Make file-only initialization and no gateway restart the defaults. 2. Require explicit, separate user consent before modifying global configuration or restarting a shared service. 3. Store participant settings in an isolated role-specific configuration consumed only by this Skill. 4. Validate all configuration changes against a strict schema before writing. 5. Use atomic writes with restrictive permissions and provide a redacted rollback mechanism that does not duplicate secrets. 6. Detect and reject collisions with existing environment keys rather than silently overwriting them. 7. Display an exact change plan before mutation, including affected keys and services, while redacting secret values. 8. Restart only the participant component where architecture permits; otherwise ask the operator to perform the shared gateway restart during an approved maintenance window. ]]>
Vulnerability Patterns
  • Rogue AgentSelf-Modification, Session Persistence
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
Findings (2)

Rp1

Medium
Category
MCP Rug Pull
Confidence
93% confidence
Finding
The skill instructs users to run `npx clawhub@latest install openfunderse-participant`, which fetches and executes whatever code is currently published under that package tag. Using `@latest` for an installer creates a supply-chain risk because a malicious or compromised upstream release could execute arbitrary code on the host at install time, and this skill already operates in a sensitive context with private keys and OpenClaw global state.

Session Persistence

Medium
Category
Rogue Agent
Content
npx clawhub@latest install openfunderse-participant
```

2) Optional: create or rotate a dedicated participant signer key.

If you already have a key, set `PARTICIPANT_PRIVATE_KEY` and `PARTICIPANT_ADDRESS` directly in OpenClaw env (`/home/ubuntu/.openclaw/openclaw.json` -> `env.vars`) or in `~/.openclaw/workspace/.env.participant`. You do not need to run `bot-init`.
Confidence
84% confidence
Finding
The skill explicitly directs operators to store `PARTICIPANT_PRIVATE_KEY` in persistent local files such as `/home/ubuntu/.openclaw/openclaw.json` or `~/.openclaw/workspace/.env.participant`, and notes that `bot-init` also writes wallet backups under `~/.openclaw/workspace/openfunderse/wallets`. Persisting long-lived private keys and backups on disk increases the blast radius of host compromise, accidental disclosure, backup leakage, or overly broad file permissions.

Static analysis

No suspicious patterns detected.