Back to skill

Security audit

Popover

Security checks for vulnerabilities and agentic risk

Overview

This package advertises a frontend popover generator but actually ships a local data-store CLI with persistent file writes, deletion, export, and an unsafe config update path.

Review this carefully before installing. It does not appear to generate popover UI assets; it stores and manages local text entries instead. Avoid using it for frontend generation, do not store sensitive data in it, and do not run config with untrusted keys or values unless the script is fixed to safely handle input.

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

T09 · Insecure Skill Coding Practices

Error
Location
scripts/script.sh:133
Finding

Arbitrary Command Execution Through Configuration Value Injection

Content
View full analysis
)"; fi elif [ -z "$val" ]; then grep "^${key}=" "$cfg" 2>/dev/null | cut -d= -f2- || echo "(not set)" else if [ -f "$cfg" ] && grep -q "^${key}=" "$cfg" 2>/dev/null; then sed -i "s|^${key}=.*|${key}=${val}|" "$cfg" else echo "${key}=${val}" >> "$cfg" fi echo "Set: $key=$val" fi } ``` ### Technical Analysis The `key` and `val` command-line arguments are inserted directly into a double-quoted GNU `sed` program: ```bash sed -i "s|^${key}=.*|${key}=${val}|" "$cfg" ``` Shell quoting prevents ordinary shell metacharacters in these variables from being re-evaluated directly by Bash, but it does not make them safe as `sed` program syntax. An attacker can place delimiter characters, backslashes, or literal newline characters in the value. A newline can terminate the intended substitution and introduce an additional GNU `sed` command. In particular, GNU `sed` supports the `e` command, which executes an operating-system command. A crafted multiline value can therefore close the substitution and add a standalone `e ` instruction. The vulnerable branch is reached when the supplied key already exists in `config.txt`. The key is also interpreted as an unescaped regular expression by both `grep` and `sed`, allowing unexpected matching and configuration modification even when command execution is not attempted. ### Attack Path 1. The attacker invokes ...[truncated 1386 chars]
Remediation
View remediation

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/script.sh:9
Finding

Persistent JSONL Injection Through Unescaped Entry Values

Content
View full analysis
> "$DATA_DIR/data.jsonl" } ``` ### Technical Analysis The function builds JSON through string formatting rather than using a JSON serializer. The `val` argument ultimately contains user-controlled entry text and is inserted into a JSON string without escaping: - Double quotes can terminate or alter the intended JSON string. - Backslashes can introduce invalid or unintended escape sequences. - Literal newlines can terminate the current JSONL record and create additional physical records. - Control characters can produce malformed JSON or affect terminal output when records are later displayed. The resulting `data.jsonl` file is treated as if each physical line were a trustworthy JSON object. Other commands then extract fields using `grep` and `cut` rather than a JSON parser. This compounds the problem because malformed or forged content is not rejected and may be presented as legitimate stored data. ### Attack Path 1. An attacker supplies an `add` entry containing quotes, JSON syntax, or literal newline characters. 2. `cmd_add` passes the attacker-controlled text to `_save_entry`. 3. `_save_entry` writes the text directly inside a quoted JSON field without JSON escaping. 4. The crafted content corrupts the current record or creates additional physical JSONL lines. 5. Subsequent `list`, `search`, `stats`, or `export` operations process the injected lines as stored records. 6. Forged values can appear in command output or exported files, while malformed content can disrupt parsing and normal operation. 7. If control sequences are included, displaying the stored entry in ...[truncated 552 chars]
Remediation
View remediation

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/script.sh:110
Finding

Spreadsheet Formula Injection and Malformed Output in CSV Export

Content
View full analysis
"$out" while IFS= read -r line; do ts=$(echo "$line" | grep -o '"ts":"[^"]*' | cut -d'"' -f4) c2=$(echo "$line" | grep -o '"cmd":"[^"]*' | cut -d'"' -f4) vl=$(echo "$line" | grep -o '"val":"[^"]*' | cut -d'"' -f4) echo "$ts,$c2,$vl" >> "$out" done < "$DATA_DIR/data.jsonl" ;; ``` ### Technical Analysis The export implementation concatenates fields with commas and does not apply CSV quoting or escaping. Consequently: - Commas in values create additional columns. - Quotes are not escaped according to CSV rules. - Newlines can create additional rows. - Values beginning with spreadsheet formula markers such as `=`, `+`, `-`, or `@` may be interpreted as formulas when the exported file is opened in spreadsheet software. Because the value originates from the `add` command, an attacker can persist a formula-like value and have it copied into `popover-export.csv`. The danger is realized when a user opens that export with spreadsheet software that evaluates formulas. The preceding JSON extraction is also fragile because it uses regular expressions instead of a JSON parser, so malformed injected JSON can further influence the generated CSV structure. ### Attack Path 1. An attacker adds an entry whose value begins with a spreadsheet formula marker, or includes commas, quotes, or newlines. 2. The entry is persisted in `data.jsonl`. 3. A user runs `scripts/script.sh export csv`. 4. The script writes the value directly to `popover-export.csv` without CSV encoding or formula neutralization. 5. The user opens the exported file in spreadsheet software. 6. The application may evaluate the attac ...[truncated 788 chars]
Remediation
View remediation
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 (7)

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding

