Back to skill

Security audit

remotion-to-hyperframes

Security checks for vulnerabilities and agentic risk

Overview

The skill mostly matches its stated conversion purpose, but it asks the agent to run mutable update and package commands that can change installed skill instructions or pull unpinned code before use.

Install only if you are comfortable reviewing and approving the update/render commands yourself. Prefer pinning the HyperFrames CLI, reviewing skill updates before activation, running npm/render work in a sandbox without secrets, and avoiding the bundled test corpus until its dependencies and CDN assets are locked or vendored.

Vulnerability Patterns
  • 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
  • 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 (2)

T08 · Insecure Dependencies

Warning
Location
SKILL.md:6
Finding
Unpinned HyperFrames CLI and Mutable Skill Update Supply Chain<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:6`, `SKILL.md:70`, `references/transitions.md:69` **Vulnerability Type**: Unpinned external CLI and mutable Skill retrieval **Risk Level**: Medium ### Vulnerable Code ```markdown > **First, keep this skill fresh — confirm with the user before running:** `npx hyperframes skills update remotion-to-hyperframes`. A fast no-op when everything is current; otherwise it refreshes this skill plus the core domain skills it depends on before you rely on them. ``` Additional unpinned commands include: ```markdown npx hyperframes catalog --query "<the effect, in plain English>" --json npx hyperframes add sdf-iris ``` ### Technical Analysis The Skill instructs the agent to invoke `npx hyperframes` without an exact package version or a requirement that the package already be installed from a reviewed lockfile. If the package is unavailable locally, `npx` may retrieve the currently published package from the configured npm registry and execute its CLI with the invoking user's privileges. The update command is particularly sensitive because it replaces the Skill and its dependent instructions before the agent relies on them. User confirmation makes the network operation visible, but it does not authenticate the downloaded content, verify its integrity, or present the changes for review. Consequently, the effective executable code and Skill instructions can change after this project has been audited. Relevant compromise scenarios include: - Compromise of the package publisher or npm account. - Publication of a malicious release under the legitimate package name. - Registry or configuration redirection to an untrusted source. - Compromise of the hosted Skill or catalog content. - A malicious catalog component returned by an otherwise legitimate CLI. ### Attack Path 1. An attacker compromises the `hyperframes` package publication channel, hosted Skill content, or a configured npm registry. 2. The attacker ...[truncated 1159 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin the HyperFrames CLI to an exact reviewed version, for example: ```bash npx --yes hyperframes@0.4.15 skills update remotion-to-hyperframes ``` 2. Prefer installing the pinned CLI through a committed lockfile and invoke it with: ```bash npx --no-install hyperframes ... ``` 3. Require signed releases or published checksums and verify downloaded Skill bundles before loading them. 4. Download updates into a staging directory instead of overwriting the active Skill immediately. 5. Present and review a diff of changed Skill instructions and scripts before activation. 6. Pin catalog components to immutable versions or content digests. 7. Run update and catalog commands in a sandbox with restricted filesystem access, a minimized environment, and limited network permissions. ]]>

T08 · Insecure Dependencies

Warning
Location
assets/test-corpus/run.sh:129
Finding
Non-Reproducible npm Installation and Unverified CDN Runtime Dependencies<![CDATA[ ## Vulnerability Details **File Location**: `assets/test-corpus/run.sh:129-135`; package manifests under `assets/test-corpus/tier-1-title-card/remotion-src/package.json:8-12`, `tier-2-multi-scene/remotion-src/package.json:8-12`, and `tier-3-data-driven/remotion-src/package.json:8-13`; HTML fixtures at line 6; `references/lottie.md:27,60` **Vulnerability Type**: Unlocked packages and browser dependencies without integrity verification **Risk Level**: Medium ### Vulnerable Code The test orchestrator installs dependencies without a lockfile-enforced installation: ```bash if [[ ! -d "$fixture_dir/remotion-src/node_modules" ]]; then echo " ⏳ npm install (first run)" (cd "$fixture_dir/remotion-src" && npm install --silent --no-progress >/dev/null 2>&1) fi echo " ⏳ render Remotion baseline" if ! (cd "$fixture_dir/remotion-src" && \ npx --no-install remotion render "$composition_id" out/baseline.mp4 >/dev/null 2>&1); then ``` The manifests use version ranges rather than exact versions. For example: ```json "dependencies": { "@remotion/cli": "^4.0.0", "react": "^18.3.1", "react-dom": "^18.3.1", "remotion": "^4.0.0" } ``` Tier 3 additionally includes: ```json "zod": "^3.22.0" ``` The generated HTML fixtures load GSAP from a CDN without Subresource Integrity: ```html <script src="https://cdnjs.cloudflare.com/ajax/libs/gsap/3.12.5/gsap.min.js"></script> ``` The Lottie guidance also includes externally hosted scripts, including an unversioned URL: ```html <script src="https://cdnjs.cloudflare.com/ajax/libs/bodymovin/5.12.2/lottie.min.js"></script> <script src="https://unpkg.com/@lottiefiles/dotlottie-web"></script> ``` ### Technical Analysis No package lockfiles were present in the audited directory structure. Running `npm install` against caret ranges allows dependency resolution to change over time. npm installation also permits dependency lifecycle scripts by default, so a compromised direct or transitive package can execu ...[truncated 2309 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Generate and commit a lockfile for every Remotion fixture. 2. Replace `npm install` with a frozen installation: ```bash npm ci --ignore-scripts ``` If lifecycle scripts are required, explicitly document and review them before removing `--ignore-scripts`. 3. Pin direct dependencies to exact versions rather than caret ranges. 4. Configure npm to use an approved registry and verify lockfile integrity metadata in CI. 5. Use dependency provenance, signature, and vulnerability checks where available. 6. Self-host reviewed GSAP and Lottie assets alongside the generated HTML. 7. If CDN delivery is required, pin exact versions and add SRI: ```html <script src="https://trusted.example/library.min.js" integrity="sha384-REVIEWED_HASH" crossorigin="anonymous"> </script> ``` 8. Replace the unversioned `https://unpkg.com/@lottiefiles/dotlottie-web` reference with an exact version and integrity-protected asset. 9. Apply a restrictive Content Security Policy to generated pages, limiting script sources and unnecessary outbound connections. 10. Run dependency installation and rendering in an isolated container with no secrets, read-only source mounts where practical, and constrained network access. ]]>
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
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
Findings (9)

