Skip to content
NewCybercrime Report 2026 · Eight Chapters · A Post Is Not An Incident → Explore The ChaptersCybercrime Report 2026 → Explore
Security NewsNews Explainer

How macOS Unicode Path Collisions Cross Developer Tool Boundaries

macOS Unicode path collision affects Deno, go-slug, setuptools and libarchive workflows. Compare verified fixes, exposure conditions and artifact checks.

By
Brandefense Research Team
Reviewed by
Brandefense Analyst Team
Published
17 November 2026
Reading time
8 min read
Two path spellings converge on one file across four developer workflows

macOS Unicode path collision is the shared failure behind four developer-tool vulnerabilities described in CERT/CC’s vulnerability note published on November 16, 2026. Applications compare path text one way, while the underlying filesystem can resolve a different spelling to the same file. The result depends on the application and the permissions its process already holds.

This is a local or supply-chain exposure, not a macOS kernel vulnerability. A developer workstation, packaging job, archive workflow, or CI runner becomes relevant when it processes less-trusted names under a security exclusion. CERT/CC identifies Deno, libarchive, setuptools, and HashiCorp go-slug as separate cases.

How the macOS Unicode Path Collision Crosses a Security Boundary

A filename can have visually similar or equivalent Unicode spellings with different byte sequences. Case handling can produce another difference on a case-insensitive volume. CERT/CC says vulnerable tools compare those strings without matching how the filesystem resolves the final path.

Consider a tool that excludes one path from an archive, upload, or permission grant. If it tests only the path text, another spelling can pass that check. The filesystem may then treat the two names as the same object when the tool reads or writes it.

Where the path check diverges
  1. Less-trusted inputSupplies a colliding path spelling
  2. Application filterCompares the spelling with an exclusion
  3. Filesystem lookupResolves the spelling to the protected object
  4. Workflow effectReads, packs, or writes according to process rights

The diagram summarizes the class described by CERT/CC, not a single exploit that works in every product. The boundary differs in each tool. Deno checks permissions, go-slug and setuptools exclude files from packages, and libarchive controls extraction behavior.

The attacker also needs a way to place or influence the path that the affected workflow processes. A remote visitor cannot inferably overwrite arbitrary macOS files from this advisory alone. CERT/CC limits file overwrites to locations where the affected process has write permission.

Four Products, Four Different Failure Points

The same path-equivalence problem appears at different stages of a build or extraction chain. For Vulnerability Intelligence triage, the table separates what each primary source actually establishes. A fixed version for one product does not establish a fix for another.

Component and CVE Boundary described by the source Version or action verified
Deno, CVE-2026-49401 macOS deny rules for reading, writing, execution, and FFI Deno advisory: upgrade from affected 2.7.13 or earlier to 2.7.14 or later
HashiCorp go-slug, CVE-2026-14978 .terraformignore exclusion during working-directory upload IBM bulletin: go-slug 0.4.0 through 0.18.2 affected; 0.18.3 fixed
setuptools, CVE-2026-59890 MANIFEST.in exclusions when building a source distribution CERT/CC: versions before 83.0.0 affected; 83.0.0 fixed
libarchive, CVE-2026-45110 file overwrite and directory exclusion during archive handling CERT/CC: update affected software; verify a downstream vendor fix before marking resolved

Deno’s own advisory is especially precise about the exposure. It requires macOS, less-trusted code or input, and reliance on a deny rule as a security boundary. The advisory says a broad allow rule with a narrow deny carve-out could let another spelling reach the denied path.

The Deno advisory recommends explicit allowlists while upgrading. It says the fix normalizes and folds both sides of the path comparison on macOS. Teams should verify the running Deno executable and the permissions passed by the actual job, not only a dependency manifest.

For go-slug, IBM describes a working directory whose filenames and ignore patterns differ by Unicode normalization. Such a mismatch can include files meant to stay out of Terraform Cloud or Terraform Enterprise uploads. The relevant boundary is the upload preparation step, so review the resulting bundle before transmission.

setuptools has a different disclosure path. Its source-distribution builder applies MANIFEST.in exclusion directives to names found on disk. CERT/CC says an NFD filename can bypass an NFC exclusion before version 83.0.0, allowing the file into a built source distribution.

The setuptools advisory page still labels its patched-version field “None,” although CERT/CC names 83.0.0 as fixed. The project published a v83.0.0 release, but the field conflict deserves attention. Verify the installed version and inspect the built artifact rather than relying on the advisory badge alone.

CERT/CC describes libarchive as a file-overwrite and directory-exclusion bypass. Its vendor table lists libarchive’s status as unknown and contains no vendor statement. We recommend treating the fix status as deployment-specific until a maintained upstream or downstream advisory identifies a corrected build.

Where a Local Path Becomes a Supply-Chain Risk

The risk is highest where a trusted process handles names supplied by another party. Examples include an archive submitted to a build job, a third-party package built on a macOS workstation, and a repository whose contents enter an upload. Those are workflow examples, not reported incidents.

