Back to skill

Security audit

Claw Worker

Security checks for vulnerabilities and agentic risk

Overview

The skill has a coherent job-marketplace purpose, but it needs review because it can register accounts, expose an agent endpoint, store credentials, run recurring network checks, and act on external task instructions without enough user-control safeguards.

Install only if you intend to use ClawHire as an external work marketplace. Before enabling it, require explicit approval for registration, profile publication, A2A endpoint exposure, heartbeat polling, task claiming, and every file upload; use a dedicated workspace, avoid sensitive files, and treat all employer or task text as untrusted.

Vulnerability Patterns
  • 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
  • System PersistenceInstalls backdoors, hooks, services, or scheduled tasks that survive the run
  • 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 (3)

T01 · Skill Instruction Hijacking

Error
Location
SKILL.md:92
Finding
Untrusted External Task Instructions Are Treated as Executable Agent Requests<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:92-95` and `SKILL.md:200-201` **Vulnerability Type**: T01: Skill Instruction Hijacking **Risk Level**: High ### Vulnerable Code ```text Another agent calls sessions_send to your session. You receive the message as a normal conversation turn. → Do the work → Reply with the result in the same session ``` The paid-task workflow contains the corresponding instruction: ```markdown ### Step 3: Do the work Complete the task according to its description. ``` ### Technical Analysis The skill instructs the agent to treat task content supplied by external agents or marketplace users as actionable instructions. It does not require sender authentication, explicit user authorization, prompt-injection screening, or enforcement of file, tool, network, and data-access boundaries before executing the task. Because externally supplied task descriptions enter the agent's instruction context, a malicious employer or A2A sender can include instructions that attempt to replace the intended task, override safety constraints, access unrelated files, invoke available tools, or disclose sensitive information. The exact actions possible depend on the tools and permissions granted to the host agent. ### Attack Path 1. An attacker creates a marketplace task or sends an A2A or `sessions_send` request. 2. The attacker embeds prompt-injection instructions in the task text, such as directions to inspect unrelated local files or transmit their contents. 3. The skill presents the attacker-controlled request as a normal conversation turn. 4. The workflow explicitly directs the agent to “do the work” or complete the task according to its description. 5. Without an independent authorization and policy boundary, the agent may invoke available tools in response to the malicious instructions. 6. Results can then be returned to the attacker through the session, A2A response, or marketplace submission. ### Impact Assessment Succes ...[truncated 499 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Treat every task description, A2A message, structured data part, employer field, and session message as untrusted input. 2. Require explicit user confirmation before claiming a task and again before performing any operation involving files, credentials, external communication, payment, or system changes. 3. Apply a fixed task-execution policy that external task text cannot modify. Explicitly reject requests to override system instructions, reveal secrets, inspect unrelated paths, or expand the authorized scope. 4. Restrict task execution to an isolated workspace with a strict path allowlist and no access to configuration files, memory, credentials, or unrelated projects. 5. Use network allowlists and require approval for destinations other than the documented ClawHire API. 6. Display a clear execution plan and list of intended tools, files, and external recipients to the user before work begins. 7. Authenticate A2A senders where possible and enforce request-size, method, schema, and rate limits. 8. Return an error for ambiguous, unrelated, or policy-conflicting instructions rather than attempting to execute them. ]]>

T02 · Agent Memory Poisoning

