Back to skill

Security audit

Instagram Reels

Security checks for vulnerabilities and agentic risk

Overview

This skill is a straightforward, disclosed reel transcription workflow with privacy and temp-file hygiene risks but no hidden or purpose-mismatched behavior.

Install only in a dedicated environment, avoid using exported browser cookies unless necessary, do not process private or sensitive media unless you are comfortable sending the audio to Groq, and prefer a unique private temp directory instead of the documented fixed /tmp paths.

Vulnerability Patterns
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • 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
Findings (2)

T08 · Insecure Dependencies

Warning
Location
SKILL.md:23
Finding
Unpinned Third-Party Package Installation<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, line 23 **Vulnerability Type**: Supply-chain exposure through an unpinned dependency **Risk Level**: Medium ### Vulnerable Code ```bash pip install yt-dlp ``` ### Technical Analysis The setup instructions install `yt-dlp` without a version constraint or integrity hash. Consequently, the package and its transitive dependencies may change after this Skill has been reviewed. A future compromised, malicious, or otherwise unsafe package release could execute installation-time or runtime code with the privileges of the user following these instructions. The instruction does not itself establish that the current `yt-dlp` package is malicious. The vulnerability is the absence of reproducible dependency controls, which prevents users from reliably installing the same reviewed artifact. ### Attack Path 1. An attacker compromises a future `yt-dlp` release, one of its dependencies, or the package-distribution channel. 2. A user follows the Skill's setup instructions and runs `pip install yt-dlp`. 3. `pip` resolves and downloads the latest available mutable package set rather than a previously reviewed version. 4. Malicious package code executes during installation or when the Skill later invokes `yt-dlp`. 5. The code operates with the installing or invoking user's privileges and can access resources available to that account. ### Impact Assessment Successful exploitation could result in arbitrary code execution under the affected user's account. The accessible scope may include the user's files, environment variables such as `GROQ_API_KEY`, browser-exported cookie files supplied to the workflow, and network resources available to the process. This instruction does not directly request elevated privileges for the Python package, so the default impact is limited to the privileges of the user running `pip` or `yt-dlp`. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions - Pin `yt-dlp` to a specifically reviewed version instead of installing the latest release: ```bash python3 -m pip install "yt-dlp==<reviewed-version>" ``` - Publish a lock file or requirements file containing cryptographic hashes, and install with hash verification: ```bash python3 -m pip install --require-hashes -r requirements.txt ``` - Review and update pinned versions through a controlled dependency-update process. - Install the package in a dedicated virtual environment rather than the global Python environment. - Prefer a trusted operating-system package or a verified standalone release when an appropriate integrity-validation mechanism is available. - Avoid running the installation or media-processing pipeline as root. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:37
Finding
Predictable Shared Temporary Files Permit File Clobbering and Cross-Run Interference<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 37, 48–54, 86, 93–98, 109–114, and 119–124 **Vulnerability Type**: Unsafe temporary-file handling **Risk Level**: Medium ### Vulnerable Code The primary workflow uses fixed paths in the shared `/tmp` directory: ```bash yt-dlp --write-info-json --skip-download -o "/tmp/reel" "REEL_URL" ``` ```bash AUDIO_URL=$(python3 -c " import json d = json.load(open('/tmp/reel.info.json')) for f in d.get('formats', []): if f.get('ext') == 'm4a': print(f['url']) break ") curl -sL "$AUDIO_URL" -o /tmp/reel-audio.m4a ffmpeg -y -i /tmp/reel-audio.m4a -acodec libmp3lame -q:a 4 /tmp/reel-audio.mp3 ``` Cleanup also operates on a predictable wildcard: ```bash rm -f /tmp/reel.info.json /tmp/reel-audio.* ``` The examples repeat the same fixed output names: ```bash yt-dlp --write-info-json --skip-download -o "/tmp/reel" "https://www.instagram.com/reel/ABC123/" && \ AUDIO_URL=$(python3 -c "import json; [print(f['url']) for f in json.load(open('/tmp/reel.info.json')).get('formats',[]) if f.get('ext')=='m4a'][:1]") && \ curl -sL "$AUDIO_URL" -o /tmp/reel-audio.m4a && \ ffmpeg -y -i /tmp/reel-audio.m4a -acodec libmp3lame -q:a 4 /tmp/reel-audio.mp3 2>/dev/null && \ curl -s https://api.groq.com/openai/v1/audio/transcriptions \ ``` ```bash yt-dlp --write-info-json --skip-download -o "/tmp/reel" "https://www.tiktok.com/@user/video/123" && \ AUDIO_URL=$(python3 -c "import json; [print(f['url']) for f in json.load(open('/tmp/reel.info.json')).get('formats',[]) if f.get('ext')=='m4a'][:1]") && \ curl -sL "$AUDIO_URL" -o /tmp/reel-audio.m4a && \ ffmpeg -y -i /tmp/reel-audio.m4a -acodec libmp3lame -q:a 4 /tmp/reel-audio.mp3 2>/dev/null && \ curl -s https://api.groq.com/openai/v1/audio/transcriptions \ ``` ### Technical Analysis The workflow stores metadata and media under globally predictable names in `/tmp`. On multi-user systems, another local process may predict these names and attempt to create ...[truncated 2421 chars]
Remediation
<![CDATA[ ## Remediation Suggestions Create a unique private directory for each execution and place every generated artifact inside it: ```bash set -euo pipefail TMP_DIR=$(mktemp -d "${TMPDIR:-/tmp}/instagram-reel.XXXXXX") chmod 700 "$TMP_DIR" trap 'rm -rf -- "$TMP_DIR"' EXIT INFO_FILE="$TMP_DIR/reel.info.json" M4A_FILE="$TMP_DIR/reel-audio.m4a" MP3_FILE="$TMP_DIR/reel-audio.mp3" yt-dlp \ --write-info-json \ --skip-download \ -o "$TMP_DIR/reel" \ -- "REEL_URL" AUDIO_URL=$(python3 - "$INFO_FILE" <<'PY' import json import sys with open(sys.argv[1], encoding="utf-8") as source: data = json.load(source) for item in data.get("formats", []): if item.get("ext") == "m4a" and item.get("url"): print(item["url"]) break else: raise SystemExit("No M4A audio URL was found") PY ) curl --fail --show-error --location \ --output "$M4A_FILE" \ -- "$AUDIO_URL" ffmpeg -nostdin -y \ -i "$M4A_FILE" \ -acodec libmp3lame -q:a 4 \ "$MP3_FILE" ``` Additional hardening measures: - Do not use fixed, shared names directly under `/tmp`. - Apply restrictive permissions with `umask 077` or a mode-`0700` temporary directory. - Clean only the unique directory created for the current run; avoid wildcard cleanup of shared paths. - Validate that expected artifacts are regular files and are located inside the private directory before reading or uploading them. - Avoid running the pipeline with elevated privileges. - Use separate temporary directories for concurrent jobs and containers. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • 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 (6)

Tool Parameter Abuse

High
Category
Tool Misuse
Content
- Export cookies with a browser extension like "Get cookies.txt LOCALLY"
- Groq Whisper is free (rate-limited) and returns results in ~1-2 seconds
- Max audio length: 25 minutes per request
- Clean up temp files after: `rm -f /tmp/reel.info.json /tmp/reel-audio.*`
- Also works with TikTok, YouTube Shorts, and other platforms supported by yt-dlp

## Examples
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).

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The skill sends downloaded audio to Groq for transcription and stores reel metadata and media in /tmp, but the description does not clearly warn users that third-party transmission and local persistence occur. This can lead users to process sensitive or private content without informed consent, increasing privacy and compliance risk.

External Transmission

Medium
Category
Data Exfiltration
Content
### Step 3: Transcribe with Groq Whisper

```bash
curl -s https://api.groq.com/openai/v1/audio/transcriptions \
  -H "Authorization: Bearer $GROQ_API_KEY" \
  -F "file=@/tmp/reel-audio.mp3" \
  -F "model=whisper-large-v3-turbo" \
Confidence
89% confidence
Finding
This step uploads the generated MP3 to api.groq.com, which is an external third-party service. The transmission is intentional and core to the feature, but it is still a real data-exposure surface because reel audio may contain personal, copyrighted, or sensitive information.

External Transmission

Medium
Category
Data Exfiltration
Content
AUDIO_URL=$(python3 -c "import json; [print(f['url']) for f in json.load(open('/tmp/reel.info.json')).get('formats',[]) if f.get('ext')=='m4a'][:1]") && \
curl -sL "$AUDIO_URL" -o /tmp/reel-audio.m4a && \
ffmpeg -y -i /tmp/reel-audio.m4a -acodec libmp3lame -q:a 4 /tmp/reel-audio.mp3 2>/dev/null && \
curl -s https://api.groq.com/openai/v1/audio/transcriptions \
  -H "Authorization: Bearer $GROQ_API_KEY" \
  -F "file=@/tmp/reel-audio.mp3" \
  -F "model=whisper-large-v3-turbo" \
Confidence
88% confidence
Finding
The example pipeline again transmits reel audio to Groq, creating the same external data-sharing risk in a copy-pasteable one-liner that users may run without noticing. Example commands can amplify risk because they normalize direct upload of potentially sensitive content.

External Transmission

Medium
Category
Data Exfiltration
Content
AUDIO_URL=$(python3 -c "import json; [print(f['url']) for f in json.load(open('/tmp/reel.info.json')).get('formats',[]) if f.get('ext')=='m4a'][:1]") && \
curl -sL "$AUDIO_URL" -o /tmp/reel-audio.m4a && \
ffmpeg -y -i /tmp/reel-audio.m4a -acodec libmp3lame -q:a 4 /tmp/reel-audio.mp3 2>/dev/null && \
curl -s https://api.groq.com/openai/v1/audio/transcriptions \
  -H "Authorization: Bearer $GROQ_API_KEY" \
  -F "file=@/tmp/reel-audio.mp3" \
  -F "model=whisper-large-v3-turbo" \
Confidence
88% confidence
Finding
This TikTok example extends the same external-upload behavior to another platform, increasing the range of content that may be sent to a third party. While not malicious, it broadens privacy and policy exposure without adding any additional warning or control.

Description-Behavior Mismatch

Low
Confidence
94% confidence
Finding
The manifest description frames the skill specifically as an Instagram Reels tool, but the documentation explicitly states it also works with TikTok, YouTube Shorts, and other yt-dlp-supported platforms, and even provides a TikTok transcription example. That broadens the effective behavior beyond the manifest's stated scope.

Static analysis

No suspicious patterns detected.