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 amplio y existen muchos tipos diferentes 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 API Web

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 no determinado dentro del alcance.

  • Comienza por identificar las tecnologías que usa el servidor web. Busca trucos que puedas 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?
  • ¿Se está usando alguna tecnología conocida? ¿Algún truco útil para extraer más información?
  • ¿Algún scanner especializado que ejecutar (como wpscan)?
  • Lanza scanners de propósito general. Nunca sabes si van a encontrar algo o si van a devolver información interesante.
  • Empieza con las comprobaciones iniciales: robots, sitemap, error 404 y SSL/TLS scan (si HTTPS).
  • Comienza a spidering la página web: es hora de encontrar todos los posibles ficheros, carpetas y parámetros usados. Además, busca hallazgos especiales.
  • Ten en cuenta que cada vez que se descubra un nuevo directorio durante brute-forcing o spidering, debe ser spidered.
  • Directory Brute-Forcing: Intenta brute forcear todas las carpetas descubiertas buscando nuevos ficheros y directorios.
  • Ten en cuenta que cada vez que se descubra un nuevo directorio durante brute-forcing o spidering, debe ser Brute-Forced.
  • Backups checking: Comprueba si puedes encontrar backups de los ficheros descubiertos añadiendo extensiones de backup comunes.
  • Brute-Force parameters: Intenta encontrar parámetros ocultos.
  • Una vez hayas identificado todos los posibles endpoints que aceptan user input, comprueba todo tipo de vulnerabilidades relacionadas.
  • Sigue esta checklist

Versión del servidor (¿Vulnerable?)

Identificar

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 la versión que se está usando. Un Nmap scan puede identificar la versión del servidor, pero también pueden resultar ú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

Buscar por vulnerabilities of the web application version

Comprobar si hay algún WAF

Trucos de tecnologías Web

Algunos tricks para finding vulnerabilities en diferentes bien conocidas technologies que se están usando:

Ten en cuenta que el mismo dominio puede estar usando diferentes technologies en distintos puertos, carpetas y subdominios.
Si la web application está usando alguna well known tech/platform listed before o any other, no olvides search on the Internet nuevos tricks (¡y avísame!).

Revisión de 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 algunas informaciones que podrían ser útiles para la actual Black-Box testing:

  • ¿Existe un 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 credentials (usernames o passwords)?
  • ¿Los 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 acceder a alguno de estos files explotando alguna vulnerabilidad?
  • ¿Hay alguna información interesante en los github issues (resueltos o no)? ¿O en el commit history (quizá algún password introducido en un commit antiguo)?

Source code Review / SAST Tools

Automatic scanners

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 escáner, quizá encuentres 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

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 utilizado por el cliente (si se proporcionó 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 paso a paso de la aplicación web

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

Verificaciones iniciales

Páginas por defecto con información interesante:

  • /robots.txt
  • /sitemap.xml
  • /crossdomain.xml
  • /clientaccesspolicy.xml
  • /.well-known/
  • Check also comments in the main and secondary pages.

Forzar errores

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

  • Accede a páginas falsas como /whatever_fake.php (.aspx,.html,.etc)
  • Agrega "[]", "]]", and "[[" en cookie values y parameter values para crear errores
  • Genera un error dando como input /~randomthing/%s al final de la URL
  • Prueba different HTTP Verbs como PATCH, DEBUG o inválidos como FAKE

Comprueba si puedes subir archivos (PUT verb, WebDav)

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

  • Brute Force credenciales
  • Upload files vía WebDav al rest de los found folders dentro de la página web. Puede que tengas permisos para upload files 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 alta.

Usa testssl.sh para comprobar vulnerabilidades (En Bug Bounty programs 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>

Información sobre vulnerabilidades de SSL/TLS:

Spidering

Lanza algún tipo de spider dentro del sitio web. 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 tantas rutas válidas como sea posible.

  • gospider (go): HTML spider, LinkFinder en archivos JS y fuentes externas (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
  • hakrawler (go): HML spider, con LinkFider para archivos JS y Archive.org como fuente externa.
  • dirhunt (python): HTML spider, además 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 hará fetch de 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 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 puede valer la pena echar un vistazo a JSScanner, que es un wrapper de LinkFinder.
  • goLinkFinder (go): Para extraer endpoints tanto en el source HTML como en archivos javascript embebidos. Útil para bug hunters, red teamers, infosec ninjas.
  • JSParser (python2.7): Un script en python 2.7 que usa Tornado y JSBeautifier para parsear URLs relativas desde archivos JavaScript. Útil para descubrir fácilmente solicitudes AJAX. Parece no mantenerse.
  • relative-url-extractor (ruby): Dado un archivo (HTML) extraerá URLs usando expresiones regulares ingeniosas para encontrar y extraer las URLs relativas de archivos minificados.
  • JSFScan (bash, varias herramientas): Recopila 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 renderizar la página.
  • Feroxbuster (rust): Herramienta de descubrimiento de contenido 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 devolverá el código JS beautyfied.
  • xnLinkFinder: Herramienta para descubrir endpoints para un objetivo dado.
  • waymore: Descubre links desde la wayback machine (también descarga las respuestas en la wayback y busca más links).
  • HTTPLoot (go): Crawl (incluso rellenando forms) y también encuentra info sensible usando regexes específicas.
  • SpiderSuite: Spider Suite es un crawler/spider GUI multi-feature avanzado diseñado para profesionales de ciberseguridad.
  • jsluice (go): Es un package Go y 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

Comienza el brute-forcing desde la carpeta raíz y asegúrate de brute-force todas las rutas encontradas usando este método y todas las rutas descubiertas por el Spidering (puedes hacer este brute-forcing recursivamente y añadir al inicio de la wordlist usada los nombres de los directorios encontrados).
Herramientas:

  • Dirb / Dirbuster - Incluido en Kali, old (y slow) pero funcional. Permite certificados auto-firmados y búsqueda recursiva. Demasiado lento comparado 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 - 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): No es un spider pero es una herramienta que, dada la lista de URLs encontradas, eliminará las URLs "duplicadas".
  • Scavenger: Burp Extension para crear una lista de directorios a partir del histórico de Burp 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 descubra un nuevo directorio durante el brute-forcing o el spidering, debe ser Brute-Forced.

What to check on each file found

  • Broken link checker: Encontrar enlaces rotos dentro de HTMLs que pueden ser propensos 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 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 u ocultas funcionalidades.
  • 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 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 proyectos 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 empiece 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, revisa los permisos del bucket.

Special findings

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

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 solicita autenticación es Windows o encuentras un login solicitando tus credentials (y pidiendo el domain name), puedes provocar una info disclosure.
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 colocar 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 ahí.

Web Vulnerabilities Checking

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

Web Vulnerabilities Methodology

Más información sobre web vulns en:

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

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