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

34 KiB
Raw Blame History

80,443 - Metodología de Pentesting Web

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥

Consejo de recompensa por errores: regístrate en Intigriti, una plataforma premium de recompensas por errores 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 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 para Web API

{% 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 vas a atacar un dominio (o subdominio) y solo eso. Por lo tanto, debes aplicar esta metodología a cada dominio, subdominio o IP descubiertos 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?
  • ¿Usando alguna tecnología conocida? ¿Algún truco útil para extraer más información?
  • ¿Algún escáner especializado para ejecutar (como wpscan)?
  • Ejecuta escáneres de propósito general. Nunca se sabe si van a encontrar algo o si van a encontrar alguna información interesante.
  • Comienza con las verificaciones iniciales: robots, sitemap, error 404 y análisis 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 descubra un nuevo directorio durante la fuerza bruta o el rastreo, se debe rastrear.
  • Fuerza bruta de directorios: Intenta forzar la fuerza bruta en todas las carpetas descubiertas buscando nuevos archivos y directorios.
  • Ten en cuenta que cada vez que se descubra un nuevo directorio durante la fuerza bruta o el rastreo, se debe forzar la 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.
  • 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 ellos.
  • 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 las cookies de la respuesta pueden ser muy útiles para identificar las tecnologías y/o versión que se están utilizando. El escaneo de Nmap 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

Busca vulnerabilidades de la versión de la aplicación web.

Verifica 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 conocida mencionada anteriormente o cualquier otra, no olvides buscar en Internet nuevos trucos (¡y avísame!).

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 por tu cuenta, hay alguna información que podría ser útil para la prueba de caja negra actual:

  • ¿Hay un archivo de registro de cambios o readme o versión o cualquier cosa 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 archivo (accesible?) con credenciales (nombres de usuario o contraseñas)?
  • ¿Las contraseñas están en texto plano, encriptadas o qué algoritmo de hash 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 (problemas resueltos y no resueltos)? ¿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: WordPress, Drupal, Joomla, sitios web de 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, ya deberías tener alguna información sobre el servidor web utilizado por 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 ejecutado algún escáner.

Descubrimiento paso a paso de la aplicación web

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.

Forzar 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 las cookies y los valores de los 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

Verificar si se pueden 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:

  • Atacar por fuerza bruta las credenciales
  • Cargar archivos a través de WebDav en el resto de las 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 ataques de MitM
  • Si la aplicación envía datos sensibles (contraseñas) utilizando HTTP, entonces es una vulnerabilidad grave.

Utiliza testssl.sh para verificar vulnerabilidades (en programas de recompensas por errores probablemente no se aceptarán este tipo de vulnerabilidades) 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>

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 posibles en la aplicación probada. Por lo tanto, se deben utilizar rastreo web y fuentes externas para encontrar la mayor cantidad de rutas válidas posibles.

  • gospider (go): Spider HTML, LinkFinder en archivos JS y fuentes externas (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
  • hakrawler (go): Spider HTML, 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 en la línea de comandos. También busca en Archive.org.
  • meg (go): Esta herramienta no es un spider, pero puede ser útil. Solo tienes que indicar un archivo con hosts y un archivo con rutas, y meg buscará cada ruta en cada host y guardará la respuesta.
  • urlgrab (go): Spider 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): Spider HTML que utiliza proveedores externos (wayback, otx, commoncrawl).
  • ParamSpider: Este script encontrará URLs con parámetros y las enumerará.
  • galer (go): Spider HTML con capacidades de renderizado de JS.
  • LinkFinder (python): Spider 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 errores, equipos de red y ninjas de la seguridad de la información.
  • 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 utilizando una expresión regular ingeniosa para encontrar y extraer las URLs relativas de archivos feos (minificados).
  • JSFScan (bash, varias herramientas): Recopila 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 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, dado 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/Spider de seguridad web con GUI diseñado para profesionales de la ciberseguridad.
  • jsluice (go): Es un paquete de Go y una 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 sencilla extensión de Burp Suite para extraer los parámetros y puntos finales de la solicitud y crear una lista personalizada de palabras para fuzzing y enumeración.

Fuerza bruta de 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 el Spidering (puedes hacer esta fuerza bruta de forma recursiva y agregar 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, 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 un spider, sino una herramienta que, dada la lista de URLs encontradas, eliminará las 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 las tecnologías utilizadas y seleccionar las listas de palabras a utilizar.

Diccionarios recomendados:

Ten en cuenta que cada vez que se descubra un nuevo directorio durante el ataque de fuerza bruta o el rastreo, se debe realizar un ataque de fuerza bruta.

Qué verificar en cada archivo encontrado

  • Comprobador de enlaces rotos: Busca enlaces rotos dentro de los archivos HTML que pueden ser propensos a ser tomados.
  • Copias de seguridad de archivos: Una vez que hayas encontrado todos los archivos, busca copias de seguridad de todos los archivos ejecutables (".php", ".aspx"...). Algunas 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.
  • Descubrir nuevos parámetros: Puedes usar herramientas como Arjun, parameth, x8 y Param Miner para descubrir parámetros ocultos. Si puedes, también puedes intentar buscar parámetros ocultos en cada archivo web ejecutable.
  • Arjun todas las listas de palabras por defecto: 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 un CTF, un truco "común" es ocultar información dentro de los comentarios en el lado derecho 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 el rastreo, 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 el rastreo y la fuerza bruta, podrías encontrar cosas interesantes que debes tener en cuenta.

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 parecerán" a ellos.
  • Archivos JS: En la sección de rastreo 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 posible vulnerabilidad en el código. Puedes 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 monitorizar 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)

{% 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 proxy mal configurado. Si envías una solicitud HTTP como: GET https://google.com HTTP/1.1 (con la cabecera del host y otras cabeceras 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 solicita tus credenciales (y solicita el nombre de dominio), puedes provocar una divulgación de información.
Envía la cabecera: “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 de la cabecera "WWW-Authenticate".
Puedes automatizar esto utilizando el plugin de nmap "http-ntlm-info.nse".

Redirección HTTP (CTF)

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

Comprobación de Vulnerabilidades Web

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

{% content-ref url="../../pentesting-web/web-vulnerabilities-methodology/" %} web-vulnerabilities-methodology {% endcontent-ref %}

TODO: Completa la lista de vulnerabilidades y técnicas con https://six2dez.gitbook.io/pentest-book/others/web-checklist y https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html, https://owasp-skf.gitbook.io/asvs-write-ups/kbid-111-client-side-template-injection

Monitorizar cambios en las páginas

Puedes utilizar herramientas como https://github.com/dgtlmoon/changedetection.io para monitorizar las páginas en busca de modificaciones que puedan introducir vulnerabilidades.

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}


Consejo de recompensa por errores: ¡regístrate en Intigriti, una plataforma premium de recompensas por errores 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" %}

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