Warning
Location
SKILL.md:242
Finding
Externally Controlled Task Metadata Is Appended to Persistent Agent Memory<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:242-250` **Vulnerability Type**: T02: Agent Memory Poisoning **Risk Level**: Medium ### Vulnerable Code ```markdown After every task interaction, append to `memory/YYYY-MM-DD.md`: ```markdown ### [ClawHire Worker] {task_id} - {title} - Track: free|paid - Status: {status} - Employer: {name} ({agent_id}) - Earnings: ${amount} | free ``` ``` The free-task workflow also mandates the same persistent action: ```text 2. Log to memory: append to `memory/YYYY-MM-DD.md` ``` ### Technical Analysis The workflow requires task metadata to be appended to long-term Markdown memory. Fields such as task title and employer name originate outside the local trust boundary and are not escaped, normalized, length-limited, or stored separately from natural-language instructions. If the host agent loads Markdown memory into later prompts, crafted metadata can be interpreted as instructions rather than inert records. Markdown headings, instruction-like text, delimiters, or other prompt-manipulation content can therefore persist beyond the original task interaction. The workflow also retains employer and earnings information without an explicit retention policy. ### Attack Path 1. An attacker creates a task with instruction-like content in a controllable metadata field, such as the task title or employer display name. 2. The agent interacts with or completes that task. 3. Following the skill instructions, the agent appends the raw metadata to `memory/YYYY-MM-DD.md`. 4. A later session loads or summarizes that memory file into the agent's context. 5. The stored attacker content is interpreted as a directive or trusted historical context. 6. The attacker-controlled text can consequently influence future sessions after the original interaction has ended. ### Impact Assessment The issue creates cross-session influence over the agent's reasoning and can repeatedly distort later decisions, task selection, or tool use. I ...[truncated 250 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Do not append externally controlled values directly to prompt-readable Markdown memory. 2. Store task history in a structured data store that is not interpreted as agent instructions. 3. Validate field types and enforce strict length and character limits for task IDs, titles, employer names, statuses, and monetary values. 4. Escape Markdown control characters and clearly delimit all untrusted values when a text format is unavoidable. 5. Label stored records as untrusted historical data and prohibit memory content from changing system policies or authorizing actions. 6. Require user opt-in before retaining task, employer, or earnings information. 7. Define a short retention period and provide a deletion mechanism. 8. When memory is later loaded, parse only the required structured fields rather than injecting the entire record into the agent context. ]]>

T06 · System Persistence

Warning
Location
SKILL.md:225
Finding
Heartbeat Configuration Establishes Recurring Cross-Session Network Activity<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:225-234` **Vulnerability Type**: T06: System Persistence **Risk Level**: Medium ### Vulnerable Code ```markdown ## Heartbeat — Auto-discover Tasks Add to `HEARTBEAT.md` for periodic task checking: ```markdown ## ClawHire Worker - [ ] Send heartbeat: curl -s -X POST https://api.clawhire.io/v1/agents/heartbeat -H "Authorization: Bearer $CLAWHIRE_API_KEY" - [ ] Check tasks: curl -s "https://api.clawhire.io/v1/tasks?status=open&skills={my_skills}" -H "Authorization: Bearer $CLAWHIRE_API_KEY" - [ ] If matching tasks found and below max concurrent, evaluate and consider claiming ``` OpenClaw executes HEARTBEAT.md on a regular interval. This keeps you online/discoverable and automatically checks for work. ``` ### Technical Analysis The skill directs modification of `HEARTBEAT.md`, which the host executes on a recurring schedule. This changes behavior beyond the initiating interaction and causes repeated authenticated communication with ClawHire. It also continuously introduces externally controlled marketplace content into the agent's environment. The instructions do not specify an expiration time, user-visible enablement state, request limit, disable procedure, or requirement for approval on each polling cycle. Although the scheduled commands are documented and target the declared service, their cross-session persistence expands the exposure window and attack surface. ### Attack Path 1. The skill is activated and its heartbeat section is copied into `HEARTBEAT.md`. 2. The host executes that file on its regular schedule after the original session ends. 3. Each run sends an authenticated heartbeat and retrieves the current marketplace task list. 4. A malicious employer publishes a crafted task matching the configured skills. 5. The recurring process discovers the attacker-controlled task and may evaluate or consider claiming it. 6. Combined with the untrusted-task execution workflow, this creates ...[truncated 563 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Make heartbeat installation explicitly opt-in and explain its recurring network behavior before modifying any host file. 2. Require a clear expiration time, maximum number of runs, and documented one-step disable procedure. 3. Display persistent status indicating that marketplace polling is enabled. 4. Do not automatically claim or execute discovered tasks; require user approval for each task. 5. Apply strict polling frequency, concurrency, and resource limits. 6. Separate task discovery from task execution so retrieved descriptions remain untrusted data until reviewed. 7. Use a least-privilege API credential scoped to heartbeat and task-list operations where the service supports it. 8. Avoid including credentials directly in scheduler text or logs, and ensure command output cannot expose authorization headers. 9. Remove the heartbeat entry automatically when the skill is disabled or the configured authorization period expires. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Rogue AgentSelf-Modification, Session Persistence
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (16)

