Méthodologie de Pentest

Lien mindmap: https://www.edrawmind.com/online/map.html?sharecode=D65e1e5f363fa68a12807794

Reconnaissance

La phase de reconnaissance est importante afin de collecter autant d'informations que possible sur la cible. Elle est divisée en reconnaissance passive et active.

La reconnaissance passive consiste à collecter des informations sur la cible sans interaction directe, utilisant des sources publiques pour obtenir des données telles que des sous-domaine, adresses IP, liens..

La reconnaissance active implique une interaction directe avec la cible pour obtenir des données comme les services exposés et les configurations de sécurité, en utilisant par exemple des balayages de ports, du bruteforce, etc..

Reconnaissance Passive

• Shodan
  • Utilisation: shodan init <api key>
  • Explication: Initialiser Shodan avec une clé API pour rechercher des informations sur les systèmes connectés à Internet sans interagir directement avec la cible. Permet d'obtenir en temps réel les sous-domaines d'une cible
  • Installation: pip install -U --user shodan
  • Shodan subfinder:

import subprocess
import sys

if len(sys.argv) < 2:
    print("Usage: python script.py <domain>")
    sys.exit(1)

domain = sys.argv[1].lower()

command = f'shodan domain {domain}'

result = subprocess.run(['bash', '-c', command], capture_output=True, text=True)

if result.returncode == 0:
    input_text = result.stdout
else:
    print("Error :", result.stderr)
    sys.exit(1)

full_subdomains = []
for line in input_text.splitlines():
    if line.strip() and " " in line:
        subdomain_part = line.strip().split()[0]
        if subdomain_part and not subdomain_part.startswith("_"):
            full_subdomains.append(f"{subdomain_part.lower()}.{domain}")

full_subdomains = sorted(set(full_subdomains))

file_path = 'full_subdomains.txt'
with open(file_path, 'w') as file:
    for subdomain in full_subdomains:
        file.write(f"{subdomain}\n")

print(f"Subdomains have been written to {file_path}")

• Amass

  • Utilisation: amass enum -d example.com
  • Explication: Utiliser Amass pour énumérer des sous domaines. L'option -d spécifie le domaine cible. Amass fait de la reconnaissance passive car l'outil se base sur des données publiques et accessibles sur internet. (Enregistrement DNS, WHOIS..)
  • Il est possible d'utiliser une config custom avec des clés API, permettant une recherche plus approfondie. Usage: amass enum -config config.ini -d exemple.com
  • Note: Après la version 3.19.3, il est nécessaire d'utiliser OAM tool afin de changer le config.ini en fichier .yaml. https://github.com/owasp-amass/oam-tools
  • Installation: From source avec go install, ou déjà build: https://github.com/owasp-amass/amass/releases

• Waymore

  • Utilisation: waymore.py -i exemple.com -mode U
  • Explication: Récupère des liens indéxés sur internet par le biais de sources publiques, tel que wayback machine, urlscan.io, etc.. Il est possible d'utiliser ses propres clés API.
  • Installation: git clone https://github.com/xnl-h4ck3r/waymore.git, cd waymore, sudo python setup.py install, https://github.com/xnl-h4ck3r/waymore

Reconnaissance Active

• Burp Suite

  • Explication: Burp Suite permet d'intercepter, d'analyser et de modifier les requêtes entre le navigateur et les serveurs web. Cet outil est indispensable et représente le support principal pour effectuer des tests web.
  • License Pro: Avec la version professionnelle, il est possible de lancer des scans automarisés, permettant de crawler de façon automatique (C'est une automatisation de la navigation sur la cible, afin d'indexer le contenu de la cible en parcourant systématiquement les liens et les pages..), lancer des attaques (XSS, XXE, SQLi, Path Traversal, missconfiguration, headers manquants..), etc..
  • Plugins: Il est possible d'ajouter des plugins à Burp, voici une liste non exhaustive de plugins intéressants: https://portswigger.net/solutions/penetration-testing/penetration-testing-tools
  • Features:
    • L'intruder permet de selectionner une requête ainsi qu'un paramètre, et le rejouer en ajouter une wordlist de façon à réaliser un bruteforce.
    • Le collaborateur permet de générer un lien sur lequel les interactions sont récupérées, permettant de voir les requêtes sortantes HTTPS, DNS..
  • Installation: https://portswigger.net/burp/documentation/desktop/getting-started/download-and-install

