80,443 - Pentesting Web Methodology

Tip

Apprenez et pratiquez le hacking AWS :HackTricks Training AWS Red Team Expert (ARTE)
Apprenez et pratiquez le hacking GCP : HackTricks Training GCP Red Team Expert (GRTE) Apprenez et pratiquez le hacking Azure : HackTricks Training Azure Red Team Expert (AzRTE)

Soutenir HackTricks

Infos de base

Le service web est le service le plus courant et répandu et de nombreux types différents de vulnérabilités existent.

Port par défaut: 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

Conseils pour les Web API

Web API Pentesting

Résumé de la méthodologie

Dans cette méthodologie nous allons supposer que vous allez attaquer un domaine (ou sous-domaine) et uniquement celui-ci. Vous devez donc appliquer cette méthodologie à chaque domaine, sous-domaine ou IP découvert(e) avec un serveur web indéterminé dans le périmètre.

  • Commencez par identifier les technologies utilisées par le serveur web. Recherchez des tricks à garder à l’esprit pendant le reste du test si vous pouvez identifier la tech.
  • Y a-t-il une vulnérabilité connue pour la version de la technologie ?
  • Utilisez-vous une well known tech ? Une useful trick pour extraire plus d’informations ?
  • Y a-t-il un specialised scanner à lancer (comme wpscan) ?
  • Lancez des general purposes scanners. Vous ne savez jamais s’ils vont trouver quelque chose ou des informations intéressantes.
  • Commencez par les initial checks : robots, sitemap, 404 error et SSL/TLS scan (si HTTPS).
  • Commencez le spidering de la page web : il est temps de find tous les files, folders et parameters being used. Vérifiez aussi les special findings.
  • Notez que chaque fois qu’un nouveau répertoire est découvert lors du brute-forcing ou du spidering, il doit être spidered.
  • Directory Brute-Forcing : Essayez de brute force tous les dossiers découverts à la recherche de nouveaux files et directories.
  • Notez que chaque fois qu’un nouveau répertoire est découvert lors du brute-forcing ou du spidering, il doit être Brute-Forced.
  • Backups checking : Testez si vous pouvez trouver des backups des discovered files en ajoutant des extensions de sauvegarde courantes.
  • Brute-Force parameters : Essayez de find hidden parameters.
  • Une fois que vous avez identified tous les endpoints possibles acceptant user input, vérifiez tout type de vulnerabilities liées à ceux-ci.
  • Follow this checklist

Version du serveur (Vulnérable ?)

Identification

Vérifiez s’il existe des vulnérabilités connues pour la version du serveur en cours d’exécution.
Les HTTP headers and cookies of the response peuvent être très utiles pour identify les technologies et/ou la version utilisées. Un Nmap scan peut identifier la version du serveur, mais il peut aussi être utile d’utiliser les outils whatweb, webtech ou https://builtwith.com/:

whatweb -a 1 <URL> #Stealthy
whatweb -a 3 <URL> #Aggresive
webtech -u <URL>
webanalyze -host https://google.com -crawl 2

Rechercher vulnerabilities of the web application version

Vérifier s’il y a un WAF

Astuces techniques Web

Quelques astuces pour trouver des vulnérabilités dans différentes technologies bien connues utilisées :

Prenez en compte que le même domaine peut utiliser différentes technologies sur différents ports, dossiers et sous-domaines.
Si l’application web utilise une tech/plateforme listée ci‑dessus ou toute autre, n’oubliez pas de chercher sur Internet de nouvelles astuces (et dites‑moi !).

Revue du code source

Si le code source de l’application est disponible sur github, en plus d’effectuer par vous‑même un White box test de l’application, il existe des informations qui pourraient être utiles pour le Black-Box testing en cours :

  • Y a‑t‑il un Change-log or Readme or Version file ou autre chose avec des version info accessible via le web ?
  • Comment et où sont sauvegardés les credentials ? Y a‑t‑il un fichier (accessible ?) avec des credentials (usernames ou passwords) ?
  • Les passwords sont‑ils en plain text, encrypted ou quel hashing algorithm est utilisé ?
  • Utilise‑t‑il une master key pour chiffrer quelque chose ? Quel algorithm est utilisé ?
  • Pouvez‑vous accéder à l’un de ces fichiers en exploitant une vulnérabilité ?
  • Y a‑t‑il des informations intéressantes sur github (issues résolues ou non) ? Ou dans l’historique des commits (peut‑être un password introduit dans un ancien commit) ?

Source code Review / SAST Tools

Scanners automatiques

Scanners automatiques à usage général

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"

Scanners CMS

