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 amplio 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, deberías aplicar esta metodología a cada dominio, subdominio o IP descubierto con un servidor web indeterminado dentro del scope.

  • Empieza por identificar las tecnologías usadas por el servidor web. Busca trucos para tener en cuenta durante el resto de la prueba si consigues identificar la tecnología.
  • ¿Alguna vulnerabilidad conocida de la versión de la tecnología?
  • ¿Usando alguna tecnología conocida? ¿Algún truco útil para extraer más información?
  • ¿Algún scanner especializado para ejecutar (como wpscan)?
  • Lanza scanners de propósito general. Nunca sabes si van a encontrar algo o si van a descubrir información interesante.
  • Empieza con las comprobaciones iniciales: robots, sitemap, 404 error and SSL/TLS scan (if HTTPS).
  • Empieza a spidering la página web: Es hora de encontrar todos los posibles archivos, carpetas y parámetros que se están usando. También, revisa por 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 en 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 de backup comunes.
  • Brute-Force parameters: Intenta encontrar parámetros ocultos.
  • Una vez que hayas identificado todos los posibles endpoints que aceptan input de usuario, revisa todo tipo de vulnerabilidades relacionadas con ellos.
  • Sigue este checklist

Versión del servidor (¿Vulnerable?)

Identificar

Comprueba si existen vulnerabilidades conocidas para la versión del servidor que está corriendo.
Los HTTP headers and cookies of the response pueden ser muy útiles para identificar las tecnologías y/o la versión que se está usando. 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

Buscar por vulnerabilities of the web application version

Comprobar si hay algún WAF

Trucos de tecnología web

Algunos trucos para finding vulnerabilities en diferentes y bien conocidas technologies 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 tech/platform listed before o cualquier otra conocida, no olvides search on the Internet nuevos trucos (¡y avísame!).

Source Code Review

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, existe información que podría ser útil para la actual Black-Box testing:

  • ¿Existe un archivo Change-log or Readme or Version o cualquier cosa con version info accessible vía web?
  • ¿Cómo y dónde se guardan las credentials? ¿Hay algún (¿accesible?) file con credentials (usernames o passwords)?
  • ¿Las passwords están en plain text, encrypted o qué hashing algorithm se usa?
  • ¿Está usando alguna master key para cifrar algo? ¿Qué algorithm se usa?
  • ¿Puedes access any of these files explotando alguna vulnerabilidad?
  • ¿Hay alguna interesting information in the github (solved and not solved) en issues? ¿O en el commit history (quizá alguna password introduced inside an old commit)?

Source code Review / SAST Tools

Escáneres automáticos

Escáneres automáticos de propósito general

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"

