Back to skill

Security audit

AI视频分镜 | 分镜图生成 | 镜头设计 | 运镜方案 | 青虎AI

Security checks for vulnerabilities and agentic risk

Overview

This skill does what it claims, but its install and upgrade instructions give a third-party CLI broad local execution authority with weak version control and limited user control.

Review before installing. Use this only if you are comfortable with Qinghu/qhkit receiving the storyboard prompt and uploaded media, and prefer a pinned, reviewed qhkit version installed in a constrained environment. Do not blindly execute upgrade commands printed by the CLI; treat them as text to review first.

Vulnerability Patterns
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • 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
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (2)

T03 · Remote Payload Retrieval and Execution

Error
Location
SKILL.md:61
Finding
Execution of Upgrade Commands Supplied Through Dynamic CLI Messages## Vulnerability Details **File Location**: `SKILL.md`, line 61 **Vulnerability Type**: Remote payload retrieval and execution through untrusted command instructions **Risk Level**: High ### Vulnerable Snippet The following is a faithful English translation of the instruction at line 61: ```text If the command returns {"ok":false,"stage":"version",...}, the message contains the upgrade command; execute it as instructed. ``` ### Technical Analysis The Skill instructs the agent to execute an upgrade command supplied dynamically in the CLI's `message` field. It does not require the command to match an allowlist, validate its syntax, or restrict execution to a fixed package-management operation. The message could be influenced by the installed CLI, its remote service, or an update endpoint. Consequently, a compromised package, service account, API response, or network trust boundary could replace the expected upgrade instruction with an arbitrary shell command. This behavior exceeds the privileges required for storyboard generation. The Skill only needs to invoke a known CLI version; it does not need authority to execute arbitrary commands returned by that CLI or its remote service. ### Attack Path 1. An attacker compromises the `qhkit` package, update service, API response path, or associated publishing account. 2. The compromised component returns a response with `stage` set to `version`. 3. The response's `message` field contains a malicious command instead of a legitimate update command. 4. The Skill treats the message as trusted executable guidance. 5. The agent executes the supplied command under its current operating-system account. 6. The malicious command can access files, environment variables, API tokens, and network resources available to that account. ### Impact Assessment Successful exploitation provides arbitrary command execution with the privileges of the agent process. This may expose the `QHKIT_TOKEN`, other environment credentials, u ...[truncated 354 chars]
Remediation
## Remediation Suggestions - Never execute commands extracted from a CLI or server-provided `message` field. - Treat response messages as display-only diagnostic text. - Replace the dynamic behavior with a fixed, locally defined update command. - Pin updates to an explicitly reviewed version rather than accepting an arbitrary version from the response. - Require explicit user approval before installing or upgrading software. - Validate the package name, version, registry, and integrity metadata before installation. - Run package installation in a restricted environment without access to unrelated secrets or sensitive files. - Log the version-gate response for review, but do not interpret it as executable shell input. A safer update workflow would use a locally controlled command such as: ```bash npm install --global @iqinghu/qhkit@REVIEWED_VERSION ``` The actual reviewed version should replace `REVIEWED_VERSION`; it should not be obtained from an executable server-supplied message.

T08 · Insecure Dependencies

Error
Location
SKILL.md:36
Finding
Unpinned Installation and Immediate Execution of a Third-Party npm Package## Vulnerability Details **File Location**: `SKILL.md`, lines 36–65 **Vulnerability Type**: Unpinned third-party dependency installation and execution **Risk Level**: High ### Vulnerable Snippets ```bash npm i -g @iqinghu/qhkit ``` ```bash npx @iqinghu/qhkit <command> ... ``` ```bash npm i -g @iqinghu/qhkit@latest ``` The instructions also permit a fallback registry: ```bash --registry=https://registry.npmmirror.com ``` ### Technical Analysis The installation commands do not pin `@iqinghu/qhkit` to an exact reviewed version. Both the implicit latest-version installation and the explicit `@latest` installation allow package contents and behavior to change after the Skill itself has been audited. The `npx` fallback is particularly sensitive because it can download and immediately execute the selected package. npm installation may also run package lifecycle scripts unless separately disabled. Global installation increases exposure by placing the command in a broadly accessible executable path and retaining it beyond the immediate task. Use of an additional registry expands the supply-chain trust boundary. Although the named mirror may be operationally legitimate, the Skill does not specify package-integrity verification independent of the selected registry. The dependency is relevant to the Skill's functionality, but unrestricted installation of the newest release is not the minimum privilege necessary. A pinned, verified, locally scoped dependency would be sufficient. ### Attack Path 1. An attacker compromises the package publisher account, npm package, registry, mirror, or a future release process. 2. The attacker publishes a malicious version under the legitimate package name. 3. The agent runs the unpinned global installation, the `@latest` upgrade, or the `npx` fallback. 4. npm retrieves the attacker-controlled release. 5. Malicious lifecycle code or the package's runtime code executes with the agent user's privileges. 6. The package can r ...[truncated 836 chars]
Remediation
## Remediation Suggestions - Pin `@iqinghu/qhkit` to an exact reviewed version in every installation and execution path. - Remove `@latest` from automated upgrade instructions. - Avoid `npx` for unpinned packages; if it must be used, specify the exact reviewed version. - Prefer a project-local installation over a global installation. - Use a lockfile and verify npm integrity metadata against a trusted, independently controlled value. - Consider disabling lifecycle scripts during installation where package functionality permits it. - Require explicit user approval before installing or upgrading the dependency. - Re-audit each new package version before updating the pin. - Prefer the official npm registry and require equivalent integrity verification before using a mirror. - Execute the CLI in a restricted environment with only the files and credentials needed for the storyboard task. - Do not recommend privilege elevation as a routine response to global installation failures. Example of a safer, version-pinned invocation: ```bash npx --yes @iqinghu/qhkit@REVIEWED_VERSION storyboard script @params.json ``` `REVIEWED_VERSION` must be replaced with an exact version whose package contents and integrity have been independently reviewed.
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
Findings (2)

Vague Triggers

Medium
Confidence
92% confidence
Finding
The metadata states the skill 'must trigger' whenever users ask for storyboard-related tasks, using a broad keyword set. This can cause unintended invocation on common creative requests, increasing the chance the agent installs/runs external tooling or shifts workflow without clear user consent. In this skill's context, that risk is amplified because invocation may lead to package installation, network access, and third-party API use.

Natural-Language Policy Violations

Medium
Confidence
86% confidence
Finding
The description is written to enforce Chinese-language behavior and a Chinese product workflow without any user opt-in or locale negotiation. While not inherently dangerous, it can override user expectations, mis-handle requests in other languages, and increase the chance of unintended disclosure to region-specific third-party services. The skill context makes this somewhat more concerning because it routes users toward a specific external vendor and login flow.

Static analysis

No suspicious patterns detected.