Jul 28, 2026·5 min read·26 visits
A fail-open flaw in nono-cli version 0.61.2 and earlier allows unverified packages to execute on the host machine by simply deleting their local metadata and lockfile files.
The nono-cli package verification mechanism fails open when both the lockfile entry and local trust bundle are absent. This allows local attackers to execute unverified package profiles and native host session hooks by removing metadata configurations, bypassing cryptographic integrity controls.
The nono-cli utility is a Rust-based command-line interface designed to manage, install, and execute registry packages ("packs") containing execution profiles and session hooks. To maintain host integrity, nono-cli implements a cryptographic trust architecture to verify packages prior to execution. This process is essential because session hooks run natively on the host operating system, presenting a substantial attack surface.
The security boundary depends on validating each package against local provenance and cryptographic signatures. These controls are evaluated in crates/nono-cli/src/profile_runtime.rs inside the verify_profile_packs function. This function coordinates checks against a global registry lockfile and individual signature files.
In versions up to and including 0.61.2, a design flaw allows packages to execute without cryptographic validation if the security metadata is entirely absent. This issue is categorized under CWE-636: Not Failing Securely ('Failing Open'). An attacker with local access who can tamper with the configuration directory can execute unverified packages.
The root cause of this vulnerability lies in the structural logic of the package verification flow in crates/nono-cli/src/profile_runtime.rs. The code was designed to treat verification states as conditional depending on the presence of local metadata files. Specifically, the system tracked packages using ~/.config/nono/packages/lockfile.json and verified integrity using individual .nono-trust.bundle files.
When executing a profile, verify_profile_packs queried lockfile.json for the package entry. If the package was present but lacked a valid signature, or if the lockfile entry existed but the .nono-trust.bundle was missing, the verification logic correctly generated an error and blocked execution. This partial metadata state successfully failed closed.
However, if both the package entry in lockfile.json and the corresponding .nono-trust.bundle file were missing, the function bypassed all checks. The implementation did not enforce a default-deny policy. Instead, the absence of metadata was interpreted as a signal that verification was not required, resulting in a fail-open condition.
To understand the exact breakdown, we must analyze the vulnerable code path in crates/nono-cli/src/profile_runtime.rs. The implementation used an optional match to extract the package entry from the lockfile.
// Vulnerable implementation of lockfile lookup
let locked = lockfile.packages.get(pack_ref);
if let Some(locked_pkg) = locked {
for (artifact_name, locked_artifact) in &locked_pkg.artifacts {
// Perform verification steps...
}
}If locked evaluated to None, the entire block was bypassed without returning an error. Similarly, the trust bundle evaluation was conditional.
// Vulnerable implementation of trust bundle check
let bundle_path = install_dir.join(".nono-trust.bundle");
if bundle_path.exists() {
// Validate signature bundle...
verify_stored_bundles(&install_dir, &bundle_path, pack_ref, Some(pinned_signer))?;
}If bundle_path.exists() returned false, the system skipped signature validation. The patch in commit db07375031642f089d549b4f7b9abece87e39f87 corrected this behavior by converting these conditional blocks into strict validation rules.
// Patched lockfile check enforcing mandatory entries
let locked_pkg = lockfile.packages.get(pack_ref).ok_or_else(|| {
nono::NonoError::PackageVerification {
package: pack_ref.clone(),
reason: format!(
"pack '{}' has no lockfile entry - reinstall with: nono pull {} --force",
pack_ref, pack_ref
),
}
})?;The patched implementation treats missing trust bundles as a hard error. Additionally, it resolves potential variant bypasses by strictly verifying the signer_identity and calling verify_stored_bundles unconditionally.
Exploitation of this vulnerability requires local write access to the host configuration directory at ~/.config/nono. This path holds both the global lockfile.json and the individual package files. An attacker targeting a systems environment can leverage this state to execute malicious configurations.
Consider a configuration containing a package named always-further/claude that includes host-executed session hooks. If the package is tampered with, standard execution will fail due to signature mismatch. To bypass this restriction, the attacker deletes the entry for always-further/claude inside ~/.config/nono/packages/lockfile.json and the signature trust bundle at ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.
When the user or a system process loads the profile via nono-cli, the client reads the modified path. Because no metadata is present, the logic skips verification and executes the malicious session hooks natively on the host OS.
The impact of this vulnerability is assessed at Medium severity with a CVSS v3.1 score of 6.6. The attack vector is Local (AV:L), requiring local operating system access or file tampering capabilities to exploit. No network-facing exposure is directly associated with this vector.
The core consequence is the execution of unverified, tampered packages on the host machine. Because nono packages support session hooks running natively without isolation, a local privilege boundary is bypassed. If a low-privilege attacker can write to the user's ~/.config/nono directory, they can execute arbitrary shell commands inside the context of any process invoking nono-cli.
The vulnerability does not directly impact the availability of the system (A:N), but it completely degrades both the confidentiality (C:H) and integrity (I:H) of the host environment. The execution of arbitrary session hooks can lead to credential theft, persistence establishment, or lateral movement within the network.
Remediation requires upgrading the nono-cli utility to version 0.61.3 (which is bundled in the official release v0.62.0). This update enforces signature and lockfile verification unconditionally. Systems running vulnerable versions must be updated to prevent local exploitation vectors.
To recover from situations where legitimate metadata is missing or corrupted, administrators can run the recovery command:
nono pull always-further/claude --force
This command uses the newly implemented ExecuteOptions { allow_unmanaged_identical_write_files: true } logic. This safely regenerates the necessary lockfile entries and .nono-trust.bundle structures without opening security bypasses, provided the local file hashes match the official distribution hashes.
CVSS:3.1/AV:L/AC:L/PR:L/UI:R/S:U/C:H/I:H/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
nono-cli nolabs-ai | <= 0.61.2 | 0.61.3 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-636 |
| Attack Vector | Local (AV:L) |
| CVSS Severity | 6.6 Medium |
| Impact | High Confidentiality, High Integrity (C:H/I:H) |
| Exploit Status | Proof of Concept (PoC) |
| First Patched Version | 0.61.3 / v0.62.0 |
The product is designed to fail in a state that releases protection or permits access when a secure state cannot be maintained or when an exception occurs.
An information exposure vulnerability in Ruby on Rails Action Pack allows sensitive session cookies to be attached to public, cacheable responses served by Active Storage proxy controllers. When cookie secret rotation or a hybrid cookie serializer migration is enabled, reading a legacy-format cookie triggers an automatic cookie rewrite that ignores the session-skipping directive. If an intermediate shared cache or CDN caches the resulting response along with its Set-Cookie header, subsequent users requesting the same URL receive the leaked session token.
CVE-2026-126072 (GHSA-rwvh-fw6r-pwvp) is a concurrency deadlock vulnerability in the Ruby on Rails Action Pack framework affecting applications that utilize ActionController::Live response streaming. The defect occurs due to improper synchronization within ActionController::Live::Buffer when handling full bounded queues during stream closure and connection abortion. An unauthenticated remote attacker can trigger this condition by stalling TCP socket reads on streaming endpoints—including Active Storage proxy mode—resulting in permanent worker thread exhaustion and application-wide denial of service.
CVE-2026-126192 is an algorithmic complexity vulnerability in Soup Sieve (soupsieve), the default CSS selector engine for Beautiful Soup 4 in Python. Evaluating a CSS selector that contains a general sibling combinator (~) nested inside a :has() relational pseudo-class against attacker-controlled HTML markup triggers O(n^2) quadratic evaluation complexity when the right-hand sibling target is absent. An unauthenticated attacker can supply small HTML documents containing thousands of sibling elements to exhaust CPU resources and stall application worker threads.
CVE-2026-126190 (GHSA-mmhr-3c5m-f64f) is an inefficient algorithmic complexity vulnerability (CWE-407) in Soup Sieve, the default CSS selector library integrated into Beautiful Soup 4. In versions prior to 4.0, evaluating CSS selectors that contain descendant combinators (whitespace between compound selectors) executes an unmemoized upward traversal of the document tree. When evaluated against deeply nested HTML or XML documents, the time complexity scales polynomially at O(n^(k+1)), where n is the tree depth and k is the number of descendant combinators. Remote attackers can supply compact, deeply nested markup (1 KB to 4 KB) to trigger prolonged CPU starvation and denial of service in Python applications.
CVE-2026-122006 is a critical vulnerability in the Ruby on Rails Active Storage framework affecting versions prior to 8.0.5.2 and 8.1.4.1. When an application processes uploaded file attachments using the ImageMagick variant processor (:mini_magick), the framework invokes ImageMagick's metadata analyzer without applying a restrictive security policy. An unauthenticated attacker can upload a crafted file containing directives for unrestricted ImageMagick coders, such as Magick Scripting Language (MSL), resulting in arbitrary server-side file read and write operations. In deployments using the Disk storage service, attackers can exfiltrate sensitive application configuration files, including secret_key_base and master encryption keys, which enables remote code execution via signed payload forgery.
CVE-2026-128065 (also tracked as GHSA-gg5j-6742-v827) is an authorization bypass vulnerability affecting the @grpc/grpc-js-xds library in the Node.js gRPC ecosystem. In versions 1.14.0 and 1.14.1, XdsServer acknowledges Route and VirtualHost resources from an xDS control plane while failing to parse, store, or apply RBACPerRoute override configurations. When experimental RBAC is enabled and a broad top-level ALLOW policy is paired with restrictive VirtualHost or Route overrides, the server evaluates requests strictly against the top-level policy, permitting unauthorized RPC execution.