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-28423

SSRF and Configuration Exfiltration via Glide Integration in Statamic CMS

Amit Schendel
Amit Schendel
Senior Security Researcher

Mar 1, 2026·6 min read·51 visits

Executive Summary (TL;DR)

Unauthenticated attackers can abuse the Glide image proxy in Statamic to read internal network resources (SSRF) and extract application secrets via template injection. Fixed in 5.73.11 and 6.4.0.

A critical security flaw exists in Statamic CMS versions prior to 5.73.11 and 6.4.0, involving the interaction between the Glide image manipulation library and the Antlers template engine. When Glide is configured in insecure mode (lacking signature verification), unauthenticated attackers can exploit a logic flaw in path normalization to perform Server-Side Request Forgery (SSRF) and inject Antlers template tags into image parameters to exfiltrate sensitive application configuration, including database credentials and API keys.

Vulnerability Overview

Statamic CMS integrates the Glide library to handle on-the-fly image manipulation, resizing, and watermarking. This functionality is exposed via specific routes that accept parameters such as src (source image) and mark (watermark). The vulnerability arises from a lack of strict input validation and context isolation when processing these parameters, specifically when Glide is configured without a signing key.

The flaw manifests in two distinct attack vectors. First, the application fails to properly validate the src parameter against internal path traversal when resolving relative URLs, allowing an attacker to coerce the server into fetching arbitrary external or internal resources (SSRF). Second, the mark parameter is passed to the Antlers template engine for evaluation without adequate sandboxing. This permits the injection of template tags that are evaluated within the application's context, leading to the disclosure of sensitive configuration data.

Root Cause Analysis

The vulnerability stems from three converging architectural failures:

1. Insecure Default Configuration Support: Statamic allows Glide to operate in an "insecure mode" where the key configuration option is null. In this state, the application does not verify the cryptographic signature (s parameter) of the request, allowing attackers to modify image manipulation parameters arbitrarily.

2. Template Engine Context Exposure: When processing the watermark (mark) parameter, the string is evaluated by the Antlers engine. Prior to version 5.73.11, the evaluation context included the entire application configuration array via config()->all(). This meant that standard template tags could access high-value secrets, such as {{ config:app:key }} or {{ config:database:connections:mysql:password }}.

3. Path Normalization Logic Error: The src/Sites/Site.php class contained a flaw in how it normalized relative paths. The method used Str::removeLeft($url, $this->absoluteUrl()) to strip the site's base URL from the requested asset path. If the absolute URL contained a trailing slash (e.g., https://example.com/) and the attacker supplied a malformed URL like https://example.com/http://169.254.169.254, the function would strip the prefix and leave the absolute URL http://169.254.169.254. This result was then processed by the HTTP client, triggering an outbound request to the internal address.

Code Analysis

The remediation addresses both the path normalization logic and the data exposure in the template engine.

Path Normalization Fix (src/Sites/Site.php)

The vulnerable code naively stripped the absolute URL prefix. The patch ensures the base URL is normalized (trailing slash removed) before attempting to strip it from the input. This forces the resulting string to be treated as a path relative to the root rather than a new absolute URI scheme.

// Vulnerable Implementation
public function relativePath($url)
{
    // If absoluteUrl() has a trailing slash, it might leave the scheme of a nested URL intact
    return URL::makeRelative(Str::removeLeft($url, $this->absoluteUrl()));
}
 
// Patched Implementation
public function relativePath($url)
{
    // Explicitly remove trailing slash to ensure correct prefix stripping
    $siteUrl = Str::removeRight($this->absoluteUrl(), '/');
    return URL::makeRelative(Str::removeLeft($url, $siteUrl));
}

Context Restriction Fix (src/View/Cascade.php)

Previously, the view cascade injected all configuration values into the Antlers context. The patch introduces a strict allowlist, exposing only safe configuration items required for frontend rendering.

// Vulnerable: Exposes all config, including env secrets
// $data = array_merge($data, config()->all());
 
// Fixed: Uses a defined allowlist
public static function config(): array
{
    $defaults = ['app.name', 'app.url', 'app.locale', ...];
    // Only keys in the allowlist are merged into the view context
    // ... logic to filter config ...
}

Exploitation Methodology

Exploitation requires that the Statamic instance has Glide configured without a signing key. This is common in development environments or misconfigured production sites.

Scenario 1: Information Disclosure (Antlers Injection)

