Back to skill

Security audit

Video Podcast Maker

Security checks across malware telemetry and agentic risk

Overview

This is a coherent video-generation skill, but users should understand that it writes local project files and can send scripts/topics to external research, asset, and TTS services.

Install only if you are comfortable with a coding agent writing video project files, running ffmpeg/npx/Remotion, and sending script or topic content to search, stock-asset, and TTS providers. Avoid confidential scripts unless you configure acceptable providers and review privacy terms; back up user_prefs.json before resetting preferences and keep dependencies updated.

SkillSpector

By NVIDIA
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
  • Output HandlingUnvalidated Output Injection, Cross-Context Output, Unbounded Output
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
Findings (20)

Lp3

Medium
Category
MCP Least Privilege
Confidence
95% confidence
Finding
The skill clearly instructs the agent to use shell, read and write files, inspect environment variables, and perform network-adjacent update checks, yet it declares no permissions boundary. That creates a trust and review gap: operators may approve or invoke the skill believing it is low-risk when it can modify project files, inspect secrets, and execute external tools.

Tp4

High
Category
MCP Tool Poisoning
Confidence
92% confidence
Finding
The public description understates the full operational behavior of the skill: beyond video generation, it manages assets, persists preferences, manipulates reference libraries, verifies and auto-fixes outputs, checks local tooling/env state, and performs git-based update checks. This mismatch can cause unsafe consent because users and policy systems may not realize the skill has broader filesystem, environment, and maintenance behaviors than advertised.

Context-Inappropriate Capability

Low
Confidence
89% confidence
Finding
The component explicitly allows `src` to be a full `http(s)` URL and then fetches it at render time, which introduces arbitrary outbound network access. In a video-generation skill, this can leak environment metadata such as IP address, enable dependency on untrusted third-party content, and make builds non-deterministic; while not immediately leading to code execution, it does expand the attack surface beyond local asset loading.

Vague Triggers

Medium
Confidence
84% confidence
Finding
The skill metadata and provided description define broad trigger conditions such as topic-driven narrated explainers, knowledge videos, and iterative rebuilds, which can cause the skill to activate outside a narrowly intended scope. Overbroad activation increases the chance of inappropriate tool use, prompt-routing mistakes, or unintended handling of user content in contexts that do not actually require this pipeline.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The documented reset flow overwrites the user's preferences file in place with a template, with no confirmation step, backup, or warning about irreversible loss of custom settings. In an agentic environment, this can lead to unintended destruction of user data if the command is triggered by ambiguous input or executed automatically.

Missing User Warnings

Medium
Confidence
92% confidence
Finding
The workflow instructs the agent to use web search and fetch capabilities without requiring a privacy notice or confirmation, which can transmit user-provided topics, reference material, or sensitive context to external services. In a content-production skill, users may include unreleased plans, proprietary product details, or private research goals, so silent outbound retrieval increases data exposure risk.

Missing User Warnings

Medium
Confidence
88% confidence
Finding
This backend sends user text, authentication material, and a user identifier to an external TTS API without any in-file indication of user consent, redaction, or privacy gating. In a video/podcast generation skill, users may submit proprietary scripts or sensitive drafts, so silent third-party transmission creates a real data exposure and compliance risk.

Missing User Warnings

Medium
Confidence
88% confidence
Finding
The backend sends text chunks to the Edge TTS service, which means potentially sensitive user content leaves the local environment. In a content-generation skill, scripts may contain proprietary, personal, or unpublished material, so undisclosed third-party transmission creates a real privacy and data-handling risk.

Missing User Warnings

Medium
Confidence
89% confidence
Finding
The function reads an API key from config and sends user-provided text chunks to ElevenLabs, an external third party, without any consent gate, redaction step, or policy enforcement in this code path. In a video/podcast skill, scripts may contain sensitive or proprietary content, so silent transmission creates a real privacy and data-governance risk.

Missing User Warnings

Medium
Confidence
84% confidence
Finding
The code sends chunk text to Google's Text-to-Speech API, which is an external third party, but this file contains no indication of consent, minimization, or disclosure controls. If users provide sensitive script content, that data leaves the local environment and may be logged, retained, or processed under external service policies.

External Transmission

Medium
Category
Data Exfiltration
Content
},
                }

                resp = requests.post(endpoint, headers=headers, json=payload, timeout=timeout_sec)
                resp.raise_for_status()
                data = resp.json()
Confidence
90% confidence
Finding
The code transmits chunk text and associated credentials to a remote service, which is expected for SaaS TTS but still constitutes real external data exfiltration from the local environment. In this skill context, scripts may contain confidential or unpublished content, making undisclosed transmission materially risky even if functionally intended.

External Transmission

Medium
Category
Data Exfiltration
Content
},
                }

                resp = requests.post(url, headers=headers, json=payload, timeout=120)
                resp.raise_for_status()
                data = resp.json()
Confidence
91% confidence
Finding
This POST sends chunk text and model/voice selections to an external API endpoint, which is a real data egress event. In the context of an automated content-generation skill, that may expose unpublished scripts, internal knowledge summaries, or other sensitive user material to a third-party service.

External Transmission

