80,443 - Metodologia di Pentesting Web

Tip

Impara e pratica il hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica il hacking GCP: HackTricks Training GCP Red Team Expert (GRTE) Impara e pratica il hacking Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Supporta HackTricks

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

Guida Web API

Web API Pentesting

Riepilogo della metodologia

In questa metodologia supponiamo che tu debba 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 tricks da tenere a mente durante il resto del test se riesci a identificare la tech.
  • Ci sono vulnerabilitĂ  note per la versione della tecnologia?
  • Stai usando qualche well known tech? Qualche useful trick per estrarre piĂš informazioni?
  • C’è qualche specialised scanner da eseguire (es. wpscan)?
  • Lancia general purposes scanners. Non sai mai se troveranno qualcosa o informazioni interessanti.
  • Inizia con i controlli iniziali: robots, sitemap, 404 error e SSL/TLS scan (se HTTPS).
  • Inizia lo spidering della pagina web: è il momento di trovare tutti i possibili files, folders e parameters in uso. Controlla anche eventuali special findings.
  • Nota che ogni volta che una nuova directory viene scoperta durante brute-forcing o spidering, dovrebbe essere spidered.
  • Directory Brute-Forcing: Prova a brute forceare tutte le cartelle scoperte cercando nuovi files e directories.
  • Nota che ogni volta che una nuova directory viene scoperta durante brute-forcing o spidering, dovrebbe essere Brute-Forced.
  • Backups checking: Verifica se puoi trovare backups dei discovered files aggiungendo estensioni di backup comuni.
  • Brute-Force parameters: Prova a trovare parametri nascosti.
  • Una volta che hai identificato tutti i possibili endpoints che accettano user input, verifica tutti i tipi di vulnerabilitĂ  correlati.
  • Segui questa checklist

Versione del server (Vulnerabile?)

Identificazione

Controlla se esistono vulnerabilitĂ  note per la versione del server in esecuzione.
Le HTTP headers e i cookies della risposta possono essere molto utili per identificare le tecnologie e/o la versione in uso. Una 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

Cerca per vulnerabilities of the web application version

Controlla se c’è un WAF

Trucchi per tecnologie web

Alcuni trucchi per trovare vulnerabilitĂ  in diverse ben note tecnologie in uso:

Tieni presente che lo stesso dominio può utilizzare diverse tecnologie in diverse porte, cartelle e sottodomini.
Se l’applicazione web sta usando una delle tech/platform ben note elencate prima o qualsiasi altra, non dimenticare di cercare su Internet nuovi trucchi (e informami!).

Source Code Review

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

  • Esiste un file Change-log or Readme or Version o qualsiasi cosa con informazioni sulla versione accessibili via web?
  • Come e dove vengono salvate le credentials? Esiste qualche (accessibile?) file con credentials (username o password)?
  • Le password sono in plain text, encrypted o quale hashing algorithm viene usato?
  • Utilizza una master key per criptare qualcosa? Quale algoritmo viene usato?
  • Puoi accedere a uno di questi file sfruttando qualche vulnerabilitĂ ?
  • Ci sono informazioni interessanti su github (issues risolti e non) o nella commit history (magari qualche password introdotta in un vecchio commit)?

Source code Review / SAST Tools

Scanner automatici

Scanner automatici generici

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"

CMS scanners

Se viene usato un CMS non dimenticare di run a scanner, potresti trovare qualcosa di interessante:

Clusterd: JBoss, ColdFusion, WebLogic, Tomcat, Railo, Axis2, Glassfish
CMSScan: WordPress, Drupal, Joomla, vBulletin siti web per problemi 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 utilizzato dal cliente (se sono forniti dati) e alcuni trucchi da tenere a mente durante il test. Se sei fortunato potresti aver trovato anche un CMS ed aver eseguito qualche scanner.

Scoperta passo-passo dell’applicazione web

Da questo punto inizieremo a interagire con l’applicazione web.

Controlli iniziali

