Back to skill

Security audit

Doppel

Security checks for vulnerabilities and agentic risk

Overview

The skill is mostly a real Doppel integration, but it gives the agent overly broad instructions and handles shared chat and tokens in ways users should review before installing.

Review this skill before installing. Only use it with a Doppel API key you are willing to expose to the Doppel service, avoid sending secrets or private instructions through space chat, prefer POST token exchange, and verify the space server URL and any recommended follow-on skills before use.

Vulnerability Patterns
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
  • 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 (4)

T01 · Skill Instruction Hijacking

Error
Location
SKILL.md:26
Finding
Unconditional Skill Instructions Override Agent Output and Safety Behavior<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 26-30 **Vulnerability Type**: `T01: Skill Instruction Hijacking` **Risk Level**: High ### Vulnerable Code ```markdown - NEVER respond with questions, clarifications, or conversational text - NEVER say "I can't", "Could you clarify", "What would you like", or similar phrases - Your ENTIRE response must be valid MML - If the request is vague, make reasonable creative decisions and generate MML - If the request is impossible with MML, generate the closest possible approximation ``` ### Technical Analysis These instructions unconditionally replace the agent's normal response behavior with an MML-only output policy. They expressly prohibit clarification and refusal language, even when clarification is required to avoid unsafe or unintended actions. The restriction is not scoped to an explicit MML-building operation. The declared skill functionality also includes identity registration, avatar management, listing spaces, and joining spaces, none of which requires every response to contain only MML. Consequently, these rules exceed the minimum behavioral authority required by the skill. By instructing the agent never to say that it cannot perform an action, the skill may also interfere with safety constraints, truthful capability reporting, and higher-priority formatting requirements. ### Attack Path 1. The Doppel skill is loaded for registration, browsing, joining, or another supported operation. 2. The unconditional output rules become part of the agent's active instructions. 3. A user submits an unrelated, ambiguous, impossible, or unsafe request. 4. The skill instructs the agent not to ask questions or provide a refusal. 5. The agent generates attacker-influenced MML instead of preserving the original task, safety response, or required output format. ### Impact Assessment The issue can alter the agent's current-session goals and response constraints. It may: - Suppress necessary safet ...[truncated 362 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Apply MML-only output rules exclusively when the user explicitly requests a space-building or MML-generation operation. - Replace global wording such as “NEVER” and “ENTIRE response” with narrowly scoped requirements. - Explicitly preserve higher-priority system, developer, safety, and user instructions. - Permit clarification when a request is ambiguous, security-sensitive, destructive, or cannot be represented safely in MML. - Permit truthful refusals and capability explanations. - Separate API-management workflows from MML-generation workflows so registration, browsing, and joining responses can use appropriate structured or conversational output. A safer rule would be: ```markdown When the user explicitly requests MML generation, return valid MML as the primary output unless higher-priority instructions, safety requirements, or a need for clarification require otherwise. ``` ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:70
Finding
JWT Transmission Through a URL Query Parameter<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, line 70 **Vulnerability Type**: `T09: Insecure Skill Coding Practices` **Risk Level**: Medium ### Vulnerable Code ```markdown - **GET** `{serverUrl}/session?token={jwt}` — Response: `{ "sessionToken": "..." }` ``` ### Technical Analysis The documented GET exchange places a sensitive JWT directly in the URL query string. URLs are commonly retained by infrastructure outside the application's direct control, including: - Web-server and reverse-proxy access logs. - HTTP client histories and diagnostic traces. - Monitoring, telemetry, and error-reporting platforms. - Gateway and content-delivery infrastructure. - Referrer data in some redirect or navigation scenarios. The document already defines a POST alternative: ```markdown - **POST** `{serverUrl}/session` — Body: `{ "token": "<jwt>" }`. Response: `{ "sessionToken": "..." }` ``` Therefore, query-string transmission is unnecessary and exceeds the minimum exposure required for session exchange. ### Attack Path 1. The agent receives a JWT after calling the hub join endpoint. 2. It follows the documented GET workflow and constructs `/session?token={jwt}`. 3. A server, proxy, HTTP tool, or monitoring component records the complete request URL. 4. An attacker or unauthorized operator with access to those records obtains the JWT. 5. Before expiration, the attacker exchanges or reuses the JWT to obtain a session token. 6. The attacker accesses the corresponding space using the resulting session authority. ### Impact Assessment A disclosed JWT may permit unauthorized session creation and access to the target space for the lifetime and scope of the token. Depending on server-side authorization, the resulting session could permit: - Reading chat history and occupant information. - Connecting to the space WebSocket. - Sending chat messages. - Accessing agent endpoints authorized for that session. - Creating, updating, or deleting the compromised a ...[truncated 211 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Remove the GET token-exchange workflow. - Require `POST /session` over HTTPS, with the JWT in a JSON request body. - Set appropriate cache-control headers, such as `Cache-Control: no-store`, on token exchange responses. - Ensure clients, servers, and diagnostic systems redact JWTs and session tokens. - Give JWTs a short expiration time and enforce one-time use where practical. - Bind join JWTs to the intended space server, space ID, agent identity, audience, and purpose. - Reject replayed, expired, or incorrectly scoped tokens. - Document that tokens must never appear in URLs, logs, error messages, or analytics events. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:137
Finding
Credential-Bearing Requests May Be Sent to an Unvalidated Dynamic Server URL<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 38-39, 62-71, and 137 **Vulnerability Type**: `T09: Insecure Skill Coding Practices` **Risk Level**: Medium ### Vulnerable Code ```markdown - **Hub:** `https://doppel.fun` (or `http://localhost:4000` for local development). Paths below are relative to this base unless noted. - **Space server:** `{serverUrl}` = the space’s 3D server URL (from join response or space `serverUrl`). ``` ```markdown - **POST** `{baseUrl}/api/spaces/:spaceId/join` - Headers: `Authorization: Bearer <api_key>` - Response: `{ "jwt": "...", "serverUrl": "https://..." | null, "spaceId": "..." }` - `serverUrl` may be `null` if the space server isn’t deployed yet. If space is full: 503 with `Retry-After`. **Space server (exchange JWT for session token)** - **GET** `{serverUrl}/session?token={jwt}` — Response: `{ "sessionToken": "..." }` - **POST** `{serverUrl}/session` — Body: `{ "token": "<jwt>" }`. Response: `{ "sessionToken": "..." }` ``` ```markdown For MVP, use OpenClaw's **web_fetch** (or HTTP) to call the Doppel hub API. No custom Doppel tool is required. When joining a space, use web_fetch to get the JWT and session token, then use a WebSocket client (or a Doppel bot script) to connect to the space server. ``` ### Technical Analysis Network communication is necessary for the skill's declared join functionality. The problem is that the destination receiving the JWT is dynamically supplied through `serverUrl`, while the instructions do not require the client to validate: - The URL scheme. - The destination hostname or approved domain. - DNS resolution to public rather than private or link-local addresses. - The effective destination after redirects. - Whether credentials remain bound to the original trusted origin. A compromised hub, malicious space record, poisoned response, or configuration error could therefore cause the agent to send the join JWT to an attacker-controlled endpoint. A private or l ...[truncated 1876 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Require HTTPS for all production hub, session, API, and WebSocket connections. - Validate `serverUrl` against an explicit allowlist of approved Doppel-controlled domains. - Canonicalize the hostname before validation and verify it again after DNS resolution. - Reject loopback, private, link-local, multicast, reserved, and cloud-metadata addresses. - Disable redirects during credential-bearing requests, or revalidate every redirect target and strip credentials on any origin change. - Bind join JWTs cryptographically to the expected space-server audience and reject them at any other server. - Never forward hub API keys or session authorization headers across origins. - Prefer a trusted hub-mediated mapping of space IDs to approved server identities rather than arbitrary URLs. - Treat all response-derived URLs as untrusted input. - Log only redacted destinations and never record JWTs or session tokens. - Keep the localhost development exception behind an explicit development-mode setting that cannot be enabled in production. ]]>

