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

28 KiB
Raw Blame History

80,443 - Metodologia Pentesting Web

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

Informazioni di base

Il servizio web è il servizio più comune e diffuso e esistono molti diversi tipi di vulnerabilità.

Porta predefinita: 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

Linee guida Web API

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

Riassunto della metodologia

In questa metodologia supponiamo che tu stia per attaccare un dominio (o sottodominio) e solo quello. Quindi, dovresti applicare questa metodologia a ogni dominio, sottodominio o IP scoperto con web server non determinato all'interno dell'ambito.

  • Inizia identificando le tecnologie usate dal web server. Cerca trucchi da tenere a mente durante il resto del test se riesci a identificare con successo la tech.
  • Qualsiasi vulnerabilità nota della versione della tecnologia?
  • Stai usando qualche tech ben nota? Qualche trucco utile per estrarre più informazioni?
  • Qualche scanner specializzato da eseguire (come wpscan)?
  • Avvia scanner a scopo generale. Non sai mai se troveranno qualcosa o qualche informazione interessante.
  • Inizia con i controlli iniziali: robots, sitemap, errore 404 e SSL/TLS scan (se HTTPS).
  • Inizia a spiderare la pagina web: è il momento di trovare tutti i possibili file, cartelle e parametri in uso. Controlla anche la presenza di risultati speciali.
  • Nota che ogni volta che viene scoperta una nuova directory durante brute-forcing o spidering, dovrebbe essere spiderata.
  • Directory Brute-Forcing: prova a brute-forzare tutte le cartelle scoperte cercando nuovi file e directory.
  • Nota che ogni volta che viene scoperta una nuova directory durante brute-forcing o spidering, dovrebbe essere Brute-Forced.
  • Controllo backup: verifica se puoi trovare backup di file scoperti aggiungendo estensioni di backup comuni.
  • Brute-Force parametri: prova a trovare parametri nascosti.
  • Una volta che hai identificato tutti i possibili endpoint che accettano input utente, verifica ogni tipo di vulnerabilità relativa a essi.
  • Follow this checklist

Versione del Server (Vulnerabile?)

Identificare

Controlla se esistono vulnerabilità note per la versione del server in esecuzione.
Le HTTP headers e i cookies della response potrebbero essere molto utili per identificare le tecnologie e/o la versione in uso. Nmap scan può identificare la versione del server, ma possono essere utili anche gli strumenti 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

Verifica la presenza di WAF

Web tech tricks

Alcuni trucchi per finding vulnerabilities in diverse ben note technologies in uso:

Tieni in considerazione che lo stesso dominio può utilizzare diverse tecnologie su diverse porte, cartelle e sottodomini.
Se la web application sta usando una delle tech/platform elencate prima o qualsiasi altra, non dimenticare di cercare su Internet nuovi trucchi (e fammi sapere!).

Source Code Review

Se il source code dell'applicazione è disponibile su github, oltre a eseguire da te un White box test dell'applicazione ci sono alcune informazioni che potrebbero essere utili per l'attuale Black-Box testing:

  • Esiste un Change-log o Readme o Version file o qualcosa con informazioni di versione accessibile via web?
  • Come e dove vengono salvate le credentials? Esiste qualche (accessibile?) file con credentials (usernames o passwords)?
  • Le passwords sono in plain text, encrypted o quale hashing algorithm viene usato?
  • Sta usando una master key per cifrare qualcosa? Quale algoritmo viene usato?
  • Puoi accedere a uno di questi file sfruttando qualche vulnerability?
  • Ci sono informazioni interessanti su github (issues risolte e non risolte)? O nella cronologia dei commit (forse qualche password introdotta in un vecchio commit)?

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

Automatic scanners

General purpose automatic scanners

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"

Scanner per CMS

Se viene usato un CMS, non dimenticare di eseguire uno scanner, potrebbe essere trovato qualcosa di interessante:

