Back to skill

Security audit

Task Dispatch

Security checks for vulnerabilities and agentic risk

Overview

The skill is a coherent task-board dispatcher, but it gives agents recurring authority to run subagents, change task-board state, execute an unpinned remote installer, and copy access tokens into workspace files.

Install only if you trust the ClawBoard source and task authors, and prefer using a reviewed pinned release, a least-privilege token, protected secret storage, and manual approval for tasks that request network access, credential access, package installation, persistence, or work outside the intended project.

Vulnerability Patterns
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • 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
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (3)

T01 · Skill Instruction Hijacking

Error
Location
SKILL.md:222
Finding
Untrusted task-board content is converted into executable subagent instructions<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:222-248`; related template logic in `references/dispatch-template.md:10-45` and `references/dispatch-template.md:165-174` **Vulnerability Type**: Prompt injection across a trust boundary **Risk Level**: High ### Complete Code Snippet ```markdown ### Prepare Dispatch Context Before spawning subagent, prepare context using the **Dispatch Template**: See [references/dispatch-template.md](references/dispatch-template.md) for full template. **Required fields to fill:** - Task Identity (from task data) - Goal (one sentence) - Hard Constraints (what NOT to do) - Deliverables (from task.deliverables) - Acceptance Criteria (from task.acceptanceCriteria) - Output Format (completion_signal block) ### Spawn with Wait Use `sessions_spawn` with the dispatch context: ```json { "runtime": "subagent", "mode": "run", "task": "<filled dispatch template>", "timeoutSeconds": 300 } ``` The main agent should: 1. Fill dispatch template with task context 2. Spawn subagent with the template 3. **Wait for completion** (blocking or polling) 4. Parse `completion_signal` from response 5. Verify deliverables and update status 6. **Immediately continue to next task** ``` The related integration instructions state: ```markdown 1. 从任务数据提取字段 2. 填充模板 3. 调用 `sessions_spawn`,将模板内容作为 `task` 参数 4. 等待 subagent 完成 5. 解析 `completion_signal` 6. 根据状态更新任务 ``` ### Technical Analysis Task titles, descriptions, context, deliverables, acceptance criteria, and paths originate from the task-board API. These fields cross from an external data source into a tool-capable subagent prompt without a defined trust boundary. The Skill does not require: - Treating task fields strictly as quoted data. - Rejecting embedded instructions or prompt-control text. - Restricting requested paths to an approved project root. - Allowlists for subagent tools and operations. - Human approval for access to credentials, external networks, or unrelated ...[truncated 1847 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Treat every task-board field as untrusted data and place it in a strictly delimited, serialized data block rather than the instruction section. 2. Add an explicit invariant stating that instructions embedded in task fields, documents, filenames, or API responses must never override dispatcher policy. 3. Validate task fields against a schema with length limits and reject control-like content where practical. 4. Canonicalize every requested path and require it to remain under an explicitly approved project root. 5. Restrict subagents through independently enforced tool policies: - Deny access to `.env`, SSH keys, cloud credentials, and other secret locations. - Deny unrelated filesystem paths. - Disable external network access unless the task explicitly requires it. - Require approval for shell commands or destructive modifications. 6. Require human confirmation for tasks requesting credential access, package installation, network transmission, persistence, or operations outside the project. 7. Validate completion signals structurally and bind `task_id` to the dispatched task rather than trusting the returned identifier. 8. Verify deliverables against the original allowlisted paths and inspect actual changes before changing task status. 9. Use a low-privilege execution sandbox for each subagent and discard it after task completion. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
SKILL.md:54
Finding
Board access token is duplicated into Agent workspace files without secure handling<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:54-58` **Vulnerability Type**: Plaintext credential duplication and excessive credential exposure **Risk Level**: High ### Complete Code Snippet ```bash # 获取 token TOKEN=$(cat ~/ClawBoard/.env | grep BOARD_ACCESS_TOKEN | cut -d= -f2) # 写入 Agent 工作目录 echo "TASKBOARD_API_URL=http://127.0.0.1:3000" >> ~/.openclaw/workspace-<name>/.env echo "TASKBOARD_ACCESS_TOKEN=$TOKEN" >> ~/.openclaw/workspace-<name>/.env ``` ### Technical Analysis The board token is read from `~/ClawBoard/.env` and copied in plaintext into another `.env` file. Although board authentication is necessary for dispatching, persistent duplication into an Agent workspace is broader than the minimum privilege required. The instructions do not: - Create the destination with mode `0600`. - Check the ownership or permissions of the workspace or existing `.env`. - Validate or canonicalize the substituted workspace name. - Prevent symbolic-link traversal at the destination. - Replace existing variables atomically. - Prevent duplicate or stale token entries. - Issue a separate token scoped only to required read/update operations. - Prevent delegated subagents and workspace tools from reading the copied token. The use of `grep` and `cut` is also not robust `.env` parsing. Multiple matching entries, whitespace, comments, or values containing `=` can produce an incorrect value. Append mode can retain old credentials and create ambiguous configuration. ### Attack Path 1. The user follows the setup instructions. 2. The shell reads `BOARD_ACCESS_TOKEN` from `~/ClawBoard/.env`. 3. The token is appended to an Agent workspace `.env` file. 4. A subagent, plugin, local process, backup service, or user with access to that workspace reads the file. 5. The recovered bearer token is used against the ClawBoard API. 6. Based on the token's server-side permissions, the attacker reads projects and tasks, creates tasks, changes task status, or injects mal ...[truncated 867 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Do not copy the board's primary token into Agent workspaces. 2. Inject credentials into the dispatcher process at runtime through a secret manager or protected environment mechanism. 3. Create a separate per-dispatcher token limited to the minimum required API operations and board scope. 4. Ensure spawned subagents do not inherit the dispatcher token. 5. If a file is unavoidable: - Validate and canonicalize the target workspace path. - Reject symbolic links. - Create the file atomically with mode `0600`. - Verify expected ownership. - Replace the specific key instead of appending. - Avoid printing the token in commands, logs, or responses. 6. Use a proper `.env` parser or a trusted ClawBoard command that returns the token without ambiguous text processing. 7. Rotate the board token after suspected exposure and remove stale copies from all workspaces, backups, and logs. 8. Prefer short-lived credentials and server-side authorization that permits only project/task reads and necessary status updates. ]]>

