Español - Ht
HackTricks Training Twitter Linkedin Sponsor

80,443 - Pentesting Web Methodology

Apoya a HackTricks

Si estás interesado en una carrera de hacking y en hackear lo inhackeable - ¡estamos contratando! (se requiere polaco fluido escrito y hablado).

Información Básica

El servicio web es el 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 API Web

Web API Pentesting

Resumen de metodología

En esta metodología vamos a suponer que vas a atacar un dominio (o subdominio) y solo eso. Por lo tanto, debes aplicar esta metodología a cada dominio, subdominio o IP descubierta con servidor web indeterminado dentro del alcance.

Versión del servidor (¿Vulnerable?)

Identificar

Verifica si hay vulnerabilidades conocidas para la versión del servidor que se está ejecutando. Los encabezados HTTP y cookies de la respuesta podrían ser muy útiles para identificar las tecnologías y/o versión que se están utilizando. Un escaneo de Nmap puede identificar la versión del servidor, pero también podrían 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 vulnerabilidades de la aplicación web versión

Verificar si hay algún WAF

Trucos de tecnología web

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

Toma en cuenta que el mismo dominio puede estar utilizando diferentes tecnologías en diferentes puertos, carpetas y subdominios. Si la aplicación web está utilizando alguna tecnología/plataforma bien conocida listada anteriormente o cualquiera otra, no olvides buscar en Internet nuevos trucos (¡y házmelo saber!).

Revisión de código fuente

