Back to skill

Security audit

zambo

Security checks for vulnerabilities and agentic risk

Overview

The skill openly connects your agent to Zambo's remote tool service, but it gives that service broad, mutable authority without enough privacy, consent, or install-supply-chain controls.

Install only if you are comfortable sending job content to Zambo's remote service. Avoid secrets, credentials, private keys, regulated data, confidential prompts, or proprietary repositories unless you have explicit approval and understand the service's retention and logging policies. Prefer the explicit MCP config over the unpinned `npx` installer, and review the tools returned by `tools/list` before allowing the agent to use them.

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

T08 · Insecure Dependencies

Error
Location
SKILL.md:34
Finding
Unpinned Package Execution Through npx## Vulnerability Details **File Location**: `SKILL.md`, lines 34-36 **Vulnerability Type**: Unpinned third-party package execution **Risk Level**: High **Vulnerable Code Snippet**: ```markdown Or run: ```bash npx zambo install ``` ``` ### Technical Analysis The installation instructions execute the `zambo` package through `npx` without specifying an exact version, integrity hash, trusted package source, or reviewed artifact. If the package is not already cached locally, `npx` can resolve and download the current package version from the configured registry before executing it. Because package resolution is mutable, the code executed at installation time may differ from the code available when this Skill was audited. A compromised package release, registry account, publisher account, dependency, or package-resolution configuration could consequently introduce arbitrary code. Package lifecycle scripts and the CLI itself may execute with the permissions of the user running the command. ### Attack Path 1. An attacker compromises the package publisher, registry entry, package dependency chain, or another component involved in package resolution. 2. The attacker publishes a malicious version under the package name resolved by `npx`. 3. A user follows the documented command without pinning a known-safe version. 4. `npx` downloads the mutable package release and executes its CLI or lifecycle code. 5. The malicious package performs arbitrary actions under the invoking user's account. ### Impact Assessment Successful exploitation could provide arbitrary code execution with the privileges of the user invoking `npx`. Depending on that user's permissions and environment, the malicious package could access local source code, configuration files, environment variables, authentication tokens, SSH material, MCP client configuration, and other user-readable data. It could also modify user-owned files or establish additional mali ...[truncated 230 chars]
Remediation
## Remediation Suggestions - Pin the command to a specific, reviewed package version, such as `npx zambo@<reviewed-version> install`. - Verify the package publisher, registry source, release provenance, and cryptographic integrity before recommending execution. - Publish expected checksums or signed release metadata and provide verification instructions. - Avoid package lifecycle scripts where possible; consider `--ignore-scripts` if compatible with the installer. - Prefer downloading and reviewing a versioned artifact before execution rather than resolving and running the latest registry release automatically. - Document the local files, commands, permissions, and configuration changes performed by the installer. - Recommend running installation with the minimum required user privileges and never with administrator or root privileges unless strictly necessary.

other

Warning
Location
SKILL.md:27
Finding
Unrestricted Trust in a Mutable Zero-Authentication Remote MCP Endpoint## Vulnerability Details **File Location**: `SKILL.md`, lines 27-43 **Vulnerability Type**: Untrusted remote capability and sensitive-data disclosure risk **Risk Level**: Medium **Vulnerable Code Snippet**: ```markdown Paste this into your MCP client config (Claude, Cursor, Windsurf, Cline) — no API key, no signup, no account: ```json {"mcpServers":{"zambo":{"url":"https://zambo.dev/api/mcp"}}} ``` That's it. The endpoint is a single remote URL (`https://zambo.dev/api/mcp`, Streamable HTTP). Your agent discovers the exact tool names via the standard MCP `tools/list` call — always list tools first, then call. ## How to work with Zambo 1. **List tools** (`tools/list`) to see what's available — 120 native tools across 17 products. 2. **Describe the job** in the tool call the way a user would type it. Zambo tools take job-style input and return receipts: what was done, which tools ran, and the result. 3. **Report the receipt** back to the user: what the job was, which tools were called, and the outcome. ``` ### Technical Analysis The Skill directs users to register an external, zero-authentication MCP endpoint and dynamically accept the tools returned by its `tools/list` operation. The remote endpoint's available tools, schemas, descriptions, and behavior can change independently after the local Skill has been reviewed. The instructions also direct the agent to submit user-described jobs to the service without requiring explicit consent for each transmission, applying a reviewed tool allowlist, minimizing transmitted data, or excluding secrets and sensitive content. Tasks advertised by the Skill include repository auditing, lead research, wallet analysis, and prompt testing, all of which may involve proprietary source code, personal information, wallet identifiers, internal prompts, or security-relevant data. This creates a mutable external trust boundary. The documentation does not establish that the endpoint is malic ...[truncated 1772 chars]
Remediation
## Remediation Suggestions - Require explicit user approval before sending each job or sensitive data to the remote endpoint. - Show the destination, selected tool, and exact categories of data to be transmitted before invocation. - Establish an allowlist of reviewed tool names and schemas rather than trusting every capability returned dynamically by `tools/list`. - Version or pin the expected MCP interface and alert users when tool definitions differ from the reviewed version. - Prohibit transmission of credentials, API keys, authentication tokens, private keys, unpublished source code, personal information, and confidential prompts by default. - Apply data minimization and redact secrets or unnecessary identifiers before making a request. - Document the service's retention, logging, subprocessors, training use, deletion, and incident-response policies. - Configure the MCP client with least privilege and require separate confirmation before any tool result triggers local file changes, command execution, financial actions, or additional external requests. - Provide a self-hosted or independently auditable deployment option for sensitive workloads.
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
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (3)

Missing User Warnings

Medium
Confidence
97% confidence
Finding
The skill prominently advertises a 'zero-auth remote MCP endpoint' and encourages use for real-world execution and analysis, but does not warn that prompts, code, documents, wallet data, or other user inputs may be transmitted to an external service. This omission is dangerous because users may send sensitive material under the assumption the skill is just local agent functionality, leading to privacy, confidentiality, and compliance risks.

Vague Triggers

Medium
Confidence
90% confidence
Finding
The trigger guidance is broad enough to encourage using this external zero-auth execution service for many loosely defined tasks such as research, analysis, and any multi-step job. In practice, that can cause agents or users to route routine or sensitive requests to a third-party endpoint unnecessarily, increasing the chance of data leakage, overreach, or unintended external actions.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
The skill instructs users to run `npx zambo install` without pinning a version or integrity source, which can pull whatever package version is current at execution time. This creates a supply-chain risk: if the package is compromised, typosquatted, or updated maliciously, users may execute attacker-controlled code during installation.

Static analysis

No suspicious patterns detected.