
Análise de patch-diff com Ghidra da condição de corrida no IOKit IODMACommand no macOS Tahoe 26.6, com um PoC em espaço de usuário não destrutivo que reproduz a janela de estado obsoleto.
Análise e PoC da Race Condition em
IODMACommanddo IOKit
CVE-2026-43805 é uma vulnerabilidade de condição de corrida (Race Condition) no Apple IOKit.
O comunicado oficial da Apple descreve que um app pode causar um encerramento inesperado do sistema ou escrever na memória do kernel. A versão corrigida é o macOS Tahoe 26.6, o CVSS é 9.8 e o CWE é 362.
| Classificação | Conteúdo |
|---|---|
| CVE | CVE-2026-43805 |
| Componente | IOKit |
| Versão vulnerável | macOS Tahoe 26.5 |
| Versão corrigida | macOS Tahoe 26.6 |
| Tipo de vulnerabilidade | Condição de corrida (Race Condition) |
| Impacto | Encerramento inesperado do sistema ou gravação na memória do kernel |
Antecipando o resultado da análise, o lock que faltava em IODMACommand::PerformOperation_Impl foi adicionado na versão corrigida.
PrepareForDMA_Impl e CompleteDMA_Impl já utilizavam o mesmo lock anteriormente, mas apenas PerformOperation_Impl não utilizava o lock no trecho em que verifica e utiliza o estado compartilhado. No Tahoe 26.6, esse trecho passou a ser protegido por lock e, após adquirir o lock, o estado também é verificado novamente.
Inicialmente comparei as Kernel Collections do Sequoia 15.7.7 e 15.7.8, mas parte da implementação central do IOKit está incluída no próprio kernel do XNU, e não em KEXTs individuais. Além disso, como análises públicas mencionam mudanças em IODMACommand entre o Tahoe 26.5 e o 26.6, defini o Tahoe KDK como alvo final da análise.
Obtive os dois KDKs abaixo utilizando o ipsw.
| Versão | Build | kernel SHA-256 |
|---|---|---|
| Tahoe 26.5 | 25F71 | f4dcaa7e59ae59f3d945c2332862772596b71e9823cc202983ba4f9d897b5bec |
| Tahoe 26.6 | 25G70 | 754db65cb15599183ccebfaa2e4909f673de5d7da42ba4293256cb1184587efd |
Extraí o KernelDebugKit.pkg do DMG baixado e obtive o kernel e o kernel.development a partir do Payload interno. Ambos os arquivos são Mach-O x86_64, então pude compará-los diretamente no Ghidra.
Carreguei os kernel do 26.5 e do 26.6 no Ghidra, executei a análise automática em cada um e, em seguida, fiz o matching das mesmas funções com o Version Tracking.
As funções finalmente confirmadas aqui são as 3 abaixo.
IODMACommand::PrepareForDMA_ImplIODMACommand::PerformOperation_ImplIODMACommand::CompleteDMA_ImplComparando primeiro o PerformOperation_Impl, a versão vulnerável verifica o estado compartilhado e depois executa as operações relacionadas à memória, mas não há lock protegendo esse trecho.
if (*(int *)(this + 0x68) == 0) {
result = 0xe00002d8;
} else {
// 메모리 관련 작업 수행
}
Na versão corrigida, a aquisição e liberação do bloqueio foram adicionadas conforme mostrado abaixo.
IOLockLock(lock);
if (*(int *)(this + 0x68) == 0) {
result = 0xe00002d8;
} else {
// 기존 메모리 관련 작업 수행
}
IOLockUnlock(lock);
No disassembly real de 26.6, também foi confirmado o fluxo em que, após a chamada a _lck_mtx_lock, o estado de this + 0x68 é verificado e, no caminho de conclusão da tarefa, _lck_mtx_unlock é chamado.
Em seguida, PrepareForDMA_Impl e CompleteDMA_Impl também foram verificados. Ambas as funções usavam o lock do mesmo objeto tanto em 26.5 quanto em 26.6.
| Função | Tahoe 26.5 | Tahoe 26.6 |
|---|---|---|
PrepareForDMA_Impl | usa lock | usa lock |
PerformOperation_Impl | lock ausente | lock adicionado e revalidação de estado |
CompleteDMA_Impl | usa lock | usa lock |
O que importa em uma Race Condition é que várias threads podem acessar o mesmo estado e a mesma memória simultaneamente.
Na versão vulnerável, um fluxo aproximadamente como o abaixo é possível.
PerformOperation_Impl se o DMA está ativo.CompleteDMA_Impl e altera o estado do DMA ou libera a memória.Ou seja, entre a verificação de estado em PerformOperation_Impl e o uso efetivo, CompleteDMA_Impl pode se interpor.
Após o patch, PerformOperation_Impl também usa o mesmo lock que PrepareForDMA_Impl e CompleteDMA_Impl. E, após adquirir o lock, verifica novamente o estado de this + 0x68. Assim, da verificação de estado até o uso da memória, outras threads não conseguem alterar o mesmo estado.
Essa parte também coincide com o improved state handling mencionado no aviso da Apple.
Em vez de um exploit que corrompe memória do kernel de fato, a condição de corrida identificada na análise foi reproduzida em espaço de usuário.
No PoC, a Thread A faz o papel de PerformOperation_Impl e a Thread B o de CompleteDMA_Impl. Usando std::promise e std::future, a ordem de execução foi ajustada para que, logo após a Thread A verificar o estado, a Thread B invalide a memória.
A compilação e a execução podem ser feitas como abaixo.
make -C poc
./poc/race_model
O resultado da execução é o seguinte.
[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
Em before, o Thread A pode verificar o estado ativo e, em seguida, o Thread B pode invalidar a memória. Assim, active_at_check=true, mas no momento do uso real torna-se memory_valid_at_use=false, reproduzindo-se a situação em que um estado obsoleto é utilizado.
Em after, as duas threads usam o mesmo mutex. Como o Thread B não pode alterar o estado enquanto o Thread A verifica o estado e usa a memória, ACCESS PROTECTED é impresso.
Como resultado, confirmou-se que uma Race Condition pode ocorrer se não houver sincronização entre a verificação e o uso do estado compartilhado, e que isso pode ser evitado protegendo esse trecho com o mesmo lock.
O código PoC está em poc/race_model.cpp.
Não é um exploit que chama de fato o IODMACommand e chega a causar kernel crash ou kernel memory write; é um PoC que compara a versão com a verificação de estado para lock/unlock adicionada, por não haver lock nesse trecho, com a versão sem essa verificação.