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

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

Alon Barad
Alon Barad
Software Engineer

Nov 20, 2026·9 min read·2 visits

Executive Summary (TL;DR)

An omitted Doctrine ORM query filter in Bolt CMS before 6.1.4 allows unauthenticated users to retrieve relationship graphs and metadata of unpublished, draft, and viewless content via the public Relation REST and GraphQL API endpoints.

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.

Vulnerability Overview

Bolt CMS (bolt/core) is an open-source content management system built on the Symfony framework and Doctrine ORM. To support headless deployments and external integrations, Bolt integrates API Platform to automatically expose internal data entities as standardized REST and GraphQL endpoints. Access to these endpoints is governed by Symfony security attributes and custom Doctrine ORM query extensions that enforce content visibility rules.

In Bolt CMS versions prior to 6.1.4, the Bolt\Entity\Relation entity is exposed via API Platform with the api:get attribute configured for PUBLIC_ACCESS. A Relation entity defines a directional link between two content records, storing references to both a source content item (fromContent) and a target content item (toContent). Under normal operation, anonymous API consumers should only be permitted to view content items that are explicitly marked as published and belong to publicly visible content types.

The vulnerability classified under CVE-2026-77379 (CWE-402: Transmission of Private Resources into a New Sphere) occurs because the custom Doctrine ORM extension responsible for enforcing publication status and visibility constraints—Bolt\Api\Extensions\ContentExtension—omits filtering logic for the Relation resource class. While direct queries to Content and Field endpoints are properly constrained, queries directed at the /api/relations REST endpoint or the equivalent GraphQL relation resolvers execute without visibility checks.

Consequently, unauthenticated remote actors can query the public Relation API to retrieve relationship records that link unpublished, draft, held, or viewless content items. Because the serialized Relation response embeds references and metadata for both fromContent and toContent, an attacker can reconstruct the internal content relationship graph, confirm the existence of private records, and extract internal entity identifiers.

Root Cause Analysis

The root cause of CVE-2026-77379 is an incomplete implementation of the API Platform query extension interface within src/Api/Extensions/ContentExtension.php. API Platform utilizes Doctrine ORM extensions implementing QueryCollectionExtensionInterface and QueryItemExtensionInterface to intercept and modify the Doctrine QueryBuilder before database queries are executed for collection and single-item operations.

In Bolt CMS, ContentExtension inspects the $resourceClass parameter passed to applyToCollection() and applyToItem(). Prior to version 6.1.4, the extension only evaluated two conditional branches: one for Bolt\Entity\Content::class and one for Bolt\Entity\Field::class. When a request targeted Content::class, the extension invoked filterUnpublishedViewlessContent(), appending AND clauses to the Doctrine query to ensure status = 'published' and excluding any content types marked as viewless: true in contenttypes.yaml.

When a request targeted Field::class, the extension invoked filterUnpublishedViewlessFields(), performing an inner join against the parent content association and applying the identical status and content type constraints. However, the developers failed to implement a third conditional branch for Bolt\Entity\Relation::class. When API Platform processed a GET request for /api/relations or /api/relations/{id}, ContentExtension returned early without modifying the QueryBuilder.

A critical aspect of relational data modeling in Bolt CMS is that a Relation connects two distinct Content entities (fromContent and toContent). For a relationship to be safely exposed to an unauthenticated consumer, both endpoints of the relation must independently satisfy public visibility requirements. If either fromContent or toContent is in a draft, timed, or held state, or belongs to a viewless content type, exposing the relation record leaks the existence and metadata of the restricted entity on the private end of the association.

Code Analysis

Analyzing the vulnerable code in src/Api/Extensions/ContentExtension.php prior to commit 577b2232209c9285143a2f505ca306416b38f3f9 demonstrates how the resource class dispatch omitted the Relation entity:

// Vulnerable code in src/Api/Extensions/ContentExtension.php (Prior to 6.1.4)
public function applyToCollection(
    QueryBuilder $queryBuilder,
    QueryNameGeneratorInterface $queryNameGenerator,
    string $resourceClass,
    ?Operation $operation = null,
    array $context = []
): void {
    if ($this->security->isGranted('ROLE_ADMIN')) {
        return;
    }
 
    if ($resourceClass === Content::class) {
        $this->filterUnpublishedViewlessContent($queryBuilder);
    }
 
    if ($resourceClass === Field::class) {
        $this->filterUnpublishedViewlessFields($queryBuilder);
    }
    // Missing check for Relation::class
}

Because Relation::class was not matched in applyToCollection() or applyToItem(), the raw QueryBuilder selected all rows from the bolt_relation table without joining or verifying the status of the associated bolt_content records.

