Introduction
Any client able to reach the HTTPS listener of an Incus server older than 7.6.0 could be accepted as a trusted identity, including the server itself or another cluster member, without ever holding that identity's private key. Because Incus manages containers and virtual machines through a single REST API, this trust failure extends past ordinary client login into cluster internals, the certificate trust store, and authorization scriptlet decisions.
Incus is a system container, application container, and virtual machine manager maintained under the Linux Containers project. It exposes one REST API for local and remote management across multiple storage and network backends. It is Apache 2 licensed free software for deployments from a single laptop or cloud instance up to full server racks, and Zabbly offers commercial support. The official material does not publish market share or installed base figures. Incus began in August 2023 as a community fork of LXD, which is why a closely related certificate chain flaw was also disclosed for Canonical's LXD under a separate identifier, CVE-2026-112816.
| Attribute | Value |
|---|---|
| CVE | CVE-2026-130778 |
| Advisory | GHSA-xg75-xf37-cph9 |
| CNA | VulnCheck |
| CVSS 4.0 (VulnCheck) | 10.0 Critical, CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:H |
| CVSS 3.1 (Incus advisory) | 10.0 Critical, CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H |
| Weakness | CWE-287 Improper Authentication; the advisory also lists CWE-295 Improper Certificate Validation |
| NVD publication | November 18, 2026 |
The two scores come from different CVSS versions, so they do not conflict. Both describe network-reachable exploitation with low complexity, no privileges, and no user interaction.
Technical Information
How Incus authenticates remote clients
Incus serves its remote API over HTTPS and supports two authentication methods: TLS client certificates and OpenID Connect. For certificate authentication, the server compares the client certificate against entries in its trust store, which hold different certificate types: server (cluster) certificates, metrics certificates, and regular client certificates.
Root cause: trusting certificates whose keys were never proven
The HTTPS listener asks for client certificates using Go's tls.RequestClientCert and never verifies the presented chain. In that mode, the TLS handshake establishes exactly one fact: the client holds the private key for the first certificate it sends, r.TLS.PeerCertificates[0]. Every certificate after that is simply bytes the client chose to include.
The Incus trust logic did not respect that boundary. Every trust check looped over the entire presented chain and accepted the client if any entry matched the trust store. The fix commit describes the effect plainly: a client could "authenticate as, or take over, any trust entry by appending that entry's public certificate to its own chain."
The pre-patch cluster traffic check in cmd/incusd/daemon.go shows the pattern (reconstructed from the removed lines of the fix diff):
if r.TLS != nil { for _, i := range r.TLS.PeerCertificates { trusted, fingerprint := localUtil.CheckTrustState(*i, trustedCerts[certificate.TypeServer], ...)
Nothing in this loop distinguishes the certificate whose key was proven from certificates the client merely attached. A public certificate, which is not normally a secret, effectively became a bearer credential.
Affected trust paths
The advisory and fix identify the same flawed loop in several places:
| Path | Documented consequence |
|---|---|
Trusted client certificate (TypeClient) | Impersonation without the matching private key |
Trusted metrics certificate (TypeMetrics) | Authentication as the trusted metrics identity |
Server certificate (TypeServer) | Database gateway access |
| Another cluster member's certificate | Internal cluster access and authorization bypass |
Self-service renew (doCertificateUpdate) and delete (certificateDelete) | Renewal or deletion of any trust store entry |
certificatesPost | Used the last certificate in the chain as the caller identity |
| Host-to-VM agent connection | Authentication in both directions affected |
| Authorization scriptlet | Attacker-chosen certificates can influence authorization decisions, including from token and OIDC clients |
The scriptlet issue reaches beyond certificate-authenticated clients. Token and OIDC clients can still present an arbitrary certificate during the TLS handshake, and the scriptlet received the raw r.TLS.PeerCertificates list regardless of how the request was actually authenticated.
Attack flow
Based on the advisory's server certificate scenario:
- The attacker reaches the Incus HTTPS listener over the network.
- During an ordinary TLS handshake, the server presents its own public certificate. The attacker records it. No prior access or credential theft is needed.
- The attacker creates a certificate for which they hold the private key and places it first in their client chain, then appends the server's public certificate.
- The handshake succeeds because the attacker proves possession of the key for the first certificate, and the listener does not verify the chain.
- The trust check iterates the chain, matches the appended server certificate against
TypeServertrust entries, and treats the request as trusted server traffic, granting database gateway access. - Substituting another cluster member's public certificate instead yields internal cluster access with authorization bypassed. Appending a trusted client certificate impersonates that client, and the renew and delete paths allow taking over or removing arbitrary trust entries.
The TLS session is properly encrypted, and the transport cryptography is not at fault. The defect is in identity selection, meaning which certificate the application chooses to treat as the authenticated identity.
Exploitation status
The reviewed advisory and technical reporting describe these capabilities, but they do not establish a confirmed Incus intrusion, a named threat actor, a verified standalone public exploit, or CISA KEV listing. The advisory GHSA-xg75-xf37-cph9 was published October 29, 2026, three weeks before the CVE appeared in NVD, so public technical detail has been available since late October.
Patch Information
Incus fixed this in v7.6.0. The advisory lists versions below v7.6.0 as affected and v7.6.0 and later as patched. The change is commit 8381e54c, titled "incusd: Only trust the key proven client certificate" (paraphrasing the commit title's wording), written by Stéphane Graber and merged into main on October 30, 2026 as part of PR #4293, "Security fixes for Incus 7.6". It touches 6 files, and its message names the advisory.
The commit makes every trust store check match only the first peer certificate. Each loop over r.TLS.PeerCertificates becomes a single check on element [0], guarded by a length check. In cmd/incusd/daemon.go, the patch introduces a single peerCert derived from the key-proven leaf:
var peerCert *x509.Certificate if r.TLS != nil && len(r.TLS.PeerCertificates) > 0 { peerCert = r.TLS.PeerCertificates[0] }
The cluster check then becomes:
if peerCert != nil { trusted, fingerprint := localUtil.CheckTrustState(*peerCert, trustedCerts[certificate.TypeServer], ...)
The same peerCert is used for the server and cluster (TypeServer), metrics (TypeMetrics), and regular client (TypeClient) trust checks, so appending a server certificate observed during a handshake no longer yields cluster-level access. The patch also adds a code comment stating that the listener only proves possession of the first peer certificate's key and that the remainder of the chain must never be matched against the trust store.
Every other occurrence received the same treatment:
internal/server/cluster/tls.go(CheckCert): validates internal cluster traffic against the node's own server certificate and trusted cluster members. It now returnsfalsefor an empty chain and checks onlyPeerCertificates[0], where it previously looped over and logged every certificate.cmd/incusd/certificates.go: the renew (doCertificateUpdate) and delete (certificateDelete) ownership checks now examine only the leaf.certificatesPost, which had taken the last certificate in the chain as the caller identity, now usesPeerCertificates[0].cmd/incusd/api_vsock.goand the agent'sserver.go: both directions of the host-to-VM agent connection now compare only the first certificate against the expected agent or server certificate. The agent side also explicitly rejects an empty chain.internal/server/auth/driver_scriptlet.go: a new helper,clientCertificates(), passes the chain to the scriptlet only when the request was actually authenticated over TLS and the leaf fingerprint matches the authenticated username:
if r.TLS == nil || details.Protocol != api.AuthenticationMethodTLS || len(r.TLS.PeerCertificates) == 0 { return nil, nil } // Only expose the chain when its leaf is the authenticated certificate. if localtls.CertFingerprint(r.TLS.PeerCertificates[0]) != details.Username { return nil, nil }
Why this works. The bug was a mismatch between what the handshake proves and what the code trusts. After the patch, only the certificate whose private key was demonstrated in the handshake can be matched against the trust store. The metrics path still passes the full chain to CheckTrustStateIssuer, which is the separate CA- or issuer-based check. Only the direct trust store comparisons were narrowed to the leaf.
Getting the fix. Upstream, 7.6.0 is the fixed release. The Incus 7.6 release and the maintainer announcement both reference the security fixes. Downstream packages must be based on 7.6.0 or carry commit 8381e54c to be protected.
Until patched. The vendor's interim measure is to restrict network access to the HTTPS listener to trusted hosts, and the advisory states there is no configuration-based workaround. Restricting the listener reduces who can attempt the attack but leaves the defective logic in place.
After patching. Corgea's response guidance recommends restarting incusd after upgrading and reviewing certificate trust entries for unexpected modifications or deletions. That guidance covers this issue together with companion Incus and LXD flaws, so it should be read as investigative hygiene rather than a dedicated indicator of exploitation.
Affected Systems and Versions
| Item | Status |
|---|---|
| Product | lxc Incus, including Go package github.com/lxc/incus/v7/cmd/incusd |
| Affected | All versions before 7.6.0 |
| Patched | 7.6.0 and later |
| Downstream builds | Protected only if based on 7.6.0 or carrying commit 8381e54c |
| Exposed configuration | Any deployment where the Incus HTTPS listener is reachable by untrusted hosts. Clustered deployments are exposed to cluster identity impersonation. |
| VM agent | Host-to-VM agent authentication is affected on unpatched builds |
Version qualification: Corgea reports a 6.0.9 LTS fix in addition to 7.6, but the primary advisory lists only 7.6.0 and later as patched and does not document a separate LTS backport. Treat 6.0.9 as a secondary report until the project confirms it. Canonical LXD is affected by a related but separately tracked issue, CVE-2026-112816, with its own advisory and remediation versions. The identifiers and fixed versions are not interchangeable.
Vendor Security History
Incus has a visible security process. A 7ASecurity audit, requested by the maintainers and funded by the Sovereign Tech Agency, used Incus v6.22.0 as its baseline and combined whitebox testing, runtime validation, fuzzing, supply chain review, and threat modeling. It reported 14 vulnerabilities and 17 hardening recommendations. All 14 vulnerabilities were resolved and confirmed. Of the hardening recommendations, 14 were resolved, and the remaining three documented maintainer decisions or context rather than open vulnerabilities.
The project security page also lists other October 2026 advisories: a Critical issue where restricted users could access host files through backup or image metadata, and a High issue involving local hijacking of VM migration and disk export sockets. Issues can be reported to [email protected] or through GitHub private advisory reporting. Per the published policy, only the latest feature release is supported, while LTS releases receive periodic fixes.
Independent auditing and confirmed remediation are meaningful signals, yet critical trust-boundary flaws still surfaced afterward, in an interface that carries significant authority over hosts and clusters.
References
- NVD: CVE-2026-130778
- CVE Record: CVE-2026-130778
- Incus advisory GHSA-xg75-xf37-cph9: Authentication and authorization bypass through unverified client certificate chains
- GitHub API: Incus advisory GHSA-xg75-xf37-cph9
- Fix commit 8381e54c
- GitHub API: Fix commit 8381e54c
- PR #4293: Security fixes for Incus 7.6
- GitHub API: PR #4293
- Release Incus 7.6
- Announcing Incus 7.6, Stéphane Graber
- Incus security overview
- Rapid7 Vulnerability Database: CVE-2026-130778
- Canonical LXD advisory GHSA-99jp-jwmc-65p4
- Corgea research on the LXD and Incus mTLS certificate chain bypass
- Ostorlab: LXD and Incus mTLS Authentication Bypass
- GBHackers: Critical Incus and LXD Vulnerabilities
- 7ASecurity: Incus security audit
- Linux Containers: Incus announcement
- Linux Containers: Incus introduction
- Incus documentation: Remote API authentication
- Incus documentation: Support
- Linux Containers: Incus news
- CISA Known Exploited Vulnerabilities Catalog