• Scrapy

  • Explication: Outil de crawling/scrapping comme expliqué précédemment, est utile dans les cas ou Burpsuite Pro n'est pas accessible.
  • Installation: https://github.com/scrapy/scrapy

• Nuclei

  • C'est un outil de scan de vulnérabilités et d'enumeration, qui utilise des modèles yaml pour détecter des vulnérabilités spécifiques de façon automatisé. Nuclei est maintenu par une communauté, qui intègre des PoC au fur et à mesure.
  • Utilisation: nuclei -u http://exemple.com, nuclei -l list.txt, nuclei -t template_custom.yaml -u http://exemple.com
  • Installation: From source avec go install -v github.com/projectdiscovery/nuclei/v3/cmd/nuclei@latest, ou déjà build https://github.com/projectdiscovery/nuclei/releases/tag/v3.1.10

• Wappalyzer

  • Explication: Plugin pour navigateur, permettant d'avoir connaissance des technologies présentent sur une cible rapidemment.
  • Installation: https://www.wappalyzer.com/

• Nmap

  • Utilisation: nmap -sV -sC -oA output example.com
  • Explication: Permet de scanner les ports de la cible, détecter les versions des services et exécuter des scripts par défaut contre les services trouvés. Nmap possède beaucoup d'options, par exemple, pour faire un scan très large sur tous les ports possible, il est possible d'utiliser l'option -p-
  • Installation: apt install nmap ou https://nmap.org/book/inst-linux.html

• Gobuster

  • Utilisation: gobuster dns -d example.com -w wordlist.txt
  • Explication: Énumérer les sous-domaines de la cible en bruteforcant avec une liste de mots spécifiée par -w.
  • Utilisation: gobuster dir -u example.com -w wordlist.txt
  • Explication: Énumérer des chemins/fichiers en bruteforcant
  • Wordlist: https://github.com/danielmiessler/SecLists
  • Installation: From source avec go install github.com/OJ/gobuster/v3@latest, ou déjà build https://github.com/OJ/gobuster/releases/tag/v3.6.0

• Ffuf

  • Utilisation: ffuf -w wordlist.txt -u example.com/FUZZ.zip
  • Explication: Alternantive a Gobuster, permet aussi d'énumérer en utilisant une wordlist. FUZZ représente l'endroit ou la wordlist sera placée. Il est possible de fuzz en spéficiant des extensions, comme dans cet exemple .zip, il n'est pas rare de trouver des fichiers exposés sur des serveurs.
  • Installation: From source avec go install github.com/ffuf/ffuf/v2@latest, ou déjà build https://github.com/ffuf/ffuf/releases/tag/v2.1.0

Analyse

• HTTPX

  • Utilisation: httpx -l /list.txt --status-code | grep '200'
  • Explication: Permet de scanner et identifier des informations sur des sites web, comme leur disponibilité, titres, technologies utilisées, et statuts de réponse.. Permet surtout d'avoir le status de réponse d'un site (200, 302, 403..) afin de trier ceux accessible.
  • Installation: From source avec go install -v github.com/projectdiscovery/httpx/cmd/httpx@latest, ou déjà build https://github.com/projectdiscovery/httpx/releases/tag/v1.4.0

• Gowitness

  • Utilisation: gowitness file -f list.txt, gowitness server :7171
  • Explication: Génère en arrière plan des proccess chromium afin de prendre des captures d'écran des sites web/URL récupérés avec shodan, waymore, dirb.. Permet d'avoir un visuel rapide afin de déterminer quels endpoints sont intéressants. Il aussi possible de trier les images par ressemblance.
  • Installation: From source avec go install github.com/sensepost/gowitness@latest, ou déjà build avec https://github.com/sensepost/gowitness/releases/tag/2.5.1

