critical

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:

  1. GHSA-47w9-6r3f-938g (CVE-2026-48751, CVSS 9.9 Critical): Instance snapshots bypassed the restricted.containers.lowlevel=block project restriction, allowing a restricted project user to restore or configure low-level hooks (raw.lxc, raw.qemu) and execute arbitrary commands as root on the LXD host. The corresponding Incus advisory is GHSA-48q5-w887-33wv; the LXD fix is commit 5aac658c88.
  2. GHSA-fmc8-p6q7-75cc (CVE-2026-48755, CVSS 9.9 Critical): LXD validated user-supplied backup compression_algorithm strings 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 split compression_algorithm with shellquote.Split(value) and validated only fields[0] against the compressor allowlist (bzip2, gzip, lz4, xz, zstd, tar2sqfs) while forwarding fields[1:] directly to compressFile() (commit 0915bb88cb; corresponding Incus advisory GHSA-v6mj-8pf4-hhw4).
  3. GHSA-vghh-5rfx-xhq8 (CVE-2026-48749, CVSS 9.9 Critical), GHSA-jpf8-86f3-wp38 (CVE-2026-48752, CVSS 9.9 Critical), and GHSA-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 during archive.Unpack, and exec-output directory symlink abused through /instances/$name/exec with record-output=true).
    • templates/ symlink (GHSA-jpf8-86f3-wp38): When importing a container image, shared/archive/archive.go stripped device nodes during tar extraction but preserved a top-level templates symlink (such as ln -s /etc/cron.d templates). Calling the template API (lxc config template ls / show / edit) then read or wrote arbitrary files in /etc/cron.d on the host as root. Fixed in commit 190e2451544a by changing RootfsPath() and TemplatesPath() in lxd/instance/drivers/driver_common.go to call d.subPath(), which inspects os.Lstat(path) and rejects symlinks.
    • exec-output symlink (GHSA-9j25-mm2h-2f76): When calling /1.0/instances/<name>/exec with "record-output": true, instanceExecPost in lxd/instance_exec.go called os.Mkdir(execOutputDir, 0600) (ignoring fs.ErrExist) and os.OpenFile(filepath.Join(execOutputDir, "exec_" + opID + ".stdout"), os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666). Packing ln -s /etc/cron.d exec-output at the top level of an imported image let an attacker write controlled command output directly into /etc/cron.d/exec_<UUID>.stdout on the host. Fixed in commit 124f90100640 by opening exec-output via os.OpenRoot (inst.OpenExecOutput()).
  4. GHSA-pjff-c2wc-f6jm (CVE-2026-48769, CVSS 9.9 Critical): When importing an image via source.type=url, a malicious image server returning a crafted Incus-Image-Hash / LXD-Image-Hash header could traverse paths and write arbitrary files on the client/server. LXD issued a HEAD request and passed the remote server’s header directly into filepath.Join(destDir, fp) before opening the destination path with os.Create(), so the overwrite happened before hash validation ran (corresponding Incus advisory GHSA-f6m5-xw2g-xc4x).
  5. GHSA-hhf9-qw4v-72xp (CVE-2026-12411 / GO-2026-6917, CVSS 8.4 High) and GHSA-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 when security.devlxd.management.volumes is enabled (PR #18585), plus missing source-project authorization checks when copying custom volumes or instances across projects, along with CVE-2026-9639 (GHSA-j93m-3j9p-m5m8, nil-pointer dereference in CreateCustomVolumeFromBackup) and CVE-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) checks isDevLXDVolumeOwner (volatile.devlxd.owner) on GET, PUT, and DELETE, devLXDInstancePatchHandler() and generateDevLXDInstanceDevices() in lxd/devlxd_instances.go only checked device ownership when updating or deleting an already-attached device (if exists && !isOwned). When adding a new disk device via PATCH /1.0/instance over the container’s /dev/lxd/sock Unix socket, LXD never checked whether the referenced storage volume (pool + source) belonged to the calling container’s DevLXD identity. Fixed in PR #18585 (commits 7cb96ac80a6d and 752e25cfb849). Commit 7cb96ac80a6d adds newDevLXDDeviceResourceOwnershipValidator() to verify volume ownership via devLXDStoragePoolVolumeGet() before attaching any disk device.
    • Cross-project copy bypasses (GHSA-7mr3-28h5-m5vx / CVE-2026-55621 and GHSA-qx75-2p3r-pwm5 / CVE-2026-55622): POST /1.0/storage-pools/{pool}/volumes/custom and POST /1.0/instances checked permissions only on the destination project and never verified CanView on req.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/images with source.type=url allowed authenticated users holding can_create_images to probe internal loopback, RFC 1918, and cloud metadata endpoints (169.254.169.254) through error-based inference (fixed in commit c4a919f3f4e2). CVE-2026-9639 is rated CVSS 6.5 Medium.

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):

  1. 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 with tls.RequestClientCert rather than tls.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 in r.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 entire r.TLS.PeerCertificates slice 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 index 0 and the server’s public certificate appended at index 1, and immediately authenticate as "cluster" (bypassing project and RBAC restrictions to gain host root access).
  2. Seventeen companion Incus 7.6 / 6.0.9 multi-tenant and host-escape advisories: In the same security batch (lxc/incus PR #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 as root on the host via raw.dnsmasq dhcp-script (GHSA-jcw9-v2ff-8m79 and GHSA-5c64-j5m6-8433), arbitrary host block-device and file overwrites via special files and hard links in backup metadata (GHSA-5pgx-q9xx-j3qv), OCI image config.json newline injection into LXC config and LD_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-6qq3 and GHSA-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 / DistributionProject / PackageAdvisory / CVESeverityAffected versionsFixed versionVulnerable component
Snap / Go (github.com/canonical/lxd)Canonical LXDCVE-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.14.0.15, 5.0.11, 5.21.9, 6.10.1Mutual-TLS client and cluster authentication (r.TLS.PeerCertificates iteration)
Snap / Go (github.com/canonical/lxd)Canonical LXDGHSA-47w9-6r3f-938g, GHSA-pjff-c2wc-f6jm, GHSA-fmc8-p6q7-75cc, GHSA-vghh-5rfx-xhq8, GHSA-jpf8-86f3-wp38, GHSA-9j25-mm2h-2f76CVSS 9.9 Critical< 0.0.0-20260630083100-c5184be310b14.0.15, 5.0.11, 5.21.9, 6.10.1Snapshot 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 LXDCVE-2026-12411 (GHSA-hhf9-qw4v-72xp, GO-2026-6917), GHSA-7mr3-28h5-m5vx, GHSA-qx75-2p3r-pwm5, CVE-2026-9639, CVE-2026-28385CVSS 8.4 / 7.7 High; 6.5 / 5.0 Medium< 0.0.0-20260630083100-c5184be310b14.0.15, 5.0.11, 5.21.9, 6.10.1DevLXD /dev/lxd cross-guest volume hijack; cross-project volume/instance copy; ExpiresAt nil panic; URL image import SSRF
Snap (microcloud)Canonical MicroCloudCVE-2026-112816CVSS 10.0 Critical2.x < 2.1.5, 3.x < 3.4.12.1.5, 3.4.1Cluster join and mTLS API authentication
Go / Linux packages (github.com/lxc/incus)IncusGHSA-xg75-xf37-cph9CVSS 10.0 Critical< 6.0.9 LTS, < 7.66.0.9, 7.6cmd/incusd/daemon.go, internal/server/cluster/tls.go, cmd/incusd/certificates.go, cmd/incus-agent/server.go
Go / Linux packages (github.com/lxc/incus)IncusGHSA-jcw9-v2ff-8m79, GHSA-5c64-j5m6-8433Critical< 6.0.9 LTS, < 7.66.0.9, 7.6cmd/incusd/daemon.go, networks.go, images.go (effective-project authorization bypass -> host root via raw.dnsmasq)
Go / Linux packages (github.com/lxc/incus)IncusGHSA-5pgx-q9xx-j3qv, GHSA-3wxw-5gh2-j2x2, GHSA-p45f-gqqj-6qq3, GHSA-q9fc-p923-6vp7Critical< 6.0.9 LTS, < 7.66.0.9, 7.6Backup metadata special files/hardlinks, OCI config.json newline/env injection, and volume snapshot migration traversal
Go / Linux packages (github.com/lxc/incus)IncusGHSA-cwg9-8mc4-hf7j, GHSA-3rgf-297m-775x, GHSA-h2j8-4crh-vhfc, GHSA-9c46-v3hw-v6m8, GHSA-v736-5xp3-jghf, GHSA-8r3h-vc36-6xpxCritical / High< 6.0.9 LTS, < 7.66.0.9, 7.6Operation 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:

  1. CheckCert() explicitly trusts the daemon’s own serverCert (map[string]x509.Certificate{serverCert.Fingerprint(): *trustedServerCert}), and on a cluster Authenticate() trusts every member certificate in trustedCerts[certificate.TypeServer].
  2. The server presents serverCert (or the cluster networkCert) to every connecting TLS client during the standard server Certificate handshake flight.
  3. An unauthenticated attacker connects once to :8443 to read the server’s public X.509 certificate, generates an ephemeral keypair and leaf certificate cert_0, and opens a second TLS connection presenting [cert_0, serverCert].
  4. The TLS handshake succeeds because the attacker signs CertificateVerify with cert_0’s private key. When Authenticate() or CheckCert() iterates to r.TLS.PeerCertificates[1], CheckTrustState() sees serverCert, returns trusted = true with 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.dnsmasq host root execution (GHSA-jcw9-v2ff-8m79 and GHSA-5c64-j5m6-8433, commits 929041ead7 and c738b76035): When a project disables a feature flag such as features.networks=false (the default for non-default projects) or features.storage.volumes=false, Incus creates those resources in the default project instead. However, networksPost, imagesPost, networkACLsPost, and networkZonesPost checked s.Authorizer.CheckPermission() against the request’s project parameter (?project=tenant-a) rather than the effective project (default). A client restricted to tenant-a could therefore create a bridge network in default with raw.dnsmasq set to leasefile-ro and dhcp-script=/path/to/payload. Because setting raw.dnsmasq skips the dnsmasq AppArmor profile and dnsmasq runs dhcp-script as root at startup (even when -u drops privileges for the DNS/DHCP worker), creating the network immediately executed commands as root on the host.
  • OCI image config.json newline injection and LD_PRELOAD leak into forklxc (GHSA-3wxw-5gh2-j2x2, commits e933b9f920, 084e2d4820, e00b75d4ac): When starting a container from an image that included an OCI /config.json metadata file (even a system container image), incusd read environment variables from /config.json, passed them through forklxc (cmd/incusd/main_forklxc.go called os.Setenv(k, v) inside the host helper process before entering the container), and wrote lxc.environment lines into the container’s LXC config file without rejecting \n or \r. An untrusted image could inject arbitrary LXC directives such as lxc.init.cmd or lxc.execute.cmd via a newline in an environment variable value, or set LD_PRELOAD / LD_LIBRARY_PATH in the forklxc process environment.
  • Special device nodes and hard links in instance backup metadata (GHSA-5pgx-q9xx-j3qv, commit 724ab0fee1): When importing an instance backup or image, incusd extracted the metadata area (backup.yaml, metadata.yaml) as root outside container confinement without stripping non-regular files. Replacing backup.yaml in 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, commit c7008821c1): During live VM migration or disk export, incusd bound 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

  1. Upgrade Canonical LXD and MicroCloud snaps:
    sudo snap refresh lxd
    sudo snap refresh microcloud
    Verify that LXD is on >= 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.1 or >= 2.1.5.
  2. Upgrade Incus to >= 7.6 or >= 6.0.9 LTS via your distribution or Zabbly packages, and restart incusd.
  3. Audit for post-exploitation indicators: If your LXD or Incus HTTPS listener (core.https_address) was reachable from untrusted networks before patching, inspect lxc config trust list / incus config trust list for modified or deleted certificates, check the default project for networks carrying raw.dnsmasq (incus network list --project default), and review host authentication and systemd logs for unexpected container or VM privileged device attachments (security.privileged=true or disk devices mapping / on the host).

Timeline

  • 2026-09-25 to 2026-10-26: Stéphane Graber authors the 20 security commits for incusd (including commit 8381e54c36 on 13 October fixing r.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 LXD 6.10.1, 5.21.9, 5.0.11, and 4.0.15 along with MicroCloud 3.4.1 and 2.1.5.
  • 2026-10-29 (22:13 to 22:19 UTC) and 2026-10-30 (00:20 to 01:24 UTC): Linux Containers publishes 18 GitHub Security Advisories (GHSA-xg75-xf37-cph9 et al.), merges PR #4293, and tags Incus 7.6 and 6.0.9 LTS.
  • 2026-10-30 (17:17 UTC): NVD publishes CVE-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