T03 · Remote Payload Retrieval and Execution

Error
Location
SKILL.md:25
Finding
Mutable remote repository is downloaded and executed without integrity verification<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:25-31` **Vulnerability Type**: Unpinned remote payload retrieval and execution **Risk Level**: High ### Complete Code Snippet ```bash # 克隆仓库 git clone https://github.com/CCCaptain0129/ClawBoard.git ~/ClawBoard cd ~/ClawBoard # 安装依赖并初始化 ./clawboard install ``` ### Technical Analysis The Skill instructs the user or Agent to clone the mutable default branch of an external Git repository and immediately execute its `clawboard` installer. No release tag, commit hash, checksum, signature, review step, or reproducible dependency verification is required. Consequently, the effective executable payload is not fixed by the audited Skill package. It can change after this review if the upstream repository, maintainer account, default branch, release process, or transitive dependencies are compromised. The repository identity is also documented inconsistently: `SKILL.md` names a concrete GitHub repository, while `README.md` uses placeholder repository references. This makes canonical-source verification less reliable. ### Attack Path 1. An attacker compromises the upstream repository, a maintainer account, or a dependency resolved by the installer. 2. The attacker modifies the default branch or installation path to contain malicious commands. 3. A user invokes the Skill's deployment workflow. 4. `git clone` downloads the current attacker-controlled content. 5. `./clawboard install` executes that content with the privileges of the invoking user. 6. The malicious installer can modify files, steal user-accessible secrets, install additional software, start services, or establish persistence. 7. Subsequent `./clawboard start` operations may continue executing the compromised application. ### Impact Assessment Successful exploitation grants code execution with the privileges of the user running the installation. This can expose all files, credentials, environment variables, and network resources available ...[truncated 413 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin the installation to a reviewed immutable commit hash or signed release tag. 2. Publish and verify a cryptographic checksum or signature before execution. 3. Document one canonical repository consistently across `README.md`, `SKILL.md`, and all examples. 4. Download the release artifact without executing it automatically, then require an explicit review or confirmation step. 5. Audit the `clawboard` installer and all scripts it invokes. 6. Require lockfiles and deterministic dependency installation; avoid unconstrained package updates during setup. 7. Run installation in a restricted environment with minimal filesystem, network, and credential access. 8. Do not execute the installer as root or with elevated privileges. 9. Record the verified version and commit in the generated configuration so future updates cannot occur silently. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Rogue AgentSelf-Modification, Session Persistence
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
Findings (22)