Medium
Category
Data Exfiltration
Content
success = False
        for attempt in range(1, 4):
            try:
                url = f"https://api.elevenlabs.io/v1/text-to-speech/{voice}/with-timestamps"
                payload = {
                    "text": chunk,
                    "model_id": model,
Confidence
87% confidence
Finding
The hardcoded ElevenLabs API endpoint indicates the backend is designed to transmit content off-box to a specific third-party service. That is not inherently malicious, but it is security-relevant because it creates an external data-sharing path for all synthesized text handled by this skill.

External Transmission

Medium
Category
Data Exfiltration
Content
},
                }

                resp = requests.post(url, json=payload, headers=headers, timeout=120)
                resp.raise_for_status()
                data = resp.json()
Confidence
90% confidence
Finding
This request transmits user-provided text content and an API key to an external Google endpoint, creating a real data egress boundary. In a video/podcast generation skill, scripts may contain proprietary, personal, or unpublished material, so undisclosed external transfer can expose sensitive information beyond the local system.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
1. Assets the user explicitly supplied or requested → always plan them.
2. Free sources (user files, assetSeeker stock, Iconify icons) → plan and
   resolve without asking. 2–4 well-placed assets beat wall-to-wall media;
   text-only sections remain perfectly valid.
3. Paid generation (imagenCN / videogenCN) → register as `planned` /
   `pending_confirmation` with a `--cost-estimate`; present the cost sheet and
Confidence
84% confidence
Finding
The instruction to 'plan and resolve without asking' allows the agent to autonomously fetch third-party assets based on inferred needs rather than explicit per-asset user approval. In context, this can lead to unintended network access, unexpected incorporation of external media, and potential mismatch with user expectations around privacy, provenance, or content appropriateness.

Unvalidated Output Injection

High
Category
Output Handling
Content
'--public-dir', output_dir,
    ]
    print(f"    Rendering: {' '.join(cmd)}")
    result = subprocess.run(cmd, capture_output=True, text=True)
    if result.returncode != 0:
        print(f"    Render failed: {result.stderr.strip()}", file=sys.stderr)
        return False
Confidence
64% confidence
Finding
While there is no classic shell injection, this code launches 'npx remotion render' on a user-influenced index path and composition ID within an automation skill that may process untrusted project directories. In this context, invoking a JS toolchain over attacker-controlled project files can execute arbitrary build-time code from the selected Remotion entrypoint or dependency scripts, turning the render step into code execution in the agent environment.

Unvalidated Output Injection

High
Category
Output Handling
Content
with open(tmp_file, 'wb') as f:
                    f.write(resp.content)

                result = subprocess.run(
                    ["ffmpeg", "-y", "-i", tmp_file, "-ar", "48000", "-ac", "1", part_file],
                    capture_output=True, text=True)
                if result.returncode != 0:
Confidence
72% confidence
Finding
The code writes untrusted audio bytes returned by a remote API directly to disk and immediately feeds them into ffmpeg, a complex native parser with a long history of memory-safety issues. Even though there is no shell injection, processing attacker-influenced media with external decoders can expose the host to parser exploits or denial-of-service if the upstream service, network path, or API credentials are compromised.

Unvalidated Output Injection

High
Category
Output Handling
Content
raise RuntimeError(f"FFmpeg normalize failed: {result.stderr}")
                os.remove(tmp_file)

                probe = subprocess.run(
                    ["ffprobe", "-v", "quiet", "-show_entries", "format=duration", "-of", "csv=p=0", part_file],
                    capture_output=True, text=True)
                chunk_duration = float(probe.stdout.strip()) if probe.stdout.strip() else 0
Confidence
69% confidence
Finding
This ffprobe invocation parses the generated audio file again, creating a second pass of native parsing on data that originated from an external service. In a video-generation skill that may process arbitrary user-supplied text at scale, repeatedly handling untrusted media increases exposure to parser bugs and potential crashes or sandbox escapes if the host is not isolated.

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 manifest includes zod 3.22.0, which is flagged for a denial-of-service advisory. If the skill uses Zod to validate attacker-controlled input, specially crafted payloads could trigger excessive processing or crash validation paths, which is more relevant here because this skill is topic-driven and likely accepts rich external input.

Known Vulnerable Dependency: requests==2.31.0 — 6 advisory(ies): CVE-2024-47081 (Requests vulnerable to .netrc credentials leak via malicious URLs); CVE-2024-35195 (Requests `Session` object does not verify requests after making first request wi); CVE-2026-25645 (Requests has Insecure Temp File Reuse in its extract_zipped_paths() utility func) +3 more

Medium
Category
Supply Chain
Confidence
91% confidence
Finding
The requirement allows installation of requests 2.31.0, a version with multiple published advisories, because the specifier `>=2.31.0,<3.0.0` does not exclude known vulnerable releases and can resolve to 2.31.0 in some environments. In a skill that performs network access for TTS and related services, dependency-level flaws in HTTP handling can affect credential exposure, TLS verification behavior, or other request-processing paths if vulnerable versions are installed and reachable in the code path.

VirusTotal

64/64 vendors flagged this skill as clean.

View on VirusTotal

Static analysis

No suspicious patterns detected.