Skip to main content

mise EUVDEUVD-2026-101154

| CVE-2026-103929 HIGH
OS Command Injection (CWE-78)
2026-10-14 GitHub_M GHSA-g74g-rg72-j2p3
7.8
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Developer opens malicious repository
  2. Delivery
    Plant .mise.toml default-shell-args settings
  3. Exploit
    Run trusted task lacking explicit shell
  4. Execution
    Attacker interpreter arguments execute first
  5. Impact
    Arbitrary command runs as developer account

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization OS command sanitization, avoid shell exec
MITRE ATT&CK

2 techniques across 1 tactic: Execution

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Requires: (1) mise running in its default non-safe mode; (2) the victim executing mise inside an untrusted local project whose .mise.toml [settings] sets unix_default_file_shell_args, unix_default_inline_shell_args, windows_default_file_shell_args, or windows_default_inline_shell_args; and (3) a trusted task that has NO explicit shell - or a postinstall directive, template exec operation, or hook that falls back to the default shell. LIMITING FACTORS: exploitation is local (attacker must get the victim to use a malicious repo) and needs user interaction (the developer must run the affected task); tasks that specify an explicit shell are not affected, and versions 2026.7.14+ strip these settings from local configs so only global config can set them.

Impact

This is a legitimate but conditional local-escalation risk rather than a mass-exploitation threat. The CVSS 3.1 vector (AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H = 7.8 HIGH) correctly reflects that exploitation is local and requires user interaction: a developer must run mise inside an attacker-supplied repository. No EPSS score was provided in the input, and there is no CISA KEV listing and no standalone public exploit, so the exploitation status is 'no public exploit identified at time of analysis' - the only code evidence is the vendor fix PR (#11293) and its regression tests, which demonstrate the mechanism but are not a weaponized exploit. The signals are internally consistent: local vector + required user interaction + no KEV/EPSS data all point to a supply-chain/social-engineering style issue (malicious repo) rather than remote automatable compromise. PR:N is accurate because the attacker needs no account on the victim host - they only need to get the victim to clone and operate on a hostile project. Net: worth prioritizing for developer workstations and CI that auto-run mise on untrusted code, but it is not a drop-everything internet-facing emergency; absence of EPSS/KEV data should be noted, not treated as 'low risk confirmed.'

Exploit ScenarioDerived

A developer clones or opens an attacker-controlled repository containing a malicious .mise.toml that sets unix_default_inline_shell_args (or the file/windows equivalents) to a hostile interpreter plus arguments. In mise's default non-safe mode this local [settings] block is loaded before the project is trusted, so when the developer runs a trusted task that has no explicit shell (or a postinstall/template-exec/hook that falls back to the default shell), mise invokes the attacker's interpreter arguments first and the attacker-chosen command executes with the developer's privileges. No public exploit is published, though the fix PR includes tests illustrating the flaw.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 14, 2026

mise (a polyglot dev tool manager for node, python, cmake, terraform, and others) before version 2026.7.14 lets a malicious local project inject interpreter arguments through an untrusted .mise.toml [settings] file, causing attacker-chosen commands to execute with the developer's privileges. In default non-safe mode, mise applies local project settings before trust approval, and the unix_default_file_shell_args, unix_default_inline_shell_args, windows_default_file_shell_args, and windows_default_inline_shell_args fields were missing the global_only marker, so they survived strip_local_only_settings. When a developer later runs a trusted task, postinstall directive, template exec, or hook that has no explicit shell, mise appends the legitimate command after the attacker-controlled interpreter arguments, and the attacker's command runs first despite the config never being trusted. Exploitation is local and requires user interaction (the victim must clone/open and run the affected task); there is no public exploit code and no confirmed active exploitation at time of analysis, and this is best characterized as a conditional local-escalation risk rather than a mass-exploitation threat. Fixed in 2026.7.14.

RemediationAI

Vendor-released patch: upgrade to mise 2026.7.14 or later (https://github.com/jdx/mise/releases/tag/v2026.7.14), which marks unix_default_file_shell_args, unix_default_inline_shell_args, windows_default_file_shell_args, and windows_default_inline_shell_args as global_only so strip_local_only_settings drops them from untrusted local configs (see PR #11293 / commit c6cd7a9a and advisory GHSA-g74g-rg72-j2p3). If upgrading is not immediately possible, compensating controls are: run mise with the safe mode / safe config option so untrusted local settings are not applied before trust approval (trade-off: some project-local convenience settings will be ignored or must be explicitly trusted); avoid running mise tasks, postinstall directives, template execs, or hooks inside repositories you have not reviewed; and require tasks to specify an explicit shell, since tasks with an explicit shell do not fall back to the vulnerable default interpreter arguments (trade-off: this requires editing/authoring tasks and does not protect third-party tasks that rely on defaults). Note that after 2026.7.14 these settings can still be set at global scope in trusted global config, so review ~/.config/mise/config.toml (or equivalent) for unexpected shell-argument overrides. This CVE's advisory also contains a separate path-sanitization hardening note, but that is out of scope for this vulnerability.

Affected VersionsENISA

mise < 2026.7.14

Affected Packages

cargo mise fix: 2026.7.14

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

mise reads project-level .mise.toml files to configure tool versions and shell behavior. The vulnerability is a classic OS command injection (CWE-78) rooted in a trust-boundary defect: the strip_local_only_settings routine is supposed to remove security-sensitive fields from untrusted local configs, keeping only fields explicitly marked global_only. The four default shell-argument settings (unix_default_file_shell_args, unix_default_inline_shell_args, windows_default_* equivalents) define the interpreter invocation used when a task omits an explicit shell or when postinstall directives, template exec operations, or hooks fall back to the default. Because these fields lacked global_only = true, an untrusted repository could supply its own interpreter arguments. mise then constructs the final command by concatenating the attacker-supplied interpreter arguments with the trusted trailing command, so the injected command is interpreted first by the shell. The upstream fix (PR #11293, commit c6cd7a9a) marks all four settings as global_only in settings.toml and adds regression tests confirming that strip_local_only_settings removes them from local (/tmp/.mise.toml) configs while preserving them for global configs. The advisory's separate path-sanitization hardening note is explicitly out of scope for this CVE.

Know when Mise gets its next vulnerability

  • 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 (GitHub_M) PRIMARY 7.8 HIGH
AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
vuln.today AI 7.8 HIGH

Attacker supplies a malicious local repo (AV:L, PR:N) that the developer must run a fallback-shell task against (UI:R); resulting code execution as the user yields full C/I/A:H.

3.1 AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
4.0 AV:L/AC:L/AT:N/PR:N/UI:A/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

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

Lifecycle Timeline

2
Patch available
Oct 14, 2026 - 16:03 EUVD
CVE Published
Oct 14, 2026 - 15:11 cve.org
HIGH 7.8

DescriptionCVE.org

mise manages dev tools like node, python, cmake, and terraform. Prior to 2026.7.14, in the default non-safe mode, mise loads .mise.toml [settings] from an untrusted local project before trust approval and strip_local_only_settings removes only fields marked global_only. The unix_default_file_shell_args, unix_default_inline_shell_args, windows_default_file_shell_args, and windows_default_inline_shell_args settings were not marked global_only, allowing a repository to replace the default interpreter arguments used by trusted tasks that have no explicit shell, postinstall directives, template exec operations, or hooks that fall back to the default shell. When mise appends the trusted command after the attacker-controlled interpreter arguments, the attacker-selected command can execute first with the developer account's privileges even though the local configuration was never trusted. The separate path-sanitization hardening note in the advisory is outside this vulnerability. This issue is fixed in version 2026.7.14.

Executive ViewAI

Why It Matters

A configuration-handling flaw in mise, the polyglot developer tool manager used by engineering teams for Node, Python, CMake, Terraform and similar toolchains, lets a malicious project repository execute attacker-chosen commands on a developer's workstation with that developer's own privileges, even though the project's configuration was never approved. The risk is local and requires a developer to clone or open a hostile repository and run an affected task, postinstall directive, template exec, or hook, so no remote attacker can trigger it directly; there is no public exploit identified at time of analysis. Leadership should care because developer endpoints concentrate source code, CI tokens, package-registry and cloud credentials, meaning a single careless run in an untrusted repository can expose high-value assets that are otherwise well defended at the network perimeter.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: keep mise in safe/trusted mode so untrusted local project settings are not applied before trust approval; do not run tasks, postinstall directives, template exec, or hooks in untrusted, vendor-supplied, or freshly cloned repositories; manually inspect .mise.toml [settings] for the unix_default_file_shell_args, unix_default_inline_shell_args, windows_default_file_shell_args, and windows_default_inline_shell_args fields and reject configurations containing them; restrict the scope of credentials and tokens present on developer endpoints and build hosts; and monitor for anomalous child-process spawning or unexpected interpreter arguments originating from mise.

Threat Intelligence Overview

EPSS Score
0.2%
Top 91% exploitable
Prevalence
Medium
popular polyglot dev-tool version manager, common among developers but not universal
Threat Intel
1
1 source
Data Quality
5 sources
Confidence: Medium
EUVD NVD CVE.org EPSS Vulnrichment GHSA 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 HIGH
CISA KEV No
Public POC No
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.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
Defer
Exploitation
Poc
System Exposure· derived
Small
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

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

Attack Technique

OS command injection occurs when an application passes unsanitized user input directly into system shell commands.

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