CVE
CVE-2026-112816, CVE-2026-48751, CVE-2026-48769, CVE-2026-48755, CVE-2026-48749, CVE-2026-48752, CVE-2026-48750, CVE-2026-12411, CVE-2026-55621, CVE-2026-55622, CVE-2026-9639, CVE-2026-28385
CWE
CWE-295, CWE-287, CWE-863, CWE-22, CWE-78, CWE-59, CWE-88
Affected Surface
- Canonical LXD versions `< 4.0.15` (`4.0/stable`), `< 5.0.11` (`5.0/stable`), `< 5.21.9` (`5.21/stable`), and `< 6.10.1` (`6/stable`), plus Canonical MicroCloud versions `< 2.1.5` (`2/stable`) and `< 3.4.1` (`3/stable`) (`CVE-2026-112816` / `GHSA-99jp-jwmc-65p4` CVSS 10.0 Critical, `CVE-2026-12411` / `GHSA-hhf9-qw4v-72xp` CVSS 8.4 High, `GHSA-47w9-6r3f-938g`, `GHSA-pjff-c2wc-f6jm`, `GHSA-fmc8-p6q7-75cc`, `GHSA-vghh-5rfx-xhq8`, `GHSA-jpf8-86f3-wp38`, and `GHSA-9j25-mm2h-2f76` all CVSS 9.9 Critical)
- Linux Containers Incus (`github.com/lxc/incus`) versions `< 6.0.9` LTS and `< 7.6` (`GHSA-xg75-xf37-cph9` CVSS 10.0 Critical, `GHSA-jcw9-v2ff-8m79`, `GHSA-5pgx-q9xx-j3qv`, `GHSA-3wxw-5gh2-j2x2`, `GHSA-cwg9-8mc4-hf7j`, `GHSA-5c64-j5m6-8433`, `GHSA-p45f-gqqj-6qq3`, `GHSA-q9fc-p923-6vp7`, `GHSA-3rgf-297m-775x`, and nine additional advisories)
- Any host or cluster exposing the LXD (`:8443`) or Incus (`:8443`) HTTPS REST API, cluster listener, or VM `incus-agent` / `lxd-agent` socket to untrusted networks or restricted multi-tenant clients
Update, 8 November 2026: Between 5 and 6 November 2026 (17:40 UTC on 5 November to 19:51 UTC on 6 November), the GitHub Advisory Database and Go Vulnerability Database (GO-2026-6917) published 11 additional reviewed advisories for Canonical LXD (github.com/canonical/lxd), including six Critical (CVSS 9.9) host-escape and command-execution flaws and three High (CVSS 7.7 to 8.4) cross-project/cross-guest volume hijacks:
GHSA-47w9-6r3f-938g(CVE-2026-48751, CVSS 9.9 Critical): Instance snapshots bypassed therestricted.containers.lowlevel=blockproject restriction, allowing a restricted project user to restore or configure low-level hooks (raw.lxc,raw.qemu) and execute arbitrary commands asrooton the LXD host. The corresponding Incus advisory isGHSA-48q5-w887-33wv; the LXD fix is commit5aac658c88.GHSA-fmc8-p6q7-75cc(CVE-2026-48755, CVSS 9.9 Critical): LXD validated user-supplied backupcompression_algorithmstrings by checking only the first whitespace-delimited token against its allowlist before passing the full argument list to the compression command, enabling argument injection for arbitrary host file writes and command execution. LXD splitcompression_algorithmwithshellquote.Split(value)and validated onlyfields[0]against the compressor allowlist (bzip2,gzip,lz4,xz,zstd,tar2sqfs) while forwardingfields[1:]directly tocompressFile()(commit0915bb88cb; corresponding Incus advisoryGHSA-v6mj-8pf4-hhw4).GHSA-vghh-5rfx-xhq8(CVE-2026-48749, CVSS 9.9 Critical),GHSA-jpf8-86f3-wp38(CVE-2026-48752, CVSS 9.9 Critical), andGHSA-9j25-mm2h-2f76(CVE-2026-48750, CVSS 9.9 Critical): Arbitrary host file read and write via symlinks in crafted container images (rootfs/duplicate tar entry,templates/symlink duringarchive.Unpack, andexec-outputdirectory symlink abused through/instances/$name/execwithrecord-output=true).templates/symlink (GHSA-jpf8-86f3-wp38): When importing a container image,shared/archive/archive.gostripped device nodes during tar extraction but preserved a top-leveltemplatessymlink (such asln -s /etc/cron.d templates). Calling the template API (lxc config template ls/show/edit) then read or wrote arbitrary files in/etc/cron.don the host asroot. Fixed in commit190e2451544aby changingRootfsPath()andTemplatesPath()inlxd/instance/drivers/driver_common.goto calld.subPath(), which inspectsos.Lstat(path)and rejects symlinks.exec-outputsymlink (GHSA-9j25-mm2h-2f76): When calling/1.0/instances/<name>/execwith"record-output": true,instanceExecPostinlxd/instance_exec.gocalledos.Mkdir(execOutputDir, 0600)(ignoringfs.ErrExist) andos.OpenFile(filepath.Join(execOutputDir, "exec_" + opID + ".stdout"), os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666). Packingln -s /etc/cron.d exec-outputat the top level of an imported image let an attacker write controlled command output directly into/etc/cron.d/exec_<UUID>.stdouton the host. Fixed in commit124f90100640by openingexec-outputviaos.OpenRoot(inst.OpenExecOutput()).
GHSA-pjff-c2wc-f6jm(CVE-2026-48769, CVSS 9.9 Critical): When importing an image viasource.type=url, a malicious image server returning a craftedIncus-Image-Hash/LXD-Image-Hashheader could traverse paths and write arbitrary files on the client/server. LXD issued aHEADrequest and passed the remote server’s header directly intofilepath.Join(destDir, fp)before opening the destination path withos.Create(), so the overwrite happened before hash validation ran (corresponding Incus advisoryGHSA-f6m5-xw2g-xc4x).GHSA-hhf9-qw4v-72xp(CVE-2026-12411/GO-2026-6917, CVSS 8.4 High) andGHSA-7mr3-28h5-m5vx/GHSA-qx75-2p3r-pwm5(CVE-2026-55621,CVE-2026-55622, CVSS 7.7 High): Cross-guest storage volume hijacking via the/dev/lxd(DevLXD) device-patch API whensecurity.devlxd.management.volumesis enabled (PR #18585), plus missing source-project authorization checks when copying custom volumes or instances across projects, along withCVE-2026-9639(GHSA-j93m-3j9p-m5m8, nil-pointer dereference inCreateCustomVolumeFromBackup) andCVE-2026-28385(GHSA-3gq2-x4qg-p4g6, SSRF via URL image import).- Cross-guest custom storage volume hijack over
/dev/lxd(CVE-2026-12411): While the DevLXD storage volume API (lxd/devlxd_storage.go) checksisDevLXDVolumeOwner(volatile.devlxd.owner) onGET,PUT, andDELETE,devLXDInstancePatchHandler()andgenerateDevLXDInstanceDevices()inlxd/devlxd_instances.goonly checked device ownership when updating or deleting an already-attached device (if exists && !isOwned). When adding a new disk device viaPATCH /1.0/instanceover the container’s/dev/lxd/sockUnix socket, LXD never checked whether the referenced storage volume (pool+source) belonged to the calling container’s DevLXD identity. Fixed in PR#18585(commits7cb96ac80a6dand752e25cfb849). Commit7cb96ac80a6daddsnewDevLXDDeviceResourceOwnershipValidator()to verify volume ownership viadevLXDStoragePoolVolumeGet()before attaching any disk device. - Cross-project copy bypasses (
GHSA-7mr3-28h5-m5vx/CVE-2026-55621andGHSA-qx75-2p3r-pwm5/CVE-2026-55622):POST /1.0/storage-pools/{pool}/volumes/customandPOST /1.0/instanceschecked permissions only on the destination project and never verifiedCanViewonreq.Source.Project, allowing a restricted user to copy instances or custom volumes out of any other project whose name they knew. - SSRF via image import (
CVE-2026-28385, CVSS 5.0 Medium):POST /1.0/imageswithsource.type=urlallowed authenticated users holdingcan_create_imagesto probe internal loopback, RFC 1918, and cloud metadata endpoints (169.254.169.254) through error-based inference (fixed in commitc4a919f3f4e2).CVE-2026-9639is rated CVSS 6.5 Medium.
- Cross-guest custom storage volume hijack over
TL;DR
Between 29 and 30 October 2026, the Linux Containers Incus project and Canonical disclosed a shared, CVSS 10.0 Critical mutual-TLS authentication bypass affecting both Canonical LXD (CVE-2026-112816 / GHSA-99jp-jwmc-65p4, plus Canonical MicroCloud) and Incus (GHSA-xg75-xf37-cph9, shipped alongside 17 additional container and VM isolation fixes in Incus 7.6 and 6.0.9 LTS):
- Unauthenticated cluster and root takeover via
r.TLS.PeerCertificates(CVE-2026-112816/GHSA-xg75-xf37-cph9, CVSS 10.0 Critical): Both LXD and Incus configure their Go HTTPS listeners withtls.RequestClientCertrather thantls.RequireAndVerifyClientCert. During the TLS handshake, Go verifies only that the client holds the private key for the first certificate in the presented chain (r.TLS.PeerCertificates[0]); any intermediate or trailing certificates inr.TLS.PeerCertificates[1:]are unchecked and completely controlled by the client. However,Authenticate(),CheckCert(),doCertificateUpdate(),certificateDelete(), and the VM guest-agent authenticators looped over the entirer.TLS.PeerCertificatesslice and matched each entry against the daemon’s trust store. Because the daemon presents its own server certificate during every TLS handshake, an unauthenticated network attacker with no prior credentials can fetch the server’s public certificate on a first connection, reconnect with a self-signed throwaway leaf certificate at index0and the server’s public certificate appended at index1, and immediately authenticate as"cluster"(bypassing project and RBAC restrictions to gain host root access). - Seventeen companion Incus
7.6/6.0.9multi-tenant and host-escape advisories: In the same security batch (lxc/incusPR#4293), Incus patched seven additional Critical advisories and ten High/Medium flaws, including default-project authorization bypasses that let a project-restricted user execute commands asrooton the host viaraw.dnsmasqdhcp-script(GHSA-jcw9-v2ff-8m79andGHSA-5c64-j5m6-8433), arbitrary host block-device and file overwrites via special files and hard links in backup metadata (GHSA-5pgx-q9xx-j3qv), OCI imageconfig.jsonnewline injection into LXCconfigandLD_PRELOAD(GHSA-3wxw-5gh2-j2x2), abstract Unix socket hijacking of live VM NBD disk migrations (GHSA-3rgf-297m-775x), and btrfs/custom-volume migration path traversal (GHSA-p45f-gqqj-6qq3andGHSA-q9fc-p923-6vp7).
What to do now: Immediately refresh Canonical LXD snaps to 6.10.1, 5.21.9, 5.0.11, or 4.0.15, refresh MicroCloud snaps to 3.4.1 or 2.1.5, and upgrade Incus packages to 7.6 or 6.0.9 LTS. Because there is no configuration workaround for the mTLS chain bypass, restrict network access to port 8443 (and cluster ports) at the host firewall until patched daemons are running.
Affected packages and projects
| Ecosystem / Distribution | Project / Package | Advisory / CVE | Severity | Affected versions | Fixed version | Vulnerable component |
|---|---|---|---|---|---|---|
Snap / Go (github.com/canonical/lxd) | Canonical LXD | CVE-2026-112816 (GHSA-99jp-jwmc-65p4) | CVSS 10.0 Critical | < 4.0.15, 5.0.x < 5.0.11, 5.21.x < 5.21.9, 6.x < 6.10.1 | 4.0.15, 5.0.11, 5.21.9, 6.10.1 | Mutual-TLS client and cluster authentication (r.TLS.PeerCertificates iteration) |
Snap / Go (github.com/canonical/lxd) | Canonical LXD | GHSA-47w9-6r3f-938g, GHSA-pjff-c2wc-f6jm, GHSA-fmc8-p6q7-75cc, GHSA-vghh-5rfx-xhq8, GHSA-jpf8-86f3-wp38, GHSA-9j25-mm2h-2f76 | CVSS 9.9 Critical | < 0.0.0-20260630083100-c5184be310b1 | 4.0.15, 5.0.11, 5.21.9, 6.10.1 | Snapshot restricted.containers.lowlevel bypass (raw.lxc/raw.qemu), compression_algorithm injection, image hash & rootfs/templates/exec-output symlinks |
Snap / Go (github.com/canonical/lxd) | Canonical LXD | CVE-2026-12411 (GHSA-hhf9-qw4v-72xp, GO-2026-6917), GHSA-7mr3-28h5-m5vx, GHSA-qx75-2p3r-pwm5, CVE-2026-9639, CVE-2026-28385 | CVSS 8.4 / 7.7 High; 6.5 / 5.0 Medium | < 0.0.0-20260630083100-c5184be310b1 | 4.0.15, 5.0.11, 5.21.9, 6.10.1 | DevLXD /dev/lxd cross-guest volume hijack; cross-project volume/instance copy; ExpiresAt nil panic; URL image import SSRF |
Snap (microcloud) | Canonical MicroCloud | CVE-2026-112816 | CVSS 10.0 Critical | 2.x < 2.1.5, 3.x < 3.4.1 | 2.1.5, 3.4.1 | Cluster join and mTLS API authentication |
Go / Linux packages (github.com/lxc/incus) | Incus | GHSA-xg75-xf37-cph9 | CVSS 10.0 Critical | < 6.0.9 LTS, < 7.6 | 6.0.9, 7.6 | cmd/incusd/daemon.go, internal/server/cluster/tls.go, cmd/incusd/certificates.go, cmd/incus-agent/server.go |
Go / Linux packages (github.com/lxc/incus) | Incus | GHSA-jcw9-v2ff-8m79, GHSA-5c64-j5m6-8433 | Critical | < 6.0.9 LTS, < 7.6 | 6.0.9, 7.6 | cmd/incusd/daemon.go, networks.go, images.go (effective-project authorization bypass -> host root via raw.dnsmasq) |
Go / Linux packages (github.com/lxc/incus) | Incus | GHSA-5pgx-q9xx-j3qv, GHSA-3wxw-5gh2-j2x2, GHSA-p45f-gqqj-6qq3, GHSA-q9fc-p923-6vp7 | Critical | < 6.0.9 LTS, < 7.6 | 6.0.9, 7.6 | Backup metadata special files/hardlinks, OCI config.json newline/env injection, and volume snapshot migration traversal |
Go / Linux packages (github.com/lxc/incus) | Incus | GHSA-cwg9-8mc4-hf7j, GHSA-3rgf-297m-775x, GHSA-h2j8-4crh-vhfc, GHSA-9c46-v3hw-v6m8, GHSA-v736-5xp3-jghf, GHSA-8r3h-vc36-6xpx | Critical / High | < 6.0.9 LTS, < 7.6 | 6.0.9, 7.6 | Operation websocket/token event leaks, abstract NBD migration sockets, unprivileged rebuild idmap, and /dev/incus cgroup spoofing |
Technical analysis
1. Why iterating over r.TLS.PeerCertificates under tls.RequestClientCert breaks mutual TLS (CVE-2026-112816 / GHSA-xg75-xf37-cph9)
Both LXD and Incus authenticate REST API clients, cluster peers, metrics scrapers, and VM guest agents using client TLS certificates stored by SHA-256 fingerprint in the daemon’s trust store (rather than chaining to a single shared CA). To support self-signed client certificates alongside token and OIDC authentication, the HTTPS listener configures Go’s crypto/tls server with ClientAuth: tls.RequestClientCert.
In Go’s crypto/tls implementation, when a client sends a Certificate message containing a list of X.509 certificates [cert_0, cert_1, ...], the client’s CertificateVerify handshake signature is computed and verified only against the public key of cert_0 (r.TLS.PeerCertificates[0]). When ClientAuth is tls.RequestClientCert (as opposed to tls.RequireAndVerifyClientCert), crypto/tls does not verify that cert_1 signed cert_0 or that cert_1 is a CA certificate at all. The slice r.TLS.PeerCertificates[1:] is simply whatever raw DER certificates the client chose to append to its TLS handshake message.
Before commit 8381e54c36 in Incus and the corresponding 29 October LXD releases (6.10.1, 5.21.9, 5.0.11, 4.0.15), every trust-store check iterated across the entire r.TLS.PeerCertificates slice:
--- a/cmd/incusd/daemon.go
+++ b/cmd/incusd/daemon.go
@@ -619,13 +619,18 @@ func (d *Daemon) Authenticate(w http.ResponseWriter, r *http.Request) (bool, str
return false, "", "", nil, err
}
+ // The TLS listener only proves possession of the first peer certificate's key, so the rest of
+ // the presented chain is attacker-controlled and must never be matched against the trust store.
+ var peerCert *x509.Certificate
+ if r.TLS != nil && len(r.TLS.PeerCertificates) > 0 {
+ peerCert = r.TLS.PeerCertificates[0]
+ }
+
// Allow internal cluster traffic by checking against the trusted certificates.
- if r.TLS != nil {
- for _, i := range r.TLS.PeerCertificates {
- trusted, fingerprint := localUtil.CheckTrustState(*i, trustedCerts[certificate.TypeServer], d.endpoints.NetworkCert(), false)
- if trusted {
- return true, fingerprint, "cluster", nil, nil
- }
+ if peerCert != nil {
+ trusted, fingerprint := localUtil.CheckTrustState(*peerCert, trustedCerts[certificate.TypeServer], d.endpoints.NetworkCert(), false)
+ if trusted {
+ return true, fingerprint, "cluster", nil, nil
}
}
The exact same loop appeared in internal/server/cluster/tls.go (CheckCert, which guards the internal Cowsql/dqlite database gateway), cmd/incusd/certificates.go (doCertificateUpdate and certificateDelete), cmd/incus-agent/server.go, and cmd/incusd/api_vsock.go:
--- a/internal/server/cluster/tls.go
+++ b/internal/server/cluster/tls.go
@@ -24,10 +24,14 @@ func CheckCert(r *http.Request, networkCert *localtls.CertInfo, serverCert *loca
- for _, i := range r.TLS.PeerCertificates {
+ if len(r.TLS.PeerCertificates) == 0 {
+ return false
+ }
+ // Only the first peer certificate is proven by the TLS handshake; ignore the rest of the chain.
+ peerCert := r.TLS.PeerCertificates[0]
trustedServerCert, _ := x509.ParseCertificate(serverCert.KeyPair().Certificate[0])
- trusted, _ := localUtil.CheckTrustState(*i, map[string]x509.Certificate{serverCert.Fingerprint(): *trustedServerCert}, networkCert, false)
+ trusted, _ := localUtil.CheckTrustState(*peerCert, map[string]x509.Certificate{serverCert.Fingerprint(): *trustedServerCert}, networkCert, false)
Notice why CheckCert() in internal/server/cluster/tls.go makes exploitation trivial even on a standalone node where the attacker knows no client certificates:
CheckCert()explicitly trusts the daemon’s ownserverCert(map[string]x509.Certificate{serverCert.Fingerprint(): *trustedServerCert}), and on a clusterAuthenticate()trusts every member certificate intrustedCerts[certificate.TypeServer].- The server presents
serverCert(or the clusternetworkCert) to every connecting TLS client during the standard serverCertificatehandshake flight. - An unauthenticated attacker connects once to
:8443to read the server’s public X.509 certificate, generates an ephemeral keypair and leaf certificatecert_0, and opens a second TLS connection presenting[cert_0, serverCert]. - The TLS handshake succeeds because the attacker signs
CertificateVerifywithcert_0’s private key. WhenAuthenticate()orCheckCert()iterates tor.TLS.PeerCertificates[1],CheckTrustState()seesserverCert, returnstrusted = truewith protocol"cluster", and grants full internal cluster and database-gateway access.
Even worse, in cmd/incusd/certificates.go, certificatesPost (token-based certificate enrollment) previously selected r.TLS.PeerCertificates[len(r.TLS.PeerCertificates)-1] instead of r.TLS.PeerCertificates[0], and internal/server/auth/driver_scriptlet.go passed the unverified r.TLS.PeerCertificates slice to Starlark authorization scriptlets even when the caller authenticated via OIDC or a bearer token.
2. Companion host-root escapes in Incus 7.6 and 6.0.9 LTS (PR #4293)
Alongside GHSA-xg75-xf37-cph9, Incus 7.6 and 6.0.9 fix a cluster of project-isolation and host-confinement bugs that allow a restricted tenant client to reach root execution on the hypervisor:
- Default-project
raw.dnsmasqhost root execution (GHSA-jcw9-v2ff-8m79andGHSA-5c64-j5m6-8433, commits929041ead7andc738b76035): When a project disables a feature flag such asfeatures.networks=false(the default for non-default projects) orfeatures.storage.volumes=false, Incus creates those resources in thedefaultproject instead. However,networksPost,imagesPost,networkACLsPost, andnetworkZonesPostcheckeds.Authorizer.CheckPermission()against the request’s project parameter (?project=tenant-a) rather than the effective project (default). A client restricted totenant-acould therefore create a bridge network indefaultwithraw.dnsmasqset toleasefile-roanddhcp-script=/path/to/payload. Because settingraw.dnsmasqskips thednsmasqAppArmor profile anddnsmasqrunsdhcp-scriptasrootat startup (even when-udrops privileges for the DNS/DHCP worker), creating the network immediately executed commands asrooton the host. - OCI image
config.jsonnewline injection andLD_PRELOADleak intoforklxc(GHSA-3wxw-5gh2-j2x2, commitse933b9f920,084e2d4820,e00b75d4ac): When starting a container from an image that included an OCI/config.jsonmetadata file (even a system container image),incusdread environment variables from/config.json, passed them throughforklxc(cmd/incusd/main_forklxc.gocalledos.Setenv(k, v)inside the host helper process before entering the container), and wrotelxc.environmentlines into the container’s LXCconfigfile without rejecting\nor\r. An untrusted image could inject arbitrary LXC directives such aslxc.init.cmdorlxc.execute.cmdvia a newline in an environment variable value, or setLD_PRELOAD/LD_LIBRARY_PATHin theforklxcprocess environment. - Special device nodes and hard links in instance backup metadata (
GHSA-5pgx-q9xx-j3qv, commit724ab0fee1): When importing an instance backup or image,incusdextracted the metadata area (backup.yaml,metadata.yaml) asrootoutside container confinement without stripping non-regular files. Replacingbackup.yamlin the archive with a hard link or symlink caused the daemon to overwrite arbitrary host files when saving backup state, while placing a block or character device node in the metadata tar let the daemon read or corrupt host block devices. - Abstract Unix sockets for VM NBD disk migration (
GHSA-3rgf-297m-775x, commitc7008821c1): During live VM migration or disk export,incusdbound the QEMU NBD server to an abstract Unix socket (@\x00...). Because abstract Unix sockets live in the host network namespace and ignore filesystem permissions, any unprivileged local user on the host could spot the socket name in/proc/net/unix, connect during migration, and read or overwrite the guest VM’s raw disk in flight.
Detection and remediation
1. Check LXD, MicroCloud, and Incus versions and exposed HTTPS listeners
# 1. Check installed Canonical LXD / MicroCloud snap versions and Incus daemon version
snap list lxd microcloud 2>/dev/null || true
incusd --version 2>/dev/null || incus version 2>/dev/null || lxc version 2>/dev/null || true
# 2. Check whether port 8443 (or a custom core.https_address) is exposed on non-loopback interfaces
ss -tlpn 2>/dev/null | grep -E 'lxd|incusd|8443' || true
lxc config get core.https_address 2>/dev/null || incus config get core.https_address 2>/dev/null || true
# 3. Audit the trust store for unexpected client, server, or metrics certificates
lxc config trust list 2>/dev/null || incus config trust list 2>/dev/null || true
2. Upgrade immediately and audit trust stores and default project resources
- Upgrade Canonical LXD and MicroCloud snaps:
Verify that LXD is onsudo snap refresh lxd sudo snap refresh microcloud>= 6.10.1(6/stable),>= 5.21.9(5.21/stable),>= 5.0.11(5.0/stable), or>= 4.0.15(4.0/stable), and MicroCloud is on>= 3.4.1or>= 2.1.5. - Upgrade Incus to
>= 7.6or>= 6.0.9LTS via your distribution or Zabbly packages, and restartincusd. - Audit for post-exploitation indicators: If your LXD or Incus HTTPS listener (
core.https_address) was reachable from untrusted networks before patching, inspectlxc config trust list/incus config trust listfor modified or deleted certificates, check thedefaultproject for networks carryingraw.dnsmasq(incus network list --project default), and review host authentication and systemd logs for unexpected container or VM privileged device attachments (security.privileged=trueordiskdevices mapping/on the host).
Timeline
- 2026-09-25 to 2026-10-26: Stéphane Graber authors the 20 security commits for
incusd(including commit8381e54c36on 13 October fixingr.TLS.PeerCertificates[0]verification) and refers the mTLS chain bypass to the Canonical LXD team. - 2026-10-28 (
17:50 UTC) to 2026-10-29 (14:33 UTC): Canonical publishes its security advisory (90557) and releases LXD6.10.1,5.21.9,5.0.11, and4.0.15along with MicroCloud3.4.1and2.1.5. - 2026-10-29 (
22:13to22:19 UTC) and 2026-10-30 (00:20to01:24 UTC): Linux Containers publishes 18 GitHub Security Advisories (GHSA-xg75-xf37-cph9et al.), merges PR#4293, and tags Incus7.6and6.0.9LTS. - 2026-10-30 (
17:17 UTC): NVD publishesCVE-2026-112816(CVSS 10.0 Critical).
From research to remediation
Check whether this pattern exists in your codebase
Turn this research into a remediation workflow. Use AI-native static analysis to find similar application vulnerabilities and generate review-ready fixes.
References
- Ubuntu Discourse Security Advisory: Critical vulnerability found in Canonical LXD and MicroCloud (CVE-2026-112816)
- Canonical LXD Security Advisories (5-6 November 2026): GHSA-jpf8-86f3-wp38 (templates/ symlink), GHSA-9j25-mm2h-2f76 (exec-output symlink), GHSA-hhf9-qw4v-72xp / CVE-2026-12411 (DevLXD volume hijack), and GHSA-3gq2-x4qg-p4g6 / CVE-2026-28385
- NVD: CVE-2026-112816 (Canonical LXD improper certificate validation)
- Canonical LXD Security Advisories (5-6 November 2026): GHSA-47w9-6r3f-938g, GHSA-pjff-c2wc-f6jm, GHSA-fmc8-p6q7-75cc, GHSA-vghh-5rfx-xhq8, GHSA-jpf8-86f3-wp38, GHSA-9j25-mm2h-2f76, and GHSA-hhf9-qw4v-72xp (CVE-2026-12411)
- lxc/incus Security Advisory GHSA-xg75-xf37-cph9: Authentication and authorization bypass through unverified client certificate chains
- lxc/incus commit 8381e54c36 (PR #4293: incusd: Only trust the key-proven client certificate)
- lxc/incus Security Advisories GHSA-jcw9-v2ff-8m79, GHSA-5pgx-q9xx-j3qv, GHSA-3wxw-5gh2-j2x2, and GHSA-3rgf-297m-775x
- Canonical LXD Security Advisories (6 November 2026): GHSA-47w9-6r3f-938g (CVE-2026-48751), GHSA-pjff-c2wc-f6jm (CVE-2026-48769), GHSA-fmc8-p6q7-75cc (CVE-2026-48755), GHSA-vghh-5rfx-xhq8 (CVE-2026-48749), GHSA-jpf8-86f3-wp38 (CVE-2026-48752), GHSA-9j25-mm2h-2f76 (CVE-2026-48750), and GHSA-hhf9-qw4v-72xp (CVE-2026-12411)
- Canonical LXD Advisory GHSA-hhf9-qw4v-72xp and commit 7cb96ac80a6d (CVE-2026-12411: Cross-guest volume hijack via DevLXD device PATCH)