Exploitation Automatisée

Il n'est pas neccessaire d'utiliser des outils afin d'exploiter une vulnérabilité, généralement cela se fait à la main à l'aide de Burp Suite pour rajouter les requêtes.. Mais il est pratique dans certains cas d'avoir des outils automatisants la tâche.

• SQLMap

  • Utilisation depuis Burp: Mettre un * dans le paramètre, Save item, puis sqlmap -r $PWD/item_saved --random-agent --banner
  • Utilisation: sqlmap -u "http://example.com/vuln.php?id=1*" --random-agent --banner
  • Explication: Exploiter de façon automatisé les vulnérabilités d'injection SQL sur une page web spécifiée. Si besoin, les options --risk et --level augmentent l'agressivité du scan.
  • Installation: apt install sqlmap, git clone --depth 1 https://github.com/sqlmapproject/sqlmap.git sqlmap-dev

• Hydra

  • Utilisation: hydra -l username -P wordlist.txt ssh://example.com
  • Explication: Permet de procéder à une attaque par bruteforce sur un service, par exemple dans ce cas SSH, en utilisant une wordlist.
  • Wordlist: https://github.com/danielmiessler/SecLists/tree/master/Passwords
  • Plus d'options: https://www.freecodecamp.org/news/how-to-use-hydra-pentesting-tutorial
  • Installation: pip install hydra-core --upgrade

• Metasploit

  • Utilisation: msfconsole, search exemple, use exploit/exploit... Configuration: set RHOSTS IP DE LA CIBLE, set LHOST IP D'ÉCOUTE, puis exploit pour lancer l'attaque. Il est possible d'utiliser un reverse shell préçis (reverse TCP, reverse HTTP/HTTPS, reverse DNS..), set payload linux/x64/meterpreter/reverse_tcp
  • Explication: Lancer Metasploit, sélectionner et configurer un exploit pour exploiter une vulnérabilité de façon automatisé. Pratique lorsqu'une vulnérabilité a été repérée (Par exemple CVE..).
  • Installation: curl https://raw.githubusercontent.com/rapid7/metasploit-omnibus/master/config/templates/metasploit-framework-wrappers/msfupdate.erb > msfinstall && chmod 755 msfinstall && ./msfinstall

Rapport

• Pwndoc
  • Explication: Utiliser le Pwndoc interne pour générer des rapports de pentest plus rapidement et de façon partagée. Accéder au domaine … en utilisant le VPN interne.

Docker

Docker permet d'avoir directement dans un conteneur ces outils sans avoir a les télécharger un par un.. Le voici

DockerFile

FROM debian:latest

ENV DEBIAN_FRONTEND=noninteractive

COPY install.sh /install.sh

RUN chmod +x /install.sh && /install.sh

WORKDIR /root

CMD ["/bin/bash"]

install.sh

#!/bin/bash

set -e

apt-get update && apt-get install -y wget git python3 python3-pip build-essential libc6-dev

wget https://golang.org/dl/go1.22.0.linux-amd64.tar.gz
tar -xvf go1.22.0.linux-amd64.tar.gz
mv go /usr/local/

export GOPATH=/root/go
export PATH=$PATH:/usr/local/go/bin:$GOPATH/bin

go install -v github.com/owasp-amass/amass/v4/...@master
go install github.com/tomnomnom/assetfinder@latest
go install -v github.com/projectdiscovery/subfinder/v2/cmd/subfinder@latest
pip3 install shodan --break-system-packages
shodan init <API Key>
go install -v github.com/projectdiscovery/httpx/cmd/httpx@latest
go install github.com/sensepost/gowitness@latest
go install -v github.com/tomnomnom/waybackurls@latest
go install -v github.com/projectdiscovery/nuclei/v3/cmd/nuclei@latest


