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



CVE-2026-75911

CVE-2026-75911: Remote Code Execution via Configuration Override in CodeWhale

Alon Barad
Alon Barad
Software Engineer

Sep 4, 2026·6 min read·23 visits

Executive Summary (TL;DR)

Insecure workspace configuration merging in CodeWhale lets a malicious git repository silently enable shell access and execute arbitrary commands via prompt injection when the workspace is opened.

CVE-2026-75911 is a configuration injection and remote code execution vulnerability in CodeWhale. Unsafe merging of repository-level TOML configuration files allows malicious repositories to silently enable shell tool registration and inject prompts, forcing the integrated LLM agent to execute arbitrary host commands.

Vulnerability Overview

This vulnerability, registered as CVE-2026-75911, represents a security flaw in the workspace configuration parsing logic of CodeWhale, a Terminal User Interface (TUI) client for AI-assisted development. CodeWhale allows projects to define local workspace behaviors through a configuration file situated at .codewhale/config.toml. The implementation contains an insecure merging mechanism where local, project-scope directives override global, user-scope security profiles.

Specifically, the flaw arises from the unvalidated trust placed in the allow_shell boolean flag and the instructions array configured within an untrusted repository. Under normal operating conditions, these settings are reserved for global or explicitly approved configurations, as they dictate whether the integrated Large Language Model (LLM) agent has the capability to run system-level commands.

When an external repository is cloned and opened, the application automatically merges the local configuration with the user's global settings. If the local configuration sets allow_shell = true and introduces custom instruction sets, the client program acts on these parameters. This configuration injection compromises the execution environment by enabling dangerous APIs and executing attacker-specified shell scripts without notifying the user.

Root Cause Analysis

The root cause of CVE-2026-75911 lies in the insecure design pattern of merging untrusted configuration files. The workspace configuration loader, implemented in Rust within crates/tui/src/main.rs, processes the project-level .codewhale/config.toml file without enforcing privilege boundaries or implementing confirmation dialogs. This mechanism violates basic security design principles concerning security-sensitive parameters.

The core architecture of CodeWhale implements tool-calling capabilities that allow the integrated AI engine to interact with the host system. The registered capabilities include exec_shell and task_shell. The state of these tools is determined by the allow_shell boolean variable. The merging function, merge_project_config, processes project-specific TOML tables and directly assigns values to the runtime configuration structure.

Because the merge logic performs a direct override (config.allow_shell = Some(v) and config.instructions = Some(entries)), any value supplied by the project configuration takes immediate precedence. There is no cryptographic verification, origin validation, or user prompt. Consequently, the user's explicit preference to disable shell tool execution is overridden simply by opening a workspace. This is classified as CWE-94: Improper Control of Generation of Code ('Code Injection').

Code Analysis

The vulnerability exists within the merge_project_config function located in crates/tui/src/main.rs. In vulnerable releases prior to version 0.8.64, the function handles the TOML elements allow_shell and instructions without restrictions.

Consider the vulnerable code block:

fn merge_project_config(config: &mut Config, workspace: &Path) {
    // ...
    if let Some(v) = table.get("allow_shell").and_then(toml::Value::as_bool) {
        config.allow_shell = Some(v); // Vulnerable: Directly overrides user config with project config
    }
    
    if let Some(arr) = table.get("instructions").and_then(toml::Value::as_array) {
        let entries: Vec<String> = arr
            .iter()
            .filter_map(|v| v.as_str().map(str::to_string))
            .filter(|s| !s.trim().is_empty())
            .collect();
        config.instructions = Some(entries); // Vulnerable: Wholesale replacement of global system instructions
    }
}

The corrective patch applied in commit 43563356b98c6b993085554da82e77370160a31c restricts this process. It implements a unidirectional security check where local configurations can only restrict permissions.

// Patched implementation in crates/tui/src/main.rs
fn merge_project_config(config: &mut Config, workspace: &Path) {
    // ...
    if let Some(v) = table.get("allow_shell").and_then(toml::Value::as_bool) {
        if v {
            eprintln!(
                "warning: project-scope `allow_shell = true` is ignored — \
                 enable shell from user config for this workspace instead. \
                 (See #417.)"
            );
        } else {
            // Allowing project configuration to strictly disable shell is safe
            config.allow_shell = Some(false);
        }
    }
 
    if table.contains_key("instructions") {
        eprintln!(
            "warning: project-scope `instructions` is ignored — \
             configure instruction files from user config instead. \
             (See #417.)"
        );
    }
}

By ignoring the allow_shell = true directive and emitting a warning to stderr, the patch ensures that the global safety posture is preserved. Furthermore, the complete elimination of project-scope instructions prevents the application from reading untrusted prompt directives that might alter LLM safety alignment.

