Back to skill

Security audit

uno

Security checks for vulnerabilities and agentic risk

Overview

This skill is a legitimate remote tool broker, but it uses broad authorization, persistent bearer-token storage, and third-party tool delegation without enough scoping or sensitive-data guidance.

Install only if you are comfortable sending tool searches and arguments to MCPMarket and using it as a broker for many third-party tools. Avoid sending secrets, private documents, credentials, source code, or regulated data unless you have explicitly reviewed the selected tool and destination. Treat `~/.uno/token` as a sensitive credential, prefer revocation or rotation if exposed, and be cautious when linking downstream accounts such as GitHub or Notion.

Vulnerability Patterns
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • 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)

T05 · Unauthorized Access and Privilege Escalation

Error
Location
SKILL.md:20
Finding
Overbroad OAuth Scope and Centralized Remote Tool Delegation## Vulnerability Details **File Location**: `SKILL.md:20-22`, `SKILL.md:51-55`, and `SKILL.md:104-110` **Vulnerability Type**: Excessive OAuth scope and broad delegation to a remote tool platform **Risk Level**: High ### Vulnerable Code ```bash # 1. Request a device code curl -s -X POST https://mcpmarket.cn/oauth/device/code \ -d "client_id=skill-agent&scope=mcp:*" ``` ```bash # Step 2: Call the tool curl -s -X POST https://mcpmarket.cn/api/uno/call-tool \ -H "Authorization: Bearer $(cat ~/.uno/token)" \ -H "Content-Type: application/json" \ -d '{"tool_name":"tonghu-weather.weatherArea","arguments":{"area":"Beijing"}}' ``` ```markdown **Downstream OAuth:** Some services (e.g. GitHub, Notion) require authorization on first call: ```json {"auth_required": true, "auth_url": "https://...", "state_id": "..."} ``` Open `auth_url`, complete authorization, then **call again directly** — the platform links the token server-side automatically. ``` ### Technical Analysis The Skill requests the wildcard OAuth scope `mcp:*`, rather than requesting permissions limited to the specific tool or operation selected by the user. It then sends a reusable bearer token, tool identifiers, and tool arguments to a centralized remote execution endpoint. This architecture is consistent with the Skill's advertised remote-tool functionality, so the network communication itself is not unrelated or covert. However, the wildcard authorization exceeds the minimum privilege required for many individual operations, such as querying weather data. The same platform can also hold links to downstream accounts such as GitHub or Notion, expanding the authorization boundary beyond a single MCP operation. Tool arguments may contain source code, document contents, search terms, locations, account identifiers, or other sensitive user data. The Skill does not instruct the agent to classify arguments, redact secrets, obtain explicit con ...[truncated 1716 chars]
Remediation
## Remediation Suggestions 1. Replace `mcp:*` with narrowly scoped, per-tool or per-capability OAuth permissions. 2. Request additional scopes only when the user selects a tool that requires them, using incremental authorization. 3. Require explicit user confirmation before sending secrets, private documents, source code, personal information, or account identifiers in tool arguments. 4. Add argument classification and redaction guidance, including a prohibition on transmitting credentials, session cookies, private keys, and unrelated environment data. 5. Display the selected tool, destination host, requested permissions, and data to be transmitted before invocation. 6. Maintain an allowlist of trusted tools and require additional approval for tools capable of writes, financial actions, account changes, or external publication. 7. Isolate downstream OAuth grants by service and tool, and provide clear procedures for reviewing and revoking each linked integration. 8. Document platform-side data retention, logging, subprocessors, encryption, and deletion behavior. 9. Use short-lived, audience-restricted tokens and rotate or revoke them after suspected exposure.

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:33
Finding
Bearer Token May Be Exposed Through Shell History and Process Logging## Vulnerability Details **File Location**: `SKILL.md:33-35` **Vulnerability Type**: Plaintext secret supplied as a shell command argument **Risk Level**: Medium ### Vulnerable Code ```bash # 3. Store the token mkdir -p ~/.uno && chmod 700 ~/.uno echo "ACCESS_TOKEN_VALUE" > ~/.uno/token && chmod 600 ~/.uno/token ``` ### Technical Analysis The destination directory and token file receive restrictive permissions, which protects the stored file from ordinary access by other local users. However, the instructions encourage replacing `ACCESS_TOKEN_VALUE` directly in an interactive shell command. A plaintext token entered this way may be retained in shell history, terminal transcripts, command auditing systems, remote-session logs, support recordings, or process-execution telemetry. The final file permissions do not remove copies created through those channels. Because the token is a bearer credential and is requested with the broad `mcp:*` scope, possession may be sufficient to authenticate to the documented API without an additional user secret. ### Attack Path 1. The user substitutes the real access token for `ACCESS_TOKEN_VALUE`. 2. The user executes the resulting `echo` command in an interactive shell. 3. The shell or endpoint-monitoring infrastructure records the complete command line. 4. An attacker with access to shell history, terminal logs, backups, audit data, or monitoring records obtains the token. 5. The attacker sends the token in an `Authorization: Bearer` header to supported API endpoints. 6. The attacker may invoke capabilities available to the token until it expires or is revoked. This path requires access to local or centralized command records; the reviewed Skill does not itself read or transmit shell history. ### Impact Assessment A recovered bearer token could allow impersonation of the authenticated user against the Uno API. Depending on server-side authorization, the a ...[truncated 299 chars]
Remediation
## Remediation Suggestions 1. Do not instruct users to place bearer tokens directly in shell command arguments. 2. Capture the token without terminal echo and write it through standard input, for example with a hidden-input prompt whose value is not included in command history. 3. Prefer an operating-system credential manager or secret-storage service over a plaintext file. 4. If file storage is required, create the file atomically with restrictive permissions by setting `umask 077` before writing it. 5. Avoid exporting the token as a persistent environment variable, since environment values may also be exposed through diagnostics or process inspection. 6. Document token expiration, rotation, logout, and server-side revocation procedures. 7. Recommend immediate revocation if a token is pasted into a command, chat, log, or other recorded interface. 8. Use short-lived and narrowly scoped tokens so that accidental disclosure has limited impact.
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • Rogue AgentSelf-Modification, Session Persistence
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
Findings (12)

