/

CVE-2026-33874

Severity:

HIGH RISK

(7.8)

OS Command Injection in Gematik Authenticator for macOS via

CVE-2026-33874

Modified

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-78

Impact:

Remote Code Execution on Client System

Severity:

HIGH RISK

(7.8)

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 macOS version of Gematik Authenticator between 4.12.0 and 4.15.x contains an OS command injection vulnerability that can be triggered when a victim opens a specially crafted file.

Under these conditions, an attacker may be able to execute arbitrary code on the victim's machine with the privileges of the Authenticator process.

Affected context

This vulnerability affects Gematik Authenticator installations on macOS in environments where users open files that are associated with or otherwise handled by the Authenticator.

The risk becomes relevant when untrusted or externally supplied files can reach end users—for example, via email, downloads, or file sharing—because merely opening a malicious file can trigger the vulnerable behavior.

The issue is confined to the macOS client application and depends on how the application parses and acts upon file content or metadata.

Exploit preconditions

  • Attack surface: Local file handling in the Gematik Authenticator macOS application
  • Required access: Ability to deliver a malicious file to a victim (e.g., email attachment, download link, shared drive) and convince them to open it
  • Trigger point: User interaction that causes the Authenticator to open or process the crafted file
  • Why exploitation is possible: The file-processing logic ultimately influences OS-level command execution without adequately constraining or sanitizing the data used in those commands, enabling attacker-controlled input to affect command arguments or invocation flow.

Why this happens

The underlying issue aligns with CWE-78: OS Command Injection, where untrusted input is incorporated into operating system commands without robust validation or strict separation.

In this case, data derived from a user-supplied file is trusted too much by the macOS Authenticator component and is allowed to shape command execution (such as arguments, paths, flags, or subcommands).

Instead of treating file contents purely as data, the application likely routes some portion of that data into a command execution API or a shell-like context, allowing crafted input to break out of expected parameters and inject additional behavior.

Potential impact

  • Execution of arbitrary code with the privileges of the Authenticator process on the victim's Mac
  • Installation of malware or persistence mechanisms on the user's system
  • Unauthorized access to sensitive information available to the compromised user account
  • Lateral movement within the user's environment, depending on local network access and stored credentials
  • Tampering with or impersonating digital health application sessions that rely on the Authenticator

General mitigation guidance

Effective mitigation focuses on eliminating the ability for file-derived data to influence OS command execution in an unsafe way.

Recommended defensive patterns include:

  • Avoid constructing shell commands from file content; prefer calling system APIs or pre-defined executable paths with fixed argument sets.
  • If command execution is unavoidable, use parameterized, non-shell APIs (e.g., avoiding shell interpretation) and strictly validate all inputs against a whitelist of allowed values.
  • Treat any data originating from external files as untrusted: normalize, validate, and reject unexpected characters, control sequences, or meta-constructs.
  • Reduce the privileges of the Authenticator process where feasible (e.g., sandboxing mechanisms provided by macOS) so that a compromise yields minimal system access.
  • Implement robust error handling for file parsing: fail closed on malformed or unexpected file structures rather than attempting to recover with dynamic behavior.

How teams detect issues like this

Organizations can approach detection of this vulnerability pattern using a combination of code- and behavior-based strategies:

  • Static analysis: Configure rules to flag any use of shell execution APIs (e.g., system, popen, exec, NSTask with shell invocation) where arguments are derived from file content or other external sources without strict validation.
  • Code review cues: During manual review, scrutinize file-opening handlers, import routines, and any logic that maps file contents or metadata to OS commands, environment variables, or script invocation.
  • Security testing: Employ fuzzing or dynamic testing focused on file formats handled by the Authenticator, looking for crashes, unexpected subprocess creation, or anomalous system calls.
  • Runtime monitoring: On endpoints, monitor the Authenticator process for unexpected child processes, command-line arguments, or execution of tools that are not part of its normal operational profile.

Sources

SourceLink
github.comgithub.com/gematik/app-Authenticator/security/advisories/GHSA-mjgm-7hwc-qqcr
machinespirits.demachinespirits.de/advisory/2e655e/

Frequently asked

questions

It is indirectly remote: an attacker typically must deliver a malicious file to the victim and rely on the victim opening it locally. The attacker does not need direct network access to the Authenticator service itself, but the attack can originate remotely (for example, via email or web download).

The attacker needs the ability to supply a crafted file to the user and convince them to open it with the macOS Gematik Authenticator. No pre-existing access to the victim's system or prior authentication within the Authenticator is inherently required.

The safest pattern is to remove any reliance on shell or command-line construction from untrusted data. Replace dynamic command generation with fixed, parameterized calls to system APIs, and ensure all input from files is validated against strict, narrowly defined expectations.

Adopt secure coding guidelines that explicitly ban shell execution with untrusted input, enforce rigorous input validation on all external data (including files), and integrate security reviews and static analysis into the development lifecycle to catch OS command injection patterns early.

Find out what's already
exploitable in your codebase.