Back to skill

Security audit

Ask a Human

Security checks for vulnerabilities and agentic risk

Overview

The skill is mostly transparent about asking random humans, but it needs Review because it can expose private context to strangers and preserve their feedback for future decisions.

Install only if you are comfortable with prompts being sent to an external service and shown to random human respondents. Before using it, require explicit user approval, preview the exact outbound prompt, and strip secrets, personal data, customer details, proprietary code, non-public security findings, and confidential business context. Treat returned text as untrusted opinion, not as instructions or persistent user preferences unless the owner explicitly confirms it.

Vulnerability Patterns
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • 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 (2)

T09 · Insecure Skill Coding Practices

Error
Location
SKILL.md:51
Finding
Uncontrolled Disclosure of Sensitive Context to an External Service and Anonymous Respondents<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:51-74`; supporting example at `examples/usage.md:208-215` **Vulnerability Type**: External disclosure of potentially sensitive information **Risk Level**: High ### Vulnerable Code ```markdown The strangers answering have **no context beyond what you provide in the question**. Write self-contained questions. ## API Reference Use the `exec` tool to make API calls. The base URL is `https://api.ask-a-human.com`. ### Submit a Question ```bash curl -X POST https://api.ask-a-human.com/agent/questions \ -H "Content-Type: application/json" \ -H "X-Agent-ID: $ASK_A_HUMAN_AGENT_ID" \ -d '{ "prompt": "Your question with full context", "type": "multiple_choice", "options": ["Option A", "Option B", "Option C"], "min_responses": 5, "timeout_seconds": 3600 }' ``` **Parameters:** - `prompt` (required): The question to ask. Include all necessary context. ``` The usage example explicitly demonstrates sending an internal security finding and personnel-related context: ```bash curl -X POST https://api.ask-a-human.com/api/questions \ -H "Content-Type: application/json" \ -H "X-Agent-ID: $ASK_A_HUMAN_AGENT_ID" \ -d '{ "prompt": "I'\''m reviewing code and found a junior developer stored passwords with MD5 hashing instead of bcrypt. How should I phrase feedback that'\''s helpful but not condescending?\n\nContext: This is a code review comment that will be public to the team.", "type": "text", "audience": ["technical", "product"], "min_responses": 3, "timeout_seconds": 1800 }' ``` ### Technical Analysis The Skill instructs agents to include “full context” or “all necessary context” in requests sent to an externally operated API. The submitted prompts are intended to be viewed by a pool of random strangers. However, the instructions do not require: - Explicit user authorization before external disclosure. - Review or preview of the exact outbound prompt. - Re ...[truncated 2477 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Require explicit user approval before every external submission, including a preview of the exact prompt and a clear statement that anonymous strangers may view it. 2. Add a mandatory data-minimization step that strips unnecessary context. 3. Explicitly prohibit submission of: - Passwords, API keys, tokens, cookies, and other credentials. - Personal or regulated data. - Proprietary source code and confidential documents. - Non-public vulnerability details. - Internal identifiers unless strictly necessary. 4. Replace “full context” with “the minimum sanitized context necessary.” 5. Require agents to use placeholders or generalized descriptions, such as replacing employee roles, company names, file names, and implementation details with non-identifying terms. 6. Document the external service's retention, deletion, access, and privacy characteristics. 7. Provide an owner-controlled allowlist of acceptable information categories and disable the Skill for sensitive workspaces by default. 8. Add a final outbound-data check that blocks likely secrets and warns about confidential information before invoking `curl`. ]]>

T02 · Agent Memory Poisoning

