mirror of
https://github.com/carlospolop/hacktricks
synced 2024-11-24 13:43:24 +00:00
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
This commit is contained in:
Translator
parent
530a024d81
commit
2cf8b55b16
3 changed files with 269 additions and 50 deletions
|
|
@ -159,7 +159,7 @@
|
|||
* [macOS Universal binaries & Mach-O Format](macos-hardening/macos-security-and-privilege-escalation/macos-files-folders-and-binaries/universal-binaries-and-mach-o-format.md)
|
||||
* [macOS Objective-C](macos-hardening/macos-security-and-privilege-escalation/macos-basic-objective-c.md)
|
||||
* [macOS Privilege Escalation](macos-hardening/macos-security-and-privilege-escalation/macos-privilege-escalation.md)
|
||||
* [macOS Proces Abuse](macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/README.md)
|
||||
* [macOS Process Abuse](macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/README.md)
|
||||
* [macOS Dirty NIB](macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-dirty-nib.md)
|
||||
* [macOS Chromium Injection](macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-chromium-injection.md)
|
||||
* [macOS Electron Applications Injection](macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-electron-applications-injection.md)
|
||||
|
|
|
|||
|
|
@ -6,34 +6,99 @@
|
|||
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Compartilhe seus truques de hacking enviando PRs para o** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
|
||||
- Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
- Obtenha o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
- Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
- **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
- **Compartilhe seus truques de hacking enviando PRs para o** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
|
||||
|
||||
</details>
|
||||
|
||||
## Informações Básicas
|
||||
|
||||
**Grand Central Dispatch (GCD),** também conhecido como **libdispatch**, está disponível tanto no macOS quanto no iOS. É uma tecnologia desenvolvida pela Apple para otimizar o suporte de aplicativos para execução concorrente (multithreaded) em hardware multicore.
|
||||
**Grand Central Dispatch (GCD),** também conhecido como **libdispatch** (`libdispatch.dyld`), está disponível tanto no macOS quanto no iOS. É uma tecnologia desenvolvida pela Apple para otimizar o suporte de aplicativos para execução concorrente (multithreaded) em hardware multicore.
|
||||
|
||||
**GCD** fornece e gerencia **filas FIFO** para as quais seu aplicativo pode **enviar tarefas** na forma de **objetos de bloco**. Blocos enviados para filas de despacho são **executados em um pool de threads** totalmente gerenciado pelo sistema. GCD cria automaticamente threads para executar as tarefas nas filas de despacho e agenda essas tarefas para serem executadas nos núcleos disponíveis.
|
||||
|
||||
{% hint style="success" %}
|
||||
Em resumo, para executar código em **paralelo**, os processos podem enviar **blocos de código para o GCD**, que cuidará de sua execução. Portanto, os processos não criam novas threads; **o GCD executa o código fornecido com seu próprio pool de threads**.
|
||||
Em resumo, para executar código em **paralelo**, os processos podem enviar **blocos de código para o GCD**, que cuidará de sua execução. Portanto, os processos não criam novas threads; **o GCD executa o código fornecido com seu próprio pool de threads** (que pode aumentar ou diminuir conforme necessário).
|
||||
{% endhint %}
|
||||
|
||||
Isso é muito útil para gerenciar a execução paralela com sucesso, reduzindo significativamente o número de threads que os processos criam e otimizando a execução paralela. Isso é ideal para tarefas que requerem **grande paralelismo** (força bruta?) ou para tarefas que não devem bloquear a thread principal: Por exemplo, a thread principal no iOS lida com interações de UI, então qualquer outra funcionalidade que possa fazer o aplicativo travar (pesquisa, acesso a uma web, leitura de um arquivo...) é gerenciada dessa maneira.
|
||||
Isso é muito útil para gerenciar a execução paralela com sucesso, reduzindo significativamente o número de threads que os processos criam e otimizando a execução paralela. Isso é ideal para tarefas que requerem **grande paralelismo** (força bruta?) ou para tarefas que não devem bloquear a thread principal: Por exemplo, a thread principal no iOS lida com interações de UI, então qualquer outra funcionalidade que possa fazer o aplicativo travar (pesquisar, acessar uma web, ler um arquivo...) é gerenciada dessa maneira.
|
||||
|
||||
### Blocos
|
||||
|
||||
Um bloco é uma **seção de código autocontida** (como uma função com argumentos que retorna um valor) e também pode especificar variáveis vinculadas.\
|
||||
No entanto, no nível do compilador, os blocos não existem, eles são `os_object`s. Cada um desses objetos é formado por duas estruturas:
|
||||
|
||||
- **literal de bloco**: 
|
||||
- Começa pelo campo **`isa`**, apontando para a classe do bloco:
|
||||
- `NSConcreteGlobalBlock` (blocos de `__DATA.__const`)
|
||||
- `NSConcreteMallocBlock` (blocos na heap)
|
||||
- `NSConcreateStackBlock` (blocos na pilha)
|
||||
- Possui **`flags`** (indicando campos presentes no descritor do bloco) e alguns bytes reservados
|
||||
- O ponteiro da função a ser chamada
|
||||
- Um ponteiro para o descritor do bloco
|
||||
- Variáveis importadas do bloco (se houver)
|
||||
- **descritor de bloco**: Seu tamanho depende dos dados presentes (conforme indicado nas flags anteriores)
|
||||
- Possui alguns bytes reservados
|
||||
- O tamanho dele
|
||||
- Normalmente terá um ponteiro para uma assinatura de estilo Objective-C para saber quanto espaço é necessário para os parâmetros (flag `BLOCK_HAS_SIGNATURE`)
|
||||
- Se variáveis são referenciadas, este bloco também terá ponteiros para um auxiliar de cópia (copiando o valor no início) e um auxiliar de liberação (liberando-o).
|
||||
|
||||
### Filas
|
||||
|
||||
Uma fila de despacho é um objeto nomeado que fornece a ordenação FIFO de blocos para execuções.
|
||||
|
||||
Blocos são definidos em filas para serem executados, e essas suportam 2 modos: `DISPATCH_QUEUE_SERIAL` e `DISPATCH_QUEUE_CONCURRENT`. Claro que a **serial** não terá problemas de condição de corrida, pois um bloco não será executado até que o anterior tenha terminado. Mas **o outro tipo de fila pode ter**.
|
||||
|
||||
Filas padrão:
|
||||
|
||||
- `.main-thread`: De `dispatch_get_main_queue()`
|
||||
- `.libdispatch-manager`: Gerenciador de filas do GCD
|
||||
- `.root.libdispatch-manager`: Gerenciador de filas do GCD
|
||||
- `.root.maintenance-qos`: Tarefas de menor prioridade
|
||||
- `.root.maintenance-qos.overcommit`
|
||||
- `.root.background-qos`: Disponível como `DISPATCH_QUEUE_PRIORITY_BACKGROUND`
|
||||
- `.root.background-qos.overcommit`
|
||||
- `.root.utility-qos`: Disponível como `DISPATCH_QUEUE_PRIORITY_NON_INTERACTIVE`
|
||||
- `.root.utility-qos.overcommit`
|
||||
- `.root.default-qos`: Disponível como `DISPATCH_QUEUE_PRIORITY_DEFAULT`
|
||||
- `.root.background-qos.overcommit`
|
||||
- `.root.user-initiated-qos`: Disponível como `DISPATCH_QUEUE_PRIORITY_HIGH`
|
||||
- `.root.background-qos.overcommit`
|
||||
- `.root.user-interactive-qos`: Maior prioridade
|
||||
- `.root.background-qos.overcommit`
|
||||
|
||||
Observe que será o sistema quem decide **quais threads manipulam quais filas em cada momento** (várias threads podem trabalhar na mesma fila ou a mesma thread pode trabalhar em filas diferentes em algum momento)
|
||||
|
||||
#### Atributos
|
||||
|
||||
Ao criar uma fila com **`dispatch_queue_create`** o terceiro argumento é um `dispatch_queue_attr_t`, que geralmente é `DISPATCH_QUEUE_SERIAL` (que na verdade é NULL) ou `DISPATCH_QUEUE_CONCURRENT` que é um ponteiro para uma estrutura `dispatch_queue_attr_t` que permite controlar alguns parâmetros da fila.
|
||||
|
||||
### Objetos de Despacho
|
||||
|
||||
Existem vários objetos que o libdispatch usa e filas e blocos são apenas 2 deles. É possível criar esses objetos com `dispatch_object_create`:
|
||||
|
||||
- `bloco`
|
||||
- `dados`: Blocos de dados
|
||||
- `grupo`: Grupo de blocos
|
||||
- `io`: Solicitações de E/S assíncronas
|
||||
- `mach`: Portas Mach
|
||||
- `mach_msg`: Mensagens Mach
|
||||
- `pthread_root_queue`: Uma fila com um pool de threads pthread e sem workqueues
|
||||
- `fila`
|
||||
- `semáforo`
|
||||
- `fonte`: Fonte de evento
|
||||
|
||||
## Objective-C
|
||||
|
||||
Em Objetive-C, existem diferentes funções para enviar um bloco a ser executado em paralelo:
|
||||
Em Objetive-C existem diferentes funções para enviar um bloco para ser executado em paralelo:
|
||||
|
||||
* [**dispatch\_async**](https://developer.apple.com/documentation/dispatch/1453057-dispatch\_async): Submete um bloco para execução assíncrona em uma fila de despacho e retorna imediatamente.
|
||||
* [**dispatch\_sync**](https://developer.apple.com/documentation/dispatch/1452870-dispatch\_sync): Submete um objeto de bloco para execução e retorna após a conclusão desse bloco.
|
||||
* [**dispatch\_once**](https://developer.apple.com/documentation/dispatch/1447169-dispatch\_once): Executa um objeto de bloco apenas uma vez durante a vida útil de um aplicativo.
|
||||
* [**dispatch\_async\_and\_wait**](https://developer.apple.com/documentation/dispatch/3191901-dispatch\_async\_and\_wait): Submete um item de trabalho para execução e retorna somente após a conclusão. Ao contrário de [**`dispatch_sync`**](https://developer.apple.com/documentation/dispatch/1452870-dispatch\_sync), esta função respeita todos os atributos da fila ao executar o bloco.
|
||||
- [**dispatch\_async**](https://developer.apple.com/documentation/dispatch/1453057-dispatch\_async): Submete um bloco para execução assíncrona em uma fila de despacho e retorna imediatamente.
|
||||
- [**dispatch\_sync**](https://developer.apple.com/documentation/dispatch/1452870-dispatch\_sync): Submete um objeto de bloco para execução e retorna após a conclusão desse bloco.
|
||||
- [**dispatch\_once**](https://developer.apple.com/documentation/dispatch/1447169-dispatch\_once): Executa um objeto de bloco apenas uma vez durante a vida útil de um aplicativo.
|
||||
- [**dispatch\_async\_and\_wait**](https://developer.apple.com/documentation/dispatch/3191901-dispatch\_async\_and\_wait): Submete um item de trabalho para execução e retorna somente após sua conclusão. Ao contrário de [**`dispatch_sync`**](https://developer.apple.com/documentation/dispatch/1452870-dispatch\_sync), esta função respeita todos os atributos da fila ao executar o bloco.
|
||||
|
||||
Essas funções esperam esses parâmetros: [**`dispatch_queue_t`**](https://developer.apple.com/documentation/dispatch/dispatch\_queue\_t) **`queue,`** [**`dispatch_block_t`**](https://developer.apple.com/documentation/dispatch/dispatch\_block\_t) **`block`**
|
||||
|
||||
|
|
@ -80,7 +145,7 @@ return 0;
|
|||
```
|
||||
## Swift
|
||||
|
||||
A **`libswiftDispatch`** é uma biblioteca que fornece **ligações Swift** para o framework Grand Central Dispatch (GCD) originalmente escrito em C.\
|
||||
A **`libswiftDispatch`** é uma biblioteca que fornece **ligações Swift** para o framework Grand Central Dispatch (GCD), que foi originalmente escrito em C.\
|
||||
A biblioteca **`libswiftDispatch`** encapsula as APIs C do GCD em uma interface mais amigável ao Swift, tornando mais fácil e intuitivo para os desenvolvedores Swift trabalharem com o GCD.
|
||||
|
||||
* **`DispatchQueue.global().sync{ ... }`**
|
||||
|
|
@ -118,7 +183,7 @@ sleep(1) // Simulate a long-running task
|
|||
```
|
||||
## Frida
|
||||
|
||||
O seguinte script Frida pode ser usado para **interceptar várias funções `dispatch`** e extrair o nome da fila, o rastreamento de pilha e o bloco: [**https://github.com/seemoo-lab/frida-scripts/blob/main/scripts/libdispatch.js**](https://github.com/seemoo-lab/frida-scripts/blob/main/scripts/libdispatch.js)
|
||||
O seguinte script Frida pode ser usado para **interceptar várias funções `dispatch`** e extrair o nome da fila, o backtrace e o bloco: [**https://github.com/seemoo-lab/frida-scripts/blob/main/scripts/libdispatch.js**](https://github.com/seemoo-lab/frida-scripts/blob/main/scripts/libdispatch.js)
|
||||
```bash
|
||||
frida -U <prog_name> -l libdispatch.js
|
||||
|
||||
|
|
@ -137,24 +202,28 @@ Atualmente, o Ghidra não entende nem a estrutura **`dispatch_block_t`** do Obje
|
|||
|
||||
Portanto, se você deseja que ele as entenda, você pode simplesmente **declará-las**:
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (688).png" alt="" width="563"><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1157).png" alt="" width="563"><figcaption></figcaption></figure>
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (690).png" alt="" width="563"><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1159).png" alt="" width="563"><figcaption></figcaption></figure>
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (691).png" alt="" width="563"><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1160).png" alt="" width="563"><figcaption></figcaption></figure>
|
||||
|
||||
Em seguida, encontre um local no código onde elas são **usadas**:
|
||||
|
||||
{% hint style="success" %}
|
||||
Observe todas as referências feitas a "block" para entender como você pode descobrir que a estrutura está sendo usada.
|
||||
Observe todas as referências feitas a "block" para entender como você poderia descobrir que a estrutura está sendo usada.
|
||||
{% endhint %}
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (692).png" alt="" width="563"><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1161).png" alt="" width="563"><figcaption></figcaption></figure>
|
||||
|
||||
Clique com o botão direito na variável -> Alterar Tipo de Variável e selecione neste caso **`swift_dispatch_block`**:
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (693).png" alt="" width="563"><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1162).png" alt="" width="563"><figcaption></figcaption></figure>
|
||||
|
||||
O Ghidra irá reescrever automaticamente tudo:
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (694).png" alt="" width="563"><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1163).png" alt="" width="563"><figcaption></figcaption></figure>
|
||||
|
||||
## Referências
|
||||
|
||||
* [**\*OS Internals, Volume I: User Mode. Por Jonathan Levin**](https://www.amazon.com/MacOS-iOS-Internals-User-Mode/dp/099105556X)
|
||||
|
|
|
|||
|
|
@ -1,22 +1,160 @@
|
|||
# macOS Proces Abuse
|
||||
# Abuso de Processos no macOS
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprenda hacking AWS do zero ao avançado com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Aprenda hacking AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Outras formas de apoiar o HackTricks:
|
||||
Outras maneiras de apoiar o HackTricks:
|
||||
|
||||
* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe seus truques de hacking enviando PRs para os repositórios do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
- Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
- Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
- Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
- **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
- **Compartilhe seus truques de hacking enviando PRs para o** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
|
||||
|
||||
</details>
|
||||
|
||||
## Abuso de Processos no macOS
|
||||
## Informações Básicas sobre Processos
|
||||
|
||||
O macOS, como qualquer outro sistema operacional, fornece uma variedade de métodos e mecanismos para que os **processos interajam, comuniquem e compartilhem dados**. Embora essas técnicas sejam essenciais para o funcionamento eficiente do sistema, também podem ser abusadas por atores maliciosos para **realizar atividades maliciosas**.
|
||||
Um processo é uma instância de um executável em execução, no entanto, os processos não executam código, esses são threads. Portanto, **os processos são apenas contêineres para threads em execução** fornecendo memória, descritores, portas, permissões...
|
||||
|
||||
Tradicionalmente, os processos eram iniciados dentro de outros processos (exceto o PID 1) chamando **`fork`** que criaria uma cópia exata do processo atual e então o **processo filho** geralmente chamaria **`execve`** para carregar o novo executável e executá-lo. Em seguida, **`vfork`** foi introduzido para tornar esse processo mais rápido sem qualquer cópia de memória.\
|
||||
Então **`posix_spawn`** foi introduzido combinando **`vfork`** e **`execve`** em uma chamada e aceitando flags:
|
||||
|
||||
- `POSIX_SPAWN_RESETIDS`: Redefinir ids efetivos para ids reais
|
||||
- `POSIX_SPAWN_SETPGROUP`: Definir a afiliação do grupo de processos
|
||||
- `POSUX_SPAWN_SETSIGDEF`: Definir o comportamento padrão do sinal
|
||||
- `POSIX_SPAWN_SETSIGMASK`: Definir a máscara de sinal
|
||||
- `POSIX_SPAWN_SETEXEC`: Executar no mesmo processo (como `execve` com mais opções)
|
||||
- `POSIX_SPAWN_START_SUSPENDED`: Iniciar suspenso
|
||||
- `_POSIX_SPAWN_DISABLE_ASLR`: Iniciar sem ASLR
|
||||
- `_POSIX_SPAWN_NANO_ALLOCATOR:` Usar o Nano alocador do libmalloc
|
||||
- `_POSIX_SPAWN_ALLOW_DATA_EXEC:` Permitir `rwx` em segmentos de dados
|
||||
- `POSIX_SPAWN_CLOEXEC_DEFAULT`: Fechar todas as descrições de arquivos em exec(2) por padrão
|
||||
- `_POSIX_SPAWN_HIGH_BITS_ASLR:` Aleatorizar bits altos do slide ASLR
|
||||
|
||||
Além disso, `posix_spawn` permite especificar uma matriz de **`posix_spawnattr`** que controla alguns aspectos do processo gerado, e **`posix_spawn_file_actions`** para modificar o estado dos descritores.
|
||||
|
||||
Quando um processo morre, ele envia o **código de retorno para o processo pai** (se o pai morreu, o novo pai é o PID 1) com o sinal `SIGCHLD`. O pai precisa obter esse valor chamando `wait4()` ou `waitid()` e até que isso aconteça, o filho permanece em um estado zumbi onde ainda está listado, mas não consome recursos.
|
||||
|
||||
### PIDs
|
||||
|
||||
PIDs, identificadores de processo, identificam um processo único. No XNU, os **PIDs** são de **64 bits** aumentando monotonicamente e **nunca se repetem** (para evitar abusos).
|
||||
|
||||
### Grupos de Processos, Sessões e Coalizões
|
||||
|
||||
**Processos** podem ser inseridos em **grupos** para facilitar o seu manuseio. Por exemplo, comandos em um script de shell estarão no mesmo grupo de processos, então é possível **sinalizá-los juntos** usando kill, por exemplo.\
|
||||
Também é possível **agrupar processos em sessões**. Quando um processo inicia uma sessão (`setsid(2)`), os processos filhos são colocados dentro da sessão, a menos que iniciem sua própria sessão.
|
||||
|
||||
Coalition é outra maneira de agrupar processos no Darwin. Um processo que ingressa em uma coalizão permite acessar recursos compartilhados, compartilhar um livro-razão ou enfrentar Jetsam. As coalizões têm diferentes papéis: Líder, serviço XPC, Extensão.
|
||||
|
||||
### Credenciais e Personas
|
||||
|
||||
Cada processo mantém **credenciais** que **identificam seus privilégios** no sistema. Cada processo terá um `uid` primário e um `gid` primário (embora possa pertencer a vários grupos).\
|
||||
Também é possível alterar o id do usuário e do grupo se o binário tiver o bit `setuid/setgid`.\
|
||||
Existem várias funções para **definir novos uids/gids**.
|
||||
|
||||
A chamada de sistema **`persona`** fornece um **conjunto alternativo** de **credenciais**. Adotar uma persona assume seu uid, gid e associações de grupo **de uma vez**. No [**código-fonte**](https://github.com/apple/darwin-xnu/blob/main/bsd/sys/persona.h) é possível encontrar a struct:
|
||||
```c
|
||||
struct kpersona_info { uint32_t persona_info_version;
|
||||
uid_t persona_id; /* overlaps with UID */
|
||||
int persona_type;
|
||||
gid_t persona_gid;
|
||||
uint32_t persona_ngroups;
|
||||
gid_t persona_groups[NGROUPS];
|
||||
uid_t persona_gmuid;
|
||||
char persona_name[MAXLOGNAME + 1];
|
||||
|
||||
/* TODO: MAC policies?! */
|
||||
}
|
||||
```
|
||||
## Informações Básicas sobre Threads
|
||||
|
||||
1. **Threads POSIX (pthreads):** O macOS suporta threads POSIX (`pthreads`), que fazem parte de uma API de threads padrão para C/C++. A implementação de pthreads no macOS é encontrada em `/usr/lib/system/libsystem_pthread.dylib`, que vem do projeto publicamente disponível `libpthread`. Esta biblioteca fornece as funções necessárias para criar e gerenciar threads.
|
||||
2. **Criando Threads:** A função `pthread_create()` é usada para criar novas threads. Internamente, esta função chama `bsdthread_create()`, que é uma chamada de sistema de nível mais baixo específica para o kernel XNU (o kernel no qual o macOS é baseado). Esta chamada de sistema recebe vários flags derivados de `pthread_attr` (atributos) que especificam o comportamento da thread, incluindo políticas de agendamento e tamanho da pilha.
|
||||
* **Tamanho Padrão da Pilha:** O tamanho padrão da pilha para novas threads é de 512 KB, o que é suficiente para operações típicas, mas pode ser ajustado via atributos da thread se mais ou menos espaço for necessário.
|
||||
3. **Inicialização da Thread:** A função `__pthread_init()` é crucial durante a configuração da thread, utilizando o argumento `env[]` para analisar variáveis de ambiente que podem incluir detalhes sobre a localização e tamanho da pilha.
|
||||
|
||||
#### Término de Threads no macOS
|
||||
|
||||
1. **Encerrando Threads:** As threads são tipicamente encerradas chamando `pthread_exit()`. Esta função permite que uma thread saia limparmente, realizando a limpeza necessária e permitindo que a thread envie um valor de retorno de volta para qualquer thread que a esteja aguardando.
|
||||
2. **Limpeza da Thread:** Ao chamar `pthread_exit()`, a função `pthread_terminate()` é invocada, que lida com a remoção de todas as estruturas de thread associadas. Ela desaloca as portas de thread Mach (Mach é o subsistema de comunicação no kernel XNU) e chama `bsdthread_terminate`, uma chamada de sistema que remove as estruturas de nível de kernel associadas à thread.
|
||||
|
||||
#### Mecanismos de Sincronização
|
||||
|
||||
Para gerenciar o acesso a recursos compartilhados e evitar condições de corrida, o macOS fornece vários primitivos de sincronização. Estes são críticos em ambientes de múltiplas threads para garantir a integridade dos dados e a estabilidade do sistema:
|
||||
|
||||
1. **Mutexes:**
|
||||
* **Mutex Regular (Assinatura: 0x4D555458):** Mutex padrão com uma pegada de memória de 60 bytes (56 bytes para o mutex e 4 bytes para a assinatura).
|
||||
* **Mutex Rápido (Assinatura: 0x4d55545A):** Semelhante a um mutex regular, mas otimizado para operações mais rápidas, também com 60 bytes de tamanho.
|
||||
2. **Variáveis de Condição:**
|
||||
* Usadas para aguardar que certas condições ocorram, com um tamanho de 44 bytes (40 bytes mais uma assinatura de 4 bytes).
|
||||
* **Atributos de Variável de Condição (Assinatura: 0x434e4441):** Atributos de configuração para variáveis de condição, com tamanho de 12 bytes.
|
||||
3. **Variável Once (Assinatura: 0x4f4e4345):**
|
||||
* Garante que um trecho de código de inicialização seja executado apenas uma vez. Seu tamanho é de 12 bytes.
|
||||
4. **Travas de Leitura-Escrita:**
|
||||
* Permite múltiplos leitores ou um escritor por vez, facilitando o acesso eficiente a dados compartilhados.
|
||||
* **Trava de Leitura-Escrita (Assinatura: 0x52574c4b):** Com tamanho de 196 bytes.
|
||||
* **Atributos de Trava de Leitura-Escrita (Assinatura: 0x52574c41):** Atributos para travas de leitura-escrita, com 20 bytes de tamanho.
|
||||
|
||||
{% hint style="success" %}
|
||||
Os últimos 4 bytes desses objetos são usados para detectar estouros.
|
||||
{% endhint %}
|
||||
|
||||
### Variáveis Locais da Thread (TLV)
|
||||
|
||||
**Variáveis Locais da Thread (TLV)** no contexto de arquivos Mach-O (o formato para executáveis no macOS) são usadas para declarar variáveis específicas para **cada thread** em um aplicativo multi-thread. Isso garante que cada thread tenha sua própria instância separada de uma variável, fornecendo uma maneira de evitar conflitos e manter a integridade dos dados sem a necessidade de mecanismos explícitos de sincronização como mutexes.
|
||||
|
||||
Em C e linguagens relacionadas, você pode declarar uma variável local da thread usando a palavra-chave **`__thread`**. Veja como funciona no seu exemplo:
|
||||
```c
|
||||
cCopy code__thread int tlv_var;
|
||||
|
||||
void main (int argc, char **argv){
|
||||
tlv_var = 10;
|
||||
}
|
||||
```
|
||||
Este trecho define `tlv_var` como uma variável local de thread. Cada thread que executa este código terá sua própria `tlv_var`, e as alterações feitas por uma thread em `tlv_var` não afetarão `tlv_var` em outra thread.
|
||||
|
||||
No binário Mach-O, os dados relacionados às variáveis locais de thread são organizados em seções específicas:
|
||||
|
||||
- **`__DATA.__thread_vars`**: Esta seção contém metadados sobre as variáveis locais de thread, como seus tipos e status de inicialização.
|
||||
- **`__DATA.__thread_bss`**: Esta seção é usada para variáveis locais de thread que não são inicializadas explicitamente. É uma parte da memória reservada para dados inicializados com zero.
|
||||
|
||||
O Mach-O também fornece uma API específica chamada **`tlv_atexit`** para gerenciar variáveis locais de thread quando uma thread é encerrada. Esta API permite que você **registre destruidores** - funções especiais que limpam os dados locais da thread quando uma thread termina.
|
||||
|
||||
### Prioridades de Thread
|
||||
|
||||
Entender as prioridades de thread envolve observar como o sistema operacional decide quais threads executar e quando. Essa decisão é influenciada pelo nível de prioridade atribuído a cada thread. Em sistemas macOS e Unix-like, isso é tratado usando conceitos como `nice`, `renice` e classes de Qualidade de Serviço (QoS).
|
||||
|
||||
#### Nice e Renice
|
||||
|
||||
1. **Nice:**
|
||||
- O valor `nice` de um processo é um número que afeta sua prioridade. Cada processo tem um valor `nice` variando de -20 (a maior prioridade) a 19 (a menor prioridade). O valor `nice` padrão quando um processo é criado é tipicamente 0.
|
||||
- Um valor `nice` mais baixo (mais próximo de -20) torna um processo mais "egoísta", dando-lhe mais tempo de CPU em comparação com outros processos com valores `nice` mais altos.
|
||||
2. **Renice:**
|
||||
- `renice` é um comando usado para alterar o valor `nice` de um processo em execução. Isso pode ser usado para ajustar dinamicamente a prioridade dos processos, aumentando ou diminuindo sua alocação de tempo de CPU com base em novos valores `nice`.
|
||||
- Por exemplo, se um processo precisa de mais recursos de CPU temporariamente, você pode diminuir seu valor `nice` usando `renice`.
|
||||
|
||||
#### Classes de Qualidade de Serviço (QoS)
|
||||
|
||||
As classes de QoS são uma abordagem mais moderna para lidar com as prioridades de thread, especialmente em sistemas como macOS que suportam o **Grand Central Dispatch (GCD)**. As classes de QoS permitem que os desenvolvedores **classifiquem** o trabalho em diferentes níveis com base em sua importância ou urgência. O macOS gerencia a priorização de threads automaticamente com base nessas classes de QoS:
|
||||
|
||||
1. **Interativo do Usuário:**
|
||||
- Esta classe é para tarefas que estão interagindo atualmente com o usuário ou que exigem resultados imediatos para fornecer uma boa experiência ao usuário. Essas tarefas recebem a mais alta prioridade para manter a interface responsiva (por exemplo, animações ou manipulação de eventos).
|
||||
2. **Iniciado pelo Usuário:**
|
||||
- Tarefas que o usuário inicia e espera resultados imediatos, como abrir um documento ou clicar em um botão que requer cálculos. Estas são de alta prioridade, mas abaixo do interativo do usuário.
|
||||
3. **Utilitário:**
|
||||
- Essas tarefas são de longa duração e geralmente mostram um indicador de progresso (por exemplo, baixar arquivos, importar dados). Elas têm prioridade mais baixa do que tarefas iniciadas pelo usuário e não precisam ser concluídas imediatamente.
|
||||
4. **Background:**
|
||||
- Esta classe é para tarefas que operam em segundo plano e não são visíveis para o usuário. Podem ser tarefas como indexação, sincronização ou backups. Elas têm a menor prioridade e impacto mínimo no desempenho do sistema.
|
||||
|
||||
Usando classes de QoS, os desenvolvedores não precisam gerenciar os números exatos de prioridade, mas sim focar na natureza da tarefa, e o sistema otimiza os recursos da CPU de acordo.
|
||||
|
||||
Além disso, existem diferentes **políticas de agendamento de threads** que fluem para especificar um conjunto de parâmetros de agendamento que o agendador levará em consideração. Isso pode ser feito usando `thread_policy_[set/get]`. Isso pode ser útil em ataques de condição de corrida.
|
||||
|
||||
## Abuso de Processos no MacOS
|
||||
|
||||
O MacOS, como qualquer outro sistema operacional, fornece uma variedade de métodos e mecanismos para **processos interagirem, comunicarem e compartilharem dados**. Embora essas técnicas sejam essenciais para o funcionamento eficiente do sistema, elas também podem ser abusadas por atores maliciosos para **realizar atividades maliciosas**.
|
||||
|
||||
### Injeção de Biblioteca
|
||||
|
||||
|
|
@ -50,7 +188,7 @@ Aplicações Electron executadas com variáveis de ambiente específicas podem s
|
|||
[macos-electron-applications-injection.md](macos-electron-applications-injection.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
### Injeção em Chromium
|
||||
### Injeção no Chromium
|
||||
|
||||
É possível usar as flags `--load-extension` e `--use-fake-ui-for-media-stream` para realizar um **ataque man in the browser** permitindo roubar pressionamentos de teclas, tráfego, cookies, injetar scripts em páginas...:
|
||||
|
||||
|
|
@ -60,7 +198,7 @@ Aplicações Electron executadas com variáveis de ambiente específicas podem s
|
|||
|
||||
### NIB Sujo
|
||||
|
||||
Arquivos NIB **definem elementos de interface do usuário (UI)** e suas interações dentro de um aplicativo. No entanto, eles podem **executar comandos arbitrários** e o **Gatekeeper não impede** que um aplicativo já executado seja executado se um **arquivo NIB for modificado**. Portanto, eles poderiam ser usados para fazer programas arbitrários executarem comandos arbitrários:
|
||||
Arquivos NIB **definem elementos de interface do usuário (UI)** e suas interações dentro de uma aplicação. No entanto, eles podem **executar comandos arbitrários** e o Gatekeeper não impede que uma aplicação já executada seja executada novamente se um **arquivo NIB for modificado**. Portanto, eles poderiam ser usados para fazer programas arbitrários executarem comandos arbitrários:
|
||||
|
||||
{% content-ref url="macos-dirty-nib.md" %}
|
||||
[macos-dirty-nib.md](macos-dirty-nib.md)
|
||||
|
|
@ -68,7 +206,7 @@ Arquivos NIB **definem elementos de interface do usuário (UI)** e suas interaç
|
|||
|
||||
### Injeção em Aplicações Java
|
||||
|
||||
É possível abusar de certas capacidades do Java (como a variável de ambiente **`_JAVA_OPTS`**) para fazer um aplicativo Java executar **código/comandos arbitrários**.
|
||||
É possível abusar de certas capacidades do Java (como a variável de ambiente **`_JAVA_OPTS`**) para fazer uma aplicação Java executar **código/comandos arbitrários**.
|
||||
|
||||
{% content-ref url="macos-java-apps-injection.md" %}
|
||||
[macos-java-apps-injection.md](macos-java-apps-injection.md)
|
||||
|
|
@ -76,7 +214,7 @@ Arquivos NIB **definem elementos de interface do usuário (UI)** e suas interaç
|
|||
|
||||
### Injeção em Aplicações .Net
|
||||
|
||||
É possível injetar código em aplicativos .Net **abusando da funcionalidade de depuração do .Net** (não protegida por proteções do macOS, como o fortalecimento em tempo de execução).
|
||||
É possível injetar código em aplicações .Net **abusando da funcionalidade de depuração do .Net** (não protegida por proteções do macOS como endurecimento em tempo de execução).
|
||||
|
||||
{% content-ref url="macos-.net-applications-injection.md" %}
|
||||
[macos-.net-applications-injection.md](macos-.net-applications-injection.md)
|
||||
|
|
@ -97,17 +235,29 @@ Também é possível abusar das variáveis de ambiente do Ruby para fazer script
|
|||
{% content-ref url="macos-ruby-applications-injection.md" %}
|
||||
[macos-ruby-applications-injection.md](macos-ruby-applications-injection.md)
|
||||
{% endcontent-ref %}
|
||||
### Injeção de Python
|
||||
|
||||
### Injeção em Python
|
||||
Se a variável de ambiente **`PYTHONINSPECT`** estiver definida, o processo python entrará em um cli python assim que terminar. Também é possível usar **`PYTHONSTARTUP`** para indicar um script python a ser executado no início de uma sessão interativa.\
|
||||
No entanto, observe que o script **`PYTHONSTARTUP`** não será executado quando o **`PYTHONINSPECT`** criar a sessão interativa.
|
||||
|
||||
Se a variável de ambiente **`PYTHONINSPECT`** estiver definida, o processo Python entrará em um cli Python assim que terminar. Também é possível usar **`PYTHONSTARTUP`** para indicar um script Python a ser executado no início de uma sessão interativa.\
|
||||
No entanto, observe que o script **`PYTHONSTARTUP`** não será executado quando o **`PYTHONINSPECT`** cria a sessão interativa.
|
||||
Outras variáveis de ambiente como **`PYTHONPATH`** e **`PYTHONHOME`** também podem ser úteis para fazer um comando python executar código arbitrário.
|
||||
|
||||
Outras variáveis de ambiente, como **`PYTHONPATH`** e **`PYTHONHOME`**, também podem ser úteis para fazer um comando Python executar código arbitrário.
|
||||
Observe que executáveis compilados com **`pyinstaller`** não usarão essas variáveis ambientais, mesmo que estejam sendo executados usando um python incorporado.
|
||||
|
||||
Observe que executáveis compilados com **`pyinstaller`** não usarão essas variáveis ambientais, mesmo que estejam sendo executados usando um Python incorporado.
|
||||
|
||||
No geral, não consegui encontrar uma maneira de fazer o Python executar código arbitrário abusando de variáveis de ambiente.\ No entanto, a maioria das pessoas instala o Python usando o \*\*Hombrew\*\*, que instalará o Python em um \*\*local gravável\*\* para o usuário administrador padrão. Você pode se apropriar disso com algo como: \`\`\`bash mv /opt/homebrew/bin/python3 /opt/homebrew/bin/python3.old cat > /opt/homebrew/bin/python3 <
|
||||
{% hint style="danger" %}
|
||||
No geral, não consegui encontrar uma maneira de fazer o python executar código arbitrário abusando de variáveis de ambiente.\
|
||||
No entanto, a maioria das pessoas instala o python usando o **Hombrew**, que instalará o python em um **local gravável** para o usuário administrador padrão. Você pode sequestrá-lo com algo como:
|
||||
```bash
|
||||
mv /opt/homebrew/bin/python3 /opt/homebrew/bin/python3.old
|
||||
cat > /opt/homebrew/bin/python3 <<EOF
|
||||
#!/bin/bash
|
||||
# Extra hijack code
|
||||
/opt/homebrew/bin/python3.old "$@"
|
||||
EOF
|
||||
chmod +x /opt/homebrew/bin/python3
|
||||
```
|
||||
Até mesmo **root** executará este código ao executar python.
|
||||
{% endhint %}
|
||||
|
||||
## Detecção
|
||||
|
||||
|
|
@ -116,15 +266,15 @@ No geral, não consegui encontrar uma maneira de fazer o Python executar código
|
|||
[**Shield**](https://theevilbit.github.io/shield/) ([**Github**](https://github.com/theevilbit/Shield)) é um aplicativo de código aberto que pode **detectar e bloquear ações de injeção de processo**:
|
||||
|
||||
* Usando **Variáveis Ambientais**: Ele monitorará a presença de qualquer uma das seguintes variáveis ambientais: **`DYLD_INSERT_LIBRARIES`**, **`CFNETWORK_LIBRARY_PATH`**, **`RAWCAMERA_BUNDLE_PATH`** e **`ELECTRON_RUN_AS_NODE`**
|
||||
* Usando chamadas de **`task_for_pid`**: Para encontrar quando um processo deseja obter a **porta de tarefa de outro**, o que permite injetar código no processo.
|
||||
* Usando chamadas de **`task_for_pid`**: Para encontrar quando um processo deseja obter a **porta de tarefa de outro** o que permite injetar código no processo.
|
||||
* Parâmetros de aplicativos **Electron**: Alguém pode usar os argumentos de linha de comando **`--inspect`**, **`--inspect-brk`** e **`--remote-debugging-port`** para iniciar um aplicativo Electron no modo de depuração e, assim, injetar código nele.
|
||||
* Usando **links simbólicos** ou **hardlinks**: Tipicamente, o abuso mais comum é **colocar um link com nossos privilégios de usuário** e **apontá-lo para uma localização de privilégio superior**. A detecção é muito simples para ambos, hardlinks e links simbólicos. Se o processo que cria o link tiver um **nível de privilégio diferente** do arquivo de destino, criamos um **alerta**. Infelizmente, no caso de links simbólicos, o bloqueio não é possível, pois não temos informações sobre o destino do link antes da criação. Esta é uma limitação do framework EndpointSecuriy da Apple.
|
||||
* Usando **links simbólicos** ou **hardlinks**: Tipicamente, o abuso mais comum é **colocar um link com nossos privilégios de usuário** e **apontá-lo para uma localização de privilégio mais alto**. A detecção é muito simples para ambos, hardlinks e links simbólicos. Se o processo que cria o link tiver um **nível de privilégio diferente** do arquivo de destino, criamos um **alerta**. Infelizmente, no caso de links simbólicos, o bloqueio não é possível, pois não temos informações sobre o destino do link antes da criação. Esta é uma limitação do framework de EndpointSecuriy da Apple.
|
||||
|
||||
### Chamadas feitas por outros processos
|
||||
|
||||
Neste [**post do blog**](https://knight.sc/reverse%20engineering/2019/04/15/detecting-task-modifications.html), você pode encontrar como é possível usar a função **`task_name_for_pid`** para obter informações sobre outros **processos injetando código em um processo** e, em seguida, obter informações sobre esse outro processo.
|
||||
Neste [**post do blog**](https://knight.sc/reverse%20engineering/2019/04/15/detecting-task-modifications.html) você pode encontrar como é possível usar a função **`task_name_for_pid`** para obter informações sobre outros **processos injetando código em um processo** e então obter informações sobre esse outro processo.
|
||||
|
||||
Observe que para chamar essa função, você precisa ter **o mesmo uid** que o processo em execução ou ser **root** (e ela retorna informações sobre o processo, não uma maneira de injetar código).
|
||||
Observe que para chamar essa função você precisa ser **o mesmo uid** que está executando o processo ou **root** (e ela retorna informações sobre o processo, não uma maneira de injetar código).
|
||||
|
||||
## Referências
|
||||
|
||||
|
|
@ -137,8 +287,8 @@ Observe que para chamar essa função, você precisa ter **o mesmo uid** que o p
|
|||
|
||||
Outras maneiras de apoiar o HackTricks:
|
||||
|
||||
* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtenha o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe seus truques de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
|
|
|||
Loading…
Reference in a new issue