Back to skill

Security audit

Xeonupscale

Security checks for vulnerabilities and agentic risk

Overview

This video-upscaling skill does what it claims, but its installer relies on mutable remote code and an unverified FFmpeg binary that it executes locally.

Review the installer before use. Prefer cloning a pinned commit or release, verify any FFmpeg archive with a published checksum/signature, and avoid the curl-to-bash command. Do not run the installer with elevated privileges, and back up any existing xeonupscale skill directory before reinstalling.

Vulnerability Patterns
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • 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
Findings (3)

T03 · Remote Payload Retrieval and Execution

Error
Location
README.md:17
Finding
Mutable Remote Installer Is Piped Directly into Bash<![CDATA[ ## Vulnerability Details **File Location**: `README.md`, lines 17-18 **Vulnerability Type**: Remote payload retrieval and execution **Risk Level**: High ```bash curl -fsSL https://raw.githubusercontent.com/Wray151/xeonupscale/main/install.sh \ | REPO_URL=https://github.com/Wray151/xeonupscale bash ``` ### Technical Analysis The documented installation method downloads `install.sh` from the mutable `main` branch of a personal GitHub repository and immediately passes its contents to Bash. There is no commit pinning, release pinning, checksum validation, digital-signature verification, or opportunity to review the downloaded content before execution. Although downloading installation code can support the Skill's functionality, immediate execution of mutable remote content is not required. The same functionality can be implemented by downloading a pinned release, verifying it, and executing it separately. This design means that the code actually executed can differ from the version reviewed during this audit. HTTPS protects data in transit but does not protect against repository compromise, maintainer account takeover, malicious upstream changes, or an incorrectly configured repository. ### Attack Path 1. An attacker compromises the repository, its maintainer account, or the `main` branch. 2. The attacker modifies `install.sh` to include arbitrary commands. 3. A user or Agent follows the documented one-line installation command. 4. `curl` retrieves the attacker-controlled script. 5. Bash executes the script immediately without integrity verification. 6. The payload runs with all permissions available to the installing user. ### Impact Assessment Successful exploitation provides arbitrary command execution under the account running the installer. The attacker could read or modify files accessible to that user, alter Agent or Skill configuration, steal user-accessible credentials, install additional payloads, or destroy data. The command does not ...[truncated 194 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Remove the `curl | bash` installation method from the documentation. - Publish versioned, immutable releases and instruct users to download a specific release or commit. - Publish a SHA-256 digest through a separately controlled or signed release channel. - Download the installer to a local file, verify its digest or signature, and only then execute it. - Prefer a workflow such as: 1. Download a pinned release archive. 2. Verify its cryptographic checksum or signature. 3. Extract it into a newly created directory. 4. Review and execute the local installer. - If Git is used, pin and verify a specific commit rather than relying on the mutable `main` branch. - Clearly state that the installer should not be run with `sudo` or as root. ]]>

T08 · Insecure Dependencies

Error
Location
install.sh:27
Finding
Unverified Mutable FFmpeg Binary Is Downloaded and Executed<![CDATA[ ## Vulnerability Details **File Location**: `install.sh`, lines 27-44 **Vulnerability Type**: Insecure third-party executable dependency **Risk Level**: High ```bash if [ ! -x "$FFMPEG_BIN" ]; then case "$(uname -s)-$(uname -m)" in Linux-x86_64) URL="https://github.com/BtbN/FFmpeg-Builds/releases/download/latest/ffmpeg-master-latest-linux64-gpl.tar.xz" ;; Linux-aarch64) URL="https://github.com/BtbN/FFmpeg-Builds/releases/download/latest/ffmpeg-master-latest-linuxarm64-gpl.tar.xz" ;; *) echo "no static ffmpeg build for $(uname -s)-$(uname -m); install ffmpeg manually"; exit 1 ;; esac echo "downloading ffmpeg from $URL" mkdir -p "$FFMPEG_DIR" TMP="$(mktemp -t ffmpeg.XXXXXX.tar.xz)" curl -fL --retry 3 -o "$TMP" "$URL" tar -xJf "$TMP" -C "$FFMPEG_DIR" --strip-components=2 \ --wildcards '*/bin/ffmpeg' '*/bin/ffprobe' rm -f "$TMP" chmod +x "$FFMPEG_DIR"/ffmpeg "$FFMPEG_DIR"/ffprobe fi echo "ffmpeg: $($FFMPEG_BIN -version | head -1)" ``` ### Technical Analysis The installer downloads a precompiled FFmpeg archive through a mutable `latest` URL. It neither pins an immutable release nor validates the archive with a cryptographic checksum or trusted digital signature. After extraction, the downloaded binary is marked executable and immediately invoked through: ```bash $FFMPEG_BIN -version ``` Bundling FFmpeg is related to the declared video-upscaling function, but consuming an unverified, mutable executable exceeds the minimum supply-chain trust necessary to provide that function. HTTPS alone does not establish that the artifact is the exact binary expected by the Skill. The installer restricts extraction to `ffmpeg` and `ffprobe`, which reduces general archive traversal exposure, but it does not establish the integrity or authenticity of those executable files. ### Attack Path 1. An attacker compromises the upstream build project, release workflow, maintainer account, or release artifact. 2. The mutable `lat ...[truncated 1072 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Replace the `latest` URLs with immutable, version-specific release asset URLs. - Publish and pin expected SHA-256 or stronger digests for each supported architecture. - Verify the archive before extraction and fail closed on any mismatch. - Where upstream signing is available, verify the artifact using a pinned, trusted signing key. - Do not invoke the binary until all integrity and authenticity checks have succeeded. - Prefer a trusted system FFmpeg installation when it meets the required feature and version constraints. - Record the selected FFmpeg version and digest in the repository to make builds reproducible and reviewable. - Consider extracting into a staging directory and atomically moving verified binaries into their final location. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
install.sh:52
Finding
Installer Recursively Deletes an Existing Skill Destination Without Confirmation<![CDATA[ ## Vulnerability Details **File Location**: `install.sh`, lines 52-53 **Vulnerability Type**: Unsafe destructive installation behavior **Risk Level**: Medium ```bash [ -e "$DEST" ] && rm -rf "$DEST" ln -s "$REPO_DIR" "$DEST" ``` ### Technical Analysis Before registering the Skill, the installer recursively removes anything already located at the selected destination. The destination is selected from two fixed user-level paths earlier in the script: ```bash openclaw) DEST="$HOME/.openclaw/workspace/skills/xeonupscale" ;; claude) DEST="$HOME/.claude/skills/xeonupscale" ;; ``` This constraint limits the deletion scope, but the operation can still destroy an existing installation, locally modified scripts, configuration, or other user data stored at that path. The installer does not request confirmation, create a backup, verify ownership, or require an explicit force option. Replacing a Skill registration may be necessary during upgrades, but unconditional recursive deletion is not the least-destructive method. ### Attack Path 1. A user already has a directory or file at the selected `xeonupscale` destination. 2. The existing path contains an installation, local modifications, or other user data. 3. The user runs `install.sh`. 4. The installer executes `rm -rf "$DEST"` without confirmation or backup. 5. The existing content is deleted and replaced with a symbolic link to the new repository. This issue does not provide a demonstrated path to broader arbitrary deletion because `TARGET` only selects between two fixed destinations and `DEST` is not directly user-controlled. ### Impact Assessment The primary impact is loss of user data or local modifications within the existing Skill destination. The affected scope is limited to the selected user-level `xeonupscale` path. There is no demonstrated privilege escalation or arbitrary command execution from this behavior. The deletion runs with the current user's permissions and can only remove content ...[truncated 38 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Refuse to continue when the destination already exists unless the user explicitly supplies a `--force` or upgrade option. - Display the exact path that would be removed and request confirmation in interactive installations. - Create a timestamped backup before replacing an existing installation. - Validate that the destination resolves beneath the expected Skill directory before performing any destructive operation. - Handle files, directories, and symbolic links separately. - For upgrades, update the existing repository in place or create a new versioned directory and atomically replace only the registration symlink. - Avoid `rm -rf` where a narrower operation such as removing a known symbolic link is sufficient. ]]>
Vulnerability Patterns
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
Findings (4)

Lp1

High
Category
MCP Least Privilege
Confidence
75% confidence
Finding
The skill uses 'shell' capability that is not listed in its permissions. This may indicate deceptive intent or missing permission declarations.

Chaining Abuse

High
Category
Tool Misuse
Content
fi

mkdir -p "$(dirname "$DEST")"
[ -e "$DEST" ] && rm -rf "$DEST"
ln -s "$REPO_DIR" "$DEST"
echo "✓ skill installed at $DEST -> $REPO_DIR"
echo "  在 agent 里 /reset 或开新会话即可使用。"
Confidence
75% confidence
Finding
Tool calls are chained to bypass individual safety checks or escalate capabilities beyond what any single tool call would allow.

Missing User Warnings

Medium
Confidence
98% confidence
Finding
The README explicitly instructs users to execute a remote script fetched via curl and piped directly into bash, which removes the opportunity to inspect the script before execution and grants immediate code execution to whatever content is served at that URL. In a skill-installation context, this is especially dangerous because users or agents may run it automatically, and any compromise of the repository, branch, or delivery path could lead to arbitrary command execution on the host.

Natural-Language Policy Violations

Low
Confidence
94% confidence
Finding
The script's final user-facing message is written only in Chinese, which imposes a specific language on users without opt-in or alternative locale handling. This matches the language/locale policy concern for natural-language content in code files.

Static analysis

No suspicious patterns detected.