Back to skill

Security audit

Massive(Polygon)

Security checks for vulnerabilities and agentic risk

Overview

The skill is a straightforward market-data CLI reference, with a real but disclosed supply-chain caution around running an unpinned npm CLI with an API key.

Use a pinned and reviewed version of the `massive` npm package where possible, provide only the needed `MASSIVE_API_KEY`, and run the CLI in an environment without unrelated secrets or broad filesystem access.

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

T08 · Insecure Dependencies

Warning
Location
SKILL.md:5
Finding
Unpinned npm Package Is Automatically Downloaded and Executed with API-Key Access## Vulnerability Details **File Location**: `SKILL.md:5-9` and `SKILL.md:16-20` **Vulnerability Type**: Unpinned third-party dependency execution **Risk Level**: Medium ### Vulnerable Code ```yaml metadata: openclaw: requires: bins: ["npx"] env: ["MASSIVE_API_KEY"] primaryEnv: "MASSIVE_API_KEY" ``` ```markdown ## CLI Usage ```bash npx --yes massive <command> [options] ``` ``` The same unpinned invocation pattern appears throughout all eight files under `references/`, including: - `references/crypto_commands.md:41-141` - `references/forex_commands.md:12-236` - `references/indices_commands.md:12-173` - `references/market_commands.md:12-36` - `references/news_commands.md:12-32` - `references/options_commands.md:12-257` - `references/reference_commands.md:12-215` - `references/stocks_commands.md:12-272` ### Technical Analysis The command `npx --yes massive` does not specify an exact package version. If the package is not already available locally, `npx` can resolve the current package release from the configured npm registry, download it, and execute it without an interactive confirmation prompt. The project does not contain the CLI implementation, a package manifest, a lockfile, a package-integrity hash, or vendored source that would bind execution to the code reviewed during this audit. The effective executable can therefore change after the Skill has been reviewed. This is particularly sensitive because the Skill explicitly requires `MASSIVE_API_KEY`. A process launched by `npx` normally inherits the invoking process's environment, so downloaded package code may be able to read that credential. The package also executes with the filesystem, process, and network permissions of the Agent account. No evidence establishes that the current `massive` package is malicious. The vulnerability is the mutable and unaudited supply-chain execution path. ### Attack Path ...[truncated 1555 chars]
Remediation
## Remediation Suggestions 1. Replace the mutable invocation with an exact, reviewed version, for example `npx --yes massive@X.Y.Z`, after verifying that the selected version is legitimate. 2. Prefer installing the dependency through a committed package manifest and lockfile so the complete dependency graph is reproducible. 3. Enforce registry integrity verification and retain the expected package integrity hash in the lockfile. 4. Review the package source, executable entry point, installation scripts, and transitive dependencies before approving a version. 5. Use a trusted, allowlisted npm registry and enable package provenance or signature verification where supported. 6. Disable dependency lifecycle scripts when they are unnecessary, and fail closed rather than automatically accepting unexpected installation behavior. 7. Run the CLI in a restricted environment with minimal filesystem access, limited outbound networking, and no unrelated environment variables. 8. Scope and rotate `MASSIVE_API_KEY`, and provide it only to the reviewed process at invocation time rather than exposing it broadly in the parent environment. 9. Update every command example under `references/` to use the same pinned and verified execution mechanism.
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 (126)

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
The skill instructs users to execute an unpinned package via `npx --yes massive`, which fetches and runs the latest published package version at execution time. If the upstream package is compromised, replaced, or a malicious version is published, arbitrary code could run in the user's environment with access to the configured `MASSIVE_API_KEY` and local system resources.

Rp1

Medium
Category
MCP Rug Pull
Confidence
97% confidence
Finding
The example invokes `npx --yes massive` without pinning a specific package version, so users may install and execute whatever version is current at runtime. This creates a supply-chain risk: a compromised latest release, malicious dependency update, or unexpected breaking change could lead to arbitrary code execution when the command is copied from the documentation.

Rp1

Medium
Category
MCP Rug Pull
Confidence
97% confidence
Finding
This documentation example uses `npx --yes massive` with no version pin, causing runtime retrieval and execution of the latest published package. If the package or one of its dependencies is compromised, a user following the example could execute attacker-controlled code on their machine.

Rp1

Medium
Category
MCP Rug Pull
Confidence
97% confidence
Finding
The command shown is an unpinned `npx` execution, which implicitly trusts the latest registry state at the moment of use. That exposes users to supply-chain compromise and non-deterministic behavior, especially because documentation examples are often copied directly into shells.

Rp1

