Back to skill

Security audit

Poly Daily Reading

Security checks for vulnerabilities and agentic risk

Overview

The skill’s reading-list purpose is clear, but it asks the agent to run risky shell commands and delete archived files without enough safeguards.

Review before installing. This skill should only be used if you intend to let it read and write the named Obsidian reading-list files and update Mission Control. Before unattended use, pin the Mission Control CLI tooling, avoid inline JSON in shell commands, validate web-derived fields, and make archive deletion confirmable or reversible.

Vulnerability Patterns
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • 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
Findings (2)

T08 · Insecure Dependencies

Warning
Location
SKILL.md:107
Finding
Unpinned npx Execution Creates a Dependency Supply-Chain Risk<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 103-107, 127, 134-136, and 148-150 **Vulnerability Type**: Unpinned third-party package execution **Risk Level**: Medium ### Vulnerable Code ```bash cd ~/.openclaw/workspace/mission-control/apps/cli npx tsx src/index.ts ingest reading-list --data '<JSON>' ``` Additional occurrences: ```bash npx tsx src/index.ts ingest status --agent-id poly --status online --activity-message "Reading list delivered" ``` ```bash npx tsx src/index.ts query reading-lists --dateFrom <mon> --dateTo <sun> --agentId poly --format json ``` ```bash npx tsx src/index.ts ingest task --agentId poly --title "Daily Reading Weekly Archive" --description "Archived last week's reading lists" --status completed --category maintenance ``` ### Technical Analysis The skill repeatedly invokes `npx tsx` without requiring a locally installed, lockfile-pinned, and audited version of `tsx`. If the package is unavailable in the target project, `npx` can retrieve a package from the configured npm registry and execute it. This makes the code ultimately executed by the skill dependent on mutable external package-resolution state rather than solely on the reviewed project. Relevant threats include: - A compromised upstream package or npm account. - An unexpected or malicious package version selected because no version is pinned. - Registry or package-source substitution in the local npm configuration. - Installation-script or runtime behavior introduced by a future dependency release. The downloaded package executes with the same operating-system privileges as the agent. The skill has access to the user's Obsidian vault, OpenClaw workspaces, reading-status data, and Mission Control directory, making supply-chain compromise consequential. ### Attack Path 1. The Mission Control project does not have an audited local `tsx` binary available, or package resolution otherwise falls back to the registry. 2. The skill runs one of the ...[truncated 907 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Add `tsx` at an exact reviewed version to the Mission Control project's dependencies or development dependencies. 2. Commit and enforce a package lockfile with integrity hashes. 3. Install dependencies through a controlled process such as `npm ci`, using a trusted registry and lockfile. 4. Invoke the audited local executable directly: ```bash ./node_modules/.bin/tsx src/index.ts ingest reading-list --data-file /secure/path/reading-list.json ``` 5. Alternatively, require offline package execution: ```bash npm exec --offline -- tsx src/index.ts ... ``` 6. Configure CI or deployment checks to reject missing lockfiles and unexpected dependency changes. 7. Disable package lifecycle scripts where operationally possible and perform periodic dependency-integrity and vulnerability reviews. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
SKILL.md:103
Finding
Search-Derived JSON Can Be Injected into a Shell Command<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 103-120 **Vulnerability Type**: OS command injection through unsafe shell interpolation **Risk Level**: High ### Vulnerable Code ```bash cd ~/.openclaw/workspace/mission-control/apps/cli npx tsx src/index.ts ingest reading-list --data '<JSON>' ``` The substituted JSON is specified as: ```json { "agentId": "poly", "date": "YYYY-MM-DD", "articles": [ {"title": "...", "url": "...", "category": "ai"} ], "delivered": true, "deliveryChannel": "telegram" } ``` ### Technical Analysis The skill instructs the agent to place a JSON document inside a single-quoted shell argument. Article titles and URLs originate from externally controlled web content. JSON encoding does not make a value safe for insertion into a shell command: JSON permits apostrophes without escaping them, while an apostrophe terminates a single-quoted POSIX shell string. If the JSON is substituted into this command as written, an attacker-controlled title or URL containing an apostrophe followed by shell syntax can escape the intended argument and add a new command. For example, a malicious title shaped like the following can alter the shell command structure: ```text '; touch /tmp/agent-command-injection; # ``` Escaping content for JSON alone does not address this vulnerability because JSON and the shell use different parsing and quoting rules. ### Attack Path 1. An attacker publishes an article or search result with a crafted title or URL containing an apostrophe and shell metacharacters. 2. The skill's search workflow selects that result for the daily reading list. 3. The external title or URL is serialized into the Mission Control JSON payload. 4. The agent substitutes the serialized JSON for `<JSON>` in the documented single-quoted command. 5. The malicious apostrophe closes the shell argument. 6. The shell interprets the remaining attacker-controlled text as a separate command. 7. The injected command ...[truncated 859 chars]
Remediation
<![CDATA[ ## Remediation Suggestions Do not concatenate serialized JSON or web-derived values into a shell command. Use one of the following designs: 1. Add a file-based input option to the Mission Control CLI. 2. Serialize the payload with a real JSON library. 3. Write it to a securely created file with restrictive permissions. 4. Pass the file path as a separate process argument. 5. Invoke the executable through an argument-array API without a shell. Conceptual safe invocation: ```text argv = [ "./node_modules/.bin/tsx", "src/index.ts", "ingest", "reading-list", "--data-file", securely_created_json_path ] execute(argv, shell=false) ``` If the CLI must accept inline JSON, pass it as one argument through a process API such as `spawn` or `execFile` with `shell: false`: ```javascript spawn( "./node_modules/.bin/tsx", ["src/index.ts", "ingest", "reading-list", "--data", JSON.stringify(payload)], { shell: false } ); ``` Additional hardening should include: - Validating article URLs against expected `http:` and `https:` schemes. - Applying reasonable length limits to titles, URLs, and summaries. - Treating all search-result metadata as untrusted input. - Avoiding ad hoc shell-escaping functions, which are easy to apply incorrectly. - Adding tests containing apostrophes, quotes, newlines, command substitutions, and shell metacharacters. ]]>
Vulnerability Patterns
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Rogue AgentSelf-Modification, Session Persistence
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
Findings (8)

Session Persistence

Medium
Category
Rogue Agent
Content
Remove any URL matching the exclusion set from Step 1.

### 4. Write Daily File (Unchanged)

Create `<vault>/Daily Reading/daily-YYYY-MM-DD.md`:
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.

Context-Inappropriate Capability

Medium
Confidence
93% confidence
Finding
The manifest describes generating a daily reading list, deduplication, file output, Mission Control ingestion, and archiving. However, the documented implementation requires changing directories and invoking a local TypeScript CLI through `npx tsx`, which introduces arbitrary code execution capability beyond the core content-curation purpose.

Rp1

Medium
Category
MCP Rug Pull
Confidence
81% confidence
Finding
The skill instructs the agent to execute Mission Control ingestion through `npx tsx`, which resolves and runs JavaScript tooling dynamically unless the environment is tightly controlled. That introduces supply-chain and execution-integrity risk because the exact toolchain version is not pinned or otherwise verified before running code on the host.

Rp1

Medium
Category
MCP Rug Pull
Confidence
81% confidence
Finding
This command again relies on `npx tsx` to execute application code, creating the same risk that an unexpected package version or compromised dependency is run in the agent's environment. Because the skill is operational and automated, repeated use increases exposure to dependency confusion or drift.

Rp1

Medium
Category
MCP Rug Pull
Confidence
81% confidence
Finding
The weekly archiving workflow queries data via `npx tsx`, again delegating trust to a potentially mutable JavaScript execution path. In an automated skill, this can let unreviewed code execute with the user's filesystem and workspace access.

Context-Inappropriate Capability

Medium
Confidence
90% confidence
Finding
The skill includes destructive deletion of prior reading files as part of archiving, which goes beyond simple generation of a daily reading list and can cause irreversible data loss if run incorrectly. In an automated cron-like context, mistakes in date logic, path handling, or archive creation could delete user content without review.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The archiving workflow deletes existing files with no user-facing warning, confirmation, or rollback path. Because this skill is designed for scheduled execution, silent destructive actions materially increase the chance of unintended data loss from logic errors or compromised inputs.

Rp1

Medium
Category
MCP Rug Pull
Confidence
81% confidence
Finding
This archive-task ingestion step uses the same unpinned `npx tsx` pattern, so it carries the same supply-chain and arbitrary code execution risk. Because it is coupled with maintenance actions, compromise here could be chained with file modification or deletion activities.

Static analysis

No suspicious patterns detected.