The patch introduced in commit 577b2232209c9285143a2f505ca306416b38f3f9 resolves the vulnerability by importing Bolt\Entity\Relation, checking for Relation::class in both interception methods, and introducing the filterUnpublishedViewlessRelations() private method:

// Patched code in src/Api/Extensions/ContentExtension.php (Version 6.1.4)
public function applyToCollection(
    QueryBuilder $queryBuilder,
    QueryNameGeneratorInterface $queryNameGenerator,
    string $resourceClass,
    ?Operation $operation = null,
    array $context = []
): void {
    // ... existing checks ...
    if ($resourceClass === Relation::class) {
        $this->filterUnpublishedViewlessRelations($queryBuilder);
    }
}
 
private function filterUnpublishedViewlessRelations(QueryBuilder $queryBuilder): void
{
    $rootAlias = $queryBuilder->getRootAliases()[0];
 
    // Join both ends of the relation to verify visibility on both sides
    $queryBuilder->join($rootAlias . '.fromContent', 'relation_from');
    $queryBuilder->join($rootAlias . '.toContent', 'relation_to');
    $queryBuilder->andWhere('relation_from.status = :status');
    $queryBuilder->andWhere('relation_to.status = :status');
 
    $queryBuilder->setParameter('status', Statuses::PUBLISHED);
 
    if ($this->viewlessContentTypes->isNotEmpty()) {
        $queryBuilder->andWhere('relation_from.contentType NOT IN (:cts)');
        $queryBuilder->andWhere('relation_to.contentType NOT IN (:cts)');
        $queryBuilder->setParameter('cts', $this->viewlessContentTypes);
    }
}

The fix is structurally complete for the Relation entity. By performing an inner join() on both .fromContent (aliased as relation_from) and .toContent (aliased as relation_to) and applying andWhere() constraints requiring Statuses::PUBLISHED and non-membership in $this->viewlessContentTypes for both aliases, Doctrine ORM guarantees that a relation is omitted if either connected content record is non-public. The patch also includes unit tests in tests/php/Api/ContentExtensionTest.php verifying the generated DQL for both collection and item operations.

Exploitation

Exploitation of CVE-2026-77379 requires no authentication, no specialized privileges, and no user interaction. The only prerequisite is network access to a Bolt CMS instance running a version prior to 6.1.4 where the API Platform endpoints (/api) are reachable by external clients (the default configuration).

An attacker can exploit this flaw using standard HTTP GET requests against the REST API or POST queries against the GraphQL endpoint. To enumerate all content relationships via the REST API, the requester issues a collection query to /api/relations:

GET /api/relations?page=1&itemsPerPage=100 HTTP/1.1
Host: target-bolt-cms.example.com
Accept: application/ld+json

In a vulnerable installation, the server responds with a 200 OK status and a JSON-LD payload containing an array of Relation objects under hydra:member. Each object includes the IRIs and embedded properties of fromContent and toContent, even when one or both of those content items are unpublished drafts or belong to viewless content types:

{
  "@context": "/api/contexts/Relation",
  "@id": "/api/relations",
  "@type": "hydra:Collection",
  "hydra:member": [
    {
      "@id": "/api/relations/42",
      "@type": "Relation",
      "fromContent": "/api/contents/108",
      "toContent": "/api/contents/215",
      "name": "related_articles"
    }
  ]
}

By cross-referencing the content IDs discovered in /api/relations against the direct /api/contents/{id} endpoint (which properly returns 404 Not Found or filters out unpublished entries), an attacker can systematically identify which content IDs correspond to hidden or draft items. Furthermore, if GraphQL is enabled, the attacker can query nested relational fields to extract additional relational topology and metadata without authenticating.

> [!NOTE] > As of the latest threat intelligence assessment, no public proof-of-concept exploit tools or active exploitation campaigns in the wild have been observed for CVE-2026-77379.

Impact Assessment

CVE-2026-77379 is rated as a Medium severity vulnerability with a CVSS v3.1 base score of 5.3 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N). The Attack Vector is Network (AV:N), Attack Complexity is Low (AC:L), Privileges Required is None (PR:N), and User Interaction is None (UI:N), reflecting that the affected API endpoints are publicly accessible by default and trivial to query.

The impact is strictly confined to Confidentiality (C:L), with no impact on Integrity (I:N) or Availability (A:N). The vulnerability does not permit unauthenticated attackers to modify database records, elevate privileges, or execute arbitrary code. Furthermore, because ContentExtension still enforces filters on direct Content and Field resource queries, attackers cannot trivially dump the full body text of an unpublished article solely through the Content endpoint.

