Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-23 05:03:35 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/network-services-pentesting/pentesting-web/README.md

30 KiB
Raw Blame History

80,443 - Metodología de Pentesting Web

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

Otras formas de apoyar a HackTricks:

Consejo para bug bounty: regístrate en Intigriti, una plataforma premium de bug bounty 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" %}

Información Básica

El servicio web es el servicio más común y extenso y existen diferentes tipos 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

Orientación para API Web

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

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, deberías aplicar esta metodología a cada dominio, subdominio o IP con 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.
  • ¿Alguna vulnerabilidad conocida de la versión de la tecnología?
  • ¿Utiliza alguna tecnología conocida? ¿Algún truco útil para extraer más información?
  • ¿Algún escáner especializado para ejecutar (como wpscan)?
  • Lanza escáneres de propósitos generales. Nunca sabes si van a encontrar algo o si van a encontrar información interesante.
  • Comienza con las verificaciones iniciales: robots, sitemap, error 404 y escaneo 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. Además, busca hallazgos especiales.
  • Ten en cuenta que cada vez que se descubre un nuevo directorio durante el fuerza bruta o el rastreo, debe ser rastreado.
  • Fuerza bruta de directorios: Intenta forzar todos los directorios descubiertos en busca de nuevos archivos y directorios.
  • Ten en cuenta que cada vez que se descubre un nuevo directorio durante el fuerza bruta o el rastreo, debe ser sometido a fuerza bruta.
  • Verificación de copias de seguridad: Prueba si puedes encontrar copias de seguridad de archivos descubiertos añadiendo extensiones comunes de copia de seguridad.
  • Fuerza bruta de 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

Comprueba si hay vulnerabilidades conocidas para la versión del servidor que está en funcionamiento.
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. El escaneo 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

Búsqueda de vulnerabilidades de la versión de la aplicación web

Verificar si hay algún WAF

Trucos de tecnología web

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

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 mencionada 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, aparte de realizar tu propio test de Caja Blanca de la aplicación, hay información que podría ser útil para el actual test de Caja Negra:

  • ¿Hay un archivo de Change-log o Readme o Versión o algo con información de la versión accesible vía web?
  • ¿Cómo y dónde se guardan las credenciales? ¿Hay algún archivo con credenciales (nombres de usuario o contraseñas) accesible?
  • ¿Las contraseñas están en texto plano, cifradas o qué algoritmo de hash se utiliza?
  • ¿Se está utilizando alguna clave maestra para cifrar algo? ¿Qué algoritmo se utiliza?
  • ¿Puedes acceder a alguno de estos archivos explotando alguna vulnerabilidad?
  • ¿Hay alguna información interesante en los issues de github (resueltos y no resueltos)? ¿O en el historial de commits (tal vez 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, quizás se encuentre algo interesante:

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

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 predeterminadas con información interesante:

  • /robots.txt
  • /sitemap.xml
  • /crossdomain.xml
  • /clientaccesspolicy.xml
  • /.well-known/
  • Revisa también los comentarios en las páginas principales y secundarias.

Forzando errores

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

  • Accede a páginas falsas como /whatever_fake.php (.aspx,.html,.etc)
  • Añade "[]", "]]", y "[[" en los valores de cookie y en los valores de parámetro para crear errores
  • Genera error proporcionando 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 en las credenciales
  • Sube archivos a través de WebDav al resto de 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 el uso de HTTPS en alguna 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 buscar 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 tantas rutas como sea posible de la aplicación probada. Por lo tanto, se deben utilizar el rastreo web y fuentes externas para encontrar tantas rutas válidas como sea posible.

  • gospider (go): Spider de HTML, LinkFinder en archivos JS y fuentes externas (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
  • hakrawler (go): Spider de HML, con LinkFider para archivos JS y Archive.org como fuente externa.
  • dirhunt (python): Spider de HTML, también indica "archivos jugosos".
  • evine (go): Spider de HTML interactivo CLI. 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 rutas y meg obtendrá cada ruta en cada host y guardará la respuesta.
  • urlgrab (go): Spider de 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 compila.
  • gau (go): Spider de HTML que utiliza proveedores externos (wayback, otx, commoncrawl).
  • ParamSpider: Este script encontrará URLs con parámetro y las listará.
  • galer (go): Spider de HTML con capacidades de renderizado de JS.
  • LinkFinder (python): Spider de 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 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 se mantiene.
  • 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): Recopilar información interesante de archivos JS utilizando varias herramientas.
  • subjs (go): Encontrar 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, dada la URL .js.map, te proporcionará el código JS embellecido.
  • xnLinkFinder: Esta es una herramienta utilizada para descubrir endpoints para un objetivo dado.
  • waymore: Descubrir enlaces desde la máquina del tiempo wayback (también descargando las respuestas en el wayback y buscando más enlaces).
  • HTTPLoot (go): Rastrear (incluso rellenando formularios) y también encontrar información sensible utilizando regexes específicos.
  • SpiderSuite: Spider Suite es un avanzado Crawler/Spider de seguridad web multi-característica con GUI diseñado para profesionales de la 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 una lista de palabras personalizada para fuzzing y enumeración.

Fuerza bruta de directorios y archivos

Comienza fuerza bruta desde la carpeta raíz y asegúrate de aplicar fuerza bruta a todos los directorios encontrados utilizando este método y todos los directorios descubiertos por el Spidering (puedes hacer esto de manera recursiva 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 una spider sino una herramienta que, dada la lista 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: Eliminar 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:

Nota que cada vez que se descubre un nuevo directorio durante la fuerza bruta o el spidering, este debe ser sometido a Fuerza Bruta.

Qué verificar en cada archivo encontrado

  • Comprobador de enlaces rotos: Encuentra enlaces rotos dentro de HTMLs que pueden ser propensos a takeovers.
  • 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.
  • Todas las listas de palabras por defecto 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 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 líneas nuevas 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 parezca AIzaSyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik puedes usar el proyecto gmapapiscanner para comprobar a qué apis puede acceder la clave.
  • S3 Buckets: Mientras haces spidering, busca si algún subdominio o algún enlace está relacionado con algún S3 bucket. En ese caso, verifica los permisos del bucket.

Hallazgos Especiales

Mientras realizas el 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 api, contraseñas de dbs y otra información.
  • Si encuentras endpoints de API también deberías probarlos. Estos no son archivos, pero probablemente "parecerán" serlo.
  • 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 encontrar si es vulnerable.
  • 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 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 funcionalidad nueva potencialmente vulnerable.

403 Prohibido/Autenticación Básica/401 No Autorizado (bypass)

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

Error de Proxy 502

Si alguna página

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 para bug bounty: regístrate en Intigriti, una plataforma premium de bug bounty 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 (HackTricks AWS Red Team Expert)!

Otras formas de apoyar a HackTricks: