Back to skill

Security audit

Video Enhancement

Security checks for vulnerabilities and agentic risk

Overview

The skill appears to perform cloud video enhancement as advertised, but its install path and command-style runtime instructions leave avoidable local execution and data-handling risks.

Review before installing. Use this only for videos you are allowed to process and are comfortable sending to Verging/external storage, avoid sensitive local media, do not pass untrusted URLs or trim values, avoid running the installer with elevated privileges, and prefer a pinned or verified install source if available.

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

T09 · Insecure Skill Coding Practices

Error
Location
skill.md:116
Finding
Command Injection Through Unvalidated User-Controlled Arguments<![CDATA[ ## Vulnerability Details **File Location**: `skill.md`, lines 116-123 **Vulnerability Type**: Shell command injection through unsafe argument interpolation **Risk Level**: High ### Vulnerable Code ```markdown 1. **Parse args** → extract video path/URL, options 2. **Download remote video** (if URL): `yt-dlp "URL" -o /tmp/verging-video-enhancement/input.mp4` 3. **Get duration** → `ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 video.mp4` 4. **Trim if needed** (--start/--end or duration > 30s): ```bash ffmpeg -i input.mp4 -ss <start> -to <end> -c:v libx264 -c:a aac /tmp/verging-video-enhancement/trimmed.mp4 ``` ``` ### Technical Analysis The Skill instructs an agent to parse user-supplied video URLs, file paths, start times, and end times and insert them into shell commands. It does not require strict numeric validation for `--start` or `--end`, canonical path validation, URL validation, or process execution through a shell-free argument array. The `<start>` and `<end>` substitutions are shown without quoting. If an implementation constructs a command string according to this documentation and invokes it through a shell, shell control characters in either value can terminate or alter the `ffmpeg` command. Although the URL placeholder is surrounded by double quotes, quoting alone is not a complete security boundary when a value can contain embedded quotation marks, command substitutions, or other shell-significant syntax. The local video path is likewise user-controlled but the documented flow does not define safe handling for it. The vulnerability is conditional on the agent or runtime implementing these documented commands by interpolating arguments into a shell command, which is the execution model implied by the examples. ### Attack Path 1. An attacker invokes the Skill and supplies a crafted value through `--start`, `--end`, `--video`, or a maliciously formed URL. 2. The Skill parses the value w ...[truncated 1073 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Parse `--start` and `--end` using a strict numeric parser. Reject non-finite, negative, malformed, and out-of-range values. 2. Enforce `0 <= start < end <= 30` after parsing. 3. Do not concatenate user input into shell command strings. Invoke `yt-dlp`, `ffprobe`, and `ffmpeg` through APIs that accept explicit argument arrays with shell execution disabled. 4. Accept only explicitly supported URL schemes, such as HTTPS, and validate remote hostnames against a documented allowlist if only YouTube and Bilibili are supported. 5. Canonicalize local paths and apply a defined file-access policy before processing them. 6. Insert `--` before positional filenames where supported so filenames beginning with a hyphen cannot be interpreted as options. 7. Reject control characters, null bytes, and unexpected shell syntax as defense in depth. 8. Add tests using malicious quotation marks, command substitutions, separators, option-like filenames, malformed numeric values, and Unicode edge cases. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
skill.md:87
Finding
Predictable Shared Temporary Directory and Filenames<![CDATA[ ## Vulnerability Details **File Location**: `skill.md`, lines 87-89, 117-123, and 136 **Vulnerability Type**: Unsafe temporary-file handling, race conditions, and symbolic-link exposure **Risk Level**: Medium ### Vulnerable Code ```bash curl -X PUT -T /tmp/verging-video-enhancement/trimmed.mp4 \ -H "Content-Type: video/mp4" \ "<presigned_url_from_step_2>" ``` ```markdown 2. **Download remote video** (if URL): `yt-dlp "URL" -o /tmp/verging-video-enhancement/input.mp4` 3. **Get duration** → `ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 video.mp4` 4. **Trim if needed** (--start/--end or duration > 30s): ```bash ffmpeg -i input.mp4 -ss <start> -to <end> -c:v libx264 -c:a aac /tmp/verging-video-enhancement/trimmed.mp4 ``` ``` ```markdown - **Temp directory:** `/tmp/verging-video-enhancement/` ``` ### Technical Analysis The Skill uses one globally predictable temporary directory and fixed filenames, including `input.mp4` and `trimmed.mp4`. It does not specify secure per-run directory creation, restrictive permissions, exclusive file creation, ownership checks, symbolic-link rejection, or concurrency controls. In a multi-user or concurrent environment, another process can anticipate these paths. A local attacker may create files or symbolic links before the Skill runs, while simultaneous Skill invocations may overwrite or consume one another's files. The later `curl -T` operation reads the predictable `trimmed.mp4` path and uploads its current contents to an externally supplied presigned storage URL. The Skill states that temporary files are cleaned after use, but its execution flow does not contain a cleanup command or guaranteed cleanup handler. ### Attack Path 1. A local attacker or competing process anticipates `/tmp/verging-video-enhancement/input.mp4` or `/tmp/verging-video-enhancement/trimmed.mp4`. 2. Before or during execution, it creates a conflicting file, replaces a file, or places a s ...[truncated 1015 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Create a unique per-invocation temporary directory with a secure facility such as `mktemp -d`. 2. Set owner-only permissions, such as mode `0700`, before writing media. 3. Generate unpredictable filenames and create output files atomically. 4. Refuse symbolic links and verify that each file is a regular file owned by the expected user before reading or uploading it. 5. Never reuse one temporary directory across concurrent jobs. 6. Keep file descriptors open where practical rather than reopening predictable paths after validation. 7. Install a guaranteed cleanup handler, such as a shell `trap`, that executes on normal completion, errors, interruption, and timeout. 8. Avoid recursively deleting a path unless its identity and ownership have been securely established. 9. Add concurrent-execution and symbolic-link race tests. ]]>

T08 · Insecure Dependencies

Warning
Location
README.md:4
Finding
Unpinned Third-Party Package Execution During Installation<![CDATA[ ## Vulnerability Details **File Location**: `README.md`, lines 4-8 **Vulnerability Type**: Mutable and unpinned third-party installation dependency **Risk Level**: Medium ### Vulnerable Code ```markdown ## Install ```bash npx skills add verging-ai/agent-skills --skill video-enhancement ``` ``` ### Technical Analysis The documented installation command uses `npx` without pinning the `skills` package to a specific verified version. It also identifies the Skill source as `verging-ai/agent-skills` without an immutable commit hash, signed release, or integrity checksum. `npx` can retrieve and execute package code from a package registry. Consequently, installation behavior may depend on package and repository content available at execution time rather than the content reviewed in this audit. If the registry package, publisher account, dependency graph, or referenced repository is compromised, users may execute code that was not present in the audited project. No evidence in the reviewed files establishes that the current dependency is malicious. The security issue is the absence of reproducible version and integrity controls around code execution. ### Attack Path 1. An attacker compromises the package publisher, registry entry, upstream repository, or a transitive installation dependency. 2. The attacker publishes or exposes a modified version under the mutable package or repository reference. 3. A user follows the README and runs the unpinned `npx skills add` command. 4. `npx` resolves and retrieves the version available at that time. 5. The altered installer or dependency executes with the user's local privileges. 6. The malicious installation can modify files or access data available to the installation process. ### Impact Assessment A compromised installer can execute code with the privileges of the user running the command. This may expose local files, environment variables and credentials, alter installed Skills, or install additional malic ...[truncated 203 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin the `skills` package to an explicitly reviewed version rather than allowing `npx` to resolve the current release. 2. Pin the Skill repository to an immutable commit hash or signed release tag. 3. Publish and verify cryptographic checksums or signatures for released Skill artifacts. 4. Use a lockfile with integrity metadata for all installer dependencies. 5. Prefer a workflow that downloads and verifies an artifact before executing installation code. 6. Document the exact package version, repository commit, expected checksums, and verification procedure. 7. Review package ownership, release provenance, and transitive dependencies before upgrading. 8. Avoid running the installation command with administrator or root privileges. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
Findings (3)

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The README advertises support for YouTube/Bilibili URLs and API-based enhancement, but it does not clearly warn that remote videos may be downloaded locally and/or transmitted to the third-party Verging service for processing. This can lead users to unknowingly send copyrighted, private, or sensitive media to external infrastructure, creating privacy, legal, and data-handling risk.

Rp1

Medium
Category
MCP Rug Pull
Confidence
88% confidence
Finding
The installation command uses `npx skills` without pinning an exact package version, so users may execute whatever version is current at install time. Because `npx` can fetch and run remote code, a compromised, malicious, or breaking upstream release could be executed on the user's machine during installation.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The skill instructs the agent to download remote videos and upload processed media to verging.ai and a presigned external storage URL, but it does not require an explicit user-facing warning or confirmation about data leaving the local environment. This creates a real privacy and data-handling risk because users may provide sensitive local media or third-party URLs without understanding that content will be transmitted to external services and temporarily stored outside the system.

Static analysis

No suspicious patterns detected.