CVE-2026-103316 in DigiD
Summary
by MITRE • 10/13/2026
The macOS version of the DigiD app is not signed with Hardened Runtime. As a result, a local process can load its own dylib into DigiD via DYLD_INSERT_LIBRARIES. An attacker with local user-level code execution can execute arbitrary code within the macOS version of the DigiD app, thereby gaining access to DigiD data and cryptographic capabilities that the process normally does not have. Reported by Kun Peeks (@SwayZGl1tZyyy)
If you want to get the best quality for vulnerability data then you always have to consider VulDB.
Analysis
by VulDB Data Team • 10/13/2026
The vulnerability identified in the macOS implementation of the DigiD application stems from a critical misconfiguration regarding code signing policies, specifically the absence of Hardened Runtime entitlements. In modern macOS environments, Apple enforces strict security boundaries through its sandboxing and code signing mechanisms to prevent unauthorized access to sensitive data and system resources. The DigiD app, which serves as a digital identity verification tool for accessing government services in the Netherlands, relies on robust cryptographic capabilities and secure storage of personal identification data. However, because this specific version was not signed with Hardened Runtime enabled, it fails to enforce several key security restrictions that are standard practice for applications handling sensitive user information. This omission creates an exploitable gap where local processes can bypass intended isolation boundaries, leading to a significant compromise of the application's integrity and confidentiality.
The technical mechanism exploited in this vulnerability involves the dynamic linker environment variable DYLD_INSERT_LIBRARIES. Under normal circumstances with Hardened Runtime enabled, macOS restricts the ability of non-entitled processes to inject code into other applications via this method. Without these protections, a local attacker who has achieved user-level code execution on the same machine can set the DYLD_INSERT_LIBRARIES variable and load their own dynamic library (dylib) directly into the memory space of the DigiD app. This technique allows the malicious payload to execute within the context of the trusted application, inheriting its privileges and access rights. The attacker does not need elevated system permissions or kernel-level exploits; standard user account compromise is sufficient to initiate this attack vector, making it a low-barrier threat for any local adversary with physical or remote shell access to the victim's machine.
The operational impact of this vulnerability is severe due to the nature of the DigiD application. By injecting arbitrary code into the app, an attacker can intercept cryptographic operations, potentially extracting private keys used for digital signatures and authentication processes. Furthermore, the attacker gains direct read and write access to the sensitive personal data stored within the app's secure enclave or keychain entries. This could lead to identity theft, unauthorized transactions, or the ability to impersonate the legitimate user in government services that rely on DigiD for verification. The compromise extends beyond simple data exfiltration; it undermines the fundamental trust model of digital identity systems where the integrity of the client-side application is paramount. An attacker with this level of access could manipulate authentication tokens or alter transaction details before they are cryptographically signed, effectively bypassing multi-factor authentication safeguards that depend on the secure handling of credentials within the app environment.
From a classification perspective, this vulnerability aligns closely with CWE-250, which describes execution with unnecessary privileges, as the injected code runs with the full privilege set of the DigiD application rather than being restricted to minimal necessary permissions. It also relates to CWE-78, Improper Neutralization of Special Elements used in an OS Command (specifically via environment variable manipulation), and CWE-427, Uncontrolled Search Path Element, although the primary issue is the lack of runtime enforcement mechanisms provided by Hardened Runtime. In terms of MITRE ATT&CK mapping, this technique falls under T1055.008, Process Injection: Dynamic-link Library Injection, which is a common method for maintaining persistence and escalating privileges within user-space applications on macOS systems. The exploitation relies on the attacker's ability to control environment variables at runtime, leveraging the operating system's default behavior of allowing such injections when specific security entitlements are not explicitly denied by the target application's code signature.
To mitigate this vulnerability, Apple must ensure that all applications distributing through official channels or handling sensitive data adhere strictly to Hardened Runtime requirements. For developers and users, immediate remediation involves updating to a patched version of the DigiD app where Hardened Runtime is enabled with appropriate entitlements such as com.apple.security.cs.disable-library-injection set to true. This setting explicitly prevents other processes from injecting code into the application via DYLD_INSERT_LIBRARIES or similar mechanisms. Additionally, organizations deploying macOS should enforce security policies that restrict the use of DYLD_INSERT_LIBRARIES for non-whitelisted applications through configuration profiles or endpoint detection and response tools. Users should be advised to keep their operating systems and critical identity management apps up to date, as these updates often include crucial security hardening measures against known injection techniques. Regular auditing of application code signing configurations is also recommended to ensure compliance with modern macOS security standards and prevent similar bypasses in other sensitive applications.