Back to skill

Security audit

Hyperframes Video Studio

Security checks for vulnerabilities and agentic risk

Overview

The skill is a coherent video-generation tool, but it has enough under-disclosed file, network, and dependency risks that users should review it carefully before installing.

Install only if you are comfortable with this skill reading user-selected files and storing excerpts and absolute paths in its cache/project files. Avoid pointing it at broad or sensitive folders, prefer local Piper over Edge-TTS for confidential narration, keep TTS outputs under .cache, and do not share generated HTML/project directories without reviewing them. The npm install and CDN-loaded GSAP are not proven malicious, but they are third-party code paths without strong pinning.

Vulnerability Patterns
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • 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)

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/video_engine.py:420
Finding

CSS Injection Through Unvalidated Style Values

Content
View full analysis
str: return str(value if value is not None else "").replace("\\", "\\\\").replace('"', '\\"') ``` ```python def _layout_css(layout: str, width: int, height: int, font: str) -> str: """Return layout-specific CSS.""" common = f''' * {{ box-sizing: border-box; margin: 0; }} html, body {{ width: 100%; height: 100%; overflow: hidden; background: var(--bg); color: var(--fg); font-family: {font}, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }} ``` ```python palette = list((project.get("style") or {}).get("palette") or ["#0B0F19", "#F8FAFC", "#22D3EE", "#A3E635"]) while len(palette) < 4: palette.append(palette[-1]) font = str((project.get("style") or {}).get("font") or "Inter") ``` ```python :root {{ --w: {width}px; --h: {height}px; --duration: {duration:.3f}s; --bg: {_css_string(palette[0])}; --fg: {_css_string(palette[1])}; --accent: {_css_string(palette[2])}; --accent-2: {_css_string(palette[3])}; }} ``` ### Technical Analysis The request schema describes palette entries as hexadecimal colors and the font as a CSS font-family name, but the implementation does not enforce either constraint. The `font` value is inserted directly into a generated stylesheet. Palette values are passed through `_css_string()`, which only escapes backslashes and double quotes. It does not neutralize CSS delimiters such as semicolons, braces, comments, or `url(...)`. Consequently, an attacker who can control the video request may terminate the intended CSS declaration and inject additional stylesheet rules. Injected CSS can alter the generated project, hide or falsify disp ...[truncated 1596 chars]
Remediation
View remediation
str: if not HEX_COLOR.fullmatch(value): raise ValueError("Palette entries must be six- or eight-digit hexadecimal colors.") return value ``` 2. Restrict fonts to a predefined allowlist of supported system fonts. If arbitrary family names are required, permit only a conservative character set and emit the name as a properly quoted CSS string. 3. Reject style values containing braces, semicolons, comments, control characters, `url`, `@import`, or other CSS constructs. 4. Do not rely on generic string replacement for CSS safety. Use context-specific validation and serialization. 5. Add tests using malicious values such as declaration terminators, braces, comments, `url(...)`, and `@import` to ensure they are rejected before HTML generation. 6. Consider applying a restrictive Content Security Policy to generated projects, such as blocking remote image, font, media, and style sources unless explicitly needed. ]]>

T05 · Unauthorized Access and Privilege Escalation

Warning
Location
scripts/tts_handler.py:221
Finding

TTS Output Path Is Not Confined to the Skill Cache

Content
View full analysis
Remediation
View remediation

T08 · Insecure Dependencies

Warning
Location
scripts/install_hyperframes.py:69
Finding

Third-Party Code Is Installed and Loaded Without Integrity Pinning

Content
View full analysis
``` ### Technical Analysis The npm command resolves the current package version and dependency graph at installation time. The repository does not supply a lockfile or integrity requirement for this installation path. npm lifecycle scripts may execute during installation unless explicitly disabled. The generated HTML pins a GSAP version in the URL, but it does not provide an SRI hash. Therefore, the executable response is trusted based on the CDN and transport channel at the time the project is loaded. This also contradicts the Skill's local-first positioning because previews and renders depend on network-hosted code. User confirmation before npm installation is a useful consent control, but it does not protect against compromised package releases, dependency-chain attacks, registry account compromise, or altered CDN content. ### Attack Path #### npm installation path 1. The user approves local Hyperframes installation. 2. The Skill executes `npm install --prefix ... hyperframes`. 3. npm resolves the package and transitive dependencies available at that time. 4. A compromised package, dependency, or lifecycle script is downloaded. 5. npm executes applicable installation scripts with the privileges of the Agent account. 6. Malicious dependency code ...[truncated 1298 chars]
Remediation
View remediation
", ] ``` 2. Maintain and distribute an audited lockfile. Prefer a reproducible installation method such as `npm ci` against that lockfile. 3. Verify expected package and lockfile integrity before execution. 4. Evaluate whether Hyperframes and its dependencies require lifecycle scripts. If they do not, install using `--ignore-scripts`. If scripts are necessary, audit them and document the reason. 5. Bundle a reviewed GSAP artifact within the Skill cache or generated project instead of loading it at runtime. 6. If a CDN must remain, specify a fixed Subresource Integrity hash and `crossorigin="anonymous"`: ```html ``` 7. Add a restrictive Content Security Policy that permits scripts only from approved local files or explicitly trusted, integrity-protected sources. 8. Record dependency versions in generated project metadata so renders are reproducible and auditable. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • Behavioral ASTexec() Call, eval() Call, Dynamic Import
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
Findings (16)

Vague Triggers

Medium
Category
Not specified by scanner
Confidence
96% confidence
Finding

The trigger conditions include broad, natural-language phrases such as requests to create a video or make a promo, which are likely to overlap with ordinary user prompts unrelated to this specific skill. That can cause unintended skill activation, leading the agent to ingest files, run local scripts, or initiate installation/render workflows in contexts where the user did not clearly intend to invoke this skill.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
93% confidence
Finding

The script ingests attacker- or user-specified paths, recursively reads local files, extracts text from supported formats, computes hashes, and writes a manifest containing absolute paths and content excerpts. In an agent/skill context, this can expose sensitive local data from arbitrary directories without any access restrictions, path allowlisting, consent gate, or minimization, making it a genuine data exfiltration/privacy risk.

Content

No source excerpt is available for this finding.

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 · scripts/install_hyperframes.py (reported line 72)May include surrounding context.

python
NPM_PREFIX.mkdir(parents=True, exist_ok=True)
    command = ["npm", "install", "--prefix", str(NPM_PREFIX), "hyperframes"]
    try:
        completed = subprocess.run(command, check=True, capture_output=True, text=True)
    except subprocess.CalledProcessError as exc:
        return {
            "status": "install_failed",

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 · scripts/system_audit.py (reported line 39)May include surrounding context.

python
def _run_text(command: list[str]) -> str:
    try:
        return subprocess.check_output(command, text=True, stderr=subprocess.DEVNULL, timeout=2).strip()
    except Exception:
        return ""

Intent-Code Divergence

Medium
Category
Not specified by scanner
Confidence
88% confidence
Finding

The top-level docstring frames the module as a generic 'Free TTS router', but the implementation explicitly falls back to edge-tts and even advertises 'zero-cost keyless TTS'. That means the skill is not just routing among local engines; it can send user text to an external service, which is a materially different behavior from a reader's likely interpretation of the documentation.

Content

No source excerpt is available for this finding.

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 · scripts/tts_handler.py (reported line 56)May include surrounding context.

python
str(path),
    ]
    try:
        output = subprocess.check_output(command, text=True).strip()
        return float(output)
    except Exception:
        return _wav_duration(path)

Dynamic import via __import__()

Medium
Category
Dangerous Code Execution
Confidence
75% confidence
Finding

Dynamic import() can load arbitrary modules at runtime, bypassing static analysis and potentially importing malicious code.

Content

Scanner excerpt · scripts/tts_handler.py (reported line 105)May include surrounding context.

python
def _python_module_available(name: str) -> bool:
    try:
        __import__(name)
        return True
    except Exception:
        return False

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 · scripts/tts_handler.py (reported line 128)May include surrounding context.

python
command = [piper_bin, "--model", model, "--output_file", str(output)]
    try:
        subprocess.run(command, input=text, text=True, check=True, capture_output=True)
    except subprocess.CalledProcessError as exc:
        return {
            "status": "tts_failed",

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
95% confidence
Finding

When edge-tts is selected, the provided text is sent to an external network-backed service without any explicit consent, warning, or policy gate. If users pass sensitive scripts, secrets, internal content, or regulated data, this can cause unintended data disclosure outside the local environment.

Content

No source excerpt is available for this finding.

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 · scripts/tts_handler.py (reported line 164)May include surrounding context.

python
str(subtitle_path),
        ]
        try:
            subprocess.run(command, check=True, capture_output=True, text=True)
        except subprocess.CalledProcessError as exc:
            return {
                "status": "tts_failed",

Intent-Code Divergence

Medium
Category
Not specified by scanner
Confidence
98% confidence
Finding

The generated HTML embeds the entire project object in a script tag and includes absolute local asset paths in both the project JSON and asset metadata. If that HTML is shared, hosted, or inspected by another tool, it can disclose filesystem structure, source material excerpts, manifest summaries, and potentially base64-embedded local content that users may not realize is being packaged into the output.

Content

No source excerpt is available for this finding.

Natural-Language Policy Violations

Medium
Category
Not specified by scanner
Confidence
97% confidence
Finding

The generated document sets <html lang="en">, which forces an English locale in output even though the file contains explicit support for multiple scripts and languages elsewhere. There is no user opt-in or region-specific justification for this language choice, so it conflicts with the language/locale policy rule.

Content

No source excerpt is available for this finding.

Context-Inappropriate Capability

Medium
Category
Not specified by scanner
Confidence
97% confidence
Finding

The generated local HTML loads GSAP from a third-party CDN at render/view time, creating a supply-chain and privacy risk. Opening the file can trigger outbound network access, leak usage metadata/IP information, and execute whatever script the CDN serves or an on-path attacker can influence in a compromised environment.

Content

No source excerpt is available for this finding.

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 · scripts/video_engine.py (reported line 913)May include surrounding context.

python
str(path),
    ]
    try:
        return float(subprocess.check_output(command, text=True).strip())
    except Exception:
        return _wav_duration(path)

Scope Creep

Low
Category
Excessive Agency
Confidence
70% confidence
Finding

Skill's behavior or capabilities extend beyond its stated purpose. Scope creep allows an agent to perform actions unrelated to its documented functionality, increasing the attack surface.

Content

Scanner excerpt · LICENSE.txt (reported line 12)May include surrounding context.

text
permit persons to whom the Software is furnished to do so.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

Natural-Language Policy Violations

Low
Category
Not specified by scanner
Confidence
92% confidence
Finding

When no voice is supplied, the code hard-codes "en-US-JennyNeural" as the selected voice. This imposes a specific language/locale by default rather than offering a neutral choice or requiring explicit user selection.

Content

No source excerpt is available for this finding.

Static analysis

No suspicious patterns detected.