The skill claims to generate frontend popover UI assets, but the documented behavior is a local data-management utility with persistent storage, search, removal, export, and configuration capabilities. This mismatch is dangerous because it can cause an agent or user to invoke file-affecting functionality under false pretenses, increasing the chance of unintended data manipulation or covert collection/export of local information.

Content

No source excerpt is available for this finding.

Description-Behavior Mismatch

High
Category
Not specified by scanner
Confidence
98% confidence
Finding

The documentation advertises a UI popover generator, but every listed command corresponds to generic record management rather than design or component generation. In an agent ecosystem, deceptive documentation is a serious security issue because it can trick orchestration logic or users into granting trust and executing commands unrelated to the declared purpose.

Content

No source excerpt is available for this finding.

Intent-Code Divergence

High
Category
Not specified by scanner
Confidence
98% confidence
Finding

The inline header explicitly claims the script generates popover UI elements, yet the code only manages a local log/database in ~/.popover. This deceptive documentation increases the chance that reviewers, users, or automated systems will misclassify the skill and overlook undisclosed data-handling behavior, enabling stealthy collection or retention of local information.

Content

No source excerpt is available for this finding.

Description-Behavior Mismatch

High
Category
Not specified by scanner
Confidence
99% confidence
Finding

The declared skill purpose is generating popover UI/design assets, but the implementation is an unrelated local datastore CLI that records, searches, removes, and exports user-provided entries. This capability mismatch is dangerous because it can mislead users and host systems into granting trust or access to a skill that performs undisclosed data collection and persistence on the local machine.

Content

No source excerpt is available for this finding.

Vague Triggers

Medium
Category
Not specified by scanner
Confidence
90% confidence
Finding

The activation guidance is broad enough that an agent may select this skill for general interface or styling tasks despite the documented commands not matching that purpose. Overbroad routing criteria increase the likelihood of accidental execution of unrelated local state and file operations in inappropriate contexts.

Content

No source excerpt is available for this finding.

Intent-Code Divergence

Medium
Category
Not specified by scanner
Confidence
95% confidence
Finding

The skill's internal documentation contradicts itself by presenting a frontend/design purpose while documenting stateful entry-management operations and local storage. Such contradiction undermines trust boundaries and can lead to unsafe invocation of commands with side effects that a user would not expect from a design helper.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
90% confidence
Finding

The documentation exposes commands like remove, export, and config without warning that they modify persistent local state or write files. Missing side-effect warnings are dangerous in agent-driven environments because destructive or privacy-impacting actions may be taken without informed consent or additional confirmation.

Content

No source excerpt is available for this finding.

Static analysis

No suspicious patterns detected.