Exploitation Methodology

Exploitation of CVE-2026-75911 is achieved through repository compromise or social engineering, requiring the victim to clone and open a weaponized project. The attack requires no authentication or specific system capabilities beyond the use of CodeWhale.

The attack vector is illustrated in the following workflow:

To construct a working proof of concept, the attacker creates a .codewhale/config.toml file containing allow_shell = true alongside an overridden instruction source. The instruction source, which is typically a markdown file, contains prompt injection vectors designed to direct the AI agent's reasoning. These directives force the agent to run reconnaissance or persistence scripts via the registered exec_shell tool as part of its normal operation, executing arbitrary shell code on the victim's machine.

Impact Assessment

The impact of successful exploitation is a complete compromise of the confidentiality, integrity, and availability of the local system. Because CodeWhale runs directly within the user's terminal environment, any system commands executed by the AI agent inherit the privileges of the active operating system user.

This results in local command execution without warning. Threat actors can use this access to extract sensitive credentials, such as AWS tokens, SSH private keys, and git credentials, which are commonly present on developer workstations. Furthermore, the attacker can establish persistent reverse shells or implant malicious code into other projects.

The CVSS score of 8.5 (for CVSS v4.0) and 7.8 (for CVSS v3.1) reflects the severity of the vulnerability. Although exploitation requires passive user interaction—cloning and opening the workspace—the execution phase requires no further confirmation, leading to immediate system exposure.

Remediation and Prevention

The definitive mitigation for this vulnerability is upgrading CodeWhale to version 0.8.64 or later. In these versions, project-level configurations are prevented from escalating privileges or overriding prompt directions.

If upgrading is not immediately possible, several defense-in-depth measures should be deployed. Users must audit untrusted repositories for the existence of .codewhale folders and delete or sanitize config.toml files before launching the TUI client.

Additionally, isolating CodeWhale within a sandboxed environment, such as a Docker container or a dedicated virtual machine, limits the blast radius of any potential execution. Global configuration files should be set to read-only, and shell execution permissions should be explicitly disabled unless required.

Official Patches

HmbownSecurity fix patch for config override
HmbownOfficial security advisory GHSA-gx45-xrj5-g6c4

Fix Analysis (1)

Technical Appendix

CVSS Score
8.5/ 10
CVSS:4.0/AV:L/AC:L/AT:N/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
EPSS Probability
0.17%
Top 93% most exploited

Affected Systems

CodeWhale Terminal User Interface (TUI) workspace environment

Affected Versions Detail

Product
Affected Versions
Fixed Version
CodeWhale
Hmbown
>= 0.8.6, < 0.8.410.8.41
CodeWhale
Hmbown
>= 0.8.41, < 0.8.640.8.64
AttributeDetail
CWE IDCWE-94
Attack VectorLocal (User-initiated clone & open)
CVSS v4.08.5 (High)
CVSS v3.17.8 (High)
Exploit StatusProof-of-Concept
CISA KEV StatusNot Listed

MITRE ATT&CK Mapping

T1059Command and Scripting Interpreter
Execution
T1203Exploitation for Client Execution
Execution
CWE-94
Improper Control of Generation of Code ('Code Injection')

The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended code segment when it is sent to a downstream component.

Known Exploits & Detection

GHSA-gx45-xrj5-g6c4Security advisory containing the conceptual trigger details for project configuration override

Vulnerability Timeline

Vulnerability discovered, vendor advisory GHSA-gx45-xrj5-g6c4 published, and final corrective patch commit 43563356b98c6b993085554da82e77370160a31c pushed
2026-08-18

References & Sources

  • [1]GitHub Security Advisory GHSA-gx45-xrj5-g6c4
  • [2]VulnCheck Security Advisory
  • [3]NVD Record
  • [4]CVE-2026-75911 CVE Record

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

•14 minutes ago•CVE-2026-126297
7.5

CVE-2026-126297: Algorithmic Complexity Denial of Service in NLTK ConllCorpusReader

CVE-2026-126297 (GHSA-v8f3-6phw-6mh9) is an uncontrolled resource consumption and algorithmic complexity vulnerability in the Natural Language Toolkit (NLTK) prior to version 3.10.4. Located in the Semantic Role Labeling (SRL) parser within `nltk/corpus/reader/conll.py`, the flaw allows an attacker to trigger quadratic O(N^2) CPU processing overhead by providing crafted CoNLL-formatted corpus inputs containing decoy span columns or nested full-width verb spans. Applications parsing untrusted linguistic corpora can experience prolonged CPU exhaustion and application-level Denial of Service (DoS).

