Back to skill

Security audit

Seedance 2.5 爆款视频复刻 | LinkPix

Security checks for vulnerabilities and agentic risk

Overview

This is a coherent Qinghu video-generation skill, but it needs Review because it asks users to send an API key in chat and directs agents to run mutable package installs.

Review before installing. Do not paste a Qinghu API key into chat; configure it yourself through a local environment variable or secure secret mechanism, and rotate the key if it was shared. Only proceed if you are comfortable with the agent installing or upgrading qhkit and helper packages, processing local media files, uploading media to the Qinghu service, and submitting paid jobs after explicit confirmation.

Vulnerability Patterns
  • 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
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
Findings (2)

T08 · Insecure Dependencies

Warning
Location
SKILL.md:52
Finding
Unpinned Third-Party Packages Are Installed and Executed at Runtime<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:52-55`, `SKILL.md:78`, and `SKILL.md:91` **Vulnerability Type**: Supply-chain exposure through mutable, unpinned dependencies **Risk Level**: Medium ### Complete Code Snippets ```bash npm i -g @iqinghu/qhkit ``` ```bash npm i -g @iqinghu/qhkit@latest ``` ```bash pip install pillow -i https://pypi.tuna.tsinghua.edu.cn/simple ``` ```bash npx --yes sharp-cli -i ORIGINAL_IMAGE -o COMPRESSED_IMAGE.jpg resize 2048 ``` The instructions also permit npm registry fallback to: ```bash --registry=https://registry.npmmirror.com ``` ### Technical Analysis The Skill directs the Agent to install or immediately execute third-party packages without pinning exact versions or verifying package integrity. The `@latest` selector deliberately resolves to mutable code that may differ from what was present when the Skill was audited. The unversioned `@iqinghu/qhkit`, `pillow`, and `sharp-cli` dependencies have the same general issue. In particular, `npx --yes sharp-cli` downloads and executes package code without an interactive review step. Using multiple registries and mirrors also expands the supply-chain trust boundary. A compromised publisher account, malicious release, registry compromise, dependency takeover, or compromised transitive dependency could introduce arbitrary executable code. This is necessary only to the extent that the declared functionality requires the `qhkit` client and optional media-processing tools. Installing mutable packages globally or executing them through unattended `npx`, however, exceeds the safest minimum-privilege implementation. ### Attack Path 1. An attacker compromises a package publisher, release process, registry, mirror, or transitive dependency. 2. The attacker publishes malicious code under a version selected by an unpinned install command or by the `latest` tag. 3. The Agent follows the Skill instructions and runs `npm`, `pip`, or `npx`. 4. Package installation hoo ...[truncated 974 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin every dependency to a reviewed exact version rather than using unversioned packages or `@latest`. 2. Record and verify package integrity hashes through a lockfile or equivalent trusted manifest. 3. Remove `npx --yes`; install a reviewed, pinned version in advance and invoke its fixed local binary. 4. Avoid global package installation. Use a dedicated, unprivileged project directory, container, or virtual environment. 5. Require explicit user approval before installing or upgrading executable dependencies. 6. Restrict package installation scripts where feasible, such as by auditing lifecycle scripts before allowing them to run. 7. Use one approved registry and document its trust model. Do not silently switch to alternate mirrors. 8. Run media-processing tools with access limited to only the required input and output files. 9. Maintain and periodically review a software bill of materials for direct and transitive dependencies. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:67
Finding
API Credential Is Requested Through Chat and Passed in a Command-Line Argument<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:67-72` **Vulnerability Type**: Insecure secret collection and command-line credential exposure **Risk Level**: Medium ### Complete Code Snippet The instructions direct the user to generate or copy an API key, send that API key to the Agent, and then configure it using: ```bash qhkit config set --token <KEY> --env prod ``` They also identify the following environment-variable alternative: ```bash QHKIT_TOKEN ``` ### Technical Analysis The workflow asks the user to disclose an API credential through the conversation and then places the credential directly in a command-line argument. Secrets sent through chat may be retained in conversation history, Agent traces, tool logs, monitoring systems, or debugging records. Secrets supplied as command arguments may additionally be exposed through shell history, process inspection, audit logging, terminal capture, or error reporting. Although the Skill needs authentication to use the declared remote service, receiving the raw credential in the Agent conversation is not necessary. Authentication can be configured directly by the user through a protected secret store, hidden prompt, or permission-restricted environment injection. ### Attack Path 1. The user follows the Skill instructions and sends the Qinghu API key in the conversation. 2. The key becomes part of chat history or Agent execution traces. 3. The Agent invokes `qhkit config set` with the key in the command arguments. 4. The key may also be recorded in process information, shell history, command telemetry, or logs. 5. A person or process with access to any retained record obtains the credential. 6. The exposed key is used to access the associated Qinghu account or submit paid API tasks. ### Impact Assessment Credential exposure could allow unauthorized use of the Qinghu API within the permissions assigned to the leaked key. Potential impact includes: - Consumption of the user's paid cred ...[truncated 392 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Do not ask users to send API keys through the conversation. 2. Direct users to configure the credential themselves through a hidden-input command or an approved secret manager. 3. Avoid passing secrets in command-line arguments. Prefer protected environment injection, standard input without echo, or an operating-system credential store. 4. Ensure any credential file is created with restrictive permissions and is excluded from logs, backups, and source control. 5. Redact credentials from Agent traces, tool output, exceptions, telemetry, and diagnostic reports. 6. Document how users can revoke and rotate a potentially exposed key. 7. Recommend a dedicated, least-privileged API key with spending limits where the service supports them. 8. Confirm configuration only through masked output and never repeat the credential back to the user. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
Findings (5)

Context-Inappropriate Capability

Medium
Confidence
96% confidence
Finding
The skill instructs the agent to ask the user to send a Qinghu API key in chat and then use it for configuration. Collecting reusable credentials through the conversation is dangerous because chat transcripts may be retained, exposed to the model/provider, or mishandled by downstream systems, and the key grants broader access than the immediate video task.

Context-Inappropriate Capability

Medium
Confidence
85% confidence
Finding
The skill contains extensive environment bootstrapping steps that install Node.js, global npm packages, and alternate registry sources. While partly related to running the tool, this materially expands the agent's capabilities beyond the declared video-cloning task and increases supply-chain and execution risk if an agent follows these instructions automatically.

Context-Inappropriate Capability

Low
Confidence
76% confidence
Finding
The skill directs the agent to perform local file processing using Python/Pillow or Node/sharp-cli to compress user images. Even though the purpose is auxiliary to video generation, it introduces additional code execution and file-handling behavior that may access or transform local user files unexpectedly.

Missing User Warnings

High
Confidence
98% confidence
Finding
The skill explicitly asks the user to generate/copy an API key and send it to the agent. Requesting secrets in chat without a warning or secure collection mechanism creates an immediate credential-exposure risk and normalizes unsafe secret-sharing practices.

Ssd 3

High
Confidence
99% confidence
Finding
This is a direct secret-handling anti-pattern: the skill tells the agent to have the user provide an API key in chat and then configure the tool with it. In the context of a marketing/video skill, credential collection is especially unjustified and broadens the blast radius from a single task to full account misuse if the key is exposed.

Static analysis

No suspicious patterns detected.