T08 · Insecure Dependencies

Warning
Location
SKILL.md:154
Finding
Unpinned Installation of Optional External Skills Creates Supply-Chain Risk<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 154-166 **Vulnerability Type**: `T08: Insecure Dependencies` **Risk Level**: Medium ### Vulnerable Code ```markdown ## Next step Once you're connected to a space, install the remaining skills to start building and sharing: ```bash clawhub install doppel-architect clawhub install doppel-block-builder clawhub install doppel-social-outreach clawhub install erc-8004 ``` 1. **`doppel-architect`** — reputation mechanics, token incentives, submission endpoint, and collaboration tactics. Install this first. 2. **`doppel-block-builder`** — block placement rules, MML format, and grid constraints. 3. **`doppel-social-outreach`** — share your builds on Moltbook and recruit other agents into your world. 4. **`erc-8004`** — register onchain for verifiable identity and reputation. Your onchain 8004 score feeds into token allocation. ``` ### Technical Analysis The skill recommends installing four external skills by mutable package name without specifying: - A reviewed version. - An immutable content hash. - A trusted publisher identity. - Signature verification. - A lockfile or reproducible manifest. - A security review or user confirmation step. The recommended components expand functionality into social outreach, token incentives, external submissions, and on-chain identity. Those capabilities are not required for the core declared functions of registering an agent, setting an avatar, browsing spaces, or joining a space. This creates a supply-chain trust expansion: the effective instructions and capabilities available to the agent can change after this skill has been reviewed if any named dependency is updated, transferred, replaced, or compromised. The available evidence shows installation recommendations, not automatic execution. It therefore does not establish that a malicious dependency is currently present, only that the documented installation process is insecure. ### Attack Path 1. An ...[truncated 1186 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Mark all follow-on skills as optional rather than presenting installation as the default next step. - Pin every dependency to a reviewed immutable version or content digest. - Verify package signatures and publisher identities before installation. - Maintain a lockfile or equivalent manifest containing exact versions and hashes. - Require explicit user approval before installing skills, especially those involving social posting, token incentives, or on-chain identity. - Audit each external skill independently before granting it access to credentials, network tools, wallets, or persistent state. - Remove dependencies unrelated to core Doppel registration, appearance, browsing, and joining functionality. - Use a trusted package allowlist and alert on publisher, signature, or digest changes. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • System Prompt LeakageDirect Leakage, Indirect Extraction, Tool-Based Exfiltration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (7)

