Back to skill

Security audit

xeon-smartupscale_v2

Security checks for vulnerabilities and agentic risk

Overview

This video upscaling skill is mostly purpose-aligned, but its installer runs mutable third-party code and installs unverified binaries.

Review the installer before use. Avoid running it as root, prefer installing ffmpeg and pip from trusted system packages, and use an isolated environment because the current installer may execute remote bootstrap code and unverified native binaries with your user privileges.

Vulnerability Patterns
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • 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
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (3)

T03 · Remote Payload Retrieval and Execution

Error
Location
install.sh:35
Finding

Unverified Remote pip Bootstrap Is Executed Directly

Content
View full analysis
/dev/null; then echo "Bootstrapping pip..." curl -sSL https://bootstrap.pypa.io/get-pip.py | python fi ``` ### Technical Analysis The installer streams a mutable script from an external URL directly into the Python interpreter. The downloaded content is neither saved for inspection nor validated using a pinned cryptographic hash or publisher signature. HTTPS protects the connection under normal circumstances, but it does not establish that the retrieved script is the exact artifact reviewed by the Skill auditor. Compromise of the upstream server, DNS or certificate trust infrastructure, or the remote distribution process could change the effective code executed by the installer. Bootstrapping `pip` may be necessary when a virtual environment lacks it, but direct remote execution is not the minimum-risk method required for video upscaling. The installer could instead require packaged `pip`, use Python's `ensurepip`, or verify a pinned bootstrap artifact before execution. ### Attack Path 1. The attacker compromises the upstream bootstrap service or another trusted part of the delivery chain. 2. The user runs `bash install.sh` on a system where the created virtual environment does not contain `pip`. 3. `curl` retrieves the attacker-controlled replacement for `get-pip.py`. 4. The shell pipes the response directly into Python without integrity verification. 5. The malicious Python payload executes with all privileges and filesystem access available to the user running the installer. 6. The payload can modify files, access credentials readable by that user, install further components, or alter the Skill environment. ### Impact Assessment The payload obtains arbitrary Python code execution with the installer's effective user p ...[truncated 398 chars]
Remediation
View remediation

T08 · Insecure Dependencies

Error
Location
install.sh:50
Finding

Unpinned and Unverified Third-Party FFmpeg Binaries Are Installed and Executed

Content
View full analysis
Remediation
View remediation

T08 · Insecure Dependencies

Warning
Location
install.sh:40
Finding

Python Runtime Dependencies Are Not Fully Pinned or Hash-Verified