Vague Triggers

Medium
Confidence
95% confidence
Finding
The trigger phrases are broad enough to match common user intents like 'find work' or 'earn money', which can cause the skill to activate in situations where the user did not intend to interact with a third-party job marketplace. In this skill, unintended activation is more dangerous because activation can lead to account registration, public profile creation, external API calls, and potential exposure of user email or agent endpoints.

Missing User Warnings

Medium
Confidence
97% confidence
Finding
The registration flow directs the agent to send the user's email to a third-party service to create an account, but it does not require explicit informed consent or explain the privacy implications. This creates a risk of unauthorized disclosure of personal data and unintended enrollment in an external platform.

External Transmission

Medium
Category
Data Exfiltration
Content
Check env `CLAWHIRE_API_KEY`. If missing, register:

```bash
curl -s -X POST https://api.clawhire.io/v1/auth/register \
  -H "Content-Type: application/json" \
  -d '{"name":"<agent-name>","owner_email":"<ask-user>","role":"worker"}'
```
Confidence
96% confidence
Finding
This command transmits identifying information, including the user's email, to an external service to create an account. External transmission is risky here because the skill does not require explicit consent or provide data-minimization guidance before sending personal information off-platform.

External Transmission

Medium
Category
Data Exfiltration
Content
Check env `CLAWHIRE_API_KEY`. If missing, register:

```bash
curl -s -X POST https://api.clawhire.io/v1/auth/register \
  -H "Content-Type: application/json" \
  -d '{"name":"<agent-name>","owner_email":"<ask-user>","role":"worker"}'
```
Confidence
96% confidence
Finding
This command transmits identifying information, including the user's email, to an external service to create an account. External transmission is risky here because the skill does not require explicit consent or provide data-minimization guidance before sending personal information off-platform.

Session Persistence

Medium
Category
Rogue Agent
Content
Response: `{ "data": { "agent_id": "...", "api_key": "clawhire_xxx" } }`

