Back to skill

Security audit

詹明明·标题与封面

Security checks for vulnerabilities and agentic risk

Overview

The skill is a title-and-cover copywriting helper, but it tells the agent to save user feedback into long-term shared writing rules without explicit approval.

Install only if you are comfortable with this skill updating long-term copywriting memory from normal feedback. Prefer using it in a workspace where memory writes are reviewed or disabled, and treat any shared vault content it reads or writes as editable agent state rather than fixed policy.

Vulnerability Patterns
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • 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
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
Findings (1)

T02 · Agent Memory Poisoning

Error
Location
SKILL.md:101
Finding
Automatic Persistent Modification of Shared Agent Memory<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 101–105 and 191 **Vulnerability Type**: Automatic storage of user-controlled feedback in persistent Agent state **Risk Level**: High ### Vulnerable Instructions `SKILL.md`, lines 101–105, translated into English: ```markdown **`{vault}/00-Rules-and-Indexes/Copywriting-Framework-Main-Entry.md`** is the sole navigation document for writing copy: Seven-layer map ... conflict resolution table ... default drafting process ... **automatic feedback write-back mechanism**. **Execute it by default; the user does not need to request it each time.** **Any feedback supplied by the user must be automatically written back into the framework according to Section 5, without requiring the user to explicitly request this.** ``` `SKILL.md`, line 191, translated into English: ```markdown Before finishing, check which title styles the user rejected and which formulas or cover methods were validated by click-through or completion data. Write them into `08-Skill-Memory/zmm-title/` after checking for duplicates. ``` ### Technical Analysis The Skill explicitly directs the Agent to transform user feedback into persistent rules without requiring explicit consent. It also permits feedback to be written into a shared copywriting framework rather than limiting storage to isolated, Skill-specific preferences. This creates an Agent memory-poisoning condition because ordinary conversational input can become durable state that influences later sessions. The duplicate check mentioned at line 191 only prevents identical entries; it does not establish that the stored instruction is safe, accurate, appropriately scoped, or authorized. The risk is amplified by the instruction to use the shared vault framework as the default source of behavior. Once malicious or context-specific feedback is written there, future executions may treat it as trusted policy. ### Attack Path 1. An attacker invokes the Skill for a normal ti ...[truncated 1463 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove automatic feedback write-back from the default workflow. 2. Require explicit, informed user confirmation before every persistent write. 3. Show the exact proposed memory entry, destination, and future scope before requesting confirmation. 4. Restrict this Skill to a dedicated, Skill-owned preference store; do not allow it to modify shared framework or policy files. 5. Store preferences as validated structured data rather than executable natural-language instructions. 6. Reject entries that attempt to alter safety constraints, tool permissions, system instructions, memory controls, or unrelated workflows. 7. Attach provenance metadata to each entry, including source conversation, timestamp, requesting user, scope, and approval status. 8. Apply per-user and per-workspace isolation so one user cannot affect another user's Agent state. 9. Provide review, expiration, rollback, and deletion controls for all stored preferences. 10. Treat vault content as untrusted input when it is read back, and prevent it from overriding system-level or security-sensitive instructions. 11. Log persistent writes and alert on attempts to modify shared framework files. 12. Replace the current instruction with a safe pattern such as: “Offer to save this preference; write it only after the user explicitly approves the displayed entry.” ]]>
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
Findings (3)

Vague Triggers

Medium
Confidence
88% confidence
Finding
The skill advertises very broad trigger phrases like generic requests for titles/covers, which can overlap with ordinary user intents and cause the skill to activate when the user did not explicitly request it. That creates routing/control risk: a general conversation may be steered into this skill’s prescriptive workflow, potentially causing unwanted data reads, unexpected behavior, or degraded user autonomy.

Natural-Language Policy Violations

Medium
Confidence
80% confidence
Finding
The instruction to always speak in a specific language/style without checking the user’s language preference can override the user’s intent and produce outputs in an unexpected language. In agent settings, forced language behavior is a control-flow and UX safety issue because it can mis-handle requests, reduce transparency, and make the system less predictable for non-Chinese users.

Natural-Language Policy Violations

Low
Confidence
83% confidence
Finding
The skill directs the agent to automatically apply a framework and write user feedback back into memory without explicit opt-in. Automatic persistence and hidden state updates are risky because users may not expect their feedback to be stored or reused, and silent framework application can reduce user control over how their data is processed.

Static analysis

No suspicious patterns detected.