However, the confidentiality exposure is significant for organizations using Bolt CMS to manage confidential workflows, embargoed press releases, internal relational directories, or viewless configuration entities. Viewless content types in Bolt are frequently used by developers to store internal application taxonomies, private customer groupings, or staging linkages that are never meant to be rendered on a public URI.

By enumerating the /api/relations endpoint, an attacker can map out the exact structural connections between published items and upcoming unpublished drafts, determine the rate of internal content creation via sequential entity ID inspection, and identify the relationship names (name property) binding private objects together.

Remediation

The primary remediation for CVE-2026-77379 is to upgrade bolt/core to version 6.1.4 or later. The fix is included in official release tag 6.1.4 via commit 577b2232209c9285143a2f505ca306416b38f3f9. Administrators managing Bolt CMS installations via Composer should execute the following command from their project root:

composer update bolt/core --with-dependencies
php bin/console cache:clear --env=prod

For deployments where an immediate upgrade to 6.1.4 cannot be performed, administrators can implement one of two effective workarounds. First, if the public REST and GraphQL APIs are not required by unauthenticated frontend clients, access to the /api path prefix should be blocked or restricted to trusted internal IP addresses at the reverse proxy (Nginx, Apache) or Web Application Firewall (WAF) layer.

Second, developers can override the API Platform resource configuration or security policies within their Symfony application to require authentication for the Relation resource. In config/packages/api_platform.yaml or a custom resource configuration override, access to Bolt\Entity\Relation operations can be restricted from PUBLIC_ACCESS to IS_AUTHENTICATED_FULLY or ROLE_ADMIN.

To verify that an instance is properly remediated, security teams should issue an unauthenticated GET request to /api/relations and confirm that any relationship involving a draft, held, or viewless content item is omitted from the response collection, and that direct requests to /api/relations/{id} for such relationships return a 404 Not Found response.

Official Patches

Bolt CMSGitHub commit filtering unpublished and viewless content from the public Relation API
Bolt CMSBolt CMS 6.1.4 release tag containing the security fix
GitHubOfficial GitHub Security Advisory GHSA-6358-jg5p-hmjj

Fix Analysis (1)

Technical Appendix

CVSS Score
5.3/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N

Affected Systems

Bolt CMS (bolt/core)

Affected Versions Detail

Product
Affected Versions
Fixed Version
bolt/core
Bolt
< 6.1.4 (6.0.0-beta.1 through 6.1.3)6.1.4
AttributeDetail
Vulnerability TypeCWE-402: Transmission of Private Resources into a New Sphere
CVSS v3.1 Score5.3 Medium (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N)
Affected ComponentBolt\Api\Extensions\ContentExtension (src/Api/Extensions/ContentExtension.php)
Attack VectorNetwork (Unauthenticated REST /api/relations and GraphQL API queries)
Security ImpactInformation disclosure of unpublished/draft content IDs, existence, and relationship graphs
Patched Versionbolt/core 6.1.4
Exploit StatusNo known public exploits or active exploitation
CISA KEV StatusNot Listed

MITRE ATT&CK Mapping

T1083File and Directory Discovery
Discovery
T1213Data from Information Repositories
Collection
T1592Gather Victim Host Information
Reconnaissance
CWE-402
Transmission of Private Resources into a New Sphere ('Resource Leak')

The software transmits sensitive data, draft objects, or metadata intended for a restricted sphere (administrative drafts and viewless private content) into an unrestricted or public sphere (unauthenticated public API consumers).

Vulnerability Timeline

Vulnerability reported and remediation commit (577b2232209c9285143a2f505ca306416b38f3f9) created by Tomas Vondracek (@Vondry).
2026-06-11
Bolt CMS release 6.1.4 published containing security fixes for CVE-2026-77379.
2026-07-04
GitHub Security Advisory GHSA-6358-jg5p-hmjj published.
2026-11-19
CVE-2026-77379 assigned and indexed by NVD and CVE.org.
2026-11-19

References & Sources

  • [1]GitHub Security Advisory: GHSA-6358-jg5p-hmjj
  • [2]Bolt CMS Fix Commit: 577b2232209c9285143a2f505ca306416b38f3f9
  • [3]Bolt CMS Release 6.1.4
  • [4]Pull Request: Filter unpublished/viewless content from the public Relation API
  • [5]National Vulnerability Database: CVE-2026-77379
  • [6]CVE.org Record: CVE-2026-77379
  • [7]CVEProject cvelistV5 JSON Record: CVE-2026-77379

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 1 hour ago•CVE-2026-77377
5.2

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

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.

Amit Schendel
Amit Schendel
1 views•10 min read
•about 3 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 4 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
5 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