Pagine di default con informazioni interessanti:

  • /robots.txt
  • /sitemap.xml
  • /crossdomain.xml
  • /clientaccesspolicy.xml
  • /.well-known/
  • Controlla anche i commenti nelle pagine principali e secondarie.

Forzare errori

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

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

Verifica se puoi caricare file (PUT verb, WebDav)

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

  • Brute Force delle credenziali
  • Caricare file via WebDav nelle altre cartelle trovate all’interno della pagina web. Potresti avere permessi per caricare file in altre cartelle.

VulnerabilitĂ  SSL/TLS

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

Usa testssl.sh per verificare le vulnerabilitĂ  (Nei programmi Bug Bounty probabilmente questo tipo di vulnerabilitĂ  non sarĂ  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

Avviare una sorta di spider sul web. L’obiettivo dello spider è trovare il maggior numero possibile di percorsi dell’applicazione testata. Pertanto, web crawling e fonti esterne dovrebbero essere usati per trovare il maggior numero possibile di percorsi validi.

  • gospider (go): spider HTML, LinkFinder nei file JS e fonti esterne (Archive.org, CommonCrawl.org, VirusTotal.com).
  • hakrawler (go): spider HTML, con LinkFider per i file JS e Archive.org come fonte esterna.
  • dirhunt (python): spider HTML, indica anche i “juicy files”.
  • evine (go): spider HTML CLI interattivo. 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 percorsi; meg recupererĂ  ogni percorso per ogni host e salverĂ  la risposta.
  • urlgrab (go): spider HTML con capacitĂ  di rendering JS. Tuttavia, sembra non mantenuto, la versione precompilata è vecchia e il codice corrente non compila.
  • gau (go): spider HTML che usa provider esterni (wayback, otx, commoncrawl).
  • ParamSpider: Questo script troverĂ  URL con parametri e li elencherĂ .
  • galer (go): spider HTML con capacitĂ  di rendering JS.
  • LinkFinder (python): spider HTML, con capacitĂ  di JS beautify capace di cercare nuovi percorsi nei file JS. Vale anche la pena dare un’occhiata a JSScanner, che è un wrapper di LinkFinder.
  • goLinkFinder (go): Estrae endpoint sia dal sorgente HTML che dai file javascript embedded. 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 mantenuto.
  • relative-url-extractor (ruby): Dato un file (HTML) estrarrĂ  URL da esso usando una comoda espressione regolare per trovare ed estrarre URL relative da file “brutti” (minified).
  • JSFScan (bash, diversi strumenti): 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 degli strumenti precedenti.
  • Javascript Parsing: Un’estensione Burp per trovare path e params nei file JS.
  • Sourcemapper: Uno strumento che, dato l’URL .js.map, ottiene il codice JS beautified.
  • xnLinkFinder: Strumento usato per scoprire endpoint per un dato target.
  • waymore: Scopri link dalla wayback machine (scaricando anche le risposte nella wayback e cercando altri link).
  • HTTPLoot (go): Crawl (anche compilando form) e trova informazioni sensibili usando regex specifiche.
  • SpiderSuite: Spider Suite è un avanzato crawler/spider GUI multi-funzione progettato per professionisti della cyber security.
  • jsluice (go): È un package Go e uno strumento da riga di comando per estrarre URL, percorsi, secret e altri dati interessanti dal codice sorgente JavaScript.
  • ParaForge: ParaForge è una semplice Burp Suite extension per estrarre i parametri e gli endpoint dalle request per creare wordlist personalizzate per fuzzing ed enumerazione.
  • katana (go): Strumento eccellente 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).
Strumenti:

  • Dirb / Dirbuster - Incluso in Kali, vecchio (e lento) ma funzionale. Permette certificati auto-firmati e ricerca ricorsiva. Troppo lento rispetto ad altre opzioni.
  • Dirsearch (python): Non permette certificati auto-firmati ma consente ricerca ricorsiva.
  • Gobuster (go): Permette certificati auto-firmati, non ha ricerca ricorsiva.
  • Feroxbuster - Veloce, supporta ricerca ricorsiva.
  • wfuzz wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ
  • ffuf - Veloce: ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ
  • uro (python): Non è uno spider ma uno strumento che, data la lista di URL trovati, rimuove 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.

