maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity
hacktricks/src/network-services-pentesting/pentesting-web/README.md

29 KiB
Raw Blame History

80,443 - Metodología de Pentesting Web

{{#include ../../banners/hacktricks-training.md}}

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)

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

{{#ref}} web-api-pentesting.md {{#endref}}

Resumen de la metodología

En esta metodología vamos a suponer que vas a atacar un dominio (o subdominio) y solo ese. Por lo 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 web server. Busca trucos para tener en cuenta durante el resto del test si consigues identificar correctamente la tech.
  • ¿Alguna known vulnerability 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 que ejecutar (como wpscan)?
  • Lanza general purposes scanners. Nunca sabes si van a encontrar algo o si van a revelar información interesante.
  • Empieza con las initial checks: robots, sitemap, 404 error y SSL/TLS scan (si HTTPS).
  • Comienza con spidering la página web: es hora de find todos los posibles files, folders y parameters being used. Además, revisa si hay special findings.
  • Nota: 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 files y directories.
  • Nota: cada vez que se descubra un nuevo directorio durante brute-forcing o spidering, debe ser Brute-Forced.
  • Backups checking: Prueba si puedes encontrar backups de discovered files añadiendo extensiones de backup comunes.
  • Brute-Force parameters: Intenta find hidden parameters.
  • Una vez que hayas identified todos los posibles endpoints que aceptan user input, verifica todo tipo de vulnerabilities relacionadas con ellos.
  • Follow this checklist

Server Version (Vulnerable?)

Identificar

Check if there are known vulnerabilities for the server version that is running.
Los HTTP headers and cookies of the response pueden ser muy útiles para identificar las tecnologies y/o la version que se está usando. Un Nmap scan puede identificar la versión del servidor, pero también pueden 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 vulnerabilities of the web application version

Comprobar si hay algún WAF

Trucos de tecnología web

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

Ten en cuenta que el same domain puede estar usando different technologies en diferentes ports, folders y subdomains.
Si la web application está usando alguna bien conocida tech/platform listed before o any other, no olvides search on the Internet nuevos trucos (¡y avísame!).

Revisión del Source Code

Si el source code de la aplicación está disponible en github, aparte de realizar por your own a White box test de la aplicación, hay some information que podría ser useful para el 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 or passwords)?
  • ¿Los passwords están en plain text, encrypted o qué hashing algorithm se usa?
  • ¿Usa 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) en issues? ¿O en commit history (quizá algún password introduced inside an old commit)?

{{#ref}} code-review-tools.md {{#endref}}

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

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 información sobre el servidor web que utiliza el cliente (si se han dado datos) y algunos trucos a tener en cuenta durante la prueba. Si tienes suerte, incluso has encontrado un CMS y ejecutado algún scanner.

Descubrimiento paso a paso de aplicaciones 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/
  • Revisa también los comentarios en las páginas principales y secundarias.

Provocar errores

Los servidores web pueden comportarse de forma inesperada cuando se les envían 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 "[]", "]]", and "[[" en valores de cookie y valores de parámetros para generar errores
  • Genera un error dando como entrada /~randomthing/%s al final de la URL
  • Prueba distintos verbos HTTP como PATCH, DEBUG o verbos incorrectos como FAKE

Comprueba si puedes subir archivos (PUT verb, WebDav)

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

  • Brute Force credentials
  • Subir archivos vía 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 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 crítica.

Usa testssl.sh para comprobar vulnerabilidades (en programas de Bug Bounty probablemente este tipo de vulnerabilidades no serán aceptadas) y usa a2sv to recheck the vulnerabilities:

./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 SSL/TLS:

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 tanto, se deben usar crawling y fuentes externas para hallar la mayor cantidad de rutas válidas posible.

  • gospider (go): (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 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 estar mantenida, 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 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 que usa Tornado y JSBeautifier para parsear URLs relativas desde archivos JavaScript. Útil para descubrir fácilmente requests AJAX. Parece no estar mantenido.
  • relative-url-extractor (ruby): Dado un archivo (HTML) extraerá URLs usando una expresión regular ingeniosa para encontrar y extraer URLs relativas de archivos 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 renderizar la página.
  • Feroxbuster (rust): Herramienta de content discovery 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 obtiene el código JS beautified.
  • xnLinkFinder: Herramienta usada para descubrir endpoints para un objetivo dado.
  • waymore: Descubre enlaces desde wayback machine (también descarga las respuestas en wayback y busca más enlaces).
  • HTTPLoot (go): Crawl (incluso rellenando formularios) y además encuentra info sensible usando regexes específicas.
  • SpiderSuite: Spider Suite es un crawler/spider GUI multi-función diseñado para profesionales de ciberseguridad.
  • jsluice (go): Es un paquete Go y herramienta CLI para extraer URLs, paths, secrets y otros datos interesantes del código fuente JavaScript.
  • ParaForge: ParaForge es una simple Burp Suite extension para extraer parámetros y endpoints de las requests para crear wordlists custom para fuzzing y enumeración.
  • katana (go): Herramienta excelente para esto.
  • Crawley (go): Imprime cada link que es capaz de encontrar.

Brute Force directories and files

Start brute-forcing from the root folder and be sure to brute-force all the directories found using this method and all the directories discovered by the Spidering (you can do this brute-forcing recursively and appending at the beginning of the used wordlist the names of the found directories).
Herramientas:

  • Dirb / Dirbuster - Incluido en Kali, antiguo (y lento) 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 - 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, eliminará URLs "duplicadas".
  • Scavenger: Burp Extension para crear una lista de directorios a partir del historial de Burp de diferentes páginas.
  • TrashCompactor: Elimina URLs con funcionalidades duplicadas (basado en imports de 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: Encuentra enlaces rotos dentro de los HTML que pueden ser susceptibles a takeovers.
  • File Backups: Una vez que hayas 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 credenciales o funcionalidad oculta.
  • Si juegas 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 existe una guía que indica cómo usar API keys de diferentes plataformas: keyhacks, zile, truffleHog, SecretFinder, RegHex, DumpsterDive, EarlyBird
  • Google API keys: Si encuentras una API key que parezca AIzaSyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik puedes usar el proyecto gmapapiscanner para comprobar a qué apis puede acceder la key.
  • S3 Buckets: Mientras haces spidering mira si algún subdomain o algún link está relacionado con algún S3 bucket. En ese caso, comprueba 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)

{{#ref}} 403-and-401-bypasses.md {{#endref}}

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 es Windows o encuentras un login solicitando tus credenciales (y pidiendo el domain name), puedes provocar una divulgación de información.
Envía el header: “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 header "WWW-Authenticate".
Puedes automatizar esto usando el nmap plugin "http-ntlm-info.nse".

HTTP Redirect (CTF)

Es posible incluir 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í.

Web Vulnerabilities Checking

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

{{#ref}} ../../pentesting-web/web-vulnerabilities-methodology.md {{#endref}}

Encuentra más info sobre vulnerabilidades web 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}

{{#include ../../banners/hacktricks-training.md}}