Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
CVE-2026-43805 — Analisi patch-diff con Ghidra della race condition in IOKit IODMACommand in macOS Tahoe 26.6, con un PoC non distruttivo in user-space che riproduce la finestra di stato obsoleto. | Kitploit
Strumenti/GitHubGitHub/whysocscs/cve-2026-43805
Analisi delle VulnerabilitàReverse EngineeringAnalisi di BinariPaper e Ricerca
GitHubwhysocscs/cve-2026-43805

CVE-2026-43805

Analisi patch-diff con Ghidra della race condition in IOKit IODMACommand in macOS Tahoe 26.6, con un PoC non distruttivo in user-space che riproduce la finestra di stato obsoleto.

Vedi Repository
1 mese faNon ancora revisionato

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Nessun dato di popolarità ancora.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi

Analisi di CVE-2026-43805

Analisi della race condition in IOKit IODMACommand e PoC

Riepilogo

CVE-2026-43805 è una vulnerabilità di Race Condition che si verifica in Apple IOKit.

L'avviso ufficiale Apple spiega che un'app può causare un arresto imprevisto del sistema o scrivere nella memoria del kernel. La versione corretta è macOS Tahoe 26.6, il CVSS è 9.8, il CWE è 362.

CategoriaContenuto
CVECVE-2026-43805
ComponenteIOKit
Versione vulnerabilemacOS Tahoe 26.5
Versione con patchmacOS Tahoe 26.6
Tipo di vulnerabilitàRace Condition
ImpattoUnexpected system termination or kernel memory write

Anticipando il risultato dell'analisi, il lock mancante in IODMACommand::PerformOperation_Impl è stato aggiunto nella versione corretta.

PrepareForDMA_Impl e CompleteDMA_Impl utilizzavano già lo stesso lock in precedenza, mentre solo PerformOperation_Impl non utilizzava il lock nella sezione in cui verifica e utilizza lo stato condiviso. In Tahoe 26.6 questa sezione è stata protetta con il lock e, dopo aver acquisito il lock, lo stato viene verificato nuovamente.

Acquisizione del target di analisi

Inizialmente ho confrontato i Kernel Collection di Sequoia 15.7.7 e 15.7.8, ma alcune parti dell'implementazione core di IOKit non sono incluse in singoli KEXT bensì nel corpo del kernel XNU. Inoltre, in un'analisi pubblica viene menzionata una modifica a IODMACommand tra Tahoe 26.5 e 26.6, quindi ho scelto il Tahoe KDK come target finale dell'analisi.

Ho acquisito i due KDK seguenti utilizzando ipsw.

VersioneBuildkernel SHA-256
Tahoe 26.525F71f4dcaa7e59ae59f3d945c2332862772596b71e9823cc202983ba4f9d897b5bec
Tahoe 26.625G70754db65cb15599183ccebfaa2e4909f673de5d7da42ba4293256cb1184587efd

Ho estratto KernelDebugKit.pkg dal DMG scaricato e ho ottenuto kernel e kernel.development dal Payload interno. Entrambi i file sono Mach-O x86_64, quindi è stato possibile confrontarli direttamente in Ghidra.

Patch Diff

Ho caricato i kernel di 26.5 e 26.6 in Ghidra, avviato l'analisi automatica e poi abbinato le stesse funzioni tramite Version Tracking.

Le funzioni confermate in definitiva sono le 3 seguenti.

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

Confrontando prima PerformOperation_Impl, nella versione vulnerabile viene verificato lo stato condiviso e poi vengono eseguite le operazioni relative alla memoria, ma non c'è un lock che protegga tale sezione.

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

Nella versione patchata, l'acquisizione e il rilascio del lock sono stati aggiunti come segue.

IOLockLock(lock);

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

IOLockUnlock(lock);

Anche nel disassemblaggio reale di 26.6 è stato confermato il flusso in cui, dopo la chiamata a _lck_mtx_lock, viene verificato lo stato di this + 0x68 e, nel percorso di completamento dell'operazione, viene chiamato _lck_mtx_unlock.

Successivamente sono stati esaminati anche PrepareForDMA_Impl e CompleteDMA_Impl. Entrambe le funzioni, sia in 26.5 che in 26.6, utilizzavano il lock dello stesso oggetto.

FunzioneTahoe 26.5Tahoe 26.6
PrepareForDMA_ImplUsa il lockUsa il lock
PerformOperation_ImplLock mancanteLock aggiunto e ricontrollo dello stato
CompleteDMA_ImplUsa il lockUsa il lock

Perché è una Race Condition?

Ciò che conta in una Race Condition è che più thread possano accedere contemporaneamente allo stesso stato e alla stessa memoria.

Nella versione vulnerabile è possibile un flusso approssimativamente come il seguente.

  1. Il Thread A verifica in PerformOperation_Impl se il DMA è attivo.
  2. Il Thread B acquisisce il lock in CompleteDMA_Impl e modifica lo stato del DMA o libera la memoria.
  3. Il Thread A, avendo già verificato lo stato, continua l'operazione basandosi sullo stato precedente.
  4. Al momento dell'uso effettivo, la memoria è invalidata e viene utilizzato uno stato obsoleto.

In altre parole, tra il controllo dello stato in PerformOperation_Impl e l'uso effettivo, CompleteDMA_Impl può inserirsi.

Dopo la patch, anche PerformOperation_Impl utilizza lo stesso lock di PrepareForDMA_Impl e CompleteDMA_Impl. Inoltre, dopo aver acquisito il lock, ricontrolla lo stato di this + 0x68. In questo modo, dal controllo dello stato fino all'uso della memoria, gli altri thread non possono modificare lo stesso stato.

Questo aspetto è coerente con l'improved state handling menzionato nell'avviso di Apple.

PoC

Invece di un exploit che corrompe realmente la memoria del kernel, è stata riprodotta nello spazio utente la race condition identificata durante l'analisi.

Nel PoC, il Thread A svolge il ruolo di PerformOperation_Impl e il Thread B quello di CompleteDMA_Impl. Utilizzando std::promise e std::future, è stato allineato l'ordine di esecuzione in modo che il Thread B invalidi la memoria subito dopo che il Thread A ha verificato lo stato.

La build e l'esecuzione si effettuano come segue.

make -C poc
./poc/race_model

Il risultato dell'esecuzione è il seguente.

[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, dopo che il Thread A ha verificato lo stato attivo, il Thread B può invalidare la memoria. Quindi active_at_check=true, ma al momento dell'uso effettivo si ha memory_valid_at_use=false, e si riproduce la situazione in cui viene utilizzato uno stato obsoleto.

In after, i due thread utilizzano lo stesso mutex. Poiché il Thread B non può modificare lo stato mentre il Thread A verifica lo stato e utilizza la memoria, viene stampato ACCESS PROTECTED.

Di conseguenza, si è confermato che se non c'è sincronizzazione tra la verifica e l'utilizzo dello stato condiviso può verificarsi una Race Condition, e che proteggere tale sezione con lo stesso lock può prevenirlo.

Il codice PoC si trova in poc/race_model.cpp.

Limiti

Non è un exploit che, chiamando effettivamente IODMACommand, provoca un kernel crash o una kernel memory write, ma è un PoC che confronta la versione in cui, a causa dell'assenza di lock in quella sezione, è stata aggiunta una ricontrollo dello stato su lock/unlock con quella in cui non lo è.

Materiali di riferimento

  • Apple - Informazioni sul contenuto di sicurezza di macOS Tahoe 26.6
  • CVE-2026-43805 - Vulnerability-Lookup
  • 상세 분석 글
Scarica lo strumento