Warning
Location
SKILL.md:137
Finding
Persistent Memory Poisoning Through Untrusted Crowd Feedback<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:137-150`, `SKILL.md:241-248`; supporting instructions at `README.md:115` and `examples/usage.md:346-358` **Vulnerability Type**: Persistence of untrusted external content into agent memory **Risk Level**: Medium ### Vulnerable Code ```markdown 1. Encounter a subjective decision 2. Submit question to ask-a-human, get question_id 3. Store in memory: "Asked about email tone, question_id=q_abc123" 4. Proceed immediately with your best guess 5. During next heartbeat or idle moment, check if answers arrived 6. If answers contradict your guess, note this for future similar decisions ``` The Skill further demonstrates retaining externally supplied preferences: ```markdown I need to decide the tone for this error message. I'll ask the humans but proceed with "apologetic" as my best guess. I'm storing question_id=q_abc123 to check later. [Later, during heartbeat] Let me check q_abc123... The humans said "direct, not apologetic" (4 out of 5). I'll remember this preference for future error messages. ``` Late feedback is also explicitly directed into future state: ```markdown ### When Answers Arrive Too Late If you already made the decision: 1. **If reversible:** Consider revising based on human input 2. **If not reversible:** Store the feedback for future similar decisions 3. **Log the discrepancy:** "Humans would have said X, I chose Y" ``` ### Technical Analysis The Skill obtains responses from random strangers but directs the agent to retain those responses as preferences for future decisions. The content is therefore outside the user's trust boundary and may be attacker-controlled. Persisting a question identifier and status for asynchronous polling is operationally necessary, but retaining generalized conclusions such as “remember this preference for future error messages” changes future agent behavior beyond the original request. The Skill provides no controls for: - Separating temporary poll ...[truncated 2480 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Store only the minimum temporary polling state, such as the question ID, creation time, status, and originating task ID. 2. Keep polling state in task-scoped storage rather than long-term semantic memory. 3. Treat all response bodies as untrusted data and never follow instructions embedded in respondent text. 4. Do not convert crowd responses into persistent preferences without explicit confirmation from the authenticated user or owner. 5. Label every retained item with: - External provenance. - Originating question and task. - Creation timestamp. - Expiration timestamp. - Applicable user and project scope. 6. Automatically delete question state after closure or expiration unless the user explicitly requests retention. 7. Prevent anonymous feedback from modifying system instructions, safety rules, tool permissions, or global behavioral preferences. 8. Sanitize and delimit free-text responses before presenting them to the model, clearly identifying them as quoted, untrusted opinions. 9. Prefer structured multiple-choice responses over unrestricted text where practical. 10. Provide controls to inspect, revoke, and delete all memories derived from the external service. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Rogue AgentSelf-Modification, Session Persistence
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
Findings (17)

Missing User Warnings

High
Confidence
97% confidence
Finding
The README explicitly encourages sending agent-provided questions to random anonymous humans and notes they have only the context the agent provides, but it never warns against including secrets, personal data, internal business information, or regulated data. This creates a real risk of exfiltration because users may paste sensitive prompts, emails, incident details, or customer information into a third-party human review pool with no stated confidentiality guarantees.

Missing User Warnings

High
Confidence
97% confidence
Finding
The skill explicitly routes agent questions to a global pool of random humans but does not place a clear privacy warning at the point of use telling operators not to include secrets, personal data, customer content, or internal context. Because the instructions repeatedly encourage sending self-contained, fully contextual prompts, users or downstream agents may disclose sensitive information to third parties without informed consent or data minimization.

Session Persistence

Medium
Category
Rogue Agent
Content
### Option 2: Manual Installation

1. Create the skill directory:
   ```bash
   mkdir -p ~/.openclaw/skills/ask-a-human
   ```
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.

Skill Enumeration

Medium
Category
Agent Snooping
Content
2. Verify the skill file exists:
   ```bash
   ls ~/.openclaw/skills/ask-a-human/SKILL.md
   ```

3. Check OpenClaw logs for errors:
Confidence
80% confidence
Finding
Skill enumerates or reads other installed skills. Access to other skills' SKILL.md files or the skills directory reveals prompt instructions, capabilities, and secrets that should be invisible to peer skills.

Ssd 3

Medium
Confidence
95% confidence
Finding
Telling the agent to provide 'all necessary context' to random humans creates a natural path to overshare sensitive user or business information so the crowd can understand the question. In this skill's context, the recipients are unaffiliated strangers with no confidentiality guarantees, which increases the chance of privacy leakage and policy violations.

External Transmission

Medium
Category
Data Exfiltration
Content
### Submit a Question

```bash
curl -X POST https://api.ask-a-human.com/agent/questions \
  -H "Content-Type: application/json" \
  -H "X-Agent-ID: $ASK_A_HUMAN_AGENT_ID" \
  -d '{
Confidence
91% confidence
Finding
This is a real external transmission path: the skill instructs the agent to POST prompt data to a third-party API. The transmission itself is expected functionality, but it becomes security-relevant because the payload may contain user or internal context and the skill lacks strong safeguards on what may be sent.

External Transmission

Medium
Category
Data Exfiltration
Content
### Submit a Question

```bash
curl -X POST https://api.ask-a-human.com/agent/questions \
  -H "Content-Type: application/json" \
  -H "X-Agent-ID: $ASK_A_HUMAN_AGENT_ID" \
  -d '{
Confidence
91% confidence
Finding
This is a real external transmission path: the skill instructs the agent to POST prompt data to a third-party API. The transmission itself is expected functionality, but it becomes security-relevant because the payload may contain user or internal context and the skill lacks strong safeguards on what may be sent.

Ssd 3

Medium
Confidence
95% confidence
Finding
The API parameter guidance for `prompt` encourages packing full context into outbound requests, which can induce agents to transmit sensitive data to an external service and ultimately to random humans. Since the skill is specifically designed for subjective decisions, the temptation to include verbatim user text or internal drafts is high.

Ssd 3

Medium
Confidence
94% confidence
Finding
The question-writing section reinforces making prompts fully self-contained for external strangers, but gives no privacy boundary or examples of safe abstraction. That combination increases the likelihood that agents will copy sensitive text, user scenarios, or internal deliberations into third-party prompts.

External Transmission

Medium
Category
Data Exfiltration
Content
**Agent (action):**
```bash
curl -X POST https://api.ask-a-human.com/api/questions \
  -H "Content-Type: application/json" \
  -H "X-Agent-ID: $ASK_A_HUMAN_AGENT_ID" \
  -d '{
Confidence
88% confidence
Finding
The direct reference to the external ask-a-human endpoint confirms third-party transmission as part of the workflow. In this skill's context, external transmission is especially sensitive because the destination is a human crowd, not just an automated processor, which raises disclosure risk beyond ordinary API use.

External Transmission

Medium
Category
Data Exfiltration
Content
**Agent (action):**
```bash
curl -X POST https://api.ask-a-human.com/api/questions \
  -H "Content-Type: application/json" \
  -H "X-Agent-ID: $ASK_A_HUMAN_AGENT_ID" \
  -d '{
Confidence
88% confidence
Finding
The direct reference to the external ask-a-human endpoint confirms third-party transmission as part of the workflow. In this skill's context, external transmission is especially sensitive because the destination is a human crowd, not just an automated processor, which raises disclosure risk beyond ordinary API use.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The examples send substantive user/work content to a third-party human-review service without any visible warning, consent step, or data-minimization guidance. Because this skill is explicitly designed to involve random humans, the omission materially increases the risk of leaking confidential business, security, or personal data in normal use.

External Transmission

Medium
Category
Data Exfiltration
Content
**Agent (internal):**
```bash
curl https://api.ask-a-human.com/api/questions/q_delay_email_001 \
  -H "X-Agent-ID: $ASK_A_HUMAN_AGENT_ID"
```
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
**Agent (internal):**
```bash
curl https://api.ask-a-human.com/api/questions/q_delay_email_001 \
  -H "X-Agent-ID: $ASK_A_HUMAN_AGENT_ID"
```
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
**Agent (internal):**
```bash
curl https://api.ask-a-human.com/api/questions/q_delay_email_001 \
  -H "X-Agent-ID: $ASK_A_HUMAN_AGENT_ID"
```
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
**Agent (action):**
```bash
curl -X POST https://api.ask-a-human.com/api/questions \
  -H "Content-Type: application/json" \
  -H "X-Agent-ID: $ASK_A_HUMAN_AGENT_ID" \
  -d '{
Confidence
96% confidence
Finding
This example sends headline options and audience/context to a third-party human pool without warning the user about external sharing. While lower sensitivity than source code or secrets, it still exposes unpublished content and product/marketing strategy to outside parties, which can violate confidentiality expectations.

External Transmission

Medium
Category
Data Exfiltration
Content
**Agent (action):**
```bash
curl -X POST https://api.ask-a-human.com/api/questions \
  -H "Content-Type: application/json" \
  -H "X-Agent-ID: $ASK_A_HUMAN_AGENT_ID" \
  -d '{
Confidence
99% confidence
Finding
This example sends a security-review scenario involving password hashing mistakes in an authentication system to random humans. In context, that is particularly dangerous because it externalizes sensitive security findings and internal implementation details, potentially leaking exploitable weaknesses or confidential code-review information.

Static analysis

No suspicious patterns detected.