Dizionari raccomandati:

Nota: ogni volta che viene scoperta una nuova directory durante brute-forcing o spidering, dovrebbe essere sottoposta a Brute-Force.

What to check on each file found

  • Broken link checker: Trova link rotti dentro gli HTML che possono essere suscettibili di takeover.
  • File Backups: Una volta trovati tutti i file, cerca i backup di tutti i file eseguibili (“.php”, “.aspx”…). Variazioni comuni per il nome di un backup sono: file.ext~, #file.ext#, ~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp e file.old. Puoi anche usare lo strumento bfac o backup-gen.
  • Discover new parameters: Puoi usare tool come Arjun, parameth, x8 e Param Miner per scoprire parametri nascosti. Se possibile, prova a cercare parametri nascosti in ogni file web eseguibile.
  • 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: Controlla i commenti di tutti i file, puoi trovare credentials o funzionalitĂ  nascoste.
  • Se stai giocando una CTF, un trucco “comune” è nascondere informazioni dentro commenti alla destra della pagina (usando centinaia di spazi cosĂŹ non vedi i dati se apri il sorgente con il browser). Un’altra possibilitĂ  è usare diverse righe vuote e nascondere informazioni in un commento in fondo alla pagina web.
  • API keys: Se trovi una API key esiste una guida che indica come usare API keys di diverse piattaforme: keyhacks, zile, truffleHog, SecretFinder, RegHex, DumpsterDive, EarlyBird
  • Google API keys: Se trovi una API key che inizia come AIzaSyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik puoi usare il progetto gmapapiscanner per controllare quali API la key può accedere.
  • S3 Buckets: Durante lo spidering verifica se qualche subdomain o qualche link è correlato a un S3 bucket. In tal caso, controlla i permessi del bucket.

Special findings

Durante l’esecuzione di spidering e brute-forcing potresti trovare cose interessanti che devi segnalare.

File interessanti

403 Forbidden/Basic Authentication/401 Unauthorized (bypass)

403 & 401 Bypasses

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 oppure trovi una login che richiede le tue credentials (e chiede il domain), puoi provocare una information disclosure.
Invia l’header: “Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=” e, a causa del funzionamento dell’NTLM authentication, il server risponderà con informazioni interne (versione IIS, versione Windows…) nell’header “WWW-Authenticate”.
Puoi automatizzare questo usando il plugin nmap “http-ntlm-info.nse”.

HTTP Redirect (CTF)

È possibile inserire contenuto dentro una Redirect. Questo contenuto non sarà mostrato all’utente (poiché il browser eseguirà la redirezione) ma qualcosa potrebbe essere nascosto lì dentro.

Web Vulnerabilities Checking

Ora che è stata eseguita un’enumerazione completa dell’applicazione web è il momento di verificare molte possibili vulnerabilità. Puoi trovare la checklist qui:

Web Vulnerabilities Methodology

Trova piĂš informazioni sulle web vulns in:

Monitor Pages for changes

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

HackTricks Automatic Commands

HackTricks Automatic Commands ```yaml 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}

</details>

> [!TIP]
> Impara e pratica il hacking AWS:<img src="../../../../../images/arte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../../../images/arte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">\
> Impara e pratica il hacking GCP: <img src="../../../../../images/grte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">[**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte)<img src="../../../../../images/grte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">
> Impara e pratica il hacking Azure: <img src="../../../../../images/azrte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">[**HackTricks Training Azure Red Team Expert (AzRTE)**](https://training.hacktricks.xyz/courses/azrte)<img src="../../../../../images/azrte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">
>
> <details>
>
> <summary>Supporta HackTricks</summary>
>
> - Controlla i [**piani di abbonamento**](https://github.com/sponsors/carlospolop)!
> - **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
> - **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos github.
>
> </details>