80,443 - Metodología de Pentesting Web

Tip

Aprende y practica Hacking en AWS:HackTricks Training AWS Red Team Expert (ARTE)
Aprende y practica Hacking en GCP: HackTricks Training GCP Red Team Expert (GRTE) Aprende y practica Hacking en Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Apoya a HackTricks

Información básica

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)

PORT    STATE SERVICE
80/tcp  open  http
443/tcp open  ssl/https

nc -v domain.com 80 # GET / HTTP/1.0
openssl s_client -connect domain.com:443 # GET / HTTP/1.0

Guía de Web API

Web API Pentesting

Resumen de la metodología

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 usadas por el servidor web. Busca trucos para tener en cuenta durante el resto de la prueba si logras identificar la tecnología.
  • ¿Alguna vulnerabilidad conocida de la versión de la tecnología?
  • ¿Se está 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 descubrir información interesante.
  • Comienza con las comprobaciones iniciales: robots, sitemap, error 404 y SSL/TLS scan (si HTTPS).
  • Comienza spidering de la página web: es hora de encontrar todos los posibles archivos, carpetas y parámetros que se están usando. Además, revisa si hay hallazgos especiales.
  • Ten en cuenta que cada vez que se descubra un nuevo directorio durante brute-forcing o spidering, debería ser spidered.
  • Directory Brute-Forcing: Intenta brute force todas las carpetas descubiertas buscando nuevos files y directories.
  • Ten en cuenta que cada vez que se descubra un nuevo directorio durante brute-forcing o spidering, debería ser Brute-Forced.
  • Backups checking: Comprueba si puedes encontrar backups de archivos descubiertos añadiendo extensiones de backup comunes.
  • Brute-Force parameters: Intenta encontrar parámetros ocultos.
  • Una vez que hayas identificado todos los posibles endpoints que aceptan input del usuario, comprueba todo tipo de vulnerabilidades relacionadas con ellos.
  • Sigue esta checklist

Server Version (¿Vulnerable?)

Identify

Comprueba si existen vulnerabilidades conocidas para la versión del servidor que está ejecutándose.
Los HTTP headers y cookies de la respuesta pueden ser muy útiles para identificar las tecnologías y/o versiones usadas. Un Nmap scan puede identificar la versión del servidor, pero también pueden ser útiles las herramientas whatweb, webtech o https://builtwith.com/:

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

Comprobar si hay algún WAF

Trucos de tecnologías web

Algunos trucos para encontrar vulnerabilidades en diferentes tecnologías bien conocidas que se estén usando:

Ten en cuenta que el mismo dominio puede estar usando diferentes tecnologías en distintos puertos, carpetas y subdominios.
Si la aplicación web está usando alguna de las tecnologías/plataformas mencionadas antes o cualquier otra, no olvides buscar en Internet nuevos trucos (¡y avísame!).

Revisión del código fuente

Si el source code de la aplicación está disponible en github, además de realizar por tu cuenta un White box test de la aplicación, hay información que podría ser útil para el actual Black-Box testing:

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

Source code Review / SAST Tools

Automatic scanners

General purpose automatic scanners

nikto -h <URL>
whatweb -a 4 <URL>
wapiti -u <URL>
W3af
zaproxy #You can use an API
nuclei -ut && nuclei -target <URL>

# https://github.com/ignis-sec/puff (client side vulns fuzzer)
node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi2rVUN/?query=FUZZ"

CMS scanners

Si se usa un CMS, no olvides ejecutar un scanner, quizá se encuentre algo jugoso:

Clusterd: JBoss, ColdFusion, WebLogic, Tomcat, Railo, Axis2, Glassfish
CMSScan: WordPress, Drupal, Joomla, vBulletin sitios web para detectar problemas de seguridad. (GUI)
VulnX: Joomla, Wordpress, Drupal, PrestaShop, Opencart
CMSMap: (W)ordpress, (J)oomla, (D)rupal o (M)oodle
droopscan: Drupal, Joomla, Moodle, Silverstripe, Wordpress

