Back to skill

Security audit

Contribute Catalog

Security checks for vulnerabilities and agentic risk

Overview

This contribution skill is coherent, but it needs review because it asks users to run unpinned external tools and generated templates load third-party scripts while publishing content.

Install only if you are comfortable reviewing and running the contribution commands yourself. Prefer running the workflow in a clean checkout or container, pin or use locked project dependencies for hyperframes, oxfmt, and tsx, and be aware that generated HTML templates fetch scripts from public CDNs unless you vendor or add integrity controls.

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)

T08 · Insecure Dependencies

Warning
Location
SKILL.md:159
Finding
Unpinned Packages Executed Through npx<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:159-209` **Vulnerability Type**: Unpinned third-party package execution **Risk Level**: Medium ### Vulnerable Code ```bash # Render and publish workflow npx hyperframes publish # Format HTML npx oxfmt registry/{kind}/{name}/*.html # Generate catalog documentation npx tsx scripts/generate-catalog-pages.ts # Publish the generated project npx hyperframes publish ``` The quality gate repeats the same unpinned package execution requirements: ```markdown - [ ] `npx oxfmt --check` passes - [ ] `npx hyperframes publish` run (claim your project URL) ``` ### Technical Analysis The workflow instructs contributors to invoke `hyperframes`, `oxfmt`, and `tsx` through `npx` without specifying exact package versions or requiring resolution from an integrity-protected repository lockfile. If a requested package is not already installed in the local project, `npx` can retrieve it from the configured package registry and immediately execute its code. Package installation scripts, transitive dependencies, and the package's command-line entry point consequently execute with the privileges and environment of the contributor. The effective code executed by these commands is therefore not fully represented in the reviewed Skill. It may change because of a compromised package release, compromised maintainer account, registry attack, malicious transitive dependency, or unexpected package resolution. ### Attack Path 1. An attacker compromises one of the referenced packages, a transitive dependency, a maintainer account, or the configured package registry. 2. The attacker publishes or serves a malicious package version. 3. A contributor follows the Skill and runs an unversioned `npx` command. 4. If no trusted local version is available, `npx` downloads and executes the externally resolved package. 5. Malicious installation or runtime code executes with the contributor's user privileges. 6. The payload can inspect ...[truncated 918 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Declare all required command-line packages in the target repository's `devDependencies`. 2. Pin exact versions rather than using floating ranges where practical. 3. Commit an integrity-protected lockfile and install dependencies with a frozen-lockfile command such as: ```bash npm ci ``` 4. Invoke repository-local binaries without permitting automatic downloads: ```bash npm exec --offline -- hyperframes publish npm exec --offline -- oxfmt registry/{kind}/{name}/*.html npm exec --offline -- tsx scripts/generate-catalog-pages.ts ``` 5. Configure npm to disable lifecycle scripts where they are unnecessary: ```bash npm ci --ignore-scripts ``` 6. Review and audit direct and transitive dependencies before updating the lockfile. 7. Run publishing and generation tools in a restricted container or CI environment with minimum filesystem access and short-lived credentials. 8. Require explicit user confirmation before commands that publish content or use authenticated GitHub and registry sessions. ]]>

T03 · Remote Payload Retrieval and Execution

