Back to skill

Security audit

Furnace

Security checks for vulnerabilities and agentic risk

Overview

This skill is labeled as a furnace control tool, but it behaves like a local note store and includes unsafe command handling that could run unintended local commands.

Review carefully before installing. This does not show network exfiltration, credential theft, or background persistence, but it is materially mislabeled and should not be trusted for furnace or industrial-control workflows. If used at all, treat it as an unsafe local record script, avoid untrusted config/add values, and avoid running export/remove in important working directories until the implementation is corrected.

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

Error
Location
scripts/script.sh:135
Finding

Arbitrary Command Execution Through GNU sed Script 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 configuration key and value are inserted directly into a GNU `sed` program: ```bash sed -i "s|^${key}=.*|${key}=${val}|" "$cfg" ``` Shell quoting prevents ordinary shell metacharacters in these variables from being interpreted directly by Bash, but it does not make the resulting sed program safe. An attacker can include the `|` delimiter, newline characters, regular-expression syntax, replacement metacharacters, or additional sed instructions in either argument. On GNU sed, the `e` command executes a system command. A newline-containing value can terminate the intended substitution and introduce an `e` instruction. This produces arbitrary command execution under the account running the Skill. The key is also interpolated into `grep` regular expressions on lines 143 and 146 without escaping. This permits unintended key matching and helps an attacker reach the vulnerable update branch. ### Attack Path A concrete exploitation sequence on a system using GNU sed is: 1. Create a normal configuration entry so that the update branch is reachable: ```bash ...[truncated 1396 chars]
Remediation
View remediation
&2 return 1 } ``` 3. Reject control characters, including carriage returns and newlines, in configuration values unless multiline values are explicitly supported with a safe storage format. 4. Replace the sed update operation with a parser that treats values as data rather than executable syntax. JSON handled through `jq --arg`, for example, avoids dynamic sed programs. 5. If the text format must be retained, rewrite it through a securely created temporary file, compare keys as literal strings, and atomically replace the original file. 6. Apply restrictive permissions to the data directory and configuration file, such as directory mode `0700` and file mode `0600`. 7. Add regression tests covering sed delimiters, backslashes, ampersands, newlines, regular-expression characters, and attempted `e`-command injection. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/script.sh:10
Finding

Unescaped JSONL Storage and Spreadsheet Formula Injection in CSV Exports

Content
View full analysis
> "$DATA_DIR/data.jsonl" } ``` The export routine parses records using regular expressions and emits CSV fields without CSV quoting or spreadsheet-formula neutralization: ```bash cmd_export() { local fmt="${1:-json}" local out="furnace-export.$fmt" if [ ! -f "$DATA_DIR/data.jsonl" ]; then echo "No data."; return 0; fi case "$fmt" in json) cp "$DATA_DIR/data.jsonl" "$out" ;; csv) echo "timestamp,command,value" > "$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" ;; *) echo "Formats: json, csv"; return 1 ;; esac echo "Exported: $out ($(wc -c < "$out") bytes)" } ``` ### Technical Analysis The `val` field originates from arguments to the `add` command and is placed directly between JSON quotation marks. JSON requires quotation marks, backslashes, control characters, and newlines to be escaped. Because no serializer is used, a crafted entry can: - Terminate the intended JSON string. - Add attacker-selected properties. - Inject line breaks and forge additional JSONL records. - Corrupt subsequent parsing and display operations. The application later attempts to parse JSON using `grep` and `cut`, which ...[truncated 2532 chars]
Remediation
View remediation
> "$DATA_DIR/data.jsonl" ``` 2. Parse stored records with a JSON parser rather than `grep` and `cut`. 3. Reject malformed existing records and report corruption instead of silently processing partial matches. 4. Generate CSV according to RFC 4180: - Enclose every field in double quotes. - Replace each embedded double quote with two double quotes. - Preserve record boundaries safely. 5. If exports are intended for spreadsheet applications, neutralize fields beginning with `=`, `+`, `-`, `@`, tab, carriage return, or other application-specific formula prefixes. A common strategy is to prefix such values with a single quote, while documenting that transformation. 6. Add tests for quotation marks, backslashes, commas, CR/LF characters, Unicode, multiline input, and spreadsheet formula prefixes. 7. Consider migrating existing malformed JSONL records through a validation and repair process before relying on them for export or deletion. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (8)

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding

The skill is presented as a furnace temperature and control manager, but the documented behavior is a generic local record manager with add/list/search/remove/export/config operations and no apparent furnace-specific monitoring or control. This mismatch is dangerous because users or higher-level agents may invoke it under false assumptions, causing unintended filesystem operations, data deletion, or export behavior in contexts that expect industrial-control functionality.

Content

No source excerpt is available for this finding.

Description-Behavior Mismatch

High
Category
Not specified by scanner
Confidence
98% confidence
Finding

The manifest advertises an industrial furnace control skill, but the commands describe a generic local entry manager storing JSONL under ~/.furnace and supporting export/remove operations. In an agent ecosystem, this semantic deception can route the skill into privileged or safety-sensitive workflows where it performs unrelated local data handling instead of the expected operational checks or controls.

Content

No source excerpt is available for this finding.

Intent-Code Divergence

High
Category
Not specified by scanner
Confidence
98% confidence
Finding

The inline documentation explicitly claims furnace management while the code only stores, searches, removes, and exports generic entries. In an agent-skill setting, deceptive or materially inaccurate documentation is a security issue because it can cause the skill to be selected and executed under false assumptions about its function and data handling.

Content

No source excerpt is available for this finding.

Description-Behavior Mismatch

High
Category
Not specified by scanner
Confidence
99% confidence
Finding

The skill is presented as a furnace temperature/control manager, but its actual behavior is a generic local data store for arbitrary user-supplied entries. This mismatch is dangerous because it can mislead operators, reviewers, or higher-level agents into granting the script trust, permissions, or automation context inappropriate for what it really does, increasing the risk of covert data collection or misuse.

Content

No source excerpt is available for this finding.

Intent-Code Divergence

Medium
Category
Not specified by scanner
Confidence
95% confidence
Finding

The command documentation claims furnace-oriented behavior at a high level, yet the listed commands are generic CRUD-style operations unrelated to industrial control. This inconsistency increases the risk of misuse by users and autonomous agents, especially where command names like status or config may be interpreted as applying to physical equipment rather than local files.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
92% confidence
Finding

The documentation describes remove and export capabilities and persistent storage under ~/.furnace without warning about deletion, overwriting, data exfiltration, or filesystem impact. Even if the behavior is local-only, lack of disclosure is risky because agents or users may trigger destructive or sensitive file operations without informed consent.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
91% confidence
Finding

The remove operation deletes a selected line from the persistent data file immediately, with no confirmation prompt, dry-run mode, backup, or undo capability. This makes accidental or automated data loss easy, especially if the skill is invoked by another agent or script with incorrect arguments.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
90% confidence
Finding

The export command writes to a predictable filename in the current directory and overwrites existing files without warning. This can destroy existing user data or clobber important files in automated environments where the working directory is not carefully controlled.

Content

No source excerpt is available for this finding.

Static analysis

No suspicious patterns detected.