A line break in a container file is enough to run code as root on an Incus host
Incus fixes CVE-2026-130786, a configuration injection that lets a user able to launch an instance inject LXC directives through line breaks in the OCI config.json, up to running code as root on the host. Every installation older than Incus 7.6.0 must be upgraded, multi-tenant deployments first.
November 18, 2026. The NVD publishes CVE-2026-130786, a configuration injection in Incus before version 7.6.0. November 18, 2026. Its CVSS 3.1 score is 9.9, critical, with a changed scope (S:C) that spills from the container onto the host. November 18, 2026. Exploitation means inserting line breaks into the values of an OCI image’s config.json to inject LXC directives. Why it matters: a user authorized to launch a simple instance can execute code as root on the host, even from a restricted project — that is, escape multi-tenant isolation.
A line break that becomes a directive
Incus is the community fork of LXD — the manager that runs system containers, OCI application containers, and QEMU virtual machines with a single command. We detailed its positioning in our Incus guide. Its security model rests on a clear boundary: a container image is data you supply, and the host is the surface you protect.
CVE-2026-130786 pierces that boundary at the most unexpected point: formatting. When Incus launches an OCI application container, it reads the image’s config.json — the document describing the process to run, the working directory, the mounts. Some of those values, such as oci.entrypoint or oci.cwd, are then converted into LXC directives in the container’s configuration.
That is where the flaw lives: the values were not neutralized. An attacker who can supply an image — or modify one — can insert a line break into a config.json value. Instead of being treated as content, that newline becomes a directive separator: everything after it is parsed by LXC as a fresh configuration instruction. A path value becomes a vector for arbitrary directive injection.
What the attacker injects, and how far it goes
The conversion pipeline is worth understanding. Incus does not launch an OCI container directly: it translates the OCI config.json into an LXC profile, the native format of the system-container runtime. That is where the oci.entrypoint and oci.cwd values become directives such as lxc.execute.cmd or lxc.init.cwd. The flaw is in that translation: it copied the raw values without escaping control characters. A \n inside oci.cwd became a directive separator in the generated LXC profile.
The GitHub security advisory (GHSA-3wxw-5gh2-j2x2) and the NVD bulletin spell out what those directives enable. The attacker can add liblxc hooks — scripts run by the runtime at specific moments in the container lifecycle — or forge lxc.mount.entry fields on a tmpfs. Two direct consequences: running commands as root on the host, or bind-mounting host paths into the container.
The mount is the easy part to grasp. An lxc.mount.entry directive can bind a host directory — /etc or /root, say — into the container’s filesystem. An attacker who mounts a sensitive path can then read or modify host files as if they were their own. The hooks go further: an lxc.hook.start-host hook runs in the host namespace, with the daemon’s privileges — direct code execution, without even passing through the container.
The CVSS 3.1 vector states the severity: CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H. Low privileges — the ability to launch an instance, which multi-tenant platforms grant to ordinary users — no interaction, and crucially S:C, a changed scope: compromising the container reaches the host. The CVSS 4.0 score is 9.4, critical. The bulletin’s final note is the heaviest: exploitation works even from restricted projects, the projects whose instances are supposed to be the most confined.
The image/host boundary was too thin
What makes the flaw instructive is that it rests on no spectacular implementation error. It comes down to a misplaced trust boundary: Incus treated the values of an OCI config.json as safe, even though that file originates from an image — a potentially hostile piece of data. The line break is a mere \n character; its danger comes from being interpreted, downstream, by a component that gives it structural meaning.
It is the same family of defects as classic command injection, transposed to the container world. Where a shell interprets a semicolon or a backtick, LXC interprets a newline inside a value. The countermeasure is the same: neutralize — escape, validate, or reject — any value crossing the boundary between untrusted data and an interpreter.
The flaw sits inside a known family. Container escapes classically run through mishandled capabilities, badly mounted volumes, or excessive privileges. This one is subtler: it runs through the configuration file itself, the equivalent of command injection into an instance description format. That is why the fix is not a one-off patch but a posture change: any value coming from an image must be treated as untrusted.
Part of the danger is how ordinary the trigger looks. The flaw does not require a malicious image repository or a compromised registry — only a config.json whose values an attacker controls. In a multi-tenant Incus deployment, any tenant who can push an image can craft that file themselves; they do not need to wait for a supply-chain attack. The line break is invisible in most editors, survives JSON serialization untouched, and only misbehaves once the value reaches the LXC converter. That asymmetry — trivial to produce, catastrophic when interpreted — is why the CVSS tops out near 10 and why the fix had to change the conversion pipeline rather than escape one character.
The multi-tenant context makes it all worse. Incus is increasingly used to host instances for several teams or customers on one machine, with projects to isolate tenants. A flaw that turns instance-launch rights into host root cancels that isolation: the least privileged tenant becomes the owner of the entire machine.
Remediation
The fix is simple to state: upgrade to Incus 7.6.0, which neutralizes the OCI config.json values before they are converted into LXC directives. The flaw affects every earlier version, including maintenance branches — there is no “patched in place” release before 7.6.0.
# Check the installed version
incus version
# Upgrade per your distribution (Debian/Ubuntu example via the zabbly repository)
apt-get update && apt-get install -y incus
# Confirm the new version
incus version Two reflexes limit exposure while waiting to upgrade. Restrict who can launch instances: the flaw requires that right, and removing it from accounts that do not need it shrinks the surface immediately. Do not run untrusted images — or, if you must, never run them on a host that serves other tenants. Operators should also inventory which of their images originate from third parties: the trigger is a value inside the image itself, not a request a network monitor would flag, so the only reliable control is to upgrade and to keep untrusted images off shared hosts. And if you operate a multi-tenant deployment, treat this upgrade as an absolute emergency: it is host root within reach of your tenants.
The verdict
If you are below Incus 7.6.0, upgrade now — CVE-2026-130786 turns a simple instance-launch right into root code execution on the host, including from restricted projects. The absolute priority goes to multi-tenant deployments and hosts running third-party images: that is where the boundary between tenant and machine is genuinely at stake.
If you are on a single-user host running only your own images, the risk is lower but not zero — the defect is in the config.json conversion, and a single modified image triggers it. The lesson applies to the whole container ecosystem: a configuration file from an image is hostile data until proven otherwise, and every character crossing it toward an interpreter must be neutralized.