Back to skill

Security audit

Lint

Security checks for vulnerabilities and agentic risk

Overview

This package is labeled as a linting tool, but it mainly stores user-provided developer text in local logs, so it needs review before use.

Install only if you want a local activity log, not a real linting or auto-fix tool. Do not record secrets, tokens, proprietary code snippets, or sensitive review notes unless you are comfortable keeping them in ~/.local/share/lint and exporting/searching them later. Treat exported CSV/JSON as untrusted if log content came from another person.

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:55
Finding

Unsafe JSON and CSV Export of Attacker-Controlled Log Values

Content
View full analysis
"$out" local first=1 for f in "$DATA_DIR"/*.log; do [ -f "$f" ] || continue local name=$(basename "$f" .log) while IFS='|' read -r ts val; do [ $first -eq 1 ] && first=0 || echo "," >> "$out" printf ' {"type":"%s","time":"%s","value":"%s"}' "$name" "$ts" "$val" >> "$out" done < "$f" done echo "" >> "$out" echo "]" >> "$out" ;; csv) echo "type,time,value" > "$out" for f in "$DATA_DIR"/*.log; do [ -f "$f" ] || continue local name=$(basename "$f" .log) while IFS='|' read -r ts val; do echo "$name,$ts,$val" >> "$out" done < "$f" done ;; ``` ### Technical Analysis The export implementation directly interpolates log contents into JSON and CSV without format-specific encoding. For JSON, characters such as double quotes, backslashes, control characters, and embedded newlines are not escaped. A crafted value can terminate the intended JSON string, inject additional properties or records, or make the entire document invalid. For CSV, fields containing commas, double quotes, carriage returns, or newlines are not quoted according to CSV rules. In addition, values beginning with spreadsheet formula markers such as `=`, `+`, `-`, or `@` are written unchanged. If such an export is opened in spreadsheet software, the value may be interpreted as a formula rather than inert text. The affected values originate from local log files populated with user-provided command arguments. Although the current action-command implementation has a separate top-level `local` correctness defect that may prevent normal recording, existing, manually created, or externally populated log files remain exploitable. ### ...[truncated 1513 chars]
Remediation
View remediation

T09 · Insecure Skill Coding Practices

Note
Location
scripts/script.sh:109
Finding

Option Injection Through the Search Term

Content
View full analysis
}" echo "Searching for: $term" local found=0 for f in "$DATA_DIR"/*.log; do [ -f "$f" ] || continue local matches=$(grep -i "$term" "$f" 2>/dev/null || true) if [ -n "$matches" ]; then echo " --- $(basename "$f" .log) ---" echo "$matches" | while read -r line; do echo " $line" found=$((found + 1)) done fi done [ $found -eq 0 ] && echo " No matches found." } ``` ### Technical Analysis The search term is quoted, which prevents shell word splitting and shell metacharacter execution, but it is passed to `grep` before an end-of-options marker. Consequently, a term beginning with `-` is interpreted as one or more `grep` command-line options instead of a literal search pattern. For example, option-shaped values can change matching behavior, provide an alternate pattern through `-e`, request special output, or cause errors. This is argument injection rather than shell command injection: the supplied text cannot introduce a new shell command through this code path, but it can control supported `grep` options. ### Attack Path 1. An attacker controls or influences the value passed to `lint search`. 2. The attacker supplies an option-shaped term such as `-v`, `--help`, or an argument using `-e`. 3. `_search` invokes `grep -i "$term" "$f"` without `--`. 4. `grep` parses the attacker-controlled term as an option rather than as search data. 5. Search semantics are changed, output is manipulated, or the requested search fails. ### Impact Assessment Successful exploitation can produce misleading search results, suppress expected matches, expose unexpected command output, or cause denial of t ...[truncated 234 chars]
Remediation
View remediation
/dev/null || true) ``` Additional hardening measures: 1. Treat the term as a fixed string if regular expressions are unnecessary: ```bash matches=$(grep -iF -- "$term" "$f" 2>/dev/null || true) ``` 2. Validate the expected number of search arguments and reject unsupported extra arguments. 3. Add regression tests for terms such as `-v`, `--help`, `-efoo`, spaces, wildcard characters, and regular-expression metacharacters. 4. Preserve a clear distinction between literal searches and regular-expression searches if both are intentionally supported. ]]>
Vulnerability Patterns
  • 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
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • 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 linting and CI-oriented code quality tool, but the documented behavior is actually a generic persistent logger for arbitrary user input with export and search features. This mismatch is dangerous because users may provide source code, secrets, internal filenames, PR details, or review notes expecting transient linting, while the skill silently normalizes long-term local retention of that data in a structured store.

Content

No source excerpt is available for this finding.

Description-Behavior Mismatch

High
Category
Not specified by scanner
Confidence
99% confidence
Finding

The manifest claims code linting and auto-fix functionality, but the content describes a local activity recorder that does not actually perform syntax checking or style enforcement. In a developer tooling context, this can mislead users into trusting the skill with repository content and operational decisions while it instead accumulates potentially sensitive engineering data without delivering the promised security or quality controls.

Content

No source excerpt is available for this finding.

Intent-Code Divergence

High
Category
Not specified by scanner
Confidence
98% confidence
Finding

The documentation explicitly states that commands 'record' entries, directly contradicting the branding as a linting tool. This contradiction is dangerous because it creates a deceptive workflow where users may think they are running code checks when they are actually just persisting operational notes or code-derived content to local logs, undermining trust and potentially causing accidental sensitive data retention.

Content

No source excerpt is available for this finding.

Intent-Code Divergence

High
Category
Not specified by scanner
Confidence
97% confidence
Finding

The documentation and command names advertise check/format/lint/fix capabilities, but the handlers merely write provided text into log files. This deceptive behavior can trick users or automation into feeding sensitive repository content to a tool that does not perform the claimed function, creating a privacy and trust breach.

Content

No source excerpt is available for this finding.

Description-Behavior Mismatch

High
Category
Not specified by scanner
Confidence
98% confidence
Finding

The script is presented as a linting tool, but its actual behavior is to collect arbitrary user-supplied text and persist it under a private local data directory. That mismatch is dangerous because users may provide source code, secrets, or CI data expecting analysis, while the tool silently stores and later exposes that data via export/search/report functions.

Content

No source excerpt is available for this finding.

Context-Inappropriate Capability

Medium
Category
Not specified by scanner
Confidence
94% confidence
Finding

The inclusion of generation, conversion, templating, diff, preview, and report commands expands the skill far beyond linting, increasing the chance that users submit broader and more sensitive content under false assumptions about scope. While the documented commands only record entries, their unjustified breadth makes the skill a generic capture surface for arbitrary development artifacts and metadata.

Content

No source excerpt is available for this finding.

Context-Inappropriate Capability

Medium
Category
Not specified by scanner
Confidence
89% confidence
Finding

The export, search, recent, status, and reporting features operate over a persistent datastore unrelated to normal linting behavior, increasing the chance that captured user input can be browsed, aggregated, and exfiltrated locally. In the context of a supposed development lint tool, these hidden data-management capabilities expand exposure of potentially sensitive code snippets or tokens supplied by users.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
97% confidence
Finding

User input is appended to persistent logs without any clear warning, consent, retention limit, or indication that the data can later be exported and searched. For a lint skill, inputs may include source code, diffs, file paths, and secrets from CI workflows, so silent retention creates unnecessary exposure.

Content

No source excerpt is available for this finding.

Static analysis

No suspicious patterns detected.