Back to skill

Security audit

talking-head-recut

Security checks for vulnerabilities and agentic risk

Overview

The skill is mostly a coherent local video-overlay workflow, but it asks users to run a mutable self-update and unpinned npm CLI before use.

Install only if you are comfortable with HyperFrames/npm code running with your user permissions. Prefer reviewing and pinning a specific HyperFrames version, avoid the pre-run skill update during normal use, and run video processing in a constrained workspace with only the source media needed.

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

T08 · Insecure Dependencies

Warning
Location
SKILL.md:6
Finding
Unpinned npm Package Execution and Mutable Pre-Execution Skill Update## Vulnerability Details **File Location**: `SKILL.md`, lines 6, 41, 53, 100, 1176, 1196, and 1215 **Vulnerability Type**: Unpinned third-party dependency execution **Risk Level**: Medium ### Vulnerable Code ```markdown > **First, keep this skill fresh — confirm with the user before running:** `npx hyperframes skills update talking-head-recut`. ``` ```bash npx hyperframes --help npx hyperframes doctor npx hyperframes transcribe "$WORK_DIR/audio.mp3" -d "$WORK_DIR" --json --model small.en PRODUCER_BROWSER_GPU_MODE=hardware npx hyperframes render public \ --skill=talking-head-recut \ -o output.mp4 \ --fps 30 npx hyperframes snapshot public --at 5 (cd "$WORK_DIR/public" && npx hyperframes preview --background) ``` ### Technical Analysis The skill repeatedly invokes `hyperframes` through `npx` without specifying an exact package version, a lockfile-backed installation, or an integrity-verified local executable. Depending on the local npm configuration and package availability, `npx` can retrieve and execute package code from the npm registry at runtime. The effective executable may therefore change after this skill has been reviewed. The update instruction increases this risk because it directs the user to run `npx hyperframes skills update talking-head-recut` before relying on the skill. That operation can replace the audited skill and its dependent instructions with newer, unreviewed content. User confirmation reduces accidental execution but does not provide package authenticity, integrity, or reproducibility. No evidence shows that the current `hyperframes` package is malicious. The vulnerability is the unsafe, mutable dependency execution model and its resulting supply-chain exposure. ### Attack Path 1. An attacker compromises the `hyperframes` npm publication account, its dependency chain, or another relevant package-distribution component. 2. The attacker publishes a malicious package version ...[truncated 1421 chars]
Remediation
## Remediation Suggestions 1. Pin `hyperframes` to an exact, reviewed version rather than invoking an unversioned package: ```json { "devDependencies": { "hyperframes": "X.Y.Z" } } ``` 2. Commit the generated lockfile and use a deterministic installation process: ```bash npm ci --ignore-scripts ``` 3. Review whether the dependency requires lifecycle scripts. If required, enable them only after reviewing the package and its transitive dependencies. 4. Invoke the lockfile-installed executable instead of allowing `npx` to resolve a mutable remote version: ```bash ./node_modules/.bin/hyperframes doctor ./node_modules/.bin/hyperframes transcribe ... ./node_modules/.bin/hyperframes render ... ``` 5. Verify registry provenance and package integrity in CI. Use dependency allowlists, package hashes, signed provenance where available, and automated supply-chain scanning. 6. Remove the pre-execution update instruction from the normal workflow. Perform skill updates as a separate administrative operation with explicit version review and approval. 7. Re-audit the skill and its dependent instructions after every update. Do not treat updated content as covered by an audit of the previous version. 8. Run video processing in a restricted environment with minimum filesystem access, sanitized environment variables, and constrained outbound network access.
Vulnerability Patterns
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
Findings (1)

Context-Inappropriate Capability

Medium
Confidence
94% confidence
Finding
The skill instructs the agent to run `npx hyperframes skills update talking-head-recut` before execution, which causes network/package update behavior outside the core local-media processing task. Allowing a skill to self-update at runtime expands the trust boundary to whatever the package registry or update source currently serves, creating supply-chain and reproducibility risks.

Static analysis

No suspicious patterns detected.