Automated Threat Modeling

Brief Summary: Incus CVE-2026-130778 TLS Client Certificate Chain Authentication Bypass

A brief summary of CVE-2026-130778, a CVSS 10.0 authentication bypass in Incus before 7.6.0. Appending a trusted public certificate to a TLS client chain grants that identity. Covers the root cause, the affected trust paths, and the upstream fix in commit 8381e54c.

CVE Analysis

9 min read

Gaurav Sarraf
Gaurav Sarraf

2026-11-18

Brief Summary: Incus CVE-2026-130778 TLS Client Certificate Chain Authentication Bypass

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.

AttributeValue
CVECVE-2026-130778
AdvisoryGHSA-xg75-xf37-cph9
CNAVulnCheck
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
WeaknessCWE-287 Improper Authentication; the advisory also lists CWE-295 Improper Certificate Validation
NVD publicationNovember 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:

PathDocumented 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 certificateInternal cluster access and authorization bypass
Self-service renew (doCertificateUpdate) and delete (certificateDelete)Renewal or deletion of any trust store entry
certificatesPostUsed the last certificate in the chain as the caller identity
Host-to-VM agent connectionAuthentication in both directions affected
Authorization scriptletAttacker-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:

  1. The attacker reaches the Incus HTTPS listener over the network.
  2. During an ordinary TLS handshake, the server presents its own public certificate. The attacker records it. No prior access or credential theft is needed.
  3. 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.
  4. The handshake succeeds because the attacker proves possession of the key for the first certificate, and the listener does not verify the chain.
  5. The trust check iterates the chain, matches the appended server certificate against TypeServer trust entries, and treats the request as trusted server traffic, granting database gateway access.
  6. 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 returns false for an empty chain and checks only PeerCertificates[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 uses PeerCertificates[0].
  • cmd/incusd/api_vsock.go and the agent's server.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

ItemStatus
Productlxc Incus, including Go package github.com/lxc/incus/v7/cmd/incusd
AffectedAll versions before 7.6.0
Patched7.6.0 and later
Downstream buildsProtected only if based on 7.6.0 or carrying commit 8381e54c
Exposed configurationAny deployment where the Incus HTTPS listener is reachable by untrusted hosts. Clustered deployments are exposed to cluster identity impersonation.
VM agentHost-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

Detect & fix
what others miss

Works with
  • GitHub
  • GitLab
  • Bitbucket
  • Azure DevOps Services
  • Gerrit
  • CVS
  • Jira
  • Linear
  • Slack
  • Security Compass
Explore integrations
Security magnifying glass visualization