ox1111/cve-2022-32932Analyse technique et preuve de concept pour CVE-2022-32932, une vulnérabilité de double récupération (double fetch) dans le pilote du noyau ANE d'Apple menant à une écriture hors limites via la manipulation de la mémoire partagée.
CVE-2022-32932 est une autre vulnérabilité que j'ai découverte dans l'interface du noyau ANE ; il s'agit d'un problème de double récupération qui a entraîné une intéressante écriture hors limites.
H11ANEIn::patchMutableSurface() (accessible depuis H11ANEIn::ANE_ProgramSendRequest_gated) est appelée si le model.hwx possède une procédure mutable et également une section initInfo. J'ai cherché un tel modèle mais n'en ai trouvé aucun, j'ai donc fini par patcher l'un des modèles précompilés et utilisé CVE-2022-32845 pour le charger. Veuillez noter que CVE-2022-32845 n'est pas nécessaire pour atteindre le chemin de code vulnérable depuis le sandbox d'application par défaut, il suffit de compiler un mlmodel personnalisé pour obtenir les mêmes résultats. Vous pouvez trouver plus de détails sur CVE-2022-32845 dans mes diapositives de présentation.
ZinComputeProgramUpdateMutables() est une autre fonction appelée par H11ANEIn::patchMutableSurface() et le prototype de la fonction est le suivant :
ZinComputeProgramStatus __cdecl ZinComputeProgramUpdateMutables(
uint64_t procedureId,
const ZinComputeProgramInitInfo *init_info,
const ANECMutableProcedureInfo *mutable_procedure_info,
uint64_t mut_procedure_info_size,
void *MUTK_kernel_section,
uint64_t MUTK_kernel_section_size);
init_info : est la section initInfo qui contient une entrée sérialisée. Vous pouvez trouver la fonction de sérialisation serialize_initinfo_section() dans le code source de l'exploit weightBufs. mutable_procedure_info : est un tampon IOSurface partagé fourni par l'attaquant, également appelé weightsBuffer dans l'exploit weightBufs. mut_procedure_info_size : désigne la taille du tampon de surface mutable_procedure_info. MUTK_kernel_section : (ou MUTK) est un tampon de mappage d'un objet IOSurface créé par le noyau pendant la phase de chargement du programme. MUTK_kernel_section_size : est la taille de la section mutable du noyau.
La boucle 88-92 calcule le nombre d'objets MutableWeight dans l'objet mutable_procedure_info, puis calcule la taille d'allocation du tableau MutableWeight à 93. Après cela, le tableau d'objets ANECMutableWeight est alloué à 100, puis rempli avec la paire tampon/taille de poids appropriée dans la boucle 111-127 par ANECGetMutableWeight().
ANECGetMutableOperationInfo() retourne un objet opsInfo de notre mémoire partagée :
opsInfo *__fastcall ANECGetMutableOperationInfo(const ANECMutableProcedureInfo *MutableProcedureInfo, unsigned int id)
{
unsigned int weight_buffer_size; // w8
opsInfo *opInfo; // x0
weight_buffer_size = MutableProcedureInfo->header.weight_buffer_size;
if ( !weight_buffer_size )
return 0LL;
opInfo = (opsInfo *)((char *)MutableProcedureInfo + MutableProcedureInfo->wb_offsets[id]);
while ( opInfo->op_index != id )
{
if ( !--weight_buffer_size )
return 0LL;
}
return opInfo;
}
Le pseudo-code de ANECGetMutableWeight est le suivant :
void __fastcall ANECGetMutableWeight(
const ANECMutableProcedureInfo *procedure_info,
weightInfo *a2,
ANECMutableWeight *a3)
{
uint64_t wi_size; // x9
wi_size = a2->wi_size;
a3->_weightBuf = (char *)procedure_info + a2->wi_off;
a3->_weightBufSize = wi_size;
}
Le pseudo-code de ANECGetMutableWeightInfo est le suivant :
weightInfo *__fastcall ANECGetMutableWeightInfo(
const ANECMutableProcedureInfo *MutableProcedureInfo,
opsInfo *a2,
unsigned int a3)
{
if ( a2->op_count <= a3 )
return 0LL;
else
return (weightInfo *)((char *)MutableProcedureInfo + a2->op_offsets[a3]);
}
J'ai déjà décrit le format de ANECMutableProcedureInfo dans les diapositives « Attacking Apple’s Neural Engine », n'hésitez pas à les lire si vous ne l'avez pas déjà fait. La définition de la structure se trouve dans l'exploit weightBufs dans ' aneProgram.h '.
Si vous l'avez remarqué, ANECGetMutableOperationInfo()->op_count est récupéré deux fois : une fois pour calculer la taille afin d'allouer le tableau ANECMutableWeight, et une fois pour remplir ce tableau.
Comme le tampon mutable_procedure_info est une mémoire partagée, un attaquant pourrait utiliser un thread séparé pour modifier la valeur de opsInfo->op_count entre la première et la seconde utilisation, entraînant un décalage de taille qui conduira à une intéressante écriture hors limites dans une zone kalloc var, kheap defaul ou la carte du noyau.
La vulnérabilité peut être utilisée de nombreuses manières intéressantes. Par exemple, un attaquant pourrait définir total_count = 0x1000; à la ligne 93, puis augmenter opsInfo->count à une valeur plus grande, provoquant la copie de données hors limites dans ANECGetMutableWeight().
Le noyau paniquera à l'instruction ci-dessous si l'écriture hors limites a atteint une zone mémoire non mappée :
com.apple.driver.AppleH11ANEInterface:__text:FFFFFE0008913D08 EXPORT _ANECGetMutableWeight
com.apple.driver.AppleH11ANEInterface:__text:FFFFFE0008913D08 _ANECGetMutableWeight ; CODE XREF: _ZinComputeProgramUpdateMutables+270↓p
com.apple.driver.AppleH11ANEInterface:__text:FFFFFE0008913D08 LDP X8, X9, [X1,#8]
com.apple.driver.AppleH11ANEInterface:__text:FFFFFE0008913D0C ADD X8, X0, X8
com.apple.driver.AppleH11ANEInterface:__text:FFFFFE0008913D10 STP X8, X9, [X2] // <---- Kernel panic
com.apple.driver.AppleH11ANEInterface:__text:FFFFFE0008913D14 RET
Ce bogue fournit une primitive puissante en ce qu'il écrit deux valeurs 64 bits : une adresse noyau pointant vers notre tampon partagé utilisateur et une valeur 64 bits (semi-)arbitraire.
La preuve de concept est laissée en exercice pour le lecteur. Cependant, l'exploit weightBufs inclut tout ce qui est nécessaire pour atteindre le chemin de code vulnérable. Bonne chance :-).