/

CVE-2026-32323

Severity:

HIGH RISK

(7.3)

Privilege Management and Untrusted Path Execution

CVE-2026-32323

Analyzed

Vulnerability type

Category:

Privilege Management and Untrusted Path Execution

CWE:

CWE-269, CWE-345, CWE-427

Impact:

Local Privilege Escalation to Root

Severity:

HIGH RISK

(7.3)

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

The Mullvad VPN macOS installer up to version 2026.1 may execute binaries from /Applications/Mullvad VPN.app without verifying that the bundle is the legitimate Mullvad application.

An attacker with admin-group privileges who can pre-place a crafted bundle at that path could achieve code execution as root during installation or upgrade.

Affected context

This vulnerability appears in the Mullvad VPN installer and upgrader on macOS systems when versions 2026.1 and below are used.

It is relevant in environments where:

  • Users belong to the local admin group and can write to /Applications
  • The Mullvad VPN application is being freshly installed or upgraded
  • The installer implicitly trusts that /Applications/Mullvad VPN.app points to a genuine, vendor-controlled bundle

The risk is primarily during the installation/upgrade workflow; already-installed, older runtimes are not directly affected outside that process.

Exploit preconditions

  • Attack surface: Local system installation and upgrade flow for Mullvad VPN on macOS
  • Required access:
  • Membership in the local admin group (or equivalent rights to write to /Applications)
  • Ability to create or replace /Applications/Mullvad VPN.app before the installer runs
  • Trigger point:
  • Execution of the Mullvad VPN installer or upgrader (versions 2026.1 and below)
  • Installer invoking binaries from /Applications/Mullvad VPN.app
  • Why exploitation is possible:
  • The installer assumes that the bundle at /Applications/Mullvad VPN.app is trusted
  • No validation is performed to confirm authenticity, ownership, or integrity of the application bundle
  • As a result, attacker-controlled code at that location can be executed with elevated (root) privileges.

Why this happens

The core issue is that the installer relies on a filesystem path to locate and execute application binaries without establishing trust in the bundle found at that path.

This maps primarily to CWE-269: Improper Privilege Management, because privileged installer logic delegates execution to code residing at a location writable by less-privileged users without appropriately constraining or validating it.

Contributing aspects include:

  • CWE-427: Uncontrolled Search Path Element patterns, where a fixed directory path is treated as trusted without verifying its contents or ensuring it is controlled solely by the vendor.
  • CWE-345: Insufficient Verification of Data Authenticity, as there is no check (e.g., signature, bundle identifier, ownership) to ensure that the application bundle is genuine and not replaced by an attacker.

Abstractly, the insecure pattern is:

  • A high-privilege installer launches external binaries by path
  • The path is located in a directory that non-root users with admin membership can modify
  • No cryptographic or policy-based validation is performed on the binaries before execution.

Potential impact

  • Local users with admin-group membership could gain full root code execution during installation or upgrade.
  • Malicious installers or scripts could persist root-level backdoors or system modifications under the guise of a legitimate VPN installation.
  • System integrity could be reduced if attackers leverage the installer to bypass typical privilege escalation barriers.
  • Security tools relying on trust in vendor installers may be undermined, impacting endpoint hardening assumptions.

General mitigation guidance

Effective mitigation centers on tightening trust boundaries around privileged installation workflows and enforcing strong authenticity guarantees:

  • Treat installer-executed binaries as untrusted by default: Avoid executing binaries by path from locations writable by non-root users; instead, ship and execute self-contained, vendor-controlled binaries within the installer's own trusted payload.
  • Enforce authenticity checks on external bundles: If external bundles must be used, validate them using:
  • Code signing verification
  • Expected bundle identifiers and entitlements
  • Ownership and permissions checks preventing modification by non-root users
  • Restrict writable locations for privileged code execution: Use directories with restricted permissions (root-owned, non-writable by standard or admin users) for any component that may be executed as root.
  • Use least-privilege execution: Where possible, separate privileged operations (such as system modifications) from application logic and run only the minimal necessary operations as root, keeping all other actions under non-privileged contexts.
  • Harden installation workflows: Adopt installer patterns that avoid reusing pre-existing binaries during upgrades, favoring atomic replacement strategies that maintain integrity checks throughout the process.

How teams detect issues like this

Organizations and developers can identify similar weaknesses by:

  • Static analysis and code review:
  • Review installer scripts and packaging logic for calls that execute external binaries (e.g., exec, system, installer hooks) using absolute or relative paths into globally writable or semi-writable directories like /Applications.
  • Flag any logic where high-privilege processes defer to binaries located outside the installer's trusted payload without authenticity checks.
  • Look for missing signature verification or bundle identity validation before invoking app binaries.
  • Policy and configuration audits:
  • Enforce policies requiring that all privileged installers:
  • Execute only vendor-controlled binaries
  • Validate external artifacts via code signing or checksums
  • Use configuration management tools to detect and alert on unusual or non-vendor-owned bundles at expected application paths.
  • Behavioral monitoring:
  • Monitor installer executions for spawning processes from unexpected or newly created application bundles.
  • Use endpoint detection tools to alert when installers launch binaries that differ in signature or hash from known-good versions.
  • Automated tooling integration:
  • Integrate build-time checks that scan installer packages for references to external paths and require explicit justification or waiver when external application bundles are invoked.

Sources

SourceLink
github.comgithub.com/mullvad/mullvadvpn-app/commit/032fdcb927c0b6d3e5e1aba4140d33adf22a6bfb
github.comgithub.com/mullvad/mullvadvpn-app/security/advisories/GHSA-c2g6-w5fq-vw3m

Frequently asked

questions

No. Exploitation is local and requires a user with admin-group privileges on the affected macOS system. The attacker must be able to place or replace an application bundle at /Applications/Mullvad VPN.app before the installer or upgrader runs.

The attacker needs local system access and membership in the admin group (or equivalent permissions) to write into /Applications. Without the ability to create or modify the application bundle at that path, exploitation is not feasible.

The most robust fix is to ensure privileged installers never execute code from locations that are writable by less-privileged users without strong authenticity checks. Instead, installers should execute only bundled, vendor-controlled binaries or validate any external bundles via code signing, identity checks, and strict permission controls before use.

Prevention relies on designing installers with explicit trust boundaries:

  • Treat all external paths as untrusted unless proven otherwise.
  • Ensure all privileged operations are performed by binaries delivered and verified as part of the installer.
  • Require code signing and integrity verification for any external components.
  • Incorporate security-focused code review and automated checks for installer scripts and packaging logic, with special attention to where and how privileged processes execute external programs.
Find out what's already
exploitable in your codebase.