Clusterd: JBoss, ColdFusion, WebLogic, Tomcat, Railo, Axis2, Glassfish
CMSScan: WordPress, Drupal, Joomla, vBulletin siti web per vulnerabilità di sicurezza. (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

A questo punto dovresti già avere alcune informazioni sul web server usato dal client (se sono stati forniti dati) e alcuni trucchi da tenere a mente durante il test. Se sei fortunato potresti aver anche trovato un CMS ed eseguito qualche scanner.

Step-by-step Web Application Discovery

From this point we are going to start interacting with the web application.

Initial checks

Default pages with interesting info:

  • /robots.txt
  • /sitemap.xml
  • /crossdomain.xml
  • /clientaccesspolicy.xml
  • /.well-known/
  • Check also comments in the main and secondary pages.

Forcing errors

I web server possono comportarsi in modo inaspettato quando vengono inviati dati strani. Questo può aprire vulnerabilità o causare esposizione di informazioni sensibili.

  • Accedi a pagine fake come /whatever_fake.php (.aspx,.html,.etc)
  • Aggiungi "[]", "]]", and "[[" nei valori dei cookie e nei valori dei parametri per creare errori
  • Genera un errore fornendo come input /~randomthing/%s alla fine della URL
  • Prova diversi HTTP Verbs come PATCH, DEBUG o sbagliati come FAKE

Check if you can upload files (PUT verb, WebDav)

Se scopri che WebDav è abilitato ma non hai permessi sufficienti per caricare file nella cartella root, prova a:

  • Brute Force credentials
  • Caricare file via WebDav nelle altre cartelle trovate all'interno della pagina web. Potresti avere i permessi per caricare file in altre directory.

SSL/TLS vulnerabilites

  • Se l'applicazione non forza l'uso di HTTPS in nessuna parte, allora è vulnerabile a MitM
  • Se l'applicazione invia dati sensibili (password) usando HTTP. Allora è una vulnerabilità critica.

Usa testssl.sh per verificare la presenza di vulnerabilità (Nei programmi di Bug Bounty probabilmente questo tipo di vulnerabilità non verrà accettato) e usa a2sv per ricontrollare le vulnerabilità:

./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>

Informazioni sulle vulnerabilità SSL/TLS:

Spidering

Avvia una sorta di spider sul web. L'obiettivo dello spider è trovare quanti più percorsi possibile dall'applicazione testata. Perciò, web crawling e fonti esterne dovrebbero essere usate per trovare il maggior numero possibile di percorsi validi.

  • gospider (go): HTML spider, LinkFinder nei file JS e in fonti esterne (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
  • hakrawler (go): HTML spider, con LinkFinder per file JS e Archive.org come fonte esterna.
  • dirhunt (python): HTML spider, indica anche i "juicy files".
  • evine (go): Interactive CLI HTML spider. Cerca anche in Archive.org.
  • meg (go): Questo strumento non è uno spider ma può essere utile. Puoi indicare un file con hosts e un file con path e meg scaricherà ogni path su ogni host e salverà la risposta.
  • urlgrab (go): HTML spider con capacità di rendering JS. Tuttavia, sembra non essere mantenuto, la versione precompilata è vecchia e il codice attuale non compila.
  • gau (go): HTML spider che usa provider esterni (wayback, otx, commoncrawl).
  • ParamSpider: Questo script troverà URL con parametri e li elencherà.
  • galer (go): HTML spider con capacità di rendering JS.
  • LinkFinder (python): HTML spider, con capacità di JS beautify in grado di cercare nuovi percorsi nei file JS. Potrebbe valere la pena dare un'occhiata anche a JSScanner, che è un wrapper di LinkFinder.
  • goLinkFinder (go): Per estrarre endpoint sia dal sorgente HTML che dai file javascript incorporati. Utile per bug hunters, red teamers, infosec ninjas.
  • JSParser (python2.7): Uno script python 2.7 che usa Tornado e JSBeautifier per parsare URL relative dai file JavaScript. Utile per scoprire facilmente richieste AJAX. Sembra non essere mantenuto.
  • relative-url-extractor (ruby): Dato un file (HTML) estrarrà URL da esso usando espressioni regolari per trovare ed estrarre URL relative da file minificati.
  • JSFScan (bash, diversi tools): Raccoglie informazioni interessanti dai file JS usando diversi strumenti.
  • subjs (go): Trova file JS.
  • page-fetch (go): Carica una pagina in un browser headless e stampa tutti gli url caricati per caricare la pagina.
  • Feroxbuster (rust): Strumento di content discovery che combina varie opzioni dei tool precedenti.
  • Javascript Parsing: Una estensione per Burp per trovare path e param nei file JS.
  • Sourcemapper: Uno strumento che, dato l'URL .js.map, restituisce il codice JS beatificato.
  • xnLinkFinder: Strumento per scoprire endpoint per un target dato.
  • waymore: Scopri link dalla wayback machine (scaricando anche le risposte nella wayback e cercando altri link).
  • HTTPLoot (go): Crawl (anche compilando form) e trova anche info sensibili usando regex specifiche.
  • SpiderSuite: Spider Suite è un advance multi-feature GUI web security Crawler/Spider progettato per professionisti della cyber security.
  • jsluice (go): È un package Go e uno strumento da riga di comando per estrarre URLs, path, secrets e altri dati interessanti dal codice sorgente JavaScript.
  • ParaForge: ParaForge è una semplice Burp Suite extension per estrarre i parametri e gli endpoint dalle richieste per creare wordlist personalizzate per fuzzing e enumerazione.
  • katana (go): Ottimo strumento per questo.
  • Crawley (go): Stampa ogni link che riesce a trovare.

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).
Tools:

  • Dirb / Dirbuster - Included in Kali, old (and slow) but functional. Allow auto-signed certificates and recursive search. Too slow compared with th other options.
  • Dirsearch (python): It doesn't allow auto-signed certificates but allows recursive search.
  • Gobuster (go): It allows auto-signed certificates, it doesn't have recursive search.
  • Feroxbuster - Fast, supports recursive search.
  • wfuzz wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ
  • ffuf - Fast: ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ
  • uro (python): Questo non è uno spider ma uno strumento che, data la lista di URL trovati, elimina gli URL "duplicati".
  • Scavenger: Burp Extension per creare una lista di directory dalla history di Burp di diverse pagine.
  • TrashCompactor: Rimuove URL con funzionalità duplicate (basato su import JS).
  • Chamaleon: Usa wapalyzer per rilevare le tecnologie usate e selezionare le wordlist da usare.

Recommended dictionaries:

Note that anytime a new directory is discovered during brute-forcing or spidering, it should be Brute-Forced.

What to check on each file found

Special findings

While performing the spidering and brute-forcing you could find interesting things that you have to notice.

Interesting files

403 Forbidden/Basic Authentication/401 Unauthorized (bypass)

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

502 Proxy Error

Se una pagina risponde con quel codice, probabilmente è un proxy mal configurato. Se invii una richiesta HTTP come: GET https://google.com HTTP/1.1 (con l'header Host e altri header comuni), il proxy tenterà di accedere a google.com e avrai trovato una SSRF.

NTLM Authentication - Info disclosure

Se il server che richiede l'autenticazione è Windows o trovi una login che chiede le tue credentials (e chiede il domain name), puoi provocare una information disclosure.
Invia l'header: “Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=” e, a causa di come funziona l'NTLM authentication, il server risponderà con info interne (versione IIS, versione Windows...) nell'header "WWW-Authenticate".
Puoi automatizzare questo usando il nmap plugin "http-ntlm-info.nse".

HTTP Redirect (CTF)

È possibile mettere contenuto all'interno di una Redirection. Questo contenuto non sarà mostrato all'utente (poiché il browser eseguirà la redirezione) ma qualcosa potrebbe essere nascosto lì.

Web Vulnerabilities Checking

Now that a comprehensive enumeration of the web application has been performed it's time to check for a lot of possible vulnerabilities. You can find the checklist here:

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

Find more info about web vulns in:

Monitor Pages for changes

Puoi usare strumenti come https://github.com/dgtlmoon/changedetection.io per monitorare pagine e rilevare modifiche che potrebbero introdurre vulnerabilità.

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