Tool Parameter Abuse

High
Category
Tool Misuse
Content
|------|-------|
| Token file | `~/.uno/token` (permissions 0600) |
| API Base URL | `https://mcpmarket.cn` |
| Logout | `rm ~/.uno/token` |

____
Confidence
85% confidence
Finding
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Vague Triggers

Medium
Confidence
86% confidence
Finding
The skill is described so broadly ('call 2000+ tools') that it can be invoked for many generic requests without making clear that actions may be delegated to arbitrary third-party tools. This increases the chance of overbroad routing and unintended use of external services with weak user awareness or insufficient per-tool trust evaluation.

Missing User Warnings

Medium
Confidence
92% confidence
Finding
The documentation does not clearly warn users that search and invocation requests may send prompts, arguments, and possibly sensitive content to MCPMarket and downstream third-party services. In a broker skill that can call 2000+ tools, this omission materially increases privacy and data-handling risk because users may not realize their data leaves the local environment.

External Transmission

Medium
Category
Data Exfiltration
Content
```bash
# 1. Request a device code
curl -s -X POST https://mcpmarket.cn/oauth/device/code \
  -d "client_id=skill-agent&scope=mcp:*"
```
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
-d "grant_type=urn:ietf:params:oauth:grant-type:device_code&device_code=DEVICE_CODE&client_id=skill-agent"

# 3. Store the token
mkdir -p ~/.uno && chmod 700 ~/.uno
echo "ACCESS_TOKEN_VALUE" > ~/.uno/token && chmod 600 ~/.uno/token
```
Confidence
80% confidence
Finding
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.

Session Persistence

Medium
Category
Rogue Agent
Content
-d "grant_type=urn:ietf:params:oauth:grant-type:device_code&device_code=DEVICE_CODE&client_id=skill-agent"

# 3. Store the token
mkdir -p ~/.uno && chmod 700 ~/.uno
echo "ACCESS_TOKEN_VALUE" > ~/.uno/token && chmod 600 ~/.uno/token
```
Confidence
84% confidence
Finding
The skill explicitly persists a reusable bearer token across sessions in a local file, increasing the duration and scope of compromise if the host, account, backups, or shell environment are exposed. Session persistence is particularly sensitive here because the token can authorize searches and tool invocations across a broad third-party ecosystem.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
# 3. Store the token
mkdir -p ~/.uno && chmod 700 ~/.uno
echo "ACCESS_TOKEN_VALUE" > ~/.uno/token && chmod 600 ~/.uno/token
```

Verify login:
Confidence
80% confidence
Finding
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.

External Transmission

Medium
Category
Data Exfiltration
Content
## categories (Browse by Category)

```bash
curl -s https://mcpmarket.cn/api/uno/categories \
  -H "Authorization: Bearer $(cat ~/.uno/token)"
```
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
## credits (Balance + Recharge)

```bash
curl -s https://mcpmarket.cn/api/uno/credits \
  -H "Authorization: Bearer $(cat ~/.uno/token)"
```
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
## skills-fetch (Fetch Full Skill Content)

```bash
curl -s -X POST https://mcpmarket.cn/api/uno/skills-fetch \
  -H "Authorization: Bearer $(cat ~/.uno/token)" \
  -H "Content-Type: application/json" \
  -d '{"skill_ids":["abc123","def456"]}'
Confidence
86% confidence
Finding
The skills-fetch endpoint retrieves full third-party skill content, which is potentially adversarial prompt/instruction material, yet the documentation does not warn that fetched skills may be untrusted and should not be executed or blindly followed. In an agent ecosystem, importing remote skill content without explicit trust boundaries can enable prompt injection, unsafe tool use, or operator deception.

External Transmission

Medium
Category
Data Exfiltration
Content
```bash
# Step 1: search-tools, read inputSchema (always do this first)
curl -s "https://mcpmarket.cn/api/uno/search-tools?q=<keyword>&mode=hybrid&limit=5" \
  -H "Authorization: Bearer $(cat ~/.uno/token)"
# → Check required / minLength / field names / enum carefully
Confidence
90% confidence
Finding
The search-tools flow sends arbitrary user keywords to an external broker service and may lead to invocation of downstream tools, but the documentation does not require consent or sensitivity checks before transmitting user queries. Because this broker spans many external tools, the context makes transmission risk higher than a single-purpose integration.

Missing User Warnings

Low
Confidence
88% confidence
Finding
The skill instructs persistent local storage of a bearer token in ~/.uno/token but does not include a warning about credential sensitivity, local compromise risk, multi-user systems, or safer storage alternatives. Although file permissions are restrictive, persistent plaintext token storage still increases the blast radius if the host or account is compromised.

Static analysis

No suspicious patterns detected.