Back to skill

Security audit

Github Release Watcher

Security checks for vulnerabilities and agentic risk

Overview

This release-watcher skill has a coherent purpose, but its bundled script can turn untrusted GitHub release data into local code execution.

Review before installing. Use this only with repositories you trust, avoid unattended scheduling until the Python interpolation is fixed, and run it with a least-privileged GitHub/session environment because a malicious release tag could execute commands locally.

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

T09 · Insecure Skill Coding Practices

Error
Location
scripts/check_releases.sh:36
Finding

Arbitrary Python Code Execution Through Unsafe String Interpolation

Content
View full analysis
/dev/null) ``` ```bash python3 -c " import json with open('$STATE_FILE','r') as f: d=json.load(f) d['$repo']='$tag' with open('$STATE_FILE','w') as f: json.dump(d,f,indent=2) " ``` ### Technical Analysis The script directly interpolates shell variables into Python source passed to `python3 -c`. The values are placed inside single-quoted Python string literals without escaping or argument binding. The affected values include: - `$tag`, obtained from release metadata returned by GitHub. - `$repo`, obtained from the repository configuration. - `$STATE_FILE`, which can be supplied through an environment variable. An input containing a single quote can terminate the intended Python string literal and append arbitrary Python statements. For example, a release tag shaped like: ```text ';__import__("os").system("id");# ``` would produce Python source equivalent to: ```python d['owner/repository']='';__import__("os").system("id");#' ``` The injected `os.system` call would consequently execute on the local host. Shell quoting around the earlier `gh api` command does not prevent this issue because the injection occurs when dynamically constructing Python code. A malicious release tag is the most direct externally controlled exploitation vector. Repository maintainers or attackers who compromise release-publishing permissions can control tag names returned by the GitHub API. The environment-controlled state-file path is an additional unsafe interpolation boundary. ### Attack Path 1. A victim adds an attacker-controlled repository to `repos.txt`, or already monitors a repository whose release-publishing account is later compromised. 2. The attacker publishes a GitHub ...[truncated 1256 chars]
Remediation
View remediation
Vulnerability Patterns
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • 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 (1)

Tool Parameter Abuse

High
Category
Tool Misuse
Confidence
85% confidence
Finding

Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Content

Scanner excerpt · SKILL.md (reported line 20)May include surrounding context.

bash scripts/check_releases.sh /path/to/repos.txt

Dry run (show all latest releases regardless of state)

rm -f scripts/.last_seen.json && bash scripts/check_releases.sh

text

## Integration