Back to skill

Security audit

Animejs

Security checks for vulnerabilities and agentic risk

Overview

The skill is coherent Anime.js guidance, but it tells users to load or execute mutable third-party JavaScript without pinning versions.

Review before installing. The skill is not deceptive and does not show credential theft or persistence, but users should pin the Anime.js CDN import and run HyperFrames validation through a lockfile-pinned local dependency or npx --no-install.

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:74
Finding
Unversioned Remote Anime.js Module Can Change After Review<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, line 74 **Vulnerability Type**: Mutable remote JavaScript retrieval and execution **Risk Level**: High ### Vulnerable Code ```html import { animate } from "https://cdn.jsdelivr.net/npm/animejs/+esm"; ``` ### Technical Analysis The documented ES module import retrieves executable JavaScript from a third-party CDN without specifying an exact Anime.js version. Consequently, the code executed by compositions can change after the skill has been reviewed. The browser trusts and executes whatever module the mutable URL returns. If the upstream package, npm publishing account, CDN resolution process, or package release is compromised, the effective payload could become attacker-controlled without any modification to this repository. Unlike the versioned Anime.js example at line 23, this import does not provide a stable dependency version. It also lacks an integrity mechanism that would allow the consumer to verify the retrieved content against a reviewed digest. ### Attack Path 1. A user follows the module-build example in `SKILL.md`. 2. The resulting composition imports Anime.js from the unversioned jsDelivr URL. 3. An attacker compromises the upstream package publication channel, causes a malicious release to become the version resolved by the URL, or otherwise compromises the remote delivery path. 4. The composition loads the mutable URL. 5. The browser executes the attacker-controlled module in the composition's JavaScript context. ### Impact Assessment A successful attack could execute arbitrary JavaScript with the privileges available to the rendered composition. Depending on its hosting context and browser security boundaries, this could permit DOM manipulation, access to data exposed to the page, unauthorized network requests, theft of accessible application state, or corruption of rendered output. The immediate scope is the browser or renderer context that imports the module. This find ...[truncated 136 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin the dependency to an exact, reviewed version: ```html import { animate } from "https://cdn.jsdelivr.net/npm/animejs@4.0.2/+esm"; ``` 2. Prefer vendoring the reviewed module or installing it through a lockfile-controlled package workflow rather than importing executable code directly from a mutable remote URL. 3. Where supported, verify remotely loaded resources with Subresource Integrity or an equivalent cryptographic digest. 4. Apply an appropriately restrictive Content Security Policy that limits script origins and outbound connections. 5. Periodically review pinned versions and update them through an explicit, tested dependency-update process. ]]>

T08 · Insecure Dependencies

Error
Location
SKILL.md:107
Finding
Unpinned npx Commands May Download and Execute Mutable Packages<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 107–108 **Vulnerability Type**: Unpinned package execution through `npx` **Risk Level**: High ### Vulnerable Code ```bash npx hyperframes lint npx hyperframes validate ``` ### Technical Analysis The validation instructions invoke `hyperframes` through `npx` without specifying a version or requiring an existing local installation. If the package is unavailable locally, `npx` may retrieve a package from the npm registry and execute it. The retrieved package version can change over time and is not bound to a reviewed lockfile in this project. This creates a supply-chain execution boundary: package code and applicable installation lifecycle behavior can run with the invoking user's privileges. A compromised package release, publisher account, or registry delivery path could therefore turn routine validation into arbitrary local code execution. ### Attack Path 1. A user follows the validation instructions in `SKILL.md`. 2. No trusted, lockfile-pinned local `hyperframes` executable is available. 3. `npx` resolves and downloads the current package from the configured npm registry. 4. An attacker has compromised the package, its publisher account, or the relevant package-delivery channel and supplied malicious package content. 5. `npx` executes the retrieved package under the user's account when running `lint` or `validate`. ### Impact Assessment Successful exploitation could run arbitrary code with the privileges of the user executing the commands. This may expose readable source code, environment variables, credentials, tokens, and user-accessible files; permit modification or deletion of writable files; and enable outbound network communication. The impact is limited by the invoking account's permissions, but no sandbox or least-privilege boundary is specified in the documented workflow. The finding does not independently demonstrate administrative privilege escalation. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions 1. Declare an exact reviewed HyperFrames version in the project's dependency manifest and commit the associated lockfile. 2. Install dependencies reproducibly with a lockfile-enforcing command such as: ```bash npm ci ``` 3. Require execution of the installed local binary without permitting an implicit download: ```bash npx --no-install hyperframes lint npx --no-install hyperframes validate ``` 4. Alternatively, use package-manager scripts that resolve only the lockfile-pinned local dependency. 5. Validate package provenance and integrity before version updates, review lifecycle scripts, and conduct dependency upgrades through an explicit testing and approval process. 6. Run validation in a restricted environment with minimal filesystem access, no unnecessary credentials, and limited network access. ]]>
Vulnerability Patterns
  • 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
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
Findings (2)

Rp1

Medium
Category
MCP Rug Pull
Confidence
70% confidence
Finding
npx commands without a version suffix (e.g. @1.0.0) create a rug-pull risk if the upstream server is compromised and publishes a malicious update.

Rp1

Medium
Category
MCP Rug Pull
Confidence
70% confidence
Finding
npx commands without a version suffix (e.g. @1.0.0) create a rug-pull risk if the upstream server is compromised and publishes a malicious update.

Static analysis

No suspicious patterns detected.