Back to skill

Security audit

digital staff

Security checks for vulnerabilities and agentic risk

Overview

This is a real OpenClaw agent-management dashboard, but it exposes powerful agent, skill, and configuration controls over a network service without visible authentication.

Install only in a tightly controlled local environment, preferably after changing the host to 127.0.0.1, removing the open_port.sh firewall exposure, and adding authentication before using any agent, skill-installation, or configuration endpoints. Treat this as an administrative tool with access to OpenClaw agents, prompts, skills, model configuration, and local dashboard state.

Vulnerability Patterns
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • System PersistenceInstalls backdoors, hooks, services, or scheduled tasks that survive the run
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
Findings (8)

T05 · Unauthorized Access and Privilege Escalation

Error
Location
dashboard_server.py:872
Finding
Unauthenticated Administrative API Exposed on All Network Interfaces<![CDATA[ ## Vulnerability Details **File Location**: `dashboard_server.py:872-875` **Vulnerability Type**: Missing authentication and network access control **Risk Level**: Critical ### Vulnerable Code ```python app.run( host=config.get('host', '0.0.0.0'), port=config.get('port', 5178), debug=config.get('debug', False), threaded=True ) ``` The configured value confirms the unsafe default: ```json { "host": "0.0.0.0", "port": 5181 } ``` Administrative routes are registered without authentication or authorization checks, for example: ```python @app.route('/api/agents/<agent_name>', methods=['DELETE']) def delete_agent_endpoint(agent_name): if not _validate_agent_name(agent_name): abort(400, "Invalid agent name") try: result = openclaw_config_manager.delete_agent(agent_name) return jsonify(result) except Exception as e: return jsonify({"success": False, "error": str(e)}), 500 ``` ### Technical Analysis The Flask application binds to every interface while implementing no login mechanism, bearer-token validation, session authorization, request-signature validation, or authorization middleware. Network access to port 5181 is therefore sufficient to invoke privileged API operations. The exposed API can read OpenClaw session information and system paths, update dashboard and OpenClaw configuration, create or delete agents, modify subagent permissions, enable or disable skills, upload files, and initiate skill installation. This contradicts the documentation statement that authentication is inherited from OpenClaw. The dashboard is a separate Flask application and contains no implementation that performs such inheritance. ### Attack Path 1. An attacker discovers TCP port 5181 on a host running the dashboard. 2. The attacker requests `/api/agents` or `/api/system-info` without credentials to enumerate agents and installation paths. 3. The attacker submits unauthenticated POST or DELETE request ...[truncated 666 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Bind to `127.0.0.1` by default and require an explicit secure configuration to permit remote access. 2. Add authentication to every `/api/` endpoint. Use a securely generated credential or integrate with OpenClaw through a documented, verified authentication protocol. 3. Enforce authorization by operation. Destructive and installation actions should require an administrator role and explicit reauthentication. 4. Add CSRF protection to state-changing browser requests and reject requests with untrusted `Origin` or `Host` headers. 5. Place remote deployments behind a TLS-enabled reverse proxy and restrict access through firewall rules or a private VPN. 6. Add rate limiting, audit logging, and alerts for agent deletion, configuration changes, prompt changes, and skill installation. 7. Update the documentation so it does not claim inherited authentication unless that integration is actually implemented and tested. ]]>

T02 · Agent Memory Poisoning

Error
Location
openclaw_config.py:510
Finding
Persistent Agent Instruction Poisoning Through Attacker-Controlled System Prompts<![CDATA[ ## Vulnerability Details **File Location**: `openclaw_config.py:510-527` **Vulnerability Type**: Persistent instruction injection **Risk Level**: Critical ### Vulnerable Code ```python metadata = { "display_name": agent_data.get("display_name", agent_name), "role": agent_data.get("role", "Agent"), "emoji": agent_data.get("emoji", "🤖"), "description": agent_data.get("description", ""), "color": agent_data.get("color", "cyan"), "system_prompt": agent_data.get("system_prompt", ""), "model_provider": model_provider, "model_id": model_id, "created_at": datetime.now().isoformat(), "version": "1.0" } metadata_file = agent_dir / "agent" / "metadata.json" with open(metadata_file, 'w', encoding='utf-8') as f: json.dump(metadata, f, indent=2, ensure_ascii=False) # Write the system prompt into the agent workspace. system_prompt = agent_data.get("system_prompt", "").strip() if system_prompt: soul_file = workspace_dir / "soul.md" with open(soul_file, 'w', encoding='utf-8') as f: f.write(system_prompt) ``` ### Technical Analysis The agent-creation API accepts an arbitrary `system_prompt` and persists it in both agent metadata and the agent workspace's `soul.md`. No trust validation, review step, policy validation, or authorization boundary is applied before the instructions are stored. This becomes directly exploitable because `/api/agents` is unauthenticated. The injected instructions survive the original HTTP request and can influence future agent sessions whenever OpenClaw consumes the workspace instructions. ### Attack Path 1. An attacker reaches the unauthenticated dashboard API. 2. The attacker sends `POST /api/agents` with a new agent identifier and a malicious `system_prompt`. 3. The server creates the agent and writes the supplied prompt to `metadata.json` and `workspace-<agent>/soul.md`. 4. A user or automated workflow later starts or delegates work to the poisoned agent. 5. The agent f ...[truncated 462 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Require strong administrator authentication and authorization before creating agents or changing their instructions. 2. Treat system-prompt changes as security-sensitive configuration requiring explicit review and confirmation. 3. Validate prompts against prohibited instruction patterns and display the complete resulting prompt before committing it. 4. Record immutable audit events containing the actor, timestamp, affected agent, and reviewed change. 5. Separate untrusted display metadata from executable agent instructions. 6. Apply least-privilege tool permissions to newly created agents and do not automatically grant broad delegation or tool access. 7. Support rollback to a trusted prompt version and alert administrators when persistent instructions change. ]]>

T08 · Insecure Dependencies

Error
Location
dashboard_server.py:821
Finding
Unauthenticated Installation and Automatic Enablement of Third-Party Skills<![CDATA[ ## Vulnerability Details **File Location**: `dashboard_server.py:821-855` **Vulnerability Type**: Unrestricted software installation **Risk Level**: High ### Vulnerable Code ```python @app.route('/api/agents/<agent_name>/skills/install', methods=['POST']) def install_agent_skill(agent_name): """Install a new skill for an Agent through the OpenClaw CLI.""" if not _validate_agent_name(agent_name): abort(400, "Invalid agent name") try: data = request.get_json() skill_id = data.get('skillId') if not skill_id: return jsonify({"success": False, "error": "skillId is required"}), 400 import subprocess result = subprocess.run( ['openclaw', 'skills', 'install', skill_id], capture_output=True, text=True, timeout=120 ) if result.returncode == 0: skills_manager.enable_skill_for_agent(agent_name, skill_id) return jsonify({ "success": True, "message": f"Skill '{skill_id}' installed and enabled for '{agent_name}'", "output": result.stdout }) ``` ### Technical Analysis The process invocation uses an argument array, so direct shell metacharacter injection is not established. However, `skillId` is entirely caller-controlled and is passed to a package-installation function without authentication, an allowlist, source restrictions, version pinning, integrity verification, or administrator approval. Successful installation is followed by automatic enablement for the selected agent. If the OpenClaw CLI accepts remote package identifiers, repositories, or mutable package names, an attacker can cause unreviewed third-party content to be introduced into the OpenClaw environment. ### Attack Path 1. An attacker enumerates an existing agent through `GET /api/agents`. 2. The attacker chooses a malicious or compromised skill identifier accepted by the Op ...[truncated 682 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Require administrator authentication and explicit authorization for all installation operations. 2. Restrict installation to an administrator-maintained allowlist of trusted skill names and sources. 3. Pin every skill to an immutable version or commit and verify a cryptographic digest or signature before installation. 4. Do not automatically enable newly installed skills. Require a separate review and approval action. 5. Display the source, version, requested permissions, files, and installation hooks before confirmation. 6. Run installation in an isolated environment with minimal filesystem and network privileges. 7. Log installation attempts and reject URL, path, repository, and package forms not explicitly supported by policy. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
static/js/app.js:709
Finding
Stored DOM Cross-Site Scripting in Agent Cards<![CDATA[ ## Vulnerability Details **File Location**: `static/js/app.js:709-773` **Vulnerability Type**: Stored DOM cross-site scripting **Risk Level**: High ### Vulnerable Code ```javascript card.innerHTML = ` <div class="agent-header"> <div class="agent-identity"> <div class="avatar-container" onclick="event.stopPropagation(); openAvatarUpload('${agent.name}')"> <div class="avatar ${display.color}"> <div class="avatar-bg"></div> <img src="/api/agents/${agent.name}/avatar" alt="${display.emoji} ${display.name}" onerror="this.style.display='none'; this.nextElementSibling.style.display='flex';"> <span class="emoji-fallback" style="display:none">${display.emoji}</span> </div> <div class="avatar-upload-overlay">📷</div> <div class="status-indicator"></div> </div> <div class="agent-info"> <div class="agent-name">${display.name}</div> <div class="agent-role">${display.role}</div> <span class="status-badge ${isRunning ? 'running' : 'idle'}"> ${isRunning ? '●' : '○'} ${isRunning ? 'Running' : 'Idle'} </span> ${agentStats.currentModel ? ` <div class="current-model-compact"> <span>${agentStats.currentModel}</span> </div> ` : ''} </div> </div> </div> <button class="work-check-btn" onclick="event.stopPropagation(); openWorkCheck('${agent.name}')" ${state.openclawBaseUrl ? '' : 'disabled title="OpenClaw URL not configured"'}> <span class="work-check-tooltip">Chat</span> </button> <button class="agent-skills-btn" onclick="event.stopPropagation(); openSkillsManager('${agent.name}')" title="Manage skills"> ...[truncated 1664 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Replace dynamic `innerHTML` templates with DOM construction and assign untrusted values through `textContent`. 2. Remove inline event handlers. Register event listeners with `addEventListener` and pass identifiers through closures. 3. Validate agent identifiers against a strict server-side and client-side allowlist such as `^[a-z0-9][a-z0-9_-]{0,63}$`. 4. Validate colors against a fixed set of CSS class names rather than accepting arbitrary text. 5. If HTML rendering is unavoidable, use a proven sanitizer and apply context-aware escaping to text, attribute, URL, and JavaScript contexts. 6. Deploy a restrictive Content Security Policy that blocks inline scripts and event handlers. 7. Add regression tests using payloads in every metadata and session field rendered by the interface. ]]>

other

Warning
Location
static/js/app.js:289
Finding
Precise Location and IP Information Disclosed to Multiple Third-Party Services<![CDATA[ ## Vulnerability Details **File Location**: `static/js/app.js:289-439` **Vulnerability Type**: Location data disclosure **Risk Level**: Medium ### Vulnerable Code ```javascript const fetchWeather = async (lat, lon, cityName = null) => { try { const location = cityName || `${lat},${lon}`; const response = await fetch( `https://wttr.in/${encodeURIComponent(location)}?format=%c+%t+%C+%l`, { mode: 'cors' } ).catch(() => null); if (response && response.ok) { const text = await response.text(); return parseWeatherData(text); } return await fetchOpenMeteo(lat, lon, cityName); } catch (e) { return null; } }; const fetchOpenMeteo = async (lat, lon, cityName) => { const url = `https://api.open-meteo.com/v1/forecast?latitude=${lat}&longitude=${lon}&current=temperature_2m,weather_code&timezone=auto`; const response = await fetch(url); // ... }; const getLocationByIP = async () => { const response = await fetch('https://ipapi.co/json/'); // ... }; const reverseGeocode = async (lat, lon) => { const url = `https://api.bigdatacloud.net/data/reverse-geocode-client?latitude=${lat}&longitude=${lon}&localityLanguage=zh`; const response = await fetch(url); // ... }; if (navigator.geolocation) { navigator.geolocation.getCurrentPosition( async (position) => { const { latitude, longitude } = position.coords; const cityName = await reverseGeocode(latitude, longitude); const weather = await fetchWeather(latitude, longitude, cityName); renderWeather(weather); }, async () => { const location = await getLocationByIP(); if (location) { const weather = await fetchWeather(location.lat, location.lon, location.city); renderWeather(weather); } } ); } ``` ### Technical Analysis ...[truncated 1425 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Disable weather and all location requests by default. 2. Present an explicit, informed opt-in before requesting browser geolocation or contacting an IP-geolocation service. 3. Provide a setting that permanently disables third-party network calls. 4. Reduce coordinate precision before transmission and avoid sending exact coordinates when city-level weather is sufficient. 5. Prefer a user-entered city over automatic location discovery. 6. Document every recipient, transmitted field, purpose, retention implication, and update interval. 7. Consider a controlled backend proxy with caching and data minimization if the weather feature must be retained. ]]>

T06 · System Persistence

Warning
Location
install.sh:87
Finding
Persistent Auto-Start Service Extends Exposure Across User Sessions<![CDATA[ ## Vulnerability Details **File Location**: `install.sh:87-110` **Vulnerability Type**: Persistent user service installation **Risk Level**: Medium ### Vulnerable Code ```bash mkdir -p "$HOME/.config/systemd/user" cat > "$HOME/.config/systemd/user/${SERVICE_NAME}.service" << EOF [Unit] Description=Agent Dashboard V2 After=network.target [Service] Type=simple WorkingDirectory=$SCRIPT_DIR Environment="OPENCLAW_HOME=$OPENCLAW_HOME" Environment="DASHBOARD_PORT=$PORT" ExecStart=$PYTHON_CMD $SCRIPT_DIR/dashboard_server.py Restart=on-failure RestartSec=5 [Install] WantedBy=default.target EOF systemctl --user daemon-reload systemctl --user enable ${SERVICE_NAME}.service ``` ### Technical Analysis The installer optionally writes and enables a systemd user service with automatic restart. The installation is interactive and therefore not covert, but it creates cross-session persistence for a service that binds to all network interfaces and exposes privileged APIs without authentication. The service definition also references executable code directly from the project directory. If that directory is later modified, the changed code will run automatically under the user's account when the service starts or restarts. ### Attack Path 1. The user accepts the installer option to create a systemd service. 2. The installer enables the service for future user sessions. 3. The dashboard starts or restarts automatically and listens on all interfaces. 4. A network attacker reaches the unauthenticated API even after the user believed the original interactive run had ended. 5. If project files are modified, systemd executes the modified server code on the next restart. ### Impact Assessment The vulnerable dashboard remains available across logins and automatically recovers after failure. This materially increases the duration and reliability of the remote attack surface. The persistent process runs with the user's access to OpenClaw configuration, agents, workspa ...[truncated 22 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Do not offer auto-start until authentication and safe local binding are implemented. 2. Keep persistence disabled by default and clearly explain the network-security implications before enabling it. 3. Configure the service to bind only to loopback unless a secure remote-access mode is explicitly selected. 4. Apply systemd hardening such as `NoNewPrivileges=true`, `PrivateTmp=true`, `ProtectSystem=strict`, `ProtectHome=read-only`, and narrowly scoped writable paths. 5. Execute code from an administrator-controlled, non-world-writable installation directory. 6. Provide a complete uninstall command that disables and removes the service and verifies that no process remains. ]]>

T05 · Unauthorized Access and Privilege Escalation

Error
Location
open_port.sh:27
Finding
Firewall Script Creates an Unrestricted Inbound Rule<![CDATA[ ## Vulnerability Details **File Location**: `open_port.sh:27-36` **Vulnerability Type**: Overbroad network exposure **Risk Level**: High ### Vulnerable Code ```bash if command -v ufw &> /dev/null; then echo "" echo "Detected ufw firewall; opening the port..." sudo ufw allow from 192.168.0.0/16 to any port $PORT comment 'Dashboard LAN access' sudo ufw reload fi echo "" echo "Adding iptables rule..." sudo iptables -C INPUT -p tcp --dport $PORT -j ACCEPT 2>/dev/null || { sudo iptables -I INPUT -p tcp --dport $PORT -j ACCEPT echo "iptables rule added" } ``` ### Technical Analysis The UFW rule is limited to `192.168.0.0/16`, but the script subsequently inserts a raw iptables rule that accepts traffic to the dashboard port from every source and every interface. The unrestricted rule defeats the intended LAN-only restriction whenever routing and upstream controls permit external traffic. The script also mixes UFW and direct iptables management, which can produce inconsistent policy behavior and makes removal difficult. No corresponding removal of the inserted rule is present in the reviewed uninstall workflow. ### Attack Path 1. An administrator runs `open_port.sh` to permit LAN access. 2. The script inserts `-I INPUT -p tcp --dport 5181 -j ACCEPT` without a source restriction. 3. The dashboard is already listening on `0.0.0.0`. 4. A client reachable through any routed interface connects to port 5181. 5. The client invokes the unauthenticated administrative APIs and modifies OpenClaw resources. ### Impact Assessment The rule can expose the dashboard beyond the intended local network. Combined with missing authentication, this can provide remote administrative access to OpenClaw configuration, agents, session metadata, and the skill installer. The script requires `sudo`, so it also changes host-wide firewall state rather than limiting changes to the Skill process. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove the unrestricted raw iptables rule. 2. Use one firewall-management mechanism rather than mixing UFW and direct iptables commands. 3. Restrict access by exact source CIDR and network interface. 4. Require authenticated TLS access even on a trusted LAN. 5. Display the exact firewall change and request confirmation before applying it. 6. Add a matching removal operation to the uninstall script. 7. Verify the effective firewall policy after modification and warn if the service is reachable from unintended interfaces. ]]>

T08 · Insecure Dependencies

Warning
Location
install.sh:56
Finding
Runtime Dependencies Are Installed Without Version or Integrity Pinning<![CDATA[ ## Vulnerability Details **File Location**: `install.sh:56-56` **Vulnerability Type**: Unpinned dependency installation **Risk Level**: Medium ### Vulnerable Code ```bash $PYTHON_CMD -m pip install --user flask flask-cors 2>/dev/null || true ``` The accompanying requirements also permit mutable future versions: ```text flask>=2.0.0 werkzeug>=2.0.0 ``` ### Technical Analysis The installer retrieves the latest package versions satisfying broad or absent constraints at installation time. No lockfile, package hash, signature check, trusted index configuration, or reviewed version set is used. Consequently, the effective installed code can change after the Skill itself has been reviewed. Suppressing installation errors with `|| true` can also leave the environment in an unexpected state, potentially causing execution against pre-existing dependency versions with unknown security properties. `flask-cors` is installed by the script even though no corresponding use was found in the reviewed server code. ### Attack Path 1. A user executes `install.sh`. 2. Pip resolves current packages from the configured package index rather than a reviewed immutable dependency set. 3. A compromised release, index, mirror, account, or dependency version is selected. 4. The package is installed into the user's Python environment. 5. The dashboard imports and executes dependency code when it starts. ### Impact Assessment A compromised dependency can execute with the dashboard user's privileges and access OpenClaw configuration, agents, workspaces, and session metadata. Even without a supply-chain compromise, unconstrained upgrades can introduce incompatible or vulnerable behavior that was absent during review. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin exact dependency versions in a lockfile. 2. Use hash-verified installation, such as `pip install --require-hashes -r requirements.txt`. 3. Configure an approved package index and prevent fallback to untrusted indexes. 4. Remove `flask-cors` if it is not used. 5. Fail installation clearly when dependency installation fails instead of continuing with `|| true`. 6. Regularly update the lockfile through a reviewed dependency-update process with vulnerability scanning. 7. Prefer an isolated virtual environment rather than modifying the user's shared package environment. ]]>
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • Rogue AgentSelf-Modification, Session Persistence
Findings (85)

Tool Parameter Abuse

High
Category
Tool Misuse
Content
"model_id": "deepseek-chat"
  }
  ```
- `DELETE /api/agents/<name>` - 删除 Agent(移动到回收站)
- `GET /api/model-providers` - 获取可用的模型提供商列表

### 配置相关
Confidence
80% confidence
Finding
The README exposes a destructive endpoint pattern, `DELETE /api/agents/<name>`, for an application that directly manages files under the user's OpenClaw directory. In this skill context, agent names map to filesystem-managed resources, so if the implementation lacks strict authentication, authorization, CSRF protection, and name/path validation, the endpoint could be abused to delete or move arbitrary agent data.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding
Browser geolocation, IP-based location lookup, reverse geocoding, and third-party weather API calls are materially different from core dashboard functionality and introduce privacy exposure to external services. Because these network disclosures are not central to agent management, they enlarge data-sharing risk beyond user expectations.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
Browser geolocation, IP-based location lookup, reverse geocoding, and third-party weather API calls are materially different from core dashboard functionality and introduce privacy exposure to external services. Because these network disclosures are not central to agent management, they enlarge data-sharing risk beyond user expectations.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
Browser geolocation, IP-based location lookup, reverse geocoding, and third-party weather API calls are materially different from core dashboard functionality and introduce privacy exposure to external services. Because these network disclosures are not central to agent management, they enlarge data-sharing risk beyond user expectations.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
Browser geolocation, IP-based location lookup, reverse geocoding, and third-party weather API calls are materially different from core dashboard functionality and introduce privacy exposure to external services. Because these network disclosures are not central to agent management, they enlarge data-sharing risk beyond user expectations.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
Browser geolocation, IP-based location lookup, reverse geocoding, and third-party weather API calls are materially different from core dashboard functionality and introduce privacy exposure to external services. Because these network disclosures are not central to agent management, they enlarge data-sharing risk beyond user expectations.

Tp4

High
Category
MCP Tool Poisoning
Confidence
91% confidence
Finding
Browser geolocation, IP-based location lookup, reverse geocoding, and third-party weather API calls are materially different from core dashboard functionality and introduce privacy exposure to external services. Because these network disclosures are not central to agent management, they enlarge data-sharing risk beyond user expectations.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
Browser geolocation, IP-based location lookup, reverse geocoding, and third-party weather API calls are materially different from core dashboard functionality and introduce privacy exposure to external services. Because these network disclosures are not central to agent management, they enlarge data-sharing risk beyond user expectations.

Tool Parameter Abuse

High
Category
Tool Misuse
Content
GET  /api/agents              # List all agents
POST /api/agents              # Create new agent
GET  /api/agents/<name>       # Get agent details
DELETE /api/agents/<name>     # Delete agent
GET  /api/skills              # List all skills
GET  /api/agents/<name>/skills # Get agent skills
POST /api/agents/<name>/skills/<id>/enable
Confidence
86% confidence
Finding
An API endpoint that deletes agents is inherently destructive, and in the context of a dashboard managing local agent state it can remove configurations or workspaces if not strongly protected. The risk is elevated because the documentation claims the service is web-accessible and does not describe authentication, authorization, CSRF protection, or confirmation safeguards for destructive actions.

Tool Parameter Abuse

High
Category
Tool Misuse
Content
systemctl --user disable agent-dashboard

# Remove files
rm -rf ~/.agents/skills/agent-dashboard-v2
rm -f ~/.config/systemd/user/agent-dashboard.service
```
Confidence
90% 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).

Tool Parameter Abuse

High
Category
Tool Misuse
Content
systemctl --user disable agent-dashboard

# Remove files
rm -rf ~/.agents/skills/agent-dashboard-v2
rm -f ~/.config/systemd/user/agent-dashboard.service
```
Confidence
90% 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).

Tool Parameter Abuse

High
Category
Tool Misuse
Content
# Remove files
rm -rf ~/.agents/skills/agent-dashboard-v2
rm -f ~/.config/systemd/user/agent-dashboard.service
```

## License
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).

Context-Inappropriate Capability

High
Confidence
99% confidence
Finding
The dashboard exposes a network-accessible endpoint that invokes the OpenClaw CLI to install skills, which is effectively remote code or capability deployment into the agent environment. In the context of an agent-management dashboard, this is especially dangerous because installed skills may execute privileged logic, alter agent behavior, or introduce persistence and supply-chain compromise paths.

Intent-Code Divergence

High
Confidence
99% confidence
Finding
The comments and ufw rule suggest LAN-only exposure, but the iptables rule accepts TCP traffic to the dashboard port from any source. This mismatch can unintentionally publish a management dashboard beyond the LAN, materially increasing exposure to unauthorized access if the host has broader network reach.

Hidden Instructions

High
Category
Prompt Injection
Content
<div class="bg-animation"></div>
    <div class="grid-pattern"></div>
    
    <!-- Floating particles -->
    <div id="particles"></div>

    <!-- Sidebar Toggle Button (Fixed) -->
Confidence
70% confidence
Finding
Hidden instructions were detected in comments or invisible text. These could contain malicious directives. Manual review is recommended.

Tool Parameter Abuse

High
Category
Tool Misuse
Content
systemctl --user disable ${SERVICE_NAME} 2>/dev/null || true
    
    # Remove service file
    rm -f "$HOME/.config/systemd/user/${SERVICE_NAME}.service"
    
    # Reload systemd
    systemctl --user daemon-reload
Confidence
95% 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).

Tool Parameter Abuse

High
Category
Tool Misuse
Content
# Remove desktop entry
if [ -f "$HOME/.local/share/applications/agent-dashboard.desktop" ]; then
    echo -e "${BLUE}Removing desktop shortcut...${NC}"
    rm -f "$HOME/.local/share/applications/agent-dashboard.desktop"
    echo -e "${GREEN}✓ Desktop shortcut removed${NC}"
fi
Confidence
95% 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).

Natural-Language Policy Violations

Medium
Confidence
92% confidence
Finding
This markdown file presents all operational guidance exclusively in Chinese, including the title and usage instructions, with no indication that the language is optional or that the skill is intended only for Chinese-speaking users. Under the policy for natural-language violations, forcing a specific language without user opt-in is a reportable locale/language constraint.

Unsafe Defaults

Medium
Category
Tool Misuse
Content
```python
# 在开发调试时可跳过验证
manager = get_openclaw_config_manager(skip_validation=True)
```

## Schema 定义文件
Confidence
84% confidence
Finding
The documentation explicitly advertises a `skip_validation=True` mode, which can normalize disabling schema validation safeguards during development and potentially allow invalid or dangerous configuration to be accepted if copied into non-development workflows. In a dashboard that manages agents, skills, tools, and execution settings, bypassing validation increases the risk of misconfiguration that could weaken security controls or permit unsafe runtime behavior.

Natural-Language Policy Violations

Medium
Confidence
90% confidence
Finding
The primary descriptive content is presented in Chinese, and the document does not indicate that this is a region-specific skill or provide an explicit language choice. Under the stated policy, forcing a specific language without user opt-in is a natural-language policy concern.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The README explicitly states that per-agent model configuration includes API keys and is copied into `~/.openclaw/agents/{agent_name}/agent/models.json`. Duplicating secrets into multiple per-agent files increases credential exposure through weaker file permissions, backups, accidental commits, and broader local read access, especially in a dashboard that creates agents automatically.

Lp3

Medium
Category
MCP Least Privilege
Confidence
89% confidence
Finding
The skill documentation advertises capabilities that clearly require sensitive operations such as file access, network serving, shell execution, and configuration mutation, but it declares no explicit tool scope or permission boundaries. In an agent skill ecosystem, this increases the chance that the skill executes with broader-than-expected authority and makes review, containment, and informed consent harder.

Session Persistence

Medium
Category
Rogue Agent
Content
- 🎨 **Modern UI**: Dark theme with beautiful animations and responsive design
- 🛠️ **Skill Management**: Enable/disable skills for each agent with blacklist support
- 🔀 **Subagent Dispatch**: Visual management of agent delegation and permissions
- 🤖 **Agent Creation**: Create new agents with guided configuration
- 🌐 **Multi-language**: Automatic language detection (English/Chinese)
- 🌤️ **Weather Widget**: Real-time local weather and time display
- 📱 **Responsive Design**: Works on desktop and mobile devices
Confidence
60% confidence
Finding
Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.

Rp1

Medium
Category
MCP Rug Pull
Confidence
83% confidence
Finding
Using `npx skills add ...` without a pinned version allows the installed package or referenced content to change over time, which can silently introduce new behavior or malicious updates. This creates a supply-chain risk because users may install different code than what was originally reviewed.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The troubleshooting command `lsof -ti:5181 | xargs kill -9` forcibly terminates whatever process is using the port without warning or verification. This can kill unrelated applications, cause data loss, and trains users to use indiscriminate destructive commands during troubleshooting.

Static analysis

Detected: suspicious.install_untrusted_source

Install source points to URL shortener or raw IP.

Warn
Code
suspicious.install_untrusted_source
Location
data/config.json:89