
La mia segnalazione più recente all'Apple Security Bounty. Corretta in iOS 27.2
/usr/lib/libarchive.2.dylib (così come distribuito in iOS 27.0 / 24A437) scrive due byte oltre un'allocazione heap di 1024 byte durante l'analisi di un'immagine ISO 9660 contenente una tabella di nomi Joliet.
In build_pathname_utf16be(), le scritture del separatore di percorso non sono delimitate:
if (build_pathname_utf16be(p, max, len, file->parent) != 0)
return (-1);
p[*len] = 0;
p[*len + 1] = '/';
*len += 2;
Quando il pathname padre è di 1024 byte, *len == 1024 e la funzione scrive p[1024] e p[1025] oltre malloc(1024). Il controllo di lunghezza che restituisce "Pathname is too long" viene eseguito dopo queste scritture.
I due byte scritti sono 0x00 0x2f. Nel PoC standalone allegato, essi corrompono un oggetto puntatore/lunghezza adiacente e producono una scrittura arbitraria confermata dal Target Flag, esecuzione reindirizzata e controllo dei registri. Separatamente, lo stesso file appositamente costruito raggiunge ArchiveService di iOS tramite Files e causa un crash riproducibile di autenticazione PAC nel percorso di pulizia ISO 9660 di libarchive.
Il lettore ISO 9660 Joliet ricostruisce i percorsi delle directory in modo ricorsivo in build_pathname_utf16be(). Dopo aver elaborato una directory padre, aggiunge un separatore di percorso UTF-16BE tramite due scritture:
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;
Queste scritture vengono eseguite senza prima verificare che rimangano almeno due byte nel buffer di destinazione. Se il pathname padre ricostruito è lungo esattamente 1024 byte, *len è uguale alla dimensione dell'allocazione quando le scritture vengono eseguite. La funzione scrive quindi 0x00 all'offset 1024 e / all'offset 1025, al di fuori dell'allocazione utf16be_path di 1024 byte.
La validazione della lunghezza del pathname che restituisce "Pathname is too long" avviene solo dopo queste scritture. Di conseguenza, la funzione segnala l'errore dopo che la scrittura fuori dai limiti ha già modificato la memoria heap adiacente.
Il progetto Xcode allegato chiama l'API pubblica di libarchive:
archive_read_open_memory → archive_read_next_header
Utilizza un'immagine ISO 9660/Joliet appositamente costruita e modella il proprio heap in modo che la sovrascrittura di due byte interessi un oggetto puntatore/lunghezza adiacente. Un singolo avvio dimostra:
_COMM_PAGE_ASB_TARGET_VALUE viene scritto in _COMM_PAGE_ASB_TARGET_ADDRESS e in un indirizzo mappato separatamente, con la scrittura mappata verificata tramite rilettura._COMM_PAGE_ASB_TARGET_ADDRESS e chiamato._COMM_PAGE_ASB_TARGET_VALUE è presente in x0 nel target di esecuzione reindirizzata.Il PoC è un'applicazione in sandbox avviata normalmente su un dispositivo fisico. I valori del Target Flag vengono letti a runtime e non sono hardcoded.
PoC/, usando lo schema poc. Il prodotto è libarchive2.app, bundle identifier eliya.m.asb.xcrun devicectl device process launch --console --terminate-existing eliya.m.asb
poc.iso incluso all'avvio senza ulteriore interazione dell'utente.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
Ho trasferito lo stesso input appositamente costruito su un iPhone17,1 con iOS 27.0 (24A437) e su un iPhone14,5 con iOS 26.7 (23H24). Dopo aver ricevuto il file, ho toccato il file una volta in Files. Questo ha richiamato il percorso di gestione/estrazione degli archivi.
Files ha passato l'input a:
/System/Library/PrivateFrameworks/DesktopServicesPriv.framework/XPCServices/ArchiveService.xpc/ArchiveService
Risultato di raggiungibilità di un file controllato dall'attaccante con un solo tocco dell'utente :)
Il file fornito si chiama target.zip, ma il suo contenuto è un'immagine ISO 9660. ArchiveService ha selezionato il lettore ISO 9660 in base al contenuto del file. La sua catena di directory appositamente costruita produce un percorso padre di 1024 byte, causando le scritture fuori dai limiti.
Il crash si verifica durante la fase di pulizia immediatamente dopo la liberazione di iso9660->utf16be_path e prima della liberazione di 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
Lo stato dei registri catturato è coerente con il qword sovrascritto che si trova 1024 byte dopo l'allocazione del percorso da 1024 byte:
x0 = 0x1030ec5c0
x8 = 0x1030ec9c0 x8 - x0 = 1024
[x8] = 0x0aa00000002f00 low 16 bits = 0x2f00
x9 = [x8 + 8] = 7
I 16 bit bassi 0x2f00 corrispondono ai due byte scritti dagli store vulnerabili. Il successivo fallimento di autdb in mfm_free è coerente con l'autenticazione di un campo dell'allocatore corrotto contenente un puntatore.
Eliya M.