Back to skill

Security audit

Boiler

Security checks for vulnerabilities and agentic risk

Overview

This skill is branded as a boiler sizing tool, but it behaves like a persistent local record manager and contains unsafe shell handling that needs review before installation.

Install only if you intend to use a local generic record manager, not a boiler efficiency or sizing calculator. Treat stored entries and exports as persistent local files, avoid opening CSV exports from untrusted data in spreadsheets, and do not let untrusted users or agents pass arbitrary config arguments to this script.

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

T09 · Insecure Skill Coding Practices

Error
Location
scripts/script.sh:138
Finding

Arbitrary Command Execution Through Unsafe Configuration Editing

Content
View full analysis
/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 Both `key` and `val` originate from command-line arguments and are inserted directly into a GNU `sed` program. The implementation does not escape regular-expression metacharacters in `key` or replacement, delimiter, newline, and command metacharacters in `val`. GNU `sed` supports the `e` substitution flag, which executes the resulting pattern space through a shell. A crafted value containing a delimiter, an `e` flag, and a newline can terminate the intended substitution and introduce another `sed` instruction. An attacker can also select a crafted key so that the replacement text becomes a valid shell command followed by a comment. The same unescaped key is used in `grep` as a regular expression, which can cause incorrect key matching, although command execution occurs at the `sed` sink. ### Attack Path 1. The attacker invokes `config` with a crafted key to create a matching line in `config.txt`. 2. The attacker invokes `config` again for that key, supplying a value containing `sed` delimiters, an `e` flag, and a newline. 3. The interpolated input changes the effective `sed` program instead of remaining ordinary replacement data. 4. GNU `sed` processes the injected `e` flag. 5. The generated replacement text is passed to `/bin/sh`. 6. The injected shell command executes with the privileges of the user or agent running the Skill. Exploitation requires the ability to invoke the Skill with attacker-controlle ...[truncated 548 chars]
Remediation
View remediation

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/script.sh:11
Finding

Persistent JSONL Injection Through Unescaped Entry Values

Content
View full analysis
> "$DATA_DIR/data.jsonl" } ``` The affected function receives attacker-controlled content from the `add` command at `scripts/script.sh:50-54`: ```bash cmd_add() { local value="${1:?Usage: boiler add }" shift || true _save_entry "add" "$value $*" local count=$(wc -l < "$DATA_DIR/data.jsonl" 2>/dev/null || echo 0) echo "Added: $value (entry #$count)" } ``` ### Technical Analysis The script creates JSON by inserting values into a fixed `printf` template. It does not JSON-escape quotation marks, backslashes, newlines, carriage returns, tabs, or other control characters. An entry containing a quotation mark can terminate the intended `val` string. Embedded newline characters can then create additional physical lines in the JSONL file. Consequently, attacker input can corrupt the current record or create apparent additional records that are subsequently processed by `list`, `search`, `stats`, and `export`. The parsing logic later uses `grep` and `cut` rather than a JSON parser, making it especially vulnerable to malformed or forged record structures. ### Attack Path 1. The attacker invokes `scripts/script.sh add` with an entry containing JSON syntax and one or more newline characters. 2. `_save_entry` writes the input verbatim inside a quoted JSON field. 3. The supplied quotation mark terminates the intended value, and the newline creates another JSONL line. 4. The data file now contains malformed data or attacker-forged apparent records. 5. Subsequent listing, searching, statistics, or export operations consume the manipulated file and present inac ...[truncated 442 chars]
Remediation
View remediation

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/script.sh:115
Finding

Spreadsheet Formula Injection in CSV Exports

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 `vl` field can contain attacker-controlled entry data. It is written directly to a CSV file without standards-compliant quoting, escaping, or spreadsheet formula neutralization. Spreadsheet applications may interpret cells beginning with `=`, `+`, `-`, or `@` as formulas. Merely quoting a field according to CSV syntax is not sufficient to prevent formula interpretation in all spreadsheet applications, so explicit neutralization is also required. The implementation additionally fails to escape commas, quotation marks, and line breaks, allowing malformed rows and column injection. ### Attack Path 1. The attacker adds an entry whose value begins with a spreadsheet formula trigger such as `=`, `+`, `-`, or `@`. 2. A user invokes `scripts/script.sh export csv`. 3. The attacker-controlled value is copied directly into `boiler-export.csv`. 4. The user opens the exported file in a spreadsheet application. 5. The spreadsheet may evaluate the value as a formula rather than displaying it as text. 6. Depending on spreadsheet behavior and security settings, the formula may generate deceptive content, reference other cells, or initiate external requests. ### Impact Assessment The impact occurs in the context of the user opening the exported CSV file. Potential consequences include spreadsheet content manipulation, disclosure of spreadsheet data through external references, and network ...[truncated 230 chars]
Remediation
View remediation

T09 · Insecure Skill Coding Practices

Note
Location
scripts/script.sh:8
Finding

Symlink-Following Writes Allow Modification of Unintended Files

Content
View full analysis
> "$DATA_DIR/data.jsonl" } ``` The export paths are also fixed and opened without symbolic-link validation: ```bash local out="boiler-export.$fmt" ``` ```bash json) cp "$DATA_DIR/data.jsonl" "$out" ;; ``` For CSV export, the fixed destination is opened with shell redirection: ```bash echo "timestamp,command,value" > "$out" ``` ### Technical Analysis The script assumes that the configured data directory, `data.jsonl`, and fixed export destinations are trustworthy regular files. It does not verify directory ownership or permissions and does not reject symbolic links before appending to or overwriting files. If another local user or process can pre-create one of these paths as a symbolic link, append redirection, overwrite redirection, or `cp` may follow the link. The resulting write is performed with the privileges of the user running the Skill. Exploitation depends on the attacker having write access to the configured data directory or the working directory used for export. It also depends on the target file being writable by the Skill caller. ### Attack Path 1. The attacker gains write access to the configured data directory or the directory from which export is run. 2. The attacker creates `data.jsonl`, `boiler-export.json`, or `boiler-export.csv` as a symbolic link to another file. 3. The victim runs `add` or `export`. 4. The script opens the attacker-controlled path without checking whether it is a symbolic link. 5. Data is appended to or copied over the linked target with the victim ...[truncated 396 chars]
Remediation
View remediation
Vulnerability Patterns
  • 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
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
Findings (9)

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding

