Back to skill

Security audit

Weibo User Profile API

Security checks for vulnerabilities and agentic risk

Overview

This skill is a focused Weibo profile lookup through JustOneAPI, with a real but disclosed token-handling risk.

Install only if you are comfortable giving this skill a JustOneAPI token. Prefer a narrowly scoped, revocable token, avoid shared machines or verbose process logging, and rotate the token if you suspect command-line or URL logs may capture it.

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:35
Finding

API Token Exposed Through Process Command-Line Arguments

Content
View full analysis
"}' ``` The executable explicitly accepts the credential through a command-line flag: ```js if (flag === "--token") { parsed.token = value; index += 1; continue; } ``` ### Technical Analysis The documented invocation expands `JUST_ONE_API_TOKEN` into the process argument vector. On operating systems where process arguments are accessible through process inspection tools, `/proc` interfaces, monitoring agents, shell auditing, crash reports, or command telemetry, the plaintext token may be exposed to local users or log operators. This transmission mechanism is not required merely because the Skill needs a token. The implementation could read `JUST_ONE_API_TOKEN` directly from the environment without copying it into the argument vector. Environment variables still require protection, but this avoids the additional process-list exposure introduced by `--token`. ### Attack Path 1. A user invokes the Skill using the documented command. 2. The shell expands `$JUST_ONE_API_TOKEN` into the plaintext `--token` argument. 3. While the Node.js process is running, an attacker with sufficient local process-inspection access, or a monitoring system that records command lines, captures the argument vector. 4. The attacker extracts the token following `--token`. 5. The token is reused to make unauthorized requests to JustOneAPI, subject to the token's assigned permissions and service-side limits. ### Impact Assessment Successful exploitation discloses the JustOneAPI access token. An attacker could make API requests authorized by that token, consume its quota, incur associated usage costs, and access any other JustOneA ...[truncated 280 chars]
Remediation
View remediation

T09 · Insecure Skill Coding Practices

Warning
Location
bin/run.mjs:210
Finding

API Token Transmitted in the Request URL Query String

Content
View full analysis
parameter.name === "token"); if (!tokenParam || params.token !== undefined) { return; } if (!cliToken) { fail("--token is required for this operation.", { operationId: operation.operationId, }); } params.token = cliToken; } ``` All parameters marked as query parameters are appended to the request URL: ```js function applyQueryParams(operation, params, url) { for (const parameter of operation.parameters.filter((item) => item.location === "query")) { const value = params[parameter.name]; if (value === undefined) { continue; } appendValue(url.searchParams, parameter.name, value); } } ``` The resulting URL is then sent over the network: ```js try { response = await fetch(url, requestInit); } catch (error) { fail("Network request failed.", { cause: error instanceof Error ? error.message : String(error), operationId: operation.operationId, }); } ``` ### Technical Analysis The Skill necessarily sends an authentication credential to JustOneAPI, and the destination is constrained to the hard-coded HTTPS origin `https://api.justoneapi.com`. HTTPS protects the URL from passive observation while it is in transit. However, embedding credentials in query strings creates additional exposure because complete URLs are commonly retained by reverse proxies, API gateways, se ...[truncated 1492 chars]
Remediation
View remediation
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
Findings (5)

Credential Access

High
Category
Privilege Escalation
Confidence
90% confidence
Finding

This finding reflects that the skill explicitly handles an access token, which is not inherently malicious, but in this implementation the credential is collected and transmitted in a less secure way via the URL. In the context of an external API integration, this increases the chance of accidental credential exposure to infrastructure or logs rather than indicating deliberate credential theft.

Content

Scanner excerpt · bin/run.mjs (reported line 20)May include surrounding context.

js
"parameters": [
        {
          "defaultValue": null,
          "description": "API access token.",
          "enumValues": [],
          "location": "query",
          "name": "token",

Credential Access

High
Category
Privilege Escalation
Confidence
98% confidence
Finding

The skill requires an API access token to be sent as a query parameter, which is an insecure credential handling pattern. Query-string secrets are commonly exposed through logs, browser history, intermediary proxies, analytics, and monitoring systems, making accidental credential disclosure more likely even when HTTPS is used.

Content

Scanner excerpt · generated/operations.json (reported line 15)May include surrounding context.

json
"parameters": [
        {
          "defaultValue": null,
          "description": "API access token.",
          "enumValues": [],
          "location": "query",
          "name": "token",

Credential Access

High
Category
Privilege Escalation
Confidence
70% confidence
Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · generated/operations.md (reported line 19)May include surrounding context.

md
| Name | In | Required | Type | Default | Description |
| --- | --- | --- | --- | --- | --- |
| `token` | `query` | yes | `string` | n/a | API access token. |
| `uid` | `query` | yes | `string` | n/a | Weibo User ID (UID). |

### Request body

Undeclared Tool Scope

Medium
Category
MCP Least Privilege
Confidence
86% confidence
Finding

The skill invokes a network-capable helper (node .../bin/run.mjs) and requires an API token, but it does not declare an explicit tool scope such as permissions or allowed-tools. This creates an authorization gap where an agent or platform may permit broader-than-intended execution or make unsafe assumptions about what external access the skill needs.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
98% confidence
Finding

The skill defines the API access token as a query parameter and later appends all query parameters directly into the request URL. Tokens in URLs are routinely exposed through logs, browser/history mechanisms, proxy layers, monitoring systems, and error telemetry, making credential leakage more likely than if the token were sent in an Authorization header.

Content

No source excerpt is available for this finding.