80,443 - Metodología de Pentesting Web
Reading time: 20 minutes
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
- Revisa los planes de suscripción!
- Únete al 💬 grupo de Discord o al grupo de telegram o síguenos en Twitter 🐦 @hacktricks_live.
- Comparte trucos de hacking enviando PRs a los HackTricks y HackTricks Cloud repositorios de github.
Información Básica
El servicio web es el servicio más común y extenso y existen muchos diferentes tipos 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
Resumen de la metodología
En esta metodología vamos a suponer que vas a atacar un dominio (o subdominio) y solo ese. Por tanto, debes aplicar esta metodología a cada dominio, subdominio o IP descubierto con servidor web indeterminado dentro del alcance.
- Comienza por identificar las tecnologías usadas por el servidor web. Busca trucos que debas 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?
- ¿Usando alguna well known tech? ¿Algún useful trick 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 si van a revelar información interesante.
- Comienza con las initial checks: robots, sitemap, 404 error y SSL/TLS scan (si HTTPS).
- Comienza con spidering de la web: es tiempo de encontrar todos los posibles files, folders y parameters being used. También, revisa special findings.
- 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 files y directories.
- 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 discovered files añadiendo extensiones de backup comunes.
- Brute-Force parameters: Intenta encontrar hidden parameters.
- Una vez que hayas identificado todos los posibles endpoints que aceptan user input, revisa todo tipo de vulnerabilidades relacionadas con ellos.
- Sigue esta lista de verificación
Server Version (Vulnerable?)
Identificar
Comprueba si existen vulnerabilidades conocidas para la versión del servidor que se está ejecutando.
Las cabeceras HTTP y cookies de la respuesta pueden ser muy útiles para identificar las tecnologías y/o la versión que se está usando. Nmap scan puede identificar la versión del servidor, pero también pueden ser útiles herramientas como 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
- https://github.com/EnableSecurity/wafw00f
- https://github.com/Ekultek/WhatWaf.git
- https://nmap.org/nsedoc/scripts/http-waf-detect.html
Trucos de tecnología web
Algunos trucos para finding vulnerabilities en diferentes bien conocidas technologies que se estén usando:
- AEM - Adobe Experience Cloud
- Apache
- Artifactory
- Buckets
- CGI
- Drupal
- Flask
- Git
- Golang
- GraphQL
- H2 - Java SQL database
- ISPConfig
- IIS tricks
- Microsoft SharePoint
- JBOSS
- Jenkins
- Jira
- Joomla
- JSP
- Laravel
- Moodle
- Nginx
- PHP (php has a lot of interesting tricks that could be exploited)
- Python
- Spring Actuators
- Symphony
- Tomcat
- VMWare
- Web API Pentesting
- WebDav
- Werkzeug
- Wordpress
- Electron Desktop (XSS to RCE)
- Sitecore
- Zabbix
Ten en cuenta que el same domain puede estar usando different technologies en distintos ports, folders y subdomains.
Si la aplicación web está usando alguna tech/platform listed before o any other, no olvides buscar en Internet nuevos trucos (¡y avísame!).
Revisión de código fuente
Si el source code de la aplicación está disponible en github, aparte de realizar por tu cuenta un White box test de la aplicación, hay some information que podría ser useful para la actual Black-Box testing:
- ¿Existe algún Change-log or Readme or Version file o cualquier cosa con version info accessible vía web?
- ¿Cómo y dónde se guardan las credentials? ¿Hay algún (accessible?) file con credenciales (usernames o passwords)?
- ¿Los passwords están en plain text, encrypted o qué hashing algorithm se usa?
- ¿Está usando alguna master key para encriptar 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) issues? ¿O en commit history (quizás algún 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 utiliza 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 en busca de 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 algo de información sobre el servidor web que usa el cliente (si se proporcionó 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/
- Comprueba 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 provocar la divulgación de información sensible.
- Accede a páginas falsas como /whatever_fake.php (.aspx,.html,.etc)
- Añade "[]", "]]" y "[[" en los valores de cookies y valores de parámetros para provocar errores
- Genera un error introduciendo
/~randomthing/%s
al final de la URL - Prueba diferentes HTTP Verbs como PATCH, DEBUG o incluso incorrectos como FAKE
Comprueba si puedes subir archivos (PUT verb, WebDav)
Si descubres que WebDav está habilitado pero no tienes permisos suficientes para subir archivos en la carpeta raíz, intenta:
- Realiza Brute Force contra las credenciales
- Sube archivos vía WebDav a las restantes 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 fuerza el uso de HTTPS en ninguna parte, entonces es vulnerable a MitM
- Si la aplicación envía datos sensibles (contraseñas) usando HTTP. Entonces es una vulnerabilidad grave.
Usa testssl.sh para comprobar vulnerabilidades (En programas de Bug Bounty probablemente este tipo de vulnerabilidades no serán aceptadas) y usa a2sv para volver a comprobar las vulnerabilidades:
./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>
Information about SSL/TLS vulnerabilities:
- https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/
- https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/
Spidering
Lanza algún tipo de spider dentro del web. El objetivo del spider es encontrar la mayor cantidad de rutas posible de la aplicación testeada. Por lo tanto, se debe usar web crawling y fuentes externas 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 interactivo 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 descargará cada path en cada host y guardará la respuesta.
- urlgrab (go): HTML spider con capacidades de renderizado JS. Sin embargo, parece no mantenerse, la versión precompilada es vieja 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 vale 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 mantenerse.
- relative-url-extractor (ruby): Dado un archivo (HTML) extraerá URLs usando una expresión regular ingeniosa para encontrar y extraer URLs relativas de archivos ofuscados/minificados.
- 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 mostrar la página.
- Feroxbuster (rust): Herramienta de content discovery mezclando 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 links desde the wayback machine (también descarga las respuestas en el wayback y busca más links).
- HTTPLoot (go): Crawl (incluso rellenando forms) y además encuentra información sensible usando regexes específicas.
- SpiderSuite: Spider Suite es un crawler/spider GUI avanzado multi-feature diseñado para profesionales de ciberseguridad.
- jsluice (go): Es un paquete Go y una herramienta de línea de comandos 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 parámetros y endpoints de las requests para crear wordlists personalizadas para fuzzing y enumeración.
- katana (go): Excelente herramienta para esto.
- Crawley (go): Imprime cada link que es capaz de encontrar.
Brute Force directories and files
Empieza brute-forcing desde la carpeta raíz y asegúrate de brute-forcear todos los directorios encontrados usando este método y todos los directorios descubiertos por el Spidering (puedes hacer este brute-forcing recursivamente y anteponer al principio de la wordlist usada los nombres de los directorios encontrados).
Herramientas:
- Dirb / Dirbuster - Incluidos en Kali, viejos (y lentos) pero funcionales. Permiten certificados auto-firmados y búsqueda recursiva. Demasiado lentos comparados con otras opciones.
- Dirsearch (python): No permite certificados auto-firmados pero permite búsqueda recursiva.
- Gobuster (go): Permite certificados auto-firmados, no tiene búsqueda recursiva.
- Feroxbuster - Rápido, soporta búsqueda recursiva.
- wfuzz
wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ
- ffuf - Rápido:
ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ
- uro (python): Esto no es un spider sino una herramienta que, dada la lista de URLs encontradas, elimina URLs "duplicadas".
- Scavenger: Burp Extension para crear una lista de directorios desde el burp history de diferentes páginas.
- TrashCompactor: Elimina URLs con funcionalidades duplicadas (basado en imports JS).
- Chamaleon: Usa wapalyzer para detectar tecnologías usadas y seleccionar las wordlists a usar.
Diccionarios recomendados:
- https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt
- Dirsearch included dictionary
- http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10
- Assetnote wordlists
- https://github.com/danielmiessler/SecLists/tree/master/Discovery/Web-Content
- raft-large-directories-lowercase.txt
- directory-list-2.3-medium.txt
- RobotsDisallowed/top10000.txt
- https://github.com/random-robbie/bruteforce-lists
- https://github.com/google/fuzzing/tree/master/dictionaries
- https://github.com/six2dez/OneListForAll
- https://github.com/random-robbie/bruteforce-lists
- https://github.com/ayoubfathi/leaky-paths
- https://github.com/danielmiessler/SecLists/tree/master/Discovery/Web-Content
- /usr/share/wordlists/dirb/common.txt
- /usr/share/wordlists/dirb/big.txt
- /usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt
Ten en cuenta que cada vez que se descubre un nuevo directorio durante brute-forcing o spidering, debe ser Brute-Forced.
What to check on each file found
- Broken link checker: Encuentra links rotos dentro de HTMLs que pueden ser susceptibles a takeovers.
- File Backups: Una vez que has encontrado 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 y 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 credenciales o funcionalidad oculta.
- Si estás en 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 en la parte inferior 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 empieza por AIzaSyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik puedes usar el proyecto gmapapiscanner para comprobar qué APIs puede acceder 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.
Special findings
Mientras realizas el spidering y el brute-forcing podrías encontrar cosas interesantes que debes tener en cuenta.
Archivos interesantes
- Busca links a otros archivos dentro de los archivos CSS.
- Si encuentras un .git se puede extraer algo de información
- Si encuentras un .env se pueden encontrar información como api keys, contraseñas de bases de datos y otra información.
- Si encuentras API endpoints deberías también testearlos. Estos no son archivos, pero probablemente "parecerán" archivos.
- JS files: En la sección de spidering se mencionaron varias herramientas que pueden extraer paths de archivos JS. Además, sería interesante monitorizar cada archivo JS encontrado, ya que en algunas ocasiones, un cambio puede indicar que se ha introducido una potencial vulnerabilidad en el código. Por ejemplo podrías usar JSMon.
- También deberías revisar los JS descubiertos con RetireJS o JSHole para ver si son vulnerables.
- Javascript Deobfuscator and Unpacker: https://lelinhtinh.github.io/de4js/, https://www.dcode.fr/javascript-unobfuscator
- Javascript Beautifier: http://jsbeautifier.org/, http://jsnice.org/
- JsFuck deobfuscation (javascript con chars:"[]!+" 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 usadas. Esto será útil: https://regex101.com/ o https://pythonium.net/regex
- También podrías monitorizar los archivos donde se detectaron forms, ya que un cambio en los parámetros o la aparición de un nuevo form puede indicar una nueva funcionalidad potencialmente vulnerable.
403 Forbidden/Basic Authentication/401 Unauthorized (bypass)
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 pide autenticación está corriendo en Windows o encuentras un login pidiendo tus credenciales (y solicitando el 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 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 nmap plugin "http-ntlm-info.nse".
HTTP Redirect (CTF)
Es posible poner contenido dentro de una Redirection. Este contenido no será mostrado al usuario (ya que el navegador ejecutará la redirección) pero algo podría estar oculto ahí.
Web Vulnerabilities Checking
Ahora que se ha realizado una enumeración completa de la aplicación web, es hora de comprobar un gran número de posibles vulnerabilidades. Puedes encontrar el checklist aquí:
Web Vulnerabilities Methodology
Encuentra más info sobre web vulns en:
- 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://owasp-skf.gitbook.io/asvs-write-ups/kbid-111-client-side-template-injection
Monitor Pages for changes
Puedes usar herramientas como https://github.com/dgtlmoon/changedetection.io para monitorizar páginas por modificaciones que puedan introducir vulnerabilidades.
HackTricks Automatic Commands
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}
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
- Revisa los planes de suscripción!
- Únete al 💬 grupo de Discord o al grupo de telegram o síguenos en Twitter 🐦 @hacktricks_live.
- Comparte trucos de hacking enviando PRs a los HackTricks y HackTricks Cloud repositorios de github.