Back to skill

Security audit

SpaceRouter

Security checks for vulnerabilities and agentic risk

Overview

This skill is a disclosed residential proxy helper, but users should treat its API key and proxied traffic carefully.

Install only if you intentionally want web requests routed through Space Router's residential proxy network. Avoid using it for sensitive sites or plaintext HTTP unless you accept that proxy metadata and non-TLS contents may be visible to the provider. Keep the API key out of shell history, logs, screenshots, and source control, prefer isolated environments, and pin or review SDK versions before installing them.

Vulnerability Patterns
  • 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
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
Findings (2)

T08 · Insecure Dependencies

Warning
Location
SKILL.md:42
Finding
Unpinned Third-Party Dependencies Installed from Mutable Package Registries## Vulnerability Details **File Location**: `SKILL.md:42`, `SKILL.md:64`, `SKILL.md:67`, and `SKILL.md:142` **Vulnerability Type**: Supply-chain exposure through unpinned dependencies **Risk Level**: Medium **Complete Code Snippets**: ```bash pip install spacerouter ``` ```bash npm install @spacenetwork/spacerouter ``` ```bash pip install spacerouter-cli spacerouter config set api-key sr_live_YOUR_API_KEY spacerouter request get https://example.com ``` ```python pip install spacerouter[socks] client = SpaceRouter("sr_live_xxx", protocol="socks5", gateway_url="socks5://gateway:1080") ``` ### Technical Analysis The documented installation commands retrieve packages by name without pinning an audited version, validating package hashes, using a lockfile, or identifying a verified source revision. Consequently, the code installed when a user follows these instructions can change independently of the reviewed Skill. Python and Node.js package installation may execute package-controlled build or lifecycle logic. A compromised publisher account, malicious new release, registry compromise, or dependency-confusion condition could therefore introduce code that was not present during this audit. The project does not vendor these dependencies, so their behavior cannot be validated from the supplied artifact. This finding does not establish that the named packages are currently malicious. It establishes that the documented dependency process does not guarantee that users receive the same reviewed package content. ### Attack Path 1. An attacker compromises a package publisher, dependency, or relevant registry path, or publishes an unsafe replacement release. 2. The attacker places malicious code in an installation hook, build backend, lifecycle script, imported module, or executable. 3. A user follows one of the unpinned `pip install` or `npm install` instructions. 4. The package manager resolves the current m ...[truncated 916 chars]
Remediation
## Remediation Suggestions 1. Pin every documented dependency to a specifically reviewed version, for example by using exact Python and npm versions. 2. Provide lockfiles or constraints generated from reviewed dependency trees, including transitive dependencies. 3. For Python, distribute and verify hashes with a requirements file and `pip install --require-hashes`. 4. For Node.js, provide a committed lockfile and recommend deterministic installation with `npm ci`. 5. Identify the official package registry entries and source repositories so users can verify package ownership. 6. Review package build scripts and npm lifecycle hooks before approving version updates. 7. Recommend installation in an isolated virtual environment or container without unnecessary credentials or filesystem access. 8. Establish an update process that re-audits dependencies before changing pinned versions.

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:67
Finding
Proxy API Key Exposed Through Command-Line Configuration Instructions## Vulnerability Details **File Location**: `SKILL.md:67-71` **Vulnerability Type**: Sensitive credential exposure through command-line arguments and shell history **Risk Level**: Medium **Complete Code Snippet**: ```bash pip install spacerouter-cli spacerouter config set api-key sr_live_YOUR_API_KEY spacerouter request get https://example.com ``` ### Technical Analysis The instructions encourage users to replace `sr_live_YOUR_API_KEY` with a real API key directly in an interactive command. Commands entered this way are commonly retained in shell history files. Depending on operating-system configuration and execution timing, command arguments may also be captured by process inspection, audit facilities, terminal logging, command telemetry, support bundles, or session recording. The documentation does not state where the CLI persists the credential, what permissions protect that storage, or whether the key is encrypted. As a result, users lack the information needed to assess the credential's exposure after running the command. The placeholder itself is not a hardcoded live secret. The vulnerability is the recommended method for supplying a real secret. ### Attack Path 1. A user replaces the placeholder with a valid Space Router API key and runs the documented command. 2. The shell records the command in its history, or local monitoring and audit systems capture its arguments. 3. Another local user, administrator, malicious process, compromised backup, or log recipient obtains the recorded command. 4. The party extracts the `sr_live_...` credential. 5. The party uses the key to authenticate to the proxy service and consume the associated account's proxy capabilities until the key is revoked or expires. ### Impact Assessment An exposed key may permit unauthorized use of the victim's Space Router account, including consumption of rate limits or paid capacity and proxy requests attributed to that account. Abuse ma ...[truncated 328 chars]
Remediation
## Remediation Suggestions 1. Do not place API keys directly in command-line arguments. 2. Support a protected environment variable, standard input, or an interactive prompt that disables terminal echo. 3. Prefer an instruction such as reading `SPACE_ROUTER_PROXY_URL` or a dedicated API-key environment variable internally, without expanding the value into a displayed command. 4. Document the CLI credential storage location, file permissions, encryption behavior, and deletion procedure. 5. Ensure stored credential files are restricted to the owning user, such as mode `0600` on applicable systems. 6. Warn users not to place real keys in shell history, scripts, screenshots, logs, or source control. 7. Provide key revocation and rotation instructions for suspected exposure. 8. Recommend clearing affected history and telemetry records where feasible if the existing command has already been used with a real key.
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
Findings (2)

Lp3

Medium
Category
MCP Least Privilege
Confidence
90% confidence
Finding
The skill documents shell-based installation, environment export, curl usage, and execution of a local verification script, but it does not declare any tool scope such as allowed-tools or permissions. That mismatch can cause the agent runtime or reviewer to underestimate the skill's operational capabilities, increasing the risk of unintended shell execution and environment-variable handling involving proxy credentials.

Missing User Warnings

Medium
Confidence
96% confidence
Finding
This skill routes HTTP traffic through a third-party residential proxy network but does not clearly warn users that request destinations, timing, metadata, and potentially plaintext non-TLS traffic will transit an external service. In context, the skill is specifically intended to bypass IP-based blocking and scraping restrictions, which makes informed consent and disclosure especially important because sensitive browsing targets or user data could be exposed to the proxy provider.

Static analysis

No suspicious patterns detected.