Si un CMS est utilisé, n’oubliez pas de lancer un scanner, quelque chose d’intéressant pourrait être trouvé :

Clusterd: JBoss, ColdFusion, WebLogic, Tomcat, Railo, Axis2, Glassfish
CMSScan: WordPress, Drupal, Joomla, vBulletin sites web pour des problèmes de sécurité. (GUI)
VulnX: Joomla, Wordpress, Drupal, PrestaShop, Opencart
CMSMap: (W)ordpress, (J)oomla, (D)rupal ou (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

À ce stade, vous devriez déjà avoir quelques informations sur le serveur web utilisé par le client (si des données sont fournies) et quelques astuces à garder en tête pendant le test. Si vous avez de la chance, vous avez même trouvé un CMS et lancé un scanner.

Découverte de l’application web étape par étape

À partir de maintenant nous allons commencer à interagir avec l’application web.

Vérifications initiales

Pages par défaut contenant des informations intéressantes :

  • /robots.txt
  • /sitemap.xml
  • /crossdomain.xml
  • /clientaccesspolicy.xml
  • /.well-known/
  • Vérifier aussi les commentaires dans les pages principales et secondaires.

Forcer des erreurs

Les serveurs web peuvent se comporter de manière inattendue lorsque des données étranges leur sont envoyées. Cela peut ouvrir des vulnérabilités ou divulguer des informations sensibles.

  • Accéder à des pages factices comme /whatever_fake.php (.aspx, .html, .etc)
  • Ajouter “[]”, “]]” et “[[” dans les valeurs de cookie et les valeurs de paramètres pour provoquer des erreurs
  • Générer une erreur en fournissant l’entrée /~randomthing/%s à la fin de l’URL
  • Essayer différents HTTP Verbs comme PATCH, DEBUG ou incorrects comme FAKE

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

Si vous constatez que WebDav est activé mais que vous n’avez pas suffisamment d’autorisations pour uploading files dans le dossier racine, essayez de :

  • Brute Force credentials
  • Upload files via WebDav dans le reste des dossiers trouvés à l’intérieur de la page web. Il se peut que vous ayez des permissions pour uploader des fichiers dans d’autres dossiers.

Vulnérabilités SSL/TLS

  • Si l’application n’oblige pas l’utilisation de HTTPS dans une quelconque partie, alors elle est vulnérable à MitM
  • Si l’application envoie des données sensibles (mots de passe) via HTTP. C’est alors une vulnérabilité élevée.

Utilisez testssl.sh pour vérifier les vulnérabilités (dans les programmes Bug Bounty, probablement ce type de vulnérabilités ne sera pas accepté) et utilisez a2sv pour revérifier les vulnérabilités :

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

Information about SSL/TLS vulnerabilities:

Spidering

Lancez une sorte de spider sur le web. L’objectif du spider est de trouver autant de chemins que possible depuis l’application testée. Par conséquent, le crawling web et les sources externes doivent être utilisés pour récupérer le plus grand nombre de chemins valides possible.

  • gospider (go): HTML spider, LinkFinder in JS files and external sources (Archive.org, CommonCrawl.org, VirusTotal.com).
  • hakrawler (go): HML spider, avec LinkFider pour les fichiers JS et Archive.org comme source externe.
  • dirhunt (python): HTML spider, indique aussi les “juicy files”.
  • evine (go): CLI interactif HTML spider. Il recherche aussi dans Archive.org
  • meg (go): Cet outil n’est pas un spider mais il peut être utile. Vous pouvez indiquer un fichier d’hôtes et un fichier de chemins ; meg récupérera chaque chemin sur chaque hôte et sauvegardera la réponse.
  • urlgrab (go): HTML spider avec capacités de rendu JS. Cependant, il semble non maintenu, la version précompilée est ancienne et le code actuel ne compile pas
  • gau (go): HTML spider qui utilise des fournisseurs externes (wayback, otx, commoncrawl)
  • ParamSpider: Ce script trouvera les URLs avec paramètres et les listera.
  • galer (go): HTML spider avec rendu JS.
  • LinkFinder (python): HTML spider, avec capacités de JS beautify capable de rechercher de nouveaux chemins dans les fichiers JS. Il peut être utile également de jeter un œil à JSScanner, qui est un wrapper de LinkFinder.
  • goLinkFinder (go): Pour extraire des endpoints dans le source HTML et dans les fichiers javascript embarqués. Utile pour bug hunters, red teamers, infosec ninjas.
  • JSParser (python2.7): Un script python 2.7 utilisant Tornado et JSBeautifier pour parser les URLs relatives depuis les fichiers JavaScript. Utile pour découvrir facilement des requêtes AJAX. Semble non maintenu.
  • relative-url-extractor (ruby): Étant donné un fichier (HTML) il extraira les URLs en utilisant une regex pratique pour trouver et extraire les URLs relatives depuis des fichiers minifiés.
  • JSFScan (bash, plusieurs outils): Rassemble des informations intéressantes depuis des fichiers JS en utilisant plusieurs outils.
  • subjs (go): Trouve les fichiers JS.
  • page-fetch (go): Charge une page dans un navigateur headless et imprime toutes les urls chargées pour afficher la page.
  • Feroxbuster (rust): Outil de découverte de contenu mixant plusieurs options des outils précédents
  • Javascript Parsing: Une extension Burp pour trouver des chemins et paramètres dans les fichiers JS.
  • Sourcemapper: Un outil qui, donné l’URL du .js.map, récupère le code JS beautified
  • xnLinkFinder: Outil utilisé pour découvrir des endpoints pour une cible donnée.
  • waymore: Découvre des liens depuis la wayback machine (télécharge aussi les réponses dans la wayback et recherche d’autres liens)
  • HTTPLoot (go): Crawl (même en remplissant les forms) et trouve aussi des informations sensibles avec des regexs spécifiques.
  • SpiderSuite: Spider Suite est un crawler/spider GUI multi-fonction avancé conçu pour les professionnels de la cybersécurité.
  • jsluice (go): C’est un package Go et un command-line tool pour extraire URLs, chemins, secrets et autres données intéressantes depuis le code source JavaScript.
  • ParaForge: ParaForge est une simple Burp Suite extension pour extraire les paramètres et endpoints depuis les requêtes afin de créer des wordlists personnalisées pour le fuzzing et l’énumération.
  • katana (go): Excellent outil pour cela.
  • Crawley (go): Imprime chaque lien qu’il est capable de trouver.

Brute Force directories and files

Démarrez le brute-forcing depuis le dossier racine et assurez-vous de brute-forcer tous les répertoires trouvés en utilisant cette méthode ainsi que tous les répertoires découverts par le Spidering (vous pouvez effectuer ce brute-forcing récursivement en préfixant dans la wordlist utilisée les noms des répertoires trouvés).
Outils :

  • Dirb / Dirbuster - Inclus dans Kali, ancien (et lent) mais fonctionnel. Permet certificats auto-signés et recherche récursive. Trop lent comparé aux autres options.
  • Dirsearch (python): Il n’autorise pas les certificats auto-signés mais permet la recherche récursive.
  • Gobuster (go): Il permet les certificats auto-signés, il n’a pas de recherche récursive.
  • Feroxbuster - Rapide, supporte la recherche récursive.
  • wfuzz wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ
  • ffuf - Rapide: ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ
  • uro (python): Ce n’est pas un spider mais un outil qui, donné la liste d’URLs trouvées, supprimera les URLs “dupliquées”.
  • Scavenger: Burp Extension pour créer une liste de répertoires depuis l’historique Burp de différentes pages
  • TrashCompactor: Supprime les URLs avec des fonctionnalités dupliquées (basé sur les imports js)
  • Chamaleon: Utilise wapalyzer pour détecter les technologies utilisées et sélectionner les wordlists à utiliser.

Dictionnaires recommandés :

Notez que chaque fois qu’un nouveau répertoire est découvert pendant le brute-forcing ou le spidering, il doit être Brute-Forced.

Ce qu’il faut vérifier pour chaque fichier trouvé

  • Broken link checker: Trouver les liens cassés dans les HTMLs qui peuvent être susceptibles de takeover
  • File Backups: Une fois que vous avez trouvé tous les fichiers, cherchez des backups de tous les fichiers exécutables (“.php”, “.aspx”…). Les variations courantes pour nommer un backup sont : file.ext~, #file.ext#, ~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp et file.old. Vous pouvez aussi utiliser l’outil bfac ou backup-gen.
  • Discover new parameters: Vous pouvez utiliser des outils comme Arjun, parameth, x8 et Param Miner pour découvrir des paramètres cachés. Si possible, essayez de rechercher des paramètres cachés sur chaque fichier web exécutable.
  • 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 : Vérifiez les commentaires de tous les fichiers, vous pouvez y trouver des credentials ou des fonctionnalités cachées.
  • Si vous jouez en CTF, une astuce “classique” est de cacher des informations dans des commentaires à droite de la page (en utilisant des centaines d’espaces pour ne pas voir les données si vous ouvrez le source avec le navigateur). Une autre possibilité est d’utiliser plusieurs retours à la ligne et de cacher des informations dans un commentaire en bas de la page web.
  • API keys: Si vous trouvez une API key il existe des projets qui indiquent comment utiliser les API keys de différentes plateformes : keyhacks, zile, truffleHog, SecretFinder, RegHex, DumpsterDive, EarlyBird
  • Google API keys: Si vous trouvez une API key ressemblant à AIzaSyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik vous pouvez utiliser le projet gmapapiscanner pour vérifier à quelles APIs la clé donne accès.
  • S3 Buckets: Pendant le spidering, vérifiez si un sous-domaine ou un lien est lié à un S3 bucket. Dans ce cas, vérifiez les permissions du bucket.

Special findings

Pendant le spidering et le brute-forcing vous pouvez trouver des éléments intéressants qu’il faut prendre en compte.

Fichiers intéressants

  • Cherchez des liens vers d’autres fichiers à l’intérieur des fichiers CSS.
  • If you find a .git file some information can be extracted
  • Si vous trouvez un fichier .env, des informations telles que des api keys, mots de passe de DB et autres peuvent être trouvées.
  • Si vous trouvez des API endpoints vous should also test them. Ceux-ci ne sont pas des fichiers, mais ressembleront probablement à des fichiers.
  • JS files: Dans la section spidering plusieurs outils capables d’extraire des chemins depuis des fichiers JS ont été mentionnés. Il serait aussi intéressant de monitorer chaque fichier JS trouvé, car parfois un changement peut indiquer qu’une vulnérabilité potentielle a été introduite dans le code. Vous pouvez par exemple utiliser JSMon.
  • Vous devriez aussi vérifier les fichiers JS découverts avec RetireJS ou JSHole pour voir s’ils sont vulnérables.
  • Javascript Deobfuscator and Unpacker: https://lelinhtinh.github.io/de4js/, https://www.dcode.fr/javascript-unobfuscator
  • Javascript Beautifier: http://jsbeautifier.org/, http://jsnice.org/
  • JsFuck deobfuscation (javascript with chars:“[]!+” https://enkhee-osiris.github.io/Decoder-JSFuck/)
  • TrainFuck: +72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.
  • À plusieurs occasions, vous aurez besoin de comprendre les expressions régulières utilisées. Ceci sera utile : https://regex101.com/ ou https://pythonium.net/regex
  • Vous pouvez aussi monitorer les fichiers où des forms ont été détectés, car un changement dans un paramètre ou l’apparition d’un nouveau formulaire peut indiquer une nouvelle fonctionnalité vulnérable potentielle.

403 Forbidden/Basic Authentication/401 Unauthorized (bypass)

403 & 401 Bypasses

502 Proxy Error

Si une page répond avec ce code, c’est probablement un proxy mal configuré. Si vous envoyez une requête HTTP comme : GET https://google.com HTTP/1.1 (avec l’en-tête host et d’autres en-têtes courants), le proxy essayera d’accéder à google.com et vous aurez trouvé un SSRF.

NTLM Authentication - Info disclosure

Si le serveur qui demande l’authentification est Windows ou si vous trouvez un login qui demande vos credentials (et demande le domain name), vous pouvez provoquer une divulgation d’information.
Envoyez l’en-tête : “Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=” et à cause du fonctionnement de l’NTLM authentication, le serveur répondra avec des infos internes (version IIS, version Windows…) dans l’en-tête “WWW-Authenticate”.
Vous pouvez automatiser ceci en utilisant le nmap plugin “http-ntlm-info.nse”.

HTTP Redirect (CTF)

Il est possible d’insérer du contenu dans une redirection. Ce contenu ne sera pas affiché à l’utilisateur (puisque le navigateur exécutera la redirection) mais quelque chose pourrait être caché là-dedans.

Web Vulnerabilities Checking

Maintenant qu’une énumération exhaustive de l’application web a été réalisée, il est temps de vérifier de nombreuses vulnérabilités possibles. Vous pouvez trouver la checklist ici :

Web Vulnerabilities Methodology

Trouvez plus d’infos sur les vulnérabilités web sur :

Monitor Pages for changes

Vous pouvez utiliser des outils tels que https://github.com/dgtlmoon/changedetection.io pour monitorer des pages à la recherche de modifications qui pourraient introduire des vulnérabilités.

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]
> Apprenez et pratiquez le 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;">\
> Apprenez et pratiquez le 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;">
> Apprenez et pratiquez le 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>Soutenir HackTricks</summary>
>
> - Vérifiez les [**plans d'abonnement**](https://github.com/sponsors/carlospolop) !
> - **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez-nous sur** **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
> - **Partagez des astuces de hacking en soumettant des PR au** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts github.
>
> </details>