Si el código fuente de la aplicación está disponible en github, además de realizar por tu cuenta una prueba de caja blanca de la aplicación, hay alguna información que podría ser útil para la actual prueba de caja negra:

  • ¿Hay un Change-log o Readme o archivo de versión o algo con información de versión accesible a través de la web?

  • ¿Cómo y dónde se guardan las credenciales? ¿Hay algún (¿accesible?) archivo con credenciales (nombres de usuario o contraseñas)?

  • ¿Las contraseñas están en texto plano, encriptadas o qué algoritmo de hash se utiliza?

  • ¿Se está utilizando alguna clave maestra para encriptar algo? ¿Qué algoritmo se utiliza?

  • ¿Puedes acceder a alguno de estos archivos explotando alguna vulnerabilidad?

  • ¿Hay alguna información interesante en el github (problemas resueltos y no resueltos)? ¿O en el historial de commits (quizás alguna contraseña introducida dentro de un antiguo 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 escáner, tal vez se encuentre algo jugoso:

Clusterd: JBoss, ColdFusion, WebLogic, Tomcat, Railo, Axis2, Glassfish CMSScan: WordPress, Drupal, Joomla, vBulletin sitios web para 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 está utilizando el cliente (si se proporciona algún dato) y algunos trucos a tener en cuenta durante la prueba. Si tienes suerte, incluso has encontrado un CMS y has ejecutado algún escáner.

Descubrimiento de Aplicaciones Web Paso a Paso

A partir de este punto, comenzaremos a interactuar con la aplicación web.

Comprobaciones Iniciales

Páginas predeterminadas con información interesante:

  • /robots.txt

  • /sitemap.xml

  • /crossdomain.xml

  • /clientaccesspolicy.xml

  • /.well-known/

  • También revisa los comentarios en las páginas principales y secundarias.

Forzando errores

Los servidores web pueden comportarse de manera inesperada cuando se les envían 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 "[]", "]]" y "[[" en los valores de cookies y los valores de parámetros para crear errores

  • Genera un error dando entrada como /~randomthing/%s al final de la URL

  • Prueba diferentes verbos HTTP como PATCH, DEBUG o incorrectos como FAKE

Verifica si puedes subir archivos (verbo PUT, WebDav)

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

  • Fuerza Bruta de credenciales

  • Sube archivos a través de 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 al usuario a usar HTTPS en ninguna parte, entonces es vulnerable a MitM

  • Si la aplicación está enviando datos sensibles (contraseñas) usando HTTP. Entonces es una alta vulnerabilidad.

Usa testssl.sh para verificar vulnerabilidades (En programas de Bug Bounty, probablemente este tipo de vulnerabilidades no serán aceptadas) y usa a2sv para volver a verificar 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>

Información sobre vulnerabilidades de SSL/TLS:

Spidering

Lanza algún tipo de spider dentro de la web. El objetivo del spider es encontrar la mayor cantidad de rutas posible desde la aplicación probada. Por lo tanto, se deben utilizar la exploración web y fuentes externas para encontrar la mayor cantidad de rutas válidas posible.

  • gospider (go): Spider HTML, LinkFinder en archivos JS y fuentes externas (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).

  • hakrawler (go): Spider HML, con LinkFinder para archivos JS y Archive.org como fuente externa.

  • dirhunt (python): Spider HTML, también indica "archivos jugosos".

  • evine (go): Spider HTML interactivo CLI. También busca en Archive.org.

  • meg (go): Esta herramienta no es un spider, pero puede ser útil. Solo puedes indicar un archivo con hosts y un archivo con rutas y meg obtendrá cada ruta en cada host y guardará la respuesta.

  • urlgrab (go): Spider HTML con capacidades de renderizado JS. Sin embargo, parece que no está mantenido, la versión precompilada es antigua y el código actual no compila.

  • gau (go): Spider HTML que utiliza proveedores externos (wayback, otx, commoncrawl).

  • ParamSpider: Este script encontrará URLs con parámetros y las listará.

  • galer (go): Spider HTML con capacidades de renderizado JS.

  • LinkFinder (python): Spider HTML, con capacidades de embellecimiento JS capaz de buscar nuevas rutas en archivos JS. También podría valer la pena echar un vistazo a JSScanner, que es un envoltorio de LinkFinder.

  • goLinkFinder (go): Para extraer endpoints tanto en el código fuente HTML como en archivos javascript incrustados. Útil para cazadores de bugs, equipos rojos, ninjas de infosec.

  • JSParser (python2.7): Un script de python 2.7 que utiliza Tornado y JSBeautifier para analizar URLs relativas de archivos JavaScript. Útil para descubrir fácilmente solicitudes AJAX. Parece que no está mantenido.

  • relative-url-extractor (ruby): Dado un archivo (HTML) extraerá URLs de él utilizando expresiones regulares ingeniosas para encontrar y extraer las URLs relativas de archivos feos (minificados).

  • JSFScan (bash, varias herramientas): Reúne información interesante de archivos JS utilizando varias herramientas.

  • subjs (go): Encuentra archivos JS.

  • page-fetch (go): Carga una página en un navegador sin cabeza e imprime todas las URLs cargadas para cargar 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 rutas y parámetros en archivos JS.

  • Sourcemapper: Una herramienta que dado el URL .js.map te proporcionará el código JS embellecido.

  • xnLinkFinder: Esta es una herramienta utilizada para descubrir endpoints para un objetivo dado.

  • waymore: Descubre enlaces de la máquina Wayback (también descargando las respuestas en Wayback y buscando más enlaces).

  • HTTPLoot (go): Rastrea (incluso llenando formularios) y también encuentra información sensible utilizando expresiones regulares específicas.

  • SpiderSuite: Spider Suite es un avanzado Crawler/Spider de seguridad web con múltiples funciones diseñado para profesionales de ciberseguridad.

  • jsluice (go): Es un paquete de Go y herramienta de línea de comandos para extraer URLs, rutas, secretos y otros datos interesantes del código fuente de JavaScript.

  • ParaForge: ParaForge es una simple extensión de Burp Suite para extraer los parámetros y endpoints de la solicitud para crear listas de palabras personalizadas para fuzzing y enumeración.

  • katana (go): Herramienta impresionante para esto.

  • Crawley (go): Imprime cada enlace que puede encontrar.

Fuerza bruta de directorios y archivos

Comienza fuerza bruta desde la carpeta raíz y asegúrate de hacer fuerza bruta en todos los directorios encontrados utilizando este método y todos los directorios descubiertos por el Spidering (puedes hacer esta fuerza bruta recursivamente y añadiendo al principio de la lista de palabras utilizada los nombres de los directorios encontrados). Herramientas:

  • Dirb / Dirbuster - Incluido en Kali, antiguo (y lento) pero funcional. Permite certificados auto-firmados y búsqueda recursiva. Demasiado lento en comparación con las 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): Esta no es un spider, sino una herramienta que dado el listado de URLs encontradas eliminará URLs "duplicadas".

  • Scavenger: Extensión de Burp para crear una lista de directorios a partir del historial de burp de diferentes páginas.

  • TrashCompactor: Elimina URLs con funcionalidades duplicadas (basado en importaciones de js).

  • Chamaleon: Utiliza wapalyzer para detectar tecnologías utilizadas y seleccionar las listas de palabras a usar.

Diccionarios recomendados:

Ten en cuenta que cada vez que se descubra un nuevo directorio durante la fuerza bruta o el spidering, debe ser Fuerza Bruta.

