nono-cli CVE-2026-47128
MEDIUMAttack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAttain code execution within nono-sandboxed AI agent
-
DeliveryInvoke systemd-run --user over unrestricted D-Bus Unix socket
-
ExploitHost systemd spawns unsandboxed sibling process
-
ExecutionSibling executes arbitrary commands outside Landlock/seccomp policies
-
ImpactWrite files, spawn processes, or exfiltrate data within user permissions
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V8 - Authorization Authorization logic validation
MITRE ATT&CK
1 technique across 1 tactic: Privilege Escalation The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires all of the following concrete conditions: (1) the host Linux system has a running per-user systemd instance with the D-Bus socket active at /run/user/<uid>/bus - standard on most modern systemd-based Linux desktops and many server configurations; (2) the victim process is launched by nono-cli using an affected bundled profile (e.g., 'claude-code') or any custom profile that does not explicitly restrict Unix domain socket access; (3) the nono invocation includes a policy that permits shell execution (e.g., 'allow bash'), giving the sandboxed process the ability to invoke systemd-run; (4) the attacker has code execution within the sandboxed process - either as the AI agent itself responding to a crafted prompt, or via prompt injection into an agent accepting external input. Exploitation is limited to the launching user's existing OS permissions and does NOT provide privilege escalation, root access, cross-user access, or kernel compromise. Systems without a running systemd user instance (e.g., containers without systemd, non-systemd init systems, or user sessions explicitly configured without D-Bus) are not exploitable via this specific vector. |
| Impact | The CVSS 3.1 score of 6.1 (Medium) accurately reflects the local-only attack vector (AV:L) and low-privilege prerequisite (PR:L), which constrain the exposure compared to network-reachable vulnerabilities. However, within the specific threat model for which nono is deployed - containing AI coding agents such as Aider, Claude Code, or OpenCode running with 'allow bash' - the practical risk is substantially higher than the score implies. The integrity impact is rated HIGH (I:H) because the escape is reliable and complete, and the scope is unchanged (S:U), meaning no kernel or cross-user privilege escalation occurs; the blast radius is bounded by the launching user's existing permissions. A public proof-of-concept is embedded in the GitHub Security Advisory, lowering the barrier to exploitation. EPSS data was not provided in the available intelligence. The advisory tags include 'Privilege Escalation,' but this conflicts with the maintainer's explicit clarification that the issue does not provide privilege escalation, cross-user access, or host compromise beyond the invoking user's authority - the maintainer's statement is treated as authoritative. The risk is highest in CI/CD pipelines and AI-assisted development environments where nono is used to contain agents that accept external or untrusted input, since a single prompt injection can trigger the escape. |
| Exploit ScenarioDerived | An AI coding agent running inside a nono sandbox configured with the 'claude-code' profile and --allow-bash is manipulated via prompt injection to execute the command 'systemd-run --user -q --wait --collect /bin/sh -c "malicious command"'. Because the sandbox policies do not restrict Unix domain socket access, the command communicates freely over the per-user D-Bus socket at /run/user/<uid>/bus, requesting that the host's systemd user instance spawn a new unsandboxed service. The resulting sibling process runs entirely outside nono's Landlock/seccomp policies and can write files to any user-accessible path, exfiltrate source code or credentials, or establish outbound network connections - all under the authority of the user who launched the original sandbox. A working one-liner reproducer is publicly documented in the GitHub Security Advisory. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – May 28, 2026
Sandbox escape in nono-cli allows a sandboxed process to fully break out of Landlock/seccomp confinement by communicating over the unmediated per-user systemd D-Bus Unix domain socket. Versions prior to 0.55.0 of the Rust CLI crate are affected, specifically when using bundled profiles such as 'claude-code' that permit bash execution. An attacker - or a prompt-injected AI coding agent - can invoke systemd-run --user from within the sandbox to spawn an unsandboxed sibling process capable of writing anywhere the launching user can write, executing arbitrary commands, and establishing network connections. A working proof-of-concept reproducer is publicly available in the GitHub Security Advisory GHSA-27vp-2mmc-vmh3; no CISA KEV listing exists at time of analysis.
RemediationAI
Upgrade nono-cli to version 0.55.0 or later, which adds support for restricting Unix domain socket access - both concrete and abstract namespace - within sandbox policies, closing the D-Bus escape vector. The fix is confirmed available in the upstream repository per GHSA-27vp-2mmc-vmh3 (https://github.com/always-further/nono/security/advisories/GHSA-27vp-2mmc-vmh3); operators should verify the 0.55.0 release is published to crates.io before deploying, as the advisory noted the fix was 'pending release' at time of disclosure. As a compensating control prior to patching, avoid running AI agents or untrusted command streams under profiles that combine 'allow bash' with access to the host D-Bus socket - note this substantially reduces agent functionality, particularly for workflows invoking build tools. A more targeted workaround is to run the sandboxed workload inside a dedicated unprivileged user session where no systemd user instance is active (for example, a minimal OCI container without systemd-user), which eliminates the D-Bus escape path at the cost of disabling systemd user services in that environment.
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in cargo
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
nono is a Rust-based sandboxing CLI tool that uses Linux Landlock LSM and seccomp BPF to confine child processes according to configurable policy profiles. CWE-863 (Incorrect Authorization) identifies the root cause: the bundled sandbox profiles, including the 'claude-code' profile, performed incomplete mediation of local Unix domain socket access. Linux supports two types of Unix domain sockets - concrete filesystem-path-bound sockets and abstract namespace sockets (which bypass the filesystem entirely). Neither was restricted by the affected policies. The per-user systemd D-Bus socket at /run/user/<uid>/bus is exposed as a Unix domain socket, and a sandboxed process retaining access to it can invoke systemd-run --user to request that the host's user systemd instance spawn new, fully unsandboxed services. The affected package is identified by CPE as pkg:rust/nono-cli. The vulnerability exists in the CLI policy layer and bundled profile definitions only; the core nono library and language SDKs do not ship policy definitions and are not affected.
Know when the next one hits your stack
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:L
Primary rating from Vendor (https://github.com/always-further/nono).
CVSS VectorVendor: https://github.com/always-further/nono
DescriptionCVE.org
Summary
The nono Landlock/seccomp policies allow access to local Unix domain sockets (concrete and abstract). This allows an easy sandbox escape by talking to the per-user systemd dbus socket.
Threat scenario: Running Aider, Claude Code, OpenCode or similar tools with "allow bash" policy so that it can invoke arbitrary host tools like make, gcc, etc. to write code.
Reproducer
Here, instead of running a tool like opencode or claude one can just invoke systemd-run, but this is something an agent could be tricked into doing:
$ cd ~/src/myproject
$ nono run -s --allow-cwd --profile claude-code -- \
systemd-run --user -q --wait --collect \
/bin/sh -c "echo oops > ~/Documents/escaped.txt"
$ cat /var/home/test/Documents/escaped.txt
oops
$Impact
Complete sandbox escape. The unsandboxed sibling process can write anywhere the user can write, spawn arbitrary processes with network access, etc.
Maintainer Context
This issue allows a process running inside the sandbox to escape confinement by interacting with local user-scoped IPC mechanisms and regain the authority already held by the invoking user or service account.
The issue impacts the sandbox’s confinement and blast-radius reduction guarantees for agents and sandboxed tooling. However, exploitation does not provide privilege escalation, cross-user access, or host compromise beyond the permissions already available to the launcher outside the sandbox.
This issue affects the CLI policy layer and bundled sandbox profiles. The underlying core library nono does not ship with policy definitions or agent-facing confinement profiles by default, nor do the language SDKs.
This is considered a serious issue because an AI agent or untrusted command stream operating within the sandbox could abuse the bypass to perform unauthorized or destructive actions using the delegated authority of the launching user.
The root cause was incomplete mediation of local Unix domain socket access within affected sandbox policies. Support for restricting this behavior has since been added and the fix is available in the repository pending release.
CVSS rationale: exploitation requires execution within a locally launched sandboxed process using the authority already delegated by the invoking user or service account (AV:L/PR:L). The issue allows reliable bypass of sandbox confinement and policy guarantees, resulting in high integrity impact (I:H) and limited availability impact (A:L) through destructive actions within the launcher’s existing permissions. However, the issue does not provide privilege escalation, cross-user access, or a change in security scope (S:U).
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.
Privilege escalation occurs when an attacker leverages flaws in access control mechanisms to gain permissions beyond what they were originally granted.
GHSA-27vp-2mmc-vmh3
NVD
CVE.org
EPSS
Exploit-DB