Nov 20, 2026·10 min read·1 visit
Authenticated users with ROLE_EDITOR permissions in Bolt CMS (< 6.1.5) can bypass URL safety checks on the /bolt/async/upload-url and /bolt/async/embed endpoints by supplying a public URL that redirects to internal or link-local IP addresses, resulting in Server-Side Request Forgery (CWE-918).
Bolt CMS prior to version 6.1.5 is vulnerable to Server-Side Request Forgery (SSRF) in its asynchronous URL upload and media embed endpoints. While the application validates the initial user-supplied URL against internal network ranges using UrlSafetyChecker, the underlying HTTP transport libraries automatically follow HTTP 3xx redirects and HTML meta refresh directives without re-validating the target destinations. An authenticated user with editor privileges can exploit this discrepancy via an open redirector or DNS rebinding to access internal network resources and cloud metadata services.
Bolt CMS is an open-source content management system built on the Symfony framework. It provides administrative interfaces for managing digital content, including asynchronous backend utilities that allow content editors to upload files from remote URLs or fetch OpenGraph and oEmbed metadata from external web pages. These operations are handled by the bolt/core package through dedicated controller endpoints.
In bolt/core versions prior to 6.1.5, the asynchronous endpoints /bolt/async/upload-url and /bolt/async/embed contain a Server-Side Request Forgery (SSRF) vulnerability, tracked as CVE-2026-77380 (GHSA-3xjf-9q55-vxw4) and classified under CWE-918. To prevent SSRF attacks, Bolt CMS employs a helper utility named UrlSafetyChecker designed to parse user-supplied URLs, resolve their hostnames, and block requests targeting private, loopback, or link-local IP ranges.
The security control fails because UrlSafetyChecker is executed only once against the initial URL string before the network request is dispatched. The subsequent HTTP retrieval operations are handed off to external libraries—specifically Embed\Embed for metadata scraping and Symfony's Filesystem::copy for remote file downloads—that automatically follow HTTP 3xx redirects and HTML <meta http-equiv="refresh"> directives without invoking UrlSafetyChecker on the redirect destinations.
Furthermore, separating the initial hostname resolution check from the actual socket connection introduces a Time-of-Check to Time-of-Use (TOCTOU) window. An authenticated attacker with privileges to access these endpoints (such as ROLE_EDITOR) can bypass the defensive filter by providing an external URL under their control that redirects to an internal address, or by utilizing a DNS rebinding service that resolves to a public IP during validation and a private IP during the connection phase.
The root cause of CVE-2026-77380 is an architectural decoupling between the URL validation logic and the HTTP transport layer across two distinct controller methods: Bolt\Controller\Backend\Async\EmbedController::fetchEmbed and Bolt\Controller\Backend\Async\UploadController::handleURLUpload. Both methods implement a single-pass validation pattern rather than enforcing network-layer restrictions at connection time.
In EmbedController::fetchEmbed, after UrlSafetyChecker validates the initial input, the controller instantiates the third-party Embed\Embed library via (new EmbedFactory())->get($url). By default, EmbedFactory creates an internal Crawler instance backed by a standard PSR-18 client or cURL handle configured to follow redirects automatically. In addition to following standard HTTP status codes (301, 302, 303, 307, 308), the Embed crawler parses HTML bodies for <meta http-equiv="refresh" content="0;url=..."> tags and follows those targets as well. None of the intermediate hops or final destinations are passed back to UrlSafetyChecker.
In UploadController::handleURLUpload, the controller validates the incoming URL and then executes $this->filesystem->copy($url, $tmpFile). When Symfony's Filesystem::copy is given a remote URL with an http:// or https:// scheme, it relies on PHP's native HTTP stream wrapper (php_stream_url_wrap_http). PHP's native stream wrapper follows up to 20 HTTP redirects by default (max_redirects = 20) at the C level without providing a callback mechanism to inspect intermediate destination IPs.
Because both transport mechanisms operate independently of UrlSafetyChecker, any discrepancy between the validated initial URL and the actual socket connection target results in a complete bypass of the SSRF protection. Whether the target change occurs via an application-layer HTTP redirect, an HTML meta tag redirect, or a DNS rebinding rotation between the DNS lookup in UrlSafetyChecker and the DNS lookup in the HTTP client, the application connects directly to the restricted network address.
The remediation for CVE-2026-77380, introduced in commit 41d7aaf73f7b75c70819208cde513da70f0d2055, replaces the unguarded HTTP transports in both controllers with Symfony's NoPrivateNetworkHttpClient. This decorator wraps an existing HttpClientInterface instance and hooks directly into the DNS resolution and connection lifecycle, inspecting the resolved IP address on every individual network hop before establishing a socket connection.
In src/Controller/Backend/Async/EmbedController.php, the patch injects Symfony's HttpClientInterface via constructor dependency injection. Instead of allowing EmbedFactory to instantiate its own default HTTP client, the patched code wraps the injected client in NoPrivateNetworkHttpClient, adapts it to PSR-18 using Psr18Client, and passes it into Embed\Http\Crawler.
// src/Controller/Backend/Async/EmbedController.php (Before Patch)
try {
$info = (new EmbedFactory())->get($url);
$oembed = $info->getOEmbed();
$response = $oembed->all();
// ...
return new JsonResponse($response);
} catch (RequestExceptionInterface $e) {
// ...
}// src/Controller/Backend/Async/EmbedController.php (After Patch)
try {
// Wrap the Symfony HTTP client with NoPrivateNetworkHttpClient to validate every redirect hop
$client = new Psr18Client(new NoPrivateNetworkHttpClient($this->httpClient));
// Inject the hardened PSR-18 client into the Embed Crawler
$info = (new EmbedFactory(new Crawler($client)))->get($url);
$oembed = $info->getOEmbed();
$response = $oembed->all();
// ...
return new JsonResponse($response);
} catch (Throwable $e) { // Broadened from RequestExceptionInterface to catch Symfony transport exceptions
return new JsonResponse([
'error' => [
'message' => $e->getMessage(),
],
], Response::HTTP_BAD_REQUEST);
}In src/Controller/Backend/Async/UploadController.php, the vulnerable $this->filesystem->copy($url, $tmpFile) call is removed entirely. It is replaced by a dedicated private helper method, downloadUrlToFile(), which streams the response chunks through NoPrivateNetworkHttpClient into a local file handle. Additionally, if an exception occurs during the streaming process (such as a redirect targeting a private IP), the catch block explicitly calls $this->filesystem->remove($tmpFile) to ensure no partial or empty temporary files are left on disk.
// src/Controller/Backend/Async/UploadController.php (After Patch)
try {
$this->filesystem->mkdir($tmpFolder);
// Replace filesystem->copy() with SSRF-guarded chunked download
$this->downloadUrlToFile($url, $tmpFile);
} catch (Throwable $e) {
// Ensure partial files are cleaned up on blocked redirects or transport errors
$this->filesystem->remove($tmpFile);
return new JsonResponse([
'error' => [
'message' => $e->getMessage(),
],
], Response::HTTP_BAD_REQUEST);
}
private function downloadUrlToFile(string $url, string $tmpFile): void
{
// Enforce private IP blacklisting at the socket connection level for all hops
$client = new NoPrivateNetworkHttpClient($this->httpClient);
$response = $client->request('GET', $url);
$handle = fopen($tmpFile, 'wb');
if ($handle === false) {
throw new RuntimeException('Unable to open temporary file for writing.');
}
try {
foreach ($client->stream($response) as $chunk) {
fwrite($handle, $chunk->getContent());
}
} finally {
fclose($handle);
}
}> [!NOTE]
> Assessment of Fix Completeness: The introduction of NoPrivateNetworkHttpClient effectively addresses both the redirect bypass and the DNS rebinding TOCTOU flaw. Because NoPrivateNetworkHttpClient resolves the hostname itself and binds the underlying transport to the verified IP address on every redirect hop (and because Embed\Http\Crawler executes <meta http-equiv="refresh"> requests through the provided PSR-18 client), both HTTP 3xx and HTML meta redirects are subjected to IP filtering. UrlSafetyChecker remains in place as an initial scheme (http/https) and syntax filter.
Exploiting CVE-2026-77380 requires an authenticated session on the target Bolt CMS instance. Both affected controllers enforce access control attributes via Symfony's security component: EmbedController requires the fetch_embed_data permission attribute, and UploadController requires the upload permission attribute. In a default Bolt CMS configuration, these permissions are granted to users assigned ROLE_EDITOR or higher (ROLE_ADMIN, ROLE_DEVELOPER). Both endpoints also validate a Cross-Site Request Forgery (CSRF) token via CsrfTrait.
To execute the attack, the adversary first sets up an external web server on a public IPv4 address with a valid domain name (e.g., https://attacker.example.com). This server is configured with an endpoint that returns an HTTP 302 Found redirect pointing to an internal target, such as the AWS/OpenStack Instance Metadata Service (IMDSv1) at http://169.254.169.254/latest/meta-data/iam/security-credentials/ or an internal service listening on http://127.0.0.1:8080/.
HTTP/1.1 302 Found
Location: http://169.254.169.254/latest/meta-data/
Content-Length: 0
Connection: closeAlternatively, if targeting the /bolt/async/embed endpoint, the attacker can return an HTTP 200 OK response containing an HTML <meta http-equiv="refresh"> tag, which the Embed crawler will parse and follow:
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="refresh" content="0; url=http://169.254.169.254/latest/meta-data/">
</head>
<body></body>
</html>With the redirector active, the authenticated attacker sends an HTTP POST request to /bolt/async/embed or /bolt/async/upload-url including a valid session cookie, the required _csrf_token parameter, and the url parameter pointing to https://attacker.example.com/redirect.
/bolt/async/embed, the server follows the redirect to the internal resource, parses any HTML metadata or title tags found in the internal response, and returns the extracted data directly in the JSON response body./bolt/async/upload-url, the server downloads the raw response body from the internal endpoint and writes it to the CMS media storage directory (provided the filename extension and content pass subsequent file upload validators), allowing the attacker to retrieve the full response payload by downloading the uploaded file.CVE-2026-77380 carries a CVSS v3.1 base score of 5.2 (Medium) with the vector CVSS:3.1/AV:N/AC:L/PR:H/UI:R/S:U/C:H/I:L/A:N. The score is moderated primarily by the high privilege requirement (PR:H), as anonymous users or low-privileged subscribers cannot invoke the asynchronous backend controllers. However, in multi-user publishing environments where content editors (ROLE_EDITOR) are not trusted with underlying infrastructure access, this vulnerability crosses a critical trust boundary between CMS application users and the host operating environment.
The primary security impact is high confidentiality loss (C:H). By forcing the application server to issue arbitrary HTTP GET requests to internal network segments, an attacker can enumerate internal ports, query unauthenticated REST APIs (such as local Redis HTTP bridges, Elasticsearch clusters, or internal microservices), and extract cloud provider metadata. On cloud deployments using IMDSv1 (which does not require session token headers via PUT requests), an attacker using /bolt/async/upload-url can save temporary IAM role credentials directly into the CMS file storage and download them.
The integrity impact is rated low (I:L). While the HTTP client only issues GET requests during redirect following, internal services that perform state-changing operations via GET parameters can be triggered. Furthermore, the upload endpoint writes the fetched payload to the server's temporary and media directories before validation completes.
There is no known active exploitation of CVE-2026-77380 in the wild. The vulnerability is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog, and no public standalone Proof-of-Concept (PoC) exploits or Nuclei templates have been published at the time of disclosure.
Organizations running Bolt CMS should upgrade the bolt/core package to version 6.1.5 or later. Version 6.1.5 incorporates commit 41d7aaf73f7b75c70819208cde513da70f0d2055, which enforces IP address validation across all redirect hops and resolves the DNS rebinding TOCTOU window. The upgrade can be applied using Composer:
composer update bolt/core --with-dependenciesIf an immediate upgrade is not possible, administrators can apply defense-in-depth measures at the application, host, and cloud infrastructure levels to mitigate the risk of exploitation:
upload and fetch_embed_data permissions (such as ROLE_EDITOR) strictly to trusted personnel. If remote URL uploading or oEmbed fetching is not required by editorial workflows, block requests to /bolt/async/upload-url and /bolt/async/embed at the reverse proxy (Nginx/Apache) or Web Application Firewall (WAF) layer.HttpTokens=required) and setting the PUT response hop limit to 1 (HttpPutResponseHopLimit=1). Because IMDSv2 requires an initial HTTP PUT request with a custom X-aws-ec2-metadata-token-ttl-seconds header, a GET-based SSRF via HTTP redirect cannot retrieve credentials.iptables, nftables) or container network policies to block the web server process user (e.g., www-data) from initiating outbound TCP connections to RFC 1918 private subnets (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16), loopback interfaces (127.0.0.0/8, ::1), and link-local ranges (169.254.0.0/16, fe80::/10).CVSS:3.1/AV:N/AC:L/PR:H/UI:R/S:U/C:H/I:L/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
bolt/core Bolt | < 6.1.5 | 6.1.5 |
| Attribute | Detail |
|---|---|
| Vulnerability Type | Server-Side Request Forgery (CWE-918) |
| Affected Component | bolt/core (EmbedController & UploadController) |
| Vulnerable Endpoints | /bolt/async/embed, /bolt/async/upload-url |
| CVSS v3.1 Score | 5.2 Medium (CVSS:3.1/AV:N/AC:L/PR:H/UI:R/S:U/C:H/I:L/A:N) |
| Authentication Required | Yes (ROLE_EDITOR / upload or fetch_embed_data permission) |
| Patched Version | bolt/core 6.1.5 |
| Exploit Status | No known public exploits or active exploitation |
| CISA KEV Status | Not Listed |
The web server receives a URL or similar request from an upstream component and retrieves the contents of this URL, but it does not sufficiently ensure that the request is being sent to the expected destination.
CVE-2026-77378 (GHSA-r7h9-qx4h-77j5) is an authenticated SQL injection vulnerability affecting the bolt/core package of Bolt CMS in versions prior to 6.1.4. The flaw resides in the ListFormatHelper utility class, where content-type slugs are dynamically interpolated into raw SQL query strings via sprintf rather than bound as parameterized inputs. When the general/caching/list_format configuration directive is enabled, an authenticated user with upload privileges can exploit the /async/select-options endpoint to inject arbitrary SQL commands and query the underlying database.
A cryptographic soundness defect in the discrete-Gaussian sampler of falcon-rust prior to version 0.2.0 degrades acceptance-probability precision to approximately 2^-33. By evaluating exponential approximations using 32-bit fractional fixed-point arithmetic (FixedPoint64) and left-shifting polynomial inputs by 31 bits, the implementation violates Falcon's required precision bound of 2^-40 to 2^-46, invalidating the theoretical security reduction against statistical private key leakage.
CVE-2026-62955 is an authenticated path traversal vulnerability in baserCMS affecting versions 5.2.3 up to, but not including, 5.3.0. The flaw resides in the BcThemeFileService::getFullpath() method within the bc-theme-file plugin and represents an incomplete remediation of CVE-2026-30940. Because the path containment check relies on PHP's realpath() returning a non-false value, supplying a nonexistent theme subdirectory causes the verification guard to be skipped entirely. An authenticated administrator can exploit this flaw to read, write, overwrite, or delete arbitrary files within the permissions of the PHP process, leading to remote code execution when executable PHP files are written to the webroot.
CVE-2026-63012 is an authorization bypass and information disclosure vulnerability in baserCMS versions prior to 5.3.0. An architectural flaw in the authentication service configuration combined with overly permissive API access control rules allows low-privileged operator accounts to query restricted administrative API endpoints by supplying a matching HTTP Referer header.
CVE-2026-102945 is a denial-of-service vulnerability affecting the Access and Mobility Management Function (AMF) of the Aether Project (omec-project/amf) prior to version 3.1.6. When processing an NGAP PathSwitchRequest message over the 3GPP N2 interface, the HandlePathSwitchRequest function fails to verify the byte slice lengths of extensible APER bit strings inside the UESecurityCapabilities Information Element before accessing index zero. Because the NGAP receive goroutine lacks a panic recovery handler, supplying a zero-length bit string triggers an out-of-bounds slice read panic that terminates the entire AMF daemon.
CVE-2026-103025 (GHSA-7hvw-3c2q-45qg) is a high-severity denial-of-service (DoS) vulnerability in github.com/bep/imagemeta prior to version 0.17.3. The PNG metadata parser fails to validate declared chunk lengths prior to heap buffer allocation (CWE-789) and inflates zlib-compressed zTXt IPTC chunks without an output size limit (CWE-409). Additionally, out-of-bounds slice indexing in the PNG zTXt handler and IPTC character set resolver allows remote attackers to trigger runtime panics.