Back to skill

Security audit

Hexo Blog with SEO

Security checks for vulnerabilities and agentic risk

Overview

The skill is mostly a disclosed Hexo publishing helper, but it can run live deployment after ordinary edits and uses unpinned npx commands with deploy credentials available.

Install only if you are comfortable with an agent editing your Hexo repository and potentially deploying with your configured git or hosting credentials. Before use, revise the workflow so deployment requires fresh explicit approval after reviewing the target remote and pending changes, and replace bare npx hexo commands with a pinned, lockfile-backed local Hexo command or vetted repository script.

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:142
Finding
Unpinned npx Execution May Retrieve and Execute Unreviewed Packages## Vulnerability Details **File Location**: `SKILL.md:1-5, 142-148`; corroborated by `README.md:42-44` **Vulnerability Type**: Unpinned third-party package execution **Risk Level**: Medium ### Vulnerable Code ```yaml --- name: blog-hexo description: Draft and publish Hexo posts end-to-end (front matter + SEO polish + deploy) metadata: { "openclaw": { "requires": { "bins": ["node", "npm", "npx", "hexo"] } } } --- ``` ```markdown ## Hexo Command Workflow Whenever you modify or create a post in the user-specified blog repository, confirm the path (ask if unsure) and run: 1. `npx hexo clean` 2. `npx hexo generate` 3. `npx hexo deploy` These commands rebuild the site and push to the configured remote using the user’s git credentials. ``` The README repeats the executable workflow: ```bash npx hexo clean npx hexo generate npx hexo deploy ``` ### Technical Analysis The skill repeatedly directs the agent to invoke `npx hexo` without specifying a package version, requiring a lockfile-backed local dependency, or prohibiting package downloads. The audited project contains only documentation and does not include a package manifest or lockfile that establishes the exact Hexo package and transitive dependency versions to execute. Depending on the installed npm/npx version and local environment, `npx` can resolve and download a package when the requested executable is not already available locally. Any downloaded package and its dependency code may execute with the privileges of the agent process. This creates a supply-chain boundary in which the code ultimately executed can differ from the code reviewed during this audit. This finding does not establish that the genuine Hexo package is malicious. The vulnerability is the workflow's failure to ensure that only a reviewed, locally installed, version-locked executable is used. ### Attack Path 1. The user asks the agent to create, modify, preview, or publi ...[truncated 1308 chars]
Remediation
## Remediation Suggestions 1. Add Hexo and all required plugins to the target blog repository's `package.json` using exact or appropriately constrained versions. 2. Commit and review the package lockfile, and use `npm ci` to reproduce the locked dependency graph. 3. Replace download-capable execution with a local-only invocation, such as: ```bash npm exec --offline -- hexo clean npm exec --offline -- hexo generate npm exec --offline -- hexo deploy ``` Alternatively, use a supported `npx --no-install` equivalent where applicable. 4. Fail safely if the expected local executable is unavailable rather than retrieving a package automatically. 5. Pin the Node.js and npm versions used by the workflow. 6. Review Hexo plugins and deployer packages because they execute with the same access as Hexo itself. 7. Run generation in a restricted environment without deployment credentials. Expose credentials only to the separately authorized deployment step.

T09 · Insecure Skill Coding Practices

Error
Location
SKILL.md:142
Finding
Conflicting Workflow Instructions May Trigger Deployment Without Explicit Publication Authorization## Vulnerability Details **File Location**: `SKILL.md:142-148`; conflicting authorization controls at `SKILL.md:48-55, 68-72` **Vulnerability Type**: Unsafe deployment control and ambiguous authorization **Risk Level**: High ### Vulnerable Code The draft workflow correctly establishes an explicit authorization requirement: ```markdown 5. Do **not** run `hexo deploy` unless the user explicitly wants to publish. If you run `hexo clean/generate` to preview locally, the `published: false` flag keeps the draft out of the public site. - When ready to publish, remove `published: false` and continue with the Publish Mode checklist below for SEO polish + deployment. ``` The publish workflow repeats that requirement: ```markdown Before editing, confirm the repository path and ensure you have permission to modify it. If the path is not in memory, ask the user directly. Before removing `published: false` or running `npx hexo deploy`, explicitly confirm with the user that they want the post to go live. If confirmation is not granted, stop after preparing the draft. ``` However, a later section gives an unconditional deployment instruction after any creation or modification: ```markdown ## Hexo Command Workflow Whenever you modify or create a post in the user-specified blog repository, confirm the path (ask if unsure) and run: 1. `npx hexo clean` 2. `npx hexo generate` 3. `npx hexo deploy` These commands rebuild the site and push to the configured remote using the user’s git credentials. ``` ### Technical Analysis The skill contains mutually inconsistent control-flow requirements. Earlier sections state that deployment requires explicit confirmation and must not occur for draft-only work. The later Hexo command workflow says to run deployment whenever a post is created or modified. Agent behavior is instruction-driven, so this ambiguity can bypass the intended publication boundary even without conventional execu ...[truncated 2302 chars]
Remediation
## Remediation Suggestions 1. Remove `npx hexo deploy` from every generic create, edit, draft, and preview workflow. 2. Define separate, unambiguous phases: - Draft: edit files only. - Validation: optionally run `clean` and `generate`. - Deployment: run only after explicit user authorization. 3. Require fresh confirmation immediately before deployment, including the repository path, target remote or environment, branch, and list of changes to publish. 4. State that silence, prior drafting approval, or a request to preview does not authorize deployment. 5. Before requesting approval, show a diff or deployment preview and identify unrelated pending changes. 6. Abort deployment if the working tree contains unreviewed changes or if the remote cannot be verified. 7. Use separate credentials or environments for preview and production. Generation should not have access to production deployment credentials. 8. Update the workflow to use language such as: ```markdown After modifying a post, optionally run `hexo clean` and `hexo generate` for local validation. Never run `hexo deploy` unless the user gives fresh, explicit approval after reviewing the exact deployment target and changes. ``` 9. Keep `published: false` for drafts, but treat it as a content-state setting rather than a security or authorization boundary.
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
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
Findings (18)

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
90% confidence
Finding
This is the same command instance containing another bare `npx hexo` invocation. Repeated unpinned `npx` execution increases exposure to supply-chain or package-resolution risks if the environment does not use a trusted local dependency.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The publish workflow tells the agent to generate and deploy the site but does not require an explicit confirmation immediately before making remote changes. In an agent skill, this can cause unintended publication or repository modifications, especially because the workflow includes `hexo deploy` and assumes available credentials.

