From 6406ff6a42877cb723757eeb4c3e661b0115206b Mon Sep 17 00:00:00 2001 From: Translator Date: Tue, 26 Aug 2025 17:02:00 +0000 Subject: [PATCH] Translated ['src/macos-hardening/macos-security-and-privilege-escalation --- .../macos-proces-abuse/macos-dirty-nib.md | 156 +++++++++++++----- 1 file changed, 115 insertions(+), 41 deletions(-) diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-dirty-nib.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-dirty-nib.md index 8ec86b69e..37c764cfe 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-dirty-nib.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-dirty-nib.md @@ -2,72 +2,146 @@ {{#include ../../../banners/hacktricks-training.md}} -**Para mais detalhes sobre a técnica, consulte o post original em:** [**https://blog.xpnsec.com/dirtynib/**](https://blog.xpnsec.com/dirtynib/) e o seguinte post por [**https://sector7.computest.nl/post/2024-04-bringing-process-injection-into-view-exploiting-all-macos-apps-using-nib-files/**](https://sector7.computest.nl/post/2024-04-bringing-process-injection-into-view-exploiting-all-macos-apps-using-nib-files/)**.** Aqui está um resumo: +Dirty NIB refere-se ao abuso de arquivos do Interface Builder (.xib/.nib) dentro de um bundle macOS assinado para executar lógica controlada pelo atacante dentro do processo alvo, herdando assim seus entitlements e permissões TCC. Esta técnica foi originalmente documentada por xpn (MDSec) e posteriormente generalizada e significativamente expandida por Sector7, que também cobriu as mitigações da Apple no macOS 13 Ventura e macOS 14 Sonoma. Para contexto e análises aprofundadas, veja as referências ao final. -### O que são arquivos Nib +> TL;DR +> • Antes do macOS 13 Ventura: substituir o MainMenu.nib de um bundle (ou outro nib carregado na inicialização) podia conseguir injeção de processo de forma confiável e frequentemente escalada de privilégios. +> • Desde o macOS 13 (Ventura) e aprimorado no macOS 14 (Sonoma): verificação profunda no primeiro lançamento, proteção de bundles, Launch Constraints e a nova permissão TCC “App Management” impedem em grande parte a adulteração de nibs pós‑lançamento por apps não relacionados. Ataques ainda podem ser viáveis em casos de nicho (por exemplo, ferramentas do mesmo desenvolvedor modificando seus próprios apps, ou terminais concedidos App Management/Full Disk Access pelo usuário). -Arquivos Nib (abreviação de NeXT Interface Builder), parte do ecossistema de desenvolvimento da Apple, são destinados a definir **elementos de UI** e suas interações em aplicativos. Eles abrangem objetos serializados, como janelas e botões, e são carregados em tempo de execução. Apesar de seu uso contínuo, a Apple agora defende o uso de Storyboards para uma visualização de fluxo de UI mais abrangente. +## What are NIB/XIB files -O arquivo Nib principal é referenciado no valor **`NSMainNibFile`** dentro do arquivo `Info.plist` do aplicativo e é carregado pela função **`NSApplicationMain`** executada na função `main` do aplicativo. +Arquivos Nib (abreviação de NeXT Interface Builder) são grafos de objetos de UI serializados usados por apps AppKit. O Xcode moderno armazena arquivos .xib XML editáveis que são compilados em .nib no tempo de build. Um app típico carrega sua UI principal via `NSApplicationMain()` que lê a chave `NSMainNibFile` do Info.plist do app e instancia o grafo de objetos em tempo de execução. -### Processo de Injeção de Nib Sujo +Pontos-chave que habilitam o ataque: +- O carregamento de NIB instaura classes arbitrary Objective‑C sem exigir que elas conformem a NSSecureCoding (o nib loader da Apple recorre a `init`/`initWithFrame:` quando `initWithCoder:` não está disponível). +- Cocoa Bindings podem ser abusadas para chamar métodos enquanto os nibs são instanciados, incluindo chamadas encadeadas que não exigem interação do usuário. -#### Criando e Configurando um Arquivo NIB +## Dirty NIB injection process (attacker view) -1. **Configuração Inicial**: -- Crie um novo arquivo NIB usando o XCode. -- Adicione um Objeto à interface, definindo sua classe como `NSAppleScript`. -- Configure a propriedade `source` inicial através de Atributos de Tempo de Execução Definidos pelo Usuário. -2. **Gadget de Execução de Código**: -- A configuração facilita a execução de AppleScript sob demanda. -- Integre um botão para ativar o objeto `Apple Script`, acionando especificamente o seletor `executeAndReturnError:`. -3. **Teste**: +O fluxo clássico pré‑Ventura: +1) Create a malicious .xib +- Add an `NSAppleScript` object (or other “gadget” classes such as `NSTask`). +- Add an `NSTextField` whose title contains the payload (e.g., AppleScript or command arguments). +- Add one or more `NSMenuItem` objects wired via bindings to call methods on the target object. -- Um Apple Script simples para fins de teste: +2) Auto‑trigger without user clicks +- Use bindings to set a menu item’s target/selector and then invoke the private `_corePerformAction` method so the action fires automatically when the nib loads. This removes the need for a user to click a button. -```bash +Minimal example of an auto‑trigger chain inside a .xib (abridged for clarity): +```xml + + + + + + + + + + + + + + + + + + + + + + +``` +Isto permite a execução arbitrária de AppleScript no processo alvo quando o nib é carregado. Cadeias avançadas podem: +- Instanciar classes arbitrárias do AppKit (por exemplo, `NSTask`) e chamar métodos sem argumentos como `-launch`. +- Chamar selectors arbitrários com argumentos objeto via o binding trick acima. +- Carregar AppleScriptObjC.framework para fazer ponte com Objective‑C e até chamar APIs C selecionadas. +- Em sistemas mais antigos que ainda incluem Python.framework, fazer ponte para Python e então usar `ctypes` para chamar funções C arbitrárias (Sector7’s research). + +3) Replace the app’s nib +- Copy target.app to a writable location, replace e.g., `Contents/Resources/MainMenu.nib` with the malicious nib, and run target.app. Pre‑Ventura, after a one‑time Gatekeeper assessment, subsequent launches only performed shallow signature checks, so non‑executable resources (like .nib) weren’t re‑validated. + +Example AppleScript payload for a visible test: +```applescript set theDialogText to "PWND" display dialog theDialogText ``` +## Proteções modernas do macOS (Ventura/Monterey/Sonoma/Sequoia) -- Teste executando no depurador do XCode e clicando no botão. +A Apple introduziu várias mitigações sistêmicas que reduzem drasticamente a viabilidade do Dirty NIB no macOS moderno: +- First‑launch deep verification and bundle protection (macOS 13 Ventura) +- No primeiro lançamento de qualquer app (quarentenado ou não), uma verificação profunda da assinatura abrange todos os recursos do bundle. Depois disso, o bundle fica protegido: somente apps do mesmo desenvolvedor (ou explicitamente permitidos pelo app) podem modificar seu conteúdo. Outros apps exigem a nova permissão TCC “App Management” para escrever no bundle de outro app. +- Launch Constraints (macOS 13 Ventura) +- System/Apple‑bundled apps can’t be copied elsewhere and launched; this kills the “copy to /tmp, patch, run” approach for OS apps. +- Improvements in macOS 14 Sonoma +- Apple hardened App Management and fixed known bypasses (e.g., CVE‑2023‑40450) noted by Sector7. Python.framework was removed earlier (macOS 12.3), breaking some privilege‑escalation chains. +- Gatekeeper/Quarantine changes +- For a broader discussion of Gatekeeper, provenance, and assessment changes that impacted this technique, see the page referenced below. -#### Alvo de um Aplicativo (Exemplo: Pages) +> Implicação prática +> • On Ventura+ you generally cannot modify a third‑party app’s .nib unless your process has App Management or is signed by the same Team ID as the target (e.g., developer tooling). +> • Granting App Management or Full Disk Access to shells/terminals effectively re‑opens this attack surface for anything that can execute code inside that terminal’s context. -1. **Preparação**: -- Copie o aplicativo alvo (por exemplo, Pages) para um diretório separado (por exemplo, `/tmp/`). -- Inicie o aplicativo para contornar problemas do Gatekeeper e armazená-lo em cache. -2. **Substituindo o Arquivo NIB**: -- Substitua um arquivo NIB existente (por exemplo, About Panel NIB) pelo arquivo DirtyNIB criado. -3. **Execução**: -- Acione a execução interagindo com o aplicativo (por exemplo, selecionando o item de menu `About`). -#### Prova de Conceito: Acessando Dados do Usuário +### Lidando com Launch Constraints -- Modifique o AppleScript para acessar e extrair dados do usuário, como fotos, sem o consentimento do usuário. +Launch Constraints impedem a execução de muitos apps da Apple a partir de locais não‑padrão a partir do Ventura. Se você dependia de fluxos de trabalho pré‑Ventura como copiar um app da Apple para um diretório temporário, modificar `MainMenu.nib` e executá‑lo, espere que isso falhe em >= 13.0. -### Exemplo de Código: Arquivo .xib Malicioso -- Acesse e revise um [**exemplo de um arquivo .xib malicioso**](https://gist.github.com/xpn/16bfbe5a3f64fedfcc1822d0562636b4) que demonstra a execução de código arbitrário. +## Enumerando alvos e nibs (útil para pesquisa / sistemas legados) -### Outro Exemplo +- Localizar apps cuja UI é nib‑driven: +```bash +find /Applications -maxdepth 2 -name Info.plist -exec sh -c \ +'for p; do if /usr/libexec/PlistBuddy -c "Print :NSMainNibFile" "$p" >/dev/null 2>&1; \ +then echo "[+] $(dirname "$p") uses NSMainNibFile=$( /usr/libexec/PlistBuddy -c "Print :NSMainNibFile" "$p" )"; fi; done' sh {} + +``` +- Encontrar recursos nib candidatos dentro de um bundle: +```bash +find target.app -type f \( -name "*.nib" -o -name "*.xib" \) -print +``` +- Validar profundamente as assinaturas de código (falhará se você tiver alterado recursos e não os re-assinou): +```bash +codesign --verify --deep --strict --verbose=4 target.app +``` +> Nota: No macOS moderno você também será bloqueado pela bundle protection/TCC ao tentar escrever no bundle de outro app sem autorização adequada. -No post [https://sector7.computest.nl/post/2024-04-bringing-process-injection-into-view-exploiting-all-macos-apps-using-nib-files/](https://sector7.computest.nl/post/2024-04-bringing-process-injection-into-view-exploiting-all-macos-apps-using-nib-files/) você pode encontrar um tutorial sobre como criar um nib sujo. -### Abordando Restrições de Lançamento +## Detecção e dicas de DFIR -- Restrições de Lançamento dificultam a execução de aplicativos de locais inesperados (por exemplo, `/tmp`). -- É possível identificar aplicativos que não estão protegidos por Restrições de Lançamento e direcioná-los para injeção de arquivo NIB. +- Monitoramento de integridade de arquivos em recursos de bundle +- Monitore alterações de mtime/ctime em `Contents/Resources/*.nib` e outros recursos não‑executáveis em apps instalados. +- Logs unificados e comportamento de processos +- Monitore execuções inesperadas de AppleScript dentro de apps GUI e processos carregando AppleScriptObjC ou Python.framework. Exemplo: +```bash +log stream --info --predicate 'processImagePath CONTAINS[cd] ".app/Contents/MacOS/" AND (eventMessage CONTAINS[cd] "AppleScript" OR eventMessage CONTAINS[cd] "loadAppleScriptObjectiveCScripts")' +``` +- Avaliações proativas +- Execute periodicamente `codesign --verify --deep` em apps críticos para garantir que os recursos permaneçam intactos. +- Contexto de privilégio +- Audite quem/o que tem TCC “App Management” ou Full Disk Access (especialmente terminais e agentes de gestão). Remover esses privilégios de shells de uso geral impede reativar trivialmente a manipulação no estilo Dirty NIB. -### Proteções Adicionais do macOS -A partir do macOS Sonoma, modificações dentro de pacotes de aplicativos são restritas. No entanto, métodos anteriores envolviam: +## Defensive hardening (developers and defenders) -1. Copiar o aplicativo para um local diferente (por exemplo, `/tmp/`). -2. Renomear diretórios dentro do pacote do aplicativo para contornar proteções iniciais. -3. Após executar o aplicativo para registrar com o Gatekeeper, modificar o pacote do aplicativo (por exemplo, substituindo MainMenu.nib por Dirty.nib). -4. Renomear os diretórios de volta e executar novamente o aplicativo para executar o arquivo NIB injetado. +- Prefira UI programática ou limite o que é instanciado a partir de nibs. Evite incluir classes poderosas (e.g., `NSTask`) em grafos de nib e evite bindings que invoquem selectors indiretamente em objetos arbitrários. +- Adote o hardened runtime com Library Validation (já padrão em apps modernos). Embora isso não impeça a nib injection por si só, bloqueia o carregamento fácil de código nativo e força atacantes a payloads apenas por scripting. +- Não solicite nem dependa de permissões amplas de App Management em ferramentas de uso geral. Se o MDM exigir App Management, segrege esse contexto de shells orientados ao usuário. +- Verifique regularmente a integridade do bundle do seu app e faça com que seus mecanismos de atualização restaurem automaticamente os recursos do bundle. -**Nota**: Atualizações recentes do macOS mitigaram essa exploração, impedindo modificações de arquivos dentro de pacotes de aplicativos após o cache do Gatekeeper, tornando a exploração ineficaz. + +## Related reading in HackTricks + +Saiba mais sobre Gatekeeper, quarantine e alterações de provenance que afetam esta técnica: + +{{#ref}} +../macos-security-protections/macos-gatekeeper.md +{{#endref}} + + +## References + +- xpn – DirtyNIB (relato original com exemplo no Pages): https://blog.xpnsec.com/dirtynib/ +- Sector7 – Bringing process injection into view(s): exploiting all macOS apps using nib files (5 de abril de 2024): https://sector7.computest.nl/post/2024-04-bringing-process-injection-into-view-exploiting-all-macos-apps-using-nib-files/ {{#include ../../../banners/hacktricks-training.md}}