cmsmap [-f W] -F -d <URL>
wpscan --force update -e --url <URL>
joomscan --ec -u <URL>
joomlavs.rb #https://github.com/rastating/joomlavs

En este punto ya deberías tener cierta información del servidor web que está usando 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 scanner.

Descubrimiento paso a paso de la Aplicación Web

A partir de este punto vamos a empezar a interactuar con la aplicación web.

Comprobaciones iniciales

Páginas por defecto con información interesante:

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

Forzar errores

Los servidores web pueden comportarse de forma inesperada cuando se les envían datos raros. Esto puede abrir vulnerabilidades o revelar información sensible.

  • Accede a fake pages como /whatever_fake.php (.aspx,.html,.etc)
  • Add “[]”, “]]”, and “[[” in cookie values and parameter values to create errors
  • Genera un error dando la entrada como /~randomthing/%s al final de la URL
  • Prueba different HTTP Verbs como PATCH, DEBUG o incluso incorrectos como FAKE

Comprueba si puedes subir archivos (PUT verb, WebDav)

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

  • Brute Force credentials
  • Sube archivos vía WebDav al resto de las carpetas encontradas dentro de la página web. Puede que tengas permisos para subir archivos en otras carpetas.

Vulnerabilidades SSL/TLS

  • 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 alta.

Usa testssl.sh para comprobar vulnerabilidades (En los programas Bug Bounty probablemente este tipo de vulnerabilidades no serán aceptadas) y usa a2sv to recheck the vulnerabilities:

./testssl.sh [--htmlfile] 10.10.10.10:443
#Use the --htmlfile to save the output inside an htmlfile also

# You can also use other tools, by testssl.sh at this momment is the best one (I think)
sslscan <host:port>
sslyze --regular <ip:port>

Información sobre vulnerabilidades SSL/TLS:

Spidering

Lanza algún tipo de spider dentro del sitio web. El objetivo del spider es find as much paths as possible desde la aplicación probada. Por lo tanto, se debe usar web crawling y fuentes externas para encontrar la mayor cantidad posible de paths válidos.

  • gospider (go): HTML spider, LinkFinder in JS files and fuentes externas (Archive.org, CommonCrawl.org, VirusTotal.com).
  • hakrawler (go): HML spider, with LinkFider for JS files and Archive.org as external source.
  • dirhunt (python): HTML spider, también indica “juicy files”.
  • evine (go): Interactive CLI HTML spider. It also searches in Archive.org
  • meg (go): This tool isn’t a spider but it can be useful. You can just indicate a file with hosts and a file with paths and meg will fetch each path on each host and save the response.
  • urlgrab (go): HTML spider with JS rendering capabilities. However, it looks like it’s unmaintained, the precompiled version is old and the current code doesn’t compile
  • gau (go): HTML spider that uses external providers (wayback, otx, commoncrawl)
  • ParamSpider: This script will find URLs with parameter and will list them.
  • galer (go): HTML spider with JS rendering capabilities.
  • LinkFinder (python): HTML spider, with JS beautify capabilities capable of search new paths in JS files. It could be worth it also take a look to JSScanner, which is a wrapper of LinkFinder.
  • goLinkFinder (go): To extract endpoints in both HTML source and embedded javascript files. Useful for bug hunters, red teamers, infosec ninjas.
  • JSParser (python2.7): A python 2.7 script using Tornado and JSBeautifier to parse relative URLs from JavaScript files. Useful for easily discovering AJAX requests. Looks like unmaintained.
  • relative-url-extractor (ruby): Given a file (HTML) it will extract URLs from it using nifty regular expression to find and extract the relative URLs from ugly (minify) files.
  • JSFScan (bash, several tools): Gather interesting information from JS files using several tools.
  • subjs (go): Find JS files.
  • page-fetch (go): Load a page in a headless browser and print out all the urls loaded to load the page.
  • Feroxbuster (rust): Content discovery tool mixing several options of the previous tools
  • Javascript Parsing: A Burp extension to find path and params in JS files.
  • BurpJSLinkFinder Enhanced: Burp extension (Jython) that passively analyzes JavaScript responses (by MIME type and /js paths) to extract endpoints/links and optionally flag embedded secrets with severity.
  • Sourcemapper: A tool that given the .js.map URL will get you the beatified JS code
  • xnLinkFinder: This is a tool used to discover endpoints for a given target.
  • waymore: Discover links from the wayback machine (also downloading the responses in the wayback and looking for more links)
  • HTTPLoot (go): Crawl (even by filling forms) and also find sensitive info using specific regexes.
  • SpiderSuite: Spider Suite is an advance multi-feature GUI web security Crawler/Spider designed for cyber security professionals.
  • jsluice (go): It’s a Go package and command-line tool for extracting URLs, paths, secrets, and other interesting data from JavaScript source code.
  • ParaForge: ParaForge is a simple Burp Suite extension to extract the paramters and endpoints from the request to create custom wordlist for fuzzing and enumeration.
  • katana (go): Awesome tool for this.
  • Crawley (go): Print every link it’s able to find.

Brute Force directorios y archivos

Start brute-forcing desde la carpeta raíz y asegúrate de brute-force all the directories found usando this method y todos los directorios discovered por el Spidering (puedes hacer este brute-forcing recursivamente y anteponer al inicio de la wordlist usada los nombres de los directorios encontrados).
Tools:

  • 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 (python): It doesn’t allow auto-signed certificates but allows recursive search.
  • Gobuster (go): It allows auto-signed certificates, it doesn’t have recursive search.
  • Feroxbuster - Fast, supports recursive search.
  • wfuzz wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ
  • ffuf - Fast: ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ
  • uro (python): This isn’t a spider but a tool that given the list of found URLs will to delete “duplicated” URLs.
  • Scavenger: Burp Extension to create a list of directories from the burp history of different pages
  • TrashCompactor: Remove URLs with duplicated functionalities (based on js imports)
  • Chamaleon: It uses wapalyzer to detect used technologies and select the wordlists to use.

Recommended dictionaries:

Note that anytime a new directory is discovered during brute-forcing or spidering, it should be Brute-Forced.

What to check on each file found

Special findings

While performing the spidering and brute-forcing you could find interesting things that you have to notice.

Interesting files

403 Forbidden/Basic Authentication/401 Unauthorized (bypass)

403 & 401 Bypasses

502 Proxy Error

If any page responds with that code, it’s probably a bad configured proxy. If you send a HTTP request like: GET https://google.com HTTP/1.1 (with the host header and other common headers), the proxy will try to access google.com and you will have found a SSRF.

NTLM Authentication - Info disclosure

If the running server asking for authentication is Windows or you find a login asking for your credentials (and asking for domain name), you can provoke an information disclosure.
Send the header: “Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=” and due to how the NTLM authentication works, the server will respond with internal info (IIS version, Windows version…) inside the header “WWW-Authenticate”.
You can automate this using the nmap plugin “http-ntlm-info.nse”.

HTTP Redirect (CTF)

It is possible to put content inside a Redirection. This content won’t be shown to the user (as the browser will execute the redirection) but something could be hidden in there.

Web Vulnerabilities Checking

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:

Web Vulnerabilities Methodology

Find more info about web vulns in:

Monitor Pages for changes

You can use tools such as https://github.com/dgtlmoon/changedetection.io to monitor pages for modifications that might insert vulnerabilities.

HackTricks Automatic Commands

HackTricks Automatic Commands ```yaml Protocol_Name: Web #Protocol Abbreviation if there is one. Port_Number: 80,443 #Comma separated if there is more than one. Protocol_Description: Web #Protocol Abbreviation Spelled out

Entry_1: Name: Notes Description: Notes for Web Note: | https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/index.html

Entry_2: Name: Quick Web Scan Description: Nikto and GoBuster Command: nikto -host {Web_Proto}://{IP}:{Web_Port} &&&& gobuster dir -w {Small_Dirlist} -u {Web_Proto}://{IP}:{Web_Port} && gobuster dir -w {Big_Dirlist} -u {Web_Proto}://{IP}:{Web_Port}

Entry_3: Name: Nikto Description: Basic Site Info via Nikto Command: nikto -host {Web_Proto}://{IP}:{Web_Port}

Entry_4: Name: WhatWeb Description: General purpose auto scanner Command: whatweb -a 4 {IP}

Entry_5: Name: Directory Brute Force Non-Recursive Description: Non-Recursive Directory Brute Force Command: gobuster dir -w {Big_Dirlist} -u {Web_Proto}://{IP}:{Web_Port}

Entry_6: Name: Directory Brute Force Recursive Description: Recursive Directory Brute Force Command: python3 {Tool_Dir}dirsearch/dirsearch.py -w {Small_Dirlist} -e php,exe,sh,py,html,pl -f -t 20 -u {Web_Proto}://{IP}:{Web_Port} -r 10

Entry_7: Name: Directory Brute Force CGI Description: Common Gateway Interface Brute Force Command: gobuster dir -u {Web_Proto}://{IP}:{Web_Port}/ -w /usr/share/seclists/Discovery/Web-Content/CGIs.txt -s 200

Entry_8: Name: Nmap Web Vuln Scan Description: Tailored Nmap Scan for web Vulnerabilities Command: nmap -vv –reason -Pn -sV -p {Web_Port} –script=banner,(http* or ssl*) and not (brute or broadcast or dos or external or http-slowloris* or fuzzer) {IP}

Entry_9: Name: Drupal Description: Drupal Enumeration Notes Note: | git clone https://github.com/immunIT/drupwn.git for low hanging fruit and git clone https://github.com/droope/droopescan.git for deeper enumeration

Entry_10: Name: WordPress Description: WordPress Enumeration with WPScan Command: | ?What is the location of the wp-login.php? Example: /Yeet/cannon/wp-login.php wpscan –url {Web_Proto}://{IP}{1} –enumerate ap,at,cb,dbe && wpscan –url {Web_Proto}://{IP}{1} –enumerate u,tt,t,vp –passwords {Big_Passwordlist} -e

Entry_11: Name: WordPress Hydra Brute Force Description: Need User (admin is default) Command: hydra -l admin -P {Big_Passwordlist} {IP} -V http-form-post ‘/wp-login.php:log=^USER^&pwd=^PASS^&wp-submit=Log In&testcookie=1:S=Location’

Entry_12: Name: Ffuf Vhost Description: Simple Scan with Ffuf for discovering additional vhosts Command: ffuf -w {Subdomain_List}:FUZZ -u {Web_Proto}://{Domain_Name} -H “Host:FUZZ.{Domain_Name}” -c -mc all {Ffuf_Filters}

</details>

## Referencias

- [https://github.com/panchocosil/burp-js-linkfinder-enhanced](https://github.com/panchocosil/burp-js-linkfinder-enhanced)

> [!TIP]
> Aprende y practica Hacking en AWS:<img src="../../../../../images/arte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../../../images/arte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">\
> Aprende y practica Hacking en GCP: <img src="../../../../../images/grte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">[**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte)<img src="../../../../../images/grte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">
> Aprende y practica Hacking en Azure: <img src="../../../../../images/azrte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">[**HackTricks Training Azure Red Team Expert (AzRTE)**](https://training.hacktricks.xyz/courses/azrte)<img src="../../../../../images/azrte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">
>
> <details>
>
> <summary>Apoya a HackTricks</summary>
>
> - Revisa los [**planes de suscripción**](https://github.com/sponsors/carlospolop)!
> - **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos en** **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
> - **Comparte trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositorios de github.
>
> </details>