Back to skill

Security audit

Excellent Ai Employee

Security checks for vulnerabilities and agentic risk

Overview

The skill is a coherent professional-behavior framework, but it broadly tells agents to persist and reload user/work memory without enough consent, scoping, or retention controls.

Review this skill before installing if you do not want an agent to keep workspace memory. Only use it where persistent notes are acceptable, and configure the agent to ask before writing memory, avoid storing sensitive or third-party instruction text, treat old memory as untrusted context, and provide a way to review and delete stored entries. Maintainers should also avoid running the packaging script in directories that contain .env files, keys, private notes, caches, or other non-distributable files.

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)

T02 · Agent Memory Poisoning

Warning
Location
SKILL.md:59
Finding
Unsafe Cross-Session Memory Persistence and Automatic Reloading<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:59-62`; `references/memory-patterns.md:3-34` **Vulnerability Type**: Persistent memory poisoning and unsafe information retention **Risk Level**: Medium ### Vulnerable Instructions `SKILL.md:59-62`: ```markdown ### Memory Management - Always write important information to files (`memory/YYYY-MM-DD.md`, `MEMORY.md`) - Update long-term memory with distilled insights from daily experiences - Reference relevant past context before making decisions ``` `references/memory-patterns.md:3-34`: ```markdown ## Daily Memory Files - **Location**: `memory/YYYY-MM-DD.md` - **Purpose**: Raw logs of daily activities, decisions, and events - **Best Practices**: - Create automatically if missing for current date - Append significant events as they occur - Include context, decisions, and outcomes - Reference related files or external resources - Use consistent formatting for easy parsing ## Long-term Memory - **Location**: `MEMORY.md` - **Purpose**: Curated wisdom and distilled insights - **Best Practices**: - Only include information worth remembering long-term - Remove outdated or irrelevant content periodically - Organize by categories or themes - Link to detailed daily logs when appropriate - Update during periodic reviews (e.g., weekly) ## Context Loading Strategy - **Main Sessions**: Load both daily and long-term memory - **Group Sessions**: Load only daily memory (security consideration) - **New Sessions**: Always check for existing memory files - **Memory Gaps**: Handle gracefully when files don't exist ## Memory Writing Guidelines - **Write Everything Important**: Don't rely on "mental notes" - **Be Specific**: Include enough detail for future reference - **Use Timestamps**: For time-sensitive information - **Link Related Content**: Cross-reference other memory entries - **Respect Privacy**: Never store sensitive personal data without explicit permission ``` ### Technical Analysis ...[truncated 2293 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Replace “Always write” and “Write Everything Important” with an explicit opt-in policy for persistent storage. 2. Store only user-approved factual preferences or durable task state; prohibit storage of prompts, executable instructions, tool commands, authentication material, and third-party content. 3. Treat every reloaded memory entry as untrusted data rather than as an instruction. 4. Attach metadata to each entry, including source, owner, creation time, expiration time, trust level, and user consent status. 5. Isolate memory by user, workspace, and session security context. Do not load one user's memory into another user's session. 6. Scan entries for prompt-injection patterns before writing and again before loading. 7. Require confirmation before promoting daily-session content into `MEMORY.md`. 8. Implement retention limits, user-visible review, selective deletion, and complete memory-reset mechanisms. 9. Load only entries relevant to the current task instead of automatically loading complete raw logs. 10. Document that persisted content cannot override system policies, safety constraints, current user instructions, or tool authorization requirements. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/package_skill.py:25
Finding
Unrestricted Recursive Packaging Can Disclose Sensitive Files<![CDATA[ ## Vulnerability Details **File Location**: `scripts/package_skill.py:25-36` **Vulnerability Type**: Unrestricted archive inclusion and possible sensitive-file disclosure **Risk Level**: Medium ### Vulnerable Code ```python # Create zip file with zipfile.ZipFile(skill_file, 'w', zipfile.ZIP_DEFLATED) as zf: for root, dirs, files in os.walk(skill_path): for file in files: file_path = Path(root) / file # Skip the package script itself to avoid recursion if file == 'package_skill.py': continue # Calculate archive name (relative to skill directory) arcname = file_path.relative_to(skill_path) zf.write(file_path, arcname) ``` ### Technical Analysis The packaging function recursively archives every file under the supplied Skill directory except files named `package_skill.py`. It does not use an allowlist, apply ignore rules, detect secrets, reject symbolic links, or verify that a resolved file target remains inside the resolved Skill root. Consequently, files not intended for distribution can be included in the generated `.skill` archive. Examples include `.env` files, private keys, credentials, persistent memory, editor backups, version-control metadata, caches, local configuration, and build artifacts. Symbolic links are an additional boundary concern. Because the code does not compare `file_path.resolve()` against `skill_path.resolve()`, an outward-pointing link encountered below the packaging root may cause content outside the intended project boundary to be read into the archive. The script does not upload the archive or perform network communication. Disclosure occurs only if the generated package is subsequently shared or uploaded. ### Attack Path 1. A sensitive file is accidentally placed under the selected Skill directory, or an attacker introduces a symbolic link that points to a readable file outsi ...[truncated 998 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Replace recursive inclusion with an explicit allowlist of distributable files and directories. 2. Permit only expected paths such as `SKILL.md`, `README.md`, approved files under `references/`, and reviewed scripts. 3. Reject symbolic links rather than following or packaging them. 4. Resolve every candidate path and verify containment before reading it: ```python root = skill_path.resolve() candidate = file_path.resolve() if root != candidate and root not in candidate.parents: raise ValueError(f"Path escapes skill root: {file_path}") ``` 5. Exclude sensitive and generated patterns, including `.env*`, `*.pem`, `*.key`, credential files, `MEMORY.md`, `memory/`, `.git/`, caches, temporary files, editor backups, and existing archives. 6. Fail closed when an unknown file is encountered instead of silently adding it. 7. Run secret detection before archive creation and abort if likely credentials or private keys are found. 8. Produce a deterministic manifest containing every archived path, file size, and digest. 9. Display the final manifest and require explicit confirmation before a package is uploaded or distributed. 10. Add automated tests covering hidden files, nested secrets, symbolic links, path-boundary enforcement, and unexpected file types. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
Findings (10)

Vague Triggers

High
Confidence
96% confidence
Finding
The README states the skill is 'automatically triggered' whenever the assistant needs to demonstrate professional workplace behaviors, which is a vague and overly broad activation condition. Broad trigger language can cause the skill to activate in many unrelated contexts, potentially overriding narrower instructions or importing expansive behavioral guidance in situations where it was not explicitly requested.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
The declared description presents a sophisticated AI-agent behavior framework with planning, closed-loop execution, and collaborative tool orchestration. The supplied code does not implement any of those behaviors. Instead, it is a local setup utility that initializes folders and placeholder files for a skill. While filesystem scaffolding could be a supporting development utility, this code chunk’s actual purpose is materially different from the declared runtime capability of the skill. Therefore, this is a clear description-to-behavior mismatch.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
The declared description presents a conceptual AI agent framework for behavior, planning, and tool orchestration. The supplied code does not implement agent logic, planning loops, decision-making, collaboration, or any runtime AI behavior. Instead, it is a standalone filesystem utility that walks a directory and packages files into a .skill archive for upload/distribution. This is a materially different primary purpose, so the description does not accurately represent the code.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
The declared description presents a high-level AI agent framework focused on autonomous behavior, planning, decision-making, and tool orchestration. The supplied code does not implement any of those agent capabilities. Instead, it performs local filesystem validation for a specific skill package structure and metadata. This is a materially different primary purpose, not merely a supporting detail of the declared framework. No agent loop, planning logic, collaboration, or execution orchestration is present in the code chunk.

Lp3

Medium
Category
MCP Least Privilege
Confidence
86% confidence
Finding
The skill explicitly instructs persistent file writes in its Memory Management section, but the frontmatter declares no tool scope or permissions. That creates an undeclared capability boundary: a user or host system may invoke the skill expecting advisory behavior, while the skill encourages filesystem persistence that can retain sensitive data or alter local state.

Vague Triggers

Medium
Confidence
94% confidence
Finding
The description is broad enough to trigger on many normal professional or multi-step requests, which can cause over-activation of the skill. In context, that matters because the skill also promotes memory writes, dynamic decision-making, and multi-tool orchestration; broad activation increases the chance those behaviors occur without specific user expectation or need.

Missing User Warnings

Medium
Confidence
97% confidence
Finding
The skill directs the agent to always write important information to persistent files and maintain long-term memory, but it does not require disclosure, consent, minimization, or retention limits. In practice, this can lead to silent storage of sensitive user data, cross-session profiling, and unintended persistence of confidential information.

Vague Triggers

Medium
Confidence
95% confidence
Finding
The 'When to Apply' section covers common scenarios like complex requests, business communication, leadership behavior, and long-term relationships, making the skill applicable to a very large share of interactions. This broad scope is risky because it can normalize persistent memory use and autonomous planning/tool behavior in contexts where a lightweight, non-persistent response would be safer.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
6. **Document reasoning**: Record the decision process for future reference

### Red Lines (Never Cross):
- **Privacy violations**: Exposing confidential information without consent
- **Harmful content**: Generating content that promotes violence, hate, or illegal activity
- **Deception**: Misrepresenting capabilities, identity, or intentions
- **Exploitation**: Taking advantage of user vulnerabilities or trust
Confidence
75% confidence
Finding
Skill enables autonomous high-impact decisions without human-in-the-loop verification. Critical operations (destructive commands, financial transactions, data deletion) should require explicit user confirmation.

Natural-Language Policy Violations

Low
Confidence
72% confidence
Finding
Several capability labels and principles are presented in Chinese alongside English glosses, but the skill does not state whether this bilingual presentation is optional or user-preference driven. Because language choice is not explicitly offered, this may conflict with a policy requiring language or locale opt-in.

Static analysis

No suspicious patterns detected.