Skip to content
KitploitKITPLOIT
ToolsExploitsBlog
Log in
Submit
ToolsExploitsBlog
Submit

Hacking, PenTest, and Cybersecurity Tools for Your Security Arsenal!

Kitploit is a directory of hacking, cybersecurity, and pentesting tools. Discover the latest project updates to find vulnerabilities, analyze systems, automate testing, and strengthen your security.

FeedsContactPrivacy© 2026 Kitploit

Tool Directory

Categories

View all categories
Loading categories
CVE-2026-43805 — Ghidra patch-diff analysis of the IOKit IODMACommand race condition in macOS Tahoe 26.6, with a non-destructive user-space PoC reproducing the stale-state window. | Kitploit
Tools/GitHubGitHub/whysocscs/cve-2026-43805
Vulnerability AnalysisReverse EngineeringBinary AnalysisPapers & Research
GitHubwhysocscs/cve-2026-43805

CVE-2026-43805

Ghidra patch-diff analysis of the IOKit IODMACommand race condition in macOS Tahoe 26.6, with a non-destructive user-space PoC reproducing the stale-state window.

View Repository
1 month agoNot yet reviewed
Share

CVE-2026-43805 Analysis

IOKit IODMACommand Race Condition Analysis and PoC

Summary

CVE-2026-43805는 Apple IOKit에서 발생하는 Race Condition 취약점이다.

Apple's official advisory states that an app may be able to cause an unexpected system termination or write to kernel memory. The patched version is macOS Tahoe 26.6, the CVSS is 9.8, and the CWE is 362.

구분내용
CVECVE-2026-43805
ComponentIOKit
취약 버전macOS Tahoe 26.5
패치 버전macOS Tahoe 26.6
취약점 종류Race Condition
영향Unexpected system termination or kernel memory write

To state the analysis result first, the lock that was missing in IODMACommand::PerformOperation_Impl was added in the patched version.

PrepareForDMA_Impl and CompleteDMA_Impl had already been using the same lock, but only PerformOperation_Impl was not using a lock in the section where it checks and uses shared state. In Tahoe 26.6, this section was changed to be protected by a lock and to re-check the state after acquiring the lock.

Obtaining the Analysis Target

Initially, I compared the Kernel Collections of Sequoia 15.7.7 and 15.7.8, but some of the core IOKit implementations are included not in individual KEXTs but in the XNU kernel itself. Also, since a published analysis mentioned changes to IODMACommand between Tahoe 26.5 and 26.6, I set the Tahoe KDK as the final analysis target.

I obtained the following two KDKs using ipsw.

VersionBuildkernel SHA-256
Tahoe 26.525F71f4dcaa7e59ae59f3d945c2332862772596b71e9823cc202983ba4f9d897b5bec
Tahoe 26.625G70754db65cb15599183ccebfaa2e4909f673de5d7da42ba4293256cb1184587efd

I extracted KernelDebugKit.pkg from the downloaded DMG, and obtained kernel and kernel.development from the internal Payload. Both files are x86_64 Mach-O, so they could be compared directly in Ghidra.

Patch Diff

I loaded the kernel of 26.5 and 26.6 into Ghidra respectively, ran automatic analysis, and then matched the same functions using Version Tracking.

The functions finally confirmed here are the following three.

  • IODMACommand::PrepareForDMA_Impl
  • IODMACommand::PerformOperation_Impl
  • IODMACommand::CompleteDMA_Impl

First, comparing PerformOperation_Impl, the vulnerable version checks the shared state and then performs memory-related operations, but there is no lock protecting that section.

if (*(int *)(this + 0x68) == 0) {
    result = 0xe00002d8;
} else {
    // 메모리 관련 작업 수행
}

In the patched version, lock acquisition and release were added as follows.

IOLockLock(lock);

if (*(int *)(this + 0x68) == 0) {
    result = 0xe00002d8;
} else {
    // 기존 메모리 관련 작업 수행
}

IOLockUnlock(lock);