Lp3

Medium
Category
MCP Least Privilege
Confidence
95% confidence
Finding
The skill instructs the agent to run shell commands, read and write project files, and potentially access environment context, but it declares no permissions or capability boundaries. This creates a trust and review gap: a caller may believe the skill is documentation-only while it can actually execute commands and modify local workspace state.

Tp4

High
Category
MCP Tool Poisoning
Confidence
91% confidence
Finding
The stated purpose is source conversion, but the skill also performs substantial auxiliary behavior: updating dependencies, running lint and test harnesses, rendering media, computing diffs, and generating artifacts. This mismatch can lead operators to invoke the skill under a narrower trust assumption than its actual behavior, increasing the risk of unexpected command execution, resource consumption, and file modifications.

Context-Inappropriate Capability

Medium
Confidence
88% confidence
Finding
The HTML imports GSAP from a public CDN, introducing a network-fetched third-party dependency into what should be a self-contained Remotion-to-HyperFrames translation artifact. This creates supply-chain and integrity risk: if the CDN asset is unavailable, tampered with, or blocked, the rendered output can fail or execute unexpected code in the consumer environment.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
The code sends user-provided text to an external service as part of a fetch URL, which can expose potentially sensitive input to a third party without any visible disclosure or consent mechanism. In this skill context, the request occurs during metadata calculation, making the transmission implicit and harder for users to anticipate.

External Transmission

Medium
Category
Data Exfiltration
Content
export const calculateMetadata = async ({ props }: { props: Props }) => {
  const response = await fetch(
    `https://api.example.com/duration?text=${encodeURIComponent(props.text)}`,
  );
  const { durationInFrames } = await response.json();
  return {
Confidence
88% confidence
Finding
This code performs an external network request to api.example.com during calculateMetadata, causing composition data derived from user input to leave the local environment. In the context of a conversion skill, unexpected outbound requests are more dangerous because metadata resolution is supposed to be deterministic up front, and remote dependencies can leak data and undermine safe, reproducible conversion.

Known Vulnerable Dependency: remotion==4.0.0 — 2 advisory(ies): CVE-2026-30120 (Remotion: remote code execution (RCE) vulnerability); CVE-2026-30121 (Remotion: arbitrary file write vulnerability)

Critical
Category
Supply Chain
Confidence
98% confidence
Finding
This manifest includes remotion 4.0.0, which the finding states is affected by RCE and arbitrary file write advisories. In a video rendering skill, dependencies may process project content and execute rendering-related code paths, so a compromised or vulnerable package could enable host compromise or filesystem manipulation during normal development or rendering workflows.

Known Vulnerable Dependency: remotion==4.0.0 — 2 advisory(ies): CVE-2026-30120 (Remotion: remote code execution (RCE) vulnerability); CVE-2026-30121 (Remotion: arbitrary file write vulnerability)

Critical
Category
Supply Chain
Confidence
97% confidence
Finding
The package declares remotion ^4.0.0, and the finding states remotion 4.0.0 is affected by critical issues including remote code execution and arbitrary file write. In a video-rendering skill context, tooling often processes project content and executes rendering workflows, so a vulnerable rendering dependency could be especially dangerous if untrusted inputs or automated render jobs are involved.

Known Vulnerable Dependency: remotion==4.0.0 — 2 advisory(ies): CVE-2026-30120 (Remotion: remote code execution (RCE) vulnerability); CVE-2026-30121 (Remotion: arbitrary file write vulnerability)

Critical
Category
Supply Chain
Confidence
98% confidence
Finding
This project depends on remotion 4.0.0, which is flagged with advisory-backed critical issues including remote code execution and arbitrary file write. In this skill context, Remotion is actively used by the render script, so a vulnerable package is especially dangerous because rendering workflows often process project code and media inputs, increasing the chance of exploit during normal use.

Known Vulnerable Dependency: zod==3.22.0 — 1 advisory(ies): CVE-2023-4316 (Zod denial of service vulnerability)

Low
Category
Supply Chain
Confidence
91% confidence
Finding
The dependency list includes zod 3.22.0, which is reported as affected by a denial-of-service vulnerability. If this package is used to validate attacker-controlled or untrusted input, crafted payloads could consume excessive resources and disrupt rendering or related processing.

Static analysis

No suspicious patterns detected.