The skill is presented as a boiler efficiency and sizing tool, but its documented behavior is a generic persistent record manager that stores, searches, removes, and exports arbitrary local data. This mismatch is dangerous because users and agents may grant trust, permissions, or run workflows under false assumptions, enabling unintended local data collection and file-writing behavior.

Content

No source excerpt is available for this finding.

Description-Behavior Mismatch

High
Category
Not specified by scanner
Confidence
97% confidence
Finding

The manifest claims a domain-specific industrial calculation tool, but the commands implement a generic local data manager with persistent storage. In an agent ecosystem, this kind of scope deception can bypass user expectations and policy review, increasing the risk of unauthorized data retention or misuse of the skill for unrelated record handling.

Content

No source excerpt is available for this finding.

Intent-Code Divergence

High
Category
Not specified by scanner
Confidence
98% confidence
Finding

The inline comments and help output reinforce a false claim that this is a boiler tooling utility, while the code behaves like a generic note/log database. In skill ecosystems, this kind of impersonation materially increases risk because it conceals true capabilities from reviewers and end users, enabling covert data collection or persistence under a trusted-looking label.

Content

No source excerpt is available for this finding.

Description-Behavior Mismatch

High
Category
Not specified by scanner
Confidence
99% confidence
Finding

The skill advertises a boiler efficiency/sizing tool but actually implements a generic local data store, search, export, and config manager. This deceptive mismatch is dangerous because users may grant trust and provide inputs under false pretenses, while the script quietly persists and manipulates data unrelated to the declared purpose, which is a strong indicator of trojanized or misleading functionality.

Content

No source excerpt is available for this finding.

Intent-Code Divergence

Medium
Category
Not specified by scanner
Confidence
93% confidence
Finding

The documentation promises boiler efficiency and sizing functionality, but the listed commands only describe generic entry management operations. This contradiction undermines transparency and can mislead users into invoking a skill with broader data-handling behavior than expected.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
91% confidence
Finding

A documented remove command without any warning, confirmation, or scope description increases the chance of accidental destructive actions against locally stored data. In a skill designed for agent use, lack of safety affordances can lead to silent data loss if the command is triggered automatically or by misunderstanding.

Content

No source excerpt is available for this finding.

Missing User Warnings

Low
Category
Not specified by scanner
Confidence
85% confidence
Finding

The skill description advertises an export command that writes data to a file, but it does not warn users about file creation/overwrite behavior or destination handling. Markdown guidance for skills should disclose behaviors that may affect user data or the filesystem.

Content

No source excerpt is available for this finding.

Missing User Warnings

Low
Category
Not specified by scanner
Confidence
88% confidence
Finding

The export command copies or transforms stored entries into boiler-export. in the current working directory. While the command prints after completion, the skill does not warn beforehand in its help or documentation that invoking export creates a file containing stored user data.

Content

No source excerpt is available for this finding.

Missing User Warnings

Low
Category
Not specified by scanner
Confidence
86% confidence
Finding

The script modifies persistent configuration state by updating or appending to $DATA_DIR/config.txt. Although it prints a success message after the change, there is no prior warning in comments/help text that the command writes configuration data to disk, so the persistence side effect is not disclosed.

Content

No source excerpt is available for this finding.

Static analysis

No suspicious patterns detected.