Back to skill

Security audit

Wundervault Vault

Security checks for vulnerabilities and agentic risk

Overview

The skill is a coherent secret-vault integration, but its install path and optional secret-writing capabilities create Review-level risk.

Review this skill before installing if you plan to grant it real secrets, SSH keys, deployment authority, wallet keys, or .env write access. Prefer pinned package versions, independently verify the onboarding script before running it, keep .env injection disabled unless needed, and grant each agent only the vault entries and command authority it truly requires.

Vulnerability Patterns
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • 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
INSTALL.md:27
Finding
Execution of a Mutable Remote Onboarding Script Without Mandatory Pre-Execution Verification## Vulnerability Details **File Location**: `INSTALL.md:27-28` **Vulnerability Type**: Remote payload retrieval and execution **Risk Level**: High **Vulnerable Code:** ```bash curl -fsSL https://wundervault.com/onboard -o /tmp/wv-onboard.py python3 /tmp/wv-onboard.py "https://wundervault.com/setup/agent/TOKEN#PASSPHRASE" ``` ### Technical Analysis The installation procedure downloads a Python program from a mutable external URL and immediately instructs the user to execute it. Although downloading before execution is safer than directly piping `curl` into an interpreter, the effective security behavior remains remote payload retrieval followed by local code execution. The downloaded program is not included in the audited project, so its implementation and the claimed Ed25519 self-verification cannot be independently inspected as part of this audit. More importantly, verification performed by the downloaded program itself does not provide a reliable trust boundary if both the payload and its verification logic come from the same mutable endpoint. A modified payload could omit or bypass the claimed check. The documentation references a checksum and public key on another page, but the installation commands do not require users to verify either value before executing the program. The onboarding program also receives a setup URL containing a token and passphrase and reportedly writes credentials and modifies agent configuration, making the execution security-sensitive. ### Attack Path 1. An attacker compromises the onboarding endpoint, its deployment infrastructure, DNS resolution, or another component capable of controlling the response from `https://wundervault.com/onboard`. 2. The endpoint supplies a modified Python program. 3. A user follows the documented installation procedure and executes the downloaded file without first performing independent signature or checksum verification. 4. The malicious program receives the se ...[truncated 1239 chars]
Remediation
## Remediation Suggestions 1. Include the onboarding script in the reviewed package so that its contents are available during security assessment. 2. If remote retrieval is required, use an immutable, versioned artifact URL rather than a mutable `/onboard` endpoint. 3. Pin the expected SHA-256 digest in `INSTALL.md` and make verification an explicit prerequisite: ```bash curl -fsSLo /tmp/wv-onboard.py https://wundervault.com/releases/onboard-vX.Y.Z.py printf '%s %s\n' 'EXPECTED_SHA256' '/tmp/wv-onboard.py' | sha256sum --check - python3 /tmp/wv-onboard.py 'SETUP_URL' ``` 4. Prefer detached signature verification by a trusted tool before Python executes the file. Embed or distribute the public key through a channel independent of the downloaded payload. 5. Abort installation when verification fails; do not present verification as optional. 6. Avoid exposing the setup secret in process arguments. Pass it through a protected file descriptor or restrictive temporary file and remove it immediately after use. 7. Run onboarding with the least-privileged user and explicitly document every file and configuration location it may modify.

T08 · Insecure Dependencies

Warning
Location
INSTALL.md:12
Finding
Unpinned npm Dependency Installation## Vulnerability Details **File Location**: `INSTALL.md:12-19` **Vulnerability Type**: Insecure third-party dependency installation **Risk Level**: Medium **Vulnerable Code:** ```bash npm install -g @wundervault/mcp-server ``` The documented local alternative is also unpinned: ```bash cd ~/.openclaw/workspace npm install @wundervault/mcp-server ``` ### Technical Analysis Both installation alternatives request the current registry-selected release of `@wundervault/mcp-server` without an exact version or independently enforced integrity value. Consequently, the code installed by a future user can differ from the code intended when this Skill version was audited. npm packages may execute lifecycle scripts during installation and later run as MCP servers. Therefore, compromise of the package publisher account, npm registry entry, or a newly published release could introduce code execution into the installation process or the agent's ongoing tool interface. The global installation alternative further broadens exposure by placing the executable in a user-wide command location. The audited project contains only documentation and metadata; it does not include the MCP server source or a lockfile through which the dependency contents could be evaluated. ### Attack Path 1. An attacker compromises the npm publisher account or causes a malicious release to be published under `@wundervault/mcp-server`. 2. The malicious release becomes the version selected by the unpinned installation command. 3. A user follows `INSTALL.md` and installs the package. 4. Malicious logic executes through an npm lifecycle script or when an MCP client launches `wundervault-mcp`. 5. The package accesses data and resources available to the invoking user or abuses the MCP server's trusted position in the vault workflow. ### Impact Assessment A compromised dependency could execute with the installing user's privileges. Depending on the local en ...[truncated 584 chars]
Remediation
## Remediation Suggestions 1. Pin an exact reviewed package version: ```bash npm install @wundervault/mcp-server@X.Y.Z ``` 2. Prefer a project-local dependency over global installation to reduce system-wide exposure. 3. Commit a lockfile containing npm integrity metadata and use `npm ci` for reproducible installation. 4. Publish expected package provenance and integrity information through an independently controlled release channel. 5. Verify npm package signatures or registry provenance where supported. 6. Disable lifecycle scripts during installation when they are unnecessary: ```bash npm install --ignore-scripts @wundervault/mcp-server@X.Y.Z ``` If lifecycle scripts are required, document and audit each script before installation. 7. Review and repin the dependency deliberately when releasing a new Skill version rather than automatically accepting the latest package.
Vulnerability Patterns
  • 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
  • Rogue AgentSelf-Modification, Session Persistence
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
Findings (8)