Self-Modification

High
Category
Rogue Agent
Content
# Task Dispatch Skill

任务调度技能,让 Agent 能够自动检查任务看板、派发任务给 subagent 执行、验收结果并更新状态。
Confidence
85% confidence
Finding
Skill modifies its own code, configuration, or behavior at runtime. Self-modification enables an agent to escalate privileges, disable safety constraints, or install persistent backdoors.

Context-Inappropriate Capability

High
Confidence
99% confidence
Finding
The skill extracts a bearer token from one application’s .env file and copies it into another workspace’s .env file, broadening credential exposure across trust boundaries. This creates unnecessary credential proliferation, increases the chance of token leakage via logs/files/workspace sharing, and normalizes secret handling that exceeds the skill’s stated dispatch purpose.

Credential Access

High
Category
Privilege Escalation
Content
```bash
# 获取 token
TOKEN=$(cat ~/ClawBoard/.env | grep BOARD_ACCESS_TOKEN | cut -d= -f2)

# 写入 Agent 工作目录
echo "TASKBOARD_API_URL=http://127.0.0.1:3000" >> ~/.openclaw/workspace-<name>/.env
Confidence
99% confidence
Finding
Reading `BOARD_ACCESS_TOKEN` from `~/ClawBoard/.env` is direct credential extraction from a secret-bearing file. In this skill, the extracted token is then propagated for reuse, making the act more dangerous because it facilitates unauthorized API access if the workspace, shell history, or subsequent commands are exposed.

Credential Access

High
Category
Privilege Escalation
Content
TOKEN=$(cat ~/ClawBoard/.env | grep BOARD_ACCESS_TOKEN | cut -d= -f2)

# 写入 Agent 工作目录
echo "TASKBOARD_API_URL=http://127.0.0.1:3000" >> ~/.openclaw/workspace-<name>/.env
echo "TASKBOARD_ACCESS_TOKEN=$TOKEN" >> ~/.openclaw/workspace-<name>/.env
```
Confidence
98% confidence
Finding
Appending task board API configuration into another workspace’s .env file is credential material propagation into a secondary storage location. Even though the URL itself is not secret, placing it adjacent to secret material as part of automated credential setup contributes to insecure secret management patterns and broadens the footprint of sensitive configuration.

Credential Access

High
Category
Privilege Escalation
Content
# 写入 Agent 工作目录
echo "TASKBOARD_API_URL=http://127.0.0.1:3000" >> ~/.openclaw/workspace-<name>/.env
echo "TASKBOARD_ACCESS_TOKEN=$TOKEN" >> ~/.openclaw/workspace-<name>/.env
```

### Step 5: 打开看板
Confidence
99% confidence
Finding
This line writes the extracted bearer token into a workspace .env file in plaintext, creating a durable copy of a sensitive credential outside its original trust boundary. If that workspace is shared, backed up, inspected by tools, or later exfiltrated, the token can be reused to access the task board API.

Credential Access

High
Category
Privilege Escalation
Content
| Command | Description |
|---------|-------------|
| `./clawboard install` | Install dependencies, create .env |
| `./clawboard start` | Start frontend + backend services |
| `./clawboard stop` | Stop all services |
| `./clawboard status` | Check service health |
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
| Command | Description |
|---------|-------------|
| `./clawboard install` | Install dependencies, create .env |
| `./clawboard start` | Start frontend + backend services |
| `./clawboard stop` | Stop all services |
| `./clawboard status` | Check service health |
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
| `./clawboard start` | Start frontend + backend services |
| `./clawboard stop` | Stop all services |
| `./clawboard status` | Check service health |
| `./clawboard token` | Show current access token |
| `./clawboard token --generate` | Generate new token |

### Verification Checklist
Confidence
70% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The README explicitly promotes automated dispatch, execution, acceptance, and task-state transitions on an external task board, but it does not clearly warn users that enabling the skill will cause persistent changes to external system data. In an agent context, hidden or insufficiently disclosed side effects increase the risk of unintended modifications, especially when the skill can run continuously and act without per-task user confirmation.

External Transmission

Medium
Category
Data Exfiltration
Content
### 创建可自动派发的任务

```bash
curl -X POST http://127.0.0.1:3000/api/tasks/projects/{projectId}/tasks \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Natural-Language Policy Violations

