Oct 10, 2026·4 min read·23 visits
Contao's ModuleSearch failed to filter out stale protected page index entries from database table tl_search when contao.search.index_protected configuration was set to false, resulting in sensitive content disclosure in search results.
An information disclosure vulnerability in Contao CMS allows unauthenticated site visitors to view protected page titles, URLs, and text excerpts through search queries when protected page indexing is disabled after previously being enabled.
Contao is an open-source Content Management System (CMS) built on the Symfony PHP framework. The framework provides indexed full-text search capabilities through ModuleSearch and the underlying database table tl_search. When pages are indexed, metadata including protection status and permitted user groups are recorded alongside textual excerpts.
CVE-2026-107842 represents an information disclosure flaw (CWE-200) located within the ModuleSearch component. The flaw occurs when system administrators toggle the global parameter contao.search.index_protected from true to false. When disabled, the search execution engine stops filtering out previously indexed records that belong to protected pages.
While direct HTTP access control to protected target URLs remains enforced by Contao's access control layer, unauthenticated remote attackers can query the public search endpoint to expose protected page titles, canonical URLs, and indexed content snippets.
Contao's full-text search engine indexes web pages into the tl_search table. Each row in tl_search stores indexed body text alongside metadata columns, specifically protected (a boolean flag indicating if the page requires authentication) and groups (a serialized array of allowed member group IDs).
When contao.search.index_protected is set to true, Contao allows protected pages to be indexed. During search execution, ModuleSearch::compile() queries tl_search and executes an inline filtering callback. This callback evaluates whether the current user possesses authorization for each returned row via ContaoCorePermissions::MEMBER_IN_GROUPS checks.
Prior to the patch, the filtering callback was wrapped in an if condition checking whether contao.search.index_protected was active. If an administrator set contao.search.index_protected to false, no else block existed. Consequently, existing database records in tl_search marked with protected = true were returned directly to unauthenticated visitors without filtering.
The vulnerability was resolved in commit 572686a113bca60f92cf2d0496cf3a74d0b6b457 on August 25, 2026. The patch modifies core-bundle/contao/modules/ModuleSearch.php by introducing an explicit fallback filter when contao.search.index_protected evaluates to false.
// Prior to patch:
if (System::getContainer()->getParameter('contao.search.index_protected')) {
$objResult->applyFilter(static function ($v) {
return empty($v['protected']) || System::getContainer()->get('security.helper')->isGranted(ContaoCorePermissions::MEMBER_IN_GROUPS, StringUtil::deserialize($v['groups'] ?? null, true));
});
}
// Patched logic in core-bundle/contao/modules/ModuleSearch.php:
if (System::getContainer()->getParameter('contao.search.index_protected')) {
$objResult->applyFilter(static function ($v) {
return empty($v['protected']) || System::getContainer()->get('security.helper')->isGranted(ContaoCorePermissions::MEMBER_IN_GROUPS, StringUtil::deserialize($v['groups'] ?? null, true));
});
}
else
{
$objResult->applyFilter(static function ($v) {
return empty($v['protected']);
});
}The added else block enforces strict filtering on search results. When contao.search.index_protected is disabled, the system filters out any result where $v['protected'] is non-empty, preventing historical protected index records from leaking to unauthenticated clients.
Exploitation does not require authentication, specialized tools, or complex payload construction. An attacker submits standard search queries to the target Contao website's search form endpoint (typically /search or pages containing ModuleSearch).
If the website previously indexed protected pages while contao.search.index_protected was enabled, those entries persist in tl_search. Upon querying relevant terms, the search results page renders title links, full target URLs, and contextual excerpts of restricted pages.
The vulnerability is assigned a CVSS v3.1 base score of 5.3 (Medium) with vector string CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N. Direct exposure is limited to search metadata and indexed body text snippets rather than full underlying database records or administrative session access.
Impact severity depends on the nature of information contained within protected pages. If member-only areas contain sensitive technical documentation, draft publications, internal contact lists, or personal identifying information (PII), unauthenticated extraction via targeted search terms represents a partial confidentiality breach.
No integrity loss or system availability disruption occurs as a result of this flaw. Furthermore, direct requests to the exposed target page URLs remain blocked by Contao's page-level security controls.
Software updates have been issued in Contao maintenance releases 5.3.50 and 5.7.12. Administrators operating affected releases should update their dependencies using Composer.
composer update contao/contao --with-dependenciesFor environments where immediate framework upgrades cannot be applied, administrators who disabled contao.search.index_protected must navigate to the Contao Maintenance backend panel and initiate a complete purge and rebuild of the search index. Rebuilding the search index purges existing entries in tl_search, eliminating stale protected index entries.
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
contao/contao Contao | >= 4.0.0, < 5.3.50 | 5.3.50 |
contao/contao Contao | >= 5.4.0-RC1, < 5.7.12 | 5.7.12 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-200 |
| Attack Vector | Network (AV:N) |
| CVSS v3.1 Score | 5.3 (Medium) |
| EPSS Score | 0.00262 (16.62th percentile) |
| Impact | Partial Information Disclosure |
| Exploit Status | Unproven / No Public Exploits |
| CISA KEV Status | Not Listed |
The product exposes sensitive information to an actor who is not authorized to have access to that information.
CVE-2026-28385 (GHSA-3gq2-x4qg-p4g6) is a Server-Side Request Forgery (SSRF) vulnerability in Canonical LXD versions 4.12 through 6.9. An authenticated user possessing the can_create_images entitlement can force the LXD daemon to execute arbitrary outbound HTTP and HTTPS requests via the /1.0/images API endpoint. Due to the absence of egress destination validation, an attacker can probe host loopback services, RFC 1918 private network segments, and cloud Instance Metadata Services (IMDS) from the network position of the privileged LXD daemon.
Canonical LXD and LXC Incus contain an arbitrary file write vulnerability (CWE-73 / CWE-59) in the `/1.0/instances/<name>/exec` REST API endpoint. When an instance is unpacked from an image archive, top-level symbolic links are extracted directly onto the host filesystem within the instance storage directory. If a crafted image includes a symbolic link named `exec-output` pointing to an arbitrary host path, invoking the execution endpoint with `record-output: true` causes the privileged host daemon to follow the symlink and write command output files directly to the target host directory. An authenticated attacker with permissions to import images and execute commands can exploit this flaw to write controlled content to sensitive host directories such as `/etc/cron.d`, resulting in arbitrary code execution on the host as `root`.
CVE-2026-48749 (tracked as GHSA-vghh-5rfx-xhq8 for LXD and GHSA-2q3f-q5pq-g8wv for Incus) is a critical container escape vulnerability in the Canonical LXD and Linux Containers Incus system container managers. By importing a specially crafted container image archive containing duplicate tar member headers, an authenticated attacker can replace the instance rootfs directory with a symbolic link pointing to the underlying host root filesystem. When performing file operations on a stopped container, the privileged forkfile helper binary resolves the symbolic link without confinement and chroots directly into the host filesystem, granting arbitrary root-level file read and write access.
GHSA-fmc8-p6q7-75cc (associated with CVE-2026-48755) is a critical argument injection vulnerability in Canonical LXD (github.com/canonical/lxd). The vulnerability occurs during instance and storage volume backup operations when processing the user-supplied compression_algorithm configuration parameter. While LXD validates the primary executable token against an allowlist of supported compression binaries, it fails to sanitize or restrict subsequent tokens parsed via shellquote.Split. These additional arguments are passed directly to exec.Command. An authenticated attacker with privileges to trigger backups can inject command-line flags for utilities like zstd to read staged files from a container filesystem and write them to arbitrary paths on the underlying host filesystem, such as /etc/cron.d/, achieving root-level arbitrary code execution on the host.
A critical path traversal vulnerability caused by improper input validation (CWE-20) exists in the direct image download handler of Canonical LXD and Linux Containers Incus. When an authenticated user requests an image import using the URL source type, the daemon reads the image fingerprint from an untrusted HTTP response header (`Incus-Image-Hash` or `LXD-Image-Hash`) without validating that it conforms to a SHA-256 format. This unvalidated string is concatenated directly into a filesystem path via `filepath.Join` prior to file creation and cryptographic verification, allowing directory traversal sequences to write arbitrary files on the host filesystem as root.
CVE-2026-9639 (GHSA-j93m-3j9p-m5m8) is a null pointer dereference vulnerability in Canonical LXD affecting versions 5.0.0 through 5.21.4 and 6.0 through 6.8. The flaw resides in the (*lxdBackend).CreateCustomVolumeFromBackup method within lxd/storage/backend_lxd.go. An authenticated attacker with the can_create_storage_volumes permission can upload a crafted custom volume backup tarball that omits the expires_at field on a snapshot entry, triggering an unhandled SIGSEGV panic and terminating the LXD daemon.