Cybersecurity researchers have discovered several vulnerabilities in macOS tools that allow attackers to bypass file access restrictions by manipulating the way filenames are written. Under certain conditions, these flaws could lead to system files being overwritten, sensitive information being exposed, or even malicious code execution.
Specialists at the CERT Coordination Center (CERT/CC) at Carnegie Mellon University reported inconsistencies in how Apple’s Apple File System (APFS) and third-party applications handle filenames. The issue is related to Unicode, which allows certain characters to be represented in multiple ways. For example, an application may treat the filenames paßwd and passwd as different, while APFS may consider them identical under certain configurations.
Attackers can exploit this behavior to bypass security checks and overwrite files that an application would normally restrict access to. To do so, they only need to manipulate a filename inside an archive or another data set processed by a vulnerable tool. If the process has the necessary write permissions, the system may silently overwrite a protected file.
For example, an attacker could include a specially crafted filename in an archive. When a vulnerable application extracts that archive on macOS, it may mistakenly overwrite /etc/passwd, an important system file in Unix-like operating systems.
The issue is not limited to a single application. Researchers found that improper Unicode handling can affect dozens of libraries, archiving tools, software build systems, and runtime environments. Such vulnerabilities pose particular risks to developers because they can affect automated CI/CD processes and software supply chains.
One of the affected components is Libarchive, a library used for working with archives. The CVE-2026-45110 vulnerability allows attackers to bypass file overwrite protections and excluded directory checks. This could result in data corruption, configuration changes, or arbitrary code execution if the affected process has sufficient permissions.
CERT/CC also disclosed several related vulnerabilities:
CVE-2026-14978 (HashiCorp go-slug). Allows attackers to bypass
.terraformignorerules, potentially causing sensitive files to be unintentionally included in packages that Terraform uploads to servers.
CVE-2026-49401 (Deno). Allows attackers to bypass file access and program execution restrictions by using alternative Unicode representations of file paths.
CVE-2026-59890 (Python setuptools). Makes it possible to bypass file exclusion rules and include private data in software packages distributed by developers to other users.
CERT/CC also assigned the identifier VU#604762.8 to track this broader class of vulnerabilities. Some developers have already released fixes. For example, the issue in Python setuptools was resolved in version 83.0.0. However, at the time CERT/CC published its advisory, a fix for Libarchive was still pending.
CERT/CC emphasizes that these vulnerabilities can affect not only archiving tools but also backup software, digital forensics tools, and automated software build systems. If a tool incorrectly compares filenames, an attacker may bypass restrictions on file processing, steal private data, or compromise software packages.
Importantly, Apple is listed in the CERT/CC advisory as a vendor that is not directly affected by these vulnerabilities. The issue primarily affects third-party tools that fail to properly account for how the APFS file system handles filenames.
Researchers recommend updating potentially vulnerable software to the latest available versions. Developers are also advised to review their file path handling mechanisms to ensure that security checks account for Unicode normalization and match the behavior of the underlying file system, rather than relying solely on byte-by-byte filename comparisons.
The issue was reported by cybersecurity researcher Tomas Illuminati, who submitted his findings to CERT/CC. The discovery demonstrates that even a seemingly minor difference in how a filename is written can create serious security risks for applications handling sensitive information.