Medium
Category
MCP Rug Pull
Confidence
97% confidence
Finding
By using `npx --yes massive` without a fixed version, the documentation instructs users to execute code that may change over time without review. In the event of a malicious publish or account compromise, this can become a straightforward arbitrary code execution vector via copy-pasted documentation.

Rp1

Medium
Category
MCP Rug Pull
Confidence
97% confidence
Finding
The example relies on an unversioned `npx` package execution, which means the exact code being run is uncontrolled and can differ across time and environments. This is a documented supply-chain weakness because users may unknowingly run a compromised or altered package version.

Rp1

Medium
Category
MCP Rug Pull
Confidence
97% confidence
Finding
This sample command fetches and runs the `massive` package via `npx` without pinning its version. That makes the example vulnerable to npm supply-chain attacks and undermines reproducibility, since the executed code may change after the documentation is published.

Rp1

Medium
Category
MCP Rug Pull
Confidence
97% confidence
Finding
The documentation tells users to run an unpinned npm package directly from the registry. If the package owner account, package contents, or transitive dependencies are compromised, anyone following the example may execute malicious code immediately.

Rp1

Medium
Category
MCP Rug Pull
Confidence
97% confidence
Finding
Because `npx --yes massive` is unpinned, the documentation example depends on mutable external package state at execution time. In a CLI skill context, this is more dangerous because the natural user action is to copy-paste the command directly into a shell, turning a documentation issue into a practical code-execution path.

Rp1

Medium
Category
MCP Rug Pull
Confidence
97% confidence
Finding
This `npx` example does not lock the package to a known-good version, so the code executed by users can change without notice. The risk is heightened by the fact that these are operational command references, which are likely to be copied verbatim by end users, making supply-chain compromise easier to exploit.

Rp1

Medium
Category
MCP Rug Pull
Confidence
97% confidence
Finding
The command example executes the `massive` package via `npx` without specifying a version, exposing users to arbitrary changes in the package contents over time. An attacker who compromises the package or release pipeline could leverage this pattern to achieve code execution on systems where the example is run.

Rp1

Medium
Category
MCP Rug Pull
Confidence
97% confidence
Finding
The final example also uses an unpinned `npx` invocation, which is a genuine supply-chain security issue rather than a harmless stylistic concern. In documentation for market-data CLI usage, users are expected to run these commands locally, so an attacker only needs the package stream to be compromised for the example to become an execution vector.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
The documentation instructs users to run `npx --yes massive` without pinning a package version, which causes execution of whatever version is currently published under that name. If the package is compromised, typo-squatted, or a malicious update is released, users following the docs may execute attacker-controlled code.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
This example uses `npx --yes massive` without a version pin, so the command resolves and executes the latest published package at runtime. That creates a supply-chain execution risk if the upstream package changes maliciously or unexpectedly.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
Running an unpinned package through `npx` can download and execute code that differs from what the author originally tested. In documentation, this is especially risky because users may copy-paste the command directly, amplifying supply-chain compromise impact.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
The unversioned `npx --yes massive` invocation permits execution of the latest remote package version rather than a known-good release. A compromised maintainer account or malicious publication could therefore lead to arbitrary code execution on user systems.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
Because `npx` fetches packages on demand, omitting an exact version means this documented command is non-deterministic and can run unreviewed code. That exposes users to supply-chain attacks and breaks reproducibility.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
This command example references a floating package name via `npx`, which is a known risky pattern for CLI documentation. If the package registry entry is hijacked or updated maliciously, users may execute arbitrary attacker code by following the docs.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
An unpinned `npx` command in documentation creates a supply-chain trust issue because the package contents are not fixed. Users may believe they are running the documented tool while actually executing a newer, potentially malicious package version.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
The example's `npx --yes massive` usage can execute whatever package version is currently published, which is unsafe in a security-sensitive sense. Copy-pasteable docs increase the likelihood of users running the command without reviewing what is fetched.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
This documentation snippet promotes execution of an unpinned remote npm package. That exposes users to arbitrary code execution if the package is replaced, compromised, or altered after the docs are published.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
Using `npx` without a version pin means the executed code is not stable over time and may include malicious updates. In reference documentation, this is a real supply-chain risk because examples are intended for direct execution.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
The command fetches and runs the latest `massive` package from the registry rather than a verified, fixed release. That can lead to arbitrary code execution on the user's machine if the package supply chain is compromised.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
An unpinned package reference in an `npx` example is a legitimate vulnerability because it delegates trust to the current registry state at execution time. Attackers exploiting the package distribution path could abuse this to run malicious code on user endpoints.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
This example is vulnerable to supply-chain abuse because it invokes `npx --yes massive` without constraining the resolved version. The documentation context makes exploitation plausible since readers may run the example as-is.

Static analysis

No suspicious patterns detected.