Skip to main content

nono-cli CVE-2026-47128

MEDIUM
Incorrect Authorization (CWE-863)
2026-05-28 https://github.com/always-further/nono GHSA-27vp-2mmc-vmh3
6.1
CVSS 3.1 · Vendor: https://github.com/always-further/nono
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Attain code execution within nono-sandboxed AI agent
  2. Delivery
    Invoke systemd-run --user over unrestricted D-Bus Unix socket
  3. Exploit
    Host systemd spawns unsandboxed sibling process
  4. Execution
    Sibling executes arbitrary commands outside Landlock/seccomp policies
  5. Impact
    Write 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.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.0% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

cargo nono-cli fix: 0.55.0

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

Vendor (https://github.com/always-further/nono) PRIMARY 6.1 MEDIUM
AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:L
SUSE MEDIUM

Primary rating from Vendor (https://github.com/always-further/nono).

CVSS VectorVendor: https://github.com/always-further/nono

Attack Vector
Local
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
High
Availability
Low

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:

bash
$ 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

EPSS Score
0.0%
Top 98% exploitable
Threat Intel
1
1 source
Data Quality
5 sources
Confidence: Medium
NVD CVE.org EPSS GHSA Vendor GitHub

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.

SignalValue
Severity MEDIUM
CISA KEV No
Public POC No
EPSS 0.0%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Defer
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact· derived
Medium

Priority Score

30
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +30
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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.

Affected Products (CPE)CVE.org

pkg:rust/nono-cli

Vendor StatusVendor

SUSE

Severity: Moderate

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy