Back to skill

Security audit

jiujiu-mindmap-summary

Security checks for vulnerabilities and agentic risk

Overview

This skill performs the advertised mind-map generation task, but it asks users to use a shared API key and sends user text plus that key to an under-disclosed HTTP service.

Review before installing. Do not submit confidential, proprietary, regulated, or secret-bearing text unless you control and trust the service listening on 127.0.0.1:8000. Replace the shared trial key with a unique key, and prefer an authenticated HTTPS or protected local IPC setup before routine use.

Vulnerability Patterns
  • 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
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (2)

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:18
Finding
Publicly Documented Shared API Credential<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:18` **Vulnerability Type**: Hardcoded shared credential **Risk Level**: Medium ### Vulnerable Code Snippet ```text JIUJIUMINDMAP_API_KEY=jiujiu-secret-key-123-456 ``` The documentation exposes `jiujiu-secret-key-123-456` as a default trial API key and instructs users to assign it to `JIUJIUMINDMAP_API_KEY`. ### Technical Analysis API credentials must not be embedded in publicly distributed skill packages or their documentation. Because every user receives the same value, the credential cannot provide reliable authentication or request attribution. The effective severity depends on whether a compatible API service accepts this documented credential and whether that service is reachable by an attacker. The repository does not contain the server implementation, so server reachability and accepted privileges cannot be confirmed from the audited files alone. ### Attack Path 1. An attacker obtains the skill package or reads its documentation. 2. The attacker extracts the documented API key. 3. The attacker identifies a service that accepts this shared credential. 4. The attacker supplies the value through the expected `x-api-key` header. 5. If the service still accepts the key, the attacker can issue requests with the same authorization assigned to legitimate trial users. ### Impact Assessment If accepted by a reachable service, the exposed key may allow unauthorized API requests, quota consumption, service abuse, and impersonation of legitimate users. All users sharing the key would be represented by the same credential, preventing meaningful per-user attribution and selective revocation. No administrative privileges or access beyond the API key's server-side authorization can be established from the audited client code. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove the shared credential from the documentation and all distributed artifacts. 2. Revoke or rotate `jiujiu-secret-key-123-456` wherever it is currently accepted. 3. Provision a unique credential for each user or installation through an authenticated enrollment process. 4. Store credentials only in a secret manager or protected environment variable; never provide a working default value. 5. Prefer scoped, short-lived tokens with expiration, revocation, and rate limits. 6. Add server-side monitoring to detect use of the exposed key and investigate historical abuse. 7. Update the documentation to use an unambiguously nonfunctional placeholder, such as `YOUR_API_KEY`. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/generate.mjs:38
Finding
Sensitive Input and API Credential Sent to an Unauthenticated Plaintext Local Service<![CDATA[ ## Vulnerability Details **File Location**: `scripts/generate.mjs:38-52` **Vulnerability Type**: Plaintext transmission of sensitive information to an unauthenticated local endpoint **Risk Level**: Medium ### Vulnerable Code Snippet ```js const API_URL = "http://127.0.0.1:8000/generate"; const body = { text: textInput }; const resp = await fetch(API_URL, { method: "POST", headers: { "Content-Type": "application/json", "x-api-key": apiKey }, body: JSON.stringify(body), }); ``` ### Technical Analysis The script sends both user-controlled text and the reusable API credential over HTTP. The endpoint is hardcoded to loopback, which prevents ordinary remote network interception, but HTTP does not authenticate the process listening on port `8000` and does not protect the request at the transport layer. Any local process able to bind to `127.0.0.1:8000` before the intended service starts can impersonate the expected API. When the skill runs, the impersonating process receives the `x-api-key` header and the complete text submitted for summarization. This issue does not itself grant remote access. Exploitation requires local code execution or another capability to control the expected loopback listener. ### Attack Path 1. An attacker obtains the ability to run an untrusted process in the same host or sufficiently shared network namespace. 2. The malicious process binds to `127.0.0.1:8000` while the legitimate service is unavailable. 3. A user invokes the skill with potentially sensitive text. 4. The script sends a plaintext HTTP request to the malicious listener. 5. The listener captures the `x-api-key` header and the complete input body. 6. The attacker may replay the credential against any other service that accepts it or retain the submitted content. ### Impact Assessment Successful exploitation can disclose all text submitted for summarization and the configured API key. The captured credential may grant whatever API privilege ...[truncated 343 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Use HTTPS with certificate validation when communicating with an HTTP service, including local services when sensitive credentials are transmitted. 2. For a strictly local service, prefer an authenticated operating-system IPC mechanism such as a Unix domain socket with restrictive filesystem permissions. 3. Authenticate the local server rather than assuming that any process bound to port `8000` is trusted. 4. Make the endpoint explicitly configurable and validate its scheme, host, and allowed destination before sending credentials. 5. Use short-lived, narrowly scoped tokens so capture does not expose a reusable long-term secret. 6. Ensure the expected service binds securely and fails closed if its authenticated transport cannot be established. 7. Avoid sending confidential source text unless the user has been clearly informed of the destination and trust boundary. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
Findings (8)

Lp3

Medium
Category
MCP Least Privilege
Confidence
95% confidence
Finding
The skill declares code-related capabilities through required binaries and environment variables, and it appears to rely on an external API, but it does not explicitly declare tool scope such as allowed tools or permissions. This creates unnecessary ambiguity about what execution and network access the skill may use, making review and policy enforcement harder and increasing the risk of unintended data access or outbound transmission.

Natural-Language Policy Violations

Medium
Confidence
88% confidence
Finding
The manifest description and instructions are entirely in Chinese and present the skill as operating in that language without any indication that users may choose another language or that the locale restriction is required. This can violate language/locale policy when no opt-in or justification is provided.

Missing User Warnings

Medium
Confidence
98% confidence
Finding
The skill asks for an API key and takes arbitrary input text, but it does not disclose that the text will be sent to an external service for processing. This omission is dangerous because users may pass sensitive, proprietary, or regulated content under the false assumption that processing is local, resulting in unconsented data disclosure.

Context-Inappropriate Capability

Medium
Confidence
99% confidence
Finding
The documentation instructs users to set a hardcoded default trial API key in an environment variable, which is a major red flag because embedded credentials encourage secret reuse and may route requests through an untrusted shared account. Hardcoded or shared API keys can enable unauthorized service use, abuse attribution confusion, and possible exfiltration of user-submitted content to a third party without proper ownership or consent.

Natural-Language Policy Violations

Medium
Confidence
91% confidence
Finding
The script includes user-facing comments and error/output strings in Chinese, such as the prompt at L24 and status text at L56/L62, without offering any locale or language selection. This creates a natural-language policy issue because it imposes a specific language on users without documented opt-in or justification.

Description-Behavior Mismatch

Medium
Confidence
96% confidence
Finding
The script transmits the full user-provided text to an external service for processing, but the skill description only presents this as a local mind-map generation capability. This creates a data disclosure and trust-boundary issue because users may provide sensitive text without realizing it is being forwarded off-process to another server.

Missing User Warnings

Medium
Confidence
97% confidence
Finding
The request sends both the user's full text and an API key to a server without any user-facing warning or disclosure, preventing informed consent for data sharing. In addition, the endpoint uses plain HTTP, so if this is changed from localhost to a remote host as the comment suggests, the payload and credential could be exposed in transit.

Context-Inappropriate Capability

Low
Confidence
83% confidence
Finding
The skill requires an API key from the environment even though that capability is not disclosed in the manifest, which weakens transparency around credential use. While the code does not itself exfiltrate arbitrary environment data, it does handle a secret and sends it in a request header to a service that users are not clearly informed about.

Static analysis

Detected: suspicious.exposed_secret_literal

File appears to expose a hardcoded API secret or token.

Critical
Code
suspicious.exposed_secret_literal
Location
SKILL.md:20