Aug 5, 2026·5 min read·39 visits
Ghost Admin did not rotate session identifiers upon login. This allowed session fixation attacks, enabling attackers with subdomain or domain-level cookie injection capabilities to hijack administrative sessions.
A critical session fixation vulnerability exists in the Ghost Admin panel from version 2.2.0 until 6.54.1. The Express-based authentication backend fails to invalidate or rotate the session identifier during login, allowing attackers to hijack administrative sessions.
The Ghost content management system uses an Express-based backend to manage administrator authentication and session states. The administration interface, known as Ghost Admin, exposes API endpoints designed to authenticate users and issue session tokens. Historically, this authentication workflow accepted existing session cookies without validating whether they were established prior to authentication.
This behavior exposes the application to session fixation vulnerabilities categorized under CWE-384. By maintaining the same session identifier before and after a user logs in, the backend fails to separate unauthorized and authorized states. If an attacker can inject a chosen session ID into a victim's browser, the attacker can hijack the session once the victim authenticates.
The vulnerability originates in the administrative session establishment process managed by the createSessionForUser function in the authentication service. When an administrator authenticates via the /ghost/api/admin/session/ endpoint, the server processes the login request and updates the current session state stored in the backend database. However, the system does not generate a new cryptographic session key.
Instead, the server maps the authenticated user metadata onto the existing, pre-login session object associated with the incoming request. Because this pre-login session identifier remains completely unchanged, any party holding the original cookie gains immediate administrative privileges upon the user's successful authentication. Successful exploitation relies on a secondary mechanism to plant the pre-login cookie, such as cookie tossing from a co-hosted subdomain or exploiting local cross-site scripting.
In vulnerable versions of Ghost, the session setup routine directly retrieved and modified the existing session object. The following code demonstrates the lack of session regeneration:
// Vulnerable Implementation
async function createSessionForUser(req, res, user) {
const session = await getSession(req, res);
const origin = getOriginOfRequest(req);
await assignUserToSession({
session,
user,
origin
});
}The fix introduced in version 6.54.1 remediates this flaw by invoking the regenerate() function provided by express-session. This method destroys the previous session identifier and replaces it with a new, cryptographically secure token. The patch also copies necessary metadata, such as multi-factor authentication challenges, while isolating user contexts:
// Patched Implementation in v6.54.1
async function createSessionForUser(req, res, user) {
const previousSession = await getSession(req, res);
const {
user_id: previousUserId,
verified: previousVerified,
auth_code_challenge: previousAuthCodeChallenge,
auth_code_generated_at: previousAuthCodeGeneratedAt
} = previousSession;
await new Promise((resolve, reject) => {
req.session.regenerate((err) => {
if (err) {
reject(err);
return;
}
resolve();
});
});
const session = req.session;
session.user_id = previousUserId;
session.verified = previousUserId && previousUserId !== user.id ? undefined : previousVerified;
session.auth_code_challenge = previousAuthCodeChallenge;
session.auth_code_generated_at = previousAuthCodeGeneratedAt;
const origin = getOriginOfRequest(req);
await assignUserToSession({
session,
user,
origin
});
}Exploitation of CVE-2026-70594 requires the attacker to plant a known session cookie into the target user's browser. Since Ghost Admin restricts cookie paths, the attacker must bypass domain isolation boundaries to perform a cookie injection or cookie tossing attack. This requires hosting a malicious application on a sibling subdomain or exploiting a secondary vulnerability on the same parent domain.
Once the victim's browser is loaded with the fixated cookie, the victim visits the Ghost Admin panel and enters their credentials. The Ghost server updates the backend storage associated with the fixated cookie. The attacker, who already possesses this cookie value, can then access administrative endpoints directly without prompting for credentials.
Successful exploitation of this session fixation vulnerability grants the attacker full administrative access to the Ghost CMS backend. Administrative access allows the compromise of publishing rights, enabling attackers to inject malicious scripts, modify public articles, or deface the site. Furthermore, the attacker gains access to the database of registered users, API keys, and system configuration settings.
The CVSS v3.1 base score is 6.7, reflecting a Medium severity rating. The attack vector is restricted to adjacent networks or specific local-domain topologies due to cookie domain constraints. High confidentiality, integrity, and availability impacts are limited only by the privileges associated with the targeted administrator account.
To remediate the vulnerability, deployers must update their installations to Ghost version 6.54.1 or later. This version incorporates the req.session.regenerate() logic to ensure immediate invalidation of the pre-login session. To apply the patch, run ghost update within the server command-line interface.
In environments where patching cannot be completed immediately, apply defense-in-depth domain isolation. Do not co-host untrusted applications on sibling subdomains of the same parent domain. Configure reverse proxies to set the HostOnly attribute on administrative cookies and enforce strict SameSite=Lax or SameSite=Strict directives to limit unauthorized session manipulation.
CVSS:3.1/AV:A/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:L| Product | Affected Versions | Fixed Version |
|---|---|---|
Ghost TryGhost | >= 2.2.0, < 6.54.1 | 6.54.1 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-384 |
| Attack Vector | Adjacent Network |
| Attack Complexity | High |
| CVSS Score | 6.7 (Medium) |
| Exploit Status | Proof-of-Concept |
| CISA KEV Status | Not Listed |
The application authenticates a user without first invalidating the existing session identifier, thereby keeping the same session identifier after authentication.
GHSA-fmc8-p6q7-75cc (associated with CVE-2026-48755) is a critical argument injection vulnerability in Canonical LXD (github.com/canonical/lxd). The vulnerability occurs during instance and storage volume backup operations when processing the user-supplied compression_algorithm configuration parameter. While LXD validates the primary executable token against an allowlist of supported compression binaries, it fails to sanitize or restrict subsequent tokens parsed via shellquote.Split. These additional arguments are passed directly to exec.Command. An authenticated attacker with privileges to trigger backups can inject command-line flags for utilities like zstd to read staged files from a container filesystem and write them to arbitrary paths on the underlying host filesystem, such as /etc/cron.d/, achieving root-level arbitrary code execution on the host.
A critical path traversal vulnerability caused by improper input validation (CWE-20) exists in the direct image download handler of Canonical LXD and Linux Containers Incus. When an authenticated user requests an image import using the URL source type, the daemon reads the image fingerprint from an untrusted HTTP response header (`Incus-Image-Hash` or `LXD-Image-Hash`) without validating that it conforms to a SHA-256 format. This unvalidated string is concatenated directly into a filesystem path via `filepath.Join` prior to file creation and cryptographic verification, allowing directory traversal sequences to write arbitrary files on the host filesystem as root.
CVE-2026-9639 (GHSA-j93m-3j9p-m5m8) is a null pointer dereference vulnerability in Canonical LXD affecting versions 5.0.0 through 5.21.4 and 6.0 through 6.8. The flaw resides in the (*lxdBackend).CreateCustomVolumeFromBackup method within lxd/storage/backend_lxd.go. An authenticated attacker with the can_create_storage_volumes permission can upload a crafted custom volume backup tarball that omits the expires_at field on a snapshot entry, triggering an unhandled SIGSEGV panic and terminating the LXD daemon.
An operating system command injection vulnerability (CWE-78) exists in GeoNode versions prior to 5.1.0. The vulnerability occurs in the vector upload processing pipeline when handling user-supplied geospatial files. By supplying a crafted layer name containing shell metacharacters, an authenticated attacker with basic data upload privileges can execute arbitrary commands on the underlying server or container hosting the GeoNode application and Celery worker processes.
GeoNode versions prior to 5.0.3 contain an unrestricted file upload vulnerability (CWE-434) within the document and dataset ingestion architecture. Authenticated low-privileged users can bypass upload validation via direct REST API interactions, file extension masquerading, metadata mutation via PATCH requests, or malicious archive submissions. This allows attackers to store and serve dangerous file types, alter on-disk file references, or trigger path traversal and resource exhaustion during archive extraction.
CVE-2026-55649 is a stored Cross-Site Scripting (XSS) vulnerability in GeoNode versions prior to 5.0.3. The flaw exists because document abstract metadata fields are ingested via the metadata management pipeline and stored in the backend database without HTML sanitization or input neutralization. An authenticated attacker with privileges to create or edit document metadata can inject arbitrary HTML and JavaScript payloads into these fields. When another user, such as an administrator, views the affected document page or catalog listing, the unencoded payload is rendered into the Document Object Model (DOM) and executes within the victim's browser session.