Rp1

Medium
Category
MCP Rug Pull
Confidence
92% confidence
Finding
The publish workflow directs running `npx hexo clean` during a deployment sequence without version pinning. In an agent-driven workflow, this creates avoidable risk of executing an unintended or compromised package in a context that also has repository write access.

Rp1

Medium
Category
MCP Rug Pull
Confidence
92% confidence
Finding
The skill instructs `npx hexo generate` as part of the live publish pipeline without ensuring a pinned, trusted Hexo binary. Because generation runs code from the Node toolchain in a repository context, a compromised package or dependency chain could lead to local code execution.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
`npx hexo deploy` is especially sensitive because it executes package code while also using deploy credentials to push to a remote. If `hexo` or a related dependency is malicious or unexpectedly resolved, the attack could compromise local secrets, alter deployment output, or publish unauthorized content.

Vague Triggers

Medium
Confidence
90% confidence
Finding
The description says to use the skill to manage the 'entire Hexo workflow' and includes both drafting and publishing, but it does not define specific trigger phrases, boundaries, or exclusion conditions. This broad wording increases the chance the skill is invoked for general blogging requests that may not actually require deployment actions.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
The skill instructs use of `npx` for Hexo without pinning an exact package/version, which can cause execution of whatever package version is currently resolved from the registry or local environment. In a skill that performs file writes and deployment with repository credentials, this creates a supply-chain execution path where a compromised or unexpected package version could run arbitrary code during blog generation or deploy.

Rp1

Medium
Category
MCP Rug Pull
Confidence
97% confidence
Finding
Referring users to `npx hexo ...` without a pinned version allows package resolution at runtime, which can execute an unintended or malicious Hexo package. Because this skill also expects deployment tokens or git credentials to be configured, compromise of the CLI execution path could expose credentials or alter deployed site contents.

Rp1

Medium
Category
MCP Rug Pull
Confidence
97% confidence
Finding
This duplicate `npx hexo` reference represents the same supply-chain risk: unpinned command resolution can invoke untrusted code. In this skill context, command execution occurs alongside write access to the blog repo, increasing the blast radius from package compromise.

Rp1

Medium
Category
MCP Rug Pull
Confidence
97% confidence
Finding
The skill asks the agent to run `npx hexo deploy`, an unpinned package execution step that can run arbitrary code at the moment credentials and deployment access are available. That makes the issue more dangerous than a generic build command, because compromise could directly affect production content and secrets used for pushing to the hosting remote.

Intent-Code Divergence

Medium
Confidence
94% confidence
Finding
The documentation conflicts with earlier instructions that say not to deploy unless the user explicitly wants to publish, yet later says to always run clean/generate/deploy whenever a post is modified. Contradictory operational guidance in an autonomous skill can cause accidental publication or unintended command execution, especially when deployment is a destructive or externally visible action.

Rp1

Medium
Category
MCP Rug Pull
Confidence
97% confidence
Finding
Mandating `npx hexo clean` after modifying repository content introduces unpinned package execution into the standard workflow. While `clean` sounds low risk, it still executes package code with filesystem access in the repository context and could be abused if the resolved package is malicious.

Rp1

Medium
Category
MCP Rug Pull
Confidence
97% confidence
Finding
Mandating `npx hexo generate` without version pinning exposes the user to arbitrary code execution during site generation. Since generation processes user content, templates, and plugins, the combination of unpinned execution and broad repository access significantly increases the chance of content tampering or environment compromise.

Rp1

Medium
Category
MCP Rug Pull
Confidence
98% confidence
Finding
The required `npx hexo deploy` step is especially sensitive because it combines unpinned package execution with outbound publishing using configured credentials. If the package or plugin chain is compromised, an attacker could alter live content, exfiltrate tokens, or push unauthorized changes to the hosting remote.

Vague Triggers

Low
Confidence
84% confidence
Finding
The instruction to use the skill whenever the user wants to draft a Hexo blog post is still fairly broad and does not clarify whether simple ideation, outline generation, or non-repository writing tasks should invoke it. Without negative examples or scope constraints, routine content-writing requests may unintentionally activate repository-modifying behavior.

Natural-Language Policy Violations

Low
Confidence
95% confidence
Finding
The instruction says to use the user's timezone with a default of America/Los_Angeles, which effectively forces a locale-specific default if the user's preference is unknown. This is a language/locale policy concern because it applies a regional setting without explicit confirmation or opt-in.

Description-Behavior Mismatch

Low
Confidence
88% confidence
Finding
The manifest and earlier sections present this skill as handling the full Hexo workflow, including creating drafts and publishing them end-to-end (L003, L009-L012, L021-L053). However, the `Improving Existing Markdown` section says brand-new unpublished articles should use the `draft-hexo` skill first, which narrows actual intended use and conflicts with the claimed integrated workflow.

Static analysis

No suspicious patterns detected.