Back to skill

Security audit

Seedance 2.0 爆款视频复刻 | LinkPix

Security checks for vulnerabilities and agentic risk

Overview

The skill’s video-generation purpose is coherent, but it needs review because it asks the agent to install mutable third-party tools and handle a production API key through chat/commands.

Install only if you are comfortable with the agent installing/upgrading command-line packages and uploading media to Qinghu. Configure the API key through a managed secret or local environment variable rather than pasting it into chat, and prefer a sandboxed environment with pinned dependencies for package installation.

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

Error
Location
SKILL.md:52
Finding
Unpinned Third-Party Packages Are Installed and Executed<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 52–91 **Vulnerability Type**: `T08: Insecure Dependencies` **Risk Level**: High ### Vulnerable Code ```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 ``` The same section also directs the agent to invoke `sharp-cli` through an unpinned, automatically approved `npx --yes` installation. ### Technical Analysis The Skill directs the agent to download and execute mutable third-party packages without pinning exact versions or verifying package integrity. The explicit use of `@latest` guarantees that future executions may run code that was not available during this audit. The unversioned npm, pip, and `npx` operations have the same underlying problem. npm packages can execute lifecycle scripts during installation. Packages invoked through `npx` are downloaded and executed, while Python packages can run build or installation logic. Consequently, compromise of a package publisher, dependency, package release, or configured registry can turn a routine Skill invocation into arbitrary local code execution. The use of npm mirrors and a separately configured Python mirror expands the supply-chain trust boundary. Unlike the Node.js archive installation described elsewhere in the file, these package installation commands do not perform an independent hash or signature check. ### Attack Path 1. An attacker compromises a referenced package, one of its transitive dependencies, its publisher account, or a configured package registry. 2. The attacker publishes a malicious release under the expected package name. 3. The Skill encounters a missing dependency, an upgrade condition, or an oversized image requiring a conversion utility. 4. The agent follows the documented unpinned `npm`, `pip`, or `npx` command. 5. The package manager downloads the attacker-controlled release. 6. Installation lifecycle code, ...[truncated 945 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin every dependency to a reviewed exact version rather than using unversioned packages or `@latest`. 2. Maintain a lockfile or an internal manifest containing expected package versions and integrity hashes. 3. Verify downloaded artifacts against independently maintained checksums or trusted signatures before execution. 4. Replace `npx --yes` with a preinstalled, pinned utility or a locally reviewed tool included in a controlled runtime image. 5. Use a trusted internal registry or explicitly approved official registry, and document the registry trust model. 6. Disable npm lifecycle scripts where the package does not require them, for example by using `--ignore-scripts` after compatibility testing. 7. Run dependency installation and media processing in a sandbox with restricted filesystem access, no unnecessary credentials, and limited outbound network access. 8. Require explicit user approval before installing or upgrading software. 9. Do not recommend privilege elevation as a routine response to installation failures; prefer a user-scoped installation. 10. Continuously scan pinned packages and transitive dependencies for known vulnerabilities and publisher or ownership changes. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:67
Finding
API Token May Be Exposed Through Chat and Command-Line Arguments<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 67–72 **Vulnerability Type**: `T09: Insecure Skill Coding Practices` **Risk Level**: Medium ### Vulnerable Code The Skill instructs the user to obtain an API key, send that key to the agent, and then configure it using a command equivalent to: ```bash qhkit config set --token <API_KEY> --env prod ``` It alternatively permits configuration through: ```bash QHKIT_TOKEN ``` ### Technical Analysis The primary workflow asks the user to transmit a production API token through the conversation and directs the agent to place that secret directly in a command-line argument. This unnecessarily exposes the token to several storage and observation channels: - Conversation transcripts and model-processing infrastructure - Agent tool-call records and execution logs - Shell history, if the command is run interactively - Process inspection utilities while the command is executing - Debug output, telemetry, or error reports that capture command arguments The Skill states that `qhkit config show` produces redacted output, but redaction of that command does not protect the original chat message or the command used to set the token. It also does not specify secure file permissions for any locally stored configuration, token lifetime, revocation, or cleanup. Using the `QHKIT_TOKEN` environment variable can reduce exposure in process arguments, but it remains unsafe if the value is entered in chat, inherited by unrelated child processes, captured in environment diagnostics, or retained longer than necessary. ### Attack Path 1. The user follows the Skill instructions and sends a production API token to the agent. 2. The token is retained in a conversation transcript, agent log, tool invocation, or telemetry system. 3. The agent places the token in a command-line argument to configure `qhkit`. 4. A local user, monitoring process, logging component, or party with later access to the transcript obtains th ...[truncated 871 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Do not ask users to send API keys through ordinary chat messages. 2. Use a dedicated secret-entry interface, interactive hidden prompt, operating-system keychain, or managed secret store. 3. Avoid passing tokens as command-line arguments. Prefer a protected file descriptor, secret manager integration, or narrowly scoped environment injection. 4. If an environment variable must be used, provide it only to the specific child process and remove it immediately afterward. 5. Ensure local credential files are created with owner-only permissions and are excluded from source control, backups, and diagnostic bundles where appropriate. 6. Redact secrets from command logs, tool-call records, exception traces, telemetry, and process output. 7. Use narrowly scoped, short-lived tokens that permit only the operations required by this Skill. 8. Document token expiration, rotation, revocation, and incident-response procedures. 9. Add a warning that users must immediately revoke a token accidentally disclosed in chat or logs. 10. Confirm that uploaded media and service requests are associated only with the intended account and cannot be accessed through an overprivileged token. ]]>
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 (2)

Context-Inappropriate Capability

Medium
Confidence
92% confidence
Finding
The skill explicitly instructs the agent to ask the user for a Qinghu API key and then use it to configure a CLI. Asking users to transmit API secrets through the chat expands secret exposure beyond the video-generation task, and if the agent or platform is compromised, the key could be misused for unauthorized API calls and billing.

Context-Inappropriate Capability

Medium
Confidence
84% confidence
Finding
The skill contains extensive environment-bootstrapping instructions, including installing Node, npm packages, and fallback tooling, which materially increase the agent's operational scope beyond simple video replication. This creates unnecessary supply-chain and system-modification risk, especially when the agent is encouraged to install global packages and execute network-fetched setup commands automatically.

Static analysis

No suspicious patterns detected.