External Script Fetching

High
Category
Supply Chain
Content
In your Wundervault dashboard under **Settings → Agents**, create an agent and copy the setup URL (it includes the passphrase in the `#fragment`). Download the script, then run it:

```bash
curl -fsSL https://wundervault.com/onboard -o /tmp/wv-onboard.py
python3 /tmp/wv-onboard.py "https://wundervault.com/setup/agent/TOKEN#PASSPHRASE"
```
Confidence
95% confidence
Finding
The instructions direct users to fetch and execute a remote Python script that receives a setup URL containing a TOKEN and PASSPHRASE, then writes credentials locally and alters configuration. Even with claims of self-signature verification and published checksums, this pattern creates a high-trust remote-code-execution path: compromise of the distribution endpoint, onboarding script, or verification design could lead to credential theft or system modification.

MCP Config Access

High
Category
Agent Snooping
Content
```

Common global MCP config locations:
- **Claude Code**: `~/.claude/mcp.json`
- **Cursor**: `~/.cursor/mcp.json`
- **Windsurf**: `~/.codeium/windsurf/mcp_config.json`
Confidence
95% confidence
Finding
Skill accesses MCP server configuration files (mcp.json). MCP configs contain server URLs, authentication tokens, and tool definitions — reading them allows the skill to discover and potentially abuse other tool integrations.

External Script Fetching

High
Category
Supply Chain
Content
vault_exec(
  entry_id: "abc123",
  purpose: "check subscribers on prod",
  command: "curl -s -u \"admin:$DB_PASSWORD\" http://localhost:9000/api/subscribers",
  inject_as: { env_key: "DB_PASSWORD" },
  remote_host: { host: "192.168.1.50", user: "opc", ssh_key_entry_id: "ssh-key-entry-id" }
)
Confidence
90% confidence
Finding
Remote code is downloaded and executed. This bypasses code review and could introduce malicious code.

Credential Access

High
Category
Privilege Escalation
Content
vault_entry_inject_env(
  entry_id: "abc123",
  purpose: "inject API key into app config",
  file_path: "/home/user/app/.env",
  env_key: "RESEND_API_KEY"
)
```
Confidence
95% confidence
Finding
`vault_entry_inject_env` writes secrets to arbitrary `.env` paths, causing credentials to persist on disk outside the vault's burn-on-read protections. If an agent is manipulated, it could plant secrets into attacker-controlled or unintended locations, leading to credential disclosure, later reuse, or exfiltration by other processes.

Credential Access

High
Category
Privilege Escalation
Content
**Write a secret to a config file:**
```
1. vault_entries_list() → find entry ID
2. vault_entry_inject_env(entry_id: "abc123", purpose: "...", file_path: "/app/.env", env_key: "MY_KEY")
```

**Deploy files to a remote server:**
Confidence
94% confidence
Finding
This example normalizes writing secrets directly into `/app/.env`, reinforcing a workflow where secrets persist in files rather than remaining ephemeral. In an agent setting, that persistence makes credential theft easier through later file reads, backups, logs, container image inclusion, or accidental source control exposure.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The installation flow instructs users to run a downloaded onboarding script that writes credential files, modifies OpenClaw configuration, and clears MCP session state. Although these actions are described, the instructions do not present them as sensitive system changes requiring explicit user review or consent, which increases the risk of users granting broad local changes without understanding the consequences.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
```
vault_exec(
  purpose: "restart the service on prod",
  command: "sudo systemctl restart wundervault",
  remote_host: { host: "prod.example.com", user: "opc", ssh_key_entry_id: "ssh-key-entry-id" }
)
```
Confidence
87% confidence
Finding
The skill explicitly enables privileged remote command execution using `sudo systemctl restart ...` via `vault_exec`. Even though this is presented as an administrative example, it gives an agent a path to perform root-level actions on a remote host, which materially increases the blast radius if the agent is prompt-injected, misused, or compromised.

Session Persistence

Medium
Category
Rogue Agent
Content
```

### `vault_entry_inject_env`
Write a secret directly into an environment file (`.env`) as an environment variable, without it passing through chat.

**Disabled by default.** To use this tool, enable it in Settings > Agent Capabilities at wundervault.com. You can disable it again at any time.
Confidence
93% confidence
Finding
The skill deliberately supports persisting secrets into `.env` files, which extends secret lifetime beyond a single authorized action. That persistence weakens the security model advertised elsewhere in the skill and creates a durable artifact that may be discovered by local users, other agents, malware, backups, or deployment tooling.

Static analysis

No suspicious patterns detected.