For Deno, the relevant trust boundary is code running with permissions broader than its deny exclusions suggest. For go-slug and setuptools, it is the difference between intended exclusions and the artifact actually shipped. For libarchive, it is the extraction destination and the rights of the extracting process.

That distinction changes triage. An affected version alone is not enough to infer exposure. Check whether the job ran on a relevant filesystem, whether a less-trusted actor could influence names, and whether the excluded path mattered to confidentiality or integrity.

Brandefense Blackhole counted 1,176 dark-chat posts matching “CERT” from August 19 through November 17, 2026. This is a broad CERT term count, not discussion attributed to these CVEs. It cannot establish that a path-collision attack occurred.

Teams that depend on outside packages can record this case in a Third-Party Risk Management review. The useful question is which supplier-built artifact or local build step crosses a trust boundary. A general software supply chain attack label should not replace that specific investigation.

Follow the Data Through Each Build and Extraction Step

First, inventory where these components run. Record the executable or library version, the host filesystem, the job owner, and whether file names come from a repository, dependency, archive, or user input. Include developer machines when they produce release artifacts.

Next, inspect the exact controls that the workflow expects to enforce. Deno jobs need their allow and deny flags reviewed. Terraform upload jobs need their .terraformignore rules checked against actual bundle contents. Python release jobs need MANIFEST.in rules checked against the produced source distribution.

For archive extraction, identify the calling application, its libarchive build, and the destination permissions. Compare extraction output with the intended exclusions in a controlled test using non-sensitive files. A matching version number from another package does not prove the embedded libarchive build is corrected.

Inspect outputs before publication or upload. A source distribution and a Terraform working-directory bundle should contain only the expected files. Treat any unexpected inclusion as a possible disclosure that needs a separate impact review, even if the build completed normally.

Record any unexpected modification in extraction destinations separately. Preserve the input artifact, job logs, and resulting file metadata under the organization’s response process. Do not treat a clean log as proof that the exclusion operated correctly; the mismatch can be silent.

Verify the boundary, then the fix
  • Map the workflowFind macOS builds, uploads, and extraction jobs that use the affected components.
  • Check control inputsReview deny flags, ignore rules, and exclusion patterns against the paths processed.
  • Upgrade each componentInstall Deno 2.7.14, go-slug 0.18.3, and setuptools 83.0.0 where applicable.
  • Verify libarchiveObtain the maintained application’s security notice and confirm its bundled library build.
  • Inspect outputsCompare release artifacts, upload bundles, and extraction destinations with expected contents.
  • Track exceptionsAssign an owner to workflows that cannot be updated or verified yet.

Use the patch management process to keep component-specific exceptions visible. For a broader rollout, a vulnerability management workflow can document the affected jobs and their evidence. Neither process substitutes for checking the actual build output.

What the Advisory Does and Does Not Establish

CERT/CC published VU#604762 on November 16, 2026. Its vendor table includes many organizations with unknown status. That list is coordination context, not evidence that every named project is vulnerable or that the four CVEs share one universal fix.

The same note marks Apple “Not Affected” overall while listing several product-specific entries as unknown. That is consistent with an application-level comparison problem on top of filesystem behavior. The defensive change belongs in the affected tool or its downstream package.

Some paths in the note are illustrative. A collision does not itself grant a process more filesystem rights. The application must already possess the relevant read or write permission, and the workflow must accept a name that can cross its intended exclusion.

For security teams, the practical decision is to rank workflows by trust boundary and consequence. A publishing job that could include unintended material deserves prompt artifact review. An extraction job with writable sensitive destinations deserves controlled validation before ordinary processing resumes.

Keep the source-specific limits visible in the record. Deno’s fixed version, go-slug’s fixed version, and setuptools’ fixed version come from separate primary statements. The libarchive row requires a distinct maintained-build verification before closure.

Frequently Asked Questions

Is this a macOS kernel vulnerability?

CERT/CC describes application path comparisons that differ from APFS resolution. The four CVEs concern developer tools and libraries, not a macOS kernel flaw.

Which versions should teams verify?

Deno identifies 2.7.14; IBM identifies go-slug 0.18.3; CERT/CC identifies setuptools 83.0.0. Check libarchive fixes through the maintained application or distributor.

Can a remote visitor overwrite arbitrary files?

CERT/CC describes local and supply-chain conditions. A workflow must process a colliding name, and writes remain limited to the affected process’s permissions.

What evidence should a build team keep?

Keep component versions, host filesystem details, exclusion rules, build or extraction logs, and a reviewed list of files in resulting artifacts.

Sources

  1. CERT/CC: VU#604762 Unicode Normalization Collision on macOS
  2. Deno: Permission Bypass Advisory
  3. IBM: go-slug Security Bulletin
  4. setuptools: MANIFEST.in Advisory
  5. setuptools: v83.0.0 Release
Share this articleLinkedInXEmail
Brandefense logo

Stay Ahead of Digital Threats.

Take control of your digital security with an exclusive demo of our AI-driven threat intelligence platform.

Open The Full Demo Form →