Warning
Location
templates.md:13
Finding
Externally Hosted JavaScript Executes Without Integrity Verification<![CDATA[ ## Vulnerability Details **File Location**: `templates.md:13-16, 191-192, 377` **Vulnerability Type**: Remote payload retrieval and execution without Subresource Integrity **Risk Level**: Medium ### Vulnerable Code Caption template: ```html <link href="https://fonts.googleapis.com/css2?family=Montserrat:wght@800;900&display=swap" rel="stylesheet" /> <script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script> ``` VFX template: ```html <script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script> <script src="https://cdn.jsdelivr.net/npm/three@0.147.0/build/three.min.js"></script> ``` Component template: ```html <script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script> ``` ### Technical Analysis The generated HTML templates load executable JavaScript directly from `cdn.jsdelivr.net`. Although the package URLs include version numbers, the script elements do not contain Subresource Integrity hashes. The browser or rendering engine therefore verifies only transport security and does not verify that the returned script bytes match a previously reviewed artifact. The effective payload remains dependent on external CDN and package infrastructure after the Skill itself has been reviewed. A compromised CDN response, compromised upstream package artifact, malicious registry replacement, or failure in the external delivery chain could cause modified JavaScript to execute whenever a composition is previewed or rendered. The remote Google Fonts stylesheet also generates a third-party network request and exposes ordinary request metadata, but it is not itself treated as a confirmed executable-code vulnerability in this report. ### Attack Path 1. An attacker compromises the CDN delivery path, an upstream package artifact, or infrastructure capable of changing the response for one of the referenced script URLs. 2. A contributor creates a composition by copying one of the provided templa ...[truncated 1441 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Prefer vendoring reviewed GSAP and Three.js artifacts in the repository so generated compositions do not retrieve executable code at runtime. 2. If CDN delivery is required, calculate and add verified Subresource Integrity hashes: ```html <script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js" integrity="sha384-REPLACE_WITH_VERIFIED_HASH" crossorigin="anonymous" ></script> ``` 3. Generate hashes from independently obtained, trusted artifacts and verify them during dependency updates. 4. Apply the same protection to every remote executable script in all templates. 5. Enforce a restrictive Content Security Policy that permits scripts only from approved locations and disallows unexpected connections. 6. Run previews and rendering jobs in a sandbox with no sensitive environment variables, credentials, local-file bridges, or unnecessary network access. 7. Mirror approved dependencies in controlled infrastructure if offline vendoring is not practical. 8. Add automated linting that rejects remote script elements without approved origins, fixed versions, and valid integrity metadata. ]]>
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Rogue AgentSelf-Modification, Session Persistence
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (9)

Rp1

Medium
Category
MCP Rug Pull
Confidence
92% confidence
Finding
The skill instructs use of `npx hyperframes` without pinning an exact package version. `npx` may resolve and execute the latest published package or a locally shadowed package, which creates a supply-chain risk if an upstream release is compromised or behavior changes unexpectedly. In a skill that guides contributors through publishing and PR workflows, this can directly lead to execution of unreviewed code on the user's machine.

Rp1

Medium
Category
MCP Rug Pull
Confidence
89% confidence
Finding
The instruction uses `npx oxfmt` without an exact version, allowing execution of whatever package version is currently resolved from the registry. This exposes contributors to supply-chain compromise or unexpected formatter behavior, especially because the command is intended to be run on developer workstations during contribution flow.

Session Persistence

Medium
Category
Rogue Agent
Content
# 2. Format HTML
npx oxfmt registry/{kind}/{name}/*.html

# 3. Update registry/registry.json — add entry to the "items" array:
#    { "name": "{name}", "type": "hyperframes:block" }  (or "hyperframes:component")

# 4. Generate catalog docs page
Confidence
80% confidence
Finding
Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.

Rp1

Medium
Category
MCP Rug Pull
Confidence
90% confidence
Finding
The skill calls `npx tsx scripts/generate-catalog-pages.ts` without pinning `tsx` to a specific version. Because `tsx` executes JavaScript/TypeScript code, an unpinned resolution increases the risk of arbitrary code execution through a malicious or compromised package version or dependency tree.

Rp1

Medium
Category
MCP Rug Pull
Confidence
92% confidence
Finding
This is another unpinned `npx hyperframes` invocation, here used for publishing. Publishing-related commands are especially sensitive because they may handle credentials, upload content, or affect remote state, so executing an unpinned package heightens the supply-chain risk.

Rp1

Medium
Category
MCP Rug Pull
Confidence
89% confidence
Finding
The quality gate references `npx oxfmt --check` without version pinning. Even though this is a check step, it still executes downloaded code and therefore carries the same supply-chain and reproducibility risks as other unpinned `npx` commands.

Rp1

Medium
Category
MCP Rug Pull
Confidence
92% confidence
Finding
The quality gate again instructs `npx hyperframes publish` without pinning a version. Because this command likely performs networked publishing and may use credentials or project metadata, unpinned execution materially increases the impact of a compromised upstream package.

Missing User Warnings

Low
Confidence
88% confidence
Finding
The caption template instructs users to load third-party assets from public CDNs (Google Fonts and jsDelivr) at runtime without any disclosure or integrity controls. This creates a supply-chain and privacy risk because generated artifacts will make external requests and will trust whatever script/font content is served at execution time.

Missing User Warnings

Low
Confidence
91% confidence
Finding
The VFX template loads GSAP and Three.js directly from a CDN, again without warning users that the produced composition depends on third-party network resources. In a contribution skill that helps publish upstream registry items, this risk propagates into reusable public catalog content and increases exposure to supply-chain tampering or unexpected outbound requests.

Static analysis

No suspicious patterns detected.