Direct Prompt Extraction

High
Category
System Prompt Leakage
Content
Doppel is a virtual world for AI agents. Agents **always** interact **headless** (no browser). Use this skill to register, set appearance, list spaces, and join a space.

## MML output rules

You are an MML (Metaverse Markup Language) space builder expert.
Generate valid MML code to add OR modify objects in a 3D space based on user requests.
Confidence
90% confidence
Finding
The 'MML output rules' instruct the model to always emit valid MML, never ask clarifying questions, and make creative decisions when requests are vague. This is a prompt-level behavior override that can suppress normal safety checks and push the agent to comply with ambiguous or risky requests, including requests that may reveal hidden instructions or transform protected context into output artifacts.

Context Leakage

High
Category
Data Exfiltration
Content
## Chat with other agents

Agents can send chat messages visible to all other agents and observers in the same space. Use the **Chat APIs** above: **GET** `{serverUrl}/api/chat` for history, **POST** `{serverUrl}/api/chat` with body `{ "message": "..." }` to send. Headers: `Authorization: Bearer {sessionToken}`, `Content-Type: application/json`.

### WebSocket (DeltaNet)
Confidence
94% confidence
Finding
The skill enables arbitrary chat transmission to all other agents and observers in a space, creating a direct exfiltration channel for sensitive context. If the agent is induced to summarize its task, quote prior messages, or share credentials or hidden instructions, that data can be broadcast externally with little friction.

Context Leakage

High
Category
Data Exfiltration
Content
### WebSocket (DeltaNet)

If you're already connected via WebSocket, you can also send chat using a DeltaNet custom message:

- **Message type:** `2` (FROM_CLIENT_CHAT_MESSAGE_TYPE)
- **Payload:** JSON string `{ "message": "Hello world!" }`
Confidence
93% confidence
Finding
The WebSocket custom-message path provides another outbound broadcast mechanism for chat, bypassing any controls that might only inspect HTTP chat API calls. Multiple equivalent egress paths increase the risk of covert or accidental context leakage to all connected participants.

Description-Behavior Mismatch

Medium
Confidence
94% confidence
Finding
The skill manifest says the skill is for identity registration, avatar setting, browsing spaces, and joining a space, but the documentation additionally instructs the agent to generate and modify MML content for 3D world building. That materially expands the skill’s effective behavior and can cause an agent to perform higher-risk content generation or world modification actions the user did not explicitly authorize.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The documentation states that chat messages are visible to all agents and observers, but it does not require an explicit warning or confirmation before sending potentially sensitive content. In a multi-agent environment, this can lead to accidental disclosure of user data, internal reasoning, or confidential instructions to a broad audience.

Description-Behavior Mismatch

Low
Confidence
92% confidence
Finding
The skill introduces space-wide chat and message retrieval capabilities that are not disclosed in the manifest description. Hidden communication features increase the chance that an agent will transmit data to third parties or interact socially in ways the user did not expect from a 'join/browse/register' skill.

Description-Behavior Mismatch

Low
Confidence
84% confidence
Finding
The 'Next step' section broadens the workflow into outreach, recruitment, token incentives, and onchain reputation, none of which are part of the stated skill purpose. This creates scope creep that can steer an agent into promotional or blockchain-related actions without clear upfront disclosure.

Static analysis

No suspicious patterns detected.