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

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)

bash
PORT    STATE SERVICE
80/tcp  open  http
443/tcp open  ssl/https
bash
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 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/:

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

Comprobar si hay algún WAF

Trucos de tecnología web

Algunos trucos para finding vulnerabilities en diferentes bien conocidas technologies que se estén usando:

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

bash
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

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

bash
./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:

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:

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

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

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