/

CVE-2026-35533

Severity:

HIGH RISK

(7.7)

Improper Access Control in mise Project Configuration

CVE-2026-35533

Analyzed

Vulnerability type

Category:

Improper Access Control

CWE:

CWE-284

Impact:

Local Code Execution and Environment Compromise

Severity:

HIGH RISK

(7.7)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

mise versions 2026.2.18 through 2026.4.5 load trust-control settings from a local project .mise.toml before performing the intended trust check.

An attacker who can introduce a malicious .mise.toml into a repository can cause that same file to be treated as trusted and trigger dangerous directives such as [env] _.source, templates, hooks, or tasks.

Affected context

This vulnerability affects environments where mise is used to manage development tools and project automation via .mise.toml files.

It is most relevant when developers:

  • Clone or work with repositories from partially trusted or unverified sources
  • Run mise commands in project directories without reviewing the .mise.toml
  • Rely on mise's trust model to prevent execution of untrusted project configuration

The risk appears when a project directory contains an attacker-controlled .mise.toml that is loaded before the trust check is fully enforced.

Exploit preconditions

  • Attack surface: Local developer machines, CI agents, or other systems where mise is installed and used on untrusted or semi-trusted repositories.
  • Required access: Ability to add or modify .mise.toml in a repository or working directory (e.g., via supplying a malicious repo, compromising a repo, or contributing configuration changes that get pulled).
  • Trigger point: A user or automated system runs mise in that directory, causing it to load trust-control settings from .mise.toml prior to validating trust.
  • Why exploitation is possible: The trust model is inverted: trust-related options are read from the same configuration file whose trust is supposed to be checked, allowing the file to self-declare or influence its trusted status and unlock dangerous directives.

Why this happens

The issue stems from improper access control around configuration trust, aligning with CWE-284: Improper Access Control.

mise is designed to treat certain project configuration and automation features as privileged, gated by a trust mechanism so that untrusted repositories cannot execute arbitrary directives.

However, in the affected versions, the implementation loads trust-control settings from .mise.toml before the trust decision is finalized.

This creates a circular dependency where the untrusted configuration file is allowed to influence whether it is considered trustworthy, effectively bypassing the intended protections.

Instead of enforcing a clear separation between trusted policy sources and untrusted project configuration, the same file controls both behavior and its own trust level.

Potential impact

  • Execution of arbitrary commands or scripts via hooks, tasks, or template processing when the project is opened or mise commands are run
  • Silent modification of environment variables through [env] directives, potentially altering build, test, or deployment behavior
  • Contamination of local development environments, including installation or configuration of malicious tooling
  • Compromise of CI pipelines that rely on mise, leading to poisoned artifacts or altered infrastructure-as-code flows
  • Lateral movement opportunities if credentials, tokens, or secrets are exposed to malicious tasks or hooks

General mitigation guidance

Effective mitigation centers on enforcing a strict separation between trust policy and project configuration, and minimizing implicit trust in repository contents.

Pattern-based approaches include:

  • Ensuring that trust decisions are derived from external, immutable sources (e.g., global configuration, allowlists, or signed metadata) rather than from the project file being evaluated.
  • Designing trust checks to run before any project configuration is parsed or acted upon, especially for directives that can execute code, read files, or alter the environment.
  • Restricting or sandboxing powerful directives (e.g., hooks, tasks, env sourcing) so they require explicit opt-in from a trusted context, regardless of project-level settings.
  • Encouraging workflows where developers must explicitly acknowledge or view configuration from new repositories before enabling advanced features.
  • Running mise-driven automation with least privilege, limiting the impact of any configuration that does execute (e.g., constrained environment variables, minimal filesystem and network access).

How teams detect issues like this

Detection focuses on locating configurations and code paths where trust and execution are intermingled:

  • Static analysis and code review:
  • Flag code paths where trust flags or policies are read from the same file that defines executable directives.
  • Identify logic that reads project configuration before evaluating trust state, especially around hooks, tasks, templates, and environment sourcing.
  • Look for conditions where a configuration file can elevate its own privileges (e.g., "if setting X in this file is true, treat this file as trusted").
  • Configuration auditing:
  • Scan repositories for .mise.toml entries that enable powerful directives in contexts where the repository origin is not strongly validated.
  • Use policy checks in CI to block or require review for changes that introduce or modify hooks, tasks, or env-sourcing sections.
  • Runtime monitoring:
  • Log and monitor executions triggered by project configuration (tasks, hooks, templates) and correlate them with repository origin or trust status.
  • Automated security review tools can be integrated into development workflows to enforce patterns such as "no code-executing directives in untrusted or newly added configuration files."

Sources

SourceLink
github.comgithub.com/jdx/mise/security/advisories/GHSA-436v-8fw5-4mj8

Frequently asked

questions

Exploitation is typically local to systems where mise is installed and used on untrusted or semi-trusted repositories. The attacker must be able to supply or influence a .mise.toml file, but once that condition is met, execution can occur whenever mise processes the project.

Not necessarily. The attacker primarily needs a path to deliver a malicious repository or configuration (for example, a public repo that a developer clones, or a pull request that modifies .mise.toml). The actual execution then occurs under the victim's local user or CI identity when mise is run.

The most robust pattern is to decouple trust policy from project configuration: trust decisions should be based on external, trusted configuration or metadata, and must be evaluated before any project-specific directives are parsed or executed. Project files should never be allowed to determine their own trust level or unlock privileged behavior.

Adopt a design where:

  • Trust is explicit, external, and fail-safe (default to untrusted).
  • Configuration parsing is staged so that non-executable metadata is read first, with any executable or side-effectful features gated behind a confirmed trust state.
  • Security reviews and automated checks focus on areas where configuration can trigger execution or environment changes, ensuring those paths respect centralized trust controls.
Find out what's already
exploitable in your codebase.