export PATH=$PATH:/usr/local/go/bin:$GOPATH/bin
apt-get clean && rm -rf /var/lib/apt/lists/*

Utilisation:

docker build -t pentest_container .
docker images

Différences entre black box et white box

Black Box

Un pentest en "Black Box" est un test de pénétration où le testeur a très peu, voire aucune information sur les systèmes internes ou le réseau de l'organisation cible avant de commencer le test. Il ne possède pas de credentials sur la cible.
L'approche simule un attaquant externe qui essaie de pénétrer dans le système sans connaissances préalables.

Phase 1: Reconnaissance

Objectif : Collecter autant d'informations que possible sans accès préalable ou autorisations internes.

• Recherche d'informations publiques : Utiliser des moteurs de recherche (google dorking), des réseaux sociaux..

Voici une liste utile de google dork:

1. Trouver des fichiers sensibles :

   • site:example.com filetype:pdf confidential
   • site:example.com ext:docx | ext:pdf | ext:xls "internal use only"

2. Identifier des pages d'administration :

   • site:example.com inurl:admin
   • site:example.com inurl:login | inurl:admin | inurl:account

3. Découvrir des serveurs, des versions, des technologies.. :

   • site:example.com "Apache/2.4.41" -inurl:https
   • site:example.com inurl:"phpinfo.php"

4. Rechercher des traceback, logs.. :

   • site:example.com "SQL syntax near"
   • site:example.com intext:"database error"

5. Trouver des documents contenant des mots-clés sensibles :

   • site:example.com intitle:"index of" password
   • site:example.com filetype:xls | filetype:xlsx intext:password | intext:username

6. Détecter des configurations et des fichiers exposés :

   • site:example.com filetype:xml | filetype:conf | filetype:cnf | filetype:reg | filetype:inf | filetype:rdp | filetype:cfg
   • site:example.com ext:sql | ext:dbf | ext:mdb

7. Trouver des répertoires non sécurisés et des fichiers de sauvegarde :

   • site:example.com intitle:"index of" /backup
   • site:example.com intitle:"index of" backup.zip

8. Localiser des webcams accessibles publiquement :

   • inurl:/view.shtml
   • intitle:"Live View / - AXIS"

9. Rechercher des portails et des services en ligne :

   • site:example.com inurl:wp-login | inurl:wp-admin
   • site:example.com inurl:joomla | inurl:drupal

10. Trouver des listes d'emails et des contacts :

    • site:example.com filetype:xls | filetype:xlsx intext:email | intext:contact

• Analyse des domaines et sous-domaines : Utiliser des outils comme Shodan, Amass, etc pour identifier les domaines et sous-domaines associés, ainsi que les services exposés sur internet (nmap, etc..)

• Analyse passive : Observer le trafic autour des ressources sans interagir directement avec les systèmes (waybackmachine, etc..

Phase 2: Analyse

• Détection de vulnérabilités : Utiliser Nikto, Gobuster, et ffuf.. pour rechercher des vulnérabilités connues, des fichiers et des répertoires cachés ou sensibles sur les domaines préalablement obtenus.

Phase 3: Exploitation

• Exploitation des vulnérabilités : Utiliser des outils comme SQLMap.. pour exploiter les vulnérabilités potentielles

• Phishing : Il est possible dans certains cas de mener une campagne de phishing ciblée (si cela est inclus dans le scope du pentest) pour tenter d'obtenir des identifiants d'accès via des emails trompeurs..

En plus | Campagne de phishing

Il est possible dans certain cas de réaliser une campagne de phishing, visant à tromper les cibles pour qu'ils divulgent des informations sensibles, cliquent sur des liens dangereux, ouvrent des pièces jointes infectées..

Email

Envoie d'emails qui semblant provenir d'organisations légitimes (banques, services en ligne..) afin d'inciter les cibles à divulguer des informations personnelles ou des données d'identification

Smishing

Technique de spoofing utilisant des messages SMS pour inciter les cibles à cliquer sur un lien malveillant ou à fournir des informations personnelles

Vishing

Implique des appels téléphoniques où l'attaquant se fait passer pour une autorité ou un service légitime pour extraire des informations personnelle

White Box

Le pentest en white box fait référence à une approche de test où l'on dispose d'une connaissance complète des mécanismes internes du système, de l'application ou du code à tester. Cela signifie que le testeur a accès au code source, à la documentation détaillée, aux schémas de l'architecture réseau et à d'autres informations internes..
En possédant le code source, il est possible de comprendre comment marche en profondeur l'application. Il faut adapter ses tests en fonction, par exemple faire attention aux champs contrôlés par les utilisateurs, permettant dans certains cas des SQLi..

Phase 1: Analyse du code ainsi que des informations

Analyse de code static

L'analyse de code statique examine le code source d'une application sans l'exécuter.
Elle est réalisée à l'aide d'outils qui peuvent identifier automatiquement certaines vulnérabilités potentielles, ou bien manuellement.

• En premier plan, il faut identifier les langages utilisés ainsi que les versions des paquets par exemple, dans le but de trouver des CVE.

• Il est aussi possible de rechercher des confusions de dépendance dans les requirements du projet (utilisé par exemple avec nodejs, python, golang, rust..) Cela se passe lorsque les gestionnaire de paquets d'une application installe par erreur un paquet malveillant depuis un dépôt public au lieu d'un paquet interne privé de même nom.

  • L'attaque consiste à publier un paquet malveillant dans un dépôt public sous le même nom qu'un paquet interne. Si le paquet malveillant a une version plus élevée que le paquet interne, le gestionnaire de paquets peut l'installer, injectant du code malveillant dans l'application.

• Il est tout simplement possible d'utiliser grep pour rechercher des fonctions dangereuses utilisées par le langage, par exemple shel_exec..

• https://github.com/xtiankisutsa/MARA_Framework
  Permet de décompiler et analyser automatiquement les APK. Permet de trouver des secrets et des paths hardcodés..

• https://github.com/SonarSource/sonarqube
  Détecte les bugs, vulnérabilités, "code smells" et fournit des suggestions de remédiation. Supporte une grande variété de langages de programmation

• https://chat.openai.com
  Très utile lorsque le code n'est pas sensible, permet de détécter un grand nombre de vulnérabilités/missconfigurations

Analyse de code dynamique

Permet d'exécuter une application web un programme ou bien même une application android afin d'observer comment il se comporte en direct, pour identifier les problèmes ou les vulnérabilités.

Il peut être nécessaire de faire tourner localement un webserver afin de tester directement la plateforme

• Pour android, il est nécessaire d'émuler une device. IL est possible de le faire avec Genymotion, QUEMU..
  https://www.genymotion.com/

• Il est aussi possible d'utiliser scrcpy, un package utilisant adb afin de connecter une device android physique à son ordinateur

• Faire du hookig est utile dans certains cas, par exemple pour bypass des fonctionnalités. Cela peut se faire avec frida. Il est aussi possible de faire du bypass de noroot (nécessaire lors d'émulation) https://frida.re/docs/android/

• Afin d'intercepter les requêtes web partants de l'application, il est nécessaire d'ajouter son propre certificat/proxy, et par la suite intercepter les requêtes avec BurpSuite.

• reFlutter permet de décompiler automatiquement une application flutter, ajouter son IP locale et intercepter par la suite les requêtes. https://github.com/ptswarm/reFlutter

• Pour les apk plus classique, apk-mitm et un outils permettant de décompiler l'apk, ajouter un certificat, et la signer. https://github.com/shroudedcode/apk-mitm

• Après chaque modification, il est nécessaire de resigner l'application. https://github.com/patrickfav/uber-apk-signer

Phase 2: Connaissance de l'architecture interne

Il est nécessaire d'analyser celle-ci et d'en prendre connaissance. Il peut être utile parfois de catographier les informations, afin d'avoir un visuel complet.

Phase 3:

Analyse et exploitation similaire aux tests en black box