Escáneres de CMS

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 Security issues. (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 alguna información del 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 has encontrado un CMS y ejecutado algún scanner.

Descubrimiento de aplicaciones web paso a paso

A partir de aquí 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.

Provocar errores

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

  • Accede a páginas falsas como /whatever_fake.php (.aspx,.html,.etc)
  • Añade “[]”, “]]”, y “[[” en los cookie values y parameter values para crear errores
  • Genera un error dando como entrada /~randomthing/%s al final de la URL
  • Prueba different HTTP Verbs como PATCH, DEBUG o incorrectos como FAKE

Comprueba si puedes subir archivos (PUT verb, WebDav)

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

  • Brute Force las credenciales
  • 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 está forzando el 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 para comprobar vulnerabilidades (en 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 contra la web. El objetivo del spider es encontrar la mayor cantidad de rutas posible de la aplicación probada. Por lo tanto, web crawling y fuentes externas deben usarse para encontrar la mayor cantidad de rutas válidas posible.

  • gospider (go): HTML spider, LinkFinder en archivos JS y fuentes externas (Archive.org, CommonCrawl.org, VirusTotal.com).
  • hakrawler (go): HML spider, con LinkFider para archivos JS y Archive.org como fuente externa.
  • dirhunt (python): HTML spider, también indica “juicy files”.
  • evine (go): CLI interactiva HTML spider. También busca en Archive.org
  • 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 recuperará cada path en cada host y guardará la respuesta.
  • urlgrab (go): HTML spider con capacidades de renderizado JS. Sin embargo, parece que no se mantiene, la versión precompilada es antigua y el código actual no compila.
  • gau (go): HTML spider que usa proveedores externos (wayback, otx, commoncrawl)
  • ParamSpider: Este script encontrará URLs con parámetros y las listará.
  • galer (go): HTML spider con capacidades de renderizado JS.
  • LinkFinder (python): HTML spider, con capacidades de JS beautify capaz de buscar nuevas rutas en archivos JS. También podría valer la pena echar un vistazo a JSScanner, que es un wrapper de LinkFinder.
  • goLinkFinder (go): Para extraer endpoints tanto del source HTML como de archivos javascript embebidos. Útil para bug hunters, red teamers, infosec ninjas.
  • 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 requests AJAX. Parece no estar mantenido.
  • relative-url-extractor (ruby): Dado un archivo (HTML) extrae URLs usando expresiones regulares ingeniosas para encontrar y extraer URLs relativas de archivos feos (minify).
  • JSFScan (bash, varias herramientas): Recolecta información interesante de archivos JS usando varias herramientas.
  • subjs (go): Encuentra archivos JS.
  • page-fetch (go): Carga una página en un navegador headless e imprime todas las urls cargadas para cargar la página.
  • Feroxbuster (rust): Herramienta de content discovery que mezcla varias opciones de las herramientas anteriores.
  • Javascript Parsing: Una extensión de Burp para encontrar paths y params en archivos JS.
  • Sourcemapper: Una herramienta que, dada la URL .js.map, te obtiene el código JS beautified.
  • xnLinkFinder: Herramienta usada para descubrir endpoints para un target dado.
  • waymore: Descubre enlaces desde la wayback machine (también descargando las respuestas en la wayback y buscando más links).
  • HTTPLoot (go): Crawl (incluso rellenando forms) y además encuentra info sensible usando regexes específicas.
  • SpiderSuite: Spider Suite es un crawler/spider GUI avanzado multi-función diseñado para profesionales de ciberseguridad.
  • jsluice (go): Es un paquete Go y command-line tool para extraer URLs, paths, secrets y otros datos interesantes del código fuente JavaScript.
  • ParaForge: ParaForge es una simple Burp Suite extension para extraer los parameters y endpoints de las requests y crear wordlists personalizadas para fuzzing y enumeración.
  • katana (go): Herramienta excelente para esto.
  • Crawley (go): Imprime cada link que puede encontrar.

Brute Force directories and files

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 - 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

  • Broken link checker: Encontrar enlaces rotos dentro de los HTML que pueden ser susceptibles a takeovers.
  • File Backups: Una vez encontrados todos los archivos, busca backups de todos los archivos ejecutables (“.php”, “.aspx”…). Variaciones comunes para nombrar un backup 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 o backup-gen.
  • Discover new parameters: Puedes usar herramientas como Arjun, parameth, x8 y 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
  • Param-miner “params” : https://github.com/PortSwigger/param-miner/blob/master/resources/params
  • Assetnote “parameters_top_1m”: https://wordlists.assetnote.io/
  • nullenc0de “params.txt”: https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773
  • Comments: Revisa los comentarios de todos los archivos; puedes encontrar credentials o funcionalidades ocultas.
  • Si estás jugando un 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 source 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 guías que indican cómo usar API keys de diferentes plataformas: keyhacks, zile, truffleHog, SecretFinder, RegHex, DumpsterDive, EarlyBird
  • Google API keys: Si encuentras una API key que tiene este formato AIzaSyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik puedes usar el proyecto gmapapiscanner para comprobar a qué apis puede acceder la key.
  • S3 Buckets: Mientras haces spidering busca si algún subdominio o enlace está relacionado con algún S3 bucket. En ese caso, revisa los permisos del bucket.

Special findings

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

Interesting files

403 Forbidden/Basic Authentication/401 Unauthorized (bypass)

403 & 401 Bypasses

502 Proxy Error

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 que solicita autenticación es Windows o encuentras un login que pide tus credenciales (y pide el domain name), puedes provocar una divulgación de información.
Envía el header: “Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=” y debido a cómo funciona la NTLM authentication, 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 plugin de nmap “http-ntlm-info.nse”.

HTTP Redirect (CTF)

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

Web Vulnerabilities Checking

Ahora que se ha realizado una enumeración completa de la aplicación web es momento de comprobar muchas vulnerabilidades posibles. Puedes encontrar la checklist aquí:

Web Vulnerabilities Methodology

Find more info about web vulns in:

Monitor Pages for changes

Puedes usar herramientas como https://github.com/dgtlmoon/changedetection.io para monitorizar páginas en busca de modificaciones que puedan insertar vulnerabilidades.

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>

> [!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>