Content
View full analysis
/dev/null python -m pip install "openvino==2025.2.0" numpy opencv-python-headless >/dev/null ``` ### Technical Analysis Only `openvino` is pinned to an exact version. The installer upgrades `pip` to whichever release is current and installs unconstrained versions of `numpy` and `opencv-python-headless`. No package hashes are supplied. As a result, the dependency set can change without any modification to the reviewed Skill. Future releases, compromised packages, or dependency-resolution changes could introduce malicious behavior, incompatible native code, or unexpected transitive dependencies. These libraries are relevant to the declared OpenVINO video-upscaling function, so installing them is functionally justified. The risk arises from retrieving mutable, non-reproducible package versions rather than from the need for the dependencies themselves. ### Attack Path 1. An attacker compromises a selected package release, publisher account, package-index delivery path, or transitive dependency. 2. Alternatively, an unsafe or incompatible future release becomes the newest version matching the unconstrained requirement. 3. The user runs `install.sh`. 4. `pip` resolves the current versions of itself, `numpy`, and `opencv-python-headless` rather than a previously reviewed dependency set. 5. The affected package is installed into the Skill's virtual environment. 6. Malicious package code or native extensions execute during installation or when imported by `sr_video_ov.py`. This finding does not establish that the current packages are malicious. It identifies the absence of controls needed to ensure that future installations use the audited artifacts. ### Impact Assessment A malicious dependency can execute code with the ...[truncated 482 chars]
Remediation
View remediation
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • Behavioral ASTexec() Call, eval() Call, Dynamic Import
Findings (15)

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding

The skill description promises a deterministic multi-stage planning pipeline, but the analyzed behavior reportedly does not implement that planner and instead performs only a simpler single-pass workflow. This is dangerous because agents or users may rely on the documented constraints and safety assumptions when deciding how to invoke the skill, leading to incorrect outputs, unexpected resource usage, or unsafe orchestration decisions based on false capabilities.

Content

No source excerpt is available for this finding.

Context-Inappropriate Capability

High
Category
Not specified by scanner
Confidence
98% confidence
Finding

The script fetches a remote Python script from bootstrap.pypa.io and immediately executes it via a shell pipeline. This is dangerous because any compromise of the remote endpoint, TLS interception, or unexpected content change results in arbitrary code execution during installation.

Content

No source excerpt is available for this finding.

Chaining Abuse

High
Category
Tool Misuse
Confidence
99% confidence
Finding

The command chaining of network retrieval directly into Python removes any opportunity for inspection or integrity validation before execution. In the context of an installer, this gives remote content full execution privileges inside the user's environment, making compromise highly impactful.

Content

Scanner excerpt · install.sh (reported line 37)May include surrounding context.

sh
if ! python -m pip --version &>/dev/null; then
  echo "Bootstrapping pip..."
  curl -sSL https://bootstrap.pypa.io/get-pip.py | python
fi

python -m pip install --upgrade pip >/dev/null

YARA rule 'privilege_escalation_tools': Privilege escalation tools and techniques [hacktools]

High
Category
YARA Match
Confidence
75% confidence
Finding

YARA rule matched a hack tool or exploit indicator (offensive tools, reconnaissance, privilege escalation, or exploit frameworks).

Content

Scanner excerpt · model/realesr-general-x4v3_480x270.weights.dat (reported line 4551)May include surrounding context.

text
nRhqLln+QZyFWJfec4qW6K0mtfKppryuaraU/rt8m
eaJnqFkmNSlEJYKqJalkqe+m4aqTqG0keB3EGOIg/iRemAkcsqbWJBKv+Jzhqfmo2CzWJWCu/K56
r/mv9qyHsCOjLysbqOuisp7CroUmgioyoGid6yU1qcypeBozpJGiaCzaLE2toqQYqg2n7KyVpLwo
9CmWJIcfAKdzFq0l0im8JJ+sTq+Or9Ychy2QK0SisSLoKgQoVCcpJfMlPKggLAkffyPrno6mBBqv
Kz4lTZTbnu0izqogKQ6pTB9vIUMbpaV+I48oCSu1K5ii0ijlH2soF6yQqiUsRygAIASpqyRjqGkn
eqmbHtGonagYqBcrjyavK1ARdKldKfkiKCOXBX6hYiQ+JLkgHSpspYMm9CmIKqGpGC/kMUGtCJsM
MDqraiogMaefTx9mrREozByBImgoFCtZrIIqvSibHlEo46HFK3ocbKh0IQOtTq4PrXekhiVxJGkt
vy8XMCCXbigSnSWrrpI1JvCrbqTtqDupE6uMqnOXNShQqo6icaj0pnEn/BhYLpQl5rAFLngt9Szw
LqSX6qN3nGgk/qCAJ8IqVyyyLfms9aFHqHKsSK4+oo6kgizPJHekqiXZF5KeCikVKfCUOic/Ihuo
y6dHrA+otCgqKdqv5apMqiod0qhbLAGt4zjXIUys16pDLN6ibhxUos+i4SRDH6GPnSibn/4orikX
LROYCx4fJPYdNxtwKlIePKUuKT+Uwa+3JLEknipoJlss5SmPKsijWqo0Jx8oEpqCKCaobaXepxKq
iKIFrTEmmCUpKBOqOCcIIQanRYw7FMgsui27LIglkSokqZKqpSWQqLslQiSKq8oYWqmlIqMsUKmH
KoQvrivBLOghGCHeqxito6slsCoieKiQqgmjZy5VK3Ks/hh5JsiwKaamqkSp5SiZpEchL6Q6oMQe
3SrDImqpfqjCrTwmxyqBqP0ifitkqgSugq

Undeclared Tool Scope

Medium
Category
MCP Least Privilege
Confidence
95% confidence
Finding

The skill advertises executable installation and shell-based usage, and its declared metadata requires command-line binaries, but it does not declare any explicit tool scope or permissions. In an agent ecosystem, this increases the attack surface because the skill can read environment data, access files, and invoke shell commands without a clear least-privilege boundary, making misuse or unexpected execution paths harder to control.

Content

No source excerpt is available for this finding.

Description-Behavior Mismatch

Medium
Category
Not specified by scanner
Confidence
90% confidence
Finding

The installer performs multiple network downloads and package installations, including bootstrapping pip, installing Python packages, and downloading ffmpeg binaries. While this is common installer behavior, it expands the trust boundary well beyond simple local video upscaling and introduces supply-chain risk if any remote source is compromised or tampered with.

Content

No source excerpt is available for this finding.

External Transmission

Medium
Category
Data Exfiltration
Confidence
84% confidence
Finding

The installer downloads a prebuilt static ffmpeg archive from an external website and installs executables from it without authenticity verification. Because ffmpeg will later process attacker-controlled media inputs, a compromised binary could yield arbitrary code execution or persistent system compromise.

Content

Scanner excerpt · install.sh (reported line 53)May include surrounding context.

sh
else
    echo "Downloading static ffmpeg..."
    tmp="$(mktemp -d)"
    curl -sSL https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-amd64-static.tar.xz -o "$tmp/ff.tar.xz"
    tar -xf "$tmp/ff.tar.xz" -C "$tmp/"
    cp "$tmp"/ffmpeg-*-amd64-static/ffmpeg "$DIR/bin/ffmpeg"
    cp "$tmp"/ffmpeg-*-amd64-static/ffprobe "$DIR/bin/ffprobe"

subprocess module call

Medium
Category
Dangerous Code Execution
Confidence
70% confidence
Finding

subprocess module calls execute external commands. Without careful input validation, this enables command injection.

Content

Scanner excerpt · sr_video_ov.py (reported line 56)May include surrounding context.

python
pass

    try:
        out = subprocess.check_output(["lscpu"], text=True, stderr=subprocess.DEVNULL)
        for line in out.splitlines():
            if line.startswith("Flags:") and ":" in line:
                flags.update(line.split(":", 1)[1].strip().split())

subprocess module call

Medium
Category
Dangerous Code Execution
Confidence
70% confidence
Finding

subprocess module calls execute external commands. Without careful input validation, this enables command injection.

Content

Scanner excerpt · sr_video_ov.py (reported line 109)May include surrounding context.

python
"-show_format",
        video_path,
    ]
    result = subprocess.run(cmd, capture_output=True, text=True)
    if result.returncode != 0:
        raise RuntimeError(f"ffprobe failed: {result.stderr}")

Description-Behavior Mismatch

Medium
Category
Not specified by scanner
Confidence
97% confidence
Finding

The manifest describes a skill that plans a Lanczos pre-scale plus N Real-ESRGAN x4 passes to reach arbitrary target resolutions, with super-resolution always last and a 270-line pre-scale floor. In this file, the CLI only accepts a single integer --scale (default 4), computes one output size as infer_w * scale and infer_h * scale, and runs one inference pass; there is no planning for multiple x4 passes, no arbitrary target-resolution solver, and no enforcement of a 270-line minimum pre-scale floor.

Content

No source excerpt is available for this finding.

subprocess module call

Medium
Category
Dangerous Code Execution
Confidence
81% confidence
Finding

This launches ffmpeg with arguments partly sourced from environment variables (preset and CRF) and sends attacker-influenced processing options into an external executable. Although shell injection is avoided by using an argument list, unvalidated environment-controlled ffmpeg options can still cause unsafe behavior, denial of service, or unexpected encoder/module selection depending on the deployed ffmpeg build and surrounding environment.

Content

Scanner excerpt · sr_video_ov.py (reported line 233)May include surrounding context.

python
"yuv420p",
            tmp_video,
        ]
        pipe = subprocess.Popen(ffmpeg_cmd, stdin=subprocess.PIPE, stderr=subprocess.DEVNULL)

        frame_idx = 0
        total_infer_time = 0.0

Tainted flow: 'ffmpeg_cmd' from os.environ.get (line 208, credential/environment) → subprocess.Popen (code execution)

Medium
Category
Data Flow
Confidence
88% confidence
Finding

Environment variables OV_REALX4_PRESET and OV_REALX4_CRF flow into ffmpeg_cmd and then into subprocess.Popen, giving the execution environment influence over an external media-processing invocation. Even without a shell, this is risky in agent or multi-tenant settings because hostile environment configuration can force pathological encoding behavior, resource exhaustion, or unexpected ffmpeg option values that alter processing semantics.

Content

Scanner excerpt · sr_video_ov.py (reported line 233)May include surrounding context.

python
"yuv420p",
            tmp_video,
        ]
        pipe = subprocess.Popen(ffmpeg_cmd, stdin=subprocess.PIPE, stderr=subprocess.DEVNULL)

        frame_idx = 0
        total_infer_time = 0.0

subprocess module call

Medium
Category
Dangerous Code Execution
Confidence
70% confidence
Finding

subprocess module calls execute external commands. Without careful input validation, this enables command injection.

Content

Scanner excerpt · sr_video_ov.py (reported line 309)May include surrounding context.

python
"-shortest",
                output_video,
            ]
            result = subprocess.run(merge_cmd, capture_output=True, text=True)
            if result.returncode != 0:
                print(f"Audio merge warning: {result.stderr}")
                shutil.copy2(tmp_video, output_video)

External Script Fetching

Low
Category
Supply Chain
Confidence
97% confidence
Finding

This line retrieves an external script and executes it immediately, which is a classic unsafe installation pattern. Even if the source is legitimate today, the pattern creates a direct remote-code-execution path at install time with no content validation.

Content

Scanner excerpt · install.sh (reported line 37)May include surrounding context.

sh
if ! python -m pip --version &>/dev/null; then
  echo "Bootstrapping pip..."
  curl -sSL https://bootstrap.pypa.io/get-pip.py | python
fi

python -m pip install --upgrade pip >/dev/null

Intent-Code Divergence

Low
Category
Not specified by scanner
Confidence
83% confidence
Finding

The ArgumentParser description and default model path explicitly describe 'Real-ESRGAN general-x4v3 video super-resolution (OpenVINO)' with a specific x4 model file. This contradicts the manifest's claim of a generic Xeon-CPU upscaler that plans combinations of Lanczos pre-scale and N x4 passes to reach any target resolution, because the embedded documentation presents a much narrower single-model, single-pass implementation.

Content

No source excerpt is available for this finding.