/

CVE-2026-43892

Severity:

HIGH RISK

(8.8)

Code Injection / Cross-Site Scripting in AntSword noxss()

CVE-2026-43892

Deferred

Vulnerability type

Category:

Code Injection / Cross-Site Scripting

CWE:

CWE-79, CWE-94, CWE-1188

Impact:

One-Click Remote Code Execution in the AntSword Environment

Severity:

HIGH RISK

(8.8)

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

AntSword, a cross-platform website management toolkit, contains an incomplete input sanitization issue in its noxss() routine that allows format code injection into the jquery.terminal component.

When a victim triggers a crafted terminal interaction (e.g., by clicking a malicious link or action), attacker-controlled format codes can be executed, ultimately leading to one-click remote code execution in the context of the AntSword application.

Affected context

This vulnerability occurs in AntSword deployments that expose interactive terminal functionality built on top of jquery.terminal and rely on the noxss() helper for sanitizing user-controlled data.

It becomes relevant when untrusted or semi-trusted input is rendered in the terminal interface and interpreted as formatting codes without robust validation.

Typical scenarios include operators viewing or interacting with data returned from remote web shells or backend endpoints that can be influenced by an attacker.

Exploit preconditions

  • Attack surface: AntSword UI terminal interface built on jquery.terminal.
  • Required access: Ability to influence content rendered in the terminal (for example, controlling shell output, server responses, or shared project data) or to convince an operator to load attacker-controlled terminal content via a link, script, or project file.
  • User interaction: A single click or equivalent action by an operator to open or interact with the malicious terminal session or output is generally required.
  • Trigger point: Rendering of attacker-supplied content inside jquery.terminal where formatting codes are parsed and executed.
  • Why exploitation is possible: The noxss() sanitization is incomplete and does not correctly neutralize special sequences that jquery.terminal treats as formatting or command codes, allowing embedded code to be interpreted and executed in the AntSword context.

Why this happens

The root cause is incomplete and overly narrow input sanitization that attempts to prevent XSS but fails to account for the specific interpretation rules of jquery.terminal.

Instead of enforcing a robust allowlist or neutralizing all control sequences that can alter behavior, the noxss() routine leaves format codes intact, which jquery.terminal then processes as executable formatting or script-like commands.

This aligns with:

  • CWE-94: Improper Control of Generation of Code, as untrusted data is allowed to influence code-like behavior within the terminal.
  • CWE-79: Improper Neutralization of Input During Web Page Generation (XSS), because user-controlled data is rendered in a web-based UI without full neutralization.
  • CWE-1188: Insecure Default Initialization of Resource, since the default sanitization and terminal configuration allow powerful behavior by default instead of adopting restrictive-safe defaults.

Potential impact

  • One-click remote code execution within the AntSword environment, potentially allowing execution of arbitrary commands via the managed shells or local environment.
  • Compromise of the operator's session, including access tokens, project configurations, and stored connection details.
  • Ability to pivot from the AntSword UI to backend servers or managed web shells, expanding the attacker's control over target infrastructure.
  • Unauthorized modification of managed sites, defacement, data theft, or deployment of additional malware.
  • Potential use of the compromised AntSword instance as a platform for further lateral movement within the operator's network.

General mitigation guidance

Effective mitigation focuses on aligning input handling with the capabilities of jquery.terminal and reducing trust in any data rendered in the terminal:

  • Prefer strict allowlist-based filtering for terminal output, permitting only known-safe characters and markup, and rejecting or escaping all control and formatting sequences.
  • Normalize and escape user-controllable strings before passing them into terminal rendering functions so that they are treated as plain text, not formatting or commands.
  • Configure UI components with secure-by-default settings, disabling or limiting advanced formatting or scripting features where they are not strictly necessary.
  • Segregate untrusted data flows from sensitive UI functions, ensuring that output coming from remote shells or external sources is always treated as untrusted.
  • Run AntSword and any associated interpreters with least privilege, limiting the impact of any code execution that might occur.

How teams detect issues like this

Organizations can look for this class of issue using both code-centric and behavior-centric approaches:

  • Static analysis and code review:
  • Search for uses of jquery.terminal or similar terminal/console components that directly interpolate user-controlled data.
  • Identify custom sanitization helpers like noxss() and review them for incomplete escaping, blacklist-based logic, or context-agnostic filtering.
  • Flag any code where strings are passed into rendering or evaluation APIs without being encoded for the specific output context (HTML, terminal format, etc.).
  • Policy and tooling:
  • Establish secure coding guidelines requiring context-aware encoding and allowlist validation for all UI-rendered data.
  • Integrate linting or SAST tools that can highlight potential XSS/code injection sinks in UI code and terminal-like components.
  • Runtime monitoring:
  • Monitor for unusual terminal content patterns, such as unexpected control sequences or script-like payloads in logged output.

Sources

SourceLink
github.comgithub.com/AntSwordProject/antSword/security/advisories/GHSA-c63g-p4cp-r45x

Frequently asked

questions

Yes. An attacker who can control data rendered in the AntSword terminal or can entice an operator to load a crafted terminal view can remotely trigger the issue. However, exploitation typically requires that an operator interacts with malicious content (e.g., a single click to open or use the affected terminal/session).

The attacker needs a way to inject or influence content that appears within the jquery.terminal interface, such as controlling shell output, backend responses, or project data. They do not necessarily need direct access to the AntSword host, but they do need influence over what the operator's UI renders.

The safest pattern is to apply strict, context-aware encoding and allowlist validation for any user-controlled content before it reaches UI components capable of interpreting control or formatting codes. Inputs should be treated as untrusted data and rendered as plain text, with all special sequences either removed or safely escaped.

Adopt secure-by-design practices for UI components: disable powerful features by default, require explicit opt-in for formatting or scripting behaviors, and enforce a standard library of encoding/escaping functions. Complement this with regular security reviews, SAST/DAST integration in CI pipelines, and clear internal guidelines on handling terminal-like or rich-text rendering of untrusted data.

Find out what's already
exploitable in your codebase.