
Ma soumission la plus récente au programme Apple Security Bounty. Corrigé dans iOS 27.2
/usr/lib/libarchive.2.dylib (tel que livré dans iOS 27.0 / 24A437) écrit deux octets au-delà d'une allocation de tas de 1024 octets lors de l'analyse d'une image ISO 9660 contenant une table de noms Joliet.
Dans build_pathname_utf16be(), les écritures du séparateur de chemin ne sont pas bornées :
if (build_pathname_utf16be(p, max, len, file->parent) != 0)
return (-1);
p[*len] = 0;
p[*len + 1] = '/';
*len += 2;
Lorsque le chemin d'accès parent fait 1024 octets, *len == 1024 et la fonction écrit p[1024] et p[1025] au-delà de malloc(1024). La vérification de longueur qui renvoie "Pathname is too long" s'exécute après ces écritures.
Les deux octets écrits sont 0x00 0x2f. Dans le PoC autonome joint, ils corrompent un objet pointeur/longueur adjacent et produisent une écriture arbitraire confirmée par le Target Flag, une exécution redirigée et un contrôle des registres. Séparément, le même fichier forgé atteint ArchiveService d'iOS via Files et provoque un crash reproductible d'authentification PAC dans le chemin de nettoyage ISO 9660 de libarchive.
Le lecteur ISO 9660 Joliet reconstruit les chemins de répertoires de manière récursive dans build_pathname_utf16be(). Après le traitement d'un répertoire parent, il ajoute un séparateur de chemin UTF-16BE à l'aide de deux écritures :
if (build_pathname_utf16be(p, max, len, file->parent) != 0)
return (-1);
p[*len] = 0; /* no check that *len + 2 <= max */
p[*len + 1] = '/';
*len += 2;
Ces écritures sont effectuées sans vérifier au préalable qu'il reste au moins deux octets dans le tampon de destination. Si le chemin parent reconstruit mesure exactement 1024 octets, *len est égal à la taille de l'allocation au moment de l'exécution des écritures. La fonction écrit alors 0x00 à l'offset 1024 et / à l'offset 1025, en dehors de l'allocation utf16be_path de 1024 octets.
La validation de la longueur du chemin qui renvoie « Pathname is too long » n'intervient qu'après ces écritures. Par conséquent, la fonction signale l'erreur après que l'écriture hors limites a déjà modifié la mémoire du tas adjacente.
Le projet Xcode joint appelle l'API publique de libarchive :
archive_read_open_memory → archive_read_next_header
Il utilise une image ISO 9660/Joliet conçue et façonne son propre tas de sorte que l'écrasement de deux octets affecte un objet pointeur/longueur adjacent. Un seul lancement démontre :
_COMM_PAGE_ASB_TARGET_VALUE est écrit dans _COMM_PAGE_ASB_TARGET_ADDRESS et dans une adresse mappée séparément, l'écriture mappée étant vérifiée par relecture._COMM_PAGE_ASB_TARGET_ADDRESS et appelé._COMM_PAGE_ASB_TARGET_VALUE complet sur 64 bits est présent dans x0 au niveau de la cible d'exécution redirigée.Le PoC est une application lancée normalement, en sandbox, sur un appareil physique. Les valeurs du Target Flag sont lues à l'exécution et ne sont pas codées en dur.
PoC/, en utilisant le schéma poc. Le produit est libarchive2.app, identifiant de bundle eliya.m.asb.xcrun devicectl device process launch --console --terminate-existing eliya.m.asb
poc.iso intégré au lancement, sans interaction supplémentaire de l'utilisateur.libarchive2 PoC: document poc.iso
commpage TARGET_VALUE=0x08acf5210b466b05 TARGET_ADDRESS=0xc7df4e66456a598b
write *(0x00000001001f0010) = 0x08acf5210b466b05 verified by readback
write *(0xc7df4e66456a598b) = 0x08acf5210b466b05 far=0xc7df4e66456a598b x6=0x08acf5210b466b05
result: success
J'ai transféré la même entrée forgée vers un iPhone17,1 exécutant iOS 27.0 (24A437) et un iPhone14,5 sous iOS 26.7 (23H24). Une fois le fichier reçu, j'ai appuyé une fois sur le fichier dans Files. Cela a invoqué le chemin de traitement/extraction des archives.
Files a transmis l'entrée à :
/System/Library/PrivateFrameworks/DesktopServicesPriv.framework/XPCServices/ArchiveService.xpc/ArchiveService
Résultat d'accessibilité d'un fichier contrôlé par l'attaquant avec un seul appui de l'utilisateur :)
Le fichier fourni est nommé target.zip, mais son contenu est une image ISO 9660. ArchiveService a sélectionné le lecteur ISO 9660 en fonction du contenu du fichier. Sa chaîne de répertoires conçue produit un chemin parent de 1024 octets, déclenchant les écritures hors limites.
Le plantage se produit lors du nettoyage, immédiatement après la libération de iso9660->utf16be_path et avant la libération de iso9660->utf16be_previous_path :
ldr x8, [sp, #0x10] ; iso9660
ldr x0, [x8, #0x1f0] ; iso9660->utf16be_path
bl free ; return address corresponds to cleanup + 208
ldr x8, [sp, #0x10]
ldr x0, [x8, #0x200] ; iso9660->utf16be_previous_path
bl free
L'état des registres capturé est cohérent avec le fait que le qword écrasé se trouve 1024 octets après l'allocation de chemin de 1024 octets :
x0 = 0x1030ec5c0
x8 = 0x1030ec9c0 x8 - x0 = 1024
[x8] = 0x0aa00000002f00 low 16 bits = 0x2f00
x9 = [x8 + 8] = 7
Les 16 bits de poids faible 0x2f00 correspondent aux deux octets écrits par les stores vulnérables. L'échec ultérieur de autdb dans mfm_free est cohérent avec l'authentification d'un champ d'allocateur corrompu contenant un pointeur.
Eliya M.