actually bind /dev/kvm into the container, and test it initializes

DeviceAllow= only grants cgroup permission to open a device node - it
doesn't create one, and nspawn can't mknod a device inside a user
namespace. The node needs an explicit bind from the host as well, so
both are required together.

Also add a test that actually boots qemu-system-x86_64 -enable-kvm
(no disk, killed by timeout) and checks for "Permission denied" /
"Could not access KVM" in its output, rather than just checking the
node opens - a wrong-gid or unmapped node still opens but fails the
ioctls qemu needs.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Dzy7tEKLCFFXD96LmR8we3

.github/workflows/vulnix.yml

@@ -5,10 +5,6 @@ on:
     - cron: "0 6 * * 1"
   workflow_dispatch:
 
-permissions:
-  contents: read
-  issues: write
-
 jobs:
   scan:
     runs-on: nix

ci.py

@@ -42,7 +42,7 @@ def gitea(method, path, body=None):
 
 
 def find_open_issue(label):
-    issues = gitea("GET", f"/issues?state=open&labels={label}")
+    issues = gitea("GET", f"/issues?state=open&type=issues&labels={label}")
     return issues[0] if issues else None
 
 
@@ -239,7 +239,7 @@ def format_vulnix(vulns):
     for v in vulns:
         for cve in v["affected_by"]:
             score = v.get("cvssv3_basescore", {}).get(cve)
-            desc = v.get("description", {}).get(cve, "")
+            desc = v.get("description", {}).get(cve, "").replace("\n", " ").replace("|", "∣")
             if len(desc) > 120:
                 desc = desc[:117] + "..."
             rows.append((v["pname"], v["version"], cve, score, desc))

containers/server-n0/ssh.nix

@@ -75,15 +75,6 @@ let
       packages = with pkgs; [ tmux ] ++ packages;
       miscProperties = self._sshpiperRegister routingInfo;
     };
