/

CVE-2026-10220

Severity:

HIGH RISK

(7.3)

Injection in hermes-agent Plugin Skill Endpoint

CVE-2026-10220

Deferred

Vulnerability type

Category:

Injection

CWE:

CWE-74, CWE-707

Impact:

Unauthorized Command or Data Injection via Remote Requests

Severity:

HIGH RISK

(7.3)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

NousResearch hermes-agent up to 2026.4.30 contains an input injection vulnerability in the _serve_plugin_skill/skill_view handler within tools/skills_tool.py.

Remote attackers can manipulate skill-related inputs to inject crafted data into downstream interpreters or execution contexts, potentially leading to unauthorized actions or responses by the agent.

Affected context

The vulnerability occurs in deployments of hermes-agent (through version 2026.4.30) that expose the plugin/skill-serving functionality, particularly the _serve_plugin_skill/skill_view endpoint in tools/skills_tool.py.

It is relevant whenever external clients or integrated services can supply parameters or payloads that the agent uses to invoke skills, tools, or plugins, and where those values are passed into downstream processing components without strict validation, encoding, or constraints.

Exploit preconditions

  • Attack surface: Network-accessible hermes-agent instances exposing plugin/skill endpoints.
  • Required access: Ability to send crafted requests or messages to the _serve_plugin_skill/skill_view code path (e.g., via HTTP, WebSocket, or an integrated API gateway).
  • Trigger point: Submission of malicious input fields (such as skill identifiers, arguments, or configuration values) that the endpoint incorporates into subsequent operations without proper sanitization or contextual encoding.
  • Why exploitation is possible: The endpoint appears to directly propagate attacker-controlled data into internal interpreters, templating logic, or execution environments, aligning with CWE-74 (Improper Neutralization of Special Elements in Output Used by a Downstream Component) and CWE-707 (Improper Neutralization at Multiple Layers).

Why this happens

At its core, this is an injection bug where user-controlled input is not correctly constrained or neutralized before being used by downstream components.

The _serve_plugin_skill/skill_view function likely takes parameters such as skill names, arguments, or configuration fragments and passes them into interpreters, command wrappers, prompt templates, or plugin dispatch logic.

Because these values are treated as trusted, special characters or structured payloads can alter how the downstream component parses or executes them, which matches the CWE-74 pattern of improper neutralization.

CWE-707 highlights that multiple layers (request parsing, skill routing, and underlying tool invocation) may each lack robust input handling, compounding the risk and making injection easier.

Potential impact

  • Remote triggering of unintended plugin or skill executions with attacker-controlled parameters.
  • Manipulation of the agent's behavior, including data exfiltration, unauthorized actions, or misleading responses.
  • Potential access to sensitive internal data that the agent or its tools can reach.
  • Abuse of integrations (e.g., databases, external APIs, or automation backends) invoked by skills, possibly leading to data modification or service misuse.
  • Expanded attack surface for chaining into more severe impacts, depending on what underlying tools or environments skills can control.

General mitigation guidance

Risk reduction for this class of injection issues centers on strict input handling and careful boundary control between the agent and its skills or tools.

Recommended patterns include:

  • Constraining inputs: Treat skill identifiers, arguments, and configuration values as untrusted and validate them against allowlists, schemas, or strict type checks before use.
  • Contextual encoding and neutralization: When passing user data into templating, interpreters, or any execution-like context, apply encoding/escaping appropriate to that context so special control characters cannot alter logic.
  • Clear separation of data and control: Design skill interfaces so that control flow (which skill to call, what operation to perform) is decided by static mappings rather than user-provided strings wherever possible.
  • Principle of least privilege: Ensure skills and plugins run with minimal privileges and narrowly scoped capabilities so that even if injection occurs, the blast radius is limited.
  • Defensive defaults: Disable or restrict dynamic skill discovery and arbitrary parameter forwarding from external inputs; require explicit configuration for any high-risk tool or integration.

How teams detect issues like this

Effective detection relies on a combination of code-centric and behavior-centric approaches:

  • Static analysis patterns:
  • Flag functions that route or dispatch based on unvalidated external input (e.g., dynamic lookup of skills or tools from user-provided strings).
  • Detect concatenation or direct interpolation of user data into templates, command-like strings, or interpreter calls used by skills.
  • Highlight any code paths that pass raw request parameters into plugin execution APIs or dynamic evaluators.
  • Code review signals:
  • Endpoints where external inputs map directly to skill or tool selection, or where caller-provided parameters are forwarded without transformation.
  • Lack of schema validation, type coercion, or allowlist checks for skill names, parameters, or configuration blocks.
  • Complex, multi-layer flows (HTTP → agent → tool) where input validation appears only at the perimeter or is entirely missing.
  • Policy and automated review:
  • Establish secure coding guidelines that prohibit dynamic execution or interpretation of user-controlled data within skills or plugins.
  • Use automated code review tools or CI checks to enforce validation and encoding patterns on exposed endpoints and plugin interfaces.

Sources

SourceLink
gist.github.comgist.github.com/YLChen-007/9dd399c6f75b31fa741a613dfd41de08
vuldb.comvuldb.com/cve/CVE-2026-10220
vuldb.comvuldb.com/submit/822018
vuldb.comvuldb.com/vuln/367499
vuldb.comvuldb.com/vuln/367499/cti

Frequently asked

questions

Yes. The issue lies in a remotely reachable skill-serving endpoint, so an attacker who can send crafted requests to hermes-agent can attempt to exploit the injection behavior.

The attacker typically needs network access to the hermes-agent instance and the ability to reach the _serve_plugin_skill/skill_view functionality. No additional local access is required if the instance is exposed over an API or service interface.

The most robust fix is to treat all skill-related inputs as untrusted data: validate them against strict schemas or allowlists, ensure that control flow is not influenced by arbitrary user strings, and apply contextual neutralization before passing data into any downstream component that interprets it.

Adopt a secure-design approach for agent and plugin interfaces: define clear, typed contracts for skills; enforce validation and encoding at every trust boundary; avoid dynamic evaluation of user-controlled content; and integrate security checks (static analysis, code review criteria, and policy enforcement) into the development workflow for all new or modified endpoints.

Find out what's already
exploitable in your codebase.