In the actual 26.6 disassembly as well, we confirmed the flow that checks the state of this + 0x68 after the _lck_mtx_lock call, and calls _lck_mtx_unlock on the path where the work finishes.

Next, we also examined PrepareForDMA_Impl and CompleteDMA_Impl. Both functions were using the lock of the same object in both 26.5 and 26.6.

FunctionTahoe 26.5Tahoe 26.6
PrepareForDMA_ImplUses lockUses lock
PerformOperation_ImplLock missingLock added and state re-checked
CompleteDMA_ImplUses lockUses lock

Why Is It a Race Condition?

What matters in a race condition is that multiple threads can access the same state and memory simultaneously.

In the vulnerable version, roughly the following flow is possible.

  1. Thread A checks in PerformOperation_Impl whether DMA is active.
  2. Thread B acquires the lock in CompleteDMA_Impl and changes the DMA state or cleans up memory.
  3. Because Thread A has already checked the state, it continues working based on the previous state.
  4. At the actual point of use, the memory has been invalidated, so a stale state is used.

In other words, CompleteDMA_Impl can interleave between the state check in PerformOperation_Impl and the actual use.

After the patch, PerformOperation_Impl also uses the same lock as PrepareForDMA_Impl and CompleteDMA_Impl. And after acquiring the lock, it re-checks the state of this + 0x68. This prevents other threads from changing the same state from the state check through to the memory use.

This part also matches the improved state handling mentioned in Apple's advisory.

PoC

Instead of an exploit that actually corrupts kernel memory, we reproduced the race condition identified in the analysis in user space.

In the PoC, Thread A plays the role of PerformOperation_Impl and Thread B plays the role of CompleteDMA_Impl. Using std::promise and std::future, we aligned the execution order so that Thread B invalidates the memory immediately after Thread A checks the state.

You can build and run it as follows.

make -C poc
./poc/race_model

The execution result is as follows.

[before] active_at_check=true memory_valid_at_use=false -> STALE STATE OBSERVED
[after ] active_at_check=true memory_valid_at_use=true -> ACCESS PROTECTED

In before, after Thread A checks the active state, Thread B can invalidate the memory. So active_at_check=true, but at the actual point of use memory_valid_at_use=false, and the situation of using stale state is reproduced.

In after, the two threads use the same mutex. Because Thread B cannot change the state while Thread A checks the state and uses the memory, ACCESS PROTECTED is printed.

As a result, it was confirmed that a Race Condition can occur if there is no synchronization between the check and use of shared state, and that protecting that section with the same lock can prevent it.

The PoC code is in poc/race_model.cpp.

Limitations

This is not an exploit that actually calls IODMACommand to cause a kernel crash or kernel memory write; it is a PoC that compares a version with an added state re-check for lock/unlock, due to the absence of a lock in that section, against a version without it.

References

  • Apple - About the security content of macOS Tahoe 26.6
  • CVE-2026-43805 - Vulnerability-Lookup
  • 상세 분석 글
Download Tool

Most Popular

View all →

Discover the most used tools by our community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 The ultimate OSINT toolkit: investigation graph, confidence scoring, alias families, map, timeline and reports. 49 modules, 400+ sites, no API keys required.

    806
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    GhostLock One-Tap Execution App (CVE-2026-43499)

    523
  • 3

    ARTEX

    baarai/artex

    LLM multi-agent autonomous penetration testing platform with planner/worker agents, asset and exploration graphs, MITM traffic recording, and vulnerability retesting.

    441
  • 4

    redforge

    cybersecurity91/redforge

    Browser-side red team toolkit with 102 offline tools for recon, payload generation, credential attacks, crypto, encoding and engagement reporting.

    346
  • 5

    looking-glass

    anonghosty/looking-glass

    CSIRT platform that ingests Shadowserver reports into MongoDB and replays them as interactive maps, analysis, findings, advisories and executive dashboards.

    270
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    The system of action for AI-native cybersecurity—where intent becomes governed execution, evidence becomes operational memory, and every operation improves the next.

    264

Explore all tools

Browse our collection of tools

View all tools →