Oct 8, 2026·6 min read·13 visits
An authenticated administrator can cause a permanent Denial of Service (DoS) of the Ghost CMS server by uploading a crafted ZIP containing recursive/nested directory patterns or triggering malicious wildcard domain matching in the external media inliner, freezing the single-threaded Node.js event loop.
CVE-2026-105645 is a regular expression denial of service (ReDoS) vulnerability affecting Ghost, an open-source Node.js content management system. The vulnerability exists within directory import handlers and the external media inliner, allowing authenticated administrators to trigger catastrophic backtracking in the V8 JavaScript engine, resulting in infinite loops, 100% CPU utilization, and total denial of service.
The vulnerability identified as CVE-2026-105645 (GHSA-9m4w-fmjw-fvjq) represents a medium-severity Regular Expression Denial of Service (ReDoS) flaw in the core architecture of Ghost, a widely-deployed open-source Node.js Content Management System (CMS). The defect manifests in two distinct functional modules: the directory import subsystem (responsible for parsing content archives) and the External Media Inliner service (designed to retrieve external media during database migrations).
An authenticated attacker with administrative privileges can exploit this weakness by submitting input patterns specifically crafted to induce catastrophic backtracking in the V8 JavaScript regular expression engine. Because Node.js is built on a single-threaded execution model, a CPU-bound operation like regular expression backtracking blocks the entire event loop, preventing the server from processing any subsequent incoming HTTP requests.
The impact is confined to application availability, resulting in a complete denial of service for the target instance. The issue affects Ghost versions ranging from 5.37.0 up to (but not including) 6.67.0. Mitigation involves updating to version 6.67.0, which introduces comprehensive input escaping for import pathways and enforces execution time limits via a separate virtual machine context for wildcard domain matching.
The fundamental cause of the vulnerability lies in the use of user-controlled inputs during the dynamic compilation of regular expressions. Within the import handlers, Ghost dynamically constructs regular expressions to normalize archive directory layouts and match static file prefixes using path-derived variables such as baseDir and startDir. When constructing these regular expressions, the engine did not escape or validate literal directory paths before appending them directly into the regular expression constructor.
If an administrator uploads an archive where a folder name contains regex metacharacters with nested quantifiers, such as (a+)+b, the variable is evaluated directly. This causes the regular expression parser to interpret the path as an active pattern rather than a literal string. When matching a filename like aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac.jpg against /^(a+)+b//, the engine evaluates exponential combinations of the character group before encountering the non-matching character at the end, leading to catastrophic backtracking.
In the External Media Inliner service, the root cause is slightly different but yields the same system-level outcome. The service parses post contents to discover and download media from external wildcards. Because these external domains contain intentional wildcards (e.g., https?://i[0-9]{1}.wp.com), escaping is not viable. The combined regular expression built to locate matches is evaluated synchronously without any execution time bounds. An attacker-controlled wildcard domain containing nested groupings evaluated against long, repetitive structures inside post contents can indefinitely starve the event loop.
An examination of the fix commit (88ae6d6d56f8a239cb38a8c89de02f034f50e2ce) reveals a two-pronged remediation strategy designed by the maintainers. For the directory import handlers, the dynamic path compilation is secured by integrating lodash's escaping library. By wrapping the variable parameters inside _.escapeRegExp(), all metacharacters are safely escaped, ensuring that V8 evaluates folder structures purely as literal sequences of characters.
In contrast, the External Media Inliner requires wildcard evaluation to perform its core tasks. Because escaping would destroy the wildcard functionality, the developers utilized the Node.js node:vm standard library module. This module permits executing JavaScript scripts within an isolated V8 context under strict performance criteria.
// A snippet illustrating the sandbox matching model introduced in the patch
const vm = require('node:vm');
const FIND_MATCHES_TIMEOUT_MS = 1000;
let findMatchesScript;
let findMatchesContext;
function matchAllWithTimeout(content, regex, timeout) {
if (!findMatchesScript) {
findMatchesScript = new vm.Script('Array.from(content.matchAll(regex), (match) => match[1])');
findMatchesContext = vm.createContext({});
}
findMatchesContext.content = content;
findMatchesContext.regex = regex;
try {
return Array.from(findMatchesScript.runInContext(findMatchesContext, { timeout }));
} finally {
findMatchesContext.content = undefined;
findMatchesContext.regex = undefined;
}
}By executing the regex search within a sandbox with a timeout of 1000 milliseconds, the engine guarantees that any search requiring intensive backtracking is terminated. When the timeout threshold is breached, the runtime throws an ERR_SCRIPT_EXECUTION_TIMEOUT exception, which is caught and handled gracefully by logging the failure and continuing processing. This ensures the single-threaded event loop is freed up for pending networking tasks.
Exploitation requires administrative-level authentication to target either the directory import system or the media inliner configuration settings. An attacker begins by packaging a ZIP archive that mirrors the structure of an image or content import. The attacker names one of the directories within the archive (a+)+b. Inside this directory, the attacker places a file named aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac.jpg.
Upon uploading this file via the Ghost admin control panel, the application invokes the loadFile() method inside the ImporterContentFileHandler or ImageHandler modules. The server extracts the archive, retrieves the path string, and initiates the dynamic compilation step: const baseDirRegex = new RegExp('^' + baseDir + '/'). The resulting regular expression /^(a+)+b// is then matched against the long name of the nested file. This starts the catastrophic backtracking process, forcing the CPU core hosting the Ghost instance to 100% capacity and preventing incoming connection responses.
Alternatively, the attacker can leverage the External Media Inliner. The attacker registers or specifies a domain pattern containing nested-backtracking sequences, such as (a+)+b. By subsequently creating or importing post content that contains a lengthy, repetitive sequence of characters that lacks the terminating character (such as 40 characters of 'a' followed by a 'c'), the attacker triggers the processing queue. When inlineContent() executes, the synchronous call to findMatches() matches the malicious content against the vulnerable domain pattern, stalling the entire application.
This vulnerability has been assigned a CVSS v3.1 base score of 4.9 (Medium), with a vector of CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:N/I:N/A:H. The assessment reflects a high impact on availability, balanced by the requirement for administrative privileges (PR:H). Because administrative access is necessary to initiate ZIP imports or configure external media services, the likelihood of drive-by remote exploitation is minimal.
The consequence of a successful exploitation is a complete Denial of Service (DoS) of the Node.js application process. In single-instance deployments lacking auto-restarts or process monitoring, the server remains in a hung state indefinitely. In containerized environments managed by orchestrators like Kubernetes, the container may eventually trigger a liveness probe failure and restart, but repeated exploitation attempts can lead to a continuous crash-loop state, rendering the platform permanently unavailable.
Furthermore, because the synchronous timeout inside the patched version of the media inliner is capped at 1000 milliseconds, a sequence of multiple crafted payloads can still induce a temporary event loop lag. Although the immediate risk of infinite freezing is mitigated by the VM sandbox, administrators must remain vigilant against potential exploitation windows that could slow down legitimate HTTP traffic.
CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:N/I:N/A:H| Product | Affected Versions | Fixed Version |
|---|---|---|
Ghost TryGhost | >= 5.37.0, < 6.67.0 | 6.67.0 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-1333 |
| Attack Vector | Network |
| CVSS v3.1 Score | 4.9 (Medium) |
| EPSS Score | 0.00327 (Percentile: 23.71%) |
| Impact | Denial of Service (Availability) |
| Exploit Status | Proof of Concept (PoC) |
| KEV Status | Not Listed |
The application uses a regular expression with an inefficient evaluation complexity that can be exploited to consume excessive CPU resources.
NATS Server prior to versions 2.12.8 and 2.14.3 contains an incorrect authorization vulnerability (CWE-863) in its message tracing subsystem. When evaluating whether a connection is permitted to publish trace events to a destination subject specified in the Nats-Trace-Dest header, the server only checks standard client permissions and omits permission checks for leaf node connections. This allows a connected leaf node operator with restricted publishing privileges to emit internal trace events to unauthorized subjects and suppress standard message delivery using the Nats-Trace-Only header.
CVE-2026-63341 is a high-severity Denial of Service (DoS) vulnerability in the Aedes MQTT broker for Node.js affecting all versions prior to 1.1.1. The flaw stems from missing input validation on the hierarchical depth of incoming MQTT topic strings before they are passed to the underlying topic-matching engine, qlobber. Because qlobber enforces a hardcoded limit of 100 topic levels and throws a synchronous exception when this threshold is exceeded, an attacker can send a single MQTT packet containing 101 or more forward-slash-separated levels to trigger an uncaught exception that immediately terminates the Node.js broker process.
CVE-2026-61725 is a path traversal vulnerability (CWE-22) in the sevenz-rust2 Cargo package prior to version 0.21.1. The vulnerability occurs because the decompression utility fails to validate or sanitize archive entry filenames before joining them with the destination directory path via std::path::Path::join. An attacker who supplies a crafted 7z archive containing parent directory traversal sequences or absolute paths can write or overwrite arbitrary files on the host filesystem with the privileges of the extracting process.
CVE-2026-77309 (GHSA-jrjx-9jjw-747m) is a high-severity unauthenticated remote code execution vulnerability affecting NASA-AMMOS AIT-GUI versions 1.0.0 through 2.5.0. The flaw results from chaining an incomplete file cleanup error in the telemetry query endpoint (/tlm/query) with a directory traversal flaw in the script execution endpoint (/script/run). An attacker on an adjacent network can stage arbitrary Python statements into a static file on disk and execute that file under the privileges of the AIT-GUI web server process.
A vulnerability classified under CWE-116 (Improper Encoding or Escaping of Output) exists in memtomem-stm versions 0.1.0 through 0.1.33. The software acts as a Model Context Protocol (MCP) short-term memory proxy gateway for AI agent architectures. When surfacing retrieved memories and scratchpad items into downstream Large Language Model (LLM) context envelopes, the SurfacingFormatter component fails to properly sanitize untrusted memory attributes. An attacker with the ability to plant untrusted content into the agent's long-term or working memory store can inject arbitrary structural delimiters, close the <surfaced-memories> XML boundary prematurely, visually obscure instructions using Unicode bidirectional overrides, and execute stored prompt injection attacks against downstream LLM agents.
CVE-2026-77331 (GHSA-72jh-722p-rqr3) is a concurrency and session-state synchronization vulnerability in memtomem-stm, a short-term memory proxy gateway for AI agents. In versions 0.1.2 prior to 0.1.34, concurrent Model Context Protocol (MCP) Remote Procedure Call (RPC) failures or mid-flight task cancellations can initiate duplicate reconnect loops and permit dirty or cancelled transport sessions to be reused. This deficiency results in session-state integrity loss and local service degradation.