Back to skill

Security audit

Mindmap

Security checks for vulnerabilities and agentic risk

Overview

This package is not clearly malicious, but it is marketed as a mind-map tool while it actually persists local notes and command history, including a removal command that does not remove stored data.

Review this carefully before installing. It should be treated as a local logging or note-capture utility, not a mind-map tool. Do not store sensitive information unless you are comfortable with plain-text retention in the configured data directory and a separate history log; do not rely on its remove command to delete data.

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 (2)

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/script.sh:67
Finding
Search-Term Option Injection in grep<![CDATA[ ## Vulnerability Details **File Location**: `scripts/script.sh:67-70` **Vulnerability Type**: Argument/option injection **Risk Level**: Medium ### Vulnerable Code ```bash cmd_search() { grep -i "$1" "$DB" 2>/dev/null || echo " Not found: $1" _log "search" "${1:-}" } ``` ### Technical Analysis The user-controlled search term is passed to `grep` without the `--` end-of-options delimiter. Quoting `"$1"` prevents shell word splitting and shell command injection, but it does not prevent `grep` from interpreting a value beginning with `-` as a command-line option. For example, a search term such as `--help` changes the operation from searching the database to displaying `grep` help. Supplying `-f` causes the following database-path argument to be treated as a pattern file; because no input file then remains, `grep` may wait for standard input. Other implementation-supported options can similarly alter matching, input interpretation, and output behavior. This is option injection rather than arbitrary shell command execution. The reviewed code does not establish a path to execute arbitrary commands or gain additional operating-system privileges. ### Attack Path 1. An attacker supplies or influences a search term beginning with a hyphen. 2. An Agent or user invokes `mindmap search` with that term. 3. `cmd_search` passes the value directly to `grep` after `-i`. 4. `grep` interprets the search term as one or more options instead of as a literal pattern. 5. The attacker changes search behavior, produces unintended output, or causes an automated process to wait for input or otherwise fail. ### Impact Assessment Exploitation occurs with the privileges of the user running the Skill. It can disrupt availability and integrity of search results, interfere with automation, and expose unintended `grep` behavior or output. No privilege escalation, persistence, network access, or arbitrary code execution was demonstrated. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions Terminate option parsing before the user-controlled search pattern: ```bash cmd_search() { if [[ $# -ne 1 || -z "$1" ]]; then echo "Usage: mindmap search <term>" >&2 return 2 fi grep -i -- "$1" "$DB" 2>/dev/null || echo " Not found: $1" _log "search" "$1" } ``` Additional hardening measures: 1. Require exactly one non-empty search argument. 2. Use `grep -F -i -- "$1" "$DB"` if search terms are intended to be literal text rather than regular expressions. 3. Distinguish “no matches” from genuine `grep` execution errors instead of treating all nonzero statuses as “not found.” 4. Add regression tests for values such as `--help`, `-f`, `-e`, empty input, and patterns beginning with a hyphen. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/script.sh:62
Finding
Removal Command Falsely Reports Deletion While Retaining Data<![CDATA[ ## Vulnerability Details **File Location**: `scripts/script.sh:62-65`; documented behavior at `SKILL.md:29` **Vulnerability Type**: Data lifecycle and integrity failure **Risk Level**: Medium ### Vulnerable Code ```bash cmd_remove() { echo " Removed: $1" _log "remove" "${1:-}" } ``` The documented command promises actual removal: ```markdown | `remove <item>` | Remove an entry (logs the removal) | ``` ### Technical Analysis The `remove` implementation neither reads nor modifies `data.log`. It only prints a successful removal message and appends an audit-history record. Consequently, the requested entry remains available through `list`, `search`, and `export`. This creates a discrepancy between documented behavior, reported execution status, and actual persistent state. A user or Agent may reasonably rely on the success response when attempting to delete sensitive, inaccurate, or obsolete information. The issue is especially relevant because storage is plain text and the export command returns the retained records. The history log also records the requested item independently, so deletion semantics should explicitly define whether associated history is retained or redacted. ### Attack Path 1. A user or Agent adds confidential or obsolete content through `mindmap add`. 2. The user invokes `mindmap remove` for that content. 3. The command prints `Removed`, causing the user or calling automation to treat deletion as successful. 4. The implementation leaves `data.log` unchanged. 5. A later `mindmap list`, `mindmap search`, or `mindmap export` operation reveals the supposedly deleted content. ### Impact Assessment The flaw affects the confidentiality and integrity of all records users attempt to remove. Data remains accessible to the same local accounts and processes that can read the configured data directory, and it may subsequently be included in backups or exports. The issue does not grant new system privileges or cross an access- ...[truncated 101 chars]
Remediation
<![CDATA[ ## Remediation Suggestions Implement real deletion with explicit matching semantics and atomic replacement: 1. Validate that a non-empty item argument was supplied. 2. Define whether removal targets an exact complete record, an entry excluding its date prefix, or a stable record identifier. Stable identifiers are preferable where duplicate entries are possible. 3. Create the replacement file inside the same data directory with `mktemp`. 4. Copy every nonmatching record to the temporary file. 5. Preserve restrictive ownership and permissions. 6. Atomically replace `data.log` using `mv` only after successful processing. 7. Install a `trap` to delete the temporary file on errors or interruption. 8. Report success only if at least one record was actually removed; otherwise return a nonzero status. 9. Document whether `history.log` intentionally retains the removed content. Avoid logging sensitive item text if deletion is expected to cover all copies. 10. Add tests confirming that removed records no longer appear in `list`, `search`, or `export`, including duplicate and multiline-input cases. If the intended behavior is only to record a logical removal marker, rename the command and documentation accordingly, and ensure listing, searching, and exporting consistently suppress records marked as removed. ]]>
Vulnerability Patterns
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (9)

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
The skill’s declared purpose is terminal mind-mapping, but the documented behavior is actually a generic local logging utility with command history tracking. This kind of description-behavior mismatch is dangerous because agents or users may invoke the skill under false assumptions, causing unintended local data storage and logging outside the expected brainstorming/mind-map context.

Description-Behavior Mismatch

High
Confidence
99% confidence
Finding
The manifest markets the skill as a mind-mapping and visualization tool, while the body defines commands for local data-log management instead. This semantic deception can mislead automated skill routing and users into supplying content to a tool that persists and audits data locally, creating privacy and trust risks.

Description-Behavior Mismatch

High
Confidence
98% confidence
Finding
The implementation materially contradicts the advertised skill purpose: instead of creating or visualizing mind maps, it acts as a generic local logging and entry-management utility with persistent storage. This kind of capability mismatch is dangerous in an agent skill because users and orchestrators may grant trust or invoke it under false assumptions, enabling unintended data collection or misuse of user input.

Vague Triggers

Medium
Confidence
88% confidence
Finding
The top-level description uses broad brainstorming and organizing language that can trigger selection in many contexts, despite the skill actually persisting entries to local files. This mismatch makes accidental invocation more likely and can expose user content to storage and history logging without clear expectation.

Intent-Code Divergence

Medium
Confidence
96% confidence
Finding
The documentation contradicts itself by presenting the skill as a mind-map tool while operational details describe a generic text-entry manager. Such contradictions increase the chance of operator error, unsafe invocation, and accidental disclosure of sensitive brainstorming content into persistent logs.

Vague Triggers

Medium
Confidence
91% confidence
Finding
The 'When to Use' guidance is broad enough to make the skill a candidate for many generic note-taking, data collection, and automation tasks. Overbroad invocation criteria can cause an agent to select this skill in situations where persistent local logging is unnecessary or inappropriate, increasing the risk of unintended data handling.

Intent-Code Divergence

Medium
Confidence
95% confidence
Finding
The header and help text describe a 'multi-purpose utility tool' rather than a mind-map utility, reinforcing that the script is not what the skill claims to be. Mislabeling a skill in this way weakens transparency and can conceal unexpected capabilities, increasing the risk of users exposing data or invoking operations they did not intend.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The script writes activity history to a persistent log file via `_log()` for multiple commands, but the skill description and help output do not clearly disclose this behavior. Undisclosed persistence is risky because user queries, search terms, and operational metadata may be retained on disk without informed consent, which is especially concerning for agent-executed skills handling potentially sensitive content.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The `add` command appends raw user-provided input to a persistent data file without clear disclosure, creating silent retention of potentially sensitive notes or prompts. In the context of an allegedly mind-map-focused skill, this undisclosed storage is more dangerous because users may assume transient brainstorming behavior rather than durable local recording.

Static analysis

No suspicious patterns detected.