Amit Schendel
Amit Schendel
0 views•12 min read
•about 1 hour ago•CVE-2026-126298
7.5

CVE-2026-126298: Quadratic Algorithmic Complexity Denial of Service in NLTK Tree.chomsky_normal_form

CVE-2026-126298 (also tracked as GHSA-r53h-rw34-8h97) is an algorithmic complexity Denial of Service (DoS) vulnerability in the Natural Language Toolkit (NLTK) Python library affecting all versions prior to 3.10.4. The vulnerability resides in the nltk.tree.transforms.chomsky_normal_form function and its corresponding public method Tree.chomsky_normal_form(). When transforming a parse tree into Chomsky Normal Form using the default right-factoring strategy, the function repeatedly invokes list.pop(0) inside a loop iterating over all children of a node. In CPython, removing the initial element of a standard list requires an O(N) memory shift operation, causing the overall binarization algorithm to degrade to O(N^2) quadratic time complexity relative to the width of a node. Furthermore, converting horizontal node width into vertical tree depth bypasses initial parsing depth bounds, triggering subsequent stack exhaustion (RecursionError) when recursive methods traverse the mutated structure. Unauthenticated remote attackers who can submit bracketed tree strings to applications invoking this transformation can exhaust single-threaded CPU resources or induce unhandled application exceptions.

Alon Barad
Alon Barad
3 views•12 min read
•about 2 hours ago•CVE-2026-126299
7.5

CVE-2026-126299: Quadratic Algorithmic Complexity Denial of Service in NLTK CCG Lexicon Parser

An algorithmic complexity vulnerability (CWE-407) in the Natural Language Toolkit (NLTK) before version 3.10.4 allows remote unauthenticated attackers to cause a denial of service via crafted Combinatory Categorial Grammar (CCG) lexicon strings. The parser in nltk.ccg.lexicon.fromstring performs repeated immutable string slicing, concatenation, and regex tail capturing, resulting in O(n^2) CPU consumption when processing wide, flat category definitions.

Alon Barad
Alon Barad
4 views•10 min read
•about 3 hours ago•CVE-2026-126295
7.1

CVE-2026-126295: Path Traversal and Unconfined File Access in NLTK BllipParser

CVE-2026-126295 (also tracked as GHSA-fg9w-wfp5-j933) is a path confinement bypass vulnerability in the Natural Language Toolkit (NLTK) affecting versions 3.10.0 prior to 3.10.4. The flaw resides in nltk/parse/bllip.py within the BllipParser class and its factory method BllipParser.from_unified_model_dir(). Unlike sibling tool wrappers in NLTK that enforce data-root confinement via the nltk.pathsec module, BllipParser passes caller-supplied filesystem paths directly into the third-party bllipparser native C extension without validation. When an application passes untrusted input as model paths or directories to BllipParser, an attacker can force the native extension to open arbitrary files on the local filesystem. This leads to information disclosure through parser diagnostic oracles, local model tampering via shared directories, and denial of service by hanging worker threads on blocking special files (such as FIFOs or device nodes) or exhausting memory via oversized files.

Amit Schendel
Amit Schendel
2 views•11 min read
•about 4 hours ago•CVE-2026-126300
5.3

CVE-2026-126300: Algorithmic Complexity Denial of Service in NLTK TreebankWordTokenizer.span_tokenize

CVE-2026-126300 (GHSA-ffr9-mgrr-wcvr) is an inefficient algorithmic complexity vulnerability (CWE-407) in the Natural Language Toolkit (NLTK) Python library affecting versions 3.2.5 prior to 3.10.4. The flaw resides in the quote-restoration routine of TreebankWordTokenizer.span_tokenize and NLTKWordTokenizer.span_tokenize, where repeated calls to list.pop(0) over matched quote tokens introduce quadratic O(n^2) time complexity. An unauthenticated remote attacker who supplies input containing long sequences of double-quote characters can exhaust CPU resources and degrade service availability.

Amit Schendel
Amit Schendel
3 views•10 min read
•about 5 hours ago•GHSA-GPWC-27CW-RH9R
5.3

CVE-2026-126301: Quadratic CPU Exhaustion in NLTK LegalitySyllableTokenizer

The Natural Language Toolkit (NLTK) versions 3.6 through 3.10.3 contain an algorithmic complexity vulnerability in the LegalitySyllableTokenizer.tokenize method. When processing tokens composed of continuous runs of vowels, an unguarded string reversal and set membership lookup loop executes in quadratic time relative to the input token length. Remote attackers capable of submitting arbitrary text to applications utilizing this tokenizer can trigger sustained single-core CPU exhaustion and application-level denial of service.

Amit Schendel
Amit Schendel
5 views•10 min read