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

33 KiB
Raw Blame History

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 estás interesado en una carrera de hacking y hackear lo imposible - ¡estamos contratando! (se requiere dominio del polaco escrito y hablado).

{% embed url="https://www.stmcyber.com/careers" %}

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 por 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

Trucos tecnológicos 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 puertos, carpetas y subdominios diferentes.
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 prueba de caja negra actual:

  • ¿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: WordPress, Drupal, Joomla, vBulletin para buscar problemas de seguridad. (Interfaz gráfica)
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 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 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 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:

  • Realizar un ataque de fuerza bruta a las credenciales
  • Subir archivos a través de WebDav al resto de las carpetas encontradas dentro de la página web. Es posible que tengas permisos para subir 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 recompensas por errores 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:

Spidering

Inicie 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 indique 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 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): 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 wayback (también descargando las respuestas en wayback 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 sencilla extensión de Burp Suite para extraer los parámetros y puntos finales de la solicitud para crear una lista de palabras personalizada para fuzzing y enumeración.

Fuerza bruta en directorios y archivos

Comience la fuerza bruta desde la carpeta raíz y asegúrese de realizar la fuerza bruta en todos los directorios encontrados utilizando este método y todos los directorios descubiertos por la Spidering (puede hacer esta fuerza bruta de forma recursiva y agregando 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 una araña, 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 tecnologías utilizadas y seleccionar las listas de palabras a utilizar.

Diccionarios recomendados:

Nota que cada vez que se descubre un nuevo directorio durante el ataque de fuerza bruta o spidering, se debe realizar un ataque de fuerza bruta en él.

Qué verificar en cada archivo encontrado

  • Verificador de enlaces rotos: Encuentra 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"...). 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 de palabras 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 participando en un CTF, un "truco" común es ocultar información dentro de comentarios al final de la página (usando cientos de espacios para que no se vea la información al abrir 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 utilizar 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 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 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 spidering se mencionaron varias herramientas que pueden extraer rutas de archivos JS. También 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 potencial nueva funcionalidad 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 el encabezado del 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 solicita tus credenciales (y pide un 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 usando el plugin de nmap "http-ntlm-info.nse".

Redirección HTTP (CTF)

Es posible colocar 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 exhaustiva de la aplicación web, es hora de verificar muchas posibles vulnerabilidades. Puedes encontrar la lista de verificación aquí:

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

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

Monitorear Páginas para cambios

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

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

{% embed url="https://www.stmcyber.com/careers" %}

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}
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: