hacktricks/network-services-pentesting/pentesting-web

80,443 - Metodología de Pentesting Web

Aprende hacking en AWS de cero a héroe con htARTE (Experto en Red Team de AWS de HackTricks)!

Otras formas de apoyar a HackTricks:

• Si quieres ver tu empresa anunciada en HackTricks o descargar HackTricks en PDF Consulta los PLANES DE SUSCRIPCIÓN!
• Obtén la merchandising oficial de PEASS & HackTricks
• Descubre La Familia PEASS, nuestra colección exclusiva de NFTs
• Únete al 💬 grupo de Discord o al grupo de telegram o síguenos en Twitter 🐦 @carlospolopm.
• Comparte tus trucos de hacking enviando PRs a los HackTricks y HackTricks Cloud repositorios de github.

Consejo de recompensa por errores: Regístrate en Intigriti, una plataforma de recompensas por errores premium creada por hackers, para hackers! ¡Únete a nosotros en https://go.intigriti.com/hacktricks hoy, y comienza a ganar recompensas de hasta $100,000!

{% embed url="https://go.intigriti.com/hacktricks" %}

Información Básica

El servicio web es el servicio más común y extenso y existen muchos tipos diferentes de vulnerabilidades.

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

{% content-ref url="web-api-pentesting.md" %} web-api-pentesting.md {% endcontent-ref %}

Resumen de la metodología

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

• Comienza por identificar las tecnologías utilizadas por el servidor web. Busca trucos para tener en cuenta durante el resto de la prueba si puedes identificar con éxito la tecnología.
• ¿Hay alguna vulnerabilidad conocida de la versión de la tecnología?
• ¿Se está utilizando alguna tecnología conocida? ¿Algún truco útil para extraer más información?
• ¿Hay algún escáner especializado para ejecutar (como wpscan)?
• Ejecuta escáneres de propósitos generales. Nunca se sabe si van a encontrar algo interesante.
• Comienza con las verificaciones iniciales: robots, sitemap, error 404 y escaneo de SSL/TLS (si es HTTPS).
• Comienza a rastrear la página web: Es hora de encontrar todos los posibles archivos, carpetas y parámetros que se están utilizando. También verifica si hay hallazgos especiales.
• Ten en cuenta que cada vez que se descubre un nuevo directorio durante el ataque de fuerza bruta o el rastreo, se debe rastrear.
• Ataque de fuerza bruta a directorios: Intenta forzar todos los directorios descubiertos buscando nuevos archivos y directorios.
• Ten en cuenta que cada vez que se descubre un nuevo directorio durante el ataque de fuerza bruta o el rastreo, se debe atacar de fuerza bruta.
• Verificación de copias de seguridad: Prueba si puedes encontrar copias de seguridad de los archivos descubiertos agregando extensiones de copia de seguridad comunes.
• Ataque de fuerza bruta a parámetros: Intenta encontrar parámetros ocultos.
• Una vez que hayas identificado todos los posibles puntos finales que aceptan entrada de usuario, verifica todo tipo de vulnerabilidades relacionadas con ello.
• Sigue esta lista de verificación

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. Nmap scan 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

Busca vulnerabilidades de la versión de la aplicación web aquí

Verifica 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 tecnológicos web

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

• AEM - Adobe Experience Cloud
• Apache
• Artifactory
• Buckets
• CGI
• Drupal
• Flask
• Git
• Golang
• GraphQL
• H2 - Base de datos SQL de Java
• Trucos de IIS
• JBOSS
• Jenkins
• Jira
• Joomla
• JSP
• Laravel
• Moodle
• Nginx
• PHP (php tiene muchos trucos interesantes que podrían ser explotados)
• Python
• Spring Actuators
• Symphony
• Tomcat
• VMWare
• Pruebas de penetración de API web
• WebDav
• Werkzeug
• Wordpress
• Electron Desktop (XSS a RCE)

Ten 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 conocida de las mencionadas anteriormente o cualquier otra, ¡no olvides buscar en Internet nuevos trucos (¡y házmelo saber!).

Revisión del código fuente

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

• ¿Existe un archivo de registro de cambios o Readme o versión u otra información de versión accesible a través de la web?
• ¿Cómo y dónde se guardan las credenciales? ¿Hay algún archivo (¿accesible?) con credenciales (nombres de usuario o contraseñas)?
• ¿Las contraseñas están en texto plano, encriptadas o qué algoritmo de hashing se utiliza?
• ¿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 github (resuelta y no resuelta) issues? ¿O en el historial de commits (quizás alguna contraseña introducida en un commit antiguo)?

{% content-ref url="code-review-tools.md" %} code-review-tools.md {% endcontent-ref %}

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 encuentres algo interesante:

Clusterd: JBoss, ColdFusion, WebLogic, Tomcat, Railo, Axis2, Glassfish
CMSScan: Sitios web de WordPress, Drupal, Joomla, vBulletin 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, deberías tener alguna información sobre el servidor web utilizado por el cliente (si se proporciona algún dato) y algunos trucos para tener en cuenta durante la prueba. Si tienes suerte, incluso podrías haber encontrado un CMS y ejecutar algún escáner.

Descubrimiento de la aplicación web paso a paso

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

Verificaciones iniciales

Páginas predeterminadas con información interesante:

• /robots.txt
• /sitemap.xml
• /crossdomain.xml
• /clientaccesspolicy.xml
• /.well-known/
• También verifica 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 /loquesea_fake.php (.aspx,.html,.etc)
• Agrega "[]", "]]" y "[[" en los valores de cookies y en los valores de parámetros para crear errores
• Genera un error al ingresar /~randomthing/%s al final de la URL
• Prueba con diferentes verbos HTTP como PATCH, DEBUG o incorrectos como FAKE

Verifica si puedes cargar archivos (verbo PUT, WebDav)

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

• Realizar un ataque de fuerza bruta a las credenciales
• Cargar archivos a través de WebDav en el resto de carpetas encontradas dentro de la página web. Es posible que tengas permisos para cargar archivos en otras carpetas.

Vulnerabilidades de SSL/TLS

• Si la aplicación no obliga al uso de HTTPS en ninguna parte, entonces es vulnerable a MitM
• Si la aplicación está enviando datos sensibles (contraseñas) mediante HTTP. Entonces es una vulnerabilidad alta.

Utiliza testssl.sh para verificar vulnerabilidades (en programas de Bug Bounty, probablemente este tipo de vulnerabilidades no serán aceptadas) y utiliza 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>

Vulnerabilidades de SSL/TLS:

• https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/
• https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/

Spidering

Inicia algún tipo de araña dentro de la web. El objetivo de la araña es encontrar la mayor cantidad de rutas posible desde la aplicación probada. Por lo tanto, se deben utilizar el rastreo web y fuentes externas para encontrar la mayor cantidad de rutas válidas posible.

