CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



GHSA-HC4M-Q9JH-XW4J

GHSA-hc4m-q9jh-xw4j: Registry Pack Verification Fail-Open Vulnerability in nono-cli

Alon Barad
Alon Barad
Software Engineer

Jul 28, 2026·5 min read·26 visits

Executive Summary (TL;DR)

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.

Vulnerability Overview

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.

Root Cause Analysis

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.

Code Analysis

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 Methodology

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.

Impact Assessment

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 and Defensive Strategies

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.

Official Patches

always-furtherGit commit fixing the verification logic

Fix Analysis (1)

Technical Appendix

CVSS Score
6.6/ 10
CVSS:3.1/AV:L/AC:L/PR:L/UI:R/S:U/C:H/I:H/A:N
EPSS Probability
0.04%
Top 100% most exploited

Affected Systems

nono-clinono profile runtime

Affected Versions Detail

Product
Affected Versions
Fixed Version
nono-cli
nolabs-ai
<= 0.61.20.61.3
AttributeDetail
CWE IDCWE-636
Attack VectorLocal (AV:L)
CVSS Severity6.6 Medium
ImpactHigh Confidentiality, High Integrity (C:H/I:H)
Exploit StatusProof of Concept (PoC)
First Patched Version0.61.3 / v0.62.0

MITRE ATT&CK Mapping

T1553.006Subvert Trust Controls: Code Signing
Defense Evasion
T1059Command and Scripting Interpreter
Execution
T1546Event Triggered Execution
Persistence
CWE-636
Not Failing Securely ('Failing Open')

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.

Known Exploits & Detection

GitHub Security Advisory Research ContextProof of concept demonstrating bypass by removing both lockfile.json and .nono-trust.bundle.

Vulnerability Timeline

Vulnerability patched and advisory published
2026-07-28

References & Sources

  • [1]GitHub Security Advisory GHSA-hc4m-q9jh-xw4j
  • [2]always-further/nono Advisory on Github
  • [3]Fix Commit db07375
  • [4]Release v0.62.0

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•31 minutes ago•CVE-2026-126077
6.8

CVE-2026-126077: Session Information Leak in Ruby on Rails Action Pack and Active Storage Proxy Mode

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.

Amit Schendel
Amit Schendel
2 views•11 min read
•about 2 hours ago•CVE-2026-126072
5.9

CVE-2026-126072: Thread Deadlock and Denial of Service in Ruby on Rails ActionController::Live

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.

Amit Schendel
Amit Schendel
3 views•10 min read
•about 3 hours ago•CVE-2026-126192
6.3

CVE-2026-126192: Quadratic Algorithmic Complexity Denial of Service in Soup Sieve CSS Selector Engine

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.

Alon Barad
Alon Barad
2 views•10 min read
•about 4 hours ago•CVE-2026-126190
7.5

CVE-2026-126190: Polynomial-Time Denial of Service in Soup Sieve CSS Descendant Combinator

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.

Amit Schendel
Amit Schendel
3 views•9 min read
•about 5 hours ago•CVE-2026-122006
9.8

CVE-2026-122006: Unauthenticated Arbitrary File Read and Write in Ruby on Rails Active Storage via ImageMagick

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.

Alon Barad
Alon Barad
3 views•10 min read
•about 6 hours ago•CVE-2026-128065
6.9

CVE-2026-128065: Authorization Bypass via Unapplied RBAC Overrides in @grpc/grpc-js-xds

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.

Alon Barad
Alon Barad
4 views•10 min read