-
-  kvmTrait = {
-    containerConfig =
-      { pkgs, ... }:
-      {
-        users.users.runner.extraGroups = [ "kvm" ];
-        environment.systemPackages = [ pkgs.qemu_kvm ];
-      };
-  };
 in
 {
   ssh-admin = mkSsh {
@@ -126,32 +117,27 @@ in
   ssh-generic = mkSsh {
     name = "ssh-generic";
     net.access = [ { to = "@internet"; } ];
+    # /dev/kvm keeps its host ownership, so the kvm gid must not be shifted.
+    isolation.privateUsers = "identity";
     resources = {
       fs."/home/runner/data" = {
         hostPath = "${data}/ssh/generic";
         isReadOnly = false;
       };
+      devices = [ "/dev/kvm" ];
       mem = "16G";
       cpu = 65;
     };
-    traits = [ kvmTrait ];
-    isolation.allowedDevices = [
+    packages = with pkgs; [ qemu_kvm ];
+    traits = [
       {
-        node = "/dev/kvm";
-        modifier = "rw";
+        containerConfig =
+          { config, ... }:
+          {
+            users.groups.kvm.gid = config.ids.gids.kvm;
+            users.users.runner.extraGroups = [ "kvm" ];
+          };
       }
-      {
-        node = "/dev/vhost-net";
-        modifier = "rw";
-      }
-      {
-        node = "/dev/net/tun";
-        modifier = "rwm";
-      }
-    ];
-    isolation.additionalCapabilities = [
-      "CAP_NET_ADMIN"
-      "CAP_MKNOD"
     ];
     routingInfo = [
       {

dsl.nix

@@ -221,6 +221,17 @@ rec {
     `resources.fs`
     : Bind mounts, keyed by mount point.
 
+    `resources.devices`
+    : Host device nodes to expose, as paths. Bound into the container at the
+      same path and added to the unit's `DeviceAllow=` - the cgroup
+      permission alone doesn't get you a working node (nothing can `mknod` a
+      device inside a user namespace), and the bind alone leaves the cgroup
+      denying `open()`, so both are needed. The bind is unconditional, so
+      the device must actually exist on whatever host runs the container.
+      Nodes keep their host ownership, so a consumer inside needs
+      `isolation.privateUsers = "identity"` for the owning gid to mean
+      anything.
+
     `isolation.nixDaemon`
     : Whether the Nix daemon and CLI are available inside the container.
 
@@ -228,17 +239,6 @@ rec {
     : systemd-nspawn user namespacing; see `--private-users=` in
       systemd-nspawn(1). Bind mounts always go through idmapped `--bind`.
 
-    `isolation.allowedDevices`
-    : List of `{ node; modifier; }` host devices to grant the container's
-      cgroup access to; see `containers.<name>.allowedDevices` in the NixOS
-      manual. nspawn bind-mounts a handful of devices (`/dev/kvm`,
-      `/dev/net/tun`, ...) into the container itself once the cgroup allows it -
-      this doesn't need a matching `resources.fs` bind mount.
-
-    `isolation.additionalCapabilities`
-    : Extra Linux capabilities granted to the container; see
-      `containers.<name>.additionalCapabilities` in the NixOS manual.
-
     `miscProperties`
     : Arbitrary data attached to the result. Used for cross-container discovery
       via `collectContainers`.
@@ -281,16 +281,15 @@ rec {
       cpuQuota = "${toString (cpu * 100)}%";
       memoryMax = resources.mem or "512M";
       bindMounts = resources.fs or { };
+      devices = resources.devices or [ ];
       allowsNixDaemon = isolation.nixDaemon or false;
       privateUsers = isolation.privateUsers or "pick";
-      allowedDevices = isolation.allowedDevices or [ ];
-      additionalCapabilities = isolation.additionalCapabilities or [ ];
 
       allowInternet = hasInternetAccess access;
       allBindMounts = builtins.foldl' (acc: t: acc // (t.resources.fs or { })) { } traits // bindMounts;
       userModules = map mkUser (lib.concatMap (t: t.users or [ ]) traits ++ users);
       allPorts = ports ++ map (p: (normalizePort p).container) hostPorts;
-      useIdmap = privateUsers != "no";
+      useIdmap = privateUsers == "pick" || (builtins.isInt privateUsers && privateUsers > 0);
       bindMountExtraFlags = lib.mapAttrsToList (
         mountPoint: bm:
         (if bm.isReadOnly then "--bind-ro=" else "--bind=")
@@ -298,6 +297,10 @@ rec {
         + lib.optionalString useIdmap ":idmap"
       ) allBindMounts;
       bindMountHostPaths = map (bm: bm.hostPath) (lib.attrValues allBindMounts);
+      # DeviceAllow= alone only grants cgroup permission - nspawn can't
+      # mknod a device node inside a user namespace, so the node still
+      # needs an explicit bind from the host.
+      deviceFlags = map (d: "--bind=${d}") devices;
       inherit (deriveIdentity ifPrefix.nspawn name)
         iface
         mac
@@ -376,19 +379,15 @@ rec {
         hostAddr
         bindMountHostPaths
         includedInTests
+        devices
         ;
       bindMounts = allBindMounts;
       kind = "nspawn";
       miscProperties = flattenMiscProp self miscProperties;
       nixosContainer = {
-        inherit
-          autoStart
-          privateUsers
-          allowedDevices
-          additionalCapabilities
-          ;
+        inherit autoStart privateUsers;
         bindMounts = { };
-        extraFlags = bindMountExtraFlags;
+        extraFlags = bindMountExtraFlags ++ deviceFlags;
         privateNetwork = true;
         extraVeths = linkVeths;
         config =
@@ -521,6 +520,7 @@ rec {
         ;
       inherit needsGateway;
       bindMountHostPaths = map (s: s.source) shares;
+      devices = [ ];
       kind = "vm";
       miscProperties = flattenMiscProp self miscProperties;
       microvmConfig = {
@@ -957,6 +957,7 @@ rec {
           startLimitBurst = 5;
           startLimitIntervalSec = 120;
           unitConfig.RequiresMountsFor = c.bindMountHostPaths;
+          serviceConfig.DeviceAllow = map (d: "${d} rw") c.devices;
         };
 
       # the host end of a link, for both kinds. nixos-containers only configures
@@ -1316,6 +1317,7 @@ rec {
         HOST_ADDR = ${pyDict pyStr (lib.mapAttrs (_: c: c.hostAddr) autoStartTestContainers)}
         IFACE = ${pyDict pyStr (lib.mapAttrs (_: c: c.iface) autoStartTestContainers)}
         KIND = ${pyDict pyStr (lib.mapAttrs (_: c: c.kind) autoStartTestContainers)}
+        DEVICES = ${pyDict pyList (lib.mapAttrs (_: c: c.devices) autoStartTestContainers)}
         # only nspawn guests can be entered with nsenter; a vm has no host-side
         # netns, so every probe that runs *inside* a guest is limited to these
         enterable = [c for c in included if KIND[c] == "nspawn"]

tests/server-n0/integration.py

@@ -27,6 +27,7 @@ if TYPE_CHECKING:
     HOST_ADDR: dict[str, str] = {}
     IFACE: dict[str, str] = {}
     KIND: dict[str, str] = {}
+    DEVICES: dict[str, list[str]] = {}
     EDGES: list[tuple[str, str, list[int], list[int]]] = []
     SSH_KEY: str = ""
     SSH_OPTS: str = ""
@@ -55,6 +56,11 @@ def container_pid(name):
     return server.succeed(f"machinectl show {name} -p Leader --value").strip()
 
 
+def ct_cmd(name, cmd):
+    pid = container_pid(name)
+    return f"{NSENTER} --mount=/proc/{pid}/ns/mnt --root=/proc/{pid}/root -- {SH} -c '{cmd}'"
+
+
 def net_cmd(name, cmd):
     pid = container_pid(name)
     return f"{NSENTER} --net=/proc/{pid}/ns/net -- {cmd}"
@@ -323,3 +329,40 @@ with subtest("(functional): published ports follow the container's lifetime"):
     server.succeed("systemctl start container@nginx")
     server.wait_for_unit("container@nginx.service")
     internet.wait_until_succeeds(ext_connect(80), timeout=30)
+
+with subtest("(functional): declared devices are usable in-container"):
+    for name, devices in DEVICES.items():
+        for dev in devices:
+            # opened, not stat'd: without DeviceAllow= the node is still visible
+            server.succeed(ct_cmd(name, f"exec 3<> {dev}"))
+
+
+with subtest("(functional): /dev/kvm actually initializes, not just opens"):
+    # a wrong-gid or unmapped node still opens but fails the ioctls qemu
+    # needs, so boot with no disk (never completes) and kill it - the
+    # failure mode this catches is qemu refusing to start at all.
+    for name, devices in DEVICES.items():
+        if "/dev/kvm" not in devices:
+            continue
+        out = server.succeed(
+            ct_cmd(
+                name,
+                f"{TIMEOUT} 3 qemu-system-x86_64 -enable-kvm -m 256 -nographic -no-reboot "
+                ">/tmp/qemu.out 2>&1; cat /tmp/qemu.out",
+            )
+        )
+        assert "Permission denied" not in out, f"{name}: qemu couldn't use /dev/kvm:\n{out}"
+        assert "Could not access KVM" not in out, f"{name}: qemu couldn't use /dev/kvm:\n{out}"
+
+
+with subtest("(isolation): devices reach only the container that declared them"):
+    for name in enterable:
+        for dev in {d for ds in DEVICES.values() for d in ds} - set(DEVICES.get(name, [])):
+            server.fail(ct_cmd(name, f"test -e {dev}"))
+
+
+with subtest("(isolation): identity uid mapping keeps the user namespace"):
+    for name in (n for n, ds in DEVICES.items() if ds):
+        host_ns = server.succeed("readlink /proc/1/ns/user").strip()
+        ct_ns = server.succeed(f"readlink /proc/{container_pid(name)}/ns/user").strip()
+        assert host_ns != ct_ns, f"{name} shares the host user namespace"