T09 · Insecure Skill Coding Practices
- Location
config.example.json:2- Finding
Plaintext HTTP Configuration Permits Exposure of Sensitive Video Data and API Credentials
- Content
View full analysis
- Remediation
View remediation
Security audit
Security checks for vulnerabilities and agentic risk
The skill mostly matches its video-processing purpose, but its deployment examples can expose unauthenticated model services and send sensitive video data over plaintext HTTP.
Install only if you are comfortable processing the video through the configured AI endpoints. Before running the Docker model stack, bind ports to localhost or put the services behind authentication, TLS, firewall rules, and rate limits. Prefer HTTPS for any non-local provider, never send API keys over plaintext HTTP, and avoid processing private or regulated videos unless the provider and retention controls are acceptable.
config.example.json:2Plaintext HTTP Configuration Permits Exposure of Sensitive Video Data and API Credentials
deploy/docker-compose.models.yml:21Unauthenticated Model Services Are Published on All Host Network Interfaces
The documented purpose focuses on video processing, but the behavior reportedly includes bootstrap/setup and downloading models into local storage. Hidden or under-disclosed side effects are dangerous because users may invoke the skill expecting only local pipeline execution while it performs network retrievals and persistent filesystem changes, which broadens supply-chain and integrity risk.
The documented purpose focuses on video processing, but the behavior reportedly includes bootstrap/setup and downloading models into local storage. Hidden or under-disclosed side effects are dangerous because users may invoke the skill expecting only local pipeline execution while it performs network retrievals and persistent filesystem changes, which broadens supply-chain and integrity risk.
The documented purpose focuses on video processing, but the behavior reportedly includes bootstrap/setup and downloading models into local storage. Hidden or under-disclosed side effects are dangerous because users may invoke the skill expecting only local pipeline execution while it performs network retrievals and persistent filesystem changes, which broadens supply-chain and integrity risk.
The function builds user_parts from the text prompt plus image URLs and sends them via agent.run_sync(user_parts) to the model provider. Because this may expose image-linked content or metadata to a remote service, the lack of any warning, confirmation, or explanatory comment is a safety-relevant omission.
The README instructs users to send video-derived data, transcripts, frames, and enrichment inputs to external or self-hosted AI endpoints, but it does not warn that these artifacts may contain sensitive personal, proprietary, or regulated information. In this skill context, the pipeline explicitly processes narrated videos and extracted frames, which increases the likelihood of transmitting confidential content off-host without informed user consent or appropriate handling controls.
The skill declares executable behavior that uses shell commands, filesystem access, environment-dependent configuration, and network connectivity, but it does not declare any explicit tool scope or permissions boundary. That makes the skill harder to sandbox and review, and increases the chance it will be invoked with broader capabilities than necessary, especially because it runs setup, validation, and provider connectivity commands.
The invocation description is broad enough to match generic requests like debugging connectivity or generating markdown, which may cause the skill to be selected outside its intended narrow context. Over-broad routing increases the likelihood of unnecessary shell, file, or network-capable execution in response to ambiguous prompts, expanding attack surface and enabling prompt-triggered overreach.
The manifest describes a skill for processing narrated videos into structured step data, debugging provider connectivity, and generating markdown from extracted skills. This script instead provisions local AI model assets by downloading multiple large models from Hugging Face, which is an environment setup operation rather than part of the user-facing video-processing pipeline described in the manifest.
This code invokes an external OpenAI-compatible model with agent.run_sync(user_prompt), which transmits user-supplied content to a remote provider. The file contains retry/error handling but no confirmation prompt, print/log disclosure, or comment/docstring warning that user data may be sent off-box.
The code unconditionally passes -y to ffmpeg and writes predictable filenames like step_<segment_id>.mp4 into the output directory, causing silent overwrite of existing files. If segment IDs or output directories collide with prior runs or important user data, this can destroy or replace artifacts without warning, which is especially relevant in an automated video-processing skill that routinely writes files to disk.
_data_url_for_image reads arbitrary local image paths and base64-encodes them for later inclusion in provider requests. While this is expected functionality for a VLM pipeline, it becomes a real security/privacy issue because local files are transformed for outbound transmission with no validation that the files are safe to export and no user-facing warning that local content may be disclosed externally.
The code sends image contents to external model providers via run_structured_with_images, and those images are constructed from local frame files without any consent, disclosure, or data-classification gate in this module. In a video-processing skill, frames may contain sensitive personal, proprietary, or on-screen credential data, so silent transmission to third-party AI services creates a real privacy and data-governance risk.
The code serializes transcript chunk content, including raw text, and sends it to an external AI provider via run_structured without any evidence in this file of consent, minimization, redaction, or provider-boundary checks. Because transcripts can contain sensitive spoken data, this creates a real data-exposure/privacy risk if users are unaware their content is being transmitted off-box to a third party.
subprocess module calls execute external commands. Without careful input validation, this enables command injection.
"2",
str(out_path),
]
subprocess.run(cmd, check=True, capture_output=True, text=True)
frame_paths.append(str(out_path))
rows.append(
subprocess module calls execute external commands. Without careful input validation, this enables command injection.
"2",
str(out_path),
]
subprocess.run(cmd, check=True, capture_output=True, text=True)
frame_paths.append(str(out_path))
rows.append(
This code constructs a remote transcription endpoint and uploads the local video file via an HTTP POST request. The file contains no confirmation prompt, print/log disclosure, or comment/docstring warning that user media will be transmitted off-box, which is a safety-relevant behavior for code files.
The document explicitly recommends optional AI-generated asset creation and asynchronous asset generation in the pipeline, but it does not require disclosure, consent, or data-minimization controls before sending project-derived prompts, transcripts, frames, or brand data to external AI providers. In a video-processing workflow, those inputs can contain proprietary footage, sensitive narration, internal process details, or customer information, so omission of privacy and data-sharing safeguards creates a real risk of unintended third-party disclosure.
Dependency has known vulnerabilities (CVEs). Using packages with unpatched security flaws exposes the environment to known exploits.
The project depends on pydantic-ai without an upper bound or lockfile, and the package has multiple SSRF-related advisories. Given this skill processes videos and may interact with provider connectivity or remote resources, an unpinned install could resolve to a vulnerable version and expose internal network access or cloud metadata endpoints if any URL-fetching features are used.
Dependency has known vulnerabilities (CVEs). Using packages with unpatched security flaws exposes the environment to known exploits.
The comment says the script bootstraps model directories for "course-step-extractor," while the manifest identifies this skill as "video-skill." This creates intent ambiguity in the documentation and suggests the file may have been repurposed without aligning its inline documentation to the current skill identity.
write_enriched_steps_jsonl creates parent directories and writes output JSONL to disk, which is a filesystem-modifying operation. In this file there is no confirmation, logging, or explanatory comment/docstring indicating that the skill will create directories and overwrite/write output content.
The function creates parent directories and writes JSONL output to the provided path, which can modify the filesystem. In this file there is no confirmation prompt, user-facing log/print, or explanatory comment/docstring disclosing that behavior.
The function creates parent directories and writes JSONL output to the provided path, which modifies the filesystem. In this file there is no confirmation prompt, logging, print statement, or explanatory comment/docstring disclosing that behavior to the user.
This code creates directories and writes extracted JPEG frames and a JSONL manifest to disk, but there is no confirmation prompt, logging, comment, or docstring disclosing that filesystem changes will occur. For a code-file review under this rule, file writes should have some visible warning or explanation unless the behavior is explicitly documented elsewhere.