
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.
Scopri gli strumenti più utilizzati dalla nostra community.
Nessun dato di popolarità ancora.
Analisi della race condition in IOKit
IODMACommande PoC
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.
| Categoria | Contenuto |
|---|---|
| CVE | CVE-2026-43805 |
| Componente | IOKit |
| Versione vulnerabile | macOS Tahoe 26.5 |
| Versione con patch | macOS Tahoe 26.6 |
| Tipo di vulnerabilità | Race Condition |
| Impatto | Unexpected 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.
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.
| Versione | Build | kernel SHA-256 |
|---|---|---|
| Tahoe 26.5 | 25F71 | f4dcaa7e59ae59f3d945c2332862772596b71e9823cc202983ba4f9d897b5bec |
| Tahoe 26.6 | 25G70 | 754db65cb15599183ccebfaa2e4909f673de5d7da42ba4293256cb1184587efd |
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.
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_ImplIODMACommand::PerformOperation_ImplIODMACommand::CompleteDMA_ImplConfrontando 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.
| Funzione | Tahoe 26.5 | Tahoe 26.6 |
|---|---|---|
PrepareForDMA_Impl | Usa il lock | Usa il lock |
PerformOperation_Impl | Lock mancante | Lock aggiunto e ricontrollo dello stato |
CompleteDMA_Impl | Usa il lock | Usa il lock |
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.
PerformOperation_Impl se il DMA è attivo.CompleteDMA_Impl e modifica lo stato del DMA o libera la memoria.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.
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.
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 è.