Medium
Confidence
95% confidence
Finding
The activation guidance is written as specific Chinese-language utterances such as `用户说"设置任务调度"或"部署 ClawBoard"时`, which implies a required locale for invocation. The file does not offer multilingual alternatives or state that the skill is intentionally limited to Chinese-speaking users for a documented reason.

File System Enumeration

Medium
Category
Data Exfiltration
Content
node --version  # 需要 >= 18

# 检查 ClawBoard 是否已安装
ls -la ~/ClawBoard 2>/dev/null || echo "ClawBoard not installed"
```

### Step 2: 部署 ClawBoard(如未安装)
Confidence
60% confidence
Finding
Code scans file system directories looking for sensitive files. This could be reconnaissance for credential theft.

Description-Behavior Mismatch

Medium
Confidence
95% confidence
Finding
The skill’s declared purpose is task dispatching, but it also directs full local deployment of ClawBoard, including cloning a repository, installing dependencies, starting services, and configuring credentials. This expands the operational scope far beyond dispatch logic and increases attack surface by enabling system changes and execution of unvetted external code under the guise of a scheduling skill.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The deployment section performs meaningful system changes—repository download, dependency installation, service startup, and token generation—without clearly warning the user that code will be executed and local services modified. In a skill context, missing safety prompts materially increases the risk of unintended or socially engineered host changes.

Context-Inappropriate Capability

Medium
Confidence
97% confidence
Finding
These instructions authorize cloning a third-party repository and running its installer/startup commands even though the skill’s role says the agent is only a dispatcher. That mismatch can be abused to cause unauthorized code execution, package installation, process creation, and persistent system modification in environments where a user expected only task-board orchestration.

Missing User Warnings

Medium
Confidence
96% confidence
Finding
The skill instructs writing sensitive API credentials into a local agent workspace .env without any warning about persistence, file permissions, downstream access, or cleanup. Even if intended for convenience, storing secrets this way can expose them to other tools, users, backups, or later agent actions in the same workspace.

Intent-Code Divergence

Medium
Confidence
90% confidence
Finding
The failure-handling section states to 'Return task to actionable state (todo or in-progress)', which implies recovery back into dispatchable workflow. But the same section's scenario table says timeouts, blocked results, and missing deliverables should 'Set failed', and earlier sections also describe failed as the terminal outcome for unsuccessful execution, so the documentation contradicts itself about actual intended state transitions.

Natural-Language Policy Violations

Medium
Confidence
96% confidence
Finding
This markdown file contains multiple natural-language comments and the cron payload message in Chinese (for example at L063, L069-L075, and L090) while the rest of the document is in English. For a general configuration reference, forcing a specific language without opt-in or documented locale scope can violate language/locale policy expectations.

Natural-Language Policy Violations

Medium
Confidence
94% confidence
Finding
The document instructs users in Chinese and the template fields require Chinese outputs such as '<一句话目标>' and Chinese status text, which imposes a specific language on skill usage. There is no opt-in or documented locale-specific justification, so this is a natural-language policy concern.

Natural-Language Policy Violations

Medium
Confidence
91% confidence
Finding
The 'Output Format (Required)' section requires fields like 'summary: <一句话总结>' and 'blocked 写阻塞点与建议', which constrains replies to Chinese-language content. Because no alternative locale or user choice is provided, this violates the language/locale policy criteria.

Natural-Language Policy Violations

Medium
Confidence
95% confidence
Finding
The default `--message` value is written entirely in Chinese and will be used unless the user overrides it. This imposes a specific language choice by default without offering any locale selection or documenting that the skill is intentionally region-specific.

Missing User Warnings

Low
Confidence
87% confidence
Finding
The setup instructions tell users to export an API access token but do not warn that the token is sensitive credential material that grants access to the task board API. In practice, README examples are often copied into shells, logs, screenshots, and shared environments, so lack of credential-handling guidance can lead to accidental exposure or misuse.

Static analysis

No suspicious patterns detected.