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

CVE-2026-77377: Authenticated Server-Side Request Forgery in Bolt CMS Backend Asynchronous Endpoints

Amit Schendel
Amit Schendel
Senior Security Researcher

Nov 20, 2026·10 min read·1 visit

Executive Summary (TL;DR)

Authenticated users in Bolt CMS prior to 6.1.4 can trigger Server-Side Request Forgery via the /async/upload-url and /async/embed endpoints to query internal networks and cloud metadata services. Upgrade bolt/core to 6.1.4 or later to enforce scheme and IP address validation via UrlSafetyChecker.

Bolt CMS (bolt/core) versions prior to 6.1.4 contain a Server-Side Request Forgery (SSRF) vulnerability in the authenticated URL-upload (/async/upload-url) and media embed (/async/embed) endpoints. Backend users with file upload or media embedding privileges can supply arbitrary URLs that the application fetches without destination IP validation. This allows authenticated attackers to force the server to initiate HTTP requests to loopback interfaces, RFC 1918 private networks, and cloud instance metadata services.

Vulnerability Overview

Bolt CMS is an open-source content management system built on the Symfony framework and distributed via Packagist as bolt/core. To support editorial workflows, the Bolt backend exposes asynchronous endpoints that allow authenticated content managers to import remote media files and fetch oEmbed metadata from external web pages. These features are handled by the UploadController and EmbedController classes inside the Bolt\Controller\Backend\Async namespace.

In versions of bolt/core prior to 6.1.4, both the remote URL upload endpoint (/async/upload-url) and the media embed endpoint (/async/embed) suffer from a Server-Side Request Forgery (SSRF) vulnerability tracked as CVE-2026-77377 (CWE-918). When an authenticated backend user submits a target URL to either endpoint, the server parses and requests the remote resource on behalf of the user. Prior to version 6.1.4, the application validated only basic syntactic URL formatting and session CSRF tokens before dispatching the outbound network request.

Because the application performed no destination host resolution or IP address range verification, an attacker with backend credentials could specify URLs pointing to internal network resources. This includes loopback interfaces (127.0.0.1, [::1]), private RFC 1918 network ranges (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16), and link-local cloud instance metadata endpoints (169.254.169.254).

Exploitation requires an active session with permissions to either upload files or fetch embed data (fetch_embed_data). Once authenticated, an attacker can leverage the Bolt server as an HTTP proxy to interact with internal services that are segmented from the public internet, scan internal ports, or exfiltrate sensitive cloud infrastructure credentials.

Root Cause Analysis

The root cause of CVE-2026-77377 is the absence of URI scheme restriction, DNS resolution verification, and destination IP address filtering prior to initiating server-side HTTP connections across two distinct asynchronous controllers. Both controllers trusted user-controlled string parameters extracted from the HTTP POST body after passing basic Symfony request validation.

The first vulnerable code path resides in Bolt\Controller\Backend\Async\UploadController::handleURLUpload, which handles requests routed to /async/upload-url. This method extracts the url parameter from the request, verifies the CSRF token, and uses Symfony's validator component to check that the input conforms to standard URL syntax. Once syntactic validation passes, the controller immediately initiates a file transfer from the remote location into a temporary directory (kernel.cache_dir/tmpupload). Because standard URL validators consider http://127.0.0.1/ and http://169.254.169.254/ syntactically valid, the file retrieval mechanism executes requests against internal sockets without restriction.

The second vulnerable code path resides in Bolt\Controller\Backend\Async\EmbedController::fetchEmbed, which services /async/embed. Access to this controller is gated by the #[IsGranted(attribute: 'fetch_embed_data')] attribute and a CSRF token validation check. The controller reads the url parameter via $request->request->getString('url') and passes it directly into the third-party Embed\Embed library ((new EmbedFactory())->get($url)).

When EmbedFactory::get() is invoked, its underlying PSR-18 HTTP client immediately dispatches outbound HTTP GET requests to the target URL to scrape HTML meta tags, OpenGraph data, and oEmbed discovery headers. Neither the Bolt controller nor the default configuration of the Embed factory restricts outbound connections to public routable IP spaces. Consequently, the HTTP client follows the user-supplied hostname or IP literal directly into local or private network segments.

Code Analysis

The vulnerability was remediated across commits 4be8861fb5dd3706db363598631026d683bbf4b7 and c5686bfacc4461cb141b38cc5ff00d7bd224f5f2 by introducing a dedicated utility class, Bolt\Utils\UrlSafetyChecker, and invoking it in both controllers before any network I/O occurs.

In src/Controller/Backend/Async/EmbedController.php, the unpatched code passed the request parameter straight to EmbedFactory inside a single try block. The patch extracts the url parameter first and passes it to UrlSafetyChecker::assertSafe($url):