• gospider (go): Araña HTML, LinkFinder en archivos JS y fuentes externas (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
• hakrawler (go): Araña HTML, con LinkFinder para archivos JS y Archive.org como fuente externa.
• dirhunt (python): Araña HTML, también indica "archivos jugosos".
• evine (go): Araña HTML interactiva en CLI. También busca en Archive.org.
• meg (go): Esta herramienta no es una araña pero puede ser útil. Simplemente puedes indicar un archivo con hosts y un archivo con rutas y meg recuperará cada ruta en cada host y guardará la respuesta.
• urlgrab (go): Araña HTML con capacidades de renderizado de JS. Sin embargo, parece que no se mantiene, la versión precompilada es antigua y el código actual no se compila.
• gau (go): Araña HTML que utiliza proveedores externos (wayback, otx, commoncrawl).
• ParamSpider: Este script encontrará URLs con parámetros y las listará.
• galer (go): Araña HTML con capacidades de renderizado de JS.
• LinkFinder (python): Araña HTML, con capacidades de embellecimiento de 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 puntos finales tanto en la fuente HTML como en los archivos javascript incrustados. Útil para cazadores de bugs, equipos de red y ninjas de la ciberseguridad.
• 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 no estar mantenido.
• relative-url-extractor (ruby): Dado un archivo (HTML), extraerá URLs de él utilizando una expresión regular ingeniosa 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 URL cargadas para cargar la página.
• Feroxbuster (rust): Herramienta de descubrimiento de contenido que combina 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, dada la URL .js.map, obtendrá el código JS embellecido.
• xnLinkFinder: Esta es una herramienta utilizada para descubrir puntos finales para un objetivo dado.
• waymore: Descubre enlaces de la máquina del pasado (también descargando las respuestas en el pasado y buscando más enlaces).
• HTTPLoot (go): Rastrea (incluso rellenando formularios) y también encuentra información sensible utilizando expresiones regulares específicas.
• SpiderSuite: Spider Suite es un avanzado Crawler/Araña de seguridad web GUI multi-función diseñado para profesionales de la ciberseguridad.
• jsluice (go): Es un paquete 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 puntos finales de la solicitud para crear una lista de palabras personalizada para el fuzzing y la enumeración.

Fuerza bruta en directorios y archivos

Comienza la fuerza bruta desde la carpeta raíz y asegúrate de realizar la fuerza bruta en todos los directorios encontrados utilizando este método y todos los directorios descubiertos por la Spidering (puedes hacer esta fuerza bruta de forma recursiva y añadir 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 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, compatible con 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 una araña, sino una herramienta que, dada la lista de URLs encontradas, eliminará URLs "duplicadas".
• Scavenger: Extensión de Burp para crear una lista de directorios 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 utilizar.

Diccionarios recomendados:

• https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt
• Diccionario incluido en Dirsearch
• http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10
• Listas de palabras de Assetnote
• 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
• /usr/share/wordlists/dirb/common.txt
• /usr/share/wordlists/dirb/big.txt
• /usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt

Nota que cada vez que se descubra un nuevo directorio durante la fuerza bruta o la araña, se debe realizar una Fuerza Bruta en él.

Qué verificar en cada archivo encontrado

• Comprobador de enlaces rotos: 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"...). Las 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.
• Todos los listados predeterminados de Arjun: 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 funcionalidades ocultas.
• Si estás jugando CTF, un truco "común" es ocultar información dentro de comentarios en la parte 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 líneas nuevas y ocultar información en un comentario en la parte inferior de la página web.
• Claves de API: Si encuentras alguna clave de API hay una guía que indica cómo usar claves de API de diferentes plataformas: keyhacks, zile, truffleHog, SecretFinder, RegHex, DumpsterDive, EarlyBird
• Claves de API de Google: Si encuentras alguna clave de API que se parezca a AIzaSyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik puedes usar el proyecto gmapapiscanner para verificar a qué APIs puede acceder la clave.
• Buckets de S3: Mientras haces spidering, verifica si algún subdominio o algún enlace está relacionado con algún bucket de S3. En ese caso, verifica los permisos del bucket.

Hallazgos especiales

Mientras realizas la spidering y la 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 archivo .env se pueden encontrar información como claves de API, contraseñas de bases de datos y otra información.
• Si encuentras puntos finales de 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 debes verificar los archivos JS descubiertos con RetireJS o JSHole para ver si son vulnerables.
• Desofuscador y desempaquetador de JavaScript: https://lelinhtinh.github.io/de4js/, https://www.dcode.fr/javascript-unobfuscator
• Embellecedor 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 las 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 vulnerable potencial.

403 Forbidden/Basic Authentication/401 Unauthorized (bypass)

{% content-ref url="403-and-401-bypasses.md" %} 403-and-401-bypasses.md {% endcontent-ref %}

502 Proxy Error

Si alguna página responde con ese código, probablemente sea un

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}

Consejo de recompensa por errores: ¡Regístrate en Intigriti, una plataforma de recompensas por errores premium creada por hackers, para hackers! Únete a nosotros en https://go.intigriti.com/hacktricks hoy mismo y comienza a ganar recompensas de hasta $100,000!

{% embed url="https://go.intigriti.com/hacktricks" %}

Aprende a hackear AWS de cero a héroe con htARTE (Experto en Equipos Rojos de AWS de HackTricks)!

Otras formas de apoyar a HackTricks:

• Si deseas ver tu empresa anunciada en HackTricks o descargar HackTricks en PDF, consulta los PLANES DE SUSCRIPCIÓN!
• Obtén la merchandising oficial de PEASS & HackTricks
• Descubre La Familia PEASS, nuestra colección exclusiva de NFTs
• Únete al 💬 grupo de Discord o al grupo de telegram o síguenos en Twitter 🐦 @carlospolopm.
• Comparte tus trucos de hacking enviando PRs a los repositorios de HackTricks y HackTricks Cloud.