Back to skill

Security audit

HappyHorse 1.1 爆款视频复刻 | LinkPix

Security checks for vulnerabilities and agentic risk

Overview

The skill is coherent for AI video replication, but it asks the agent to install mutable command-line software globally and handle an API key in ways that warrant careful review.

Only install this if you are comfortable letting qhkit and its dependencies run locally, upload selected media to Qinghu, and spend account credits after confirmation. Prefer configuring the API key yourself through a protected secret mechanism, and use a pinned, isolated qhkit install instead of global unpinned npm or npx execution.

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:47
Finding
Unpinned Third-Party Package Installation and Execution## Vulnerability Details **File Location**: `SKILL.md`, lines 47-51 **Vulnerability Type**: Unpinned and automatically executed third-party dependencies **Risk Level**: Medium ### Vulnerable Code ```bash npm i -g @iqinghu/qhkit ``` The instructions also permit direct execution through an unpinned package reference: ```bash npx @iqinghu/qhkit <command> ... ``` ### Technical Analysis The Skill instructs the Agent to install `@iqinghu/qhkit` globally without specifying a reviewed version or integrity hash. It also provides an `npx` fallback that may download and execute the package dynamically. Consequently, the code executed at runtime can differ from the code available when the Skill was audited. NPM installation can execute package lifecycle scripts. If the package, publisher account, dependency tree, registry response, or configured mirror is compromised, attacker-controlled code could run during installation or subsequent CLI invocation. Global installation unnecessarily increases the affected scope compared with a local, isolated installation. The later instruction to upgrade using `@latest` further prevents the Skill from maintaining a stable, reviewable dependency version. ### Attack Path 1. An attacker compromises the package publisher account, the package itself, a transitive dependency, or a package registry response. 2. The compromised component publishes malicious code under a version that satisfies the unpinned installation request. 3. The Agent follows the automatic bootstrap or upgrade instructions. 4. `npm` or `npx` retrieves the mutable package and executes its installation scripts or CLI entry point. 5. The malicious code executes with the privileges of the Agent process and can access files, environment variables, credentials, media, and network resources available to that account. ### Impact Assessment Successful exploitation could provide arbitrary code execution under the operati ...[truncated 578 chars]
Remediation
## Remediation Suggestions - Pin `@iqinghu/qhkit` to a specifically reviewed version instead of using an implicit latest version or `@latest`. - Verify package integrity using a lockfile and registry integrity metadata. - Install the package locally in a dedicated, minimally privileged working directory rather than globally. - Avoid `npx` execution that implicitly downloads packages. If unavoidable, specify an exact reviewed version and disable lifecycle scripts where compatible. - Require explicit user approval before installing or upgrading executable dependencies. - Run the CLI in a sandbox or container with restricted filesystem access, a controlled environment, and limited outbound network access. - Pin and review transitive dependencies, and use a trusted registry with provenance or signature verification. - Do not automatically switch to alternate package registries without separately establishing their trust and integrity guarantees.

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:68
Finding
API Token Exposure Through Chat and Command-Line Arguments## Vulnerability Details **File Location**: `SKILL.md`, lines 68-74 **Vulnerability Type**: Insecure secret collection and transmission **Risk Level**: Medium ### Vulnerable Code The Skill tells the user to generate an API key and send that key to the Agent, after which the Agent is instructed to execute: ```bash qhkit config set --token <API_KEY> --env prod ``` It also suggests the following alternative: ```bash QHKIT_TOKEN ``` ### Technical Analysis Asking a user to send an API token through the conversation exposes the secret to all systems that store, process, inspect, or log the transcript. The token may remain in persistent conversation records even after configuration is complete. Passing the token through the `--token` command-line argument creates additional exposure. Depending on the runtime environment, command arguments may be visible in process listings, shell history, Agent execution traces, telemetry, audit logs, or error reports. Although an environment variable can avoid direct command-line exposure, it remains sensitive and may still leak through debug logs, child processes, crash reports, or environment inspection unless the execution environment provides explicit secret isolation. ### Attack Path 1. The user follows the Skill instructions and sends an API token in the conversation. 2. The token is retained in chat history, execution logs, telemetry, or another transcript-processing system. 3. The Agent places the token in a command-line argument, potentially creating additional copies in process metadata, shell history, or tool logs. 4. A party with access to any exposed record recovers the token. 5. The party authenticates to Qinghu services using the stolen token and performs operations permitted by that credential. ### Impact Assessment The exposed token could permit unauthorized use of the associated Qinghu account within the token's granted scope. Potential consequences i ...[truncated 389 chars]
Remediation
## Remediation Suggestions - Never ask users to paste API tokens into the conversation. - Direct users to configure the token themselves through a non-echoing interactive prompt or an approved secret manager. - Do not place secrets in command-line arguments. - Inject the token through a protected secret mechanism that redacts values from logs and limits visibility to the intended process. - Ensure child processes do not unnecessarily inherit the secret. - Redact tokens from stdout, stderr, telemetry, error messages, and Agent tool-call records. - Store credentials with restrictive filesystem permissions if persistent storage is required. - Use narrowly scoped, short-lived tokens where supported. - Document token rotation and immediate revocation procedures for suspected exposure.
Vulnerability Patterns
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • 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)

Vague Triggers

Medium
Confidence
95% confidence
Finding
The skill metadata description embeds many broad trigger terms such as major platform names and generic video-creation phrases, which can cause the agent to invoke this skill for loosely related requests. Over-broad activation increases the chance of routing users into a tool that installs software, requests API keys, and initiates billable external actions without sufficient relevance checks.

Vague Triggers

Medium
Confidence
92% confidence
Finding
The '何时触发' section uses permissive phrasing like '复刻/对标/照着做' and relies on broad combinations involving common platforms and links, but does not define near-miss exclusions. In practice this can misfire on ordinary analysis or editing requests, causing unnecessary external-tool usage, package installation, secret solicitation, and potentially chargeable operations.

Static analysis

No suspicious patterns detected.