Nov 20, 2026·9 min read·1 visit
Bolt CMS versions prior to 6.1.4 contain an open redirect vulnerability in LoginFormAuthenticator. Both successful and failed login flows fail to validate redirect destinations, allowing attackers to redirect users to external domains via session manipulation or HTTP Referer header injection. Upgrade bolt/core to version 6.1.4 to remediate.
CVE-2026-77376 is an open redirect vulnerability (CWE-601) in the core framework of Bolt CMS prior to version 6.1.4. The vulnerability resides within the LoginFormAuthenticator class, which processes post-authentication redirection for both successful and failed login attempts. Due to a lack of destination validation, the application accepts untrusted target paths from user sessions and directly reflects unvalidated HTTP Referer headers into HTTP Location response headers. Attackers can exploit this behavior to redirect users to arbitrary external domains after interacting with the Bolt login endpoint, facilitating credential harvesting and phishing attacks.
Bolt CMS is an open-source content management system built on the Symfony PHP framework. Authentication within the core package (bolt/core) relies on Symfony's Security component, utilizing custom authenticators to manage user sessions and access control. The Bolt\Security\LoginFormAuthenticator class handles form-based authentication requests submitted via HTTP POST to the /bolt/login route (bolt_login).
In versions of bolt/core prior to 6.1.4, LoginFormAuthenticator contains an open redirect vulnerability classified under CWE-601 (URL Redirection to Untrusted Site). When a user completes an authentication attempt—regardless of whether the credential validation succeeds or fails—the authenticator generates an HTTP redirect response to guide the user to their subsequent destination. However, the authenticator constructs these redirect responses using unvalidated inputs derived from the user session and HTTP request headers.
Because the /bolt/login endpoint is publicly accessible by design, this flaw exposes an unauthenticated attack surface to remote adversaries. An attacker can craft cross-origin requests or manipulate pre-authentication navigation states to supply an arbitrary external URI as the redirect target.
When a victim interacts with the authentication workflow under these conditions, the Bolt application issues an HTTP 302 Found response pointing to the attacker-controlled domain. This mechanism allows adversaries to chain the trusted domain reputation of a legitimate Bolt CMS instance into phishing workflows and credential harvesting operations.
The root cause of CVE-2026-77376 is the direct instantiation of Symfony\Component\HttpFoundation\RedirectResponse with untrusted input inside src/Security/LoginFormAuthenticator.php. In the Symfony framework, the RedirectResponse constructor accepts a target URL string and assigns it directly to the HTTP Location header without verifying whether the URI is relative, scheme-relative, or bound to the local host.
The vulnerability manifests across two distinct code paths within LoginFormAuthenticator: the authentication failure handler (onAuthenticationFailure) and the authentication success handler (onAuthenticationSuccess).
In onAuthenticationFailure(), the authenticator attempts to return the user to their previous page by reading the HTTP Referer header via $request->headers->get('referer'). Because the Referer header is controlled entirely by the client browser and depends on the origin of the initiating request, passing this value directly to new RedirectResponse() creates an immediate open redirect primitive. If a login submission originates from an external domain, the browser transmits that external URL in the Referer header, and Bolt redirects the user back to the external site upon failure.
In onAuthenticationSuccess(), the authenticator determines the post-login destination by querying the user session for _security.<firewallName>.target_path. If an attacker can influence the value stored in this session variable prior to authentication—such as through query parameter injection or unvalidated pre-login route interception—passing the retrieved string directly to RedirectResponse allows external redirection immediately after valid credentials are submitted.
A secondary technical indicator of this flaw was present in the project's static analysis configuration (phpstan-baseline.php). The baseline explicitly suppressed a PHPStan type error noting that $request->headers->get('referer') returns string|null while RedirectResponse expects a strict string. Rather than validating the input or providing a safe default route, the developer baseline ignored the type mismatch, leaving the unvalidated header pass-through intact.
Commit db37ed5d7563f19e57597671598e284c9b34456c resolves CVE-2026-77376 by modifying src/Security/LoginFormAuthenticator.php and updating phpstan-baseline.php. The patch eliminates direct reliance on RedirectResponse for dynamic URLs and removes usage of the HTTP Referer header during authentication failures.
Below is the diff for src/Security/LoginFormAuthenticator.php:
@@ -18,20 +18,23 @@
use Symfony\Component\Security\Http\Authenticator\Passport\Badge\UserBadge;
use Symfony\Component\Security\Http\Authenticator\Passport\Credentials\PasswordCredentials;
use Symfony\Component\Security\Http\Authenticator\Passport\Passport;
+use Symfony\Component\Security\Http\HttpUtils;
use Symfony\Component\Security\Http\SecurityRequestAttributes;
class LoginFormAuthenticator extends AbstractAuthenticator implements AuthenticatorInterface
{
public function __construct(
private readonly Security $security,
private readonly UserRepository $userRepository,
- private readonly RouterInterface $router
+ private readonly RouterInterface $router,
+ private readonly HttpUtils $httpUtils,
) {
}
public function supports(Request $request): ?bool
{
- return $request->attributes->get('_route') === 'bolt_login' && $request->isMethod('POST');
+ return $request->attributes->get('_route') === 'bolt_login'
+ && $request->isMethod(Request::METHOD_POST);
}
public function authenticate(Request $request): Passport
@@ -68,7 +71,7 @@ public function onAuthenticationSuccess(Request $request, TokenInterface $token,
$fallback = $this->router->generate('homepage');
}
- return new RedirectResponse($request->getSession()->get(
+ return $this->httpUtils->createRedirectResponse($request, $request->getSession()->get(
'_security.' . $firewallName . '.target_path',
$fallback
));
@@ -81,6 +84,6 @@ public function onAuthenticationFailure(Request $request, AuthenticationExceptio
}
// Redirect back to where we came from
- return new RedirectResponse($request->headers->get('referer'));
+ return new RedirectResponse($this->router->generate('bolt_login'));
}
}To secure the success path, the patch injects Symfony\Component\Security\Http\HttpUtils into the LoginFormAuthenticator constructor. In onAuthenticationSuccess(), the direct new RedirectResponse(...) call is replaced with $this->httpUtils->createRedirectResponse($request, ...). Internally, HttpUtils::createRedirectResponse() calls HttpUtils::generateUri(), which parses the target path and compares its host and scheme against the current Request object. If the target path points to an external domain, HttpUtils strips the external host or falls back to the local application context.
To secure the failure path, the patch removes $request->headers->get('referer') entirely from onAuthenticationFailure(). Instead, it passes $this->router->generate('bolt_login') to RedirectResponse. Because the Symfony RouterInterface generates a deterministic, internal path for the bolt_login route, external redirection via failed login attempts is no longer possible.
> [!NOTE]
> The patch also cleans up phpstan-baseline.php by removing the ignored error rule for LoginFormAuthenticator.php, as $this->router->generate('bolt_login') is guaranteed to return a non-null string.
The fix is complete for the LoginFormAuthenticator component. By delegating URI validation to Symfony's native HttpUtils utility on success and enforcing a hardcoded internal route on failure, both injection vectors are neutralized against standard open redirect bypass techniques (such as protocol-relative URLs like //evil.example).
Exploiting CVE-2026-77376 requires no authentication privileges (PR:N), though it requires user interaction (UI:R) where a victim clicks a link or submits a form controlled or initiated by an attacker. Two primary exploitation scenarios exist corresponding to the two flawed methods.
The most direct exploitation vector targets onAuthenticationFailure(). An attacker hosts a web page on an external domain (https://attacker.example/session-timeout) containing an HTML form that automatically submits an invalid POST request to the target Bolt CMS instance (https://target-bolt.example/bolt/login).
<!-- Hosted at https://attacker.example/redirect.html -->
<!DOCTYPE html>
<html>
<body onload="document.forms[0].submit()">
<form action="https://target-bolt.example/bolt/login" method="POST">
<input type="hidden" name="login[username]" value="invalid_user" />
<input type="hidden" name="login[password]" value="invalid_pass" />
</form>
</body>
</html>When the victim visits the attacker's page (or clicks a link on the attacker's page that triggers a cross-origin POST), the browser dispatches the HTTP POST request to https://target-bolt.example/bolt/login with the HTTP header Referer: https://attacker.example/redirect.html (assuming the attacker's page sets a permissive Referrer-Policy such as unsafe-url).
Because the credentials (invalid_user) fail validation or lack a valid CSRF token, Bolt invokes onAuthenticationFailure(). The server extracts the Referer header and responds with:
HTTP/1.1 302 Found
Location: https://attacker.example/redirect.htmlThe victim sees their browser interact with the legitimate target-bolt.example domain before landing back on attacker.example, where the attacker can present a cloned Bolt CMS login interface indicating that authentication failed and prompting the user to re-enter their credentials.
The second vector targets onAuthenticationSuccess(). In Symfony applications, when an unauthenticated user attempts to access a protected route, the firewall stores the requested URL in the session key _security.<firewallName>.target_path before redirecting the user to the login page. If the application or a custom route listener permits an attacker to populate _security.<firewallName>.target_path with an arbitrary external URL (or a protocol-relative path such as //attacker.example), the payload remains dormant in the user's session during login.
Once the victim enters valid credentials on /bolt/login, onAuthenticationSuccess() retrieves the unvalidated session value and emits an HTTP 302 Found redirect to the external domain. Because this redirect occurs immediately after a legitimate login, the victim is seamlessly transitioned from an authenticated CMS workflow to an adversary-controlled server.
CVE-2026-77376 is rated at a CVSS v3.1 base score of 6.1 (Medium) with the vector CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N. The Scope is marked as Changed (S:C) because although the vulnerable component is the Bolt CMS server, the security impact occurs within the victim's browser context as it is redirected to an untrusted third-party security domain.
The primary operational impact of this vulnerability is the facilitation of targeted spearphishing campaigns (MITRE ATT&CK T1566.002). Content management systems like Bolt are routinely targeted by adversaries seeking administrative access to deface websites, inject client-side skimmers, or pivot into underlying hosting infrastructure. By leveraging an open redirect on the legitimate /bolt/login endpoint, attackers can make phishing flows appear authentic during user inspection and evade basic email or web gateway filters that inspect initial landing domains.
In addition to credential harvesting via spoofed post-redirect login forms, open redirects in authentication flows carry a secondary risk of sensitive data exposure. If any upstream authentication middleware, analytics script, or custom appendage attaches query parameters or tokens to the state before or during redirection, those parameters may be leaked to the external domain either directly in the redirected URL or via subsequent Referer header transmission.
There is no direct impact to system availability (A:N), and the vulnerability does not allow direct server-side code execution or unauthorized database read access without first capturing valid user credentials through user interaction.
The primary remediation for CVE-2026-77376 is to upgrade the bolt/core package to version 6.1.4 or later. This version incorporates commit db37ed5d7563f19e57597671598e284c9b34456c, which enforces host-bound redirection via Symfony's HttpUtils and hardcodes the failure redirect destination to the internal bolt_login route.
Administrators managing Bolt installations via Composer can apply the update by executing:
composer update bolt/core --with-dependenciesAfter updating the package, clear the Symfony application cache to ensure the updated LoginFormAuthenticator service definition (which now injects Symfony\Component\Security\Http\HttpUtils via dependency injection) is compiled into the service container:
php bin/console cache:clear --env=prodFor environments where an immediate upgrade of bolt/core is not feasible, administrators can implement a mitigation at the reverse proxy or web server tier (such as Nginx or Apache). By inspecting outbound HTTP 302 responses originating from /bolt/login, the proxy can rewrite any Location header pointing to an external domain back to the local /bolt/login path.
Below is an example Nginx configuration snippet using proxy_redirect (or header_filter_by_lua / map directives depending on the FastCGI setup) to strip external redirects on the login endpoint:
location = /bolt/login {
# Standard PHP-FPM / proxy pass configuration
try_files $uri /index.php$is_args$args;
}
# If running behind an Nginx reverse proxy:
proxy_redirect ~^https?://(?!cms\.example\.com)(.*)$ /bolt/login;
proxy_redirect ~^//(?!cms\.example\.com)(.*)$ /bolt/login;CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
bolt/core Bolt | < 6.1.4 | 6.1.4 |
| Attribute | Detail |
|---|---|
| CVE ID | CVE-2026-77376 (GHSA-xr6g-7g83-j865) |
| Vulnerability Class | CWE-601: URL Redirection to Untrusted Site ('Open Redirect') |
| Affected Component | Bolt\Security\LoginFormAuthenticator (bolt/core < 6.1.4) |
| CVSS v3.1 Score | 6.1 Medium (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N) |
| Attack Vector | Network (Unauthenticated HTTP POST to /bolt/login) |
| Impact | Post-authentication open redirection enabling phishing and credential harvesting |
| Exploit Status | None / Advisory Only (No public exploits tracked in KEV or ExploitDB) |
| Fixed Version | bolt/core 6.1.4 |
An HTTP parameter or header may contain a URL value and could cause the web application to redirect the request to the specified URL. By submitting the URL value of a malicious site, an attacker may successfully launch a phishing scam and steal user credentials or authentication tokens.
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.
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.
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.
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.