// File: src/Controller/Backend/Async/EmbedController.php
public function fetchEmbed(Request $request): JsonResponse
{
    try {
        $this->validateCsrf('editrecord');
    } catch (InvalidCsrfTokenException) {
        return new JsonResponse([
            'error' => [
                'message' => 'Invalid CSRF token',
            ],
        ], Response::HTTP_FORBIDDEN);
    }
 
    $url = $request->request->getString('url') ?? '';
 
    // PATCH: Validate scheme, resolve DNS, and enforce public IP range before fetching
    try {
        UrlSafetyChecker::assertSafe($url);
    } catch (Throwable $e) {
        return new JsonResponse([
            'error' => [
                'message' => $e->getMessage(),
            ],
        ], Response::HTTP_BAD_REQUEST);
    }
 
    try {
        $info = (new EmbedFactory())->get($url);
        $oembed = $info->getOEmbed();

An identical pre-check was added to src/Controller/Backend/Async/UploadController.php inside handleURLUpload immediately before the temporary upload path is allocated. The core defense logic resides in src/Utils/UrlSafetyChecker.php:

// File: src/Utils/UrlSafetyChecker.php
class UrlSafetyChecker
{
    private const ALLOWED_SCHEMES = ['http', 'https'];
 
    public static function assertSafe(string $url): void
    {
        $parts = parse_url($url);
 
        if (! is_array($parts) || empty($parts['scheme']) || empty($parts['host'])) {
            throw new RuntimeException('The provided URL is not valid.');
        }
 
        // 1. Enforce strict scheme allowlist (blocks file://, phar://, gopher://, etc.)
        $scheme = mb_strtolower($parts['scheme']);
        if (! in_array($scheme, self::ALLOWED_SCHEMES, true)) {
            throw new RuntimeException(sprintf('The URL scheme "%s" is not allowed.', $scheme));
        }
 
        // 2. Normalize IPv6 literals by stripping bracket notation (e.g., [::1] -> ::1)
        $host = mb_trim($parts['host'], '[]');
 
        // 3. Resolve hostname to all associated IPv4 and IPv6 records
        $ips = self::resolveHost($host);
        if ($ips === []) {
            throw new RuntimeException('The host of the provided URL could not be resolved.');
        }
 
        // 4. Reject the URL if ANY resolved IP falls within private or reserved ranges
        foreach ($ips as $ip) {
            if (! self::isPublicIp($ip)) {
                throw new RuntimeException('The provided URL resolves to a non-public IP address and is not allowed.');
            }
        }
    }
 
    private static function isPublicIp(string $ip): bool
    {
        // Unwrap IPv4-mapped IPv6 addresses (e.g., ::ffff:127.0.0.1 -> 127.0.0.1)
        // to prevent bypassing IPv4 private range checks via IPv6 notation.
        if (mb_stripos($ip, '::ffff:') === 0) {
            $mapped = mb_substr($ip, 7);
            if (filter_var($mapped, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4) !== false) {
                $ip = $mapped;
            }
        }
 
        return filter_var(
            $ip,
            FILTER_VALIDATE_IP,
            FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE
        ) !== false;
    }
}

The UrlSafetyChecker implementation addresses several common SSRF filter bypass techniques. It restricts protocols strictly to http and https, neutralizing local file inclusion via file:// or PHP stream wrappers like phar:// and php://. Furthermore, in resolveHost(), it queries both DNS_A and DNS_AAAA records via dns_get_record() (falling back to gethostbynamel()), ensuring that dual-stack hosts with an internal IPv6 address and a public IPv4 address are blocked if any returned record is non-public. It also explicitly unpacks IPv4-mapped IPv6 addresses (::ffff:x.x.x.x) before applying PHP's FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE filters.

> [!NOTE] > Fix Completeness Assessment: While UrlSafetyChecker effectively blocks direct IP literals, IPv4-mapped IPv6 bypasses, and standard DNS records pointing to internal ranges, the validation is decoupled from the downstream HTTP clients (EmbedFactory and file stream copy). Because UrlSafetyChecker::assertSafe() performs a DNS lookup prior to the downstream client performing its own independent DNS lookup and HTTP connection, a Time-of-Check to Time-of-Use (TOCTOU) window exists for DNS rebinding attacks. In addition, if a remote public server responds with an HTTP 301 or 302 redirect pointing to http://127.0.0.1/ or http://169.254.169.254/, the downstream HTTP client may follow the redirect without re-invoking UrlSafetyChecker::assertSafe().

Exploitation

To exploit CVE-2026-77377, an attacker must possess valid authentication credentials for a Bolt CMS backend account that has permissions to create/edit content (providing the fetch_embed_data permission) or upload media files. The attacker must also obtain a valid CSRF token (editrecord or upload) from an authenticated backend page.

In a cloud-hosted deployment such as Amazon Web Services (AWS) EC2 where Instance Metadata Service Version 1 (IMDSv1) is enabled, the attacker can target the link-local metadata endpoint 169.254.169.254. By sending a crafted HTTP POST request to /async/embed or /async/upload-url, the attacker instructs the Bolt server to fetch IAM role credentials or instance configuration data:

POST /async/embed HTTP/1.1
Host: bolt-target.example.com
Cookie: PHPSESSID=a1b2c3d4e5f6g7h8i9j0
Content-Type: application/x-www-form-urlencoded
X-Requested-With: XMLHttpRequest
 
url=http%3A%2F%2F169.254.169.254%2Flatest%2Fmeta-data%2Fiam%2Fsecurity-credentials%2F&token=valid_csrf_token

When targeting /async/upload-url, the attacker can cause the application to download the HTTP response body from an internal service and save it as a media file inside the Bolt CMS uploads directory, provided the response or URL structure satisfies downstream media extension/MIME checks. This allows full read exfiltration of internal HTTP responses.

POST /async/upload-url HTTP/1.1
Host: bolt-target.example.com
Cookie: PHPSESSID=a1b2c3d4e5f6g7h8i9j0
Content-Type: application/x-www-form-urlencoded
X-Requested-With: XMLHttpRequest
 
url=http%3A%2F%2F127.0.0.1%3A8080%2Fadmin%2Fconfig.json&token=valid_csrf_token

Even when the response cannot be parsed as valid oEmbed JSON or saved as an uploaded file, an attacker can perform blind and error-based reconnaissance of the internal network. By observing variations in HTTP response latency and error messages returned by the JSON API (such as connection refused, timeout, or invalid oEmbed content), the attacker can map active hosts and open TCP ports on the loopback interface and local subnets.

On patched systems running Bolt 6.1.4 or later, both requests are intercepted by UrlSafetyChecker::assertSafe() before any socket connection is attempted, returning an HTTP 400 Bad Request response containing {"error":{"message":"The provided URL resolves to a non-public IP address and is not allowed."}}.

Impact Assessment

CVE-2026-77377 is assigned 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 Attack Vector is Network (AV:N) and Attack Complexity is Low (AC:L), as exploitation requires only standard HTTP requests to the backend endpoints. The score is moderated by High Privileges Required (PR:H), reflecting the requirement for an authenticated backend user account with specific editorial or administrative capabilities.

The Confidentiality impact is rated High (C:H). In cloud environments (AWS, GCP, Azure, DigitalOcean) where metadata endpoints accept plain HTTP GET requests without custom metadata headers, SSRF directly enables the extraction of temporary cloud IAM credentials, service account tokens, and instance user-data scripts. In on-premises or containerized deployments, attackers can read unauthenticated internal dashboards, metrics endpoints, or management APIs bound to 127.0.0.1.

The Integrity impact is rated Low (I:L), and Availability impact is None (A:N). Because the outbound requests generated by EmbedController and UploadController are HTTP GET requests without attacker-controlled request headers or request bodies, the ability to modify internal state is limited to internal services that perform state-changing operations via GET parameters.

According to threat intelligence data, CVE-2026-77377 is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog, has no observed associations with ransomware campaigns, and maintains an EPSS score below 0.001. Public exploit maturity is limited to functional test cases included in the vendor patch commits.

Remediation

Organizations running Bolt CMS must upgrade the bolt/core package to version 6.1.4 or later. Version 6.1.4 integrates Bolt\Utils\UrlSafetyChecker into both /async/upload-url and /async/embed, blocking non-HTTP/HTTPS schemes and any hostname or IP literal that resolves to private, loopback, or reserved IP ranges.

To apply the update using Composer, execute the following commands from the Bolt project root directory:

composer update bolt/core --with-dependencies
composer show bolt/core

Verify that the output of composer show bolt/core reports version 6.1.4 or higher, and clear the Symfony application cache (php bin/console cache:clear) to ensure the updated controller definitions are active.

For environments where immediate patching is not feasible, or to establish defense-in-depth against potential DNS rebinding and HTTP redirect bypasses, operators should implement infrastructure-level mitigations:

  1. Enforce Cloud Metadata Protection (IMDSv2): On AWS EC2 instances, enforce session-oriented IMDSv2 by requiring PUT requests with custom TTL headers (HttpTokens=required) and set the metadata response hop limit to 1. Because the SSRF in Bolt CMS only dispatches standard GET requests without custom headers, enforcing IMDSv2 neutralizes AWS metadata credential theft.
  2. Egress Network Filtering: Configure host-level firewall rules (iptables, nftables) or cloud security groups to prevent the web server user/process 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), link-local space (169.254.0.0/16), and non-essential loopback ports.
  3. Restrict Backend Permissions: Audit existing Bolt CMS user accounts and revoke fetch_embed_data and file upload permissions from untrusted or low-privilege backend roles via config/bolt/permissions.yaml.

Official Patches

Bolt CMSGitHub Security Advisory GHSA-2535-j2pq-qq4r
Bolt CMSBolt Core 6.1.4 Official Release
Bolt CMSUploadController SSRF Patch Commit
Bolt CMSEmbedController SSRF Patch Commit

Fix Analysis (2)

Technical Appendix

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

Affected Systems

Bolt CMS Core (bolt/core) < 6.1.4

Affected Versions Detail

Product
Affected Versions
Fixed Version
bolt/core
Bolt CMS
< 6.1.46.1.4
AttributeDetail
Vulnerability TypeCWE-918: Server-Side Request Forgery (SSRF)
CVSS v3.1 Score5.2 Medium (CVSS:3.1/AV:N/AC:L/PR:H/UI:R/S:U/C:H/I:L/A:N)
Affected Packagebolt/core (Packagist) < 6.1.4
Patched Version6.1.4
Vulnerable EndpointsPOST /async/upload-url and POST /async/embed
Authentication RequiredYes (Backend user with upload or fetch_embed_data permission)
Exploit StatusPoC / Regression Test Cases Available
CISA KEV StatusNot Listed

MITRE ATT&CK Mapping

T1190Exploit Public-Facing Application
Initial Access
T1005Data from Local System
Collection
T1552.005Cloud Instance Metadata API
Credential Access
CWE-918
Server-Side Request Forgery (SSRF)

The web server receives a URL or similar request from an upstream component and retrieves the contents of this specified URL, but does not sufficiently ensure that the request is being sent to the expected destination.

Vulnerability Timeline

Pull request created and fix commits (4be8861fb5dd3706db363598631026d683bbf4b7 and c5686bfacc4461cb141b38cc5ff00d7bd224f5f2) authored.
2026-06-11
Bolt CMS version 6.1.4 released containing the UrlSafetyChecker SSRF mitigations.
2026-07-04
CVE-2026-77377 and GitHub Security Advisory GHSA-2535-j2pq-qq4r officially published.
2026-11-19

References & Sources

  • [1]CVE-2026-77377 Official Record
  • [2]NVD Vulnerability Detail: CVE-2026-77377
  • [3]GitHub Security Advisory GHSA-2535-j2pq-qq4r
  • [4]Patch Commit: Prevent SSRF in upload-from-URL endpoint
  • [5]Patch Commit: Prevent SSRF in embed endpoint and add controller-level SSRF tests
  • [6]Bolt Core Release 6.1.4
  • [7]Fix Pull Request (Vondry/bolt-cms#3)
  • [8]CVEProject cvelistV5 Entry for CVE-2026-77377

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 2 hours ago•CVE-2026-77379
5.3

CVE-2026-77379: Information Disclosure in Bolt CMS Public Relation API

Bolt CMS prior to version 6.1.4 contains an information disclosure vulnerability in its public Relation API endpoints. The Doctrine ORM query extension (ContentExtension) fails to filter out unpublished, draft, or viewless content when querying the Relation entity. Because the Relation resource is configured with public read access (PUBLIC_ACCESS) via API Platform REST and GraphQL endpoints, unauthenticated remote attackers can enumerate relationship graphs, entity identifiers, and metadata associated with private content.

Alon Barad
Alon Barad
2 views•9 min read
•about 2 hours ago•CVE-2026-77380
5.2

CVE-2026-77380: Server-Side Request Forgery via Unchecked Redirects in Bolt CMS

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.

Alon Barad
Alon Barad
4 views•10 min read
•about 3 hours ago•CVE-2026-77378
6.5

CVE-2026-77378: Authenticated SQL Injection in Bolt CMS ListFormatHelper

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.

Alon Barad
Alon Barad
4 views•11 min read
•about 5 hours ago•CVE-2026-77382
5.9

CVE-2026-77382: Cryptographic Precision Loss in falcon-rust Discrete-Gaussian Sampler

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.

Amit Schendel
Amit Schendel
4 views•11 min read
•about 6 hours ago•CVE-2026-62955
7.2

CVE-2026-62955: Authenticated Path Traversal and Remote Code Execution via realpath() Bypass in baserCMS BcThemeFileService

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.

Amit Schendel
Amit Schendel
6 views•11 min read
•about 7 hours ago•CVE-2026-63012
6.5

CVE-2026-63012: Authorization Bypass and Information Disclosure in baserCMS Administrative API

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.

Alon Barad
Alon Barad
3 views•9 min read