The attacker sends a request to a Glide endpoint with a malicious mark parameter. The server interprets the parameter as a path to a watermark image but first evaluates it as an Antlers template.

GET /img/asset.jpg?mark={{ config:database:connections:mysql:password }} HTTP/1.1
Host: target.com

If successful, the Antlers engine resolves the tag to the actual database password. While the resulting string is likely an invalid file path, the error message generated by the application (or the reflection of the path in the response) typically leaks the evaluated content.

Scenario 2: Server-Side Request Forgery (SSRF)

The attacker targets the image proxy functionality to access cloud metadata services. By crafting a URL that abuses the path normalization bug, they bypass the restriction that usually limits src to local assets.

GET /img/proxy?src=https://target.com/http://169.254.169.254/latest/meta-data/iam/security-credentials/ HTTP/1.1
Host: target.com

The removeLeft function strips https://target.com/, leaving http://169.254.169.254/.... The backend HTTP client then fetches this URL. The response body (AWS credentials) may be returned as a corrupted image stream or revealed in debug output.

Impact Assessment

The impact of this vulnerability is significant due to the nature of the data exposed. While it requires a specific configuration ('insecure mode'), the consequences of exploitation are severe.

Confidentiality (High): The ability to dump config()->all() provides attackers with database credentials, mail server passwords, third-party API keys (AWS, Stripe), and the Laravel APP_KEY. Possession of the APP_KEY can often be escalated to Remote Code Execution (RCE) via deserialization attacks if the attacker can interact with session cookies or encrypted payloads.

SSRF Impact: Access to internal network services allows attackers to map the internal network, interact with unauthenticated services (like Redis or Memcached), or retrieve cloud instance credentials. This can lead to full infrastructure compromise depending on the permissions attached to the cloud instance profile.

Remediation and Mitigation

Users must upgrade to Statamic versions 5.73.11 or 6.4.0 immediately. These versions introduce strict configuration allowlisting and fix the path normalization logic.

Configuration Hardening

Regardless of the patch status, administrators should strictly enforce URL signing for Glide. This prevents attackers from tampering with parameters entirely.

// config/statamic/glide.php
'key' => env('STATAMIC_GLIDE_KEY', 'generate-a-long-random-string'),

Defense in Depth

  1. Network Segmentation: Block outbound traffic from the web server to sensitive internal subnets (e.g., 169.254.169.254, 10.0.0.0/8).
  2. WAF Rules: Configure Web Application Firewalls to inspect query parameters for Antlers/Blade syntax (e.g., {{, }}) and common SSRF payloads.

Official Patches

StatamicRelease notes for version 5.73.11
StatamicRelease notes for version 6.4.0

Fix Analysis (2)

Technical Appendix

CVSS Score
6.8/ 10
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:C/C:H/I:N/A:N
EPSS Probability
0.05%
Top 84% most exploited

Affected Systems

Statamic CMS

Affected Versions Detail

Product
Affected Versions
Fixed Version
Statamic CMS
Statamic
< 5.73.115.73.11
Statamic CMS
Statamic
>= 6.0.0, < 6.4.06.4.0
AttributeDetail
CWE IDCWE-918
Secondary CWECWE-200
Attack VectorNetwork
CVSS6.8
Privileges RequiredNone
Exploit StatusPoC Available

MITRE ATT&CK Mapping

T1190Exploit Public-Facing Application
Initial Access
T1552Unsecured Credentials
Credential Access
T1213Data from Information Repositories
Collection
CWE-918
Server-Side Request Forgery (SSRF)

Server-Side Request Forgery (SSRF)

Known Exploits & Detection

GitHub Security AdvisoryOfficial advisory with proof of concept details

Vulnerability Timeline

Initial fix commits pushed
2026-02-23
Vulnerability Published
2026-02-27
Patched versions 5.73.11 and 6.4.0 released
2026-02-27

References & Sources

  • [1]GHSA-cwpp-325q-2cvp

More Reports

•16 minutes ago•CVE-2026-129300
5.3

CVE-2026-129300: Uncaught Exception Denial of Service in SpamScope mail-parser

CVE-2026-129300 (GHSA-xhrq-2mqv-q8wx) is an unhandled exception vulnerability in SpamScope mail-parser, a Python library used to parse raw emails. When processing an email with a malformed Received header containing an out-of-range year or timezone offset, standard library datetime conversion routines raise OverflowError or OSError. Because the internal error handler only caught TypeError and ValueError, these exceptions escape the parser hierarchy, terminating email ingestion pipelines and causing a denial of service.