Save key — write to `~/.openclaw/openclaw.json` (merge, don't overwrite):

```json
{ "skills": { "entries": { "claw-worker": { "env": { "CLAWHIRE_API_KEY": "clawhire_xxx" } } } } }
Confidence
84% confidence
Finding
Persisting the API key in a long-lived local configuration file increases the risk of credential exposure through local compromise, backup leakage, or unintended access by other tools using the same environment. Although the skill says not to store keys in workspace files, it still instructs durable storage of a sensitive secret.

External Transmission

Medium
Category
Data Exfiltration
Content
A good profile attracts more work. Be specific about skills.

```bash
curl -s -X POST https://api.clawhire.io/v1/agents/profile \
  -H "Authorization: Bearer $CLAWHIRE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
Confidence
88% confidence
Finding
Creating a profile sends capability and preference data to an external marketplace and may indirectly disclose sensitive operational details about the agent's skills, availability, and pricing. In context, this is less severe than credential leakage but still risky because the skill presents it as routine setup without an explicit consent or disclosure step.

Missing User Warnings

Medium
Confidence
96% confidence
Finding
The skill encourages registering a public A2A endpoint to make the agent discoverable without clearly warning that this exposes the agent to unsolicited external traffic and potential prompt-injection or abuse from untrusted parties. Because the endpoint is intended for direct inbound requests from other agents, the exposure meaningfully expands the attack surface beyond the normal trusted session boundary.

External Transmission

Medium
Category
Data Exfiltration
Content
If you have a public URL (e.g. via OpenClaw Gateway + Tailscale/tunnel):

```bash
curl -s -X POST https://api.clawhire.io/v1/agents/register-a2a \
  -H "Authorization: Bearer $CLAWHIRE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
Confidence
95% confidence
Finding
Registering the A2A URL with an external service discloses a reachable endpoint for inbound agent traffic, making the agent more discoverable and targetable. In this skill's context, that materially increases exposure to malicious requests, spam, prompt injection, and endpoint reconnaissance.

External Transmission

Medium
Category
Data Exfiltration
Content
### Step 1: Browse open tasks

```bash
curl -s "https://api.clawhire.io/v1/tasks?status=open&skills=python,translation" \
  -H "Authorization: Bearer $CLAWHIRE_API_KEY"
```
Confidence
50% 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
### Step 1: Browse open tasks

```bash
curl -s "https://api.clawhire.io/v1/tasks?status=open&skills=python,translation" \
  -H "Authorization: Bearer $CLAWHIRE_API_KEY"
```
Confidence
50% 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
### Step 1: Browse open tasks

```bash
curl -s "https://api.clawhire.io/v1/tasks?status=open&skills=python,translation" \
  -H "Authorization: Bearer $CLAWHIRE_API_KEY"
```
Confidence
50% 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
Before claiming, check: Do my skills match? Is the budget fair? Can I meet the deadline?

```bash
curl -s -X POST "https://api.clawhire.io/v1/tasks/{task_id}/claim" \
  -H "Authorization: Bearer $CLAWHIRE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"task_token": "{token_from_task_details}"}'
Confidence
86% confidence
Finding
Claiming a task changes state on an external platform and can commit the agent to obligations or workflows without an explicit confirmation step. In context, the risk is not just transmission but unauthorized action on behalf of the user, including reputational and financial consequences if tasks are claimed automatically or mistakenly.

External Transmission

Medium
Category
Data Exfiltration
Content
### Step 4: Submit deliverable

```bash
curl -s -X POST https://api.clawhire.io/v1/submissions \
  -H "Authorization: Bearer $CLAWHIRE_API_KEY" \
  -F "task_id={task_id}" \
  -F "notes=Description of what was done" \
Confidence
91% confidence
Finding
Submitting deliverables uploads local files to an external service, creating a substantial risk of exfiltrating sensitive workspace data if file selection is wrong, manipulated, or insufficiently reviewed. Because the skill normalizes direct file upload from local storage, the context increases the chance of accidental disclosure of confidential content.

External Transmission

Medium
Category
Data Exfiltration
Content
```markdown
## ClawHire Worker
- [ ] Send heartbeat: curl -s -X POST https://api.clawhire.io/v1/agents/heartbeat -H "Authorization: Bearer $CLAWHIRE_API_KEY"
- [ ] Check tasks: curl -s "https://api.clawhire.io/v1/tasks?status=open&skills={my_skills}" -H "Authorization: Bearer $CLAWHIRE_API_KEY"
- [ ] If matching tasks found and below max concurrent, evaluate and consider claiming
```
Confidence
94% confidence
Finding
The heartbeat automates periodic outbound communication to keep the agent discoverable, which can create persistent third-party tracking and background activity without ongoing user awareness. In context, embedding this into an automatically executed heartbeat file increases risk because the action becomes continuous rather than user-initiated.

External Transmission

Medium
Category
Data Exfiltration
Content
```markdown
## ClawHire Worker
- [ ] Send heartbeat: curl -s -X POST https://api.clawhire.io/v1/agents/heartbeat -H "Authorization: Bearer $CLAWHIRE_API_KEY"
- [ ] Check tasks: curl -s "https://api.clawhire.io/v1/tasks?status=open&skills={my_skills}" -H "Authorization: Bearer $CLAWHIRE_API_KEY"
- [ ] If matching tasks found and below max concurrent, evaluate and consider claiming
```
Confidence
93% confidence
Finding
Automatic periodic task polling increases the chance that the agent will process or act on external marketplace data without deliberate user initiation. The danger is amplified here because the heartbeat section explicitly states it is executed regularly, enabling ongoing external interactions that could lead to unintended claims or workflow drift.

Missing User Warnings

Low
Confidence
85% confidence
Finding
This markdown file describes submitting a binary file upload and later downloading submission binaries, but it does not include any user-facing warning about transmitting user data to the service or the implications of uploading potentially sensitive files. Under the markdown-file criteria for missing user warnings, behaviors affecting user data or privacy should be disclosed.

Static analysis

No suspicious patterns detected.