Back to skill

Security audit

Deep Research Pro Litiao

Security checks for vulnerabilities and agentic risk

Overview

This research skill is mostly coherent, but it needs review because it fetches arbitrary web pages with raw shell commands and saves reports to disk by default without clear safeguards.

Review before installing. Use this only in a constrained environment where web access is acceptable, avoid feeding it private/internal URLs, treat Tavily use as an external API dependency, and prefer changing report saving to opt-in with a user-approved path. The evidence supports review-level concerns, not a finding of malicious intent.

Vulnerability Patterns
  • 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
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (1)

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:73
Finding
Unsafe External URL Interpolation and Unrestricted Web Fetching<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 73-80 **Vulnerability Type**: Command injection and server-side request forgery (SSRF) risk **Risk Level**: Medium ### Vulnerable Code ```bash curl -sL "<url>" | python3 -c " import sys, re html = sys.stdin.read() # Strip tags, get text text = re.sub('<[^>]+>', ' ', html) text = re.sub(r'\s+', ' ', text).strip() print(text[:5000]) " ``` ### Technical Analysis The Skill instructs the agent to place a URL obtained during web research directly into a shell command. Although the remote HTTP response is only passed to Python through standard input and is not itself executed, the URL is embedded into shell syntax. If an attacker-controlled URL contains a quotation mark or other shell metacharacters and the agent reproduces it without robust escaping, it can terminate the quoted `curl` argument and introduce an additional shell command. The exact exploitability depends on how the hosting agent substitutes and escapes the `<url>` placeholder, but the documented pattern does not impose safe argument handling. The command also uses `curl -L`, which follows redirects without restricting destination protocols, host classes, or network ranges. A malicious source can redirect the request to loopback, link-local, private-network, or cloud metadata endpoints. This creates an SSRF risk when the Skill runs in an environment with access to services that are not reachable by the original attacker. The detected pipeline is not a `curl | bash` remote-code execution mechanism: downloaded page content is supplied as data to a fixed Python program. Nevertheless, unrestricted URL handling exceeds the minimum network privileges needed for ordinary public-web research. ### Attack Path 1. An attacker publishes a page crafted to appear in search results relevant to a research query. 2. The research agent selects the attacker-controlled URL as a promising source. 3. One of the following paths occurs: - The U ...[truncated 1475 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Do not construct shell commands by interpolating URLs into command strings. 2. Use a dedicated HTTP library or invoke `curl` through an argument-array API that bypasses shell parsing. 3. Parse and normalize each URL before fetching it, and permit only `http` and `https` schemes. 4. Reject URLs containing embedded credentials, malformed hostnames, control characters, or unexpected syntax. 5. Resolve the destination hostname and block loopback, private, link-local, multicast, reserved, and cloud metadata address ranges for both IPv4 and IPv6. 6. Validate every redirect target independently rather than trusting the original URL validation. 7. Disable non-HTTP redirect protocols and impose strict redirect-count, connection-timeout, total-time, and response-size limits. 8. Run page retrieval in a sandbox with minimal filesystem access, no unnecessary credentials, and restricted outbound network access. 9. Replace the documented shell example with a safe helper program that accepts the URL as a discrete argument and applies the preceding controls. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Rogue AgentSelf-Modification, Session Persistence
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
Findings (7)

External Script Fetching

High
Category
Supply Chain
Content
For the most promising URLs, fetch full content:

```bash
curl -sL "<url>" | python3 -c "
import sys, re
html = sys.stdin.read()
# Strip tags, get text
Confidence
95% confidence
Finding
The skill instructs fetching arbitrary URLs with curl and piping attacker-controlled content directly into a Python process via stdin for parsing. Although the Python snippet is static, this still creates a risky external-content ingestion path that can expose the agent to SSRF-like access to internal URLs, retrieval of malicious or oversized content, and unsafe processing of untrusted remote data without validation or sandboxing.

Vague Triggers

Medium
Confidence
94% confidence
Finding
The instruction 'When the user asks for research on any topic' is very broad and overlaps with common user requests, without clear boundaries for when this skill should activate versus when ordinary conversational help should continue. The file does not provide exclusion conditions or negative examples to narrow invocation scope.

Missing User Warnings

Medium
Confidence
88% confidence
Finding
The skill directs the agent to create directories and save reports to disk without requiring explicit user consent or notifying the user that persistent artifacts will be created. This can lead to unintended storage of sensitive research topics, accumulation of files, and persistence of potentially confidential outputs beyond the active session.

Session Persistence

Medium
Category
Rogue Agent
Content
Save the full report:
```bash
mkdir -p ~/clawd/research/[slug]
# Write report to ~/clawd/research/[slug]/report.md
```
Confidence
90% confidence
Finding
The skill explicitly establishes persistent session artifacts by creating a directory and writing a report file under a stable location. Persistent storage increases the risk that sensitive user queries, proprietary research, or regulated information remains accessible after the task ends, especially on shared or long-lived environments.

Skill Enumeration

Medium
Category
Agent Snooping
Content
```
sessions_spawn(
  task: "Run deep research on [TOPIC]. Follow the deep-research-pro SKILL.md workflow.
  Read /home/clawdbot/clawd/skills/deep-research-pro/SKILL.md first.
  Goal: [user's goal]
  Specific angles: [any specifics]
  Save report to ~/clawd/research/[slug]/report.md
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.

Description-Behavior Mismatch

Medium
Confidence
95% confidence
Finding
The package manifest states 'No API keys required' while the skill metadata says the agent prefers Tavily API, which typically requires an API key. This inconsistency can mislead users and reviewers about external service dependencies, causing insecure deployment assumptions, broken functionality, or accidental credential handling outside expected controls. In a research agent that performs web access, misleading dependency claims are more concerning because operators may enable the skill without properly planning for third-party data flow and secret management.

Missing User Warnings

Low
Confidence
88% confidence
Finding
The README advertises web searching, page fetching, and saving output to local files, but it does not clearly warn users that running the skill will initiate network access and may write data to disk. In an agent-skill context, implicit network and filesystem side effects can surprise users and increase the chance of unintended data exposure or unauthorized writes, even if the functionality is expected for the tool’s purpose.

Static analysis

No suspicious patterns detected.