Alon Barad
Alon Barad
0 views•8 min read
•about 1 hour ago•CVE-2026-129301
6.5

CVE-2026-129301: Security Scanner Evasion and Batch Denial of Service in SpamScope mail-parser via Unhandled Attachment Exceptions

CVE-2026-129301 (GHSA-8cgq-x343-p74c) is an uncaught exception and MIME interpretation conflict vulnerability in the Python email parsing library mail-parser (versions >= 4.6.0 and < 4.6.3). The write_attachments() function iterates over parsed email attachments without per-attachment exception containment. When processing a specially crafted MIME part containing an RFC 2231-encoded null byte in the filename, a basename exceeding filesystem NAME_MAX limits, or a malformed base64 payload, the function raises an unhandled standard library exception (ValueError, OSError, or binascii.Error). This prematurely aborts the attachment extraction loop, preventing subsequent attachments from being written to disk for downstream security inspection while also triggering unhandled worker crashes in applications that only catch MailParserError.

Amit Schendel
Amit Schendel
3 views•11 min read
•about 2 hours ago•CVE-2026-129239
6.5

CVE-2026-129239: Privilege Escalation and Unauthorized Data Exposure in Directus SharesService

Directus versions prior to 12.3.1 contain an authorization bypass and privilege management flaw in the SharesService component. Authenticated non-administrative users with update permissions on the directus_shares collection can modify the user_created, role, item, and collection fields of an existing owned share. Because the update operation validates permissions solely against the pre-update record state without revalidating the modified fields, an attacker can reassign share ownership and role context to an administrator. Subsequent guest access using the share token derives administrative accountability, exposing restricted relational data.

Alon Barad
Alon Barad
3 views•10 min read
•about 3 hours ago•CVE-2026-88987
5.4

CVE-2026-88987: Stored Cross-Site Scripting via XHTML and XML Data URIs in Silverstripe Framework

CVE-2026-88987 (GHSA-qqrg-8jpm-8mph) is a stored Cross-Site Scripting (XSS) vulnerability in the Silverstripe Framework prior to version 6.2.13. The framework's HTML sanitization engine, XssSanitiser, relies on an incomplete regular expression denylist when filtering URI schemes in HTML attributes. Specifically, the sanitizer strips data:text/html URIs but fails to restrict executable XML and XHTML media types such as data:application/xhtml+xml, data:text/xml, and data:application/xml. An authenticated user with content creation privileges can embed crafted data URIs inside HTML attributes like iframe src or object data, leading to arbitrary JavaScript execution when the content is rendered by a victim's browser.

Amit Schendel
Amit Schendel
2 views•9 min read
•about 4 hours ago•CVE-2026-88988
5.4

CVE-2026-88988: Stored Cross-Site Scripting via SVG Data URIs in Silverstripe Framework

A Stored Cross-Site Scripting (XSS) vulnerability exists in Silverstripe Framework versions prior to 6.2.13 within the SilverStripe\Core\XssSanitiser component. The HTML sanitizer fails to strip SVG data URIs (data:image/svg*) from dangerous HTML attributes such as href, src, lowsrc, and data. Authenticated CMS authors can persist crafted SVG data URIs in stored content, leading to arbitrary JavaScript execution in the browser context of users who view or interact with the rendered page.

Alon Barad
Alon Barad
4 views•9 min read
•about 5 hours ago•CVE-2026-88989
4.3

CVE-2026-88989: Authorization Bypass in Silverstripe Framework GridFieldDetailForm

CVE-2026-88989 (tracked as GHSA-3qh3-54qg-gpq3) is a missing authorization vulnerability (CWE-862) in the Silverstripe Framework affecting versions prior to 6.2.13. The flaw exists within the GridFieldDetailForm_ItemRequest request handler, which orchestrates record creation and editing workflows inside the Silverstripe CMS backend. Specifically, the server-side persistence method saveFormIntoRecord() fails to verify whether an authenticated user possesses the necessary creation permissions (canCreate) when processing an unpersisted DataObject record. Consequently, a low-privileged CMS user who has permission to access a GridField interface and edit existing records can bypass role-based creation restrictions. By sending a crafted HTTP POST request directly to the item/new endpoint with the action_doSave parameter, the user can instantiate and persist unauthorized database records. The vulnerability is rated Medium severity with a CVSS v3.1 base score of 4.3 and is remediated in Silverstripe Framework version 6.2.13.

Amit Schendel
Amit Schendel
3 views•10 min read