Qué verificar en cada archivo encontrado

  • Broken link checker: Encuentra enlaces rotos dentro de HTMLs que pueden ser propensos a tomas de control.

  • Copias de seguridad de archivos: Una vez que hayas encontrado todos los archivos, busca copias de seguridad de todos los archivos ejecutables (".php", ".aspx"...). Variaciones comunes para nombrar una copia de seguridad 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.

  • Descubrir nuevos parámetros: Puedes usar herramientas como Arjun, parameth, x8 y Param Miner para descubrir parámetros ocultos. Si puedes, podrías intentar buscar parámetros ocultos en cada archivo web ejecutable.

  • Arjun todas las listas de palabras predeterminadas: 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

  • Comentarios: Revisa los comentarios de todos los archivos, puedes encontrar credenciales o funcionalidad oculta.

  • Si estás jugando 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 código fuente con el navegador). Otra posibilidad es usar varias nuevas líneas y ocultar información en un comentario en la parte inferior de la página web.

  • Claves API: Si encuentras alguna clave API hay una guía que indica cómo usar claves API de diferentes plataformas: keyhacks, zile, truffleHog, SecretFinder, RegHex, DumpsterDive, EarlyBird.

  • Claves API de Google: Si encuentras alguna clave API que se parezca a AIzaSyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik puedes usar el proyecto gmapapiscanner para verificar a qué APIs puede acceder la clave.

  • Buckets S3: Mientras haces spidering, verifica si algún subdominio o algún enlace está relacionado con algún bucket S3. En ese caso, verifica los permisos del bucket.

Hallazgos especiales

Mientras realizas el spidering y fuerza bruta podrías encontrar cosas interesantes que debes notar.

Archivos interesantes

  • Busca enlaces a otros archivos dentro de los archivos CSS.

  • Si encuentras un archivo .git se puede extraer información.

  • Si encuentras un .env se puede encontrar información como claves API, contraseñas de bases de datos y otra información.

  • Si encuentras endpoints API también deberías probarlos. Estos no son archivos, pero probablemente "se verán como" ellos.

  • Archivos JS: En la sección de spidering se mencionaron varias herramientas que pueden extraer rutas de archivos JS. Además, sería interesante monitorear cada archivo JS encontrado, ya que en algunas ocasiones, un cambio puede indicar que se introdujo una vulnerabilidad potencial en el código. Podrías usar por ejemplo JSMon.

  • También deberías verificar los archivos JS descubiertos con RetireJS o JSHole para encontrar si es vulnerable.

  • Desofuscador y desempaquetador de Javascript: https://lelinhtinh.github.io/de4js/, https://www.dcode.fr/javascript-unobfuscator.

  • Beautificador de Javascript: http://jsbeautifier.org/, http://jsnice.org/.

  • Desofuscación de JsFuck (javascript con caracteres:"[]!+" https://ooze.ninja/javascript/poisonjs/).

  • TrainFuck: +72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.

  • En varias ocasiones necesitarás entender expresiones regulares utilizadas, esto será útil: https://regex101.com/.

  • También podrías monitorear los archivos donde se detectaron formularios, ya que un cambio en el parámetro o la aparición de un nuevo formulario puede indicar una nueva funcionalidad potencialmente vulnerable.

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 solicitud HTTP como: GET https://google.com HTTP/1.1 (con el encabezado de host y otros encabezados comunes), el proxy intentará acceder a google.com y habrás encontrado un SSRF.

Autenticación NTLM - Divulgación de información

Si el servidor en ejecución que solicita autenticación es Windows o encuentras un inicio de sesión que pide tus credenciales (y solicita el nombre de dominio), puedes provocar una divulgación de información. Envía el encabezado: “Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=” y debido a cómo funciona la autenticación NTLM, el servidor responderá con información interna (versión de IIS, versión de Windows...) dentro del encabezado "WWW-Authenticate". Puedes automatizar esto utilizando el plugin de nmap "http-ntlm-info.nse".

Redirección HTTP (CTF)

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

Verificación de vulnerabilidades web

Ahora que se ha realizado una enumeración completa de la aplicación web, es hora de verificar muchas posibles vulnerabilidades. Puedes encontrar la lista de verificación aquí:

Web Vulnerabilities Methodology

Encuentra más información sobre vulnerabilidades web en:

Monitorear páginas para cambios

Puedes usar herramientas como https://github.com/dgtlmoon/changedetection.io para monitorear páginas por modificaciones que podrían insertar vulnerabilidades.

Si estás interesado en una carrera de hacking y hackear lo inhackeable - ¡estamos contratando! (se requiere polaco fluido escrito y hablado).

Comandos automáticos de HackTricks

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.xyz/pentesting/pentesting-web

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}
Apoya a HackTricks
Previous79 - Pentesting FingerNext403 & 401 Bypasses

Last updated