hacktricks/network-services-pentesting/pentesting-web

80,443 - Méthodologie de pentesting Web

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

• Travaillez-vous dans une entreprise de cybersécurité ? Voulez-vous voir votre entreprise annoncée dans HackTricks ? Ou voulez-vous avoir accès à la dernière version de PEASS ou télécharger HackTricks en PDF ? Consultez les PLANS D'ABONNEMENT !
• Découvrez La famille PEASS, notre collection exclusive de NFT
• Obtenez le swag officiel PEASS & HackTricks
• Rejoignez le 💬 groupe Discord ou le groupe Telegram ou suivez moi sur Twitter 🐦@carlospolopm.
• Partagez vos astuces de piratage en soumettant des PR au repo hacktricks et au repo hacktricks-cloud.

Astuce pour les primes de bug : inscrivez-vous sur Intigriti, une plateforme premium de prime de bug créée par des pirates, pour des pirates ! Rejoignez-nous sur https://go.intigriti.com/hacktricks dès aujourd'hui et commencez à gagner des primes allant jusqu'à 100 000 $ !

{% embed url="https://go.intigriti.com/hacktricks" %}

Informations de base

Le service web est le service le plus courant et le plus étendu et il existe de nombreux types de vulnérabilités différents.

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 API Web

{% content-ref url="web-api-pentesting.md" %} web-api-pentesting.md {% endcontent-ref %}

Résumé de la méthodologie

Dans cette méthodologie, nous supposons 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 adresse IP découvert avec un serveur web indéterminé dans le périmètre.

• Commencez par identifier les technologies utilisées par le serveur web. Recherchez des astuces à garder à l'esprit pendant le reste du test si vous parvenez à identifier avec succès la technologie.
• Y a-t-il une vulnérabilité connue de la version de la technologie ?
• Utilisez-vous une technologie bien connue ? Y a-t-il une astuce utile pour extraire plus d'informations ?
• Utilisez-vous un scanner spécialisé à exécuter (comme wpscan) ?
• Lancez des scanners à usage général. On ne sait jamais s'ils vont trouver quelque chose ou si ils vont trouver des informations intéressantes.
• Commencez par les vérifications initiales : robots, sitemap, erreur 404 et analyse SSL/TLS (si HTTPS).
• Commencez à explorer la page web : Il est temps de trouver tous les fichiers, dossiers et paramètres possibles utilisés. Vérifiez également les découvertes spéciales.
• Notez qu'à chaque fois qu'un nouveau répertoire est découvert lors d'une attaque par force brute ou d'une exploration, il doit être exploré.
• Attaque par force brute des répertoires : Essayez de forcer par la méthode de force brute tous les répertoires découverts à la recherche de nouveaux fichiers et répertoires.
• Notez qu'à chaque fois qu'un nouveau répertoire est découvert lors d'une attaque par force brute ou d'une exploration, il doit être attaqué par force brute.
• Vérification des sauvegardes : Testez si vous pouvez trouver des sauvegardes des fichiers découverts en ajoutant des extensions de sauvegarde courantes.
• Attaque par force brute des paramètres : Essayez de trouver des paramètres cachés.
• Une fois que vous avez identifié tous les points d'extrémité possibles acceptant une entrée utilisateur, vérifiez toutes sortes de vulnérabilités qui y sont liées.
• Suivez cette liste de contrôle

Version du serveur (Vulnérable ?)

Identification

Vérifiez s'il existe des vulnérabilités connues pour la version du serveur qui est en cours d'exécution.
Les en-têtes HTTP et les cookies de la réponse peuvent être très utiles pour identifier les technologies et/ou la version utilisées. L'outil Nmap scan peut identifier la version du serveur, mais les outils whatweb, webtech ou https://builtwith.com/: peuvent également être utiles.

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

Recherchez les vulnérabilités de la version de l'application Web ici.

Vérifiez si un WAF est utilisé

• https://github.com/EnableSecurity/wafw00f
• https://github.com/Ekultek/WhatWaf.git
• https://nmap.org/nsedoc/scripts/http-waf-detect.html

Astuces techniques Web

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

• AEM - Adobe Experience Cloud
• Apache
• Artifactory
• Buckets
• CGI
• Drupal
• Flask
• Git
• Golang
• GraphQL
• H2 - Base de données SQL Java
• Astuces IIS
• JBOSS
• Jenkins
• Jira
• Joomla
• JSP
• Laravel
• Moodle
• Nginx
• PHP (php a beaucoup d'astuces intéressantes qui pourraient être exploitées)
• Python
• Spring Actuators
• Symphony
• Tomcat
• VMWare
• Test de pénétration de l'API Web
• WebDav
• Werkzeug
• Wordpress
• Electron Desktop (XSS to RCE)

Tenez compte du fait que le même domaine peut utiliser différentes technologies sur différents ports, dossiers et sous-domaines.
Si l'application Web utilise une technologie/plateforme bien connue ou autre, n'oubliez pas de rechercher sur Internet de nouvelles astuces (et faites-le moi savoir !).

Examen du code source

Si le code source de l'application est disponible sur github, en plus de réaliser vous-même un test White box de l'application, il y a des informations qui pourraient être utiles pour le test Black-Box actuel :

• Y a-t-il un fichier journal des modifications ou readme ou version ou toute autre information de version accessible via le web ?
• Comment et où sont enregistrées les informations d'identification ? Y a-t-il un fichier (accessible ?) avec des informations d'identification (noms d'utilisateur ou mots de passe) ?
• Les mots de passe sont-ils en clair, chiffrés ou quel algorithme de hachage est utilisé ?
• Utilise-t-il une clé principale pour chiffrer quelque chose ? Quel algorithme est utilisé ?
• Pouvez-vous accéder à l'un de ces fichiers en exploitant une vulnérabilité ?
• Y a-t-il des informations intéressantes dans les problèmes (résolus et non résolus) github ? Ou dans l'historique des commits (peut-être un mot de passe introduit dans un ancien commit) ?

{% content-ref url="code-review-tools.md" %} code-review-tools.md {% endcontent-ref %}

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>

Scanners de CMS

Si un CMS est utilisé, n'oubliez pas d'exécuter un scanner, peut-être que quelque chose de juteux sera trouvé :

Clusterd** :** JBoss, ColdFusion, WebLogic, Tomcat, Railo, Axis2, Glassfish
CMSScan : WordPress, Drupal, Joomla, sites vBulletin pour les 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 des informations sur le serveur web utilisé par le client (si des données sont fournies) et quelques astuces à garder à l'esprit pendant le test. Si vous avez de la chance, vous avez même trouvé un CMS et exécuté un scanner.

Découverte pas à pas de l'application Web

À partir de ce point, nous allons commencer à interagir avec l'application Web.

Vérifications initiales

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

• /robots.txt
• /sitemap.xml
• /crossdomain.xml
• /clientaccesspolicy.xml
• /.well-known/
• Vérifiez également les commentaires sur les pages principales et secondaires.

Forcer des erreurs

Les serveurs Web peuvent avoir un comportement inattendu lorsque des données étranges leur sont envoyées. Cela peut ouvrir des vulnérabilités ou révéler des informations sensibles.

• Accédez à des pages fictives telles que /whatever_fake.php (.aspx, .html, etc.)
• Ajoutez "[]", "]]" et "[[" dans les valeurs des cookies et les valeurs des paramètres pour créer des erreurs
• Générez une erreur en donnant une entrée sous la forme de /~randomthing/%s à la fin de l'URL
• Essayez différentes méthodes HTTP telles que PATCH, DEBUG ou des méthodes incorrectes comme FAKE

Vérifiez si vous pouvez télécharger des fichiers (verbe PUT, WebDav)

Si vous découvrez que WebDav est activé mais que vous n'avez pas suffisamment de permissions pour télécharger des fichiers dans le dossier racine, essayez de :

• Forcer les identifiants
• Télécharger des fichiers via WebDav vers le reste des dossiers trouvés à l'intérieur de la page Web. Vous pouvez avoir les permissions pour télécharger des fichiers dans d'autres dossiers.

Vulnérabilités SSL/TLS

• Si l'application n'impose pas l'utilisation de HTTPS à un moment donné, alors elle est vulnérable aux attaques de type MitM
• Si l'application envoie des données sensibles (mots de passe) en utilisant HTTP. Alors c'est une vulnérabilité élevée.

Utilisez testssl.sh pour vérifier les vulnérabilités (dans le cadre des programmes de Bug Bounty, ce type de vulnérabilités ne sera probablement 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>

Informations sur les vulnérabilités SSL/TLS :

• https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/
• https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/

Spidering

Lancez une sorte de spider à l'intérieur du web. L'objectif de l'araignée est de trouver autant de chemins que possible à partir de l'application testée. Par conséquent, le crawling web et les sources externes doivent être utilisés pour trouver autant de chemins valides que possible.

• gospider (go) : araignée HTML, LinkFinder dans les fichiers JS et sources externes (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
• hakrawler (go) : araignée HML, avec LinkFider pour les fichiers JS et Archive.org comme source externe.
• dirhunt (python) : araignée HTML, indique également les "fichiers juteux".
• evine (go) : araignée HTML interactive en ligne de commande. Il recherche également dans Archive.org.
• meg (go) : Cet outil n'est pas une araignée mais peut être utile. Vous pouvez simplement indiquer un fichier avec des hôtes et un fichier avec des chemins et meg récupérera chaque chemin sur chaque hôte et enregistrera la réponse.
• urlgrab (go) : araignée HTML avec des capacités de rendu JS. Cependant, il semble qu'il ne soit plus maintenu, la version précompilée est ancienne et le code actuel ne compile pas.
• gau (go) : araignée HTML qui utilise des fournisseurs externes (wayback, otx, commoncrawl).
• ParamSpider : Ce script trouvera les URL avec des paramètres et les listera.
• galer (go) : araignée HTML avec des capacités de rendu JS.
• LinkFinder (python) : araignée HTML, avec des capacités de beautification JS capable de rechercher de nouveaux chemins dans les fichiers JS. Il peut également être intéressant de jeter un coup d'œil à JSScanner, qui est un wrapper de LinkFinder.
• goLinkFinder (go) : Pour extraire les points de terminaison à la fois dans la source HTML et dans les fichiers javascript intégrés. Utile pour les chasseurs de bugs, les équipes rouges et les ninjas de la sécurité de l'information.
• JSParser (python2.7) : Un script python 2.7 utilisant Tornado et JSBeautifier pour analyser les URL relatives à partir des fichiers JavaScript. Utile pour découvrir facilement les requêtes AJAX. Semble ne plus être maintenu.
• relative-url-extractor (ruby) : À partir d'un fichier (HTML), il extraira les URL en utilisant une expression régulière astucieuse pour trouver et extraire les URL relatives à partir de fichiers moches (minifiés).
• JSFScan (bash, plusieurs outils) : Rassemble des informations intéressantes à partir de fichiers JS en utilisant plusieurs outils.
• subjs (go) : Trouve des fichiers JS.
• page-fetch (go) : Charge une page dans un navigateur sans tête et affiche toutes les URL chargées pour charger la page.
• Feroxbuster (rust) : Outil de découverte de contenu mélangeant plusieurs options des outils précédents.
• Javascript Parsing : Une extension Burp pour trouver des chemins et des paramètres dans les fichiers JS.
• Sourcemapper : Un outil qui, étant donné l'URL .js.map, vous donnera le code JS beautifié.
• xnLinkFinder : Cet outil est utilisé pour découvrir les points de terminaison pour une cible donnée.
• waymore : Découvre les liens à partir de la machine wayback (télécharge également les réponses dans wayback et recherche d'autres liens).
• HTTPLoot (go) : Crawl (même en remplissant des formulaires) et trouve également des informations sensibles en utilisant des regex spécifiques.
• SpiderSuite : Spider Suite est un crawler/spider de sécurité web GUI multi-fonction avancé conçu pour les professionnels de la cybersécurité.
• jsluice (go) : C'est un package Go et un outil en ligne de commande pour extraire des URL, des chemins, des secrets et d'autres données intéressantes à partir du code source JavaScript.

Brute Force des répertoires et des fichiers

Commencez par brute-forcer à partir du dossier racine et assurez-vous de brute-forcer tous les répertoires trouvés en utilisant cette méthode et tous les répertoires découverts par le Spidering (vous pouvez effectuer cette brute-forcing récursivement et ajouter au début de la liste de mots utilisée les noms des répertoires trouvés).
Outils :

• Dirb / Dirbuster - Inclus dans Kali, ancien (et ** lent **) mais fonctionnel. Autorise les certificats auto-signés et la recherche récursive. Trop lent par rapport aux autres options.
• Dirsearch (python) : Il n'autorise pas les certificats auto-signés mais permet une recherche récursive.
• Gobuster (go) : Il autorise les certificats auto-signés, il n'a pas de recherche récursive.
• Feroxbuster - Rapide, prend en charge 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 une araignée mais un outil qui, étant donné la liste des URL trouvées, supprimera les URL "dupliquées".
• Scavenger : Extension Burp pour créer une liste de répertoires à partir de l'historique de burp de différentes pages.
• TrashCompactor : Supprime les URL avec des fonctionnalités en double (basé sur les imports JS).
• Chamaleon : Il utilise wapalyzer pour détecter les technologies utilisées et sélectionner les listes de mots à utiliser.

Dictionnaires recommandés :

• https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt
• Dirsearch dictionnaire inclus
• http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10
• Listes de mots Assetnote
• https://github.com/danielmiessler/SecLists/tree/master/Discovery/Web-Content
• raft-large-directories-lowercase.txt
• directory-list-2.3-medium.txt
• RobotsDisallowed/top10000.txt
• https://github.com/random-robbie/bruteforce-lists
• https://github.com/google/fuzzing/tree/master/dictionaries
• https://github.com/six2dez/OneListForAll
• https://github.com/random-robbie/bruteforce-lists
• /usr/share/wordlists/dirb/common.txt
• /usr/share/wordlists/dirb/big.txt
• /usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt

Notez que chaque fois qu'un nouveau répertoire est découvert lors d'une attaque par force brute ou d'une exploration, il doit être soumis à une attaque par force brute.

Ce qu'il faut vérifier sur chaque fichier trouvé

• Vérificateur de liens brisés : Trouvez les liens brisés à l'intérieur des fichiers HTML qui pourraient être vulnérables aux prises de contrôle.
• Sauvegardes de fichiers : Une fois que vous avez trouvé tous les fichiers, recherchez les sauvegardes de tous les fichiers exécutables (".php", ".aspx"...). Les variations courantes pour nommer une sauvegarde 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 également utiliser l'outil bfac.
• Découverte de nouveaux paramètres : Vous pouvez utiliser des outils tels que Arjun, parameth, x8 et Param Miner pour découvrir les paramètres cachés. Si possible, vous pouvez essayer de rechercher des paramètres cachés dans chaque fichier web exécutable.
• Tous les wordlists par défaut d'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
• Commentaires : Vérifiez les commentaires de tous les fichiers, vous pouvez y trouver des informations d'identification ou des fonctionnalités cachées.
• Si vous jouez à un CTF, une astuce "courante" consiste à cacher des informations à l'intérieur des commentaires à droite de la page (en utilisant des centaines d'espaces pour que vous ne voyiez pas les données si vous ouvrez le code source avec le navigateur). Une autre possibilité est d'utiliser plusieurs nouvelles lignes et de cacher des informations dans un commentaire en bas de la page web.
• Clés d'API : Si vous trouvez une clé d'API, il existe un guide qui indique comment utiliser les clés d'API de différentes plateformes : keyhacks, zile, truffleHog, SecretFinder, RegHex, DumpsterDive, EarlyBird
• Clés d'API Google : Si vous trouvez une clé d'API ressemblant à AIzaSyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik, vous pouvez utiliser le projet gmapapiscanner pour vérifier quelles API la clé peut accéder.
• Buckets S3 : Lors de l'exploration, vérifiez si un sous-domaine ou un lien est lié à un bucket S3. Dans ce cas, vérifiez les permissions du bucket.

Découvertes spéciales

Pendant l'exploration et l'attaque par force brute, vous pourriez trouver des choses intéressantes dont vous devez prendre note.

Fichiers intéressants

• Recherchez des liens vers d'autres fichiers à l'intérieur des fichiers CSS.
• Si vous trouvez un fichier .git, des informations peuvent être extraites
• Si vous trouvez un fichier .env, des informations telles que des clés d'API, des mots de passe de bases de données et d'autres informations peuvent être trouvées.
• Si vous trouvez des points de terminaison d'API, vous devriez également les tester. Ce ne sont pas des fichiers, mais ils ressembleront probablement à des fichiers.
• Fichiers JS : Dans la section d'exploration, plusieurs outils capables d'extraire des chemins à partir de fichiers JS ont été mentionnés. De plus, il serait intéressant de surveiller chaque fichier JS trouvé, car dans certaines occasions, un changement peut indiquer qu'une vulnérabilité potentielle a été introduite dans le code. Vous pouvez utiliser par exemple JSMon.
• Vous devriez également vérifier les fichiers JS découverts avec RetireJS ou JSHole pour voir s'ils sont vulnérables.
• Déobfuscateur et désassembleur JavaScript : https://lelinhtinh.github.io/de4js/, https://www.dcode.fr/javascript-unobfuscator
• Embelleur JavaScript : http://jsbeautifier.org/, http://jsnice.org/
• Déobfuscation JsFuck (javascript avec les caractères :"[]!+" https://ooze.ninja/javascript/poisonjs/)
• TrainFuck: +72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.
• Dans plusieurs occasions, vous devrez comprendre les expressions régulières utilisées, cela sera utile : https://regex101.com/
• Vous pouvez également surveiller les fichiers où des formulaires ont été détectés, car un changement dans le paramètre ou l'apparition d'un nouveau formulaire peut indiquer une nouvelle fonctionnalité potentiellement vulnérable.

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 une page répond avec ce code, il s'agit probablement d'un proxy mal configuré. Si vous envoyez une requête HTTP comme: GET https://google.com HTTP/1.1 (avec l'en-tête d'hôte et d'autres en-têtes courants), le proxy essaiera d'accéder à google.com et vous aurez trouvé une SSRF.

Authentification NTLM - Divulgation d'informations

Si le serveur en cours d'exécution qui demande une authentification est Windows ou si vous trouvez une connexion qui demande vos informations d'identification (et demande le nom de domaine), vous pouvez provoquer une divulgation d'informations. Envoyez l'en-tête: “Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=” et en raison du fonctionnement de l'authentification NTLM, le serveur répondra avec des informations internes (version IIS, version Windows...) dans l'en-tête "WWW-Authenticate". Vous pouvez automatiser cela en utilisant le plugin nmap "http-ntlm-info.nse".

Redirection HTTP (CTF)

Il est possible d'insérer du contenu dans une redirection. Ce contenu ne sera pas affiché à l'utilisateur (car le navigateur exécutera la redirection), mais quelque chose pourrait être caché à l'intérieur.

Vérification des vulnérabilités Web

Maintenant qu'une énumération complète de l'application Web a été effectuée, il est temps de vérifier de nombreuses vulnérabilités possibles. Vous pouvez trouver la liste de contrôle ici:

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

TODO: Complétez la liste des vulnérabilités et des techniques avec https://six2dez.gitbook.io/pentest-book/others/web-checklist et 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

Surveiller les pages pour les modifications

Vous pouvez utiliser des outils tels que https://github.com/dgtlmoon/changedetection.io pour surveiller les pages afin de détecter les modifications qui pourraient introduire des vulnérabilités.

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

Astuce de prime de bug: inscrivez-vous à Intigriti, une plateforme premium de prime de bug créée par des hackers, pour des hackers! Rejoignez-nous sur https://go.intigriti.com/hacktricks dès aujourd'hui et commencez à gagner des primes allant jusqu'à 100 000 $!

{% embed url="https://go.intigriti.com/hacktricks" %}

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

• Travaillez-vous dans une entreprise de cybersécurité? Voulez-vous voir votre entreprise annoncée dans HackTricks? ou voulez-vous avoir accès à la dernière version de PEASS ou télécharger HackTricks en PDF? Consultez les PLANS D'ABONNEMENT!
• Découvrez La famille PEASS, notre collection exclusive de NFT
• Obtenez le swag officiel PEASS & HackTricks
• Rejoignez le 💬 groupe Discord ou le groupe Telegram ou suivez moi sur Twitter 🐦@carlospolopm.
• Partagez vos astuces de piratage en soumettant des PR au repo hacktricks et au repo hacktricks-cloud.